aq_cyclicrefresh.c 23.8 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
4 5 6 7 8 9
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
Jingning Han's avatar
Jingning Han committed
10 11 12 13 14
 */

#include <limits.h>
#include <math.h>

Yaowu Xu's avatar
Yaowu Xu committed
15 16 17 18
#include "av1/common/seg_common.h"
#include "av1/encoder/aq_cyclicrefresh.h"
#include "av1/encoder/ratectrl.h"
#include "av1/encoder/segmentation.h"
Adrian Grange's avatar
Adrian Grange committed
19
#include "aom_dsp/aom_dsp_common.h"
Yaowu Xu's avatar
Yaowu Xu committed
20
#include "aom_ports/system_state.h"
Jingning Han's avatar
Jingning Han committed
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

struct CYCLIC_REFRESH {
  // Percentage of blocks per frame that are targeted as candidates
  // for cyclic refresh.
  int percent_refresh;
  // Maximum q-delta as percentage of base q.
  int max_qdelta_perc;
  // Superblock starting index for cycling through the frame.
  int sb_index;
  // Controls how long block will need to wait to be refreshed again, in
  // excess of the cycle time, i.e., in the case of all zero motion, block
  // will be refreshed every (100/percent_refresh + time_for_refresh) frames.
  int time_for_refresh;
  // Target number of (8x8) blocks that are set for delta-q.
  int target_num_seg_blocks;
  // Actual number of (8x8) blocks that were applied delta-q.
  int actual_num_seg1_blocks;
  int actual_num_seg2_blocks;
  // RD mult. parameters for segment 1.
  int rdmult;
  // Cyclic refresh map.
  signed char *map;
  // Map of the last q a block was coded at.
  uint8_t *last_coded_q_map;
  // Thresholds applied to the projected rate/distortion of the coding block,
  // when deciding whether block should be refreshed.
  int64_t thresh_rate_sb;
  int64_t thresh_dist_sb;
  // Threshold applied to the motion vector (in units of 1/8 pel) of the
  // coding block, when deciding whether block should be refreshed.
  int16_t motion_thresh;
  // Rate target ratio to set q delta.
  double rate_ratio_qdelta;
  // Boost factor for rate target ratio, for segment CR_SEGMENT_ID_BOOST2.
  int rate_boost_fac;
  double low_content_avg;
  int qindex_delta[3];
};

60
CYCLIC_REFRESH *av1_cyclic_refresh_alloc(int mi_rows, int mi_cols) {
Jingning Han's avatar
Jingning Han committed
61
  size_t last_coded_q_map_size;
Adrian Grange's avatar
Adrian Grange committed
62
  CYCLIC_REFRESH *const cr = aom_calloc(1, sizeof(*cr));
clang-format's avatar
clang-format committed
63
  if (cr == NULL) return NULL;
Jingning Han's avatar
Jingning Han committed
64

Adrian Grange's avatar
Adrian Grange committed
65
  cr->map = aom_calloc(mi_rows * mi_cols, sizeof(*cr->map));
Jingning Han's avatar
Jingning Han committed
66
  if (cr->map == NULL) {
Adrian Grange's avatar
Adrian Grange committed
67
    aom_free(cr);
Jingning Han's avatar
Jingning Han committed
68 69 70
    return NULL;
  }
  last_coded_q_map_size = mi_rows * mi_cols * sizeof(*cr->last_coded_q_map);
Adrian Grange's avatar
Adrian Grange committed
71
  cr->last_coded_q_map = aom_malloc(last_coded_q_map_size);
Jingning Han's avatar
Jingning Han committed
72
  if (cr->last_coded_q_map == NULL) {
Adrian Grange's avatar
Adrian Grange committed
73
    aom_free(cr);
Jingning Han's avatar
Jingning Han committed
74 75 76 77 78 79 80 81
    return NULL;
  }
  assert(MAXQ <= 255);
  memset(cr->last_coded_q_map, MAXQ, last_coded_q_map_size);

  return cr;
}

82
void av1_cyclic_refresh_free(CYCLIC_REFRESH *cr) {
Adrian Grange's avatar
Adrian Grange committed
83 84 85
  aom_free(cr->map);
  aom_free(cr->last_coded_q_map);
  aom_free(cr);
Jingning Han's avatar
Jingning Han committed
86 87 88
}

// Check if we should turn off cyclic refresh based on bitrate condition.
89
static int apply_cyclic_refresh_bitrate(const AV1_COMMON *cm,
Jingning Han's avatar
Jingning Han committed
90 91 92 93 94 95 96
                                        const RATE_CONTROL *rc) {
  // Turn off cyclic refresh if bits available per frame is not sufficiently
  // larger than bit cost of segmentation. Segment map bit cost should scale
  // with number of seg blocks, so compare available bits to number of blocks.
  // Average bits available per frame = avg_frame_bandwidth
  // Number of (8x8) blocks in frame = mi_rows * mi_cols;
  const float factor = 0.25;
clang-format's avatar
clang-format committed
97
  const int number_blocks = cm->mi_rows * cm->mi_cols;
Jingning Han's avatar
Jingning Han committed
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
  // The condition below corresponds to turning off at target bitrates:
  // (at 30fps), ~12kbps for CIF, 36kbps for VGA, 100kps for HD/720p.
  // Also turn off at very small frame sizes, to avoid too large fraction of
  // superblocks to be refreshed per frame. Threshold below is less than QCIF.
  if (rc->avg_frame_bandwidth < factor * number_blocks ||
      number_blocks / 64 < 5)
    return 0;
  else
    return 1;
}

// Check if this coding block, of size bsize, should be considered for refresh
// (lower-qp coding). Decision can be based on various factors, such as
// size of the coding block (i.e., below min_block size rejected), coding
// mode, and rate/distortion.
static int candidate_refresh_aq(const CYCLIC_REFRESH *cr,
clang-format's avatar
clang-format committed
114 115
                                const MB_MODE_INFO *mbmi, int64_t rate,
                                int64_t dist, int bsize) {
Jingning Han's avatar
Jingning Han committed
116 117 118 119 120 121 122 123 124 125 126
  MV mv = mbmi->mv[0].as_mv;
  // Reject the block for lower-qp coding if projected distortion
  // is above the threshold, and any of the following is true:
  // 1) mode uses large mv
  // 2) mode is an intra-mode
  // Otherwise accept for refresh.
  if (dist > cr->thresh_dist_sb &&
      (mv.row > cr->motion_thresh || mv.row < -cr->motion_thresh ||
       mv.col > cr->motion_thresh || mv.col < -cr->motion_thresh ||
       !is_inter_block(mbmi)))
    return CR_SEGMENT_ID_BASE;
clang-format's avatar
clang-format committed
127 128 129
  else if (bsize >= BLOCK_16X16 && rate < cr->thresh_rate_sb &&
           is_inter_block(mbmi) && mbmi->mv[0].as_int == 0 &&
           cr->rate_boost_fac > 10)
Jingning Han's avatar
Jingning Han committed
130 131 132 133 134 135 136
    // More aggressive delta-q for bigger blocks with zero motion.
    return CR_SEGMENT_ID_BOOST2;
  else
    return CR_SEGMENT_ID_BOOST1;
}

// Compute delta-q for the segment.
137
static int compute_deltaq(const AV1_COMP *cpi, int q, double rate_factor) {
Jingning Han's avatar
Jingning Han committed
138 139
  const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  const RATE_CONTROL *const rc = &cpi->rc;
140
  int deltaq = av1_compute_qdelta_by_rate(rc, cpi->common.frame_type, q,
clang-format's avatar
clang-format committed
141
                                          rate_factor, cpi->common.bit_depth);
Jingning Han's avatar
Jingning Han committed
142 143 144 145 146 147 148 149 150 151
  if ((-deltaq) > cr->max_qdelta_perc * q / 100) {
    deltaq = -cr->max_qdelta_perc * q / 100;
  }
  return deltaq;
}

// For the just encoded frame, estimate the bits, incorporating the delta-q
// from non-base segment. For now ignore effect of multiple segments
// (with different delta-q). Note this function is called in the postencode
// (called from rc_update_rate_correction_factors()).
152
int av1_cyclic_refresh_estimate_bits_at_q(const AV1_COMP *cpi,
clang-format's avatar
clang-format committed
153
                                          double correction_factor) {
154
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
155 156 157 158 159 160 161 162 163
  const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  int estimated_bits;
  int mbs = cm->MBs;
  int num8x8bl = mbs << 2;
  // Weight for non-base segments: use actual number of blocks refreshed in
  // previous/just encoded frame. Note number of blocks here is in 8x8 units.
  double weight_segment1 = (double)cr->actual_num_seg1_blocks / num8x8bl;
  double weight_segment2 = (double)cr->actual_num_seg2_blocks / num8x8bl;
  // Take segment weighted average for estimated bits.
clang-format's avatar
clang-format committed
164 165
  estimated_bits =
      (int)((1.0 - weight_segment1 - weight_segment2) *
166
                av1_estimate_bits_at_q(cm->frame_type, cm->base_qindex, mbs,
clang-format's avatar
clang-format committed
167
                                       correction_factor, cm->bit_depth) +
clang-format's avatar
clang-format committed
168
            weight_segment1 *
169
                av1_estimate_bits_at_q(cm->frame_type,
clang-format's avatar
clang-format committed
170 171
                                       cm->base_qindex + cr->qindex_delta[1],
                                       mbs, correction_factor, cm->bit_depth) +
clang-format's avatar
clang-format committed
172
            weight_segment2 *
173
                av1_estimate_bits_at_q(cm->frame_type,
clang-format's avatar
clang-format committed
174 175
                                       cm->base_qindex + cr->qindex_delta[2],
                                       mbs, correction_factor, cm->bit_depth));
Jingning Han's avatar
Jingning Han committed
176 177 178 179 180 181 182 183
  return estimated_bits;
}

// Prior to encoding the frame, estimate the bits per mb, for a given q = i and
// a corresponding delta-q (for segment 1). This function is called in the
// rc_regulate_q() to set the base qp index.
// Note: the segment map is set to either 0/CR_SEGMENT_ID_BASE (no refresh) or
// to 1/CR_SEGMENT_ID_BOOST1 (refresh) for each superblock, prior to encoding.
184
int av1_cyclic_refresh_rc_bits_per_mb(const AV1_COMP *cpi, int i,
clang-format's avatar
clang-format committed
185
                                      double correction_factor) {
186
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
187 188 189 190 191
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  int bits_per_mb;
  int num8x8bl = cm->MBs << 2;
  // Weight for segment prior to encoding: take the average of the target
  // number for the frame to be encoded and the actual from the previous frame.
clang-format's avatar
clang-format committed
192 193 194 195
  double weight_segment =
      (double)((cr->target_num_seg_blocks + cr->actual_num_seg1_blocks +
                cr->actual_num_seg2_blocks) >>
               1) /
Jingning Han's avatar
Jingning Han committed
196 197 198 199
      num8x8bl;
  // Compute delta-q corresponding to qindex i.
  int deltaq = compute_deltaq(cpi, i, cr->rate_ratio_qdelta);
  // Take segment weighted average for bits per mb.
clang-format's avatar
clang-format committed
200 201 202 203 204 205
  bits_per_mb = (int)((1.0 - weight_segment) *
                          av1_rc_bits_per_mb(cm->frame_type, i,
                                             correction_factor, cm->bit_depth) +
                      weight_segment *
                          av1_rc_bits_per_mb(cm->frame_type, i + deltaq,
                                             correction_factor, cm->bit_depth));
Jingning Han's avatar
Jingning Han committed
206 207 208 209 210 211
  return bits_per_mb;
}

// Prior to coding a given prediction block, of size bsize at (mi_row, mi_col),
// check if we should reset the segment_id, and update the cyclic_refresh map
// and segmentation map.
212
void av1_cyclic_refresh_update_segment(const AV1_COMP *cpi,
clang-format's avatar
clang-format committed
213 214 215
                                       MB_MODE_INFO *const mbmi, int mi_row,
                                       int mi_col, BLOCK_SIZE bsize,
                                       int64_t rate, int64_t dist, int skip) {
216
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
217 218 219
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  const int bw = num_8x8_blocks_wide_lookup[bsize];
  const int bh = num_8x8_blocks_high_lookup[bsize];
Adrian Grange's avatar
Adrian Grange committed
220 221
  const int xmis = AOMMIN(cm->mi_cols - mi_col, bw);
  const int ymis = AOMMIN(cm->mi_rows - mi_row, bh);
Jingning Han's avatar
Jingning Han committed
222
  const int block_index = mi_row * cm->mi_cols + mi_col;
clang-format's avatar
clang-format committed
223 224
  const int refresh_this_block =
      candidate_refresh_aq(cr, mbmi, rate, dist, bsize);
Jingning Han's avatar
Jingning Han committed
225 226
  // Default is to not update the refresh map.
  int new_map_value = cr->map[block_index];
clang-format's avatar
clang-format committed
227 228
  int x = 0;
  int y = 0;
Jingning Han's avatar
Jingning Han committed
229 230 231 232 233 234

  // If this block is labeled for refresh, check if we should reset the
  // segment_id.
  if (cyclic_refresh_segment_id_boosted(mbmi->segment_id)) {
    mbmi->segment_id = refresh_this_block;
    // Reset segment_id if will be skipped.
clang-format's avatar
clang-format committed
235
    if (skip) mbmi->segment_id = CR_SEGMENT_ID_BASE;
Jingning Han's avatar
Jingning Han committed
236 237 238 239 240 241 242 243 244 245 246 247
  }

  // Update the cyclic refresh map, to be used for setting segmentation map
  // for the next frame. If the block  will be refreshed this frame, mark it
  // as clean. The magnitude of the -ve influences how long before we consider
  // it for refresh again.
  if (cyclic_refresh_segment_id_boosted(mbmi->segment_id)) {
    new_map_value = -cr->time_for_refresh;
  } else if (refresh_this_block) {
    // Else if it is accepted as candidate for refresh, and has not already
    // been refreshed (marked as 1) then mark it as a candidate for cleanup
    // for future time (marked as 0), otherwise don't update it.
clang-format's avatar
clang-format committed
248
    if (cr->map[block_index] == 1) new_map_value = 0;
Jingning Han's avatar
Jingning Han committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
  } else {
    // Leave it marked as block that is not candidate for refresh.
    new_map_value = 1;
  }

  // Update entries in the cyclic refresh map with new_map_value, and
  // copy mbmi->segment_id into global segmentation map.
  for (y = 0; y < ymis; y++)
    for (x = 0; x < xmis; x++) {
      int map_offset = block_index + y * cm->mi_cols + x;
      cr->map[map_offset] = new_map_value;
      cpi->segmentation_map[map_offset] = mbmi->segment_id;
      // Inter skip blocks were clearly not coded at the current qindex, so
      // don't update the map for them. For cases where motion is non-zero or
      // the reference frame isn't the previous frame, the previous value in
      // the map for this spatial location is not entirely correct.
265 266
      if ((!is_inter_block(mbmi) || !skip) &&
          mbmi->segment_id <= CR_SEGMENT_ID_BOOST2) {
Jingning Han's avatar
Jingning Han committed
267 268
        cr->last_coded_q_map[map_offset] = clamp(
            cm->base_qindex + cr->qindex_delta[mbmi->segment_id], 0, MAXQ);
269 270 271
      } else if (is_inter_block(mbmi) && skip &&
                 mbmi->segment_id <= CR_SEGMENT_ID_BOOST2) {
        cr->last_coded_q_map[map_offset] =
Adrian Grange's avatar
Adrian Grange committed
272
            AOMMIN(clamp(cm->base_qindex + cr->qindex_delta[mbmi->segment_id],
273 274 275
                         0, MAXQ),
                   cr->last_coded_q_map[map_offset]);
      }
Jingning Han's avatar
Jingning Han committed
276 277 278 279
    }
}

// Update the actual number of blocks that were applied the segment delta q.
280 281
void av1_cyclic_refresh_postencode(AV1_COMP *const cpi) {
  AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
282 283 284 285 286 287 288
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  unsigned char *const seg_map = cpi->segmentation_map;
  int mi_row, mi_col;
  cr->actual_num_seg1_blocks = 0;
  cr->actual_num_seg2_blocks = 0;
  for (mi_row = 0; mi_row < cm->mi_rows; mi_row++)
    for (mi_col = 0; mi_col < cm->mi_cols; mi_col++) {
clang-format's avatar
clang-format committed
289 290
      if (cyclic_refresh_segment_id(seg_map[mi_row * cm->mi_cols + mi_col]) ==
          CR_SEGMENT_ID_BOOST1)
Jingning Han's avatar
Jingning Han committed
291 292
        cr->actual_num_seg1_blocks++;
      else if (cyclic_refresh_segment_id(
clang-format's avatar
clang-format committed
293 294
                   seg_map[mi_row * cm->mi_cols + mi_col]) ==
               CR_SEGMENT_ID_BOOST2)
Jingning Han's avatar
Jingning Han committed
295 296 297 298
        cr->actual_num_seg2_blocks++;
    }
}

Yunqing Wang's avatar
Yunqing Wang committed
299
// Set golden frame update interval, for 1 pass CBR mode.
300
void av1_cyclic_refresh_set_golden_update(AV1_COMP *const cpi) {
Jingning Han's avatar
Jingning Han committed
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
  RATE_CONTROL *const rc = &cpi->rc;
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  // Set minimum gf_interval for GF update to a multiple (== 2) of refresh
  // period. Depending on past encoding stats, GF flag may be reset and update
  // may not occur until next baseline_gf_interval.
  if (cr->percent_refresh > 0)
    rc->baseline_gf_interval = 4 * (100 / cr->percent_refresh);
  else
    rc->baseline_gf_interval = 40;
}

// Update some encoding stats (from the just encoded frame). If this frame's
// background has high motion, refresh the golden frame. Otherwise, if the
// golden reference is to be updated check if we should NOT update the golden
// ref.
316 317
void av1_cyclic_refresh_check_golden_update(AV1_COMP *const cpi) {
  AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
318 319 320 321 322 323 324 325 326 327 328 329 330
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  int mi_row, mi_col;
  double fraction_low = 0.0;
  int low_content_frame = 0;

  MODE_INFO **mi = cm->mi_grid_visible;
  RATE_CONTROL *const rc = &cpi->rc;
  const int rows = cm->mi_rows, cols = cm->mi_cols;
  int cnt1 = 0, cnt2 = 0;
  int force_gf_refresh = 0;

  for (mi_row = 0; mi_row < rows; mi_row++) {
    for (mi_col = 0; mi_col < cols; mi_col++) {
clang-format's avatar
clang-format committed
331 332 333 334 335 336
      int16_t abs_mvr = mi[0]->mbmi.mv[0].as_mv.row >= 0
                            ? mi[0]->mbmi.mv[0].as_mv.row
                            : -1 * mi[0]->mbmi.mv[0].as_mv.row;
      int16_t abs_mvc = mi[0]->mbmi.mv[0].as_mv.col >= 0
                            ? mi[0]->mbmi.mv[0].as_mv.col
                            : -1 * mi[0]->mbmi.mv[0].as_mv.col;
Jingning Han's avatar
Jingning Han committed
337 338 339 340

      // Calculate the motion of the background.
      if (abs_mvr <= 16 && abs_mvc <= 16) {
        cnt1++;
clang-format's avatar
clang-format committed
341
        if (abs_mvr == 0 && abs_mvc == 0) cnt2++;
Jingning Han's avatar
Jingning Han committed
342 343 344 345
      }
      mi++;

      // Accumulate low_content_frame.
clang-format's avatar
clang-format committed
346
      if (cr->map[mi_row * cols + mi_col] < 1) low_content_frame++;
Jingning Han's avatar
Jingning Han committed
347 348 349 350 351 352 353 354 355 356
    }
    mi += 8;
  }

  // For video conference clips, if the background has high motion in current
  // frame because of the camera movement, set this frame as the golden frame.
  // Use 70% and 5% as the thresholds for golden frame refreshing.
  // Also, force this frame as a golden update frame if this frame will change
  // the resolution (resize_pending != 0).
  if (cpi->resize_pending != 0 ||
clang-format's avatar
clang-format committed
357
      (cnt1 * 10 > (70 * rows * cols) && cnt2 * 20 < cnt1)) {
358
    av1_cyclic_refresh_set_golden_update(cpi);
Jingning Han's avatar
Jingning Han committed
359 360 361 362 363 364 365 366
    rc->frames_till_gf_update_due = rc->baseline_gf_interval;

    if (rc->frames_till_gf_update_due > rc->frames_to_key)
      rc->frames_till_gf_update_due = rc->frames_to_key;
    cpi->refresh_golden_frame = 1;
    force_gf_refresh = 1;
  }

clang-format's avatar
clang-format committed
367
  fraction_low = (double)low_content_frame / (rows * cols);
Jingning Han's avatar
Jingning Han committed
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
  // Update average.
  cr->low_content_avg = (fraction_low + 3 * cr->low_content_avg) / 4;
  if (!force_gf_refresh && cpi->refresh_golden_frame == 1) {
    // Don't update golden reference if the amount of low_content for the
    // current encoded frame is small, or if the recursive average of the
    // low_content over the update interval window falls below threshold.
    if (fraction_low < 0.8 || cr->low_content_avg < 0.7)
      cpi->refresh_golden_frame = 0;
    // Reset for next internal.
    cr->low_content_avg = fraction_low;
  }
}

// Update the segmentation map, and related quantities: cyclic refresh map,
// refresh sb_index, and target number of blocks to be refreshed.
// The map is set to either 0/CR_SEGMENT_ID_BASE (no refresh) or to
// 1/CR_SEGMENT_ID_BOOST1 (refresh) for each superblock.
// Blocks labeled as BOOST1 may later get set to BOOST2 (during the
// encoding of the superblock).
387 388
static void cyclic_refresh_update_map(AV1_COMP *const cpi) {
  AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
389 390 391 392 393
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  unsigned char *const seg_map = cpi->segmentation_map;
  int i, block_count, bl_index, sb_rows, sb_cols, sbs_in_frame;
  int xmis, ymis, x, y;
  memset(seg_map, CR_SEGMENT_ID_BASE, cm->mi_rows * cm->mi_cols);
394 395
  sb_cols = (cm->mi_cols + MAX_MIB_SIZE - 1) / MAX_MIB_SIZE;
  sb_rows = (cm->mi_rows + MAX_MIB_SIZE - 1) / MAX_MIB_SIZE;
Jingning Han's avatar
Jingning Han committed
396 397 398 399 400 401 402 403 404 405 406 407 408 409
  sbs_in_frame = sb_cols * sb_rows;
  // Number of target blocks to get the q delta (segment 1).
  block_count = cr->percent_refresh * cm->mi_rows * cm->mi_cols / 100;
  // Set the segmentation map: cycle through the superblocks, starting at
  // cr->mb_index, and stopping when either block_count blocks have been found
  // to be refreshed, or we have passed through whole frame.
  assert(cr->sb_index < sbs_in_frame);
  i = cr->sb_index;
  cr->target_num_seg_blocks = 0;
  do {
    int sum_map = 0;
    // Get the mi_row/mi_col corresponding to superblock index i.
    int sb_row_index = (i / sb_cols);
    int sb_col_index = i - sb_row_index * sb_cols;
410 411
    int mi_row = sb_row_index * MAX_MIB_SIZE;
    int mi_col = sb_col_index * MAX_MIB_SIZE;
Jingning Han's avatar
Jingning Han committed
412
    int qindex_thresh =
Adrian Grange's avatar
Adrian Grange committed
413
        cpi->oxcf.content == AOM_CONTENT_SCREEN
414
            ? av1_get_qindex(&cm->seg, CR_SEGMENT_ID_BOOST2, cm->base_qindex)
Jingning Han's avatar
Jingning Han committed
415 416 417 418 419
            : 0;
    assert(mi_row >= 0 && mi_row < cm->mi_rows);
    assert(mi_col >= 0 && mi_col < cm->mi_cols);
    bl_index = mi_row * cm->mi_cols + mi_col;
    // Loop through all 8x8 blocks in superblock and update map.
420
    xmis =
Adrian Grange's avatar
Adrian Grange committed
421
        AOMMIN(cm->mi_cols - mi_col, num_8x8_blocks_wide_lookup[BLOCK_64X64]);
422
    ymis =
Adrian Grange's avatar
Adrian Grange committed
423
        AOMMIN(cm->mi_rows - mi_row, num_8x8_blocks_high_lookup[BLOCK_64X64]);
Jingning Han's avatar
Jingning Han committed
424 425 426 427 428 429 430
    for (y = 0; y < ymis; y++) {
      for (x = 0; x < xmis; x++) {
        const int bl_index2 = bl_index + y * cm->mi_cols + x;
        // If the block is as a candidate for clean up then mark it
        // for possible boost/refresh (segment 1). The segment id may get
        // reset to 0 later if block gets coded anything other than ZEROMV.
        if (cr->map[bl_index2] == 0) {
clang-format's avatar
clang-format committed
431
          if (cr->last_coded_q_map[bl_index2] > qindex_thresh) sum_map++;
Jingning Han's avatar
Jingning Han committed
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
        } else if (cr->map[bl_index2] < 0) {
          cr->map[bl_index2]++;
        }
      }
    }
    // Enforce constant segment over superblock.
    // If segment is at least half of superblock, set to 1.
    if (sum_map >= xmis * ymis / 2) {
      for (y = 0; y < ymis; y++)
        for (x = 0; x < xmis; x++) {
          seg_map[bl_index + y * cm->mi_cols + x] = CR_SEGMENT_ID_BOOST1;
        }
      cr->target_num_seg_blocks += xmis * ymis;
    }
    i++;
    if (i == sbs_in_frame) {
      i = 0;
    }
  } while (cr->target_num_seg_blocks < block_count && i != cr->sb_index);
  cr->sb_index = i;
}

// Set cyclic refresh parameters.
455
void av1_cyclic_refresh_update_parameters(AV1_COMP *const cpi) {
Jingning Han's avatar
Jingning Han committed
456
  const RATE_CONTROL *const rc = &cpi->rc;
457
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
458 459 460 461 462 463
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  cr->percent_refresh = 10;
  cr->max_qdelta_perc = 50;
  cr->time_for_refresh = 0;
  // Use larger delta-qp (increase rate_ratio_qdelta) for first few (~4)
  // periods of the refresh cycle, after a key frame.
clang-format's avatar
clang-format committed
464
  if (rc->frames_since_key < 4 * cr->percent_refresh)
Jingning Han's avatar
Jingning Han committed
465 466 467 468
    cr->rate_ratio_qdelta = 3.0;
  else
    cr->rate_ratio_qdelta = 2.0;
  // Adjust some parameters for low resolutions at low bitrates.
clang-format's avatar
clang-format committed
469
  if (cm->width <= 352 && cm->height <= 288 && rc->avg_frame_bandwidth < 3400) {
Jingning Han's avatar
Jingning Han committed
470 471 472 473 474 475 476 477 478
    cr->motion_thresh = 4;
    cr->rate_boost_fac = 10;
  } else {
    cr->motion_thresh = 32;
    cr->rate_boost_fac = 17;
  }
}

// Setup cyclic background refresh: set delta q and segmentation map.
479 480
void av1_cyclic_refresh_setup(AV1_COMP *const cpi) {
  AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
481 482 483
  const RATE_CONTROL *const rc = &cpi->rc;
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  struct segmentation *const seg = &cm->seg;
clang-format's avatar
clang-format committed
484 485
  const int apply_cyclic_refresh = apply_cyclic_refresh_bitrate(cm, rc);
  if (cm->current_video_frame == 0) cr->low_content_avg = 0.0;
Jingning Han's avatar
Jingning Han committed
486
  // Don't apply refresh on key frame or enhancement layer frames.
Yunqing Wang's avatar
Yunqing Wang committed
487
  if (!apply_cyclic_refresh || cm->frame_type == KEY_FRAME) {
Jingning Han's avatar
Jingning Han committed
488 489 490
    // Set segmentation map to 0 and disable.
    unsigned char *const seg_map = cpi->segmentation_map;
    memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
491
    av1_disable_segmentation(&cm->seg);
Jingning Han's avatar
Jingning Han committed
492 493 494 495 496 497 498 499 500
    if (cm->frame_type == KEY_FRAME) {
      memset(cr->last_coded_q_map, MAXQ,
             cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
      cr->sb_index = 0;
    }
    return;
  } else {
    int qindex_delta = 0;
    int qindex2;
501
    const double q = av1_convert_qindex_to_q(cm->base_qindex, cm->bit_depth);
Adrian Grange's avatar
Adrian Grange committed
502
    aom_clear_system_state();
Jingning Han's avatar
Jingning Han committed
503 504 505 506 507
    // Set rate threshold to some multiple (set to 2 for now) of the target
    // rate (target is given by sb64_target_rate and scaled by 256).
    cr->thresh_rate_sb = ((int64_t)(rc->sb64_target_rate) << 8) << 2;
    // Distortion threshold, quadratic in Q, scale factor to be adjusted.
    // q will not exceed 457, so (q * q) is within 32bit; see:
508
    // av1_convert_qindex_to_q(), av1_ac_quant(), ac_qlookup*[].
Jingning Han's avatar
Jingning Han committed
509 510 511 512
    cr->thresh_dist_sb = ((int64_t)(q * q)) << 2;

    // Set up segmentation.
    // Clear down the segment map.
513 514
    av1_enable_segmentation(&cm->seg);
    av1_clearall_segfeatures(seg);
Jingning Han's avatar
Jingning Han committed
515 516 517 518
    // Select delta coding method.
    seg->abs_delta = SEGMENT_DELTADATA;

    // Note: setting temporal_update has no effect, as the seg-map coding method
clang-format's avatar
clang-format committed
519
    // (temporal or spatial) is determined in
520
    // av1_choose_segmap_coding_method(),
Jingning Han's avatar
Jingning Han committed
521 522 523 524 525 526
    // based on the coding cost of each method. For error_resilient mode on the
    // last_frame_seg_map is set to 0, so if temporal coding is used, it is
    // relative to 0 previous map.
    // seg->temporal_update = 0;

    // Segment BASE "Q" feature is disabled so it defaults to the baseline Q.
527
    av1_disable_segfeature(seg, CR_SEGMENT_ID_BASE, SEG_LVL_ALT_Q);
Jingning Han's avatar
Jingning Han committed
528
    // Use segment BOOST1 for in-frame Q adjustment.
529
    av1_enable_segfeature(seg, CR_SEGMENT_ID_BOOST1, SEG_LVL_ALT_Q);
Jingning Han's avatar
Jingning Han committed
530
    // Use segment BOOST2 for more aggressive in-frame Q adjustment.
531
    av1_enable_segfeature(seg, CR_SEGMENT_ID_BOOST2, SEG_LVL_ALT_Q);
Jingning Han's avatar
Jingning Han committed
532 533 534 535 536 537 538 539

    // Set the q delta for segment BOOST1.
    qindex_delta = compute_deltaq(cpi, cm->base_qindex, cr->rate_ratio_qdelta);
    cr->qindex_delta[1] = qindex_delta;

    // Compute rd-mult for segment BOOST1.
    qindex2 = clamp(cm->base_qindex + cm->y_dc_delta_q + qindex_delta, 0, MAXQ);

540
    cr->rdmult = av1_compute_rd_mult(cpi, qindex2);
Jingning Han's avatar
Jingning Han committed
541

542
    av1_set_segdata(seg, CR_SEGMENT_ID_BOOST1, SEG_LVL_ALT_Q, qindex_delta);
Jingning Han's avatar
Jingning Han committed
543 544 545

    // Set a more aggressive (higher) q delta for segment BOOST2.
    qindex_delta = compute_deltaq(
546
        cpi, cm->base_qindex,
Adrian Grange's avatar
Adrian Grange committed
547
        AOMMIN(CR_MAX_RATE_TARGET_RATIO,
548
               0.1 * cr->rate_boost_fac * cr->rate_ratio_qdelta));
Jingning Han's avatar
Jingning Han committed
549
    cr->qindex_delta[2] = qindex_delta;
550
    av1_set_segdata(seg, CR_SEGMENT_ID_BOOST2, SEG_LVL_ALT_Q, qindex_delta);
Jingning Han's avatar
Jingning Han committed
551 552 553 554 555 556

    // Update the segmentation and refresh map.
    cyclic_refresh_update_map(cpi);
  }
}

557
int av1_cyclic_refresh_get_rdmult(const CYCLIC_REFRESH *cr) {
Jingning Han's avatar
Jingning Han committed
558 559 560
  return cr->rdmult;
}

561 562
void av1_cyclic_refresh_reset_resize(AV1_COMP *const cpi) {
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
563 564 565 566 567
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  memset(cr->map, 0, cm->mi_rows * cm->mi_cols);
  cr->sb_index = 0;
  cpi->refresh_golden_frame = 1;
}