int_mv ref_mv_full;
int tmp_err;
- int step_param = 3; //3; // Dont search over full range for first pass
- int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param; //3;
+ int step_param = 3;
+ int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
int n;
vp8_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
int new_mv_mode_penalty = 256;
// Experimental search in an older reference frame
if (cm->current_video_frame > 1)
{
+ // Simple 0,0 motion with no mv overhead
+ zz_motion_search( cpi, x, gld_yv12,
+ &gf_motion_error, recon_yoffset );
+
first_pass_motion_search(cpi, x, &zero_ref_mv,
&tmp_mv.as_mv, gld_yv12,
&gf_motion_error, recon_yoffset);
fps.MVrv = 0.0;
fps.MVcv = 0.0;
fps.mv_in_out_count = 0.0;
+ fps.new_mv_count = 0.0;
fps.count = 1.0;
fps.pcnt_inter = 1.0 * (double)intercount / cm->MBs;
return 0;
}
-static double calc_correction_factor( VP8_COMP *cpi,
- FIRSTPASS_STATS * fpstats,
- double err_per_mb,
+static double calc_correction_factor( double err_per_mb,
double err_divisor,
double pt_low,
double pt_high,
double power_term;
double error_term = err_per_mb / err_divisor;
double correction_factor;
- double sr_err_diff;
- double sr_correction;
-
// Adjustment based on actual quantizer to power term.
power_term = (vp8_convert_qindex_to_q(Q) * 0.01) + pt_low;
// Adjustments to error term
// TBD
- // Calculate a correction factor based on error per mb
+ // Calculate correction factor
correction_factor = pow(error_term, power_term);
-#if 0
- // Look at the drop in prediction quality between the last frame
- // and the GF buffer (which contained an older frame).
- sr_err_diff =
- (fpstats->sr_coded_error - fpstats->coded_error) /
- (fpstats->count * cpi->common.MBs * 32);
- sr_correction = pow( sr_err_diff, 0.5 );
- if ( sr_correction < 0.5 )
- sr_correction = 0.5;
- else if ( sr_correction > 1.25 )
- sr_correction = 1.25;
-
- correction_factor = correction_factor * sr_correction;
-#endif
-
// Clip range
correction_factor =
(correction_factor < 0.05)
int target_norm_bits_per_mb;
double section_err = (fpstats->coded_error / fpstats->count);
+ double sr_err_diff;
+ double sr_correction;
double err_per_mb = section_err / num_mbs;
double err_correction_factor;
double corr_high;
? (512 * section_target_bandwitdh) / num_mbs
: 512 * (section_target_bandwitdh / num_mbs);
+ // Look at the drop in prediction quality between the last frame
+ // and the GF buffer (which contained an older frame).
+ sr_err_diff =
+ (fpstats->sr_coded_error - fpstats->coded_error) /
+ (fpstats->count * cpi->common.MBs);
+ sr_correction = (sr_err_diff / 32.0);
+ sr_correction = pow( sr_correction, 0.25 );
+ if ( sr_correction < 0.75 )
+ sr_correction = 0.75;
+ else if ( sr_correction > 1.25 )
+ sr_correction = 1.25;
+
// Calculate a corrective factor based on a rolling ratio of bits spent
// vs target bits
if ((cpi->rolling_target_bits > 0) &&
{
int bits_per_mb_at_this_q;
- // Error per MB based correction factor
err_correction_factor =
- calc_correction_factor(cpi, fpstats, err_per_mb,
- ERR_DIVISOR, 0.40, 0.90, Q) *
- speed_correction *
+ calc_correction_factor(err_per_mb, ERR_DIVISOR, 0.4, 0.90, Q) *
+ sr_correction * speed_correction *
cpi->twopass.est_max_qcorrection_factor;
if ( err_correction_factor < 0.05 )
double section_err = (fpstats->coded_error / fpstats->count);
double err_per_mb = section_err / num_mbs;
double err_correction_factor;
+ double sr_err_diff;
+ double sr_correction;
double corr_high;
double speed_correction = 1.0;
double clip_iiratio;
double intra_pct = 1.0 - inter_pct;
int overhead_bits_per_mb;
- if (0)
- {
- FILE *f = fopen("epmp.stt", "a");
- fprintf(f, "%10.2f\n", err_per_mb );
- fclose(f);
- }
target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
? (512 * section_target_bandwitdh) / num_mbs
speed_correction = 1.25;
}
+ // Look at the drop in prediction quality between the last frame
+ // and the GF buffer (which contained an older frame).
+ sr_err_diff =
+ (fpstats->sr_coded_error - fpstats->coded_error) /
+ (fpstats->count * cpi->common.MBs);
+ sr_correction = (sr_err_diff / 32.0);
+ sr_correction = pow( sr_correction, 0.25 );
+ if ( sr_correction < 0.75 )
+ sr_correction = 0.75;
+ else if ( sr_correction > 1.25 )
+ sr_correction = 1.25;
+
// II ratio correction factor for clip as a whole
clip_iiratio = cpi->twopass.total_stats->intra_error /
DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats->coded_error);
// Error per MB based correction factor
err_correction_factor =
- calc_correction_factor(cpi, fpstats, err_per_mb,
- 100.0, 0.40, 0.90, Q) *
- speed_correction * clip_iifactor;
+ calc_correction_factor(err_per_mb, 100.0, 0.4, 0.90, Q) *
+ sr_correction * speed_correction * clip_iifactor;
if ( err_correction_factor < 0.05 )
err_correction_factor = 0.05;
bits_per_mb_at_this_q =
vp8_bits_per_mb(INTER_FRAME, Q) + overhead_bits_per_mb;
- bits_per_mb_at_this_q =
- (int)( .5 + err_correction_factor *
- (double)bits_per_mb_at_this_q);
+ bits_per_mb_at_this_q = (int)(.5 + err_correction_factor *
+ (double)bits_per_mb_at_this_q);
// Mode and motion overhead
// As Q rises in real encode loop rd code will force overhead down
// This function gives and estimate of how badly we believe
// the prediction quality is decaying from frame to frame.
-static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
+static double get_prediction_decay_rate( VP8_COMP *cpi,
+ FIRSTPASS_STATS *next_frame)
{
double prediction_decay_rate;
double second_ref_decay;
double mb_sr_err_diff;
// Initial basis is the % mbs inter coded
- prediction_decay_rate = pow(next_frame->pcnt_inter, 0.5);
+ prediction_decay_rate = next_frame->pcnt_inter;
// Look at the observed drop in prediction quality between the last frame
// and the GF buffer (which contains an older frame).
(next_frame.pcnt_second_ref >= 0.5 ) )
{
flash_detected = TRUE;
-
- /*if (1)
- {
- FILE *f = fopen("flash.stt", "a");
- fprintf(f, "%8.0f %6.2f %6.2f\n",
- next_frame.frame,
- next_frame.pcnt_inter,
- next_frame.pcnt_second_ref);
- fclose(f);
- }*/
}
}
unsigned int allow_alt_ref =
cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
- int alt_boost = 0;
int f_boost = 0;
int b_boost = 0;
BOOL flash_detected;
// Accumulate error score of frames in this gf group
mod_frame_err = calculate_modified_err(cpi, this_frame);
-
gf_group_err += mod_frame_err;
if (EOF == input_stats(cpi, &next_frame))
}
}
- cpi->gfu_boost = boost_score;
-
- // Alterrnative boost calculation for alt ref
- alt_boost = calc_arf_boost( cpi, 0, (i-1), (i-1), &f_boost, &b_boost );
-
- // Set the interval till the next gf or arf.
+ // Set the interval till the next gf or arf.
cpi->baseline_gf_interval = i;
// Should we use the alternate refernce frame
(next_frame.pcnt_second_ref > 0.5)) &&
((mv_in_out_accumulator / (double)i > -0.2) ||
(mv_in_out_accumulator > -2.0)) &&
- ((b_boost + f_boost) > 100) )
+ (boost_score > 100))
{
- cpi->gfu_boost = alt_boost;
+ // Alterrnative boost calculation for alt ref
+ cpi->gfu_boost = calc_arf_boost( cpi, 0, (i-1), (i-1), &f_boost, &b_boost );
cpi->source_alt_ref_pending = TRUE;
configure_arnr_filter( cpi, this_frame );
}
else
{
+ cpi->gfu_boost = (int)boost_score;
cpi->source_alt_ref_pending = FALSE;
}
else
cpi->twopass.alt_extra_bits = 0;
}
+
+ if (cpi->common.frame_type != KEY_FRAME)
+ {
+ FIRSTPASS_STATS sectionstats;
+
+ zero_stats(§ionstats);
+ reset_fpf_position(cpi, start_pos);
+
+ for (i = 0 ; i < cpi->baseline_gf_interval ; i++)
+ {
+ input_stats(cpi, &next_frame);
+ accumulate_stats(§ionstats, &next_frame);
+ }
+
+ avg_stats(§ionstats);
+
+ cpi->twopass.section_intra_rating =
+ sectionstats.intra_error /
+ DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
+
+ reset_fpf_position(cpi, start_pos);
+ }
}
// Allocate bits to a normal frame that is neither a gf an arf or a key frame.
target_frame_size += cpi->min_frame_bandwidth; // Add in the minimum number of bits that is set aside for every frame.
- // Every other frame gets a few extra bits
- if ( (cpi->common.frames_since_golden & 0x01) &&
- (cpi->frames_till_gf_update_due > 0) )
- {
- target_frame_size += cpi->twopass.alt_extra_bits;
- }
cpi->per_frame_bandwidth = target_frame_size; // Per frame bit target for this frame
}
(next_frame->pcnt_second_ref < 0.10) &&
((this_frame->pcnt_inter < 0.05) ||
(
- ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
+ ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .35) &&
((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
(fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) ||
boost_score = 0.0;
loop_decay_rate = 1.00; // Starting decay rate
- for (i = 0; i < cpi->twopass.frames_to_key; i++)
+ for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
{
double r;
}
// How fast is prediction quality decaying
- loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
-
- decay_accumulator = decay_accumulator * loop_decay_rate;
- decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
+ if ( !detect_flash(cpi, 0) )
+ {
+ loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
+ decay_accumulator = decay_accumulator * loop_decay_rate;
+ decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
+ }
boost_score += (decay_accumulator * r);
old_boost_score = boost_score;
}
+ {
+ FIRSTPASS_STATS sectionstats;
+
+ zero_stats(§ionstats);
+ reset_fpf_position(cpi, start_position);
+
+ for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
+ {
+ input_stats(cpi, &next_frame);
+ accumulate_stats(§ionstats, &next_frame);
+ }
+
+ avg_stats(§ionstats);
+
+ cpi->twopass.section_intra_rating =
+ sectionstats.intra_error
+ / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
+ }
+
// Reset the first pass file position
reset_fpf_position(cpi, start_position);
if (kf_boost < 250) // Min KF boost
kf_boost = 250;
- // Make a not of baseline boost and the zero motion
+ // Make a note of baseline boost and the zero motion
// accumulator value for use elsewhere.
cpi->kf_boost = kf_boost;
cpi->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
// allocation it would have received based on its own error score vs
// the error score remaining
// Special case if the sequence appears almost totaly static
- // as measured by the decay accumulator. In this case we want to
- // spend almost all of the bits on the key frame.
+ // In this case we want to spend almost all of the bits on the
+ // key frame.
// cpi->twopass.frames_to_key-1 because key frame itself is taken
// care of by kf_boost.
if ( zero_motion_accumulator >= 0.99 )
int zbin_boost[16] = { 0, 0, 8, 10, 12, 14, 16, 20,
24, 28, 32, 36, 40, 44, 44, 44};
- int zbin_boost_8x8[64] = { 0, 0, 8, 10, 12, 14, 16, 20,
- 24, 28, 32, 36, 40, 44, 48, 52,
- 56, 60, 64, 68, 72, 76, 80, 80,
- 80, 80, 80, 80, 80, 80, 80, 80,
- 80, 80, 80, 80, 80, 80, 80, 80,
- 80, 80, 80, 80, 80, 80, 80, 80,
- 80, 80, 80, 80, 80, 80, 80, 80,
- 80, 80, 80, 80, 80, 80, 80, 80 };
+ int zbin_boost_8x8[64] = { 0, 0, 0, 8, 8, 8, 10, 12,
+ 14, 16, 18, 20, 22, 24, 26, 28,
+ 30, 32, 34, 36, 38, 40, 42, 44,
+ 46, 48, 48, 48, 48, 48, 48, 48,
+ 48, 48, 48, 48, 48, 48, 48, 48,
+ 48, 48, 48, 48, 48, 48, 48, 48,
+ 48, 48, 48, 48, 48, 48, 48, 48,
+ 48, 48, 48, 48, 48, 48, 48, 48 };
int qrounding_factor = 48;
+
for (Q = 0; Q < QINDEX_RANGE; Q++)
{
int qzbin_factor = (vp8_dc_quant(Q,0) < 148) ? 84 : 80;
projects / libvpx / commitdiff