svc_layercontext.c (31208B)
1 /* 2 * Copyright (c) 2019, Alliance for Open Media. All rights reserved. 3 * 4 * This source code is subject to the terms of the BSD 2 Clause License and 5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License 6 * was not distributed with this source code in the LICENSE file, you can 7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open 8 * Media Patent License 1.0 was not distributed with this source code in the 9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent. 10 */ 11 12 #include <assert.h> 13 #include <math.h> 14 15 #include "av1/encoder/encoder.h" 16 #include "av1/encoder/encoder_alloc.h" 17 18 static void swap_ptr(void *a, void *b) { 19 void **a_p = (void **)a; 20 void **b_p = (void **)b; 21 void *c = *a_p; 22 *a_p = *b_p; 23 *b_p = c; 24 } 25 26 void av1_init_layer_context(AV1_COMP *const cpi) { 27 AV1_COMMON *const cm = &cpi->common; 28 const AV1EncoderConfig *const oxcf = &cpi->oxcf; 29 SVC *const svc = &cpi->svc; 30 int mi_rows = cpi->common.mi_params.mi_rows; 31 int mi_cols = cpi->common.mi_params.mi_cols; 32 svc->base_framerate = 30.0; 33 svc->current_superframe = 0; 34 svc->force_zero_mode_spatial_ref = 1; 35 svc->num_encoded_top_layer = 0; 36 svc->use_flexible_mode = 0; 37 svc->has_lower_quality_layer = 0; 38 39 for (int sl = 0; sl < svc->number_spatial_layers; ++sl) { 40 for (int tl = 0; tl < svc->number_temporal_layers; ++tl) { 41 int layer = LAYER_IDS_TO_IDX(sl, tl, svc->number_temporal_layers); 42 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; 43 RATE_CONTROL *const lrc = &lc->rc; 44 PRIMARY_RATE_CONTROL *const lp_rc = &lc->p_rc; 45 lrc->ni_av_qi = oxcf->rc_cfg.worst_allowed_q; 46 lp_rc->total_actual_bits = 0; 47 lrc->ni_tot_qi = 0; 48 lp_rc->tot_q = 0.0; 49 lp_rc->avg_q = 0.0; 50 lp_rc->ni_frames = 0; 51 lrc->decimation_count = 0; 52 lrc->decimation_factor = 0; 53 lrc->worst_quality = av1_quantizer_to_qindex(lc->max_q); 54 lrc->best_quality = av1_quantizer_to_qindex(lc->min_q); 55 lrc->rtc_external_ratectrl = 0; 56 for (int i = 0; i < RATE_FACTOR_LEVELS; ++i) { 57 lp_rc->rate_correction_factors[i] = 1.0; 58 } 59 lc->target_bandwidth = lc->layer_target_bitrate; 60 lp_rc->last_q[INTER_FRAME] = lrc->worst_quality; 61 lp_rc->avg_frame_qindex[INTER_FRAME] = lrc->worst_quality; 62 lp_rc->avg_frame_qindex[KEY_FRAME] = lrc->worst_quality; 63 lp_rc->buffer_level = 64 oxcf->rc_cfg.starting_buffer_level_ms * lc->target_bandwidth / 1000; 65 lp_rc->bits_off_target = lp_rc->buffer_level; 66 // Initialize the cyclic refresh parameters. If spatial layers are used 67 // (i.e., ss_number_layers > 1), these need to be updated per spatial 68 // layer. Cyclic refresh is only applied on base temporal layer. 69 if (svc->number_spatial_layers > 1 && tl == 0) { 70 lc->sb_index = 0; 71 lc->actual_num_seg1_blocks = 0; 72 lc->actual_num_seg2_blocks = 0; 73 lc->counter_encode_maxq_scene_change = 0; 74 aom_free(lc->map); 75 CHECK_MEM_ERROR(cm, lc->map, 76 aom_calloc(mi_rows * mi_cols, sizeof(*lc->map))); 77 } 78 } 79 svc->downsample_filter_type[sl] = BILINEAR; 80 svc->downsample_filter_phase[sl] = 8; 81 svc->last_layer_dropped[sl] = false; 82 svc->drop_spatial_layer[sl] = false; 83 } 84 if (svc->number_spatial_layers == 3) { 85 svc->downsample_filter_type[0] = EIGHTTAP_SMOOTH; 86 } 87 } 88 89 bool av1_alloc_layer_context(AV1_COMP *cpi, int num_layers) { 90 SVC *const svc = &cpi->svc; 91 if (svc->layer_context == NULL || svc->num_allocated_layers < num_layers) { 92 assert(num_layers > 1); 93 aom_free(svc->layer_context); 94 svc->num_allocated_layers = 0; 95 svc->layer_context = 96 (LAYER_CONTEXT *)aom_calloc(num_layers, sizeof(*svc->layer_context)); 97 if (svc->layer_context == NULL) return false; 98 svc->num_allocated_layers = num_layers; 99 } 100 return true; 101 } 102 103 // Update the layer context from a change_config() call. 104 void av1_update_layer_context_change_config(AV1_COMP *const cpi, 105 const int64_t target_bandwidth) { 106 const RATE_CONTROL *const rc = &cpi->rc; 107 const PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc; 108 AV1_COMMON *const cm = &cpi->common; 109 SVC *const svc = &cpi->svc; 110 int layer = 0; 111 int64_t spatial_layer_target = 0; 112 float bitrate_alloc = 1.0; 113 const int mi_rows = cm->mi_params.mi_rows; 114 const int mi_cols = cm->mi_params.mi_cols; 115 for (int sl = 0; sl < svc->number_spatial_layers; ++sl) { 116 for (int tl = 0; tl < svc->number_temporal_layers; ++tl) { 117 layer = LAYER_IDS_TO_IDX(sl, tl, svc->number_temporal_layers); 118 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; 119 svc->layer_context[layer].target_bandwidth = lc->layer_target_bitrate; 120 } 121 spatial_layer_target = svc->layer_context[layer].target_bandwidth; 122 for (int tl = 0; tl < svc->number_temporal_layers; ++tl) { 123 LAYER_CONTEXT *const lc = 124 &svc->layer_context[sl * svc->number_temporal_layers + tl]; 125 RATE_CONTROL *const lrc = &lc->rc; 126 PRIMARY_RATE_CONTROL *const lp_rc = &lc->p_rc; 127 lc->spatial_layer_target_bandwidth = spatial_layer_target; 128 if (target_bandwidth != 0) { 129 bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth; 130 } 131 lp_rc->starting_buffer_level = 132 (int64_t)(p_rc->starting_buffer_level * bitrate_alloc); 133 lp_rc->optimal_buffer_level = 134 (int64_t)(p_rc->optimal_buffer_level * bitrate_alloc); 135 lp_rc->maximum_buffer_size = 136 (int64_t)(p_rc->maximum_buffer_size * bitrate_alloc); 137 lp_rc->bits_off_target = 138 AOMMIN(lp_rc->bits_off_target, lp_rc->maximum_buffer_size); 139 lp_rc->buffer_level = 140 AOMMIN(lp_rc->buffer_level, lp_rc->maximum_buffer_size); 141 lc->framerate = cpi->framerate / lc->framerate_factor; 142 lrc->avg_frame_bandwidth = 143 (int)round(lc->target_bandwidth / lc->framerate); 144 lrc->max_frame_bandwidth = rc->max_frame_bandwidth; 145 lrc->rtc_external_ratectrl = rc->rtc_external_ratectrl; 146 lrc->worst_quality = av1_quantizer_to_qindex(lc->max_q); 147 lrc->best_quality = av1_quantizer_to_qindex(lc->min_q); 148 if (rc->use_external_qp_one_pass) { 149 lrc->worst_quality = rc->worst_quality; 150 lrc->best_quality = rc->best_quality; 151 } 152 // Reset the cyclic refresh parameters, if needed (map is NULL), 153 // or number of spatial layers has changed. 154 // Cyclic refresh is only applied on base temporal layer. 155 if (svc->number_spatial_layers > 1 && tl == 0 && 156 (lc->map == NULL || 157 svc->prev_number_spatial_layers != svc->number_spatial_layers)) { 158 lc->sb_index = 0; 159 lc->actual_num_seg1_blocks = 0; 160 lc->actual_num_seg2_blocks = 0; 161 lc->counter_encode_maxq_scene_change = 0; 162 aom_free(lc->map); 163 CHECK_MEM_ERROR(cm, lc->map, 164 aom_calloc(mi_rows * mi_cols, sizeof(*lc->map))); 165 } 166 } 167 } 168 } 169 170 /*!\brief Return layer context for current layer. 171 * 172 * \ingroup rate_control 173 * \param[in] cpi Top level encoder structure 174 * 175 * \return LAYER_CONTEXT for current layer. 176 */ 177 static LAYER_CONTEXT *get_layer_context(AV1_COMP *const cpi) { 178 return &cpi->svc.layer_context[cpi->svc.spatial_layer_id * 179 cpi->svc.number_temporal_layers + 180 cpi->svc.temporal_layer_id]; 181 } 182 183 void av1_update_temporal_layer_framerate(AV1_COMP *const cpi) { 184 SVC *const svc = &cpi->svc; 185 LAYER_CONTEXT *const lc = get_layer_context(cpi); 186 RATE_CONTROL *const lrc = &lc->rc; 187 const int tl = svc->temporal_layer_id; 188 lc->framerate = cpi->framerate / lc->framerate_factor; 189 lrc->avg_frame_bandwidth = 190 saturate_cast_double_to_int(round(lc->target_bandwidth / lc->framerate)); 191 lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth; 192 // Update the average layer frame size (non-cumulative per-frame-bw). 193 if (tl == 0) { 194 lc->avg_frame_size = lrc->avg_frame_bandwidth; 195 } else { 196 int prev_layer = svc->spatial_layer_id * svc->number_temporal_layers + 197 svc->temporal_layer_id - 1; 198 LAYER_CONTEXT *const lcprev = &svc->layer_context[prev_layer]; 199 const double prev_layer_framerate = 200 cpi->framerate / lcprev->framerate_factor; 201 const int64_t prev_layer_target_bandwidth = lcprev->layer_target_bitrate; 202 if (lc->framerate > prev_layer_framerate) { 203 lc->avg_frame_size = 204 (int)round((lc->target_bandwidth - prev_layer_target_bandwidth) / 205 (lc->framerate - prev_layer_framerate)); 206 } else { 207 lc->avg_frame_size = (int)round(lc->target_bandwidth / lc->framerate); 208 } 209 } 210 } 211 212 bool av1_check_ref_is_low_spatial_res_super_frame(AV1_COMP *const cpi, 213 int ref_frame) { 214 SVC *svc = &cpi->svc; 215 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 216 int ref_frame_idx = rtc_ref->ref_idx[ref_frame - 1]; 217 return rtc_ref->buffer_time_index[ref_frame_idx] == svc->current_superframe && 218 rtc_ref->buffer_spatial_layer[ref_frame_idx] <= 219 svc->spatial_layer_id - 1; 220 } 221 222 void av1_restore_layer_context(AV1_COMP *const cpi) { 223 SVC *const svc = &cpi->svc; 224 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 225 const AV1_COMMON *const cm = &cpi->common; 226 LAYER_CONTEXT *const lc = get_layer_context(cpi); 227 const int old_frame_since_key = cpi->rc.frames_since_key; 228 const int old_frame_to_key = cpi->rc.frames_to_key; 229 const int frames_since_scene_change = cpi->rc.frames_since_scene_change; 230 const int last_encoded_size_keyframe = cpi->rc.last_encoded_size_keyframe; 231 const int last_target_size_keyframe = cpi->rc.last_target_size_keyframe; 232 const int max_consec_drop = cpi->rc.max_consec_drop; 233 const int postencode_drop = cpi->rc.postencode_drop; 234 const int static_since_last_scene_change = 235 cpi->rc.static_since_last_scene_change; 236 // Restore layer rate control. 237 cpi->rc = lc->rc; 238 cpi->ppi->p_rc = lc->p_rc; 239 cpi->oxcf.rc_cfg.target_bandwidth = lc->target_bandwidth; 240 cpi->gf_frame_index = 0; 241 cpi->mv_search_params.max_mv_magnitude = lc->max_mv_magnitude; 242 if (cpi->mv_search_params.max_mv_magnitude == 0) 243 cpi->mv_search_params.max_mv_magnitude = AOMMAX(cm->width, cm->height); 244 // Reset the following parameters to their values before 245 // the layer restore. Keep these defined for the stream (not layer). 246 cpi->rc.frames_since_key = old_frame_since_key; 247 cpi->rc.frames_to_key = old_frame_to_key; 248 cpi->rc.frames_since_scene_change = frames_since_scene_change; 249 cpi->rc.last_encoded_size_keyframe = last_encoded_size_keyframe; 250 cpi->rc.last_target_size_keyframe = last_target_size_keyframe; 251 cpi->rc.max_consec_drop = max_consec_drop; 252 cpi->rc.postencode_drop = postencode_drop; 253 cpi->rc.static_since_last_scene_change = static_since_last_scene_change; 254 // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers, 255 // for the base temporal layer. 256 if (cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ && 257 svc->number_spatial_layers > 1 && svc->temporal_layer_id == 0) { 258 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; 259 swap_ptr(&cr->map, &lc->map); 260 cr->sb_index = lc->sb_index; 261 cr->actual_num_seg1_blocks = lc->actual_num_seg1_blocks; 262 cr->actual_num_seg2_blocks = lc->actual_num_seg2_blocks; 263 cr->counter_encode_maxq_scene_change = lc->counter_encode_maxq_scene_change; 264 } 265 svc->skip_mvsearch_last = 0; 266 svc->skip_mvsearch_gf = 0; 267 svc->skip_mvsearch_altref = 0; 268 // For each reference (LAST/GOLDEN) set the skip_mvsearch_last/gf frame flags. 269 // This is to skip searching mv for that reference if it was last 270 // refreshed (i.e., buffer slot holding that reference was refreshed) on the 271 // previous spatial layer(s) at the same time (current_superframe). 272 if (rtc_ref->set_ref_frame_config && svc->force_zero_mode_spatial_ref && 273 cpi->sf.rt_sf.use_nonrd_pick_mode) { 274 if (av1_check_ref_is_low_spatial_res_super_frame(cpi, LAST_FRAME)) { 275 svc->skip_mvsearch_last = 1; 276 } 277 if (av1_check_ref_is_low_spatial_res_super_frame(cpi, GOLDEN_FRAME)) { 278 svc->skip_mvsearch_gf = 1; 279 } 280 if (av1_check_ref_is_low_spatial_res_super_frame(cpi, ALTREF_FRAME)) { 281 svc->skip_mvsearch_altref = 1; 282 } 283 } 284 } 285 286 void av1_svc_update_buffer_slot_refreshed(AV1_COMP *const cpi) { 287 SVC *const svc = &cpi->svc; 288 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 289 const unsigned int current_frame = 290 cpi->ppi->use_svc ? svc->current_superframe 291 : cpi->common.current_frame.frame_number; 292 // For any buffer slot that is refreshed, update it with 293 // the spatial_layer_id and the current_superframe. 294 if (cpi->common.current_frame.frame_type == KEY_FRAME) { 295 // All slots are refreshed on KEY. 296 for (unsigned int i = 0; i < REF_FRAMES; i++) { 297 rtc_ref->buffer_time_index[i] = current_frame; 298 rtc_ref->buffer_spatial_layer[i] = svc->spatial_layer_id; 299 } 300 } else if (rtc_ref->set_ref_frame_config) { 301 for (unsigned int i = 0; i < INTER_REFS_PER_FRAME; i++) { 302 const int ref_frame_map_idx = rtc_ref->ref_idx[i]; 303 if (rtc_ref->refresh[ref_frame_map_idx]) { 304 rtc_ref->buffer_time_index[ref_frame_map_idx] = current_frame; 305 rtc_ref->buffer_spatial_layer[ref_frame_map_idx] = 306 svc->spatial_layer_id; 307 } 308 } 309 } 310 } 311 312 void av1_save_layer_context(AV1_COMP *const cpi) { 313 SVC *const svc = &cpi->svc; 314 const AV1_COMMON *const cm = &cpi->common; 315 LAYER_CONTEXT *lc = get_layer_context(cpi); 316 lc->rc = cpi->rc; 317 lc->p_rc = cpi->ppi->p_rc; 318 lc->target_bandwidth = (int)cpi->oxcf.rc_cfg.target_bandwidth; 319 lc->group_index = cpi->gf_frame_index; 320 lc->max_mv_magnitude = cpi->mv_search_params.max_mv_magnitude; 321 if (svc->spatial_layer_id == 0) svc->base_framerate = cpi->framerate; 322 // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers, 323 // for the base temporal layer. 324 if (cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ && 325 cpi->svc.number_spatial_layers > 1 && svc->temporal_layer_id == 0) { 326 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; 327 signed char *temp = lc->map; 328 lc->map = cr->map; 329 cr->map = temp; 330 lc->sb_index = cr->sb_index; 331 lc->actual_num_seg1_blocks = cr->actual_num_seg1_blocks; 332 lc->actual_num_seg2_blocks = cr->actual_num_seg2_blocks; 333 lc->counter_encode_maxq_scene_change = cr->counter_encode_maxq_scene_change; 334 } 335 if (!cpi->is_dropped_frame) { 336 av1_svc_update_buffer_slot_refreshed(cpi); 337 for (unsigned int i = 0; i < REF_FRAMES; i++) { 338 if (frame_is_intra_only(cm) || 339 cm->current_frame.refresh_frame_flags & (1 << i)) { 340 svc->spatial_layer_fb[i] = svc->spatial_layer_id; 341 svc->temporal_layer_fb[i] = svc->temporal_layer_id; 342 } 343 } 344 } 345 if (svc->spatial_layer_id == svc->number_spatial_layers - 1) { 346 svc->current_superframe++; 347 // Reset drop flag to false for next superframe. 348 for (int sl = 0; sl < svc->number_spatial_layers; sl++) 349 svc->drop_spatial_layer[sl] = false; 350 } 351 } 352 353 int av1_svc_primary_ref_frame(const AV1_COMP *const cpi) { 354 const SVC *const svc = &cpi->svc; 355 const AV1_COMMON *const cm = &cpi->common; 356 int fb_idx = -1; 357 int primary_ref_frame = PRIMARY_REF_NONE; 358 if (cpi->svc.number_spatial_layers > 1 || 359 cpi->svc.number_temporal_layers > 1) { 360 // Set the primary_ref_frame to LAST_FRAME if that buffer slot for LAST 361 // was last updated on a lower temporal layer (or base TL0) and for the 362 // same spatial layer. For RTC patterns this allows for continued decoding 363 // when set of enhancement layers are dropped (continued decoding starting 364 // at next base TL0), so error_resilience can be off/0 for all layers. 365 fb_idx = get_ref_frame_map_idx(cm, LAST_FRAME); 366 if (cpi->ppi->rtc_ref.reference[0] == 1 && 367 svc->spatial_layer_fb[fb_idx] == svc->spatial_layer_id && 368 (svc->temporal_layer_fb[fb_idx] < svc->temporal_layer_id || 369 svc->temporal_layer_fb[fb_idx] == 0)) { 370 primary_ref_frame = 0; // LAST_FRAME: ref_frame - LAST_FRAME 371 } 372 } else if (cpi->ppi->rtc_ref.set_ref_frame_config) { 373 const ExternalFlags *const ext_flags = &cpi->ext_flags; 374 int flags = ext_flags->ref_frame_flags; 375 if (flags & AOM_LAST_FLAG) { 376 primary_ref_frame = 0; // LAST_FRAME: ref_frame - LAST_FRAME 377 } else if (flags & AOM_GOLD_FLAG) { 378 primary_ref_frame = GOLDEN_FRAME - LAST_FRAME; 379 } else if (flags & AOM_ALT_FLAG) { 380 primary_ref_frame = ALTREF_FRAME - LAST_FRAME; 381 } 382 } 383 return primary_ref_frame; 384 } 385 386 void av1_free_svc_cyclic_refresh(AV1_COMP *const cpi) { 387 SVC *const svc = &cpi->svc; 388 for (int sl = 0; sl < svc->number_spatial_layers; ++sl) { 389 for (int tl = 0; tl < svc->number_temporal_layers; ++tl) { 390 int layer = LAYER_IDS_TO_IDX(sl, tl, svc->number_temporal_layers); 391 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; 392 aom_free(lc->map); 393 lc->map = NULL; 394 } 395 } 396 } 397 398 void av1_svc_reset_temporal_layers(AV1_COMP *const cpi, int is_key) { 399 SVC *const svc = &cpi->svc; 400 LAYER_CONTEXT *lc = NULL; 401 for (int sl = 0; sl < svc->number_spatial_layers; ++sl) { 402 for (int tl = 0; tl < svc->number_temporal_layers; ++tl) { 403 lc = &cpi->svc.layer_context[sl * svc->number_temporal_layers + tl]; 404 if (is_key) lc->frames_from_key_frame = 0; 405 } 406 } 407 av1_update_temporal_layer_framerate(cpi); 408 av1_restore_layer_context(cpi); 409 } 410 411 void av1_get_layer_resolution(const int width_org, const int height_org, 412 const int num, const int den, int *width_out, 413 int *height_out) { 414 int w, h; 415 if (width_out == NULL || height_out == NULL || den == 0) return; 416 if (den == 1 && num == 1) { 417 *width_out = width_org; 418 *height_out = height_org; 419 return; 420 } 421 w = width_org * num / den; 422 h = height_org * num / den; 423 // Make height and width even. 424 w += w % 2; 425 h += h % 2; 426 *width_out = w; 427 *height_out = h; 428 } 429 430 void av1_one_pass_cbr_svc_start_layer(AV1_COMP *const cpi) { 431 SVC *const svc = &cpi->svc; 432 AV1_COMMON *const cm = &cpi->common; 433 LAYER_CONTEXT *lc = NULL; 434 int width = 0, height = 0; 435 lc = &svc->layer_context[svc->spatial_layer_id * svc->number_temporal_layers + 436 svc->temporal_layer_id]; 437 // Set the lower quality layer flag. 438 svc->has_lower_quality_layer = 0; 439 if (cpi->svc.spatial_layer_id > 0) { 440 const LAYER_CONTEXT *lc_prev = 441 &svc->layer_context[(svc->spatial_layer_id - 1) * 442 svc->number_temporal_layers + 443 svc->temporal_layer_id]; 444 if (lc_prev->scaling_factor_den == 1 && lc_prev->scaling_factor_num == 1) 445 svc->has_lower_quality_layer = 1; 446 } 447 av1_get_layer_resolution(cpi->oxcf.frm_dim_cfg.width, 448 cpi->oxcf.frm_dim_cfg.height, lc->scaling_factor_num, 449 lc->scaling_factor_den, &width, &height); 450 // Use Eightap_smooth for low resolutions. 451 if (width * height <= 320 * 240) 452 svc->downsample_filter_type[svc->spatial_layer_id] = EIGHTTAP_SMOOTH; 453 454 cm->width = width; 455 cm->height = height; 456 alloc_mb_mode_info_buffers(cpi); 457 av1_update_frame_size(cpi); 458 if (svc->spatial_layer_id == svc->number_spatial_layers - 1) { 459 svc->mi_cols_full_resoln = cm->mi_params.mi_cols; 460 svc->mi_rows_full_resoln = cm->mi_params.mi_rows; 461 } 462 } 463 464 enum { 465 SVC_LAST_FRAME = 0, 466 SVC_LAST2_FRAME, 467 SVC_LAST3_FRAME, 468 SVC_GOLDEN_FRAME, 469 SVC_BWDREF_FRAME, 470 SVC_ALTREF2_FRAME, 471 SVC_ALTREF_FRAME 472 }; 473 474 // For fixed svc mode: fixed pattern is set based on the number of 475 // spatial and temporal layers, and the ksvc_fixed_mode. 476 void av1_set_svc_fixed_mode(AV1_COMP *const cpi) { 477 SVC *const svc = &cpi->svc; 478 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 479 int i; 480 assert(svc->use_flexible_mode == 0); 481 assert(svc->number_spatial_layers >= 1 && svc->number_temporal_layers >= 1); 482 // Fixed SVC mode only supports at most 3 spatial or temporal layers. 483 if (svc->number_spatial_layers > 3 || svc->number_temporal_layers > 3) { 484 aom_internal_error(&cpi->ppi->error, AOM_CODEC_INVALID_PARAM, 485 "Invalid number of spatial/temporal layers for fixed " 486 "SVC mode (max: 3)"); 487 } 488 rtc_ref->set_ref_frame_config = 1; 489 int superframe_cnt = svc->current_superframe; 490 // Set the reference map buffer idx for the 7 references: 491 // LAST_FRAME (0), LAST2_FRAME(1), LAST3_FRAME(2), GOLDEN_FRAME(3), 492 // BWDREF_FRAME(4), ALTREF2_FRAME(5), ALTREF_FRAME(6). 493 for (i = 0; i < INTER_REFS_PER_FRAME; i++) { 494 rtc_ref->reference[i] = 0; 495 rtc_ref->ref_idx[i] = i; 496 } 497 for (i = 0; i < REF_FRAMES; i++) rtc_ref->refresh[i] = 0; 498 // Always reference LAST, and reference GOLDEN on SL > 0. 499 // For KSVC: GOLDEN reference will be removed on INTER_FRAMES later 500 // when frame_type is set. 501 rtc_ref->reference[SVC_LAST_FRAME] = 1; 502 if (svc->spatial_layer_id > 0) rtc_ref->reference[SVC_GOLDEN_FRAME] = 1; 503 if (svc->temporal_layer_id == 0) { 504 // Base temporal layer. 505 if (svc->spatial_layer_id == 0) { 506 // Set all buffer_idx to 0. Update slot 0 (LAST). 507 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 508 rtc_ref->refresh[0] = 1; 509 } else if (svc->spatial_layer_id == 1) { 510 // Set buffer_idx for LAST to slot 1, GOLDEN (and all other refs) to 511 // slot 0. Update slot 1 (LAST). 512 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 513 rtc_ref->ref_idx[SVC_LAST_FRAME] = 1; 514 rtc_ref->refresh[1] = 1; 515 } else if (svc->spatial_layer_id == 2) { 516 // Set buffer_idx for LAST to slot 2, GOLDEN (and all other refs) to 517 // slot 1. Update slot 2 (LAST). 518 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 1; 519 rtc_ref->ref_idx[SVC_LAST_FRAME] = 2; 520 rtc_ref->refresh[2] = 1; 521 } 522 } else if (svc->temporal_layer_id == 2 && (superframe_cnt - 1) % 4 == 0) { 523 // First top temporal enhancement layer. 524 if (svc->spatial_layer_id == 0) { 525 // Reference LAST (slot 0). 526 // Set GOLDEN to slot 3 and update slot 3. 527 // Set all other buffer_idx to slot 0. 528 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 529 if (svc->spatial_layer_id < svc->number_spatial_layers - 1) { 530 rtc_ref->ref_idx[SVC_GOLDEN_FRAME] = 3; 531 rtc_ref->refresh[3] = 1; 532 } 533 } else if (svc->spatial_layer_id == 1) { 534 // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 1, 535 // GOLDEN (and all other refs) to slot 3. 536 // Set LAST2 to slot 4 and Update slot 4. 537 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 3; 538 rtc_ref->ref_idx[SVC_LAST_FRAME] = 1; 539 if (svc->spatial_layer_id < svc->number_spatial_layers - 1) { 540 rtc_ref->ref_idx[SVC_LAST2_FRAME] = 4; 541 rtc_ref->refresh[4] = 1; 542 } 543 } else if (svc->spatial_layer_id == 2) { 544 // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 2, 545 // GOLDEN (and all other refs) to slot 4. 546 // No update. 547 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 4; 548 rtc_ref->ref_idx[SVC_LAST_FRAME] = 2; 549 } 550 } else if (svc->temporal_layer_id == 1) { 551 // Middle temporal enhancement layer. 552 if (svc->spatial_layer_id == 0) { 553 // Reference LAST. 554 // Set all buffer_idx to 0. 555 // Set GOLDEN to slot 5 and update slot 5. 556 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 557 if (svc->temporal_layer_id < svc->number_temporal_layers - 1 || 558 svc->spatial_layer_id < svc->number_spatial_layers - 1) { 559 rtc_ref->ref_idx[SVC_GOLDEN_FRAME] = 5; 560 rtc_ref->refresh[5] = 1; 561 } 562 } else if (svc->spatial_layer_id == 1) { 563 // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 1, 564 // GOLDEN (and all other refs) to slot 5. 565 // Set LAST3 to slot 6 and update slot 6. 566 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 5; 567 rtc_ref->ref_idx[SVC_LAST_FRAME] = 1; 568 if (svc->temporal_layer_id < svc->number_temporal_layers - 1 || 569 svc->spatial_layer_id < svc->number_spatial_layers - 1) { 570 rtc_ref->ref_idx[SVC_LAST3_FRAME] = 6; 571 rtc_ref->refresh[6] = 1; 572 } 573 } else if (svc->spatial_layer_id == 2) { 574 // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 2, 575 // GOLDEN (and all other refs) to slot 6. 576 // Set LAST3 to slot 7 and update slot 7. 577 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 6; 578 rtc_ref->ref_idx[SVC_LAST_FRAME] = 2; 579 if (svc->temporal_layer_id < svc->number_temporal_layers - 1) { 580 rtc_ref->ref_idx[SVC_LAST3_FRAME] = 7; 581 rtc_ref->refresh[7] = 1; 582 } 583 } 584 } else if (svc->temporal_layer_id == 2 && (superframe_cnt - 3) % 4 == 0) { 585 // Second top temporal enhancement layer. 586 if (svc->spatial_layer_id == 0) { 587 // Set LAST to slot 5 and reference LAST. 588 // Set GOLDEN to slot 3 and update slot 3. 589 // Set all other buffer_idx to 0. 590 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 591 rtc_ref->ref_idx[SVC_LAST_FRAME] = 5; 592 if (svc->spatial_layer_id < svc->number_spatial_layers - 1) { 593 rtc_ref->ref_idx[SVC_GOLDEN_FRAME] = 3; 594 rtc_ref->refresh[3] = 1; 595 } 596 } else if (svc->spatial_layer_id == 1) { 597 // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 6, 598 // GOLDEN to slot 3. Set LAST2 to slot 4 and update slot 4. 599 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 600 rtc_ref->ref_idx[SVC_LAST_FRAME] = 6; 601 rtc_ref->ref_idx[SVC_GOLDEN_FRAME] = 3; 602 if (svc->spatial_layer_id < svc->number_spatial_layers - 1) { 603 rtc_ref->ref_idx[SVC_LAST2_FRAME] = 4; 604 rtc_ref->refresh[4] = 1; 605 } 606 } else if (svc->spatial_layer_id == 2) { 607 // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 7, 608 // GOLDEN to slot 4. No update. 609 for (i = 0; i < INTER_REFS_PER_FRAME; i++) rtc_ref->ref_idx[i] = 0; 610 rtc_ref->ref_idx[SVC_LAST_FRAME] = 7; 611 rtc_ref->ref_idx[SVC_GOLDEN_FRAME] = 4; 612 } 613 } 614 } 615 616 void av1_svc_check_reset_layer_rc_flag(AV1_COMP *const cpi) { 617 SVC *const svc = &cpi->svc; 618 for (int sl = 0; sl < svc->number_spatial_layers; ++sl) { 619 // Check for reset based on avg_frame_bandwidth for spatial layer sl. 620 // If avg_frame_bandwidth for top temporal layer is not set 621 // (because enhancement layer was inactive), use the base TL0 622 int layer = LAYER_IDS_TO_IDX(sl, svc->number_temporal_layers - 1, 623 svc->number_temporal_layers); 624 LAYER_CONTEXT *lc = &svc->layer_context[layer]; 625 RATE_CONTROL *lrc = &lc->rc; 626 int avg_frame_bandwidth = lrc->avg_frame_bandwidth; 627 int prev_avg_frame_bandwidth = lrc->prev_avg_frame_bandwidth; 628 if (avg_frame_bandwidth == 0 || prev_avg_frame_bandwidth == 0) { 629 // Use base TL0. 630 layer = LAYER_IDS_TO_IDX(sl, 0, svc->number_temporal_layers); 631 lc = &svc->layer_context[layer]; 632 lrc = &lc->rc; 633 avg_frame_bandwidth = lrc->avg_frame_bandwidth; 634 prev_avg_frame_bandwidth = lrc->prev_avg_frame_bandwidth; 635 } 636 if (avg_frame_bandwidth / 3 > (prev_avg_frame_bandwidth >> 1) || 637 avg_frame_bandwidth < (prev_avg_frame_bandwidth >> 1)) { 638 // Reset for all temporal layers with spatial layer sl. 639 for (int tl = 0; tl < svc->number_temporal_layers; ++tl) { 640 int layer2 = LAYER_IDS_TO_IDX(sl, tl, svc->number_temporal_layers); 641 LAYER_CONTEXT *lc2 = &svc->layer_context[layer2]; 642 RATE_CONTROL *lrc2 = &lc2->rc; 643 PRIMARY_RATE_CONTROL *lp_rc2 = &lc2->p_rc; 644 PRIMARY_RATE_CONTROL *const lp_rc = &lc2->p_rc; 645 lrc2->rc_1_frame = 0; 646 lrc2->rc_2_frame = 0; 647 lp_rc2->bits_off_target = lp_rc->optimal_buffer_level; 648 lp_rc2->buffer_level = lp_rc->optimal_buffer_level; 649 } 650 } 651 } 652 } 653 654 void av1_svc_set_last_source(AV1_COMP *const cpi, EncodeFrameInput *frame_input, 655 YV12_BUFFER_CONFIG *prev_source) { 656 frame_input->last_source = prev_source != NULL ? prev_source : NULL; 657 if (!cpi->ppi->use_svc && cpi->rc.prev_frame_is_dropped && 658 cpi->rc.frame_number_encoded > 0) { 659 frame_input->last_source = &cpi->svc.source_last_TL0; 660 } else { 661 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 662 if (cpi->svc.spatial_layer_id == 0) { 663 // For base spatial layer: if the LAST reference (index 0) is not 664 // the previous (super)frame set the last_source to the source 665 // corresponding to the last TL0, otherwise keep it at prev_source. 666 // Always use source_last_TL0 if previous base TL0 was dropped. 667 if (cpi->svc.current_superframe > 0) { 668 const int buffslot_last = rtc_ref->ref_idx[0]; 669 // Check if previous frame was dropped on base TL0 layer. 670 const int layer = 671 LAYER_IDS_TO_IDX(0, 0, cpi->svc.number_temporal_layers); 672 LAYER_CONTEXT *lc = &cpi->svc.layer_context[layer]; 673 RATE_CONTROL *lrc = &lc->rc; 674 if (lrc->prev_frame_is_dropped || 675 rtc_ref->buffer_time_index[buffslot_last] < 676 cpi->svc.current_superframe - 1) { 677 frame_input->last_source = &cpi->svc.source_last_TL0; 678 } 679 } 680 } else if (cpi->svc.spatial_layer_id > 0) { 681 // For spatial enhancement layers: the previous source (prev_source) 682 // corresponds to the lower spatial layer (which is the same source so 683 // we can't use that), so always set the last_source to the source of the 684 // last TL0. 685 if (cpi->svc.current_superframe > 0) 686 frame_input->last_source = &cpi->svc.source_last_TL0; 687 else 688 frame_input->last_source = NULL; 689 } 690 } 691 } 692 693 int av1_svc_get_min_ref_dist(const AV1_COMP *cpi) { 694 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 695 int min_dist = INT_MAX; 696 const unsigned int current_frame_num = 697 cpi->ppi->use_svc ? cpi->svc.current_superframe 698 : cpi->common.current_frame.frame_number; 699 for (unsigned int i = 0; i < INTER_REFS_PER_FRAME; i++) { 700 if (rtc_ref->reference[i]) { 701 const int ref_frame_map_idx = rtc_ref->ref_idx[i]; 702 const int dist = (1 + current_frame_num) - 703 rtc_ref->buffer_time_index[ref_frame_map_idx]; 704 if (dist < min_dist) min_dist = dist; 705 } 706 } 707 return min_dist; 708 } 709 710 void av1_svc_set_reference_was_previous(AV1_COMP *cpi) { 711 RTC_REF *const rtc_ref = &cpi->ppi->rtc_ref; 712 // Check if the encoded frame had some reference that was the 713 // previous frame. 714 const unsigned int current_frame = 715 cpi->ppi->use_svc ? cpi->svc.current_superframe 716 : cpi->common.current_frame.frame_number; 717 rtc_ref->reference_was_previous_frame = true; 718 if (current_frame > 0) { 719 rtc_ref->reference_was_previous_frame = false; 720 for (unsigned int i = 0; i < INTER_REFS_PER_FRAME; i++) { 721 if (rtc_ref->reference[i]) { 722 const int ref_frame_map_idx = rtc_ref->ref_idx[i]; 723 if (rtc_ref->buffer_time_index[ref_frame_map_idx] == current_frame - 1) 724 rtc_ref->reference_was_previous_frame = true; 725 } 726 } 727 } 728 }