contrib/patch-x264-vbv-2pass.patch

   1 Index: encoder/ratecontrol.c
   2 ===================================================================
   3 --- encoder/ratecontrol.c       (revision 680)
   4 +++ encoder/ratecontrol.c       (working copy)
   5 @@ -43,6 +43,7 @@
   6      int p_tex_bits;
   7      int misc_bits;
   8      uint64_t expected_bits;
   9 +    double expected_vbv;
  10      float new_qscale;
  11      int new_qp;
  12      int i_count;
  13 @@ -1149,7 +1150,7 @@
  14          return;
  15
  16      rct->buffer_fill_final += rct->buffer_rate - bits;
  17 -    if( rct->buffer_fill_final < 0 && !rct->b_2pass )
  18 +    if( rct->buffer_fill_final < 0 )
  19          x264_log( h, X264_LOG_WARNING, "VBV underflow (%.0f bits)\n", rct->buffer_fill_final );
  20      rct->buffer_fill_final = x264_clip3f( rct->buffer_fill_final, 0, rct->buffer_size );
  21  }
  22 @@ -1325,6 +1326,28 @@
  23                  double w = x264_clip3f( time*100, 0.0, 1.0 );
  24                  q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
  25              }
  26 +            if( rcc->b_vbv )
  27 +            {
  28 +                double expected_size = qscale2bits(&rce, q);
  29 +                double expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
  30 +                if( (expected_vbv < rcc->buffer_size*.4) && (expected_vbv < rce.expected_vbv) )
  31 +                {
  32 +                    double qmax = (expected_vbv < rcc->buffer_size*.15) ? lmax : q*1.5;
  33 +                    double size_constraint = 1 + rce.expected_vbv/rcc->buffer_size;
  34 +                    while( (expected_vbv < rce.expected_vbv/size_constraint) && (q < qmax) )
  35 +                    {
  36 +                        q *= 1.05;
  37 +                        expected_size = qscale2bits(&rce, q);
  38 +                        expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
  39 +                    }
  40 +/*    x264_log( h, X264_LOG_INFO,
  41 +              "frame %d rcc expected vbv = %d encoding expected vbv = %d\n",
  42 +              (int)(h->fenc->i_frame),
  43 +              (int)(rce.expected_vbv),
  44 +              (int)(expected_vbv));*/
  45 +
  46 +                }
  47 +            }
  48              q = x264_clip3f( q, lmin, lmax );
  49          }
  50          else /* 1pass ABR */
  51 @@ -1455,6 +1478,137 @@
  52      /* the rest of the variables are either constant or thread-local */
  53  }
  54
  55 +FILE *fh_vbv;
  56 +
  57 +static int find_underflow( x264_t *h, double *fills, int *t0, int *t1, int over )
  58 +{
  59 +    /* find an interval ending on an overflow or underflow (depending on whether
  60 +     * we're adding or removing bits), and starting on the earliest frame that
  61 +     * can influence the buffer fill of that end frame. */
  62 +    x264_ratecontrol_t *rcc = h->rc;
  63 +    const double buffer_min = (over ? .1 : .1) * rcc->buffer_size;
  64 +    const double buffer_max = .9 * rcc->buffer_size;
  65 +    double fill = fills[*t0-1];
  66 +    double parity = over ? 1. : -1.;
  67 +    int i, start=-1, end=-1;
  68 +    for(i=*t0; i<rcc->num_entries; i++)
  69 +    {
  70 +        fill += (rcc->buffer_rate - qscale2bits(&rcc->entry[i], rcc->entry[i].new_qscale)) * parity;
  71 +        fill = x264_clip3f(fill, 0, rcc->buffer_size);
  72 +        fills[i] = fill;
  73 +        if(fill <= buffer_min || i == 0)
  74 +        {
  75 +            if(end >= 0)
  76 +                break;
  77 +            start = i;
  78 +        }
  79 +        else if(fill >= buffer_max && start >= 0)
  80 +            end = i;
  81 +    }
  82 +    *t0 = start;
  83 +    *t1 = end;
  84 +    return start>=0 && end>=0;
  85 +}
  86 +
  87 +static void fix_underflow( x264_t *h, int t0, int t1, double adjustment )
  88 +{
  89 +    x264_ratecontrol_t *rcc = h->rc;
  90 +    int i;
  91 +    if(t0 > 0)
  92 +        t0++;
  93 +//  printf("interval [%d,%d] %.4f\n", t0, t1, adjustment);
  94 +    for(i=t0; i<=t1; i++)
  95 +        rcc->entry[i].new_qscale *= adjustment;
  96 +}
  97 +
  98 +static double count_expected_bits( x264_t *h )
  99 +{
 100 +    x264_ratecontrol_t *rcc = h->rc;
 101 +    double expected_bits = 0;
 102 +    int i;
 103 +    for(i=0; i<rcc->num_entries; i++)
 104 +    {
 105 +        ratecontrol_entry_t *rce = &rcc->entry[i];
 106 +        rce->expected_bits = expected_bits;
 107 +        expected_bits += qscale2bits(rce, rce->new_qscale);
 108 +    }
 109 +    return expected_bits;
 110 +}
 111 +
 112 +static void debug_dump_vbv( x264_t *h )
 113 +{
 114 +    x264_ratecontrol_t *rcc = h->rc;
 115 +    double fill = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
 116 +    int i;
 117 +    for(i=0; i<rcc->num_entries; i++)
 118 +    {
 119 +        fill += rcc->buffer_rate - qscale2bits(&rcc->entry[i], rcc->entry[i].new_qscale);
 120 +        fill = x264_clip3f(fill, rcc->buffer_size*-.5, rcc->buffer_size);
 121 +        fprintf(fh_vbv, "%d %.0f\n", i, fill);
 122 +    }
 123 +}
 124 +
 125 +static void vbv_pass2( x264_t *h )
 126 +{
 127 +    /* foreach interval of buffer_full .. underflow
 128 +     *   uniformly increase the qp of all frames in the interval until either
 129 +     *     buffer is full at some intermediate frame
 130 +     *     or the last frame in the interval no longer underflows
 131 +     * recompute intervals and repeat
 132 +     * then do the converse to put bits back into overflow areas until target size is met */
 133 +
 134 +    x264_ratecontrol_t *rcc = h->rc;
 135 +    double *fills = x264_malloc((rcc->num_entries+1)*sizeof(double));
 136 +    double all_available_bits = h->param.rc.i_bitrate * 1000. * rcc->num_entries / rcc->fps;
 137 +    double expected_bits, prev_bits, adjustment;
 138 +    int i, t0, t1, space;
 139 +
 140 +    fills++;
 141 +//  fh_vbv = fopen("vbv.log", "w");
 142 +
 143 +       //adjust overall stream size
 144 +    do {
 145 +        space = 0;
 146 +
 147 +        fills[-1] = rcc->buffer_size * (1. - h->param.rc.f_vbv_buffer_init);
 148 +        t0 = 0;
 149 +               //fix underflows
 150 +        while(find_underflow(h, fills, &t0, &t1, 0))
 151 +        {
 152 +            fix_underflow(h, t0, t1, 1.001);
 153 +            space = 1;
 154 +        }
 155 +
 156 +        prev_bits = expected_bits = count_expected_bits(h);
 157 +        adjustment = X264_MAX(expected_bits / all_available_bits, 0.999);
 158 +        fills[-1] = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
 159 +        t0 = 0;
 160 +               //fix overflows
 161 +        while(find_underflow(h, fills, &t0, &t1, 1))
 162 +        {
 163 +            fix_underflow(h, t0, t1, adjustment);
 164 +            t0 = t1;
 165 +            space = 1;
 166 +        }
 167 +        expected_bits = count_expected_bits(h);
 168 +    } while(space && expected_bits < .995*all_available_bits && expected_bits >= prev_bits+1);
 169 +
 170 +    //better undersizing target than underflowing vbv
 171 +    fills[-1] = rcc->buffer_size * (1. - h->param.rc.f_vbv_buffer_init);
 172 +    t0 = 0;
 173 +    while(find_underflow(h, fills, &t0, &t1, 0))
 174 +        fix_underflow(h, t0, t1, 1.001);
 175 +
 176 +//  debug_dump_vbv(h);
 177 +
 178 +    //store expected vbv filling values for tracking when encoding
 179 +    for(i=0; i<rcc->num_entries; i++)
 180 +        rcc->entry[i].expected_vbv = rcc->buffer_size - fills[i];
 181 +
 182 +//  fclose(fh_vbv);
 183 +    x264_free(fills-1);
 184 +}
 185 +
 186  static int init_pass2( x264_t *h )
 187  {
 188      x264_ratecontrol_t *rcc = h->rc;
 189 @@ -1543,7 +1697,6 @@
 190          rcc->last_non_b_pict_type = -1;
 191          rcc->last_accum_p_norm = 1;
 192          rcc->accum_p_norm = 0;
 193 -        rcc->buffer_fill = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
 194
 195          /* find qscale */
 196          for(i=0; i<rcc->num_entries; i++){
 197 @@ -1580,15 +1733,9 @@
 198          /* find expected bits */
 199          for(i=0; i<rcc->num_entries; i++){
 200              ratecontrol_entry_t *rce = &rcc->entry[i];
 201 -            double bits;
 202              rce->new_qscale = clip_qscale(h, rce->pict_type, blurred_qscale[i]);
 203              assert(rce->new_qscale >= 0);
 204 -            bits = qscale2bits(rce, rce->new_qscale);
 205 -
 206 -            rce->expected_bits = expected_bits;
 207 -            expected_bits += bits;
 208 -            update_vbv(h, bits);
 209 -            rcc->buffer_fill = rcc->buffer_fill_final;
 210 +            expected_bits += qscale2bits(rce, rce->new_qscale);
 211          }
 212
 213  //printf("expected:%llu available:%llu factor:%lf avgQ:%lf\n", (uint64_t)expected_bits, all_available_bits, rate_factor);
 214 @@ -1599,6 +1746,10 @@
 215      if(filter_size > 1)
 216          x264_free(blurred_qscale);
 217
 218 +    if(rcc->b_vbv)
 219 +        vbv_pass2(h);
 220 +    expected_bits = count_expected_bits(h);
 221 +
 222      if(fabs(expected_bits/all_available_bits - 1.0) > 0.01)
 223      {
 224          double avgq = 0;
 225 @@ -1606,7 +1757,8 @@
 226              avgq += rcc->entry[i].new_qscale;
 227          avgq = qscale2qp(avgq / rcc->num_entries);
 228
 229 -        x264_log(h, X264_LOG_WARNING, "Error: 2pass curve failed to converge\n");
 230 +        if ((expected_bits > all_available_bits) || (!rcc->b_vbv))
 231 +            x264_log(h, X264_LOG_WARNING, "Error: 2pass curve failed to converge\n");
 232          x264_log(h, X264_LOG_WARNING, "target: %.2f kbit/s, expected: %.2f kbit/s, avg QP: %.4f\n",
 233                   (float)h->param.rc.i_bitrate,
 234                   expected_bits * rcc->fps / (rcc->num_entries * 1000.),
 235 @@ -1625,7 +1777,7 @@
 236              else
 237                  x264_log(h, X264_LOG_WARNING, "try increasing target bitrate\n");
 238          }
 239 -        else
 240 +        else if(!(rcc->b_2pass && rcc->b_vbv))
 241              x264_log(h, X264_LOG_WARNING, "internal error\n");
 242      }
 243
 244 @@ -1633,3 +1785,4 @@
 245  }
 246
 247
 248 +