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( Mackie::RouteSignal * );
  91         /// Signal handler for Route::mute
  92         void notify_mute_changed( Mackie::RouteSignal * );
  93         /// Signal handler for Route::record_enable_changed
  94         void notify_record_enable_changed( Mackie::RouteSignal * );
  95         /// Signal handler for Route::gain_changed ( from IO )
  96         void notify_gain_changed( Mackie::RouteSignal * );
  97         /// Signal handler for Route::name_change
  98         void notify_name_changed( void *, Mackie::RouteSignal * );
  99         /// Signal handler from Panner::Change
 100         void notify_panner_changed( Mackie::RouteSignal * );
 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         virtual Mackie::LedState clicking_press( Mackie::Button & );
 171         virtual Mackie::LedState clicking_release( Mackie::Button & );
 172
 173         virtual Mackie::LedState global_solo_press( Mackie::Button & );
 174         virtual Mackie::LedState global_solo_release( Mackie::Button & );
 175
 176   protected:
 177         // create instances of MackiePort, depending on what's found in ardour.rc
 178         void create_ports();
 179
 180         // shut down the surface
 181         void close();
 182
 183         // create the Surface object, with the correct number
 184         // of strips for the currently connected ports and
 185         // hook up the control event notification
 186         void initialize_surface();
 187
 188         // This sets up the notifications and sets the
 189    // controls to the correct values
 190         void update_surface();
 191
 192    // connects global (not strip) signals from the Session to here
 193    // so the surface can be notified of changes from the other UIs.
 194    void connect_session_signals();
 195
 196    // set all controls to their zero position
 197         void zero_all();
 198
 199         /**
 200                 Fetch the set of routes to be considered for control by the
 201                 surface. Excluding master, hidden and control routes, and inactive routes
 202         */
 203         typedef std::vector<boost::shared_ptr<ARDOUR::Route> > Sorted;
 204         Sorted get_sorted_routes();
 205
 206    // bank switching
 207    void switch_banks( int initial );
 208    void prev_track();
 209    void next_track();
 210
 211    // delete all RouteSignal objects connecting Routes to Strips
 212    void clear_route_signals();
 213
 214    /// This is the main MCU port, ie not an extender port
 215         const Mackie::MackiePort & mcu_port() const;
 216         Mackie::MackiePort & mcu_port();
 217
 218         typedef std::vector<Mackie::RouteSignal*> RouteSignals;
 219         RouteSignals route_signals;
 220
 221    // return which of the ports a particular route_table
 222    // index belongs to
 223         Mackie::MackiePort & port_for_id( uint32_t index );
 224
 225         /**
 226                 Handle a button press for the control and return whether
 227                 the corresponding light should be on or off.
 228         */
 229         bool handle_strip_button( Mackie::Control &, Mackie::ButtonState, boost::shared_ptr<ARDOUR::Route> );
 230
 231         /// thread started. Calls monitor_work.
 232         static void* _monitor_work (void* arg);
 233
 234         /// Polling midi port(s) for incoming messages
 235         void* monitor_work ();
 236
 237         /// rebuild the set of ports for this surface
 238         void update_ports();
 239
 240         /// Returns true if there is pending data, false otherwise
 241         bool poll_ports();
 242
 243         /// Trigger the MIDI::Parser
 244         void read_ports();
 245
 246         void add_port( MIDI::Port &, int number );
 247
 248         /// read automation data from the currently active routes and send to surface
 249         void poll_automation();
 250
 251         // called from poll_automation to figure out which automations need to be sent
 252         void update_automation( Mackie::RouteSignal & );
 253
 254         /**
 255                 notification that the port is about to start it's init sequence.
 256                 We must make sure that before this exits, the port is being polled
 257                 for new data.
 258         */
 259         void handle_port_init( Mackie::SurfacePort * );
 260
 261         /// notification from a MackiePort that it's now active
 262         void handle_port_active( Mackie::SurfacePort * );
 263
 264         /// notification from a MackiePort that it's now inactive
 265         void handle_port_inactive( Mackie::SurfacePort * );
 266
 267         boost::shared_ptr<ARDOUR::Route> master_route();
 268         Mackie::Strip & master_strip();
 269
 270   private:
 271         boost::shared_ptr<Mackie::RouteSignal> master_route_signal;
 272
 273    static const char * default_port_name;
 274
 275         /// The Midi port(s) connected to the units
 276         typedef vector<Mackie::MackiePort*> MackiePorts;
 277         MackiePorts _ports;
 278
 279    // the thread that polls the ports for incoming midi data
 280         pthread_t thread;
 281
 282         /// The initial remote_id of the currently switched in bank.
 283    uint32_t _current_initial_bank;
 284
 285    /// protects the port list, and polling structures
 286         Glib::Mutex update_mutex;
 287
 288         /// Protects set_active, and allows waiting on the poll thread
 289         Glib::Cond update_cond;
 290
 291         // because sigc::trackable doesn't seem to be working
 292         std::vector<sigc::connection> _connections;
 293         std::back_insert_iterator<std::vector<sigc::connection> > connections_back;
 294
 295    /// The representation of the physical controls on the surface.
 296         Mackie::Surface * _surface;
 297
 298         /// If a port is opened or closed, this will be
 299         /// true until the port configuration is updated;
 300         bool _ports_changed;
 301
 302         bool _polling;
 303         struct pollfd * pfd;
 304         int nfds;
 305 };
 306
 307 #endif // ardour_mackie_control_protocol_h