X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fbundle.h;h=ef2247f12b84338e609fa594f44e605853fac933;hb=94e0a15325278ec26dbeba4990a0e883db859338;hp=ba92063b309dbbc00a9e656f3f1664d9b0a22353;hpb=77f16522e0b396262bc272c1637753faa9da0ba7;p=ardour.git diff --git a/libs/ardour/ardour/bundle.h b/libs/ardour/ardour/bundle.h index ba92063b30..ef2247f12b 100644 --- a/libs/ardour/ardour/bundle.h +++ b/libs/ardour/ardour/bundle.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2007 Paul Davis + Copyright (C) 2002-2007 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 @@ -21,53 +21,156 @@ #define __ardour_bundle_h__ #include -#include +#include +#include +#include + +#include "pbd/signals.h" + #include "ardour/data_type.h" +#include "ardour/chan_count.h" namespace ARDOUR { -typedef std::vector PortList; - -/** - * A set of `channels', each of which is associated with 0 or more JACK ports. - */ +class AudioEngine; -class Bundle { +/** A set of `channels', each of which is associated with 0 or more ports. + * Each channel has a name which can be anything useful, and a data type. + * Intended for grouping things like, for example, a buss' outputs. + * `Channel' is a rather overloaded term but I can't think of a better + * one right now. + */ +class LIBARDOUR_API Bundle : public PBD::ScopedConnectionList +{ public: - Bundle () : _type (DataType::AUDIO) {} - Bundle (bool i) : _type (DataType::AUDIO), _ports_are_inputs (i) {} - Bundle (std::string const & n, bool i = true) : _name (n), _type (DataType::AUDIO), _ports_are_inputs (i) {} - virtual ~Bundle() {} - /** - * @return Number of channels that this Bundle has. - */ - virtual uint32_t nchannels () const = 0; - virtual const PortList& channel_ports (uint32_t) const = 0; + /// List of ports associated with a channel. We can't use a + /// PortSet because we might want to involve non-Ardour ports + /// (ie those without a Port object) + typedef std::vector PortList; - void set_name (std::string const & n) { - _name = n; - NameChanged (); - } - - std::string name () const { return _name; } + struct Channel { + Channel (std::string n, DataType t) : name (n), type (t) {} + Channel (std::string n, DataType t, PortList p) : name (n), type (t), ports (p) {} + Channel (std::string n, DataType t, std::string const & p) : name (n), type (t) { + ports.push_back (p); + } - sigc::signal NameChanged; + bool operator== (Channel const &o) const { + return name == o.name && type == o.type && ports == o.ports; + } - void set_type (DataType t) { _type = t; } - DataType type () const { return _type; } + std::string name; + DataType type; + PortList ports; + }; - void set_ports_are_inputs () { _ports_are_inputs = true; } - void set_ports_are_outputs () { _ports_are_inputs = false; } + Bundle (bool i = true); + Bundle (std::string const &, bool i = true); + Bundle (boost::shared_ptr); + + virtual ~Bundle() {} + + /** @return Number of channels that this Bundle has */ + ChanCount nchannels () const; + + /** @param Channel index. + * @return Ports associated with this channel. + */ + PortList const & channel_ports (uint32_t) const; + + void add_channel (std::string const &, DataType); + void add_channel (std::string const &, DataType, std::string const &); + void add_channel (std::string const &, DataType, PortList); + std::string channel_name (uint32_t) const; + DataType channel_type (uint32_t) const; + void set_channel_name (uint32_t, std::string const &); + void add_port_to_channel (uint32_t, std::string); + void set_port (uint32_t, std::string); + void remove_port_from_channel (uint32_t, std::string); + void remove_ports_from_channel (uint32_t); + void remove_ports_from_channels (); + bool port_attached_to_channel (uint32_t, std::string); + bool offers_port (std::string) const; + bool offers_port_alone (std::string) const; + void remove_channel (uint32_t); + void remove_channels (); + void add_channels_from_bundle (boost::shared_ptr); + void connect (boost::shared_ptr, AudioEngine &); + void disconnect (boost::shared_ptr, AudioEngine &); + bool connected_to (boost::shared_ptr, AudioEngine &); + bool connected_to_anything (AudioEngine &); + bool has_same_ports (boost::shared_ptr) const; + uint32_t type_channel_to_overall (DataType, uint32_t) const; + uint32_t overall_channel_to_type (DataType, uint32_t) const; + + void set_name (std::string const &); + + /** @return Bundle name */ + std::string name () const { return _name; } + + void set_ports_are_inputs (); + void set_ports_are_outputs (); bool ports_are_inputs () const { return _ports_are_inputs; } bool ports_are_outputs () const { return !_ports_are_inputs; } + void suspend_signals (); + void resume_signals (); + + bool operator== (Bundle const & other); + + /** Things that might change about this bundle */ + enum Change { + NameChanged = 0x1, ///< the bundle name or a channel name has changed + ConfigurationChanged = 0x2, ///< the number of channels has changed + PortsChanged = 0x4, ///< the port list associated with one of our channels has changed + TypeChanged = 0x8, ///< the data type has changed + DirectionChanged = 0x10 ///< the direction (whether ports are inputs or outputs) has changed + }; + + PBD::Signal1 Changed; + + protected: + + /// mutex for _channel_ports and _channel_names + /// XXX: is this necessary? + mutable Glib::Threads::Mutex _channel_mutex; + std::vector _channel; + private: + int set_channels (std::string const &); + int parse_io_string (std::string const &, std::vector &); + void emit_changed (Change); + std::string _name; - ARDOUR::DataType _type; bool _ports_are_inputs; + + bool _signals_suspended; + Change _pending_change; +}; + +class LIBARDOUR_API BundleChannel +{ +public: + BundleChannel () : channel (-1) {} + + BundleChannel (boost::shared_ptr b, int c) + : bundle (b), channel (c) {} + + bool operator== (BundleChannel const& other) const { + return bundle == other.bundle && channel == other.channel; + } + + bool operator!= (BundleChannel const& other) const { + return bundle != other.bundle || channel != other.channel; + } + + boost::shared_ptr bundle; + int channel; ///< channel index, or -1 for "all" }; } +std::ostream & operator<< (std::ostream & o, ARDOUR::Bundle const &); + #endif /* __ardour_bundle_h__ */