using namespace std;
using namespace PBD;
-size_t Port::nports = 0;
pthread_t Port::_process_thread;
Signal0<void> Port::JackHalted;
Signal0<void> Port::MakeConnections;
+string Port::state_node_name = "MIDI-port";
-Port::Port (string const & name, int mode, jack_client_t* jack_client)
+Port::Port (string const & name, Flags flags, jack_client_t* jack_client)
: _currently_in_cycle (false)
, _nframes_this_cycle (0)
, _jack_client (jack_client)
- , _jack_input_port (0)
- , _jack_output_port (0)
+ , _jack_port (0)
, _last_read_index (0)
, output_fifo (512)
, input_fifo (1024)
+ , _flags (flags)
{
- init (name, mode);
+ assert (jack_client);
+ init (name, flags);
}
Port::Port (const XMLNode& node, jack_client_t* jack_client)
: _currently_in_cycle (false)
, _nframes_this_cycle (0)
, _jack_client (jack_client)
- , _jack_input_port (0)
- , _jack_output_port (0)
+ , _jack_port (0)
, _last_read_index (0)
, output_fifo (512)
, input_fifo (1024)
{
+ assert (jack_client);
+
Descriptor desc (node);
- init (desc.tag, desc.mode);
+ init (desc.tag, desc.flags);
set_state (node);
}
void
-Port::init (string const & name, int mode)
+Port::init (string const & name, Flags flags)
{
_ok = false; /* derived class must set to true if constructor
succeeds.
*/
- input_parser = 0;
- output_parser = 0;
+ _parser = 0;
_tagname = name;
- _mode = mode;
+ _flags = flags;
- if (_mode == O_RDONLY || _mode == O_RDWR) {
- input_parser = new Parser (*this);
- } else {
- input_parser = 0;
- }
-
- if (_mode == O_WRONLY || _mode == O_RDWR) {
- output_parser = new Parser (*this);
- } else {
- output_parser = 0;
- }
+ _parser = new Parser (*this);
for (int i = 0; i < 16; i++) {
- _channel[i] = new Channel (i, *this);
-
- if (input_parser) {
- _channel[i]->connect_input_signals ();
- }
-
- if (output_parser) {
- _channel[i]->connect_output_signals ();
- }
+ _channel[i] = new Channel (i, *this);
+ _channel[i]->connect_signals ();
}
- create_port_names ();
-
- if (!create_ports ()) {
+ if (!create_port ()) {
_ok = true;
}
delete _channel[i];
}
- if (_jack_input_port) {
- if (_jack_client && _jack_input_port) {
- jack_port_unregister (_jack_client, _jack_input_port);
- }
- _jack_input_port = 0;
- }
-
- if (_jack_output_port) {
- if (_jack_client && _jack_output_port) {
- jack_port_unregister (_jack_client, _jack_output_port);
+ if (_jack_port) {
+ if (_jack_client && _jack_port) {
+ jack_port_unregister (_jack_client, _jack_port);
}
- _jack_output_port = 0;
+ _jack_port = 0;
}
}
void
-Port::parse (nframes_t timestamp)
+Port::parse (framecnt_t timestamp)
{
byte buf[512];
once it has data ready.
*/
- if (input_parser) {
- input_parser->set_timestamp (timestamp);
- }
+ _parser->set_timestamp (timestamp);
while (1) {
{
static byte clockmsg = 0xf8;
- if (_mode != O_RDONLY) {
+ if (sends_output()) {
return midimsg (&clockmsg, 1, timestamp);
}
}
void
-Port::cycle_start (nframes_t nframes)
+Port::cycle_start (pframes_t nframes)
{
+ assert (_jack_port);
+
_currently_in_cycle = true;
_nframes_this_cycle = nframes;
_last_read_index = 0;
_last_write_timestamp = 0;
- if (_jack_output_port != 0) {
- // output
- void *buffer = jack_port_get_buffer (_jack_output_port, nframes);
+ if (sends_output()) {
+ void *buffer = jack_port_get_buffer (_jack_port, nframes);
jack_midi_clear_buffer (buffer);
flush (buffer);
}
- if (_jack_input_port != 0) {
- // input
- void* jack_buffer = jack_port_get_buffer(_jack_input_port, nframes);
- const nframes_t event_count = jack_midi_get_event_count(jack_buffer);
+ if (receives_input()) {
+ void* jack_buffer = jack_port_get_buffer(_jack_port, nframes);
+ const pframes_t event_count = jack_midi_get_event_count(jack_buffer);
jack_midi_event_t ev;
timestamp_t cycle_start_frame = jack_last_frame_time (_jack_client);
- for (nframes_t i = 0; i < event_count; ++i) {
+ for (pframes_t i = 0; i < event_count; ++i) {
jack_midi_event_get (&ev, jack_buffer, i);
input_fifo.write (cycle_start_frame + ev.time, (Evoral::EventType) 0, ev.size, ev.buffer);
}
void
Port::cycle_end ()
{
- if (_jack_output_port != 0) {
- flush (jack_port_get_buffer (_jack_output_port, _nframes_this_cycle));
+ if (sends_output()) {
+ flush (jack_port_get_buffer (_jack_port, _nframes_this_cycle));
}
_currently_in_cycle = false;
os << "MIDI::Port { ";
os << "name: " << port.name();
os << "; ";
- os << "mode: " << port.mode();
- os << "; ";
os << "ok: " << port.ok();
os << "; ";
os << " }";
if ((prop = node.property ("mode")) != 0) {
- mode = O_RDWR;
-
if (strings_equal_ignore_case (prop->value(), "output") || strings_equal_ignore_case (prop->value(), "out")) {
- mode = O_WRONLY;
+ flags = IsOutput;
} else if (strings_equal_ignore_case (prop->value(), "input") || strings_equal_ignore_case (prop->value(), "in")) {
- mode = O_RDONLY;
+ flags = IsInput;
}
have_mode = true;
Port::jack_halted ()
{
_jack_client = 0;
- _jack_input_port = 0;
- _jack_output_port = 0;
+ _jack_port = 0;
}
int
{
int ret = 0;
- if (!_jack_output_port) {
+ if (!sends_output()) {
return ret;
}
timestamp = _last_write_timestamp;
}
- if (jack_midi_event_write (jack_port_get_buffer (_jack_output_port, _nframes_this_cycle),
+ if (jack_midi_event_write (jack_port_get_buffer (_jack_port, _nframes_this_cycle),
timestamp, msg, msglen) == 0) {
ret = msglen;
_last_write_timestamp = timestamp;
} else {
ret = 0;
cerr << "write of " << msglen << " failed, port holds "
- << jack_midi_get_event_count (jack_port_get_buffer (_jack_output_port, _nframes_this_cycle))
+ << jack_midi_get_event_count (jack_port_get_buffer (_jack_port, _nframes_this_cycle))
<< endl;
}
} else {
}
}
- if (ret > 0 && output_parser) {
+ if (ret > 0 && _parser) {
// ardour doesn't care about this and neither should your app, probably
// output_parser->raw_preparse (*output_parser, msg, ret);
for (int i = 0; i < ret; i++) {
- output_parser->scanner (msg[i]);
+ _parser->scanner (msg[i]);
}
// ardour doesn't care about this and neither should your app, probably
// output_parser->raw_postparse (*output_parser, msg, ret);
int
Port::read (byte *, size_t)
{
+ if (!receives_input()) {
+ return 0;
+ }
+
timestamp_t time;
Evoral::EventType type;
uint32_t size;
byte buffer[input_fifo.capacity()];
while (input_fifo.read (&time, &type, &size, buffer)) {
- if (input_parser) {
- input_parser->set_timestamp (time);
- for (uint32_t i = 0; i < size; ++i) {
- input_parser->scanner (buffer[i]);
- }
+ _parser->set_timestamp (time);
+ for (uint32_t i = 0; i < size; ++i) {
+ _parser->scanner (buffer[i]);
}
}
return 0;
}
-void
-Port::create_port_names ()
-{
- assert(!_jack_input_port);
- assert(!_jack_output_port);
-
- if (_mode == O_RDWR || _mode == O_WRONLY) {
- _jack_output_port_name = _tagname.append ("_out");
- }
-
- if (_mode == O_RDWR || _mode == O_RDONLY) {
- _jack_input_port_name = _tagname.append ("_in");
- }
-}
-
int
-Port::create_ports ()
+Port::create_port ()
{
- bool ret = true;
-
- jack_nframes_t nframes = jack_get_buffer_size(_jack_client);
-
- if (!_jack_output_port_name.empty()) {
- _jack_output_port = jack_port_register(_jack_client, _jack_output_port_name.c_str(),
- JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
- if (_jack_output_port) {
- jack_midi_clear_buffer(jack_port_get_buffer(_jack_output_port, nframes));
- }
- ret = ret && (_jack_output_port != NULL);
- }
-
- if (!_jack_input_port_name.empty()) {
- _jack_input_port = jack_port_register(_jack_client, _jack_input_port_name.c_str(),
- JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
- if (_jack_input_port) {
- jack_midi_clear_buffer(jack_port_get_buffer(_jack_input_port, nframes));
- }
- ret = ret && (_jack_input_port != NULL);
- }
-
- return ret ? 0 : -1;
+ _jack_port = jack_port_register(_jack_client, _tagname.c_str(), JACK_DEFAULT_MIDI_TYPE, _flags, 0);
+ return _jack_port == 0 ? -1 : 0;
}
XMLNode&
Port::get_state () const
{
- XMLNode* root = new XMLNode ("MIDI-port");
+ XMLNode* root = new XMLNode (state_node_name);
root->add_property ("tag", _tagname);
- if (_mode == O_RDONLY) {
+ if (_flags == IsInput) {
root->add_property ("mode", "input");
- } else if (_mode == O_WRONLY) {
- root->add_property ("mode", "output");
} else {
- root->add_property ("mode", "duplex");
+ root->add_property ("mode", "output");
}
#if 0
write (device_inquiry, sizeof (device_inquiry), 0);
#endif
- if (_jack_output_port) {
+ if (_jack_port) {
- const char** jc = jack_port_get_connections (_jack_output_port);
+ const char** jc = jack_port_get_connections (_jack_port);
string connection_string;
if (jc) {
for (int i = 0; jc[i]; ++i) {
}
if (!connection_string.empty()) {
- root->add_property ("outbound", connection_string);
- }
- } else {
- if (!_outbound_connections.empty()) {
- root->add_property ("outbound", _outbound_connections);
- }
- }
-
- if (_jack_input_port) {
-
- const char** jc = jack_port_get_connections (_jack_input_port);
- string connection_string;
- if (jc) {
- for (int i = 0; jc[i]; ++i) {
- if (i > 0) {
- connection_string += ',';
- }
- connection_string += jc[i];
- }
- free (jc);
- }
-
- if (!connection_string.empty()) {
- root->add_property ("inbound", connection_string);
+ root->add_property ("connections", connection_string);
}
} else {
- if (!_inbound_connections.empty()) {
- root->add_property ("inbound", _inbound_connections);
+ if (!_connections.empty()) {
+ root->add_property ("connections", _connections);
}
}
{
const XMLProperty* prop;
- if ((prop = node.property ("inbound")) != 0 && _jack_input_port) {
- _inbound_connections = prop->value ();
+ if ((prop = node.property ("tag")) == 0 || prop->value() != _tagname) {
+ return;
}
- if ((prop = node.property ("outbound")) != 0 && _jack_output_port) {
- _outbound_connections = prop->value();
+ if ((prop = node.property ("connections")) != 0 && _jack_port) {
+ _connections = prop->value ();
}
}
void
Port::make_connections ()
{
- if (!_inbound_connections.empty()) {
+ if (!_connections.empty()) {
vector<string> ports;
- split (_inbound_connections, ports, ',');
+ split (_connections, ports, ',');
for (vector<string>::iterator x = ports.begin(); x != ports.end(); ++x) {
if (_jack_client) {
- jack_connect (_jack_client, (*x).c_str(), jack_port_name (_jack_input_port));
+ if (receives_input()) {
+ jack_connect (_jack_client, (*x).c_str(), jack_port_name (_jack_port));
+ } else {
+ jack_connect (_jack_client, jack_port_name (_jack_port), (*x).c_str());
+ }
/* ignore failures */
}
}
}
- if (!_outbound_connections.empty()) {
- vector<string> ports;
- split (_outbound_connections, ports, ',');
- for (vector<string>::iterator x = ports.begin(); x != ports.end(); ++x) {
- if (_jack_client) {
- jack_connect (_jack_client, jack_port_name (_jack_output_port), (*x).c_str());
- /* ignore failures */
- }
- }
- }
connect_connection.disconnect ();
}
}
void
-Port::reestablish (void* jack)
+Port::reestablish (jack_client_t* jack)
{
- _jack_client = static_cast<jack_client_t*> (jack);
- int const r = create_ports ();
+ _jack_client = jack;
+ int const r = create_port ();
if (r) {
PBD::error << "could not reregister ports for " << name() << endmsg;
projects / ardour.git / blobdiff