gtk2_ardour/engine_dialog.cc

   1 /*
   2     Copyright (C) 2010 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 #include <exception>
  21 #include <vector>
  22 #include <cmath>
  23 #include <fstream>
  24 #include <map>
  25
  26 #include <boost/scoped_ptr.hpp>
  27
  28 #include <gtkmm/messagedialog.h>
  29
  30 #include "pbd/error.h"
  31 #include "pbd/xml++.h"
  32 #include "pbd/unwind.h"
  33 #include "pbd/failed_constructor.h"
  34
  35 #include <gtkmm/alignment.h>
  36 #include <gtkmm/stock.h>
  37 #include <gtkmm/notebook.h>
  38 #include <gtkmm2ext/utils.h>
  39
  40 #include "ardour/audio_backend.h"
  41 #include "ardour/audioengine.h"
  42 #include "ardour/mtdm.h"
  43 #include "ardour/rc_configuration.h"
  44 #include "ardour/types.h"
  45
  46 #include "pbd/convert.h"
  47 #include "pbd/error.h"
  48
  49 #include "ardour_ui.h"
  50 #include "engine_dialog.h"
  51 #include "gui_thread.h"
  52 #include "utils.h"
  53 #include "i18n.h"
  54
  55 using namespace std;
  56 using namespace Gtk;
  57 using namespace Gtkmm2ext;
  58 using namespace PBD;
  59 using namespace Glib;
  60
  61 static const unsigned int midi_tab = -1; /* not currently in use */
  62 static const unsigned int latency_tab = 1; /* zero-based, page zero is the main setup page */
  63
  64 static const char* results_markup = X_("<span foreground=\"red\" style=\"italic\" size=\"larger\">%1</span>");
  65
  66 EngineControl::EngineControl ()
  67         : ArdourDialog (_("Audio/MIDI Setup"))
  68         , basic_packer (9, 4)
  69         , input_latency_adjustment (0, 0, 99999, 1)
  70         , input_latency (input_latency_adjustment)
  71         , output_latency_adjustment (0, 0, 99999, 1)
  72         , output_latency (output_latency_adjustment)
  73         , input_channels_adjustment (0, 0, 256, 1)
  74         , input_channels (input_channels_adjustment)
  75         , output_channels_adjustment (0, 0, 256, 1)
  76         , output_channels (output_channels_adjustment)
  77         , ports_adjustment (128, 8, 1024, 1, 16)
  78         , ports_spinner (ports_adjustment)
  79         , control_app_button (_("Device Control Panel"))
  80         , lm_measure_button (_("Measure"))
  81         , lm_use_button (_("Use results"))
  82         , lm_back_button (_("Back to settings ... (ignore results)"))
  83         , lm_button (_("Calibrate..."))
  84         , lm_table (12, 3)
  85         , have_lm_results (false)
  86         , lm_running (false)
  87         , midi_refresh_button (_("Refresh list"))
  88         , ignore_changes (0)
  89         , _desired_sample_rate (0)
  90         , no_push (true)
  91         , started_at_least_once (false)
  92 {
  93         using namespace Notebook_Helpers;
  94         vector<string> strings;
  95         Label* label;
  96         AttachOptions xopt = AttachOptions (FILL|EXPAND);
  97         int row;
  98
  99         set_name (X_("AudioMIDISetup"));
 100
 101         /* the backend combo is the one thing that is ALWAYS visible
 102          */
 103
 104         vector<const ARDOUR::AudioBackendInfo*> backends = ARDOUR::AudioEngine::instance()->available_backends();
 105
 106         if (backends.empty()) {
 107                 MessageDialog msg (string_compose (_("No audio/MIDI backends detected. %1 cannot run\n\n(This is a build/packaging/system error. It should never happen.)"), PROGRAM_NAME));
 108                 msg.run ();
 109                 throw failed_constructor ();
 110         }
 111
 112         for (vector<const ARDOUR::AudioBackendInfo*>::const_iterator b = backends.begin(); b != backends.end(); ++b) {
 113                 strings.push_back ((*b)->name);
 114         }
 115
 116         set_popdown_strings (backend_combo, strings);
 117         backend_combo.set_active_text (strings.front());
 118         backend_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::backend_changed));
 119
 120         /* setup basic packing characteristics for the table used on the main
 121          * tab of the notebook
 122          */
 123
 124         basic_packer.set_spacings (6);
 125         basic_packer.set_border_width (12);
 126         basic_packer.set_homogeneous (false);
 127
 128         /* pack it in */
 129
 130         basic_hbox.pack_start (basic_packer, false, false);
 131
 132         /* latency tab */
 133
 134         /* latency measurement tab */
 135
 136         lm_title.set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("Latency Measurement Tool")));
 137
 138         row = 0;
 139         lm_table.set_row_spacings (12);
 140         lm_table.set_col_spacings (6);
 141         lm_table.set_homogeneous (false);
 142
 143         lm_table.attach (lm_title, 0, 3, row, row+1, xopt, (AttachOptions) 0);
 144         row++;
 145
 146         Gtk::Label* preamble;
 147
 148         preamble = manage (new Label);
 149         preamble->set_width_chars (60);
 150         preamble->set_line_wrap (true);
 151         preamble->set_markup (_("<span weight=\"bold\">Turn down the volume on your audio equipment to a very low level.</span>"));
 152
 153         lm_table.attach (*preamble, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 154         row++;
 155
 156         preamble = manage (new Label);
 157         preamble->set_width_chars (60);
 158         preamble->set_line_wrap (true);
 159         preamble->set_markup (_("Select two channels below and connect them using a cable."));
 160
 161         lm_table.attach (*preamble, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 162         row++;
 163
 164         label = manage (new Label (_("Output channel")));
 165         lm_table.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 166
 167         Gtk::Alignment* misc_align = manage (new Alignment (0.0, 0.5));
 168         misc_align->add (lm_output_channel_combo);
 169         lm_table.attach (*misc_align, 1, 3, row, row+1, xopt, (AttachOptions) 0);
 170         ++row;
 171
 172         label = manage (new Label (_("Input channel")));
 173         lm_table.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 174
 175         misc_align = manage (new Alignment (0.0, 0.5));
 176         misc_align->add (lm_input_channel_combo);
 177         lm_table.attach (*misc_align, 1, 3, row, row+1, FILL, (AttachOptions) 0);
 178         ++row;
 179
 180         xopt = AttachOptions(0);
 181
 182         lm_measure_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::latency_button_clicked));
 183         lm_use_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::use_latency_button_clicked));
 184         lm_back_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (notebook, &Gtk::Notebook::set_current_page), 0));
 185
 186         lm_use_button.set_sensitive (false);
 187
 188         /* Increase the default spacing around the labels of these three
 189          * buttons
 190          */
 191
 192         Gtk::Misc* l;
 193
 194         if ((l = dynamic_cast<Gtk::Misc*>(lm_measure_button.get_child())) != 0) {
 195                 l->set_padding (10, 10);
 196         }
 197
 198         if ((l = dynamic_cast<Gtk::Misc*>(lm_use_button.get_child())) != 0) {
 199                 l->set_padding (10, 10);
 200         }
 201
 202         if ((l = dynamic_cast<Gtk::Misc*>(lm_back_button.get_child())) != 0) {
 203                 l->set_padding (10, 10);
 204         }
 205
 206         preamble = manage (new Label);
 207         preamble->set_width_chars (60);
 208         preamble->set_line_wrap (true);
 209         preamble->set_markup (_("Once the channels are connected, click the \"Measure\" button."));
 210         lm_table.attach (*preamble, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 211         row++;
 212
 213         preamble = manage (new Label);
 214         preamble->set_width_chars (60);
 215         preamble->set_line_wrap (true);
 216         preamble->set_markup (_("When satisfied with the results, click the \"Use results\" button."));
 217         lm_table.attach (*preamble, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 218
 219         ++row; // skip a row in the table
 220         ++row; // skip a row in the table
 221
 222         lm_table.attach (lm_results, 0, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 223
 224         ++row; // skip a row in the table
 225         ++row; // skip a row in the table
 226
 227         lm_table.attach (lm_measure_button, 0, 1, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 228         lm_table.attach (lm_use_button, 1, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 229         lm_table.attach (lm_back_button, 2, 3, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
 230
 231         lm_results.set_markup (string_compose (results_markup, _("No measurement results yet")));
 232
 233         lm_vbox.set_border_width (12);
 234         lm_vbox.pack_start (lm_table, false, false);
 235
 236         /* pack it all up */
 237
 238         notebook.pages().push_back (TabElem (basic_vbox, _("Audio")));
 239         // notebook.pages().push_back (TabElem (midi_vbox, _("MIDI")));
 240         notebook.pages().push_back (TabElem (lm_vbox, _("Latency")));
 241         notebook.set_border_width (12);
 242
 243         notebook.set_show_tabs (false);
 244         notebook.show_all ();
 245
 246         notebook.set_name ("SettingsNotebook");
 247
 248         /* packup the notebook */
 249
 250         get_vbox()->set_border_width (12);
 251         get_vbox()->pack_start (notebook);
 252
 253         /* need a special function to print "all available channels" when the
 254          * channel counts hit zero.
 255          */
 256
 257         input_channels.signal_output().connect (sigc::bind (sigc::ptr_fun (&EngineControl::print_channel_count), &input_channels));
 258         output_channels.signal_output().connect (sigc::bind (sigc::ptr_fun (&EngineControl::print_channel_count), &output_channels));
 259
 260         control_app_button.signal_clicked().connect (mem_fun (*this, &EngineControl::control_app_button_clicked));
 261         manage_control_app_sensitivity ();
 262
 263         cancel_button = add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 264         ok_button = add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
 265         apply_button = add_button (Gtk::Stock::APPLY, Gtk::RESPONSE_APPLY);
 266
 267         /* Pick up any existing audio setup configuration, if appropriate */
 268
 269         XMLNode* audio_setup = ARDOUR::Config->extra_xml ("AudioMIDISetup");
 270
 271         ARDOUR::AudioEngine::instance()->Running.connect (running_connection, MISSING_INVALIDATOR, boost::bind (&EngineControl::engine_running, this), gui_context());
 272         ARDOUR::AudioEngine::instance()->Stopped.connect (stopped_connection, MISSING_INVALIDATOR, boost::bind (&EngineControl::engine_stopped, this), gui_context());
 273         ARDOUR::AudioEngine::instance()->Halted.connect (stopped_connection, MISSING_INVALIDATOR, boost::bind (&EngineControl::engine_stopped, this), gui_context());
 274
 275         backend_changed ();
 276
 277         if (audio_setup) {
 278                 set_state (*audio_setup);
 279         }
 280
 281         /* Connect to signals */
 282
 283         driver_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::driver_changed));
 284         sample_rate_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::sample_rate_changed));
 285         buffer_size_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::buffer_size_changed));
 286         device_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::device_changed));
 287         midi_option_combo.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::midi_option_changed));
 288
 289         input_latency.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 290         output_latency.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 291         input_channels.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 292         output_channels.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
 293
 294         notebook.signal_switch_page().connect (sigc::mem_fun (*this, &EngineControl::on_switch_page));
 295
 296         no_push = false;
 297  }
 298
 299  void
 300  EngineControl::on_response (int response_id)
 301  {
 302          ArdourDialog::on_response (response_id);
 303
 304          switch (response_id) {
 305          case RESPONSE_APPLY:
 306                  push_state_to_backend (true);
 307                  break;
 308          case RESPONSE_OK:
 309                  push_state_to_backend (true);
 310                  hide ();
 311                  break;
 312          case RESPONSE_DELETE_EVENT: {
 313                  GdkEventButton ev;
 314                  ev.type = GDK_BUTTON_PRESS;
 315                  ev.button = 1;
 316                  on_delete_event ((GdkEventAny*) &ev);
 317                  break;
 318          }
 319          default:
 320                  hide ();
 321          }
 322  }
 323
 324  void
 325  EngineControl::build_notebook ()
 326  {
 327          Label* label;
 328          AttachOptions xopt = AttachOptions (FILL|EXPAND);
 329
 330          /* clear the table */
 331
 332          Gtkmm2ext::container_clear (basic_vbox);
 333          Gtkmm2ext::container_clear (basic_packer);
 334
 335          label = manage (left_aligned_label (_("Audio System:")));
 336          basic_packer.attach (*label, 0, 1, 0, 1, xopt, (AttachOptions) 0);
 337          basic_packer.attach (backend_combo, 1, 2, 0, 1, xopt, (AttachOptions) 0);
 338
 339          lm_button.signal_clicked.connect (sigc::bind (sigc::mem_fun (notebook, &Gtk::Notebook::set_current_page), latency_tab));
 340          lm_button.set_name ("record enable button");
 341          if (_have_control) {
 342                  build_full_control_notebook ();
 343          } else {
 344                  build_no_control_notebook ();
 345          }
 346
 347          basic_vbox.pack_start (basic_hbox, false, false);
 348
 349          if (_have_control) {
 350                  Gtk::HBox* hpacker = manage (new HBox);
 351                  hpacker->set_border_width (12);
 352                  hpacker->pack_start (control_app_button, false, false);
 353                  hpacker->show ();
 354                  control_app_button.show();
 355                  basic_vbox.pack_start (*hpacker);
 356          }
 357
 358          basic_vbox.show_all ();
 359  }
 360
 361  void
 362  EngineControl::build_full_control_notebook ()
 363  {
 364          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 365          assert (backend);
 366
 367          using namespace Notebook_Helpers;
 368          Label* label;
 369          vector<string> strings;
 370          AttachOptions xopt = AttachOptions (FILL|EXPAND);
 371          int row = 1; // row zero == backend combo
 372
 373          /* start packing it up */
 374
 375          if (backend->requires_driver_selection()) {
 376                  label = manage (left_aligned_label (_("Driver:")));
 377                  basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 378                  basic_packer.attach (driver_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
 379                  row++;
 380          }
 381
 382          label = manage (left_aligned_label (_("Device:")));
 383          basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 384          basic_packer.attach (device_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
 385          row++;
 386
 387          label = manage (left_aligned_label (_("Sample rate:")));
 388          basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 389          basic_packer.attach (sample_rate_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
 390          row++;
 391
 392
 393          label = manage (left_aligned_label (_("Buffer size:")));
 394          basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 395          basic_packer.attach (buffer_size_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
 396          buffer_size_duration_label.set_alignment (0.0); /* left-align */
 397          basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, SHRINK, (AttachOptions) 0);
 398          row++;
 399
 400          input_channels.set_name ("InputChannels");
 401          input_channels.set_flags(Gtk::CAN_FOCUS);
 402          input_channels.set_digits(0);
 403          input_channels.set_wrap(false);
 404          output_channels.set_editable (true);
 405
 406          label = manage (left_aligned_label (_("Input Channels:")));
 407          basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 408          basic_packer.attach (input_channels, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 409          ++row;
 410
 411          output_channels.set_name ("OutputChannels");
 412          output_channels.set_flags(Gtk::CAN_FOCUS);
 413          output_channels.set_digits(0);
 414          output_channels.set_wrap(false);
 415          output_channels.set_editable (true);
 416
 417          label = manage (left_aligned_label (_("Output Channels:")));
 418          basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 419          basic_packer.attach (output_channels, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 420          ++row;
 421
 422          input_latency.set_name ("InputLatency");
 423          input_latency.set_flags(Gtk::CAN_FOCUS);
 424          input_latency.set_digits(0);
 425          input_latency.set_wrap(false);
 426          input_latency.set_editable (true);
 427
 428          label = manage (left_aligned_label (_("Hardware input latency:")));
 429          basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 430          basic_packer.attach (input_latency, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 431          label = manage (left_aligned_label (_("samples")));
 432          basic_packer.attach (*label, 2, 3, row, row+1, SHRINK, (AttachOptions) 0);
 433          ++row;
 434
 435          output_latency.set_name ("OutputLatency");
 436          output_latency.set_flags(Gtk::CAN_FOCUS);
 437          output_latency.set_digits(0);
 438          output_latency.set_wrap(false);
 439          output_latency.set_editable (true);
 440
 441          label = manage (left_aligned_label (_("Hardware output latency:")));
 442          basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
 443          basic_packer.attach (output_latency, 1, 2, row, row+1, xopt, (AttachOptions) 0);
 444          label = manage (left_aligned_label (_("samples")));
 445          basic_packer.attach (*label, 2, 3, row, row+1, SHRINK, (AttachOptions) 0);
 446
 447          /* button spans 2 rows */
 448
 449          basic_packer.attach (lm_button, 3, 4, row-1, row+1, xopt, xopt);
 450          ++row;
 451
 452          label = manage (left_aligned_label (_("MIDI System")));
 453          basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 454          basic_packer.attach (midi_option_combo, 1, 2, row, row + 1, SHRINK, (AttachOptions) 0);
 455          row++;
 456  }
 457
 458  void
 459  EngineControl::build_no_control_notebook ()
 460  {
 461          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 462          assert (backend);
 463
 464          using namespace Notebook_Helpers;
 465          Label* label;
 466          vector<string> strings;
 467          AttachOptions xopt = AttachOptions (FILL|EXPAND);
 468          int row = 1; // row zero == backend combo
 469          const string msg = string_compose (_("The %1 audio backend was configured and started externally.\nThis limits your control over it."), backend->name());
 470
 471          label = manage (new Label);
 472          label->set_markup (string_compose ("<span weight=\"bold\" foreground=\"red\">%1</span>", msg));
 473          basic_packer.attach (*label, 0, 2, row, row + 1, xopt, (AttachOptions) 0);
 474          row++;
 475
 476          if (backend->can_change_sample_rate_when_running()) {
 477                  label = manage (left_aligned_label (_("Sample rate:")));
 478                  basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 479                  basic_packer.attach (sample_rate_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
 480                  row++;
 481          }
 482
 483          if (backend->can_change_buffer_size_when_running()) {
 484                  label = manage (left_aligned_label (_("Buffer size:")));
 485                  basic_packer.attach (*label, 0, 1, row, row + 1, xopt, (AttachOptions) 0);
 486                  basic_packer.attach (buffer_size_combo, 1, 2, row, row + 1, xopt, (AttachOptions) 0);
 487                  buffer_size_duration_label.set_alignment (0.0); /* left-align */
 488                  basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
 489                  row++;
 490          }
 491
 492          connect_disconnect_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::connect_disconnect_click));
 493
 494          basic_packer.attach (connect_disconnect_button, 0, 2, row, row+1, FILL, AttachOptions (0));
 495          row++;
 496  }
 497
 498  EngineControl::~EngineControl ()
 499  {
 500          ignore_changes = true;
 501  }
 502
 503  void
 504  EngineControl::disable_latency_tab ()
 505  {
 506          vector<string> empty;
 507          set_popdown_strings (lm_output_channel_combo, empty);
 508          set_popdown_strings (lm_input_channel_combo, empty);
 509          lm_measure_button.set_sensitive (false);
 510          lm_use_button.set_sensitive (false);
 511  }
 512
 513  void
 514  EngineControl::enable_latency_tab ()
 515  {
 516          vector<string> outputs;
 517          ARDOUR::AudioEngine::instance()->get_physical_outputs (ARDOUR::DataType::AUDIO, outputs);
 518          set_popdown_strings (lm_output_channel_combo, outputs);
 519          lm_output_channel_combo.set_active_text (outputs.front());
 520
 521          vector<string> inputs;
 522          ARDOUR::AudioEngine::instance()->get_physical_inputs (ARDOUR::DataType::AUDIO, inputs);
 523          set_popdown_strings (lm_input_channel_combo, inputs);
 524          lm_input_channel_combo.set_active_text (inputs.front());
 525
 526          lm_measure_button.set_sensitive (true);
 527  }
 528
 529  void
 530  EngineControl::setup_midi_tab_for_backend ()
 531  {
 532          string backend = backend_combo.get_active_text ();
 533
 534          Gtkmm2ext::container_clear (midi_vbox);
 535
 536          midi_vbox.set_border_width (12);
 537          midi_device_table.set_border_width (12);
 538
 539          if (backend == "JACK") {
 540                  setup_midi_tab_for_jack ();
 541          }
 542
 543          midi_vbox.pack_start (midi_device_table, true, true);
 544          midi_vbox.pack_start (midi_refresh_button, false, false);
 545          midi_vbox.show_all ();
 546
 547          midi_refresh_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::refresh_midi_display));
 548  }
 549
 550  void
 551  EngineControl::setup_midi_tab_for_jack ()
 552  {
 553  }
 554
 555  void
 556  EngineControl::refresh_midi_display ()
 557  {
 558          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 559          assert (backend);
 560
 561          vector<string> midi_inputs;
 562          vector<string> midi_outputs;
 563          int row  = 0;
 564          AttachOptions xopt = AttachOptions (FILL|EXPAND);
 565          Gtk::Label* l;
 566
 567          Gtkmm2ext::container_clear (midi_device_table);
 568
 569          backend->get_physical_inputs (ARDOUR::DataType::MIDI, midi_inputs);
 570          backend->get_physical_outputs (ARDOUR::DataType::MIDI, midi_outputs);
 571
 572          midi_device_table.set_spacings (6);
 573          midi_device_table.set_homogeneous (true);
 574          midi_device_table.resize (midi_inputs.size() + midi_outputs.size() + 3, 1);
 575
 576          l = manage (new Label);
 577          l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Inputs")));
 578          midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
 579          l->set_alignment (0, 0.5);
 580          row++;
 581          l->show ();
 582
 583          for (vector<string>::iterator p = midi_inputs.begin(); p != midi_inputs.end(); ++p) {
 584                  l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
 585                  l->set_alignment (0, 0.5);
 586                  midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
 587                  l->show ();
 588                  row++;
 589          }
 590
 591          row++; // extra row of spacing
 592
 593          l = manage (new Label);
 594          l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Outputs")));
 595          midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
 596          l->set_alignment (0, 0.5);
 597          row++;
 598          l->show ();
 599
 600          for (vector<string>::iterator p = midi_outputs.begin(); p != midi_outputs.end(); ++p) {
 601                  l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
 602                  l->set_alignment (0, 0.5);
 603                  midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
 604                  l->show ();
 605                  row++;
 606          }
 607  }
 608
 609  void
 610  EngineControl::update_sensitivity ()
 611  {
 612  }
 613
 614  void
 615  EngineControl::backend_changed ()
 616  {
 617          if (ignore_changes) {
 618                  return;
 619          }
 620
 621          string backend_name = backend_combo.get_active_text();
 622          boost::shared_ptr<ARDOUR::AudioBackend> backend;
 623
 624          if (!(backend = ARDOUR::AudioEngine::instance()->set_backend (backend_name, "ardour", ""))) {
 625                  /* eh? setting the backend failed... how ? */
 626                  return;
 627          }
 628
 629          _have_control = ARDOUR::AudioEngine::instance()->setup_required ();
 630
 631          build_notebook ();
 632          setup_midi_tab_for_backend ();
 633
 634          if (backend->requires_driver_selection()) {
 635                  vector<string> drivers = backend->enumerate_drivers();
 636
 637                  if (!drivers.empty()) {
 638                          {
 639                                  PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
 640                                  set_popdown_strings (driver_combo, drivers);
 641                                  driver_combo.set_active_text (drivers.front());
 642                          }
 643
 644                          driver_changed ();
 645                  }
 646
 647          } else {
 648                  driver_combo.set_sensitive (false);
 649                  /* this will change the device text which will cause a call to
 650                   * device changed which will set up parameters
 651                   */
 652                  list_devices ();
 653          }
 654
 655          vector<string> midi_options = backend->enumerate_midi_options();
 656
 657          if (midi_options.size() == 1) {
 658                  /* only contains the "none" option */
 659                  midi_option_combo.set_sensitive (false);
 660          } else {
 661                  if (_have_control) {
 662                          set_popdown_strings (midi_option_combo, midi_options);
 663                          midi_option_combo.set_active_text (midi_options.front());
 664                          midi_option_combo.set_sensitive (true);
 665                  } else {
 666                          midi_option_combo.set_sensitive (false);
 667                  }
 668          }
 669
 670          maybe_display_saved_state ();
 671  }
 672
 673  bool
 674  EngineControl::print_channel_count (Gtk::SpinButton* sb)
 675  {
 676          uint32_t cnt = (uint32_t) sb->get_value();
 677          if (cnt == 0) {
 678                  sb->set_text (_("all available channels"));
 679          } else {
 680                  char buf[32];
 681                  snprintf (buf, sizeof (buf), "%d", cnt);
 682                  sb->set_text (buf);
 683          }
 684          return true;
 685  }
 686
 687  void
 688  EngineControl::list_devices ()
 689  {
 690          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 691          assert (backend);
 692
 693          /* now fill out devices, mark sample rates, buffer sizes insensitive */
 694
 695          vector<ARDOUR::AudioBackend::DeviceStatus> all_devices = backend->enumerate_devices ();
 696
 697          /* NOTE: Ardour currently does not display the "available" field of the
 698           * returned devices.
 699           *
 700           * Doing so would require a different GUI widget than the combo
 701           * box/popdown that we currently use, since it has no way to list
 702           * items that are not selectable. Something more like a popup menu,
 703           * which could have unselectable items, would be appropriate.
 704           */
 705
 706          vector<string> available_devices;
 707
 708          for (vector<ARDOUR::AudioBackend::DeviceStatus>::const_iterator i = all_devices.begin(); i != all_devices.end(); ++i) {
 709                  available_devices.push_back (i->name);
 710          }
 711
 712          if (!available_devices.empty()) {
 713
 714                  update_sensitivity ();
 715
 716                  {
 717                          PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
 718                          set_popdown_strings (device_combo, available_devices);
 719                          device_combo.set_active_text (available_devices.front());
 720                  }
 721
 722                  device_changed ();
 723
 724                  ok_button->set_sensitive (true);
 725                  apply_button->set_sensitive (true);
 726
 727          } else {
 728                  sample_rate_combo.set_sensitive (false);
 729                  buffer_size_combo.set_sensitive (false);
 730                  input_latency.set_sensitive (false);
 731                  output_latency.set_sensitive (false);
 732                  input_channels.set_sensitive (false);
 733                  output_channels.set_sensitive (false);
 734                  ok_button->set_sensitive (false);
 735                  apply_button->set_sensitive (false);
 736          }
 737  }
 738
 739  void
 740  EngineControl::driver_changed ()
 741  {
 742          if (ignore_changes) {
 743                  return;
 744          }
 745
 746          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 747          assert (backend);
 748
 749          backend->set_driver (driver_combo.get_active_text());
 750          list_devices ();
 751
 752          maybe_display_saved_state ();
 753  }
 754
 755  void
 756  EngineControl::device_changed ()
 757  {
 758          if (ignore_changes) {
 759                  return;
 760          }
 761
 762          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 763          assert (backend);
 764          string device_name = device_combo.get_active_text ();
 765          vector<string> s;
 766
 767          {
 768                  PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
 769
 770                  /* don't allow programmatic change to combos to cause a
 771                     recursive call to this method.
 772                  */
 773
 774                  /* sample rates */
 775
 776                  string desired;
 777
 778                  vector<float> sr;
 779
 780                  if (_have_control) {
 781                          sr = backend->available_sample_rates (device_name);
 782                  } else {
 783
 784                          sr.push_back (8000.0f);
 785                          sr.push_back (16000.0f);
 786                          sr.push_back (32000.0f);
 787                          sr.push_back (44100.0f);
 788                          sr.push_back (48000.0f);
 789                          sr.push_back (88200.0f);
 790                          sr.push_back (96000.0f);
 791                          sr.push_back (192000.0f);
 792                          sr.push_back (384000.0f);
 793                  }
 794
 795                  for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
 796                          s.push_back (rate_as_string (*x));
 797                          if (*x == _desired_sample_rate) {
 798                                  desired = s.back();
 799                          }
 800                  }
 801
 802                  if (!s.empty()) {
 803                          sample_rate_combo.set_sensitive (true);
 804                          set_popdown_strings (sample_rate_combo, s);
 805
 806                          if (desired.empty()) {
 807                                  sample_rate_combo.set_active_text (s.front());
 808                          } else {
 809                                  sample_rate_combo.set_active_text (desired);
 810                          }
 811
 812                  } else {
 813                          sample_rate_combo.set_sensitive (false);
 814                  }
 815
 816                  /* buffer sizes */
 817
 818                  vector<uint32_t> bs;
 819
 820                  if (_have_control) {
 821                          bs = backend->available_buffer_sizes(device_name);
 822                  } else if (backend->can_change_buffer_size_when_running()) {
 823                          bs.push_back (8);
 824                          bs.push_back (16);
 825                          bs.push_back (32);
 826                          bs.push_back (64);
 827                          bs.push_back (128);
 828                          bs.push_back (256);
 829                          bs.push_back (512);
 830                          bs.push_back (1024);
 831                          bs.push_back (2048);
 832                          bs.push_back (4096);
 833                          bs.push_back (8192);
 834                  }
 835                  s.clear ();
 836                  for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
 837                          s.push_back (bufsize_as_string (*x));
 838                  }
 839
 840                  if (!s.empty()) {
 841                          buffer_size_combo.set_sensitive (true);
 842                          set_popdown_strings (buffer_size_combo, s);
 843
 844                          buffer_size_combo.set_active_text (s.front());
 845                          show_buffer_duration ();
 846                  } else {
 847                          buffer_size_combo.set_sensitive (false);
 848                  }
 849
 850                  /* XXX theoretically need to set min + max channel counts here
 851                   */
 852
 853                  manage_control_app_sensitivity ();
 854          }
 855
 856          /* pick up any saved state for this device */
 857
 858          maybe_display_saved_state ();
 859
 860          /* and push it to the backend */
 861
 862          push_state_to_backend (false);
 863  }
 864
 865  string
 866  EngineControl::bufsize_as_string (uint32_t sz)
 867  {
 868          /* Translators: "samples" is always plural here, so no
 869             need for plural+singular forms.
 870          */
 871          char buf[32];
 872          snprintf (buf, sizeof (buf), _("%u samples"), sz);
 873          return buf;
 874  }
 875
 876  void
 877  EngineControl::sample_rate_changed ()
 878  {
 879          if (ignore_changes) {
 880                  return;
 881          }
 882
 883          /* reset the strings for buffer size to show the correct msec value
 884             (reflecting the new sample rate).
 885          */
 886
 887          show_buffer_duration ();
 888          save_state ();
 889
 890  }
 891
 892  void
 893  EngineControl::buffer_size_changed ()
 894  {
 895          if (ignore_changes) {
 896                  return;
 897          }
 898
 899          show_buffer_duration ();
 900          save_state ();
 901  }
 902
 903  void
 904  EngineControl::show_buffer_duration ()
 905  {
 906
 907          /* buffer sizes  - convert from just samples to samples + msecs for
 908           * the displayed string
 909           */
 910
 911          string bs_text = buffer_size_combo.get_active_text ();
 912          uint32_t samples = atoi (bs_text); /* will ignore trailing text */
 913          uint32_t rate = get_rate();
 914
 915          /* Translators: "msecs" is ALWAYS plural here, so we do not
 916             need singular form as well.
 917          */
 918          /* Developers: note the hard-coding of a double buffered model
 919             in the (2 * samples) computation of latency. we always start
 920             the audiobackend in this configuration.
 921          */
 922          char buf[32];
 923          snprintf (buf, sizeof (buf), _("(%.1f msecs)"), (2 * samples) / (rate/1000.0));
 924          buffer_size_duration_label.set_text (buf);
 925  }
 926
 927  void
 928  EngineControl::midi_option_changed ()
 929  {
 930          if (!ignore_changes) {
 931                  save_state ();
 932          }
 933  }
 934
 935  void
 936  EngineControl::parameter_changed ()
 937  {
 938          if (!ignore_changes) {
 939                  save_state ();
 940          }
 941  }
 942
 943  EngineControl::State*
 944  EngineControl::get_matching_state (const string& backend,
 945                                     const string& driver,
 946                                     const string& device)
 947  {
 948          for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
 949                  if ((*i).backend == backend &&
 950                      (*i).driver == driver &&
 951                      (*i).device == device) {
 952                          return &(*i);
 953                  }
 954          }
 955          return 0;
 956  }
 957
 958  EngineControl::State*
 959  EngineControl::get_saved_state_for_currently_displayed_backend_and_device ()
 960  {
 961          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
 962
 963          if (backend) {
 964                  return get_matching_state (backend_combo.get_active_text(),
 965                                             (backend->requires_driver_selection() ? (std::string) driver_combo.get_active_text() : string()),
 966                                             device_combo.get_active_text());
 967          }
 968
 969
 970          return get_matching_state (backend_combo.get_active_text(),
 971                                     string(),
 972                                     device_combo.get_active_text());
 973  }
 974
 975  EngineControl::State*
 976  EngineControl::save_state ()
 977  {
 978          if (!_have_control) {
 979                  return 0;
 980          }
 981
 982          bool existing = true;
 983          State* state = get_saved_state_for_currently_displayed_backend_and_device ();
 984
 985          if (!state) {
 986                  existing = false;
 987                  state = new State;
 988          }
 989
 990          store_state (*state);
 991
 992          if (!existing) {
 993                  states.push_back (*state);
 994          }
 995
 996          return state;
 997  }
 998
 999  void
1000  EngineControl::store_state (State& state)
1001  {
1002          state.backend = get_backend ();
1003          state.driver = get_driver ();
1004          state.device = get_device_name ();
1005          state.sample_rate = get_rate ();
1006          state.buffer_size = get_buffer_size ();
1007          state.input_latency = get_input_latency ();
1008          state.output_latency = get_output_latency ();
1009          state.input_channels = get_input_channels ();
1010          state.output_channels = get_output_channels ();
1011          state.midi_option = get_midi_option ();
1012  }
1013
1014  void
1015  EngineControl::maybe_display_saved_state ()
1016  {
1017          if (!_have_control) {
1018                  return;
1019          }
1020
1021          State* state = get_saved_state_for_currently_displayed_backend_and_device ();
1022
1023          if (state) {
1024                  PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
1025
1026                  if (!_desired_sample_rate) {
1027                          sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
1028                  }
1029                  buffer_size_combo.set_active_text (bufsize_as_string (state->buffer_size));
1030                  /* call this explicitly because we're ignoring changes to
1031                     the controls at this point.
1032                  */
1033                  show_buffer_duration ();
1034                  input_latency.set_value (state->input_latency);
1035                  output_latency.set_value (state->output_latency);
1036
1037                  if (!state->midi_option.empty()) {
1038                          midi_option_combo.set_active_text (state->midi_option);
1039                  }
1040          }
1041  }
1042
1043  XMLNode&
1044  EngineControl::get_state ()
1045  {
1046          XMLNode* root = new XMLNode ("AudioMIDISetup");
1047          std::string path;
1048
1049          if (!states.empty()) {
1050                  XMLNode* state_nodes = new XMLNode ("EngineStates");
1051
1052                  for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
1053
1054                          XMLNode* node = new XMLNode ("State");
1055
1056                          node->add_property ("backend", (*i).backend);
1057                          node->add_property ("driver", (*i).driver);
1058                          node->add_property ("device", (*i).device);
1059                          node->add_property ("sample-rate", (*i).sample_rate);
1060                          node->add_property ("buffer-size", (*i).buffer_size);
1061                          node->add_property ("input-latency", (*i).input_latency);
1062                          node->add_property ("output-latency", (*i).output_latency);
1063                          node->add_property ("input-channels", (*i).input_channels);
1064                          node->add_property ("output-channels", (*i).output_channels);
1065                          node->add_property ("active", (*i).active ? "yes" : "no");
1066                          node->add_property ("midi-option", (*i).midi_option);
1067
1068                          state_nodes->add_child_nocopy (*node);
1069                  }
1070
1071                  root->add_child_nocopy (*state_nodes);
1072          }
1073
1074          return *root;
1075  }
1076
1077  void
1078  EngineControl::set_state (const XMLNode& root)
1079  {
1080          XMLNodeList          clist, cclist;
1081          XMLNodeConstIterator citer, cciter;
1082          XMLNode* child;
1083          XMLNode* grandchild;
1084          XMLProperty* prop = NULL;
1085
1086          if (root.name() != "AudioMIDISetup") {
1087                  return;
1088          }
1089
1090          clist = root.children();
1091
1092          states.clear ();
1093
1094          for (citer = clist.begin(); citer != clist.end(); ++citer) {
1095
1096                  child = *citer;
1097
1098                  if (child->name() != "EngineStates") {
1099                          continue;
1100                  }
1101
1102                  cclist = child->children();
1103
1104                  for (cciter = cclist.begin(); cciter != cclist.end(); ++cciter) {
1105                          State state;
1106
1107                          grandchild = *cciter;
1108
1109                          if (grandchild->name() != "State") {
1110                                  continue;
1111                          }
1112
1113                          if ((prop = grandchild->property ("backend")) == 0) {
1114                                  continue;
1115                          }
1116                          state.backend = prop->value ();
1117
1118                          if ((prop = grandchild->property ("driver")) == 0) {
1119                                  continue;
1120                          }
1121                          state.driver = prop->value ();
1122
1123                          if ((prop = grandchild->property ("device")) == 0) {
1124                                  continue;
1125                          }
1126                          state.device = prop->value ();
1127
1128                          if ((prop = grandchild->property ("sample-rate")) == 0) {
1129                                  continue;
1130                          }
1131                          state.sample_rate = atof (prop->value ());
1132
1133                          if ((prop = grandchild->property ("buffer-size")) == 0) {
1134                                  continue;
1135                          }
1136                          state.buffer_size = atoi (prop->value ());
1137
1138                          if ((prop = grandchild->property ("input-latency")) == 0) {
1139                                  continue;
1140                          }
1141                          state.input_latency = atoi (prop->value ());
1142
1143                          if ((prop = grandchild->property ("output-latency")) == 0) {
1144                                  continue;
1145                          }
1146                          state.output_latency = atoi (prop->value ());
1147
1148                          if ((prop = grandchild->property ("input-channels")) == 0) {
1149                                  continue;
1150                          }
1151                          state.input_channels = atoi (prop->value ());
1152
1153                          if ((prop = grandchild->property ("output-channels")) == 0) {
1154                                  continue;
1155                          }
1156                          state.output_channels = atoi (prop->value ());
1157
1158                          if ((prop = grandchild->property ("active")) == 0) {
1159                                  continue;
1160                          }
1161                          state.active = string_is_affirmative (prop->value ());
1162
1163                          if ((prop = grandchild->property ("midi-option")) == 0) {
1164                                  continue;
1165                          }
1166                          state.midi_option = prop->value ();
1167
1168                          states.push_back (state);
1169                  }
1170          }
1171
1172          /* now see if there was an active state and switch the setup to it */
1173
1174          for (StateList::const_iterator i = states.begin(); i != states.end(); ++i) {
1175
1176                  if ((*i).active) {
1177                          ignore_changes++;
1178                          backend_combo.set_active_text ((*i).backend);
1179                          driver_combo.set_active_text ((*i).driver);
1180                          device_combo.set_active_text ((*i).device);
1181                          sample_rate_combo.set_active_text (rate_as_string ((*i).sample_rate));
1182                          buffer_size_combo.set_active_text (bufsize_as_string ((*i).buffer_size));
1183                          input_latency.set_value ((*i).input_latency);
1184                          output_latency.set_value ((*i).output_latency);
1185                          midi_option_combo.set_active_text ((*i).midi_option);
1186                          ignore_changes--;
1187                          break;
1188                  }
1189          }
1190  }
1191
1192
1193  int
1194  EngineControl::push_state_to_backend (bool start)
1195  {
1196          if (no_push) {
1197                  return 0;
1198          }
1199
1200          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
1201
1202          if (!backend) {
1203                  return 0;
1204          }
1205
1206          /* figure out what is going to change */
1207
1208          bool restart_required = false;
1209          bool was_running = ARDOUR::AudioEngine::instance()->running();
1210          bool change_driver = false;
1211          bool change_device = false;
1212          bool change_rate = false;
1213          bool change_bufsize = false;
1214          bool change_latency = false;
1215          bool change_channels = false;
1216          bool change_midi = false;
1217
1218          uint32_t ochan = get_output_channels ();
1219          uint32_t ichan = get_input_channels ();
1220
1221          if (_have_control) {
1222
1223                  if (started_at_least_once) {
1224
1225                          /* we can control the backend */
1226
1227                          if (backend->requires_driver_selection()) {
1228                                  if (get_driver() != backend->driver_name()) {
1229                                          change_driver = true;
1230                                  }
1231                          }
1232
1233                          if (get_device_name() != backend->device_name()) {
1234                                  change_device = true;
1235                          }
1236
1237                          if (get_rate() != backend->sample_rate()) {
1238                                  change_rate = true;
1239                          }
1240
1241                          if (get_buffer_size() != backend->buffer_size()) {
1242                                  change_bufsize = true;
1243                          }
1244
1245                          if (get_midi_option() != backend->midi_option()) {
1246                                  change_midi = true;
1247                          }
1248
1249                          /* zero-requested channels means "all available" */
1250
1251                          if (ichan == 0) {
1252                                  ichan = backend->input_channels();
1253                          }
1254
1255                          if (ochan == 0) {
1256                                  ochan = backend->output_channels();
1257                          }
1258
1259                          if (ichan != backend->input_channels()) {
1260                                  change_channels = true;
1261                          }
1262
1263                          if (ochan != backend->output_channels()) {
1264                                  change_channels = true;
1265                          }
1266
1267                          if (get_input_latency() != backend->systemic_input_latency() ||
1268                              get_output_latency() != backend->systemic_output_latency()) {
1269                                  change_latency = true;
1270                          }
1271                  } else {
1272                          /* backend never started, so we have to force a group
1273                             of settings.
1274                          */
1275                          change_driver = true;
1276                          if (backend->requires_driver_selection()) {
1277                                  change_device = true;
1278                          }
1279                          change_rate = true;
1280                          change_bufsize = true;
1281                          change_channels = true;
1282                          change_latency = true;
1283                          change_midi = true;
1284                  }
1285
1286          } else {
1287
1288                  /* we have no control over the backend, meaning that we can
1289                   * only possibly change sample rate and buffer size.
1290                   */
1291
1292
1293                  if (get_rate() != backend->sample_rate()) {
1294                          change_bufsize = true;
1295                  }
1296
1297                  if (get_buffer_size() != backend->buffer_size()) {
1298                          change_bufsize = true;
1299                  }
1300          }
1301
1302          if (!_have_control) {
1303
1304                  /* We do not have control over the backend, so the best we can
1305                   * do is try to change the sample rate and/or bufsize and get
1306                   * out of here.
1307                   */
1308
1309                  if (change_rate && !backend->can_change_sample_rate_when_running()) {
1310                          return 1;
1311                  }
1312
1313                  if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
1314                          return 1;
1315                  }
1316
1317                  if (change_rate) {
1318                          backend->set_sample_rate (get_rate());
1319                  }
1320
1321                  if (change_bufsize) {
1322                          backend->set_buffer_size (get_buffer_size());
1323                  }
1324
1325                  post_push ();
1326
1327                  return 0;
1328          }
1329
1330          /* determine if we need to stop the backend before changing parameters */
1331
1332          if (change_driver || change_device || change_channels || change_latency ||
1333              (change_rate && !backend->can_change_sample_rate_when_running()) ||
1334              change_midi ||
1335              (change_bufsize && !backend->can_change_buffer_size_when_running())) {
1336                  restart_required = true;
1337          } else {
1338                  restart_required = false;
1339          }
1340
1341          if (was_running) {
1342
1343                  if (!change_driver && !change_device && !change_channels && !change_latency && !change_midi) {
1344                          /* no changes in any parameters that absolutely require a
1345                           * restart, so check those that might be changeable without a
1346                           * restart
1347                           */
1348
1349                          if (change_rate && !backend->can_change_sample_rate_when_running()) {
1350                                  /* can't do this while running ... */
1351                                  restart_required = true;
1352                          }
1353
1354                          if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
1355                                  /* can't do this while running ... */
1356                                  restart_required = true;
1357                          }
1358                  }
1359          }
1360
1361          if (was_running) {
1362                  if (restart_required) {
1363                          if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
1364                                  return -1;
1365                          }
1366                  }
1367          }
1368
1369
1370          if (change_driver && backend->set_driver (get_driver())) {
1371                  error << string_compose (_("Cannot set driver to %1"), get_driver()) << endmsg;
1372                  return -1;
1373          }
1374          if (change_device && backend->set_device_name (get_device_name())) {
1375                  error << string_compose (_("Cannot set device name to %1"), get_device_name()) << endmsg;
1376                  return -1;
1377          }
1378          if (change_rate && backend->set_sample_rate (get_rate())) {
1379                  error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
1380                  return -1;
1381          }
1382          if (change_bufsize && backend->set_buffer_size (get_buffer_size())) {
1383                  error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
1384                  return -1;
1385          }
1386
1387          if (change_channels || get_input_channels() == 0 || get_output_channels() == 0) {
1388                  if (backend->set_input_channels (get_input_channels())) {
1389                          error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
1390                          return -1;
1391                  }
1392                  if (backend->set_output_channels (get_output_channels())) {
1393                          error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
1394                          return -1;
1395                  }
1396          }
1397          if (change_latency) {
1398                  if (backend->set_systemic_input_latency (get_input_latency())) {
1399                          error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
1400                          return -1;
1401                  }
1402                  if (backend->set_systemic_output_latency (get_output_latency())) {
1403                          error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
1404                          return -1;
1405                  }
1406          }
1407
1408          if (change_midi) {
1409                  backend->set_midi_option (get_midi_option());
1410          }
1411
1412          if (start || (was_running && restart_required)) {
1413                  if (ARDOUR_UI::instance()->reconnect_to_engine()) {
1414                          return -1;
1415                  }
1416          }
1417
1418          post_push ();
1419
1420          return 0;
1421  }
1422
1423  void
1424  EngineControl::post_push ()
1425  {
1426          /* get a pointer to the current state object, creating one if
1427           * necessary
1428           */
1429
1430          if (_have_control) {
1431                  State* state = get_saved_state_for_currently_displayed_backend_and_device ();
1432
1433                  if (!state) {
1434                          state = save_state ();
1435                          assert (state);
1436                  }
1437
1438                  /* all off */
1439
1440                  for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
1441                          (*i).active = false;
1442                  }
1443
1444                  /* mark this one active (to be used next time the dialog is
1445                   * shown)
1446                   */
1447
1448                  state->active = true;
1449
1450                  manage_control_app_sensitivity ();
1451          }
1452
1453          /* schedule a redisplay of MIDI ports */
1454
1455          Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
1456  }
1457
1458
1459  float
1460  EngineControl::get_rate () const
1461  {
1462          float r = atof (sample_rate_combo.get_active_text ());
1463          /* the string may have been translated with an abbreviation for
1464           * thousands, so use a crude heuristic to fix this.
1465           */
1466          if (r < 1000.0) {
1467                  r *= 1000.0;
1468          }
1469          return r;
1470  }
1471
1472
1473  uint32_t
1474  EngineControl::get_buffer_size () const
1475  {
1476          string txt = buffer_size_combo.get_active_text ();
1477          uint32_t samples;
1478
1479          if (sscanf (txt.c_str(), "%d", &samples) != 1) {
1480                  throw exception ();
1481          }
1482
1483          return samples;
1484  }
1485
1486  string
1487  EngineControl::get_midi_option () const
1488  {
1489          return midi_option_combo.get_active_text();
1490  }
1491
1492  uint32_t
1493  EngineControl::get_input_channels() const
1494  {
1495          return (uint32_t) input_channels_adjustment.get_value();
1496  }
1497
1498  uint32_t
1499  EngineControl::get_output_channels() const
1500  {
1501          return (uint32_t) output_channels_adjustment.get_value();
1502  }
1503
1504  uint32_t
1505  EngineControl::get_input_latency() const
1506  {
1507          return (uint32_t) input_latency_adjustment.get_value();
1508  }
1509
1510  uint32_t
1511  EngineControl::get_output_latency() const
1512  {
1513          return (uint32_t) output_latency_adjustment.get_value();
1514  }
1515
1516  string
1517  EngineControl::get_backend () const
1518  {
1519          return backend_combo.get_active_text ();
1520  }
1521
1522  string
1523  EngineControl::get_driver () const
1524  {
1525          return driver_combo.get_active_text ();
1526  }
1527
1528  string
1529  EngineControl::get_device_name () const
1530  {
1531          return device_combo.get_active_text ();
1532  }
1533
1534  void
1535  EngineControl::control_app_button_clicked ()
1536  {
1537          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
1538
1539          if (!backend) {
1540                  return;
1541          }
1542
1543          backend->launch_control_app ();
1544  }
1545
1546  void
1547  EngineControl::manage_control_app_sensitivity ()
1548  {
1549          boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
1550
1551          if (!backend) {
1552                  return;
1553          }
1554
1555          string appname = backend->control_app_name();
1556
1557          if (appname.empty()) {
1558                  control_app_button.set_sensitive (false);
1559          } else {
1560                  control_app_button.set_sensitive (true);
1561          }
1562  }
1563
1564  void
1565  EngineControl::set_desired_sample_rate (uint32_t sr)
1566  {
1567          _desired_sample_rate = sr;
1568          device_changed ();
1569  }
1570
1571  void
1572  EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
1573  {
1574          if (page_num == 0) {
1575                  cancel_button->set_sensitive (true);
1576                  ok_button->set_sensitive (true);
1577                  apply_button->set_sensitive (true);
1578          } else {
1579                  cancel_button->set_sensitive (false);
1580                  ok_button->set_sensitive (false);
1581                  apply_button->set_sensitive (false);
1582          }
1583
1584          if (page_num == midi_tab) {
1585                  /* MIDI tab */
1586                  refresh_midi_display ();
1587          }
1588
1589          if (page_num == latency_tab) {
1590                  /* latency tab */
1591
1592                  if (!ARDOUR::AudioEngine::instance()->running()) {
1593
1594                          PBD::Unwinder<uint32_t> protect_ignore_changes (ignore_changes, ignore_changes + 1);
1595
1596                          /* save any existing latency values */
1597
1598                          uint32_t il = (uint32_t) input_latency.get_value ();
1599                          uint32_t ol = (uint32_t) input_latency.get_value ();
1600
1601                          /* reset to zero so that our new test instance of JACK
1602                             will be clean of any existing latency measures.
1603                          */
1604
1605                          input_latency.set_value (0);
1606                          output_latency.set_value (0);
1607
1608                          /* reset control */
1609
1610                          input_latency.set_value (il);
1611                          output_latency.set_value (ol);
1612
1613                  }
1614
1615                  if (ARDOUR::AudioEngine::instance()->prepare_for_latency_measurement()) {
1616                          disable_latency_tab ();
1617                  }
1618
1619                  enable_latency_tab ();
1620
1621          } else {
1622                  ARDOUR::AudioEngine::instance()->stop_latency_detection();
1623          }
1624  }
1625
1626  /* latency measurement */
1627
1628  bool
1629  EngineControl::check_latency_measurement ()
1630  {
1631          MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
1632
1633          if (mtdm->resolve () < 0) {
1634                  lm_results.set_markup (string_compose (results_markup, _("No signal detected ")));
1635                  return true;
1636          }
1637
1638          if (mtdm->err () > 0.3) {
1639                  mtdm->invert ();
1640                  mtdm->resolve ();
1641          }
1642
1643          char buf[128];
1644          ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
1645
1646          if (sample_rate == 0) {
1647                  lm_results.set_markup (string_compose (results_markup, _("Disconnected from audio engine")));
1648                  ARDOUR::AudioEngine::instance()->stop_latency_detection ();
1649                  return false;
1650          }
1651
1652          uint32_t frames_total = mtdm->del();
1653          uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
1654
1655          snprintf (buf, sizeof (buf), "%u samples / %.3lf ms", extra, extra * 1000.0f/sample_rate);
1656
1657          bool solid = true;
1658
1659          if (mtdm->err () > 0.2) {
1660                  strcat (buf, " ");
1661                  strcat (buf, _("(signal detection error)"));
1662                  solid = false;
1663          }
1664
1665          if (mtdm->inv ()) {
1666                  strcat (buf, " ");
1667                  strcat (buf, _("(inverted - bad wiring)"));
1668                  solid = false;
1669          }
1670
1671          if (solid) {
1672                  end_latency_detection ();
1673                  lm_use_button.set_sensitive (true);
1674                  have_lm_results = true;
1675         }
1676
1677         lm_results.set_markup (string_compose (results_markup, string_compose (_("Detected roundtrip latency: %1"), buf)));
1678
1679         return true;
1680 }
1681
1682 void
1683 EngineControl::start_latency_detection ()
1684 {
1685         ARDOUR::AudioEngine::instance()->set_latency_input_port (lm_input_channel_combo.get_active_text());
1686         ARDOUR::AudioEngine::instance()->set_latency_output_port (lm_output_channel_combo.get_active_text());
1687
1688         if (ARDOUR::AudioEngine::instance()->start_latency_detection () == 0) {
1689                 lm_results.set_markup (string_compose (results_markup, _("Detecting ...")));
1690                 latency_timeout = Glib::signal_timeout().connect (mem_fun (*this, &EngineControl::check_latency_measurement), 100);
1691                 lm_measure_button.set_label (_("Cancel"));
1692                 have_lm_results = false;
1693                 lm_use_button.set_sensitive (false);
1694                 lm_input_channel_combo.set_sensitive (false);
1695                 lm_output_channel_combo.set_sensitive (false);
1696                 lm_running = true;
1697         }
1698 }
1699
1700 void
1701 EngineControl::end_latency_detection ()
1702 {
1703         latency_timeout.disconnect ();
1704         ARDOUR::AudioEngine::instance()->stop_latency_detection ();
1705         lm_measure_button.set_label (_("Measure"));
1706         if (!have_lm_results) {
1707                 lm_results.set_markup (string_compose (results_markup, _("No measurement results yet")));
1708         } else {
1709                 lm_use_button.set_sensitive (false);
1710         }
1711         lm_input_channel_combo.set_sensitive (true);
1712         lm_output_channel_combo.set_sensitive (true);
1713         lm_running = false;
1714 }
1715
1716 void
1717 EngineControl::latency_button_clicked ()
1718 {
1719         if (!lm_running) {
1720                 start_latency_detection ();
1721         } else {
1722                 end_latency_detection ();
1723         }
1724 }
1725
1726 void
1727 EngineControl::use_latency_button_clicked ()
1728 {
1729         MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
1730
1731         if (!mtdm) {
1732                 return;
1733         }
1734
1735         uint32_t frames_total = mtdm->del();
1736         uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
1737         uint32_t one_way = extra/2;
1738
1739         input_latency_adjustment.set_value (one_way);
1740         output_latency_adjustment.set_value (one_way);
1741
1742         /* back to settings page */
1743
1744         notebook.set_current_page (0);
1745 }
1746
1747 bool
1748 EngineControl::on_delete_event (GdkEventAny* ev)
1749 {
1750         if (notebook.get_current_page() == 2) {
1751                 /* currently on latency tab - be sure to clean up */
1752                 end_latency_detection ();
1753         }
1754         return ArdourDialog::on_delete_event (ev);
1755 }
1756
1757 void
1758 EngineControl::engine_running ()
1759 {
1760         boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
1761         assert (backend);
1762
1763         buffer_size_combo.set_active_text (bufsize_as_string (backend->buffer_size()));
1764         sample_rate_combo.set_active_text (rate_as_string (backend->sample_rate()));
1765
1766         buffer_size_combo.set_sensitive (true);
1767         sample_rate_combo.set_sensitive (true);
1768
1769         connect_disconnect_button.set_label (string_compose (_("Disconnect from %1"), backend->name()));
1770
1771         started_at_least_once = true;
1772 }
1773
1774 void
1775 EngineControl::engine_stopped ()
1776 {
1777         boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
1778         assert (backend);
1779
1780         buffer_size_combo.set_sensitive (false);
1781         connect_disconnect_button.set_label (string_compose (_("Connect to %1"), backend->name()));
1782
1783         sample_rate_combo.set_sensitive (true);
1784         buffer_size_combo.set_sensitive (true);
1785 }
1786
1787 void
1788 EngineControl::connect_disconnect_click()
1789 {
1790         if (ARDOUR::AudioEngine::instance()->running()) {
1791                 ARDOUR_UI::instance()->disconnect_from_engine ();
1792         } else {
1793                 ARDOUR_UI::instance()->reconnect_to_engine ();
1794         }
1795 }