libs/ardour/export_handler.cc

   1 /*
   2     Copyright (C) 2008-2009 Paul Davis
   3     Author: Sakari Bergen
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include "ardour/export_handler.h"
  22
  23 #include <glibmm.h>
  24 #include <glibmm/convert.h>
  25
  26 #include "pbd/convert.h"
  27
  28 #include "ardour/audiofile_tagger.h"
  29 #include "ardour/export_graph_builder.h"
  30 #include "ardour/export_timespan.h"
  31 #include "ardour/export_channel_configuration.h"
  32 #include "ardour/export_status.h"
  33 #include "ardour/export_format_specification.h"
  34 #include "ardour/export_filename.h"
  35 #include "ardour/soundcloud_upload.h"
  36 #include "ardour/system_exec.h"
  37 #include "pbd/openuri.h"
  38 #include "pbd/basename.h"
  39 #include "ardour/session_metadata.h"
  40
  41 #include "i18n.h"
  42
  43 using namespace std;
  44 using namespace PBD;
  45
  46 namespace ARDOUR
  47 {
  48
  49 /*** ExportElementFactory ***/
  50
  51 ExportElementFactory::ExportElementFactory (Session & session) :
  52   session (session)
  53 {
  54
  55 }
  56
  57 ExportElementFactory::~ExportElementFactory ()
  58 {
  59
  60 }
  61
  62 ExportTimespanPtr
  63 ExportElementFactory::add_timespan ()
  64 {
  65         return ExportTimespanPtr (new ExportTimespan (session.get_export_status(), session.frame_rate()));
  66 }
  67
  68 ExportChannelConfigPtr
  69 ExportElementFactory::add_channel_config ()
  70 {
  71         return ExportChannelConfigPtr (new ExportChannelConfiguration (session));
  72 }
  73
  74 ExportFormatSpecPtr
  75 ExportElementFactory::add_format ()
  76 {
  77         return ExportFormatSpecPtr (new ExportFormatSpecification (session));
  78 }
  79
  80 ExportFormatSpecPtr
  81 ExportElementFactory::add_format (XMLNode const & state)
  82 {
  83         return ExportFormatSpecPtr (new ExportFormatSpecification (session, state));
  84 }
  85
  86 ExportFormatSpecPtr
  87 ExportElementFactory::add_format_copy (ExportFormatSpecPtr other)
  88 {
  89         return ExportFormatSpecPtr (new ExportFormatSpecification (*other));
  90 }
  91
  92 ExportFilenamePtr
  93 ExportElementFactory::add_filename ()
  94 {
  95         return ExportFilenamePtr (new ExportFilename (session));
  96 }
  97
  98 ExportFilenamePtr
  99 ExportElementFactory::add_filename_copy (ExportFilenamePtr other)
 100 {
 101         return ExportFilenamePtr (new ExportFilename (*other));
 102 }
 103
 104 /*** ExportHandler ***/
 105
 106 ExportHandler::ExportHandler (Session & session)
 107   : ExportElementFactory (session)
 108   , session (session)
 109   , graph_builder (new ExportGraphBuilder (session))
 110   , export_status (session.get_export_status ())
 111   , normalizing (false)
 112   , cue_tracknum (0)
 113   , cue_indexnum (0)
 114 {
 115 }
 116
 117 ExportHandler::~ExportHandler ()
 118 {
 119         // TODO remove files that were written but not finished
 120 }
 121
 122 /** Add an export to the `to-do' list */
 123 bool
 124 ExportHandler::add_export_config (ExportTimespanPtr timespan, ExportChannelConfigPtr channel_config,
 125                                   ExportFormatSpecPtr format, ExportFilenamePtr filename,
 126                                   BroadcastInfoPtr broadcast_info)
 127 {
 128         FileSpec spec (channel_config, format, filename, broadcast_info);
 129         config_map.insert (make_pair (timespan, spec));
 130
 131         return true;
 132 }
 133
 134 void
 135 ExportHandler::do_export ()
 136 {
 137         /* Count timespans */
 138
 139         export_status->init();
 140         std::set<ExportTimespanPtr> timespan_set;
 141         for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) {
 142                 bool new_timespan = timespan_set.insert (it->first).second;
 143                 if (new_timespan) {
 144                         export_status->total_frames += it->first->get_length();
 145                 }
 146         }
 147         export_status->total_timespans = timespan_set.size();
 148
 149         /* Start export */
 150
 151         start_timespan ();
 152 }
 153
 154 void
 155 ExportHandler::start_timespan ()
 156 {
 157         export_status->timespan++;
 158
 159         if (config_map.empty()) {
 160                 // freewheeling has to be stopped from outside the process cycle
 161                 export_status->running = false;
 162                 return;
 163         }
 164
 165         /* finish_timespan pops the config_map entry that has been done, so
 166            this is the timespan to do this time
 167         */
 168         current_timespan = config_map.begin()->first;
 169
 170         export_status->total_frames_current_timespan = current_timespan->get_length();
 171         export_status->timespan_name = current_timespan->name();
 172         export_status->processed_frames_current_timespan = 0;
 173
 174         /* Register file configurations to graph builder */
 175
 176         /* Here's the config_map entries that use this timespan */
 177         timespan_bounds = config_map.equal_range (current_timespan);
 178         graph_builder->reset ();
 179         graph_builder->set_current_timespan (current_timespan);
 180         handle_duplicate_format_extensions();
 181         for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
 182                 // Filenames can be shared across timespans
 183                 FileSpec & spec = it->second;
 184                 spec.filename->set_timespan (it->first);
 185                 graph_builder->add_config (spec);
 186         }
 187
 188         /* start export */
 189
 190         normalizing = false;
 191         session.ProcessExport.connect_same_thread (process_connection, boost::bind (&ExportHandler::process, this, _1));
 192         process_position = current_timespan->get_start();
 193         session.start_audio_export (process_position);
 194 }
 195
 196 void
 197 ExportHandler::handle_duplicate_format_extensions()
 198 {
 199         typedef std::map<std::string, int> ExtCountMap;
 200
 201         ExtCountMap counts;
 202         for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
 203                 counts[it->second.format->extension()]++;
 204         }
 205
 206         bool duplicates_found = false;
 207         for (ExtCountMap::iterator it = counts.begin(); it != counts.end(); ++it) {
 208                 if (it->second > 1) { duplicates_found = true; }
 209         }
 210
 211         // Set this always, as the filenames are shared...
 212         for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
 213                 it->second.filename->include_format_name = duplicates_found;
 214         }
 215 }
 216
 217 int
 218 ExportHandler::process (framecnt_t frames)
 219 {
 220         if (!export_status->running) {
 221                 return 0;
 222         } else if (normalizing) {
 223                 return process_normalize ();
 224         } else {
 225                 return process_timespan (frames);
 226         }
 227 }
 228
 229 int
 230 ExportHandler::process_timespan (framecnt_t frames)
 231 {
 232         /* update position */
 233
 234         framecnt_t frames_to_read = 0;
 235         framepos_t const end = current_timespan->get_end();
 236
 237         bool const last_cycle = (process_position + frames >= end);
 238
 239         if (last_cycle) {
 240                 frames_to_read = end - process_position;
 241                 export_status->stop = true;
 242         } else {
 243                 frames_to_read = frames;
 244         }
 245
 246         process_position += frames_to_read;
 247         export_status->processed_frames += frames_to_read;
 248         export_status->processed_frames_current_timespan += frames_to_read;
 249
 250         /* Do actual processing */
 251         int ret = graph_builder->process (frames_to_read, last_cycle);
 252
 253         /* Start normalizing if necessary */
 254         if (last_cycle) {
 255                 normalizing = graph_builder->will_normalize();
 256                 if (normalizing) {
 257                         export_status->total_normalize_cycles = graph_builder->get_normalize_cycle_count();
 258                         export_status->current_normalize_cycle = 0;
 259                 } else {
 260                         finish_timespan ();
 261                         return 0;
 262                 }
 263         }
 264
 265         return ret;
 266 }
 267
 268 int
 269 ExportHandler::process_normalize ()
 270 {
 271         if (graph_builder->process_normalize ()) {
 272                 finish_timespan ();
 273                 export_status->normalizing = false;
 274         } else {
 275                 export_status->normalizing = true;
 276         }
 277
 278         export_status->current_normalize_cycle++;
 279
 280         return 0;
 281 }
 282
 283 void
 284 ExportHandler::command_output(std::string output, size_t size)
 285 {
 286         std::cerr << "command: " << size << ", " << output << std::endl;
 287         info << output << endmsg;
 288 }
 289
 290 void
 291 ExportHandler::finish_timespan ()
 292 {
 293         while (config_map.begin() != timespan_bounds.second) {
 294
 295                 ExportFormatSpecPtr fmt = config_map.begin()->second.format;
 296                 std::string filename = config_map.begin()->second.filename->get_path(fmt);
 297
 298                 if (fmt->with_cue()) {
 299                         export_cd_marker_file (current_timespan, fmt, filename, CDMarkerCUE);
 300                 }
 301
 302                 if (fmt->with_toc()) {
 303                         export_cd_marker_file (current_timespan, fmt, filename, CDMarkerTOC);
 304                 }
 305
 306                 if (fmt->tag()) {
 307                         AudiofileTagger::tag_file(filename, *SessionMetadata::Metadata());
 308                 }
 309
 310                 if (!fmt->command().empty()) {
 311
 312 #if 0                   // would be nicer with C++11 initialiser...
 313                         std::map<char, std::string> subs {
 314                                 { 'f', filename },
 315                                 { 'd', Glib::path_get_dirname(filename) },
 316                                 { 'b', PBD::basename_nosuffix(filename) },
 317                                 { 'u', upload_username },
 318                                 { 'p', upload_password}
 319                         };
 320 #endif
 321
 322                         PBD::ScopedConnection command_connection;
 323                         std::map<char, std::string> subs;
 324                         subs.insert (std::pair<char, std::string> ('f', filename));
 325                         subs.insert (std::pair<char, std::string> ('d', Glib::path_get_dirname(filename)));
 326                         subs.insert (std::pair<char, std::string> ('b', PBD::basename_nosuffix(filename)));
 327                         subs.insert (std::pair<char, std::string> ('u', upload_username));
 328                         subs.insert (std::pair<char, std::string> ('p', upload_password));
 329
 330
 331                         std::cerr << "running command: " << fmt->command() << "..." << std::endl;
 332                         ARDOUR::SystemExec *se = new ARDOUR::SystemExec(fmt->command(), subs);
 333                         se->ReadStdout.connect_same_thread(command_connection, boost::bind(&ExportHandler::command_output, this, _1, _2));
 334                         if (se->start (2) == 0) {
 335                                 // successfully started
 336                                 std::cerr << "started!" << std::endl;
 337                                 while (se->is_running ()) {
 338                                         // wait for system exec to terminate
 339                                         // std::cerr << "waiting..." << std::endl;
 340                                         usleep (1000);
 341                                 }
 342                         }
 343                         std::cerr << "done! deleting..." << std::endl;
 344                         delete (se);
 345                 }
 346
 347                 if (fmt->upload()) {
 348                         SoundcloudUploader *soundcloud_uploader = new SoundcloudUploader;
 349                         std::string token = soundcloud_uploader->Get_Auth_Token(upload_username, upload_password);
 350                         std::cerr
 351                                 << "uploading "
 352                                 << filename << std::endl
 353                                 << "username = " << upload_username
 354                                 << ", password = " << upload_password
 355                                 << " - token = " << token << " ..."
 356                                 << std::endl;
 357                         std::string path = soundcloud_uploader->Upload (
 358                                         filename,
 359                                         PBD::basename_nosuffix(filename), // title
 360                                         token,
 361                                         upload_public,
 362                                         this);
 363
 364                         if (path.length() != 0) {
 365                                 if (upload_open) {
 366                                 std::cerr << "opening " << path << " ..." << std::endl;
 367                                 open_uri(path.c_str());  // open the soundcloud website to the new file
 368                                 }
 369                         } else {
 370                                 error << _("upload to Soundcloud failed.  Perhaps your email or password are incorrect?\n") << endmsg;
 371                         }
 372                         delete soundcloud_uploader;
 373                 }
 374                 config_map.erase (config_map.begin());
 375         }
 376
 377         start_timespan ();
 378 }
 379
 380 /*** CD Marker stuff ***/
 381
 382 struct LocationSortByStart {
 383     bool operator() (Location *a, Location *b) {
 384             return a->start() < b->start();
 385     }
 386 };
 387
 388 void
 389 ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSpecPtr file_format,
 390                                       std::string filename, CDMarkerFormat format)
 391 {
 392         string filepath = get_cd_marker_filename(filename, format);
 393
 394         try {
 395                 void (ExportHandler::*header_func) (CDMarkerStatus &);
 396                 void (ExportHandler::*track_func) (CDMarkerStatus &);
 397                 void (ExportHandler::*index_func) (CDMarkerStatus &);
 398
 399                 switch (format) {
 400                 case CDMarkerTOC:
 401                         header_func = &ExportHandler::write_toc_header;
 402                         track_func = &ExportHandler::write_track_info_toc;
 403                         index_func = &ExportHandler::write_index_info_toc;
 404                         break;
 405                 case CDMarkerCUE:
 406                         header_func = &ExportHandler::write_cue_header;
 407                         track_func = &ExportHandler::write_track_info_cue;
 408                         index_func = &ExportHandler::write_index_info_cue;
 409                         break;
 410                 default:
 411                         return;
 412                 }
 413
 414                 CDMarkerStatus status (filepath, timespan, file_format, filename);
 415
 416                 if (!status.out) {
 417                         error << string_compose(_("Editor: cannot open \"%1\" as export file for CD marker file"), filepath) << endmsg;
 418                         return;
 419                 }
 420
 421                 (this->*header_func) (status);
 422
 423                 /* Get locations and sort */
 424
 425                 Locations::LocationList const & locations (session.locations()->list());
 426                 Locations::LocationList::const_iterator i;
 427                 Locations::LocationList temp;
 428
 429                 for (i = locations.begin(); i != locations.end(); ++i) {
 430                         if ((*i)->start() >= timespan->get_start() && (*i)->end() <= timespan->get_end() && (*i)->is_cd_marker() && !(*i)->is_session_range()) {
 431                                 temp.push_back (*i);
 432                         }
 433                 }
 434
 435                 if (temp.empty()) {
 436                         // TODO One index marker for whole thing
 437                         return;
 438                 }
 439
 440                 LocationSortByStart cmp;
 441                 temp.sort (cmp);
 442                 Locations::LocationList::const_iterator nexti;
 443
 444                 /* Start actual marker stuff */
 445
 446                 framepos_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
 447                 status.track_position = last_start_time - timespan->get_start();
 448
 449                 for (i = temp.begin(); i != temp.end(); ++i) {
 450
 451                         status.marker = *i;
 452
 453                         if ((*i)->start() < last_end_time) {
 454                                 if ((*i)->is_mark()) {
 455                                         /* Index within track */
 456
 457                                         status.index_position = (*i)->start() - timespan->get_start();
 458                                         (this->*index_func) (status);
 459                                 }
 460
 461                                 continue;
 462                         }
 463
 464                         /* A track, defined by a cd range marker or a cd location marker outside of a cd range */
 465
 466                         status.track_position = last_end_time - timespan->get_start();
 467                         status.track_start_frame = (*i)->start() - timespan->get_start();  // everything before this is the pregap
 468                         status.track_duration = 0;
 469
 470                         if ((*i)->is_mark()) {
 471                                 // a mark track location needs to look ahead to the next marker's start to determine length
 472                                 nexti = i;
 473                                 ++nexti;
 474
 475                                 if (nexti != temp.end()) {
 476                                         status.track_duration = (*nexti)->start() - last_end_time;
 477
 478                                         last_start_time = (*i)->start();
 479                                         last_end_time = (*nexti)->start();
 480                                 } else {
 481                                         // this was the last marker, use timespan end
 482                                         status.track_duration = timespan->get_end() - last_end_time;
 483
 484                                         last_start_time = (*i)->start();
 485                                         last_end_time = timespan->get_end();
 486                                 }
 487                         } else {
 488                                 // range
 489                                 status.track_duration = (*i)->end() - last_end_time;
 490
 491                                 last_start_time = (*i)->start();
 492                                 last_end_time = (*i)->end();
 493                         }
 494
 495                         (this->*track_func) (status);
 496                 }
 497
 498         } catch (std::exception& e) {
 499                 error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
 500                 ::unlink (filepath.c_str());
 501         } catch (Glib::Exception& e) {
 502                 error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
 503                 ::unlink (filepath.c_str());
 504         }
 505 }
 506
 507 string
 508 ExportHandler::get_cd_marker_filename(std::string filename, CDMarkerFormat format)
 509 {
 510         /* do not strip file suffix because there may be more than one format,
 511            and we do not want the CD marker file from one format to overwrite
 512            another (e.g. foo.wav.cue > foo.aiff.cue)
 513         */
 514
 515         switch (format) {
 516           case CDMarkerTOC:
 517                 return filename + ".toc";
 518           case CDMarkerCUE:
 519                 return filename + ".cue";
 520           default:
 521                 return filename + ".marker"; // Should not be reached when actually creating a file
 522         }
 523 }
 524
 525 void
 526 ExportHandler::write_cue_header (CDMarkerStatus & status)
 527 {
 528         string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
 529
 530         status.out << "REM Cue file generated by " << PROGRAM_NAME << endl;
 531         status.out << "TITLE " << cue_escape_cdtext (title) << endl;
 532
 533         /*  The original cue sheet sepc metions five file types
 534                 WAVE, AIFF,
 535                 BINARY   = "header-less" audio (44.1 kHz, 16 Bit, little endian),
 536                 MOTOROLA = "header-less" audio (44.1 kHz, 16 Bit, big endian),
 537                 and MP3
 538
 539                 We try to use these file types whenever appropriate and
 540                 default to our own names otherwise.
 541         */
 542         status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
 543         if (!status.format->format_name().compare ("WAV")  || !status.format->format_name().compare ("BWF")) {
 544                 status.out  << "WAVE";
 545         } else if (status.format->format_id() == ExportFormatBase::F_RAW &&
 546                    status.format->sample_format() == ExportFormatBase::SF_16 &&
 547                    status.format->sample_rate() == ExportFormatBase::SR_44_1) {
 548                 // Format is RAW 16bit 44.1kHz
 549                 if (status.format->endianness() == ExportFormatBase::E_Little) {
 550                         status.out << "BINARY";
 551                 } else {
 552                         status.out << "MOTOROLA";
 553                 }
 554         } else {
 555                 // no special case for AIFF format it's name is already "AIFF"
 556                 status.out << status.format->format_name();
 557         }
 558         status.out << endl;
 559 }
 560
 561 void
 562 ExportHandler::write_toc_header (CDMarkerStatus & status)
 563 {
 564         string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
 565
 566         status.out << "CD_DA" << endl;
 567         status.out << "CD_TEXT {" << endl << "  LANGUAGE_MAP {" << endl << "    0 : EN" << endl << "  }" << endl;
 568         status.out << "  LANGUAGE 0 {" << endl << "    TITLE " << toc_escape_cdtext (title) << endl ;
 569         status.out << "    PERFORMER \"\"" << endl << "  }" << endl << "}" << endl;
 570 }
 571
 572 void
 573 ExportHandler::write_track_info_cue (CDMarkerStatus & status)
 574 {
 575         gchar buf[18];
 576
 577         snprintf (buf, sizeof(buf), "  TRACK %02d AUDIO", status.track_number);
 578         status.out << buf << endl;
 579
 580         status.out << "    FLAGS" ;
 581         if (status.marker->cd_info.find("scms") != status.marker->cd_info.end())  {
 582                 status.out << " SCMS ";
 583         } else {
 584                 status.out << " DCP ";
 585         }
 586
 587         if (status.marker->cd_info.find("preemph") != status.marker->cd_info.end())  {
 588                 status.out << " PRE";
 589         }
 590         status.out << endl;
 591
 592         if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end())  {
 593                 status.out << "    ISRC " << status.marker->cd_info["isrc"] << endl;
 594         }
 595
 596         if (status.marker->name() != "") {
 597                 status.out << "    TITLE " << cue_escape_cdtext (status.marker->name()) << endl;
 598         }
 599
 600         if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) {
 601                 status.out <<  "    PERFORMER " << cue_escape_cdtext (status.marker->cd_info["performer"]) << endl;
 602         }
 603
 604         if (status.marker->cd_info.find("composer") != status.marker->cd_info.end()) {
 605                 status.out << "    SONGWRITER " << cue_escape_cdtext (status.marker->cd_info["composer"]) << endl;
 606         }
 607
 608         if (status.track_position != status.track_start_frame) {
 609                 frames_to_cd_frames_string (buf, status.track_position);
 610                 status.out << "    INDEX 00" << buf << endl;
 611         }
 612
 613         frames_to_cd_frames_string (buf, status.track_start_frame);
 614         status.out << "    INDEX 01" << buf << endl;
 615
 616         status.index_number = 2;
 617         status.track_number++;
 618 }
 619
 620 void
 621 ExportHandler::write_track_info_toc (CDMarkerStatus & status)
 622 {
 623         gchar buf[18];
 624
 625         status.out << endl << "TRACK AUDIO" << endl;
 626
 627         if (status.marker->cd_info.find("scms") != status.marker->cd_info.end())  {
 628                 status.out << "NO ";
 629         }
 630         status.out << "COPY" << endl;
 631
 632         if (status.marker->cd_info.find("preemph") != status.marker->cd_info.end())  {
 633                 status.out << "PRE_EMPHASIS" << endl;
 634         } else {
 635                 status.out << "NO PRE_EMPHASIS" << endl;
 636         }
 637
 638         if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end())  {
 639                 status.out << "ISRC \"" << status.marker->cd_info["isrc"] << "\"" << endl;
 640         }
 641
 642         status.out << "CD_TEXT {" << endl << "  LANGUAGE 0 {" << endl;
 643         status.out << "     TITLE " << toc_escape_cdtext (status.marker->name()) << endl;
 644
 645         status.out << "     PERFORMER ";
 646         if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) {
 647                 status.out << toc_escape_cdtext (status.marker->cd_info["performer"]) << endl;
 648         } else {
 649                 status.out << "\"\"" << endl;
 650         }
 651
 652         if (status.marker->cd_info.find("composer") != status.marker->cd_info.end()) {
 653                 status.out  << "     SONGWRITER " << toc_escape_cdtext (status.marker->cd_info["composer"]) << endl;
 654         }
 655
 656         if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
 657                 status.out  << "     ISRC \"";
 658                 status.out << status.marker->cd_info["isrc"].substr(0,2) << "-";
 659                 status.out << status.marker->cd_info["isrc"].substr(2,3) << "-";
 660                 status.out << status.marker->cd_info["isrc"].substr(5,2) << "-";
 661                 status.out << status.marker->cd_info["isrc"].substr(7,5) << "\"" << endl;
 662         }
 663
 664         status.out << "  }" << endl << "}" << endl;
 665
 666         frames_to_cd_frames_string (buf, status.track_position);
 667         status.out << "FILE " << toc_escape_filename (status.filename) << ' ' << buf;
 668
 669         frames_to_cd_frames_string (buf, status.track_duration);
 670         status.out << buf << endl;
 671
 672         frames_to_cd_frames_string (buf, status.track_start_frame - status.track_position);
 673         status.out << "START" << buf << endl;
 674 }
 675
 676 void
 677 ExportHandler::write_index_info_cue (CDMarkerStatus & status)
 678 {
 679         gchar buf[18];
 680
 681         snprintf (buf, sizeof(buf), "    INDEX %02d", cue_indexnum);
 682         status.out << buf;
 683         frames_to_cd_frames_string (buf, status.index_position);
 684         status.out << buf << endl;
 685
 686         cue_indexnum++;
 687 }
 688
 689 void
 690 ExportHandler::write_index_info_toc (CDMarkerStatus & status)
 691 {
 692         gchar buf[18];
 693
 694         frames_to_cd_frames_string (buf, status.index_position - status.track_position);
 695         status.out << "INDEX" << buf << endl;
 696 }
 697
 698 void
 699 ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when)
 700 {
 701         framecnt_t remainder;
 702         framecnt_t fr = session.nominal_frame_rate();
 703         int mins, secs, frames;
 704
 705         mins = when / (60 * fr);
 706         remainder = when - (mins * 60 * fr);
 707         secs = remainder / fr;
 708         remainder -= secs * fr;
 709         frames = remainder / (fr / 75);
 710         sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
 711 }
 712
 713 std::string
 714 ExportHandler::toc_escape_cdtext (const std::string& txt)
 715 {
 716         Glib::ustring check (txt);
 717         std::string out;
 718         std::string latin1_txt;
 719         char buf[5];
 720
 721         try {
 722                 latin1_txt = Glib::convert (txt, "ISO-8859-1", "UTF-8");
 723         } catch (Glib::ConvertError& err) {
 724                 throw Glib::ConvertError (err.code(), string_compose (_("Cannot convert %1 to Latin-1 text"), txt));
 725         }
 726
 727         out = '"';
 728
 729         for (std::string::const_iterator c = latin1_txt.begin(); c != latin1_txt.end(); ++c) {
 730
 731                 if ((*c) == '"') {
 732                         out += "\\\"";
 733                 } else if ((*c) == '\\') {
 734                         out += "\\134";
 735                 } else if (isprint (*c)) {
 736                         out += *c;
 737                 } else {
 738                         snprintf (buf, sizeof (buf), "\\%03o", (int) (unsigned char) *c);
 739                         out += buf;
 740                 }
 741         }
 742
 743         out += '"';
 744
 745         return out;
 746 }
 747
 748 std::string
 749 ExportHandler::toc_escape_filename (const std::string& txt)
 750 {
 751         std::string out;
 752
 753         out = '"';
 754
 755         // We iterate byte-wise not character-wise over a UTF-8 string here,
 756         // because we only want to translate backslashes and double quotes
 757         for (std::string::const_iterator c = txt.begin(); c != txt.end(); ++c) {
 758
 759                 if (*c == '"') {
 760                         out += "\\\"";
 761                 } else if (*c == '\\') {
 762                         out += "\\134";
 763                 } else {
 764                         out += *c;
 765                 }
 766         }
 767
 768         out += '"';
 769
 770         return out;
 771 }
 772
 773 std::string
 774 ExportHandler::cue_escape_cdtext (const std::string& txt)
 775 {
 776         std::string latin1_txt;
 777         std::string out;
 778
 779         try {
 780                 latin1_txt = Glib::convert (txt, "ISO-8859-1", "UTF-8");
 781         } catch (Glib::ConvertError& err) {
 782                 throw Glib::ConvertError (err.code(), string_compose (_("Cannot convert %1 to Latin-1 text"), txt));
 783         }
 784
 785         // does not do much mor than UTF-8 to Latin1 translation yet, but
 786         // that may have to change if cue parsers in burning programs change
 787         out = '"' + latin1_txt + '"';
 788
 789         return out;
 790 }
 791
 792 } // namespace ARDOUR