X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=551e21790d9f71daacd89d1fc6a740baca0723a1;hb=63a912898083c06cc75f336f8d9a367a707e378a;hp=e27d2299bae5d2746b0478491a450c7421f8dabb;hpb=a43cd0787ec6042f24ee6bea7d9cbc8ce0579f17;p=nageru diff --git a/mixer.h b/mixer.h index e27d229..551e217 100644 --- a/mixer.h +++ b/mixer.h @@ -3,53 +3,48 @@ // The actual video mixer, running in its own separate background thread. +#include #include + #undef Success + #include #include - -#include -#include -#include #include +#include #include #include #include +#include #include #include +#include #include #include #include +#include "audio_mixer.h" #include "bmusb/bmusb.h" -#include "alsa_output.h" -#include "ebu_r128_proc.h" -#include "h264encode.h" +#include "defs.h" #include "httpd.h" +#include "input_state.h" +#include "libusb.h" #include "pbo_frame_allocator.h" #include "ref_counted_frame.h" #include "ref_counted_gl_sync.h" -#include "resampling_queue.h" #include "theme.h" #include "timebase.h" -#include "stereocompressor.h" -#include "filter.h" -#include "input_state.h" -#include "correlation_measurer.h" +#include "video_encoder.h" -class H264Encoder; +class ALSAOutput; class QSurface; + namespace movit { class Effect; class EffectChain; class FlatInput; class ResourcePool; } // namespace movit - -namespace movit { -class YCbCrInput; -} -class QOpenGLContext; class QSurfaceFormat; // For any card that's not the master (where we pick out the frames as they @@ -71,10 +66,12 @@ class QSurfaceFormat; // // N is reduced as follows: If the queue has had at least one spare frame for // at least 50 (master) frames (ie., it's been too conservative for a second), -// we reduce N by 1 and reset the timers. +// we reduce N by 1 and reset the timers. TODO: Only do this if N ever actually +// touched the limit. // -// Whenever the queue is starved (we needed a frame but there was none), N was -// obviously too low, so we increment N. We will never set N above 5, though. +// Whenever the queue is starved (we needed a frame but there was none), +// and we've been at N since the last starvation, N was obviously too low, +// so we increment it. We will never set N above 5, though. class QueueLengthPolicy { public: QueueLengthPolicy() {} @@ -82,6 +79,7 @@ public: this->card_index = card_index; safe_queue_length = 0; frames_with_at_least_one = 0; + been_at_safe_point_since_last_starvation = false; } void update_policy(int queue_length); // Give in -1 for starvation. @@ -91,6 +89,7 @@ private: unsigned card_index; // For debugging only. unsigned safe_queue_length = 0; // Called N in the comments. unsigned frames_with_at_least_one = 0; + bool been_at_safe_point_since_last_starvation = false; }; class Mixer { @@ -143,13 +142,23 @@ public: output_channel[output].set_frame_ready_callback(callback); } - typedef std::function audio_level_callback_t; - void set_audio_level_callback(audio_level_callback_t callback) + // TODO: Should this really be per-channel? Shouldn't it just be called for e.g. the live output? + typedef std::function &)> transition_names_updated_callback_t; + void set_transition_names_updated_callback(Output output, transition_names_updated_callback_t callback) { - audio_level_callback = callback; + output_channel[output].set_transition_names_updated_callback(callback); + } + + typedef std::function name_updated_callback_t; + void set_name_updated_callback(Output output, name_updated_callback_t callback) + { + output_channel[output].set_name_updated_callback(callback); + } + + typedef std::function color_updated_callback_t; + void set_color_updated_callback(Output output, color_updated_callback_t callback) + { + output_channel[output].set_color_updated_callback(callback); } std::vector get_transition_names() @@ -167,6 +176,11 @@ public: return theme->get_channel_name(channel); } + std::string get_channel_color(unsigned channel) const + { + return theme->get_channel_color(channel); + } + int get_channel_signal(unsigned channel) const { return theme->get_channel_signal(channel); @@ -177,14 +191,14 @@ public: return theme->map_signal(channel); } - unsigned get_audio_source() const + unsigned get_master_clock() const { - return audio_source_channel; + return master_clock_channel; } - void set_audio_source(unsigned channel) + void set_master_clock(unsigned channel) { - audio_source_channel = channel; + master_clock_channel = channel; } void set_signal_mapping(int signal, int card) @@ -202,79 +216,15 @@ public: theme->set_wb(channel, r, g, b); } - void set_locut_cutoff(float cutoff_hz) - { - locut_cutoff_hz = cutoff_hz; - } - - void set_locut_enabled(bool enabled) - { - locut_enabled = enabled; - } - - float get_limiter_threshold_dbfs() - { - return limiter_threshold_dbfs; - } - - float get_compressor_threshold_dbfs() - { - return compressor_threshold_dbfs; - } - - void set_limiter_threshold_dbfs(float threshold_dbfs) - { - limiter_threshold_dbfs = threshold_dbfs; - } - - void set_compressor_threshold_dbfs(float threshold_dbfs) - { - compressor_threshold_dbfs = threshold_dbfs; - } - - void set_limiter_enabled(bool enabled) - { - limiter_enabled = enabled; - } - - void set_compressor_enabled(bool enabled) - { - compressor_enabled = enabled; - } - - void set_gain_staging_db(float gain_db) - { - std::unique_lock lock(compressor_mutex); - level_compressor_enabled = false; - gain_staging_db = gain_db; - } - - void set_gain_staging_auto(bool enabled) - { - std::unique_lock lock(compressor_mutex); - level_compressor_enabled = enabled; - } - - void set_final_makeup_gain_db(float gain_db) - { - std::unique_lock lock(compressor_mutex); - final_makeup_gain_auto = false; - final_makeup_gain = pow(10.0f, gain_db / 20.0f); - } - - void set_final_makeup_gain_auto(bool enabled) - { - std::unique_lock lock(compressor_mutex); - final_makeup_gain_auto = enabled; - } + // Note: You can also get this through the global variable global_audio_mixer. + AudioMixer *get_audio_mixer() { return &audio_mixer; } + const AudioMixer *get_audio_mixer() const { return &audio_mixer; } void schedule_cut() { should_cut = true; } - void reset_meters(); - unsigned get_num_cards() const { return num_cards; } std::string get_card_description(unsigned card_index) const { @@ -282,7 +232,7 @@ public: return cards[card_index].capture->get_description(); } - std::map get_available_video_modes(unsigned card_index) const { + std::map get_available_video_modes(unsigned card_index) const { assert(card_index < num_cards); return cards[card_index].capture->get_available_video_modes(); } @@ -329,16 +279,23 @@ public: cards[card_index].capture->set_audio_input(input); } + void change_x264_bitrate(unsigned rate_kbit) { + video_encoder->change_x264_bitrate(rate_kbit); + } + private: - void configure_card(unsigned card_index, const QSurfaceFormat &format, CaptureInterface *capture); + void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, bool is_fake_capture); void bm_frame(unsigned card_index, uint16_t timecode, - FrameAllocator::Frame video_frame, size_t video_offset, VideoFormat video_format, - FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format); + bmusb::FrameAllocator::Frame video_frame, size_t video_offset, bmusb::VideoFormat video_format, + bmusb::FrameAllocator::Frame audio_frame, size_t audio_offset, bmusb::AudioFormat audio_format); + void bm_hotplug_add(libusb_device *dev); + void bm_hotplug_remove(unsigned card_index); void place_rectangle(movit::Effect *resample_effect, movit::Effect *padding_effect, float x0, float y0, float x1, float y1); void thread_func(); - void render_one_frame(); + void handle_hotplugged_cards(); + void schedule_audio_resampling_tasks(unsigned dropped_frames, int num_samples_per_frame, int length_per_frame); + void render_one_frame(int64_t duration); void audio_thread_func(); - void process_audio_one_frame(int64_t frame_pts_int, int num_samples); void subsample_chroma(GLuint src_tex, GLuint dst_dst); void release_display_frame(DisplayFrame *frame); double pts() { return double(pts_int) / TIMEBASE; } @@ -350,11 +307,12 @@ private: std::unique_ptr resource_pool; std::unique_ptr theme; std::atomic audio_source_channel{0}; + std::atomic master_clock_channel{0}; std::unique_ptr display_chain; GLuint cbcr_program_num; // Owned by . GLuint cbcr_vbo; // Holds position and texcoord data. GLuint cbcr_position_attribute_index, cbcr_texcoord_attribute_index; - std::unique_ptr h264_encoder; + std::unique_ptr video_encoder; // Effects part of . Owned by . movit::FlatInput *display_input; @@ -362,21 +320,23 @@ private: int64_t pts_int = 0; // In TIMEBASE units. std::mutex bmusb_mutex; + bool has_bmusb_thread = false; struct CaptureCard { - CaptureInterface *capture; + bmusb::CaptureInterface *capture = nullptr; + bool is_fake_capture; std::unique_ptr frame_allocator; // Stuff for the OpenGL context (for texture uploading). - QSurface *surface; - QOpenGLContext *context; + QSurface *surface = nullptr; struct NewFrame { RefCountedFrame frame; int64_t length; // In TIMEBASE units. bool interlaced; unsigned field; // Which field (0 or 1) of the frame to use. Always 0 for progressive. - GLsync ready_fence; // Whether frame is ready for rendering. + std::function upload_func; // Needs to be called to actually upload the texture to OpenGL. unsigned dropped_frames = 0; // Number of dropped frames before this one. + std::chrono::steady_clock::time_point received_timestamp = std::chrono::steady_clock::time_point::min(); }; std::queue new_frames; bool should_quit = false; @@ -388,31 +348,44 @@ private: // frame rate is integer, will always stay zero. unsigned fractional_samples = 0; - std::mutex audio_mutex; - std::unique_ptr resampling_queue; // Under audio_mutex. int last_timecode = -1; // Unwrapped. - int64_t next_local_pts = 0; // Beginning of next frame, in TIMEBASE units. }; - CaptureCard cards[MAX_CARDS]; // protected by + CaptureCard cards[MAX_VIDEO_CARDS]; // protected by + AudioMixer audio_mixer; // Same as global_audio_mixer (see audio_mixer.h). + void get_one_frame_from_each_card(unsigned master_card_index, CaptureCard::NewFrame new_frames[MAX_VIDEO_CARDS], bool has_new_frame[MAX_VIDEO_CARDS], int num_samples[MAX_VIDEO_CARDS]); InputState input_state; + // Cards we have been noticed about being hotplugged, but haven't tried adding yet. + // Protected by its own mutex. + std::mutex hotplug_mutex; + std::vector hotplugged_cards; + class OutputChannel { public: ~OutputChannel(); void output_frame(DisplayFrame frame); bool get_display_frame(DisplayFrame *frame); void set_frame_ready_callback(new_frame_ready_callback_t callback); + void set_transition_names_updated_callback(transition_names_updated_callback_t callback); + void set_name_updated_callback(name_updated_callback_t callback); + void set_color_updated_callback(color_updated_callback_t callback); private: friend class Mixer; + unsigned channel; Mixer *parent = nullptr; // Not owned. std::mutex frame_mutex; DisplayFrame current_frame, ready_frame; // protected by bool has_current_frame = false, has_ready_frame = false; // protected by new_frame_ready_callback_t new_frame_ready_callback; - bool has_new_frame_ready_callback = false; + transition_names_updated_callback_t transition_names_updated_callback; + name_updated_callback_t name_updated_callback; + color_updated_callback_t color_updated_callback; + + std::vector last_transition_names; + std::string last_name, last_color; }; OutputChannel output_channel[NUM_OUTPUTS]; @@ -421,53 +394,25 @@ private: std::atomic should_quit{false}; std::atomic should_cut{false}; - audio_level_callback_t audio_level_callback = nullptr; - std::mutex compressor_mutex; - Ebu_r128_proc r128; // Under compressor_mutex. - CorrelationMeasurer correlation; // Under compressor_mutex. - - Resampler peak_resampler; - std::atomic peak{0.0f}; - - StereoFilter locut; // Default cutoff 120 Hz, 24 dB/oct. - std::atomic locut_cutoff_hz; - std::atomic locut_enabled{true}; - - // First compressor; takes us up to about -12 dBFS. - StereoCompressor level_compressor; // Under compressor_mutex. Used to set/override gain_staging_db if . - float gain_staging_db = 0.0f; // Under compressor_mutex. - bool level_compressor_enabled = true; // Under compressor_mutex. - - static constexpr float ref_level_dbfs = -14.0f; // Chosen so that we end up around 0 LU in practice. - static constexpr float ref_level_lufs = -23.0f; // 0 LU, more or less by definition. - - StereoCompressor limiter; - std::atomic limiter_threshold_dbfs{ref_level_dbfs + 4.0f}; // 4 dB. - std::atomic limiter_enabled{true}; - StereoCompressor compressor; - std::atomic compressor_threshold_dbfs{ref_level_dbfs - 12.0f}; // -12 dB. - std::atomic compressor_enabled{true}; - - double final_makeup_gain = 1.0; // Under compressor_mutex. Read/write by the user. Note: Not in dB, we want the numeric precision so that we can change it slowly. - bool final_makeup_gain_auto = true; // Under compressor_mutex. - std::unique_ptr alsa; struct AudioTask { int64_t pts_int; int num_samples; + bool adjust_rate; }; std::mutex audio_mutex; std::condition_variable audio_task_queue_changed; std::queue audio_task_queue; // Under audio_mutex. // For mode scanning. - bool is_mode_scanning[MAX_CARDS]{ false }; - std::vector mode_scanlist[MAX_CARDS]; - unsigned mode_scanlist_index[MAX_CARDS]{ 0 }; - timespec last_mode_scan_change[MAX_CARDS]; + bool is_mode_scanning[MAX_VIDEO_CARDS]{ false }; + std::vector mode_scanlist[MAX_VIDEO_CARDS]; + unsigned mode_scanlist_index[MAX_VIDEO_CARDS]{ 0 }; + std::chrono::steady_clock::time_point last_mode_scan_change[MAX_VIDEO_CARDS]; }; extern Mixer *global_mixer; +extern bool uses_mlock; #endif // !defined(_MIXER_H)