Removed unused GOP decision functions.
These functions are replaced by the updated strategy based on
first pass stats analysis.
Change-Id: I839f8dabe568a85d50d3c8db5337eddb03482c83
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c
index cd69c4c..0016a25 100644
--- a/av1/encoder/pass2_strategy.c
+++ b/av1/encoder/pass2_strategy.c
@@ -971,245 +971,13 @@
return 0;
}
-#define MAX_PAD_GF_CHECK 6 // padding length to check for gf length
-#define AVG_SI_THRES 0.6 // thres for average silouette
-#define GF_SHRINK_OUTPUT 0 // print output for gf length decision
-int determine_high_err_gf(double *errs, int *is_high, double *si, int len,
- double *ratio, int gf_start, int gf_end,
- int before_pad) {
- (void)gf_start;
- (void)gf_end;
- (void)before_pad;
- // alpha and beta controls the threshold placement
- // e.g. a smaller alpha makes the lower group more rigid
- const double alpha = 0.5;
- const double beta = 1 - alpha;
- double mean = 0;
- double mean_low = 0;
- double mean_high = 0;
- double prev_mean_low = 0;
- double prev_mean_high = 0;
- int count_low = 0;
- int count_high = 0;
- // calculate mean of errs
- for (int i = 0; i < len; i++) {
- mean += errs[i];
- }
- mean /= len;
- // separate into two initial groups with greater / lower than mean
- for (int i = 0; i < len; i++) {
- if (errs[i] <= mean) {
- is_high[i] = 0;
- count_low++;
- prev_mean_low += errs[i];
- } else {
- is_high[i] = 1;
- count_high++;
- prev_mean_high += errs[i];
- }
- }
- prev_mean_low /= count_low;
- prev_mean_high /= count_high;
- // kmeans to refine
- int count = 0;
- while (count < 10) {
- // re-group
- mean_low = 0;
- mean_high = 0;
- count_low = 0;
- count_high = 0;
- double thres = prev_mean_low * alpha + prev_mean_high * beta;
- for (int i = 0; i < len; i++) {
- if (errs[i] <= thres) {
- is_high[i] = 0;
- count_low++;
- mean_low += errs[i];
- } else {
- is_high[i] = 1;
- count_high++;
- mean_high += errs[i];
- }
- }
- mean_low /= count_low;
- mean_high /= count_high;
-
- // break if not changed much
- if (fabs((mean_low - prev_mean_low) / (prev_mean_low + 0.00001)) <
- 0.00001 &&
- fabs((mean_high - prev_mean_high) / (prev_mean_high + 0.00001)) <
- 0.00001)
- break;
-
- // update means
- prev_mean_high = mean_high;
- prev_mean_low = mean_low;
-
- count++;
- }
-
- // count how many jumps of group changes
- int num_change = 0;
- for (int i = 0; i < len - 1; i++) {
- if (is_high[i] != is_high[i + 1]) num_change++;
- }
-
- // get silhouette as a measure of the classification quality
- double avg_si = 0;
- // ai: avg dist of its own class, bi: avg dist to the other class
- double ai, bi;
- if (count_low > 1 && count_high > 1) {
- for (int i = 0; i < len; i++) {
- ai = 0;
- bi = 0;
- // calculate average distance to everyone in the same group
- // and in the other group
- for (int j = 0; j < len; j++) {
- if (i == j) continue;
- if (is_high[i] == is_high[j]) {
- ai += fabs(errs[i] - errs[j]);
- } else {
- bi += fabs(errs[i] - errs[j]);
- }
- }
- if (is_high[i] == 0) {
- ai = ai / (count_low - 1);
- bi = bi / count_high;
- } else {
- ai = ai / (count_high - 1);
- bi = bi / count_low;
- }
- if (ai <= bi) {
- si[i] = 1 - ai / (bi + 0.00001);
- } else {
- si[i] = bi / (ai + 0.00001) - 1;
- }
- avg_si += si[i];
- }
- avg_si /= len;
- }
-
- int reset = 0;
- *ratio = mean_high / (mean_low + 0.00001);
- // if the two groups too similar, or
- // if too many numbers of changes, or
- // silhouette is too small, not confident
- // reset everything to 0 later so we fallback to the original decision
- if (*ratio < 1.3 || num_change > AOMMAX(len / 3, 6) ||
- avg_si < AVG_SI_THRES) {
- reset = 1;
- }
-
-#if GF_SHRINK_OUTPUT
- printf("\n");
- for (int i = 0; i < len; i++) {
- printf("%d: err %.1f, ishigh %d, si %.2f, (i=%d)\n",
- gf_start + i - before_pad, errs[i], is_high[i], si[i], gf_end);
- }
- printf(
- "count: %d, mean_high: %.1f, mean_low: %.1f, avg_si: %.2f, num_change: "
- "%d, ratio %.2f, reset: %d\n",
- count, mean_high, mean_low, avg_si, num_change,
- mean_high / (mean_low + 0.000001), reset);
-#endif
-
- if (reset) {
- memset(is_high, 0, sizeof(is_high[0]) * len);
- memset(si, 0, sizeof(si[0]) * len);
- }
- return reset;
-}
-
#if GROUP_ADAPTIVE_MAXQ
#define RC_FACTOR_MIN 0.75
#define RC_FACTOR_MAX 1.25
#endif // GROUP_ADAPTIVE_MAXQ
+
#define MIN_FWD_KF_INTERVAL 8
-#define MIN_SHRINK_LEN 6 // the minimum length of gf if we are shrinking
-#define SI_HIGH AVG_SI_THRES // high quality classification
-#define SI_LOW 0.3 // very unsure classification
-// this function finds an low error frame previously to the current last frame
-// in the gf group, and set the last frame to it.
-// The resulting last frame is then returned by *cur_last_ptr
-// *cur_start_ptr and cut_pos[n] could also change due to shrinking
-// previous gf groups
-void set_last_prev_low_err(int *cur_start_ptr, int *cur_last_ptr, int *cut_pos,
- int count_cuts, int before_pad, double ratio,
- int *is_high, double *si, int prev_lows,
- int min_shrink_len) {
- int n;
- int cur_start = *cur_start_ptr;
- int cur_last = *cur_last_ptr;
- for (n = cur_last; n >= cur_start + min_shrink_len; n--) {
- // try to find a point that is very probable to be good
- if (is_high[n - cur_start + before_pad] == 0 &&
- si[n - cur_start + before_pad] > SI_HIGH) {
- *cur_last_ptr = n;
- return;
- }
- }
- // could not find a low-err point, then let's try find an "unsure"
- // point at least
- for (n = cur_last; n >= cur_start + min_shrink_len; n--) {
- if ((is_high[n - cur_start + before_pad] == 0) ||
- (is_high[n - cur_start + before_pad] &&
- si[n - cur_start + before_pad] < SI_LOW)) {
- *cur_last_ptr = n;
- return;
- }
- }
- if (prev_lows) {
- // try with shrinking previous all_zero interval
- for (n = cur_start + min_shrink_len - 1; n > cur_start; n--) {
- if (is_high[n - cur_start + before_pad] == 0 &&
- si[n - cur_start + before_pad] > SI_HIGH) {
- int tentative_start = n - min_shrink_len;
- // check if the previous interval can shrink this much
- int available =
- tentative_start - cut_pos[count_cuts - 2] > min_shrink_len &&
- cur_start - tentative_start < prev_lows;
- // shrinking too agressively may worsen performance
- // set stricter thres for shorter length
- double ratio_thres =
- 1.0 * (cur_start - tentative_start) / (double)(min_shrink_len) +
- 1.0;
-
- if (available && (ratio > ratio_thres)) {
- cut_pos[count_cuts - 1] = tentative_start;
- *cur_start_ptr = tentative_start;
- *cur_last_ptr = n;
- return;
- }
- }
- }
- }
- if (prev_lows) {
- // try with shrinking previous all_zero interval with unsure points
- for (n = cur_start + min_shrink_len - 1; n > cur_start; n--) {
- if ((is_high[n - cur_start + before_pad] == 0) ||
- (is_high[n - cur_start + before_pad] &&
- si[n - cur_start + before_pad] < SI_LOW)) {
- int tentative_start = n - min_shrink_len;
- // check if the previous interval can shrink this much
- int available =
- tentative_start - cut_pos[count_cuts - 2] > min_shrink_len &&
- cur_start - tentative_start < prev_lows;
- // shrinking too agressively may worsen performance
- double ratio_thres =
- 1.0 * (cur_start - tentative_start) / (double)(min_shrink_len) +
- 1.0;
-
- if (available && (ratio > ratio_thres)) {
- cut_pos[count_cuts - 1] = tentative_start;
- *cur_start_ptr = tentative_start;
- *cur_last_ptr = n;
- return;
- }
- }
- }
- } // prev_lows
- return;
-}
-
+#define MIN_SHRINK_LEN 6 // the minimum length of gf if we are shrinking
#define SMOOTH_FILT_LEN 7
#define HALF_FILT_LEN (SMOOTH_FILT_LEN / 2)
#define WINDOW_SIZE 7
@@ -2308,19 +2076,6 @@
}
rc->cur_gf_index = 0;
twopass->stats_in = start_pos;
-
-#if GF_SHRINK_OUTPUT
- printf("\nf_to_key: %d, count_cut: %d. ", rc->frames_to_key, count_cuts);
- for (int n = 0; n < count_cuts; n++) {
- printf("%d ", cut_pos[n]);
- }
- printf("\n");
-
- for (int n = 0; n < rc->intervals_till_gf_calculate_due; n++) {
- printf("%d ", rc->gf_intervals[n]);
- }
- printf("\n\n");
-#endif
}
static void correct_frames_to_key(AV1_COMP *cpi) {
