#include "common/common.h"
#include "common/cpu.h"
#include "ratecontrol.h"
+#include "me.h"
typedef struct
{
int s_count;
float blurred_complexity;
char direct_mode;
+ int refcount[16];
+ int refs;
} ratecontrol_entry_t;
typedef struct
goto fail;
for( i = 0; i < h->mb.i_mb_count; i++ )
+ {
frame->f_qp_offset[i] = ((float)(int16_t)endian_fix16( rc->qp_buffer[i] )) * (1/256.0);
+ if( h->frames.b_have_lowres )
+ frame->i_inv_qscale_factor[i] = x264_exp2fix8(frame->f_qp_offset[i]);
+ }
}
else
x264_adaptive_quant_frame( h, frame );
return -1;
}
+int x264_reference_build_list_optimal( x264_t *h )
+{
+ ratecontrol_entry_t *rce = h->rc->rce;
+ x264_frame_t *frames[16];
+ int ref, i;
+
+ if( rce->refs != h->i_ref0 )
+ return -1;
+
+ memcpy( frames, h->fref0, sizeof(frames) );
+
+ /* For now don't reorder ref 0; it seems to lower quality
+ in most cases due to skips. */
+ for( ref = 1; ref < h->i_ref0; ref++ )
+ {
+ int max = -1;
+ int bestref = 1;
+ for( i = 1; i < h->i_ref0; i++ )
+ /* Favor lower POC as a tiebreaker. */
+ COPY2_IF_GT( max, rce->refcount[i], bestref, i );
+ rce->refcount[bestref] = -1;
+ h->fref0[ref] = frames[bestref];
+ }
+
+ return 0;
+}
+
static char *x264_strcat_filename( char *input, char *suffix )
{
char *output = x264_malloc( strlen( input ) + strlen( suffix ) + 1 );
int e;
char *next;
float qp;
+ int ref;
next= strchr(p, ';');
if(next)
&rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
&rce->s_count, &rce->direct_mode);
+ p = strstr( p, "ref:" );
+ if( !p )
+ goto parse_error;
+ p += 4;
+ for( ref = 0; ref < 16; ref++ )
+ {
+ if( sscanf( p, " %d", &rce->refcount[ref] ) != 1 )
+ break;
+ p = strchr( p+1, ' ' );
+ if( !p )
+ goto parse_error;
+ }
+ rce->refs = ref;
+
switch(pict_type)
{
case 'I': rce->kept_as_ref = 1;
}
if(e < 10)
{
+parse_error:
x264_log(h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
return -1;
}
double pred_t = 0;
if( h->sh.i_type == SLICE_TYPE_I || qp >= h->fref0[0]->i_row_qp[y] )
{
- if( h->sh.i_type != SLICE_TYPE_I
+ if( h->sh.i_type == SLICE_TYPE_P
&& h->fref0[0]->i_type == h->fdec->i_type
&& h->fref0[0]->i_row_satd[y] > 0
&& (abs(h->fref0[0]->i_row_satd[y] - h->fdec->i_row_satd[y]) < h->fdec->i_row_satd[y]/2))
h->fdec->i_row_qp[y] = rc->qpm;
- if( h->sh.i_type == SLICE_TYPE_B )
+ update_predictor( rc->row_pred[0], qp2qscale(rc->qpm), h->fdec->i_row_satd[y], h->fdec->i_row_bits[y] );
+ if( h->sh.i_type == SLICE_TYPE_P && rc->qpm < h->fref0[0]->i_row_qp[y] )
{
- /* B-frames shouldn't use lower QP than their reference frames.
- * This code is a bit overzealous in limiting B-frame quantizers, but it helps avoid
- * underflows due to the fact that B-frames are not explicitly covered by VBV. */
- if( y < h->sps->i_mb_height-1 )
- {
- int i_estimated;
- int avg_qp = X264_MIN(h->fref0[0]->i_row_qp[y+1], h->fref1[0]->i_row_qp[y+1])
- + rc->pb_offset * ((h->fenc->i_type == X264_TYPE_BREF) ? 0.5 : 1);
- rc->qpm = X264_MIN(X264_MAX( rc->qp, avg_qp), 51); //avg_qp could go higher than 51 due to pb_offset
- i_estimated = row_bits_so_far(h, y); //FIXME: compute full estimated size
- if (i_estimated > h->rc->frame_size_planned)
- x264_ratecontrol_set_estimated_size(h, i_estimated);
- }
+ double newq = qp2qscale(rc->qpm);
+ double oldq = qp2qscale(h->fref0[0]->i_row_qp[y]);
+ update_predictor( rc->row_pred[1], (1 - newq / oldq) * newq, h->fdec->i_row_satds[0][0][y], h->fdec->i_row_bits[y] );
}
- else
+
+ /* tweak quality based on difference from predicted size */
+ if( y < h->sps->i_mb_height-1 )
{
- update_predictor( rc->row_pred[0], qp2qscale(rc->qpm), h->fdec->i_row_satd[y], h->fdec->i_row_bits[y] );
- if( h->sh.i_type != SLICE_TYPE_I && rc->qpm < h->fref0[0]->i_row_qp[y] )
+ int prev_row_qp = h->fdec->i_row_qp[y];
+ int i_qp_max = X264_MIN( prev_row_qp + h->param.rc.i_qp_step, h->param.rc.i_qp_max );
+ int i_qp_min = X264_MAX( prev_row_qp - h->param.rc.i_qp_step, h->param.rc.i_qp_min );
+
+ /* B-frames shouldn't use lower QP than their reference frames. */
+ if( h->sh.i_type == SLICE_TYPE_B )
{
- double newq = qp2qscale(rc->qpm);
- double oldq = qp2qscale(h->fref0[0]->i_row_qp[y]);
- update_predictor( rc->row_pred[1], (1 - newq / oldq) * newq, h->fdec->i_row_satds[0][0][y], h->fdec->i_row_bits[y] );
+ i_qp_min = X264_MAX( i_qp_min, X264_MAX( h->fref0[0]->i_row_qp[y+1], h->fref1[0]->i_row_qp[y+1] ) );
+ rc->qpm = X264_MAX( rc->qpm, i_qp_min );
}
- /* tweak quality based on difference from predicted size */
- if( y < h->sps->i_mb_height-1 )// && h->stat.i_frame_count[h->sh.i_type] > 0 )
- {
- int prev_row_qp = h->fdec->i_row_qp[y];
- int b0 = predict_row_size_sum( h, y, rc->qpm );
- int b1 = b0;
- int i_qp_max = X264_MIN( prev_row_qp + h->param.rc.i_qp_step, h->param.rc.i_qp_max );
- int i_qp_min = X264_MAX( prev_row_qp - h->param.rc.i_qp_step, h->param.rc.i_qp_min );
- float buffer_left_planned = rc->buffer_fill - rc->frame_size_planned;
-
- /* More threads means we have to be more cautious in letting ratecontrol use up extra bits.
- * In 2-pass mode we can be more trusting of the planned frame sizes, since they were decided
- * by actual encoding instead of SATD prediction. */
- float rc_tol = h->param.rc.b_stat_read ? (buffer_left_planned / rc->buffer_size) * rc->frame_size_planned
- : (buffer_left_planned / h->param.i_threads);
- /* Don't modify the row QPs until a sufficent amount of the bits of the frame have been processed, in case a flat */
- /* area at the top of the frame was measured inaccurately. */
- if( row_bits_so_far(h,y) < 0.05 * rc->frame_size_planned )
- return;
-
- if(h->sh.i_type != SLICE_TYPE_I)
- rc_tol /= 2;
-
- if( !rc->b_vbv_min_rate )
- i_qp_min = X264_MAX( i_qp_min, h->sh.i_qp );
-
- while( rc->qpm < i_qp_max
- && ((b1 > rc->frame_size_planned + rc_tol) ||
- (rc->buffer_fill - b1 < buffer_left_planned * 0.5) ||
- (b1 > rc->frame_size_planned && rc->qpm < rc->qp_novbv)) )
- {
- rc->qpm ++;
- b1 = predict_row_size_sum( h, y, rc->qpm );
- }
+ int b0 = predict_row_size_sum( h, y, rc->qpm );
+ int b1 = b0;
+ float buffer_left_planned = rc->buffer_fill - rc->frame_size_planned;
- while( rc->qpm > i_qp_min
- && (rc->qpm > h->fdec->i_row_qp[0] || rc->single_frame_vbv)
- && ((b1 < rc->frame_size_planned * 0.8 && rc->qpm <= prev_row_qp)
- || b1 < (rc->buffer_fill - rc->buffer_size + rc->buffer_rate) * 1.1) )
- {
- rc->qpm --;
- b1 = predict_row_size_sum( h, y, rc->qpm );
- }
+ /* More threads means we have to be more cautious in letting ratecontrol use up extra bits. */
+ float rc_tol = buffer_left_planned / h->param.i_threads * rc->rate_tolerance;
- /* avoid VBV underflow */
- while( (rc->qpm < h->param.rc.i_qp_max)
- && (rc->buffer_fill - b1 < rc->buffer_rate * 0.05 ) )
- {
- rc->qpm ++;
- b1 = predict_row_size_sum( h, y, rc->qpm );
- }
+ /* Don't modify the row QPs until a sufficent amount of the bits of the frame have been processed, in case a flat */
+ /* area at the top of the frame was measured inaccurately. */
+ if( row_bits_so_far(h,y) < 0.05 * rc->frame_size_planned )
+ return;
+
+ if( h->sh.i_type != SLICE_TYPE_I )
+ rc_tol /= 2;
+
+ if( !rc->b_vbv_min_rate )
+ i_qp_min = X264_MAX( i_qp_min, h->sh.i_qp );
+
+ while( rc->qpm < i_qp_max
+ && ((b1 > rc->frame_size_planned + rc_tol) ||
+ (rc->buffer_fill - b1 < buffer_left_planned * 0.5) ||
+ (b1 > rc->frame_size_planned && rc->qpm < rc->qp_novbv)) )
+ {
+ rc->qpm ++;
+ b1 = predict_row_size_sum( h, y, rc->qpm );
+ }
+
+ while( rc->qpm > i_qp_min
+ && (rc->qpm > h->fdec->i_row_qp[0] || rc->single_frame_vbv)
+ && ((b1 < rc->frame_size_planned * 0.8 && rc->qpm <= prev_row_qp)
+ || b1 < (rc->buffer_fill - rc->buffer_size + rc->buffer_rate) * 1.1) )
+ {
+ rc->qpm --;
+ b1 = predict_row_size_sum( h, y, rc->qpm );
+ }
- x264_ratecontrol_set_estimated_size(h, b1);
+ /* avoid VBV underflow */
+ while( (rc->qpm < h->param.rc.i_qp_max)
+ && (rc->buffer_fill - b1 < rc->buffer_rate * 0.05 ) )
+ {
+ rc->qpm ++;
+ b1 = predict_row_size_sum( h, y, rc->qpm );
}
+
+ x264_ratecontrol_set_estimated_size(h, b1);
}
+
/* loses the fractional part of the frame-wise qp */
rc->f_qpm = rc->qpm;
}
dir_avg>0 ? 's' : dir_avg<0 ? 't' : '-' )
: '-';
if( fprintf( rc->p_stat_file_out,
- "in:%d out:%d type:%c q:%.2f tex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c;\n",
+ "in:%d out:%d type:%c q:%.2f tex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c ref:",
h->fenc->i_frame, h->i_frame,
c_type, rc->qpa_rc,
h->stat.frame.i_tex_bits,
h->stat.frame.i_mb_count_p,
h->stat.frame.i_mb_count_skip,
c_direct) < 0 )
- goto fail;
+ goto fail;
+
+ for( i = 0; i < h->i_ref0; i++ )
+ {
+ int refcount = h->param.b_interlaced ? h->stat.frame.i_mb_count_ref[0][i*2]
+ + h->stat.frame.i_mb_count_ref[0][i*2+1] :
+ h->stat.frame.i_mb_count_ref[0][i];
+ if( fprintf( rc->p_stat_file_out, "%d ", refcount ) < 0 )
+ goto fail;
+ }
+
+ if( fprintf( rc->p_stat_file_out, ";\n" ) < 0 )
+ goto fail;
/* Don't re-write the data in multi-pass mode. */
if( h->param.rc.b_mb_tree && h->fenc->b_kept_as_ref && !h->param.rc.b_stat_read )
else
q += rcc->pb_offset;
- rcc->frame_size_planned = predict_size( rcc->pred_b_from_p, q, h->fref1[h->i_ref1-1]->i_satd );
+ if( rcc->b_2pass && rcc->b_vbv )
+ rcc->frame_size_planned = qscale2bits( &rce, q );
+ else
+ rcc->frame_size_planned = predict_size( rcc->pred_b_from_p, q, h->fref1[h->i_ref1-1]->i_satd );
x264_ratecontrol_set_estimated_size(h, rcc->frame_size_planned);
- rcc->last_satd = 0;
+
+ /* For row SATDs */
+ if( rcc->b_vbv )
+ rcc->last_satd = x264_rc_analyse_slice( h );
return qp2qscale(q);
}
else
expected_size = qscale2bits(&rce, q);
expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
}
- rcc->last_satd = x264_stack_align( x264_rc_analyse_slice, h );
+ rcc->last_satd = x264_rc_analyse_slice( h );
}
q = x264_clip3f( q, lmin, lmax );
}
double wanted_bits, overflow=1, lmin, lmax;
- rcc->last_satd = x264_stack_align( x264_rc_analyse_slice, h );
+ rcc->last_satd = x264_rc_analyse_slice( h );
rcc->short_term_cplxsum *= 0.5;
rcc->short_term_cplxcount *= 0.5;
rcc->short_term_cplxsum += rcc->last_satd;
projects / x264 / blobdiff