X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=58084817c70c9c78abef8ff9801ac71d9bd30778;hb=17aea06428516df0fdfb19e8a8f828322f2fc4f7;hp=75867ccce95b06d6ea79fdabe636c514fbcf5410;hpb=312ed2563ea113dc56960cbfedffd2ca32011a7d;p=nageru diff --git a/mixer.h b/mixer.h index 75867cc..5808481 100644 --- a/mixer.h +++ b/mixer.h @@ -3,43 +3,45 @@ // 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 "video_encoder.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 QuickSyncEncoder; +class ALSAOutput; +class ChromaSubsampler; +class DeckLinkOutput; class QSurface; +class QSurfaceFormat; + namespace movit { class Effect; class EffectChain; @@ -47,11 +49,6 @@ class FlatInput; class ResourcePool; } // namespace movit -namespace movit { -class YCbCrInput; -} -class QSurfaceFormat; - // For any card that's not the master (where we pick out the frames as they // come, as fast as we can process), there's going to be a queue. The question // is when we should drop frames from that queue (apart from the obvious @@ -166,15 +163,6 @@ public: output_channel[output].set_color_updated_callback(callback); } - typedef std::function audio_level_callback_t; - void set_audio_level_callback(audio_level_callback_t callback) - { - audio_level_callback = callback; - } - std::vector get_transition_names() { return theme->get_transition_names(pts()); @@ -205,16 +193,6 @@ public: return theme->map_signal(channel); } - unsigned get_audio_source() const - { - return audio_source_channel; - } - - void set_audio_source(unsigned channel) - { - audio_source_channel = channel; - } - unsigned get_master_clock() const { return master_clock_channel; @@ -240,112 +218,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; - } - - bool get_locut_enabled() const - { - return locut_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; - } - - bool get_limiter_enabled() const - { - return limiter_enabled; - } - - void set_compressor_enabled(bool enabled) - { - compressor_enabled = enabled; - } - - bool get_compressor_enabled() const - { - return compressor_enabled; - } - - void set_gain_staging_db(float gain_db) - { - std::unique_lock lock(compressor_mutex); - level_compressor_enabled = false; - 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); - 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; - } - - bool get_final_makeup_gain_auto() const - { - std::unique_lock lock(compressor_mutex); - return final_makeup_gain_auto; - } + // 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 { @@ -405,7 +286,8 @@ public: } private: - void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, bool is_fake_capture); + void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, bool is_fake_capture, DeckLinkOutput *output); + void set_output_card(int card_index); // -1 = no output, just stream. void bm_frame(unsigned card_index, uint16_t timecode, 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); @@ -416,25 +298,21 @@ private: 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, bool adjust_rate); - void subsample_chroma(GLuint src_tex, GLuint dst_dst); void release_display_frame(DisplayFrame *frame); double pts() { return double(pts_int) / TIMEBASE; } HTTPD httpd; unsigned num_cards; - QSurface *mixer_surface, *h264_encoder_surface; + QSurface *mixer_surface, *h264_encoder_surface, *decklink_output_surface; std::unique_ptr resource_pool; std::unique_ptr theme; std::atomic audio_source_channel{0}; - std::atomic master_clock_channel{0}; + std::atomic master_clock_channel{0}; // Gets overridden by if set. + std::atomic output_card_index{-1}; // -1 for none. 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 chroma_subsampler; std::unique_ptr video_encoder; // Effects part of . Owned by . @@ -442,11 +320,24 @@ private: int64_t pts_int = 0; // In TIMEBASE units. - std::mutex bmusb_mutex; + // Accumulated errors in number of 1/TIMEBASE audio samples. If OUTPUT_FREQUENCY divided by + // frame rate is integer, will always stay zero. + unsigned fractional_samples = 0; + + std::mutex card_mutex; bool has_bmusb_thread = false; struct CaptureCard { bmusb::CaptureInterface *capture = nullptr; bool is_fake_capture; + DeckLinkOutput *output = nullptr; + + // If this card is used for output (ie., output_card_index points to it), + // it cannot simultaneously be uesd for capture, so gets replaced + // by a FakeCapture. However, since reconstructing the real capture object + // with all its state can be annoying, it is not being deleted, just stopped + // and moved here. + bmusb::CaptureInterface *parked_capture = nullptr; + std::unique_ptr frame_allocator; // Stuff for the OpenGL context (for texture uploading). @@ -459,6 +350,7 @@ private: unsigned field; // Which field (0 or 1) of the frame to use. Always 0 for progressive. 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; @@ -466,17 +358,17 @@ private: QueueLengthPolicy queue_length_policy; // Refers to the "new_frames" queue. - // Accumulated errors in number of 1/TIMEBASE samples. If OUTPUT_FREQUENCY divided by - // 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; // Same as global_audio_mixer (see audio_mixer.h). + bool input_card_is_master_clock(unsigned card_index, unsigned master_card_index) const; + struct OutputFrameInfo { + int dropped_frames; // Since last frame. + int num_samples; // Audio samples needed for this output frame. + int64_t frame_duration; // In TIMEBASE units. + }; + 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]); InputState input_state; @@ -518,36 +410,6 @@ private: std::atomic should_quit{false}; std::atomic should_cut{false}; - audio_level_callback_t audio_level_callback = nullptr; - mutable 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 { @@ -560,10 +422,10 @@ private: 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 }; - std::chrono::steady_clock::time_point 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;