Syntax coding

Change-Id: I6cac24c4f1e44f29ffcc9b87ba1167eeb32d1b69

vp9/decoder/vp9_decodeframe.c

@@ -1509,7 +1509,7 @@ static int read_compressed_header(VP9Decoder *pbi, const uint8_t *data,
   if (vp9_reader_init(&r, data, partition_size, pbi->decrypt_cb,
                       pbi->decrypt_state))
     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
-                       "Failed to allocate bool decoder 0");
+                       "Failed to allocate boon decoder 0");
 
   cm->tx_mode = xd->lossless ? ONLY_4X4 : read_tx_mode(&r);
   if (cm->tx_mode == TX_MODE_SELECT)

vp9/decoder/vp9_decodemv.c

@@ -60,6 +60,35 @@ static int read_segment_id(vp9_reader *r, const struct segmentation *seg) {
   return vp9_read_tree(r, vp9_segment_tree, seg->tree_probs);
 }
 
+static void read_tx_size_inter(VP9_COMMON *cm, MACROBLOCKD *xd,
+                               TX_SIZE tx_size, int mi_row, int mi_col,
+                               vp9_reader *r) {
+  MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
+  int is_split = vp9_read_bit(r);
+
+  if (!is_split) {
+    mbmi->tx_size = tx_size;
+  } else {
+    BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
+    int bh = num_8x8_blocks_high_lookup[bsize];
+    int i;
+
+    if (tx_size == TX_8X8) {
+      mbmi->tx_size = TX_4X4;
+      return;
+    }
+
+    for (i = 0; i < 4; ++i) {
+      int offsetr = (i >> 1) * bh / 2;
+      int offsetc = (i & 0x01) * bh / 2;
+      if ((mi_row + offsetr < cm->mi_rows) &&
+          (mi_col + offsetc < cm->mi_cols))
+        read_tx_size_inter(cm, xd, tx_size - 1,
+                           mi_row + offsetr, mi_col + offsetc, r);
+    }
+  }
+}
+
 static TX_SIZE read_selected_tx_size(VP9_COMMON *cm, MACROBLOCKD *xd,
                                      FRAME_COUNTS *counts,
                                      TX_SIZE max_tx_size, vp9_reader *r) {
@@ -569,13 +598,29 @@ static void read_inter_frame_mode_info(VP9Decoder *const pbi,
   MODE_INFO *const mi = xd->mi[0].src_mi;
   MB_MODE_INFO *const mbmi = &mi->mbmi;
   int inter_block;
+  BLOCK_SIZE bsize = mbmi->sb_type;
 
   mbmi->mv[0].as_int = 0;
   mbmi->mv[1].as_int = 0;
   mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, r);
   mbmi->skip = read_skip(cm, xd, counts, mbmi->segment_id, r);
   inter_block = read_is_inter_block(cm, xd, counts, mbmi->segment_id, r);
-  mbmi->tx_size = read_tx_size(cm, xd, counts, !mbmi->skip || !inter_block, r);
+
+  if (mbmi->sb_type >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT &&
+      !mbmi->skip && inter_block) {
+    int txb_size = txsize_to_bsize[max_txsize_lookup[bsize]];
+    int bh = num_8x8_blocks_wide_lookup[txb_size];
+    int width  = num_8x8_blocks_wide_lookup[bsize];
+    int height = num_8x8_blocks_high_lookup[bsize];
+    int idx, idy;
+    for (idy = 0; idy < height; idy += bh)
+      for (idx = 0; idx < width; idx += bh)
+        read_tx_size_inter(cm, xd, max_txsize_lookup[mbmi->sb_type],
+                           mi_row + idy, mi_col + idx, r);
+  } else {
+    mbmi->tx_size = read_tx_size(cm, xd, counts,
+                                 !mbmi->skip || !inter_block, r);
+  }
 
   if (inter_block)
     read_inter_block_mode_info(pbi, xd, counts, tile, mi, mi_row, mi_col, r);

vp9/encoder/vp9_bitstream.c

@@ -76,6 +76,35 @@ static void prob_diff_update(const vp9_tree_index *tree,
     vp9_cond_prob_diff_update(w, &probs[i], branch_ct[i]);
 }
 
+static void write_tx_size_inter(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+                                TX_SIZE tx_size, int mi_row, int mi_col,
+                                vp9_writer *w) {
+  MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
+
+  // TODO(jingning): this assumes support of the possible 64x64 transform.
+  if (tx_size == mbmi->tx_size) {
+    vp9_write_bit(w, 0);
+  } else {  // further split
+    BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
+    int bh = num_8x8_blocks_high_lookup[bsize];
+    int i;
+
+    vp9_write_bit(w, 1);
+
+    if (tx_size == TX_8X8)
+      return;
+
+    for (i = 0; i < 4; ++i) {
+      int offsetr = (i >> 1) * bh / 2;
+      int offsetc = (i & 0x01) * bh / 2;
+      if ((mi_row + offsetr < cm->mi_rows) &&
+          (mi_col + offsetc < cm->mi_cols))
+        write_tx_size_inter(cm, xd, tx_size - 1,
+                            mi_row + offsetr, mi_col + offsetc, w);
+    }
+  }
+}
+
 static void write_selected_tx_size(const VP9_COMMON *cm,
                                    const MACROBLOCKD *xd, vp9_writer *w) {
   TX_SIZE tx_size = xd->mi[0].src_mi->mbmi.tx_size;
@@ -235,6 +264,7 @@ static void write_ref_frames(const VP9_COMMON *cm, const MACROBLOCKD *xd,
 }
 
 static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
+                                int mi_row, int mi_col,
                                 vp9_writer *w) {
   VP9_COMMON *const cm = &cpi->common;
   const nmv_context *nmvc = &cm->fc->nmvc;
@@ -269,7 +299,19 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
 
   if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT &&
       !(is_inter && skip)) {
-    write_selected_tx_size(cm, xd, w);
+    if (!is_inter) {
+      write_selected_tx_size(cm, xd, w);
+    } else {
+      int txb_size = txsize_to_bsize[max_txsize_lookup[bsize]];
+      int bh = num_8x8_blocks_wide_lookup[txb_size];
+      int width  = num_8x8_blocks_wide_lookup[bsize];
+      int height = num_8x8_blocks_high_lookup[bsize];
+      int idx, idy;
+      for (idy = 0; idy < height; idy += bh)
+        for (idx = 0; idx < width; idx += bh)
+          write_tx_size_inter(cm, xd, max_txsize_lookup[bsize],
+                              mi_row + idy, mi_col + idx, w);
+    }
   }
 
   if (!is_inter) {
@@ -391,7 +433,7 @@ static void write_modes_b(VP9_COMP *cpi, const TileInfo *const tile,
   if (frame_is_intra_only(cm)) {
     write_mb_modes_kf(cm, xd, xd->mi, w);
   } else {
-    pack_inter_mode_mvs(cpi, m, w);
+    pack_inter_mode_mvs(cpi, m, mi_row, mi_col, w);
   }
 
   assert(*tok < tok_end);
@@ -812,6 +854,10 @@ static void encode_txfm_probs(VP9_COMMON *cm, vp9_writer *w,
   if (cm->tx_mode >= ALLOW_32X32)
     vp9_write_bit(w, cm->tx_mode == TX_MODE_SELECT);
 
+  if (cm->tx_mode != TX_MODE_SELECT) {
+    int a = 10;
+  }
+
   // Probabilities
   if (cm->tx_mode == TX_MODE_SELECT) {
     int i, j;

vp9/encoder/vp9_encodeframe.c

@@ -2821,6 +2821,9 @@ static MV_REFERENCE_FRAME get_frame_type(const VP9_COMP *cpi) {
 static TX_MODE select_tx_mode(const VP9_COMP *cpi, MACROBLOCKD *const xd) {
   if (xd->lossless)
     return ONLY_4X4;
+
+  return TX_MODE_SELECT;
+
   if (cpi->common.frame_type == KEY_FRAME &&
       cpi->sf.use_nonrd_pick_mode &&
       cpi->sf.partition_search_type == VAR_BASED_PARTITION)
@@ -4087,8 +4090,9 @@ static void encode_superblock(VP9_COMP *cpi, ThreadData *td,
     if (cm->tx_mode == TX_MODE_SELECT &&
         mbmi->sb_type >= BLOCK_8X8  &&
         !(is_inter_block(mbmi) && (mbmi->skip || seg_skip))) {
-      ++get_tx_counts(max_txsize_lookup[bsize], vp9_get_tx_size_context(xd),
-                      &td->counts->tx)[mbmi->tx_size];
+      if (!is_inter_block(mbmi))
+        ++get_tx_counts(max_txsize_lookup[bsize], vp9_get_tx_size_context(xd),
+                        &td->counts->tx)[mbmi->tx_size];
     } else {
       int x, y;
       TX_SIZE tx_size;

vp9/encoder/vp9_encoder.h

@@ -416,6 +416,7 @@ typedef struct VP9_COMP {
   double total_ssimg_all;
 
   int b_calculate_ssimg;
+  int dummy_writing;
 #endif
   int b_calculate_psnr;
 

vpx/vpx_encoder.h

@@ -59,7 +59,7 @@ extern "C" {
    * types, removing or reassigning enums, adding/removing/rearranging
    * fields to structures
    */
-#define VPX_ENCODER_ABI_VERSION (4 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/
+#define VPX_ENCODER_ABI_VERSION (4 + 1 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/
 
 
   /*! \brief Encoder capabilities bitfield