X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=05471d6d61ae550af47a8ceb03faebfbc29697ca;hb=8ade0b3b56c3bdad611eb62986f79e250a4def19;hp=dab567f1e80728f668eeb5a26fc8467edcff9ed1;hpb=64f9314bfe9b21fed7304a4d08a35d80e8c73144;p=nageru diff --git a/mixer.h b/mixer.h index dab567f..05471d6 100644 --- a/mixer.h +++ b/mixer.h @@ -49,7 +49,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,6 +146,25 @@ public: output_channel[output].set_frame_ready_callback(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) + { + output_channel[output].set_color_updated_callback(callback); + } + typedef std::function lock(compressor_mutex); @@ -268,12 +301,24 @@ public: gain_staging_db = gain_db; } + float get_gain_staging_db() const + { + std::unique_lock lock(compressor_mutex); + return gain_staging_db; + } + void set_gain_staging_auto(bool enabled) { std::unique_lock lock(compressor_mutex); level_compressor_enabled = enabled; } + bool get_gain_staging_auto() const + { + std::unique_lock lock(compressor_mutex); + return level_compressor_enabled; + } + void set_final_makeup_gain_db(float gain_db) { std::unique_lock lock(compressor_mutex); @@ -287,6 +332,12 @@ public: final_makeup_gain_auto = enabled; } + bool get_final_makeup_gain_auto() const + { + std::unique_lock lock(compressor_mutex); + return final_makeup_gain_auto; + } + void schedule_cut() { should_cut = true; @@ -301,7 +352,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,13 +399,20 @@ 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(); @@ -384,13 +442,14 @@ 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; @@ -420,22 +479,36 @@ private: 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]; @@ -445,7 +518,7 @@ private: std::atomic should_cut{false}; audio_level_callback_t audio_level_callback = nullptr; - std::mutex compressor_mutex; + mutable std::mutex compressor_mutex; Ebu_r128_proc r128; // Under compressor_mutex. CorrelationMeasurer correlation; // Under compressor_mutex. @@ -492,5 +565,6 @@ private: }; extern Mixer *global_mixer; +extern bool uses_mlock; #endif // !defined(_MIXER_H)