Update the queue length metric after trimming, not before.

[nageru] / x264_encoder.cpp

diff --git a/x264_encoder.cpp b/x264_encoder.cpp
index c8f7b81279f2cf9e5c4a57dc3fe969a978cf4b0f..955491e75656815be1d7f82d387d75d8cea1a4a9 100644 (file)
--- a/x264_encoder.cpp
+++ b/x264_encoder.cpp
@@ -11,6 +11,7 @@
 
 #include "defs.h"
 #include "flags.h"
+#include "metrics.h"
 #include "mux.h"
 #include "print_latency.h"
 #include "timebase.h"
@@ -30,6 +31,9 @@ namespace {
 
 void update_vbv_settings(x264_param_t *param)
 {
+       if (global_flags.x264_bitrate == -1) {
+               return;
+       }
        if (global_flags.x264_vbv_buffer_size < 0) {
                param->rc.i_vbv_buffer_size = param->rc.i_bitrate;  // One-second VBV.
        } else {
@@ -48,11 +52,24 @@ X264Encoder::X264Encoder(AVOutputFormat *oformat)
        : wants_global_headers(oformat->flags & AVFMT_GLOBALHEADER),
          dyn(load_x264_for_bit_depth(global_flags.x264_bit_depth))
 {
-       frame_pool.reset(new uint8_t[global_flags.width * global_flags.height * 2 * X264_QUEUE_LENGTH]);
+       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) {
-               free_frames.push(frame_pool.get() + i * (global_flags.width * global_flags.height * 2));
+               free_frames.push(frame_pool.get() + i * (global_flags.width * global_flags.height * 2 * bytes_per_pixel));
        }
        encoder_thread = thread(&X264Encoder::encoder_thread_func, this);
+
+       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);
+
+       latency_histogram.init("x264");
 }
 
 X264Encoder::~X264Encoder()
@@ -79,6 +96,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;
                }
 
@@ -86,12 +104,14 @@ void X264Encoder::add_frame(int64_t pts, int64_t duration, YCbCrLumaCoefficients
                free_frames.pop();
        }
 
-       memcpy(qf.data, data, global_flags.width * global_flags.height * 2);
+       size_t bytes_per_pixel = global_flags.x264_bit_depth > 8 ? 2 : 1;
+       memcpy(qf.data, data, global_flags.width * global_flags.height * 2 * bytes_per_pixel);
 
        {
                lock_guard<mutex> lock(mu);
                queued_frames.push(qf);
                queued_frames_nonempty.notify_all();
+               metric_x264_queued_frames = queued_frames.size();
        }
 }
        
@@ -103,6 +123,9 @@ void X264Encoder::init_x264()
        param.i_width = global_flags.width;
        param.i_height = global_flags.height;
        param.i_csp = X264_CSP_NV12;
+       if (global_flags.x264_bit_depth > 8) {
+               param.i_csp |= X264_CSP_HIGH_DEPTH;
+       }
        param.b_vfr_input = 1;
        param.i_timebase_num = 1;
        param.i_timebase_den = TIMEBASE;
@@ -122,8 +145,13 @@ void X264Encoder::init_x264()
                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;
+       if (!isinf(global_flags.x264_crf)) {
+               param.rc.i_rc_method = X264_RC_CRF;
+               param.rc.f_rf_constant = global_flags.x264_crf;
+       } else {
+               param.rc.i_rc_method = X264_RC_ABR;
+               param.rc.i_bitrate = global_flags.x264_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
@@ -214,6 +242,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;
 
@@ -235,6 +264,7 @@ void X264Encoder::encoder_thread_func()
                                qf.data = nullptr;
                        }
 
+                       metric_x264_queued_frames = queued_frames.size();
                        frames_left = !queued_frames.empty();
                }
 
@@ -263,12 +293,21 @@ void X264Encoder::encode_frame(X264Encoder::QueuedFrame qf)
                dyn.x264_picture_init(&pic);
 
                pic.i_pts = qf.pts;
-               pic.img.i_csp = X264_CSP_NV12;
-               pic.img.i_plane = 2;
-               pic.img.plane[0] = qf.data;
-               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);
+               if (global_flags.x264_bit_depth > 8) {
+                       pic.img.i_csp = X264_CSP_NV12 | X264_CSP_HIGH_DEPTH;
+                       pic.img.i_plane = 2;
+                       pic.img.plane[0] = qf.data;
+                       pic.img.i_stride[0] = global_flags.width * sizeof(uint16_t);
+                       pic.img.plane[1] = qf.data + global_flags.width * global_flags.height * sizeof(uint16_t);
+                       pic.img.i_stride[1] = global_flags.width / 2 * sizeof(uint32_t);
+               } else {
+                       pic.img.i_csp = X264_CSP_NV12;
+                       pic.img.i_plane = 2;
+                       pic.img.plane[0] = qf.data;
+                       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;
@@ -321,6 +360,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);
@@ -328,7 +377,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, &latency_histogram);
        } else {
                assert(false);
        }