libs/ardour/ardour/monitor_processor.h

   1 /*
   2     Copyright (C) 2010 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_monitor_processor_h__
  21 #define __ardour_monitor_processor_h__
  22
  23 #include <iostream>
  24 #include <vector>
  25
  26 #include "pbd/signals.h"
  27 #include "pbd/compose.h"
  28 #include "pbd/controllable.h"
  29
  30 #include "ardour/types.h"
  31 #include "ardour/processor.h"
  32
  33 class XMLNode;
  34
  35 namespace ARDOUR {
  36
  37 class Session;
  38
  39 template<typename T> class MPControl : public PBD::Controllable {
  40   public:
  41         MPControl (T initial, const std::string& name, PBD::Controllable::Flag flag,
  42                    float lower = 0.0f, float upper = 1.0f)
  43                 : PBD::Controllable (name, flag)
  44                 , _value (initial)
  45                 , _lower (lower)
  46                 , _upper (upper)
  47         {}
  48
  49         /* Controllable API */
  50
  51         void set_value (double v) {
  52                 T newval = (T) v;
  53                 if (newval != _value) {
  54                         _value = newval;
  55                         Changed(); /* EMIT SIGNAL */
  56                 }
  57         }
  58
  59         double get_value () const {
  60                 return (float) _value;
  61         }
  62
  63         double lower () const { return _lower; }
  64         double upper () const { return _upper; }
  65
  66         /* "access as T" API */
  67
  68         MPControl& operator=(const T& v) {
  69                 if (v != _value) {
  70                         _value = v;
  71                         Changed (); /* EMIT SIGNAL */
  72                 }
  73                 return *this;
  74         }
  75
  76         bool operator==(const T& v) const {
  77                 return _value == v;
  78         }
  79
  80         bool operator<(const T& v) const {
  81                 return _value < v;
  82         }
  83
  84         bool operator<=(const T& v) const {
  85                 return _value <= v;
  86         }
  87
  88         bool operator>(const T& v) const {
  89                 return _value > v;
  90         }
  91
  92         bool operator>=(const T& v) const {
  93                 return _value >= v;
  94         }
  95
  96         operator T() const { return _value; }
  97         T val() const { return _value; }
  98
  99   protected:
 100         T _value;
 101         T _lower;
 102         T _upper;
 103 };
 104
 105 class MonitorProcessor : public Processor
 106 {
 107   public:
 108         MonitorProcessor (Session&);
 109         ~MonitorProcessor ();
 110
 111         bool display_to_user() const;
 112
 113         void run (BufferSet& /*bufs*/, framepos_t /*start_frame*/, framepos_t /*end_frame*/, nframes_t /*nframes*/, bool /*result_required*/);
 114
 115         XMLNode& state (bool full);
 116         int set_state (const XMLNode&, int /* version */);
 117
 118         bool configure_io (ChanCount in, ChanCount out);
 119         bool can_support_io_configuration (const ChanCount& in, ChanCount& out) const;
 120
 121         void set_cut_all (bool);
 122         void set_dim_all (bool);
 123         void set_polarity (uint32_t, bool invert);
 124         void set_cut (uint32_t, bool cut);
 125         void set_dim (uint32_t, bool dim);
 126         void set_solo (uint32_t, bool);
 127         void set_mono (bool);
 128
 129         void set_dim_level (gain_t);
 130         void set_solo_boost_level (gain_t);
 131
 132         gain_t dim_level() const { return _dim_level; }
 133         gain_t solo_boost_level() const { return _solo_boost_level; }
 134
 135         bool dimmed (uint32_t chn) const;
 136         bool soloed (uint32_t chn) const;
 137         bool inverted (uint32_t chn) const;
 138         bool cut (uint32_t chn) const;
 139         bool cut_all () const;
 140         bool dim_all () const;
 141         bool mono () const;
 142
 143         PBD::Signal0<void> Changed;
 144
 145         boost::shared_ptr<PBD::Controllable> channel_cut_control (uint32_t) const;
 146         boost::shared_ptr<PBD::Controllable> channel_dim_control (uint32_t) const;
 147         boost::shared_ptr<PBD::Controllable> channel_polarity_control (uint32_t) const;
 148         boost::shared_ptr<PBD::Controllable> channel_solo_control (uint32_t) const;
 149
 150         boost::shared_ptr<PBD::Controllable> dim_control () const { return _dim_all_control; }
 151         boost::shared_ptr<PBD::Controllable> cut_control () const { return _cut_all_control; }
 152         boost::shared_ptr<PBD::Controllable> mono_control () const { return _mono_control; }
 153         boost::shared_ptr<PBD::Controllable> dim_level_control () const { return _dim_level_control; }
 154         boost::shared_ptr<PBD::Controllable> solo_boost_control () const { return _solo_boost_level_control; }
 155
 156   private:
 157         struct ChannelRecord {
 158             gain_t current_gain;
 159
 160             /* pointers - created first, but managed by boost::shared_ptr<> */
 161
 162             MPControl<gain_t>* cut_ptr;
 163             MPControl<bool>*   dim_ptr;
 164             MPControl<gain_t>* polarity_ptr;
 165             MPControl<bool>*   soloed_ptr;
 166
 167             /* shared ptr access and lifetime management, for external users */
 168
 169             boost::shared_ptr<PBD::Controllable> cut_control;
 170             boost::shared_ptr<PBD::Controllable> dim_control;
 171             boost::shared_ptr<PBD::Controllable> polarity_control;
 172             boost::shared_ptr<PBD::Controllable> soloed_control;
 173
 174             /* typed controllables for internal use */
 175
 176             MPControl<gain_t>& cut;
 177             MPControl<bool>&   dim;
 178             MPControl<gain_t>& polarity;
 179             MPControl<bool>&   soloed;
 180
 181             ChannelRecord (uint32_t);
 182         };
 183
 184         std::vector<ChannelRecord*> _channels;
 185
 186         uint32_t             solo_cnt;
 187
 188         /* pointers - created first, but managed by boost::shared_ptr<> */
 189
 190         MPControl<bool>*            _dim_all_ptr;
 191         MPControl<bool>*            _cut_all_ptr;
 192         MPControl<bool>*            _mono_ptr;
 193         MPControl<volatile gain_t>* _dim_level_ptr;
 194         MPControl<volatile gain_t>* _solo_boost_level_ptr;
 195
 196         /* shared ptr access and lifetime management, for external users */
 197
 198         boost::shared_ptr<PBD::Controllable> _dim_all_control;
 199         boost::shared_ptr<PBD::Controllable> _cut_all_control;
 200         boost::shared_ptr<PBD::Controllable> _mono_control;
 201         boost::shared_ptr<PBD::Controllable> _dim_level_control;
 202         boost::shared_ptr<PBD::Controllable> _solo_boost_level_control;
 203
 204         /* typed controllables for internal use */
 205
 206         MPControl<bool>&            _dim_all;
 207         MPControl<bool>&            _cut_all;
 208         MPControl<bool>&            _mono;
 209         MPControl<volatile gain_t>& _dim_level;
 210         MPControl<volatile gain_t>& _solo_boost_level;
 211
 212         void allocate_channels (uint32_t);
 213 };
 214
 215 } /* namespace */
 216
 217 #endif /* __ardour_monitor_processor_h__ */