vp9_aq_cyclicrefresh.c 19.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
 *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

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

Marco Paniconi's avatar
Marco Paniconi committed
14
#include "vp9/encoder/vp9_aq_cyclicrefresh.h"
15
16
17
18
19
20

#include "vp9/common/vp9_seg_common.h"

#include "vp9/encoder/vp9_ratectrl.h"
#include "vp9/encoder/vp9_segmentation.h"

21
struct CYCLIC_REFRESH {
22
  // Percentage of blocks per frame that are targeted as candidates
23
  // for cyclic refresh.
24
  int percent_refresh;
25
26
  // Maximum q-delta as percentage of base q.
  int max_qdelta_perc;
27
28
  // Superblock starting index for cycling through the frame.
  int sb_index;
29
30
31
  // 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.
32
  int time_for_refresh;
33
34
  // // Target number of (8x8) blocks that are set for delta-q (segment 1).
  int target_num_seg_blocks;
35
  // Actual number of (8x8) blocks that were applied delta-q (segment 1).
36
  int actual_num_seg_blocks;
37
38
39
40
  // RD mult. parameters for segment 1.
  int rdmult;
  // Cyclic refresh map.
  signed char *map;
41
42
  // Thresholds applied to the projected rate/distortion of the coding block,
  // when deciding whether block should be refreshed.
43
44
  int64_t thresh_rate_sb;
  int64_t thresh_dist_sb;
45
46
47
  // 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;
48
49
  // Rate target ratio to set q delta.
  double rate_ratio_qdelta;
50
  double low_content_avg;
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
};

CYCLIC_REFRESH *vp9_cyclic_refresh_alloc(int mi_rows, int mi_cols) {
  CYCLIC_REFRESH *const cr = vpx_calloc(1, sizeof(*cr));
  if (cr == NULL)
    return NULL;

  cr->map = vpx_calloc(mi_rows * mi_cols, sizeof(*cr->map));
  if (cr->map == NULL) {
    vpx_free(cr);
    return NULL;
  }

  return cr;
}

void vp9_cyclic_refresh_free(CYCLIC_REFRESH *cr) {
  vpx_free(cr->map);
  vpx_free(cr);
}
71
72

// Check if we should turn off cyclic refresh based on bitrate condition.
73
74
static int apply_cyclic_refresh_bitrate(const VP9_COMMON *cm,
                                        const RATE_CONTROL *rc) {
75
76
77
  // 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.
78
  // Average bits available per frame = avg_frame_bandwidth
79
  // Number of (8x8) blocks in frame = mi_rows * mi_cols;
80
81
  const float factor  = 0.5;
  const int number_blocks = cm->mi_rows  * cm->mi_cols;
82
83
  // The condition below corresponds to turning off at target bitrates:
  // ~24kbps for CIF, 72kbps for VGA (at 30fps).
84
85
  // 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.
86
  if (rc->avg_frame_bandwidth < factor * number_blocks ||
87
88
89
90
      number_blocks / 64 < 5)
    return 0;
  else
    return 1;
91
92
93
94
95
96
}

// 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.
97
98
static int candidate_refresh_aq(const CYCLIC_REFRESH *cr,
                                const MB_MODE_INFO *mbmi,
99
                                int64_t rate,
100
101
                                int64_t dist,
                                int bsize) {
102
  MV mv = mbmi->mv[0].as_mv;
103
  // Reject the block for lower-qp coding if projected distortion
104
105
106
  // is above the threshold, and any of the following is true:
  // 1) mode uses large mv
  // 2) mode is an intra-mode
107
108
109
110
111
112
113
114
115
116
117
118
  // 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;
  else  if (bsize >= BLOCK_32X32 &&
            rate < cr->thresh_rate_sb &&
            is_inter_block(mbmi) &&
            mbmi->mv[0].as_int == 0)
    // More aggressive delta-q for bigger blocks with zero motion.
    return CR_SEGMENT_ID_BOOST2;
119
  else
120
    return CR_SEGMENT_ID_BOOST1;
121
122
}

123
// Compute delta-q for the segment.
124
static int compute_deltaq(const VP9_COMP *cpi, int q, double rate_factor) {
125
126
127
  const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  const RATE_CONTROL *const rc = &cpi->rc;
  int deltaq = vp9_compute_qdelta_by_rate(rc, cpi->common.frame_type,
128
                                          q, rate_factor,
129
130
131
132
133
134
135
136
                                          cpi->common.bit_depth);
  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
137
138
139
// 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()).
140
141
142
143
144
145
146
int vp9_cyclic_refresh_estimate_bits_at_q(const VP9_COMP *cpi,
                                          double correction_factor) {
  const VP9_COMMON *const cm = &cpi->common;
  const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  int estimated_bits;
  int mbs = cm->MBs;
  int num8x8bl = mbs << 2;
147
  // Weight for non-base segments: use actual number of blocks refreshed in
148
149
150
  // previous/just encoded frame. Note number of blocks here is in 8x8 units.
  double weight_segment = (double)cr->actual_num_seg_blocks / num8x8bl;
  // Compute delta-q that was used in the just encoded frame.
151
  int deltaq = compute_deltaq(cpi, cm->base_qindex, cr->rate_ratio_qdelta);
152
153
154
155
156
157
158
159
160
161
162
163
164
  // Take segment weighted average for estimated bits.
  estimated_bits = (int)((1.0 - weight_segment) *
      vp9_estimate_bits_at_q(cm->frame_type, cm->base_qindex, mbs,
                             correction_factor, cm->bit_depth) +
                             weight_segment *
      vp9_estimate_bits_at_q(cm->frame_type, cm->base_qindex + deltaq, mbs,
                             correction_factor, cm->bit_depth));
  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.
165
166
// 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.
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
int vp9_cyclic_refresh_rc_bits_per_mb(const VP9_COMP *cpi, int i,
                                      double correction_factor) {
  const VP9_COMMON *const cm = &cpi->common;
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  int bits_per_mb;
  int num8x8bl = cm->MBs << 2;
  // Weight for segment 1 prior to encoding: take the target number for the
  // frame to be encoded. Number of blocks here is in 8x8 units.
  // Note that this is called in rc_regulate_q, which is called before the
  // cyclic_refresh_setup (which sets cr->target_num_seg_blocks). So a mismatch
  // may occur between the cr->target_num_seg_blocks value here and the
  // cr->target_num_seg_block set for encoding the frame. For the current use
  // case of fixed cr->percent_refresh and cr->time_for_refresh = 0, mismatch
  // does not occur/is very small.
  double weight_segment = (double)cr->target_num_seg_blocks / num8x8bl;
  // Compute delta-q corresponding to qindex i.
183
  int deltaq = compute_deltaq(cpi, i, cr->rate_ratio_qdelta);
184
185
186
187
188
189
190
191
192
  // Take segment weighted average for bits per mb.
  bits_per_mb = (int)((1.0 - weight_segment) *
      vp9_rc_bits_per_mb(cm->frame_type, i, correction_factor, cm->bit_depth) +
      weight_segment *
      vp9_rc_bits_per_mb(cm->frame_type, i + deltaq, correction_factor,
                         cm->bit_depth));
  return bits_per_mb;
}

193
194
195
// 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.
196
197
198
void vp9_cyclic_refresh_update_segment(VP9_COMP *const cpi,
                                       MB_MODE_INFO *const mbmi,
                                       int mi_row, int mi_col,
199
200
201
                                       BLOCK_SIZE bsize,
                                       int64_t rate,
                                       int64_t dist) {
202
  const VP9_COMMON *const cm = &cpi->common;
203
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
204
205
206
207
208
  const int bw = num_8x8_blocks_wide_lookup[bsize];
  const int bh = num_8x8_blocks_high_lookup[bsize];
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  const int block_index = mi_row * cm->mi_cols + mi_col;
209
210
  const int refresh_this_block = candidate_refresh_aq(cr, mbmi, rate, dist,
                                                      bsize);
211
212
213
  // Default is to not update the refresh map.
  int new_map_value = cr->map[block_index];
  int x = 0; int y = 0;
214

215
216
  // If this block is labeled for refresh, check if we should reset the
  // segment_id.
217
  if (cyclic_refresh_segment_id_boosted(mbmi->segment_id))
218
    mbmi->segment_id = refresh_this_block;
219
220
221
222
223

  // 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.
224
  if (cyclic_refresh_segment_id_boosted(mbmi->segment_id)) {
225
226
227
228
229
230
231
232
233
234
235
    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.
    if (cr->map[block_index] == 1)
      new_map_value = 0;
  } else {
    // Leave it marked as block that is not candidate for refresh.
    new_map_value = 1;
  }
236

237
238
239
240
241
242
  // 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++) {
      cr->map[block_index + y * cm->mi_cols + x] = new_map_value;
      cpi->segmentation_map[block_index + y * cm->mi_cols + x] =
243
          mbmi->segment_id;
244
    }
245
246
247
}

// Update the actual number of blocks that were applied the segment delta q.
248
void vp9_cyclic_refresh_postencode(VP9_COMP *const cpi) {
249
250
251
252
253
254
  VP9_COMMON *const cm = &cpi->common;
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  unsigned char *const seg_map = cpi->segmentation_map;
  int mi_row, mi_col;
  cr->actual_num_seg_blocks = 0;
  for (mi_row = 0; mi_row < cm->mi_rows; mi_row++)
255
256
257
258
259
    for (mi_col = 0; mi_col < cm->mi_cols; mi_col++) {
      if (cyclic_refresh_segment_id_boosted(
              seg_map[mi_row * cm->mi_cols + mi_col]))
        cr->actual_num_seg_blocks++;
    }
260
261
}

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
// Set golden frame update interval, for non-svc 1 pass CBR mode.
void vp9_cyclic_refresh_set_golden_update(VP9_COMP *const cpi) {
  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 = 2 * (100 / cr->percent_refresh);
  else
    rc->baseline_gf_interval = 20;
}

// Update some encoding stats (from the just encoded frame), and if the golden
// reference is to be updated check if we should NOT update the golden ref.
void vp9_cyclic_refresh_check_golden_update(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  int mi_row, mi_col;
  double fraction_low = 0.0;
  int low_content_frame = 0;
  for (mi_row = 0; mi_row < cm->mi_rows; mi_row++)
    for (mi_col = 0; mi_col < cm->mi_cols; mi_col++) {
      if (cr->map[mi_row * cm->mi_cols + mi_col] < 1)
        low_content_frame++;
    }
  fraction_low =
      (double)low_content_frame / (cm->mi_rows * cm->mi_cols);
  // Update average.
  cr->low_content_avg = (fraction_low + 3 * cr->low_content_avg) / 4;
  if (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;
  }
}

303
304
// Update the segmentation map, and related quantities: cyclic refresh map,
// refresh sb_index, and target number of blocks to be refreshed.
305
306
307
308
// 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).
309
310
311
312
313
314
void vp9_cyclic_refresh_update_map(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
  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;
315
  vpx_memset(seg_map, CR_SEGMENT_ID_BASE, cm->mi_rows * cm->mi_cols);
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
  sb_cols = (cm->mi_cols + MI_BLOCK_SIZE - 1) / MI_BLOCK_SIZE;
  sb_rows = (cm->mi_rows + MI_BLOCK_SIZE - 1) / MI_BLOCK_SIZE;
  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;
    int mi_row = sb_row_index * MI_BLOCK_SIZE;
    int mi_col = sb_col_index * MI_BLOCK_SIZE;
    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.
    xmis = MIN(cm->mi_cols - mi_col,
               num_8x8_blocks_wide_lookup[BLOCK_64X64]);
    ymis = MIN(cm->mi_rows - mi_row,
               num_8x8_blocks_high_lookup[BLOCK_64X64]);
    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) {
          sum_map++;
        } 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++) {
360
          seg_map[bl_index + y * cm->mi_cols + x] = CR_SEGMENT_ID_BOOST1;
361
362
363
364
365
366
367
368
369
        }
      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;
370
371
}

372
373
374
375
376
377
378
379
380
381
382
383
384
385
// Set/update global/frame level cyclic refresh parameters.
void vp9_cyclic_refresh_update_parameters(VP9_COMP *const cpi) {
  const RATE_CONTROL *const rc = &cpi->rc;
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
  cr->percent_refresh = 10;
  // Use larger delta-qp (increase rate_ratio_qdelta) for first few (~4)
  // periods of the refresh cycle, after a key frame. This corresponds to ~40
  // frames with cr->percent_refresh = 10.
  if (rc->frames_since_key <  40)
    cr->rate_ratio_qdelta = 3.0;
  else
    cr->rate_ratio_qdelta = 2.0;
}

386
// Setup cyclic background refresh: set delta q and segmentation map.
387
void vp9_cyclic_refresh_setup(VP9_COMP *const cpi) {
388
  VP9_COMMON *const cm = &cpi->common;
389
  const RATE_CONTROL *const rc = &cpi->rc;
390
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
391
  struct segmentation *const seg = &cm->seg;
392
  const int apply_cyclic_refresh  = apply_cyclic_refresh_bitrate(cm, rc);
393
394
  if (cm->current_video_frame == 0)
    cr->low_content_avg = 0.0;
395
396
  // Don't apply refresh on key frame or enhancement layer frames.
  if (!apply_cyclic_refresh ||
397
      (cm->frame_type == KEY_FRAME) ||
398
399
      (cpi->svc.temporal_layer_id > 0) ||
      (cpi->svc.spatial_layer_id > 0)) {
400
    // Set segmentation map to 0 and disable.
401
    unsigned char *const seg_map = cpi->segmentation_map;
402
403
    vpx_memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
    vp9_disable_segmentation(&cm->seg);
404
    if (cm->frame_type == KEY_FRAME)
405
      cr->sb_index = 0;
406
407
408
    return;
  } else {
    int qindex_delta = 0;
409
    int qindex2;
410
    const double q = vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth);
411
412
    vp9_clear_system_state();
    cr->max_qdelta_perc = 50;
413
    cr->time_for_refresh = 0;
414
    // Set rate threshold to some multiple (set to 2 for now) of the target
415
    // rate (target is given by sb64_target_rate and scaled by 256).
Marco's avatar
Marco committed
416
    cr->thresh_rate_sb = ((int64_t)(rc->sb64_target_rate) << 8) << 1;
417
    // Distortion threshold, quadratic in Q, scale factor to be adjusted.
Marco's avatar
Marco committed
418
419
420
    // q will not exceed 457, so (q * q) is within 32bit; see:
    // vp9_convert_qindex_to_q(), vp9_ac_quant(), ac_qlookup*[].
    cr->thresh_dist_sb = ((int64_t)(q * q)) << 2;
421
    cr->motion_thresh = 32;
422
423
424
425
426
427
428
429
430
431
432
433
434
435
    // Set up segmentation.
    // Clear down the segment map.
    vp9_enable_segmentation(&cm->seg);
    vp9_clearall_segfeatures(seg);
    // Select delta coding method.
    seg->abs_delta = SEGMENT_DELTADATA;

    // Note: setting temporal_update has no effect, as the seg-map coding method
    // (temporal or spatial) is determined in vp9_choose_segmap_coding_method(),
    // 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;

436
437
438
439
440
441
    // Segment BASE "Q" feature is disabled so it defaults to the baseline Q.
    vp9_disable_segfeature(seg, CR_SEGMENT_ID_BASE, SEG_LVL_ALT_Q);
    // Use segment BOOST1 for in-frame Q adjustment.
    vp9_enable_segfeature(seg, CR_SEGMENT_ID_BOOST1, SEG_LVL_ALT_Q);
    // Use segment BOOST2 for more aggressive in-frame Q adjustment.
    vp9_enable_segfeature(seg, CR_SEGMENT_ID_BOOST2, SEG_LVL_ALT_Q);
442

443
444
    // Set the q delta for segment BOOST1.
    qindex_delta = compute_deltaq(cpi, cm->base_qindex, cr->rate_ratio_qdelta);
445

446
    // Compute rd-mult for segment BOOST1.
447
448
449
    qindex2 = clamp(cm->base_qindex + cm->y_dc_delta_q + qindex_delta, 0, MAXQ);
    cr->rdmult = vp9_compute_rd_mult(cpi, qindex2);

450
451
452
453
454
455
456
    vp9_set_segdata(seg, CR_SEGMENT_ID_BOOST1, SEG_LVL_ALT_Q, qindex_delta);

    // Set a more aggressive (higher) q delta for segment BOOST2.
    qindex_delta = compute_deltaq(cpi, cm->base_qindex,
                                  MIN(CR_MAX_RATE_TARGET_RATIO,
                                      CR_BOOST2_FAC * cr->rate_ratio_qdelta));
    vp9_set_segdata(seg, CR_SEGMENT_ID_BOOST2, SEG_LVL_ALT_Q, qindex_delta);
457

458
459
    // Update the segmentation and refresh map.
    vp9_cyclic_refresh_update_map(cpi);
460
461
  }
}
462
463
464
465

int vp9_cyclic_refresh_get_rdmult(const CYCLIC_REFRESH *cr) {
  return cr->rdmult;
}