shithub: libvpx

--- a/vp9/encoder/vp9_firstpass.c

+++ b/vp9/encoder/vp9_firstpass.c

@@ -2201,8 +2201,7 @@

   // Define middle frame

   mid_frame_idx = frame_index + (rc->baseline_gf_interval >> 1) - 1;

-  normal_frames =

-      rc->baseline_gf_interval - (key_frame || rc->source_alt_ref_pending);

+  normal_frames = (rc->baseline_gf_interval - rc->source_alt_ref_pending);

   if (normal_frames > 1)

     normal_frame_bits = (int)(total_group_bits / normal_frames);

   else

@@ -2441,9 +2440,8 @@

       loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);

       // Monitor for static sections.

-      if ((rc->frames_since_key + i - 1) > 1) {

-        zero_motion_accumulator *= get_zero_motion_factor(cpi, &next_frame);

-      }

+      zero_motion_accumulator = VPXMIN(

+          zero_motion_accumulator, get_zero_motion_factor(cpi, &next_frame));

       // Break clause to detect very still sections after motion. For example,

       // a static image after a fade or other transition.

@@ -2464,18 +2462,9 @@

     // Break out conditions.

-    // Break at maximum of active_max_gf_interval unless almost totally static.

-    //

-    // Note that the addition of a test of rc->source_alt_ref_active is

-    // deliberate. The effect of this is that after a normal altref group even

-    // if the material is static there will be one normal length GF group

-    // before allowing longer GF groups. The reason for this is that in cases

-    // such as slide shows where slides are separated by a complex transition

-    // such as a fade, the arf group spanning the transition may not be coded

-    // at a very high quality and hence this frame (with its overlay) is a

-    // poor golden frame to use for an extended group.

-    if (((i >= active_max_gf_interval) &&

-         ((zero_motion_accumulator < 0.995) || (rc->source_alt_ref_active))) ||

+    if (

+        // Break at active_max_gf_interval unless almost totally static.

+        ((i >= active_max_gf_interval) && (zero_motion_accumulator < 0.995)) ||

             // Don't break out with a very short interval.

             (i >= active_min_gf_interval) &&

@@ -2495,8 +2484,8 @@

   rc->constrained_gf_group = (i >= rc->frames_to_key) ? 1 : 0;

   // Should we use the alternate reference frame.

-  if ((zero_motion_accumulator < 0.995) && allow_alt_ref &&

-      (i < cpi->oxcf.lag_in_frames) && (i >= rc->min_gf_interval)) {

+  if (allow_alt_ref && (i < cpi->oxcf.lag_in_frames) &&

+      (i >= rc->min_gf_interval)) {

     const int forward_frames = (rc->frames_to_key - i >= i - 1)

                                    ? i - 1

                                    : VPXMAX(0, rc->frames_to_key - i);

@@ -2523,11 +2512,8 @@

   rc->gfu_boost = VPXMIN((int)rc->gfu_boost, i * 200);

 #endif

-  rc->baseline_gf_interval =

-      ((twopass->kf_zeromotion_pct >= STATIC_KF_GROUP_THRESH) &&

-       (i >= rc->frames_to_key))

-          ? i

-          : (i - (is_key_frame || rc->source_alt_ref_pending));

+  // Set the interval until the next gf.

+  rc->baseline_gf_interval = i - (is_key_frame || rc->source_alt_ref_pending);

   rc->frames_till_gf_update_due = rc->baseline_gf_interval;

@@ -2774,7 +2760,6 @@

   vp9_zero(next_frame);

   cpi->common.frame_type = KEY_FRAME;

-  rc->frames_since_key = 0;

   // Reset the GF group data structures.

   vp9_zero(*gf_group);

@@ -2919,22 +2904,13 @@

   for (i = 0; i < (rc->frames_to_key - 1); ++i) {

     if (EOF == input_stats(twopass, &next_frame)) break;

-    // The zero motion test here insures that if we mark a kf group as static

-    // it is static throughout not just the first KF_BOOST_SCAN_MAX_FRAMES.

-    // It also allows for a larger boost on long static groups.

-    if ((i <= KF_BOOST_SCAN_MAX_FRAMES) || (zero_motion_accumulator >= 0.99)) {

+    if (i <= KF_BOOST_SCAN_MAX_FRAMES) {

       double frame_boost;

       double zm_factor;

       // Monitor for static sections.

-      // First frame in kf group the second ref indicator is invalid.

-      if (i > 0) {

-        zero_motion_accumulator = VPXMIN(

-            zero_motion_accumulator, get_zero_motion_factor(cpi, &next_frame));

-      } else {

-        zero_motion_accumulator =

-            next_frame.pcnt_inter - next_frame.pcnt_motion;

-      }

+      zero_motion_accumulator = VPXMIN(

+          zero_motion_accumulator, get_zero_motion_factor(cpi, &next_frame));

       // Factor 0.75-1.25 based on how much of frame is static.

       zm_factor = (0.75 + (zero_motion_accumulator / 2.0));

@@ -2971,16 +2947,10 @@

   twopass->section_intra_rating = calculate_section_intra_ratio(

       start_position, twopass->stats_in_end, rc->frames_to_key);

-  // Special case for static / slide show content but dont apply

-  // if the kf group is very short.

-  if ((zero_motion_accumulator > 0.99) && (rc->frames_to_key > 8)) {

-    rc->kf_boost = VPXMAX((rc->frames_to_key * 100), MAX_KF_TOT_BOOST);

-  } else {

-    // Apply various clamps for min and max boost

-    rc->kf_boost = VPXMAX((int)boost_score, (rc->frames_to_key * 3));

-    rc->kf_boost = VPXMAX(rc->kf_boost, MIN_KF_TOT_BOOST);

-    rc->kf_boost = VPXMIN(rc->kf_boost, MAX_KF_TOT_BOOST);

-  }

+  // Apply various clamps for min and max boost

+  rc->kf_boost = VPXMAX((int)boost_score, (rc->frames_to_key * 3));

+  rc->kf_boost = VPXMAX(rc->kf_boost, MIN_KF_TOT_BOOST);

+  rc->kf_boost = VPXMIN(rc->kf_boost, MAX_KF_TOT_BOOST);

   // Work out how many bits to allocate for the key frame itself.

   kf_bits = calculate_boost_bits((rc->frames_to_key - 1), rc->kf_boost,

--- a/vp9/encoder/vp9_firstpass.h

+++ b/vp9/encoder/vp9_firstpass.h

@@ -120,12 +120,12 @@

 typedef struct {

   unsigned char index;

   unsigned char first_inter_index;

-  RATE_FACTOR_LEVEL rf_level[MAX_STATIC_GF_GROUP_LENGTH + 1];

-  FRAME_UPDATE_TYPE update_type[MAX_STATIC_GF_GROUP_LENGTH + 1];

-  unsigned char arf_src_offset[MAX_STATIC_GF_GROUP_LENGTH + 1];

-  unsigned char arf_update_idx[MAX_STATIC_GF_GROUP_LENGTH + 1];

-  unsigned char arf_ref_idx[MAX_STATIC_GF_GROUP_LENGTH + 1];

-  int bit_allocation[MAX_STATIC_GF_GROUP_LENGTH + 1];

+  RATE_FACTOR_LEVEL rf_level[(MAX_LAG_BUFFERS * 2) + 1];

+  FRAME_UPDATE_TYPE update_type[(MAX_LAG_BUFFERS * 2) + 1];

+  unsigned char arf_src_offset[(MAX_LAG_BUFFERS * 2) + 1];

+  unsigned char arf_update_idx[(MAX_LAG_BUFFERS * 2) + 1];

+  unsigned char arf_ref_idx[(MAX_LAG_BUFFERS * 2) + 1];

+  int bit_allocation[(MAX_LAG_BUFFERS * 2) + 1];

 } GF_GROUP;

 typedef struct {

--- a/vp9/encoder/vp9_ratectrl.c

+++ b/vp9/encoder/vp9_ratectrl.c

@@ -1222,9 +1222,6 @@

       // Baseline value derived from cpi->active_worst_quality and kf boost.

       active_best_quality =

           get_kf_active_quality(rc, active_worst_quality, cm->bit_depth);

-      if (cpi->twopass.kf_zeromotion_pct >= STATIC_KF_GROUP_THRESH) {

-        active_best_quality /= 4;

-      }

       // Allow somewhat lower kf minq with small image formats.

       if ((cm->width * cm->height) <= (352 * 288)) {

@@ -1971,8 +1968,13 @@

       rc->max_gf_interval = vp9_rc_get_default_max_gf_interval(

           cpi->framerate, rc->min_gf_interval);

-    // Extended max interval for genuinely static scenes like slide shows.

-    rc->static_scene_max_gf_interval = MAX_STATIC_GF_GROUP_LENGTH;

+    // Extended interval for genuinely static scenes

+    rc->static_scene_max_gf_interval = MAX_LAG_BUFFERS * 2;

+    if (is_altref_enabled(cpi)) {

+      if (rc->static_scene_max_gf_interval > oxcf->lag_in_frames - 1)

+        rc->static_scene_max_gf_interval = oxcf->lag_in_frames - 1;

+    }

     if (rc->max_gf_interval > rc->static_scene_max_gf_interval)

       rc->max_gf_interval = rc->static_scene_max_gf_interval;

--- a/vp9/encoder/vp9_ratectrl.h

+++ b/vp9/encoder/vp9_ratectrl.h

@@ -34,14 +34,6 @@

 #define FRAME_OVERHEAD_BITS 200

-// Threshold used to define a KF group as static (e.g. a slide show).

-// Essentially this means that no frame in the group has more than 1% of MBs

-// that are not marked as coded with 0,0 motion in the first pass.

-#define STATIC_KF_GROUP_THRESH 99

-// The maximum duration of a GF group that is static (for example a slide show).

-#define MAX_STATIC_GF_GROUP_LENGTH 25

 typedef enum {

   INTER_NORMAL = 0,

   INTER_HIGH = 1,