X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=8504d5eb4bb9d6a56d8b68dd2ab04464b0bcecfd;hb=96cb6414f85e0ef4d660b7bd56267303e80fcd05;hp=547691428ad5fcfe60f5f1720c5d4a36514e2fb2;hpb=29cccb8cb0bb613b7f4b3e9d27a4a5c71a2f82e8;p=nageru diff --git a/mixer.h b/mixer.h index 5476914..8504d5e 100644 --- a/mixer.h +++ b/mixer.h @@ -3,55 +3,56 @@ // 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 "bmusb/bmusb.h" -#include "alsa_output.h" +#include + #include "audio_mixer.h" -#include "ebu_r128_proc.h" -#include "video_encoder.h" +#include "bmusb/bmusb.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" +#include "ycbcr_interpretation.h" -class QuickSyncEncoder; +class ALSAOutput; +class ChromaSubsampler; +class DeckLinkOutput; class QSurface; +class QSurfaceFormat; +class TimecodeRenderer; +class v210Converter; + namespace movit { class Effect; class EffectChain; -class FlatInput; class ResourcePool; -} // namespace movit - -namespace movit { class YCbCrInput; -} -class QSurfaceFormat; +} // namespace movit // 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 @@ -72,8 +73,7 @@ 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. TODO: Only do this if N ever actually -// touched the limit. +// we reduce N by 1 and reset the timers. // // 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, @@ -83,19 +83,26 @@ public: QueueLengthPolicy() {} void reset(unsigned card_index) { this->card_index = card_index; - safe_queue_length = 0; + safe_queue_length = 1; 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. + void register_metrics(const std::vector> &labels); + + void update_policy(unsigned queue_length); // Call before picking out a frame, so 0 means starvation. unsigned get_safe_queue_length() const { return safe_queue_length; } private: unsigned card_index; // For debugging only. - unsigned safe_queue_length = 0; // Called N in the comments. + unsigned safe_queue_length = 1; // Called N in the comments. Can never go below 1. unsigned frames_with_at_least_one = 0; bool been_at_safe_point_since_last_starvation = false; + + // Metrics. + std::atomic metric_input_queue_length_frames{0}; + std::atomic metric_input_queue_safe_length_frames{1}; + std::atomic metric_input_duped_frames{0}; }; class Mixer { @@ -142,10 +149,17 @@ public: return output_channel[output].get_display_frame(frame); } + // NOTE: Callbacks will be called with a mutex held, so you should probably + // not do real work in them. typedef std::function new_frame_ready_callback_t; - void set_frame_ready_callback(Output output, new_frame_ready_callback_t callback) + void add_frame_ready_callback(Output output, void *key, new_frame_ready_callback_t callback) + { + output_channel[output].add_frame_ready_callback(key, callback); + } + + void remove_frame_ready_callback(Output output, void *key) { - output_channel[output].set_frame_ready_callback(callback); + output_channel[output].remove_frame_ready_callback(key); } // TODO: Should this really be per-channel? Shouldn't it just be called for e.g. the live output? @@ -167,15 +181,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()); @@ -206,16 +211,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; @@ -231,6 +226,9 @@ public: return theme->set_signal_mapping(signal, card); } + YCbCrInterpretation get_input_ycbcr_interpretation(unsigned card_index) const; + void set_input_ycbcr_interpretation(unsigned card_index, const YCbCrInterpretation &interpretation); + bool get_supports_set_wb(unsigned channel) const { return theme->get_supports_set_wb(channel); @@ -241,6 +239,7 @@ public: theme->set_wb(channel, r, g, b); } + // 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; } @@ -249,8 +248,6 @@ public: should_cut = true; } - void reset_meters(); - unsigned get_num_cards() const { return num_cards; } std::string get_card_description(unsigned card_index) const { @@ -258,6 +255,25 @@ public: return cards[card_index].capture->get_description(); } + // The difference between this and the previous function is that if a card + // is used as the current output, get_card_description() will return the + // fake card that's replacing it for input, whereas this function will return + // the card's actual name. + std::string get_output_card_description(unsigned card_index) const { + assert(card_can_be_used_as_output(card_index)); + assert(card_index < num_cards); + if (cards[card_index].parked_capture) { + return cards[card_index].parked_capture->get_description(); + } else { + return cards[card_index].capture->get_description(); + } + } + + bool card_can_be_used_as_output(unsigned card_index) const { + assert(card_index < num_cards); + return cards[card_index].output != nullptr; + } + std::map get_available_video_modes(unsigned card_index) const { assert(card_index < num_cards); return cards[card_index].capture->get_available_video_modes(); @@ -309,8 +325,42 @@ public: video_encoder->change_x264_bitrate(rate_kbit); } + int get_output_card_index() const { // -1 = no output, just stream. + return desired_output_card_index; + } + + void set_output_card(int card_index) { // -1 = no output, just stream. + desired_output_card_index = card_index; + } + + std::map get_available_output_video_modes() const; + + uint32_t get_output_video_mode() const { + return desired_output_video_mode; + } + + void set_output_video_mode(uint32_t mode) { + desired_output_video_mode = mode; + } + + void set_display_timecode_in_stream(bool enable) { + display_timecode_in_stream = enable; + } + + void set_display_timecode_on_stdout(bool enable) { + display_timecode_on_stdout = enable; + } + private: - void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, bool is_fake_capture); + struct CaptureCard; + + enum class CardType { + LIVE_CARD, + FAKE_CAPTURE, + FFMPEG_INPUT + }; + void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, CardType card_type, DeckLinkOutput *output); + void set_output_card_internal(int card_index); // Should only be called from the mixer thread. 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); @@ -319,39 +369,69 @@ private: 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 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); + std::string get_timecode_text() const; 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, ResamplingQueue::RateAdjustmentPolicy rate_adjustment_policy); - void subsample_chroma(GLuint src_tex, GLuint dst_dst); void release_display_frame(DisplayFrame *frame); double pts() { return double(pts_int) / TIMEBASE; } + // Call this _before_ trying to pull out a frame from a capture card; + // it will update the policy and drop the right amount of frames for you. + void trim_queue(CaptureCard *card, unsigned card_index); HTTPD httpd; - unsigned num_cards; + unsigned num_cards, num_video_inputs; - 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. + int output_card_index = -1; // -1 for none. + uint32_t output_video_mode = -1; + + // The mechanics of changing the output card and modes are so intricately connected + // with the work the mixer thread is doing. Thus, we don't change it directly, + // we just set this variable instead, which signals to the mixer thread that + // it should do the change before the next frame. This simplifies locking + // considerations immensely. + std::atomic desired_output_card_index{-1}; + std::atomic desired_output_video_mode{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 chroma_subsampler; + std::unique_ptr v210_converter; std::unique_ptr video_encoder; + std::unique_ptr timecode_renderer; + std::atomic display_timecode_in_stream{false}; + std::atomic display_timecode_on_stdout{false}; + // Effects part of . Owned by . - movit::FlatInput *display_input; + movit::YCbCrInput *display_input; int64_t pts_int = 0; // In TIMEBASE units. + unsigned frame_num = 0; - 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; + + mutable std::mutex card_mutex; bool has_bmusb_thread = false; struct CaptureCard { - bmusb::CaptureInterface *capture = nullptr; + std::unique_ptr capture; bool is_fake_capture; + CardType type; + std::unique_ptr output; + + // 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. + std::unique_ptr parked_capture; + std::unique_ptr frame_allocator; // Stuff for the OpenGL context (for texture uploading). @@ -364,22 +444,42 @@ 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; + std::deque new_frames; bool should_quit = false; std::condition_variable new_frames_changed; // Set whenever new_frames (or should_quit) is changed. 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; - int last_timecode = -1; // Unwrapped. + + // Metrics. + std::atomic metric_input_dropped_frames_jitter{0}; + std::atomic metric_input_dropped_frames_error{0}; + std::atomic metric_input_resets{0}; + + std::atomic metric_input_has_signal_bool{-1}; + std::atomic metric_input_is_connected_bool{-1}; + std::atomic metric_input_interlaced_bool{-1}; + std::atomic metric_input_width_pixels{-1}; + std::atomic metric_input_height_pixels{-1}; + std::atomic metric_input_frame_rate_nom{-1}; + std::atomic metric_input_frame_rate_den{-1}; + std::atomic metric_input_sample_rate_hz{-1}; + }; + CaptureCard cards[MAX_VIDEO_CARDS]; // Protected by . + YCbCrInterpretation ycbcr_interpretation[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. + bool is_preroll; + std::chrono::steady_clock::time_point frame_timestamp; }; - CaptureCard cards[MAX_CARDS]; // protected by - AudioMixer audio_mixer; - 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]); + 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; @@ -393,7 +493,8 @@ private: ~OutputChannel(); void output_frame(DisplayFrame frame); bool get_display_frame(DisplayFrame *frame); - void set_frame_ready_callback(new_frame_ready_callback_t callback); + void add_frame_ready_callback(void *key, new_frame_ready_callback_t callback); + void remove_frame_ready_callback(void *key); 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); @@ -406,7 +507,7 @@ private: 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; + std::map new_frame_ready_callbacks; // protected by transition_names_updated_callback_t transition_names_updated_callback; name_updated_callback_t name_updated_callback; color_updated_callback_t color_updated_callback; @@ -421,29 +522,30 @@ private: std::atomic should_quit{false}; std::atomic should_cut{false}; - audio_level_callback_t audio_level_callback = nullptr; - mutable std::mutex audio_measure_mutex; - Ebu_r128_proc r128; // Under audio_measure_mutex. - CorrelationMeasurer correlation; // Under audio_measure_mutex. - Resampler peak_resampler; // Under audio_measure_mutex. - std::atomic peak{0.0f}; - std::unique_ptr alsa; struct AudioTask { int64_t pts_int; int num_samples; bool adjust_rate; + std::chrono::steady_clock::time_point frame_timestamp; }; 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 }; - 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]; + + // Metrics. + std::atomic metric_frames_output_total{0}; + std::atomic metric_frames_output_dropped{0}; + std::atomic metric_start_time_seconds{0.0 / 0.0}; + std::atomic metrics_memory_used_bytes{0}; + std::atomic metrics_memory_locked_limit_bytes{0.0 / 0.0}; }; extern Mixer *global_mixer;