Merge "Renaming txfm_size to tx_size."

diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index a48045eda335569bbf282400c8ff4bf59cb2d06c..98f8766ba76c07a2a8091fa053afb47bebf5ca9a 100644 (file)
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -144,11 +144,8 @@ static void decode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                           b_width_log2(plane_bsize), tx_size, mode,
                           dst, pd->dst.stride, dst, pd->dst.stride);
 
-  // Early exit if there are no coefficients
-  if (mi->mbmi.skip_coeff)
-    return;
-
-  decode_block(plane, block, plane_bsize, tx_size, arg);
+  if (!mi->mbmi.skip_coeff)
+    decode_block(plane, block, plane_bsize, tx_size, arg);
 }
 
 static int decode_tokens(VP9D_COMP *pbi, BLOCK_SIZE bsize, vp9_reader *r) {
@@ -170,16 +167,15 @@ static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE 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);
-  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
+  const int bh = num_8x8_blocks_high_lookup[bsize];
+  const int bw = num_8x8_blocks_wide_lookup[bsize];
+  const int offset = mi_row * cm->mode_info_stride + mi_col;
 
-  xd->mode_info_context = cm->mi + mi_idx;
+  xd->mode_info_context = cm->mi + offset;
   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 + offset : NULL;
 
   set_skip_context(cm, xd, mi_row, mi_col);
   set_partition_seg_context(cm, xd, mi_row, mi_col);
@@ -236,7 +232,7 @@ static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
     int eobtotal;
 
     set_ref(pbi, 0, mi_row, mi_col);
-    if (mbmi->ref_frame[1] > INTRA_FRAME)
+    if (has_second_ref(mbmi))
       set_ref(pbi, 1, mi_row, mi_col);
 
     vp9_setup_interp_filters(xd, mbmi->interp_filter, cm);
@@ -261,7 +257,7 @@ static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
                             vp9_reader* r, BLOCK_SIZE bsize) {
   VP9_COMMON *const pc = &pbi->common;
   MACROBLOCKD *const xd = &pbi->mb;
-  const int bs = (1 << mi_width_log2(bsize)) / 2;
+  const int hbs = num_8x8_blocks_wide_lookup[bsize] / 2;
   PARTITION_TYPE partition = PARTITION_NONE;
   BLOCK_SIZE subsize;
 
@@ -273,7 +269,7 @@ static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
       return;
   } else {
     int pl;
-    const int idx = check_bsize_coverage(bs, pc->mi_rows, pc->mi_cols,
+    const int idx = check_bsize_coverage(hbs, pc->mi_rows, pc->mi_cols,
                                          mi_row, mi_col);
     set_partition_seg_context(pc, xd, mi_row, mi_col);
     pl = partition_plane_context(xd, bsize);
@@ -291,7 +287,7 @@ static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
   }
 
   subsize = get_subsize(bsize, partition);
-  *(get_sb_index(xd, subsize)) = 0;
+  *get_sb_index(xd, subsize) = 0;
 
   switch (partition) {
     case PARTITION_NONE:
@@ -299,22 +295,22 @@ static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
       break;
     case PARTITION_HORZ:
       decode_modes_b(pbi, mi_row, mi_col, r, subsize);
-      *(get_sb_index(xd, subsize)) = 1;
-      if (mi_row + bs < pc->mi_rows)
-        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
+      *get_sb_index(xd, subsize) = 1;
+      if (mi_row + hbs < pc->mi_rows)
+        decode_modes_b(pbi, mi_row + hbs, mi_col, r, subsize);
       break;
     case PARTITION_VERT:
       decode_modes_b(pbi, mi_row, mi_col, r, subsize);
-      *(get_sb_index(xd, subsize)) = 1;
-      if (mi_col + bs < pc->mi_cols)
-        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
+      *get_sb_index(xd, subsize) = 1;
+      if (mi_col + hbs < pc->mi_cols)
+        decode_modes_b(pbi, mi_row, mi_col + hbs, r, subsize);
       break;
     case PARTITION_SPLIT: {
       int n;
       for (n = 0; n < 4; n++) {
         const int j = n >> 1, i = n & 1;
-        *(get_sb_index(xd, subsize)) = n;
-        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
+        *get_sb_index(xd, subsize) = n;
+        decode_modes_sb(pbi, mi_row + j * hbs, mi_col + i * hbs, r, subsize);
       }
     } break;
     default:
@@ -597,9 +593,8 @@ static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
     vp9_zero(pc->left_context);
     vp9_zero(pc->left_seg_context);
     for (mi_col = pc->cur_tile_mi_col_start; mi_col < pc->cur_tile_mi_col_end;
-         mi_col += MI_BLOCK_SIZE) {
+         mi_col += MI_BLOCK_SIZE)
       decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_64X64);
-    }
 
     if (pbi->do_loopfilter_inline) {
       // delay the loopfilter by 1 macroblock row.
@@ -969,9 +964,6 @@ int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) {
 
   init_dequantizer(pc, &pbi->mb);
 
-  if (!keyframe)
-    vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
-
   pc->fc = pc->frame_contexts[pc->frame_context_idx];
 
   vp9_zero(pc->counts);

diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index cbb08238419c6dd62f78a98c650cec7ca5f4a3f4..ea4a05fbd1b6722c40f631fe2204f8a28f7e1083 100644 (file)
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -584,11 +584,13 @@ static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
   if (m->mbmi.sb_type < BLOCK_8X8)
     if (xd->ab_index > 0)
       return;
+
   xd->mode_info_context = m;
-  set_mi_row_col(&cpi->common, xd, mi_row,
-                 1 << mi_height_log2(m->mbmi.sb_type),
-                 mi_col, 1 << mi_width_log2(m->mbmi.sb_type));
-  if ((cm->frame_type == KEY_FRAME) || cm->intra_only) {
+  set_mi_row_col(&cpi->common, xd,
+                 mi_row, num_8x8_blocks_high_lookup[m->mbmi.sb_type],
+                 mi_col, num_8x8_blocks_wide_lookup[m->mbmi.sb_type]);
+
+  if (cm->frame_type == KEY_FRAME || cm->intra_only) {
     write_mb_modes_kf(cpi, m, bc);
 #ifdef ENTROPY_STATS
     active_section = 8;

diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 0d140cdde9776ad9fcf723f6ca876aa0407b1332..eb83903caf480dfd7a32f7445f86ccafb8648f6f 100644 (file)
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -765,7 +765,7 @@ static void encode_b(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row, int mi_col,
     return;
 
   if (sub_index != -1)
-    *(get_sb_index(xd, bsize)) = sub_index;
+    *get_sb_index(xd, bsize) = sub_index;
 
   if (bsize < BLOCK_8X8) {
     // When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
@@ -835,7 +835,7 @@ static void encode_sb(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row, int mi_col,
       for (i = 0; i < 4; i++) {
         const int x_idx = i & 1, y_idx = i >> 1;
 
-        *(get_sb_index(xd, subsize)) = i;
+        *get_sb_index(xd, subsize) = i;
         encode_sb(cpi, tp, mi_row + y_idx * bs, mi_col + x_idx * bs,
                   output_enabled, subsize);
       }
@@ -873,23 +873,17 @@ static void copy_partitioning(VP9_COMP *cpi, MODE_INFO *m, MODE_INFO *p) {
   }
 }
 
-static void set_block_size(VP9_COMMON * const cm, MODE_INFO *m,
+static void set_block_size(VP9_COMMON * const cm, MODE_INFO *mi,
                            BLOCK_SIZE bsize, int mis, int mi_row,
                            int mi_col) {
-  int row, col;
-  int bwl = b_width_log2(bsize);
-  int bhl = b_height_log2(bsize);
-  int bsl = (bwl > bhl ? bwl : bhl);
-
-  int bs = (1 << bsl) / 2;  // Block size in units of 8 pels.
-  MODE_INFO *m2 = m + mi_row * mis + mi_col;
-  for (row = 0; row < bs; row++) {
-    for (col = 0; col < bs; col++) {
-      if (mi_row + row >= cm->mi_rows || mi_col + col >= cm->mi_cols)
-        continue;
-      m2[row * mis + col].mbmi.sb_type = bsize;
-    }
-  }
+  int r, c;
+  const int bs = MAX(num_8x8_blocks_wide_lookup[bsize],
+                     num_8x8_blocks_high_lookup[bsize]);
+  MODE_INFO *const mi2 = &mi[mi_row * mis + mi_col];
+  for (r = 0; r < bs; r++)
+    for (c = 0; c < bs; c++)
+      if (mi_row + r < cm->mi_rows && mi_col + c < cm->mi_cols)
+        mi2[r * mis + c].mbmi.sb_type = bsize;
 }
 
 typedef struct {
@@ -1280,7 +1274,7 @@ static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
                     bsize, get_block_context(x, bsize), INT64_MAX);
       break;
     case PARTITION_HORZ:
-      *(get_sb_index(xd, subsize)) = 0;
+      *get_sb_index(xd, subsize) = 0;
       pick_sb_modes(cpi, mi_row, mi_col, &last_part_rate, &last_part_dist,
                     subsize, get_block_context(x, subsize), INT64_MAX);
       if (last_part_rate != INT_MAX &&
@@ -1289,7 +1283,7 @@ static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
         int64_t dt = 0;
         update_state(cpi, get_block_context(x, subsize), subsize, 0);
         encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
-        *(get_sb_index(xd, subsize)) = 1;
+        *get_sb_index(xd, subsize) = 1;
         pick_sb_modes(cpi, mi_row + (ms >> 1), mi_col, &rt, &dt, subsize,
                       get_block_context(x, subsize), INT64_MAX);
         if (rt == INT_MAX || dt == INT_MAX) {
@@ -1303,7 +1297,7 @@ static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
       }
       break;
     case PARTITION_VERT:
-      *(get_sb_index(xd, subsize)) = 0;
+      *get_sb_index(xd, subsize) = 0;
       pick_sb_modes(cpi, mi_row, mi_col, &last_part_rate, &last_part_dist,
                     subsize, get_block_context(x, subsize), INT64_MAX);
       if (last_part_rate != INT_MAX &&
@@ -1312,7 +1306,7 @@ static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
         int64_t dt = 0;
         update_state(cpi, get_block_context(x, subsize), subsize, 0);
         encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
-        *(get_sb_index(xd, subsize)) = 1;
+        *get_sb_index(xd, subsize) = 1;
         pick_sb_modes(cpi, mi_row, mi_col + (ms >> 1), &rt, &dt, subsize,
                       get_block_context(x, subsize), INT64_MAX);
         if (rt == INT_MAX || dt == INT_MAX) {
@@ -1338,7 +1332,7 @@ static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
         if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
           continue;
 
-        *(get_sb_index(xd, subsize)) = i;
+        *get_sb_index(xd, subsize) = i;
 
         rd_use_partition(cpi, m + jj * bss * mis + ii * bss, tp, mi_row + y_idx,
                          mi_col + x_idx, subsize, &rt, &dt, i != 3);
@@ -1381,9 +1375,9 @@ static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
           || (mi_col + x_idx >= cm->mi_cols))
         continue;
 
-      *(get_sb_index(xd, split_subsize)) = i;
-      *(get_sb_partitioning(x, bsize)) = split_subsize;
-      *(get_sb_partitioning(x, split_subsize)) = split_subsize;
+      *get_sb_index(xd, split_subsize) = i;
+      *get_sb_partitioning(x, bsize) = split_subsize;
+      *get_sb_partitioning(x, split_subsize) = split_subsize;
 
       save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
 
@@ -1648,8 +1642,7 @@ static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
   VP9_COMMON * const cm = &cpi->common;
   MACROBLOCK * const x = &cpi->mb;
   MACROBLOCKD * const xd = &x->e_mbd;
-  int bsl = b_width_log2(bsize), bs = 1 << bsl;
-  int ms = bs / 2;
+  const int ms = num_8x8_blocks_wide_lookup[bsize] / 2;
   ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
   PARTITION_CONTEXT sl[8], sa[8];
   TOKENEXTRA *tp_orig = *tp;
@@ -1661,8 +1654,8 @@ static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
   int do_split = bsize >= BLOCK_8X8;
   int do_rect = 1;
   // Override skipping rectangular partition operations for edge blocks
-  const int force_horz_split = (mi_row + (ms >> 1) >= cm->mi_rows);
-  const int force_vert_split = (mi_col + (ms >> 1) >= cm->mi_cols);
+  const int force_horz_split = (mi_row + ms >= cm->mi_rows);
+  const int force_vert_split = (mi_col + ms >= cm->mi_cols);
 
   int partition_none_allowed = !force_horz_split && !force_vert_split;
   int partition_horz_allowed = !force_vert_split && bsize >= BLOCK_8X8;
@@ -1742,14 +1735,13 @@ static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
   if (do_split) {
     subsize = get_subsize(bsize, PARTITION_SPLIT);
     for (i = 0; i < 4 && sum_rd < best_rd; ++i) {
-      int x_idx = (i & 1) * (ms >> 1);
-      int y_idx = (i >> 1) * (ms >> 1);
+      const int x_idx = (i & 1) * ms;
+      const int y_idx = (i >> 1) * ms;
 
-      if ((mi_row + y_idx >= cm->mi_rows) ||
-          (mi_col + x_idx >= cm->mi_cols))
+      if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols)
         continue;
 
-      *(get_sb_index(xd, subsize)) = i;
+      *get_sb_index(xd, subsize) = i;
 
       rd_pick_partition(cpi, tp, mi_row + y_idx, mi_col + x_idx, subsize,
                         &this_rate, &this_dist, i != 3, best_rd - sum_rd);
@@ -1795,17 +1787,17 @@ static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
   // PARTITION_HORZ
   if (partition_horz_allowed && do_rect) {
     subsize = get_subsize(bsize, PARTITION_HORZ);
-    *(get_sb_index(xd, subsize)) = 0;
+    *get_sb_index(xd, subsize) = 0;
     pick_sb_modes(cpi, mi_row, mi_col, &sum_rate, &sum_dist, subsize,
                   get_block_context(x, subsize), best_rd);
     sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
 
-    if (sum_rd < best_rd && mi_row + (ms >> 1) < cm->mi_rows) {
+    if (sum_rd < best_rd && mi_row + ms < cm->mi_rows) {
       update_state(cpi, get_block_context(x, subsize), subsize, 0);
       encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
 
-      *(get_sb_index(xd, subsize)) = 1;
-      pick_sb_modes(cpi, mi_row + (ms >> 1), mi_col, &this_rate,
+      *get_sb_index(xd, subsize) = 1;
+      pick_sb_modes(cpi, mi_row + ms, mi_col, &this_rate,
                     &this_dist, subsize, get_block_context(x, subsize),
                     best_rd - sum_rd);
       if (this_rate == INT_MAX) {
@@ -1835,16 +1827,16 @@ static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
   if (partition_vert_allowed && do_rect) {
     subsize = get_subsize(bsize, PARTITION_VERT);
 
-    *(get_sb_index(xd, subsize)) = 0;
+    *get_sb_index(xd, subsize) = 0;
     pick_sb_modes(cpi, mi_row, mi_col, &sum_rate, &sum_dist, subsize,
                   get_block_context(x, subsize), best_rd);
     sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
-    if (sum_rd < best_rd && mi_col + (ms >> 1) < cm->mi_cols) {
+    if (sum_rd < best_rd && mi_col + ms < cm->mi_cols) {
       update_state(cpi, get_block_context(x, subsize), subsize, 0);
       encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
 
-      *(get_sb_index(xd, subsize)) = 1;
-      pick_sb_modes(cpi, mi_row, mi_col + (ms >> 1), &this_rate,
+      *get_sb_index(xd, subsize) = 1;
+      pick_sb_modes(cpi, mi_row, mi_col + ms, &this_rate,
                     &this_dist, subsize, get_block_context(x, subsize),
                     best_rd - sum_rd);
       if (this_rate == INT_MAX) {

diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index ec85f1b5a37e00b9197428b552b2bb10a94fc5d4..5e055dc33419c567b61240edcc8d700ee10993c4 100644 (file)
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -3092,14 +3092,11 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
   int_mv seg_mvs[4][MAX_REF_FRAMES];
   union b_mode_info best_bmodes[4];
   PARTITION_INFO best_partition;
-  int bwsl = b_width_log2(bsize);
-  int bws = (1 << bwsl) / 4;  // mode_info step for subsize
-  int bhsl = b_height_log2(bsize);
-  int bhs = (1 << bhsl) / 4;  // mode_info step for subsize
+  const int bws = num_8x8_blocks_wide_lookup[bsize] / 2;
+  const int bhs = num_8x8_blocks_high_lookup[bsize] / 2;
   int best_skip2 = 0;
 
-  x->skip_encode = (cpi->sf.skip_encode_frame &&
-                    xd->q_index < QIDX_SKIP_THRESH);
+  x->skip_encode = cpi->sf.skip_encode_frame && xd->q_index < QIDX_SKIP_THRESH;
 
   for (i = 0; i < 4; i++) {
     int j;