X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mixer.cpp;h=b00c4af0ef1a52d03ee2e6cdb453384209acb85a;hb=ba2dc655c098912b8860676596fe89c1305affe9;hp=a5ceeaf052b66edb95966446c3d5741ce925fb14;hpb=471db5155f58c3bf7a98c446575cfa0c483da765;p=nageru

diff --git a/mixer.cpp b/mixer.cpp
index a5ceeaf..b00c4af 100644
--- a/mixer.cpp
+++ b/mixer.cpp
@@ -78,10 +78,10 @@ void insert_new_frame(RefCountedFrame frame, unsigned field_num, bool interlaced
 	}
 }
 
-void ensure_texture_resolution(PBOFrameAllocator::Userdata *userdata, unsigned field, unsigned width, unsigned height)
+void ensure_texture_resolution(PBOFrameAllocator::Userdata *userdata, unsigned field, unsigned width, unsigned height, unsigned v210_width)
 {
 	bool first;
-	if (global_flags.ten_bit_input) {
+	if (userdata->pixel_format == bmusb::PixelFormat_10BitYCbCr) {
 		first = userdata->tex_v210[field] == 0 || userdata->tex_444[field] == 0;
 	} else {
 		first = userdata->tex_y[field] == 0 || userdata->tex_cbcr[field] == 0;
@@ -93,13 +93,7 @@ void ensure_texture_resolution(PBOFrameAllocator::Userdata *userdata, unsigned f
 		// 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.
-		if (global_flags.ten_bit_input) {
-			const size_t v210_width = v210Converter::get_minimum_v210_texture_width(width);
-
-			glBindTexture(GL_TEXTURE_2D, userdata->tex_v210[field]);
-			check_error();
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB10_A2, v210_width, height, 0, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, nullptr);
-			check_error();
+		if (userdata->pixel_format == bmusb::PixelFormat_10BitYCbCr) {
 			glBindTexture(GL_TEXTURE_2D, userdata->tex_444[field]);
 			check_error();
 			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB10_A2, width, height, 0, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, nullptr);
@@ -119,6 +113,15 @@ void ensure_texture_resolution(PBOFrameAllocator::Userdata *userdata, unsigned f
 		userdata->last_width[field] = width;
 		userdata->last_height[field] = height;
 	}
+	if (global_flags.ten_bit_input &&
+	    (first || v210_width != userdata->last_v210_width[field])) {
+		// Same as above; we need to recreate the texture.
+		glBindTexture(GL_TEXTURE_2D, userdata->tex_v210[field]);
+		check_error();
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB10_A2, v210_width, height, 0, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, nullptr);
+		check_error();
+		userdata->last_v210_width[field] = v210_width;
+	}
 }
 
 void upload_texture(GLuint tex, GLuint width, GLuint height, GLuint stride, bool interlaced_stride, GLenum format, GLenum type, GLintptr offset)
@@ -163,17 +166,13 @@ void QueueLengthPolicy::update_policy(unsigned queue_length)
 		been_at_safe_point_since_last_starvation = false;
 		return;
 	}
-	if (queue_length >= 1) {
-		if (queue_length >= safe_queue_length) {
-			been_at_safe_point_since_last_starvation = true;
-		}
-		if (++frames_with_at_least_one >= 1000 && safe_queue_length > 1) {
-			--safe_queue_length;
-			fprintf(stderr, "Card %u: Spare frames for more than 1000 frames, reducing safe limit to %u frame(s)\n",
-				card_index, safe_queue_length);
-			frames_with_at_least_one = 0;
-		}
-	} else {
+	if (queue_length >= safe_queue_length) {
+		been_at_safe_point_since_last_starvation = true;
+	}
+	if (++frames_with_at_least_one >= 1000 && safe_queue_length > 1) {
+		--safe_queue_length;
+		fprintf(stderr, "Card %u: Spare frames for more than 1000 frames, reducing safe limit to %u frame(s)\n",
+			card_index, safe_queue_length);
 		frames_with_at_least_one = 0;
 	}
 }
@@ -194,7 +193,6 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 	movit_texel_subpixel_precision /= 2.0;
 
 	resource_pool.reset(new ResourcePool);
-	theme.reset(new Theme(global_flags.theme_filename, global_flags.theme_dirs, resource_pool.get(), num_cards));
 	for (unsigned i = 0; i < NUM_OUTPUTS; ++i) {
 		output_channel[i].parent = this;
 		output_channel[i].channel = i;
@@ -204,10 +202,27 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 	inout_format.color_space = COLORSPACE_sRGB;
 	inout_format.gamma_curve = GAMMA_sRGB;
 
-	// Display chain; shows the live output produced by the main chain (its RGBA version).
+	// Matches the 4:2:0 format created by the main chain.
+	YCbCrFormat ycbcr_format;
+	ycbcr_format.chroma_subsampling_x = 2;
+	ycbcr_format.chroma_subsampling_y = 2;
+	if (global_flags.ycbcr_rec709_coefficients) {
+		ycbcr_format.luma_coefficients = YCBCR_REC_709;
+	} else {
+		ycbcr_format.luma_coefficients = YCBCR_REC_601;
+	}
+	ycbcr_format.full_range = false;
+	ycbcr_format.num_levels = 1 << global_flags.x264_bit_depth;
+	ycbcr_format.cb_x_position = 0.0f;
+	ycbcr_format.cr_x_position = 0.0f;
+	ycbcr_format.cb_y_position = 0.5f;
+	ycbcr_format.cr_y_position = 0.5f;
+
+	// Display chain; shows the live output produced by the main chain (or rather, a copy of it).
 	display_chain.reset(new EffectChain(global_flags.width, global_flags.height, resource_pool.get()));
 	check_error();
-	display_input = new FlatInput(inout_format, FORMAT_RGB, GL_UNSIGNED_BYTE, global_flags.width, global_flags.height);  // FIXME: GL_UNSIGNED_BYTE is really wrong.
+	GLenum type = global_flags.x264_bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE;
+	display_input = new YCbCrInput(inout_format, ycbcr_format, global_flags.width, global_flags.height, YCBCR_INPUT_SPLIT_Y_AND_CBCR, type);
 	display_chain->add_input(display_input);
 	display_chain->add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED);
 	display_chain->set_dither_bits(0);  // Don't bother.
@@ -215,6 +230,9 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 
 	video_encoder.reset(new VideoEncoder(resource_pool.get(), h264_encoder_surface, global_flags.va_display, global_flags.width, global_flags.height, &httpd, global_disk_space_estimator));
 
+	// Must be instantiated after VideoEncoder has initialized global_flags.use_zerocopy.
+	theme.reset(new Theme(global_flags.theme_filename, global_flags.theme_dirs, resource_pool.get(), num_cards));
+
 	// Start listening for clients only once VideoEncoder has written its header, if any.
 	httpd.start(9095);
 
@@ -289,6 +307,13 @@ Mixer::Mixer(const QSurfaceFormat &format, unsigned num_cards)
 		v210_converter->precompile_shader(3840);
 		v210_converter->precompile_shader(4096);
 	}
+	if (global_flags.ten_bit_output) {
+		if (!v210Converter::has_hardware_support()) {
+			fprintf(stderr, "ERROR: --ten-bit-output requires support for OpenGL compute shaders\n");
+			fprintf(stderr, "       (OpenGL 4.3, or GL_ARB_compute_shader + GL_ARB_shader_image_load_store).\n");
+			exit(1);
+		}
+	}
 
 	timecode_renderer.reset(new TimecodeRenderer(resource_pool.get(), global_flags.width, global_flags.height));
 	display_timecode_in_stream = global_flags.display_timecode_in_stream;
@@ -336,9 +361,12 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, bool
 	if (card->output.get() != output) {
 		card->output.reset(output);
 	}
+
+	bmusb::PixelFormat pixel_format = global_flags.ten_bit_input ? PixelFormat_10BitYCbCr : PixelFormat_8BitYCbCr;
+
 	card->capture->set_frame_callback(bind(&Mixer::bm_frame, this, card_index, _1, _2, _3, _4, _5, _6, _7));
 	if (card->frame_allocator == nullptr) {
-		card->frame_allocator.reset(new PBOFrameAllocator(8 << 20, global_flags.width, global_flags.height));  // 8 MB.
+		card->frame_allocator.reset(new PBOFrameAllocator(pixel_format, 8 << 20, global_flags.width, global_flags.height));  // 8 MB.
 	}
 	card->capture->set_video_frame_allocator(card->frame_allocator.get());
 	if (card->surface == nullptr) {
@@ -346,7 +374,7 @@ void Mixer::configure_card(unsigned card_index, CaptureInterface *capture, bool
 	}
 	while (!card->new_frames.empty()) card->new_frames.pop_front();
 	card->last_timecode = -1;
-	card->capture->set_pixel_format(global_flags.ten_bit_input ? PixelFormat_10BitYCbCr : PixelFormat_8BitYCbCr);
+	card->capture->set_pixel_format(pixel_format);
 	card->capture->configure_card();
 
 	// NOTE: start_bm_capture() happens in thread_func().
@@ -563,14 +591,16 @@ void Mixer::bm_frame(unsigned card_index, uint16_t timecode,
 				field_start_line = video_format.extra_lines_top;
 			}
 
-			ensure_texture_resolution(userdata, field, video_format.width, video_format.height);
+			// For 8-bit input, v210_width will be nonsensical but not used.
+			size_t v210_width = video_format.stride / sizeof(uint32_t);
+			ensure_texture_resolution(userdata, field, video_format.width, video_format.height, v210_width);
 
 			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, userdata->pbo);
 			check_error();
 
-			if (global_flags.ten_bit_input) {
+			if (userdata->pixel_format == bmusb::PixelFormat_10BitYCbCr) {
 				size_t field_start = video_offset + video_format.stride * field_start_line;
-				upload_texture(userdata->tex_v210[field], video_format.stride / sizeof(uint32_t), video_format.height, video_format.stride, interlaced_stride, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, field_start);
+				upload_texture(userdata->tex_v210[field], v210_width, video_format.height, video_format.stride, interlaced_stride, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, field_start);
 				v210_converter->convert(userdata->tex_v210[field], userdata->tex_444[field], video_format.width, video_format.height);
 			} else {
 				size_t field_y_start = y_offset + video_format.width * field_start_line;
@@ -827,10 +857,12 @@ void Mixer::trim_queue(CaptureCard *card, unsigned card_index)
 		++dropped_frames;
 	}
 
+#if 0
 	if (dropped_frames > 0) {
 		fprintf(stderr, "Card %u dropped %u frame(s) to keep latency down.\n",
 			card_index, dropped_frames);
 	}
+#endif
 }
 
 
@@ -995,14 +1027,65 @@ void Mixer::render_one_frame(int64_t duration)
 	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);
+	// If HDMI/SDI output is active and the user has requested auto mode,
+	// its mode overrides the existing Y'CbCr setting for the chain.
+	YCbCrLumaCoefficients ycbcr_output_coefficients;
+	if (global_flags.ycbcr_auto_coefficients && output_card_index != -1) {
+		ycbcr_output_coefficients = cards[output_card_index].output->preferred_ycbcr_coefficients();
+	} else {
+		ycbcr_output_coefficients = global_flags.ycbcr_rec709_coefficients ? YCBCR_REC_709 : YCBCR_REC_601;
+	}
+
+	// TODO: Reduce the duplication against theme.cpp.
+	YCbCrFormat output_ycbcr_format;
+	output_ycbcr_format.chroma_subsampling_x = 1;
+	output_ycbcr_format.chroma_subsampling_y = 1;
+	output_ycbcr_format.luma_coefficients = ycbcr_output_coefficients;
+	output_ycbcr_format.full_range = false;
+	output_ycbcr_format.num_levels = 1 << global_flags.x264_bit_depth;
+	chain->change_ycbcr_output_format(output_ycbcr_format);
+
+	// Render main chain. If we're using zerocopy Quick Sync encoding
+	// (the default case), we take an extra copy of the created outputs,
+	// so that we can display it back to the screen later (it's less memory
+	// bandwidth than writing and reading back an RGBA texture, even at 16-bit).
+	// Ideally, we'd like to avoid taking copies and just use the main textures
+	// for display as well, but they're just views into VA-API memory and must be
+	// unmapped during encoding, so we can't use them for display, unfortunately.
+	GLuint y_tex, cbcr_full_tex, cbcr_tex;
+	GLuint y_copy_tex, cbcr_copy_tex = 0;
+	GLuint y_display_tex, cbcr_display_tex;
+	GLenum y_type = (global_flags.x264_bit_depth > 8) ? GL_R16 : GL_R8;
+	GLenum cbcr_type = (global_flags.x264_bit_depth > 8) ? GL_RG16 : GL_RG8;
+	const bool is_zerocopy = video_encoder->is_zerocopy();
+	if (is_zerocopy) {
+		cbcr_full_tex = resource_pool->create_2d_texture(cbcr_type, global_flags.width, global_flags.height);
+		y_copy_tex = resource_pool->create_2d_texture(y_type, global_flags.width, global_flags.height);
+		cbcr_copy_tex = resource_pool->create_2d_texture(cbcr_type, global_flags.width / 2, global_flags.height / 2);
+
+		y_display_tex = y_copy_tex;
+		cbcr_display_tex = cbcr_copy_tex;
+
+		// y_tex and cbcr_tex will be given by VideoEncoder.
+	} else {
+		cbcr_full_tex = resource_pool->create_2d_texture(cbcr_type, global_flags.width, global_flags.height);
+		y_tex = resource_pool->create_2d_texture(y_type, global_flags.width, global_flags.height);
+		cbcr_tex = resource_pool->create_2d_texture(cbcr_type, global_flags.width / 2, global_flags.height / 2);
+
+		y_display_tex = y_tex;
+		cbcr_display_tex = cbcr_tex;
+	}
+
+	const int64_t av_delay = lrint(global_flags.audio_queue_length_ms * 0.001 * TIMEBASE);  // Corresponds to the delay in ResamplingQueue.
+	bool got_frame = video_encoder->begin_frame(pts_int + av_delay, duration, ycbcr_output_coefficients, theme_main_chain.input_frames, &y_tex, &cbcr_tex);
 	assert(got_frame);
 
-	// Render main chain.
-	GLuint cbcr_full_tex = resource_pool->create_2d_texture(GL_RG8, global_flags.width, global_flags.height);
-	GLuint rgba_tex = resource_pool->create_2d_texture(GL_RGB565, global_flags.width, global_flags.height);  // Saves texture bandwidth, although dithering gets messed up.
-	GLuint fbo = resource_pool->create_fbo(y_tex, cbcr_full_tex, rgba_tex);
+	GLuint fbo;
+	if (is_zerocopy) {
+		fbo = resource_pool->create_fbo(y_tex, cbcr_full_tex, y_copy_tex);
+	} else {
+		fbo = resource_pool->create_fbo(y_tex, cbcr_full_tex);
+	}
 	check_error();
 	chain->render_to_fbo(fbo, global_flags.width, global_flags.height);
 
@@ -1013,32 +1096,41 @@ void Mixer::render_one_frame(int64_t duration)
 
 	resource_pool->release_fbo(fbo);
 
-	chroma_subsampler->subsample_chroma(cbcr_full_tex, global_flags.width, global_flags.height, cbcr_tex);
+	if (is_zerocopy) {
+		chroma_subsampler->subsample_chroma(cbcr_full_tex, global_flags.width, global_flags.height, cbcr_tex, cbcr_copy_tex);
+	} else {
+		chroma_subsampler->subsample_chroma(cbcr_full_tex, global_flags.width, global_flags.height, cbcr_tex);
+	}
 	if (output_card_index != -1) {
-		cards[output_card_index].output->send_frame(y_tex, cbcr_full_tex, theme_main_chain.input_frames, pts_int, duration);
+		cards[output_card_index].output->send_frame(y_tex, cbcr_full_tex, ycbcr_output_coefficients, theme_main_chain.input_frames, pts_int, duration);
 	}
 	resource_pool->release_2d_texture(cbcr_full_tex);
 
-	// Set the right state for rgba_tex.
+	// Set the right state for the Y' and CbCr textures we use for display.
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	glBindTexture(GL_TEXTURE_2D, rgba_tex);
+	glBindTexture(GL_TEXTURE_2D, y_display_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 = lrint(global_flags.audio_queue_length_ms * 0.001 * TIMEBASE);  // Corresponds to the delay in ResamplingQueue.
-	RefCountedGLsync fence = video_encoder->end_frame(pts_int + av_delay, duration, theme_main_chain.input_frames);
+	glBindTexture(GL_TEXTURE_2D, cbcr_display_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 = video_encoder->end_frame();
 
-	// The live frame just shows the RGBA texture we just rendered.
-	// It owns rgba_tex now.
+	// The live frame pieces the Y'CbCr texture copies back into RGB and displays them.
+	// It owns y_display_tex and cbcr_display_tex now (whichever textures they are).
 	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.setup_chain = [this, y_display_tex, cbcr_display_tex]{
+		display_input->set_texture_num(0, y_display_tex);
+		display_input->set_texture_num(1, cbcr_display_tex);
 	};
 	live_frame.ready_fence = fence;
 	live_frame.input_frames = {};
-	live_frame.temp_textures = { rgba_tex };
+	live_frame.temp_textures = { y_display_tex, cbcr_display_tex };
 	output_channel[OUTPUT_LIVE].output_frame(live_frame);
 
 	// Set up preview and any additional channels.