X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=x264_encoder.cpp;h=f9b562443869211c8020731c94d9fe0701fd15a0;hb=d7257bb375432fe87f082876be995742f4891aa4;hp=756d673bfb40b2adc6588992e3b78c2fd3b14d3f;hpb=b85c1986b7ea63534899e2eb589f9e0888d5ccda;p=nageru

diff --git a/x264_encoder.cpp b/x264_encoder.cpp
index 756d673..f9b5624 100644
--- a/x264_encoder.cpp
+++ b/x264_encoder.cpp
@@ -1,18 +1,27 @@
+#include "x264_encoder.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <x264.h>
+#include <cstdint>
 
 #include "defs.h"
 #include "flags.h"
 #include "mux.h"
+#include "print_latency.h"
 #include "timebase.h"
-#include "x264_encoder.h"
 #include "x264_speed_control.h"
 
 extern "C" {
+#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 }
 
 using namespace std;
+using namespace std::chrono;
 
 namespace {
 
@@ -35,9 +44,9 @@ void update_vbv_settings(x264_param_t *param)
 X264Encoder::X264Encoder(AVOutputFormat *oformat)
 	: wants_global_headers(oformat->flags & AVFMT_GLOBALHEADER)
 {
-	frame_pool.reset(new uint8_t[WIDTH * HEIGHT * 2 * X264_QUEUE_LENGTH]);
+	frame_pool.reset(new uint8_t[global_flags.width * global_flags.height * 2 * X264_QUEUE_LENGTH]);
 	for (unsigned i = 0; i < X264_QUEUE_LENGTH; ++i) {
-		free_frames.push(frame_pool.get() + i * (WIDTH * HEIGHT * 2));
+		free_frames.push(frame_pool.get() + i * (global_flags.width * global_flags.height * 2));
 	}
 	encoder_thread = thread(&X264Encoder::encoder_thread_func, this);
 }
@@ -49,11 +58,12 @@ X264Encoder::~X264Encoder()
 	encoder_thread.join();
 }
 
-void X264Encoder::add_frame(int64_t pts, int64_t duration, const uint8_t *data)
+void X264Encoder::add_frame(int64_t pts, int64_t duration, const uint8_t *data, const ReceivedTimestamps &received_ts)
 {
 	QueuedFrame qf;
 	qf.pts = pts;
 	qf.duration = duration;
+	qf.received_ts = received_ts;
 
 	{
 		lock_guard<mutex> lock(mu);
@@ -66,7 +76,7 @@ void X264Encoder::add_frame(int64_t pts, int64_t duration, const uint8_t *data)
 		free_frames.pop();
 	}
 
-	memcpy(qf.data, data, WIDTH * HEIGHT * 2);
+	memcpy(qf.data, data, global_flags.width * global_flags.height * 2);
 
 	{
 		lock_guard<mutex> lock(mu);
@@ -80,8 +90,8 @@ void X264Encoder::init_x264()
 	x264_param_t param;
 	x264_param_default_preset(&param, global_flags.x264_preset.c_str(), global_flags.x264_tune.c_str());
 
-	param.i_width = WIDTH;
-	param.i_height = HEIGHT;
+	param.i_width = global_flags.width;
+	param.i_height = global_flags.height;
 	param.i_csp = X264_CSP_NV12;
 	param.b_vfr_input = 1;
 	param.i_timebase_num = 1;
@@ -91,13 +101,16 @@ void X264Encoder::init_x264()
 		param.i_frame_reference = 16;  // Because speedcontrol is never allowed to change this above what we set at start.
 	}
 
-	// NOTE: These should be in sync with the ones in h264encode.cpp (sbs_rbsp()).
+	// NOTE: These should be in sync with the ones in quicksync_encoder.cpp (sps_rbsp()).
 	param.vui.i_vidformat = 5;  // Unspecified.
 	param.vui.b_fullrange = 0;
 	param.vui.i_colorprim = 1;  // BT.709.
 	param.vui.i_transfer = 2;  // Unspecified (since we use sRGB).
-	param.vui.i_colmatrix = 6;  // BT.601/SMPTE 170M.
-
+	if (global_flags.ycbcr_rec709_coefficients) {
+		param.vui.i_colmatrix = 1;  // BT.709.
+	} else {
+		param.vui.i_colmatrix = 6;  // BT.601/SMPTE 170M.
+	}
 
 	param.rc.i_rc_method = X264_RC_ABR;
 	param.rc.i_bitrate = global_flags.x264_bitrate;
@@ -183,8 +196,12 @@ 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();
+	x264_init_done = true;
 
 	bool frames_left;
 
@@ -235,23 +252,31 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
 		pic.img.i_csp = X264_CSP_NV12;
 		pic.img.i_plane = 2;
 		pic.img.plane[0] = qf.data;
-		pic.img.i_stride[0] = WIDTH;
-		pic.img.plane[1] = qf.data + WIDTH * HEIGHT;
-		pic.img.i_stride[1] = WIDTH / 2 * sizeof(uint16_t);
+		pic.img.i_stride[0] = global_flags.width;
+		pic.img.plane[1] = qf.data + global_flags.width * global_flags.height;
+		pic.img.i_stride[1] = global_flags.width / 2 * sizeof(uint16_t);
 		pic.opaque = reinterpret_cast<void *>(intptr_t(qf.duration));
 
 		input_pic = &pic;
+
+		frames_being_encoded[qf.pts] = qf.received_ts;
 	}
 
 	// 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) {
-		x264_param_t param;
-		x264_encoder_parameters(x264, &param);
-		param.rc.i_bitrate = new_rate;
-		update_vbv_settings(&param);
-		x264_encoder_reconfig(x264, &param);
-		printf("changing rate to %u\n", new_rate);
+		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) {
@@ -262,6 +287,20 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
 		speed_control->after_frame();
 	}
 
+	if (num_nal == 0) return;
+
+	if (frames_being_encoded.count(pic.i_pts)) {
+		ReceivedTimestamps received_ts = frames_being_encoded[pic.i_pts];
+		frames_being_encoded.erase(pic.i_pts);
+
+		static int frameno = 0;
+		print_latency("Current x264 latency (video inputs → network mux):",
+			received_ts, (pic.i_type == X264_TYPE_B || pic.i_type == X264_TYPE_BREF),
+			&frameno);
+	} else {
+		assert(false);
+	}
+
 	// We really need one AVPacket for the entire frame, it seems,
 	// so combine it all.
 	size_t num_bytes = buffered_sei.size();