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
  19 #ifndef ardour_mackie_control_protocol_h
  20 #define ardour_mackie_control_protocol_h
  21
  22 #include <vector>
  23
  24 #include <sys/time.h>
  25 #include <pthread.h>
  26
  27 #include <glibmm/thread.h>
  28
  29 #include "ardour/types.h"
  30 #include "ardour/midi_ui.h"
  31 #include "midi++/types.h"
  32
  33 #include "control_protocol/control_protocol.h"
  34 #include "midi_byte_array.h"
  35 #include "controls.h"
  36 #include "dummy_port.h"
  37 #include "route_signal.h"
  38 #include "mackie_button_handler.h"
  39 #include "mackie_port.h"
  40 #include "mackie_jog_wheel.h"
  41 #include "timer.h"
  42
  43 namespace MIDI {
  44         class Port;
  45 }
  46
  47 namespace Mackie {
  48         class Surface;
  49 }
  50
  51 /**
  52         This handles the plugin duties, and the midi encoding and decoding,
  53         and the signal callbacks, mostly from ARDOUR::Route.
  54
  55         The model of the control surface is handled by classes in controls.h
  56
  57         What happens is that each strip on the control surface has
  58         a corresponding route in ControlProtocol::route_table. When
  59         an incoming midi message is signaled, the correct route
  60         is looked up, and the relevant changes made to it.
  61
  62         For each route currently in route_table, there's a RouteSignal object
  63         which encapsulates the signals that indicate that there are changes
  64         to be sent to the surface. The signals are handled by this class.
  65
  66         Calls to signal handlers pass a Route object which is used to look
  67         up the relevant Strip in Surface. Then the state is retrieved from
  68         the Route and encoded as the correct midi message.
  69 */
  70
  71 class MackieControlProtocol
  72         : public ARDOUR::ControlProtocol
  73         , public Mackie::MackieButtonHandler
  74 {
  75   public:
  76         MackieControlProtocol(ARDOUR::Session &);
  77         virtual ~MackieControlProtocol();
  78
  79         int set_active (bool yn);
  80
  81         XMLNode& get_state ();
  82         int set_state (const XMLNode&, int version);
  83
  84         static bool probe();
  85
  86         Mackie::Surface & surface();
  87
  88         // control events
  89         void handle_control_event(Mackie::SurfacePort & port, Mackie::Control & control, const Mackie::ControlState & state);
  90
  91         // strip/route related stuff
  92   public:
  93         /// Signal handler for Route::solo
  94         void notify_solo_changed(Mackie::RouteSignal *);
  95         /// Signal handler for Route::mute
  96         void notify_mute_changed(Mackie::RouteSignal *);
  97         /// Signal handler for Route::record_enable_changed
  98         void notify_record_enable_changed(Mackie::RouteSignal *);
  99         /// Signal handler for Route::gain_changed (from IO)
 100         void notify_gain_changed(Mackie::RouteSignal *, bool force_update = true);
 101         /// Signal handler for Route::name_change
 102         void notify_name_changed(Mackie::RouteSignal *);
 103         /// Signal handler from Panner::Change
 104         void notify_panner_changed(Mackie::RouteSignal *, bool force_update = true);
 105         /// Signal handler for new routes added
 106         void notify_route_added(ARDOUR::RouteList &);
 107         /// Signal handler for Route::active_changed
 108         void notify_active_changed(Mackie::RouteSignal *);
 109
 110         void notify_remote_id_changed();
 111
 112         /// rebuild the current bank. Called on route added/removed and
 113         /// remote id changed.
 114         void refresh_current_bank();
 115
 116         // global buttons (ie button not part of strips)
 117
 118   public:
 119         // button-related signals
 120         void notify_record_state_changed();
 121         void notify_transport_state_changed();
 122         // mainly to pick up punch-in and punch-out
 123         void notify_parameter_changed(std::string const &);
 124         void notify_solo_active_changed(bool);
 125
 126         /// Turn timecode on and beats off, or vice versa, depending
 127         /// on state of _timecode_type
 128         void update_timecode_beats_led();
 129
 130         /// this is called to generate the midi to send in response to a button press.
 131         void update_led(Mackie::Button & button, Mackie::LedState);
 132
 133         void update_global_button(const std::string & name, Mackie::LedState);
 134         void update_global_led(const std::string & name, Mackie::LedState);
 135
 136         // transport button handler methods from MackieButtonHandler
 137         virtual Mackie::LedState frm_left_press(Mackie::Button &);
 138         virtual Mackie::LedState frm_left_release(Mackie::Button &);
 139
 140         virtual Mackie::LedState frm_right_press(Mackie::Button &);
 141         virtual Mackie::LedState frm_right_release(Mackie::Button &);
 142
 143         virtual Mackie::LedState stop_press(Mackie::Button &);
 144         virtual Mackie::LedState stop_release(Mackie::Button &);
 145
 146         virtual Mackie::LedState play_press(Mackie::Button &);
 147         virtual Mackie::LedState play_release(Mackie::Button &);
 148
 149         virtual Mackie::LedState record_press(Mackie::Button &);
 150         virtual Mackie::LedState record_release(Mackie::Button &);
 151
 152         virtual Mackie::LedState loop_press(Mackie::Button &);
 153         virtual Mackie::LedState loop_release(Mackie::Button &);
 154
 155         virtual Mackie::LedState punch_in_press(Mackie::Button &);
 156         virtual Mackie::LedState punch_in_release(Mackie::Button &);
 157
 158         virtual Mackie::LedState punch_out_press(Mackie::Button &);
 159         virtual Mackie::LedState punch_out_release(Mackie::Button &);
 160
 161         virtual Mackie::LedState home_press(Mackie::Button &);
 162         virtual Mackie::LedState home_release(Mackie::Button &);
 163
 164         virtual Mackie::LedState end_press(Mackie::Button &);
 165         virtual Mackie::LedState end_release(Mackie::Button &);
 166
 167         virtual Mackie::LedState rewind_press(Mackie::Button & button);
 168         virtual Mackie::LedState rewind_release(Mackie::Button & button);
 169
 170         virtual Mackie::LedState ffwd_press(Mackie::Button & button);
 171         virtual Mackie::LedState ffwd_release(Mackie::Button & button);
 172
 173         // bank switching button handler methods from MackieButtonHandler
 174         virtual Mackie::LedState left_press(Mackie::Button &);
 175         virtual Mackie::LedState left_release(Mackie::Button &);
 176
 177         virtual Mackie::LedState right_press(Mackie::Button &);
 178         virtual Mackie::LedState right_release(Mackie::Button &);
 179
 180         virtual Mackie::LedState channel_left_press(Mackie::Button &);
 181         virtual Mackie::LedState channel_left_release(Mackie::Button &);
 182
 183         virtual Mackie::LedState channel_right_press(Mackie::Button &);
 184         virtual Mackie::LedState channel_right_release(Mackie::Button &);
 185
 186         virtual Mackie::LedState clicking_press(Mackie::Button &);
 187         virtual Mackie::LedState clicking_release(Mackie::Button &);
 188
 189         virtual Mackie::LedState global_solo_press(Mackie::Button &);
 190         virtual Mackie::LedState global_solo_release(Mackie::Button &);
 191
 192         // function buttons
 193         virtual Mackie::LedState marker_press(Mackie::Button &);
 194         virtual Mackie::LedState marker_release(Mackie::Button &);
 195
 196         virtual Mackie::LedState drop_press(Mackie::Button &);
 197         virtual Mackie::LedState drop_release(Mackie::Button &);
 198
 199         virtual Mackie::LedState save_press(Mackie::Button &);
 200         virtual Mackie::LedState save_release(Mackie::Button &);
 201
 202         virtual Mackie::LedState timecode_beats_press(Mackie::Button &);
 203         virtual Mackie::LedState timecode_beats_release(Mackie::Button &);
 204
 205         // jog wheel states
 206         virtual Mackie::LedState zoom_press(Mackie::Button &);
 207         virtual Mackie::LedState zoom_release(Mackie::Button &);
 208
 209         virtual Mackie::LedState scrub_press(Mackie::Button &);
 210         virtual Mackie::LedState scrub_release(Mackie::Button &);
 211
 212         /// This is the main MCU port, ie not an extender port
 213         /// Only for use by JogWheel
 214         const Mackie::SurfacePort & mcu_port() const;
 215         Mackie::SurfacePort & mcu_port();
 216         ARDOUR::Session & get_session() { return *session; }
 217
 218   protected:
 219         // create instances of MackiePort, depending on what's found in ardour.rc
 220         void create_ports();
 221
 222         // shut down the surface
 223         void close();
 224
 225         // create the Surface object, with the correct number
 226         // of strips for the currently connected ports and
 227         // hook up the control event notification
 228         void initialize_surface();
 229
 230         // This sets up the notifications and sets the
 231         // controls to the correct values
 232         void update_surface();
 233
 234         // connects global (not strip) signals from the Session to here
 235         // so the surface can be notified of changes from the other UIs.
 236         void connect_session_signals();
 237
 238         // set all controls to their zero position
 239         void zero_all();
 240
 241         /**
 242            Fetch the set of routes to be considered for control by the
 243            surface. Excluding master, hidden and control routes, and inactive routes
 244         */
 245         typedef std::vector<boost::shared_ptr<ARDOUR::Route> > Sorted;
 246         Sorted get_sorted_routes();
 247
 248         // bank switching
 249         void switch_banks(int initial);
 250         void prev_track();
 251         void next_track();
 252
 253         // delete all RouteSignal objects connecting Routes to Strips
 254         void clear_route_signals();
 255
 256         typedef std::vector<Mackie::RouteSignal*> RouteSignals;
 257         RouteSignals route_signals;
 258
 259         // return which of the ports a particular route_table
 260         // index belongs to
 261         Mackie::MackiePort & port_for_id(uint32_t index);
 262
 263         /**
 264            Handle a button press for the control and return whether
 265            the corresponding light should be on or off.
 266         */
 267         bool handle_strip_button(Mackie::Control &, Mackie::ButtonState, boost::shared_ptr<ARDOUR::Route>);
 268
 269         void add_port(MIDI::Port &, int number);
 270
 271         /**
 272            Read session data and send to surface. Includes
 273            automation from the currently active routes and
 274            timecode displays.
 275         */
 276         void poll_session_data();
 277
 278         // called from poll_automation to figure out which automations need to be sent
 279         void update_automation(Mackie::RouteSignal &);
 280
 281         // also called from poll_automation to update timecode display
 282         void update_timecode_display();
 283
 284         std::string format_bbt_timecode (ARDOUR::nframes_t now_frame);
 285         std::string format_timecode_timecode (ARDOUR::nframes_t now_frame);
 286
 287         /**
 288            notification that the port is about to start it's init sequence.
 289            We must make sure that before this exits, the port is being polled
 290            for new data.
 291         */
 292         void handle_port_init(Mackie::SurfacePort *);
 293
 294         /// notification from a MackiePort that it's now active
 295         void handle_port_active(Mackie::SurfacePort *);
 296
 297         /// notification from a MackiePort that it's now inactive
 298         void handle_port_inactive(Mackie::SurfacePort *);
 299
 300         boost::shared_ptr<ARDOUR::Route> master_route();
 301         Mackie::Strip & master_strip();
 302
 303   private:
 304         boost::shared_ptr<Mackie::RouteSignal> master_route_signal;
 305
 306         static const char * default_port_name;
 307
 308         /// The Midi port(s) connected to the units
 309         typedef std::vector<Mackie::MackiePort*> MackiePorts;
 310         MackiePorts _ports;
 311
 312         /// Sometimes the real port goes away, and we want to contain the breakage
 313         Mackie::DummyPort _dummy_port;
 314
 315         /// The initial remote_id of the currently switched in bank.
 316         uint32_t _current_initial_bank;
 317
 318         /// protects the port list
 319         Glib::Mutex update_mutex;
 320
 321         PBD::ScopedConnectionList session_connections;
 322         PBD::ScopedConnectionList port_connections;
 323         PBD::ScopedConnectionList route_connections;
 324
 325         /// The representation of the physical controls on the surface.
 326         Mackie::Surface * _surface;
 327
 328         bool _transport_previously_rolling;
 329
 330         // timer for two quick marker left presses
 331         Mackie::Timer _frm_left_last;
 332
 333         Mackie::JogWheel _jog_wheel;
 334
 335         // last written timecode string
 336         std::string _timecode_last;
 337
 338         // Which timecode are we displaying? BBT or Timecode
 339         ARDOUR::AnyTime::Type _timecode_type;
 340 };
 341
 342 #endif // ardour_mackie_control_protocol_h