Port* p = Manager::instance()->port (_port_combo.get_active_text());
if (p) {
- Parser* parser = p->input() ? p->input() : p->output();
- parser->any.connect_same_thread (_parser_connection, boost::bind (&MidiTracer::tracer, this, _1, _2, _3));
+ p->parser()->any.connect_same_thread (_parser_connection, boost::bind (&MidiTracer::tracer, this, _1, _2, _3));
}
}
DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MIDIClock_Slave: connecting to port %1\n", port->name()));
- port->input()->timing.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::update_midi_clock, this, _1, _2));
- port->input()->start.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::start, this, _1, _2));
- port->input()->contineu.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::contineu, this, _1, _2));
- port->input()->stop.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::stop, this, _1, _2));
- port->input()->position.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::position, this, _1, _2, 3));
+ port->parser()->timing.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::update_midi_clock, this, _1, _2));
+ port->parser()->start.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::start, this, _1, _2));
+ port->parser()->contineu.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::contineu, this, _1, _2));
+ port->parser()->stop.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::stop, this, _1, _2));
+ port->parser()->position.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::position, this, _1, _2, 3));
}
void
port = &p;
- port->input()->mtc_time.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
- port->input()->mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
- port->input()->mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
+ port->parser()->mtc_time.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
+ port->parser()->mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
+ port->parser()->mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
}
void
bool
MTC_Slave::locked () const
{
- return port->input()->mtc_locked();
+ return port->parser()->mtc_locked();
}
bool
ahead of the window root (taking direction into account).
*/
- switch (port->input()->mtc_running()) {
+ switch (port->parser()->mtc_running()) {
case MTC_Forward:
window_begin = root;
if (session.slave_state() == Session::Running) {
MIDI::Manager* m = MIDI::Manager::instance ();
- _mtc_input_port = m->add_port (new MIDI::Port ("MTC", O_RDONLY, _engine.jack()));
- _mtc_output_port = m->add_port (new MIDI::Port ("MTC", O_WRONLY, _engine.jack()));
- _midi_input_port = m->add_port (new MIDI::Port ("MIDI control", O_RDONLY, _engine.jack()));
- _midi_output_port = m->add_port (new MIDI::Port ("MIDI control", O_WRONLY, _engine.jack()));
- _midi_clock_input_port = m->add_port (new MIDI::Port ("MIDI clock", O_RDONLY, _engine.jack()));
- _midi_clock_output_port = m->add_port (new MIDI::Port ("MIDI clock", O_WRONLY, _engine.jack()));
+ _mtc_input_port = m->add_port (new MIDI::Port ("MTC in", MIDI::Port::IsInput, _engine.jack()));
+ _mtc_output_port = m->add_port (new MIDI::Port ("MTC out", MIDI::Port::IsOutput, _engine.jack()));
+ _midi_input_port = m->add_port (new MIDI::Port ("MIDI control in", MIDI::Port::IsInput, _engine.jack()));
+ _midi_output_port = m->add_port (new MIDI::Port ("MIDI control out", MIDI::Port::IsOutput, _engine.jack()));
+ _midi_clock_input_port = m->add_port (new MIDI::Port ("MIDI clock in", MIDI::Port::IsInput, _engine.jack()));
+ _midi_clock_output_port = m->add_port (new MIDI::Port ("MIDI clock out", MIDI::Port::IsOutput, _engine.jack()));
}
int
}
void
-Channel::connect_input_signals ()
+Channel::connect_signals ()
{
- _port.input()->channel_pressure[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_chanpress, this, _1, _2));
- _port.input()->channel_note_on[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_note_on, this, _1, _2));
- _port.input()->channel_note_off[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_note_off, this, _1, _2));
- _port.input()->channel_poly_pressure[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_polypress, this, _1, _2));
- _port.input()->channel_program_change[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_program_change, this, _1, _2));
- _port.input()->channel_controller[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_controller, this, _1, _2));
- _port.input()->channel_pitchbend[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_pitchbend, this, _1, _2));
-
- _port.input()->reset.connect_same_thread (*this, boost::bind (&Channel::process_reset, this, _1));
-}
-
-void
-Channel::connect_output_signals ()
-{
- _port.output()->channel_pressure[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_chanpress, this, _1, _2));
- _port.output()->channel_note_on[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_note_on, this, _1, _2));
- _port.output()->channel_note_off[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_note_off, this, _1, _2));
- _port.output()->channel_poly_pressure[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_polypress, this, _1, _2));
- _port.output()->channel_program_change[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_program_change, this, _1, _2));
- _port.output()->channel_controller[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_controller, this, _1, _2));
- _port.output()->channel_pitchbend[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_pitchbend, this, _1, _2));
-
- _port.output()->reset.connect_same_thread (*this, boost::bind (&Channel::process_reset, this, _1));
+ _port.parser()->channel_pressure[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_chanpress, this, _1, _2));
+ _port.parser()->channel_note_on[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_note_on, this, _1, _2));
+ _port.parser()->channel_note_off[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_note_off, this, _1, _2));
+ _port.parser()->channel_poly_pressure[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_polypress, this, _1, _2));
+ _port.parser()->channel_program_change[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_program_change, this, _1, _2));
+ _port.parser()->channel_controller[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_controller, this, _1, _2));
+ _port.parser()->channel_pitchbend[_channel_number].connect_same_thread (*this, boost::bind (&Channel::process_pitchbend, this, _1, _2));
+
+ _port.parser()->reset.connect_same_thread (*this, boost::bind (&Channel::process_reset, this, _1));
}
void
if (tb->controller_number == 0) {
_bank_number = (unsigned short) _controller_val[0];
- if (_port.input()) {
- _port.input()->bank_change (*_port.input(), _bank_number);
- _port.input()->channel_bank_change[_channel_number]
- (*_port.input(), _bank_number);
- }
+ _port.parser()->bank_change (*_port.parser(), _bank_number);
+ _port.parser()->channel_bank_change[_channel_number] (*_port.parser(), _bank_number);
}
}
protected:
friend class Port;
- void connect_input_signals ();
- void connect_output_signals ();
+ void connect_signals ();
private:
Port & _port;
class Port {
public:
- Port (std::string const &, int, jack_client_t *);
+ enum Flags {
+ IsInput = JackPortIsInput,
+ IsOutput = JackPortIsOutput,
+ };
+
+ Port (std::string const &, Flags, jack_client_t *);
Port (const XMLNode&, jack_client_t *);
~Port ();
return _channel[chn&0x7F];
}
- Parser *input() { return input_parser; }
- Parser *output() { return output_parser; }
+ Parser* parser () {
+ return _parser;
+ }
const char *name () const { return _tagname.c_str(); }
- int mode () const { return _mode; }
bool ok () const { return _ok; }
+ bool receives_input () const {
+ return _flags == IsInput;
+ }
+
+ bool sends_output () const {
+ return _flags == IsOutput;
+ }
+
struct Descriptor {
std::string tag;
- int mode;
+ Flags flags;
Descriptor (const XMLNode&);
XMLNode& get_state();
bool _currently_in_cycle;
nframes_t _nframes_this_cycle;
std::string _tagname;
- int _mode;
size_t _number;
Channel *_channel[16];
- Parser *input_parser;
- Parser *output_parser;
-
- static size_t nports;
+ Parser *_parser;
- void create_port_names ();
- int create_ports ();
+ int create_port ();
jack_client_t* _jack_client;
- std::string _jack_input_port_name; /// input port name, or empty if there isn't one
- jack_port_t* _jack_input_port;
- std::string _jack_output_port_name; /// output port name, or empty if there isn't one
- jack_port_t* _jack_output_port;
+ jack_port_t* _jack_port;
nframes_t _last_read_index;
timestamp_t _last_write_timestamp;
/** Channel used to signal to the MidiControlUI that input has arrived */
CrossThreadChannel xthread;
- std::string _inbound_connections;
- std::string _outbound_connections;
+ std::string _connections;
PBD::ScopedConnection connect_connection;
PBD::ScopedConnection halt_connection;
void flush (void* jack_port_buffer);
void jack_halted ();
- void make_connections();
- void init (std::string const &, int);
+ void make_connections ();
+ void init (std::string const &, Flags);
static pthread_t _process_thread;
Evoral::EventRingBuffer<timestamp_t> input_fifo;
Glib::Mutex output_fifo_lock;
-
+
+ Flags _flags;
};
struct PortSet {
_receive_device_id = 0;
_send_device_id = 0x7f;
- _input_port = Manager::instance()->add_port (new Port ("MMC", O_RDONLY, jack));
- _output_port = Manager::instance()->add_port (new Port ("MMC", O_WRONLY, jack));
+ _input_port = Manager::instance()->add_port (new Port ("MMC in", Port::IsInput, jack));
+ _output_port = Manager::instance()->add_port (new Port ("MMC out", Port::IsOutput, jack));
- _input_port->input()->mmc.connect_same_thread (port_connections, boost::bind (&MachineControl::process_mmc_message, this, _1, _2, _3));
- _input_port->input()->start.connect_same_thread (port_connections, boost::bind (&MachineControl::spp_start, this, _1, _2));
- _input_port->input()->contineu.connect_same_thread (port_connections, boost::bind (&MachineControl::spp_continue, this, _1, _2));
- _input_port->input()->stop.connect_same_thread (port_connections, boost::bind (&MachineControl::spp_stop, this, _1, _2));
+ _input_port->parser()->mmc.connect_same_thread (port_connections, boost::bind (&MachineControl::process_mmc_message, this, _1, _2, _3));
+ _input_port->parser()->start.connect_same_thread (port_connections, boost::bind (&MachineControl::spp_start, this, _1, _2));
+ _input_port->parser()->contineu.connect_same_thread (port_connections, boost::bind (&MachineControl::spp_continue, this, _1, _2));
+ _input_port->parser()->stop.connect_same_thread (port_connections, boost::bind (&MachineControl::spp_stop, this, _1, _2));
}
void
using namespace std;
using namespace PBD;
-size_t Port::nports = 0;
pthread_t Port::_process_thread;
Signal0<void> Port::JackHalted;
Signal0<void> Port::MakeConnections;
-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);
+ 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)
{
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;
}
}
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);
}
_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);
+ if (receives_input()) {
+ void* jack_buffer = jack_port_get_buffer(_jack_port, nframes);
const nframes_t event_count = jack_midi_get_event_count(jack_buffer);
jack_midi_event_t ev;
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);
+ _jack_port = jack_port_register(_jack_client, _tagname.c_str(), JACK_DEFAULT_MIDI_TYPE, _flags, 0);
+ if (_jack_port) {
+ jack_midi_clear_buffer (jack_port_get_buffer (_jack_port, jack_get_buffer_size (_jack_client)));
}
- return ret ? 0 : -1;
+ return _jack_port == 0 ? -1 : 0;
}
XMLNode&
XMLNode* root = new XMLNode ("MIDI-port");
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);
+ root->add_property ("connections", 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);
- }
- } 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 ("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 ();
}
Port::reestablish (void* jack)
{
_jack_client = static_cast<jack_client_t*> (jack);
- int const r = create_ports ();
+ int const r = create_port ();
if (r) {
PBD::error << "could not reregister ports for " << name() << endmsg;
MIDIControllable::learn_about_external_control ()
{
drop_external_control ();
- _port.input()->any.connect_same_thread (midi_learn_connection, boost::bind (&MIDIControllable::midi_receiver, this, _1, _2, _3));
+ _port.parser()->any.connect_same_thread (midi_learn_connection, boost::bind (&MIDIControllable::midi_receiver, this, _1, _2, _3));
}
void
/* if the our port doesn't do input anymore, forget it ... */
- if (!_port.input()) {
+ if (!_port.parser()) {
return;
}
control_channel = chn;
control_additional = additional;
- if (_port.input() == 0) {
+ if (_port.parser() == 0) {
return;
}
- Parser& p = *_port.input();
+ Parser& p = *_port.parser();
int chn_i = chn;
switch (ev) {
control_channel = chn;
control_additional = additional;
- if (_port.input() == 0) {
+ if (_port.parser() == 0) {
return;
}
- Parser& p = *_port.input();
+ Parser& p = *_port.parser();
int chn_i = chn;
}
void
-MackieControlProtocol::add_port (MIDI::Port & midi_port, int number)
+MackieControlProtocol::add_port (MIDI::Port & midi_input_port, MIDI::Port & midi_output_port, int number)
{
- DEBUG_TRACE (DEBUG::MackieControl, string_compose ("add port %1\n", midi_port.name()));
+ DEBUG_TRACE (DEBUG::MackieControl, string_compose ("add port %1 %2\n", midi_input_port.name(), midi_output_port.name()));
- MackiePort * sport = new MackiePort (*this, midi_port, number);
+ MackiePort * sport = new MackiePort (*this, midi_input_port, midi_output_port, number);
_ports.push_back (sport);
sport->init_event.connect_same_thread (port_connections, boost::bind (&MackieControlProtocol::handle_port_init, this, sport));
MackieControlProtocol::create_ports()
{
MIDI::Manager * mm = MIDI::Manager::instance();
- MIDI::Port * midi_port = mm->add_port (new MIDI::Port (default_port_name, O_RDWR, session->engine().jack()));
+ MIDI::Port * midi_input_port = mm->add_port (new MIDI::Port (default_port_name, MIDI::Port::IsInput, session->engine().jack()));
+ MIDI::Port * midi_output_port = mm->add_port (new MIDI::Port (default_port_name, MIDI::Port::IsOutput, session->engine().jack()));
// open main port
- if (!midi_port->ok()) {
+ if (!midi_input_port->ok() || !midi_output_port->ok()) {
ostringstream os;
- os << string_compose (_("no MIDI port named \"%1\" exists - Mackie control disabled"), default_port_name);
+ os << _("Mackie control MIDI ports could not be created; Mackie control disabled");
error << os.str() << endmsg;
throw MackieControlException (os.str());
}
- add_port (*midi_port, 0);
+ add_port (*midi_input_port, *midi_output_port, 0);
// open extender ports. Up to 9. Should be enough.
// could also use mm->get_midi_ports()
for (int index = 1; index <= 9; ++index) {
ostringstream os;
os << ext_port_base << index;
- MIDI::Port * midi_port = mm->add_port (new MIDI::Port (os.str(), O_RDWR, session->engine().jack()));
- if (midi_port->ok()) {
- add_port (*midi_port, index);
+ MIDI::Port * midi_input_port = mm->add_port (new MIDI::Port (os.str(), MIDI::Port::IsInput, session->engine().jack()));
+ MIDI::Port * midi_output_port = mm->add_port (new MIDI::Port (os.str(), MIDI::Port::IsOutput, session->engine().jack()));
+ if (midi_input_port->ok() && midi_output_port->ok()) {
+ add_port (*midi_input_port, *midi_output_port, index);
}
}
}
*/
bool handle_strip_button(Mackie::Control &, Mackie::ButtonState, boost::shared_ptr<ARDOUR::Route>);
- void add_port(MIDI::Port &, int number);
+ void add_port (MIDI::Port &, MIDI::Port &, int number);
/**
Read session data and send to surface. Includes
// The MCU extender sysex header
MidiByteArray mackie_sysex_hdr_xt ( 5, MIDI::sysex, 0x0, 0x0, 0x66, 0x11 );
-MackiePort::MackiePort( MackieControlProtocol & mcp, MIDI::Port & port, int number, port_type_t port_type )
- : SurfacePort( port, number )
- , _mcp( mcp )
- , _port_type( port_type )
- , _emulation( none )
- , _initialising( true )
+MackiePort::MackiePort (MackieControlProtocol & mcp, MIDI::Port & input_port, MIDI::Port & output_port, int number, port_type_t port_type)
+ : SurfacePort (input_port, output_port, number)
+ , _mcp( mcp )
+ , _port_type( port_type )
+ , _emulation( none )
+ , _initialising( true )
{
DEBUG_TRACE (DEBUG::MackieControl, "MackiePort::MackiePort\n");
}
{
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("MackiePort::open %1\n", *this));
- port().input()->sysex.connect_same_thread (sysex_connection, boost::bind (&MackiePort::handle_midi_sysex, this, _1, _2, _3));
+ input_port().parser()->sysex.connect_same_thread (sysex_connection, boost::bind (&MackiePort::handle_midi_sysex, this, _1, _2, _3));
// make sure the device is connected
init();
{
finalise_init( false );
ostringstream os;
- os << "expecting 18 bytes, read " << bytes << " from " << port().name();
+ os << "expecting 18 bytes, read " << bytes << " from " << input_port().name();
throw MackieControlException( os.str() );
}
{
finalise_init( false );
ostringstream os;
- os << "expecting 14 bytes, read " << bytes << " from " << port().name();
+ os << "expecting 14 bytes, read " << bytes << " from " << input_port().name();
throw MackieControlException( os.str() );
}
void MackiePort::connect_any()
{
if (!any_connection.connected()) {
- port().input()->any.connect_same_thread (any_connection, boost::bind (&MackiePort::handle_midi_any, this, _1, _2, _3));
+ input_port().parser()->any.connect_same_thread (any_connection, boost::bind (&MackiePort::handle_midi_any, this, _1, _2, _3));
}
}
enum port_type_t { mcu, ext };
enum emulation_t { none, mackie, bcf2000 };
- MackiePort( MackieControlProtocol & mcp, MIDI::Port & port, int number, port_type_t = mcu );
+ MackiePort (MackieControlProtocol & mcp, MIDI::Port & input_port, MIDI::Port & output_port, int number, port_type_t = mcu);
~MackiePort();
virtual void open();
using namespace Mackie;
SurfacePort::SurfacePort()
-: _port( 0 ), _number( 0 ), _active( false )
+ : _input_port (0), _output_port (0), _number (0), _active (false)
{
}
-SurfacePort::SurfacePort( MIDI::Port & port, int number )
-: _port( &port ), _number( number ), _active( false )
+SurfacePort::SurfacePort (MIDI::Port & input_port, MIDI::Port & output_port, int number)
+ : _input_port (&input_port), _output_port (&output_port), _number (number), _active (false)
{
}
#endif
// read port and copy to return value
- int nread = port().read( buf, sizeof (buf) );
+ int nread = input_port().read( buf, sizeof (buf) );
if (nread >= 0) {
retval.copy( nread, buf );
if ( errno != EAGAIN )
{
ostringstream os;
- os << "Surface: error reading from port: " << port().name();
+ os << "Surface: error reading from port: " << input_port().name();
os << ": " << errno << fetch_errmsg( errno );
cout << os.str() << endl;
Glib::RecMutex::Lock lock( _rwlock );
if ( !active() ) return;
- int count = port().write( mba.bytes().get(), mba.size(), 0);
+ int count = output_port().write( mba.bytes().get(), mba.size(), 0);
if ( count != (int)mba.size() )
{
if ( errno == 0 )
{
- cout << "port overflow on " << port().name() << ". Did not write all of " << mba << endl;
+ cout << "port overflow on " << output_port().name() << ". Did not write all of " << mba << endl;
}
else if ( errno != EAGAIN )
{
ostringstream os;
- os << "Surface: couldn't write to port " << port().name();
+ os << "Surface: couldn't write to port " << output_port().name();
os << ", error: " << fetch_errmsg( errno ) << "(" << errno << ")";
cout << os.str() << endl;
ostream & Mackie::operator << ( ostream & os, const SurfacePort & port )
{
os << "{ ";
- os << "name: " << port.port().name();
+ os << "name: " << port.input_port().name() << " " << port.output_port().name();
os << "; ";
os << " }";
return os;
class SurfacePort
{
public:
- SurfacePort( MIDI::Port & port, int number );
+ SurfacePort (MIDI::Port & input_port, MIDI::Port & output_port, int number);
virtual ~SurfacePort();
// when this is successful, active() should return true
/// return the correct sysex header for this port
virtual const MidiByteArray & sysex_hdr() const = 0;
- MIDI::Port & port() { return *_port; }
- const MIDI::Port & port() const { return *_port; }
+ MIDI::Port & input_port() { return *_input_port; }
+ const MIDI::Port & input_port() const { return *_input_port; }
+ MIDI::Port & output_port() { return *_output_port; }
+ const MIDI::Port & output_port() const { return *_output_port; }
// all control notofications are sent from here
PBD::Signal3<void,SurfacePort &, Control &, const ControlState &> control_event;
SurfacePort();
private:
- MIDI::Port * _port;
+ MIDI::Port * _input_port;
+ MIDI::Port * _output_port;
int _number;
bool _active;
projects / ardour.git / commitdiff