]> git.sesse.net Git - nageru/blob - midi_mapper.h
Make FFmpegCapture send semi-reasonable timestamps with its audio data.
[nageru] / midi_mapper.h
1 #ifndef _MIDI_MAPPER_H
2 #define _MIDI_MAPPER_H 1
3
4 // MIDIMapper is a class that listens for incoming MIDI messages from
5 // mixer controllers (ie., it is not meant to be used with regular
6 // instruments), interprets them according to a device-specific, user-defined
7 // mapping, and calls back into a receiver (typically the MainWindow).
8 // This way, it is possible to control audio functionality using physical
9 // pots and faders instead of the mouse.
10
11 #include <atomic>
12 #include <functional>
13 #include <map>
14 #include <memory>
15 #include <mutex>
16 #include <set>
17 #include <string>
18 #include <thread>
19
20 #include "defs.h"
21
22 class MIDIMappingProto;
23 typedef struct snd_seq_addr snd_seq_addr_t;
24 typedef struct snd_seq_event snd_seq_event_t;
25 typedef struct _snd_seq snd_seq_t;
26
27 // Interface for receiving interpreted controller messages.
28 class ControllerReceiver {
29 public:
30         // All values are [0.0, 1.0].
31         virtual void set_locut(float value) = 0;
32         virtual void set_limiter_threshold(float value) = 0;
33         virtual void set_makeup_gain(float value) = 0;
34
35         virtual void set_treble(unsigned bus_idx, float value) = 0;
36         virtual void set_mid(unsigned bus_idx, float value) = 0;
37         virtual void set_bass(unsigned bus_idx, float value) = 0;
38         virtual void set_gain(unsigned bus_idx, float value) = 0;
39         virtual void set_compressor_threshold(unsigned bus_idx, float value) = 0;
40         virtual void set_fader(unsigned bus_idx, float value) = 0;
41
42         virtual void toggle_mute(unsigned bus_idx) = 0;
43         virtual void toggle_locut(unsigned bus_idx) = 0;
44         virtual void toggle_auto_gain_staging(unsigned bus_idx) = 0;
45         virtual void toggle_compressor(unsigned bus_idx) = 0;
46         virtual void clear_peak(unsigned bus_idx) = 0;
47         virtual void toggle_limiter() = 0;
48         virtual void toggle_auto_makeup_gain() = 0;
49
50         // Signals to highlight controls to mark them to the user
51         // as MIDI-controllable (or not).
52         virtual void clear_all_highlights() = 0;
53
54         virtual void highlight_locut(bool highlight) = 0;
55         virtual void highlight_limiter_threshold(bool highlight) = 0;
56         virtual void highlight_makeup_gain(bool highlight) = 0;
57
58         virtual void highlight_treble(unsigned bus_idx, bool highlight) = 0;
59         virtual void highlight_mid(unsigned bus_idx, bool highlight) = 0;
60         virtual void highlight_bass(unsigned bus_idx, bool highlight) = 0;
61         virtual void highlight_gain(unsigned bus_idx, bool highlight) = 0;
62         virtual void highlight_compressor_threshold(unsigned bus_idx, bool highlight) = 0;
63         virtual void highlight_fader(unsigned bus_idx, bool highlight) = 0;
64
65         virtual void highlight_mute(unsigned bus_idx, bool highlight) = 0;
66         virtual void highlight_toggle_locut(unsigned bus_idx, bool highlight) = 0;
67         virtual void highlight_toggle_auto_gain_staging(unsigned bus_idx, bool highlight) = 0;
68         virtual void highlight_toggle_compressor(unsigned bus_idx, bool highlight) = 0;
69         virtual void highlight_clear_peak(unsigned bus_idx, bool highlight) = 0;
70         virtual void highlight_toggle_limiter(bool highlight) = 0;
71         virtual void highlight_toggle_auto_makeup_gain(bool highlight) = 0;
72
73         // Raw events; used for the editor dialog only.
74         virtual void controller_changed(unsigned controller) = 0;
75         virtual void note_on(unsigned note) = 0;
76 };
77
78 class MIDIMapper {
79 public:
80         MIDIMapper(ControllerReceiver *receiver);
81         virtual ~MIDIMapper();
82         void set_midi_mapping(const MIDIMappingProto &new_mapping);
83         void start_thread();
84         const MIDIMappingProto &get_current_mapping() const;
85
86         // Overwrites and returns the previous value.
87         ControllerReceiver *set_receiver(ControllerReceiver *new_receiver);
88
89         void refresh_highlights();
90         void refresh_lights();
91
92         void set_has_peaked(unsigned bus_idx, bool has_peaked)
93         {
94                 this->has_peaked[bus_idx] = has_peaked;
95         }
96
97 private:
98         void thread_func();
99         void handle_event(snd_seq_t *seq, snd_seq_event_t *event);
100         void subscribe_to_port_lock_held(snd_seq_t *seq, const snd_seq_addr_t &addr);
101         void match_controller(int controller, int field_number, int bank_field_number, float value, std::function<void(unsigned, float)> func);
102         void match_button(int note, int field_number, int bank_field_number, std::function<void(unsigned)> func);
103         bool has_active_controller(unsigned bus_idx, int field_number, int bank_field_number);  // Also works for buttons.
104         bool bank_mismatch(int bank_field_number);
105
106         void update_highlights();
107
108         void update_lights_lock_held();
109         void activate_lights(unsigned bus_idx, int field_number, std::set<unsigned> *active_lights);
110         void activate_lights_all_buses(int field_number, std::set<unsigned> *active_lights);
111
112         std::atomic<bool> should_quit{false};
113         int should_quit_fd;
114
115         std::atomic<bool> has_peaked[MAX_BUSES] {{ false }};
116
117         mutable std::mutex mu;
118         ControllerReceiver *receiver;  // Under <mu>.
119         std::unique_ptr<MIDIMappingProto> mapping_proto;  // Under <mu>.
120         int num_controller_banks;  // Under <mu>.
121         std::atomic<int> current_controller_bank{0};
122         std::atomic<int> num_subscribed_ports{0};
123
124         std::thread midi_thread;
125         std::map<unsigned, bool> current_light_status;  // Keyed by note number. Under <mu>.
126         snd_seq_t *alsa_seq{nullptr};  // Under <mu>.
127         int alsa_queue_id{-1};  // Under <mu>.
128 };
129
130 bool load_midi_mapping_from_file(const std::string &filename, MIDIMappingProto *new_mapping);
131 bool save_midi_mapping_to_file(const MIDIMappingProto &mapping_proto, const std::string &filename);
132
133 #endif  // !defined(_MIDI_MAPPER_H)