libs/ardour/ardour/io.h

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_io_h__
  21 #define __ardour_io_h__
  22
  23 #include <string>
  24 #include <vector>
  25 #include <cmath>
  26 #include <sigc++/signal.h>
  27 #include <jack/jack.h>
  28
  29 #include <glibmm/thread.h>
  30
  31 #include <pbd/fastlog.h>
  32 #include <pbd/undo.h>
  33 #include <pbd/statefuldestructible.h>
  34 #include <pbd/controllable.h>
  35
  36 #include <ardour/ardour.h>
  37 #include <ardour/utils.h>
  38 #include <ardour/curve.h>
  39 #include <ardour/types.h>
  40 #include <ardour/data_type.h>
  41 #include <ardour/port_set.h>
  42 #include <ardour/chan_count.h>
  43
  44 using std::string;
  45 using std::vector;
  46
  47 class XMLNode;
  48
  49 namespace ARDOUR {
  50
  51 class Session;
  52 class AudioEngine;
  53 class Connection;
  54 class Panner;
  55 class PeakMeter;
  56 class Port;
  57 class AudioPort;
  58 class MidiPort;
  59 class BufferSet;
  60
  61 /** A collection of input and output ports with connections.
  62  *
  63  * An IO can contain ports of varying types, making routes/inserts/etc with
  64  * varied combinations of types (eg MIDI and audio) possible.
  65  */
  66 class IO : public PBD::StatefulDestructible
  67 {
  68
  69   public:
  70         static const string state_node_name;
  71
  72         IO (Session&, string name,
  73             int input_min = -1, int input_max = -1,
  74             int output_min = -1, int output_max = -1,
  75             DataType default_type = DataType::AUDIO);
  76
  77         IO (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
  78
  79         virtual ~IO();
  80
  81         ChanCount input_minimum() const { return _input_minimum; }
  82         ChanCount input_maximum() const { return _input_maximum; }
  83         ChanCount output_minimum() const { return _output_minimum; }
  84         ChanCount output_maximum() const { return _output_maximum; }
  85
  86         void set_input_minimum (ChanCount n);
  87         void set_input_maximum (ChanCount n);
  88         void set_output_minimum (ChanCount n);
  89         void set_output_maximum (ChanCount n);
  90
  91         DataType default_type() const         { return _default_type; }
  92         void     set_default_type(DataType t) { _default_type = t; }
  93
  94         const string& name() const { return _name; }
  95         virtual int set_name (string str, void *src);
  96
  97         virtual void silence  (nframes_t, nframes_t offset);
  98
  99         void collect_input  (BufferSet& bufs, nframes_t nframes, nframes_t offset);
 100         void deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame,
 101                                               nframes_t nframes, nframes_t offset);
 102         void just_meter_input (nframes_t start_frame, nframes_t end_frame,
 103                                nframes_t nframes, nframes_t offset);
 104
 105         virtual void   set_gain (gain_t g, void *src);
 106         void           inc_gain (gain_t delta, void *src);
 107         gain_t         gain () const { return _desired_gain; }
 108         virtual gain_t effective_gain () const;
 109
 110         void set_phase_invert (bool yn, void *src);
 111         bool phase_invert() const { return _phase_invert; }
 112
 113         Panner& panner()        { return *_panner; }
 114         PeakMeter& peak_meter() { return *_meter; }
 115         const Panner& panner() const { return *_panner; }
 116
 117         int ensure_io (ChanCount in, ChanCount out, bool clear, void *src);
 118
 119         int use_input_connection (Connection&, void *src);
 120         int use_output_connection (Connection&, void *src);
 121
 122         Connection *input_connection() const { return _input_connection; }
 123         Connection *output_connection() const { return _output_connection; }
 124
 125         int add_input_port (string source, void *src, DataType type = DataType::NIL);
 126         int add_output_port (string destination, void *src, DataType type = DataType::NIL);
 127
 128         int remove_input_port (Port *, void *src);
 129         int remove_output_port (Port *, void *src);
 130
 131         int set_input (Port *, void *src);
 132
 133         int connect_input (Port *our_port, string other_port, void *src);
 134         int connect_output (Port *our_port, string other_port, void *src);
 135
 136         int disconnect_input (Port *our_port, string other_port, void *src);
 137         int disconnect_output (Port *our_port, string other_port, void *src);
 138
 139         int disconnect_inputs (void *src);
 140         int disconnect_outputs (void *src);
 141
 142         nframes_t output_latency() const;
 143         nframes_t input_latency() const;
 144         void           set_port_latency (nframes_t);
 145
 146         const PortSet& inputs()  const { return _inputs; }
 147         const PortSet& outputs() const { return _outputs; }
 148
 149         Port *output (uint32_t n) const {
 150                 if (n < _outputs.num_ports()) {
 151                         return _outputs.port(n);
 152                 } else {
 153                         return 0;
 154                 }
 155         }
 156
 157         Port *input (uint32_t n) const {
 158                 if (n < _inputs.num_ports()) {
 159                         return _inputs.port(n);
 160                 } else {
 161                         return 0;
 162                 }
 163         }
 164
 165         AudioPort* audio_input(uint32_t n) const;
 166         AudioPort* audio_output(uint32_t n) const;
 167         MidiPort*  midi_input(uint32_t n) const;
 168         MidiPort*  midi_output(uint32_t n) const;
 169
 170         const ChanCount& n_inputs ()  const { return _inputs.count(); }
 171         const ChanCount& n_outputs () const { return _outputs.count(); }
 172
 173         void attach_buffers(ChanCount ignored);
 174
 175         sigc::signal<void,IOChange,void*> input_changed;
 176         sigc::signal<void,IOChange,void*> output_changed;
 177
 178         sigc::signal<void,void*> gain_changed;
 179         sigc::signal<void,void*> name_changed;
 180
 181         virtual XMLNode& state (bool full);
 182         XMLNode& get_state (void);
 183         int set_state (const XMLNode&);
 184
 185         static int  disable_connecting (void);
 186
 187         static int  enable_connecting (void);
 188
 189         static int  disable_ports (void);
 190
 191         static int  enable_ports (void);
 192
 193         static int  disable_panners (void);
 194
 195         static int  reset_panners (void);
 196
 197         static sigc::signal<int>            PortsLegal;
 198         static sigc::signal<int>            PannersLegal;
 199         static sigc::signal<int>            ConnectingLegal;
 200         static sigc::signal<void,ChanCount> MoreChannels;
 201         static sigc::signal<int>            PortsCreated;
 202
 203         PBD::Controllable& gain_control() {
 204                 return _gain_control;
 205         }
 206
 207     static void update_meters();
 208
 209   private:
 210
 211     static sigc::signal<void>   Meter;
 212     static Glib::StaticMutex    m_meter_signal_lock;
 213     sigc::connection            m_meter_connection;
 214
 215   public:
 216
 217         /* automation */
 218
 219         static void set_automation_interval (nframes_t frames) {
 220                 _automation_interval = frames;
 221         }
 222
 223         static nframes_t automation_interval() {
 224                 return _automation_interval;
 225         }
 226
 227         void clear_automation ();
 228
 229         bool gain_automation_recording() const {
 230                 return (_gain_automation_curve.automation_state() & (Write|Touch));
 231         }
 232
 233         bool gain_automation_playback() const {
 234                 return (_gain_automation_curve.automation_state() & Play) ||
 235                         ((_gain_automation_curve.automation_state() & Touch) &&
 236                          !_gain_automation_curve.touching());
 237         }
 238
 239         virtual void set_gain_automation_state (AutoState);
 240         AutoState gain_automation_state() const { return _gain_automation_curve.automation_state(); }
 241         sigc::signal<void> gain_automation_state_changed;
 242
 243         virtual void set_gain_automation_style (AutoStyle);
 244         AutoStyle gain_automation_style () const { return _gain_automation_curve.automation_style(); }
 245         sigc::signal<void> gain_automation_style_changed;
 246
 247         virtual void transport_stopped (nframes_t now);
 248         void automation_snapshot (nframes_t now);
 249
 250         ARDOUR::Curve& gain_automation_curve () { return _gain_automation_curve; }
 251
 252         void start_gain_touch ();
 253         void end_gain_touch ();
 254
 255         void start_pan_touch (uint32_t which);
 256         void end_pan_touch (uint32_t which);
 257
 258         void defer_pan_reset ();
 259         void allow_pan_reset ();
 260
 261         /* the session calls this for master outs before
 262            anyone else. controls outs too, at some point.
 263         */
 264
 265         XMLNode *pending_state_node;
 266         int ports_became_legal ();
 267
 268   private:
 269         mutable Glib::Mutex io_lock;
 270
 271   protected:
 272         Session&            _session;
 273         Panner*             _panner;
 274         BufferSet*          _output_buffers; //< Set directly to output port buffers
 275         gain_t              _gain;
 276         gain_t              _effective_gain;
 277         gain_t              _desired_gain;
 278         Glib::Mutex         declick_lock;
 279         PortSet             _outputs;
 280         PortSet             _inputs;
 281         PeakMeter*          _meter;
 282         string              _name;
 283         Connection*         _input_connection;
 284         Connection*         _output_connection;
 285         bool                 no_panner_reset;
 286         bool                _phase_invert;
 287         XMLNode*             deferred_state;
 288         DataType            _default_type;
 289
 290         virtual void set_deferred_state() {}
 291
 292         void reset_panner ();
 293
 294         virtual uint32_t pans_required() const
 295                 { return _inputs.count().get(DataType::AUDIO); }
 296
 297         struct GainControllable : public PBD::Controllable {
 298             GainControllable (std::string name, IO& i) : Controllable (name), io (i) {}
 299
 300             void set_value (float val);
 301             float get_value (void) const;
 302
 303             IO& io;
 304         };
 305
 306         GainControllable _gain_control;
 307
 308         nframes_t last_automation_snapshot;
 309         static nframes_t _automation_interval;
 310
 311         AutoState      _gain_automation_state;
 312         AutoStyle      _gain_automation_style;
 313
 314         bool     apply_gain_automation;
 315         Curve    _gain_automation_curve;
 316
 317         Glib::Mutex automation_lock;
 318
 319         virtual int set_automation_state (const XMLNode&);
 320         virtual XMLNode& get_automation_state ();
 321         virtual int load_automation (std::string path);
 322
 323         /* AudioTrack::deprecated_use_diskstream_connections() needs these */
 324
 325         int set_inputs (const string& str);
 326         int set_outputs (const string& str);
 327
 328         static bool connecting_legal;
 329         static bool ports_legal;
 330
 331         BufferSet& output_buffers() { return *_output_buffers; }
 332
 333   private:
 334
 335         /* are these the best variable names ever, or what? */
 336
 337         sigc::connection input_connection_configuration_connection;
 338         sigc::connection output_connection_configuration_connection;
 339         sigc::connection input_connection_connection_connection;
 340         sigc::connection output_connection_connection_connection;
 341
 342         static bool panners_legal;
 343
 344         int connecting_became_legal ();
 345         int panners_became_legal ();
 346         sigc::connection connection_legal_c;
 347         sigc::connection port_legal_c;
 348         sigc::connection panner_legal_c;
 349
 350         ChanCount _input_minimum;
 351         ChanCount _input_maximum;
 352         ChanCount _output_minimum;
 353         ChanCount _output_maximum;
 354
 355
 356         static int parse_io_string (const string&, vector<string>& chns);
 357
 358         static int parse_gain_string (const string&, vector<string>& chns);
 359
 360         int set_sources (vector<string>&, void *src, bool add);
 361         int set_destinations (vector<string>&, void *src, bool add);
 362
 363         int ensure_inputs (ChanCount, bool clear, bool lockit, void *src);
 364         int ensure_outputs (ChanCount, bool clear, bool lockit, void *src);
 365
 366         void drop_input_connection ();
 367         void drop_output_connection ();
 368
 369         void input_connection_configuration_changed ();
 370         void input_connection_connection_changed (int);
 371         void output_connection_configuration_changed ();
 372         void output_connection_connection_changed (int);
 373
 374         int create_ports (const XMLNode&);
 375         int make_connections (const XMLNode&);
 376
 377         void setup_peak_meters ();
 378         void meter ();
 379
 380         bool ensure_inputs_locked (ChanCount, bool clear, void *src);
 381         bool ensure_outputs_locked (ChanCount, bool clear, void *src);
 382
 383         int32_t find_input_port_hole ();
 384         int32_t find_output_port_hole ();
 385 };
 386
 387 } // namespace ARDOUR
 388
 389 #endif /*__ardour_io_h__ */