| /* |
| * 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 <math.h> |
| |
| #include "vp9/encoder/vp9_aq_cyclicrefresh.h" |
| #include "vp9/encoder/vp9_encoder.h" |
| #include "vp9/encoder/vp9_svc_layercontext.h" |
| #include "vp9/encoder/vp9_extend.h" |
| #include "vpx_dsp/vpx_dsp_common.h" |
| |
| #define SMALL_FRAME_WIDTH 32 |
| #define SMALL_FRAME_HEIGHT 16 |
| |
| static void swap_ptr(void *a, void *b) { |
| void **a_p = (void **)a; |
| void **b_p = (void **)b; |
| void *c = *a_p; |
| *a_p = *b_p; |
| *b_p = c; |
| } |
| |
| void vp9_init_layer_context(VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| const VP9EncoderConfig *const oxcf = &cpi->oxcf; |
| int mi_rows = cpi->common.mi_rows; |
| int mi_cols = cpi->common.mi_cols; |
| int sl, tl, i; |
| int alt_ref_idx = svc->number_spatial_layers; |
| |
| svc->spatial_layer_id = 0; |
| svc->temporal_layer_id = 0; |
| svc->force_zero_mode_spatial_ref = 0; |
| svc->use_base_mv = 0; |
| svc->use_partition_reuse = 0; |
| svc->use_gf_temporal_ref = 1; |
| svc->use_gf_temporal_ref_current_layer = 0; |
| svc->scaled_temp_is_alloc = 0; |
| svc->scaled_one_half = 0; |
| svc->current_superframe = 0; |
| svc->non_reference_frame = 0; |
| svc->skip_enhancement_layer = 0; |
| svc->disable_inter_layer_pred = INTER_LAYER_PRED_ON; |
| svc->framedrop_mode = CONSTRAINED_LAYER_DROP; |
| svc->set_intra_only_frame = 0; |
| svc->previous_frame_is_intra_only = 0; |
| svc->superframe_has_layer_sync = 0; |
| svc->use_set_ref_frame_config = 0; |
| svc->num_encoded_top_layer = 0; |
| svc->simulcast_mode = 0; |
| svc->single_layer_svc = 0; |
| |
| for (i = 0; i < REF_FRAMES; ++i) { |
| svc->fb_idx_spatial_layer_id[i] = 0xff; |
| svc->fb_idx_temporal_layer_id[i] = 0xff; |
| svc->fb_idx_base[i] = 0; |
| } |
| for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { |
| svc->last_layer_dropped[sl] = 0; |
| svc->drop_spatial_layer[sl] = 0; |
| svc->ext_frame_flags[sl] = 0; |
| svc->lst_fb_idx[sl] = 0; |
| svc->gld_fb_idx[sl] = 1; |
| svc->alt_fb_idx[sl] = 2; |
| svc->downsample_filter_type[sl] = BILINEAR; |
| svc->downsample_filter_phase[sl] = 8; // Set to 8 for averaging filter. |
| svc->framedrop_thresh[sl] = oxcf->drop_frames_water_mark; |
| svc->fb_idx_upd_tl0[sl] = -1; |
| svc->drop_count[sl] = 0; |
| svc->spatial_layer_sync[sl] = 0; |
| svc->force_drop_constrained_from_above[sl] = 0; |
| } |
| svc->max_consec_drop = INT_MAX; |
| |
| svc->buffer_gf_temporal_ref[1].idx = 7; |
| svc->buffer_gf_temporal_ref[0].idx = 6; |
| svc->buffer_gf_temporal_ref[1].is_used = 0; |
| svc->buffer_gf_temporal_ref[0].is_used = 0; |
| |
| if (cpi->oxcf.error_resilient_mode == 0 && cpi->oxcf.pass == 2) { |
| if (vpx_realloc_frame_buffer(&cpi->svc.empty_frame.img, SMALL_FRAME_WIDTH, |
| SMALL_FRAME_HEIGHT, cpi->common.subsampling_x, |
| cpi->common.subsampling_y, |
| #if CONFIG_VP9_HIGHBITDEPTH |
| cpi->common.use_highbitdepth, |
| #endif |
| VP9_ENC_BORDER_IN_PIXELS, |
| cpi->common.byte_alignment, NULL, NULL, NULL)) |
| vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, |
| "Failed to allocate empty frame for multiple frame " |
| "contexts"); |
| |
| memset(cpi->svc.empty_frame.img.buffer_alloc, 0x80, |
| cpi->svc.empty_frame.img.buffer_alloc_sz); |
| } |
| |
| for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { |
| for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { |
| int layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers); |
| LAYER_CONTEXT *const lc = &svc->layer_context[layer]; |
| RATE_CONTROL *const lrc = &lc->rc; |
| int i; |
| lc->current_video_frame_in_layer = 0; |
| lc->layer_size = 0; |
| lc->frames_from_key_frame = 0; |
| lc->last_frame_type = FRAME_TYPES; |
| lrc->ni_av_qi = oxcf->worst_allowed_q; |
| lrc->total_actual_bits = 0; |
| lrc->total_target_vs_actual = 0; |
| lrc->ni_tot_qi = 0; |
| lrc->tot_q = 0.0; |
| lrc->avg_q = 0.0; |
| lrc->ni_frames = 0; |
| lrc->decimation_count = 0; |
| lrc->decimation_factor = 0; |
| lrc->worst_quality = oxcf->worst_allowed_q; |
| lrc->best_quality = oxcf->best_allowed_q; |
| |
| for (i = 0; i < RATE_FACTOR_LEVELS; ++i) { |
| lrc->rate_correction_factors[i] = 1.0; |
| } |
| |
| if (cpi->oxcf.rc_mode == VPX_CBR) { |
| lc->target_bandwidth = oxcf->layer_target_bitrate[layer]; |
| lrc->last_q[INTER_FRAME] = oxcf->worst_allowed_q; |
| lrc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q; |
| lrc->avg_frame_qindex[KEY_FRAME] = oxcf->worst_allowed_q; |
| } else { |
| lc->target_bandwidth = oxcf->layer_target_bitrate[layer]; |
| lrc->last_q[KEY_FRAME] = oxcf->best_allowed_q; |
| lrc->last_q[INTER_FRAME] = oxcf->best_allowed_q; |
| lrc->avg_frame_qindex[KEY_FRAME] = |
| (oxcf->worst_allowed_q + oxcf->best_allowed_q) / 2; |
| lrc->avg_frame_qindex[INTER_FRAME] = |
| (oxcf->worst_allowed_q + oxcf->best_allowed_q) / 2; |
| if (oxcf->ss_enable_auto_arf[sl]) |
| lc->alt_ref_idx = alt_ref_idx++; |
| else |
| lc->alt_ref_idx = INVALID_IDX; |
| lc->gold_ref_idx = INVALID_IDX; |
| } |
| |
| lrc->buffer_level = |
| oxcf->starting_buffer_level_ms * lc->target_bandwidth / 1000; |
| lrc->bits_off_target = lrc->buffer_level; |
| |
| // Initialize the cyclic refresh parameters. If spatial layers are used |
| // (i.e., ss_number_layers > 1), these need to be updated per spatial |
| // layer. |
| // Cyclic refresh is only applied on base temporal layer. |
| if (oxcf->ss_number_layers > 1 && tl == 0) { |
| size_t last_coded_q_map_size; |
| size_t consec_zero_mv_size; |
| VP9_COMMON *const cm = &cpi->common; |
| lc->sb_index = 0; |
| lc->actual_num_seg1_blocks = 0; |
| lc->actual_num_seg2_blocks = 0; |
| lc->counter_encode_maxq_scene_change = 0; |
| CHECK_MEM_ERROR(cm, lc->map, |
| vpx_malloc(mi_rows * mi_cols * sizeof(*lc->map))); |
| memset(lc->map, 0, mi_rows * mi_cols); |
| last_coded_q_map_size = |
| mi_rows * mi_cols * sizeof(*lc->last_coded_q_map); |
| CHECK_MEM_ERROR(cm, lc->last_coded_q_map, |
| vpx_malloc(last_coded_q_map_size)); |
| assert(MAXQ <= 255); |
| memset(lc->last_coded_q_map, MAXQ, last_coded_q_map_size); |
| consec_zero_mv_size = mi_rows * mi_cols * sizeof(*lc->consec_zero_mv); |
| CHECK_MEM_ERROR(cm, lc->consec_zero_mv, |
| vpx_malloc(consec_zero_mv_size)); |
| memset(lc->consec_zero_mv, 0, consec_zero_mv_size); |
| } |
| } |
| } |
| |
| // Still have extra buffer for base layer golden frame |
| if (!(svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) && |
| alt_ref_idx < REF_FRAMES) |
| svc->layer_context[0].gold_ref_idx = alt_ref_idx; |
| } |
| |
| // Update the layer context from a change_config() call. |
| void vp9_update_layer_context_change_config(VP9_COMP *const cpi, |
| const int target_bandwidth) { |
| SVC *const svc = &cpi->svc; |
| const VP9EncoderConfig *const oxcf = &cpi->oxcf; |
| const RATE_CONTROL *const rc = &cpi->rc; |
| int sl, tl, layer = 0, spatial_layer_target; |
| float bitrate_alloc = 1.0; |
| int num_spatial_layers_nonzero_rate = 0; |
| |
| cpi->svc.temporal_layering_mode = oxcf->temporal_layering_mode; |
| |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) { |
| for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { |
| for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { |
| layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers); |
| svc->layer_context[layer].target_bandwidth = |
| oxcf->layer_target_bitrate[layer]; |
| } |
| |
| layer = LAYER_IDS_TO_IDX( |
| sl, |
| ((oxcf->ts_number_layers - 1) < 0 ? 0 : (oxcf->ts_number_layers - 1)), |
| oxcf->ts_number_layers); |
| spatial_layer_target = svc->layer_context[layer].target_bandwidth = |
| oxcf->layer_target_bitrate[layer]; |
| |
| for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { |
| LAYER_CONTEXT *const lc = |
| &svc->layer_context[sl * oxcf->ts_number_layers + tl]; |
| RATE_CONTROL *const lrc = &lc->rc; |
| |
| lc->spatial_layer_target_bandwidth = spatial_layer_target; |
| bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth; |
| lrc->starting_buffer_level = |
| (int64_t)(rc->starting_buffer_level * bitrate_alloc); |
| lrc->optimal_buffer_level = |
| (int64_t)(rc->optimal_buffer_level * bitrate_alloc); |
| lrc->maximum_buffer_size = |
| (int64_t)(rc->maximum_buffer_size * bitrate_alloc); |
| lrc->bits_off_target = |
| VPXMIN(lrc->bits_off_target, lrc->maximum_buffer_size); |
| lrc->buffer_level = VPXMIN(lrc->buffer_level, lrc->maximum_buffer_size); |
| lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[tl]; |
| lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| lrc->max_frame_bandwidth = rc->max_frame_bandwidth; |
| lrc->worst_quality = rc->worst_quality; |
| lrc->best_quality = rc->best_quality; |
| } |
| } |
| } else { |
| int layer_end; |
| |
| if (svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) { |
| layer_end = svc->number_temporal_layers; |
| } else { |
| layer_end = svc->number_spatial_layers; |
| } |
| |
| for (layer = 0; layer < layer_end; ++layer) { |
| LAYER_CONTEXT *const lc = &svc->layer_context[layer]; |
| RATE_CONTROL *const lrc = &lc->rc; |
| |
| lc->target_bandwidth = oxcf->layer_target_bitrate[layer]; |
| |
| bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth; |
| // Update buffer-related quantities. |
| lrc->starting_buffer_level = |
| (int64_t)(rc->starting_buffer_level * bitrate_alloc); |
| lrc->optimal_buffer_level = |
| (int64_t)(rc->optimal_buffer_level * bitrate_alloc); |
| lrc->maximum_buffer_size = |
| (int64_t)(rc->maximum_buffer_size * bitrate_alloc); |
| lrc->bits_off_target = |
| VPXMIN(lrc->bits_off_target, lrc->maximum_buffer_size); |
| lrc->buffer_level = VPXMIN(lrc->buffer_level, lrc->maximum_buffer_size); |
| // Update framerate-related quantities. |
| if (svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) { |
| lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[layer]; |
| } else { |
| lc->framerate = cpi->framerate; |
| } |
| lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| lrc->max_frame_bandwidth = rc->max_frame_bandwidth; |
| // Update qp-related quantities. |
| lrc->worst_quality = rc->worst_quality; |
| lrc->best_quality = rc->best_quality; |
| } |
| } |
| for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { |
| // Check bitrate of spatia layer. |
| layer = LAYER_IDS_TO_IDX(sl, oxcf->ts_number_layers - 1, |
| oxcf->ts_number_layers); |
| if (oxcf->layer_target_bitrate[layer] > 0) |
| num_spatial_layers_nonzero_rate += 1; |
| } |
| if (num_spatial_layers_nonzero_rate == 1) |
| svc->single_layer_svc = 1; |
| else |
| svc->single_layer_svc = 0; |
| } |
| |
| static LAYER_CONTEXT *get_layer_context(VP9_COMP *const cpi) { |
| if (is_one_pass_cbr_svc(cpi)) |
| return &cpi->svc.layer_context[cpi->svc.spatial_layer_id * |
| cpi->svc.number_temporal_layers + |
| cpi->svc.temporal_layer_id]; |
| else |
| return (cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) |
| ? &cpi->svc.layer_context[cpi->svc.temporal_layer_id] |
| : &cpi->svc.layer_context[cpi->svc.spatial_layer_id]; |
| } |
| |
| void vp9_update_temporal_layer_framerate(VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| const VP9EncoderConfig *const oxcf = &cpi->oxcf; |
| LAYER_CONTEXT *const lc = get_layer_context(cpi); |
| RATE_CONTROL *const lrc = &lc->rc; |
| // Index into spatial+temporal arrays. |
| const int st_idx = svc->spatial_layer_id * svc->number_temporal_layers + |
| svc->temporal_layer_id; |
| const int tl = svc->temporal_layer_id; |
| |
| lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[tl]; |
| lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth; |
| // Update the average layer frame size (non-cumulative per-frame-bw). |
| if (tl == 0) { |
| lc->avg_frame_size = lrc->avg_frame_bandwidth; |
| } else { |
| const double prev_layer_framerate = |
| cpi->framerate / oxcf->ts_rate_decimator[tl - 1]; |
| const int prev_layer_target_bandwidth = |
| oxcf->layer_target_bitrate[st_idx - 1]; |
| lc->avg_frame_size = |
| (int)((lc->target_bandwidth - prev_layer_target_bandwidth) / |
| (lc->framerate - prev_layer_framerate)); |
| } |
| } |
| |
| void vp9_update_spatial_layer_framerate(VP9_COMP *const cpi, double framerate) { |
| const VP9EncoderConfig *const oxcf = &cpi->oxcf; |
| LAYER_CONTEXT *const lc = get_layer_context(cpi); |
| RATE_CONTROL *const lrc = &lc->rc; |
| |
| lc->framerate = framerate; |
| lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| lrc->min_frame_bandwidth = |
| (int)(lrc->avg_frame_bandwidth * oxcf->two_pass_vbrmin_section / 100); |
| lrc->max_frame_bandwidth = (int)(((int64_t)lrc->avg_frame_bandwidth * |
| oxcf->two_pass_vbrmax_section) / |
| 100); |
| vp9_rc_set_gf_interval_range(cpi, lrc); |
| } |
| |
| void vp9_restore_layer_context(VP9_COMP *const cpi) { |
| LAYER_CONTEXT *const lc = get_layer_context(cpi); |
| const int old_frame_since_key = cpi->rc.frames_since_key; |
| const int old_frame_to_key = cpi->rc.frames_to_key; |
| const int old_ext_use_post_encode_drop = cpi->rc.ext_use_post_encode_drop; |
| |
| cpi->rc = lc->rc; |
| cpi->twopass = lc->twopass; |
| cpi->oxcf.target_bandwidth = lc->target_bandwidth; |
| cpi->alt_ref_source = lc->alt_ref_source; |
| // Check if it is one_pass_cbr_svc mode and lc->speed > 0 (real-time mode |
| // does not use speed = 0). |
| if (is_one_pass_cbr_svc(cpi) && lc->speed > 0) { |
| cpi->oxcf.speed = lc->speed; |
| } |
| // Reset the frames_since_key and frames_to_key counters to their values |
| // before the layer restore. Keep these defined for the stream (not layer). |
| if (cpi->svc.number_temporal_layers > 1 || |
| cpi->svc.number_spatial_layers > 1) { |
| cpi->rc.frames_since_key = old_frame_since_key; |
| cpi->rc.frames_to_key = old_frame_to_key; |
| } |
| cpi->rc.ext_use_post_encode_drop = old_ext_use_post_encode_drop; |
| // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers, |
| // for the base temporal layer. |
| if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && |
| cpi->svc.number_spatial_layers > 1 && cpi->svc.temporal_layer_id == 0) { |
| CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; |
| swap_ptr(&cr->map, &lc->map); |
| swap_ptr(&cr->last_coded_q_map, &lc->last_coded_q_map); |
| swap_ptr(&cpi->consec_zero_mv, &lc->consec_zero_mv); |
| cr->sb_index = lc->sb_index; |
| cr->actual_num_seg1_blocks = lc->actual_num_seg1_blocks; |
| cr->actual_num_seg2_blocks = lc->actual_num_seg2_blocks; |
| cr->counter_encode_maxq_scene_change = lc->counter_encode_maxq_scene_change; |
| } |
| } |
| |
| void vp9_save_layer_context(VP9_COMP *const cpi) { |
| const VP9EncoderConfig *const oxcf = &cpi->oxcf; |
| LAYER_CONTEXT *const lc = get_layer_context(cpi); |
| |
| lc->rc = cpi->rc; |
| lc->twopass = cpi->twopass; |
| lc->target_bandwidth = (int)oxcf->target_bandwidth; |
| lc->alt_ref_source = cpi->alt_ref_source; |
| |
| // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers, |
| // for the base temporal layer. |
| if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && |
| cpi->svc.number_spatial_layers > 1 && cpi->svc.temporal_layer_id == 0) { |
| CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; |
| signed char *temp = lc->map; |
| uint8_t *temp2 = lc->last_coded_q_map; |
| uint8_t *temp3 = lc->consec_zero_mv; |
| lc->map = cr->map; |
| cr->map = temp; |
| lc->last_coded_q_map = cr->last_coded_q_map; |
| cr->last_coded_q_map = temp2; |
| lc->consec_zero_mv = cpi->consec_zero_mv; |
| cpi->consec_zero_mv = temp3; |
| lc->sb_index = cr->sb_index; |
| lc->actual_num_seg1_blocks = cr->actual_num_seg1_blocks; |
| lc->actual_num_seg2_blocks = cr->actual_num_seg2_blocks; |
| lc->counter_encode_maxq_scene_change = cr->counter_encode_maxq_scene_change; |
| } |
| } |
| |
| #if !CONFIG_REALTIME_ONLY |
| void vp9_init_second_pass_spatial_svc(VP9_COMP *cpi) { |
| SVC *const svc = &cpi->svc; |
| int i; |
| |
| for (i = 0; i < svc->number_spatial_layers; ++i) { |
| TWO_PASS *const twopass = &svc->layer_context[i].twopass; |
| |
| svc->spatial_layer_id = i; |
| vp9_init_second_pass(cpi); |
| |
| twopass->total_stats.spatial_layer_id = i; |
| twopass->total_left_stats.spatial_layer_id = i; |
| } |
| svc->spatial_layer_id = 0; |
| } |
| #endif // !CONFIG_REALTIME_ONLY |
| |
| void vp9_inc_frame_in_layer(VP9_COMP *const cpi) { |
| LAYER_CONTEXT *const lc = |
| &cpi->svc.layer_context[cpi->svc.spatial_layer_id * |
| cpi->svc.number_temporal_layers]; |
| ++lc->current_video_frame_in_layer; |
| ++lc->frames_from_key_frame; |
| if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) |
| ++cpi->svc.current_superframe; |
| } |
| |
| void get_layer_resolution(const int width_org, const int height_org, |
| const int num, const int den, int *width_out, |
| int *height_out) { |
| int w, h; |
| |
| if (width_out == NULL || height_out == NULL || den == 0) return; |
| |
| w = width_org * num / den; |
| h = height_org * num / den; |
| |
| // make height and width even to make chrome player happy |
| w += w % 2; |
| h += h % 2; |
| |
| *width_out = w; |
| *height_out = h; |
| } |
| |
| static void reset_fb_idx_unused(VP9_COMP *const cpi) { |
| // If a reference frame is not referenced or refreshed, then set the |
| // fb_idx for that reference to the first one used/referenced. |
| // This is to avoid setting fb_idx for a reference to a slot that is not |
| // used/needed (i.e., since that reference is not referenced or refreshed). |
| static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, |
| VP9_ALT_FLAG }; |
| MV_REFERENCE_FRAME ref_frame; |
| MV_REFERENCE_FRAME first_ref = 0; |
| int first_fb_idx = 0; |
| int fb_idx[3] = { cpi->lst_fb_idx, cpi->gld_fb_idx, cpi->alt_fb_idx }; |
| for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { |
| if (cpi->ref_frame_flags & flag_list[ref_frame]) { |
| first_ref = ref_frame; |
| first_fb_idx = fb_idx[ref_frame - 1]; |
| break; |
| } |
| } |
| if (first_ref > 0) { |
| if (first_ref != LAST_FRAME && |
| !(cpi->ref_frame_flags & flag_list[LAST_FRAME]) && |
| !cpi->ext_refresh_last_frame) |
| cpi->lst_fb_idx = first_fb_idx; |
| else if (first_ref != GOLDEN_FRAME && |
| !(cpi->ref_frame_flags & flag_list[GOLDEN_FRAME]) && |
| !cpi->ext_refresh_golden_frame) |
| cpi->gld_fb_idx = first_fb_idx; |
| else if (first_ref != ALTREF_FRAME && |
| !(cpi->ref_frame_flags & flag_list[ALTREF_FRAME]) && |
| !cpi->ext_refresh_alt_ref_frame) |
| cpi->alt_fb_idx = first_fb_idx; |
| } |
| } |
| |
| // Never refresh any reference frame buffers on top temporal layers in |
| // simulcast mode, which has interlayer prediction disabled. |
| static void non_reference_frame_simulcast(VP9_COMP *const cpi) { |
| if (cpi->svc.temporal_layer_id == cpi->svc.number_temporal_layers - 1 && |
| cpi->svc.temporal_layer_id > 0) { |
| cpi->ext_refresh_last_frame = 0; |
| cpi->ext_refresh_golden_frame = 0; |
| cpi->ext_refresh_alt_ref_frame = 0; |
| } |
| } |
| |
| // The function sets proper ref_frame_flags, buffer indices, and buffer update |
| // variables for temporal layering mode 3 - that does 0-2-1-2 temporal layering |
| // scheme. |
| static void set_flags_and_fb_idx_for_temporal_mode3(VP9_COMP *const cpi) { |
| int frame_num_within_temporal_struct = 0; |
| int spatial_id, temporal_id; |
| spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; |
| frame_num_within_temporal_struct = |
| cpi->svc |
| .layer_context[cpi->svc.spatial_layer_id * |
| cpi->svc.number_temporal_layers] |
| .current_video_frame_in_layer % |
| 4; |
| temporal_id = cpi->svc.temporal_layer_id = |
| (frame_num_within_temporal_struct & 1) |
| ? 2 |
| : (frame_num_within_temporal_struct >> 1); |
| cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame = |
| cpi->ext_refresh_alt_ref_frame = 0; |
| if (!temporal_id) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_last_frame = 1; |
| if (!spatial_id) { |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| } else if (cpi->svc.layer_context[temporal_id].is_key_frame) { |
| // base layer is a key frame. |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| cpi->ext_refresh_last_frame = 0; |
| cpi->ext_refresh_golden_frame = 1; |
| } else { |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } |
| } else if (temporal_id == 1) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| if (!spatial_id) { |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| } else { |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } |
| } else { |
| if (frame_num_within_temporal_struct == 1) { |
| // the first tl2 picture |
| if (spatial_id == cpi->svc.number_spatial_layers - 1) { // top layer |
| cpi->ext_refresh_frame_flags_pending = 1; |
| if (!spatial_id) |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| else |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } else if (!spatial_id) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| } else if (spatial_id < cpi->svc.number_spatial_layers - 1) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } |
| } else { |
| // The second tl2 picture |
| if (spatial_id == cpi->svc.number_spatial_layers - 1) { // top layer |
| cpi->ext_refresh_frame_flags_pending = 1; |
| if (!spatial_id) |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| else |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } else if (!spatial_id) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| } else { // top layer |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| } |
| } |
| } |
| if (temporal_id == 0) { |
| cpi->lst_fb_idx = spatial_id; |
| if (spatial_id) { |
| if (cpi->svc.layer_context[temporal_id].is_key_frame) { |
| cpi->lst_fb_idx = spatial_id - 1; |
| cpi->gld_fb_idx = spatial_id; |
| } else { |
| cpi->gld_fb_idx = spatial_id - 1; |
| } |
| } else { |
| cpi->gld_fb_idx = 0; |
| } |
| cpi->alt_fb_idx = 0; |
| } else if (temporal_id == 1) { |
| cpi->lst_fb_idx = spatial_id; |
| cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; |
| cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; |
| } else if (frame_num_within_temporal_struct == 1) { |
| cpi->lst_fb_idx = spatial_id; |
| cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; |
| cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; |
| } else { |
| cpi->lst_fb_idx = cpi->svc.number_spatial_layers + spatial_id; |
| cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; |
| cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; |
| } |
| |
| if (cpi->svc.simulcast_mode) non_reference_frame_simulcast(cpi); |
| |
| reset_fb_idx_unused(cpi); |
| } |
| |
| // The function sets proper ref_frame_flags, buffer indices, and buffer update |
| // variables for temporal layering mode 2 - that does 0-1-0-1 temporal layering |
| // scheme. |
| static void set_flags_and_fb_idx_for_temporal_mode2(VP9_COMP *const cpi) { |
| int spatial_id, temporal_id; |
| spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; |
| temporal_id = cpi->svc.temporal_layer_id = |
| cpi->svc |
| .layer_context[cpi->svc.spatial_layer_id * |
| cpi->svc.number_temporal_layers] |
| .current_video_frame_in_layer & |
| 1; |
| cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame = |
| cpi->ext_refresh_alt_ref_frame = 0; |
| if (!temporal_id) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_last_frame = 1; |
| if (!spatial_id) { |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| } else if (cpi->svc.layer_context[temporal_id].is_key_frame) { |
| // base layer is a key frame. |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| cpi->ext_refresh_last_frame = 0; |
| cpi->ext_refresh_golden_frame = 1; |
| } else { |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } |
| } else if (temporal_id == 1) { |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| if (!spatial_id) { |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| } else { |
| if (spatial_id == cpi->svc.number_spatial_layers - 1) |
| cpi->ext_refresh_alt_ref_frame = 0; |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } |
| } |
| |
| if (temporal_id == 0) { |
| cpi->lst_fb_idx = spatial_id; |
| if (spatial_id) { |
| if (cpi->svc.layer_context[temporal_id].is_key_frame) { |
| cpi->lst_fb_idx = spatial_id - 1; |
| cpi->gld_fb_idx = spatial_id; |
| } else { |
| cpi->gld_fb_idx = spatial_id - 1; |
| } |
| } else { |
| cpi->gld_fb_idx = 0; |
| } |
| cpi->alt_fb_idx = 0; |
| } else if (temporal_id == 1) { |
| cpi->lst_fb_idx = spatial_id; |
| cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1; |
| cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id; |
| } |
| |
| if (cpi->svc.simulcast_mode) non_reference_frame_simulcast(cpi); |
| |
| reset_fb_idx_unused(cpi); |
| } |
| |
| // The function sets proper ref_frame_flags, buffer indices, and buffer update |
| // variables for temporal layering mode 0 - that has no temporal layering. |
| static void set_flags_and_fb_idx_for_temporal_mode_noLayering( |
| VP9_COMP *const cpi) { |
| int spatial_id; |
| spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode; |
| cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame = |
| cpi->ext_refresh_alt_ref_frame = 0; |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->ext_refresh_last_frame = 1; |
| if (!spatial_id) { |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| } else if (cpi->svc.layer_context[0].is_key_frame) { |
| cpi->ref_frame_flags = VP9_LAST_FLAG; |
| cpi->ext_refresh_last_frame = 0; |
| cpi->ext_refresh_golden_frame = 1; |
| } else { |
| cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG; |
| } |
| cpi->lst_fb_idx = spatial_id; |
| if (spatial_id) { |
| if (cpi->svc.layer_context[0].is_key_frame) { |
| cpi->lst_fb_idx = spatial_id - 1; |
| cpi->gld_fb_idx = spatial_id; |
| } else { |
| cpi->gld_fb_idx = spatial_id - 1; |
| } |
| } else { |
| cpi->gld_fb_idx = 0; |
| } |
| |
| if (cpi->svc.simulcast_mode) non_reference_frame_simulcast(cpi); |
| |
| reset_fb_idx_unused(cpi); |
| } |
| |
| static void set_flags_and_fb_idx_bypass_via_set_ref_frame_config( |
| VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| int sl = svc->spatial_layer_id = svc->spatial_layer_to_encode; |
| cpi->svc.temporal_layer_id = cpi->svc.temporal_layer_id_per_spatial[sl]; |
| cpi->ext_refresh_frame_flags_pending = 1; |
| cpi->lst_fb_idx = svc->lst_fb_idx[sl]; |
| cpi->gld_fb_idx = svc->gld_fb_idx[sl]; |
| cpi->alt_fb_idx = svc->alt_fb_idx[sl]; |
| cpi->ext_refresh_last_frame = 0; |
| cpi->ext_refresh_golden_frame = 0; |
| cpi->ext_refresh_alt_ref_frame = 0; |
| cpi->ref_frame_flags = 0; |
| if (svc->reference_last[sl]) cpi->ref_frame_flags |= VP9_LAST_FLAG; |
| if (svc->reference_golden[sl]) cpi->ref_frame_flags |= VP9_GOLD_FLAG; |
| if (svc->reference_altref[sl]) cpi->ref_frame_flags |= VP9_ALT_FLAG; |
| } |
| |
| void vp9_copy_flags_ref_update_idx(VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, |
| VP9_ALT_FLAG }; |
| int sl = svc->spatial_layer_id; |
| svc->lst_fb_idx[sl] = cpi->lst_fb_idx; |
| svc->gld_fb_idx[sl] = cpi->gld_fb_idx; |
| svc->alt_fb_idx[sl] = cpi->alt_fb_idx; |
| // For the fixed SVC mode: pass the refresh_lst/gld/alt_frame flags to the |
| // update_buffer_slot, this is needed for the GET_SVC_REF_FRAME_CONFIG api. |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { |
| int ref; |
| for (ref = 0; ref < REF_FRAMES; ++ref) { |
| svc->update_buffer_slot[sl] &= ~(1 << ref); |
| if ((ref == svc->lst_fb_idx[sl] && cpi->refresh_last_frame) || |
| (ref == svc->gld_fb_idx[sl] && cpi->refresh_golden_frame) || |
| (ref == svc->alt_fb_idx[sl] && cpi->refresh_alt_ref_frame)) |
| svc->update_buffer_slot[sl] |= (1 << ref); |
| } |
| } |
| |
| // TODO(jianj): Remove these 3, deprecated. |
| svc->update_last[sl] = (uint8_t)cpi->refresh_last_frame; |
| svc->update_golden[sl] = (uint8_t)cpi->refresh_golden_frame; |
| svc->update_altref[sl] = (uint8_t)cpi->refresh_alt_ref_frame; |
| |
| svc->reference_last[sl] = |
| (uint8_t)(cpi->ref_frame_flags & flag_list[LAST_FRAME]); |
| svc->reference_golden[sl] = |
| (uint8_t)(cpi->ref_frame_flags & flag_list[GOLDEN_FRAME]); |
| svc->reference_altref[sl] = |
| (uint8_t)(cpi->ref_frame_flags & flag_list[ALTREF_FRAME]); |
| } |
| |
| int vp9_one_pass_cbr_svc_start_layer(VP9_COMP *const cpi) { |
| int width = 0, height = 0; |
| SVC *const svc = &cpi->svc; |
| LAYER_CONTEXT *lc = NULL; |
| int scaling_factor_num = 1; |
| int scaling_factor_den = 1; |
| svc->skip_enhancement_layer = 0; |
| |
| if (svc->disable_inter_layer_pred == INTER_LAYER_PRED_OFF && |
| svc->number_spatial_layers > 1 && svc->number_spatial_layers <= 3 && |
| svc->number_temporal_layers <= 3 && |
| !(svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->use_set_ref_frame_config)) |
| svc->simulcast_mode = 1; |
| else |
| svc->simulcast_mode = 0; |
| |
| if (svc->number_spatial_layers > 1) { |
| svc->use_base_mv = 1; |
| svc->use_partition_reuse = 1; |
| } |
| svc->force_zero_mode_spatial_ref = 1; |
| svc->mi_stride[svc->spatial_layer_id] = cpi->common.mi_stride; |
| svc->mi_rows[svc->spatial_layer_id] = cpi->common.mi_rows; |
| svc->mi_cols[svc->spatial_layer_id] = cpi->common.mi_cols; |
| |
| // For constrained_from_above drop mode: before encoding superframe (i.e., |
| // at SL0 frame) check all spatial layers (starting from top) for possible |
| // drop, and if so, set a flag to force drop of that layer and all its lower |
| // layers. |
| if (svc->spatial_layer_to_encode == svc->first_spatial_layer_to_encode) { |
| int sl; |
| for (sl = 0; sl < svc->number_spatial_layers; sl++) |
| svc->force_drop_constrained_from_above[sl] = 0; |
| if (svc->framedrop_mode == CONSTRAINED_FROM_ABOVE_DROP) { |
| for (sl = svc->number_spatial_layers - 1; |
| sl >= svc->first_spatial_layer_to_encode; sl--) { |
| int layer = sl * svc->number_temporal_layers + svc->temporal_layer_id; |
| LAYER_CONTEXT *const lc = &svc->layer_context[layer]; |
| cpi->rc = lc->rc; |
| cpi->oxcf.target_bandwidth = lc->target_bandwidth; |
| if (vp9_test_drop(cpi)) { |
| int sl2; |
| // Set flag to force drop in encoding for this mode. |
| for (sl2 = sl; sl2 >= svc->first_spatial_layer_to_encode; sl2--) |
| svc->force_drop_constrained_from_above[sl2] = 1; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0212) { |
| set_flags_and_fb_idx_for_temporal_mode3(cpi); |
| } else if (svc->temporal_layering_mode == |
| VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) { |
| set_flags_and_fb_idx_for_temporal_mode_noLayering(cpi); |
| } else if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0101) { |
| set_flags_and_fb_idx_for_temporal_mode2(cpi); |
| } else if (svc->temporal_layering_mode == |
| VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->use_set_ref_frame_config) { |
| set_flags_and_fb_idx_bypass_via_set_ref_frame_config(cpi); |
| } |
| |
| if (cpi->lst_fb_idx == svc->buffer_gf_temporal_ref[0].idx || |
| cpi->gld_fb_idx == svc->buffer_gf_temporal_ref[0].idx || |
| cpi->alt_fb_idx == svc->buffer_gf_temporal_ref[0].idx) |
| svc->buffer_gf_temporal_ref[0].is_used = 1; |
| if (cpi->lst_fb_idx == svc->buffer_gf_temporal_ref[1].idx || |
| cpi->gld_fb_idx == svc->buffer_gf_temporal_ref[1].idx || |
| cpi->alt_fb_idx == svc->buffer_gf_temporal_ref[1].idx) |
| svc->buffer_gf_temporal_ref[1].is_used = 1; |
| |
| // For the fixed (non-flexible/bypass) SVC mode: |
| // If long term temporal reference is enabled at the sequence level |
| // (use_gf_temporal_ref == 1), and inter_layer is disabled (on inter-frames), |
| // we can use golden as a second temporal reference |
| // (since the spatial/inter-layer reference is disabled). |
| // We check that the fb_idx for this reference (buffer_gf_temporal_ref.idx) is |
| // unused (slot 7 and 6 should be available for 3-3 layer system). |
| // For now usage of this second temporal reference will only be used for |
| // highest and next to highest spatial layer (i.e., top and middle layer for |
| // 3 spatial layers). |
| svc->use_gf_temporal_ref_current_layer = 0; |
| if (svc->use_gf_temporal_ref && !svc->buffer_gf_temporal_ref[0].is_used && |
| !svc->buffer_gf_temporal_ref[1].is_used && |
| svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->disable_inter_layer_pred != INTER_LAYER_PRED_ON && |
| svc->number_spatial_layers <= 3 && svc->number_temporal_layers <= 3 && |
| svc->spatial_layer_id >= svc->number_spatial_layers - 2) { |
| // Enable the second (long-term) temporal reference at the frame-level. |
| svc->use_gf_temporal_ref_current_layer = 1; |
| } |
| |
| // Check if current superframe has any layer sync, only check once on |
| // base layer. |
| if (svc->spatial_layer_id == 0) { |
| int sl = 0; |
| // Default is no sync. |
| svc->superframe_has_layer_sync = 0; |
| for (sl = 0; sl < svc->number_spatial_layers; ++sl) { |
| if (cpi->svc.spatial_layer_sync[sl]) svc->superframe_has_layer_sync = 1; |
| } |
| } |
| |
| // Reset the drop flags for all spatial layers, on the base layer. |
| if (svc->spatial_layer_id == 0) { |
| vp9_zero(svc->drop_spatial_layer); |
| // TODO(jianj/marpan): Investigate why setting svc->lst/gld/alt_fb_idx |
| // causes an issue with frame dropping and temporal layers, when the frame |
| // flags are passed via the encode call (bypass mode). Issue is that we're |
| // resetting ext_refresh_frame_flags_pending to 0 on frame drops. |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { |
| memset(&svc->lst_fb_idx, -1, sizeof(svc->lst_fb_idx)); |
| memset(&svc->gld_fb_idx, -1, sizeof(svc->lst_fb_idx)); |
| memset(&svc->alt_fb_idx, -1, sizeof(svc->lst_fb_idx)); |
| // These are set by API before the superframe is encoded and they are |
| // passed to encoder layer by layer. Don't reset them on layer 0 in bypass |
| // mode. |
| vp9_zero(svc->update_buffer_slot); |
| vp9_zero(svc->reference_last); |
| vp9_zero(svc->reference_golden); |
| vp9_zero(svc->reference_altref); |
| // TODO(jianj): Remove these 3, deprecated. |
| vp9_zero(svc->update_last); |
| vp9_zero(svc->update_golden); |
| vp9_zero(svc->update_altref); |
| } |
| } |
| |
| lc = &svc->layer_context[svc->spatial_layer_id * svc->number_temporal_layers + |
| svc->temporal_layer_id]; |
| |
| // Setting the worst/best_quality via the encoder control: SET_SVC_PARAMETERS, |
| // only for non-BYPASS mode for now. |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS || |
| svc->use_set_ref_frame_config) { |
| RATE_CONTROL *const lrc = &lc->rc; |
| lrc->worst_quality = vp9_quantizer_to_qindex(lc->max_q); |
| lrc->best_quality = vp9_quantizer_to_qindex(lc->min_q); |
| } |
| |
| if (cpi->oxcf.resize_mode == RESIZE_DYNAMIC && svc->single_layer_svc == 1 && |
| svc->spatial_layer_id == svc->first_spatial_layer_to_encode && |
| cpi->resize_state != ORIG) { |
| scaling_factor_num = lc->scaling_factor_num_resize; |
| scaling_factor_den = lc->scaling_factor_den_resize; |
| } else { |
| scaling_factor_num = lc->scaling_factor_num; |
| scaling_factor_den = lc->scaling_factor_den; |
| } |
| |
| get_layer_resolution(cpi->oxcf.width, cpi->oxcf.height, scaling_factor_num, |
| scaling_factor_den, &width, &height); |
| |
| // Use Eightap_smooth for low resolutions. |
| if (width * height <= 320 * 240) |
| svc->downsample_filter_type[svc->spatial_layer_id] = EIGHTTAP_SMOOTH; |
| // For scale factors > 0.75, set the phase to 0 (aligns decimated pixel |
| // to source pixel). |
| if (scaling_factor_num > (3 * scaling_factor_den) >> 2) |
| svc->downsample_filter_phase[svc->spatial_layer_id] = 0; |
| |
| // The usage of use_base_mv or partition_reuse assumes down-scale of 2x2. |
| // For now, turn off use of base motion vectors and partition reuse if the |
| // spatial scale factors for any layers are not 2, |
| // keep the case of 3 spatial layers with scale factor of 4x4 for base layer. |
| // TODO(marpan): Fix this to allow for use_base_mv for scale factors != 2. |
| if (svc->number_spatial_layers > 1) { |
| int sl; |
| for (sl = 0; sl < svc->number_spatial_layers - 1; ++sl) { |
| lc = &svc->layer_context[sl * svc->number_temporal_layers + |
| svc->temporal_layer_id]; |
| if ((lc->scaling_factor_num != lc->scaling_factor_den >> 1) && |
| !(lc->scaling_factor_num == lc->scaling_factor_den >> 2 && sl == 0 && |
| svc->number_spatial_layers == 3)) { |
| svc->use_base_mv = 0; |
| svc->use_partition_reuse = 0; |
| break; |
| } |
| } |
| // For non-zero spatial layers: if the previous spatial layer was dropped |
| // disable the base_mv and partition_reuse features. |
| if (svc->spatial_layer_id > 0 && |
| svc->drop_spatial_layer[svc->spatial_layer_id - 1]) { |
| svc->use_base_mv = 0; |
| svc->use_partition_reuse = 0; |
| } |
| } |
| |
| svc->non_reference_frame = 0; |
| if (cpi->common.frame_type != KEY_FRAME && !cpi->ext_refresh_last_frame && |
| !cpi->ext_refresh_golden_frame && !cpi->ext_refresh_alt_ref_frame) |
| svc->non_reference_frame = 1; |
| // For non-flexible mode, where update_buffer_slot is used, need to check if |
| // all buffer slots are not refreshed. |
| if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { |
| if (svc->update_buffer_slot[svc->spatial_layer_id] != 0) |
| svc->non_reference_frame = 0; |
| } |
| |
| if (svc->spatial_layer_id == 0) { |
| svc->high_source_sad_superframe = 0; |
| svc->high_num_blocks_with_motion = 0; |
| } |
| |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->last_layer_dropped[svc->spatial_layer_id] && |
| svc->fb_idx_upd_tl0[svc->spatial_layer_id] != -1 && |
| !svc->layer_context[svc->temporal_layer_id].is_key_frame) { |
| // For fixed/non-flexible mode, if the previous frame (same spatial layer |
| // from previous superframe) was dropped, make sure the lst_fb_idx |
| // for this frame corresponds to the buffer index updated on (last) encoded |
| // TL0 frame (with same spatial layer). |
| cpi->lst_fb_idx = svc->fb_idx_upd_tl0[svc->spatial_layer_id]; |
| } |
| |
| if (vp9_set_size_literal(cpi, width, height) != 0) |
| return VPX_CODEC_INVALID_PARAM; |
| |
| return 0; |
| } |
| |
| struct lookahead_entry *vp9_svc_lookahead_pop(VP9_COMP *const cpi, |
| struct lookahead_ctx *ctx, |
| int drain) { |
| struct lookahead_entry *buf = NULL; |
| if (ctx->sz && (drain || ctx->sz == ctx->max_sz - MAX_PRE_FRAMES)) { |
| buf = vp9_lookahead_peek(ctx, 0); |
| if (buf != NULL) { |
| // Only remove the buffer when pop the highest layer. |
| if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) { |
| vp9_lookahead_pop(ctx, drain); |
| } |
| } |
| } |
| return buf; |
| } |
| |
| void vp9_free_svc_cyclic_refresh(VP9_COMP *const cpi) { |
| int sl, tl; |
| SVC *const svc = &cpi->svc; |
| const VP9EncoderConfig *const oxcf = &cpi->oxcf; |
| for (sl = 0; sl < oxcf->ss_number_layers; ++sl) { |
| for (tl = 0; tl < oxcf->ts_number_layers; ++tl) { |
| int layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers); |
| LAYER_CONTEXT *const lc = &svc->layer_context[layer]; |
| if (lc->map) vpx_free(lc->map); |
| if (lc->last_coded_q_map) vpx_free(lc->last_coded_q_map); |
| if (lc->consec_zero_mv) vpx_free(lc->consec_zero_mv); |
| } |
| } |
| } |
| |
| // Reset on key frame: reset counters, references and buffer updates. |
| void vp9_svc_reset_temporal_layers(VP9_COMP *const cpi, int is_key) { |
| int sl, tl; |
| SVC *const svc = &cpi->svc; |
| LAYER_CONTEXT *lc = NULL; |
| for (sl = 0; sl < svc->number_spatial_layers; ++sl) { |
| for (tl = 0; tl < svc->number_temporal_layers; ++tl) { |
| lc = &cpi->svc.layer_context[sl * svc->number_temporal_layers + tl]; |
| lc->current_video_frame_in_layer = 0; |
| if (is_key) lc->frames_from_key_frame = 0; |
| } |
| } |
| if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0212) { |
| set_flags_and_fb_idx_for_temporal_mode3(cpi); |
| } else if (svc->temporal_layering_mode == |
| VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) { |
| set_flags_and_fb_idx_for_temporal_mode_noLayering(cpi); |
| } else if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0101) { |
| set_flags_and_fb_idx_for_temporal_mode2(cpi); |
| } |
| vp9_update_temporal_layer_framerate(cpi); |
| vp9_restore_layer_context(cpi); |
| } |
| |
| void vp9_svc_check_reset_layer_rc_flag(VP9_COMP *const cpi) { |
| SVC *svc = &cpi->svc; |
| int sl, tl; |
| for (sl = 0; sl < svc->number_spatial_layers; ++sl) { |
| // Check for reset based on avg_frame_bandwidth for spatial layer sl. |
| int layer = LAYER_IDS_TO_IDX(sl, svc->number_temporal_layers - 1, |
| svc->number_temporal_layers); |
| LAYER_CONTEXT *lc = &svc->layer_context[layer]; |
| RATE_CONTROL *lrc = &lc->rc; |
| if (lrc->avg_frame_bandwidth > (3 * lrc->last_avg_frame_bandwidth >> 1) || |
| lrc->avg_frame_bandwidth < (lrc->last_avg_frame_bandwidth >> 1)) { |
| // Reset for all temporal layers with spatial layer sl. |
| for (tl = 0; tl < svc->number_temporal_layers; ++tl) { |
| int layer = LAYER_IDS_TO_IDX(sl, tl, svc->number_temporal_layers); |
| LAYER_CONTEXT *lc = &svc->layer_context[layer]; |
| RATE_CONTROL *lrc = &lc->rc; |
| lrc->rc_1_frame = 0; |
| lrc->rc_2_frame = 0; |
| lrc->bits_off_target = lrc->optimal_buffer_level; |
| lrc->buffer_level = lrc->optimal_buffer_level; |
| } |
| } |
| } |
| } |
| |
| void vp9_svc_constrain_inter_layer_pred(VP9_COMP *const cpi) { |
| VP9_COMMON *const cm = &cpi->common; |
| SVC *const svc = &cpi->svc; |
| const int sl = svc->spatial_layer_id; |
| // Check for disabling inter-layer (spatial) prediction, if |
| // svc.disable_inter_layer_pred is set. If the previous spatial layer was |
| // dropped then disable the prediction from this (scaled) reference. |
| // For INTER_LAYER_PRED_OFF_NONKEY: inter-layer prediction is disabled |
| // on key frames or if any spatial layer is a sync layer. |
| if ((svc->disable_inter_layer_pred == INTER_LAYER_PRED_OFF_NONKEY && |
| !svc->layer_context[svc->temporal_layer_id].is_key_frame && |
| !svc->superframe_has_layer_sync) || |
| svc->disable_inter_layer_pred == INTER_LAYER_PRED_OFF || |
| svc->drop_spatial_layer[sl - 1]) { |
| MV_REFERENCE_FRAME ref_frame; |
| static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, |
| VP9_ALT_FLAG }; |
| for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
| const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame); |
| if (yv12 != NULL && (cpi->ref_frame_flags & flag_list[ref_frame])) { |
| const struct scale_factors *const scale_fac = |
| &cm->frame_refs[ref_frame - 1].sf; |
| if (vp9_is_scaled(scale_fac)) { |
| cpi->ref_frame_flags &= (~flag_list[ref_frame]); |
| // Point golden/altref frame buffer index to last. |
| if (!svc->simulcast_mode) { |
| if (ref_frame == GOLDEN_FRAME) |
| cpi->gld_fb_idx = cpi->lst_fb_idx; |
| else if (ref_frame == ALTREF_FRAME) |
| cpi->alt_fb_idx = cpi->lst_fb_idx; |
| } |
| } |
| } |
| } |
| } |
| // For fixed/non-flexible SVC: check for disabling inter-layer prediction. |
| // If the reference for inter-layer prediction (the reference that is scaled) |
| // is not the previous spatial layer from the same superframe, then we disable |
| // inter-layer prediction. Only need to check when inter_layer prediction is |
| // not set to OFF mode. |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->disable_inter_layer_pred != INTER_LAYER_PRED_OFF) { |
| // We only use LAST and GOLDEN for prediction in real-time mode, so we |
| // check both here. |
| MV_REFERENCE_FRAME ref_frame; |
| for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ref_frame++) { |
| struct scale_factors *scale_fac = &cm->frame_refs[ref_frame - 1].sf; |
| if (vp9_is_scaled(scale_fac)) { |
| // If this reference was updated on the previous spatial layer of the |
| // current superframe, then we keep this reference (don't disable). |
| // Otherwise we disable the inter-layer prediction. |
| // This condition is verified by checking if the current frame buffer |
| // index is equal to any of the slots for the previous spatial layer, |
| // and if so, check if that slot was updated/refreshed. If that is the |
| // case, then this reference is valid for inter-layer prediction under |
| // the mode INTER_LAYER_PRED_ON_CONSTRAINED. |
| int fb_idx = |
| ref_frame == LAST_FRAME ? cpi->lst_fb_idx : cpi->gld_fb_idx; |
| int ref_flag = ref_frame == LAST_FRAME ? VP9_LAST_FLAG : VP9_GOLD_FLAG; |
| int disable = 1; |
| if (fb_idx < 0) continue; |
| if ((fb_idx == svc->lst_fb_idx[sl - 1] && |
| (svc->update_buffer_slot[sl - 1] & (1 << fb_idx))) || |
| (fb_idx == svc->gld_fb_idx[sl - 1] && |
| (svc->update_buffer_slot[sl - 1] & (1 << fb_idx))) || |
| (fb_idx == svc->alt_fb_idx[sl - 1] && |
| (svc->update_buffer_slot[sl - 1] & (1 << fb_idx)))) |
| disable = 0; |
| if (disable) cpi->ref_frame_flags &= (~ref_flag); |
| } |
| } |
| } |
| } |
| |
| void vp9_svc_assert_constraints_pattern(VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| // For fixed/non-flexible mode, the following constraint are expected, |
| // when inter-layer prediciton is on (default). |
| if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->disable_inter_layer_pred == INTER_LAYER_PRED_ON && |
| svc->framedrop_mode != LAYER_DROP) { |
| if (!svc->layer_context[svc->temporal_layer_id].is_key_frame) { |
| // On non-key frames: LAST is always temporal reference, GOLDEN is |
| // spatial reference. |
| if (svc->temporal_layer_id == 0) |
| // Base temporal only predicts from base temporal. |
| assert(svc->fb_idx_temporal_layer_id[cpi->lst_fb_idx] == 0); |
| else |
| // Non-base temporal only predicts from lower temporal layer. |
| assert(svc->fb_idx_temporal_layer_id[cpi->lst_fb_idx] < |
| svc->temporal_layer_id); |
| if (svc->spatial_layer_id > 0 && cpi->ref_frame_flags & VP9_GOLD_FLAG && |
| svc->spatial_layer_id > svc->first_spatial_layer_to_encode) { |
| // Non-base spatial only predicts from lower spatial layer with same |
| // temporal_id. |
| assert(svc->fb_idx_spatial_layer_id[cpi->gld_fb_idx] == |
| svc->spatial_layer_id - 1); |
| assert(svc->fb_idx_temporal_layer_id[cpi->gld_fb_idx] == |
| svc->temporal_layer_id); |
| } |
| } else if (svc->spatial_layer_id > 0 && |
| svc->spatial_layer_id > svc->first_spatial_layer_to_encode) { |
| // Only 1 reference for frame whose base is key; reference may be LAST |
| // or GOLDEN, so we check both. |
| if (cpi->ref_frame_flags & VP9_LAST_FLAG) { |
| assert(svc->fb_idx_spatial_layer_id[cpi->lst_fb_idx] == |
| svc->spatial_layer_id - 1); |
| assert(svc->fb_idx_temporal_layer_id[cpi->lst_fb_idx] == |
| svc->temporal_layer_id); |
| } else if (cpi->ref_frame_flags & VP9_GOLD_FLAG) { |
| assert(svc->fb_idx_spatial_layer_id[cpi->gld_fb_idx] == |
| svc->spatial_layer_id - 1); |
| assert(svc->fb_idx_temporal_layer_id[cpi->gld_fb_idx] == |
| svc->temporal_layer_id); |
| } |
| } |
| } else if (svc->use_gf_temporal_ref_current_layer && |
| !svc->layer_context[svc->temporal_layer_id].is_key_frame) { |
| // For the usage of golden as second long term reference: the |
| // temporal_layer_id of that reference must be base temporal layer 0, and |
| // spatial_layer_id of that reference must be same as current |
| // spatial_layer_id. If not, disable feature. |
| // TODO(marpan): Investigate when this can happen, and maybe put this check |
| // and reset in a different place. |
| if (svc->fb_idx_spatial_layer_id[cpi->gld_fb_idx] != |
| svc->spatial_layer_id || |
| svc->fb_idx_temporal_layer_id[cpi->gld_fb_idx] != 0) |
| svc->use_gf_temporal_ref_current_layer = 0; |
| } |
| } |
| |
| #if CONFIG_VP9_TEMPORAL_DENOISING |
| int vp9_denoise_svc_non_key(VP9_COMP *const cpi) { |
| int layer = |
| LAYER_IDS_TO_IDX(cpi->svc.spatial_layer_id, cpi->svc.temporal_layer_id, |
| cpi->svc.number_temporal_layers); |
| LAYER_CONTEXT *lc = &cpi->svc.layer_context[layer]; |
| return denoise_svc(cpi) && !lc->is_key_frame; |
| } |
| #endif |
| |
| void vp9_svc_check_spatial_layer_sync(VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| // Only for superframes whose base is not key, as those are |
| // already sync frames. |
| if (!svc->layer_context[svc->temporal_layer_id].is_key_frame) { |
| if (svc->spatial_layer_id == 0) { |
| // On base spatial layer: if the current superframe has a layer sync then |
| // reset the pattern counters and reset to base temporal layer. |
| if (svc->superframe_has_layer_sync) |
| vp9_svc_reset_temporal_layers(cpi, cpi->common.frame_type == KEY_FRAME); |
| } |
| // If the layer sync is set for this current spatial layer then |
| // disable the temporal reference. |
| if (svc->spatial_layer_id > 0 && |
| svc->spatial_layer_sync[svc->spatial_layer_id]) { |
| cpi->ref_frame_flags &= (~VP9_LAST_FLAG); |
| if (svc->use_gf_temporal_ref_current_layer) { |
| int index = svc->spatial_layer_id; |
| // If golden is used as second reference: need to remove it from |
| // prediction, reset refresh period to 0, and update the reference. |
| svc->use_gf_temporal_ref_current_layer = 0; |
| cpi->rc.baseline_gf_interval = 0; |
| cpi->rc.frames_till_gf_update_due = 0; |
| // On layer sync frame we must update the buffer index used for long |
| // term reference. Use the alt_ref since it is not used or updated on |
| // sync frames. |
| if (svc->number_spatial_layers == 3) index = svc->spatial_layer_id - 1; |
| assert(index >= 0); |
| cpi->alt_fb_idx = svc->buffer_gf_temporal_ref[index].idx; |
| cpi->ext_refresh_alt_ref_frame = 1; |
| } |
| } |
| } |
| } |
| |
| void vp9_svc_update_ref_frame_buffer_idx(VP9_COMP *const cpi) { |
| SVC *const svc = &cpi->svc; |
| // Update the usage of frame buffer index for base spatial layers. |
| if (svc->spatial_layer_id == 0) { |
| if ((cpi->ref_frame_flags & VP9_LAST_FLAG) || cpi->refresh_last_frame) |
| svc->fb_idx_base[cpi->lst_fb_idx] = 1; |
| if ((cpi->ref_frame_flags & VP9_GOLD_FLAG) || cpi->refresh_golden_frame) |
| svc->fb_idx_base[cpi->gld_fb_idx] = 1; |
| if ((cpi->ref_frame_flags & VP9_ALT_FLAG) || cpi->refresh_alt_ref_frame) |
| svc->fb_idx_base[cpi->alt_fb_idx] = 1; |
| } |
| } |
| |
| static void vp9_svc_update_ref_frame_bypass_mode(VP9_COMP *const cpi) { |
| // For non-flexible/bypass SVC mode: check for refreshing other buffer |
| // slots. |
| SVC *const svc = &cpi->svc; |
| VP9_COMMON *const cm = &cpi->common; |
| BufferPool *const pool = cm->buffer_pool; |
| int i; |
| for (i = 0; i < REF_FRAMES; i++) { |
| if (cm->frame_type == KEY_FRAME || |
| svc->update_buffer_slot[svc->spatial_layer_id] & (1 << i)) { |
| ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[i], cm->new_fb_idx); |
| svc->fb_idx_spatial_layer_id[i] = svc->spatial_layer_id; |
| svc->fb_idx_temporal_layer_id[i] = svc->temporal_layer_id; |
| } |
| } |
| } |
| |
| void vp9_svc_update_ref_frame(VP9_COMP *const cpi) { |
| VP9_COMMON *const cm = &cpi->common; |
| SVC *const svc = &cpi->svc; |
| BufferPool *const pool = cm->buffer_pool; |
| |
| if (svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS && |
| svc->use_set_ref_frame_config) { |
| vp9_svc_update_ref_frame_bypass_mode(cpi); |
| } else if (cm->frame_type == KEY_FRAME && !svc->simulcast_mode) { |
| // Keep track of frame index for each reference frame. |
| int i; |
| // On key frame update all reference frame slots. |
| for (i = 0; i < REF_FRAMES; i++) { |
| svc->fb_idx_spatial_layer_id[i] = svc->spatial_layer_id; |
| svc->fb_idx_temporal_layer_id[i] = svc->temporal_layer_id; |
| // LAST/GOLDEN/ALTREF is already updated above. |
| if (i != cpi->lst_fb_idx && i != cpi->gld_fb_idx && i != cpi->alt_fb_idx) |
| ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[i], cm->new_fb_idx); |
| } |
| } else { |
| if (cpi->refresh_last_frame) { |
| svc->fb_idx_spatial_layer_id[cpi->lst_fb_idx] = svc->spatial_layer_id; |
| svc->fb_idx_temporal_layer_id[cpi->lst_fb_idx] = svc->temporal_layer_id; |
| } |
| if (cpi->refresh_golden_frame) { |
| svc->fb_idx_spatial_layer_id[cpi->gld_fb_idx] = svc->spatial_layer_id; |
| svc->fb_idx_temporal_layer_id[cpi->gld_fb_idx] = svc->temporal_layer_id; |
| } |
| if (cpi->refresh_alt_ref_frame) { |
| svc->fb_idx_spatial_layer_id[cpi->alt_fb_idx] = svc->spatial_layer_id; |
| svc->fb_idx_temporal_layer_id[cpi->alt_fb_idx] = svc->temporal_layer_id; |
| } |
| } |
| // Copy flags from encoder to SVC struct. |
| vp9_copy_flags_ref_update_idx(cpi); |
| vp9_svc_update_ref_frame_buffer_idx(cpi); |
| } |
| |
| void vp9_svc_adjust_frame_rate(VP9_COMP *const cpi) { |
| int64_t this_duration = |
| cpi->svc.timebase_fac * cpi->svc.duration[cpi->svc.spatial_layer_id]; |
| vp9_new_framerate(cpi, 10000000.0 / this_duration); |
| } |
| |
| void vp9_svc_adjust_avg_frame_qindex(VP9_COMP *const cpi) { |
| VP9_COMMON *const cm = &cpi->common; |
| SVC *const svc = &cpi->svc; |
| RATE_CONTROL *const rc = &cpi->rc; |
| // On key frames in CBR mode: reset the avg_frame_index for base layer |
| // (to level closer to worst_quality) if the overshoot is significant. |
| // Reset it for all temporal layers on base spatial layer. |
| if (cm->frame_type == KEY_FRAME && cpi->oxcf.rc_mode == VPX_CBR && |
| !svc->simulcast_mode && |
| rc->projected_frame_size > 3 * rc->avg_frame_bandwidth) { |
| int tl; |
| rc->avg_frame_qindex[INTER_FRAME] = |
| VPXMAX(rc->avg_frame_qindex[INTER_FRAME], |
| (cm->base_qindex + rc->worst_quality) >> 1); |
| for (tl = 0; tl < svc->number_temporal_layers; ++tl) { |
| const int layer = LAYER_IDS_TO_IDX(0, tl, svc->number_temporal_layers); |
| LAYER_CONTEXT *lc = &svc->layer_context[layer]; |
| RATE_CONTROL *lrc = &lc->rc; |
| lrc->avg_frame_qindex[INTER_FRAME] = rc->avg_frame_qindex[INTER_FRAME]; |
| } |
| } |
| } |
