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