Add a flag to output Y'CbCr using Rec. 709 coefficients.

[nageru] / x264_encoder.cpp

diff --git a/x264_encoder.cpp b/x264_encoder.cpp
index f339e8c8b27e09e7b7f059d3d6d1108daccfd37d..f9b562443869211c8020731c94d9fe0701fd15a0 100644 (file)
--- a/x264_encoder.cpp
+++ b/x264_encoder.cpp
@@ -1,5 +1,6 @@
 #include "x264_encoder.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -10,6 +11,7 @@
 #include "defs.h"
 #include "flags.h"
 #include "mux.h"
+#include "print_latency.h"
 #include "timebase.h"
 #include "x264_speed_control.h"
 
@@ -19,6 +21,7 @@ extern "C" {
 }
 
 using namespace std;
+using namespace std::chrono;
 
 namespace {
 
@@ -41,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);
 }
@@ -55,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);
@@ -72,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);
@@ -86,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;
@@ -97,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;
@@ -194,6 +201,7 @@ void X264Encoder::encoder_thread_func()
                // No exit; it's not fatal.
        }
        init_x264();
+       x264_init_done = true;
 
        bool frames_left;
 
@@ -244,12 +252,14 @@ 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.
@@ -277,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();