launch_control_xl.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Jan Lentfer <jan.lentfer@web.de>
 * Copyright (C) 2018 Robin Gareus <robin@gareus.org>
 * Copyright (C) 2018 Térence Clastres <t.clastres@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef __ardour_launch_control_h__
#define __ardour_launch_control_h__
 
#include <vector>
#include <map>
#include <stack>
#include <list>
#include <set>
 
#define ABSTRACT_UI_EXPORTS
#include "pbd/abstract_ui.h"
 
#include "midi++/types.h"
 
#include "ardour/mode.h"
#include "ardour/types.h"
 
#include "control_protocol/control_protocol.h"
#include "control_protocol/types.h"
 
#include "midi_byte_array.h"
 
namespace MIDI {
class Parser;
class Port;
} // namespace MIDI
 
namespace ARDOUR {
class AsyncMIDIPort;
class Port;
class MidiBuffer;
class MidiTrack;
} // namespace ARDOUR
 
namespace ArdourSurface {
 
 
struct LaunchControlRequest : public BaseUI::BaseRequestObject {
        public:
                LaunchControlRequest() {}
                ~LaunchControlRequest() {}
};
 
class LCXLGUI;
class LaunchControlMenu;
 
class LaunchControlXL : public ARDOUR::ControlProtocol,
                        public AbstractUI<LaunchControlRequest>
{
public:
        enum TrackMode {
                TrackMute,
                TrackSolo,
                TrackRecord
        };
 
        enum ButtonID {
                Focus1 = 0,
                Focus2,
                Focus3,
                Focus4,
                Focus5,
                Focus6,
                Focus7,
                Focus8,
                Control1,
                Control2,
                Control3,
                Control4,
                Control5,
                Control6,
                Control7,
                Control8,
                Device,
                Mute,
                Solo,
                Record,
                SelectUp,
                SelectDown,
                SelectLeft,
                SelectRight
        };
 
        enum FaderID {
                Fader1 = 0,
                Fader2,
                Fader3,
                Fader4,
                Fader5,
                Fader6,
                Fader7,
                Fader8
        };
 
        enum KnobID {
                SendA1 = 0,
                SendA2,
                SendA3,
                SendA4,
                SendA5,
                SendA6,
                SendA7,
                SendA8,
                SendB1,
                SendB2,
                SendB3,
                SendB4,
                SendB5,
                SendB6,
                SendB7,
                SendB8,
                Pan1,
                Pan2,
                Pan3,
                Pan4,
                Pan5,
                Pan6,
                Pan7,
                Pan8
        };
 
        enum DeviceStatus {
                dev_nonexistant = 0,
                dev_inactive,
                dev_active
        };
 
        enum LEDFlag { Normal = 0xC, Blink = 0x8, DoubleBuffering = 0x0 };
        enum LEDColor { Off=0, RedLow = 1, RedFull = 3, GreenLow = 16, GreenFull = 48, YellowLow = 34, YellowFull = 51, AmberLow = 18, AmberFull = 35};
 
 
#ifdef MIXBUS
        enum CompParam {
                CompMakeup,
                CompMode,
        };
#endif
 
        struct Controller {
                Controller(uint8_t cn,  uint8_t val, std::function<void ()> action)
                : _controller_number(cn)
                , _value(val)
                , action_method(action) {}
 
                uint8_t  controller_number() const { return _controller_number; }
                uint8_t value() const { return _value; }
                void set_value(uint8_t val) { _value = val; }
 
                protected:
                uint8_t _controller_number;
                uint8_t _value;
 
                public:
                std::function<void ()> action_method;
        };
 
        struct LED {
                LED(uint8_t i, LEDColor c, LaunchControlXL& l) : _index(i), _color(c), _flag(Normal), lcxl(&l)  {}
                LED(uint8_t i, LEDColor c, LEDFlag f, LaunchControlXL& lcxl) : _index(i), _color(c), _flag(f) {}
                virtual ~LED() {}
 
                LEDColor color() const { return _color; }
                LEDFlag flag() const { return _flag; }
                uint8_t index() const { return _index; }
                void set_flag(LEDFlag f) { _flag = f; }
 
                virtual MidiByteArray state_msg(bool light) const = 0;
 
                protected:
                uint8_t _index;
                LEDColor _color;
                LEDFlag _flag;
                MidiByteArray _state_msg;
                LaunchControlXL* lcxl;
        };
 
        struct MultiColorLED : public LED {
                MultiColorLED (uint8_t i, LEDColor c, LaunchControlXL& l) : LED(i, c, l) {}
                MultiColorLED (uint8_t i, LEDColor c, LEDFlag f, LaunchControlXL& l)
                        : LED(i, c, f, l) {}
 
                void set_color(LEDColor c) { _color = c; }
        };
 
        struct Button {
                Button(ButtonID id, std::function<void ()> press, std::function<void ()> release,
                                std::function<void ()> long_press)
                        : press_method(press)
                        , release_method(release)
                        , long_press_method(long_press),
                        _id(id) {}
 
                virtual ~Button() {}
 
                ButtonID id() const { return _id; }
 
                std::function<void ()> press_method;
                std::function<void ()> release_method;
                std::function<void ()> long_press_method;
 
                sigc::connection timeout_connection;
 
                protected:
                ButtonID _id;
        };
 
        struct ControllerButton : public Button {
                ControllerButton(ButtonID id, uint8_t cn,
                                std::function<void ()> press,
                                std::function<void ()> release,
                                std::function<void ()> long_release)
                        : Button(id, press, release, long_release), _controller_number(cn) {}
 
 
 
                uint8_t controller_number() const { return _controller_number; }
 
                private:
                uint8_t _controller_number;
        };
 
        struct NoteButton : public Button {
                NoteButton(ButtonID id, uint8_t cn,
                                std::function<void ()> press,
                                std::function<void ()> release,
                                std::function<void ()> release_long)
                        : Button(id, press, release, release_long), _note_number(cn) {}
 
                uint8_t note_number() const { return _note_number; }
 
                private:
                uint8_t _note_number;
        };
 
        struct TrackButton : public NoteButton, public MultiColorLED {
                TrackButton(ButtonID id, uint8_t nn, uint8_t index, LEDColor c_on, LEDColor c_off,
                                std::function<void ()> press,
                                std::function<void ()> release,
                                std::function<void ()> release_long,
                                std::function<uint8_t ()> check,
                                LaunchControlXL& l)
                        : NoteButton(id, nn, press, release, release_long)
                        , MultiColorLED(index, Off, l)
                        , check_method(check)
                        , _color_enabled (c_on)
                        , _color_disabled (c_off) {}
 
 
 
 
                LEDColor color_enabled() const { return _color_enabled; }
                LEDColor color_disabled() const { return _color_disabled; }
                void set_color_enabled (LEDColor c_on) { _color_enabled = c_on; }
                void set_color_disabled (LEDColor c_off) { _color_disabled = c_off; }
                std::function<uint8_t ()> check_method;
 
 
                MidiByteArray state_msg(bool light = true) const;
 
                private:
                LEDColor _color_enabled;
                LEDColor _color_disabled;
        };
 
        struct SelectButton : public ControllerButton, public LED {
                SelectButton(ButtonID id, uint8_t cn, uint8_t index,
                                std::function<void ()> press,
                                std::function<void ()> release,
                                std::function<void ()> long_release,
                                LaunchControlXL& l)
                        : ControllerButton(id, cn, press, release, long_release), LED(index, RedFull, l) {}
 
 
                MidiByteArray state_msg(bool light) const;
        };
 
        struct TrackStateButton : public NoteButton, public LED {
                TrackStateButton(ButtonID id, uint8_t nn, uint8_t index,
                                std::function<void ()> press,
                                std::function<void ()> release,
                                std::function<void ()> release_long,
                                LaunchControlXL& l)
                        : NoteButton(id, nn, press, release, release_long)
                        , LED(index, YellowLow, l) {}
 
                MidiByteArray state_msg(bool light) const;
        };
 
        struct Fader : public Controller {
                Fader(FaderID id, uint8_t cn, std::function<void ()> action)
                        : Controller(cn, 0, action), _id(id) {} // minimal value
 
                FaderID id() const { return _id; }
 
                void controller_changed(Controller* controller);
 
                private:
                FaderID _id;
        };
 
        struct Knob : public Controller, public MultiColorLED {
                Knob(KnobID id, uint8_t cn, uint8_t index, LEDColor c_on, LEDColor c_off, std::function<void ()> action,
                        LaunchControlXL &l)
                        : Controller(cn, 64, action)
                        , MultiColorLED(index, Off, l)
                        , _id(id)
                        , _color_enabled (c_on)
                        , _color_disabled (c_off) {} // knob 50/50 value
 
                Knob(KnobID id, uint8_t cn, uint8_t index, LEDColor c_on, LEDColor c_off, std::function<void ()> action,
                        std::function<uint8_t ()> check, LaunchControlXL &l)
                        : Controller(cn, 64, action)
                        , MultiColorLED(index, Off, l)
                        , check_method(check)
                        , _id(id)
                        , _color_enabled (c_on)
                        , _color_disabled (c_off) {} // knob 50/50 value
 
 
 
                KnobID id() const { return _id; }
                LEDColor color_enabled() const { return _color_enabled; }
                LEDColor color_disabled() const { return _color_disabled; }
                std::function<uint8_t ()> check_method;
 
                MidiByteArray state_msg(bool light = true) const;
 
                private:
                KnobID _id;
                LEDColor _color_enabled;
                LEDColor _color_disabled;
        };
 
public:
        LaunchControlXL(ARDOUR::Session &);
        ~LaunchControlXL();
 
        std::list<std::shared_ptr<ARDOUR::Bundle> > bundles();
 
        bool has_editor() const { return true; }
        void *get_gui() const;
        void tear_down_gui();
 
        int get_amount_of_tracks();
 
        int set_active(bool yn);
        XMLNode& get_state() const;
        int set_state(const XMLNode &node, int version);
 
        PBD::Signal<void()> ConnectionChange;
 
        std::shared_ptr<ARDOUR::Port> input_port();
        std::shared_ptr<ARDOUR::Port> output_port();
 
        Button *button_by_id(ButtonID);
 
        static std::string button_name_by_id(ButtonID);
        static std::string knob_name_by_id(KnobID);
        static std::string fader_name_by_id(FaderID);
 
        void write(const MidiByteArray &);
        void reset(uint8_t chan);
 
        void set_fader8master (bool yn);
        bool fader8master () const { return _fader8master; }
 
        void set_refresh_leds_flag (bool yn);
        bool refresh_leds_flag () const { return _refresh_leds_flag; }
 
        void set_device_mode (bool yn);
        bool device_mode () const { return _device_mode; }
 
#ifdef MIXBUS
        void set_ctrllowersends (bool yn);
        bool ctrllowersends () const { return _ctrllowersends; }
 
        void store_fss_type();
        bool fss_is_mixbus() const { return _fss_is_mixbus; }
#endif
        TrackMode track_mode() const { return _track_mode; }
        void set_track_mode(TrackMode mode);
 
        uint8_t template_number() const { return _template_number; }
 
        void set_send_bank (int offset);
        void send_bank_switch(bool up);
        int send_bank_base () const { return _send_bank_base; }
 
        CONTROL_PROTOCOL_THREADS_NEED_TEMPO_MAP_DECL();
 
private:
        bool in_use;
        TrackMode _track_mode;
        uint8_t _template_number;
 
        bool _fader8master;
        bool _device_mode;
#ifdef MIXBUS
        bool _ctrllowersends;
        bool _fss_is_mixbus;
#endif
        bool _refresh_leds_flag;
 
        int _send_bank_base;
 
        void do_request(LaunchControlRequest *);
 
        int begin_using_device();
        int stop_using_device();
        int ports_acquire();
        void ports_release();
        void run_event_loop();
        void stop_event_loop();
 
        void relax() {}
 
        /* map of NoteButtons by NoteNumber */
        typedef std::map<int, std::shared_ptr<NoteButton> > NNNoteButtonMap;
        NNNoteButtonMap nn_note_button_map;
        /* map of NoteButtons by ButtonID */
        typedef std::map<ButtonID, std::shared_ptr<NoteButton> > IDNoteButtonMap;
        IDNoteButtonMap id_note_button_map;
        /* map of ControllerNoteButtons by CC */
        typedef std::map<int, std::shared_ptr<ControllerButton> > CCControllerButtonMap;
        CCControllerButtonMap cc_controller_button_map;
        /* map of ControllerButtons by ButtonID */
        typedef std::map<ButtonID, std::shared_ptr<ControllerButton> > IDControllerButtonMap;
        IDControllerButtonMap id_controller_button_map;
 
 
        /* map of Fader by CC */
        typedef std::map<int, std::shared_ptr<Fader> > CCFaderMap;
        CCFaderMap cc_fader_map;
        /* map of Fader by FaderID */
        typedef std::map<FaderID, std::shared_ptr<Fader> > IDFaderMap;
        IDFaderMap id_fader_map;
 
        /* map of Knob by CC */
        typedef std::map<int, std::shared_ptr<Knob> > CCKnobMap;
        CCKnobMap cc_knob_map;
        /* map of Knob by KnobID */
        typedef std::map<KnobID, std::shared_ptr<Knob> > IDKnobMap;
        IDKnobMap id_knob_map;
 
        std::set<ButtonID> buttons_down;
        std::set<ButtonID> consumed;
 
        bool button_long_press_timeout(ButtonID id, std::shared_ptr<Button> button);
        void start_press_timeout(std::shared_ptr<Button> , ButtonID);
 
        void init_buttons();
        void init_buttons(bool startup);
        void init_buttons (ButtonID buttons[], uint8_t i);
        void init_knobs();
        void init_knobs(KnobID knobs[], uint8_t i);
        void init_knobs_and_buttons();
 
        void init_device_mode();
        void init_dm_callbacks();
 
        void switch_template(uint8_t t);
        void filter_stripables (ARDOUR::StripableList& strips) const;
 
        void build_maps();
 
        // Bundle to represent our input ports
        std::shared_ptr<ARDOUR::Bundle> _input_bundle;
        // Bundle to represent our output ports
        std::shared_ptr<ARDOUR::Bundle> _output_bundle;
 
        MIDI::Port *_input_port;
        MIDI::Port *_output_port;
        std::shared_ptr<ARDOUR::Port> _async_in;
        std::shared_ptr<ARDOUR::Port> _async_out;
 
        void connect_to_parser();
        void handle_button_message(std::shared_ptr<Button> button, MIDI::EventTwoBytes *);
 
        bool check_pick_up(std::shared_ptr<Controller> controller, std::shared_ptr<ARDOUR::AutomationControl> ac, bool rotary = false);
 
        void handle_midi_controller_message(MIDI::Parser &, MIDI::EventTwoBytes *, MIDI::channel_t chan);
        void handle_midi_note_on_message(MIDI::Parser &, MIDI::EventTwoBytes *, MIDI::channel_t chan);
        void handle_midi_note_off_message(MIDI::Parser &, MIDI::EventTwoBytes *, MIDI::channel_t chan);
        void handle_midi_sysex(MIDI::Parser &, MIDI::byte *, size_t count);
 
        bool midi_input_handler(Glib::IOCondition ioc, MIDI::Port *port);
 
        void thread_init();
 
        PBD::ScopedConnectionList session_connections;
        void connect_session_signals();
        void notify_transport_state_changed();
        void notify_loop_state_changed();
        void notify_parameter_changed(std::string);
 
        /* Knob methods */
        std::shared_ptr<Knob> knob_by_id(KnobID id);
        std::shared_ptr<Knob>* knobs_by_column(uint8_t col, std::shared_ptr<Knob>* knob_col);
        void update_knob_led_by_strip(uint8_t n);
        void update_knob_led_by_id(uint8_t id, LEDColor color);
 
        void knob_sendA(uint8_t n);
        void knob_sendB(uint8_t n);
        void knob_pan(uint8_t n);
 
        uint8_t dm_check_dummy(DeviceStatus ds);
 
        void dm_fader(FaderID id);
        uint8_t dm_check_pan_azi ();
        void dm_pan_azi(KnobID k);
        uint8_t dm_check_pan_width();
        void dm_pan_width (KnobID k);
        uint8_t dm_check_trim ();
        void dm_trim(KnobID k);
        uint8_t dm_mute_enabled();
        void dm_mute_switch();
        uint8_t dm_solo_enabled();
        void dm_solo_switch();
        uint8_t dm_recenable_enabled();
        void dm_recenable_switch();
        void dm_select_prev_strip();
        void dm_select_next_strip();
 
#ifdef MIXBUS
        void dm_mb_eq_switch();
        void dm_mb_eq (KnobID k, bool gain, uint8_t band);
        uint8_t dm_mb_eq_freq_enabled();
        uint8_t dm_mb_eq_gain_enabled(uint8_t band);
        void dm_mb_eq_shape_switch(uint8_t band);
        uint8_t dm_mb_eq_shape_enabled(uint8_t band);
        uint8_t dm_mb_flt_enabled();
        void dm_mb_flt_frq (KnobID k, bool hpf);
        void dm_mb_flt_switch();
        void dm_mb_send_enabled(KnobID k);
        uint8_t dm_mb_check_send_knob(KnobID k);
        uint8_t dm_mb_check_send_button(uint8_t s);
        void dm_mb_sends (KnobID k);
        void dm_mb_send_switch (ButtonID b);
        uint8_t dm_mb_comp_enabled();
        void dm_mb_comp_switch();
        void dm_mb_comp (KnobID k, CompParam c);
        void dm_mb_comp_thresh (FaderID id);
        uint8_t dm_mb_has_tapedrive();
        void dm_mb_tapedrive (KnobID k);
        uint8_t dm_mb_master_assign_enabled();
        void dm_mb_master_assign_switch();
#endif
 
        /* Fader methods */
        void fader(uint8_t n);
 
 
        /* Button methods */
        std::shared_ptr<TrackButton> track_button_by_range(uint8_t n, uint8_t first, uint8_t middle);
        std::shared_ptr<TrackButton> focus_button_by_column(uint8_t col) { return track_button_by_range(col, 41, 57) ; }
        std::shared_ptr<TrackButton> control_button_by_column(uint8_t col) { return track_button_by_range(col, 73, 89) ; }
 
 
        void button_device();
        void button_device_long_press();
        void button_track_mode(TrackMode state);
        void button_mute();
        void button_mute_long_press();
        void button_solo();
        void button_solo_long_press();
        void button_record();
        void button_select_up();
        void button_select_down();
        void button_select_left();
        void button_select_right();
 
        void button_track_focus(uint8_t n);
        void button_press_track_control(uint8_t n);
        void button_release_track_control(uint8_t n);
 
        std::shared_ptr<ARDOUR::AutomationControl> get_ac_by_state(uint8_t n);
        void update_track_focus_led(uint8_t n);
        void update_track_control_led(uint8_t n);
 
        void send_bank_switch_0() { send_bank_switch(0); }
        void send_bank_switch_1() { send_bank_switch(1); }
 
        /* stripables */
 
        int32_t bank_start;
        PBD::ScopedConnectionList stripable_connections;
        std::shared_ptr<ARDOUR::Stripable> stripable[8];
 
        void stripables_added ();
 
        void stripable_property_change (PBD::PropertyChange const& what_changed, uint32_t which);
 
        void switch_bank (uint32_t base);
 
        void solo_changed (uint32_t n) { solo_mute_rec_changed(n); }
        void mute_changed (uint32_t n) { solo_mute_rec_changed(n); }
        void rec_changed (uint32_t n) { solo_mute_rec_changed(n); }
        void solo_iso_changed (uint32_t n);
        void solo_iso_led_bank ();
#ifdef MIXBUS
        void master_send_changed (uint32_t n);
        void master_send_led_bank ();
#endif
 
        void solo_mute_rec_changed (uint32_t n);
 
        /* special Stripable */
 
        std::shared_ptr<ARDOUR::Stripable> master;
 
        void port_registration_handler();
 
        enum ConnectionState { InputConnected = 0x1, OutputConnected = 0x2 };
 
        int connection_state;
        bool connection_handler(std::weak_ptr<ARDOUR::Port>, std::string name1,
                        std::weak_ptr<ARDOUR::Port>, std::string name2,
                        bool yn);
        PBD::ScopedConnection port_connection;
        void connected();
 
        /* GUI */
 
        mutable LCXLGUI *gui;
        void build_gui();
 
        void stripable_selection_changed();
 
        bool in_range_select;
};
 
 
} // namespace ArdourSurface
 
#endif /* __ardour_launch_control_h__ */