vp9_aq_cyclicrefresh.c 12.9 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
21

#include "vp9/common/vp9_seg_common.h"

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

22
struct CYCLIC_REFRESH {
23
24
25
  // Percentage of super-blocks per frame that are targeted as candidates
  // for cyclic refresh.
  int max_sbs_perframe;
26
27
28
29
  // Maximum q-delta as percentage of base q.
  int max_qdelta_perc;
  // Block size below which we don't apply cyclic refresh.
  BLOCK_SIZE min_block_size;
30
31
  // Superblock starting index for cycling through the frame.
  int sb_index;
32
33
  // Controls how long a block will need to wait to be refreshed again.
  int time_for_refresh;
34
  // Actual number of (8x8) blocks that were applied delta-q (segment 1).
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
60
61
62
63
64
65
66
67
  int num_seg_blocks;
  // Actual encoding bits for segment 1.
  int actual_seg_bits;
  // RD mult. parameters for segment 1.
  int rdmult;
  // Cyclic refresh map.
  signed char *map;
  // Projected rate and distortion for the current superblock.
  int64_t projected_rate_sb;
  int64_t projected_dist_sb;
  // Thresholds applied to projected rate/distortion of the superblock.
  int64_t thresh_rate_sb;
  int64_t thresh_dist_sb;
};

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);
}
68
69

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

// 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.
94
95
96
static int candidate_refresh_aq(const CYCLIC_REFRESH *cr,
                                const MB_MODE_INFO *mbmi,
                                BLOCK_SIZE bsize, int use_rd) {
97
98
99
100
101
102
103
104
105
106
  if (use_rd) {
    // If projected rate is below the thresh_rate (well below target,
    // so undershoot expected), accept it for lower-qp coding.
    if (cr->projected_rate_sb < cr->thresh_rate_sb)
      return 1;
    // Otherwise, reject the block for lower-qp coding if any of the following:
    // 1) prediction block size is below min_block_size
    // 2) mode is non-zero mv and projected distortion is above thresh_dist
    // 3) mode is an intra-mode (we may want to allow some of this under
    // another thresh_dist)
107
108
109
110
    else if (bsize < cr->min_block_size ||
             (mbmi->mv[0].as_int != 0 &&
              cr->projected_dist_sb > cr->thresh_dist_sb) ||
             !is_inter_block(mbmi))
111
112
113
114
115
      return 0;
    else
      return 1;
  } else {
    // Rate/distortion not used for update.
116
117
118
    if (bsize < cr->min_block_size ||
        mbmi->mv[0].as_int != 0 ||
        !is_inter_block(mbmi))
119
120
121
122
123
124
125
126
127
      return 0;
    else
      return 1;
  }
}

// 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.
128
129
130
131
void vp9_cyclic_refresh_update_segment(VP9_COMP *const cpi,
                                       MB_MODE_INFO *const mbmi,
                                       int mi_row, int mi_col,
                                       BLOCK_SIZE bsize, int use_rd) {
132
  const VP9_COMMON *const cm = &cpi->common;
133
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
134
135
136
137
138
  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;
139
  const int refresh_this_block = candidate_refresh_aq(cr, mbmi, bsize, use_rd);
140
141
142
  // Default is to not update the refresh map.
  int new_map_value = cr->map[block_index];
  int x = 0; int y = 0;
143

144
  // Check if we should reset the segment_id for this block.
145
146
  if (mbmi->segment_id > 0 && !refresh_this_block)
    mbmi->segment_id = 0;
147
148
149
150
151

  // 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.
152
  if (mbmi->segment_id == 1) {
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
    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;
  }
  // 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] =
170
          mbmi->segment_id;
171
172
173
    }
  // Keep track of actual number (in units of 8x8) of blocks in segment 1 used
  // for encoding this frame.
174
  if (mbmi->segment_id)
175
176
177
178
    cr->num_seg_blocks += xmis * ymis;
}

// Setup cyclic background refresh: set delta q and segmentation map.
179
void vp9_cyclic_refresh_setup(VP9_COMP *const cpi) {
180
  VP9_COMMON *const cm = &cpi->common;
181
  const RATE_CONTROL *const rc = &cpi->rc;
182
  CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
183
  struct segmentation *const seg = &cm->seg;
184
185
  unsigned char *const seg_map = cpi->segmentation_map;
  const int apply_cyclic_refresh  = apply_cyclic_refresh_bitrate(cm, rc);
186
187
  // Don't apply refresh on key frame or enhancement layer frames.
  if (!apply_cyclic_refresh ||
188
      (cm->frame_type == KEY_FRAME) ||
189
190
191
192
      (cpi->svc.temporal_layer_id > 0)) {
    // Set segmentation map to 0 and disable.
    vpx_memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
    vp9_disable_segmentation(&cm->seg);
193
    if (cm->frame_type == KEY_FRAME)
194
      cr->sb_index = 0;
195
196
197
    return;
  } else {
    int qindex_delta = 0;
198
199
    int i, block_count, bl_index, sb_rows, sb_cols, sbs_in_frame;
    int xmis, ymis, x, y, qindex2;
200
201

    // Rate target ratio to set q delta.
202
    const float rate_ratio_qdelta = 2.0;
203
204
    vp9_clear_system_state();
    // Some of these parameters may be set via codec-control function later.
205
    cr->max_sbs_perframe = 10;
206
207
208
209
    cr->max_qdelta_perc = 50;
    cr->min_block_size = BLOCK_16X16;
    cr->time_for_refresh = 1;
    // Set rate threshold to some fraction of target (and scaled by 256).
210
    cr->thresh_rate_sb = (rc->sb64_target_rate * 256) >> 2;
211
212
213
214
215
216
    // Distortion threshold, quadratic in Q, scale factor to be adjusted.
    cr->thresh_dist_sb = 8 * (int)(vp9_convert_qindex_to_q(cm->base_qindex) *
        vp9_convert_qindex_to_q(cm->base_qindex));
    if (cpi->sf.use_nonrd_pick_mode) {
      // May want to be more conservative with thresholds in non-rd mode for now
      // as rate/distortion are derived from model based on prediction residual.
217
      cr->thresh_rate_sb = (rc->sb64_target_rate * 256) >> 3;
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
      cr->thresh_dist_sb = 4 * (int)(vp9_convert_qindex_to_q(cm->base_qindex) *
          vp9_convert_qindex_to_q(cm->base_qindex));
    }

    cr->num_seg_blocks = 0;
    // Set up segmentation.
    // Clear down the segment map.
    vpx_memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
    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;

    // Segment 0 "Q" feature is disabled so it defaults to the baseline Q.
    vp9_disable_segfeature(seg, 0, SEG_LVL_ALT_Q);
    // Use segment 1 for in-frame Q adjustment.
    vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);

    // Set the q delta for segment 1.
    qindex_delta = vp9_compute_qdelta_by_rate(cpi,
                                              cm->base_qindex,
                                              rate_ratio_qdelta);
    // TODO(marpan): Incorporate the actual-vs-target rate over/undershoot from
    // previous encoded frame.
249
    if (-qindex_delta > cr->max_qdelta_perc * cm->base_qindex / 100)
250
251
252
253
254
255
256
      qindex_delta = -cr->max_qdelta_perc * cm->base_qindex / 100;

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

    vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qindex_delta);
257
258
259
260
261
262
263

    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 superblocks to get the q delta (segment 1).
    block_count = cr->max_sbs_perframe * sbs_in_frame / 100;
    // Set the segmentation map: cycle through the superblocks, starting at
264
265
    // cr->mb_index, and stopping when either block_count blocks have been found
    // to be refreshed, or we have passed through whole frame.
266
267
    assert(cr->sb_index < sbs_in_frame);
    i = cr->sb_index;
268
    do {
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
      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) {
            seg_map[bl_index2] = 1;
            sum_map++;
          } else if (cr->map[bl_index2] < 0) {
            cr->map[bl_index2]++;
          }
        }
296
      }
297
298
299
300
      // Enforce constant segment over superblock.
      // If segment is partial over superblock, reset to either all 1 or 0.
      if (sum_map > 0 && sum_map < xmis * ymis) {
        const int new_value = (sum_map >= xmis * ymis / 2);
301
        for (y = 0; y < ymis; y++)
302
          for (x = 0; x < xmis; x++)
303
            seg_map[bl_index + y * cm->mi_cols + x] = new_value;
304
      }
305
306
307
308
309
310
311
312
      i++;
      if (i == sbs_in_frame) {
        i = 0;
      }
      if (sum_map >= xmis * ymis /2)
        block_count--;
    } while (block_count && i != cr->sb_index);
    cr->sb_index = i;
313
314
  }
}
315
316
317
318
319
320
321
322
323
324

void vp9_cyclic_refresh_set_rate_and_dist_sb(CYCLIC_REFRESH *cr,
                                             int64_t rate_sb, int64_t dist_sb) {
  cr->projected_rate_sb = rate_sb;
  cr->projected_dist_sb = dist_sb;
}

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