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