git.sesse.net Git - nageru/blob - nageru/x264_speed_control.cpp

   1 #include "x264_speed_control.h"
   2
   3 #include <dlfcn.h>
   4 #include <math.h>
   5 #include <stdio.h>
   6 #include <stdint.h>
   7 #include <x264.h>
   8 #include <algorithm>
   9 #include <chrono>
  10 #include <cmath>
  11
  12 #include "flags.h"
  13 #include "shared/metrics.h"
  14 #include "x264_dynamic.h"
  15
  16 using namespace std;
  17 using namespace std::chrono;
  18
  19 #define SC_PRESETS 23
  20
  21 X264SpeedControl::X264SpeedControl(x264_t *x264, float f_speed, int i_buffer_size, float f_buffer_init)
  22         : dyn(load_x264_for_bit_depth(global_flags.bit_depth)),
  23           x264(x264), f_speed(f_speed)
  24 {
  25         x264_param_t param;
  26         dyn.x264_encoder_parameters(x264, &param);
  27
  28         float fps = (float)param.i_fps_num / param.i_fps_den;
  29         uspf = 1e6 / fps;
  30         set_buffer_size(i_buffer_size);
  31         buffer_fill = buffer_size * f_buffer_init;
  32         buffer_fill = max<int64_t>(buffer_fill, uspf);
  33         buffer_fill = min(buffer_fill, buffer_size);
  34         timestamp = steady_clock::now();
  35         preset = -1;
  36         cplx_num = 3e3; //FIXME estimate initial complexity
  37         cplx_den = .1;
  38         stat.min_buffer = buffer_size;
  39         stat.max_buffer = 0;
  40         stat.avg_preset = 0.0;
  41         stat.den = 0;
  42
  43         metric_x264_speedcontrol_buffer_available_seconds = buffer_fill * 1e-6;
  44         metric_x264_speedcontrol_buffer_size_seconds = buffer_size * 1e-6;
  45         metric_x264_speedcontrol_preset_used_frames.init_uniform(SC_PRESETS);
  46         global_metrics.add("x264_speedcontrol_preset_used_frames", &metric_x264_speedcontrol_preset_used_frames);
  47         global_metrics.add("x264_speedcontrol_buffer_available_seconds", &metric_x264_speedcontrol_buffer_available_seconds, Metrics::TYPE_GAUGE);
  48         global_metrics.add("x264_speedcontrol_buffer_size_seconds", &metric_x264_speedcontrol_buffer_size_seconds, Metrics::TYPE_GAUGE);
  49         global_metrics.add("x264_speedcontrol_idle_frames", &metric_x264_speedcontrol_idle_frames);
  50         global_metrics.add("x264_speedcontrol_late_frames", &metric_x264_speedcontrol_late_frames);
  51 }
  52
  53 X264SpeedControl::~X264SpeedControl()
  54 {
  55         fprintf(stderr, "speedcontrol: avg preset=%.3f  buffer min=%.3f max=%.3f\n",
  56                 stat.avg_preset / stat.den,
  57                 (float)stat.min_buffer / buffer_size,
  58                 (float)stat.max_buffer / buffer_size );
  59         //  x264_log( x264, X264_LOG_INFO, "speedcontrol: avg cplx=%.5f\n", cplx_num / cplx_den );
  60         if (dyn.handle) {
  61                 dlclose(dyn.handle);
  62         }
  63 }
  64
  65 typedef struct
  66 {
  67         float time; // relative encoding time, compared to the other presets
  68         int subme;
  69         int me;
  70         int refs;
  71         int mix;
  72         int trellis;
  73         int partitions;
  74         int direct;
  75         int merange;
  76 } sc_preset_t;
  77
  78 // The actual presets, including the equivalent commandline options. Note that
  79 // all presets are benchmarked with --weightp 1 --mbtree --rc-lookahead 20
  80 // --b-adapt 1 --bframes 3 on top of the given settings (equivalent settings to
  81 // the "faster" preset). Timings and SSIM measurements were done on a four cores
  82 // of a 6-core Coffee Lake i5 2.8 GHz on the first 1000 frames of “Elephants
  83 // Dream” in 1080p. See experiments/measure-x264.pl for a way to reproduce.
  84 //
  85 // Note that the two first and the two last are also used for extrapolation
  86 // should the desired time be outside the range. Thus, it is disadvantageous if
  87 // they are chosen so that the timings are too close to each other.
  88 static const sc_preset_t presets[SC_PRESETS] = {
  89 #define I4 X264_ANALYSE_I4x4
  90 #define I8 X264_ANALYSE_I8x8
  91 #define P4 X264_ANALYSE_PSUB8x8
  92 #define P8 X264_ANALYSE_PSUB16x16
  93 #define B8 X264_ANALYSE_BSUB16x16
  94
  95         // Preset 0: 17.386db, --preset superfast
  96         { .time= 1.000, .subme=1, .me=X264_ME_DIA, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4, .direct=1, .merange=16 },
  97
  98         // Preset 1: 17.919db, --preset superfast --subme 2
  99         { .time= 1.707, .subme=2, .me=X264_ME_DIA, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4, .direct=1, .merange=16 },
 100
 101         // Preset 2: 18.051db, --preset veryfast
 102         { .time= 1.832, .subme=2, .me=X264_ME_HEX, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 103
 104         // Preset 3: 18.422db, --preset veryfast --subme 3
 105         { .time= 1.853, .subme=3, .me=X264_ME_HEX, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 106
 107         // Preset 4: 18.514db, --preset veryfast --subme 3 --ref 2
 108         { .time= 1.925, .subme=3, .me=X264_ME_HEX, .refs=2, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 109
 110         // Preset 5: 18.564db, --preset veryfast --subme 4 --ref 2
 111         { .time= 2.111, .subme=4, .me=X264_ME_HEX, .refs=2, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 112
 113         // Preset 6: 18.411db, --preset faster
 114         { .time= 2.240, .subme=4, .me=X264_ME_HEX, .refs=2, .mix=0, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 115
 116         // Preset 7: 18.429db, --preset faster --mixed-refs
 117         { .time= 2.414, .subme=4, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 118
 119         // Preset 8: 18.454db, --preset faster --mixed-refs --subme 5
 120         { .time= 2.888, .subme=5, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 121
 122         // Preset 9: 18.528db, --preset fast
 123         { .time= 3.570, .subme=6, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 124
 125         // Preset 10: 18.762db, --preset fast --subme 7
 126         { .time= 3.698, .subme=7, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 127
 128         // Preset 11: 18.819db, --preset medium
 129         { .time= 4.174, .subme=7, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 130
 131         // Preset 12: 18.889db, --preset medium --subme 8
 132         { .time= 5.155, .subme=8, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 133
 134         // Preset 13: 19.127db, --preset medium --subme 8 --trellis 2
 135         { .time= 7.237, .subme=8, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=1, .merange=16 },
 136
 137         // Preset 14: 19.118db, --preset medium --subme 8 --trellis 2 --direct auto
 138         { .time= 7.240, .subme=8, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=3, .merange=16 },
 139
 140         // Preset 15: 19.172db, --preset slow
 141         { .time= 7.910, .subme=8, .me=X264_ME_HEX, .refs=5, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=3, .merange=16 },
 142
 143         // Preset 16: 19.208db, --preset slow --subme 9
 144         { .time= 8.091, .subme=9, .me=X264_ME_HEX, .refs=5, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=3, .merange=16 },
 145
 146         // Preset 17: 19.216db, --preset slow --subme 9 --me umh
 147         { .time= 9.539, .subme=9, .me=X264_ME_UMH, .refs=5, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=3, .merange=16 },
 148
 149         // Preset 18: 19.253db, --preset slow --subme 9 --me umh --ref 6
 150         { .time=10.521, .subme=9, .me=X264_ME_UMH, .refs=6, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=3, .merange=16 },
 151
 152         // Preset 19: 19.275db, --preset slow --subme 9 --me umh --ref 7
 153         { .time=11.461, .subme=9, .me=X264_ME_UMH, .refs=7, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .direct=3, .merange=16 },
 154
 155         // Preset 20: 19.314db, --preset slower
 156         { .time=13.145, .subme=9, .me=X264_ME_UMH, .refs=8, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .direct=3, .merange=16 },
 157
 158         // Preset 21: 19.407db, --preset slower --subme 10
 159         { .time=16.386, .subme=10, .me=X264_ME_UMH, .refs=8, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .direct=3, .merange=16 },
 160
 161         // Preset 22: 19.483db, --preset veryslow
 162         { .time=26.861, .subme=10, .me=X264_ME_UMH, .refs=16, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .direct=3, .merange=24 },
 163
 164 #undef I4
 165 #undef I8
 166 #undef P4
 167 #undef P8
 168 #undef B8
 169 };
 170
 171 void X264SpeedControl::before_frame(float new_buffer_fill, int new_buffer_size, float new_uspf)
 172 {
 173         if (new_uspf > 0.0) {
 174                 uspf = new_uspf;
 175         }
 176         if (new_buffer_size) {
 177                 set_buffer_size(new_buffer_size);
 178         }
 179         buffer_fill = buffer_size * new_buffer_fill;
 180         metric_x264_speedcontrol_buffer_available_seconds = buffer_fill * 1e-6;
 181
 182         steady_clock::time_point t;
 183
 184         // update buffer state after encoding and outputting the previous frame(s)
 185         if (first) {
 186                 t = timestamp = steady_clock::now();
 187                 first = false;
 188         } else {
 189                 t = steady_clock::now();
 190         }
 191
 192         auto delta_t = t - timestamp;
 193         timestamp = t;
 194
 195         // update the time predictor
 196         if (preset >= 0) {
 197                 int cpu_time = duration_cast<microseconds>(cpu_time_last_frame).count();
 198                 cplx_num *= cplx_decay;
 199                 cplx_den *= cplx_decay;
 200                 cplx_num += cpu_time / presets[preset].time;
 201                 ++cplx_den;
 202
 203                 stat.avg_preset += preset;
 204                 ++stat.den;
 205         }
 206
 207         stat.min_buffer = min(buffer_fill, stat.min_buffer);
 208         stat.max_buffer = max(buffer_fill, stat.max_buffer);
 209
 210         if (buffer_fill >= buffer_size) { // oops, cpu was idle
 211                 buffer_fill = buffer_size;
 212                 metric_x264_speedcontrol_buffer_available_seconds = buffer_fill * 1e-6;
 213                 ++metric_x264_speedcontrol_idle_frames;
 214         } else if (buffer_fill <= 0) {  // oops, we're late
 215                 // fprintf(stderr, "speedcontrol underflow (%.6f sec)\n", buffer_fill/1e6);
 216                 ++metric_x264_speedcontrol_late_frames;
 217         }
 218
 219         {
 220                 // Pick the preset that should return the buffer to 3/4-full within a time
 221                 // specified by compensation_period.
 222                 //
 223                 // NOTE: This doesn't actually do that, at least assuming the same target is
 224                 // chosen for every frame; exactly what it does is unclear to me. It seems
 225                 // to consistently undershoot a bit, so it needs to be saved by the second
 226                 // predictor below. However, fixing the formula seems to yield somewhat less
 227                 // stable results in practice; in particular, once the buffer is half-full
 228                 // or so, it would give us a negative target. Perhaps increasing
 229                 // compensation_period would be a good idea, but initial (very brief) tests
 230                 // did not yield good results.
 231                 float target = uspf / f_speed
 232                         * (buffer_fill + compensation_period)
 233                         / (buffer_size*3/4 + compensation_period);
 234                 float cplx = cplx_num / cplx_den;
 235                 float set, t0, t1;
 236                 float filled = (float) buffer_fill / buffer_size;
 237                 int i;
 238                 t0 = presets[0].time * cplx;
 239                 for (i = 1; ; i++) {
 240                         t1 = presets[i].time * cplx;
 241                         if (t1 >= target || i == SC_PRESETS - 1)
 242                                 break;
 243                         t0 = t1;
 244                 }
 245                 // exponential interpolation between states
 246                 set = i-1 + (log(target) - log(t0)) / (log(t1) - log(t0));
 247                 set = max<float>(set, -5);
 248                 set = min<float>(set, (SC_PRESETS-1) + 5);
 249                 // Even if our time estimations in the SC_PRESETS array are off
 250                 // this will push us towards our target fullness
 251                 float s1 = set;
 252                 set += (40 * (filled-0.75));
 253                 float s2 = (40 * (filled-0.75));
 254                 set = min<float>(max<float>(set, 0), SC_PRESETS - 1);
 255                 apply_preset(dither_preset(set));
 256
 257                 if (global_flags.x264_speedcontrol_verbose) {
 258                         static float cpu, wall, tgt, den;
 259                         const float decay = 1-1/100.;
 260                         cpu = cpu*decay + duration_cast<microseconds>(cpu_time_last_frame).count();
 261                         wall = wall*decay + duration_cast<microseconds>(delta_t).count();
 262                         tgt = tgt*decay + target;
 263                         den = den*decay + 1;
 264                         fprintf(stderr, "speed: %.2f+%.2f %d[%.5f] (t/c/w: %6.0f/%6.0f/%6.0f = %.4f) fps=%.2f\r",
 265                                         s1, s2, preset, (float)buffer_fill / buffer_size,
 266                                         tgt/den, cpu/den, wall/den, cpu/wall, 1e6*den/wall );
 267                 }
 268         }
 269
 270 }
 271
 272 void X264SpeedControl::after_frame()
 273 {
 274         cpu_time_last_frame = steady_clock::now() - timestamp;
 275 }
 276
 277 void X264SpeedControl::set_buffer_size(int new_buffer_size)
 278 {
 279         new_buffer_size = max(3, new_buffer_size);
 280         buffer_size = new_buffer_size * uspf;
 281         cplx_decay = 1 - 1./new_buffer_size;
 282         compensation_period = buffer_size/4;
 283         metric_x264_speedcontrol_buffer_size_seconds = buffer_size * 1e-6;
 284 }
 285
 286 int X264SpeedControl::dither_preset(float f)
 287 {
 288         int i = f;
 289         if (f < 0) {
 290                 i--;
 291         }
 292         dither += f - i;
 293         if (dither >= 1.0) {
 294                 dither--;
 295                 i++;
 296         }
 297         return i;
 298 }
 299
 300 void X264SpeedControl::apply_preset(int new_preset)
 301 {
 302         new_preset = max(new_preset, 0);
 303         new_preset = min(new_preset, SC_PRESETS - 1);
 304
 305         const sc_preset_t *s = &presets[new_preset];
 306         x264_param_t p;
 307         dyn.x264_encoder_parameters(x264, &p);
 308
 309         p.i_frame_reference = s->refs;
 310         p.analyse.inter = s->partitions;
 311         p.analyse.i_subpel_refine = s->subme;
 312         p.analyse.i_me_method = s->me;
 313         p.analyse.i_trellis = s->trellis;
 314         p.analyse.b_mixed_references = s->mix;
 315         p.analyse.i_direct_mv_pred = s->direct;
 316         p.analyse.i_me_range = s->merange;
 317         if (override_func) {
 318                 override_func(&p);
 319         }
 320         dyn.x264_encoder_reconfig(x264, &p);
 321         preset = new_preset;
 322
 323         metric_x264_speedcontrol_preset_used_frames.count_event(new_preset);
 324 }