X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=5c69edd4450ac4922b30ac05b52a6413c6fe2084;hb=bea1be71fd06888ac03fcddb47f6d497f8e07aab;hp=f70fbd68c13a85ba91edfd6b1db0e22c48c3d3e6;hpb=8e244982fabba3771e98abd7becce02cf693ab03;p=nageru diff --git a/mixer.h b/mixer.h index f70fbd6..5c69edd 100644 --- a/mixer.h +++ b/mixer.h @@ -3,29 +3,34 @@ // 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 #include -#include "bmusb/bmusb.h" #include "alsa_output.h" -#include "ebu_r128_proc.h" -#include "quicksync_encode.h" +#include "audio_mixer.h" +#include "bmusb/bmusb.h" +#include "defs.h" #include "httpd.h" +#include "input_state.h" #include "pbo_frame_allocator.h" #include "ref_counted_frame.h" #include "ref_counted_gl_sync.h" @@ -33,12 +38,11 @@ #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 QuickSyncEncoder; +class ALSAOutput; class QSurface; +class QuickSyncEncoder; namespace movit { class Effect; class EffectChain; @@ -49,7 +53,6 @@ class ResourcePool; namespace movit { class YCbCrInput; } -class QOpenGLContext; class QSurfaceFormat; // For any card that's not the master (where we pick out the frames as they @@ -147,13 +150,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) + { + 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) { - audio_level_callback = callback; + output_channel[output].set_color_updated_callback(callback); } std::vector get_transition_names() @@ -221,79 +234,14 @@ 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; - } + 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 { @@ -301,7 +249,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(); } @@ -348,18 +296,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 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 send_audio_level_callback(); 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; } @@ -376,7 +329,7 @@ private: 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 quicksync_encoder; + std::unique_ptr video_encoder; // Effects part of . Owned by . movit::FlatInput *display_input; @@ -384,20 +337,21 @@ 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. - RefCountedGLsync 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::queue new_frames; @@ -410,32 +364,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 - void get_one_frame_from_each_card(unsigned master_card_index, CaptureCard::NewFrame new_frames[MAX_CARDS], bool has_new_frame[MAX_CARDS], int num_samples[MAX_CARDS]); + CaptureCard cards[MAX_VIDEO_CARDS]; // protected by + AudioMixer audio_mixer; + 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]; @@ -444,53 +410,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)