X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.cpp;h=fd982a5708d61d59f4dfca1204cd7dc6dda2e5d5;hb=7dec19543c858de7247f64f6c82f613f9fe05825;hp=a1c038d5329abc21ad0e9a5015e0575f7658b959;hpb=1202ad9167357a461366dab9cbbaa6c578423253;p=nageru

diff --git a/mixer.cpp b/mixer.cpp
index a1c038d..fd982a5 100644
--- a/mixer.cpp
+++ b/mixer.cpp
@@ -33,7 +33,7 @@
 #include "decklink_capture.h"
 #include "defs.h"
 #include "flags.h"
-#include "h264encode.h"
+#include "video_encoder.h"
 #include "pbo_frame_allocator.h"
 #include "ref_counted_gl_sync.h"
 #include "timebase.h"
@@ -92,27 +92,37 @@ void insert_new_frame(RefCountedFrame frame, unsigned field_num, bool interlaced
 	}
 }
 
-string generate_local_dump_filename(int frame)
+}  // namespace
+
+void QueueLengthPolicy::update_policy(int queue_length)
 {
-	time_t now = time(NULL);
-	tm now_tm;
-	localtime_r(&now, &now_tm);
-
-	char timestamp[256];
-	strftime(timestamp, sizeof(timestamp), "%F-%T%z", &now_tm);
-
-	// Use the frame number to disambiguate between two cuts starting
-	// on the same second.
-	char filename[256];
-	snprintf(filename, sizeof(filename), "%s%s-f%02d%s",
-		LOCAL_DUMP_PREFIX, timestamp, frame % 100, LOCAL_DUMP_SUFFIX);
-	return filename;
+	if (queue_length < 0) {  // Starvation.
+		if (been_at_safe_point_since_last_starvation && safe_queue_length < 5) {
+			++safe_queue_length;
+			fprintf(stderr, "Card %u: Starvation, increasing safe limit to %u frames\n",
+				card_index, safe_queue_length);
+		}
+		frames_with_at_least_one = 0;
+		been_at_safe_point_since_last_starvation = false;
+		return;
+	}
+	if (queue_length > 0) {
+		if (queue_length >= int(safe_queue_length)) {
+			been_at_safe_point_since_last_starvation = true;
+		}
+		if (++frames_with_at_least_one >= 1000 && safe_queue_length > 0) {
+			--safe_queue_length;
+			fprintf(stderr, "Card %u: Spare frames for more than 1000 frames, reducing safe limit to %u frames\n",
+				card_index, safe_queue_length);
+			frames_with_at_least_one = 0;
+		}
+	} else {
+		frames_with_at_least_one = 0;
+	}
 }
 
-}  // namespace
-
 Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
-	: httpd(WIDTH, HEIGHT),
+	: httpd(),
 	  num_cards(num_cards),
 	  mixer_surface(create_surface(format)),
 	  h264_encoder_surface(create_surface(format)),
@@ -121,9 +131,6 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 	  limiter(OUTPUT_FREQUENCY),
 	  compressor(OUTPUT_FREQUENCY)
 {
-	httpd.open_output_file(generate_local_dump_filename(/*frame=*/0).c_str());
-	httpd.start(9095);
-
 	CHECK(init_movit(MOVIT_SHADER_DIR, MOVIT_DEBUG_OFF));
 	check_error();
 
@@ -132,9 +139,10 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 	movit_texel_subpixel_precision /= 2.0;
 
 	resource_pool.reset(new ResourcePool);
-	theme.reset(new Theme("theme.lua", resource_pool.get(), num_cards));
+	theme.reset(new Theme(global_flags.theme_filename.c_str(), resource_pool.get(), num_cards));
 	for (unsigned i = 0; i < NUM_OUTPUTS; ++i) {
 		output_channel[i].parent = this;
+		output_channel[i].channel = i;
 	}
 
 	ImageFormat inout_format;
@@ -150,7 +158,10 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 	display_chain->set_dither_bits(0);  // Don't bother.
 	display_chain->finalize();
 
-	h264_encoder.reset(new H264Encoder(h264_encoder_surface, global_flags.va_display, WIDTH, HEIGHT, &httpd));
+	video_encoder.reset(new VideoEncoder(resource_pool.get(), h264_encoder_surface, global_flags.va_display, WIDTH, HEIGHT, &httpd));
+
+	// Start listening for clients only once VideoEncoder has written its header, if any.
+	httpd.start(9095);
 
 	// First try initializing the PCI devices, then USB, until we have the desired number of cards.
 	unsigned num_pci_devices = 0, num_usb_devices = 0;
@@ -182,6 +193,7 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 	}
 
 	for (card_index = 0; card_index < num_cards; ++card_index) {
+		cards[card_index].queue_length_policy.reset(card_index);
 		cards[card_index].capture->start_bm_capture();
 	}
 
@@ -233,11 +245,21 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 
 	locut.init(FILTER_HPF, 2);
 
+	// If --flat-audio is given, turn off everything that messes with the sound,
+	// except the final makeup gain.
+	if (global_flags.flat_audio) {
+		set_locut_enabled(false);
+		set_limiter_enabled(false);
+		set_compressor_enabled(false);
+	}
+
 	// hlen=16 is pretty low quality, but we use quite a bit of CPU otherwise,
 	// and there's a limit to how important the peak meter is.
 	peak_resampler.setup(OUTPUT_FREQUENCY, OUTPUT_FREQUENCY * 4, /*num_channels=*/2, /*hlen=*/16, /*frel=*/1.0);
 
-	alsa.reset(new ALSAOutput(OUTPUT_FREQUENCY, /*num_channels=*/2));
+	if (global_flags.enable_alsa_output) {
+		alsa.reset(new ALSAOutput(OUTPUT_FREQUENCY, /*num_channels=*/2));
+	}
 }
 
 Mixer::~Mixer()
@@ -250,12 +272,12 @@ Mixer::~Mixer()
 		{
 			unique_lock<mutex> lock(bmusb_mutex);
 			cards[card_index].should_quit = true;  // Unblock thread.
-			cards[card_index].new_data_ready_changed.notify_all();
+			cards[card_index].new_frames_changed.notify_all();
 		}
 		cards[card_index].capture->stop_dequeue_thread();
 	}
 
-	h264_encoder.reset(nullptr);
+	video_encoder.reset(nullptr);
 }
 
 void Mixer::configure_card(unsigned card_index, const QSurfaceFormat &format, CaptureInterface *capture)
@@ -268,18 +290,6 @@ void Mixer::configure_card(unsigned card_index, const QSurfaceFormat &format, Ca
 	card->frame_allocator.reset(new PBOFrameAllocator(8 << 20, WIDTH, HEIGHT));  // 8 MB.
 	card->capture->set_video_frame_allocator(card->frame_allocator.get());
 	card->surface = create_surface(format);
-	card->capture->set_dequeue_thread_callbacks(
-		[card]{
-			eglBindAPI(EGL_OPENGL_API);
-			card->context = create_context(card->surface);
-			if (!make_current(card->context, card->surface)) {
-				printf("failed to create bmusb context\n");
-				exit(1);
-			}
-		},
-		[this]{
-			resource_pool->clean_context();
-		});
 	card->resampling_queue.reset(new ResamplingQueue(OUTPUT_FREQUENCY, OUTPUT_FREQUENCY, 2));
 	card->capture->configure_card();
 }
@@ -351,7 +361,7 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 
 	int64_t frame_length = int64_t(TIMEBASE * video_format.frame_rate_den) / video_format.frame_rate_nom;
 
-	size_t num_samples = (audio_frame.len >= audio_offset) ? (audio_frame.len - audio_offset) / audio_format.num_channels / (audio_format.bits_per_sample / 8) : 0;
+	size_t num_samples = (audio_frame.len > audio_offset) ? (audio_frame.len - audio_offset) / audio_format.num_channels / (audio_format.bits_per_sample / 8) : 0;
 	if (num_samples > OUTPUT_FREQUENCY / 10) {
 		printf("Card %d: Dropping frame with implausible audio length (len=%d, offset=%d) [timecode=0x%04x video_len=%d video_offset=%d video_format=%x)\n",
 			card_index, int(audio_frame.len), int(audio_offset),
@@ -375,6 +385,9 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 	vector<float> audio;
 	audio.resize(num_samples * 2);
 	switch (audio_format.bits_per_sample) {
+	case 0:
+		assert(num_samples == 0);
+		break;
 	case 24:
 		convert_fixed24_to_fp32(&audio[0], 2, audio_frame.data + audio_offset, audio_format.num_channels, num_samples);
 		break;
@@ -427,13 +440,6 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 		audio_frame.owner->release_frame(audio_frame);
 	}
 
-	{
-		// Wait until the previous frame was consumed.
-		unique_lock<mutex> lock(bmusb_mutex);
-		card->new_data_ready_changed.wait(lock, [card]{ return !card->new_data_ready || card->should_quit; });
-		if (card->should_quit) return;
-	}
-
 	size_t expected_length = video_format.width * (video_format.height + video_format.extra_lines_top + video_format.extra_lines_bottom) * 2;
 	if (video_frame.len - video_offset == 0 ||
 	    video_frame.len - video_offset != expected_length) {
@@ -449,13 +455,13 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 		// so that pts can go up accordingly.
 		{
 			unique_lock<mutex> lock(bmusb_mutex);
-			card->new_data_ready = true;
-			card->new_frame = RefCountedFrame(FrameAllocator::Frame());
-			card->new_frame_length = frame_length;
-			card->new_frame_interlaced = false;
-			card->new_data_ready_fence = nullptr;
-			card->dropped_frames = dropped_frames;
-			card->new_data_ready_changed.notify_all();
+			CaptureCard::NewFrame new_frame;
+			new_frame.frame = RefCountedFrame(FrameAllocator::Frame());
+			new_frame.length = frame_length;
+			new_frame.interlaced = false;
+			new_frame.dropped_frames = dropped_frames;
+			card->new_frames.push(move(new_frame));
+			card->new_frames_changed.notify_all();
 		}
 		return;
 	}
@@ -478,7 +484,7 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 	userdata->last_has_signal = video_format.has_signal;
 	userdata->last_frame_rate_nom = video_format.frame_rate_nom;
 	userdata->last_frame_rate_den = video_format.frame_rate_den;
-	RefCountedFrame new_frame(video_frame);
+	RefCountedFrame frame(video_frame);
 
 	// Upload the textures.
 	size_t cbcr_width = video_format.width / 2;
@@ -486,49 +492,64 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 	size_t y_offset = video_frame.size / 2 + video_offset / 2;
 
 	for (unsigned field = 0; field < num_fields; ++field) {
-		unsigned field_start_line = (field == 1) ? video_format.second_field_start : video_format.extra_lines_top + field * (video_format.height + 22);
-
-		if (userdata->tex_y[field] == 0 ||
-		    userdata->tex_cbcr[field] == 0 ||
-		    video_format.width != userdata->last_width[field] ||
-		    video_format.height != userdata->last_height[field]) {
-			// We changed resolution since last use of this texture, so we need to create
-			// a new object. Note that this each card has its own PBOFrameAllocator,
-			// we don't need to worry about these flip-flopping between resolutions.
+		// Put the actual texture upload in a lambda that is executed in the main thread.
+		// It is entirely possible to do this in the same thread (and it might even be
+		// faster, depending on the GPU and driver), but it appears to be trickling
+		// driver bugs very easily.
+		//
+		// Note that this means we must hold on to the actual frame data in <userdata>
+		// until the upload command is run, but we hold on to <frame> much longer than that
+		// (in fact, all the way until we no longer use the texture in rendering).
+		auto upload_func = [field, video_format, y_offset, cbcr_offset, cbcr_width, userdata]() {
+			unsigned field_start_line = (field == 1) ? video_format.second_field_start : video_format.extra_lines_top + field * (video_format.height + 22);
+
+			if (userdata->tex_y[field] == 0 ||
+			    userdata->tex_cbcr[field] == 0 ||
+			    video_format.width != userdata->last_width[field] ||
+			    video_format.height != userdata->last_height[field]) {
+				// We changed resolution since last use of this texture, so we need to create
+				// a new object. Note that this each card has its own PBOFrameAllocator,
+				// we don't need to worry about these flip-flopping between resolutions.
+				glBindTexture(GL_TEXTURE_2D, userdata->tex_cbcr[field]);
+				check_error();
+				glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, cbcr_width, video_format.height, 0, GL_RG, GL_UNSIGNED_BYTE, nullptr);
+				check_error();
+				glBindTexture(GL_TEXTURE_2D, userdata->tex_y[field]);
+				check_error();
+				glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, video_format.width, video_format.height, 0, GL_RED, GL_UNSIGNED_BYTE, nullptr);
+				check_error();
+				userdata->last_width[field] = video_format.width;
+				userdata->last_height[field] = video_format.height;
+			}
+
+			GLuint pbo = userdata->pbo;
+			check_error();
+			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo);
+			check_error();
+
+			size_t field_y_start = y_offset + video_format.width * field_start_line;
+			size_t field_cbcr_start = cbcr_offset + cbcr_width * field_start_line * sizeof(uint16_t);
+
+			if (global_flags.flush_pbos) {
+				glFlushMappedBufferRange(GL_PIXEL_UNPACK_BUFFER, field_y_start, video_format.width * video_format.height);
+				check_error();
+				glFlushMappedBufferRange(GL_PIXEL_UNPACK_BUFFER, field_cbcr_start, cbcr_width * video_format.height * sizeof(uint16_t));
+				check_error();
+			}
+
 			glBindTexture(GL_TEXTURE_2D, userdata->tex_cbcr[field]);
 			check_error();
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, cbcr_width, video_format.height, 0, GL_RG, GL_UNSIGNED_BYTE, nullptr);
+			glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, cbcr_width, video_format.height, GL_RG, GL_UNSIGNED_BYTE, BUFFER_OFFSET(field_cbcr_start));
 			check_error();
 			glBindTexture(GL_TEXTURE_2D, userdata->tex_y[field]);
 			check_error();
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, video_format.width, video_format.height, 0, GL_RED, GL_UNSIGNED_BYTE, nullptr);
+			glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, video_format.width, video_format.height, GL_RED, GL_UNSIGNED_BYTE, BUFFER_OFFSET(field_y_start));
 			check_error();
-			userdata->last_width[field] = video_format.width;
-			userdata->last_height[field] = video_format.height;
-		}
-
-		GLuint pbo = userdata->pbo;
-		check_error();
-		glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
-		check_error();
-		glMemoryBarrier(GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);
-		check_error();
-
-		glBindTexture(GL_TEXTURE_2D, userdata->tex_cbcr[field]);
-		check_error();
-		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, cbcr_width, video_format.height, GL_RG, GL_UNSIGNED_BYTE, BUFFER_OFFSET(cbcr_offset + cbcr_width * field_start_line * sizeof(uint16_t)));
-		check_error();
-		glBindTexture(GL_TEXTURE_2D, userdata->tex_y[field]);
-		check_error();
-		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, video_format.width, video_format.height, GL_RED, GL_UNSIGNED_BYTE, BUFFER_OFFSET(y_offset + video_format.width * field_start_line));
-		check_error();
-		glBindTexture(GL_TEXTURE_2D, 0);
-		check_error();
-		glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
-		check_error();
-		GLsync fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, /*flags=*/0);
-		check_error();
-		assert(fence != nullptr);
+			glBindTexture(GL_TEXTURE_2D, 0);
+			check_error();
+			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+			check_error();
+		};
 
 		if (field == 1) {
 			// Don't upload the second field as fast as we can; wait until
@@ -551,20 +572,15 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 
 		{
 			unique_lock<mutex> lock(bmusb_mutex);
-			card->new_data_ready = true;
-			card->new_frame = new_frame;
-			card->new_frame_length = frame_length;
-			card->new_frame_field = field;
-			card->new_frame_interlaced = video_format.interlaced;
-			card->new_data_ready_fence = fence;
-			card->dropped_frames = dropped_frames;
-			card->new_data_ready_changed.notify_all();
-
-			if (field != num_fields - 1) {
-				// Wait until the previous frame was consumed.
-				card->new_data_ready_changed.wait(lock, [card]{ return !card->new_data_ready || card->should_quit; });
-				if (card->should_quit) return;
-			}
+			CaptureCard::NewFrame new_frame;
+			new_frame.frame = frame;
+			new_frame.length = frame_length;
+			new_frame.field = field;
+			new_frame.interlaced = video_format.interlaced;
+			new_frame.upload_func = upload_func;
+			new_frame.dropped_frames = dropped_frames;
+			card->new_frames.push(move(new_frame));
+			card->new_frames_changed.notify_all();
 		}
 	}
 }
@@ -585,162 +601,60 @@ void Mixer::thread_func()
 	int stats_dropped_frames = 0;
 
 	while (!should_quit) {
-		CaptureCard card_copy[MAX_CARDS];
-		int num_samples[MAX_CARDS];
+		CaptureCard::NewFrame new_frames[MAX_CARDS];
+		bool has_new_frame[MAX_CARDS] = { false };
+		int num_samples[MAX_CARDS] = { 0 };
 
-		{
-			unique_lock<mutex> lock(bmusb_mutex);
+		// TODO: Add a timeout.
+		unsigned master_card_index = theme->map_signal(master_clock_channel);
+		assert(master_card_index < num_cards);
 
-			// The first card is the master timer, so wait for it to have a new frame.
-			// TODO: Make configurable, and with a timeout.
-			cards[0].new_data_ready_changed.wait(lock, [this]{ return cards[0].new_data_ready; });
-
-			for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
-				CaptureCard *card = &cards[card_index];
-				card_copy[card_index].new_data_ready = card->new_data_ready;
-				card_copy[card_index].new_frame = card->new_frame;
-				card_copy[card_index].new_frame_length = card->new_frame_length;
-				card_copy[card_index].new_frame_field = card->new_frame_field;
-				card_copy[card_index].new_frame_interlaced = card->new_frame_interlaced;
-				card_copy[card_index].new_data_ready_fence = card->new_data_ready_fence;
-				card_copy[card_index].dropped_frames = card->dropped_frames;
-				card->new_data_ready = false;
-				card->new_data_ready_changed.notify_all();
-
-				int num_samples_times_timebase = OUTPUT_FREQUENCY * card->new_frame_length + card->fractional_samples;
-				num_samples[card_index] = num_samples_times_timebase / TIMEBASE;
-				card->fractional_samples = num_samples_times_timebase % TIMEBASE;
-				assert(num_samples[card_index] >= 0);
-			}
-		}
+		get_one_frame_from_each_card(master_card_index, new_frames, has_new_frame, num_samples);
+		schedule_audio_resampling_tasks(new_frames[master_card_index].dropped_frames, num_samples[master_card_index], new_frames[master_card_index].length);
+		stats_dropped_frames += new_frames[master_card_index].dropped_frames;
+		send_audio_level_callback();
 
-		// Resample the audio as needed, including from previously dropped frames.
-		assert(num_cards > 0);
-		for (unsigned frame_num = 0; frame_num < card_copy[0].dropped_frames + 1; ++frame_num) {
-			{
-				// Signal to the audio thread to process this frame.
-				unique_lock<mutex> lock(audio_mutex);
-				audio_task_queue.push(AudioTask{pts_int, num_samples[0]});
-				audio_task_queue_changed.notify_one();
+		for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
+			if (card_index == master_card_index || !has_new_frame[card_index]) {
+				continue;
 			}
-			if (frame_num != card_copy[0].dropped_frames) {
-				// For dropped frames, increase the pts. Note that if the format changed
-				// in the meantime, we have no way of detecting that; we just have to
-				// assume the frame length is always the same.
-				++stats_dropped_frames;
-				pts_int += card_copy[0].new_frame_length;
+			if (new_frames[card_index].frame->len == 0) {
+				++new_frames[card_index].dropped_frames;
 			}
-		}
-
-		if (audio_level_callback != nullptr) {
-			unique_lock<mutex> lock(compressor_mutex);
-			double loudness_s = r128.loudness_S();
-			double loudness_i = r128.integrated();
-			double loudness_range_low = r128.range_min();
-			double loudness_range_high = r128.range_max();
-
-			audio_level_callback(loudness_s, 20.0 * log10(peak),
-			                     loudness_i, loudness_range_low, loudness_range_high,
-			                     gain_staging_db, 20.0 * log10(final_makeup_gain),
-			                     correlation.get_correlation());
-		}
-
-		for (unsigned card_index = 1; card_index < num_cards; ++card_index) {
-			if (card_copy[card_index].new_data_ready && card_copy[card_index].new_frame->len == 0) {
-				++card_copy[card_index].dropped_frames;
-			}
-			if (card_copy[card_index].dropped_frames > 0) {
+			if (new_frames[card_index].dropped_frames > 0) {
 				printf("Card %u dropped %d frames before this\n",
-					card_index, int(card_copy[card_index].dropped_frames));
+					card_index, int(new_frames[card_index].dropped_frames));
 			}
 		}
 
 		// If the first card is reporting a corrupted or otherwise dropped frame,
 		// just increase the pts (skipping over this frame) and don't try to compute anything new.
-		if (card_copy[0].new_frame->len == 0) {
+		if (new_frames[master_card_index].frame->len == 0) {
 			++stats_dropped_frames;
-			pts_int += card_copy[0].new_frame_length;
+			pts_int += new_frames[master_card_index].length;
 			continue;
 		}
 
 		for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
-			CaptureCard *card = &card_copy[card_index];
-			if (!card->new_data_ready || card->new_frame->len == 0)
+			if (!has_new_frame[card_index] || new_frames[card_index].frame->len == 0)
 				continue;
 
-			assert(card->new_frame != nullptr);
-			insert_new_frame(card->new_frame, card->new_frame_field, card->new_frame_interlaced, card_index, &input_state);
+			CaptureCard::NewFrame *new_frame = &new_frames[card_index];
+			assert(new_frame->frame != nullptr);
+			insert_new_frame(new_frame->frame, new_frame->field, new_frame->interlaced, card_index, &input_state);
 			check_error();
 
-			// The new texture might still be uploaded,
-			// tell the GPU to wait until it's there.
-			if (card->new_data_ready_fence) {
-				glWaitSync(card->new_data_ready_fence, /*flags=*/0, GL_TIMEOUT_IGNORED);
-				check_error();
-				glDeleteSync(card->new_data_ready_fence);
-				check_error();
+			// The new texture might need uploading before use.
+			if (new_frame->upload_func) {
+				new_frame->upload_func();
+				new_frame->upload_func = nullptr;
 			}
 		}
 
-		// Get the main chain from the theme, and set its state immediately.
-		Theme::Chain theme_main_chain = theme->get_chain(0, pts(), WIDTH, HEIGHT, input_state);
-		EffectChain *chain = theme_main_chain.chain;
-		theme_main_chain.setup_chain();
-		//theme_main_chain.chain->enable_phase_timing(true);
-
-		GLuint y_tex, cbcr_tex;
-		bool got_frame = h264_encoder->begin_frame(&y_tex, &cbcr_tex);
-		assert(got_frame);
-
-		// Render main chain.
-		GLuint cbcr_full_tex = resource_pool->create_2d_texture(GL_RG8, WIDTH, HEIGHT);
-		GLuint rgba_tex = resource_pool->create_2d_texture(GL_RGB565, WIDTH, HEIGHT);  // Saves texture bandwidth, although dithering gets messed up.
-		GLuint fbo = resource_pool->create_fbo(y_tex, cbcr_full_tex, rgba_tex);
-		check_error();
-		chain->render_to_fbo(fbo, WIDTH, HEIGHT);
-		resource_pool->release_fbo(fbo);
-
-		subsample_chroma(cbcr_full_tex, cbcr_tex);
-		resource_pool->release_2d_texture(cbcr_full_tex);
-
-		// Set the right state for rgba_tex.
-		glBindFramebuffer(GL_FRAMEBUFFER, 0);
-		glBindTexture(GL_TEXTURE_2D, rgba_tex);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-		RefCountedGLsync fence(GL_SYNC_GPU_COMMANDS_COMPLETE, /*flags=*/0);
-		check_error();
-
-		const int64_t av_delay = TIMEBASE / 10;  // Corresponds to the fixed delay in resampling_queue.h. TODO: Make less hard-coded.
-		h264_encoder->end_frame(fence, pts_int + av_delay, theme_main_chain.input_frames);
+		int64_t duration = new_frames[master_card_index].length;
+		render_one_frame(duration);
 		++frame;
-		pts_int += card_copy[0].new_frame_length;
-
-		// The live frame just shows the RGBA texture we just rendered.
-		// It owns rgba_tex now.
-		DisplayFrame live_frame;
-		live_frame.chain = display_chain.get();
-		live_frame.setup_chain = [this, rgba_tex]{
-			display_input->set_texture_num(rgba_tex);
-		};
-		live_frame.ready_fence = fence;
-		live_frame.input_frames = {};
-		live_frame.temp_textures = { rgba_tex };
-		output_channel[OUTPUT_LIVE].output_frame(live_frame);
-
-		// Set up preview and any additional channels.
-		for (int i = 1; i < theme->get_num_channels() + 2; ++i) {
-			DisplayFrame display_frame;
-			Theme::Chain chain = theme->get_chain(i, pts(), WIDTH, HEIGHT, input_state);  // FIXME: dimensions
-			display_frame.chain = chain.chain;
-			display_frame.setup_chain = chain.setup_chain;
-			display_frame.ready_fence = fence;
-			display_frame.input_frames = chain.input_frames;
-			display_frame.temp_textures = {};
-			output_channel[i].output_frame(display_frame);
-		}
+		pts_int += duration;
 
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		double elapsed = now.tv_sec - start.tv_sec +
@@ -753,12 +667,7 @@ void Mixer::thread_func()
 		}
 
 		if (should_cut.exchange(false)) {  // Test and clear.
-			string filename = generate_local_dump_filename(frame);
-			printf("Starting new recording: %s\n", filename.c_str());
-			h264_encoder->shutdown();
-			httpd.close_output_file();
-			httpd.open_output_file(filename.c_str());
-			h264_encoder.reset(new H264Encoder(h264_encoder_surface, global_flags.va_display, WIDTH, HEIGHT, &httpd));
+			video_encoder->do_cut(frame);
 		}
 
 #if 0
@@ -777,6 +686,141 @@ void Mixer::thread_func()
 	resource_pool->clean_context();
 }
 
+void Mixer::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])
+{
+	// The first card is the master timer, so wait for it to have a new frame.
+	unique_lock<mutex> lock(bmusb_mutex);
+	cards[master_card_index].new_frames_changed.wait(lock, [this, master_card_index]{ return !cards[master_card_index].new_frames.empty(); });
+
+	for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
+		CaptureCard *card = &cards[card_index];
+		if (card->new_frames.empty()) {
+			assert(card_index != master_card_index);
+			card->queue_length_policy.update_policy(-1);
+			continue;
+		}
+		new_frames[card_index] = move(card->new_frames.front());
+		has_new_frame[card_index] = true;
+		card->new_frames.pop();
+		card->new_frames_changed.notify_all();
+
+		int num_samples_times_timebase = OUTPUT_FREQUENCY * new_frames[card_index].length + card->fractional_samples;
+		num_samples[card_index] = num_samples_times_timebase / TIMEBASE;
+		card->fractional_samples = num_samples_times_timebase % TIMEBASE;
+		assert(num_samples[card_index] >= 0);
+
+		if (card_index == master_card_index) {
+			// We don't use the queue length policy for the master card,
+			// but we will if it stops being the master. Thus, clear out
+			// the policy in case we switch in the future.
+			card->queue_length_policy.reset(card_index);
+		} else {
+			// If we have excess frames compared to the policy for this card,
+			// drop frames from the head.
+			card->queue_length_policy.update_policy(card->new_frames.size());
+			while (card->new_frames.size() > card->queue_length_policy.get_safe_queue_length()) {
+				card->new_frames.pop();
+			}
+		}
+	}
+}
+
+void Mixer::schedule_audio_resampling_tasks(unsigned dropped_frames, int num_samples_per_frame, int length_per_frame)
+{
+	// Resample the audio as needed, including from previously dropped frames.
+	assert(num_cards > 0);
+	for (unsigned frame_num = 0; frame_num < dropped_frames + 1; ++frame_num) {
+		{
+			// Signal to the audio thread to process this frame.
+			unique_lock<mutex> lock(audio_mutex);
+			audio_task_queue.push(AudioTask{pts_int, num_samples_per_frame});
+			audio_task_queue_changed.notify_one();
+		}
+		if (frame_num != dropped_frames) {
+			// For dropped frames, increase the pts. Note that if the format changed
+			// in the meantime, we have no way of detecting that; we just have to
+			// assume the frame length is always the same.
+			pts_int += length_per_frame;
+		}
+	}
+}
+
+void Mixer::render_one_frame(int64_t duration)
+{
+	// Get the main chain from the theme, and set its state immediately.
+	Theme::Chain theme_main_chain = theme->get_chain(0, pts(), WIDTH, HEIGHT, input_state);
+	EffectChain *chain = theme_main_chain.chain;
+	theme_main_chain.setup_chain();
+	//theme_main_chain.chain->enable_phase_timing(true);
+
+	GLuint y_tex, cbcr_tex;
+	bool got_frame = video_encoder->begin_frame(&y_tex, &cbcr_tex);
+	assert(got_frame);
+
+	// Render main chain.
+	GLuint cbcr_full_tex = resource_pool->create_2d_texture(GL_RG8, WIDTH, HEIGHT);
+	GLuint rgba_tex = resource_pool->create_2d_texture(GL_RGB565, WIDTH, HEIGHT);  // Saves texture bandwidth, although dithering gets messed up.
+	GLuint fbo = resource_pool->create_fbo(y_tex, cbcr_full_tex, rgba_tex);
+	check_error();
+	chain->render_to_fbo(fbo, WIDTH, HEIGHT);
+	resource_pool->release_fbo(fbo);
+
+	subsample_chroma(cbcr_full_tex, cbcr_tex);
+	resource_pool->release_2d_texture(cbcr_full_tex);
+
+	// Set the right state for rgba_tex.
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glBindTexture(GL_TEXTURE_2D, rgba_tex);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+	const int64_t av_delay = TIMEBASE / 10;  // Corresponds to the fixed delay in resampling_queue.h. TODO: Make less hard-coded.
+	RefCountedGLsync fence = video_encoder->end_frame(pts_int + av_delay, duration, theme_main_chain.input_frames);
+
+	// The live frame just shows the RGBA texture we just rendered.
+	// It owns rgba_tex now.
+	DisplayFrame live_frame;
+	live_frame.chain = display_chain.get();
+	live_frame.setup_chain = [this, rgba_tex]{
+		display_input->set_texture_num(rgba_tex);
+	};
+	live_frame.ready_fence = fence;
+	live_frame.input_frames = {};
+	live_frame.temp_textures = { rgba_tex };
+	output_channel[OUTPUT_LIVE].output_frame(live_frame);
+
+	// Set up preview and any additional channels.
+	for (int i = 1; i < theme->get_num_channels() + 2; ++i) {
+		DisplayFrame display_frame;
+		Theme::Chain chain = theme->get_chain(i, pts(), WIDTH, HEIGHT, input_state);  // FIXME: dimensions
+		display_frame.chain = chain.chain;
+		display_frame.setup_chain = chain.setup_chain;
+		display_frame.ready_fence = fence;
+		display_frame.input_frames = chain.input_frames;
+		display_frame.temp_textures = {};
+		output_channel[i].output_frame(display_frame);
+	}
+}
+
+void Mixer::send_audio_level_callback()
+{
+	if (audio_level_callback == nullptr) {
+		return;
+	}
+
+	unique_lock<mutex> lock(compressor_mutex);
+	double loudness_s = r128.loudness_S();
+	double loudness_i = r128.integrated();
+	double loudness_range_low = r128.range_min();
+	double loudness_range_high = r128.range_max();
+
+	audio_level_callback(loudness_s, 20.0 * log10(peak),
+		loudness_i, loudness_range_low, loudness_range_high,
+		gain_staging_db, 20.0 * log10(final_makeup_gain),
+		correlation.get_correlation());
+}
+
 void Mixer::audio_thread_func()
 {
 	while (!should_quit) {
@@ -953,7 +997,7 @@ void Mixer::process_audio_one_frame(int64_t frame_pts_int, int num_samples)
 	}
 
 	// And finally add them to the output.
-	h264_encoder->add_audio(frame_pts_int, move(samples_out));
+	video_encoder->add_audio(frame_pts_int, move(samples_out));
 }
 
 void Mixer::subsample_chroma(GLuint src_tex, GLuint dst_tex)
@@ -1097,9 +1141,47 @@ void Mixer::OutputChannel::output_frame(DisplayFrame frame)
 		has_ready_frame = true;
 	}
 
-	if (has_new_frame_ready_callback) {
+	if (new_frame_ready_callback) {
 		new_frame_ready_callback();
 	}
+
+	// Reduce the number of callbacks by filtering duplicates. The reason
+	// why we bother doing this is that Qt seemingly can get into a state
+	// where its builds up an essentially unbounded queue of signals,
+	// consuming more and more memory, and there's no good way of collapsing
+	// user-defined signals or limiting the length of the queue.
+	if (transition_names_updated_callback) {
+		vector<string> transition_names = global_mixer->get_transition_names();
+		bool changed = false;
+		if (transition_names.size() != last_transition_names.size()) {
+			changed = true;
+		} else {
+			for (unsigned i = 0; i < transition_names.size(); ++i) {
+				if (transition_names[i] != last_transition_names[i]) {
+					changed = true;
+					break;
+				}
+			}
+		}
+		if (changed) {
+			transition_names_updated_callback(transition_names);
+			last_transition_names = transition_names;
+		}
+	}
+	if (name_updated_callback) {
+		string name = global_mixer->get_channel_name(channel);
+		if (name != last_name) {
+			name_updated_callback(name);
+			last_name = name;
+		}
+	}
+	if (color_updated_callback) {
+		string color = global_mixer->get_channel_color(channel);
+		if (color != last_color) {
+			color_updated_callback(color);
+			last_color = color;
+		}
+	}
 }
 
 bool Mixer::OutputChannel::get_display_frame(DisplayFrame *frame)
@@ -1130,5 +1212,21 @@ bool Mixer::OutputChannel::get_display_frame(DisplayFrame *frame)
 void Mixer::OutputChannel::set_frame_ready_callback(Mixer::new_frame_ready_callback_t callback)
 {
 	new_frame_ready_callback = callback;
-	has_new_frame_ready_callback = true;
 }
+
+void Mixer::OutputChannel::set_transition_names_updated_callback(Mixer::transition_names_updated_callback_t callback)
+{
+	transition_names_updated_callback = callback;
+}
+
+void Mixer::OutputChannel::set_name_updated_callback(Mixer::name_updated_callback_t callback)
+{
+	name_updated_callback = callback;
+}
+
+void Mixer::OutputChannel::set_color_updated_callback(Mixer::color_updated_callback_t callback)
+{
+	color_updated_callback = callback;
+}
+
+mutex RefCountedGLsync::fence_lock;