Fix an issue where the mixer lagging too much behind CEF would cause us to display...

[nageru] / x264_encoder.cpp

diff --git a/x264_encoder.cpp b/x264_encoder.cpp
index dbdef5b1a215e61936eae6d37e78ae47e2591288..ccf6942e1813ef7aa4748b45b531d108dd06d64f 100644 (file)
--- a/x264_encoder.cpp
+++ b/x264_encoder.cpp
@@ -7,10 +7,14 @@
 #include <string.h>
 #include <unistd.h>
 #include <x264.h>
+#include <atomic>
 #include <cstdint>
+#include <functional>
+#include <mutex>
 
 #include "defs.h"
 #include "flags.h"
+#include "metrics.h"
 #include "mux.h"
 #include "print_latency.h"
 #include "timebase.h"
@@ -25,9 +29,22 @@ extern "C" {
 using namespace movit;
 using namespace std;
 using namespace std::chrono;
+using namespace std::placeholders;
 
 namespace {
 
+// X264Encoder can be restarted if --record-x264-video is set, so make these
+// metrics global.
+atomic<int64_t> metric_x264_queued_frames{0};
+atomic<int64_t> metric_x264_max_queued_frames{X264_QUEUE_LENGTH};
+atomic<int64_t> metric_x264_dropped_frames{0};
+atomic<int64_t> metric_x264_output_frames_i{0};
+atomic<int64_t> metric_x264_output_frames_p{0};
+atomic<int64_t> metric_x264_output_frames_b{0};
+Histogram metric_x264_crf;
+LatencyHistogram x264_latency_histogram;
+once_flag x264_metrics_inited;
+
 void update_vbv_settings(x264_param_t *param)
 {
        if (global_flags.x264_bitrate == -1) {
@@ -51,6 +68,19 @@ X264Encoder::X264Encoder(AVOutputFormat *oformat)
        : wants_global_headers(oformat->flags & AVFMT_GLOBALHEADER),
          dyn(load_x264_for_bit_depth(global_flags.x264_bit_depth))
 {
+       call_once(x264_metrics_inited, [](){
+               global_metrics.add("x264_queued_frames", &metric_x264_queued_frames, Metrics::TYPE_GAUGE);
+               global_metrics.add("x264_max_queued_frames", &metric_x264_max_queued_frames, Metrics::TYPE_GAUGE);
+               global_metrics.add("x264_dropped_frames", &metric_x264_dropped_frames);
+               global_metrics.add("x264_output_frames", {{ "type", "i" }}, &metric_x264_output_frames_i);
+               global_metrics.add("x264_output_frames", {{ "type", "p" }}, &metric_x264_output_frames_p);
+               global_metrics.add("x264_output_frames", {{ "type", "b" }}, &metric_x264_output_frames_b);
+
+               metric_x264_crf.init_uniform(50);
+               global_metrics.add("x264_crf", &metric_x264_crf);
+               x264_latency_histogram.init("x264");
+       });
+
        size_t bytes_per_pixel = global_flags.x264_bit_depth > 8 ? 2 : 1;
        frame_pool.reset(new uint8_t[global_flags.width * global_flags.height * 2 * bytes_per_pixel * X264_QUEUE_LENGTH]);
        for (unsigned i = 0; i < X264_QUEUE_LENGTH; ++i) {
@@ -83,6 +113,7 @@ void X264Encoder::add_frame(int64_t pts, int64_t duration, YCbCrLumaCoefficients
                lock_guard<mutex> lock(mu);
                if (free_frames.empty()) {
                        fprintf(stderr, "WARNING: x264 queue full, dropping frame with pts %ld\n", pts);
+                       ++metric_x264_dropped_frames;
                        return;
                }
 
@@ -97,6 +128,7 @@ void X264Encoder::add_frame(int64_t pts, int64_t duration, YCbCrLumaCoefficients
                lock_guard<mutex> lock(mu);
                queued_frames.push(qf);
                queued_frames_nonempty.notify_all();
+               metric_x264_queued_frames = queued_frames.size();
        }
 }
        
@@ -123,7 +155,7 @@ void X264Encoder::init_x264()
        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_transfer = 13;  // sRGB.
        if (global_flags.ycbcr_rec709_coefficients) {
                param.vui.i_colmatrix = 1;  // BT.709.
        } else {
@@ -227,6 +259,7 @@ void X264Encoder::encoder_thread_func()
                perror("nice()");
                // No exit; it's not fatal.
        }
+       pthread_setname_np(pthread_self(), "x264_encode");
        init_x264();
        x264_init_done = true;
 
@@ -248,6 +281,7 @@ void X264Encoder::encoder_thread_func()
                                qf.data = nullptr;
                        }
 
+                       metric_x264_queued_frames = queued_frames.size();
                        frames_left = !queued_frames.empty();
                }
 
@@ -298,38 +332,13 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
                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) {
-               bitrate_override_func = [new_rate](x264_param_t *param) {
-                       param->rc.i_bitrate = new_rate;
-                       update_vbv_settings(param);
-               };
-       }
-
-       auto ycbcr_coefficients_override_func = [qf](x264_param_t *param) {
-               if (qf.ycbcr_coefficients == YCBCR_REC_709) {
-                       param->vui.i_colmatrix = 1;  // BT.709.
-               } else {
-                       assert(qf.ycbcr_coefficients == YCBCR_REC_601);
-                       param->vui.i_colmatrix = 6;  // BT.601/SMPTE 170M.
-               }
-       };
-
+       unsigned new_rate = new_bitrate_kbit.load();  // Can be 0 for no change.
        if (speed_control) {
-               speed_control->set_config_override_function([this, ycbcr_coefficients_override_func](x264_param_t *param) {
-                       if (bitrate_override_func) {
-                               bitrate_override_func(param);
-                       }
-                       ycbcr_coefficients_override_func(param);
-               });
+               speed_control->set_config_override_function(bind(&speed_control_override_func, new_rate, qf.ycbcr_coefficients, _1));
        } else {
                x264_param_t param;
                dyn.x264_encoder_parameters(x264, &param);
-               if (bitrate_override_func) {
-                       bitrate_override_func(&param);
-               }
-               ycbcr_coefficients_override_func(&param);
+               speed_control_override_func(new_rate, qf.ycbcr_coefficients, &param);
                dyn.x264_encoder_reconfig(x264, &param);
        }
 
@@ -343,6 +352,16 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
 
        if (num_nal == 0) return;
 
+       if (IS_X264_TYPE_I(pic.i_type)) {
+               ++metric_x264_output_frames_i;
+       } else if (IS_X264_TYPE_B(pic.i_type)) {
+               ++metric_x264_output_frames_b;
+       } else {
+               ++metric_x264_output_frames_p;
+       }
+
+       metric_x264_crf.count_event(pic.prop.f_crf_avg);
+
        if (frames_being_encoded.count(pic.i_pts)) {
                ReceivedTimestamps received_ts = frames_being_encoded[pic.i_pts];
                frames_being_encoded.erase(pic.i_pts);
@@ -350,7 +369,7 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
                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);
+                       &frameno, &x264_latency_histogram);
        } else {
                assert(false);
        }
@@ -392,3 +411,18 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
                mux->add_packet(pkt, pic.i_pts, pic.i_dts);
        }
 }
+
+void X264Encoder::speed_control_override_func(unsigned bitrate_kbit, movit::YCbCrLumaCoefficients ycbcr_coefficients, x264_param_t *param)
+{
+       if (bitrate_kbit != 0) {
+               param->rc.i_bitrate = bitrate_kbit;
+               update_vbv_settings(param);
+       }
+
+       if (ycbcr_coefficients == YCBCR_REC_709) {
+               param->vui.i_colmatrix = 1;  // BT.709.
+       } else {
+               assert(ycbcr_coefficients == YCBCR_REC_601);
+               param->vui.i_colmatrix = 6;  // BT.601/SMPTE 170M.
+       }
+}