1 /* 2 * Copyright (c) 2014 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include <math.h> 12 13 #include "vp9/encoder/vp9_aq_cyclicrefresh.h" 14 #include "vp9/encoder/vp9_encoder.h" 15 #include "vp9/encoder/vp9_svc_layercontext.h" 16 #include "vp9/encoder/vp9_extend.h" 17 #include "vpx_dsp/vpx_dsp_common.h" 18 19 #define SMALL_FRAME_WIDTH 32 20 #define SMALL_FRAME_HEIGHT 16 21 22 void vp9_init_layer_context(VP9_COMP *const cpi) { 23 SVC *const svc = &cpi->svc; 24 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 25 int mi_rows = cpi->common.mi_rows; 26 int mi_cols = cpi->common.mi_cols; 27 int sl, tl, i; 28 int alt_ref_idx = svc->number_spatial_layers; 29 30 svc->spatial_layer_id = 0; 31 svc->temporal_layer_id = 0; 32 svc->first_spatial_layer_to_encode = 0; 33 svc->rc_drop_superframe = 0; 34 svc->force_zero_mode_spatial_ref = 0; 35 svc->use_base_mv = 0; 36 svc->scaled_temp_is_alloc = 0; 37 svc->scaled_one_half = 0; 38 svc->current_superframe = 0; 39 for (i = 0; i < REF_FRAMES; ++i) svc->ref_frame_index[i] = -1; 40 for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { 41 svc->ext_frame_flags[sl] = 0; 42 svc->ext_lst_fb_idx[sl] = 0; 43 svc->ext_gld_fb_idx[sl] = 1; 44 svc->ext_alt_fb_idx[sl] = 2; 45 svc->downsample_filter_type[sl] = EIGHTTAP; 46 svc->downsample_filter_phase[sl] = 0; // Set to 8 for averaging filter. 47 } 48 49 if (cpi->oxcf.error_resilient_mode == 0 && cpi->oxcf.pass == 2) { 50 if (vpx_realloc_frame_buffer(&cpi->svc.empty_frame.img, SMALL_FRAME_WIDTH, 51 SMALL_FRAME_HEIGHT, cpi->common.subsampling_x, 52 cpi->common.subsampling_y, 53 #if CONFIG_VP9_HIGHBITDEPTH 54 cpi->common.use_highbitdepth, 55 #endif 56 VP9_ENC_BORDER_IN_PIXELS, 57 cpi->common.byte_alignment, NULL, NULL, NULL)) 58 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 59 "Failed to allocate empty frame for multiple frame " 60 "contexts"); 61 62 memset(cpi->svc.empty_frame.img.buffer_alloc, 0x80, 63 cpi->svc.empty_frame.img.buffer_alloc_sz); 64 } 65 66 for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { 67 for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { 68 int layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers); 69 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; 70 RATE_CONTROL *const lrc = &lc->rc; 71 int i; 72 lc->current_video_frame_in_layer = 0; 73 lc->layer_size = 0; 74 lc->frames_from_key_frame = 0; 75 lc->last_frame_type = FRAME_TYPES; 76 lrc->ni_av_qi = oxcf->worst_allowed_q; 77 lrc->total_actual_bits = 0; 78 lrc->total_target_vs_actual = 0; 79 lrc->ni_tot_qi = 0; 80 lrc->tot_q = 0.0; 81 lrc->avg_q = 0.0; 82 lrc->ni_frames = 0; 83 lrc->decimation_count = 0; 84 lrc->decimation_factor = 0; 85 86 for (i = 0; i < RATE_FACTOR_LEVELS; ++i) { 87 lrc->rate_correction_factors[i] = 1.0; 88 } 89 90 if (cpi->oxcf.rc_mode == VPX_CBR) { 91 lc->target_bandwidth = oxcf->layer_target_bitrate[layer]; 92 lrc->last_q[INTER_FRAME] = oxcf->worst_allowed_q; 93 lrc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q; 94 lrc->avg_frame_qindex[KEY_FRAME] = oxcf->worst_allowed_q; 95 } else { 96 lc->target_bandwidth = oxcf->layer_target_bitrate[layer]; 97 lrc->last_q[KEY_FRAME] = oxcf->best_allowed_q; 98 lrc->last_q[INTER_FRAME] = oxcf->best_allowed_q; 99 lrc->avg_frame_qindex[KEY_FRAME] = 100 (oxcf->worst_allowed_q + oxcf->best_allowed_q) / 2; 101 lrc->avg_frame_qindex[INTER_FRAME] = 102 (oxcf->worst_allowed_q + oxcf->best_allowed_q) / 2; 103 if (oxcf->ss_enable_auto_arf[sl]) 104 lc->alt_ref_idx = alt_ref_idx++; 105 else 106 lc->alt_ref_idx = INVALID_IDX; 107 lc->gold_ref_idx = INVALID_IDX; 108 } 109 110 lrc->buffer_level = 111 oxcf->starting_buffer_level_ms * lc->target_bandwidth / 1000; 112 lrc->bits_off_target = lrc->buffer_level; 113 114 // Initialize the cyclic refresh parameters. If spatial layers are used 115 // (i.e., ss_number_layers > 1), these need to be updated per spatial 116 // layer. 117 // Cyclic refresh is only applied on base temporal layer. 118 if (oxcf->ss_number_layers > 1 && tl == 0) { 119 size_t last_coded_q_map_size; 120 size_t consec_zero_mv_size; 121 VP9_COMMON *const cm = &cpi->common; 122 lc->sb_index = 0; 123 CHECK_MEM_ERROR(cm, lc->map, 124 vpx_malloc(mi_rows * mi_cols * sizeof(*lc->map))); 125 memset(lc->map, 0, mi_rows * mi_cols); 126 last_coded_q_map_size = 127 mi_rows * mi_cols * sizeof(*lc->last_coded_q_map); 128 CHECK_MEM_ERROR(cm, lc->last_coded_q_map, 129 vpx_malloc(last_coded_q_map_size)); 130 assert(MAXQ <= 255); 131 memset(lc->last_coded_q_map, MAXQ, last_coded_q_map_size); 132 consec_zero_mv_size = mi_rows * mi_cols * sizeof(*lc->consec_zero_mv); 133 CHECK_MEM_ERROR(cm, lc->consec_zero_mv, 134 vpx_malloc(consec_zero_mv_size)); 135 memset(lc->consec_zero_mv, 0, consec_zero_mv_size); 136 } 137 } 138 } 139 140 // Still have extra buffer for base layer golden frame 141 if (!(svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) && 142 alt_ref_idx < REF_FRAMES) 143 svc->layer_context[0].gold_ref_idx = alt_ref_idx; 144 } 145 146 // Update the layer context from a change_config() call. 147 void vp9_update_layer_context_change_config(VP9_COMP *const cpi, 148 const int target_bandwidth) { 149 SVC *const svc = &cpi->svc; 150 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 151 const RATE_CONTROL *const rc = &cpi->rc; 152 int sl, tl, layer = 0, spatial_layer_target; 153 float bitrate_alloc = 1.0; 154 155 if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) { 156 for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { 157 for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { 158 layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers); 159 svc->layer_context[layer].target_bandwidth = 160 oxcf->layer_target_bitrate[layer]; 161 } 162 163 layer = LAYER_IDS_TO_IDX( 164 sl, 165 ((oxcf->ts_number_layers - 1) < 0 ? 0 : (oxcf->ts_number_layers - 1)), 166 oxcf->ts_number_layers); 167 spatial_layer_target = svc->layer_context[layer].target_bandwidth = 168 oxcf->layer_target_bitrate[layer]; 169 170 for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { 171 LAYER_CONTEXT *const lc = 172 &svc->layer_context[sl * oxcf->ts_number_layers + tl]; 173 RATE_CONTROL *const lrc = &lc->rc; 174 175 lc->spatial_layer_target_bandwidth = spatial_layer_target; 176 bitrate_alloc = (float)lc->target_bandwidth / spatial_layer_target; 177 lrc->starting_buffer_level = 178 (int64_t)(rc->starting_buffer_level * bitrate_alloc); 179 lrc->optimal_buffer_level = 180 (int64_t)(rc->optimal_buffer_level * bitrate_alloc); 181 lrc->maximum_buffer_size = 182 (int64_t)(rc->maximum_buffer_size * bitrate_alloc); 183 lrc->bits_off_target = 184 VPXMIN(lrc->bits_off_target, lrc->maximum_buffer_size); 185 lrc->buffer_level = VPXMIN(lrc->buffer_level, lrc->maximum_buffer_size); 186 lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[tl]; 187 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); 188 lrc->max_frame_bandwidth = rc->max_frame_bandwidth; 189 lrc->worst_quality = rc->worst_quality; 190 lrc->best_quality = rc->best_quality; 191 } 192 } 193 } else { 194 int layer_end; 195 196 if (svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) { 197 layer_end = svc->number_temporal_layers; 198 } else { 199 layer_end = svc->number_spatial_layers; 200 } 201 202 for (layer = 0; layer < layer_end; ++layer) { 203 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; 204 RATE_CONTROL *const lrc = &lc->rc; 205 206 lc->target_bandwidth = oxcf->layer_target_bitrate[layer]; 207 208 bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth; 209 // Update buffer-related quantities. 210 lrc->starting_buffer_level = 211 (int64_t)(rc->starting_buffer_level * bitrate_alloc); 212 lrc->optimal_buffer_level = 213 (int64_t)(rc->optimal_buffer_level * bitrate_alloc); 214 lrc->maximum_buffer_size = 215 (int64_t)(rc->maximum_buffer_size * bitrate_alloc); 216 lrc->bits_off_target = 217 VPXMIN(lrc->bits_off_target, lrc->maximum_buffer_size); 218 lrc->buffer_level = VPXMIN(lrc->buffer_level, lrc->maximum_buffer_size); 219 // Update framerate-related quantities. 220 if (svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) { 221 lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[layer]; 222 } else { 223 lc->framerate = cpi->framerate; 224 } 225 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); 226 lrc->max_frame_bandwidth = rc->max_frame_bandwidth; 227 // Update qp-related quantities. 228 lrc->worst_quality = rc->worst_quality; 229 lrc->best_quality = rc->best_quality; 230 } 231 } 232 } 233 234 static LAYER_CONTEXT *get_layer_context(VP9_COMP *const cpi) { 235 if (is_one_pass_cbr_svc(cpi)) 236 return &cpi->svc.layer_context[cpi->svc.spatial_layer_id * 237 cpi->svc.number_temporal_layers + 238 cpi->svc.temporal_layer_id]; 239 else 240 return (cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) 241 ? &cpi->svc.layer_context[cpi->svc.temporal_layer_id] 242 : &cpi->svc.layer_context[cpi->svc.spatial_layer_id]; 243 } 244 245 void vp9_update_temporal_layer_framerate(VP9_COMP *const cpi) { 246 SVC *const svc = &cpi->svc; 247 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 248 LAYER_CONTEXT *const lc = get_layer_context(cpi); 249 RATE_CONTROL *const lrc = &lc->rc; 250 // Index into spatial+temporal arrays. 251 const int st_idx = svc->spatial_layer_id * svc->number_temporal_layers + 252 svc->temporal_layer_id; 253 const int tl = svc->temporal_layer_id; 254 255 lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[tl]; 256 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); 257 lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth; 258 // Update the average layer frame size (non-cumulative per-frame-bw). 259 if (tl == 0) { 260 lc->avg_frame_size = lrc->avg_frame_bandwidth; 261 } else { 262 const double prev_layer_framerate = 263 cpi->framerate / oxcf->ts_rate_decimator[tl - 1]; 264 const int prev_layer_target_bandwidth = 265 oxcf->layer_target_bitrate[st_idx - 1]; 266 lc->avg_frame_size = 267 (int)((lc->target_bandwidth - prev_layer_target_bandwidth) / 268 (lc->framerate - prev_layer_framerate)); 269 } 270 } 271 272 void vp9_update_spatial_layer_framerate(VP9_COMP *const cpi, double framerate) { 273 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 274 LAYER_CONTEXT *const lc = get_layer_context(cpi); 275 RATE_CONTROL *const lrc = &lc->rc; 276 277 lc->framerate = framerate; 278 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); 279 lrc->min_frame_bandwidth = 280 (int)(lrc->avg_frame_bandwidth * oxcf->two_pass_vbrmin_section / 100); 281 lrc->max_frame_bandwidth = (int)(((int64_t)lrc->avg_frame_bandwidth * 282 oxcf->two_pass_vbrmax_section) / 283 100); 284 vp9_rc_set_gf_interval_range(cpi, lrc); 285 } 286 287 void vp9_restore_layer_context(VP9_COMP *const cpi) { 288 LAYER_CONTEXT *const lc = get_layer_context(cpi); 289 const int old_frame_since_key = cpi->rc.frames_since_key; 290 const int old_frame_to_key = cpi->rc.frames_to_key; 291 292 cpi->rc = lc->rc; 293 cpi->twopass = lc->twopass; 294 cpi->oxcf.target_bandwidth = lc->target_bandwidth; 295 cpi->alt_ref_source = lc->alt_ref_source; 296 // Check if it is one_pass_cbr_svc mode and lc->speed > 0 (real-time mode 297 // does not use speed = 0). 298 if (is_one_pass_cbr_svc(cpi) && lc->speed > 0) { 299 cpi->oxcf.speed = lc->speed; 300 } 301 // Reset the frames_since_key and frames_to_key counters to their values 302 // before the layer restore. Keep these defined for the stream (not layer). 303 if (cpi->svc.number_temporal_layers > 1 || 304 (cpi->svc.number_spatial_layers > 1 && !is_two_pass_svc(cpi))) { 305 cpi->rc.frames_since_key = old_frame_since_key; 306 cpi->rc.frames_to_key = old_frame_to_key; 307 } 308 309 // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers, 310 // for the base temporal layer. 311 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && 312 cpi->svc.number_spatial_layers > 1 && cpi->svc.temporal_layer_id == 0) { 313 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; 314 signed char *temp = cr->map; 315 uint8_t *temp2 = cr->last_coded_q_map; 316 uint8_t *temp3 = cpi->consec_zero_mv; 317 cr->map = lc->map; 318 lc->map = temp; 319 cr->last_coded_q_map = lc->last_coded_q_map; 320 lc->last_coded_q_map = temp2; 321 cpi->consec_zero_mv = lc->consec_zero_mv; 322 lc->consec_zero_mv = temp3; 323 cr->sb_index = lc->sb_index; 324 } 325 } 326 327 void vp9_save_layer_context(VP9_COMP *const cpi) { 328 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 329 LAYER_CONTEXT *const lc = get_layer_context(cpi); 330 331 lc->rc = cpi->rc; 332 lc->twopass = cpi->twopass; 333 lc->target_bandwidth = (int)oxcf->target_bandwidth; 334 lc->alt_ref_source = cpi->alt_ref_source; 335 336 // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers, 337 // for the base temporal layer. 338 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && 339 cpi->svc.number_spatial_layers > 1 && cpi->svc.temporal_layer_id == 0) { 340 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; 341 signed char *temp = lc->map; 342 uint8_t *temp2 = lc->last_coded_q_map; 343 uint8_t *temp3 = lc->consec_zero_mv; 344 lc->map = cr->map; 345 cr->map = temp; 346 lc->last_coded_q_map = cr->last_coded_q_map; 347 cr->last_coded_q_map = temp2; 348 lc->consec_zero_mv = cpi->consec_zero_mv; 349 cpi->consec_zero_mv = temp3; 350 lc->sb_index = cr->sb_index; 351 } 352 } 353 354 void vp9_init_second_pass_spatial_svc(VP9_COMP *cpi) { 355 SVC *const svc = &cpi->svc; 356 int i; 357 358 for (i = 0; i < svc->number_spatial_layers; ++i) { 359 TWO_PASS *const twopass = &svc->layer_context[i].twopass; 360 361 svc->spatial_layer_id = i; 362 vp9_init_second_pass(cpi); 363 364 twopass->total_stats.spatial_layer_id = i; 365 twopass->total_left_stats.spatial_layer_id = i; 366 } 367 svc->spatial_layer_id = 0; 368 } 369 370 void vp9_inc_frame_in_layer(VP9_COMP *const cpi) { 371 LAYER_CONTEXT *const lc = 372 &cpi->svc.layer_context[cpi->svc.spatial_layer_id * 373 cpi->svc.number_temporal_layers]; 374 ++lc->current_video_frame_in_layer; 375 ++lc->frames_from_key_frame; 376 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) 377 ++cpi->svc.current_superframe; 378 } 379 380 int vp9_is_upper_layer_key_frame(const VP9_COMP *const cpi) { 381 return is_two_pass_svc(cpi) && cpi->svc.spatial_layer_id > 0 && 382 cpi->svc 383 .layer_context[cpi->svc.spatial_layer_id * 384 cpi->svc.number_temporal_layers + 385 cpi->svc.temporal_layer_id] 386 .is_key_frame; 387 } 388 389 static void get_layer_resolution(const int width_org, const int height_org, 390 const int num, const int den, int *width_out, 391 int *height_out) { 392 int w, h; 393 394 if (width_out == NULL || height_out == NULL || den == 0) return; 395 396 w = width_org * num / den; 397 h = height_org * num / den; 398 399 // make height and width even to make chrome player happy 400 w += w % 2; 401 h += h % 2; 402 403 *width_out = w; 404 *height_out = h; 405 } 406 407 // The function sets proper ref_frame_flags, buffer indices, and buffer update 408 // variables for temporal layering mode 3 - that does 0-2-1-2 temporal layering 409 // scheme. 410 static void set_flags_and_fb_idx_for_temporal_mode3(VP9_COMP *const cpi) { 411 int frame_num_within_temporal_struct = 0; 412 int spatial_id, temporal_id; 413 spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; 414 frame_num_within_temporal_struct = 415 cpi->svc 416 .layer_context[cpi->svc.spatial_layer_id * 417 cpi->svc.number_temporal_layers] 418 .current_video_frame_in_layer % 419 4; 420 temporal_id = cpi->svc.temporal_layer_id = 421 (frame_num_within_temporal_struct & 1) 422 ? 2 423 : (frame_num_within_temporal_struct >> 1); 424 cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame = 425 cpi->ext_refresh_alt_ref_frame = 0; 426 if (!temporal_id) { 427 cpi->ext_refresh_frame_flags_pending = 1; 428 cpi->ext_refresh_last_frame = 1; 429 if (!spatial_id) { 430 cpi->ref_frame_flags = VP9_LAST_FLAG; 431 } else if (cpi->svc.layer_context[temporal_id].is_key_frame) { 432 // base layer is a key frame. 433 cpi->ref_frame_flags = VP9_LAST_FLAG; 434 cpi->ext_refresh_last_frame = 0; 435 cpi->ext_refresh_golden_frame = 1; 436 } else { 437 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 438 } 439 } else if (temporal_id == 1) { 440 cpi->ext_refresh_frame_flags_pending = 1; 441 cpi->ext_refresh_alt_ref_frame = 1; 442 if (!spatial_id) { 443 cpi->ref_frame_flags = VP9_LAST_FLAG; 444 } else { 445 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 446 } 447 } else { 448 if (frame_num_within_temporal_struct == 1) { 449 // the first tl2 picture 450 if (spatial_id == cpi->svc.number_spatial_layers - 1) { // top layer 451 cpi->ext_refresh_frame_flags_pending = 1; 452 if (!spatial_id) 453 cpi->ref_frame_flags = VP9_LAST_FLAG; 454 else 455 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 456 } else if (!spatial_id) { 457 cpi->ext_refresh_frame_flags_pending = 1; 458 cpi->ext_refresh_alt_ref_frame = 1; 459 cpi->ref_frame_flags = VP9_LAST_FLAG; 460 } else if (spatial_id < cpi->svc.number_spatial_layers - 1) { 461 cpi->ext_refresh_frame_flags_pending = 1; 462 cpi->ext_refresh_alt_ref_frame = 1; 463 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 464 } 465 } else { 466 // The second tl2 picture 467 if (spatial_id == cpi->svc.number_spatial_layers - 1) { // top layer 468 cpi->ext_refresh_frame_flags_pending = 1; 469 if (!spatial_id) 470 cpi->ref_frame_flags = VP9_LAST_FLAG; 471 else 472 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 473 } else if (!spatial_id) { 474 cpi->ext_refresh_frame_flags_pending = 1; 475 cpi->ref_frame_flags = VP9_LAST_FLAG; 476 cpi->ext_refresh_alt_ref_frame = 1; 477 } else { // top layer 478 cpi->ext_refresh_frame_flags_pending = 1; 479 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 480 cpi->ext_refresh_alt_ref_frame = 1; 481 } 482 } 483 } 484 if (temporal_id == 0) { 485 cpi->lst_fb_idx = spatial_id; 486 if (spatial_id) { 487 if (cpi->svc.layer_context[temporal_id].is_key_frame) { 488 cpi->lst_fb_idx = spatial_id - 1; 489 cpi->gld_fb_idx = spatial_id; 490 } else { 491 cpi->gld_fb_idx = spatial_id - 1; 492 } 493 } else { 494 cpi->gld_fb_idx = 0; 495 } 496 cpi->alt_fb_idx = 0; 497 } else if (temporal_id == 1) { 498 cpi->lst_fb_idx = spatial_id; 499 cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; 500 cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; 501 } else if (frame_num_within_temporal_struct == 1) { 502 cpi->lst_fb_idx = spatial_id; 503 cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; 504 cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; 505 } else { 506 cpi->lst_fb_idx = cpi->svc.number_spatial_layers + spatial_id; 507 cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; 508 cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; 509 } 510 } 511 512 // The function sets proper ref_frame_flags, buffer indices, and buffer update 513 // variables for temporal layering mode 2 - that does 0-1-0-1 temporal layering 514 // scheme. 515 static void set_flags_and_fb_idx_for_temporal_mode2(VP9_COMP *const cpi) { 516 int spatial_id, temporal_id; 517 spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; 518 temporal_id = cpi->svc.temporal_layer_id = 519 cpi->svc 520 .layer_context[cpi->svc.spatial_layer_id * 521 cpi->svc.number_temporal_layers] 522 .current_video_frame_in_layer & 523 1; 524 cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame = 525 cpi->ext_refresh_alt_ref_frame = 0; 526 if (!temporal_id) { 527 cpi->ext_refresh_frame_flags_pending = 1; 528 cpi->ext_refresh_last_frame = 1; 529 if (!spatial_id) { 530 cpi->ref_frame_flags = VP9_LAST_FLAG; 531 } else if (cpi->svc.layer_context[temporal_id].is_key_frame) { 532 // base layer is a key frame. 533 cpi->ref_frame_flags = VP9_LAST_FLAG; 534 cpi->ext_refresh_last_frame = 0; 535 cpi->ext_refresh_golden_frame = 1; 536 } else { 537 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 538 } 539 } else if (temporal_id == 1) { 540 cpi->ext_refresh_frame_flags_pending = 1; 541 cpi->ext_refresh_alt_ref_frame = 1; 542 if (!spatial_id) { 543 cpi->ref_frame_flags = VP9_LAST_FLAG; 544 } else { 545 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 546 } 547 } 548 549 if (temporal_id == 0) { 550 cpi->lst_fb_idx = spatial_id; 551 if (spatial_id) { 552 if (cpi->svc.layer_context[temporal_id].is_key_frame) { 553 cpi->lst_fb_idx = spatial_id - 1; 554 cpi->gld_fb_idx = spatial_id; 555 } else { 556 cpi->gld_fb_idx = spatial_id - 1; 557 } 558 } else { 559 cpi->gld_fb_idx = 0; 560 } 561 cpi->alt_fb_idx = 0; 562 } else if (temporal_id == 1) { 563 cpi->lst_fb_idx = spatial_id; 564 cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; 565 cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; 566 } 567 } 568 569 // The function sets proper ref_frame_flags, buffer indices, and buffer update 570 // variables for temporal layering mode 0 - that has no temporal layering. 571 static void set_flags_and_fb_idx_for_temporal_mode_noLayering( 572 VP9_COMP *const cpi) { 573 int spatial_id; 574 spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; 575 cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame = 576 cpi->ext_refresh_alt_ref_frame = 0; 577 cpi->ext_refresh_frame_flags_pending = 1; 578 cpi->ext_refresh_last_frame = 1; 579 if (!spatial_id) { 580 cpi->ref_frame_flags = VP9_LAST_FLAG; 581 } else if (cpi->svc.layer_context[0].is_key_frame) { 582 cpi->ref_frame_flags = VP9_LAST_FLAG; 583 cpi->ext_refresh_last_frame = 0; 584 cpi->ext_refresh_golden_frame = 1; 585 } else { 586 cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; 587 } 588 cpi->lst_fb_idx = spatial_id; 589 if (spatial_id) { 590 if (cpi->svc.layer_context[0].is_key_frame) { 591 cpi->lst_fb_idx = spatial_id - 1; 592 cpi->gld_fb_idx = spatial_id; 593 } else { 594 cpi->gld_fb_idx = spatial_id - 1; 595 } 596 } else { 597 cpi->gld_fb_idx = 0; 598 } 599 } 600 601 int vp9_one_pass_cbr_svc_start_layer(VP9_COMP *const cpi) { 602 int width = 0, height = 0; 603 LAYER_CONTEXT *lc = NULL; 604 if (cpi->svc.number_spatial_layers > 1) cpi->svc.use_base_mv = 1; 605 cpi->svc.force_zero_mode_spatial_ref = 1; 606 607 if (cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0212) { 608 set_flags_and_fb_idx_for_temporal_mode3(cpi); 609 } else if (cpi->svc.temporal_layering_mode == 610 VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) { 611 set_flags_and_fb_idx_for_temporal_mode_noLayering(cpi); 612 } else if (cpi->svc.temporal_layering_mode == 613 VP9E_TEMPORAL_LAYERING_MODE_0101) { 614 set_flags_and_fb_idx_for_temporal_mode2(cpi); 615 } else if (cpi->svc.temporal_layering_mode == 616 VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { 617 // In the BYPASS/flexible mode, the encoder is relying on the application 618 // to specify, for each spatial layer, the flags and buffer indices for the 619 // layering. 620 // Note that the check (cpi->ext_refresh_frame_flags_pending == 0) is 621 // needed to support the case where the frame flags may be passed in via 622 // vpx_codec_encode(), which can be used for the temporal-only svc case. 623 // TODO(marpan): Consider adding an enc_config parameter to better handle 624 // this case. 625 if (cpi->ext_refresh_frame_flags_pending == 0) { 626 int sl; 627 cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; 628 sl = cpi->svc.spatial_layer_id; 629 vp9_apply_encoding_flags(cpi, cpi->svc.ext_frame_flags[sl]); 630 cpi->lst_fb_idx = cpi->svc.ext_lst_fb_idx[sl]; 631 cpi->gld_fb_idx = cpi->svc.ext_gld_fb_idx[sl]; 632 cpi->alt_fb_idx = cpi->svc.ext_alt_fb_idx[sl]; 633 } 634 } 635 636 if (cpi->svc.spatial_layer_id == cpi->svc.first_spatial_layer_to_encode) 637 cpi->svc.rc_drop_superframe = 0; 638 639 lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id * 640 cpi->svc.number_temporal_layers + 641 cpi->svc.temporal_layer_id]; 642 643 // Setting the worst/best_quality via the encoder control: SET_SVC_PARAMETERS, 644 // only for non-BYPASS mode for now. 645 if (cpi->svc.temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { 646 RATE_CONTROL *const lrc = &lc->rc; 647 lrc->worst_quality = vp9_quantizer_to_qindex(lc->max_q); 648 lrc->best_quality = vp9_quantizer_to_qindex(lc->min_q); 649 } 650 651 get_layer_resolution(cpi->oxcf.width, cpi->oxcf.height, 652 lc->scaling_factor_num, lc->scaling_factor_den, &width, 653 &height); 654 655 // For low resolutions: set phase of the filter = 8 (for symmetric averaging 656 // filter), use bilinear for now. 657 if (width <= 320 && height <= 240) { 658 cpi->svc.downsample_filter_type[cpi->svc.spatial_layer_id] = BILINEAR; 659 cpi->svc.downsample_filter_phase[cpi->svc.spatial_layer_id] = 8; 660 } 661 662 // The usage of use_base_mv assumes down-scale of 2x2. For now, turn off use 663 // of base motion vectors if spatial scale factors for any layers are not 2, 664 // keep the case of 3 spatial layers with scale factor of 4x4 for base layer. 665 // TODO(marpan): Fix this to allow for use_base_mv for scale factors != 2. 666 if (cpi->svc.number_spatial_layers > 1) { 667 int sl; 668 for (sl = 0; sl < cpi->svc.number_spatial_layers - 1; ++sl) { 669 lc = &cpi->svc.layer_context[sl * cpi->svc.number_temporal_layers + 670 cpi->svc.temporal_layer_id]; 671 if ((lc->scaling_factor_num != lc->scaling_factor_den >> 1) && 672 !(lc->scaling_factor_num == lc->scaling_factor_den >> 2 && sl == 0 && 673 cpi->svc.number_spatial_layers == 3)) { 674 cpi->svc.use_base_mv = 0; 675 break; 676 } 677 } 678 } 679 680 if (vp9_set_size_literal(cpi, width, height) != 0) 681 return VPX_CODEC_INVALID_PARAM; 682 683 return 0; 684 } 685 686 #if CONFIG_SPATIAL_SVC 687 #define SMALL_FRAME_FB_IDX 7 688 689 int vp9_svc_start_frame(VP9_COMP *const cpi) { 690 int width = 0, height = 0; 691 LAYER_CONTEXT *lc; 692 struct lookahead_entry *buf; 693 int count = 1 << (cpi->svc.number_temporal_layers - 1); 694 695 cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; 696 lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id]; 697 698 cpi->svc.temporal_layer_id = 0; 699 while ((lc->current_video_frame_in_layer % count) != 0) { 700 ++cpi->svc.temporal_layer_id; 701 count >>= 1; 702 } 703 704 cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG; 705 706 cpi->lst_fb_idx = cpi->svc.spatial_layer_id; 707 708 if (cpi->svc.spatial_layer_id == 0) 709 cpi->gld_fb_idx = 710 (lc->gold_ref_idx >= 0) ? lc->gold_ref_idx : cpi->lst_fb_idx; 711 else 712 cpi->gld_fb_idx = cpi->svc.spatial_layer_id - 1; 713 714 if (lc->current_video_frame_in_layer == 0) { 715 if (cpi->svc.spatial_layer_id >= 2) { 716 cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2; 717 } else { 718 cpi->alt_fb_idx = cpi->lst_fb_idx; 719 cpi->ref_frame_flags &= (~VP9_LAST_FLAG & ~VP9_ALT_FLAG); 720 } 721 } else { 722 if (cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id]) { 723 cpi->alt_fb_idx = lc->alt_ref_idx; 724 if (!lc->has_alt_frame) cpi->ref_frame_flags &= (~VP9_ALT_FLAG); 725 } else { 726 // Find a proper alt_fb_idx for layers that don't have alt ref frame 727 if (cpi->svc.spatial_layer_id == 0) { 728 cpi->alt_fb_idx = cpi->lst_fb_idx; 729 } else { 730 LAYER_CONTEXT *lc_lower = 731 &cpi->svc.layer_context[cpi->svc.spatial_layer_id - 1]; 732 733 if (cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id - 1] && 734 lc_lower->alt_ref_source != NULL) 735 cpi->alt_fb_idx = lc_lower->alt_ref_idx; 736 else if (cpi->svc.spatial_layer_id >= 2) 737 cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2; 738 else 739 cpi->alt_fb_idx = cpi->lst_fb_idx; 740 } 741 } 742 } 743 744 get_layer_resolution(cpi->oxcf.width, cpi->oxcf.height, 745 lc->scaling_factor_num, lc->scaling_factor_den, &width, 746 &height); 747 748 // Workaround for multiple frame contexts. In some frames we can't use prev_mi 749 // since its previous frame could be changed during decoding time. The idea is 750 // we put a empty invisible frame in front of them, then we will not use 751 // prev_mi when encoding these frames. 752 753 buf = vp9_lookahead_peek(cpi->lookahead, 0); 754 if (cpi->oxcf.error_resilient_mode == 0 && cpi->oxcf.pass == 2 && 755 cpi->svc.encode_empty_frame_state == NEED_TO_ENCODE && 756 lc->rc.frames_to_key != 0 && 757 !(buf != NULL && (buf->flags & VPX_EFLAG_FORCE_KF))) { 758 if ((cpi->svc.number_temporal_layers > 1 && 759 cpi->svc.temporal_layer_id < cpi->svc.number_temporal_layers - 1) || 760 (cpi->svc.number_spatial_layers > 1 && 761 cpi->svc.spatial_layer_id == 0)) { 762 struct lookahead_entry *buf = vp9_lookahead_peek(cpi->lookahead, 0); 763 764 if (buf != NULL) { 765 cpi->svc.empty_frame.ts_start = buf->ts_start; 766 cpi->svc.empty_frame.ts_end = buf->ts_end; 767 cpi->svc.encode_empty_frame_state = ENCODING; 768 cpi->common.show_frame = 0; 769 cpi->ref_frame_flags = 0; 770 cpi->common.frame_type = INTER_FRAME; 771 cpi->lst_fb_idx = cpi->gld_fb_idx = cpi->alt_fb_idx = 772 SMALL_FRAME_FB_IDX; 773 774 if (cpi->svc.encode_intra_empty_frame != 0) cpi->common.intra_only = 1; 775 776 width = SMALL_FRAME_WIDTH; 777 height = SMALL_FRAME_HEIGHT; 778 } 779 } 780 } 781 782 cpi->oxcf.worst_allowed_q = vp9_quantizer_to_qindex(lc->max_q); 783 cpi->oxcf.best_allowed_q = vp9_quantizer_to_qindex(lc->min_q); 784 785 vp9_change_config(cpi, &cpi->oxcf); 786 787 if (vp9_set_size_literal(cpi, width, height) != 0) 788 return VPX_CODEC_INVALID_PARAM; 789 790 vp9_set_high_precision_mv(cpi, 1); 791 792 cpi->alt_ref_source = get_layer_context(cpi)->alt_ref_source; 793 794 return 0; 795 } 796 797 #undef SMALL_FRAME_FB_IDX 798 #endif // CONFIG_SPATIAL_SVC 799 800 struct lookahead_entry *vp9_svc_lookahead_pop(VP9_COMP *const cpi, 801 struct lookahead_ctx *ctx, 802 int drain) { 803 struct lookahead_entry *buf = NULL; 804 if (ctx->sz && (drain || ctx->sz == ctx->max_sz - MAX_PRE_FRAMES)) { 805 buf = vp9_lookahead_peek(ctx, 0); 806 if (buf != NULL) { 807 // Only remove the buffer when pop the highest layer. 808 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) { 809 vp9_lookahead_pop(ctx, drain); 810 } 811 } 812 } 813 return buf; 814 } 815 816 void vp9_free_svc_cyclic_refresh(VP9_COMP *const cpi) { 817 int sl, tl; 818 SVC *const svc = &cpi->svc; 819 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 820 for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { 821 for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { 822 int layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers); 823 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; 824 if (lc->map) vpx_free(lc->map); 825 if (lc->last_coded_q_map) vpx_free(lc->last_coded_q_map); 826 if (lc->consec_zero_mv) vpx_free(lc->consec_zero_mv); 827 } 828 } 829 } 830 831 // Reset on key frame: reset counters, references and buffer updates. 832 void vp9_svc_reset_key_frame(VP9_COMP *const cpi) { 833 int sl, tl; 834 SVC *const svc = &cpi->svc; 835 LAYER_CONTEXT *lc = NULL; 836 for (sl = 0; sl < svc->number_spatial_layers; ++sl) { 837 for (tl = 0; tl < svc->number_temporal_layers; ++tl) { 838 lc = &cpi->svc.layer_context[sl * svc->number_temporal_layers + tl]; 839 lc->current_video_frame_in_layer = 0; 840 lc->frames_from_key_frame = 0; 841 } 842 } 843 if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0212) { 844 set_flags_and_fb_idx_for_temporal_mode3(cpi); 845 } else if (svc->temporal_layering_mode == 846 VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) { 847 set_flags_and_fb_idx_for_temporal_mode_noLayering(cpi); 848 } else if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0101) { 849 set_flags_and_fb_idx_for_temporal_mode2(cpi); 850 } 851 vp9_update_temporal_layer_framerate(cpi); 852 vp9_restore_layer_context(cpi); 853 } 854
