/*

 *  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;

  svc->resize_set = 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;

      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->error, 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->error, 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->error, 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;

        if (target_bandwidth != 0) {

          bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth;

        }

        lrc->starting_buffer_level =

            (int64_t)(rc->starting_buffer_level * bitrate_alloc + 0.5);

        lrc->optimal_buffer_level =

            (int64_t)(rc->optimal_buffer_level * bitrate_alloc + 0.5);

        lrc->maximum_buffer_size =

            (int64_t)(rc->maximum_buffer_size * bitrate_alloc + 0.5);

        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 = saturate_cast_double_to_int(

            round(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];

      if (target_bandwidth != 0) {

        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 = saturate_cast_double_to_int(

          round(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_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 =

      saturate_cast_double_to_int(round(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)round((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 =

      saturate_cast_double_to_int(round(lc->target_bandwidth / lc->framerate));

  const int64_t vbr_min_bits =

      (int64_t)lrc->avg_frame_bandwidth * oxcf->two_pass_vbrmin_section / 100;

  lrc->min_frame_bandwidth = (int)VPXMIN(vbr_min_bits, INT_MAX);

  const int64_t vbr_max_bits =

      (int64_t)lrc->avg_frame_bandwidth * oxcf->two_pass_vbrmax_section / 100;

  lrc->max_frame_bandwidth = (int)VPXMIN(vbr_max_bits, INT_MAX);

  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_svc(cpi) && lc->speed > 0) {

    cpi->oxcf.speed = lc->speed;

  }

  cpi->loopfilter_ctrl = lc->loopfilter_ctrl;

  // 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;

  lc->frame_qp = cpi->common.base_qindex;

  lc->MBs = cpi->common.MBs;

  // 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;

    lc->qindex_delta[0] = cr->qindex_delta[0];

    lc->qindex_delta[1] = cr->qindex_delta[1];

    lc->qindex_delta[2] = cr->qindex_delta[2];

  }

}

#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) return;

  if (den == 0 || num == 0) {

    *width_out = width_org;

    *height_out = height_org;

    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).

  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 & ref_frame_to_flag(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 & VP9_LAST_FLAG) &&

        !cpi->ext_refresh_last_frame)

      cpi->lst_fb_idx = first_fb_idx;

    else if (first_ref != GOLDEN_FRAME &&

             !(cpi->ref_frame_flags & VP9_GOLD_FLAG) &&

             !cpi->ext_refresh_golden_frame)

      cpi->gld_fb_idx = first_fb_idx;

    else if (first_ref != ALTREF_FRAME &&

             !(cpi->ref_frame_flags & VP9_ALT_FLAG) &&

             !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;

  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 & VP9_LAST_FLAG);

  svc->reference_golden[sl] = (uint8_t)(cpi->ref_frame_flags & VP9_GOLD_FLAG);

  svc->reference_altref[sl] = (uint8_t)(cpi->ref_frame_flags & VP9_ALT_FLAG);

}

int vp9_one_pass_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->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;

  // 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 sl_lc = &svc->layer_context[layer];

        cpi->rc = sl_lc->rc;

        cpi->oxcf.target_bandwidth = sl_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