git.sesse.net Git - x264/blob - encoder/speed.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <math.h>
   4 #include "common/common.h"
   5 #include "common/cpu.h"
   6
   7 struct x264_speedcontrol_t
   8 {
   9     // all times are in usec
  10     int64_t timestamp;   // when was speedcontrol last invoked
  11     int64_t cpu_time;    // time spent encoding the previous frame
  12     int64_t buffer_size; // assumed application-side buffer of frames to be streamed (measured in microseconds),
  13     int64_t buffer_fill; //   where full = we don't have to hurry
  14     int64_t compensation_period; // how quickly we try to return to the target buffer fullness
  15     float uspf;          // microseconds per frame
  16     int preset;          // which setting was used in the previous frame
  17     int prev_frame;
  18     float cplx_num;      // rolling average of estimated spf for preset #0
  19     float cplx_den;
  20     float cplx_decay;
  21     float dither;
  22
  23     int first;
  24     int buffer_complete;
  25
  26     struct
  27     {
  28         int64_t min_buffer, max_buffer;
  29         double avg_preset;
  30         int den;
  31     } stat;
  32 };
  33
  34 void x264_speedcontrol_new( x264_t *h )
  35 {
  36     x264_speedcontrol_t *sc = h->sc = x264_malloc( sizeof(x264_speedcontrol_t) );
  37     x264_emms();
  38     memset( sc, 0, sizeof(x264_speedcontrol_t) );
  39
  40     if( h->param.sc.f_speed <= 0 )
  41         h->param.sc.f_speed = 1;
  42     float fps = h->param.i_fps_num / h->param.i_fps_den;
  43     sc->uspf = 1e6 / fps;
  44     h->param.sc.i_buffer_size = X264_MAX( 3, h->param.sc.i_buffer_size );
  45     sc->buffer_size = h->param.sc.i_buffer_size * sc->uspf;
  46     sc->buffer_fill = sc->buffer_size * h->param.sc.f_buffer_init;
  47     sc->buffer_fill = x264_clip3( sc->buffer_fill, sc->uspf, sc->buffer_size );
  48     sc->compensation_period = sc->buffer_size/4;
  49     sc->timestamp = x264_mdate();
  50     sc->preset = -1;
  51     sc->prev_frame = 0;
  52     sc->cplx_num = 3e3; //FIXME estimate initial complexity
  53     sc->cplx_den = .1;
  54     sc->cplx_decay = 1 - 1./h->param.sc.i_buffer_size;
  55     sc->stat.min_buffer = sc->buffer_size;
  56     sc->stat.max_buffer = 0;
  57     sc->first = 1;
  58     sc->buffer_complete = 0;
  59 }
  60
  61 void x264_speedcontrol_delete( x264_t *h )
  62 {
  63     x264_speedcontrol_t *sc = h->sc;
  64     if( !sc )
  65         return;
  66     x264_log( h, X264_LOG_INFO, "speedcontrol: avg preset=%.3f  buffer min=%.3f max=%.3f\n",
  67               sc->stat.avg_preset / sc->stat.den,
  68               (float)sc->stat.min_buffer / sc->buffer_size,
  69               (float)sc->stat.max_buffer / sc->buffer_size );
  70 //  x264_log( h, X264_LOG_INFO, "speedcontrol: avg cplx=%.5f\n", sc->cplx_num / sc->cplx_den );
  71     x264_free( sc );
  72 }
  73
  74 static int dither( x264_speedcontrol_t *sc, float f )
  75 {
  76     int i = f;
  77     if( f < 0 )
  78         i--;
  79     sc->dither += f - i;
  80     if( sc->dither >= 1. )
  81     {
  82         sc->dither--;
  83         i++;
  84     }
  85     return i;
  86 }
  87
  88 typedef struct
  89 {
  90     float time; // relative encoding time, compared to the other presets
  91     int subme;
  92     int me;
  93     int refs;
  94     int mix;
  95     int trellis;
  96     int partitions;
  97     int badapt;
  98     int bframes;
  99     int direct;
 100     int merange;
 101 } sc_preset_t;
 102
 103 // The actual presets, including the equivalent commandline options. Note that
 104 // all presets are benchmarked with --weightp 1 --mbtree --rc-lookahead 20
 105 // on top of the given settings (equivalent settings to the "faster" preset).
 106 // Timings and SSIM measurements were done on a quadcore Haswell i5 3.2 GHz
 107 // on the first 1000 frames of "Tears of Steel" in 1080p.
 108 static const sc_preset_t presets[SC_PRESETS] = {
 109 #define I4 X264_ANALYSE_I4x4
 110 #define I8 X264_ANALYSE_I8x8
 111 #define P4 X264_ANALYSE_PSUB8x8
 112 #define P8 X264_ANALYSE_PSUB16x16
 113 #define B8 X264_ANALYSE_BSUB16x16
 114   // Preset 0: 14.179db, --preset superfast --b-adapt 0 --bframes 0
 115   { .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 },
 116
 117   // Preset 1: 14.459db, --preset superfast
 118   { .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 },
 119
 120   // Preset 2: 14.761db, --preset superfast --subme 2
 121   { .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 },
 122
 123   // Preset 3: 15.543db, --preset veryfast
 124   { .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 },
 125
 126   // Preset 4: 15.716db, --preset veryfast --subme 3
 127   { .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 },
 128
 129   // Preset 5: 15.786db, --preset veryfast --subme 3 --ref 2
 130   { .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 },
 131
 132   // Preset 6: 15.813db, --preset veryfast --subme 4 --ref 2
 133   { .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 },
 134
 135   // Preset 7: 15.849db, --preset faster
 136   { .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 },
 137
 138   // Preset 8: 15.857db, --preset faster --mixed-refs
 139   { .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 },
 140
 141   // Preset 9: 15.869db, --preset faster --mixed-refs --subme 5
 142   { .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 },
 143
 144   // Preset 10: 16.051db, --preset fast
 145   { .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 },
 146
 147   // Preset 11: 16.356db, --preset fast --subme 7
 148   { .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 },
 149
 150   // Preset 12: 16.418db, --preset fast --subme 7 --ref 3
 151   { .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 },
 152
 153   // Preset 13: 16.460db, --preset medium
 154   { .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 },
 155
 156   // Preset 14: 16.517db, --preset medium --subme 8
 157   { .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 },
 158
 159   // Preset 15: 16.523db, --preset medium --subme 8 --me umh
 160   { .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 },
 161
 162   // Preset 16: 16.543db, --preset medium --subme 8 --me umh --direct auto --b-adapt 2
 163   { .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 },
 164
 165   // Preset 17: 16.613db, --preset slow
 166   { .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 },
 167
 168   // Preset 18: 16.641db, --preset slow --subme 9
 169   { .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 },
 170
 171   // Preset 19: 16.895db, --preset slow --subme 9 --trellis 2
 172   { .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 },
 173
 174   // Preset 20: 16.918db, --preset slow --subme 9 --trellis 2 --ref 6
 175   { .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 },
 176
 177   // Preset 21: 16.934db, --preset slow --subme 9 --trellis 2 --ref 7
 178   { .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 },
 179
 180   // Preset 22: 16.948db, --preset slower
 181   { .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 },
 182
 183   // Preset 23: 17.058db, --preset slower --subme 10
 184   { .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 },
 185
 186   // Preset 24: 17.268db, --preset slower --subme 10 --bframes 8
 187   { .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 },
 188
 189   // Preset 25: 17.297db, --preset veryslow
 190   { .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 },
 191 #undef I4
 192 #undef I8
 193 #undef P4
 194 #undef P8
 195 #undef B8
 196 };
 197
 198 static void apply_preset( x264_t *h, int preset )
 199 {
 200     x264_speedcontrol_t *sc = h->sc;
 201     preset = x264_clip3( preset, 0, h->param.sc.max_preset-1 );
 202     //if( preset != sc->preset )
 203     {
 204         const sc_preset_t *s = &presets[preset];
 205         x264_param_t p = h->param;
 206
 207         p.i_frame_reference = s->refs;
 208         p.i_bframe_adaptive = s->badapt;
 209         p.i_bframe = s->bframes;
 210         p.analyse.inter = s->partitions;
 211         p.analyse.i_subpel_refine = s->subme;
 212         p.analyse.i_me_method = s->me;
 213         p.analyse.i_trellis = s->trellis;
 214         p.analyse.b_mixed_references = s->mix;
 215         p.analyse.i_direct_mv_pred = s->direct;
 216         p.analyse.i_me_range = s->merange;
 217         x264_encoder_reconfig( h, &p );
 218         sc->preset = preset;
 219         x264_log( h, X264_LOG_DEBUG, "Applying speedcontrol preset %d.\n", preset );
 220     }
 221 }
 222
 223 void x264_speedcontrol_frame_end( x264_t *h )
 224 {
 225     x264_speedcontrol_t *sc = h->sc;
 226     if( h->param.sc.b_alt_timer )
 227         sc->cpu_time = x264_mdate() - sc->timestamp;
 228 }
 229
 230 void x264_speedcontrol_frame( x264_t *h )
 231 {
 232     x264_speedcontrol_t *sc = h->sc;
 233     int64_t t, delta_t, delta_buffer;
 234     int delta_f;
 235
 236     x264_emms();
 237
 238     // update buffer state after encoding and outputting the previous frame(s)
 239     if( sc->first )
 240     {
 241         t = sc->timestamp = x264_mdate();
 242         sc->first = 0;
 243     }
 244     else
 245         t = x264_mdate();
 246
 247     delta_f = h->i_frame - sc->prev_frame;
 248     delta_t = t - sc->timestamp;
 249     delta_buffer = delta_f * sc->uspf / h->param.sc.f_speed - delta_t;
 250     if( !sc->buffer_complete )
 251         sc->buffer_fill += delta_buffer;
 252     sc->prev_frame = h->i_frame;
 253     sc->timestamp = t;
 254
 255     // update the time predictor
 256     if( delta_f )
 257     {
 258         int cpu_time = h->param.sc.b_alt_timer ? sc->cpu_time : delta_t;
 259         float decay = powf( sc->cplx_decay, delta_f );
 260         sc->cplx_num *= decay;
 261         sc->cplx_den *= decay;
 262         sc->cplx_num += cpu_time / presets[sc->preset].time;
 263         sc->cplx_den += delta_f;
 264
 265         sc->stat.avg_preset += sc->preset * delta_f;
 266         sc->stat.den += delta_f;
 267     }
 268     sc->stat.min_buffer = X264_MIN( sc->buffer_fill, sc->stat.min_buffer );
 269     sc->stat.max_buffer = X264_MAX( sc->buffer_fill, sc->stat.max_buffer );
 270
 271     if( sc->buffer_fill > sc->buffer_size ) // oops, cpu was idle
 272     {
 273         // not really an error, but we'll warn for debugging purposes
 274         static int64_t idle_t = 0, print_interval = 0;
 275         idle_t += sc->buffer_fill - sc->buffer_size;
 276         if( t - print_interval > 1e6 )
 277         {
 278             x264_log( h, X264_LOG_DEBUG, "speedcontrol idle (%.6f sec)\n", idle_t/1e6 );
 279             print_interval = t;
 280             idle_t = 0;
 281         }
 282         sc->buffer_fill = sc->buffer_size;
 283     }
 284     else if( sc->buffer_fill < 0 && delta_buffer < 0 ) // oops, we're late
 285     {
 286         // don't clip fullness to 0; we'll hope the real buffer was bigger than
 287         // specified, and maybe we can catch up. if the application had to drop
 288         // frames, then it should override the buffer fullness (FIXME implement this).
 289         x264_log( h, X264_LOG_WARNING, "speedcontrol underflow (%.6f sec)\n", sc->buffer_fill/1e6 );
 290     }
 291
 292     {
 293         // pick the preset that should return the buffer to 3/4-full within a time
 294         // specified by compensation_period
 295         float target = sc->uspf / h->param.sc.f_speed
 296                      * (sc->buffer_fill + sc->compensation_period)
 297                      / (sc->buffer_size*3/4 + sc->compensation_period);
 298         float cplx = sc->cplx_num / sc->cplx_den;
 299         float set, t0, t1;
 300         float filled = (float) sc->buffer_fill / sc->buffer_size;
 301         int i;
 302         t0 = presets[0].time * cplx;
 303         for( i=1;; i++ )
 304         {
 305             t1 = presets[i].time * cplx;
 306             if( t1 >= target || i == h->param.sc.max_preset-1 )
 307                 break;
 308             t0 = t1;
 309         }
 310         // linear interpolation between states
 311         set = i-1 + (target - t0) / (t1 - t0);
 312         // Even if our time estimations in the SC_PRESETS array are off
 313         // this will push us towards our target fullness
 314         set += (40 * (filled-0.75));
 315         set = x264_clip3f( set, 0 , h->param.sc.max_preset-1 );
 316         apply_preset( h, dither( sc, set ) );
 317
 318         // FIXME
 319         if (h->param.i_log_level >= X264_LOG_DEBUG)
 320         {
 321             static float cpu, wall, tgt, den;
 322             float decay = 1-1/100.;
 323             cpu = cpu*decay + sc->cpu_time;
 324             wall = wall*decay + delta_t;
 325             tgt = tgt*decay + target;
 326             den = den*decay + 1;
 327             x264_log( h, X264_LOG_DEBUG, "speed: %.2f %d[%.5f] (t/c/w: %6.0f/%6.0f/%6.0f = %.4f) fps=%.2f\r",
 328                      set, sc->preset, (float)sc->buffer_fill / sc->buffer_size,
 329                      tgt/den, cpu/den, wall/den, cpu/wall, 1e6*den/wall );
 330         }
 331     }
 332
 333 }
 334
 335 void x264_speedcontrol_sync( x264_t *h, float f_buffer_fill, int i_buffer_size, int buffer_complete )
 336 {
 337     x264_speedcontrol_t *sc = h->sc;
 338     if( !h->param.sc.i_buffer_size )
 339         return;
 340     if( i_buffer_size )
 341         h->param.sc.i_buffer_size = X264_MAX( 3, i_buffer_size );
 342     sc->buffer_size = h->param.sc.i_buffer_size * sc->uspf;
 343     sc->cplx_decay = 1 - 1./h->param.sc.i_buffer_size;
 344     sc->compensation_period = sc->buffer_size/4;
 345     sc->buffer_fill = sc->buffer_size * f_buffer_fill;
 346     sc->buffer_complete = !!buffer_complete;
 347 }