X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.h;h=21b22552049d78c7ec9e7438648fccfcb7ed987e;hb=b85c1986b7ea63534899e2eb589f9e0888d5ccda;hp=c68ad1b81a1fd527a2c9a29c30337e724c9fd7a6;hpb=0912e41e8f564970ef32acd2db75685e47de1f48;p=nageru

diff --git a/mixer.h b/mixer.h
index c68ad1b..21b2255 100644
--- a/mixer.h
+++ b/mixer.h
@@ -24,7 +24,7 @@
 #include "bmusb/bmusb.h"
 #include "alsa_output.h"
 #include "ebu_r128_proc.h"
-#include "h264encode.h"
+#include "video_encoder.h"
 #include "httpd.h"
 #include "pbo_frame_allocator.h"
 #include "ref_counted_frame.h"
@@ -37,7 +37,7 @@
 #include "input_state.h"
 #include "correlation_measurer.h"
 
-class H264Encoder;
+class QuickSyncEncoder;
 class QSurface;
 namespace movit {
 class Effect;
@@ -49,7 +49,6 @@ class ResourcePool;
 namespace movit {
 class YCbCrInput;
 }
-class QOpenGLContext;
 class QSurfaceFormat;
 
 // For any card that's not the master (where we pick out the frames as they
@@ -71,10 +70,12 @@ 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.
+// we reduce N by 1 and reset the timers. TODO: Only do this if N ever actually
+// touched the limit.
 //
-// Whenever the queue is starved (we needed a frame but there was none), N was
-// obviously too low, so we increment N. We will never set N above 5, though.
+// 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.
 class QueueLengthPolicy {
 public:
 	QueueLengthPolicy() {}
@@ -82,6 +83,7 @@ public:
 		this->card_index = card_index;
 		safe_queue_length = 0;
 		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.
@@ -91,6 +93,7 @@ private:
 	unsigned card_index;  // For debugging only.
 	unsigned safe_queue_length = 0;  // Called N in the comments.
 	unsigned frames_with_at_least_one = 0;
+	bool been_at_safe_point_since_last_starvation = false;
 };
 
 class Mixer {
@@ -143,6 +146,25 @@ public:
 		output_channel[output].set_frame_ready_callback(callback);
 	}
 
+	// TODO: Should this really be per-channel? Shouldn't it just be called for e.g. the live output?
+	typedef std::function<void(const std::vector<std::string> &)> transition_names_updated_callback_t;
+	void set_transition_names_updated_callback(Output output, transition_names_updated_callback_t callback)
+	{
+		output_channel[output].set_transition_names_updated_callback(callback);
+	}
+
+	typedef std::function<void(const std::string &)> name_updated_callback_t;
+	void set_name_updated_callback(Output output, name_updated_callback_t callback)
+	{
+		output_channel[output].set_name_updated_callback(callback);
+	}
+
+	typedef std::function<void(const std::string &)> color_updated_callback_t;
+	void set_color_updated_callback(Output output, color_updated_callback_t callback)
+	{
+		output_channel[output].set_color_updated_callback(callback);
+	}
+
 	typedef std::function<void(float level_lufs, float peak_db,
 	                           float global_level_lufs, float range_low_lufs, float range_high_lufs,
 	                           float gain_staging_db, float final_makeup_gain_db,
@@ -167,6 +189,11 @@ public:
 		return theme->get_channel_name(channel);
 	}
 
+	std::string get_channel_color(unsigned channel) const
+	{
+		return theme->get_channel_color(channel);
+	}
+
 	int get_channel_signal(unsigned channel) const
 	{
 		return theme->get_channel_signal(channel);
@@ -187,6 +214,16 @@ public:
 		audio_source_channel = channel;
 	}
 
+	unsigned get_master_clock() const
+	{
+		return master_clock_channel;
+	}
+
+	void set_master_clock(unsigned channel)
+	{
+		master_clock_channel = channel;
+	}
+
 	void set_signal_mapping(int signal, int card)
 	{
 		return theme->set_signal_mapping(signal, card);
@@ -212,6 +249,11 @@ public:
 		locut_enabled = enabled;
 	}
 
+	bool get_locut_enabled() const
+	{
+		return locut_enabled;
+	}
+
 	float get_limiter_threshold_dbfs()
 	{
 		return limiter_threshold_dbfs;
@@ -237,11 +279,21 @@ public:
 		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<std::mutex> lock(compressor_mutex);
@@ -255,6 +307,12 @@ public:
 		level_compressor_enabled = enabled;
 	}
 
+	bool get_gain_staging_auto() const
+	{
+		std::unique_lock<std::mutex> lock(compressor_mutex);
+		return level_compressor_enabled;
+	}
+
 	void set_final_makeup_gain_db(float gain_db)
 	{
 		std::unique_lock<std::mutex> lock(compressor_mutex);
@@ -329,15 +387,22 @@ public:
 		cards[card_index].capture->set_audio_input(input);
 	}
 
+	void change_x264_bitrate(unsigned rate_kbit) {
+		video_encoder->change_x264_bitrate(rate_kbit);
+	}
+
 private:
-	void configure_card(unsigned card_index, const QSurfaceFormat &format, CaptureInterface *capture);
+	void configure_card(unsigned card_index, CaptureInterface *capture, bool is_fake_capture);
 	void bm_frame(unsigned card_index, uint16_t timecode,
 		FrameAllocator::Frame video_frame, size_t video_offset, VideoFormat video_format,
 		FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format);
+	void bm_hotplug_add(libusb_device *dev);
+	void bm_hotplug_remove(unsigned card_index);
 	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 render_one_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);
@@ -352,11 +417,12 @@ private:
 	std::unique_ptr<movit::ResourcePool> resource_pool;
 	std::unique_ptr<Theme> theme;
 	std::atomic<unsigned> audio_source_channel{0};
+	std::atomic<unsigned> master_clock_channel{0};
 	std::unique_ptr<movit::EffectChain> display_chain;
 	GLuint cbcr_program_num;  // Owned by <resource_pool>.
 	GLuint cbcr_vbo;  // Holds position and texcoord data.
 	GLuint cbcr_position_attribute_index, cbcr_texcoord_attribute_index;
-	std::unique_ptr<H264Encoder> h264_encoder;
+	std::unique_ptr<VideoEncoder> video_encoder;
 
 	// Effects part of <display_chain>. Owned by <display_chain>.
 	movit::FlatInput *display_input;
@@ -364,20 +430,21 @@ private:
 	int64_t pts_int = 0;  // In TIMEBASE units.
 
 	std::mutex bmusb_mutex;
+	bool has_bmusb_thread = false;
 	struct CaptureCard {
-		CaptureInterface *capture;
+		CaptureInterface *capture = nullptr;
+		bool is_fake_capture;
 		std::unique_ptr<PBOFrameAllocator> frame_allocator;
 
 		// Stuff for the OpenGL context (for texture uploading).
-		QSurface *surface;
-		QOpenGLContext *context;
+		QSurface *surface = nullptr;
 
 		struct NewFrame {
 			RefCountedFrame frame;
 			int64_t length;  // In TIMEBASE units.
 			bool interlaced;
 			unsigned field;  // Which field (0 or 1) of the frame to use. Always 0 for progressive.
-			GLsync ready_fence;  // Whether frame is ready for rendering.
+			std::function<void()> 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::queue<NewFrame> new_frames;
@@ -400,22 +467,36 @@ private:
 
 	InputState input_state;
 
+	// Cards we have been noticed about being hotplugged, but haven't tried adding yet.
+	// Protected by its own mutex.
+	std::mutex hotplug_mutex;
+	std::vector<libusb_device *> hotplugged_cards;
+
 	class OutputChannel {
 	public:
 		~OutputChannel();
 		void output_frame(DisplayFrame frame);
 		bool get_display_frame(DisplayFrame *frame);
 		void set_frame_ready_callback(new_frame_ready_callback_t callback);
+		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);
 
 	private:
 		friend class Mixer;
 
+		unsigned channel;
 		Mixer *parent = nullptr;  // Not owned.
 		std::mutex frame_mutex;
 		DisplayFrame current_frame, ready_frame;  // protected by <frame_mutex>
 		bool has_current_frame = false, has_ready_frame = false;  // protected by <frame_mutex>
 		new_frame_ready_callback_t new_frame_ready_callback;
-		bool has_new_frame_ready_callback = false;
+		transition_names_updated_callback_t transition_names_updated_callback;
+		name_updated_callback_t name_updated_callback;
+		color_updated_callback_t color_updated_callback;
+
+		std::vector<std::string> last_transition_names;
+		std::string last_name, last_color;
 	};
 	OutputChannel output_channel[NUM_OUTPUTS];
 
@@ -425,7 +506,7 @@ private:
 	std::atomic<bool> should_cut{false};
 
 	audio_level_callback_t audio_level_callback = nullptr;
-	std::mutex compressor_mutex;
+	mutable std::mutex compressor_mutex;
 	Ebu_r128_proc r128;  // Under compressor_mutex.
 	CorrelationMeasurer correlation;  // Under compressor_mutex.
 
@@ -472,5 +553,6 @@ private:
 };
 
 extern Mixer *global_mixer;
+extern bool uses_mlock;
 
 #endif  // !defined(_MIXER_H)