gtk2_ardour/export_dialog.cc

   1 /*
   2     Copyright (C) 1999-2005 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18
  19 */
  20
  21 #include <unistd.h>
  22 #include <utility>
  23 #include <sys/stat.h>
  24 #include <fstream>
  25
  26 #include <samplerate.h>
  27 #include <pbd/convert.h>
  28 #include <pbd/xml++.h>
  29
  30 #include <gtkmm2ext/utils.h>
  31 #include <gtkmm2ext/window_title.h>
  32
  33 #include <ardour/export.h>
  34 #include <ardour/session_directory.h>
  35 #include <ardour/sndfile_helpers.h>
  36 #include <ardour/audio_track.h>
  37 #include <ardour/audioregion.h>
  38 #include <ardour/audioengine.h>
  39 #include <ardour/gdither.h>
  40 #include <ardour/utils.h>
  41 #include <ardour/profile.h>
  42
  43 #include "export_dialog.h"
  44 #include "ardour_ui.h"
  45 #include "public_editor.h"
  46 #include "keyboard.h"
  47
  48 #include "i18n.h"
  49
  50 #define FRAME_NAME "BaseFrame"
  51
  52 using namespace std;
  53 using namespace ARDOUR;
  54 using namespace PBD;
  55 using namespace sigc;
  56 using namespace Gtk;
  57 using namespace Gtkmm2ext;
  58
  59 static const gchar *sample_rates[] = {
  60         N_("22.05kHz"),
  61         N_("44.1kHz"),
  62         N_("48kHz"),
  63         N_("88.2kHz"),
  64         N_("96kHz"),
  65         N_("192kHz"),
  66         0
  67 };
  68
  69 static const gchar *src_quality[] = {
  70         N_("best"),
  71         N_("fastest"),
  72         N_("linear"),
  73         N_("better"),
  74         N_("intermediate"),
  75         0
  76 };
  77
  78 static const gchar *dither_types[] = {
  79         N_("None"),
  80         N_("Rectangular"),
  81         N_("Shaped Noise"),
  82         N_("Triangular"),
  83         0
  84 };
  85
  86 static const gchar* channel_strings[] = {
  87         N_("stereo"),
  88         N_("mono"),
  89         0
  90 };
  91
  92 static const gchar* cue_file_types[] = {
  93         N_("None"),
  94         N_("CUE"),
  95         N_("TOC"),
  96         0
  97 };
  98
  99 ExportDialog::ExportDialog(PublicEditor& e)
 100         : ArdourDialog ("export dialog"),
 101           editor (e),
 102           format_table (9, 2),
 103           format_frame (_("Format")),
 104           cue_file_label (_("CD Marker File Type"), 1.0, 0.5),
 105           channel_count_label (_("Channels"), 1.0, 0.5),
 106           header_format_label (_("File Type"), 1.0, 0.5),
 107           bitdepth_format_label (_("Sample Format"), 1.0, 0.5),
 108           endian_format_label (_("Sample Endianness"), 1.0, 0.5),
 109           sample_rate_label (_("Sample Rate"), 1.0, 0.5),
 110           src_quality_label (_("Conversion Quality"), 1.0, 0.5),
 111           dither_type_label (_("Dither Type"), 1.0, 0.5),
 112           cuefile_only_checkbox (_("Export CD Marker File Only")),
 113           file_browse_button (_("Browse")),
 114           track_selector_button (_("Specific tracks ..."))
 115 {
 116         guint32 n;
 117         guint32 len;
 118         guint32 maxlen;
 119
 120         session = 0;
 121         track_and_master_selection_allowed = true;
 122         channel_count_selection_allowed = true;
 123         export_cd_markers_allowed = true;
 124
 125         WindowTitle title(Glib::get_application_name());
 126         title += _("Export");
 127
 128         set_title (title.get_string());
 129         set_wmclass (X_("ardour_export"), "Ardour");
 130         set_name ("ExportWindow");
 131         add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
 132
 133         spec.running = false;
 134
 135         file_entry.set_name ("ExportFileNameEntry");
 136
 137         master_list = ListStore::create (exp_cols);
 138         master_selector.set_model (master_list);
 139
 140         master_selector.set_name ("ExportTrackSelector");
 141         master_selector.set_size_request (-1, 100);
 142         master_selector.append_column(_("Output"), exp_cols.output);
 143         master_selector.append_column_editable(_("Left"), exp_cols.left);
 144         master_selector.append_column_editable(_("Right"), exp_cols.right);
 145         master_selector.get_column(0)->set_min_width(100);
 146
 147         master_selector.get_column(1)->set_min_width(40);
 148         master_selector.get_column(1)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 149         master_selector.get_column(2)->set_min_width(40);
 150         master_selector.get_column(2)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 151         master_selector.get_selection()->set_mode (Gtk::SELECTION_NONE);
 152
 153         track_list = ListStore::create (exp_cols);
 154         track_selector.set_model (track_list);
 155
 156         track_selector.set_name ("ExportTrackSelector");
 157         track_selector.set_size_request (-1, 130);
 158         track_selector.append_column(_("Output"), exp_cols.output);
 159         track_selector.append_column_editable(_("Left"), exp_cols.left);
 160         track_selector.append_column_editable(_("Right"), exp_cols.right);
 161
 162         track_selector.get_column(0)->set_min_width(100);
 163         track_selector.get_column(1)->set_min_width(40);
 164         track_selector.get_column(1)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 165         track_selector.get_column(2)->set_min_width(40);
 166         track_selector.get_column(2)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 167         track_selector.get_selection()->set_mode (Gtk::SELECTION_NONE);
 168
 169         progress_bar.set_name ("ExportProgress");
 170
 171         format_frame.add (format_table);
 172         format_frame.set_name (FRAME_NAME);
 173
 174         track_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 175         master_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 176
 177         get_vbox()->pack_start (file_frame, false, false);
 178
 179         hpacker.set_spacing (5);
 180         hpacker.set_border_width (5);
 181         hpacker.pack_start (format_frame, false, false);
 182
 183         master_scroll.add (master_selector);
 184         track_scroll.add (track_selector);
 185
 186         master_scroll.set_size_request (220, 100);
 187         track_scroll.set_size_request (220, 100);
 188
 189         /* we may hide some of these later */
 190         track_vpacker.pack_start (master_scroll);
 191         track_vpacker.pack_start (track_scroll);
 192         track_vpacker.pack_start (track_selector_button, Gtk::PACK_EXPAND_PADDING);
 193
 194         hpacker.pack_start (track_vpacker);
 195
 196         get_vbox()->pack_start (hpacker);
 197
 198         track_selector_button.set_name ("EditorGTKButton");
 199         track_selector_button.signal_clicked().connect (mem_fun(*this, &ExportDialog::track_selector_button_click));
 200
 201         get_vbox()->pack_start (progress_bar, false, false);
 202
 203         Gtkmm2ext::set_size_request_to_display_given_text (file_entry, X_("Kg/quite/a/reasonable/size/for/files/i/think"), 5, 8);
 204
 205         file_hbox.set_spacing (5);
 206         file_hbox.set_border_width (5);
 207         file_hbox.pack_start (file_entry, true, true);
 208         file_hbox.pack_start (file_browse_button, false, false);
 209
 210         file_frame.add (file_hbox);
 211         file_frame.set_border_width (5);
 212         file_frame.set_name (FRAME_NAME);
 213
 214         /* pop_strings needs to be created on the stack because set_popdown_strings()
 215            takes a reference.
 216         */
 217
 218         vector<string> pop_strings = I18N (sample_rates);
 219         Gtkmm2ext::set_popdown_strings (sample_rate_combo, pop_strings);
 220         sample_rate_combo.set_active_text (pop_strings.front());
 221         pop_strings = I18N (src_quality);
 222         Gtkmm2ext::set_popdown_strings (src_quality_combo, pop_strings);
 223         src_quality_combo.set_active_text (pop_strings.front());
 224         pop_strings = I18N (dither_types);
 225         Gtkmm2ext::set_popdown_strings (dither_type_combo, pop_strings);
 226         dither_type_combo.set_active_text (pop_strings.front());
 227         pop_strings = I18N (channel_strings);
 228         Gtkmm2ext::set_popdown_strings (channel_count_combo, pop_strings);
 229         channel_count_combo.set_active_text (pop_strings.front());
 230         pop_strings = I18N ((const char **) sndfile_header_formats_strings);
 231         Gtkmm2ext::set_popdown_strings (header_format_combo, pop_strings);
 232         header_format_combo.set_active_text (pop_strings.front());
 233         pop_strings = I18N ((const char **) sndfile_bitdepth_formats_strings);
 234         Gtkmm2ext::set_popdown_strings (bitdepth_format_combo, pop_strings);
 235         bitdepth_format_combo.set_active_text (pop_strings.front());
 236         pop_strings = I18N ((const char **) sndfile_endian_formats_strings);
 237         Gtkmm2ext::set_popdown_strings (endian_format_combo, pop_strings);
 238         endian_format_combo.set_active_text (pop_strings.front());
 239         pop_strings = I18N (cue_file_types);
 240         Gtkmm2ext::set_popdown_strings (cue_file_combo, pop_strings);
 241         cue_file_combo.set_active_text (pop_strings.front());
 242
 243         /* this will re-sensitized as soon as a non RIFF/WAV
 244            header format is chosen.
 245         */
 246
 247         endian_format_combo.set_sensitive (false);
 248
 249         /* determine longest strings at runtime */
 250
 251         maxlen = 0;
 252         const char *longest = X_("gl"); /* translators: one ascender, one descender */
 253         string longest_str;
 254
 255         for (n = 0; n < SNDFILE_HEADER_FORMATS; ++n) {
 256                 if ((len = strlen (sndfile_header_formats_strings[n])) > maxlen) {
 257                         maxlen = len;
 258                         longest = sndfile_header_formats_strings[n];
 259                 }
 260         }
 261
 262         for (n = 0; n < SNDFILE_BITDEPTH_FORMATS; ++n) {
 263                 if ((len = strlen (sndfile_bitdepth_formats_strings[n])) > maxlen) {
 264                         maxlen = len;
 265                         longest = sndfile_bitdepth_formats_strings[n];
 266                 }
 267         }
 268
 269         for (n = 0; n < SNDFILE_ENDIAN_FORMATS; ++n) {
 270                 if ((len = strlen (sndfile_endian_formats_strings[n])) > maxlen) {
 271                         maxlen = len;
 272                         longest = sndfile_endian_formats_strings[n];
 273                 }
 274         }
 275
 276         longest_str = longest;
 277
 278         /* force ascender + descender */
 279
 280         longest_str[0] = 'g';
 281         longest_str[1] = 'l';
 282
 283         //Gtkmm2ext::set_size_request_to_display_given_text (header_format_combo, longest_str.c_str(), 5+FUDGE, 5);
 284
 285         // TRANSLATORS: "slereg" is "stereo" with ascender and descender substituted
 286         //Gtkmm2ext::set_size_request_to_display_given_text (channel_count_combo, _("slereg"), 5+FUDGE, 5);
 287
 288 /*      header_format_combo.set_focus_on_click (true);
 289         bitdepth_format_combo.set_focus_on_click (true);
 290         endian_format_combo.set_focus_on_click (true);
 291         channel_count_combo.set_focus_on_click (true);
 292         src_quality_combo.set_focus_on_click (true);
 293         dither_type_combo.set_focus_on_click (true);
 294         sample_rate_combo.set_focus_on_click (true);
 295         cue_file_combo.set_focus_on_click (true);
 296 */
 297         dither_type_label.set_name ("ExportFormatLabel");
 298         sample_rate_label.set_name ("ExportFormatLabel");
 299         src_quality_label.set_name ("ExportFormatLabel");
 300         channel_count_label.set_name ("ExportFormatLabel");
 301         header_format_label.set_name ("ExportFormatLabel");
 302         bitdepth_format_label.set_name ("ExportFormatLabel");
 303         endian_format_label.set_name ("ExportFormatLabel");
 304         cue_file_label.set_name ("ExportFormatLabel");
 305
 306         header_format_combo.set_name ("ExportFormatDisplay");
 307         bitdepth_format_combo.set_name ("ExportFormatDisplay");
 308         endian_format_combo.set_name ("ExportFormatDisplay");
 309         channel_count_combo.set_name ("ExportFormatDisplay");
 310         dither_type_combo.set_name ("ExportFormatDisplay");
 311         src_quality_combo.set_name ("ExportFormatDisplay");
 312         sample_rate_combo.set_name ("ExportFormatDisplay");
 313         cue_file_combo.set_name ("ExportFormatDisplay");
 314
 315         cuefile_only_checkbox.set_name ("ExportCheckbox");
 316
 317         format_table.set_homogeneous (false);
 318         format_table.set_border_width (5);
 319         format_table.set_col_spacings (5);
 320         format_table.set_row_spacings (5);
 321
 322         int row = 0;
 323
 324         format_table.attach (channel_count_label, 0, 1, row, row+1);
 325         format_table.attach (channel_count_combo, 1, 2, row, row+1);
 326
 327         row++;
 328
 329         format_table.attach (header_format_label, 0, 1, row, row+1);
 330         format_table.attach (header_format_combo, 1, 2, row, row+1);
 331
 332         row++;
 333
 334         format_table.attach (bitdepth_format_label, 0, 1, row, row+1);
 335         format_table.attach (bitdepth_format_combo, 1, 2, row, row+1);
 336
 337         row++;
 338
 339         if (!Profile->get_sae()) {
 340                 format_table.attach (endian_format_label, 0, 1, row, row+1);
 341                 format_table.attach (endian_format_combo, 1, 2, row, row+1);
 342                 row++;
 343         }
 344
 345         format_table.attach (sample_rate_label, 0, 1, row, row+1);
 346         format_table.attach (sample_rate_combo, 1, 2, row, row+1);
 347
 348         row++;
 349
 350         if (!Profile->get_sae()) {
 351                 format_table.attach (src_quality_label, 0, 1, row, row+1);
 352                 format_table.attach (src_quality_combo, 1, 2, row, row+1);
 353                 row++;
 354         }
 355
 356         format_table.attach (dither_type_label, 0, 1, row, row+1);
 357         format_table.attach (dither_type_combo, 1, 2, row, row+1);
 358
 359         row++;
 360
 361         if (!Profile->get_sae()) {
 362                 format_table.attach (cue_file_label, 0, 1, row, row+1);
 363                 format_table.attach (cue_file_combo, 1, 2, row, row+1);
 364                 row++;
 365
 366                 format_table.attach (cuefile_only_checkbox, 0, 2, row, row+1);
 367         }
 368
 369         file_entry.set_name ("ExportFileDisplay");
 370
 371         signal_delete_event().connect (mem_fun(*this, &ExportDialog::window_closed));
 372
 373         cancel_button = add_button (Stock::CANCEL, RESPONSE_CANCEL);
 374         cancel_button->signal_clicked().connect (mem_fun(*this, &ExportDialog::end_dialog));
 375         ok_button = add_button (_("Export"), RESPONSE_ACCEPT);
 376         ok_button->signal_clicked().connect (mem_fun(*this, &ExportDialog::do_export));
 377
 378         file_browse_button.set_name ("EditorGTKButton");
 379         file_browse_button.signal_clicked().connect (mem_fun(*this, &ExportDialog::browse));
 380
 381         channel_count_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::channels_chosen));
 382         bitdepth_format_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::bitdepth_chosen));
 383         header_format_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::header_chosen));
 384         sample_rate_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::sample_rate_chosen));
 385         cue_file_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::cue_file_type_chosen));
 386 }
 387
 388 ExportDialog::~ExportDialog()
 389 {
 390 }
 391
 392 void
 393 ExportDialog::do_not_allow_track_and_master_selection()
 394 {
 395         track_and_master_selection_allowed = false;
 396         track_vpacker.set_no_show_all();
 397 }
 398
 399 void
 400 ExportDialog::do_not_allow_channel_count_selection()
 401 {
 402         channel_count_selection_allowed = false;
 403         channel_count_combo.set_no_show_all();
 404         channel_count_label.set_no_show_all();
 405 }
 406
 407 void
 408 ExportDialog::do_not_allow_export_cd_markers()
 409 {
 410         export_cd_markers_allowed = false;
 411         cue_file_label.set_no_show_all();
 412         cue_file_combo.set_no_show_all();
 413         cuefile_only_checkbox.set_no_show_all();
 414 }
 415
 416 void
 417 ExportDialog::connect_to_session (Session *s)
 418 {
 419         session = s;
 420         session->GoingAway.connect (mem_fun(*this, &Window::hide_all));
 421
 422         switch (session->frame_rate()) {
 423         case 22050:
 424                 sample_rate_combo.set_active_text (_("22.05kHz"));
 425                 break;
 426         case 44100:
 427                 sample_rate_combo.set_active_text (_("44.1kHz"));
 428                 break;
 429         case 48000:
 430                 sample_rate_combo.set_active_text (_("48kHz"));
 431                 break;
 432         case 88200:
 433                 sample_rate_combo.set_active_text (_("88.2kHz"));
 434                 break;
 435         case 96000:
 436                 sample_rate_combo.set_active_text (_("96kHz"));
 437                 break;
 438         case 192000:
 439                 sample_rate_combo.set_active_text (_("192kHz"));
 440                 break;
 441         default:
 442                 sample_rate_combo.set_active_text (_("44.1kHz"));
 443                 break;
 444         }
 445
 446         src_quality_combo.set_sensitive (false);
 447
 448         set_state();
 449 }
 450
 451 void
 452 ExportDialog::set_state()
 453 {
 454         XMLNode* node = session->instant_xml(X_("ExportDialog"));
 455         XMLProperty* prop;
 456
 457         if (node) {
 458
 459                 if ((prop = node->property (X_("sample_rate"))) != 0) {
 460                         sample_rate_combo.set_active_text(prop->value());
 461                 }
 462                 if ((prop = node->property (X_("src_quality"))) != 0) {
 463                         src_quality_combo.set_active_text(prop->value());
 464                 }
 465                 if ((prop = node->property (X_("dither_type"))) != 0) {
 466                         dither_type_combo.set_active_text(prop->value());
 467                 }
 468                 if ((prop = node->property (X_("channel_count"))) != 0) {
 469                         channel_count_combo.set_active_text(prop->value());
 470                 }
 471                 if ((prop = node->property (X_("header_format"))) != 0) {
 472                         header_format_combo.set_active_text(prop->value());
 473                 }
 474                 if ((prop = node->property (X_("bitdepth_format"))) != 0) {
 475                         bitdepth_format_combo.set_active_text(prop->value());
 476                 }
 477                 if ((prop = node->property (X_("endian_format"))) != 0) {
 478                         endian_format_combo.set_active_text(prop->value());
 479                 }
 480                 if ((prop = node->property (X_("filename"))) != 0) {
 481                         file_entry.set_text(prop->value());
 482                 }
 483                 if ((prop = node->property (X_("cue_file_type"))) != 0) {
 484                         cue_file_combo.set_active_text(prop->value());
 485                 }
 486         }
 487
 488         header_chosen ();
 489         bitdepth_chosen();
 490         channels_chosen();
 491         sample_rate_chosen();
 492
 493         if (session->master_out()) {
 494                 track_scroll.hide ();
 495         } else {
 496                 master_scroll.hide ();
 497                 track_selector_button.hide ();
 498         }
 499
 500         if (!node) {
 501                 return;
 502         }
 503
 504         if (session->master_out()) {
 505                 XMLNode* master = find_named_node(*node, (X_("Master")));
 506                 int nchns;
 507
 508                 if (!master) {
 509
 510                         /* default is to use all */
 511                         if (channel_count_combo.get_active_text() == _("mono")) {
 512                                 nchns = 1;
 513                         } else {
 514                                 nchns = 2;
 515                         }
 516
 517                         TreeModel::Children rows = master_selector.get_model()->children();
 518                         for (uint32_t r = 0; r < session->master_out()->n_outputs().n_total(); ++r) {
 519                                 if (nchns == 2) {
 520                                         if (r % 2) {
 521                                                 rows[r][exp_cols.right] = true;
 522                                         } else {
 523                                                 rows[r][exp_cols.left] = true;
 524                                         }
 525                                 } else {
 526                                         rows[r][exp_cols.left] = true;
 527                                 }
 528                         }
 529
 530                 } else {
 531                         /* XXX use XML state */
 532                 }
 533         }
 534
 535         XMLNode* tracks = find_named_node(*node, (X_("Tracks")));
 536         if (!tracks) {
 537                 return;
 538         }
 539
 540         XMLNodeList track_list = tracks->children(X_("Track"));
 541         TreeModel::Children rows = track_selector.get_model()->children();
 542         TreeModel::Children::iterator ri = rows.begin();
 543         TreeModel::Row row;
 544
 545         for (XMLNodeIterator it = track_list.begin(); it != track_list.end(); ++it, ++ri) {
 546                 if (ri == rows.end()){
 547                         break;
 548                 }
 549
 550                 XMLNode* track = *it;
 551                 row = *ri;
 552
 553                 if ((prop = track->property(X_("channel1"))) != 0) {
 554                         if (prop->value() == X_("on")) {
 555                                 row[exp_cols.left] = true;
 556                         } else {
 557                                 row[exp_cols.left] = false;
 558                         }
 559                 }
 560
 561                 if ((prop = track->property(X_("channel2"))) != 0) {
 562                         if (prop->value() == X_("on")) {
 563                                 row[exp_cols.right] = true;
 564                         } else {
 565                                 row[exp_cols.right] = false;
 566                         }
 567                 }
 568         }
 569 }
 570
 571 void
 572 ExportDialog::save_state()
 573 {
 574         if (!session) {
 575                 return;
 576         }
 577
 578         XMLNode* node = new XMLNode(X_("ExportDialog"));
 579
 580         node->add_property(X_("sample_rate"), sample_rate_combo.get_active_text());
 581         node->add_property(X_("src_quality"), src_quality_combo.get_active_text());
 582         node->add_property(X_("dither_type"), dither_type_combo.get_active_text());
 583         node->add_property(X_("channel_count"), channel_count_combo.get_active_text());
 584         node->add_property(X_("header_format"), header_format_combo.get_active_text());
 585         node->add_property(X_("bitdepth_format"), bitdepth_format_combo.get_active_text());
 586         node->add_property(X_("endian_format"), endian_format_combo.get_active_text());
 587         node->add_property(X_("filename"), file_entry.get_text());
 588         node->add_property(X_("cue_file_type"), cue_file_combo.get_active_text());
 589
 590         XMLNode* tracks = new XMLNode(X_("Tracks"));
 591
 592         TreeModel::Children rows = track_selector.get_model()->children();
 593         TreeModel::Row row;
 594         for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) {
 595                 XMLNode* track = new XMLNode(X_("Track"));
 596
 597                 row = *ri;
 598                 track->add_property(X_("channel1"), row[exp_cols.left] ? X_("on") : X_("off"));
 599                 track->add_property(X_("channel2"), row[exp_cols.right] ? X_("on") : X_("off"));
 600
 601                 tracks->add_child_nocopy(*track);
 602         }
 603         node->add_child_nocopy(*tracks);
 604
 605         session->add_instant_xml(*node);
 606 }
 607
 608 void
 609 ExportDialog::set_range (nframes_t start, nframes_t end)
 610 {
 611         spec.start_frame = start;
 612         spec.end_frame = end;
 613 }
 614
 615 gint
 616 ExportDialog::progress_timeout ()
 617 {
 618         progress_bar.set_fraction (spec.progress);
 619         return TRUE;
 620 }
 621
 622 void
 623 frames_to_cd_frames_string (char* buf, nframes_t when, nframes_t fr)
 624 {
 625
 626   long unsigned int remainder;
 627   int mins, secs, frames;
 628
 629         mins = when / (60 * fr);
 630         remainder = when - (mins * 60 * fr);
 631         secs = remainder / fr;
 632         remainder -= secs * fr;
 633         frames = remainder / (fr / 75);
 634         sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
 635
 636 }
 637
 638 struct LocationSortByStart {
 639     bool operator() (Location *a, Location *b) {
 640             return a->start() < b->start();
 641     }
 642 };
 643
 644 void
 645 ExportDialog::export_toc_file (Locations::LocationList& locations, const string& path)
 646 {
 647         if(!export_cd_markers_allowed){
 648                 return;
 649         }
 650
 651         string filepath = path + ".toc";
 652         ofstream out (filepath.c_str());
 653         long unsigned int last_end_time = spec.start_frame, last_start_time = spec.start_frame;
 654         gchar buf[18];
 655
 656         if (!out) {
 657                 error << string_compose(_("Editor: cannot open \"%1\" as export file for CD toc file"), filepath) << endmsg;
 658                 return;
 659         }
 660         out << "CD_DA" << endl;
 661         out << "CD_TEXT {" << endl << "  LANGUAGE_MAP {" << endl << "    0 : EN" << endl << "  }" << endl;
 662         out << "  LANGUAGE 0 {" << endl << "    TITLE \"" << session->name() << "\"" << endl << "  }" << endl << "}" << endl;
 663
 664         Locations::LocationList::iterator i;
 665         Locations::LocationList temp;
 666
 667         for (i = locations.begin(); i != locations.end(); ++i) {
 668                 if ((*i)->start() >= spec.start_frame && (*i)->end() <= spec.end_frame && (*i)->is_cd_marker() && !(*i)->is_end()) {
 669                         temp.push_back (*i);
 670                 }
 671         }
 672
 673         if (temp.size() > 0) {
 674                 LocationSortByStart cmp;
 675                 temp.sort (cmp);
 676                 Location * curr_range = 0;
 677                 Locations::LocationList::iterator nexti;
 678
 679                 for (i = temp.begin(); i != temp.end(); ++i) {
 680
 681                         if ((*i)->start() >= last_end_time)
 682                         {
 683                                 /* this is a track, defined by a cd range marker or a cd location marker outside of a cd range */
 684                                 out << endl << "TRACK AUDIO" << endl;
 685
 686                                 if ((*i)->cd_info.find("scms") != (*i)->cd_info.end())  {
 687                                         out << "NO ";
 688                                 }
 689                                 out << "COPY" << endl;
 690
 691                                 if ((*i)->cd_info.find("preemph") != (*i)->cd_info.end())  {
 692                                         out << "PRE_EMPHASIS" << endl;
 693                                 } else {
 694                                         out << "NO PRE_EMPHASIS" << endl;
 695                                 }
 696
 697                                 if ((*i)->cd_info.find("isrc") != (*i)->cd_info.end())  {
 698                                         out << "ISRC \"" << (*i)->cd_info["isrc"] << "\"" << endl;
 699                                 }
 700
 701                                 out << "CD_TEXT {" << endl << "  LANGUAGE 0 {" << endl << "     TITLE \"" << (*i)->name() << "\"" << endl;
 702                                 if ((*i)->cd_info.find("performer") != (*i)->cd_info.end()) {
 703                                         out << "     PERFORMER \"" << (*i)->cd_info["performer"]  << "\"" << endl;
 704                                 }
 705                                 if ((*i)->cd_info.find("string_composer") != (*i)->cd_info.end()) {
 706                                         out  << "     COMPOSER \"" << (*i)->cd_info["string_composer"] << "\"" << endl;
 707                                 }
 708
 709                                 if ((*i)->cd_info.find("isrc") != (*i)->cd_info.end()) {
 710                                         out  << "     ISRC \"";
 711                                         out << (*i)->cd_info["isrc"].substr(0,2) << "-";
 712                                         out << (*i)->cd_info["isrc"].substr(2,3) << "-";
 713                                         out << (*i)->cd_info["isrc"].substr(5,2) << "-";
 714                                         out << (*i)->cd_info["isrc"].substr(7,5) << "\"" << endl;
 715                                 }
 716
 717                                 out << "  }" << endl << "}" << endl;
 718
 719                                 frames_to_cd_frames_string (buf, last_end_time - spec.start_frame, session->frame_rate());
 720                                 out << "FILE \"" << path << "\" " << buf;
 721
 722                                 if ((*i)->is_mark()) {
 723                                         // a mark track location needs to look ahead to the next marker's start to determine length
 724                                         nexti = i;
 725                                         ++nexti;
 726                                         if (nexti != temp.end()) {
 727                                                 frames_to_cd_frames_string (buf, (*nexti)->start() - last_end_time, session->frame_rate());
 728                                                 out << buf << endl;
 729
 730                                                 frames_to_cd_frames_string (buf, (*i)->start() - last_end_time, session->frame_rate());
 731                                                 out << "START" << buf << endl;
 732
 733                                                 last_start_time = (*i)->start();
 734                                                 last_end_time = (*nexti)->start();
 735                                         }
 736                                         else {
 737                                                 // this was the last marker, use session end
 738                                                 frames_to_cd_frames_string (buf, spec.end_frame - last_end_time, session->frame_rate());
 739                                                 out << buf << endl;
 740
 741                                                 frames_to_cd_frames_string (buf, (*i)->start() - last_end_time, session->frame_rate());
 742                                                 out << "START" << buf << endl;
 743
 744                                                 last_start_time = (*i)->start();
 745                                                 last_end_time = spec.end_frame;
 746                                         }
 747
 748                                         curr_range = 0;
 749                                 }
 750                                 else {
 751                                         // range
 752                                         frames_to_cd_frames_string (buf, (*i)->end() - last_end_time, session->frame_rate());
 753                                         out << buf << endl;
 754
 755                                         frames_to_cd_frames_string (buf, (*i)->start() - last_end_time, session->frame_rate());
 756                                         out << "START" << buf << endl;
 757
 758                                         last_start_time = (*i)->start();
 759                                         last_end_time = (*i)->end();
 760
 761                                         curr_range = (*i);
 762                                 }
 763
 764                         }
 765                         else if ((*i)->is_mark())
 766                         {
 767                                 /* this is an index within a track */
 768
 769                                 frames_to_cd_frames_string (buf, (*i)->start() - last_start_time, session->frame_rate());
 770                                 out << "INDEX" << buf << endl;
 771                         }
 772                 }
 773         }
 774
 775 }
 776
 777 void
 778 ExportDialog::export_cue_file (Locations::LocationList& locations, const string& path)
 779 {
 780         if(!export_cd_markers_allowed){
 781                 return;
 782         }
 783
 784     string filepath = path + ".cue";
 785         ofstream out (filepath.c_str());
 786         gchar buf[18];
 787         long unsigned int last_track_end = spec.start_frame;
 788         int numtracks = 0, tracknum = 0, indexnum = 0;
 789
 790         if (!out) {
 791                 error << string_compose(_("Editor: cannot open \"%1\" as export file for CD cue file"), filepath) << endmsg;
 792                 return;
 793         }
 794
 795         Locations::LocationList::iterator i;
 796         Locations::LocationList temp;
 797
 798         for (i = locations.begin(); i != locations.end(); ++i) {
 799                 if ((*i)->start() >= spec.start_frame && (*i)->end() <= spec.end_frame && (*i)->is_cd_marker() && !(*i)->is_end()) {
 800                         temp.push_back (*i);
 801                         if (!(*i)->is_mark()) {
 802                                 numtracks++;
 803                         }
 804                 }
 805         }
 806
 807         out << "REM Cue file generated by Ardour" << endl;
 808         out << "TITLE \"" << session->name() << "\"" << endl;
 809
 810         if ((header_format_combo.get_active_text() == N_("WAV"))) {
 811                   out << "FILE " << path  << " WAVE" << endl;
 812         } else {
 813                   out << "FILE " << path  << ' ' << (header_format_combo.get_active_text()) << endl;
 814         }
 815
 816         if (false && numtracks == 0) {
 817                     /* the user has supplied no track markers.
 818                        the entire export is treated as one track.
 819                     */
 820
 821                   numtracks++;
 822                   tracknum++;
 823                   indexnum = 0;
 824                   out << endl << "TRACK " << tracknum << " AUDIO" << endl;
 825                   out << "FLAGS " ;
 826
 827                   out << "DCP " << endl;
 828
 829                   /* use the session name*/
 830
 831                   if (session->name() != "") {
 832                     out << "TITLE \"" << session->name() << "\"" << endl;
 833                   }
 834
 835                   /* no pregap in this case */
 836
 837                   out << "INDEX 00 00:00:00" << endl;
 838                   indexnum++;
 839                   out << "INDEX 01 00:00:00" << endl;
 840                   indexnum++;
 841                   last_track_end = spec.end_frame;
 842         }
 843
 844         if (temp.size()) {
 845                 LocationSortByStart cmp;
 846                 temp.sort (cmp);
 847                 Location * curr_range = 0;
 848                 Locations::LocationList::iterator nexti;
 849
 850                 for ( i = temp.begin(); i != temp.end(); ++i) {
 851
 852                         if ((*i)->start() >= last_track_end)
 853                         {
 854                                 /* this is a track and it doesn't start inside another one*/
 855
 856                                 tracknum++;
 857                                 indexnum = 0;
 858                                 out << endl << "TRACK " << tracknum << " AUDIO" << endl;
 859                                 out << "FLAGS " ;
 860
 861                                 if ((*i)->cd_info.find("scms") != (*i)->cd_info.end())  {
 862                                         out << "SCMS ";
 863                                 } else {
 864                                         out << "DCP ";
 865                                 }
 866
 867                                 if ((*i)->cd_info.find("preemph") != (*i)->cd_info.end())  {
 868                                         out << "PRE";
 869                                 }
 870                                 out << endl;
 871
 872                                 if ((*i)->cd_info.find("isrc") != (*i)->cd_info.end())  {
 873                                         out << "ISRC " << (*i)->cd_info["isrc"] << endl;
 874
 875                                 }
 876                                 if ((*i)->name() != "") {
 877                                         out << "TITLE \"" << (*i)->name() << "\"" << endl;
 878                                 }
 879
 880                                 if ((*i)->cd_info.find("performer") != (*i)->cd_info.end()) {
 881                                         out << "PERFORMER \"" <<  (*i)->cd_info["performer"] << "\"" << endl;
 882                                 }
 883
 884                                 if ((*i)->cd_info.find("string_composer") != (*i)->cd_info.end()) {
 885                                         out << "SONGWRITER \"" << (*i)->cd_info["string_composer"]  << "\"" << endl;
 886                                 }
 887                                 snprintf (buf, sizeof(buf), "INDEX %02d", indexnum);
 888                                 out << buf;
 889                                 frames_to_cd_frames_string (buf, last_track_end - spec.start_frame, session->frame_rate());
 890                                 out << buf << endl;
 891                                 indexnum++;
 892
 893                                 if ((*i)->is_mark()) {
 894                                         // need to find the next start to define the end
 895                                         nexti = i;
 896                                         ++nexti;
 897                                         if (nexti != temp.end()) {
 898                                                 last_track_end = (*nexti)->start();
 899                                         }
 900                                         else {
 901                                                 last_track_end = spec.end_frame;
 902                                         }
 903                                         curr_range = 0;
 904                                 }
 905                                 else {
 906                                         last_track_end = (*i)->end();
 907                                         curr_range = (*i);
 908                                 }
 909                         }
 910
 911                         if ((tracknum > 0) && ((*i)->start() < last_track_end)) {
 912                                 /*this is an index and it lies within a track*/
 913                                 snprintf (buf, sizeof(buf), "INDEX %02d", indexnum);
 914                                 out << buf;
 915                                 frames_to_cd_frames_string (buf,(*i)->start() - spec.start_frame, session->frame_rate());
 916                                 out << buf << endl;
 917                                 indexnum++;
 918                         }
 919                 }
 920         }
 921
 922 }
 923
 924 void
 925 ExportDialog::do_export_cd_markers (const string& path,const string& cuefile_type)
 926 {
 927         if (cuefile_type == _("TOC")) {
 928                 session->locations()->apply (*this, &ExportDialog::export_toc_file, path);
 929         } else {
 930                 session->locations()->apply (*this, &ExportDialog::export_cue_file, path);
 931         }
 932 }
 933
 934
 935 void
 936 ExportDialog::do_export ()
 937 {
 938         string filepath = file_entry.get_text();
 939
 940         if (!ARDOUR_UI::instance()->the_engine().connected()) {
 941                 MessageDialog msg (*this,
 942                                    _("Not connected to audioengine"),
 943                                    true,
 944                                    MESSAGE_ERROR,
 945                                    BUTTONS_OK);
 946                 msg.set_secondary_text (_("Ardour cannot export audio when disconnected"));
 947                 msg.present ();
 948                 msg.run ();
 949                 return;
 950         }
 951
 952         if(!is_filepath_valid(filepath)){
 953                 return;
 954         }
 955
 956         if (!Profile->get_sae() && export_cd_markers_allowed) {
 957                 if (cue_file_combo.get_active_text () != _("None")) {
 958                         do_export_cd_markers (file_entry.get_text(), cue_file_combo.get_active_text ());
 959                 }
 960
 961                 if (cuefile_only_checkbox.get_active()) {
 962                         end_dialog ();
 963                         return;
 964                 }
 965         }
 966
 967         ok_button->set_sensitive(false);
 968         save_state();
 969
 970         set_modal (true);
 971
 972         // read user input into spec
 973         initSpec(filepath);
 974
 975         progress_connection = Glib::signal_timeout().connect (mem_fun(*this, &ExportDialog::progress_timeout), 100);
 976         cancel_label.set_text (_("Stop Export"));
 977
 978         session->pre_export ();
 979         export_data();
 980
 981         progress_connection.disconnect ();
 982         end_dialog ();
 983 }
 984
 985 void
 986 ExportDialog::end_dialog ()
 987 {
 988         if (spec.running) {
 989                 spec.stop = true;
 990
 991                 while (spec.running) {
 992                         if (gtk_events_pending()) {
 993                                 gtk_main_iteration ();
 994                         } else {
 995                                 usleep (10000);
 996                         }
 997                 }
 998         }
 999
1000         session->finalize_export ();
1001
1002         hide_all ();
1003
1004         set_modal (false);
1005         ok_button->set_sensitive(true);
1006 }
1007
1008 void
1009 ExportDialog::start_export ()
1010 {
1011         if (session == 0) {
1012                 return;
1013         }
1014
1015         /* If the filename hasn't been set before, use the
1016            current session's export directory as a default
1017            location for the export.
1018         */
1019
1020         if (file_entry.get_text().length() == 0) {
1021
1022                 sys::path export_file_path = session->session_directory().export_path();
1023
1024                 if (!wants_dir()) {
1025                         export_file_path /= "export.wav";
1026                 }
1027
1028                 file_entry.set_text (export_file_path.to_string());
1029         }
1030
1031         progress_bar.set_fraction (0);
1032         cancel_label.set_text (_("Cancel"));
1033
1034         show_all ();
1035
1036         if (session->master_out()) {
1037                 track_scroll.hide ();
1038         } else {
1039                 master_scroll.hide ();
1040                 track_selector_button.hide ();
1041         }
1042 }
1043
1044 void
1045 ExportDialog::header_chosen ()
1046 {
1047         if (sndfile_header_format_from_string (header_format_combo.get_active_text ()) == SF_FORMAT_WAV) {
1048                 endian_format_combo.set_sensitive (false);
1049         } else {
1050                 endian_format_combo.set_sensitive (true);
1051         }
1052 }
1053
1054 void
1055 ExportDialog::bitdepth_chosen ()
1056 {
1057         int format = sndfile_bitdepth_format_from_string (bitdepth_format_combo.get_active_text ());
1058         switch (format) {
1059         case SF_FORMAT_PCM_24:
1060         case SF_FORMAT_PCM_32:
1061         case SF_FORMAT_FLOAT:
1062                 dither_type_combo.set_sensitive (false);
1063                 break;
1064
1065         default:
1066                 dither_type_combo.set_sensitive (true);
1067                 break;
1068         }
1069 }
1070
1071 void
1072 ExportDialog::cue_file_type_chosen ()
1073 {
1074         if (cue_file_combo.get_active_text () != "None") {
1075                 cuefile_only_checkbox.set_sensitive (true);
1076         } else {
1077                 cuefile_only_checkbox.set_active (false);
1078                 cuefile_only_checkbox.set_sensitive (false);
1079         }
1080 }
1081
1082 void
1083 ExportDialog::sample_rate_chosen ()
1084 {
1085         string sr_str = sample_rate_combo.get_active_text();
1086         nframes_t rate;
1087
1088         if (sr_str == N_("22.05kHz")) {
1089                 rate = 22050;
1090         } else if (sr_str == _("44.1kHz")) {
1091                 rate = 44100;
1092         } else if (sr_str == _("48kHz")) {
1093                 rate = 48000;
1094         } else if (sr_str == _("88.2kHz")) {
1095                 rate = 88200;
1096         } else if (sr_str == _("96kHz")) {
1097                 rate = 96000;
1098         } else if (sr_str == _("192kHz")) {
1099                 rate = 192000;
1100         } else {
1101                 rate = session->frame_rate();
1102         }
1103
1104         if (rate != session->frame_rate()) {
1105                 src_quality_combo.set_sensitive (true);
1106         } else {
1107                 src_quality_combo.set_sensitive (false);
1108         }
1109 }
1110
1111 void
1112 ExportDialog::channels_chosen ()
1113 {
1114         bool mono;
1115
1116         mono = (channel_count_combo.get_active_text() == _("mono"));
1117
1118         if (mono) {
1119                 track_selector.get_column(2)->set_visible(false);
1120                 track_selector.get_column(1)->set_title(_("Export"));
1121
1122                 if (session->master_out()) {
1123                         master_selector.get_column(2)->set_visible(false);
1124                         master_selector.get_column(1)->set_title(_("Export"));
1125                 }
1126
1127         } else {
1128                 track_selector.get_column(2)->set_visible(true);
1129                 track_selector.get_column(1)->set_title(_("Left"));
1130
1131                 if (session->master_out()) {
1132                         master_selector.get_column(2)->set_visible(true);
1133                         master_selector.get_column(1)->set_title(_("Left"));
1134                 }
1135         }
1136
1137         fill_lists();
1138 }
1139
1140 void
1141 ExportDialog::fill_lists ()
1142 {
1143         track_list->clear();
1144         master_list->clear();
1145
1146         boost::shared_ptr<Session::RouteList> routes = session->get_routes ();
1147
1148         for (Session::RouteList::iterator ri = routes->begin(); ri != routes->end(); ++ri) {
1149
1150                 boost::shared_ptr<Route> route = (*ri);
1151
1152                 if (route->is_hidden()) {
1153                         continue;
1154                 }
1155
1156                 for (uint32_t i=0; i < route->n_outputs().n_total(); ++i) {
1157                         string name;
1158                         if (route->n_outputs().n_total() == 1) {
1159                                 name = route->name();
1160                         } else {
1161                                 name = string_compose("%1: out-%2", route->name(), i+1);
1162                         }
1163
1164                         if (route == session->master_out()) {
1165                                 TreeModel::iterator iter = master_list->append();
1166                                 TreeModel::Row row = *iter;
1167                                 row[exp_cols.output] = name;
1168                                 row[exp_cols.left] = false;
1169                                 row[exp_cols.right] = false;
1170                                 row[exp_cols.port] = route->output (i);
1171                         } else {
1172                                 TreeModel::iterator iter = track_list->append();
1173                                 TreeModel::Row row = *iter;
1174                                 row[exp_cols.output] = name;
1175                                 row[exp_cols.left] = false;
1176                                 row[exp_cols.right] = false;
1177                                 row[exp_cols.port] = route->output (i);
1178                         }
1179                 }
1180         }
1181 }
1182
1183
1184 bool
1185 ExportDialog::is_filepath_valid(string &filepath)
1186 {
1187         // sanity check file name first
1188
1189         struct stat statbuf;
1190
1191         if (filepath.empty()) {
1192                 string txt = _("Please enter a valid filename.");
1193                 MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
1194                 msg.run();
1195                 return false;
1196         }
1197
1198         // check if file exists already and warn
1199
1200         if (stat (filepath.c_str(), &statbuf) == 0) {
1201                 if (S_ISDIR (statbuf.st_mode)) {
1202                         string txt = _("Please specify a complete filename for the audio file.");
1203                         MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
1204                         msg.run();
1205                         return false;
1206                 }
1207                 else {
1208                         string txt = _("File already exists, do you want to overwrite it?");
1209                         MessageDialog msg (*this, txt, false, MESSAGE_QUESTION, BUTTONS_YES_NO, true);
1210                         if ((ResponseType) msg.run() == Gtk::RESPONSE_NO) {
1211                                 return false;
1212                         }
1213                 }
1214         }
1215
1216         // directory needs to exist and be writable
1217
1218         string dirpath = Glib::path_get_dirname (filepath);
1219         if (::access (dirpath.c_str(), W_OK) != 0) {
1220                 string txt = _("Cannot write file in: ") + dirpath;
1221                 MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
1222                 msg.run();
1223                 return false;
1224         }
1225
1226         return true;
1227 }
1228
1229 void
1230 ExportDialog::initSpec(string &filepath)
1231 {
1232         spec.path = filepath;
1233         spec.progress = 0;
1234         spec.running = false;
1235         spec.stop = false;
1236         spec.port_map.clear();
1237
1238         if (channel_count_combo.get_active_text() == _("mono")) {
1239                 spec.channels = 1;
1240         } else {
1241                 spec.channels = 2;
1242         }
1243
1244         spec.format = 0;
1245
1246         spec.format |= sndfile_header_format_from_string (header_format_combo.get_active_text ());
1247
1248         if (!Profile->get_sae()) {
1249                 if ((spec.format & SF_FORMAT_WAV) == 0) {
1250                         /* RIFF/WAV specifies endianess */
1251                         spec.format |= sndfile_endian_format_from_string (endian_format_combo.get_active_text ());
1252                 }
1253         }
1254
1255         spec.format |= sndfile_bitdepth_format_from_string (bitdepth_format_combo.get_active_text ());
1256
1257         string sr_str = sample_rate_combo.get_active_text();
1258         if (sr_str == N_("22.05kHz")) {
1259                 spec.sample_rate = 22050;
1260         } else if (sr_str == _("44.1kHz")) {
1261                 spec.sample_rate = 44100;
1262         } else if (sr_str == _("48kHz")) {
1263                 spec.sample_rate = 48000;
1264         } else if (sr_str == _("88.2kHz")) {
1265                 spec.sample_rate = 88200;
1266         } else if (sr_str == _("96kHz")) {
1267                 spec.sample_rate = 96000;
1268         } else if (sr_str == _("192kHz")) {
1269                 spec.sample_rate = 192000;
1270         } else {
1271                 spec.sample_rate = session->frame_rate();
1272         }
1273
1274         if (Profile->get_sae()) {
1275                 spec.src_quality = SRC_SINC_BEST_QUALITY;
1276         } else {
1277                 string src_str = src_quality_combo.get_active_text();
1278                 if (src_str == _("fastest")) {
1279                         spec.src_quality = SRC_ZERO_ORDER_HOLD;
1280                 } else if (src_str == _("linear")) {
1281                         spec.src_quality = SRC_LINEAR;
1282                 } else if (src_str == _("better")) {
1283                         spec.src_quality = SRC_SINC_FASTEST;
1284                 } else if (src_str == _("intermediate")) {
1285                         spec.src_quality = SRC_SINC_MEDIUM_QUALITY;
1286                 } else {
1287                         spec.src_quality = SRC_SINC_BEST_QUALITY;
1288                 }
1289         }
1290
1291         string dither_str = dither_type_combo.get_active_text();
1292         if (dither_str == _("None")) {
1293                 spec.dither_type = GDitherNone;
1294         } else if (dither_str == _("Rectangular")) {
1295                 spec.dither_type = GDitherRect;
1296         } else if (dither_str == _("Triangular")) {
1297                 spec.dither_type = GDitherTri;
1298         } else {
1299                 spec.dither_type = GDitherShaped;
1300         }
1301
1302         write_track_and_master_selection_to_spec();
1303 }
1304
1305
1306 void
1307 ExportDialog::write_track_and_master_selection_to_spec()
1308 {
1309         if(!track_and_master_selection_allowed){
1310                 return;
1311         }
1312
1313         uint32_t chan=0;
1314         Port *last_port = 0;
1315
1316         TreeModel::Children rows = master_selector.get_model()->children();
1317         TreeModel::Children::iterator ri;
1318         TreeModel::Row row;
1319         for (ri = rows.begin(); ri != rows.end(); ++ri) {
1320                 row = *ri;
1321                 Port* port = row[exp_cols.port];
1322
1323                 if (last_port != port) {
1324                         chan = 0;
1325                 }
1326
1327                 if (row[exp_cols.left]) {
1328                         spec.port_map[0].push_back (std::pair<Port*,uint32_t>(port, chan));
1329                 }
1330
1331                 if (spec.channels == 2) {
1332                         if (row[exp_cols.right]) {
1333                                 spec.port_map[1].push_back (std::pair<Port*,uint32_t>(port, chan));
1334                         }
1335                 }
1336         }
1337
1338         chan = 0;
1339         rows = track_selector.get_model()->children();
1340
1341         for (ri = rows.begin(); ri != rows.end(); ++ri) {
1342                 row = *ri;
1343
1344                 Port* port = row[exp_cols.port];
1345
1346                 if (last_port != port) {
1347                         chan = 0;
1348                 }
1349
1350                 if (row[exp_cols.left]) {
1351                         spec.port_map[0].push_back (std::pair<Port*,uint32_t>(port, chan));
1352                 }
1353
1354                 if (spec.channels == 2) {
1355                         if (row[exp_cols.right]) {
1356                                 spec.port_map[1].push_back (std::pair<Port*,uint32_t>(port, chan));
1357                         }
1358
1359                 }
1360
1361                 last_port = port;
1362                 ++chan;
1363         }
1364 }
1365
1366
1367 gint
1368 ExportDialog::window_closed (GdkEventAny *ignored)
1369 {
1370         end_dialog ();
1371         return TRUE;
1372 }
1373
1374 void
1375 ExportDialog::browse ()
1376 {
1377         FileChooserDialog dialog("Export to file", browse_action());
1378         dialog.set_transient_for(*this);
1379         dialog.set_filename (file_entry.get_text());
1380
1381         dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1382         dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
1383
1384         int result = dialog.run();
1385
1386         if (result == Gtk::RESPONSE_OK) {
1387                 string filename = dialog.get_filename();
1388
1389                 if (filename.length()) {
1390                         file_entry.set_text (filename);
1391                 }
1392         }
1393 }
1394
1395 void
1396 ExportDialog::track_selector_button_click ()
1397 {
1398         if (track_scroll.is_visible ()) {
1399                 track_scroll.hide ();
1400         } else {
1401                 track_scroll.show_all ();
1402         }
1403 }