along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
#ifndef __ardour_io_h__
#include <pbd/fastlog.h>
#include <pbd/undo.h>
-
-#include <midi++/controllable.h>
+#include <pbd/statefuldestructible.h>
+#include <pbd/controllable.h>
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
+#include <ardour/automatable.h>
#include <ardour/utils.h>
-#include <ardour/state_manager.h>
-#include <ardour/curve.h>
+#include <ardour/types.h>
+#include <ardour/data_type.h>
+#include <ardour/port_set.h>
+#include <ardour/chan_count.h>
+#include <ardour/latent.h>
+#include <ardour/automation_control.h>
+#include <ardour/user_bundle.h>
using std::string;
using std::vector;
class Session;
class AudioEngine;
-class Port;
-class Connection;
+class Bundle;
+class AutoBundle;
class Panner;
+class PeakMeter;
+class Port;
+class AudioPort;
+class MidiPort;
+class BufferSet;
-class IO : public Stateful, public ARDOUR::StateManager
-{
+/** A collection of input and output ports with connections.
+ *
+ * An IO can contain ports of varying types, making routes/inserts/etc with
+ * varied combinations of types (eg MIDI and audio) possible.
+ */
+
+class IO : public Automatable, public Latent
+{
public:
static const string state_node_name;
- IO (Session&, string name,
+ IO (Session&, const string& name,
int input_min = -1, int input_max = -1,
- int output_min = -1, int output_max = -1);
-
+ int output_min = -1, int output_max = -1,
+ DataType default_type = DataType::AUDIO,
+ bool public_ports = true);
+
+ IO (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
+
virtual ~IO();
- int input_minimum() const { return _input_minimum; }
- int input_maximum() const { return _input_maximum; }
- int output_minimum() const { return _output_minimum; }
- int output_maximum() const { return _output_maximum; }
-
- void set_input_minimum (int n);
- void set_input_maximum (int n);
- void set_output_minimum (int n);
- void set_output_maximum (int n);
-
- const string& name() const { return _name; }
- virtual int set_name (string str, void *src);
+ ChanCount input_minimum() const { return _input_minimum; }
+ ChanCount input_maximum() const { return _input_maximum; }
+ ChanCount output_minimum() const { return _output_minimum; }
+ ChanCount output_maximum() const { return _output_maximum; }
+
+ void set_input_minimum (ChanCount n);
+ void set_input_maximum (ChanCount n);
+ void set_output_minimum (ChanCount n);
+ void set_output_maximum (ChanCount n);
+
+ bool active() const { return _active; }
+ void set_active (bool yn);
- virtual void silence (jack_nframes_t, jack_nframes_t offset);
+ DataType default_type() const { return _default_type; }
+ void set_default_type(DataType t) { _default_type = t; }
+
+ bool set_name (const string& str);
- void pan (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset, gain_t gain_coeff);
- void pan_automated (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset);
- void collect_input (vector<Sample*>&, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void deliver_output (vector<Sample *>&, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void deliver_output_no_pan (vector<Sample *>&, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void just_meter_input (jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset);
+ virtual void silence (nframes_t, nframes_t offset);
- virtual uint32_t n_process_buffers () { return 0; }
+ void collect_input (BufferSet& bufs, nframes_t nframes, nframes_t offset);
+ void deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset);
+ void just_meter_input (nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset);
- virtual void set_gain (gain_t g, void *src);
- void inc_gain (gain_t delta, void *src);
- gain_t gain () const { return _desired_gain; }
+ gain_t gain () const { return _desired_gain; }
virtual gain_t effective_gain () const;
+
+ void set_denormal_protection (bool yn, void *src);
+ bool denormal_protection() const { return _denormal_protection; }
+
+ void set_phase_invert (bool yn, void *src);
+ bool phase_invert() const { return _phase_invert; }
- Panner& panner() { return *_panner; }
-
- int ensure_io (uint32_t, uint32_t, bool clear, void *src);
+ Panner& panner() { return *_panner; }
+ PeakMeter& peak_meter() { return *_meter; }
+ const Panner& panner() const { return *_panner; }
+
+ int ensure_io (ChanCount in, ChanCount out, bool clear, void *src);
- int use_input_connection (Connection&, void *src);
- int use_output_connection (Connection&, void *src);
+ int connect_input_ports_to_bundle (boost::shared_ptr<Bundle>, void *src);
+ int connect_output_ports_to_bundle (boost::shared_ptr<Bundle>, void *src);
- Connection *input_connection() const { return _input_connection; }
- Connection *output_connection() const { return _output_connection; }
+ std::vector<boost::shared_ptr<Bundle> > bundles_connected_to_inputs ();
+ std::vector<boost::shared_ptr<Bundle> > bundles_connected_to_outputs ();
- int add_input_port (string source, void *src);
- int add_output_port (string destination, void *src);
+ boost::shared_ptr<AutoBundle> bundle_for_inputs () { return _bundle_for_inputs; }
+ boost::shared_ptr<AutoBundle> bundle_for_outputs () { return _bundle_for_outputs; }
+
+ int add_input_port (string source, void *src, DataType type = DataType::NIL);
+ int add_output_port (string destination, void *src, DataType type = DataType::NIL);
int remove_input_port (Port *, void *src);
int remove_output_port (Port *, void *src);
int disconnect_inputs (void *src);
int disconnect_outputs (void *src);
- jack_nframes_t output_latency() const;
- jack_nframes_t input_latency() const;
- void set_port_latency (jack_nframes_t);
+ nframes_t signal_latency() const { return _own_latency; }
+ nframes_t output_latency() const;
+ nframes_t input_latency() const;
+ void set_port_latency (nframes_t);
+
+ void update_port_total_latencies ();
+
+ const PortSet& inputs() const { return _inputs; }
+ const PortSet& outputs() const { return _outputs; }
Port *output (uint32_t n) const {
- if (n < _noutputs) {
- return _outputs[n];
+ if (n < _outputs.num_ports()) {
+ return _outputs.port(n);
} else {
return 0;
}
}
Port *input (uint32_t n) const {
- if (n < _ninputs) {
- return _inputs[n];
+ if (n < _inputs.num_ports()) {
+ return _inputs.port(n);
} else {
return 0;
}
}
- uint32_t n_inputs () const { return _ninputs; }
- uint32_t n_outputs () const { return _noutputs; }
+ AudioPort* audio_input(uint32_t n) const;
+ AudioPort* audio_output(uint32_t n) const;
+ MidiPort* midi_input(uint32_t n) const;
+ MidiPort* midi_output(uint32_t n) const;
+
+ const ChanCount& n_inputs () const { return _inputs.count(); }
+ const ChanCount& n_outputs () const { return _outputs.count(); }
+
+ void attach_buffers(ChanCount ignored);
+
+ sigc::signal<void> active_changed;
sigc::signal<void,IOChange,void*> input_changed;
sigc::signal<void,IOChange,void*> output_changed;
- sigc::signal<void,void*> gain_changed;
- sigc::signal<void,void*> name_changed;
-
virtual XMLNode& state (bool full);
XMLNode& get_state (void);
int set_state (const XMLNode&);
- virtual UndoAction get_memento() const;
-
-
static int disable_connecting (void);
static int enable_connecting (void);
static int reset_panners (void);
- static sigc::signal<int> PortsLegal;
- static sigc::signal<int> PannersLegal;
- static sigc::signal<int> ConnectingLegal;
- static sigc::signal<void,uint32_t> MoreOutputs;
- static sigc::signal<int> PortsCreated;
-
- /* MIDI control */
-
- void set_midi_to_gain_function (gain_t (*function)(double val)) {
- _midi_gain_control.midi_to_gain = function;
- }
-
- void set_gain_to_midi_function (double (*function)(gain_t gain)) {
- _midi_gain_control.gain_to_midi = function;
- }
-
- MIDI::Controllable& midi_gain_control() {
- return _midi_gain_control;
- }
-
- virtual void reset_midi_control (MIDI::Port*, bool on);
-
- virtual void send_all_midi_feedback ();
- virtual MIDI::byte* write_midi_feedback (MIDI::byte*, int32_t& bufsize);
-
- /* Peak metering */
-
- float peak_input_power (uint32_t n) {
- if (n < std::max (_ninputs, _noutputs)) {
- return _visible_peak_power[n];
- } else {
- return minus_infinity();
- }
- }
+ static sigc::signal<int> PortsLegal;
+ static sigc::signal<int> PannersLegal;
+ static sigc::signal<int> ConnectingLegal;
+ /// raised when the number of input or output ports changes
+ static sigc::signal<void,ChanCount> PortCountChanged;
+ static sigc::signal<int> PortsCreated;
static void update_meters();
-private:
+ private:
static sigc::signal<void> Meter;
static Glib::StaticMutex m_meter_signal_lock;
sigc::connection m_meter_connection;
-public:
+ public:
/* automation */
- void clear_automation ();
-
- bool gain_automation_recording() const {
- return (_gain_automation_curve.automation_state() & (Write|Touch));
- }
-
- bool gain_automation_playback() const {
- return (_gain_automation_curve.automation_state() & Play) ||
- ((_gain_automation_curve.automation_state() & Touch) &&
- !_gain_automation_curve.touching());
- }
-
- virtual void set_gain_automation_state (AutoState);
- AutoState gain_automation_state() const { return _gain_automation_curve.automation_state(); }
- sigc::signal<void> gain_automation_state_changed;
-
- virtual void set_gain_automation_style (AutoStyle);
- AutoStyle gain_automation_style () const { return _gain_automation_curve.automation_style(); }
- sigc::signal<void> gain_automation_style_changed;
+ struct GainControl : public AutomationControl {
+ GainControl (std::string name, IO& i, boost::shared_ptr<AutomationList> al)
+ : AutomationControl (i._session, al, name)
+ , _io (i)
+ {}
+
+ void set_value (float val);
+ float get_value (void) const;
+
+ IO& _io;
+ };
- static void set_automation_interval (jack_nframes_t frames) {
- _automation_interval = frames;
+ boost::shared_ptr<GainControl> gain_control() {
+ return _gain_control;
}
-
- static jack_nframes_t automation_interval() {
- return _automation_interval;
+ boost::shared_ptr<const GainControl> gain_control() const {
+ return _gain_control;
}
- virtual void transport_stopped (jack_nframes_t now);
- virtual void automation_snapshot (jack_nframes_t now);
-
- ARDOUR::Curve& gain_automation_curve () { return _gain_automation_curve; }
+ void clear_automation ();
+
+ void set_parameter_automation_state (Parameter, AutoState);
- void start_gain_touch ();
- void end_gain_touch ();
+ virtual void transport_stopped (nframes_t now);
+ virtual void automation_snapshot (nframes_t now, bool force);
void start_pan_touch (uint32_t which);
void end_pan_touch (uint32_t which);
- id_t id() const { return _id; }
-
void defer_pan_reset ();
void allow_pan_reset ();
mutable Glib::Mutex io_lock;
protected:
- Session& _session;
Panner* _panner;
+ BufferSet* _output_buffers; //< Set directly to output port buffers
+ bool _active;
gain_t _gain;
gain_t _effective_gain;
gain_t _desired_gain;
- Glib::Mutex declick_lock;
- vector<Port*> _outputs;
- vector<Port*> _inputs;
- vector<float> _peak_power;
- vector<float> _visible_peak_power;
- string _name;
- Connection* _input_connection;
- Connection* _output_connection;
- id_t _id;
+ Glib::Mutex declick_lock;
+ PortSet _outputs;
+ PortSet _inputs;
+ PeakMeter* _meter;
bool no_panner_reset;
+ bool _phase_invert;
+ bool _denormal_protection;
XMLNode* deferred_state;
+ DataType _default_type;
+ bool _public_ports;
virtual void set_deferred_state() {}
- void reset_peak_meters();
void reset_panner ();
- virtual uint32_t pans_required() const { return _ninputs; }
-
- static void apply_declick (vector<Sample*>&, uint32_t nbufs, jack_nframes_t nframes,
- gain_t initial, gain_t target, bool invert_polarity);
-
- struct MIDIGainControl : public MIDI::Controllable {
- MIDIGainControl (IO&, MIDI::Port *);
- void set_value (float);
-
- void send_feedback (gain_t);
- MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, gain_t val, bool force = false);
+ virtual uint32_t pans_required() const
+ { return _inputs.count().n_audio(); }
- IO& io;
- bool setting;
- MIDI::byte last_written;
+ boost::shared_ptr<GainControl> _gain_control;
- gain_t (*midi_to_gain) (double val);
- double (*gain_to_midi) (gain_t gain);
- };
-
- MIDIGainControl _midi_gain_control;
-
- /* state management */
-
- Change restore_state (State&);
- StateManager::State* state_factory (std::string why) const;
- void send_state_changed();
+ virtual void set_gain (gain_t g, void *src);
+ void inc_gain (gain_t delta, void *src);
- bool get_midi_node_info (XMLNode * node, MIDI::eventType & ev, MIDI::channel_t & chan, MIDI::byte & additional);
- bool set_midi_node_info (XMLNode * node, MIDI::eventType ev, MIDI::channel_t chan, MIDI::byte additional);
+ bool apply_gain_automation;
- /* automation */
-
- jack_nframes_t last_automation_snapshot;
- static jack_nframes_t _automation_interval;
-
- AutoState _gain_automation_state;
- AutoStyle _gain_automation_style;
-
- bool apply_gain_automation;
- Curve _gain_automation_curve;
-
- int save_automation (const string&);
- int load_automation (const string&);
-
- Glib::Mutex automation_lock;
+ virtual int load_automation (std::string path);
/* AudioTrack::deprecated_use_diskstream_connections() needs these */
static bool connecting_legal;
static bool ports_legal;
- private:
-
- uint32_t _ninputs;
- uint32_t _noutputs;
+ BufferSet& output_buffers() { return *_output_buffers; }
- /* are these the best variable names ever, or what? */
+ private:
- sigc::connection input_connection_configuration_connection;
- sigc::connection output_connection_configuration_connection;
- sigc::connection input_connection_connection_connection;
- sigc::connection output_connection_connection_connection;
+ friend class Send;
static bool panners_legal;
sigc::connection port_legal_c;
sigc::connection panner_legal_c;
- int _input_minimum;
- int _input_maximum;
- int _output_minimum;
- int _output_maximum;
-
+ ChanCount _input_minimum; ///< minimum number of input channels (0 for no minimum)
+ ChanCount _input_maximum; ///< maximum number of input channels (ChanCount::INFINITE for no maximum)
+ ChanCount _output_minimum; ///< minimum number of output channels (0 for no minimum)
+ ChanCount _output_maximum; ///< maximum number of output channels (ChanCount::INFINITE for no maximum)
+
+ boost::shared_ptr<AutoBundle> _bundle_for_inputs; ///< a bundle representing our inputs
+ boost::shared_ptr<AutoBundle> _bundle_for_outputs; ///< a bundle representing our outputs
+
+ struct UserBundleInfo {
+ UserBundleInfo (IO*, boost::shared_ptr<UserBundle> b);
+
+ boost::shared_ptr<UserBundle> bundle;
+ sigc::connection configuration_will_change;
+ sigc::connection configuration_has_changed;
+ sigc::connection ports_will_change;
+ sigc::connection ports_have_changed;
+ };
+
+ std::vector<UserBundleInfo> _bundles_connected_to_outputs; ///< user bundles connected to our outputs
+ std::vector<UserBundleInfo> _bundles_connected_to_inputs; ///< user bundles connected to our inputs
static int parse_io_string (const string&, vector<string>& chns);
int set_sources (vector<string>&, void *src, bool add);
int set_destinations (vector<string>&, void *src, bool add);
- int ensure_inputs (uint32_t, bool clear, bool lockit, void *src);
- int ensure_outputs (uint32_t, bool clear, bool lockit, void *src);
+ int ensure_inputs (ChanCount, bool clear, bool lockit, void *src);
+ int ensure_outputs (ChanCount, bool clear, bool lockit, void *src);
- void drop_input_connection ();
- void drop_output_connection ();
+ void check_bundles_connected_to_inputs ();
+ void check_bundles_connected_to_outputs ();
+ void check_bundles (std::vector<UserBundleInfo>&, const PortSet&);
- void input_connection_configuration_changed ();
- void input_connection_connection_changed (int);
- void output_connection_configuration_changed ();
- void output_connection_connection_changed (int);
+ void bundle_configuration_will_change ();
+ void bundle_configuration_has_changed ();
+ void bundle_ports_will_change (int);
+ void bundle_ports_have_changed (int);
int create_ports (const XMLNode&);
int make_connections (const XMLNode&);
+ boost::shared_ptr<Bundle> find_possible_bundle (const string &desired_name, const string &default_name, const string &connection_type_name);
void setup_peak_meters ();
void meter ();
- bool ensure_inputs_locked (uint32_t, bool clear, void *src);
- bool ensure_outputs_locked (uint32_t, bool clear, void *src);
+ bool ensure_inputs_locked (ChanCount, bool clear, void *src);
+ bool ensure_outputs_locked (ChanCount, bool clear, void *src);
+
+ std::string build_legal_port_name (DataType type, bool for_input);
+ int32_t find_input_port_hole (const char* base);
+ int32_t find_output_port_hole (const char* base);
+
+ void create_bundles_for_inputs_and_outputs ();
+ void setup_bundles_for_inputs_and_outputs ();
- int32_t find_input_port_hole ();
- int32_t find_output_port_hole ();
+ void maybe_add_input_bundle_to_list (boost::shared_ptr<Bundle>, std::vector<boost::shared_ptr<Bundle> >*);
+ void maybe_add_output_bundle_to_list (boost::shared_ptr<Bundle>, std::vector<boost::shared_ptr<Bundle> >*);
};
-}; /* namespace ARDOUR */
+} // namespace ARDOUR
#endif /*__ardour_io_h__ */
projects / ardour.git / blobdiff