X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=x264_encoder.cpp;h=9874519362aadf8a3059eb77f2e797243d230459;hb=c93433b2669d3447f8c2e1dfcae0d491b2d3a4dc;hp=d2a0cb91fb77a76e236c792e67c32936ba6d3c84;hpb=d21f8ae61b559a98970f65516db5a2dae8ad3972;p=nageru

diff --git a/x264_encoder.cpp b/x264_encoder.cpp
index d2a0cb9..9874519 100644
--- a/x264_encoder.cpp
+++ b/x264_encoder.cpp
@@ -14,6 +14,24 @@ extern "C" {
 
 using namespace std;
 
+namespace {
+
+void update_vbv_settings(x264_param_t *param)
+{
+	if (global_flags.x264_vbv_buffer_size < 0) {
+		param->rc.i_vbv_buffer_size = param->rc.i_bitrate;  // One-second VBV.
+	} else {
+		param->rc.i_vbv_buffer_size = global_flags.x264_vbv_buffer_size;
+	}
+	if (global_flags.x264_vbv_max_bitrate < 0) {
+		param->rc.i_vbv_max_bitrate = param->rc.i_bitrate;  // CBR.
+	} else {
+		param->rc.i_vbv_max_bitrate = global_flags.x264_vbv_max_bitrate;
+	}
+}
+
+}  // namespace
+
 X264Encoder::X264Encoder(AVOutputFormat *oformat)
 	: wants_global_headers(oformat->flags & AVFMT_GLOBALHEADER)
 {
@@ -83,22 +101,54 @@ void X264Encoder::init_x264()
 
 	param.rc.i_rc_method = X264_RC_ABR;
 	param.rc.i_bitrate = global_flags.x264_bitrate;
-	if (global_flags.x264_vbv_buffer_size < 0) {
-		param.rc.i_vbv_buffer_size = param.rc.i_bitrate;  // One-second VBV.
-	} else {
-		param.rc.i_vbv_buffer_size = global_flags.x264_vbv_buffer_size;
-	}
-	if (global_flags.x264_vbv_max_bitrate < 0) {
-		param.rc.i_vbv_max_bitrate = param.rc.i_bitrate;  // CBR.
-	} else {
-		param.rc.i_vbv_max_bitrate = global_flags.x264_vbv_max_bitrate;
+	update_vbv_settings(&param);
+	if (param.rc.i_vbv_max_bitrate > 0) {
+		// If the user wants VBV control to cap the max rate, it is
+		// also reasonable to assume that they are fine with the stream
+		// constantly being around that rate even for very low-complexity
+		// content; the obvious and extreme example being a static
+		// black picture.
+		//
+		// One would think it's fine to have low-complexity content use
+		// less bitrate, but it seems to cause problems in practice;
+		// e.g. VLC seems to often drop the stream (similar to a buffer
+		// underrun) in such cases, but only when streaming from Nageru,
+		// not when reading a dump of the same stream from disk.
+		// I'm not 100% sure whether it's in VLC (possibly some buffering
+		// in the HTTP layer), in microhttpd or somewhere in Nageru itself,
+		// but it's a typical case of problems that can arise. Similarly,
+		// TCP's congestion control is not always fond of the rate staying
+		// low for a while and then rising quickly -- a variation on the same
+		// problem.
+		//
+		// We solve this by simply asking x264 to fill in dummy bits
+		// in these cases, so that the bitrate stays reasonable constant.
+		// It's a waste of bandwidth, but it makes things go much more
+		// smoothly in these cases. (We don't do it if VBV control is off
+		// in general, not the least because it makes no sense and x264
+		// thus ignores the parameter.)
+		param.rc.b_filler = 1;
 	}
 
 	// Occasionally players have problem with extremely low quantizers;
 	// be on the safe side. Shouldn't affect quality in any meaningful way.
 	param.rc.i_qp_min = 5;
 
-	// TODO: more flags here, via x264_param_parse().
+	for (const string &str : global_flags.x264_extra_param) {
+		const size_t pos = str.find(',');
+		if (pos == string::npos) {
+			if (x264_param_parse(&param, str.c_str(), nullptr) != 0) {
+				fprintf(stderr, "ERROR: x264 rejected parameter '%s'\n", str.c_str());
+			}
+		} else {
+			const string key = str.substr(0, pos);
+			const string value = str.substr(pos + 1);
+			if (x264_param_parse(&param, key.c_str(), value.c_str()) != 0) {
+				fprintf(stderr, "ERROR: x264 rejected parameter '%s' set to '%s'\n",
+					key.c_str(), value.c_str());
+			}
+		}
+	}
 
 	x264_param_apply_profile(&param, "high");
 
@@ -133,7 +183,10 @@ void X264Encoder::init_x264()
 
 void X264Encoder::encoder_thread_func()
 {
-	nice(5);  // Note that x264 further nices some of its threads.
+	if (nice(5) == -1) {  // Note that x264 further nices some of its threads.
+		perror("nice()");
+		// No exit; it's not fatal.
+	}
 	init_x264();
 
 	bool frames_left;
@@ -193,6 +246,23 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
 		input_pic = &pic;
 	}
 
+	// See if we have a new bitrate to change to.
+	unsigned new_rate = new_bitrate_kbit.exchange(0);  // Read and clear.
+	if (new_rate != 0) {
+		if (speed_control) {
+			speed_control->set_config_override_function([new_rate](x264_param_t *param) {
+				param->rc.i_bitrate = new_rate;
+				update_vbv_settings(param);
+			});
+		} else {
+			x264_param_t param;
+			x264_encoder_parameters(x264, &param);
+			param.rc.i_bitrate = new_rate;
+			update_vbv_settings(&param);
+			x264_encoder_reconfig(x264, &param);
+		}
+	}
+
 	if (speed_control) {
 		speed_control->before_frame(float(free_frames.size()) / X264_QUEUE_LENGTH, X264_QUEUE_LENGTH, 1e6 * qf.duration / TIMEBASE);
 	}