X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fexport_handler.cc;h=cd3d61731d400a8d91268baa15f955520c0a16cf;hb=59b789d2bbd14012755215d72affb96696024367;hp=b315494127f0bf002e36544c1a1f62c94ebfe945;hpb=29f0ad473f1a6a23127d247abee673a5d6025df5;p=ardour.git diff --git a/libs/ardour/export_handler.cc b/libs/ardour/export_handler.cc index b315494127..cd3d61731d 100644 --- a/libs/ardour/export_handler.cc +++ b/libs/ardour/export_handler.cc @@ -20,13 +20,16 @@ #include "ardour/export_handler.h" -#include +#include "pbd/gstdio_compat.h" #include #include #include "pbd/convert.h" +#include "ardour/audioengine.h" #include "ardour/audiofile_tagger.h" +#include "ardour/audio_port.h" +#include "ardour/debug.h" #include "ardour/export_graph_builder.h" #include "ardour/export_timespan.h" #include "ardour/export_channel_configuration.h" @@ -39,7 +42,7 @@ #include "pbd/basename.h" #include "ardour/session_metadata.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace PBD; @@ -63,7 +66,7 @@ ExportElementFactory::~ExportElementFactory () ExportTimespanPtr ExportElementFactory::add_timespan () { - return ExportTimespanPtr (new ExportTimespan (session.get_export_status(), session.frame_rate())); + return ExportTimespanPtr (new ExportTimespan (session.get_export_status(), session.sample_rate())); } ExportChannelConfigPtr @@ -109,7 +112,7 @@ ExportHandler::ExportHandler (Session & session) , session (session) , graph_builder (new ExportGraphBuilder (session)) , export_status (session.get_export_status ()) - , normalizing (false) + , post_processing (false) , cue_tracknum (0) , cue_indexnum (0) { @@ -117,7 +120,7 @@ ExportHandler::ExportHandler (Session & session) ExportHandler::~ExportHandler () { - // TODO remove files that were written but not finished + graph_builder->cleanup (export_status->aborted () ); } /** Add an export to the `to-do' list */ @@ -142,13 +145,22 @@ ExportHandler::do_export () for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) { bool new_timespan = timespan_set.insert (it->first).second; if (new_timespan) { - export_status->total_frames += it->first->get_length(); + export_status->total_samples += it->first->get_length(); } } export_status->total_timespans = timespan_set.size(); + if (export_status->total_timespans > 1) { + // always include timespan if there's more than one. + for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) { + FileSpec & spec = it->second; + spec.filename->include_timespan = true; + } + } + /* Start export */ + Glib::Threads::Mutex::Lock l (export_status->lock()); start_timespan (); } @@ -159,7 +171,7 @@ ExportHandler::start_timespan () if (config_map.empty()) { // freewheeling has to be stopped from outside the process cycle - export_status->running = false; + export_status->set_running (false); return; } @@ -167,10 +179,10 @@ ExportHandler::start_timespan () 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->total_samples_current_timespan = current_timespan->get_length(); export_status->timespan_name = current_timespan->name(); - export_status->processed_frames_current_timespan = 0; + export_status->processed_samples_current_timespan = 0; /* Register file configurations to graph builder */ @@ -179,19 +191,33 @@ ExportHandler::start_timespan () graph_builder->reset (); graph_builder->set_current_timespan (current_timespan); handle_duplicate_format_extensions(); + bool realtime = current_timespan->realtime (); + bool region_export = true; 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); + switch (spec.channel_config->region_processing_type ()) { + case RegionExportChannelFactory::None: + case RegionExportChannelFactory::Processed: + region_export = false; + break; + default: + break; + } + graph_builder->add_config (spec, realtime); } + // ExportDialog::update_realtime_selection does not allow this + assert (!region_export || !realtime); + /* start export */ - normalizing = false; + post_processing = false; session.ProcessExport.connect_same_thread (process_connection, boost::bind (&ExportHandler::process, this, _1)); process_position = current_timespan->get_start(); - session.start_audio_export (process_position); + // TODO check if it's a RegionExport.. set flag to skip process_without_events() + session.start_audio_export (process_position, realtime, region_export); } void @@ -201,7 +227,16 @@ ExportHandler::handle_duplicate_format_extensions() ExtCountMap counts; for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) { - counts[it->second.format->extension()]++; + if (it->second.filename->include_channel_config && it->second.channel_config) { + /* stem-export has multiple files in the same timestamp, but a different channel_config for each. + * However channel_config is only set in ExportGraphBuilder::Encoder::init_writer() + * so we cannot yet use it->second.filename->get_path(it->second.format). + * We have to explicily check uniqueness of "channel-config + extension" here: + */ + counts[it->second.channel_config->name() + it->second.format->extension()]++; + } else { + counts[it->second.format->extension()]++; + } } bool duplicates_found = false; @@ -216,47 +251,55 @@ ExportHandler::handle_duplicate_format_extensions() } int -ExportHandler::process (framecnt_t frames) +ExportHandler::process (samplecnt_t samples) { - if (!export_status->running) { + if (!export_status->running ()) { return 0; - } else if (normalizing) { - return process_normalize (); + } else if (post_processing) { + Glib::Threads::Mutex::Lock l (export_status->lock()); + if (AudioEngine::instance()->freewheeling ()) { + return post_process (); + } else { + // wait until we're freewheeling + return 0; + } } else { - return process_timespan (frames); + Glib::Threads::Mutex::Lock l (export_status->lock()); + return process_timespan (samples); } } int -ExportHandler::process_timespan (framecnt_t frames) +ExportHandler::process_timespan (samplecnt_t samples) { + export_status->active_job = ExportStatus::Exporting; /* update position */ - framecnt_t frames_to_read = 0; - framepos_t const end = current_timespan->get_end(); + samplecnt_t samples_to_read = 0; + samplepos_t const end = current_timespan->get_end(); - bool const last_cycle = (process_position + frames >= end); + bool const last_cycle = (process_position + samples >= end); if (last_cycle) { - frames_to_read = end - process_position; + samples_to_read = end - process_position; export_status->stop = true; } else { - frames_to_read = frames; + samples_to_read = samples; } - process_position += frames_to_read; - export_status->processed_frames += frames_to_read; - export_status->processed_frames_current_timespan += frames_to_read; + process_position += samples_to_read; + export_status->processed_samples += samples_to_read; + export_status->processed_samples_current_timespan += samples_to_read; /* Do actual processing */ - int ret = graph_builder->process (frames_to_read, last_cycle); + int ret = graph_builder->process (samples_to_read, last_cycle); - /* Start normalizing if necessary */ + /* Start post-processing/normalizing if necessary */ if (last_cycle) { - normalizing = graph_builder->will_normalize(); - if (normalizing) { - export_status->total_normalize_cycles = graph_builder->get_normalize_cycle_count(); - export_status->current_normalize_cycle = 0; + post_processing = graph_builder->need_postprocessing (); + if (post_processing) { + export_status->total_postprocessing_cycles = graph_builder->get_postprocessing_cycle_count(); + export_status->current_postprocessing_cycle = 0; } else { finish_timespan (); return 0; @@ -267,16 +310,20 @@ ExportHandler::process_timespan (framecnt_t frames) } int -ExportHandler::process_normalize () +ExportHandler::post_process () { - if (graph_builder->process_normalize ()) { + if (graph_builder->post_process ()) { finish_timespan (); - export_status->normalizing = false; + export_status->active_job = ExportStatus::Exporting; } else { - export_status->normalizing = true; + if (graph_builder->realtime ()) { + export_status->active_job = ExportStatus::Encoding; + } else { + export_status->active_job = ExportStatus::Normalizing; + } } - export_status->current_normalize_cycle++; + export_status->current_postprocessing_cycle++; return 0; } @@ -291,11 +338,12 @@ ExportHandler::command_output(std::string output, size_t size) void ExportHandler::finish_timespan () { + graph_builder->get_analysis_results (export_status->result_map); + while (config_map.begin() != timespan_bounds.second) { ExportFormatSpecPtr fmt = config_map.begin()->second.format; std::string filename = config_map.begin()->second.filename->get_path(fmt); - if (fmt->with_cue()) { export_cd_marker_file (current_timespan, fmt, filename, CDMarkerCUE); } @@ -304,57 +352,103 @@ ExportHandler::finish_timespan () export_cd_marker_file (current_timespan, fmt, filename, CDMarkerTOC); } + if (fmt->with_mp4chaps()) { + export_cd_marker_file (current_timespan, fmt, filename, MP4Chaps); + } + + Session::Exported (current_timespan->name(), filename); /* EMIT SIGNAL */ + + /* close file first, otherwise TagLib enounters an ERROR_SHARING_VIOLATION + * The process cannot access the file because it is being used. + * ditto for post-export and upload. + */ + graph_builder->reset (); + if (fmt->tag()) { + /* TODO: check Umlauts and encoding in filename. + * TagLib eventually calls CreateFileA(), + */ + export_status->active_job = ExportStatus::Tagging; AudiofileTagger::tag_file(filename, *SessionMetadata::Metadata()); } if (!fmt->command().empty()) { + SessionMetadata const & metadata (*SessionMetadata::Metadata()); -#if 0 // would be nicer with C++11 initialiser... +#if 0 // would be nicer with C++11 initialiser... std::map subs { { 'f', filename }, - { 'd', Glib::path_get_dirname(filename) }, + { 'd', Glib::path_get_dirname(filename) + G_DIR_SEPARATOR }, { 'b', PBD::basename_nosuffix(filename) }, - { 'u', upload_username }, - { 'p', upload_password} + ... }; #endif - + export_status->active_job = ExportStatus::Command; PBD::ScopedConnection command_connection; std::map subs; - subs.insert (std::pair ('f', filename)); - subs.insert (std::pair ('d', Glib::path_get_dirname(filename))); - subs.insert (std::pair ('b', PBD::basename_nosuffix(filename))); - subs.insert (std::pair ('u', soundcloud_username)); - subs.insert (std::pair ('p', soundcloud_password)); + std::stringstream track_number; + track_number << metadata.track_number (); + std::stringstream total_tracks; + total_tracks << metadata.total_tracks (); + std::stringstream year; + year << metadata.year (); + + subs.insert (std::pair ('a', metadata.artist ())); + subs.insert (std::pair ('b', PBD::basename_nosuffix (filename))); + subs.insert (std::pair ('c', metadata.copyright ())); + subs.insert (std::pair ('d', Glib::path_get_dirname (filename) + G_DIR_SEPARATOR)); + subs.insert (std::pair ('f', filename)); + subs.insert (std::pair ('l', metadata.lyricist ())); + subs.insert (std::pair ('n', session.name ())); + subs.insert (std::pair ('s', session.path ())); + subs.insert (std::pair ('o', metadata.conductor ())); + subs.insert (std::pair ('t', metadata.title ())); + subs.insert (std::pair ('z', metadata.organization ())); + subs.insert (std::pair ('A', metadata.album ())); + subs.insert (std::pair ('C', metadata.comment ())); + subs.insert (std::pair ('E', metadata.engineer ())); + subs.insert (std::pair ('G', metadata.genre ())); + subs.insert (std::pair ('L', total_tracks.str ())); + subs.insert (std::pair ('M', metadata.mixer ())); + subs.insert (std::pair ('N', current_timespan->name())); // =?= config_map.begin()->first->name () + subs.insert (std::pair ('O', metadata.composer ())); + subs.insert (std::pair ('P', metadata.producer ())); + subs.insert (std::pair ('S', metadata.disc_subtitle ())); + subs.insert (std::pair ('T', track_number.str ())); + subs.insert (std::pair ('Y', year.str ())); + subs.insert (std::pair ('Z', metadata.country ())); - std::cerr << "running command: " << fmt->command() << "..." << std::endl; 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)); - if (se->start (2) == 0) { + int ret = se->start (2); + if (ret == 0) { // successfully started - std::cerr << "started!" << std::endl; while (se->is_running ()) { // wait for system exec to terminate - // std::cerr << "waiting..." << std::endl; Glib::usleep (1000); } + } else { + error << "Post-export command FAILED with Error: " << ret << endmsg; } - std::cerr << "done! deleting..." << std::endl; delete (se); } + // XXX THIS IS IN REALTIME CONTEXT, CALLED FROM + // AudioEngine::process_callback() + // freewheeling, yes, but still uploading here is NOT + // a good idea. + // + // even less so, since SoundcloudProgress is using + // connect_same_thread() - GUI updates from the RT thread + // will cause crashes. http://pastebin.com/UJKYNGHR if (fmt->soundcloud_upload()) { SoundcloudUploader *soundcloud_uploader = new SoundcloudUploader; std::string token = soundcloud_uploader->Get_Auth_Token(soundcloud_username, soundcloud_password); - std::cerr - << "uploading " - << filename << std::endl - << "username = " << soundcloud_username - << ", password = " << soundcloud_password - << " - token = " << token << " ..." - << std::endl; + 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 @@ -366,11 +460,11 @@ ExportHandler::finish_timespan () if (path.length() != 0) { info << string_compose ( _("File %1 uploaded to %2"), filename, path) << endmsg; if (soundcloud_open_page) { - std::cerr << "opening " << path << " ..." << std::endl; + 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; + error << _("upload to Soundcloud failed. Perhaps your email or password are incorrect?\n") << endmsg; } delete soundcloud_uploader; } @@ -380,6 +474,13 @@ ExportHandler::finish_timespan () start_timespan (); } +void +ExportHandler::reset () +{ + config_map.clear (); + graph_builder->reset (); +} + /*** CD Marker stuff ***/ struct LocationSortByStart { @@ -410,17 +511,17 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp track_func = &ExportHandler::write_track_info_cue; index_func = &ExportHandler::write_index_info_cue; break; + case MP4Chaps: + header_func = &ExportHandler::write_mp4ch_header; + track_func = &ExportHandler::write_track_info_mp4ch; + index_func = &ExportHandler::write_index_info_mp4ch; + break; default: return; } CDMarkerStatus status (filepath, timespan, file_format, filename); - if (!status.out) { - error << string_compose(_("Editor: cannot open \"%1\" as export file for CD marker file"), filepath) << endmsg; - return; - } - (this->*header_func) (status); /* Get locations and sort */ @@ -446,8 +547,8 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp /* 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(); + samplepos_t last_end_time = timespan->get_start(); + status.track_position = 0; for (i = temp.begin(); i != temp.end(); ++i) { @@ -467,7 +568,7 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp /* 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_start_sample = (*i)->start() - timespan->get_start(); // everything before this is the pregap status.track_duration = 0; if ((*i)->is_mark()) { @@ -478,20 +579,17 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp if (nexti != temp.end()) { status.track_duration = (*nexti)->start() - last_end_time; - last_start_time = (*i)->start(); last_end_time = (*nexti)->start(); } else { // this was the last marker, use timespan end status.track_duration = timespan->get_end() - last_end_time; - last_start_time = (*i)->start(); last_end_time = timespan->get_end(); } } else { // range status.track_duration = (*i)->end() - last_end_time; - last_start_time = (*i)->start(); last_end_time = (*i)->end(); } @@ -499,10 +597,10 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp } } catch (std::exception& e) { - error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg; + error << string_compose (_("an error occurred while writing a TOC/CUE file: %1"), e.what()) << endmsg; ::g_unlink (filepath.c_str()); } catch (Glib::Exception& e) { - error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg; + error << string_compose (_("an error occurred while writing a TOC/CUE file: %1"), e.what()) << endmsg; ::g_unlink (filepath.c_str()); } } @@ -510,17 +608,22 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp string ExportHandler::get_cd_marker_filename(std::string filename, CDMarkerFormat format) { - /* do not strip file suffix because there may be more than one format, + /* do not strip file suffix because there may be more than one format, and we do not want the CD marker file from one format to overwrite another (e.g. foo.wav.cue > foo.aiff.cue) */ switch (format) { - case CDMarkerTOC: + case CDMarkerTOC: return filename + ".toc"; - case CDMarkerCUE: + case CDMarkerCUE: return filename + ".cue"; - default: + case MP4Chaps: + { + unsigned lastdot = filename.find_last_of('.'); + return filename.substr(0,lastdot) + ".chapters.txt"; + } + default: return filename + ".marker"; // Should not be reached when actually creating a file } } @@ -530,16 +633,31 @@ ExportHandler::write_cue_header (CDMarkerStatus & status) { string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name(); + // Album metadata + string barcode = SessionMetadata::Metadata()->barcode(); + string album_artist = SessionMetadata::Metadata()->album_artist(); + string album_title = SessionMetadata::Metadata()->album(); + status.out << "REM Cue file generated by " << PROGRAM_NAME << endl; + + if (barcode != "") + status.out << "CATALOG " << barcode << endl; + + if (album_artist != "") + status.out << "PERFORMER " << cue_escape_cdtext (album_artist) << endl; + + if (album_title != "") + title = album_title; + status.out << "TITLE " << cue_escape_cdtext (title) << endl; - /* The original cue sheet sepc metions five file types + /* The original cue sheet spec mentions five file types WAVE, AIFF, BINARY = "header-less" audio (44.1 kHz, 16 Bit, little endian), MOTOROLA = "header-less" audio (44.1 kHz, 16 Bit, big endian), and MP3 - - We try to use these file types whenever appropriate and + + We try to use these file types whenever appropriate and default to our own names otherwise. */ status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" "; @@ -566,10 +684,28 @@ ExportHandler::write_toc_header (CDMarkerStatus & status) { string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name(); + // Album metadata + string barcode = SessionMetadata::Metadata()->barcode(); + string album_artist = SessionMetadata::Metadata()->album_artist(); + string album_title = SessionMetadata::Metadata()->album(); + + if (barcode != "") + status.out << "CATALOG \"" << barcode << "\"" << endl; + + if (album_title != "") + title = album_title; + status.out << "CD_DA" << endl; status.out << "CD_TEXT {" << endl << " LANGUAGE_MAP {" << endl << " 0 : EN" << endl << " }" << endl; status.out << " LANGUAGE 0 {" << endl << " TITLE " << toc_escape_cdtext (title) << endl ; - status.out << " PERFORMER \"\"" << endl << " }" << endl << "}" << endl; + status.out << " PERFORMER " << toc_escape_cdtext (album_artist) << endl; + status.out << " }" << endl << "}" << endl; +} + +void +ExportHandler::write_mp4ch_header (CDMarkerStatus & status) +{ + status.out << "00:00:00.000 Intro" << endl; } void @@ -608,12 +744,12 @@ ExportHandler::write_track_info_cue (CDMarkerStatus & status) 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); + if (status.track_position != status.track_start_sample) { + samples_to_cd_samples_string (buf, status.track_position); status.out << " INDEX 00" << buf << endl; } - frames_to_cd_frames_string (buf, status.track_start_frame); + samples_to_cd_samples_string (buf, status.track_start_sample); status.out << " INDEX 01" << buf << endl; status.index_number = 2; @@ -644,14 +780,14 @@ ExportHandler::write_track_info_toc (CDMarkerStatus & status) status.out << "CD_TEXT {" << endl << " LANGUAGE 0 {" << endl; status.out << " TITLE " << toc_escape_cdtext (status.marker->name()) << endl; - + status.out << " PERFORMER "; if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) { status.out << toc_escape_cdtext (status.marker->cd_info["performer"]) << endl; } else { status.out << "\"\"" << endl; } - + if (status.marker->cd_info.find("composer") != status.marker->cd_info.end()) { status.out << " SONGWRITER " << toc_escape_cdtext (status.marker->cd_info["composer"]) << endl; } @@ -666,16 +802,24 @@ ExportHandler::write_track_info_toc (CDMarkerStatus & status) status.out << " }" << endl << "}" << endl; - frames_to_cd_frames_string (buf, status.track_position); + samples_to_cd_samples_string (buf, status.track_position); status.out << "FILE " << toc_escape_filename (status.filename) << ' ' << buf; - frames_to_cd_frames_string (buf, status.track_duration); + samples_to_cd_samples_string (buf, status.track_duration); status.out << buf << endl; - frames_to_cd_frames_string (buf, status.track_start_frame - status.track_position); + samples_to_cd_samples_string (buf, status.track_start_sample - status.track_position); status.out << "START" << buf << endl; } +void ExportHandler::write_track_info_mp4ch (CDMarkerStatus & status) +{ + gchar buf[18]; + + samples_to_chapter_marks_string(buf, status.track_start_sample); + status.out << buf << " " << status.marker->name() << endl; +} + void ExportHandler::write_index_info_cue (CDMarkerStatus & status) { @@ -683,7 +827,7 @@ ExportHandler::write_index_info_cue (CDMarkerStatus & status) snprintf (buf, sizeof(buf), " INDEX %02d", cue_indexnum); status.out << buf; - frames_to_cd_frames_string (buf, status.index_position); + samples_to_cd_samples_string (buf, status.index_position); status.out << buf << endl; cue_indexnum++; @@ -694,23 +838,45 @@ ExportHandler::write_index_info_toc (CDMarkerStatus & status) { gchar buf[18]; - frames_to_cd_frames_string (buf, status.index_position - status.track_position); + samples_to_cd_samples_string (buf, status.index_position - status.track_position); status.out << "INDEX" << buf << endl; } void -ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when) +ExportHandler::write_index_info_mp4ch (CDMarkerStatus & status) +{ +} + +void +ExportHandler::samples_to_cd_samples_string (char* buf, samplepos_t when) { - framecnt_t remainder; - framecnt_t fr = session.nominal_frame_rate(); - int mins, secs, frames; + samplecnt_t remainder; + samplecnt_t fr = session.nominal_sample_rate(); + int mins, secs, samples; mins = when / (60 * fr); remainder = when - (mins * 60 * fr); secs = remainder / fr; remainder -= secs * fr; - frames = remainder / (fr / 75); - sprintf (buf, " %02d:%02d:%02d", mins, secs, frames); + samples = remainder / (fr / 75); + sprintf (buf, " %02d:%02d:%02d", mins, secs, samples); +} + +void +ExportHandler::samples_to_chapter_marks_string (char* buf, samplepos_t when) +{ + samplecnt_t remainder; + samplecnt_t fr = session.nominal_sample_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 @@ -722,7 +888,7 @@ ExportHandler::toc_escape_cdtext (const std::string& txt) char buf[5]; try { - latin1_txt = Glib::convert (txt, "ISO-8859-1", "UTF-8"); + latin1_txt = Glib::convert_with_fallback (txt, "ISO-8859-1", "UTF-8", "_"); } catch (Glib::ConvertError& err) { throw Glib::ConvertError (err.code(), string_compose (_("Cannot convert %1 to Latin-1 text"), txt)); } @@ -742,7 +908,7 @@ ExportHandler::toc_escape_cdtext (const std::string& txt) out += buf; } } - + out += '"'; return out; @@ -767,7 +933,7 @@ ExportHandler::toc_escape_filename (const std::string& txt) out += *c; } } - + out += '"'; return out; @@ -778,15 +944,15 @@ 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 + // that may have to change if cue parsers in burning programs change out = '"' + latin1_txt + '"'; return out;