X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fbundle.cc;h=f409e0beee4eb1493e9696a3f772a4564213539f;hb=9e0d03020ff47773f7d1c0414de1c74e6c9e0dac;hp=0d8c36a84f4fffec9b921e3e5861358c6f9fc98e;hpb=449aab3c465bbbf66d221fac3d7ea559f1720357;p=ardour.git diff --git a/libs/ardour/bundle.cc b/libs/ardour/bundle.cc index 0d8c36a84f..f409e0beee 100644 --- a/libs/ardour/bundle.cc +++ b/libs/ardour/bundle.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002 Paul Davis + Copyright (C) 2002 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -19,84 +19,124 @@ #include -#include -#include -#include -#include +#include "pbd/failed_constructor.h" +#include "ardour/ardour.h" +#include "ardour/bundle.h" +#include "ardour/audioengine.h" +#include "ardour/port.h" +#include "pbd/xml++.h" #include "i18n.h" +using namespace std; using namespace ARDOUR; using namespace PBD; -/** Construct a Bundle from an XML node. - * @param node XML node. +/** Construct an audio bundle. + * @param i true if ports are inputs, otherwise false. */ -Bundle::Bundle (const XMLNode& node) +Bundle::Bundle (bool i) + : _type (DataType::AUDIO), + _ports_are_inputs (i), + _signals_suspended (false), + _pending_change (Change (0)) { - if (set_state (node)) { - throw failed_constructor(); - } + } -/** Construct an InputBundle from an XML node. - * @param node XML node. + +/** Construct an audio bundle. + * @param n Name. + * @param i true if ports are inputs, otherwise false. */ -InputBundle::InputBundle (const XMLNode& node) - : Bundle (node) +Bundle::Bundle (std::string const & n, bool i) + : _name (n), + _type (DataType::AUDIO), + _ports_are_inputs (i), + _signals_suspended (false), + _pending_change (Change (0)) { - + } -/** Construct an OutputBundle from an XML node. - * @param node XML node. + +/** Construct a bundle. + * @param n Name. + * @param t Type. + * @param i true if ports are inputs, otherwise false. */ -OutputBundle::OutputBundle (const XMLNode& node) - : Bundle (node) +Bundle::Bundle (std::string const & n, DataType t, bool i) + : _name (n), + _type (t), + _ports_are_inputs (i), + _signals_suspended (false), + _pending_change (Change (0)) { - + } -/** Set the name. - * @param name New name. - */ -void -Bundle::set_name (string name, void *src) + +Bundle::Bundle (boost::shared_ptr other) + : _channel (other->_channel), + _name (other->_name), + _type (other->_type), + _ports_are_inputs (other->_ports_are_inputs), + _signals_suspended (other->_signals_suspended), + _pending_change (other->_pending_change) +{ + +} + +uint32_t +Bundle::nchannels () const { - _name = name; - NameChanged (src); + Glib::Mutex::Lock lm (_channel_mutex); + return _channel.size (); +} + +Bundle::PortList const & +Bundle::channel_ports (uint32_t c) const +{ + assert (c < nchannels()); + + Glib::Mutex::Lock lm (_channel_mutex); + return _channel[c].ports; } -/** Add an association between one of our channels and a JACK port. - * @param ch Channel index. - * @param portname JACK port name to associate with. +/** Add an association between one of our channels and a port. + * @param ch Channel index. + * @param portname full port name to associate with (including prefix). */ void -Bundle::add_port_to_channel (int ch, string portname) +Bundle::add_port_to_channel (uint32_t ch, string portname) { + assert (ch < nchannels()); + assert (portname.find_first_of (':') != string::npos); + { - Glib::Mutex::Lock lm (channels_lock); - _channels[ch].push_back (portname); + Glib::Mutex::Lock lm (_channel_mutex); + _channel[ch].ports.push_back (portname); } - - PortsChanged (ch); /* EMIT SIGNAL */ + + emit_changed (PortsChanged); } -/** Disassociate a JACK port from one of our channels. - * @param ch Channel index. - * @param portname JACK port name to disassociate from. +/** Disassociate a port from one of our channels. + * @param ch Channel index. + * @param portname port name to disassociate from. */ - void -Bundle::remove_port_from_channel (int ch, string portname) +Bundle::remove_port_from_channel (uint32_t ch, string portname) { + assert (ch < nchannels()); + bool changed = false; { - Glib::Mutex::Lock lm (channels_lock); - PortList& pl = _channels[ch]; + Glib::Mutex::Lock lm (_channel_mutex); + PortList& pl = _channel[ch].ports; PortList::iterator i = find (pl.begin(), pl.end(), portname); - + if (i != pl.end()) { pl.erase (i); changed = true; @@ -104,179 +144,348 @@ Bundle::remove_port_from_channel (int ch, string portname) } if (changed) { - PortsChanged (ch); /* EMIT SIGNAL */ + emit_changed (PortsChanged); } } -/** - * @param ch Channel index. - * @return List of JACK ports that this channel is connected to. +/** Set a single port to be associated with a channel, removing any others. + * @param ch Channel. + * @param portname Full port name, including prefix. */ -const Bundle::PortList& -Bundle::channel_ports (int ch) const +void +Bundle::set_port (uint32_t ch, string portname) +{ + assert (ch < nchannels()); + assert (portname.find_first_of (':') != string::npos); + + { + Glib::Mutex::Lock lm (_channel_mutex); + _channel[ch].ports.clear (); + _channel[ch].ports.push_back (portname); + } + + emit_changed (PortsChanged); +} + +/** @param n Channel name */ +void +Bundle::add_channel (std::string const & n) { - Glib::Mutex::Lock lm (channels_lock); - return _channels[ch]; + { + Glib::Mutex::Lock lm (_channel_mutex); + _channel.push_back (Channel (n)); + } + + emit_changed (ConfigurationChanged); } -/** operator== for Bundles; they are equal if their channels are the same. - * @param other Bundle to compare with this one. +bool +Bundle::port_attached_to_channel (uint32_t ch, std::string portname) +{ + assert (ch < nchannels()); + + Glib::Mutex::Lock lm (_channel_mutex); + return (std::find (_channel[ch].ports.begin (), _channel[ch].ports.end (), portname) != _channel[ch].ports.end ()); +} + +/** Remove a channel. + * @param ch Channel. + */ +void +Bundle::remove_channel (uint32_t ch) +{ + assert (ch < nchannels ()); + + Glib::Mutex::Lock lm (_channel_mutex); + _channel.erase (_channel.begin () + ch); +} + +/** Remove all channels */ +void +Bundle::remove_channels () +{ + Glib::Mutex::Lock lm (_channel_mutex); + + _channel.clear (); +} + +/** @param p Port name. + * @return true if any channel is associated with p. */ bool -Bundle::operator== (const Bundle& other) const +Bundle::uses_port (std::string p) const { - return other._channels == _channels; + Glib::Mutex::Lock lm (_channel_mutex); + + for (std::vector::const_iterator i = _channel.begin(); i != _channel.end(); ++i) { + for (PortList::const_iterator j = i->ports.begin(); j != i->ports.end(); ++j) { + if (*j == p) { + return true; + } + } + } + + return false; } +/** @param p Port name. + * @return true if this bundle offers this port on its own on a channel. + */ +bool +Bundle::offers_port_alone (std::string p) const +{ + Glib::Mutex::Lock lm (_channel_mutex); -/** Set the number of channels. - * @param n New number of channels. + for (std::vector::const_iterator i = _channel.begin(); i != _channel.end(); ++i) { + if (i->ports.size() == 1 && i->ports[0] == p) { + return true; + } + } + + return false; +} + + +/** @param ch Channel. + * @return Channel name. */ +std::string +Bundle::channel_name (uint32_t ch) const +{ + assert (ch < nchannels()); + + Glib::Mutex::Lock lm (_channel_mutex); + return _channel[ch].name; +} +/** Set the name of a channel. + * @param ch Channel. + * @param n New name. + */ void -Bundle::set_nchannels (int n) +Bundle::set_channel_name (uint32_t ch, std::string const & n) { + assert (ch < nchannels()); + { - Glib::Mutex::Lock lm (channels_lock); - _channels.clear (); - for (int i = 0; i < n; ++i) { - _channels.push_back (PortList()); - } + Glib::Mutex::Lock lm (_channel_mutex); + _channel[ch].name = n; } - ConfigurationChanged (); /* EMIT SIGNAL */ + emit_changed (NameChanged); } -XMLNode& -Bundle::get_state () +/** Take the channels from another bundle and add them to this bundle, + * so that channels from other are added to this (with their ports) + * and are named " ". + */ +void +Bundle::add_channels_from_bundle (boost::shared_ptr other) { - XMLNode *node; - string str; + uint32_t const ch = nchannels (); - if (dynamic_cast (this)) { - node = new XMLNode ("InputConnection"); - } else { - node = new XMLNode ("OutputConnection"); - } + for (uint32_t i = 0; i < other->nchannels(); ++i) { + + std::stringstream s; + s << other->name() << " " << other->channel_name(i); - node->add_property ("name", _name); + add_channel (s.str()); + + PortList const& pl = other->channel_ports (i); + for (uint32_t j = 0; j < pl.size(); ++j) { + add_port_to_channel (ch + i, pl[j]); + } + } +} - for (vector::iterator i = _channels.begin(); i != _channels.end(); ++i) { +/** Connect the ports associated with our channels to the ports associated + * with another bundle's channels. + * @param other Other bundle. + * @param engine AudioEngine to use to make the connections. + */ +void +Bundle::connect (boost::shared_ptr other, AudioEngine & engine) +{ + uint32_t const N = nchannels (); + assert (N == other->nchannels ()); - str += '{'; + for (uint32_t i = 0; i < N; ++i) { + Bundle::PortList const & our_ports = channel_ports (i); + Bundle::PortList const & other_ports = other->channel_ports (i); - for (vector::iterator ii = (*i).begin(); ii != (*i).end(); ++ii) { - if (ii != (*i).begin()) { - str += ','; + for (Bundle::PortList::const_iterator j = our_ports.begin(); j != our_ports.end(); ++j) { + for (Bundle::PortList::const_iterator k = other_ports.begin(); k != other_ports.end(); ++k) { + engine.connect (*j, *k); } - str += *ii; } - str += '}'; } +} - node->add_property ("connections", str); +void +Bundle::disconnect (boost::shared_ptr other, AudioEngine & engine) +{ + uint32_t const N = nchannels (); + assert (N == other->nchannels ()); + + for (uint32_t i = 0; i < N; ++i) { + Bundle::PortList const & our_ports = channel_ports (i); + Bundle::PortList const & other_ports = other->channel_ports (i); - return *node; + for (Bundle::PortList::const_iterator j = our_ports.begin(); j != our_ports.end(); ++j) { + for (Bundle::PortList::const_iterator k = other_ports.begin(); k != other_ports.end(); ++k) { + engine.disconnect (*j, *k); + } + } + } } -int -Bundle::set_state (const XMLNode& node) +/** Remove all ports from all channels */ +void +Bundle::remove_ports_from_channels () { - const XMLProperty *prop; + { + Glib::Mutex::Lock lm (_channel_mutex); + for (uint32_t c = 0; c < _channel.size(); ++c) { + _channel[c].ports.clear (); + } - if ((prop = node.property ("name")) == 0) { - error << _("Node for Connection has no \"name\" property") << endmsg; - return -1; } - _name = prop->value(); - _dynamic = false; - - if ((prop = node.property ("connections")) == 0) { - error << _("Node for Connection has no \"connections\" property") << endmsg; - return -1; + emit_changed (PortsChanged); +} + +/** Remove all ports from a given channel. + * @param ch Channel. + */ +void +Bundle::remove_ports_from_channel (uint32_t ch) +{ + assert (ch < nchannels ()); + + { + Glib::Mutex::Lock lm (_channel_mutex); + _channel[ch].ports.clear (); } - - set_channels (prop->value()); - return 0; + emit_changed (PortsChanged); } -/** Set up channels from an XML property string. - * @param str String. - * @return 0 on success, -1 on error. - */ -int -Bundle::set_channels (const string& str) +void +Bundle::suspend_signals () +{ + _signals_suspended = true; +} + +void +Bundle::resume_signals () { - vector ports; - int i; - int n; - int nchannels; - - if ((nchannels = count (str.begin(), str.end(), '{')) == 0) { - return 0; + if (_pending_change) { + Changed (_pending_change); + _pending_change = Change (0); } - set_nchannels (nchannels); + _signals_suspended = false; +} - string::size_type start, end, ostart; +void +Bundle::emit_changed (Change c) +{ + if (_signals_suspended) { + _pending_change = Change (int (_pending_change) | int (c)); + } else { + Changed (c); + } +} + +bool +Bundle::connected_to (boost::shared_ptr other, AudioEngine & engine) +{ + if (_ports_are_inputs == other->_ports_are_inputs || + _type != other->_type || + nchannels() != other->nchannels ()) { - ostart = 0; - start = 0; - end = 0; - i = 0; + return false; + } - while ((start = str.find_first_of ('{', ostart)) != string::npos) { - start += 1; + for (uint32_t i = 0; i < nchannels(); ++i) { + Bundle::PortList const & A = channel_ports (i); + Bundle::PortList const & B = other->channel_ports (i); - if ((end = str.find_first_of ('}', start)) == string::npos) { - error << string_compose(_("IO: badly formed string in XML node for inputs \"%1\""), str) << endmsg; - return -1; - } + for (uint32_t j = 0; j < A.size(); ++j) { + for (uint32_t k = 0; k < B.size(); ++k) { - if ((n = parse_io_string (str.substr (start, end - start), ports)) < 0) { - error << string_compose(_("bad input string in XML node \"%1\""), str) << endmsg; + Port* p = engine.get_port_by_name (A[j]); + Port* q = engine.get_port_by_name (B[k]); - return -1; - - } else if (n > 0) { + if (!p && !q) { + return false; + } - for (int x = 0; x < n; ++x) { - add_port_to_channel (i, ports[x]); + if (p && !p->connected_to (B[k])) { + return false; + } else if (q && !q->connected_to (A[j])) { + return false; + } } } - - ostart = end+1; - i++; } - return 0; + return true; } -int -Bundle::parse_io_string (const string& str, vector& ports) +/** Set the type of the ports in this Bundle. + * @param t New type. + */ +void +Bundle::set_type (DataType t) { - string::size_type pos, opos; + _type = t; + emit_changed (TypeChanged); +} - if (str.length() == 0) { - return 0; - } +void +Bundle::set_ports_are_inputs () +{ + _ports_are_inputs = true; + emit_changed (DirectionChanged); +} - pos = 0; - opos = 0; +void +Bundle::set_ports_are_outputs () +{ + _ports_are_inputs = false; + emit_changed (DirectionChanged); +} - ports.clear (); +/** Set the name. + * @param n New name. + */ +void +Bundle::set_name (string const & n) +{ + _name = n; + emit_changed (NameChanged); +} - while ((pos = str.find_first_of (',', opos)) != string::npos) { - ports.push_back (str.substr (opos, pos - opos)); - opos = pos + 1; +/** @param b Other bundle. + * @return true if b has the same number of channels as this bundle, and those channels have corresponding ports. + */ +bool +Bundle::has_same_ports (boost::shared_ptr b) const +{ + uint32_t const N = nchannels (); + + if (b->nchannels() != N) { + return false; } - - if (opos < str.length()) { - ports.push_back (str.substr(opos)); + + /* XXX: probably should sort channel port lists before comparing them */ + + for (uint32_t i = 0; i < N; ++i) { + if (channel_ports (i) != b->channel_ports (i)) { + return false; + } } - return ports.size(); + return true; } -