X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fio.h;h=6793072cba8a710eb6c0da477e95cc210224c77d;hb=90172686b92b53cc5ab1d60c0e6daecb65d17d3d;hp=8b236eadff91885bf2bbb400e6583b58206024a6;hpb=3b89d9eaa03406a5e03648f47734211f09b89d62;p=ardour.git diff --git a/libs/ardour/ardour/io.h b/libs/ardour/ardour/io.h index 8b236eadff..6793072cba 100644 --- a/libs/ardour/ardour/io.h +++ b/libs/ardour/ardour/io.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2000 Paul Davis + Copyright (C) 2000 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 @@ -23,18 +23,16 @@ #include #include #include -#include #include #include #include "pbd/fastlog.h" #include "pbd/undo.h" -#include "pbd/statefuldestructible.h" +#include "pbd/statefuldestructible.h" #include "pbd/controllable.h" #include "ardour/ardour.h" -#include "ardour/automatable_controls.h" #include "ardour/automation_control.h" #include "ardour/bundle.h" #include "ardour/chan_count.h" @@ -55,331 +53,171 @@ class AudioPort; class BufferSet; class Bundle; class MidiPort; -class Panner; class PeakMeter; class Port; +class Processor; class Session; class UserBundle; -/** A collection of input and output ports with connections. +/** A collection of ports (all input or all output) 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 SessionObject, public AutomatableControls, public Latent +class IO : public SessionObject, public Latent { public: static const std::string state_node_name; - IO (Session&, const std::string& name, DataType default_type = DataType::AUDIO, - ChanCount in_min=ChanCount::ZERO, ChanCount in_max=ChanCount::INFINITE, - ChanCount out_min=ChanCount::ZERO, ChanCount out_max=ChanCount::INFINITE); - + enum Direction { + Input, + Output + }; + + IO (Session&, const std::string& name, Direction, DataType default_type = DataType::AUDIO); IO (Session&, const XMLNode&, DataType default_type = DataType::AUDIO); - + virtual ~IO(); - 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); - + Direction direction() const { return _direction; } + DataType default_type() const { return _default_type; } void set_default_type(DataType t) { _default_type = t; } - - bool set_name (const std::string& str); - - virtual void silence (nframes_t); - - void collect_input (BufferSet& bufs, nframes_t nframes, ChanCount offset=ChanCount::ZERO); - void deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes); - void just_meter_input (nframes_t start_frame, nframes_t end_frame, nframes_t nframes); - - BufferSet& output_buffers() { return *_output_buffers; } - - gain_t gain () const { return _gain_control->user_float(); } - 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; } - - void reset_panner (); - - boost::shared_ptr amp() const { return _amp; } - - PeakMeter& peak_meter() { return *_meter.get(); } - const PeakMeter& peak_meter() const { return *_meter.get(); } - boost::shared_ptr shared_peak_meter() const { return _meter; } - boost::shared_ptr panner() const { return _panner; } - - int ensure_io (ChanCount in, ChanCount out, bool clear, void *src); - - int connect_input_ports_to_bundle (boost::shared_ptr, void *); - int disconnect_input_ports_from_bundle (boost::shared_ptr, void *); - int connect_output_ports_to_bundle (boost::shared_ptr, void *); - int disconnect_output_ports_from_bundle (boost::shared_ptr, void *); - - BundleList bundles_connected_to_inputs (); - BundleList bundles_connected_to_outputs (); + bool active() const { return _active; } + void set_active(bool yn) { _active = yn; } - boost::shared_ptr bundle_for_inputs () { return _bundle_for_inputs; } - boost::shared_ptr bundle_for_outputs () { return _bundle_for_outputs; } - - int add_input_port (std::string source, void *src, DataType type = DataType::NIL); - int add_output_port (std::string destination, void *src, DataType type = DataType::NIL); + bool set_name (const std::string& str); - int remove_input_port (Port *, void *src); - int remove_output_port (Port *, void *src); + virtual void silence (nframes_t); - int set_input (Port *, void *src); + int ensure_io (ChanCount cnt, bool clear, void *src); - int connect_input (Port *our_port, std::string other_port, void *src); - int connect_output (Port *our_port, std::string other_port, void *src); + int connect_ports_to_bundle (boost::shared_ptr, void *); + int disconnect_ports_from_bundle (boost::shared_ptr, void *); - int disconnect_input (Port *our_port, std::string other_port, void *src); - int disconnect_output (Port *our_port, std::string other_port, void *src); + BundleList bundles_connected (); - int disconnect_inputs (void *src); - int disconnect_outputs (void *src); + boost::shared_ptr bundle () { return _bundle; } + int add_port (std::string connection, void *src, DataType type = DataType::NIL); + int remove_port (Port *, void *src); + int connect (Port *our_port, std::string other_port, void *src); + int disconnect (Port *our_port, std::string other_port, void *src); + int disconnect (void *src); + bool connected_to (boost::shared_ptr) const; + bool connected () const; + bool physically_connected () const; + nframes_t signal_latency() const { return _own_latency; } - nframes_t output_latency() const; - nframes_t input_latency() const; + nframes_t 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 < _outputs.num_ports()) { - return _outputs.port(n); - } else { - return 0; - } - } + PortSet& ports() { return _ports; } + const PortSet& ports() const { return _ports; } - Port *input (uint32_t n) const { - if (n < _inputs.num_ports()) { - return _inputs.port(n); + Port *nth (uint32_t n) const { + if (n < _ports.num_ports()) { + return _ports.port(n); } else { return 0; } } - 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; + Port* port_by_name (const std::string& str) const; - const ChanCount& n_inputs () const { return _inputs.count(); } - const ChanCount& n_outputs () const { return _outputs.count(); } + AudioPort* audio(uint32_t n) const; + MidiPort* midi(uint32_t n) const; - void attach_buffers(ChanCount ignored); - - sigc::signal active_changed; + const ChanCount& n_ports () const { return _ports.count(); } - sigc::signal input_changed; - sigc::signal output_changed; + PBD::Signal2 changed; virtual XMLNode& state (bool full); XMLNode& get_state (void); - int set_state (const XMLNode&); + int set_state (const XMLNode&, int version); + int set_state_2X (const XMLNode&, int, bool); static int disable_connecting (void); static int enable_connecting (void); static int disable_ports (void); static int enable_ports (void); - static int disable_panners (void); - static int reset_panners (void); - - static sigc::signal PortsLegal; - static sigc::signal PannersLegal; - static sigc::signal ConnectingLegal; - /// raised when the number of input or output ports changes - static sigc::signal PortCountChanged; - static sigc::signal CycleStart; - - static void update_meters(); - static std::string name_from_state (const XMLNode&); - static void set_name_in_state (XMLNode&, const std::string&); - private: - - static sigc::signal Meter; - static Glib::StaticMutex m_meter_signal_lock; - sigc::connection m_meter_connection; + static PBD::Signal1 PortCountChanged; // emitted when the number of ports changes - public: - - /* automation */ - - struct GainControl : public AutomationControl { - GainControl (std::string name, IO* i, const Evoral::Parameter ¶m, - boost::shared_ptr al = boost::shared_ptr() ) - : AutomationControl (i->_session, param, al, name ) - , _io (i) - {} - - void set_value (float val); - float get_value (void) const; - - IO* _io; - }; + static std::string name_from_state (const XMLNode&); + static void set_name_in_state (XMLNode&, const std::string&); - boost::shared_ptr gain_control() { - return _gain_control; - } - boost::shared_ptr gain_control() const { - return _gain_control; - } + /* we have to defer/order port connection. this is how we do it. + */ - void clear_automation (); - - void set_parameter_automation_state (Evoral::Parameter, AutoState); + static PBD::Signal0 ConnectingLegal; + static bool connecting_legal; - virtual void transport_stopped (nframes_t now); - virtual void automation_snapshot (nframes_t now, bool force); + XMLNode *pending_state_node; + int pending_state_node_version; + bool pending_state_node_in; - void start_pan_touch (uint32_t which); - void end_pan_touch (uint32_t which); + /* three utility functions - this just seems to be simplest place to put them */ - void defer_pan_reset (); - void allow_pan_reset (); + void collect_input (BufferSet& bufs, nframes_t nframes, ChanCount offset); + void process_input (boost::shared_ptr, framepos_t start_frame, framepos_t end_frame, nframes_t nframes); + void copy_to_outputs (BufferSet& bufs, DataType type, nframes_t nframes, nframes_t offset); - /* the session calls this for master outs before - anyone else. controls outs too, at some point. - */ + /* AudioTrack::deprecated_use_diskstream_connections() needs these */ - XMLNode *pending_state_node; - int ports_became_legal (); + int set_ports (const std::string& str); private: mutable Glib::Mutex io_lock; protected: - BufferSet* _output_buffers; //< Set directly to output port buffers - bool _active; - gain_t _gain; - Glib::Mutex declick_lock; - PortSet _outputs; - PortSet _inputs; - bool no_panner_reset; - bool _phase_invert; - bool _denormal_protection; - XMLNode* deferred_state; - DataType _default_type; - nframes_t _output_offset; - ChanCount _configured_inputs; - ChanCount _configured_outputs; - - boost::shared_ptr _amp; - boost::shared_ptr _meter; - boost::shared_ptr _panner; - - virtual void prepare_inputs (nframes_t nframes); - virtual void flush_outputs (nframes_t nframes); - - virtual void set_deferred_state() {} - - virtual uint32_t pans_required() const - { return _inputs.count().n_audio(); } - - boost::shared_ptr _gain_control; - - virtual void set_gain (gain_t g, void *src); - void inc_gain (gain_t delta, void *src); - - virtual int load_automation (std::string path); - - /* AudioTrack::deprecated_use_diskstream_connections() needs these */ - - int set_inputs (const std::string& str); - int set_outputs (const std::string& str); - - void increment_output_offset (nframes_t); - void cycle_start (nframes_t); - - static bool connecting_legal; - static bool ports_legal; + PortSet _ports; + Direction _direction; + DataType _default_type; + bool _active; private: - static bool panners_legal; - - void copy_to_outputs (BufferSet& bufs, DataType type, nframes_t nframes); - int connecting_became_legal (); - int panners_became_legal (); - sigc::connection connection_legal_c; - sigc::connection port_legal_c; - sigc::connection panner_legal_c; - - 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) + PBD::ScopedConnection connection_legal_c; - boost::shared_ptr _bundle_for_inputs; ///< a bundle representing our inputs - boost::shared_ptr _bundle_for_outputs; ///< a bundle representing our outputs + boost::shared_ptr _bundle; ///< a bundle representing our ports struct UserBundleInfo { - UserBundleInfo (IO*, boost::shared_ptr b); - - boost::shared_ptr bundle; - sigc::connection changed; + UserBundleInfo (IO*, boost::shared_ptr b); + boost::shared_ptr bundle; + PBD::ScopedConnection changed; }; - std::vector _bundles_connected_to_outputs; ///< user bundles connected to our outputs - std::vector _bundles_connected_to_inputs; ///< user bundles connected to our inputs + std::vector _bundles_connected; ///< user bundles connected to our ports static int parse_io_string (const std::string&, std::vector& chns); - static int parse_gain_string (const std::string&, std::vector& chns); - - int set_sources (std::vector&, void *src, bool add); - int set_destinations (std::vector&, void *src, bool add); - int ensure_inputs (ChanCount, bool clear, bool lockit, void *src); - int ensure_outputs (ChanCount, bool clear, bool lockit, void *src); + int ensure_ports (ChanCount, bool clear, bool lockit, void *src); - void check_bundles_connected_to_inputs (); - void check_bundles_connected_to_outputs (); - void check_bundles (std::vector&, const PortSet&); + void check_bundles_connected (); + void check_bundles (std::vector&, const PortSet&); void bundle_changed (Bundle::Change); - int get_port_counts (const XMLNode& node); - int create_ports (const XMLNode&); - int make_connections (const XMLNode&); - boost::shared_ptr find_possible_bundle (const std::string &desired_name, const std::string &default_name, const std::string &connection_type_name); + int get_port_counts (const XMLNode& node, int version, ChanCount& n, boost::shared_ptr& c); + int get_port_counts_2X (const XMLNode& node, int version, ChanCount& n, boost::shared_ptr& c); + int create_ports (const XMLNode&, int version); + int make_connections (const XMLNode&, int, bool); + int make_connections_2X (const XMLNode &, int, bool); - virtual void setup_peak_meters (); - void meter (); + boost::shared_ptr find_possible_bundle (const std::string &desired_name); - bool ensure_inputs_locked (ChanCount, bool clear, void *src); - bool ensure_outputs_locked (ChanCount, bool clear, void *src); + bool ensure_ports_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); + std::string build_legal_port_name (DataType type); + int32_t find_port_hole (const char* base); - void setup_bundles_for_inputs_and_outputs (); - void setup_bundle_for_inputs (); - void setup_bundle_for_outputs (); - std::string bundle_channel_name (uint32_t, uint32_t) const; + void setup_bundle (); + std::string bundle_channel_name (uint32_t, uint32_t, DataType) const; }; } // namespace ARDOUR