git.sesse.net Git - nageru/blob - 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 <x264.h>
   7 #include <algorithm>
   8 #include <chrono>
   9 #include <cmath>
  10 #include <ratio>
  11 #include <type_traits>
  12
  13 #include "flags.h"
  14
  15 using namespace std;
  16 using namespace std::chrono;
  17
  18 X264SpeedControl::X264SpeedControl(x264_t *x264, float f_speed, int i_buffer_size, float f_buffer_init)
  19         : dyn(load_x264_for_bit_depth(global_flags.x264_bit_depth)),
  20           x264(x264), f_speed(f_speed)
  21 {
  22         x264_param_t param;
  23         dyn.x264_encoder_parameters(x264, &param);
  24
  25         float fps = (float)param.i_fps_num / param.i_fps_den;
  26         uspf = 1e6 / fps;
  27         set_buffer_size(i_buffer_size);
  28         buffer_fill = buffer_size * f_buffer_init;
  29         buffer_fill = max<int64_t>(buffer_fill, uspf);
  30         buffer_fill = min(buffer_fill, buffer_size);
  31         timestamp = steady_clock::now();
  32         preset = -1;
  33         cplx_num = 3e3; //FIXME estimate initial complexity
  34         cplx_den = .1;
  35         stat.min_buffer = buffer_size;
  36         stat.max_buffer = 0;
  37         stat.avg_preset = 0.0;
  38         stat.den = 0;
  39 }
  40
  41 X264SpeedControl::~X264SpeedControl()
  42 {
  43         fprintf(stderr, "speedcontrol: avg preset=%.3f  buffer min=%.3f max=%.3f\n",
  44                 stat.avg_preset / stat.den,
  45                 (float)stat.min_buffer / buffer_size,
  46                 (float)stat.max_buffer / buffer_size );
  47         //  x264_log( x264, X264_LOG_INFO, "speedcontrol: avg cplx=%.5f\n", cplx_num / cplx_den );
  48         if (dyn.handle) {
  49                 dlclose(dyn.handle);
  50         }
  51 }
  52
  53 typedef struct
  54 {
  55         float time; // relative encoding time, compared to the other presets
  56         int subme;
  57         int me;
  58         int refs;
  59         int mix;
  60         int trellis;
  61         int partitions;
  62         int badapt;
  63         int bframes;
  64         int direct;
  65         int merange;
  66 } sc_preset_t;
  67
  68 // The actual presets, including the equivalent commandline options. Note that
  69 // all presets are benchmarked with --weightp 1 --mbtree --rc-lookahead 20
  70 // on top of the given settings (equivalent settings to the "faster" preset).
  71 // Timings and SSIM measurements were done on a quadcore Haswell i5 3.2 GHz
  72 // on the first 1000 frames of "Tears of Steel" in 1080p.
  73 //
  74 // Note that the two first and the two last are also used for extrapolation
  75 // should the desired time be outside the range. Thus, it is disadvantageous if
  76 // they are chosen so that the timings are too close to each other.
  77 #define SC_PRESETS 26
  78 static const sc_preset_t presets[SC_PRESETS] = {
  79 #define I4 X264_ANALYSE_I4x4
  80 #define I8 X264_ANALYSE_I8x8
  81 #define P4 X264_ANALYSE_PSUB8x8
  82 #define P8 X264_ANALYSE_PSUB16x16
  83 #define B8 X264_ANALYSE_BSUB16x16
  84         // Preset 0: 14.179db, --preset superfast --b-adapt 0 --bframes 0
  85         { .time= 1.000, .subme=1, .me=X264_ME_DIA, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4, .badapt=0, .bframes=0, .direct=0, .merange=16 },
  86
  87         // Preset 1: 14.459db, --preset superfast
  88         { .time= 1.283, .subme=1, .me=X264_ME_DIA, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4, .badapt=1, .bframes=3, .direct=1, .merange=16 },
  89
  90         // Preset 2: 14.761db, --preset superfast --subme 2
  91         { .time= 1.603, .subme=2, .me=X264_ME_DIA, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4, .badapt=1, .bframes=3, .direct=1, .merange=16 },
  92
  93         // Preset 3: 15.543db, --preset veryfast
  94         { .time= 1.843, .subme=2, .me=X264_ME_HEX, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
  95
  96         // Preset 4: 15.716db, --preset veryfast --subme 3
  97         { .time= 2.452, .subme=3, .me=X264_ME_HEX, .refs=1, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
  98
  99         // Preset 5: 15.786db, --preset veryfast --subme 3 --ref 2
 100         { .time= 2.733, .subme=3, .me=X264_ME_HEX, .refs=2, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 101
 102         // Preset 6: 15.813db, --preset veryfast --subme 4 --ref 2
 103         { .time= 3.085, .subme=4, .me=X264_ME_HEX, .refs=2, .mix=0, .trellis=0, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 104
 105         // Preset 7: 15.849db, --preset faster
 106         { .time= 3.101, .subme=4, .me=X264_ME_HEX, .refs=2, .mix=0, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 107
 108         // Preset 8: 15.857db, --preset faster --mixed-refs
 109         { .time= 3.284, .subme=4, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 110
 111         // Preset 9: 15.869db, --preset faster --mixed-refs --subme 5
 112         { .time= 3.587, .subme=5, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 113
 114         // Preset 10: 16.051db, --preset fast
 115         { .time= 3.947, .subme=6, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 116
 117         // Preset 11: 16.356db, --preset fast --subme 7
 118         { .time= 4.041, .subme=7, .me=X264_ME_HEX, .refs=2, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 119
 120         // Preset 12: 16.418db, --preset fast --subme 7 --ref 3
 121         { .time= 4.406, .subme=7, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 122
 123         // Preset 13: 16.460db, --preset medium
 124         { .time= 4.707, .subme=7, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 125
 126         // Preset 14: 16.517db, --preset medium --subme 8
 127         { .time= 5.133, .subme=8, .me=X264_ME_HEX, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 128
 129         // Preset 15: 16.523db, --preset medium --subme 8 --me umh
 130         { .time= 6.050, .subme=8, .me=X264_ME_UMH, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=1, .bframes=3, .direct=1, .merange=16 },
 131
 132         // Preset 16: 16.543db, --preset medium --subme 8 --me umh --direct auto --b-adapt 2
 133         { .time= 6.849, .subme=8, .me=X264_ME_UMH, .refs=3, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 134
 135         // Preset 17: 16.613db, --preset slow
 136         { .time= 8.042, .subme=8, .me=X264_ME_UMH, .refs=5, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 137
 138         // Preset 18: 16.641db, --preset slow --subme 9
 139         { .time= 8.972, .subme=9, .me=X264_ME_UMH, .refs=5, .mix=1, .trellis=1, .partitions=I8|I4|P8|B8, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 140
 141         // Preset 19: 16.895db, --preset slow --subme 9 --trellis 2
 142         { .time=10.073, .subme=9, .me=X264_ME_UMH, .refs=5, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 143
 144         // Preset 20: 16.918db, --preset slow --subme 9 --trellis 2 --ref 6
 145         { .time=11.147, .subme=9, .me=X264_ME_UMH, .refs=6, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 146
 147         // Preset 21: 16.934db, --preset slow --subme 9 --trellis 2 --ref 7
 148         { .time=12.267, .subme=9, .me=X264_ME_UMH, .refs=7, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 149
 150         // Preset 22: 16.948db, --preset slower
 151         { .time=13.829, .subme=9, .me=X264_ME_UMH, .refs=8, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 152
 153         // Preset 23: 17.058db, --preset slower --subme 10
 154         { .time=14.831, .subme=10, .me=X264_ME_UMH, .refs=8, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .badapt=2, .bframes=3, .direct=3, .merange=16 },
 155
 156         // Preset 24: 17.268db, --preset slower --subme 10 --bframes 8
 157         { .time=18.705, .subme=10, .me=X264_ME_UMH, .refs=8, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .badapt=2, .bframes=8, .direct=3, .merange=16 },
 158
 159         // Preset 25: 17.297db, --preset veryslow
 160         { .time=31.419, .subme=10, .me=X264_ME_UMH, .refs=16, .mix=1, .trellis=2, .partitions=I8|I4|P8|B8|P4, .badapt=2, .bframes=8, .direct=3, .merange=24 },
 161 #undef I4
 162 #undef I8
 163 #undef P4
 164 #undef P8
 165 #undef B8
 166 };
 167
 168 void X264SpeedControl::before_frame(float new_buffer_fill, int new_buffer_size, float new_uspf)
 169 {
 170         if (new_uspf > 0.0) {
 171                 uspf = new_uspf;
 172         }
 173         if (new_buffer_size) {
 174                 set_buffer_size(new_buffer_size);
 175         }
 176         buffer_fill = buffer_size * new_buffer_fill;
 177
 178         steady_clock::time_point t;
 179
 180         // update buffer state after encoding and outputting the previous frame(s)
 181         if (first) {
 182                 t = timestamp = steady_clock::now();
 183                 first = false;
 184         } else {
 185                 t = steady_clock::now();
 186         }
 187
 188         auto delta_t = t - timestamp;
 189         timestamp = t;
 190
 191         // update the time predictor
 192         if (preset >= 0) {
 193                 int cpu_time = duration_cast<microseconds>(cpu_time_last_frame).count();
 194                 cplx_num *= cplx_decay;
 195                 cplx_den *= cplx_decay;
 196                 cplx_num += cpu_time / presets[preset].time;
 197                 ++cplx_den;
 198
 199                 stat.avg_preset += preset;
 200                 ++stat.den;
 201         }
 202
 203         stat.min_buffer = min(buffer_fill, stat.min_buffer);
 204         stat.max_buffer = max(buffer_fill, stat.max_buffer);
 205
 206         if (buffer_fill >= buffer_size) { // oops, cpu was idle
 207                 // not really an error, but we'll warn for debugging purposes
 208                 static int64_t idle_t = 0;
 209                 static steady_clock::time_point print_interval;
 210                 static bool first = false;
 211                 idle_t += buffer_fill - buffer_size;
 212                 if (first || duration<double>(t - print_interval).count() > 0.1) {
 213                         //fprintf(stderr, "speedcontrol idle (%.6f sec)\n", idle_t/1e6);
 214                         print_interval = t;
 215                         idle_t = 0;
 216                         first = false;
 217                 }
 218                 buffer_fill = buffer_size;
 219         } else if (buffer_fill <= 0) {  // oops, we're late
 220                 // fprintf(stderr, "speedcontrol underflow (%.6f sec)\n", buffer_fill/1e6);
 221         }
 222
 223         {
 224                 // Pick the preset that should return the buffer to 3/4-full within a time
 225                 // specified by compensation_period.
 226                 //
 227                 // NOTE: This doesn't actually do that, at least assuming the same target is
 228                 // chosen for every frame; exactly what it does is unclear to me. It seems
 229                 // to consistently undershoot a bit, so it needs to be saved by the second
 230                 // predictor below. However, fixing the formula seems to yield somewhat less
 231                 // stable results in practice; in particular, once the buffer is half-full
 232                 // or so, it would give us a negative target. Perhaps increasing
 233                 // compensation_period would be a good idea, but initial (very brief) tests
 234                 // did not yield good results.
 235                 float target = uspf / f_speed
 236                         * (buffer_fill + compensation_period)
 237                         / (buffer_size*3/4 + compensation_period);
 238                 float cplx = cplx_num / cplx_den;
 239                 float set, t0, t1;
 240                 float filled = (float) buffer_fill / buffer_size;
 241                 int i;
 242                 t0 = presets[0].time * cplx;
 243                 for (i = 1; ; i++) {
 244                         t1 = presets[i].time * cplx;
 245                         if (t1 >= target || i == SC_PRESETS - 1)
 246                                 break;
 247                         t0 = t1;
 248                 }
 249                 // exponential interpolation between states
 250                 set = i-1 + (log(target) - log(t0)) / (log(t1) - log(t0));
 251                 set = max<float>(set, -5);
 252                 set = min<float>(set, (SC_PRESETS-1) + 5);
 253                 // Even if our time estimations in the SC_PRESETS array are off
 254                 // this will push us towards our target fullness
 255                 float s1 = set;
 256                 set += (40 * (filled-0.75));
 257                 float s2 = (40 * (filled-0.75));
 258                 set = min<float>(max<float>(set, 0), SC_PRESETS - 1);
 259                 apply_preset(dither_preset(set));
 260
 261                 if (global_flags.x264_speedcontrol_verbose) {
 262                         static float cpu, wall, tgt, den;
 263                         const float decay = 1-1/100.;
 264                         cpu = cpu*decay + duration_cast<microseconds>(cpu_time_last_frame).count();
 265                         wall = wall*decay + duration_cast<microseconds>(delta_t).count();
 266                         tgt = tgt*decay + target;
 267                         den = den*decay + 1;
 268                         fprintf(stderr, "speed: %.2f+%.2f %d[%.5f] (t/c/w: %6.0f/%6.0f/%6.0f = %.4f) fps=%.2f\r",
 269                                         s1, s2, preset, (float)buffer_fill / buffer_size,
 270                                         tgt/den, cpu/den, wall/den, cpu/wall, 1e6*den/wall );
 271                 }
 272         }
 273
 274 }
 275
 276 void X264SpeedControl::after_frame()
 277 {
 278         cpu_time_last_frame = steady_clock::now() - timestamp;
 279 }
 280
 281 void X264SpeedControl::set_buffer_size(int new_buffer_size)
 282 {
 283         new_buffer_size = max(3, new_buffer_size);
 284         buffer_size = new_buffer_size * uspf;
 285         cplx_decay = 1 - 1./new_buffer_size;
 286         compensation_period = buffer_size/4;
 287 }
 288
 289 int X264SpeedControl::dither_preset(float f)
 290 {
 291         int i = f;
 292         if (f < 0) {
 293                 i--;
 294         }
 295         dither += f - i;
 296         if (dither >= 1.0) {
 297                 dither--;
 298                 i++;
 299         }
 300         return i;
 301 }
 302
 303 void X264SpeedControl::apply_preset(int new_preset)
 304 {
 305         new_preset = max(new_preset, 0);
 306         new_preset = min(new_preset, SC_PRESETS - 1);
 307
 308         const sc_preset_t *s = &presets[new_preset];
 309         x264_param_t p;
 310         dyn.x264_encoder_parameters(x264, &p);
 311
 312         p.i_frame_reference = s->refs;
 313         p.i_bframe_adaptive = s->badapt;
 314         p.i_bframe = s->bframes;
 315         p.analyse.inter = s->partitions;
 316         p.analyse.i_subpel_refine = s->subme;
 317         p.analyse.i_me_method = s->me;
 318         p.analyse.i_trellis = s->trellis;
 319         p.analyse.b_mixed_references = s->mix;
 320         p.analyse.i_direct_mv_pred = s->direct;
 321         p.analyse.i_me_range = s->merange;
 322         if (override_func) {
 323                 override_func(&p);
 324         }
 325         dyn.x264_encoder_reconfig(x264, &p);
 326         preset = new_preset;
 327 }