]> git.sesse.net Git - nageru/blob - nageru/mixer.h
Bump version number to 1.8.1-pre.
[nageru] / nageru / mixer.h
1 #ifndef _MIXER_H
2 #define _MIXER_H 1
3
4 // The actual video mixer, running in its own separate background thread.
5
6 #include <assert.h>
7 #include <epoxy/gl.h>
8
9 #undef Success
10
11 #include <stdbool.h>
12 #include <stdint.h>
13 #include <atomic>
14 #include <chrono>
15 #include <condition_variable>
16 #include <cstddef>
17 #include <functional>
18 #include <map>
19 #include <memory>
20 #include <mutex>
21 #include <queue>
22 #include <string>
23 #include <thread>
24 #include <vector>
25
26 #include <movit/image_format.h>
27
28 #include "audio_mixer.h"
29 #include "bmusb/bmusb.h"
30 #include "defs.h"
31 #include "shared/httpd.h"
32 #include "input_state.h"
33 #include "libusb.h"
34 #include "pbo_frame_allocator.h"
35 #include "ref_counted_frame.h"
36 #include "shared/ref_counted_gl_sync.h"
37 #include "theme.h"
38 #include "shared/timebase.h"
39 #include "video_encoder.h"
40 #include "ycbcr_interpretation.h"
41
42 class ALSAOutput;
43 class ChromaSubsampler;
44 class DeckLinkOutput;
45 class MJPEGEncoder;
46 class QSurface;
47 class QSurfaceFormat;
48 class TimecodeRenderer;
49 class v210Converter;
50
51 namespace movit {
52 class Effect;
53 class EffectChain;
54 class ResourcePool;
55 class YCbCrInput;
56 }  // namespace movit
57
58 // A class to estimate the future jitter. Used in QueueLengthPolicy (see below).
59 //
60 // There are many ways to estimate jitter; I've tested a few ones (and also
61 // some algorithms that don't explicitly model jitter) with different
62 // parameters on some real-life data in experiments/queue_drop_policy.cpp.
63 // This is one based on simple order statistics where I've added some margin in
64 // the number of starvation events; I believe that about one every hour would
65 // probably be acceptable, but this one typically goes lower than that, at the
66 // cost of 2–3 ms extra latency. (If the queue is hard-limited to one frame, it's
67 // possible to get ~10 ms further down, but this would mean framedrops every
68 // second or so.) The general strategy is: Take the 99.9-percentile jitter over
69 // last 5000 frames, multiply by two, and that's our worst-case jitter
70 // estimate. The fact that we're not using the max value means that we could
71 // actually even throw away very late frames immediately, which means we only
72 // get one user-visible event instead of seeing something both when the frame
73 // arrives late (duplicate frame) and then again when we drop.
74 class JitterHistory {
75 private:
76         static constexpr size_t history_length = 5000;
77         static constexpr double percentile = 0.999;
78         static constexpr double multiplier = 2.0;
79
80 public:
81         void register_metrics(const std::vector<std::pair<std::string, std::string>> &labels);
82         void unregister_metrics(const std::vector<std::pair<std::string, std::string>> &labels);
83
84         void clear() {
85                 history.clear();
86                 orders.clear();
87         }
88         void frame_arrived(std::chrono::steady_clock::time_point now, int64_t frame_duration, size_t dropped_frames);
89         std::chrono::steady_clock::time_point get_expected_next_frame() const { return expected_timestamp; }
90         double estimate_max_jitter() const;
91
92 private:
93         // A simple O(k) based algorithm for getting the k-th largest or
94         // smallest element from our window; we simply keep the multiset
95         // ordered (insertions and deletions are O(n) as always) and then
96         // iterate from one of the sides. If we had larger values of k,
97         // we could go for a more complicated setup with two sets or heaps
98         // (one increasing and one decreasing) that we keep balanced around
99         // the point, or it is possible to reimplement std::set with
100         // counts in each node. However, since k=5, we don't need this.
101         std::multiset<double> orders;
102         std::deque<std::multiset<double>::iterator> history;
103
104         std::chrono::steady_clock::time_point expected_timestamp = std::chrono::steady_clock::time_point::min();
105
106         // Metrics. There are no direct summaries for jitter, since we already have latency summaries.
107         std::atomic<int64_t> metric_input_underestimated_jitter_frames{0};
108         std::atomic<double> metric_input_estimated_max_jitter_seconds{0.0 / 0.0};
109 };
110
111 // For any card that's not the master (where we pick out the frames as they
112 // come, as fast as we can process), there's going to be a queue. The question
113 // is when we should drop frames from that queue (apart from the obvious
114 // dropping if the 16-frame queue should become full), especially given that
115 // the frame rate could be lower or higher than the master (either subtly or
116 // dramatically). We have two (conflicting) demands:
117 //
118 //   1. We want to avoid starving the queue.
119 //   2. We don't want to add more delay than is needed.
120 //
121 // Our general strategy is to drop as many frames as we can (helping for #2)
122 // that we think is safe for #1 given jitter. To this end, we measure the
123 // deviation from the expected arrival time for all cards, and use that for
124 // continuous jitter estimation.
125 //
126 // We then drop everything from the queue that we're sure we won't need to
127 // serve the output in the time before the next frame arrives. Typically,
128 // this means the queue will contain 0 or 1 frames, although more is also
129 // possible if the jitter is very high.
130 class QueueLengthPolicy {
131 public:
132         QueueLengthPolicy() {}
133         void reset(unsigned card_index) {
134                 this->card_index = card_index;
135         }
136
137         void register_metrics(const std::vector<std::pair<std::string, std::string>> &labels);
138         void unregister_metrics(const std::vector<std::pair<std::string, std::string>> &labels);
139
140         // Call after picking out a frame, so 0 means starvation.
141         void update_policy(std::chrono::steady_clock::time_point now,
142                            std::chrono::steady_clock::time_point expected_next_frame,
143                            int64_t input_frame_duration,
144                            int64_t master_frame_duration,
145                            double max_input_card_jitter_seconds,
146                            double max_master_card_jitter_seconds);
147         unsigned get_safe_queue_length() const { return safe_queue_length; }
148
149 private:
150         unsigned card_index;  // For debugging and metrics only.
151         unsigned safe_queue_length = 0;  // Can never go below zero.
152
153         // Metrics.
154         std::atomic<int64_t> metric_input_queue_safe_length_frames{1};
155 };
156
157 class Mixer {
158 public:
159         // The surface format is used for offscreen destinations for OpenGL contexts we need.
160         Mixer(const QSurfaceFormat &format, unsigned num_cards);
161         ~Mixer();
162         void start();
163         void quit();
164
165         void transition_clicked(int transition_num);
166         void channel_clicked(int preview_num);
167
168         enum Output {
169                 OUTPUT_LIVE = 0,
170                 OUTPUT_PREVIEW,
171                 OUTPUT_INPUT0,  // 1, 2, 3, up to 15 follow numerically.
172                 NUM_OUTPUTS = 18
173         };
174
175         struct DisplayFrame {
176                 // The chain for rendering this frame. To render a display frame,
177                 // first wait for <ready_fence>, then call <setup_chain>
178                 // to wire up all the inputs, and then finally call
179                 // chain->render_to_screen() or similar.
180                 movit::EffectChain *chain;
181                 std::function<void()> setup_chain;
182
183                 // Asserted when all the inputs are ready; you cannot render the chain
184                 // before this.
185                 RefCountedGLsync ready_fence;
186
187                 // Holds on to all the input frames needed for this display frame,
188                 // so they are not released while still rendering.
189                 std::vector<RefCountedFrame> input_frames;
190
191                 // Textures that should be released back to the resource pool
192                 // when this frame disappears, if any.
193                 // TODO: Refcount these as well?
194                 std::vector<GLuint> temp_textures;
195         };
196         // Implicitly frees the previous one if there's a new frame available.
197         bool get_display_frame(Output output, DisplayFrame *frame) {
198                 return output_channel[output].get_display_frame(frame);
199         }
200
201         // NOTE: Callbacks will be called with a mutex held, so you should probably
202         // not do real work in them.
203         typedef std::function<void()> new_frame_ready_callback_t;
204         void add_frame_ready_callback(Output output, void *key, new_frame_ready_callback_t callback)
205         {
206                 output_channel[output].add_frame_ready_callback(key, callback);
207         }
208
209         void remove_frame_ready_callback(Output output, void *key)
210         {
211                 output_channel[output].remove_frame_ready_callback(key);
212         }
213
214         // TODO: Should this really be per-channel? Shouldn't it just be called for e.g. the live output?
215         typedef std::function<void(const std::vector<std::string> &)> transition_names_updated_callback_t;
216         void set_transition_names_updated_callback(Output output, transition_names_updated_callback_t callback)
217         {
218                 output_channel[output].set_transition_names_updated_callback(callback);
219         }
220
221         typedef std::function<void(const std::string &)> name_updated_callback_t;
222         void set_name_updated_callback(Output output, name_updated_callback_t callback)
223         {
224                 output_channel[output].set_name_updated_callback(callback);
225         }
226
227         typedef std::function<void(const std::string &)> color_updated_callback_t;
228         void set_color_updated_callback(Output output, color_updated_callback_t callback)
229         {
230                 output_channel[output].set_color_updated_callback(callback);
231         }
232
233         std::vector<std::string> get_transition_names()
234         {
235                 return theme->get_transition_names(pts());
236         }
237
238         unsigned get_num_channels() const
239         {
240                 return theme->get_num_channels();
241         }
242
243         std::string get_channel_name(unsigned channel) const
244         {
245                 return theme->get_channel_name(channel);
246         }
247
248         std::string get_channel_color(unsigned channel) const
249         {
250                 return theme->get_channel_color(channel);
251         }
252
253         int get_channel_signal(unsigned channel) const
254         {
255                 return theme->get_channel_signal(channel);
256         }
257
258         int map_signal(unsigned channel)
259         {
260                 return theme->map_signal(channel);
261         }
262
263         unsigned get_master_clock() const
264         {
265                 return master_clock_channel;
266         }
267
268         void set_master_clock(unsigned channel)
269         {
270                 master_clock_channel = channel;
271         }
272
273         void set_signal_mapping(int signal, int card)
274         {
275                 return theme->set_signal_mapping(signal, card);
276         }
277
278         YCbCrInterpretation get_input_ycbcr_interpretation(unsigned card_index) const;
279         void set_input_ycbcr_interpretation(unsigned card_index, const YCbCrInterpretation &interpretation);
280
281         bool get_supports_set_wb(unsigned channel) const
282         {
283                 return theme->get_supports_set_wb(channel);
284         }
285
286         void set_wb(unsigned channel, double r, double g, double b) const
287         {
288                 theme->set_wb(channel, r, g, b);
289         }
290
291         // Note: You can also get this through the global variable global_audio_mixer.
292         AudioMixer *get_audio_mixer() { return audio_mixer.get(); }
293         const AudioMixer *get_audio_mixer() const { return audio_mixer.get(); }
294
295         void schedule_cut()
296         {
297                 should_cut = true;
298         }
299
300         unsigned get_num_cards() const { return num_cards; }
301
302         std::string get_card_description(unsigned card_index) const {
303                 assert(card_index < num_cards);
304                 return cards[card_index].capture->get_description();
305         }
306
307         // The difference between this and the previous function is that if a card
308         // is used as the current output, get_card_description() will return the
309         // fake card that's replacing it for input, whereas this function will return
310         // the card's actual name.
311         std::string get_output_card_description(unsigned card_index) const {
312                 assert(card_can_be_used_as_output(card_index));
313                 assert(card_index < num_cards);
314                 if (cards[card_index].parked_capture) {
315                         return cards[card_index].parked_capture->get_description();
316                 } else {
317                         return cards[card_index].capture->get_description();
318                 }
319         }
320
321         bool card_can_be_used_as_output(unsigned card_index) const {
322                 assert(card_index < num_cards);
323                 return cards[card_index].output != nullptr;
324         }
325
326         bool card_is_ffmpeg(unsigned card_index) const {
327                 assert(card_index < num_cards + num_video_inputs);
328                 return cards[card_index].type == CardType::FFMPEG_INPUT;
329         }
330
331         std::map<uint32_t, bmusb::VideoMode> get_available_video_modes(unsigned card_index) const {
332                 assert(card_index < num_cards);
333                 return cards[card_index].capture->get_available_video_modes();
334         }
335
336         uint32_t get_current_video_mode(unsigned card_index) const {
337                 assert(card_index < num_cards);
338                 return cards[card_index].capture->get_current_video_mode();
339         }
340
341         void set_video_mode(unsigned card_index, uint32_t mode) {
342                 assert(card_index < num_cards);
343                 cards[card_index].capture->set_video_mode(mode);
344         }
345
346         void start_mode_scanning(unsigned card_index);
347
348         std::map<uint32_t, std::string> get_available_video_inputs(unsigned card_index) const {
349                 assert(card_index < num_cards);
350                 return cards[card_index].capture->get_available_video_inputs();
351         }
352
353         uint32_t get_current_video_input(unsigned card_index) const {
354                 assert(card_index < num_cards);
355                 return cards[card_index].capture->get_current_video_input();
356         }
357
358         void set_video_input(unsigned card_index, uint32_t input) {
359                 assert(card_index < num_cards);
360                 cards[card_index].capture->set_video_input(input);
361         }
362
363         std::map<uint32_t, std::string> get_available_audio_inputs(unsigned card_index) const {
364                 assert(card_index < num_cards);
365                 return cards[card_index].capture->get_available_audio_inputs();
366         }
367
368         uint32_t get_current_audio_input(unsigned card_index) const {
369                 assert(card_index < num_cards);
370                 return cards[card_index].capture->get_current_audio_input();
371         }
372
373         void set_audio_input(unsigned card_index, uint32_t input) {
374                 assert(card_index < num_cards);
375                 cards[card_index].capture->set_audio_input(input);
376         }
377
378         std::string get_ffmpeg_filename(unsigned card_index) const;
379
380         void set_ffmpeg_filename(unsigned card_index, const std::string &filename);
381
382         void change_x264_bitrate(unsigned rate_kbit) {
383                 video_encoder->change_x264_bitrate(rate_kbit);
384         }
385
386         int get_output_card_index() const {  // -1 = no output, just stream.
387                 return desired_output_card_index;
388         }
389
390         void set_output_card(int card_index) { // -1 = no output, just stream.
391                 desired_output_card_index = card_index;
392         }
393
394         std::map<uint32_t, bmusb::VideoMode> get_available_output_video_modes() const;
395
396         uint32_t get_output_video_mode() const {
397                 return desired_output_video_mode;
398         }
399
400         void set_output_video_mode(uint32_t mode) {
401                 desired_output_video_mode = mode;
402         }
403
404         void set_display_timecode_in_stream(bool enable) {
405                 display_timecode_in_stream = enable;
406         }
407
408         void set_display_timecode_on_stdout(bool enable) {
409                 display_timecode_on_stdout = enable;
410         }
411
412         int64_t get_num_connected_clients() const {
413                 return httpd.get_num_connected_clients();
414         }
415
416         std::vector<Theme::MenuEntry> get_theme_menu() { return theme->get_theme_menu(); }
417
418         void theme_menu_entry_clicked(int lua_ref) { return theme->theme_menu_entry_clicked(lua_ref); }
419
420         void set_theme_menu_callback(std::function<void()> callback)
421         {
422                 theme->set_theme_menu_callback(callback);
423         }
424
425         void wait_for_next_frame();
426
427 private:
428         struct CaptureCard;
429
430         enum class CardType {
431                 LIVE_CARD,
432                 FAKE_CAPTURE,
433                 FFMPEG_INPUT,
434                 CEF_INPUT,
435         };
436         void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, CardType card_type, DeckLinkOutput *output);
437         void set_output_card_internal(int card_index);  // Should only be called from the mixer thread.
438         void bm_frame(unsigned card_index, uint16_t timecode,
439                 bmusb::FrameAllocator::Frame video_frame, size_t video_offset, bmusb::VideoFormat video_format,
440                 bmusb::FrameAllocator::Frame audio_frame, size_t audio_offset, bmusb::AudioFormat audio_format);
441         void bm_hotplug_add(libusb_device *dev);
442         void bm_hotplug_remove(unsigned card_index);
443         void place_rectangle(movit::Effect *resample_effect, movit::Effect *padding_effect, float x0, float y0, float x1, float y1);
444         void thread_func();
445         void handle_hotplugged_cards();
446         void schedule_audio_resampling_tasks(unsigned dropped_frames, int num_samples_per_frame, int length_per_frame, bool is_preroll, std::chrono::steady_clock::time_point frame_timestamp);
447         std::string get_timecode_text() const;
448         void render_one_frame(int64_t duration);
449         void audio_thread_func();
450         void release_display_frame(DisplayFrame *frame);
451         double pts() { return double(pts_int) / TIMEBASE; }
452         void trim_queue(CaptureCard *card, size_t safe_queue_length);
453         std::pair<std::string, std::string> get_channels_json();
454         std::pair<std::string, std::string> get_channel_color_http(unsigned channel_idx);
455
456         HTTPD httpd;
457         unsigned num_cards, num_video_inputs, num_html_inputs = 0;
458
459         QSurface *mixer_surface, *h264_encoder_surface, *decklink_output_surface;
460         std::unique_ptr<movit::ResourcePool> resource_pool;
461         std::unique_ptr<Theme> theme;
462         std::atomic<unsigned> audio_source_channel{0};
463         std::atomic<int> master_clock_channel{0};  // Gets overridden by <output_card_index> if set.
464         int output_card_index = -1;  // -1 for none.
465         uint32_t output_video_mode = -1;
466
467         // The mechanics of changing the output card and modes are so intricately connected
468         // with the work the mixer thread is doing. Thus, we don't change it directly,
469         // we just set this variable instead, which signals to the mixer thread that
470         // it should do the change before the next frame. This simplifies locking
471         // considerations immensely.
472         std::atomic<int> desired_output_card_index{-1};
473         std::atomic<uint32_t> desired_output_video_mode{0};
474
475         std::unique_ptr<movit::EffectChain> display_chain;
476         std::unique_ptr<ChromaSubsampler> chroma_subsampler;
477         std::unique_ptr<v210Converter> v210_converter;
478         std::unique_ptr<VideoEncoder> video_encoder;
479         std::unique_ptr<MJPEGEncoder> mjpeg_encoder;
480
481         std::unique_ptr<TimecodeRenderer> timecode_renderer;
482         std::atomic<bool> display_timecode_in_stream{false};
483         std::atomic<bool> display_timecode_on_stdout{false};
484
485         // Effects part of <display_chain>. Owned by <display_chain>.
486         movit::YCbCrInput *display_input;
487
488         int64_t pts_int = 0;  // In TIMEBASE units.
489
490         mutable std::mutex frame_num_mutex;
491         std::condition_variable frame_num_updated;
492         unsigned frame_num = 0;  // Under <frame_num_mutex>.
493
494         // Accumulated errors in number of 1/TIMEBASE audio samples. If OUTPUT_FREQUENCY divided by
495         // frame rate is integer, will always stay zero.
496         unsigned fractional_samples = 0;
497
498         mutable std::mutex card_mutex;
499         bool has_bmusb_thread = false;
500         struct CaptureCard {
501                 std::unique_ptr<bmusb::CaptureInterface> capture;
502                 bool is_fake_capture;
503                 CardType type;
504                 std::unique_ptr<DeckLinkOutput> output;
505
506                 // CEF only delivers frames when it actually has a change.
507                 // If we trim the queue for latency reasons, we could thus
508                 // end up in a situation trimming a frame that was meant to
509                 // be displayed for a long time, which is really suboptimal.
510                 // Thus, if we drop the last frame we have, may_have_dropped_last_frame
511                 // is set to true, and the next starvation event will trigger
512                 // us requestin a CEF repaint.
513                 bool is_cef_capture, may_have_dropped_last_frame = false;
514
515                 // If this card is used for output (ie., output_card_index points to it),
516                 // it cannot simultaneously be uesd for capture, so <capture> gets replaced
517                 // by a FakeCapture. However, since reconstructing the real capture object
518                 // with all its state can be annoying, it is not being deleted, just stopped
519                 // and moved here.
520                 std::unique_ptr<bmusb::CaptureInterface> parked_capture;
521
522                 std::unique_ptr<PBOFrameAllocator> frame_allocator;
523
524                 // Stuff for the OpenGL context (for texture uploading).
525                 QSurface *surface = nullptr;
526
527                 struct NewFrame {
528                         RefCountedFrame frame;
529                         int64_t length;  // In TIMEBASE units.
530                         bool interlaced;
531                         unsigned field;  // Which field (0 or 1) of the frame to use. Always 0 for progressive.
532                         std::function<void()> upload_func;  // Needs to be called to actually upload the texture to OpenGL.
533                         unsigned dropped_frames = 0;  // Number of dropped frames before this one.
534                         std::chrono::steady_clock::time_point received_timestamp = std::chrono::steady_clock::time_point::min();
535
536                         // Used for MJPEG encoding. (upload_func packs everything it needs
537                         // into the functor, but would otherwise also use these.)
538                         // width=0 or height=0 means a broken frame, ie., do not upload.
539                         bmusb::VideoFormat video_format;
540                         size_t y_offset, cbcr_offset;
541                 };
542                 std::deque<NewFrame> new_frames;
543                 std::condition_variable new_frames_changed;  // Set whenever new_frames is changed.
544
545                 QueueLengthPolicy queue_length_policy;  // Refers to the "new_frames" queue.
546
547                 int last_timecode = -1;  // Unwrapped.
548
549                 JitterHistory jitter_history;
550
551                 // Metrics.
552                 std::vector<std::pair<std::string, std::string>> labels;
553                 std::atomic<int64_t> metric_input_received_frames{0};
554                 std::atomic<int64_t> metric_input_duped_frames{0};
555                 std::atomic<int64_t> metric_input_dropped_frames_jitter{0};
556                 std::atomic<int64_t> metric_input_dropped_frames_error{0};
557                 std::atomic<int64_t> metric_input_resets{0};
558                 std::atomic<int64_t> metric_input_queue_length_frames{0};
559
560                 std::atomic<int64_t> metric_input_has_signal_bool{-1};
561                 std::atomic<int64_t> metric_input_is_connected_bool{-1};
562                 std::atomic<int64_t> metric_input_interlaced_bool{-1};
563                 std::atomic<int64_t> metric_input_width_pixels{-1};
564                 std::atomic<int64_t> metric_input_height_pixels{-1};
565                 std::atomic<int64_t> metric_input_frame_rate_nom{-1};
566                 std::atomic<int64_t> metric_input_frame_rate_den{-1};
567                 std::atomic<int64_t> metric_input_sample_rate_hz{-1};
568         };
569         JitterHistory output_jitter_history;
570         CaptureCard cards[MAX_VIDEO_CARDS];  // Protected by <card_mutex>.
571         YCbCrInterpretation ycbcr_interpretation[MAX_VIDEO_CARDS];  // Protected by <card_mutex>.
572         std::unique_ptr<AudioMixer> audio_mixer;  // Same as global_audio_mixer (see audio_mixer.h).
573         bool input_card_is_master_clock(unsigned card_index, unsigned master_card_index) const;
574         struct OutputFrameInfo {
575                 int dropped_frames;  // Since last frame.
576                 int num_samples;  // Audio samples needed for this output frame.
577                 int64_t frame_duration;  // In TIMEBASE units.
578                 bool is_preroll;
579                 std::chrono::steady_clock::time_point frame_timestamp;
580         };
581         OutputFrameInfo get_one_frame_from_each_card(unsigned master_card_index, bool master_card_is_output, CaptureCard::NewFrame new_frames[MAX_VIDEO_CARDS], bool has_new_frame[MAX_VIDEO_CARDS]);
582
583         InputState input_state;
584
585         // Cards we have been noticed about being hotplugged, but haven't tried adding yet.
586         // Protected by its own mutex.
587         std::mutex hotplug_mutex;
588         std::vector<libusb_device *> hotplugged_cards;
589
590         class OutputChannel {
591         public:
592                 ~OutputChannel();
593                 void output_frame(DisplayFrame &&frame);
594                 bool get_display_frame(DisplayFrame *frame);
595                 void add_frame_ready_callback(void *key, new_frame_ready_callback_t callback);
596                 void remove_frame_ready_callback(void *key);
597                 void set_transition_names_updated_callback(transition_names_updated_callback_t callback);
598                 void set_name_updated_callback(name_updated_callback_t callback);
599                 void set_color_updated_callback(color_updated_callback_t callback);
600
601         private:
602                 friend class Mixer;
603
604                 unsigned channel;
605                 Mixer *parent = nullptr;  // Not owned.
606                 std::mutex frame_mutex;
607                 DisplayFrame current_frame, ready_frame;  // protected by <frame_mutex>
608                 bool has_current_frame = false, has_ready_frame = false;  // protected by <frame_mutex>
609                 std::map<void *, new_frame_ready_callback_t> new_frame_ready_callbacks;  // protected by <frame_mutex>
610                 transition_names_updated_callback_t transition_names_updated_callback;
611                 name_updated_callback_t name_updated_callback;
612                 color_updated_callback_t color_updated_callback;
613
614                 std::vector<std::string> last_transition_names;
615                 std::string last_name, last_color;
616         };
617         OutputChannel output_channel[NUM_OUTPUTS];
618
619         std::thread mixer_thread;
620         std::thread audio_thread;
621         std::atomic<bool> should_quit{false};
622         std::atomic<bool> should_cut{false};
623
624         std::unique_ptr<ALSAOutput> alsa;
625
626         struct AudioTask {
627                 int64_t pts_int;
628                 int num_samples;
629                 bool adjust_rate;
630                 std::chrono::steady_clock::time_point frame_timestamp;
631         };
632         std::mutex audio_mutex;
633         std::condition_variable audio_task_queue_changed;
634         std::queue<AudioTask> audio_task_queue;  // Under audio_mutex.
635
636         // For mode scanning.
637         bool is_mode_scanning[MAX_VIDEO_CARDS]{ false };
638         std::vector<uint32_t> mode_scanlist[MAX_VIDEO_CARDS];
639         unsigned mode_scanlist_index[MAX_VIDEO_CARDS]{ 0 };
640         std::chrono::steady_clock::time_point last_mode_scan_change[MAX_VIDEO_CARDS];
641 };
642
643 extern Mixer *global_mixer;
644
645 #endif  // !defined(_MIXER_H)