Pass AV1_COMMON into get_scan

This CL will facilitate adapt_scan experiment.
In adapt_scan experiment, dynamic scan order will be stored in
AV1_COMMON

Change-Id: I4763ea931b5e1af54d4f173971befeb01a4db335

av1/common/scan.h

@@ -80,8 +80,9 @@ static INLINE const SCAN_ORDER *get_inter_scan(TX_SIZE tx_size,
 }
 #endif  // CONFIG_EXT_TX
 
-static INLINE const SCAN_ORDER *get_scan(TX_SIZE tx_size, TX_TYPE tx_type,
-                                         int is_inter) {
+static INLINE const SCAN_ORDER *get_scan(const AV1_COMMON *cm, TX_SIZE tx_size,
+                                         TX_TYPE tx_type, int is_inter) {
+  (void)cm;
 #if CONFIG_EXT_TX
   return is_inter ? &av1_inter_scan_orders[tx_size][tx_type]
                   : &av1_intra_scan_orders[tx_size][tx_type];

av1/decoder/decodeframe.c

@@ -272,7 +272,8 @@ static void inverse_transform_block(MACROBLOCKD *xd, int plane,
   }
 }
 
-static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
+static void predict_and_reconstruct_intra_block(AV1_COMMON *cm,
+                                                MACROBLOCKD *const xd,
 #if CONFIG_ANS
                                                 struct AnsDecoder *const r,
 #else
@@ -296,7 +297,7 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
 
   if (!mbmi->skip) {
     TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size);
-    const SCAN_ORDER *scan_order = get_scan(tx_size, tx_type, 0);
+    const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, 0);
     const int eob = av1_decode_block_tokens(
         xd, plane, scan_order, col, row, tx_size, tx_type, r, mbmi->segment_id);
     inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
@@ -305,9 +306,9 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
 }
 
 #if CONFIG_VAR_TX
-static void decode_reconstruct_tx(MACROBLOCKD *const xd, aom_reader *r,
-                                  MB_MODE_INFO *const mbmi, int plane,
-                                  BLOCK_SIZE plane_bsize, int block,
+static void decode_reconstruct_tx(AV1_COMMON *cm, MACROBLOCKD *const xd,
+                                  aom_reader *r, MB_MODE_INFO *const mbmi,
+                                  int plane, BLOCK_SIZE plane_bsize, int block,
                                   int blk_row, int blk_col, TX_SIZE tx_size,
                                   int *eob_total) {
   const struct macroblockd_plane *const pd = &xd->plane[plane];
@@ -330,7 +331,7 @@ static void decode_reconstruct_tx(MACROBLOCKD *const xd, aom_reader *r,
   if (tx_size == plane_tx_size) {
     PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
     TX_TYPE tx_type = get_tx_type(plane_type, xd, block, plane_tx_size);
-    const SCAN_ORDER *sc = get_scan(plane_tx_size, tx_type, 1);
+    const SCAN_ORDER *sc = get_scan(cm, plane_tx_size, tx_type, 1);
     const int eob =
         av1_decode_block_tokens(xd, plane, sc, blk_col, blk_row, plane_tx_size,
                                 tx_type, r, mbmi->segment_id);
@@ -353,15 +354,16 @@ static void decode_reconstruct_tx(MACROBLOCKD *const xd, aom_reader *r,
 
       if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
 
-      decode_reconstruct_tx(xd, r, mbmi, plane, plane_bsize, block + i * step,
-                            offsetr, offsetc, tx_size - 1, eob_total);
+      decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize,
+                            block + i * step, offsetr, offsetc, tx_size - 1,
+                            eob_total);
     }
   }
 }
 #endif  // CONFIG_VAR_TX
 
 #if !CONFIG_VAR_TX || CONFIG_SUPERTX || (CONFIG_EXT_TX && CONFIG_RECT_TX)
-static int reconstruct_inter_block(MACROBLOCKD *const xd,
+static int reconstruct_inter_block(AV1_COMMON *cm, MACROBLOCKD *const xd,
 #if CONFIG_ANS
                                    struct AnsDecoder *const r,
 #else
@@ -373,7 +375,7 @@ static int reconstruct_inter_block(MACROBLOCKD *const xd,
   PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
   int block_idx = (row << 1) + col;
   TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size);
-  const SCAN_ORDER *scan_order = get_scan(tx_size, tx_type, 1);
+  const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, 1);
   const int eob = av1_decode_block_tokens(xd, plane, scan_order, col, row,
                                           tx_size, tx_type, r, segment_id);
 
@@ -1248,7 +1250,7 @@ static void decode_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
 
       for (row = 0; row < max_blocks_high; row += stepr)
         for (col = 0; col < max_blocks_wide; col += stepc)
-          predict_and_reconstruct_intra_block(xd, r, mbmi, plane, row, col,
+          predict_and_reconstruct_intra_block(cm, xd, r, mbmi, plane, row, col,
                                               tx_size);
     }
   } else {
@@ -1338,14 +1340,14 @@ static void decode_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
 
           for (row = 0; row < max_blocks_high; row += stepr)
             for (col = 0; col < max_blocks_wide; col += stepc)
-              eobtotal += reconstruct_inter_block(xd, r, mbmi->segment_id,
+              eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id,
                                                   plane, row, col, tx_size);
         } else {
 #endif
           for (row = 0; row < num_4x4_h; row += bh_var_tx) {
             for (col = 0; col < num_4x4_w; col += bw_var_tx) {
-              decode_reconstruct_tx(xd, r, mbmi, plane, plane_bsize, block, row,
-                                    col, max_tx_size, &eobtotal);
+              decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, block,
+                                    row, col, max_tx_size, &eobtotal);
               block += step;
             }
           }
@@ -1368,8 +1370,8 @@ static void decode_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
 
         for (row = 0; row < max_blocks_high; row += stepr)
           for (col = 0; col < max_blocks_wide; col += stepc)
-            eobtotal += reconstruct_inter_block(xd, r, mbmi->segment_id, plane,
-                                                row, col, tx_size);
+            eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id,
+                                                plane, row, col, tx_size);
 #endif
       }
 
@@ -1768,8 +1770,8 @@ static void decode_partition(AV1Decoder *const pbi, MACROBLOCKD *const xd,
 
         for (row = 0; row < max_blocks_high; row += stepr)
           for (col = 0; col < max_blocks_wide; col += stepc)
-            eobtotal += reconstruct_inter_block(xd, r, mbmi->segment_id_supertx,
-                                                i, row, col, tx_size);
+            eobtotal += reconstruct_inter_block(
+                cm, xd, r, mbmi->segment_id_supertx, i, row, col, tx_size);
       }
       if (!(subsize < BLOCK_8X8) && eobtotal == 0) skip = 1;
     }

av1/encoder/encodeframe.c

@@ -2213,7 +2213,7 @@ static void encode_sb(const AV1_COMP *const cpi, ThreadData *td,
         int this_rate = 0;
         x->use_lp32x32fdct = cpi->sf.use_lp32x32fdct;
 
-        av1_encode_sb_supertx(x, bsize);
+        av1_encode_sb_supertx((AV1_COMMON *)cm, x, bsize);
         av1_tokenize_sb_supertx(cpi, td, tp, dry_run, bsize, rate);
         if (rate) *rate += this_rate;
       } else {
@@ -5107,7 +5107,8 @@ static void encode_superblock(const AV1_COMP *const cpi, ThreadData *td,
     int plane;
     mbmi->skip = 1;
     for (plane = 0; plane < MAX_MB_PLANE; ++plane)
-      av1_encode_intra_block_plane(x, AOMMAX(bsize, BLOCK_8X8), plane, 1);
+      av1_encode_intra_block_plane((AV1_COMMON *)cm, x,
+                                   AOMMAX(bsize, BLOCK_8X8), plane, 1);
     if (!dry_run)
       sum_intra_stats(td->counts, mi, xd->above_mi, xd->left_mi,
                       frame_is_intra_only(cm));
@@ -5229,7 +5230,7 @@ static void encode_superblock(const AV1_COMP *const cpi, ThreadData *td,
     }
 #endif  // CONFIG_MOTION_VAR
 
-    av1_encode_sb(x, AOMMAX(bsize, BLOCK_8X8));
+    av1_encode_sb((AV1_COMMON *)cm, x, AOMMAX(bsize, BLOCK_8X8));
 #if CONFIG_VAR_TX
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
     if (is_rect_tx(mbmi->tx_size))

av1/encoder/encodemb.c

@@ -67,8 +67,8 @@ static const int plane_rd_mult[REF_TYPES][PLANE_TYPES] = {
     rd_cost1 = RDCOST(rdmult, rddiv, rate1, error1); \
   }
 
-int av1_optimize_b(MACROBLOCK *mb, int plane, int block, TX_SIZE tx_size,
-                   int ctx) {
+int av1_optimize_b(const AV1_COMMON *cm, MACROBLOCK *mb, int plane, int block,
+                   TX_SIZE tx_size, int ctx) {
   MACROBLOCKD *const xd = &mb->e_mbd;
   struct macroblock_plane *const p = &mb->plane[plane];
   struct macroblockd_plane *const pd = &xd->plane[plane];
@@ -86,7 +86,7 @@ int av1_optimize_b(MACROBLOCK *mb, int plane, int block, TX_SIZE tx_size,
   const uint8_t *const band_translate = get_band_translate(tx_size);
   TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
   const SCAN_ORDER *const scan_order =
-      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
+      get_scan(cm, tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
   const int16_t *const scan = scan_order->scan;
   const int16_t *const nb = scan_order->neighbors;
 #if CONFIG_AOM_QM
@@ -432,16 +432,16 @@ static FWD_TXFM_OPT fwd_txfm_opt_list[AV1_XFORM_QUANT_LAST] = {
   FWD_TXFM_OPT_NORMAL, FWD_TXFM_OPT_NORMAL, FWD_TXFM_OPT_DC, FWD_TXFM_OPT_NORMAL
 };
 
-void av1_xform_quant(MACROBLOCK *x, int plane, int block, int blk_row,
-                     int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
-                     AV1_XFORM_QUANT xform_quant_idx) {
+void av1_xform_quant(const AV1_COMMON *cm, MACROBLOCK *x, int plane, int block,
+                     int blk_row, int blk_col, BLOCK_SIZE plane_bsize,
+                     TX_SIZE tx_size, AV1_XFORM_QUANT xform_quant_idx) {
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblock_plane *const p = &x->plane[plane];
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
   TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
   const int is_inter = is_inter_block(&xd->mi[0]->mbmi);
-  const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type, is_inter);
+  const SCAN_ORDER *const scan_order = get_scan(cm, tx_size, tx_type, is_inter);
   tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
   tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
   tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
@@ -505,16 +505,16 @@ void av1_xform_quant(MACROBLOCK *x, int plane, int block, int blk_row,
 }
 
 #if CONFIG_NEW_QUANT
-void av1_xform_quant_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
-                         int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
-                         int ctx) {
+void av1_xform_quant_nuq(const AV1_COMMON *cm, MACROBLOCK *x, int plane,
+                         int block, int blk_row, int blk_col,
+                         BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int ctx) {
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblock_plane *const p = &x->plane[plane];
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
   TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
   const int is_inter = is_inter_block(&xd->mi[0]->mbmi);
-  const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type, is_inter);
+  const SCAN_ORDER *const scan_order = get_scan(cm, tx_size, tx_type, is_inter);
   tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
   tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
   tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
@@ -578,16 +578,16 @@ void av1_xform_quant_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
   }
 }
 
-void av1_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
-                            int blk_col, BLOCK_SIZE plane_bsize,
-                            TX_SIZE tx_size, int ctx) {
+void av1_xform_quant_fp_nuq(const AV1_COMMON *cm, MACROBLOCK *x, int plane,
+                            int block, int blk_row, int blk_col,
+                            BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int ctx) {
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblock_plane *const p = &x->plane[plane];
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   const int is_inter = is_inter_block(&xd->mi[0]->mbmi);
   PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
   TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
-  const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type, is_inter);
+  const SCAN_ORDER *const scan_order = get_scan(cm, tx_size, tx_type, is_inter);
   int dq = get_dq_profile_from_ctx(xd->qindex[xd->mi[0]->mbmi.segment_id], ctx,
                                    is_inter, plane_type);
   tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
@@ -784,6 +784,7 @@ void av1_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
 static void encode_block(int plane, int block, int blk_row, int blk_col,
                          BLOCK_SIZE plane_bsize, TX_SIZE tx_size, void *arg) {
   struct encode_b_args *const args = arg;
+  AV1_COMMON *cm = args->cm;
   MACROBLOCK *const x = args->x;
   MACROBLOCKD *const xd = &x->e_mbd;
   int ctx;
@@ -815,10 +816,10 @@ static void encode_block(int plane, int block, int blk_row, int blk_col,
   {
 #endif
 #if CONFIG_NEW_QUANT
-    av1_xform_quant_fp_nuq(x, plane, block, blk_row, blk_col, plane_bsize,
+    av1_xform_quant_fp_nuq(cm, x, plane, block, blk_row, blk_col, plane_bsize,
                            tx_size, ctx);
 #else
-    av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
+    av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
                     AV1_XFORM_QUANT_FP);
 #endif  // CONFIG_NEW_QUANT
   }
@@ -829,7 +830,7 @@ static void encode_block(int plane, int block, int blk_row, int blk_col,
 #endif
 
   if (p->eobs[block]) {
-    *a = *l = av1_optimize_b(x, plane, block, tx_size, ctx) > 0;
+    *a = *l = av1_optimize_b(cm, x, plane, block, tx_size, ctx) > 0;
   } else {
     *a = *l = p->eobs[block] > 0;
   }
@@ -918,10 +919,17 @@ static void encode_block_inter(int plane, int block, int blk_row, int blk_col,
 }
 #endif
 
+typedef struct encode_block_pass1_args {
+  AV1_COMMON *cm;
+  MACROBLOCK *x;
+} encode_block_pass1_args;
+
 static void encode_block_pass1(int plane, int block, int blk_row, int blk_col,
                                BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
                                void *arg) {
-  MACROBLOCK *const x = (MACROBLOCK *)arg;
+  encode_block_pass1_args *args = (encode_block_pass1_args *)arg;
+  AV1_COMMON *cm = args->cm;
+  MACROBLOCK *const x = args->x;
   MACROBLOCKD *const xd = &x->e_mbd;
   struct macroblock_plane *const p = &x->plane[plane];
   struct macroblockd_plane *const pd = &xd->plane[plane];
@@ -934,10 +942,10 @@ static void encode_block_pass1(int plane, int block, int blk_row, int blk_col,
 
 #if CONFIG_NEW_QUANT
   ctx = 0;
-  av1_xform_quant_fp_nuq(x, plane, block, blk_row, blk_col, plane_bsize,
+  av1_xform_quant_fp_nuq(cm, x, plane, block, blk_row, blk_col, plane_bsize,
                          tx_size, ctx);
 #else
-  av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
+  av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
                   AV1_XFORM_QUANT_B);
 #endif  // CONFIG_NEW_QUANT
 
@@ -962,17 +970,18 @@ static void encode_block_pass1(int plane, int block, int blk_row, int blk_col,
   }
 }
 
-void av1_encode_sby_pass1(MACROBLOCK *x, BLOCK_SIZE bsize) {
+void av1_encode_sby_pass1(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize) {
+  encode_block_pass1_args args = { cm, x };
   av1_subtract_plane(x, bsize, 0);
   av1_foreach_transformed_block_in_plane(&x->e_mbd, bsize, 0,
-                                         encode_block_pass1, x);
+                                         encode_block_pass1, &args);
 }
 
-void av1_encode_sb(MACROBLOCK *x, BLOCK_SIZE bsize) {
+void av1_encode_sb(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize) {
   MACROBLOCKD *const xd = &x->e_mbd;
   struct optimize_ctx ctx;
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
-  struct encode_b_args arg = { x, &ctx, &mbmi->skip, NULL, NULL, 1 };
+  struct encode_b_args arg = { cm, x, &ctx, &mbmi->skip, NULL, NULL, 1 };
   int plane;
 
   mbmi->skip = 1;
@@ -1027,11 +1036,11 @@ void av1_encode_sb(MACROBLOCK *x, BLOCK_SIZE bsize) {
 }
 
 #if CONFIG_SUPERTX
-void av1_encode_sb_supertx(MACROBLOCK *x, BLOCK_SIZE bsize) {
+void av1_encode_sb_supertx(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize) {
   MACROBLOCKD *const xd = &x->e_mbd;
   struct optimize_ctx ctx;
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
-  struct encode_b_args arg = { x, &ctx, &mbmi->skip, NULL, NULL, 1 };
+  struct encode_b_args arg = { cm, x, &ctx, &mbmi->skip, NULL, NULL, 1 };
   int plane;
 
   mbmi->skip = 1;
@@ -1058,6 +1067,7 @@ void av1_encode_block_intra(int plane, int block, int blk_row, int blk_col,
                             BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
                             void *arg) {
   struct encode_b_args *const args = arg;
+  AV1_COMMON *cm = args->cm;
   MACROBLOCK *const x = args->x;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
@@ -1110,19 +1120,19 @@ void av1_encode_block_intra(int plane, int block, int blk_row, int blk_col,
 
   if (args->enable_optimize_b) {
 #if CONFIG_NEW_QUANT
-    av1_xform_quant_fp_nuq(x, plane, block, blk_row, blk_col, plane_bsize,
+    av1_xform_quant_fp_nuq(cm, x, plane, block, blk_row, blk_col, plane_bsize,
                            tx_size, ctx);
 #else   // CONFIG_NEW_QUANT
-    av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
+    av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
                     AV1_XFORM_QUANT_FP);
 #endif  // CONFIG_NEW_QUANT
     if (p->eobs[block]) {
-      *a = *l = av1_optimize_b(x, plane, block, tx_size, ctx) > 0;
+      *a = *l = av1_optimize_b(cm, x, plane, block, tx_size, ctx) > 0;
     } else {
       *a = *l = 0;
     }
   } else {
-    av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
+    av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
                     AV1_XFORM_QUANT_B);
     *a = *l = p->eobs[block] > 0;
   }
@@ -1148,14 +1158,16 @@ void av1_encode_block_intra(int plane, int block, int blk_row, int blk_col,
   }
 }
 
-void av1_encode_intra_block_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane,
+void av1_encode_intra_block_plane(AV1_COMMON *cm, MACROBLOCK *x,
+                                  BLOCK_SIZE bsize, int plane,
                                   int enable_optimize_b) {
   const MACROBLOCKD *const xd = &x->e_mbd;
   ENTROPY_CONTEXT ta[2 * MAX_MIB_SIZE];
   ENTROPY_CONTEXT tl[2 * MAX_MIB_SIZE];
 
-  struct encode_b_args arg = { x,  NULL, &xd->mi[0]->mbmi.skip,
-                               ta, tl,   enable_optimize_b };
+  struct encode_b_args arg = {
+    cm, x, NULL, &xd->mi[0]->mbmi.skip, ta, tl, enable_optimize_b
+  };
   if (enable_optimize_b) {
     const struct macroblockd_plane *const pd = &xd->plane[plane];
     const TX_SIZE tx_size =

av1/encoder/encodemb.h

@@ -25,6 +25,7 @@ struct optimize_ctx {
 };
 
 struct encode_b_args {
+  AV1_COMMON *cm;
   MACROBLOCK *x;
   struct optimize_ctx *ctx;
   int8_t *skip;
@@ -41,38 +42,39 @@ typedef enum AV1_XFORM_QUANT {
   AV1_XFORM_QUANT_LAST = 4
 } AV1_XFORM_QUANT;
 
-void av1_encode_sb(MACROBLOCK *x, BLOCK_SIZE bsize);
+void av1_encode_sb(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize);
 #if CONFIG_SUPERTX
-void av1_encode_sb_supertx(MACROBLOCK *x, BLOCK_SIZE bsize);
+void av1_encode_sb_supertx(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize);
 #endif  // CONFIG_SUPERTX
-void av1_encode_sby_pass1(MACROBLOCK *x, BLOCK_SIZE bsize);
-void av1_xform_quant(MACROBLOCK *x, int plane, int block, int blk_row,
-                     int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
-                     AV1_XFORM_QUANT xform_quant_idx);
+void av1_encode_sby_pass1(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize);
+void av1_xform_quant(const AV1_COMMON *cm, MACROBLOCK *x, int plane, int block,
+                     int blk_row, int blk_col, BLOCK_SIZE plane_bsize,
+                     TX_SIZE tx_size, AV1_XFORM_QUANT xform_quant_idx);
 #if CONFIG_NEW_QUANT
-void av1_xform_quant_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
-                         int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
-                         int ctx);
+void av1_xform_quant_nuq(const AV1_COMMON *cm, MACROBLOCK *x, int plane,
+                         int block, int blk_row, int blk_col,
+                         BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int ctx);
 void av1_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
                             int blk_col, BLOCK_SIZE plane_bsize,
                             TX_SIZE tx_size, int ctx);
-void av1_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
-                            int blk_col, BLOCK_SIZE plane_bsize,
-                            TX_SIZE tx_size, int ctx);
+void av1_xform_quant_fp_nuq(const AV1_COMMON *cm, MACROBLOCK *x, int plane,
+                            int block, int blk_row, int blk_col,
+                            BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int ctx);
 void av1_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
                                int blk_col, BLOCK_SIZE plane_bsize,
                                TX_SIZE tx_size, int ctx);
 #endif
 
-int av1_optimize_b(MACROBLOCK *mb, int plane, int block, TX_SIZE tx_size,
-                   int ctx);
+int av1_optimize_b(const AV1_COMMON *cm, MACROBLOCK *mb, int plane, int block,
+                   TX_SIZE tx_size, int ctx);
 
 void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
 
 void av1_encode_block_intra(int plane, int block, int blk_row, int blk_col,
                             BLOCK_SIZE plane_bsize, TX_SIZE tx_size, void *arg);
 
-void av1_encode_intra_block_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane,
+void av1_encode_intra_block_plane(AV1_COMMON *cm, MACROBLOCK *x,
+                                  BLOCK_SIZE bsize, int plane,
                                   int enable_optimize_b);
 
 #ifdef __cplusplus

av1/encoder/firstpass.c

@@ -590,7 +590,7 @@ void av1_first_pass(AV1_COMP *cpi, const struct lookahead_entry *source) {
       xd->mi[0]->mbmi.mode = DC_PRED;
       xd->mi[0]->mbmi.tx_size =
           use_dc_pred ? (bsize >= BLOCK_16X16 ? TX_16X16 : TX_8X8) : TX_4X4;
-      av1_encode_intra_block_plane(x, bsize, 0, 0);
+      av1_encode_intra_block_plane(cm, x, bsize, 0, 0);
       this_error = aom_get_mb_ss(x->plane[0].src_diff);
 
       // Keep a record of blocks that have almost no intra error residual
@@ -811,7 +811,7 @@ void av1_first_pass(AV1_COMP *cpi, const struct lookahead_entry *source) {
           xd->mi[0]->mbmi.ref_frame[0] = LAST_FRAME;
           xd->mi[0]->mbmi.ref_frame[1] = NONE;
           av1_build_inter_predictors_sby(xd, mb_row << 1, mb_col << 1, bsize);
-          av1_encode_sby_pass1(x, bsize);
+          av1_encode_sby_pass1(cm, x, bsize);
           sum_mvr += mv.row;
           sum_mvr_abs += abs(mv.row);
           sum_mvc += mv.col;

av1/encoder/rdopt.c

@@ -1122,6 +1122,7 @@ static void block_rd_txfm(int plane, int block, int blk_row, int blk_col,
   MACROBLOCK *const x = args->x;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
+  const AV1_COMMON *cm = &args->cpi->common;
   int64_t rd1, rd2, rd;
   int rate;
   int64_t dist;
@@ -1134,7 +1135,7 @@ static void block_rd_txfm(int plane, int block, int blk_row, int blk_col,
 
   if (!is_inter_block(mbmi)) {
     struct encode_b_args b_args = {
-      x, NULL, &mbmi->skip, args->t_above, args->t_left, 1
+      (AV1_COMMON *)cm, x, NULL, &mbmi->skip, args->t_above, args->t_left, 1
     };
     av1_encode_block_intra(plane, block, blk_row, blk_col, plane_bsize, tx_size,
                            &b_args);
@@ -1174,14 +1175,14 @@ static void block_rd_txfm(int plane, int block, int blk_row, int blk_col,
   } else {
 // full forward transform and quantization
 #if CONFIG_NEW_QUANT
-    av1_xform_quant_fp_nuq(x, plane, block, blk_row, blk_col, plane_bsize,
+    av1_xform_quant_fp_nuq(cm, x, plane, block, blk_row, blk_col, plane_bsize,
                            tx_size, coeff_ctx);
 #else
-    av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
+    av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
                     AV1_XFORM_QUANT_FP);
 #endif  // CONFIG_NEW_QUANT
     if (x->plane[plane].eobs[block])
-      av1_optimize_b(x, plane, block, tx_size, coeff_ctx);
+      av1_optimize_b(cm, x, plane, block, tx_size, coeff_ctx);
     dist_block(args->cpi, x, plane, block, blk_row, blk_col, tx_size, &dist,
                &sse);
   }
@@ -1219,6 +1220,7 @@ static void txfm_rd_in_plane(MACROBLOCK *x, const AV1_COMP *cpi, int *rate,
                              int64_t *distortion, int *skippable, int64_t *sse,
                              int64_t ref_best_rd, int plane, BLOCK_SIZE bsize,
                              TX_SIZE tx_size, int use_fast_coef_casting) {
+  const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   TX_TYPE tx_type;
@@ -1236,7 +1238,7 @@ static void txfm_rd_in_plane(MACROBLOCK *x, const AV1_COMP *cpi, int *rate,
 
   tx_type = get_tx_type(pd->plane_type, xd, 0, tx_size);
   args.scan_order =
-      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
+      get_scan(cm, tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
 
   av1_foreach_transformed_block_in_plane(xd, bsize, plane, block_rd_txfm,
                                          &args);
@@ -1259,6 +1261,7 @@ void av1_txfm_rd_in_plane_supertx(MACROBLOCK *x, const AV1_COMP *cpi, int *rate,
                                   int64_t *sse, int64_t ref_best_rd, int plane,
                                   BLOCK_SIZE bsize, TX_SIZE tx_size,
                                   int use_fast_coef_casting) {
+  const AV1_COMMON *cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   struct rdcost_block_args args;
@@ -1280,7 +1283,7 @@ void av1_txfm_rd_in_plane_supertx(MACROBLOCK *x, const AV1_COMP *cpi, int *rate,
 
   tx_type = get_tx_type(pd->plane_type, xd, 0, tx_size);
   args.scan_order =
-      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
+      get_scan(cm, tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
 
   block_rd_txfm(plane, 0, 0, 0, get_plane_block_size(bsize, pd), tx_size,
                 &args);
@@ -1947,14 +1950,14 @@ static int64_t rd_pick_intra4x4block(
                                     dst_stride, xd->bd);
           if (xd->lossless[xd->mi[0]->mbmi.segment_id]) {
             TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block, TX_4X4);
-            const SCAN_ORDER *scan_order = get_scan(TX_4X4, tx_type, 0);
+            const SCAN_ORDER *scan_order = get_scan(cm, TX_4X4, tx_type, 0);
             const int coeff_ctx =
                 combine_entropy_contexts(*(tempa + idx), *(templ + idy));
 #if CONFIG_NEW_QUANT
-            av1_xform_quant_fp_nuq(x, 0, block, row + idy, col + idx, BLOCK_8X8,
-                                   TX_4X4, coeff_ctx);
+            av1_xform_quant_fp_nuq(cm, x, 0, block, row + idy, col + idx,
+                                   BLOCK_8X8, TX_4X4, coeff_ctx);
 #else
-            av1_xform_quant(x, 0, block, row + idy, col + idx, BLOCK_8X8,
+            av1_xform_quant(cm, x, 0, block, row + idy, col + idx, BLOCK_8X8,
                             TX_4X4, AV1_XFORM_QUANT_FP);
 #endif  // CONFIG_NEW_QUANT
             ratey += av1_cost_coeffs(cm, x, 0, block, coeff_ctx, TX_4X4,
@@ -1972,17 +1975,17 @@ static int64_t rd_pick_intra4x4block(
             int64_t dist;
             unsigned int tmp;
             TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block, TX_4X4);
-            const SCAN_ORDER *scan_order = get_scan(TX_4X4, tx_type, 0);
+            const SCAN_ORDER *scan_order = get_scan(cm, TX_4X4, tx_type, 0);
             const int coeff_ctx =
                 combine_entropy_contexts(*(tempa + idx), *(templ + idy));
 #if CONFIG_NEW_QUANT
-            av1_xform_quant_fp_nuq(x, 0, block, row + idy, col + idx, BLOCK_8X8,
-                                   TX_4X4, coeff_ctx);
+            av1_xform_quant_fp_nuq(cm, x, 0, block, row + idy, col + idx,
+                                   BLOCK_8X8, TX_4X4, coeff_ctx);
 #else
-            av1_xform_quant(x, 0, block, row + idy, col + idx, BLOCK_8X8,
+            av1_xform_quant(cm, x, 0, block, row + idy, col + idx, BLOCK_8X8,
                             TX_4X4, AV1_XFORM_QUANT_FP);
 #endif  // CONFIG_NEW_QUANT
-            av1_optimize_b(x, 0, block, TX_4X4, coeff_ctx);
+            av1_optimize_b(cm, x, 0, block, TX_4X4, coeff_ctx);
             ratey += av1_cost_coeffs(cm, x, 0, block, coeff_ctx, TX_4X4,
                                      scan_order->scan, scan_order->neighbors,
                                      cpi->sf.use_fast_coef_costing);
@@ -2067,15 +2070,15 @@ static int64_t rd_pick_intra4x4block(
 
         if (xd->lossless[xd->mi[0]->mbmi.segment_id]) {
           TX_TYPE tx_type = get_tx_type(PLANE_TYPE_Y, xd, block, TX_4X4);
-          const SCAN_ORDER *scan_order = get_scan(TX_4X4, tx_type, 0);
+          const SCAN_ORDER *scan_order = get_scan(cm, TX_4X4, tx_type, 0);
           const int coeff_ctx =
               combine_entropy_contexts(*(tempa + idx), *(templ + idy));
 #if CONFIG_NEW_QUANT
-          av1_xform_quant_fp_nuq(x, 0, block, row + idy, col + idx, BLOCK_8X8,
-                                 TX_4X4, coeff_ctx);
+          av1_xform_quant_fp_nuq(cm, x, 0, block, row + idy, col + idx,
+                                 BLOCK_8X8, TX_4X4, coeff_ctx);
 #else
-          av1_xform_quant(x, 0, block, row + idy, col + idx, BLOCK_8X8, TX_4X4,
-                          AV1_XFORM_QUANT_B);
+          av1_xform_quant(cm, x, 0, block, row + idy, col + idx, BLOCK_8X8,
+                          TX_4X4, AV1_XFORM_QUANT_B);
 #endif  // CONFIG_NEW_QUANT
           ratey += av1_cost_coeffs(cm, x, 0, block, coeff_ctx, TX_4X4,
                                    scan_order->scan, scan_order->neighbors,
@@ -2091,17 +2094,17 @@ static int64_t rd_pick_intra4x4block(