allanger/ardour
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Activity

Merge branch 'windows' of git.ardour.org:ardour/ardour into windows

Browse Source
This commit is contained in:
John Emmas
2013-09-18 10:16:40 +01:00
parent dc3288565b 302b08c059
commit e5c426ed41
19 changed files with 811 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
gtk2_ardour/ardour.menus.in
View File

@@ -494,21 +494,6 @@
<menuitem action='ToggleGroupTabs'/>
<menuitem action='show-marker-lines'/>
</menu>
<menu name='JACK' action='JACK'>
<menuitem action='EngineDisconnect'/>
<menuitem action='EngineReconnect'/>
<menu name='Latency' action='Latency'>
<menuitem action='EngineLatency32'/>
<menuitem action='EngineLatency64'/>
<menuitem action='EngineLatency128'/>
<menuitem action='EngineLatency256'/>
<menuitem action='EngineLatency512'/>
<menuitem action='EngineLatency1024'/>
<menuitem action='EngineLatency2048'/>
<menuitem action='EngineLatency4096'/>
<menuitem action='EngineLatency8192'/>
</menu>
</menu>
<menu action = 'WindowMenu'>
<menuitem action='toggle-audio-midi-setup'/>
<separator/>

16
gtk2_ardour/ardour_ui.cc
View File

@@ -3798,7 +3798,7 @@ audio may be played at the wrong sample rate.\n"), desired, PROGRAM_NAME, actual
return 1;
}
void
int
ARDOUR_UI::disconnect_from_engine ()
{
/* drop connection to AudioEngine::Halted so that we don't act
@@ -3807,24 +3807,28 @@ ARDOUR_UI::disconnect_from_engine ()
halt_connection.disconnect ();
if (AudioEngine::instance()->stop ()) {
MessageDialog msg (*editor, _("Could not disconnect from JACK"));
MessageDialog msg (*editor, _("Could not disconnect from Audio/MIDI engine"));
msg.run ();
return -1;
} else {
AudioEngine::instance()->Halted.connect_same_thread (halt_connection, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
}
update_sample_rate (0);
return 0;
}
void
int
ARDOUR_UI::reconnect_to_engine ()
{
if (AudioEngine::instance()->start ()) {
MessageDialog msg (*editor, _("Could not reconnect to JACK"));
MessageDialog msg (*editor, _("Could not reconnect to the Audio/MIDI engine"));
msg.run ();
return -1;
}
update_sample_rate (0);
return 0;
}
void
@@ -4166,9 +4170,7 @@ ARDOUR_UI::do_audio_midi_setup (uint32_t desired_sample_rate)
_audio_midi_setup->set_desired_sample_rate (desired_sample_rate);
int r = _audio_midi_setup->run ();
switch (r) {
switch (_audio_midi_setup->run()) {
case Gtk::RESPONSE_OK:
return 0;
case Gtk::RESPONSE_APPLY:

5
gtk2_ardour/ardour_ui.h
View File

@@ -289,6 +289,9 @@ class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
const std::string& announce_string() const { return _announce_string; }
int disconnect_from_engine ();
int reconnect_to_engine ();
protected:
friend class PublicEditor;
@@ -667,8 +670,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
int pending_state_dialog ();
int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
void disconnect_from_engine ();
void reconnect_to_engine ();
void set_engine_buffer_size (ARDOUR::pframes_t);
Gtk::MenuItem* jack_disconnect_item;

34
gtk2_ardour/ardour_ui_ed.cc
View File

@@ -183,39 +183,6 @@ ARDOUR_UI::install_actions ()
ActionManager::write_sensitive_actions.push_back (act);
ActionManager::session_sensitive_actions.push_back (act);
/* AudioEngine actions */
Glib::RefPtr<ActionGroup> engine_actions = ActionGroup::create (X_("Audio"));
ActionManager::register_action (engine_actions, X_("JACK"), _("JACK"));
ActionManager::register_action (engine_actions, X_("Latency"), _("Latency"));
act = ActionManager::register_action (engine_actions, X_("EngineReconnect"), _("Reconnect"), sigc::mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_engine));
ActionManager::engine_opposite_sensitive_actions.push_back (act);
act = ActionManager::register_action (engine_actions, X_("EngineDisconnect"), _("Disconnect"), sigc::mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_engine));
ActionManager::engine_sensitive_actions.push_back (act);
RadioAction::Group latency_group;
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency32"), X_("32"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 32));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency64"), X_("64"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 64));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency128"), X_("128"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 128));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency256"), X_("256"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 256));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency512"), X_("512"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 512));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency1024"), X_("1024"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 1024));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency2048"), X_("2048"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 2048));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency4096"), X_("4096"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 4096));
ActionManager::engine_sensitive_actions.push_back (act);
act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency8192"), X_("8192"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 8192));
ActionManager::engine_sensitive_actions.push_back (act);
/* these actions are intended to be shared across all windows */
common_actions = ActionGroup::create (X_("Common"));
@@ -422,7 +389,6 @@ ARDOUR_UI::install_actions ()
ActionManager::add_action_group (shuttle_actions);
ActionManager::add_action_group (option_actions);
ActionManager::add_action_group (engine_actions);
ActionManager::add_action_group (transport_actions);
ActionManager::add_action_group (main_actions);
ActionManager::add_action_group (main_menu_actions);

4
gtk2_ardour/editor.cc
View File

@@ -365,6 +365,7 @@ Editor::Editor ()
location_loop_color = ARDOUR_UI::config()->canvasvar_LocationLoop.get();
location_punch_color = ARDOUR_UI::config()->canvasvar_LocationPunch.get();
zoom_focus = ZoomFocusLeft;
_edit_point = EditAtMouse;
_internal_editing = false;
current_canvas_cursor = 0;
@@ -373,8 +374,6 @@ Editor::Editor ()
_scroll_callbacks = 0;
zoom_focus = ZoomFocusLeft;
set_zoom_focus (ZoomFocusLeft);
zoom_range_clock->ValueChanged.connect (sigc::mem_fun(*this, &Editor::zoom_adjustment_changed));
bbt_label.set_name ("EditorRulerLabel");
@@ -635,6 +634,7 @@ Editor::Editor ()
setup_toolbar ();
set_zoom_focus (zoom_focus);
_snap_type = SnapToBeat;
set_snap_to (_snap_type);
_snap_mode = SnapOff;

654
gtk2_ardour/engine_dialog.cc
View File

@@ -31,6 +31,7 @@
#include "pbd/xml++.h"
#include "pbd/unwind.h"
#include <gtkmm/alignment.h>
#include <gtkmm/stock.h>
#include <gtkmm/notebook.h>
#include <gtkmm2ext/utils.h>
@@ -44,6 +45,7 @@
#include "pbd/convert.h"
#include "pbd/error.h"
#include "ardour_ui.h"
#include "engine_dialog.h"
#include "gui_thread.h"
#include "i18n.h"
@@ -56,6 +58,7 @@ using namespace Glib;
EngineControl::EngineControl ()
: ArdourDialog (_("Audio/MIDI Setup"))
, basic_packer (9, 3)
, input_latency_adjustment (0, 0, 99999, 1)
, input_latency (input_latency_adjustment)
, output_latency_adjustment (0, 0, 99999, 1)
@@ -66,14 +69,24 @@ EngineControl::EngineControl ()
, output_channels (output_channels_adjustment)
, ports_adjustment (128, 8, 1024, 1, 16)
, ports_spinner (ports_adjustment)
, control_app_button (_("Launch Control App"))
, lm_measure_button (_("Measure latency"))
, control_app_button (_("Device Control Panel"))
, lm_start_stop_label (_("Measure latency"))
, lm_use_button (_("Use results"))
, lm_table (5, 2)
, basic_packer (9, 3)
, have_lm_results (false)
, midi_refresh_button (_("Refresh list"))
, aj_button (_("Start MIDI ALSA/JACK bridge"))
, ignore_changes (0)
, _desired_sample_rate (0)
{
if (!ARDOUR::AudioEngine::instance()->setup_required()) {
_have_control = false;
} else {
_have_control = true;
}
set_name (X_("AudioMIDISetup"));
build_notebook ();
get_vbox()->set_border_width (12);
@@ -82,9 +95,9 @@ EngineControl::EngineControl ()
control_app_button.signal_clicked().connect (mem_fun (*this, &EngineControl::control_app_button_clicked));
manage_control_app_sensitivity ();
add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
add_button (Gtk::Stock::APPLY, Gtk::RESPONSE_APPLY);
cancel_button = add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
ok_button = add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
apply_button = add_button (Gtk::Stock::APPLY, Gtk::RESPONSE_APPLY);
/* Pick up any existing audio setup configuration, if appropriate */
@@ -111,6 +124,13 @@ EngineControl::on_response (int response_id)
push_state_to_backend (true);
hide ();
break;
case RESPONSE_DELETE_EVENT: {
GdkEventButton ev;
ev.type = GDK_BUTTON_PRESS;
ev.button = 1;
on_delete_event ((GdkEventAny*) &ev);
break;
}
default:
hide ();
}
@@ -168,18 +188,33 @@ EngineControl::build_notebook ()
basic_packer.attach (buffer_size_duration_label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
row++;
input_channels.set_name ("InputChannels");
input_channels.set_flags(Gtk::CAN_FOCUS);
input_channels.set_digits(0);
input_channels.set_wrap(false);
output_channels.set_editable (true);
label = manage (left_aligned_label (_("Input Channels:")));
basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
basic_packer.attach (input_channels, 1, 2, row, row+1, xopt, (AttachOptions) 0);
++row;
output_channels.set_name ("OutputChannels");
output_channels.set_flags(Gtk::CAN_FOCUS);
output_channels.set_digits(0);
output_channels.set_wrap(false);
output_channels.set_editable (true);
label = manage (left_aligned_label (_("Output Channels:")));
basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
basic_packer.attach (output_channels, 1, 2, row, row+1, xopt, (AttachOptions) 0);
++row;
input_latency.set_name ("InputLatency");
input_latency.set_flags(Gtk::CAN_FOCUS);
input_latency.set_digits(0);
input_latency.set_wrap(false);
input_latency.set_editable (true);
label = manage (left_aligned_label (_("Hardware input latency:")));
basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
@@ -188,6 +223,12 @@ EngineControl::build_notebook ()
basic_packer.attach (*label, 2, 3, row, row+1, xopt, (AttachOptions) 0);
++row;
output_latency.set_name ("OutputLatency");
output_latency.set_flags(Gtk::CAN_FOCUS);
output_latency.set_digits(0);
output_latency.set_wrap(false);
output_latency.set_editable (true);
label = manage (left_aligned_label (_("Hardware output latency:")));
basic_packer.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
basic_packer.attach (output_latency, 1, 2, row, row+1, xopt, (AttachOptions) 0);
@@ -205,8 +246,6 @@ EngineControl::build_notebook ()
control_app_button.show();
basic_vbox.pack_start (*hpacker);
midi_packer.set_border_width (12);
/* latency measurement tab */
lm_title.set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("Latency Measurement Tool")));
@@ -217,48 +256,81 @@ EngineControl::build_notebook ()
lm_table.attach (lm_title, 0, 2, row, row+1, xopt, (AttachOptions) 0);
row++;
lm_preamble.set_width_chars (60);
lm_preamble.set_line_wrap (true);
lm_preamble.set_markup (_("1. <span weight=\"bold\">Turn down the volume on your hardware to a very low level.</span>\n\n\
2. Connect the two channels that you select below using either a cable or (less ideally) a speaker \
and microphone.\n\n\
3. Once the channels are connected, click the \"Measure latency\" button.\n\n\
4. When satisfied with the results, click the \"Use results\" button."));
Gtk::Label* preamble;
lm_table.attach (lm_preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
preamble = manage (new Label);
preamble->set_width_chars (60);
preamble->set_line_wrap (true);
preamble->set_markup (_("<span weight=\"bold\">Turn down the volume on your hardware to a very low level.</span>"));
lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
row++;
preamble = manage (new Label);
preamble->set_width_chars (60);
preamble->set_line_wrap (true);
preamble->set_markup (_("Select two channels below and connect them using a cable or (less ideally) a speaker and microphone."));
lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
row++;
label = manage (new Label (_("Output channel")));
lm_table.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
lm_table.attach (lm_output_channel_combo, 1, 2, row, row+1, xopt, (AttachOptions) 0);
Gtk::Alignment* misc_align = manage (new Alignment (0.0, 0.5));
misc_align->add (lm_output_channel_combo);
lm_table.attach (*misc_align, 1, 2, row, row+1, xopt, (AttachOptions) 0);
++row;
label = manage (new Label (_("Input channel")));
lm_table.attach (*label, 0, 1, row, row+1, xopt, (AttachOptions) 0);
lm_table.attach (lm_input_channel_combo, 1, 2, row, row+1, xopt, (AttachOptions) 0);
misc_align = manage (new Alignment (0.0, 0.5));
misc_align->add (lm_input_channel_combo);
lm_table.attach (*misc_align, 1, 2, row, row+1, FILL, (AttachOptions) 0);
++row;
xopt = AttachOptions(0);
lm_measure_button.add (lm_start_stop_label);
lm_measure_button.signal_toggled().connect (sigc::mem_fun (*this, &EngineControl::latency_button_toggled));
lm_use_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::use_latency_button_clicked));
lm_use_button.set_sensitive (false);
preamble = manage (new Label);
preamble->set_width_chars (60);
preamble->set_line_wrap (true);
preamble->set_markup (_("Once the channels are connected, click the \"Measure latency\" button."));
lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
row++;
lm_table.attach (lm_measure_button, 0, 2, row, row+1, xopt, (AttachOptions) 0);
++row;
lm_table.attach (lm_results, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
++row;
preamble = manage (new Label);
preamble->set_width_chars (60);
preamble->set_line_wrap (true);
preamble->set_markup (_("When satisfied with the results, click the \"Use results\" button."));
lm_table.attach (*preamble, 0, 2, row, row+1, AttachOptions(FILL|EXPAND), (AttachOptions) 0);
row++;
lm_table.attach (lm_use_button, 0, 2, row, row+1, xopt, (AttachOptions) 0);
++row;
lm_results.set_markup ("<i>No measurement results yet</i>");
lm_vbox.set_border_width (12);
lm_vbox.pack_start (lm_table, false, false);
/* pack it all up */
notebook.pages().push_back (TabElem (basic_vbox, _("Audio")));
notebook.pages().push_back (TabElem (midi_hbox, _("MIDI")));
notebook.pages().push_back (TabElem (midi_vbox, _("MIDI")));
notebook.pages().push_back (TabElem (lm_vbox, _("Latency")));
notebook.set_border_width (12);
@@ -280,7 +352,6 @@ and microphone.\n\n\
input_channels.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
output_channels.signal_changed().connect (sigc::mem_fun (*this, &EngineControl::parameter_changed));
input_channels.signal_output().connect (sigc::bind (sigc::ptr_fun (&EngineControl::print_channel_count), &input_channels));
output_channels.signal_output().connect (sigc::bind (sigc::ptr_fun (&EngineControl::print_channel_count), &output_channels));
@@ -316,7 +387,87 @@ EngineControl::enable_latency_tab ()
lm_input_channel_combo.set_active_text (inputs.front());
lm_measure_button.set_sensitive (true);
lm_use_button.set_sensitive (true);
}
void
EngineControl::setup_midi_tab_for_backend ()
{
string backend = backend_combo.get_active_text ();
Gtkmm2ext::container_clear (midi_vbox);
midi_vbox.set_border_width (12);
midi_device_table.set_border_width (12);
if (backend == "JACK") {
setup_midi_tab_for_jack ();
}
midi_vbox.pack_start (midi_device_table, true, true);
midi_vbox.pack_start (midi_refresh_button, false, false);
midi_vbox.show_all ();
midi_refresh_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::refresh_midi_display));
}
void
EngineControl::setup_midi_tab_for_jack ()
{
midi_vbox.pack_start (aj_button, false, false);
}
void
EngineControl::refresh_midi_display ()
{
boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
assert (backend);
vector<string> midi_inputs;
vector<string> midi_outputs;
int row = 0;
AttachOptions xopt = AttachOptions (FILL|EXPAND);
Gtk::Label* l;
Gtkmm2ext::container_clear (midi_device_table);
backend->get_physical_inputs (ARDOUR::DataType::MIDI, midi_inputs);
backend->get_physical_outputs (ARDOUR::DataType::MIDI, midi_outputs);
midi_device_table.set_spacings (6);
midi_device_table.set_homogeneous (true);
midi_device_table.resize (midi_inputs.size() + midi_outputs.size() + 3, 1);
l = manage (new Label);
l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Inputs")));
midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
l->set_alignment (0, 0.5);
row++;
l->show ();
for (vector<string>::iterator p = midi_inputs.begin(); p != midi_inputs.end(); ++p) {
l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
l->set_alignment (0, 0.5);
midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
l->show ();
row++;
}
row++; // extra row of spacing
l = manage (new Label);
l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Outputs")));
midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
l->set_alignment (0, 0.5);
row++;
l->show ();
for (vector<string>::iterator p = midi_outputs.begin(); p != midi_outputs.end(); ++p) {
l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
l->set_alignment (0, 0.5);
midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
l->show ();
row++;
}
}
void
@@ -334,6 +485,8 @@ EngineControl::backend_changed ()
return;
}
setup_midi_tab_for_backend ();
if (backend->requires_driver_selection()) {
vector<string> drivers = backend->enumerate_drivers();
driver_combo.set_sensitive (true);
@@ -387,8 +540,10 @@ EngineControl::list_devices ()
available_devices.push_back (i->name);
}
ignore_changes++;
set_popdown_strings (device_combo, available_devices);
ignore_changes--;
if (!available_devices.empty()) {
sample_rate_combo.set_sensitive (true);
buffer_size_combo.set_sensitive (true);
@@ -452,39 +607,42 @@ EngineControl::device_changed ()
vector<float> sr = backend->available_sample_rates (device_name);
for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
char buf[32];
if (fmod (*x, 1000.0f)) {
snprintf (buf, sizeof (buf), "%.1f kHz", (*x)/1000.0);
} else {
snprintf (buf, sizeof (buf), "%.0f kHz", (*x)/1000.0);
}
s.push_back (buf);
s.push_back (rate_as_string (*x));
if (*x == _desired_sample_rate) {
desired = buf;
desired = s.back();
}
}
set_popdown_strings (sample_rate_combo, s);
if (desired.empty()) {
sample_rate_combo.set_active_text (s.front());
if (!s.empty()) {
set_popdown_strings (sample_rate_combo, s);
if (desired.empty()) {
sample_rate_combo.set_active_text (s.front());
} else {
sample_rate_combo.set_active_text (desired);
}
} else {
sample_rate_combo.set_active_text (desired);
/* hmm ... how to tell the user about the fact that we have no
* available sample rates.
*/
}
vector<uint32_t> bs = backend->available_buffer_sizes(device_name);
s.clear ();
for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
char buf[32];
/* Translators: "samples" is always plural here, so no
need for plural+singular forms.
*/
snprintf (buf, sizeof (buf), _("%u samples"), *x);
s.push_back (buf);
s.push_back (bufsize_as_string (*x));
}
set_popdown_strings (buffer_size_combo, s);
buffer_size_combo.set_active_text (s.front());
show_buffer_duration ();
if (!s.empty()) {
set_popdown_strings (buffer_size_combo, s);
buffer_size_combo.set_active_text (s.front());
show_buffer_duration ();
} else {
/* hmm ... how to tell the user about the fact that we have no
* available buffer sizes.
*/
}
manage_control_app_sensitivity ();
@@ -499,6 +657,29 @@ EngineControl::device_changed ()
push_state_to_backend (false);
}
string
EngineControl::rate_as_string (float r)
{
char buf[32];
if (fmod (r, 1000.0f)) {
snprintf (buf, sizeof (buf), "%.1f kHz", r/1000.0);
} else {
snprintf (buf, sizeof (buf), "%.0f kHz", r/1000.0);
}
return buf;
}
string
EngineControl::bufsize_as_string (uint32_t sz)
{
/* Translators: "samples" is always plural here, so no
need for plural+singular forms.
*/
char buf[32];
snprintf (buf, sizeof (buf), _("%u samples"), sz);
return buf;
}
void
EngineControl::sample_rate_changed ()
{
@@ -511,7 +692,6 @@ EngineControl::sample_rate_changed ()
*/
show_buffer_duration ();
push_state_to_backend (false);
save_state ();
}
@@ -524,7 +704,6 @@ EngineControl::buffer_size_changed ()
}
show_buffer_duration ();
push_state_to_backend (false);
save_state ();
}
@@ -603,15 +782,7 @@ EngineControl::save_state ()
state = new State;
}
state->backend = backend_combo.get_active_text ();
state->driver = driver_combo.get_active_text ();
state->device = device_combo.get_active_text ();
state->buffer_size = buffer_size_combo.get_active_text ();
state->sample_rate = sample_rate_combo.get_active_text ();
state->input_latency = (uint32_t) input_latency.get_value();
state->output_latency = (uint32_t) output_latency.get_value();
state->input_channels = (uint32_t) input_channels.get_value();
state->output_channels = (uint32_t) output_channels.get_value();
store_state (*state);
if (!existing) {
states.push_back (*state);
@@ -620,6 +791,20 @@ EngineControl::save_state ()
return state;
}
void
EngineControl::store_state (State& state)
{
state.backend = get_backend ();
state.driver = get_driver ();
state.device = get_device_name ();
state.sample_rate = get_rate ();
state.buffer_size = get_buffer_size ();
state.input_latency = get_input_latency ();
state.output_latency = get_output_latency ();
state.input_channels = get_input_channels ();
state.output_channels = get_output_channels ();
}
void
EngineControl::maybe_display_saved_state ()
{
@@ -628,9 +813,13 @@ EngineControl::maybe_display_saved_state ()
if (state) {
ignore_changes++;
if (!_desired_sample_rate) {
sample_rate_combo.set_active_text (state->sample_rate);
sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
}
buffer_size_combo.set_active_text (state->buffer_size);
buffer_size_combo.set_active_text (bufsize_as_string (state->buffer_size));
/* call this explicitly because we're ignoring changes to
the controls at this point.
*/
show_buffer_duration ();
input_latency.set_value (state->input_latency);
output_latency.set_value (state->output_latency);
ignore_changes--;
@@ -724,12 +913,12 @@ EngineControl::set_state (const XMLNode& root)
if ((prop = grandchild->property ("sample-rate")) == 0) {
continue;
}
state.sample_rate = prop->value ();
state.sample_rate = atof (prop->value ());
if ((prop = grandchild->property ("buffer-size")) == 0) {
continue;
}
state.buffer_size = prop->value ();
state.buffer_size = atoi (prop->value ());
if ((prop = grandchild->property ("input-latency")) == 0) {
continue;
@@ -768,13 +957,11 @@ EngineControl::set_state (const XMLNode& root)
backend_combo.set_active_text ((*i).backend);
driver_combo.set_active_text ((*i).driver);
device_combo.set_active_text ((*i).device);
sample_rate_combo.set_active_text ((*i).sample_rate);
buffer_size_combo.set_active_text ((*i).buffer_size);
sample_rate_combo.set_active_text (rate_as_string ((*i).sample_rate));
buffer_size_combo.set_active_text (bufsize_as_string ((*i).buffer_size));
input_latency.set_value ((*i).input_latency);
output_latency.set_value ((*i).output_latency);
ignore_changes--;
push_state_to_backend (false);
break;
}
}
@@ -788,29 +975,168 @@ EngineControl::push_state_to_backend (bool start)
if (!backend) {
return 0;
}
}
/* figure out what is going to change */
/* grab the parameters from the GUI and apply them */
bool restart_required = false;
bool was_running = ARDOUR::AudioEngine::instance()->running();
bool change_driver = false;
bool change_device = false;
bool change_rate = false;
bool change_bufsize = false;
bool change_latency = false;
bool change_channels = false;
uint32_t ochan = get_output_channels ();
uint32_t ichan = get_input_channels ();
if (_have_control) {
/* we can control the backend */
try {
if (backend->requires_driver_selection()) {
if (backend->set_driver (get_driver())) {
return -1;
if (get_driver() != backend->driver_name()) {
change_driver = true;
}
}
if (backend->set_device_name (get_device_name())) {
return -1;
if (get_device_name() != backend->device_name()) {
change_device = true;
}
if (backend->set_sample_rate (get_rate())) {
error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
return -1;
if (get_rate() != backend->sample_rate()) {
change_rate = true;
}
if (backend->set_buffer_size (get_buffer_size())) {
error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
return -1;
if (get_buffer_size() != backend->buffer_size()) {
change_bufsize = true;
}
/* zero-requested channels means "all available" */
if (ichan == 0) {
ichan = backend->input_channels();
}
if (ochan == 0) {
ochan = backend->output_channels();
}
if (ichan != backend->input_channels()) {
change_channels = true;
}
if (ochan != backend->output_channels()) {
change_channels = true;
}
if (get_input_latency() != backend->systemic_input_latency() ||
get_output_latency() != backend->systemic_output_latency()) {
change_latency = true;
}
} else {
/* we have no control over the backend, meaning that we can
* only possibly change sample rate and buffer size.
*/
if (get_rate() != backend->sample_rate()) {
change_bufsize = true;
}
if (get_buffer_size() != backend->buffer_size()) {
change_bufsize = true;
}
}
if (!_have_control) {
/* We do not have control over the backend, so the best we can
* do is try to change the sample rate and/or bufsize and get
* out of here.
*/
if (change_rate && !backend->can_change_sample_rate_when_running()) {
return 1;
}
if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
return 1;
}
if (change_rate) {
backend->set_sample_rate (get_rate());
}
if (change_bufsize) {
backend->set_buffer_size (get_buffer_size());
}
post_push ();
return 0;
}
/* determine if we need to stop the backend before changing parameters */
if (change_driver || change_device || change_channels || change_latency ||
(change_rate && !backend->can_change_sample_rate_when_running()) ||
(change_bufsize && !backend->can_change_buffer_size_when_running())) {
restart_required = true;
} else {
restart_required = false;
}
if (was_running) {
if (!change_driver && !change_device && !change_channels && !change_latency) {
/* no changes in any parameters that absolutely require a
* restart, so check those that might be changeable without a
* restart
*/
if (change_rate && !backend->can_change_sample_rate_when_running()) {
/* can't do this while running ... */
restart_required = true;
}
if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
/* can't do this while running ... */
restart_required = true;
}
}
}
if (was_running) {
if (restart_required) {
if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
return -1;
}
}
}
if (change_driver && backend->set_driver (get_driver())) {
error << string_compose (_("Cannot set driver to %1"), get_driver()) << endmsg;
return -1;
}
if (change_device && backend->set_device_name (get_device_name())) {
error << string_compose (_("Cannot set device name to %1"), get_device_name()) << endmsg;
return -1;
}
if (change_rate && backend->set_sample_rate (get_rate())) {
error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
return -1;
}
if (change_bufsize && backend->set_buffer_size (get_buffer_size())) {
error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
return -1;
}
if (change_channels || get_input_channels() == 0 || get_output_channels() == 0) {
if (backend->set_input_channels (get_input_channels())) {
error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
return -1;
@@ -819,6 +1145,8 @@ EngineControl::push_state_to_backend (bool start)
error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
return -1;
}
}
if (change_latency) {
if (backend->set_systemic_input_latency (get_input_latency())) {
error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
return -1;
@@ -827,57 +1155,66 @@ EngineControl::push_state_to_backend (bool start)
error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
return -1;
}
/* get a pointer to the current state object, creating one if
* necessary
*/
State* state = get_saved_state_for_currently_displayed_backend_and_device ();
if (!state) {
state = save_state ();
assert (state);
}
/* all off */
for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
(*i).active = false;
}
/* mark this one active (to be used next time the dialog is
* shown)
*/
state->active = true;
if (start) {
if (ARDOUR::AudioEngine::instance()->start()) {
return -1;
}
}
manage_control_app_sensitivity ();
return 0;
} catch (...) {
cerr << "exception thrown...\n";
return -1;
}
if (start || (was_running && restart_required)) {
if (ARDOUR_UI::instance()->reconnect_to_engine()) {
return -1;
}
}
post_push ();
return 0;
}
uint32_t
void
EngineControl::post_push ()
{
/* get a pointer to the current state object, creating one if
* necessary
*/
State* state = get_saved_state_for_currently_displayed_backend_and_device ();
if (!state) {
state = save_state ();
assert (state);
}
/* all off */
for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
(*i).active = false;
}
/* mark this one active (to be used next time the dialog is
* shown)
*/
state->active = true;
manage_control_app_sensitivity ();
/* schedule a redisplay of MIDI ports */
Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
}
float
EngineControl::get_rate () const
{
double r = atof (sample_rate_combo.get_active_text ());
float r = atof (sample_rate_combo.get_active_text ());
/* the string may have been translated with an abbreviation for
* thousands, so use a crude heuristic to fix this.
*/
if (r < 1000.0) {
r *= 1000.0;
}
return lrint (r);
return r;
}
uint32_t
EngineControl::get_buffer_size () const
@@ -916,6 +1253,12 @@ EngineControl::get_output_latency() const
return (uint32_t) output_latency_adjustment.get_value();
}
string
EngineControl::get_backend () const
{
return backend_combo.get_active_text ();
}
string
EngineControl::get_driver () const
{
@@ -968,6 +1311,21 @@ EngineControl::set_desired_sample_rate (uint32_t sr)
void
EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
{
if (page_num == 0) {
cancel_button->set_sensitive (true);
ok_button->set_sensitive (true);
apply_button->set_sensitive (true);
} else {
cancel_button->set_sensitive (false);
ok_button->set_sensitive (false);
apply_button->set_sensitive (false);
}
if (page_num == 1) {
/* MIDI tab */
refresh_midi_display ();
}
if (page_num == 2) {
/* latency tab */
@@ -987,18 +1345,19 @@ EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
input_latency.set_value (0);
output_latency.set_value (0);
push_state_to_backend (false);
/* reset control */
input_latency.set_value (il);
output_latency.set_value (ol);
}
}
if (ARDOUR::AudioEngine::instance()->prepare_for_latency_measurement()) {
disable_latency_tab ();
}
enable_latency_tab ();
} else {
ARDOUR::AudioEngine::instance()->stop_latency_detection();
}
@@ -1010,15 +1369,9 @@ bool
EngineControl::check_latency_measurement ()
{
MTDM* mtdm = ARDOUR::AudioEngine::instance()->mtdm ();
static uint32_t cnt = 0;
if (mtdm->resolve () < 0) {
string txt = _("No signal detected ");
uint32_t dots = cnt++%10;
for (uint32_t i = 0; i < dots; ++i) {
txt += '.';
}
lm_results.set_text (txt);
lm_results.set_markup (string_compose ("<span foreground=\"red\">%1</span>", _("No signal detected ")));
return true;
}
@@ -1037,7 +1390,6 @@ EngineControl::check_latency_measurement ()
}
uint32_t frames_total = mtdm->del();
cerr << "total = " << frames_total << " delay = " << ARDOUR::AudioEngine::instance()->latency_signal_delay() << endl;
uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
snprintf (buf, sizeof (buf), "%u samples %10.3lf ms", extra, extra * 1000.0f/sample_rate);
@@ -1058,6 +1410,7 @@ EngineControl::check_latency_measurement ()
lm_measure_button.set_active (false);
lm_use_button.set_sensitive (true);
strcat (buf, " (set)");
have_lm_results = true;
}
lm_results.set_text (buf);
@@ -1065,20 +1418,40 @@ EngineControl::check_latency_measurement ()
return true;
}
void
EngineControl::start_latency_detection ()
{
ARDOUR::AudioEngine::instance()->set_latency_input_port (lm_input_channel_combo.get_active_text());
ARDOUR::AudioEngine::instance()->set_latency_output_port (lm_output_channel_combo.get_active_text());
ARDOUR::AudioEngine::instance()->start_latency_detection ();
lm_results.set_text (_("Detecting ..."));
latency_timeout = Glib::signal_timeout().connect (mem_fun (*this, &EngineControl::check_latency_measurement), 250);
lm_start_stop_label.set_text (_("Cancel measurement"));
have_lm_results = false;
lm_input_channel_combo.set_sensitive (false);
lm_output_channel_combo.set_sensitive (false);
}
void
EngineControl::end_latency_detection ()
{
ARDOUR::AudioEngine::instance()->stop_latency_detection ();
latency_timeout.disconnect ();
lm_start_stop_label.set_text (_("Measure latency"));
if (!have_lm_results) {
lm_results.set_markup ("<i>No measurement results yet</i>");
}
lm_input_channel_combo.set_sensitive (true);
lm_output_channel_combo.set_sensitive (true);
}
void
EngineControl::latency_button_toggled ()
{
if (lm_measure_button.get_active ()) {
ARDOUR::AudioEngine::instance()->set_latency_input_port (lm_input_channel_combo.get_active_text());
ARDOUR::AudioEngine::instance()->set_latency_output_port (lm_output_channel_combo.get_active_text());
ARDOUR::AudioEngine::instance()->start_latency_detection ();
lm_results.set_text (_("Detecting ..."));
latency_timeout = Glib::signal_timeout().connect (mem_fun (*this, &EngineControl::check_latency_measurement), 250);
} else {
ARDOUR::AudioEngine::instance()->stop_latency_detection ();
latency_timeout.disconnect ();
start_latency_detection ();
} else {
end_latency_detection ();
}
}
@@ -1098,3 +1471,14 @@ EngineControl::use_latency_button_clicked ()
input_latency_adjustment.set_value (one_way);
output_latency_adjustment.set_value (one_way);
}
bool
EngineControl::on_delete_event (GdkEventAny* ev)
{
if (notebook.get_current_page() == 2) {
/* currently on latency tab - be sure to clean up */
end_latency_detection ();
}
return ArdourDialog::on_delete_event (ev);
}

79
gtk2_ardour/engine_dialog.h
View File

@@ -54,7 +54,13 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
/* core fields used by all backends */
Gtk::Table basic_packer;
Gtk::HBox basic_hbox;
Gtk::VBox basic_vbox;
Gtk::ComboBoxText backend_combo;
Gtk::ComboBoxText driver_combo;
Gtk::ComboBoxText device_combo;
Gtk::ComboBoxText sample_rate_combo;
Gtk::ComboBoxText buffer_size_combo;
Gtk::Label buffer_size_duration_label;
@@ -75,42 +81,31 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
Gtk::ComboBoxText lm_output_channel_combo;
Gtk::ComboBoxText lm_input_channel_combo;
Gtk::Label lm_start_stop_label;
Gtk::ToggleButton lm_measure_button;
Gtk::Button lm_use_button;
Gtk::Label lm_title;
Gtk::Label lm_preamble;
Gtk::Label lm_results;
Gtk::Table lm_table;
Gtk::VBox lm_vbox;
bool have_lm_results;
/* JACK specific */
Gtk::CheckButton realtime_button;
Gtk::CheckButton no_memory_lock_button;
Gtk::CheckButton unlock_memory_button;
Gtk::CheckButton soft_mode_button;
Gtk::CheckButton monitor_button;
Gtk::CheckButton force16bit_button;
Gtk::CheckButton hw_monitor_button;
Gtk::CheckButton hw_meter_button;
Gtk::CheckButton verbose_output_button;
Gtk::ComboBoxText preset_combo;
Gtk::ComboBoxText serverpath_combo;
Gtk::ComboBoxText driver_combo;
Gtk::ComboBoxText device_combo;
Gtk::ComboBoxText timeout_combo;
Gtk::ComboBoxText dither_mode_combo;
Gtk::ComboBoxText audio_mode_combo;
Gtk::ComboBoxText midi_driver_combo;
Gtk::Table basic_packer;
Gtk::Table midi_packer;
Gtk::HBox basic_hbox;
Gtk::VBox basic_vbox;
Gtk::HBox midi_hbox;
Gtk::Button* cancel_button;
Gtk::Button* ok_button;
Gtk::Button* apply_button;
/* MIDI Tab */
Gtk::VBox midi_vbox;
Gtk::Button midi_refresh_button;
Gtk::Table midi_device_table;
/* MIDI ... JACK */
Gtk::CheckButton aj_button;
uint32_t ignore_changes;
uint32_t _desired_sample_rate;
static bool engine_running ();
@@ -120,7 +115,14 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
void buffer_size_changed ();
void parameter_changed ();
uint32_t get_rate() const;
void setup_midi_tab_for_backend ();
void setup_midi_tab_for_jack ();
void refresh_midi_display ();
std::string rate_as_string (float);
std::string bufsize_as_string (uint32_t);
float get_rate() const;
uint32_t get_buffer_size() const;
uint32_t get_input_channels() const;
uint32_t get_output_channels() const;
@@ -128,6 +130,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
uint32_t get_output_latency() const;
std::string get_device_name() const;
std::string get_driver() const;
std::string get_backend() const;
void device_changed ();
void list_devices ();
@@ -137,15 +140,21 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
std::string backend;
std::string driver;
std::string device;
std::string sample_rate;
std::string buffer_size;
float sample_rate;
uint32_t buffer_size;
uint32_t input_latency;
uint32_t output_latency;
uint32_t input_channels;
uint32_t output_channels;
bool active;
State() : active (false) {};
State()
: input_latency (0)
, output_latency (0)
, input_channels (0)
, output_channels (0)
, active (false) {}
};
typedef std::list<State> StateList;
@@ -158,6 +167,9 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
State* get_saved_state_for_currently_displayed_backend_and_device ();
void maybe_display_saved_state ();
State* save_state ();
void store_state (State&);
bool _have_control;
static bool print_channel_count (Gtk::SpinButton*);
@@ -168,7 +180,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
void use_latency_button_clicked ();
void manage_control_app_sensitivity ();
int push_state_to_backend (bool start);
uint32_t _desired_sample_rate;
void post_push ();
/* latency measurement */
void latency_button_toggled ();
@@ -176,8 +188,11 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
sigc::connection latency_timeout;
void enable_latency_tab ();
void disable_latency_tab ();
void start_latency_detection ();
void end_latency_detection ();
void on_switch_page (GtkNotebookPage*, guint page_num);
bool on_delete_event (GdkEventAny*);
};
#endif /* __gtk2_ardour_engine_dialog_h__ */

9
gtk2_ardour/utils.cc
View File

@@ -365,12 +365,11 @@ relay_key_press (GdkEventKey* ev, Gtk::Window* win)
{
PublicEditor& ed (PublicEditor::instance());
if (&ed == 0) {
/* early key press in pre-main-window-dialogs, no editor yet */
return false;
}
if (!key_press_focus_accelerator_handler (*win, ev)) {
if (&ed == 0) {
/* early key press in pre-main-window-dialogs, no editor yet */
return false;
}
return ed.on_key_press_event(ev);
} else {
return true;

5
libs/ardour/ardour/audio_backend.h
View File

@@ -223,6 +223,11 @@ class AudioBackend : public PortEngine {
virtual uint32_t systemic_input_latency () const = 0;
virtual uint32_t systemic_output_latency () const = 0;
/** override this if this implementation returns true from
* requires_driver_selection()
*/
virtual std::string driver_name() const { return std::string(); }
/** Return the name of a control application for the
* selected/in-use device. If no such application exists,
* or if no device has been selected or is in-use,

11
libs/ardour/ardour/session.h
View File

@@ -1071,7 +1071,6 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
boost::scoped_ptr<SessionDirectory> _session_dir;
void hookup_io ();
int when_engine_running ();
void graph_reordered ();
/** current snapshot name, without the .ardour suffix */
@@ -1137,8 +1136,10 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
void auto_loop_changed (Location *);
void auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
int ensure_engine (uint32_t desired_sample_rate);
void pre_engine_init (std::string path);
int post_engine_init ();
int immediately_post_engine ();
void remove_empty_sounds ();
void setup_midi_control ();
@@ -1521,13 +1522,6 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
float opt
);
/* number of hardware ports we're using,
based on max (requested,available)
*/
ChanCount n_physical_outputs;
ChanCount n_physical_inputs;
int find_all_sources (std::string path, std::set<std::string>& result);
int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
@@ -1624,7 +1618,6 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
void setup_ltc ();
void setup_click ();
void setup_bundles ();
int ensure_engine (uint32_t desired_sample_rate);
};
} // namespace ARDOUR

25
libs/ardour/audioengine.cc
View File

@@ -1037,12 +1037,22 @@ AudioEngine::start_latency_detection ()
delete _mtdm;
_mtdm = 0;
/* find the ports we will connect to */
PortEngine::PortHandle* out = pe.get_port_by_name (_latency_output_name);
PortEngine::PortHandle* in = pe.get_port_by_name (_latency_input_name);
if (!out || !in) {
return;
}
/* create the ports we will use to read/write data */
if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
return;
}
if (pe.connect (_latency_output_port, _latency_output_name)) {
pe.unregister_port (_latency_output_port);
return;
}
@@ -1058,9 +1068,9 @@ AudioEngine::start_latency_detection ()
LatencyRange lr;
_latency_signal_latency = 0;
lr = pe.get_latency_range (_latency_input_port, false);
lr = pe.get_latency_range (in, false);
_latency_signal_latency = lr.max;
lr = pe.get_latency_range (_latency_output_port, true);
lr = pe.get_latency_range (out, true);
_latency_signal_latency += lr.max;
/* all created and connected, lets go */
@@ -1076,9 +1086,14 @@ AudioEngine::stop_latency_detection ()
{
_measuring_latency = false;
port_engine().unregister_port (_latency_output_port);
port_engine().unregister_port (_latency_input_port);
if (_latency_output_port) {
port_engine().unregister_port (_latency_output_port);
_latency_output_port = 0;
}
if (_latency_input_port) {
port_engine().unregister_port (_latency_input_port);
_latency_input_port = 0;
}
if (_started_for_latency) {
stop ();
}

148
libs/ardour/session.cc
View File

@@ -258,17 +258,26 @@ Session::Session (AudioEngine &eng,
, _suspend_timecode_transmission (0)
, _speakers (new Speakers)
, ignore_route_processor_changes (false)
, _midi_ports (0)
, _mmc (0)
{
uint32_t sr = 0;
pre_engine_init (fullpath);
if (_is_new) {
if (ensure_engine (sr)) {
destroy ();
throw failed_constructor ();
}
if (create (mix_template, bus_profile)) {
destroy ();
throw failed_constructor ();
}
} else {
if (load_state (_current_snapshot_name)) {
throw failed_constructor ();
}
@@ -284,11 +293,11 @@ Session::Session (AudioEngine &eng,
sr = atoi (prop->value());
}
}
}
if (ensure_engine (sr)) {
destroy ();
throw failed_constructor ();
if (ensure_engine (sr)) {
destroy ();
throw failed_constructor ();
}
}
if (post_engine_init ()) {
@@ -361,6 +370,50 @@ Session::ensure_engine (uint32_t desired_sample_rate)
return -1;
}
return immediately_post_engine ();
}
int
Session::immediately_post_engine ()
{
/* Do various initializations that should take place directly after we
* know that the engine is running, but before we either create a
* session or set state for an existing one.
*/
if (how_many_dsp_threads () > 1) {
/* For now, only create the graph if we are using >1 DSP threads, as
it is a bit slower than the old code with 1 thread.
*/
_process_graph.reset (new Graph (*this));
}
/* every time we reconnect, recompute worst case output latencies */
_engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
if (synced_to_jack()) {
_engine.transport_stop ();
}
if (config.get_jack_time_master()) {
_engine.transport_locate (_transport_frame);
}
try {
BootMessage (_("Set up LTC"));
setup_ltc ();
BootMessage (_("Set up Click"));
setup_click ();
BootMessage (_("Set up standard connections"));
setup_bundles ();
}
catch (failed_constructor& err) {
return -1;
}
return 0;
}
@@ -474,9 +527,9 @@ Session::destroy ()
/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
playlists.reset ();
delete _mmc;
delete _midi_ports;
delete _locations;
delete _mmc; _mmc = 0;
delete _midi_ports; _midi_ports = 0;
delete _locations; _locations = 0;
DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
@@ -683,81 +736,6 @@ Session::setup_bundles ()
}
int
Session::when_engine_running ()
{
/* every time we reconnect, recompute worst case output latencies */
_engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
if (synced_to_jack()) {
_engine.transport_stop ();
}
if (config.get_jack_time_master()) {
_engine.transport_locate (_transport_frame);
}
try {
BootMessage (_("Set up LTC"));
setup_ltc ();
BootMessage (_("Set up Click"));
setup_click ();
BootMessage (_("Set up standard connections"));
setup_bundles ();
}
catch (failed_constructor& err) {
return -1;
}
BootMessage (_("Setup signal flow and plugins"));
/* Reset all panners */
Delivery::reset_panners ();
/* this will cause the CPM to instantiate any protocols that are in use
* (or mandatory), which will pass it this Session, and then call
* set_state() on each instantiated protocol to match stored state.
*/
ControlProtocolManager::instance().set_session (this);
/* This must be done after the ControlProtocolManager set_session above,
as it will set states for ports which the ControlProtocolManager creates.
*/
// XXX set state of MIDI::Port's
// MidiPortManager::instance()->set_port_states (Config->midi_port_states ());
/* And this must be done after the MIDI::Manager::set_port_states as
* it will try to make connections whose details are loaded by set_port_states.
*/
hookup_io ();
/* Let control protocols know that we are now all connected, so they
* could start talking to surfaces if they want to.
*/
ControlProtocolManager::instance().midi_connectivity_established ();
if (_is_new && !no_auto_connect()) {
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
auto_connect_master_bus ();
}
_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
/* update latencies */
initialize_latencies ();
return 0;
}
void
Session::auto_connect_master_bus ()
{
@@ -917,14 +895,14 @@ Session::add_monitor_section ()
/* Monitor bus is audio only */
uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
vector<string> outputs[DataType::num_types];
for (uint32_t i = 0; i < DataType::num_types; ++i) {
_engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
}
uint32_t mod = outputs[DataType::AUDIO].size();
uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
if (mod != 0) {

53
libs/ardour/session_state.cc
View File

@@ -211,16 +211,6 @@ Session::post_engine_init ()
set_block_size (_engine.samples_per_cycle());
set_frame_rate (_engine.sample_rate());
if (how_many_dsp_threads () > 1) {
/* For now, only create the graph if we are using >1 DSP threads, as
it is a bit slower than the old code with 1 thread.
*/
_process_graph.reset (new Graph (*this));
}
n_physical_outputs = _engine.n_physical_outputs ();
n_physical_inputs = _engine.n_physical_inputs ();
BootMessage (_("Using configuration"));
_midi_ports = new MidiPortManager;
@@ -281,8 +271,47 @@ Session::post_engine_init ()
Config->map_parameters (ff);
config.map_parameters (ft);
when_engine_running ();
/* Reset all panners */
Delivery::reset_panners ();
/* this will cause the CPM to instantiate any protocols that are in use
* (or mandatory), which will pass it this Session, and then call
* set_state() on each instantiated protocol to match stored state.
*/
ControlProtocolManager::instance().set_session (this);
/* This must be done after the ControlProtocolManager set_session above,
as it will set states for ports which the ControlProtocolManager creates.
*/
// XXX set state of MIDI::Port's
// MidiPortManager::instance()->set_port_states (Config->midi_port_states ());
/* And this must be done after the MIDI::Manager::set_port_states as
* it will try to make connections whose details are loaded by set_port_states.
*/
hookup_io ();
/* Let control protocols know that we are now all connected, so they
* could start talking to surfaces if they want to.
*/
ControlProtocolManager::instance().midi_connectivity_established ();
if (_is_new && !no_auto_connect()) {
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
auto_connect_master_bus ();
}
_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
/* update latencies */
initialize_latencies ();
_locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
_locations->added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1));

82
libs/backends/jack/jack_audiobackend.cc
View File

@@ -57,8 +57,8 @@ JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnec
, _target_buffer_size (1024)
, _target_sample_format (FormatFloat)
, _target_interleaved (false)
, _target_input_channels (-1)
, _target_output_channels (-1)
, _target_input_channels (0)
, _target_output_channels (0)
, _target_systemic_input_latency (0)
, _target_systemic_output_latency (0)
, _current_sample_rate (0)
@@ -292,7 +292,10 @@ int
JACKAudioBackend::set_input_channels (uint32_t cnt)
{
if (available()) {
return -1;
if (cnt != 0) {
/* can't set a real value for this while JACK runs */
return -1;
}
}
_target_input_channels = cnt;
@@ -304,7 +307,10 @@ int
JACKAudioBackend::set_output_channels (uint32_t cnt)
{
if (available()) {
return -1;
if (cnt != 0) {
/* can't set a real value for this while JACK runs */
return -1;
}
}
_target_output_channels = cnt;
@@ -316,6 +322,7 @@ int
JACKAudioBackend::set_systemic_input_latency (uint32_t l)
{
if (available()) {
/* can't do this while JACK runs */
return -1;
}
@@ -328,6 +335,7 @@ int
JACKAudioBackend::set_systemic_output_latency (uint32_t l)
{
if (available()) {
/* can't do this while JACK runs */
return -1;
}
@@ -341,18 +349,34 @@ JACKAudioBackend::set_systemic_output_latency (uint32_t l)
std::string
JACKAudioBackend::device_name () const
{
if (available()) {
return "???";
if (!_jack_connection->in_control()) {
return "???"; // JACK has no way (as of fall 2013) to return
// the device name
}
return _target_device;
}
std::string
JACKAudioBackend::driver_name() const
{
if (!_jack_connection->in_control()) {
return "???"; // JACK has no way (as of fall 2013) to return
// the driver name
}
return _target_driver;
}
float
JACKAudioBackend::sample_rate () const
{
if (available()) {
return _current_sample_rate;
if (!_jack_connection->in_control()) {
if (available()) {
return _current_sample_rate;
} else {
return 0;
}
}
return _target_sample_rate;
}
@@ -360,8 +384,12 @@ JACKAudioBackend::sample_rate () const
uint32_t
JACKAudioBackend::buffer_size () const
{
if (available()) {
return _current_buffer_size;
if (!_jack_connection->in_control()) {
if (available()) {
return _current_buffer_size;
} else {
return 0;
}
}
return _target_buffer_size;
}
@@ -381,19 +409,37 @@ JACKAudioBackend::interleaved () const
uint32_t
JACKAudioBackend::input_channels () const
{
if (available()) {
return n_physical (JackPortIsInput).n_audio();
}
return _target_input_channels;
if (!_jack_connection->in_control()) {
if (available()) {
return n_physical (JackPortIsInput).n_audio();
} else {
return 0;
}
} else {
if (available()) {
return n_physical (JackPortIsInput).n_audio();
} else {
return _target_input_channels;
}
}
}
uint32_t
JACKAudioBackend::output_channels () const
{
if (available()) {
return n_physical (JackPortIsOutput).n_audio();
}
return _target_output_channels;
if (!_jack_connection->in_control()) {
if (available()) {
return n_physical (JackPortIsOutput).n_audio();
} else {
return 0;
}
} else {
if (available()) {
return n_physical (JackPortIsOutput).n_audio();
} else {
return _target_output_channels;
}
}
}
uint32_t

1
libs/backends/jack/jack_audiobackend.h
View File

@@ -85,6 +85,7 @@ class JACKAudioBackend : public AudioBackend {
uint32_t output_channels () const;
uint32_t systemic_input_latency () const;
uint32_t systemic_output_latency () const;
std::string driver_name() const;
std::string control_app_name () const;
void launch_control_app ();

15
libs/backends/jack/jack_connection.cc
View File

@@ -16,6 +16,7 @@
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <iostream>
#include <boost/scoped_ptr.hpp>
#include <jack/session.h>
@@ -53,6 +54,7 @@ JackConnection::JackConnection (const std::string& arg1, const std::string& arg2
, _client_name (arg1)
, session_uuid (arg2)
{
_in_control = !server_running();
}
JackConnection::~JackConnection ()
@@ -104,6 +106,19 @@ JackConnection::open ()
global_epa->restore ();
}
/* check to see if the server is already running so that we know if we
* are starting it.
*/
jack_client_t* c = jack_client_open ("ardourprobe", JackNoStartServer, &status);
if (status == 0) {
_in_control = false;
jack_client_close (c);
} else {
_in_control = true;
}
/* ensure that PATH or equivalent includes likely locations of the JACK
* server, in case the user's default does not.
*/

5
libs/backends/jack/jack_connection.h
View File

@@ -27,12 +27,15 @@ class JackConnection {
void halted_callback ();
void halted_info_callback (jack_status_t, const char*);
static bool server_running();
bool in_control() const { return _in_control; }
static bool server_running();
private:
jack_client_t* volatile _jack;
std::string _client_name;
std::string session_uuid;
bool _in_control;
};
} // namespace

8
libs/gtkmm2ext/keyboard.cc
View File

@@ -233,8 +233,9 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
DEBUG_TRACE (
DEBUG::Keyboard,
string_compose (
"Snoop widget %1 key %2 type %3 state %4 magic %5\n",
widget, event->keyval, event->type, event->state, _some_magic_widget_has_focus
"Snoop widget %1 name: [%6] key %2 type %3 state %4 magic %5\n",
widget, event->keyval, event->type, event->state, _some_magic_widget_has_focus,
gtk_widget_get_name (widget)
)
);
@@ -324,6 +325,8 @@ Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
}
}
DEBUG_TRACE (DEBUG::Keyboard, string_compose ("snooper returns %1\n", ret));
return ret;
}
@@ -346,6 +349,7 @@ bool
Keyboard::enter_window (GdkEventCrossing *, Gtk::Window* win)
{
current_window = win;
DEBUG_TRACE (DEBUG::Keyboard, string_compose ("Entering window, title = %1\n", win->get_title()));
return false;
}

9
libs/surfaces/wscript
View File

@@ -55,9 +55,12 @@ def configure(conf):
if conf.is_defined('HAVE_CWIID_H'):
conf.check_cc (header_name='bluetooth/bluetooth.h', define_name='HAVE_BLUETOOTH_H',mandatory=False)
if conf.is_defined('HAVE_BLUETOOTH_H'):
autowaf.check_pkg(conf, 'cwiid', uselib_store='CWIID', atleast_version='0.6.00')
conf.define ('BUILD_WIIMOTE', 1)
sub_config_and_use(conf, 'wiimote')
autowaf.check_pkg(conf, 'cwiid', uselib_store='CWIID', atleast_version='0.6.00',mandatory=False)
if conf.is_defined ('HAVE_CWIID'):
conf.define ('BUILD_WIIMOTE', 1)
sub_config_and_use(conf, 'wiimote')
else:
print('You have the cwiid headers needed to compile wiimote support BUT you are missing the pkg-config file for cwiid')
else:
print('You are missing the libbluetooth headers needed to compile wiimote support')
else: