granicus.if.org Git - libvpx/blob - vp9/encoder/vp9_svc_layercontext.c

   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 }