libs/surfaces/mackie/mackie_control_protocol.h

   1 /*
   2         Copyright (C) 2006,2007 John Anderson
   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 #ifndef ardour_mackie_control_protocol_h
  19 #define ardour_mackie_control_protocol_h
  20
  21 #include <vector>
  22
  23 #include <sys/time.h>
  24 #include <pthread.h>
  25
  26 #include <glibmm/thread.h>
  27
  28 #include <ardour/types.h>
  29 #include <ardour/session.h>
  30 #include <midi++/types.h>
  31
  32 #include <control_protocol/control_protocol.h>
  33 #include "midi_byte_array.h"
  34 #include "controls.h"
  35 #include "route_signal.h"
  36 #include "mackie_button_handler.h"
  37 #include "mackie_port.h"
  38
  39 namespace MIDI {
  40         class Port;
  41         class Parser;
  42 }
  43
  44 namespace Mackie {
  45         class Surface;
  46 }
  47
  48 /**
  49         This handles the plugin duties, and the midi encoding and decoding,
  50         and the signal callbacks, mostly from ARDOUR::Route.
  51
  52         The model of the control surface is handled by classes in controls.h
  53
  54         What happens is that each strip on the control surface has
  55         a corresponding route in ControlProtocol::route_table. When
  56         an incoming midi message is signaled, the correct route
  57         is looked up, and the relevant changes made to it.
  58
  59         For each route currently in route_table, there's a RouteSignal object
  60         which encapsulates the signals that indicate that there are changes
  61         to be sent to the surface. The signals are handled by this class.
  62
  63         Calls to signal handlers pass a Route object which is used to look
  64         up the relevant Strip in Surface. Then the state is retrieved from
  65         the Route and encoded as the correct midi message.
  66 */
  67 class MackieControlProtocol
  68 : public ARDOUR::ControlProtocol
  69 , public Mackie::MackieButtonHandler
  70 {
  71   public:
  72         MackieControlProtocol( ARDOUR::Session & );
  73         virtual ~MackieControlProtocol();
  74
  75         int set_active (bool yn);
  76
  77         XMLNode& get_state ();
  78         int set_state (const XMLNode&);
  79
  80         static bool probe();
  81
  82         Mackie::Surface & surface();
  83
  84    // control events
  85    void handle_control_event( Mackie::SurfacePort & port, Mackie::Control & control, const Mackie::ControlState & state );
  86
  87   // strip/route related stuff
  88   public:
  89         /// Signal handler for Route::solo
  90         void notify_solo_changed( ARDOUR::Route *, Mackie::MackiePort * );
  91         /// Signal handler for Route::mute
  92         void notify_mute_changed( ARDOUR::Route *, Mackie::MackiePort * );
  93         /// Signal handler for Route::record_enable_changed
  94         void notify_record_enable_changed( ARDOUR::Route *, Mackie::MackiePort * );
  95         /// Signal handler for Route::gain_changed ( from IO )
  96         void notify_gain_changed( ARDOUR::Route *, Mackie::MackiePort * );
  97         /// Signal handler for Route::name_change
  98         void notify_name_changed( void *, ARDOUR::Route *, Mackie::MackiePort * );
  99         /// Signal handler from Panner::Change
 100         void notify_panner_changed( ARDOUR::Route *, Mackie::MackiePort * );
 101         /// Signal handler for new routes added
 102         void notify_route_added( ARDOUR::Session::RouteList & );
 103
 104         void notify_remote_id_changed();
 105
 106         /// rebuild the current bank. Called on route added/removed and
 107    /// remote id changed.
 108         void refresh_current_bank();
 109
 110   // global buttons (ie button not part of strips)
 111   public:
 112    // button-related signals
 113         void notify_record_state_changed();
 114    void notify_transport_state_changed();
 115    // mainly to pick up punch-in and punch-out
 116         void notify_parameter_changed( const char * );
 117    void notify_solo_active_changed( bool );
 118
 119         // this is called to generate the midi to send in response to
 120    // a button press.
 121         void update_led( Mackie::Button & button, Mackie::LedState );
 122
 123         // calls update_led, but looks up the button by name
 124         void update_global_button( const std::string & name, Mackie::LedState );
 125
 126    // transport button handler methods from MackieButtonHandler
 127         virtual Mackie::LedState rewind_press( Mackie::Button & );
 128         virtual Mackie::LedState rewind_release( Mackie::Button & );
 129
 130         virtual Mackie::LedState ffwd_press( Mackie::Button & );
 131         virtual Mackie::LedState ffwd_release( Mackie::Button & );
 132
 133         virtual Mackie::LedState stop_press( Mackie::Button & );
 134         virtual Mackie::LedState stop_release( Mackie::Button & );
 135
 136         virtual Mackie::LedState play_press( Mackie::Button & );
 137         virtual Mackie::LedState play_release( Mackie::Button & );
 138
 139         virtual Mackie::LedState record_press( Mackie::Button & );
 140         virtual Mackie::LedState record_release( Mackie::Button & );
 141
 142         virtual Mackie::LedState loop_press( Mackie::Button & );
 143         virtual Mackie::LedState loop_release( Mackie::Button & );
 144
 145         virtual Mackie::LedState punch_in_press( Mackie::Button & );
 146         virtual Mackie::LedState punch_in_release( Mackie::Button & );
 147
 148         virtual Mackie::LedState punch_out_press( Mackie::Button & );
 149         virtual Mackie::LedState punch_out_release( Mackie::Button & );
 150
 151         virtual Mackie::LedState home_press( Mackie::Button & );
 152         virtual Mackie::LedState home_release( Mackie::Button & );
 153
 154         virtual Mackie::LedState end_press( Mackie::Button & );
 155         virtual Mackie::LedState end_release( Mackie::Button & );
 156
 157    // bank switching button handler methods from MackieButtonHandler
 158         virtual Mackie::LedState left_press( Mackie::Button & );
 159         virtual Mackie::LedState left_release( Mackie::Button & );
 160
 161         virtual Mackie::LedState right_press( Mackie::Button & );
 162         virtual Mackie::LedState right_release( Mackie::Button & );
 163
 164         virtual Mackie::LedState channel_left_press( Mackie::Button & );
 165         virtual Mackie::LedState channel_left_release( Mackie::Button & );
 166
 167         virtual Mackie::LedState channel_right_press( Mackie::Button & );
 168         virtual Mackie::LedState channel_right_release( Mackie::Button & );
 169
 170   protected:
 171         // create instances of MackiePort, depending on what's found in ardour.rc
 172         void create_ports();
 173
 174         // shut down the surface
 175         void close();
 176
 177         // create the Surface object, with the correct number
 178         // of strips for the currently connected ports and
 179         // hook up the control event notification
 180         void initialize_surface();
 181
 182         // This sets up the notifications and sets the
 183    // controls to the correct values
 184         void update_surface();
 185
 186    // connects global (not strip) signals from the Session to here
 187    // so the surface can be notified of changes from the other UIs.
 188    void connect_session_signals();
 189
 190    // set all controls to their zero position
 191         void zero_all();
 192
 193         /**
 194                 Fetch the set of routes to be considered for control by the
 195                 surface. Excluding master, hidden and control routes, and inactive routes
 196         */
 197         typedef std::vector<boost::shared_ptr<ARDOUR::Route> > Sorted;
 198         Sorted get_sorted_routes();
 199
 200    // bank switching
 201    void switch_banks( int initial );
 202    void prev_track();
 203    void next_track();
 204
 205    // delete all RouteSignal objects connecting Routes to Strips
 206    void clear_route_signals();
 207
 208    /// This is the main MCU port, ie not an extender port
 209         const Mackie::MackiePort & mcu_port() const;
 210         Mackie::MackiePort & mcu_port();
 211
 212         typedef std::vector<Mackie::RouteSignal*> RouteSignals;
 213         RouteSignals route_signals;
 214
 215    // return which of the ports a particular route_table
 216    // index belongs to
 217         Mackie::MackiePort & port_for_id( uint32_t index );
 218
 219         /**
 220                 Handle a button press for the control and return whether
 221                 the corresponding light should be on or off.
 222         */
 223         bool handle_strip_button( Mackie::Control &, Mackie::ButtonState, boost::shared_ptr<ARDOUR::Route> );
 224
 225         // Polling midi port(s) for incoming messages
 226         static void* _monitor_work (void* arg);
 227         void* monitor_work ();
 228         /// rebuild the set of ports for this surface
 229         void update_ports();
 230         /// Returns true if there is pending data, false otherwise
 231         bool poll_ports();
 232         /// Trigger the MIDI::Parser
 233         void read_ports();
 234
 235         void add_port( MIDI::Port &, int number );
 236
 237         /**
 238                 used by the notify_XXX methods to find
 239                 a strip corresponding to the Route passed in.
 240         */
 241         Mackie::Strip & strip_from_route( ARDOUR::Route * route );
 242
 243         /// notification from the MackiePorts that their status has changed
 244         void handle_port_changed( Mackie::SurfacePort *, bool active );
 245
 246         /**
 247                 notification that the port is about to start it's init sequence.
 248                 We must make sure that before this exits, the port is being polled
 249                 for new data.
 250         */
 251         void handle_port_init( Mackie::SurfacePort * );
 252
 253         boost::shared_ptr<ARDOUR::Route> master_route();
 254         Mackie::Strip & master_strip();
 255
 256   private:
 257         boost::shared_ptr<Mackie::RouteSignal> master_route_signal;
 258
 259    static const char * default_port_name;
 260
 261         /// The Midi port(s) connected to the units
 262         typedef vector<Mackie::MackiePort*> MackiePorts;
 263         MackiePorts _ports;
 264
 265    // the thread that polls the ports for incoming midi data
 266         pthread_t thread;
 267
 268         /// The initial remote_id of the currently switched in bank.
 269    uint32_t _current_initial_bank;
 270
 271    /// protects the port list, and polling structures
 272         Glib::Mutex update_mutex;
 273
 274         /// Protects set_active, and allows waiting on the poll thread
 275         Glib::Cond update_cond;
 276
 277         // because sigc::trackable doesn't seem to be working
 278         std::vector<sigc::connection> _connections;
 279         std::back_insert_iterator<std::vector<sigc::connection> > connections_back;
 280
 281    /// The representation of the physical controls on the surface.
 282         Mackie::Surface * _surface;
 283
 284         /// If a port is opened or closed, this will be
 285         /// true until the port configuration is updated;
 286         bool _ports_changed;
 287
 288         struct pollfd * pfd;
 289         int nfds;
 290 };
 291
 292 #endif // ardour_mackie_control_protocol_h