// 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);
}
// 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; }
+ AudioMixer *get_audio_mixer() { return audio_mixer.get(); }
+ const AudioMixer *get_audio_mixer() const { return audio_mixer.get(); }
void schedule_cut()
{
return cards[card_index].output != nullptr;
}
+ bool card_is_ffmpeg(unsigned card_index) const {
+ assert(card_index < num_cards + num_video_inputs);
+ return cards[card_index].type == CardType::FFMPEG_INPUT;
+ }
+
std::map<uint32_t, bmusb::VideoMode> get_available_video_modes(unsigned card_index) const {
assert(card_index < num_cards);
return cards[card_index].capture->get_available_video_modes();
cards[card_index].capture->set_audio_input(input);
}
+ std::string get_ffmpeg_filename(unsigned card_index) const;
+
+ void set_ffmpeg_filename(unsigned card_index, const std::string &filename);
+
void change_x264_bitrate(unsigned rate_kbit) {
video_encoder->change_x264_bitrate(rate_kbit);
}
display_timecode_on_stdout = enable;
}
+ int64_t get_num_connected_clients() const {
+ return httpd.get_num_connected_clients();
+ }
+
+ std::vector<Theme::MenuEntry> get_theme_menu() { return theme->get_theme_menu(); }
+
+ void theme_menu_entry_clicked(int lua_ref) { return theme->theme_menu_entry_clicked(lua_ref); }
+
+ void set_theme_menu_callback(std::function<void()> callback)
+ {
+ theme->set_theme_menu_callback(callback);
+ }
+
private:
struct CaptureCard;
enum class CardType {
LIVE_CARD,
FAKE_CAPTURE,
- FFMPEG_INPUT
+ FFMPEG_INPUT,
+ CEF_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 release_display_frame(DisplayFrame *frame);
double pts() { return double(pts_int) / TIMEBASE; }
void trim_queue(CaptureCard *card, size_t safe_queue_length);
+ std::pair<std::string, std::string> get_channels_json();
+ std::pair<std::string, std::string> get_channel_color_http(unsigned channel_idx);
HTTPD httpd;
- unsigned num_cards, num_video_inputs;
+ unsigned num_cards, num_video_inputs, num_html_inputs = 0;
QSurface *mixer_surface, *h264_encoder_surface, *decklink_output_surface;
std::unique_ptr<movit::ResourcePool> resource_pool;
CardType type;
std::unique_ptr<DeckLinkOutput> output;
+ // CEF only delivers frames when it actually has a change.
+ // If we trim the queue for latency reasons, we could thus
+ // end up in a situation trimming a frame that was meant to
+ // be displayed for a long time, which is really suboptimal.
+ // Thus, if we drop the last frame we have, may_have_dropped_last_frame
+ // is set to true, and the next starvation event will trigger
+ // us requestin a CEF repaint.
+ bool is_cef_capture, may_have_dropped_last_frame = false;
+
// If this card is used for output (ie., output_card_index points to it),
// it cannot simultaneously be uesd for capture, so <capture> gets replaced
// by a FakeCapture. However, since reconstructing the real capture object
JitterHistory output_jitter_history;
CaptureCard cards[MAX_VIDEO_CARDS]; // Protected by <card_mutex>.
YCbCrInterpretation ycbcr_interpretation[MAX_VIDEO_CARDS]; // Protected by <card_mutex>.
- AudioMixer audio_mixer; // Same as global_audio_mixer (see audio_mixer.h).
+ std::unique_ptr<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.
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);
std::vector<uint32_t> 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<int64_t> metric_frames_output_total{0};
- std::atomic<int64_t> metric_frames_output_dropped{0};
- std::atomic<double> metric_start_time_seconds{0.0 / 0.0};
- std::atomic<int64_t> metrics_memory_used_bytes{0};
- std::atomic<double> metrics_memory_locked_limit_bytes{0.0 / 0.0};
};
extern Mixer *global_mixer;
-extern bool uses_mlock;
#endif // !defined(_MIXER_H)