libvpx: Pull from upstream

source/libvpx/vp9/decoder/vp9_decodframe.c

 /*
  *  Copyright (c) 2010 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.
  */
 
@@ skipping 258 matching lines @@
 
   decode_block(plane, block, bsize, ss_txfrm_size, arg);
 }
 
 static void decode_atom(VP9D_COMP *pbi, MACROBLOCKD *xd,
                         int mi_row, int mi_col,
                         vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
   MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
 
   assert(mbmi->ref_frame[0] != INTRA_FRAME);
-
-  if ((pbi->common.frame_type != KEY_FRAME) && (!pbi->common.intra_only))
-    vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);
+  vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);
 
   // prediction
   vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
 
   if (mbmi->mb_skip_coeff) {
     vp9_reset_sb_tokens_context(xd, bsize);
   } else {
     if (xd->segmentation_enabled)
       mb_init_dequantizer(&pbi->common, xd);
 
@@ skipping 28 matching lines @@
   const int bw = 1 << bwl, bh = 1 << bhl;
   int n, eobtotal;
   VP9_COMMON *const pc = &pbi->common;
   MODE_INFO *const mi = xd->mode_info_context;
   MB_MODE_INFO *const mbmi = &mi->mbmi;
   const int mis = pc->mode_info_stride;
 
   assert(mbmi->sb_type == bsize);
   assert(mbmi->ref_frame[0] != INTRA_FRAME);
 
-  if (pbi->common.frame_type != KEY_FRAME)
-    vp9_setup_interp_filters(xd, mbmi->interp_filter, pc);
+  vp9_setup_interp_filters(xd, mbmi->interp_filter, pc);
 
   // generate prediction
   vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
 
   if (mbmi->mb_skip_coeff) {
     vp9_reset_sb_tokens_context(xd, bsize);
   } else {
     // re-initialize macroblock dequantizer before detokenization
     if (xd->segmentation_enabled)
       mb_init_dequantizer(pc, xd);
@@ skipping 43 matching lines @@
   set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
 
   setup_dst_planes(xd, &cm->yv12_fb[cm->new_fb_idx], mi_row, mi_col);
 }
 
 static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
   VP9_COMMON *const cm = &pbi->common;
   MACROBLOCKD *const xd = &pbi->mb;
   MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
 
-  if (mbmi->ref_frame[0] > INTRA_FRAME) {
+  // Select the appropriate reference frame for this MB
+  const int fb_idx = cm->active_ref_idx[mbmi->ref_frame[0] - 1];
+  const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[fb_idx];
+  xd->scale_factor[0] = cm->active_ref_scale[mbmi->ref_frame[0] - 1];
+  xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame[0] - 1];
+  setup_pre_planes(xd, cfg, NULL, mi_row, mi_col, xd->scale_factor,
+                   xd->scale_factor_uv);
+  xd->corrupted |= cfg->corrupted;
+
+  if (mbmi->ref_frame[1] > INTRA_FRAME) {
     // Select the appropriate reference frame for this MB
-    const int fb_idx = cm->active_ref_idx[mbmi->ref_frame[0] - 1];
-    const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[fb_idx];
-    xd->scale_factor[0]    = cm->active_ref_scale[mbmi->ref_frame[0] - 1];
-    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame[0] - 1];
-    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
-                     xd->scale_factor, xd->scale_factor_uv);
-    xd->corrupted |= cfg->corrupted;
-
-    if (mbmi->ref_frame[1] > INTRA_FRAME) {
-      // Select the appropriate reference frame for this MB
-      const int second_fb_idx = cm->active_ref_idx[mbmi->ref_frame[1] - 1];
-      const YV12_BUFFER_CONFIG *second_cfg = &cm->yv12_fb[second_fb_idx];
-      xd->scale_factor[1]    = cm->active_ref_scale[mbmi->ref_frame[1] - 1];
-      xd->scale_factor_uv[1] = cm->active_ref_scale[mbmi->ref_frame[1] - 1];
-      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
-                       xd->scale_factor, xd->scale_factor_uv);
-      xd->corrupted |= second_cfg->corrupted;
-    }
+    const int second_fb_idx = cm->active_ref_idx[mbmi->ref_frame[1] - 1];
+    const YV12_BUFFER_CONFIG *second_cfg = &cm->yv12_fb[second_fb_idx];
+    xd->scale_factor[1] = cm->active_ref_scale[mbmi->ref_frame[1] - 1];
+    xd->scale_factor_uv[1] = cm->active_ref_scale[mbmi->ref_frame[1] - 1];
+    setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col, xd->scale_factor,
+                     xd->scale_factor_uv);
+    xd->corrupted |= second_cfg->corrupted;
   }
 }
 
 static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
                            vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
   MACROBLOCKD *const xd = &pbi->mb;
 
   if (bsize < BLOCK_SIZE_SB8X8)
     if (xd->ab_index > 0)
       return;
   set_offsets(pbi, bsize, mi_row, mi_col);
   vp9_decode_mb_mode_mv(pbi, xd, mi_row, mi_col, r);
-  set_refs(pbi, mi_row, mi_col);
 
-  if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME)
+  if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) {
     decode_sb_intra(pbi, xd, mi_row, mi_col, r, (bsize < BLOCK_SIZE_SB8X8) ?
                                      BLOCK_SIZE_SB8X8 : bsize);
-  else if (bsize < BLOCK_SIZE_SB8X8)
-    decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
-  else
-    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
-
+  } else {
+    set_refs(pbi, mi_row, mi_col);
+    if (bsize < BLOCK_SIZE_SB8X8)
+      decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
+    else
+      decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
+  }
   xd->corrupted |= vp9_reader_has_error(r);
 }
 
 static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
                             vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
   VP9_COMMON *const pc = &pbi->common;
   MACROBLOCKD *const xd = &pbi->mb;
   int bs = (1 << mi_width_log2(bsize)) / 2, n;
   PARTITION_TYPE partition = PARTITION_NONE;
   BLOCK_SIZE_TYPE subsize;
@@ skipping 733 matching lines @@
                          "A stream must start with a complete key frame");
   }
 
   // Adaptation
   if (!pc->error_resilient_mode && !pc->frame_parallel_decoding_mode) {
     vp9_adapt_coef_probs(pc);
 
     if ((!keyframe) && (!pc->intra_only)) {
       vp9_adapt_mode_probs(pc);
       vp9_adapt_mode_context(pc);
-      vp9_adapt_nmv_probs(pc, xd->allow_high_precision_mv);
+      vp9_adapt_mv_probs(pc, xd->allow_high_precision_mv);
     }
   }
 
   if (pc->refresh_frame_context)
     pc->frame_contexts[pc->frame_context_idx] = pc->fc;
 
   *p_data_end = vp9_reader_find_end(&residual_bc);
   return 0;
 }