Write 1.4.0 changelog.

[nageru] / x264_encoder.cpp

diff --git a/x264_encoder.cpp b/x264_encoder.cpp
index 8ee486734a9dc72b239298db5b587f9b01b62800..f339e8c8b27e09e7b7f059d3d6d1108daccfd37d 100644 (file)
--- a/x264_encoder.cpp
+++ b/x264_encoder.cpp
@@ -1,19 +1,43 @@
+#include "x264_encoder.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 "timebase.h"
-#include "x264_encoder.h"
 #include "x264_speed_control.h"
 
 extern "C" {
+#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 }
 
 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,16 +107,7 @@ 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
@@ -100,7 +115,7 @@ void X264Encoder::init_x264()
                // content; the obvious and extreme example being a static
                // black picture.
                //
-               // One would think it's fine to have low-complexity codec use
+               // 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,
@@ -125,7 +140,21 @@ void X264Encoder::init_x264()
        // 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");
 
@@ -160,7 +189,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;
@@ -220,6 +252,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);
        }