#include <glibmm.h>
#include "dummy_audiobackend.h"
+
#include "pbd/error.h"
+#include "ardour/port_manager.h"
#include "i18n.h"
using namespace ARDOUR;
, _systemic_input_latency (0)
, _systemic_output_latency (0)
, _processed_samples (0)
+ , _port_change_flag (false)
{
_instance_name = s_instance_name;
+ pthread_mutex_init (&_port_callback_mutex, 0);
}
DummyAudioBackend::~DummyAudioBackend ()
{
+ pthread_mutex_destroy (&_port_callback_mutex);
}
/* AUDIOBACKEND API */
else {
_n_midi_inputs = _n_midi_outputs = 0;
}
- return -1;
+ return 0;
}
std::string
DummyAudioBackend::midi_option () const
{
- return "";
+ return ""; // TODO
}
/* State Control */
return -1;
}
+ engine.sample_rate_change (_samplerate);
+ engine.buffer_size_change (_samples_per_period);
+
if (engine.reestablish_ports ()) {
PBD::error << _("DummyAudioBackend: Could not re-establish ports.") << endmsg;
stop ();
}
engine.reconnect_ports ();
+ _port_change_flag = false;
if (pthread_create (&_main_thread, NULL, pthread_process, this)) {
PBD::error << _("DummyAudioBackend: cannot start.") << endmsg;
{
void *status;
if (!_running) {
- return -1;
+ return 0;
}
_running = false;
{
switch (t) {
case DataType::AUDIO:
- return _max_buffer_size * sizeof(Sample);
+ return _samples_per_period * sizeof(Sample);
case DataType::MIDI:
return _max_buffer_size; // XXX not really limited
}
if (pthread_create (&thread_id, &attr, dummy_process_thread, td)) {
PBD::error << _("AudioEngine: cannot create process thread.") << endmsg;
+ pthread_attr_destroy (&attr);
return -1;
}
+ pthread_attr_destroy (&attr);
_threads.push_back (thread_id);
return 0;
void
DummyAudioBackend::update_latencies ()
{
+ // trigger latency callback in RT thread (locked graph)
+ port_connect_add_remove_callback();
}
/* PORTENGINE API */
DummyPort* port = NULL;
switch (type) {
case DataType::AUDIO:
- port = new DummyAudioPort (name, flags);
+ port = new DummyAudioPort (*this, name, flags);
break;
case DataType::MIDI:
- port = new DummyMidiPort (name, flags);
+ port = new DummyMidiPort (*this, name, flags);
break;
default:
PBD::error << _("DummyBackend::register_port: Invalid Data Type.") << endmsg;
snprintf(tmp, sizeof(tmp), "system:playback_%d", i);
PortHandle p = add_port(std::string(tmp), DataType::AUDIO, static_cast<PortFlags>(IsInput | IsPhysical | IsTerminal));
if (!p) return -1;
- set_latency_range (p, false, lr);
+ set_latency_range (p, true, lr);
}
/* midi ports */
snprintf(tmp, sizeof(tmp), "system:midi_playback_%d", i);
PortHandle p = add_port(std::string(tmp), DataType::MIDI, static_cast<PortFlags>(IsInput | IsPhysical | IsTerminal));
if (!p) return -1;
- set_latency_range (p, false, lr);
+ set_latency_range (p, true, lr);
}
-
return 0;
}
uint32_t
DummyAudioBackend::get_midi_event_count (void* port_buffer)
{
- assert (port_buffer && _running);
+ assert (port_buffer);
return static_cast<DummyMidiBuffer*>(port_buffer)->size ();
}
void
DummyAudioBackend::midi_clear (void* port_buffer)
{
- assert (port_buffer && _running);
+ assert (port_buffer);
DummyMidiBuffer * buf = static_cast<DummyMidiBuffer*>(port_buffer);
assert (buf);
buf->clear ();
{
for (size_t i = 0; i < _ports.size (); ++i) {
DummyPort* port = _ports[i];
- if ((port->type () == type) && port->is_output () && port->is_physical ()) {
+ if ((port->type () == type) && port->is_input () && port->is_physical ()) {
port_names.push_back (port->name ());
}
}
{
for (size_t i = 0; i < _ports.size (); ++i) {
DummyPort* port = _ports[i];
- if ((port->type () == type) && port->is_input () && port->is_physical ()) {
+ if ((port->type () == type) && port->is_output () && port->is_physical ()) {
port_names.push_back (port->name ());
}
}
void*
DummyAudioBackend::get_buffer (PortEngine::PortHandle port, pframes_t nframes)
{
- assert (port && _running);
+ assert (port);
assert (valid_port (port));
return static_cast<DummyPort*>(port)->get_buffer (nframes);
}
_running = true;
_processed_samples = 0;
+ manager.registration_callback();
+ manager.graph_order_callback();
+
uint64_t clock1, clock2;
clock1 = g_get_monotonic_time();
while (_running) {
Glib::usleep (100); // don't hog cpu
}
clock1 = g_get_monotonic_time();
+
+ bool connections_changed = false;
+ bool ports_changed = false;
+ if (!pthread_mutex_trylock (&_port_callback_mutex)) {
+ if (_port_change_flag) {
+ ports_changed = true;
+ _port_change_flag = false;
+ }
+ if (!_port_connection_queue.empty ()) {
+ connections_changed = true;
+ }
+ while (!_port_connection_queue.empty ()) {
+ PortConnectData *c = _port_connection_queue.back ();
+ manager.connect_callback (c->a, c->b, c->c);
+ _port_connection_queue.pop_back ();
+ delete c;
+ }
+ pthread_mutex_unlock (&_port_callback_mutex);
+ }
+ if (ports_changed) {
+ manager.registration_callback();
+ }
+ if (connections_changed) {
+ manager.graph_order_callback();
+ }
+ if (connections_changed || ports_changed) {
+ engine.latency_callback(false);
+ engine.latency_callback(true);
+ }
+
}
_running = false;
return 0;
/******************************************************************************/
-DummyPort::DummyPort (const std::string& name, PortFlags flags)
- : _name (name)
+DummyPort::DummyPort (DummyAudioBackend &b, const std::string& name, PortFlags flags)
+ : _dummy_backend (b)
+ , _name (name)
, _flags (flags)
{
_capture_latency_range.min = 0;
_capture_latency_range.max = 0;
_playback_latency_range.min = 0;
_playback_latency_range.max = 0;
+ _dummy_backend.port_connect_add_remove_callback();
}
DummyPort::~DummyPort () {
disconnect_all ();
+ _dummy_backend.port_connect_add_remove_callback();
}
_connections.push_back (port);
if (callback) {
port->_connect (this, false);
+ _dummy_backend.port_connect_callback (name(), port->name(), true);
}
}
if (callback) {
port->_disconnect (this, false);
+ _dummy_backend.port_connect_callback (name(), port->name(), false);
}
}
{
while (!_connections.empty ()) {
_connections.back ()->_disconnect (this, false);
+ _dummy_backend.port_connect_callback (name(), _connections.back ()->name(), false);
_connections.pop_back ();
}
}
/******************************************************************************/
-DummyAudioPort::DummyAudioPort (const std::string& name, PortFlags flags)
- : DummyPort (name, flags)
+DummyAudioPort::DummyAudioPort (DummyAudioBackend &b, const std::string& name, PortFlags flags)
+ : DummyPort (b, name, flags)
{
memset (_buffer, 0, sizeof (_buffer));
}
}
-DummyMidiPort::DummyMidiPort (const std::string& name, PortFlags flags)
- : DummyPort (name, flags)
+DummyMidiPort::DummyMidiPort (DummyAudioBackend &b, const std::string& name, PortFlags flags)
+ : DummyPort (b, name, flags)
{
_buffer.clear ();
}
DummyMidiPort::~DummyMidiPort () { }
+struct MidiEventSorter {
+ bool operator() (const boost::shared_ptr<DummyMidiEvent>& a, const boost::shared_ptr<DummyMidiEvent>& b) {
+ return *a < *b;
+ }
+};
+
void* DummyMidiPort::get_buffer (pframes_t /* nframes */)
{
if (is_input ()) {
_buffer.push_back (boost::shared_ptr<DummyMidiEvent>(new DummyMidiEvent (**it)));
}
}
- std::sort (_buffer.begin (), _buffer.end ());
+ std::sort (_buffer.begin (), _buffer.end (), MidiEventSorter());
} else if (is_output () && is_physical () && is_terminal()) {
_buffer.clear ();
}
projects / ardour.git / blobdiff