X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=aa3baac2fff99e90b1113f61af65e7f82761f42e;hb=9e47a2f661b9d292598ef0277e507458e3dad62f;hp=dd44f74bd74906b88c622dd8ff5e819d703daf87;hpb=9e054cd044975cd8ec42609564be39099ce19679;p=nageru diff --git a/mixer.h b/mixer.h index dd44f74..aa3baac 100644 --- a/mixer.h +++ b/mixer.h @@ -54,6 +54,59 @@ class ResourcePool; class YCbCrInput; } // namespace movit +// A class to estimate the future jitter. Used in QueueLengthPolicy (see below). +// +// There are many ways to estimate jitter; I've tested a few ones (and also +// some algorithms that don't explicitly model jitter) with different +// parameters on some real-life data in experiments/queue_drop_policy.cpp. +// This is one based on simple order statistics where I've added some margin in +// the number of starvation events; I believe that about one every hour would +// probably be acceptable, but this one typically goes lower than that, at the +// cost of 2–3 ms extra latency. (If the queue is hard-limited to one frame, it's +// possible to get ~10 ms further down, but this would mean framedrops every +// second or so.) The general strategy is: Take the 99.9-percentile jitter over +// last 5000 frames, multiply by two, and that's our worst-case jitter +// estimate. The fact that we're not using the max value means that we could +// actually even throw away very late frames immediately, which means we only +// get one user-visible event instead of seeing something both when the frame +// arrives late (duplicate frame) and then again when we drop. +class JitterHistory { +private: + static constexpr size_t history_length = 5000; + static constexpr double percentile = 0.999; + static constexpr double multiplier = 2.0; + +public: + void register_metrics(const std::vector> &labels); + void unregister_metrics(const std::vector> &labels); + + void clear() { + history.clear(); + orders.clear(); + } + void frame_arrived(std::chrono::steady_clock::time_point now, int64_t frame_duration, size_t dropped_frames); + std::chrono::steady_clock::time_point get_expected_next_frame() const { return expected_timestamp; } + double estimate_max_jitter() const; + +private: + // A simple O(k) based algorithm for getting the k-th largest or + // smallest element from our window; we simply keep the multiset + // ordered (insertions and deletions are O(n) as always) and then + // iterate from one of the sides. If we had larger values of k, + // we could go for a more complicated setup with two sets or heaps + // (one increasing and one decreasing) that we keep balanced around + // the point, or it is possible to reimplement std::set with + // counts in each node. However, since k=5, we don't need this. + std::multiset orders; + std::deque::iterator> history; + + std::chrono::steady_clock::time_point expected_timestamp = std::chrono::steady_clock::time_point::min(); + + // Metrics. There are no direct summaries for jitter, since we already have latency summaries. + std::atomic metric_input_underestimated_jitter_frames{0}; + std::atomic metric_input_estimated_max_jitter_seconds{0.0 / 0.0}; +}; + // 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 @@ -65,44 +118,39 @@ class YCbCrInput; // 2. We don't want to add more delay than is needed. // // Our general strategy is to drop as many frames as we can (helping for #2) -// that we think is safe for #1 given jitter. To this end, we set a lower floor N, -// where we assume that if we have N frames in the queue, we're always safe from -// starvation. (Typically, N will be 0 or 1. It starts off at 0.) If we have -// more than N frames in the queue after reading out the one we need, we head-drop -// them to reduce the queue. +// that we think is safe for #1 given jitter. To this end, we measure the +// deviation from the expected arrival time for all cards, and use that for +// continuous jitter estimation. // -// 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. -// -// 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. +// We then drop everything from the queue that we're sure we won't need to +// serve the output in the time before the next frame arrives. Typically, +// this means the queue will contain 0 or 1 frames, although more is also +// possible if the jitter is very high. class QueueLengthPolicy { public: QueueLengthPolicy() {} void reset(unsigned card_index) { this->card_index = card_index; - safe_queue_length = 1; - frames_with_at_least_one = 0; - been_at_safe_point_since_last_starvation = false; } - void register_metrics(const std::string &card_name); + void register_metrics(const std::vector> &labels); + void unregister_metrics(const std::vector> &labels); - void update_policy(unsigned queue_length); // Call before picking out a frame, so 0 means starvation. + // Call after picking out a frame, so 0 means starvation. + void update_policy(std::chrono::steady_clock::time_point now, + std::chrono::steady_clock::time_point expected_next_frame, + int64_t input_frame_duration, + int64_t master_frame_duration, + double max_input_card_jitter_seconds, + double max_master_card_jitter_seconds); unsigned get_safe_queue_length() const { return safe_queue_length; } private: - unsigned card_index; // For debugging only. - 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; + unsigned card_index; // For debugging and metrics only. + unsigned safe_queue_length = 0; // Can never go below zero. // 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 { @@ -351,6 +399,10 @@ public: display_timecode_on_stdout = enable; } + int64_t get_num_connected_clients() const { + return httpd.get_num_connected_clients(); + } + private: struct CaptureCard; @@ -375,9 +427,9 @@ private: void audio_thread_func(); 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); + void trim_queue(CaptureCard *card, size_t safe_queue_length); + std::pair get_channels_json(); + std::pair get_channel_color_http(unsigned channel_idx); HTTPD httpd; unsigned num_cards, num_video_inputs; @@ -454,10 +506,16 @@ private: int last_timecode = -1; // Unwrapped. + JitterHistory jitter_history; + // Metrics. + std::vector> labels; + std::atomic metric_input_received_frames{0}; + std::atomic metric_input_duped_frames{0}; 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_queue_length_frames{0}; std::atomic metric_input_has_signal_bool{-1}; std::atomic metric_input_is_connected_bool{-1}; @@ -468,6 +526,7 @@ private: std::atomic metric_input_frame_rate_den{-1}; std::atomic metric_input_sample_rate_hz{-1}; }; + JitterHistory output_jitter_history; 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). @@ -491,7 +550,7 @@ private: class OutputChannel { public: ~OutputChannel(); - void output_frame(DisplayFrame frame); + void output_frame(DisplayFrame &&frame); bool get_display_frame(DisplayFrame *frame); void add_frame_ready_callback(void *key, new_frame_ready_callback_t callback); void remove_frame_ready_callback(void *key); @@ -539,14 +598,8 @@ private: 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_uptime_seconds{0.0}; }; extern Mixer *global_mixer; -extern bool uses_mlock; #endif // !defined(_MIXER_H)