#include "pbd/stacktrace.h"
#include "pbd/unknown_type.h"
-#include "midi++/jack.h"
+#include "midi++/port.h"
+#include "midi++/mmc.h"
+#include "midi++/manager.h"
#include "ardour/amp.h"
#include "ardour/audio_port.h"
_running = false;
_has_run = false;
last_monitor_check = 0;
- monitor_check_interval = max_frames;
+ monitor_check_interval = INT32_MAX;
_processed_frames = 0;
_usecs_per_cycle = 0;
_jack = 0;
SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
- MIDI::JACK_MidiPort::set_process_thread (pthread_self());
+ MIDI::Port::set_process_thread (pthread_self());
}
typedef void (*_JackInfoShutdownCallback)(jack_status_t code, const char* reason, void *arg);
error << _("Cannot create temporary MIDI port to determine MIDI buffer size") << endmsg;
} else {
_raw_buffer_sizes[DataType::MIDI] = jack_midi_max_event_size (jack_port_get_buffer(midi_port, blocksize));
- cerr << "MIDI port buffers = " << _raw_buffer_sizes[DataType::MIDI] << endl;
jack_port_unregister (_priv_jack, midi_port);
}
}
} else {
jack_deactivate (_priv_jack);
Stopped(); /* EMIT SIGNAL */
- MIDI::JACK_MidiPort::JackHalted (); /* EMIT SIGNAL */
+ MIDI::Port::JackHalted (); /* EMIT SIGNAL */
}
}
+ if (forever) {
+ stop_metering_thread ();
+ }
+
return _running ? -1 : 0;
}
{
/* caller must hold process lock */
- Port::increment_port_offset (offset);
+ AudioPort::increment_port_offset (offset);
/* tell all Ports that we're going to start a new (split) cycle */
}
void
-AudioEngine::finish_process_cycle (int status)
+AudioEngine::finish_process_cycle (int /* status*/ )
{
GET_PRIVATE_JACK_POINTER(_jack);
jack_cycle_signal (_jack, 0);
/* handle wrap around of total frames counter */
- if (max_frames - _processed_frames < nframes) {
- next_processed_frames = nframes - (max_frames - _processed_frames);
+ if (max_framepos - _processed_frames < nframes) {
+ next_processed_frames = nframes - (max_framepos - _processed_frames);
} else {
next_processed_frames = _processed_frames + nframes;
}
/* tell all relevant objects that we're starting a new cycle */
Delivery::CycleStart (nframes);
- Port::set_port_offset (0);
+ AudioPort::set_port_offset (0);
InternalReturn::CycleStart (nframes);
/* tell all Ports that we're starting a new cycle */
(*i)->cycle_start (nframes);
}
- if (_freewheeling) {
+ /* test if we are freewheeling and there are freewheel signals connected.
+ ardour should act normally even when freewheeling unless /it/ is exporting */
+
+
+ if (_freewheeling && !Freewheel.empty()) {
/* emit the Freewheel signal and stop freewheeling in the event of trouble
*/
boost::optional<int> r = Freewheel (nframes);
int
AudioEngine::connect (const string& source, const string& destination)
{
- /* caller must hold process lock */
-
int ret;
if (!_running) {
string d = make_port_name_non_relative (destination);
- Port* src = get_port_by_name_locked (s);
- Port* dst = get_port_by_name_locked (d);
+ Port* src = get_port_by_name (s);
+ Port* dst = get_port_by_name (d);
if (src) {
ret = src->connect (d);
int
AudioEngine::disconnect (const string& source, const string& destination)
{
- /* caller must hold process lock */
-
int ret;
if (!_running) {
string s = make_port_name_non_relative (source);
string d = make_port_name_non_relative (destination);
- Port* src = get_port_by_name_locked (s);
- Port* dst = get_port_by_name_locked (d);
+ Port* src = get_port_by_name (s);
+ Port* dst = get_port_by_name (d);
if (src) {
ret = src->disconnect (d);
AudioEngine::get_port_by_name (const string& portname)
{
string s;
- if (portname.find_first_of (':') == string::npos) {
- s = make_port_name_non_relative (portname);
- } else {
- s = portname;
- }
-
- Glib::Mutex::Lock lm (_process_lock);
- return get_port_by_name_locked (s);
-}
-
-Port *
-AudioEngine::get_port_by_name_locked (const string& portname)
-{
- /* caller must hold process lock */
if (!_running) {
if (!_has_run) {
- fatal << _("get_port_by_name_locked() called before engine was started") << endmsg;
+ fatal << _("get_port_by_name() called before engine was started") << endmsg;
/*NOTREACHED*/
} else {
return 0;
}
}
+ if (portname.find_first_of (':') == string::npos) {
+ s = make_port_name_non_relative (portname);
+ } else {
+ s = portname;
+ }
+
if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
/* not an ardour: port */
return 0;
if (was_running) {
ae->Halted(""); /* EMIT SIGNAL */
- MIDI::JACK_MidiPort::JackHalted (); /* EMIT SIGNAL */
+ MIDI::Port::JackHalted (); /* EMIT SIGNAL */
}
}
return true;
}
-
-uint32_t
-AudioEngine::n_physical_outputs (DataType type) const
+ChanCount
+AudioEngine::n_physical (unsigned long flags) const
{
- GET_PRIVATE_JACK_POINTER_RET (_jack,0);
- const char ** ports;
- uint32_t i = 0;
+ ChanCount c;
+
+ GET_PRIVATE_JACK_POINTER_RET (_jack, c);
- if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical|JackPortIsInput)) == 0) {
- return 0;
+ const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
+ if (ports == 0) {
+ return c;
+ }
+
+ for (uint32_t i = 0; ports[i]; ++i) {
+ if (!strstr (ports[i], "Midi-Through")) {
+ DataType t (jack_port_type (jack_port_by_name (_jack, ports[i])));
+ c.set (t, c.get (t) + 1);
+ }
}
- for (i = 0; ports[i]; ++i) {}
free (ports);
- return i;
+ return c;
}
-uint32_t
-AudioEngine::n_physical_inputs (DataType type) const
+ChanCount
+AudioEngine::n_physical_inputs () const
{
- GET_PRIVATE_JACK_POINTER_RET (_jack,0);
- const char ** ports;
- uint32_t i = 0;
-
- if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical|JackPortIsOutput)) == 0) {
- return 0;
- }
-
- for (i = 0; ports[i]; ++i) {}
- free (ports);
+ return n_physical (JackPortIsInput);
+}
- return i;
+ChanCount
+AudioEngine::n_physical_outputs () const
+{
+ return n_physical (JackPortIsOutput);
}
void
-AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
+AudioEngine::get_physical (DataType type, unsigned long flags, vector<string>& phy)
{
GET_PRIVATE_JACK_POINTER (_jack);
const char ** ports;
- if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical|JackPortIsOutput)) == 0) {
+ if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical | flags)) == 0) {
return;
}
if (ports) {
for (uint32_t i = 0; ports[i]; ++i) {
- ins.push_back (ports[i]);
+ if (strstr (ports[i], "Midi-Through")) {
+ continue;
+ }
+ phy.push_back (ports[i]);
}
free (ports);
}
}
+/** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
+ * a physical input connector.
+ */
void
-AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
+AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
{
- GET_PRIVATE_JACK_POINTER (_jack);
- const char ** ports;
- uint32_t i = 0;
-
- if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical|JackPortIsInput)) == 0) {
- return;
- }
-
- for (i = 0; ports[i]; ++i) {
- outs.push_back (ports[i]);
- }
- free (ports);
+ get_physical (type, JackPortIsOutput, ins);
}
-string
-AudioEngine::get_nth_physical (DataType type, uint32_t n, int flag)
+/** Get physical ports for which JackPortIsInput is set; ie those that correspond to
+ * a physical output connector.
+ */
+void
+AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
{
- GET_PRIVATE_JACK_POINTER_RET (_jack,"");
- const char ** ports;
- uint32_t i;
- string ret;
-
- assert(type != DataType::NIL);
-
- if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical|flag)) == 0) {
- return ret;
- }
-
- for (i = 0; i < n && ports[i]; ++i) {}
-
- if (ports[i]) {
- ret = ports[i];
- }
-
- free ((const char **) ports);
-
- return ret;
+ get_physical (type, JackPortIsInput, outs);
}
void
if (_running) {
_running = false;
Stopped(); /* EMIT SIGNAL */
- MIDI::JACK_MidiPort::JackHalted (); /* EMIT SIGNAL */
+ MIDI::Port::JackHalted (); /* EMIT SIGNAL */
}
return 0;
GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
+ MIDI::Manager::instance()->reestablish (_priv_jack);
+
if (_session) {
_session->reset_jack_connection (_priv_jack);
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
(*i)->reconnect ();
}
+ MIDI::Manager::instance()->reconnect ();
+
Running (); /* EMIT SIGNAL*/
start_metering_thread ();
return jack_is_realtime (_priv_jack);
}
-pthread_t
-AudioEngine::create_process_thread (boost::function<void()> f, size_t stacksize)
+int
+AudioEngine::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
{
GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
- pthread_t thread;
ThreadData* td = new ThreadData (this, f, stacksize);
- if (jack_client_create_thread (_priv_jack, &thread, jack_client_real_time_priority (_priv_jack),
+ if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
jack_is_realtime (_priv_jack), _start_process_thread, td)) {
return -1;
}
- return thread;
+ return 0;
}
void*
projects / ardour.git / blobdiff