Use floats instead of int64 in log messages, since win32 (incl. mingw) doesn't unders...
[x262.git] / encoder / ratecontrol.c
1 /***************************************************-*- coding: iso-8859-1 -*-
2  * ratecontrol.c: h264 encoder library (Rate Control)
3  *****************************************************************************
4  * Copyright (C) 2003 Laurent Aimar
5  * $Id: ratecontrol.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
6  *
7  * Authors: Måns Rullgård <mru@mru.ath.cx>
8  * 2 pass code: Michael Niedermayer <michaelni@gmx.at>
9  *              Loren Merritt <lorenm@u.washington.edu>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 #define _ISOC99_SOURCE
27 #undef NDEBUG // always check asserts, the speed effect is far too small to disable them
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <math.h>
32 #include <limits.h>
33 #include <assert.h>
34
35 #include "common/common.h"
36 #include "common/cpu.h"
37 #include "common/macroblock.h"
38 #include "ratecontrol.h"
39
40 #ifdef SYS_MACOSX
41 #define exp2f(x) ( (float) exp2( (x) ) )
42 #endif
43 #ifdef SYS_FREEBSD
44 #define exp2f(x) powf( 2, (x) )
45 #endif
46
47
48 typedef struct
49 {
50     int pict_type;
51     int idr;
52     float qscale;
53     int mv_bits;
54     int i_tex_bits;
55     int p_tex_bits;
56     int misc_bits;
57     uint64_t expected_bits;
58     float new_qscale;
59     int new_qp;
60     int i_count;
61     int p_count;
62     int s_count;
63     float blurred_complexity;
64 } ratecontrol_entry_t;
65
66 struct x264_ratecontrol_t
67 {
68     /* constants */
69     double fps;
70     int gop_size;
71     int bitrate;
72     int nmb;                    /* number of macroblocks in a frame */
73     int buffer_size;
74     int rcbufrate;
75     int init_qp;
76     int qp_constant[5];
77
78     /* 1st pass stuff */
79     int gop_qp;
80     int buffer_fullness;
81     int frames;                 /* frames in current gop */
82     int pframes;
83     int slice_type;
84     int mb;                     /* MBs processed in current frame */
85     int bits_gop;               /* allocated bits current gop */
86     int bits_last_gop;          /* bits consumed in gop */
87     int qp;                     /* qp for current frame */
88     int qpm;                    /* qp for next MB */
89     float qpa;                  /* average qp for last frame */
90     int qps;
91     float qp_avg_p;             /* average QP for P frames */
92     float qp_last_p;
93     int fbits;                  /* bits allocated for current frame */
94     int ufbits;                 /* bits used for current frame */
95     int nzcoeffs;               /* # of 0-quantized coefficients */
96     int ncoeffs;                /* total # of coefficients */
97     int overhead;
98
99     /* 2pass stuff */
100     FILE *p_stat_file_out;
101
102     int num_entries;            /* number of ratecontrol_entry_ts */
103     ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
104     double last_qscale;
105     double last_qscale_for[5];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff  */
106     int last_non_b_pict_type;
107     double accum_p_qp;          /* for determining I-frame quant */
108     double accum_p_norm;
109     double last_accum_p_norm;
110     double lmin[5];             /* min qscale by frame type */
111     double lmax[5];
112     double lstep;               /* max change (multiply) in qscale per frame */
113     double i_cplx_sum[5];       /* estimated total texture bits in intra MBs at qscale=1 */
114     double p_cplx_sum[5];
115     double mv_bits_sum[5];
116     int frame_count[5];         /* number of frames of each type */
117 };
118
119
120 static int init_pass2(x264_t *);
121 static float rate_estimate_qscale( x264_t *h, int pict_type );
122
123 /* Terminology:
124  * qp = h.264's quantizer
125  * qscale = linearized quantizer = Lagrange multiplier
126  */
127 static inline double qp2qscale(double qp)
128 {
129     return 0.85 * pow(2.0, ( qp - 12.0 ) / 6.0);
130 }
131 static inline double qscale2qp(double qscale)
132 {
133     return 12.0 + 6.0 * log(qscale/0.85) / log(2.0);
134 }
135
136 static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
137 {
138     if(qscale<0.1)
139     {
140 //      fprintf(stderr, "qscale<0.1\n");
141         qscale = 0.1;
142     }
143     return (double)(rce->i_tex_bits + rce->p_tex_bits + .1) * rce->qscale / qscale;
144 }
145
146 static inline double bits2qscale(ratecontrol_entry_t *rce, double bits)
147 {
148     if(bits<0.9)
149     {
150 //      fprintf(stderr, "bits<0.9\n");
151         bits = 1.0;
152     }
153     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + .1) / bits;
154 }
155
156
157 int x264_ratecontrol_new( x264_t *h )
158 {
159     x264_ratecontrol_t *rc;
160     float bpp;
161     int i;
162
163     /* Needed(?) for 2 pass */
164     x264_cpu_restore( h->param.cpu );
165
166     h->rc = rc = x264_malloc( sizeof( x264_ratecontrol_t ) );
167     memset(rc, 0, sizeof(*rc));
168
169     /* FIXME: use integers */
170     if(h->param.i_fps_num > 0 && h->param.i_fps_den > 0)
171         rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
172     else
173         rc->fps = 25.0;
174
175     rc->gop_size = h->param.i_keyint_max;
176     rc->bitrate = h->param.rc.i_bitrate * 1000;
177     rc->nmb = h->mb.i_mb_count;
178
179     rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
180     rc->qp_constant[SLICE_TYPE_I] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) / fabs( h->param.rc.f_ip_factor )) + 0.5 ), 0, 51 );
181     rc->qp_constant[SLICE_TYPE_B] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) * fabs( h->param.rc.f_pb_factor )) + 0.5 ), 0, 51 );
182
183     /* Init 1pass CBR algo */
184     if( h->param.rc.b_cbr ){
185         rc->buffer_size = h->param.rc.i_rc_buffer_size * 1000;
186         rc->buffer_fullness = h->param.rc.i_rc_init_buffer;
187         rc->rcbufrate = rc->bitrate / rc->fps;
188
189         if(rc->buffer_size < rc->rcbufrate){
190             x264_log(h, X264_LOG_WARNING, "rc buffer size %i too small\n",
191                      rc->buffer_size);
192             rc->buffer_size = 0;
193         }
194
195         if(rc->buffer_size <= 0)
196             rc->buffer_size = rc->bitrate / 2;
197
198         if(rc->buffer_fullness > rc->buffer_size || rc->buffer_fullness < 0){
199             x264_log(h, X264_LOG_WARNING, "invalid initial buffer fullness %i\n",
200                      rc->buffer_fullness);
201             rc->buffer_fullness = 0;
202         }
203
204         bpp = rc->bitrate / (rc->fps * h->param.i_width * h->param.i_height);
205         if(bpp <= 0.6)
206             rc->init_qp = 31;
207         else if(bpp <= 1.4)
208             rc->init_qp = 25;
209         else if(bpp <= 2.4)
210             rc->init_qp = 20;
211         else
212             rc->init_qp = 10;
213         rc->gop_qp = rc->init_qp;
214
215         rc->bits_last_gop = 0;
216
217         x264_log(h, X264_LOG_DEBUG, "%f fps, %i bps, bufsize %i\n",
218                  rc->fps, rc->bitrate, rc->buffer_size);
219     }
220
221
222     rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
223     for( i = 0; i < 5; i++ )
224     {
225         rc->last_qscale_for[i] = qp2qscale(26);
226         rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
227         rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
228     }
229 #if 0 // FIXME: do we want to assign lmin/lmax based on ip_factor, or leave them all the same?
230     rc->lmin[SLICE_TYPE_I] /= fabs(h->param.f_ip_factor);
231     rc->lmax[SLICE_TYPE_I] /= fabs(h->param.f_ip_factor);
232     rc->lmin[SLICE_TYPE_B] *= fabs(h->param.f_pb_factor);
233     rc->lmax[SLICE_TYPE_B] *= fabs(h->param.f_pb_factor);
234 #endif
235
236     /* Load stat file and init 2pass algo */
237     if( h->param.rc.b_stat_read )
238     {
239         int stats_size;
240         char *p, *stats_in;
241         FILE *stats_file;
242
243         /* read 1st pass stats */
244         assert( h->param.rc.psz_stat_in );
245         stats_file = fopen( h->param.rc.psz_stat_in, "rb");
246         if(!stats_file)
247         {
248             x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
249             return -1;
250         }
251         // FIXME: error checking
252         fseek(stats_file, 0, SEEK_END);
253         stats_size = ftell(stats_file);
254         fseek(stats_file, 0, SEEK_SET);
255         stats_in = x264_malloc(stats_size+10);
256         fread(stats_in, 1, stats_size, stats_file);
257         fclose(stats_file);
258
259         /* find number of pics */
260         p = stats_in;
261         for(i=-1; p; i++){
262             p = strchr(p+1, ';');
263         }
264         i += h->param.i_bframe;
265         rc->entry = (ratecontrol_entry_t*) x264_malloc(i*sizeof(ratecontrol_entry_t));
266         memset(rc->entry, 0, i*sizeof(ratecontrol_entry_t));
267         rc->num_entries= i;
268
269         /* init all to skipped p frames */
270         for(i=0; i<rc->num_entries; i++){
271             ratecontrol_entry_t *rce = &rc->entry[i];
272             rce->pict_type = SLICE_TYPE_P;
273             rce->qscale = rce->new_qscale = qp2qscale(20);
274             rce->misc_bits = rc->nmb + 10;
275             rce->new_qp = 0;
276         }
277
278         /* read stats */
279         p = stats_in;
280         for(i=0; i < rc->num_entries - h->param.i_bframe; i++){
281             ratecontrol_entry_t *rce;
282             int frame_number;
283             char pict_type;
284             int e;
285             char *next;
286             float qp;
287
288             next= strchr(p, ';');
289             if(next){
290                 (*next)=0; //sscanf is unbelievably slow on looong strings
291                 next++;
292             }
293             e = sscanf(p, " in:%d ", &frame_number);
294
295             assert(frame_number >= 0);
296             assert(frame_number < rc->num_entries);
297             rce = &rc->entry[frame_number];
298
299             e += sscanf(p, " in:%*d out:%*d type:%c q:%f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d",
300                    &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
301                    &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
302
303             switch(pict_type){
304                 case 'I': rce->idr = 1;
305                 case 'i': rce->pict_type = SLICE_TYPE_I; break;
306                 case 'P': rce->pict_type = SLICE_TYPE_P; break;
307                 case 'B': rce->pict_type = SLICE_TYPE_B; break;
308                 default:  e = -1; break;
309             }
310             if(e != 10){
311                 x264_log(h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
312                 return -1;
313             }
314             rce->qscale = qp2qscale(qp);
315             p = next;
316         }
317
318         x264_free(stats_in);
319
320         if(init_pass2(h) < 0) return -1;
321     }
322
323     /* Open output file */
324     if( h->param.rc.b_stat_write )
325     {
326         rc->p_stat_file_out = fopen( h->param.rc.psz_stat_out, "wb" );
327         if( rc->p_stat_file_out == NULL )
328         {
329             x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
330             return -1;
331         }
332     }
333
334     return 0;
335 }
336
337 void x264_ratecontrol_delete( x264_t *h )
338 {
339     x264_ratecontrol_t *rc = h->rc;
340
341     if( rc->p_stat_file_out )
342         fclose( rc->p_stat_file_out );
343     if( rc->entry )
344         x264_free(rc->entry);
345     x264_free( rc );
346 }
347
348 void x264_ratecontrol_start( x264_t *h, int i_slice_type )
349 {
350     x264_ratecontrol_t *rc = h->rc;
351     int gframes, iframes, pframes, bframes;
352     int minbits, maxbits;
353     int gbits, fbits;
354     int zn = 0;
355     float kp;
356     int gbuf;
357
358     rc->slice_type = i_slice_type;
359
360     x264_cpu_restore( h->param.cpu );
361
362     if( !h->param.rc.b_cbr )
363     {
364         rc->qpm = rc->qpa = rc->qp =
365             rc->qp_constant[ i_slice_type ];
366         return;
367     }
368     else if( h->param.rc.b_stat_read )
369     {
370         int frame = h->fenc->i_frame;
371         ratecontrol_entry_t *rce;
372         assert( frame >= 0 && frame < rc->num_entries );
373         rce = &h->rc->entry[frame];
374
375         rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
376         rc->qpm = rc->qpa = rc->qp = rce->new_qp =
377             (int)(qscale2qp(rce->new_qscale) + 0.5);
378         return;
379     }
380
381     switch(i_slice_type){
382     case SLICE_TYPE_I:
383         gbuf = rc->buffer_fullness + (rc->gop_size-1) * rc->rcbufrate;
384         rc->bits_gop = gbuf - rc->buffer_size / 2;
385
386         if(!rc->mb && rc->pframes){
387             int qp = rc->qp_avg_p / rc->pframes + 0.5;
388 #if 0 /* JM does this without explaining why */
389             int gdq = (float) rc->gop_size / 15 + 0.5;
390             if(gdq > 2)
391                 gdq = 2;
392             qp -= gdq;
393             if(qp > rc->qp_last_p - 2)
394                 qp--;
395 #endif
396             qp = x264_clip3(qp, rc->gop_qp - 4, rc->gop_qp + 4);
397             qp = x264_clip3(qp, h->param.rc.i_qp_min, h->param.rc.i_qp_max);
398             rc->gop_qp = qp;
399         } else if(rc->frames > 4){
400             rc->gop_qp = rc->init_qp;
401         }
402
403         kp = h->param.rc.f_ip_factor * h->param.rc.f_pb_factor;
404
405         x264_log(h, X264_LOG_DEBUG,"gbuf=%i bits_gop=%i frames=%i gop_qp=%i\n",
406                  gbuf, rc->bits_gop, rc->frames, rc->gop_qp);
407
408         rc->bits_last_gop = 0;
409         rc->frames = 0;
410         rc->pframes = 0;
411         rc->qp_avg_p = 0;
412         break;
413
414     case SLICE_TYPE_P:
415         kp = h->param.rc.f_pb_factor;
416         break;
417
418     case SLICE_TYPE_B:
419         kp = 1.0;
420         break;
421
422     default:
423         x264_log(h, X264_LOG_WARNING, "ratecontrol: unknown slice type %i\n",
424                  i_slice_type);
425         kp = 1.0;
426         break;
427     }
428
429     gframes = rc->gop_size - rc->frames;
430     iframes = gframes / rc->gop_size;
431     pframes = gframes / (h->param.i_bframe + 1) - iframes;
432     bframes = gframes - pframes - iframes;
433
434     gbits = rc->bits_gop - rc->bits_last_gop;
435     fbits = kp * gbits /
436         (h->param.rc.f_ip_factor * h->param.rc.f_pb_factor * iframes +
437          h->param.rc.f_pb_factor * pframes + bframes);
438
439     minbits = rc->buffer_fullness + rc->rcbufrate - rc->buffer_size;
440     if(minbits < 0)
441         minbits = 0;
442     maxbits = rc->buffer_fullness;
443     rc->fbits = x264_clip3(fbits, minbits, maxbits);
444
445     if(i_slice_type == SLICE_TYPE_I){
446         rc->qp = rc->gop_qp;
447     } else if(rc->ncoeffs && rc->ufbits){
448         int dqp, nonzc;
449
450         nonzc = (rc->ncoeffs - rc->nzcoeffs);
451         if(nonzc == 0)
452             zn = rc->ncoeffs;
453         else if(rc->fbits < INT_MAX / nonzc)
454             zn = rc->ncoeffs - rc->fbits * nonzc / rc->ufbits;
455         else
456             zn = 0;
457         zn = x264_clip3(zn, 0, rc->ncoeffs);
458         dqp = h->param.rc.i_rc_sens * exp2f(rc->qpa / 6) *
459             (zn - rc->nzcoeffs) / rc->nzcoeffs;
460         dqp = x264_clip3(dqp, -h->param.rc.i_qp_step, h->param.rc.i_qp_step);
461         rc->qp = (int)(rc->qpa + dqp + .5);
462     }
463
464     if(rc->fbits > 0.9 * maxbits)
465         rc->qp += 2;
466     else if(rc->fbits > 0.8 * maxbits)
467         rc->qp += 1;
468     else if(rc->fbits < 1.1 * minbits)
469         rc->qp -= 2;
470     else if(rc->fbits < 1.2 * minbits)
471         rc->qp -= 1;
472
473     rc->qp = x264_clip3(rc->qp, h->param.rc.i_qp_min, h->param.rc.i_qp_max);
474     rc->qpm = rc->qp;
475
476     x264_log(h, X264_LOG_DEBUG, "fbits=%i, qp=%i, z=%i, min=%i, max=%i\n",
477              rc->fbits, rc->qpm, zn, minbits, maxbits);
478
479     rc->fbits -= rc->overhead;
480     rc->ufbits = 0;
481     rc->ncoeffs = 0;
482     rc->nzcoeffs = 0;
483     rc->mb = 0;
484     rc->qps = 0;
485 }
486
487 void x264_ratecontrol_mb( x264_t *h, int bits )
488 {
489     x264_ratecontrol_t *rc = h->rc;
490     int rbits;
491     int zn, enz, nonz;
492     int rcoeffs;
493     int dqp;
494     int i;
495
496     if( !h->param.rc.b_cbr || h->param.rc.b_stat_read )
497         return;
498
499     x264_cpu_restore( h->param.cpu );
500
501     rc->qps += rc->qpm;
502     rc->ufbits += bits;
503     rc->mb++;
504
505     for(i = 0; i < 16 + 8; i++)
506         rc->nzcoeffs += 16 - h->mb.cache.non_zero_count[x264_scan8[i]];
507     rc->ncoeffs += 16 * (16 + 8);
508
509     if(rc->mb < rc->nmb / 16)
510         return;
511     else if(rc->mb == rc->nmb)
512         return;
513
514     rcoeffs = (rc->nmb - rc->mb) * 16 * 24;
515     rbits = rc->fbits - rc->ufbits;
516 /*     if(rbits < 0) */
517 /*      rbits = 0; */
518
519 /*     zn = (rc->nmb - rc->mb) * 16 * 24; */
520     nonz = (rc->ncoeffs - rc->nzcoeffs);
521     if(nonz == 0)
522         zn = rcoeffs;
523     else if(rc->ufbits && rbits < INT_MAX / nonz)
524         zn = rcoeffs - rbits * nonz / rc->ufbits;
525     else
526         zn = 0;
527     zn = x264_clip3(zn, 0, rcoeffs);
528     enz = rc->nzcoeffs * (rc->nmb - rc->mb) / rc->mb;
529     dqp = (float) 2*h->param.rc.i_rc_sens * exp2f((float) rc->qps / rc->mb / 6) *
530         (zn - enz) / enz;
531     rc->qpm = x264_clip3(rc->qpm + dqp, rc->qp - 3, rc->qp + 3);
532     if(rbits <= 0)
533         rc->qpm++;
534     rc->qpm = x264_clip3(rc->qpm, h->param.rc.i_qp_min, h->param.rc.i_qp_max);
535 }
536
537 int  x264_ratecontrol_qp( x264_t *h )
538 {
539     return h->rc->qpm;
540 }
541
542 int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
543 {
544     if( h->param.rc.b_stat_read )
545     {
546         if( frame_num >= h->rc->num_entries )
547         {
548             x264_log(h, X264_LOG_ERROR, "More input frames than in the 1st pass\n");
549             return X264_TYPE_P;
550         }
551         switch( h->rc->entry[frame_num].pict_type )
552         {
553             case SLICE_TYPE_I:
554                 return h->rc->entry[frame_num].idr ? X264_TYPE_IDR : X264_TYPE_I;
555
556             case SLICE_TYPE_B:
557                 return X264_TYPE_B;
558
559             case SLICE_TYPE_P:
560             default:
561                 return X264_TYPE_P;
562         }
563     }
564     else
565     {
566         return X264_TYPE_AUTO;
567     }
568 }
569
570 void x264_ratecontrol_end( x264_t *h, int bits )
571 {
572     x264_ratecontrol_t *rc = h->rc;
573     int i;
574
575     x264_cpu_restore( h->param.cpu );
576
577     h->stat.frame.i_mb_count_skip = h->stat.frame.i_mb_count[P_SKIP] + h->stat.frame.i_mb_count[B_SKIP];
578     h->stat.frame.i_mb_count_p = h->stat.frame.i_mb_count[P_L0] + h->stat.frame.i_mb_count[P_8x8];
579     for( i = B_DIRECT; i < B_8x8; i++ )
580         h->stat.frame.i_mb_count_p += h->stat.frame.i_mb_count[i];
581
582     if( h->param.rc.b_stat_write )
583     {
584         char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
585                     : rc->slice_type==SLICE_TYPE_P ? 'P' : 'B';
586         fprintf( rc->p_stat_file_out,
587                  "in:%d out:%d type:%c q:%.3f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d;\n",
588                  h->fenc->i_frame, h->i_frame-1,
589                  c_type, rc->qpa,
590                  h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
591                  h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
592                  h->stat.frame.i_mb_count[I_4x4] + h->stat.frame.i_mb_count[I_16x16],
593                  h->stat.frame.i_mb_count_p,
594                  h->stat.frame.i_mb_count_skip);
595     }
596
597     if( !h->param.rc.b_cbr || h->param.rc.b_stat_read )
598         return;
599
600     rc->buffer_fullness += rc->rcbufrate - bits;
601     if(rc->buffer_fullness < 0){
602         x264_log(h, X264_LOG_WARNING, "buffer underflow %i\n",
603                  rc->buffer_fullness);
604         rc->buffer_fullness = 0;
605     }
606
607     rc->qpa = (float)rc->qps / rc->mb;
608     if(rc->slice_type == SLICE_TYPE_P){
609         rc->qp_avg_p += rc->qpa;
610         rc->qp_last_p = rc->qpa;
611         rc->pframes++;
612     } else if(rc->slice_type == SLICE_TYPE_I){
613         float err = (float) rc->ufbits / rc->fbits;
614         if(err > 1.1)
615             rc->gop_qp++;
616         else if(err < 0.9)
617             rc->gop_qp--;
618     }
619
620     rc->overhead = bits - rc->ufbits;
621
622     x264_log(h, X264_LOG_DEBUG, "bits=%i, qp=%.1f, z=%i, zr=%6.3f, buf=%i\n",
623              bits, rc->qpa, rc->nzcoeffs, (float) rc->nzcoeffs / rc->ncoeffs,
624              rc->buffer_fullness);
625
626     rc->bits_last_gop += bits;
627     rc->frames++;
628     rc->mb = 0;
629 }
630
631 /****************************************************************************
632  * 2 pass functions
633  ***************************************************************************/
634 double x264_eval( char *s, double *const_value, const char **const_name,
635                   double (**func1)(void *, double), const char **func1_name,
636                   double (**func2)(void *, double, double), char **func2_name,
637                   void *opaque );
638
639 /**
640  * modifies the bitrate curve from pass1 for one frame
641  */
642 static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor)
643 {
644     x264_ratecontrol_t *rcc= h->rc;
645     double bits;
646     const int pict_type = rce->pict_type;
647
648     double const_values[]={
649         rce->i_tex_bits * rce->qscale,
650         rce->p_tex_bits * rce->qscale,
651         (rce->i_tex_bits + rce->p_tex_bits) * rce->qscale,
652         rce->mv_bits / rcc->nmb,
653         (double)rce->i_count / rcc->nmb,
654         (double)rce->p_count / rcc->nmb,
655         (double)rce->s_count / rcc->nmb,
656         rce->pict_type == SLICE_TYPE_I,
657         rce->pict_type == SLICE_TYPE_P,
658         rce->pict_type == SLICE_TYPE_B,
659         h->param.rc.f_qcompress,
660         rcc->i_cplx_sum[SLICE_TYPE_I] / rcc->frame_count[SLICE_TYPE_I],
661         rcc->i_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
662         rcc->p_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
663         rcc->p_cplx_sum[SLICE_TYPE_B] / rcc->frame_count[SLICE_TYPE_B],
664         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / rcc->frame_count[pict_type],
665         rce->blurred_complexity,
666         0
667     };
668     static const char *const_names[]={
669         "iTex",
670         "pTex",
671         "tex",
672         "mv",
673         "iCount",
674         "pCount",
675         "sCount",
676         "isI",
677         "isP",
678         "isB",
679         "qComp",
680         "avgIITex",
681         "avgPITex",
682         "avgPPTex",
683         "avgBPTex",
684         "avgTex",
685         "blurTex",
686         NULL
687     };
688     static double (*func1[])(void *, double)={
689         (void *)bits2qscale,
690         (void *)qscale2bits,
691         NULL
692     };
693     static const char *func1_names[]={
694         "bits2qp",
695         "qp2bits",
696         NULL
697     };
698
699     bits = x264_eval((char*)h->param.rc.psz_rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
700
701     // avoid NaN's in the rc_eq
702     if(bits != bits || rce->i_tex_bits + rce->p_tex_bits == 0)
703         bits = 0;
704
705     bits *= rate_factor;
706     if(bits<0.0) bits=0.0;
707     bits += 1.0; //avoid 1/0 issues
708
709     return bits2qscale(rce, bits);
710 }
711
712 static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
713 {
714     x264_ratecontrol_t *rcc = h->rc;
715     const int pict_type = rce->pict_type;
716
717     // force I/B quants as a function of P quants
718     const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
719     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
720     if( pict_type == SLICE_TYPE_I )
721     {
722         double iq = q;
723         double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
724         double ip_factor = fabs( h->param.rc.f_ip_factor );
725         /* don't apply ip_factor if the following frame is also I */
726         if( rcc->accum_p_norm <= 0 )
727             q = iq;
728         else if( h->param.rc.f_ip_factor < 0 )
729             q = iq / ip_factor;
730         else if( rcc->accum_p_norm >= 1 )
731             q = pq / ip_factor;
732         else
733             q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
734     }
735     else if( pict_type == SLICE_TYPE_B )
736     {
737         if( h->param.rc.f_pb_factor > 0 )
738             q = last_non_b_q;
739         q *= fabs( h->param.rc.f_pb_factor );
740     }
741     else if( pict_type == SLICE_TYPE_P
742              && rcc->last_non_b_pict_type == SLICE_TYPE_P
743              && rce->i_tex_bits + rce->p_tex_bits == 0 )
744     {
745         q = last_p_q;
746     }
747
748     /* last qscale / qdiff stuff */
749     /* TODO take intro account whether the I-frame is a scene cut
750      * or just a seek point */
751     if(rcc->last_non_b_pict_type==pict_type
752        && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
753     {
754         double last_q = rcc->last_qscale_for[pict_type];
755         double max_qscale = last_q * rcc->lstep;
756         double min_qscale = last_q / rcc->lstep;
757
758         if     (q > max_qscale) q = max_qscale;
759         else if(q < min_qscale) q = min_qscale;
760     }
761
762     rcc->last_qscale_for[pict_type] = q;
763     if(pict_type!=SLICE_TYPE_B)
764         rcc->last_non_b_pict_type = pict_type;
765     if(pict_type==SLICE_TYPE_I)
766     {
767         rcc->last_accum_p_norm = rcc->accum_p_norm;
768         rcc->accum_p_norm = 0;
769         rcc->accum_p_qp = 0;
770     }
771     if(pict_type==SLICE_TYPE_P)
772     {
773         float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
774         rcc->accum_p_qp   = mask * (qscale2qp(q) + rcc->accum_p_qp);
775         rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
776     }
777     return q;
778 }
779
780 // clip a qscale to between lmin and lmax
781 static double clip_qscale( x264_t *h, ratecontrol_entry_t *rce, double q )
782 {
783     double lmin = h->rc->lmin[rce->pict_type];
784     double lmax = h->rc->lmax[rce->pict_type];
785
786     if(lmin==lmax){
787         return lmin;
788     }else{
789         double min2 = log(lmin);
790         double max2 = log(lmax);
791         q = (log(q) - min2)/(max2-min2) - 0.5;
792         q = 1.0/(1.0 + exp(-4*q));
793         q = q*(max2-min2) + min2;
794         return exp(q);
795     }
796 }
797
798 // update qscale for 1 frame based on actual bits used so far
799 static float rate_estimate_qscale(x264_t *h, int pict_type)
800 {
801     float q;
802     float br_compensation;
803     double diff;
804     int picture_number = h->fenc->i_frame;
805     x264_ratecontrol_t *rcc = h->rc;
806     ratecontrol_entry_t *rce;
807     double lmin = rcc->lmin[pict_type];
808     double lmax = rcc->lmax[pict_type];
809     int64_t total_bits = 8*(h->stat.i_slice_size[SLICE_TYPE_I]
810                           + h->stat.i_slice_size[SLICE_TYPE_P]
811                           + h->stat.i_slice_size[SLICE_TYPE_B]);
812
813 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
814
815     rce = &rcc->entry[picture_number];
816
817     assert(pict_type == rce->pict_type);
818
819     if(rce->pict_type == SLICE_TYPE_B)
820     {
821         return rcc->last_qscale * h->param.rc.f_pb_factor;
822     }
823     else
824     {
825         diff = (int64_t)total_bits - (int64_t)rce->expected_bits;
826         br_compensation = (rcc->buffer_size - diff) / rcc->buffer_size;
827         br_compensation = x264_clip3f(br_compensation, .5, 2);
828
829         q = rce->new_qscale / br_compensation;
830         q = x264_clip3f(q, lmin, lmax);
831         rcc->last_qscale = q;
832         return q;
833     }
834 }
835
836 static int init_pass2( x264_t *h )
837 {
838     x264_ratecontrol_t *rcc = h->rc;
839     uint64_t all_const_bits = 0;
840     uint64_t all_available_bits = (uint64_t)(h->param.rc.i_bitrate * 1000 * (double)rcc->num_entries / rcc->fps);
841     double rate_factor, step, step_mult;
842     double qblur = h->param.rc.f_qblur;
843     double cplxblur = h->param.rc.f_complexity_blur;
844     const int filter_size = (int)(qblur*4) | 1;
845     double expected_bits;
846     double *qscale, *blurred_qscale;
847     int i;
848
849     /* find total/average complexity & const_bits */
850     for(i=0; i<rcc->num_entries; i++){
851         ratecontrol_entry_t *rce = &rcc->entry[i];
852         all_const_bits += rce->mv_bits + rce->misc_bits;
853         rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
854         rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
855         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
856         rcc->frame_count[rce->pict_type] ++;
857     }
858
859     if( all_available_bits < all_const_bits)
860     {
861         x264_log(h, X264_LOG_ERROR, "requested bitrate is too low. estimated minimum is %d kbps\n",
862                  (int)(all_const_bits * rcc->fps / (rcc->num_entries * 1000)));
863         return -1;
864     }
865
866     for(i=0; i<rcc->num_entries; i++){
867         ratecontrol_entry_t *rce = &rcc->entry[i];
868         double weight_sum = 0;
869         double cplx_sum = 0;
870         double weight = 1.0;
871         int j;
872         /* weighted average of cplx of future frames */
873         for(j=1; j<cplxblur*2 && j<rcc->num_entries-i; j++){
874             ratecontrol_entry_t *rcj = &rcc->entry[i+j];
875             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
876             if(weight < .0001)
877                 break;
878             weight_sum += weight;
879             cplx_sum += weight * (rcj->i_tex_bits + rcj->p_tex_bits) * rce->qscale;
880         }
881         /* weighted average of cplx of past frames */
882         weight = 1.0;
883         for(j=0; j<cplxblur*2 && j<=i; j++){
884             ratecontrol_entry_t *rcj = &rcc->entry[i-j];
885             weight_sum += weight;
886             cplx_sum += weight * (rcj->i_tex_bits + rcj->p_tex_bits) * rce->qscale;
887             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
888             if(weight < .0001)
889                 break;
890         }
891         rce->blurred_complexity = cplx_sum / weight_sum;
892     }
893
894     qscale = x264_malloc(sizeof(double)*rcc->num_entries);
895     if(filter_size > 1)
896         blurred_qscale = x264_malloc(sizeof(double)*rcc->num_entries);
897     else
898         blurred_qscale = qscale;
899
900     expected_bits = 1;
901     for(i=0; i<rcc->num_entries; i++)
902         expected_bits += qscale2bits(&rcc->entry[i], get_qscale(h, &rcc->entry[i], 1.0));
903     step_mult = all_available_bits / expected_bits;
904
905     rate_factor = 0;
906     for(step = 1E4 * step_mult; step > 1E-7 * step_mult; step *= 0.5){
907         expected_bits = 0;
908         rate_factor += step;
909
910         rcc->last_non_b_pict_type = -1;
911         rcc->last_accum_p_norm = 1;
912
913         /* find qscale */
914         for(i=0; i<rcc->num_entries; i++){
915             qscale[i] = get_qscale(h, &rcc->entry[i], rate_factor);
916         }
917
918         /* fixed I/B QP relative to P mode */
919         for(i=rcc->num_entries-1; i>=0; i--){
920             qscale[i] = get_diff_limited_q(h, &rcc->entry[i], qscale[i]);
921             assert(qscale[i] >= 0);
922         }
923
924         /* smooth curve */
925         if(filter_size > 1){
926             assert(filter_size%2==1);
927             for(i=0; i<rcc->num_entries; i++){
928                 ratecontrol_entry_t *rce = &rcc->entry[i];
929                 int j;
930                 double q=0.0, sum=0.0;
931
932                 for(j=0; j<filter_size; j++){
933                     int index = i+j-filter_size/2;
934                     double d = index-i;
935                     double coeff = qblur==0 ? 1.0 : exp(-d*d/(qblur*qblur));
936                     if(index < 0 || index >= rcc->num_entries) continue;
937                     if(rce->pict_type != rcc->entry[index].pict_type) continue;
938                     q += qscale[index] * coeff;
939                     sum += coeff;
940                 }
941                 blurred_qscale[i] = q/sum;
942             }
943         }
944
945         /* find expected bits */
946         for(i=0; i<rcc->num_entries; i++){
947             ratecontrol_entry_t *rce = &rcc->entry[i];
948             double bits;
949             rce->new_qscale = clip_qscale(h, rce, blurred_qscale[i]);
950             assert(rce->new_qscale >= 0);
951             bits = qscale2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
952
953             rce->expected_bits = expected_bits;
954             expected_bits += bits;
955         }
956
957 //printf("expected:%llu available:%llu factor:%lf avgQ:%lf\n", (uint64_t)expected_bits, all_available_bits, rate_factor);
958         if(expected_bits > all_available_bits) rate_factor -= step;
959     }
960
961     x264_free(qscale);
962     if(filter_size > 1)
963         x264_free(blurred_qscale);
964
965     if(fabs(expected_bits/all_available_bits - 1.0) > 0.01)
966     {
967         double avgq = 0;
968         for(i=0; i<rcc->num_entries; i++)
969             avgq += rcc->entry[i].new_qscale;
970         avgq = qscale2qp(avgq / rcc->num_entries);
971
972         x264_log(h, X264_LOG_ERROR, "Error: 2pass curve failed to converge\n");
973         x264_log(h, X264_LOG_ERROR, "expected bits: %llu, available: %llu, avg QP: %.4lf\n", (uint64_t)expected_bits, all_available_bits, avgq);
974         if(expected_bits < all_available_bits && avgq < h->param.rc.i_qp_min + 1)
975             x264_log(h, X264_LOG_ERROR, "try reducing bitrate or reducing qp_min\n");
976         if(expected_bits > all_available_bits && avgq > h->param.rc.i_qp_min - 1)
977             x264_log(h, X264_LOG_ERROR, "try increasing bitrate or increasing qp_max\n");
978         return -1;
979     }
980
981     return 0;
982 }
983
984