Refactor QueueLengthPolicy.

[nageru] / mixer.h

diff --git a/mixer.h b/mixer.h
index 045e9b1212fccb0f1392cd80fe87903c4079e898..191ea3dfe7b0835fecf011dcfac96c9e3cb2165d 100644 (file)
--- a/mixer.h
+++ b/mixer.h
@@ -68,8 +68,7 @@ class ResourcePool;
 //
 // 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,
@@ -79,17 +78,17 @@ 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 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;
 };
@@ -312,7 +311,19 @@ public:
                desired_output_card_index = card_index;
        }
 
+       std::map<uint32_t, bmusb::VideoMode> 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;
+       }
+
 private:
+       struct CaptureCard;
+
        void configure_card(unsigned card_index, bmusb::CaptureInterface *capture, bool is_fake_capture, 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,
@@ -323,11 +334,14 @@ 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, bool is_preroll);
+       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);
        void render_one_frame(int64_t duration);
        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);
 
        HTTPD httpd;
        unsigned num_cards;
@@ -338,13 +352,15 @@ private:
        std::atomic<unsigned> audio_source_channel{0};
        std::atomic<int> master_clock_channel{0};  // Gets overridden by <output_card_index> if set.
        int output_card_index = -1;  // -1 for none.
+       uint32_t output_video_mode = -1;
 
-       // The mechanics of changing the output card are so intricately connected
+       // 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<int> desired_output_card_index{-1};
+       std::atomic<uint32_t> desired_output_video_mode{0};
 
        std::unique_ptr<movit::EffectChain> display_chain;
        std::unique_ptr<ChromaSubsampler> chroma_subsampler;
@@ -359,7 +375,7 @@ private:
        // frame rate is integer, will always stay zero.
        unsigned fractional_samples = 0;
 
-       std::mutex card_mutex;
+       mutable std::mutex card_mutex;
        bool has_bmusb_thread = false;
        struct CaptureCard {
                std::unique_ptr<bmusb::CaptureInterface> capture;
@@ -387,7 +403,7 @@ private:
                        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<NewFrame> new_frames;
+               std::deque<NewFrame> new_frames;
                bool should_quit = false;
                std::condition_variable new_frames_changed;  // Set whenever new_frames (or should_quit) is changed.
 
@@ -403,6 +419,7 @@ private:
                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;
        };
        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]);
 
@@ -452,6 +469,7 @@ private:
                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;