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.
  */
 
 #include <assert.h>
 
 #include "./vp9_rtcd.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vpx_scale/vpx_scale.h"
 
 #include "vp9/common/vp9_extend.h"
 #include "vp9/common/vp9_modecont.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_reconintra.h"
 #include "vp9/common/vp9_reconinter.h"
 #include "vp9/common/vp9_entropy.h"
-#include "vp9/common/vp9_invtrans.h"
 #include "vp9/common/vp9_alloccommon.h"
 #include "vp9/common/vp9_entropymode.h"
 #include "vp9/common/vp9_quant_common.h"
 #include "vp9/common/vp9_seg_common.h"
 #include "vp9/common/vp9_tile_common.h"
 
 #include "vp9/decoder/vp9_dboolhuff.h"
 #include "vp9/decoder/vp9_decodframe.h"
 #include "vp9/decoder/vp9_detokenize.h"
 #include "vp9/decoder/vp9_decodemv.h"
@@ skipping 158 matching lines @@
   xd->q_index = vp9_get_qindex(xd, segment_id, pc->base_qindex);
 
   xd->plane[0].dequant = pc->y_dequant[xd->q_index];
   for (i = 1; i < MAX_MB_PLANE; i++)
     xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
 }
 
 static void decode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
                          int ss_txfrm_size, void *arg) {
   MACROBLOCKD* const xd = arg;
-  int16_t* const qcoeff = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
-  const int stride = xd->plane[plane].dst.stride;
+  struct macroblockd_plane *pd = &xd->plane[plane];
+  int16_t* const qcoeff = BLOCK_OFFSET(pd->qcoeff, block, 16);
+  const int stride = pd->dst.stride;
   const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                        block, ss_txfrm_size);
   uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
                                                  raster_block,
-                                                 xd->plane[plane].dst.buf,
-                                                 stride);
+                                                 pd->dst.buf, stride);
 
   TX_TYPE tx_type;
 
   switch (ss_txfrm_size / 2) {
     case TX_4X4:
       tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
       if (tx_type == DCT_DCT)
-        xd->itxm_add(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
+        xd->itxm_add(qcoeff, dst, stride, pd->eobs[block]);
       else
-        vp9_iht_add_c(tx_type, qcoeff, dst, stride,
-                      xd->plane[plane].eobs[block]);
+        vp9_iht_add_c(tx_type, qcoeff, dst, stride, pd->eobs[block]);
       break;
     case TX_8X8:
       tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
-      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride,
-                        xd->plane[plane].eobs[block]);
+      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride, pd->eobs[block]);
       break;
     case TX_16X16:
       tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
-      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride,
-                          xd->plane[plane].eobs[block]);
+      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride, pd->eobs[block]);
       break;
     case TX_32X32:
-      vp9_idct_add_32x32(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
+      vp9_idct_add_32x32(qcoeff, dst, stride, pd->eobs[block]);
       break;
   }
 }
 
 static void decode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
                                int ss_txfrm_size, void *arg) {
   MACROBLOCKD* const xd = arg;
-  int16_t* const qcoeff = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
-  const int stride = xd->plane[plane].dst.stride;
+  struct macroblockd_plane *pd = &xd->plane[plane];
+
   const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                        block, ss_txfrm_size);
   uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
                                                  raster_block,
-                                                 xd->plane[plane].dst.buf,
-                                                 stride);
+                                                 pd->dst.buf, pd->dst.stride);
   const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
-  TX_TYPE tx_type;
-  int mode, b_mode;
+  int b_mode;
   int plane_b_size;
-  int tx_ib = raster_block >> tx_size;
-  mode = plane == 0? xd->mode_info_context->mbmi.mode:
-                     xd->mode_info_context->mbmi.uv_mode;
+  const int tx_ib = raster_block >> tx_size;
+  const int mode = plane == 0 ? xd->mode_info_context->mbmi.mode
+                              : xd->mode_info_context->mbmi.uv_mode;
 
 
-  if (xd->mode_info_context->mbmi.sb_type < BLOCK_SIZE_SB8X8 && plane == 0) {
+  if (plane == 0 && xd->mode_info_context->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
     assert(bsize == BLOCK_SIZE_SB8X8);
     b_mode = xd->mode_info_context->bmi[raster_block].as_mode.first;
   } else {
     b_mode = mode;
   }
 
-  if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0) {
+  if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0)
     extend_for_intra(xd, plane, block, bsize, ss_txfrm_size);
-  }
 
-  plane_b_size = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
-  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size,
-                          b_mode, dst, xd->plane[plane].dst.stride);
+  plane_b_size = b_width_log2(bsize) - pd->subsampling_x;
+  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size, b_mode,
+                          dst, pd->dst.stride);
 
   // Early exit if there are no coefficients
   if (xd->mode_info_context->mbmi.mb_skip_coeff)
     return;
 
-  switch (ss_txfrm_size / 2) {
-    case TX_4X4:
-      tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
-      if (tx_type == DCT_DCT)
-        xd->itxm_add(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
-      else
-        vp9_iht_add_c(tx_type, qcoeff, dst, stride,
-                      xd->plane[plane].eobs[block]);
-      break;
-    case TX_8X8:
-      tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
-      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride,
-                        xd->plane[plane].eobs[block]);
-      break;
-    case TX_16X16:
-      tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
-      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride,
-                          xd->plane[plane].eobs[block]);
-      break;
-    case TX_32X32:
-      vp9_idct_add_32x32(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
-      break;
-  }
+  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);
 
   // 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(&pbi->common, xd);
 
-    if (!vp9_reader_has_error(r)) {
-      vp9_decode_tokens(pbi, xd, r, bsize);
-    }
+    if (!vp9_reader_has_error(r))
+      vp9_decode_tokens(pbi, r, bsize);
 
     foreach_transformed_block(xd, bsize, decode_block, xd);
   }
 }
 
 static void decode_sb_intra(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;
   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(&pbi->common, xd);
 
-    if (!vp9_reader_has_error(r)) {
-      vp9_decode_tokens(pbi, xd, r, bsize);
-    }
+    if (!vp9_reader_has_error(r))
+      vp9_decode_tokens(pbi, r, bsize);
   }
 
   foreach_transformed_block(xd, bsize, decode_block_intra, xd);
 }
 
 
 static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
                       vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
   const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
   const int bw = 1 << bwl, bh = 1 << bhl;
@@ skipping 13 matching lines @@
   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);
 
     // dequantization and idct
-    eobtotal = vp9_decode_tokens(pbi, xd, r, bsize);
+    eobtotal = vp9_decode_tokens(pbi, r, bsize);
     if (eobtotal == 0) {  // skip loopfilter
       for (n = 0; n < bw * bh; n++) {
         const int x_idx = n & (bw - 1), y_idx = n >> bwl;
 
         if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
           mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
       }
     } else {
       foreach_transformed_block(xd, bsize, decode_block, xd);
     }
   }
 }
 
 static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
                         int mi_row, int mi_col) {
+  VP9_COMMON *const cm = &pbi->common;
+  MACROBLOCKD *const xd = &pbi->mb;
   const int bh = 1 << mi_height_log2(bsize);
   const int bw = 1 << mi_width_log2(bsize);
-  VP9_COMMON *const cm = &pbi->common;
-  MACROBLOCKD *const xd = &pbi->mb;
   const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
   int i;
 
   xd->mode_info_context = cm->mi + mi_idx;
   xd->mode_info_context->mbmi.sb_type = bsize;
   // Special case: if prev_mi is NULL, the previous mode info context
   // cannot be used.
-  xd->prev_mode_info_context = cm->prev_mi ?
-                                 cm->prev_mi + mi_idx : NULL;
+  xd->prev_mode_info_context = cm->prev_mi ? cm->prev_mi + mi_idx : NULL;
 
   for (i = 0; i < MAX_MB_PLANE; i++) {
-    xd->plane[i].above_context = cm->above_context[i] +
-        (mi_col * 2 >> xd->plane[i].subsampling_x);
-    xd->plane[i].left_context = cm->left_context[i] +
-        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
+    struct macroblockd_plane *pd = &xd->plane[i];
+    pd->above_context = cm->above_context[i] +
+                            (mi_col * 2 >> pd->subsampling_x);
+    pd->left_context = cm->left_context[i] +
+                           (((mi_row * 2) & 15) >> pd->subsampling_y);
   }
   xd->above_seg_context = cm->above_seg_context + mi_col;
   xd->left_seg_context  = cm->left_seg_context + (mi_row & MI_MASK);
 
   // Distance of Mb to the various image edges. These are specified to 8th pel
   // as they are always compared to values that are in 1/8th pel units
   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);
 }
@@ skipping 45 matching lines @@
   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 bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
-  int n;
+  int bs = (1 << mi_width_log2(bsize)) / 2, n;
   PARTITION_TYPE partition = PARTITION_NONE;
   BLOCK_SIZE_TYPE subsize;
 
   if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
     return;
 
   if (bsize < BLOCK_SIZE_SB8X8)
     if (xd->ab_index != 0)
       return;
 
@@ skipping 67 matching lines @@
     vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                        "Truncated packet or corrupt tile length");
 
   if (vp9_reader_init(r, data, read_size))
     vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                        "Failed to allocate bool decoder %d", 1);
 }
 
 static void read_coef_probs_common(FRAME_CONTEXT *fc, TX_SIZE tx_size,
                                    vp9_reader *r) {
-  const int entropy_nodes_update = UNCONSTRAINED_NODES;
   vp9_coeff_probs_model *coef_probs = fc->coef_probs[tx_size];
 
-  int i, j, k, l, m;
-
   if (vp9_read_bit(r)) {
+    int i, j, k, l, m;
     for (i = 0; i < BLOCK_TYPES; i++) {
       for (j = 0; j < REF_TYPES; j++) {
         for (k = 0; k < COEF_BANDS; k++) {
           for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
-            const int mstart = 0;
             if (l >= 3 && k == 0)
               continue;
 
-            for (m = mstart; m < entropy_nodes_update; m++) {
+            for (m = 0; m < UNCONSTRAINED_NODES; m++) {
               vp9_prob *const p = coef_probs[i][j][k][l] + m;
 
-              if (vp9_read(r, VP9_COEF_UPDATE_PROB)) {
+              if (vp9_read(r, VP9_COEF_UPDATE_PROB))
                 *p = vp9_read_prob_diff_update(r, *p);
-              }
             }
           }
         }
       }
     }
   }
 }
 
 static void read_coef_probs(VP9D_COMP *pbi, vp9_reader *r) {
   const TXFM_MODE txfm_mode = pbi->common.txfm_mode;
@@ skipping 515 matching lines @@
   if (!cm->error_resilient_mode) {
     cm->refresh_frame_context = vp9_rb_read_bit(rb);
     cm->frame_parallel_decoding_mode = vp9_rb_read_bit(rb);
   } else {
     cm->refresh_frame_context = 0;
     cm->frame_parallel_decoding_mode = 1;
   }
 
   cm->frame_context_idx = vp9_rb_read_literal(rb, NUM_FRAME_CONTEXTS_LG2);
 
-  if ((cm->frame_type == KEY_FRAME) ||
-      cm->error_resilient_mode || cm->intra_only)
+  if (cm->frame_type == KEY_FRAME || cm->error_resilient_mode || cm->intra_only)
     vp9_setup_past_independence(cm, xd);
 
   setup_loopfilter(pbi, rb);
   setup_quantization(pbi, rb);
   setup_segmentation(pbi, rb);
 
   setup_tile_info(cm, rb);
 
   return vp9_rb_read_literal(rb, 16);
 }
@@ skipping 96 matching lines @@
       vp9_adapt_nmv_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;
 }