diff --git a/av1/common/av1_rtcd_defs.pl b/av1/common/av1_rtcd_defs.pl
index 597d5b2..ee46820 100644
--- a/av1/common/av1_rtcd_defs.pl
+++ b/av1/common/av1_rtcd_defs.pl
@@ -111,6 +111,9 @@
 
     add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
     specialize qw/av1_iht16x16_256_add sse2 avx2/;
+
+    add_proto qw/void av1_iht32x32_1024_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
+    specialize qw/av1_iht32x32_1024_add/;
   }
 } else {
   # Force C versions if CONFIG_EMULATE_HARDWARE is 1
@@ -141,6 +144,10 @@
 
     add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
     specialize qw/av1_iht16x16_256_add/;
+
+    add_proto qw/void av1_iht32x32_1024_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
+    specialize qw/av1_iht32x32_1024_add/;
+
   } else {
     add_proto qw/void av1_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, int tx_type";
     specialize qw/av1_iht4x4_16_add sse2 neon dspr2/;
@@ -169,6 +176,9 @@
     add_proto qw/void av1_iht16x16_256_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
     specialize qw/av1_iht16x16_256_add sse2 avx2 dspr2/;
 
+    add_proto qw/void av1_iht32x32_1024_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
+    specialize qw/av1_iht32x32_1024_add/;
+
     if (aom_config("CONFIG_EXT_TX") ne "yes") {
       specialize qw/av1_iht4x4_16_add msa/;
       specialize qw/av1_iht8x8_64_add msa/;
@@ -176,6 +186,13 @@
     }
   }
 }
+add_proto qw/void av1_iht32x32_1024_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
+specialize qw/av1_iht32x32_1024_add/;
+
+if (aom_config("CONFIG_TX64X64") eq "yes") {
+  add_proto qw/void av1_iht64x64_4096_add/, "const tran_low_t *input, uint8_t *output, int pitch, int tx_type";
+  specialize qw/av1_iht64x64_4096_add/;
+}
 
 if (aom_config("CONFIG_NEW_QUANT") eq "yes") {
   add_proto qw/void quantize_nuq/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, const int16_t *dequant_ptr, const cuml_bins_type_nuq *cuml_bins_ptr, const dequant_val_type_nuq *dequant_val, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, const int16_t *scan, const uint8_t *band";
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 2ec83ec..6c0eb3d 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -134,24 +134,32 @@
 #if CONFIG_CB4X4
   TX_2X2,  // 2x2 transform
 #endif
-  TX_4X4,                   // 4x4 transform
-  TX_8X8,                   // 8x8 transform
-  TX_16X16,                 // 16x16 transform
-  TX_32X32,                 // 32x32 transform
-  TX_4X8,                   // 4x8 transform
-  TX_8X4,                   // 8x4 transform
-  TX_8X16,                  // 8x16 transform
-  TX_16X8,                  // 16x8 transform
-  TX_16X32,                 // 16x32 transform
-  TX_32X16,                 // 32x16 transform
-  TX_SIZES_ALL,             // Includes rectangular transforms
-  TX_SIZES = TX_32X32 + 1,  // Does NOT include rectangular transforms
-  TX_INVALID = 255          // Invalid transform size
+  TX_4X4,    // 4x4 transform
+  TX_8X8,    // 8x8 transform
+  TX_16X16,  // 16x16 transform
+  TX_32X32,  // 32x32 transform
+#if CONFIG_TX64X64
+  TX_64X64,           // 64x64 transform
+#endif                // CONFIG_TX64X64
+  TX_4X8,             // 4x8 transform
+  TX_8X4,             // 8x4 transform
+  TX_8X16,            // 8x16 transform
+  TX_16X8,            // 16x8 transform
+  TX_16X32,           // 16x32 transform
+  TX_32X16,           // 32x16 transform
+#if 0                 // CONFIG_TX64X64
+  // TODO(debargha): To be enabled later
+  TX_32X64,                 // 32x64 transform
+  TX_64X32,                 // 64x32 transform
+#endif                // CONFIG_TX64X64
+  TX_SIZES_ALL,       // Includes rectangular transforms
+  TX_SIZES = TX_4X8,  // Does NOT include rectangular transforms
+  TX_INVALID = 255    // Invalid transform size
 } TX_SIZE;
 
 #define MAX_TX_DEPTH (TX_32X32 - TX_4X4)
 
-#define MAX_TX_SIZE_LOG2 5
+#define MAX_TX_SIZE_LOG2 (5 + CONFIG_TX64X64)
 #define MAX_TX_SIZE (1 << MAX_TX_SIZE_LOG2)
 #define MIN_TX_SIZE_LOG2 2
 #define MIN_TX_SIZE (1 << MIN_TX_SIZE_LOG2)
diff --git a/av1/common/idct.c b/av1/common/idct.c
index 223c577..2663d2d 100644
--- a/av1/common/idct.c
+++ b/av1/common/idct.c
@@ -23,14 +23,14 @@
 int get_tx_scale(const MACROBLOCKD *const xd, const TX_TYPE tx_type,
                  const TX_SIZE tx_size) {
   (void)tx_type;
-#if CONFIG_AOM_HIGHBITDEPTH
-  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
-    return txsize_sqr_up_map[tx_size] == TX_32X32;
-  }
-#else
   (void)xd;
-#endif
-  return txsize_sqr_up_map[tx_size] == TX_32X32;
+  if (txsize_sqr_up_map[tx_size] == TX_32X32) return 1;
+#if CONFIG_TX64X64
+  else if (txsize_sqr_up_map[tx_size] == TX_64X64)
+    return 2;
+#endif  // CONFIG_TX64X64
+  else
+    return 0;
 }
 
 // NOTE: The implementation of all inverses need to be aware of the fact
@@ -58,6 +58,14 @@
   int i;
   for (i = 0; i < 32; ++i) output[i] = input[i] * 4;
 }
+
+#if CONFIG_TX64X64
+static void iidtx64_c(const tran_low_t *input, tran_low_t *output) {
+  int i;
+  for (i = 0; i < 64; ++i)
+    output[i] = (tran_low_t)dct_const_round_shift(input[i] * 4 * Sqrt2);
+}
+#endif  // CONFIG_TX64X64
 #endif  // CONFIG_EXT_TX
 
 // For use in lieu of ADST
@@ -94,12 +102,6 @@
   for (i = 0; i < 64; ++i) output[i] = (tran_low_t)out[i];
 }
 
-static void iidtx64_c(const tran_low_t *input, tran_low_t *output) {
-  int i;
-  for (i = 0; i < 64; ++i)
-    output[i] = (tran_low_t)dct_const_round_shift(input[i] * 4 * Sqrt2);
-}
-
 // For use in lieu of ADST
 static void ihalfright64_c(const tran_low_t *input, tran_low_t *output) {
   int i;
@@ -174,7 +176,10 @@
     output[i] =
         HIGHBD_WRAPLOW(highbd_dct_const_round_shift(input[i] * 4 * Sqrt2), bd);
 }
+#endif  // CONFIG_TX64X64
+#endif  // CONFIG_EXT_TX
 
+#if CONFIG_TX64X64
 // For use in lieu of ADST
 static void highbd_ihalfright64_c(const tran_low_t *input, tran_low_t *output,
                                   int bd) {
@@ -215,7 +220,6 @@
   for (i = 0; i < 64; ++i) output[i] = (tran_low_t)out[i];
 }
 #endif  // CONFIG_TX64X64
-#endif  // CONFIG_EXT_TX
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 
 // Inverse identity transform and add.
@@ -223,7 +227,7 @@
 static void inv_idtx_add_c(const tran_low_t *input, uint8_t *dest, int stride,
                            int bs, int tx_type) {
   int r, c;
-  const int shift = bs < 32 ? 3 : 2;
+  const int shift = bs < 32 ? 3 : (bs < 64 ? 2 : 1);
   if (tx_type == IDTX) {
     for (r = 0; r < bs; ++r) {
       for (c = 0; c < bs; ++c)
@@ -929,6 +933,7 @@
     }
   }
 }
+#endif  // CONFIG_EXT_TX
 
 #if CONFIG_TX64X64
 void av1_iht64x64_4096_add_c(const tran_low_t *input, uint8_t *dest, int stride,
@@ -938,6 +943,7 @@
     { ihalfright64_c, idct64_row_c },    // ADST_DCT
     { idct64_col_c, ihalfright64_c },    // DCT_ADST
     { ihalfright64_c, ihalfright64_c },  // ADST_ADST
+#if CONFIG_EXT_TX
     { ihalfright64_c, idct64_row_c },    // FLIPADST_DCT
     { idct64_col_c, ihalfright64_c },    // DCT_FLIPADST
     { ihalfright64_c, ihalfright64_c },  // FLIPADST_FLIPADST
@@ -950,6 +956,7 @@
     { iidtx64_c, ihalfright64_c },       // H_ADST
     { ihalfright64_c, iidtx64_c },       // V_FLIPADST
     { iidtx64_c, ihalfright64_c },       // H_FLIPADST
+#endif                                   // CONFIG_EXT_TX
   };
 
   int i, j;
@@ -979,7 +986,9 @@
     IHT_64[tx_type].cols(out[i], out[i]);
   }
 
+#if CONFIG_EXT_TX
   maybe_flip_strides(&dest, &stride, &outp, &outstride, tx_type, 64, 64);
+#endif  // CONFIG_EXT_TX
 
   // Sum with the destination
   for (i = 0; i < 64; ++i) {
@@ -991,7 +1000,6 @@
   }
 }
 #endif  // CONFIG_TX64X64
-#endif  // CONFIG_EXT_TX
 
 // idct
 void av1_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
@@ -1056,6 +1064,14 @@
     aom_idct32x32_1024_add(input, dest, stride);
 }
 
+#if CONFIG_TX64X64
+void av1_idct64x64_add(const tran_low_t *input, uint8_t *dest, int stride,
+                       int eob) {
+  (void)eob;
+  av1_iht64x64_4096_add(input, dest, stride, DCT_DCT);
+}
+#endif  // CONFIG_TX64X64
+
 void av1_inv_txfm_add_4x4(const tran_low_t *input, uint8_t *dest, int stride,
                           int eob, TX_TYPE tx_type, int lossless) {
   if (lossless) {
@@ -1206,6 +1222,35 @@
   }
 }
 
+#if CONFIG_TX64X64
+void av1_inv_txfm_add_64x64(const tran_low_t *input, uint8_t *dest, int stride,
+                            int eob, TX_TYPE tx_type) {
+  switch (tx_type) {
+    case DCT_DCT: av1_idct64x64_add(input, dest, stride, eob); break;
+#if CONFIG_EXT_TX
+    case ADST_DCT:
+    case DCT_ADST:
+    case ADST_ADST:
+    case FLIPADST_DCT:
+    case DCT_FLIPADST:
+    case FLIPADST_FLIPADST:
+    case ADST_FLIPADST:
+    case FLIPADST_ADST:
+    case V_DCT:
+    case H_DCT:
+    case V_ADST:
+    case H_ADST:
+    case V_FLIPADST:
+    case H_FLIPADST:
+      av1_iht64x64_4096_add_c(input, dest, stride, tx_type);
+      break;
+    case IDTX: inv_idtx_add_c(input, dest, stride, 64, tx_type); break;
+#endif  // CONFIG_EXT_TX
+    default: assert(0); break;
+  }
+}
+#endif  // CONFIG_TX64X64
+
 #if CONFIG_AOM_HIGHBITDEPTH
 void av1_highbd_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
                                 int stride, int tx_type, int bd) {
@@ -1835,6 +1880,7 @@
     }
   }
 }
+#endif  // CONFIG_EXT_TX
 
 #if CONFIG_TX64X64
 void av1_highbd_iht64x64_4096_add_c(const tran_low_t *input, uint8_t *dest8,
@@ -1844,6 +1890,7 @@
     { highbd_ihalfright64_c, highbd_idct64_row_c },    // ADST_DCT
     { highbd_idct64_col_c, highbd_ihalfright64_c },    // DCT_ADST
     { highbd_ihalfright64_c, highbd_ihalfright64_c },  // ADST_ADST
+#if CONFIG_EXT_TX
     { highbd_ihalfright64_c, highbd_idct64_row_c },    // FLIPADST_DCT
     { highbd_idct64_col_c, highbd_ihalfright64_c },    // DCT_FLIPADST
     { highbd_ihalfright64_c, highbd_ihalfright64_c },  // FLIPADST_FLIPADST
@@ -1856,6 +1903,7 @@
     { highbd_iidtx64_c, highbd_ihalfright64_c },       // H_ADST
     { highbd_ihalfright64_c, highbd_iidtx64_c },       // V_FLIPADST
     { highbd_iidtx64_c, highbd_ihalfright64_c },       // H_FLIPADST
+#endif                                                 // CONFIG_EXT_TX
   };
 
   uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
@@ -1887,7 +1935,9 @@
     HIGH_IHT_64[tx_type].cols(out[i], out[i], bd);
   }
 
+#if CONFIG_EXT_TX
   maybe_flip_strides16(&dest, &stride, &outp, &outstride, tx_type, 64, 64);
+#endif  // CONFIG_EXT_TX
 
   // Sum with the destination
   for (i = 0; i < 64; ++i) {
@@ -1900,7 +1950,6 @@
   }
 }
 #endif  // CONFIG_TX64X64
-#endif  // CONFIG_EXT_TX
 
 // idct
 void av1_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
@@ -2155,6 +2204,42 @@
     default: assert(0); break;
   }
 }
+
+#if CONFIG_TX64X64
+void av1_highbd_inv_txfm_add_64x64(const tran_low_t *input, uint8_t *dest,
+                                   int stride, int eob, int bd,
+                                   TX_TYPE tx_type) {
+  (void)eob;
+  switch (tx_type) {
+    case DCT_DCT:
+      av1_inv_txfm2d_add_64x64(input, CONVERT_TO_SHORTPTR(dest), stride,
+                               DCT_DCT, bd);
+      break;
+#if CONFIG_EXT_TX
+    case ADST_DCT:
+    case DCT_ADST:
+    case ADST_ADST:
+    case FLIPADST_DCT:
+    case DCT_FLIPADST:
+    case FLIPADST_FLIPADST:
+    case ADST_FLIPADST:
+    case FLIPADST_ADST:
+    case V_DCT:
+    case H_DCT:
+    case V_ADST:
+    case H_ADST:
+    case V_FLIPADST:
+    case H_FLIPADST:
+      av1_highbd_iht64x64_4096_add_c(input, dest, stride, tx_type, bd);
+      break;
+    case IDTX:
+      highbd_inv_idtx_add_c(input, dest, stride, 64, tx_type, bd);
+      break;
+#endif  // CONFIG_EXT_TX
+    default: assert(0); break;
+  }
+}
+#endif  // CONFIG_TX64X64
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 
 void inv_txfm_add(const tran_low_t *input, uint8_t *dest, int stride,
@@ -2165,6 +2250,11 @@
   const int lossless = inv_txfm_param->lossless;
 
   switch (tx_size) {
+#if CONFIG_TX64X64
+    case TX_64X64:
+      av1_inv_txfm_add_64x64(input, dest, stride, eob, tx_type);
+      break;
+#endif  // CONFIG_TX64X64
     case TX_32X32:
       av1_inv_txfm_add_32x32(input, dest, stride, eob, tx_type);
       break;
@@ -2206,6 +2296,11 @@
   const int lossless = inv_txfm_param->lossless;
 
   switch (tx_size) {
+#if CONFIG_TX64X64
+    case TX_64X64:
+      av1_highbd_inv_txfm_add_64x64(input, dest, stride, eob, bd, tx_type);
+      break;
+#endif  // CONFIG_TX64X64
     case TX_32X32:
       av1_highbd_inv_txfm_add_32x32(input, dest, stride, eob, bd, tx_type);
       break;
diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index 8f0a212..f1c4239 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -369,6 +369,7 @@
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int i, j, subtile_idx;
   int h_start, h_end, v_start, v_end;
+  const int shift = bit_depth - 8;
 
   for (subtile_idx = 0; subtile_idx < BILATERAL_SUBTILES; ++subtile_idx) {
     uint16_t *data_p, *tmpdata_p;
@@ -398,7 +399,7 @@
         for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; ++y) {
           for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; ++x) {
             wt = (int)wx_lut[y + RESTORATION_HALFWIN][x + RESTORATION_HALFWIN] *
-                 (int)wr_lut_[data_p2[x] - data_p[j]];
+                 (int)wr_lut_[(data_p2[x] >> shift) - (data_p[j] >> shift)];
             wtsum += (int64_t)wt;
             flsum += (int64_t)wt * data_p2[x];
           }
diff --git a/av1/common/warped_motion.c b/av1/common/warped_motion.c
index f73e777..89534de 100644
--- a/av1/common/warped_motion.c
+++ b/av1/common/warped_motion.c
@@ -215,7 +215,7 @@
   } else if (x == (1 << WARPEDPIXEL_PREC_BITS)) {
     return p[1];
   } else {
-    const int64_t v1 = x * x * x * (3 * (p[0] - p[1]) + p[2] - p[-1]);
+    const int64_t v1 = (int64_t)x * x * x * (3 * (p[0] - p[1]) + p[2] - p[-1]);
     const int64_t v2 = x * x * (2 * p[-1] - 5 * p[0] + 4 * p[1] - p[2]);
     const int64_t v3 = x * (p[1] - p[-1]);
     const int64_t v4 = 2 * p[0];
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 0c155e0..8b0de2f 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -6180,11 +6180,12 @@
     ENTROPY_CONTEXT ctxl[2 * MAX_MIB_SIZE];
     const struct macroblockd_plane *const pd = &xd->plane[plane];
     int coeff_ctx = 1;
+    RD_STATS this_rd_stats;
 
-    this_rate = 0;
-    this_dist = 0;
-    pnsse = 0;
-    pnskip = 1;
+    this_rd_stats.rate = 0;
+    this_rd_stats.dist = 0;
+    this_rd_stats.sse = 0;
+    this_rd_stats.skip = 1;
 
     tx_size = max_txsize_lookup[bsize];
     tx_size =
@@ -6194,8 +6195,13 @@
 
     av1_subtract_plane(x, bsize, plane);
     av1_tx_block_rd_b(cpi, x, tx_size, 0, 0, plane, 0,
-                      get_plane_block_size(bsize, pd), coeff_ctx, &this_rate,
-                      &this_dist, &pnsse, &pnskip);
+                      get_plane_block_size(bsize, pd), coeff_ctx,
+                      &this_rd_stats);
+
+    this_rate = this_rd_stats.rate;
+    this_dist = this_rd_stats.dist;
+    pnsse = this_rd_stats.sse;
+    pnskip = this_rd_stats.skip;
 #else
     tx_size = max_txsize_lookup[bsize];
     tx_size =
@@ -6223,7 +6229,9 @@
     ENTROPY_CONTEXT ctxl[2 * MAX_MIB_SIZE];
     const struct macroblockd_plane *const pd = &xd->plane[0];
     int coeff_ctx = 1;
+    RD_STATS this_rd_stats;
 #endif  // CONFIG_VAR_TX
+
 #if CONFIG_EXT_TX
     if (!ext_tx_used_inter[ext_tx_set][tx_type]) continue;
 #else
@@ -6232,15 +6240,20 @@
     mbmi->tx_type = tx_type;
 
 #if CONFIG_VAR_TX
-    this_rate = 0;
-    this_dist = 0;
-    pnsse = 0;
-    pnskip = 1;
+    this_rd_stats.rate = 0;
+    this_rd_stats.dist = 0;
+    this_rd_stats.sse = 0;
+    this_rd_stats.skip = 1;
 
     av1_get_entropy_contexts(bsize, tx_size, pd, ctxa, ctxl);
     coeff_ctx = combine_entropy_contexts(ctxa[0], ctxl[0]);
-    av1_tx_block_rd_b(cpi, x, tx_size, 0, 0, 0, 0, bsize, coeff_ctx, &this_rate,
-                      &this_dist, &pnsse, &pnskip);
+    av1_tx_block_rd_b(cpi, x, tx_size, 0, 0, 0, 0, bsize, coeff_ctx,
+                      &this_rd_stats);
+
+    this_rate = this_rd_stats.rate;
+    this_dist = this_rd_stats.dist;
+    pnsse = this_rd_stats.sse;
+    pnskip = this_rd_stats.skip;
 #else
     av1_txfm_rd_in_plane_supertx(x, cpi, &this_rate, &this_dist, &pnskip,
                                  &pnsse, INT64_MAX, 0, bsize, tx_size, 0);
diff --git a/av1/encoder/global_motion.c b/av1/encoder/global_motion.c
index 5d88dbf..d8abea9 100644
--- a/av1/encoder/global_motion.c
+++ b/av1/encoder/global_motion.c
@@ -25,7 +25,7 @@
 #define MAX_CORNERS 4096
 #define MIN_INLIER_PROB 0.1
 
-INLINE RansacFunc get_ransac_type(TransformationType type) {
+static INLINE RansacFunc get_ransac_type(TransformationType type) {
   switch (type) {
     case HOMOGRAPHY: return ransac_homography;
     case AFFINE: return ransac_affine;
diff --git a/av1/encoder/hybrid_fwd_txfm.c b/av1/encoder/hybrid_fwd_txfm.c
index ff03516..a88c884 100644
--- a/av1/encoder/hybrid_fwd_txfm.c
+++ b/av1/encoder/hybrid_fwd_txfm.c
@@ -24,6 +24,24 @@
     av1_fht32x32(src, dst, src_stride, DCT_DCT);
 }
 
+#if CONFIG_TX64X64
+static INLINE void fdct64x64(const int16_t *src, tran_low_t *dst,
+                             int src_stride) {
+  av1_fht64x64(src, dst, src_stride, DCT_DCT);
+}
+
+static INLINE void fdct64x64_1(const int16_t *src, tran_low_t *dst,
+                               int src_stride) {
+  int i, j;
+  int32_t sum = 0;
+  memset(dst, 0, sizeof(*dst) * 4096);
+  for (i = 0; i < 64; ++i)
+    for (j = 0; j < 64; ++j) sum += src[i * src_stride + j];
+  // Note: this scaling makes the transform 2 times unitary
+  dst[0] = ROUND_POWER_OF_TWO_SIGNED(sum, 5);
+}
+#endif  // CONFIG_TX64X64
+
 static void fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff,
                          int diff_stride, TX_TYPE tx_type, int lossless) {
   if (lossless) {
@@ -192,6 +210,41 @@
   }
 }
 
+#if CONFIG_TX64X64
+static void fwd_txfm_64x64(const int16_t *src_diff, tran_low_t *coeff,
+                           int diff_stride, TX_TYPE tx_type,
+                           FWD_TXFM_OPT fwd_txfm_opt) {
+  switch (tx_type) {
+    case DCT_DCT:
+      if (fwd_txfm_opt == FWD_TXFM_OPT_NORMAL)
+        fdct64x64(src_diff, coeff, diff_stride);
+      else  // FWD_TXFM_OPT_DC
+        fdct64x64_1(src_diff, coeff, diff_stride);
+      break;
+#if CONFIG_EXT_TX
+    case ADST_DCT:
+    case DCT_ADST:
+    case ADST_ADST:
+    case FLIPADST_DCT:
+    case DCT_FLIPADST:
+    case FLIPADST_FLIPADST:
+    case ADST_FLIPADST:
+    case FLIPADST_ADST:
+      av1_fht64x64(src_diff, coeff, diff_stride, tx_type);
+      break;
+    case V_DCT:
+    case H_DCT:
+    case V_ADST:
+    case H_ADST:
+    case V_FLIPADST:
+    case H_FLIPADST: av1_fht32x32(src_diff, coeff, diff_stride, tx_type); break;
+    case IDTX: av1_fwd_idtx_c(src_diff, coeff, diff_stride, 64, tx_type); break;
+#endif  // CONFIG_EXT_TX
+    default: assert(0); break;
+  }
+}
+#endif  // CONFIG_TX64X64
+
 #if CONFIG_AOM_HIGHBITDEPTH
 static void highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TX_TYPE tx_type, int lossless,
@@ -379,6 +432,40 @@
     default: assert(0); break;
   }
 }
+
+#if CONFIG_TX64X64
+static void highbd_fwd_txfm_64x64(const int16_t *src_diff, tran_low_t *coeff,
+                                  int diff_stride, TX_TYPE tx_type,
+                                  FWD_TXFM_OPT fwd_txfm_opt, const int bd) {
+  (void)fwd_txfm_opt;
+  (void)bd;
+  switch (tx_type) {
+    case DCT_DCT:
+      av1_highbd_fht64x64_c(src_diff, coeff, diff_stride, tx_type);
+      break;
+#if CONFIG_EXT_TX
+    case ADST_DCT:
+    case DCT_ADST:
+    case ADST_ADST:
+    case FLIPADST_DCT:
+    case DCT_FLIPADST:
+    case FLIPADST_FLIPADST:
+    case ADST_FLIPADST:
+    case FLIPADST_ADST:
+    case V_DCT:
+    case H_DCT:
+    case V_ADST:
+    case H_ADST:
+    case V_FLIPADST:
+    case H_FLIPADST:
+      av1_highbd_fht64x64_c(src_diff, coeff, diff_stride, tx_type);
+      break;
+    case IDTX: av1_fwd_idtx_c(src_diff, coeff, diff_stride, 64, tx_type); break;
+#endif  // CONFIG_EXT_TX
+    default: assert(0); break;
+  }
+}
+#endif  // CONFIG_TX64X64
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 
 void fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, int diff_stride,
@@ -389,6 +476,11 @@
   const int rd_transform = fwd_txfm_param->rd_transform;
   const int lossless = fwd_txfm_param->lossless;
   switch (tx_size) {
+#if CONFIG_TX64X64
+    case TX_64X64:
+      fwd_txfm_64x64(src_diff, coeff, diff_stride, tx_type, fwd_txfm_opt);
+      break;
+#endif  // CONFIG_TX64X64
     case TX_32X32:
       fwd_txfm_32x32(rd_transform, src_diff, coeff, diff_stride, tx_type,
                      fwd_txfm_opt);
@@ -434,6 +526,12 @@
   const int lossless = fwd_txfm_param->lossless;
   const int bd = fwd_txfm_param->bd;
   switch (tx_size) {
+#if CONFIG_TX64X64
+    case TX_64X64:
+      highbd_fwd_txfm_64x64(src_diff, coeff, diff_stride, tx_type, fwd_txfm_opt,
+                            bd);
+      break;
+#endif  // CONFIG_TX64X64
     case TX_32X32:
       highbd_fwd_txfm_32x32(rd_transform, src_diff, coeff, diff_stride, tx_type,
                             fwd_txfm_opt, bd);
diff --git a/av1/encoder/ransac.c b/av1/encoder/ransac.c
index 714d567..2699c4f 100644
--- a/av1/encoder/ransac.c
+++ b/av1/encoder/ransac.c
@@ -81,10 +81,12 @@
                                              const int stride_points,
                                              const int stride_proj) {
   int i;
-  double x, y, Z;
+  double x, y, Z, Z_inv;
   for (i = 0; i < n; ++i) {
     x = *(points++), y = *(points++);
-    Z = 1. / (mat[7] * x + mat[6] * y + 1);
+    Z_inv = mat[7] * x + mat[6] * y + 1;
+    assert(fabs(Z_inv) > 0.00001);
+    Z = 1. / Z_inv;
     *(proj++) = (mat[1] * x + mat[0] * y + mat[3]) * Z;
     *(proj++) = (mat[2] * x + mat[4] * y + mat[4]) * Z;
     points += stride_points - 2;
@@ -155,7 +157,7 @@
   double T1[9], T2[9];
 
   *number_of_inliers = 0;
-  if (npoints < minpts * MINPTS_MULTIPLIER) {
+  if (npoints < minpts * MINPTS_MULTIPLIER || npoints == 0) {
     printf("Cannot find motion with %d matches\n", npoints);
     return 1;
   }
@@ -245,11 +247,15 @@
       }
     }
 
-    if (num_inliers >= max_inliers) {
-      double mean_distance = sum_distance / ((double)num_inliers);
-      double variance = sum_distance_squared / ((double)num_inliers - 1.0) -
-                        mean_distance * mean_distance * ((double)num_inliers) /
-                            ((double)num_inliers - 1.0);
+    if (num_inliers >= max_inliers && num_inliers > 1) {
+      int temp;
+      double fracinliers, pNoOutliers, mean_distance, variance;
+
+      assert(num_inliers > 1);
+      mean_distance = sum_distance / ((double)num_inliers);
+      variance = sum_distance_squared / ((double)num_inliers - 1.0) -
+                 mean_distance * mean_distance * ((double)num_inliers) /
+                     ((double)num_inliers - 1.0);
       if ((num_inliers > max_inliers) ||
           (num_inliers == max_inliers && variance < best_variance)) {
         best_variance = variance;
@@ -262,16 +268,15 @@
         memcpy(best_inlier_mask, inlier_mask,
                npoints * sizeof(*best_inlier_mask));
 
-        if (num_inliers > 0) {
-          double fracinliers = (double)num_inliers / (double)npoints;
-          double pNoOutliers = 1 - pow(fracinliers, minpts);
-          int temp;
-          pNoOutliers = fmax(EPS, pNoOutliers);
-          pNoOutliers = fmin(1 - EPS, pNoOutliers);
-          temp = (int)(log(1.0 - PROBABILITY_REQUIRED) / log(pNoOutliers));
-          if (temp > 0 && temp < N) {
-            N = AOMMAX(temp, MIN_TRIALS);
-          }
+        assert(npoints > 0);
+        fracinliers = (double)num_inliers / (double)npoints;
+        pNoOutliers = 1 - pow(fracinliers, minpts);
+        pNoOutliers = fmax(EPS, pNoOutliers);
+        pNoOutliers = fmin(1 - EPS, pNoOutliers);
+        assert(fabs(1.0 - pNoOutliers) > 0.00001);
+        temp = (int)(log(1.0 - PROBABILITY_REQUIRED) / log(pNoOutliers));
+        if (temp > 0 && temp < N) {
+          N = AOMMAX(temp, MIN_TRIALS);
         }
       }
     }
@@ -356,6 +361,7 @@
     // normalize so that H33 = 1
     int i;
     const double m = 1.0 / best_params[8];
+    assert(fabs(best_params[8]) > 0.00001);
     for (i = 0; i < 8; ++i) best_params[i] *= m;
     best_params[8] = 1.0;
   }
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index a3929ef..6a750d9 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2906,8 +2906,7 @@
 #if CONFIG_VAR_TX
 void av1_tx_block_rd_b(const AV1_COMP *cpi, MACROBLOCK *x, TX_SIZE tx_size,
                        int blk_row, int blk_col, int plane, int block,
-                       int plane_bsize, int coeff_ctx, int *rate, int64_t *dist,
-                       int64_t *bsse, int *skip) {
+                       int plane_bsize, int coeff_ctx, RD_STATS *rd_stats) {
   const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *xd = &x->e_mbd;
   const struct macroblock_plane *const p = &x->plane[plane];
@@ -2994,7 +2993,7 @@
   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
     tmp = ROUND_POWER_OF_TWO(tmp, (xd->bd - 8) * 2);
 #endif  // CONFIG_AOM_HIGHBITDEPTH
-  *bsse += tmp * 16;
+  rd_stats->sse += tmp * 16;
 
   if (p->eobs[block] > 0) {
     INV_TXFM_PARAM inv_txfm_param;
@@ -3035,10 +3034,10 @@
       tmp = this_dist;
     }
   }
-  *dist += tmp * 16;
-  *rate += av1_cost_coeffs(cm, x, plane, block, coeff_ctx, tx_size,
-                           scan_order->scan, scan_order->neighbors, 0);
-  *skip &= (p->eobs[block] == 0);
+  rd_stats->dist += tmp * 16;
+  rd_stats->rate += av1_cost_coeffs(cm, x, plane, block, coeff_ctx, tx_size,
+                                    scan_order->scan, scan_order->neighbors, 0);
+  rd_stats->skip &= (p->eobs[block] == 0);
 }
 
 static void select_tx_block(const AV1_COMP *cpi, MACROBLOCK *x, int blk_row,
@@ -3046,8 +3045,8 @@
                             int depth, BLOCK_SIZE plane_bsize,
                             ENTROPY_CONTEXT *ta, ENTROPY_CONTEXT *tl,
                             TXFM_CONTEXT *tx_above, TXFM_CONTEXT *tx_left,
-                            int *rate, int64_t *dist, int64_t *bsse, int *skip,
-                            int64_t ref_best_rd, int *is_cost_valid) {
+                            RD_STATS *rd_stats, int64_t ref_best_rd,
+                            int *is_cost_valid) {
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   struct macroblock_plane *const p = &x->plane[plane];
@@ -3086,10 +3085,10 @@
 
   coeff_ctx = get_entropy_context(tx_size, pta, ptl);
 
-  *rate = 0;
-  *dist = 0;
-  *bsse = 0;
-  *skip = 1;
+  rd_stats->rate = 0;
+  rd_stats->dist = 0;
+  rd_stats->sse = 0;
+  rd_stats->skip = 1;
 
   if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
 
@@ -3099,25 +3098,26 @@
   if (cpi->common.tx_mode == TX_MODE_SELECT || tx_size == TX_4X4) {
     inter_tx_size[0][0] = tx_size;
     av1_tx_block_rd_b(cpi, x, tx_size, blk_row, blk_col, plane, block,
-                      plane_bsize, coeff_ctx, rate, dist, bsse, skip);
+                      plane_bsize, coeff_ctx, rd_stats);
 
-    if ((RDCOST(x->rdmult, x->rddiv, *rate, *dist) >=
-             RDCOST(x->rdmult, x->rddiv, zero_blk_rate, *bsse) ||
-         *skip == 1) &&
+    if ((RDCOST(x->rdmult, x->rddiv, rd_stats->rate, rd_stats->dist) >=
+             RDCOST(x->rdmult, x->rddiv, zero_blk_rate, rd_stats->sse) ||
+         rd_stats->skip == 1) &&
         !xd->lossless[mbmi->segment_id]) {
-      *rate = zero_blk_rate;
-      *dist = *bsse;
-      *skip = 1;
+      rd_stats->rate = zero_blk_rate;
+      rd_stats->dist = rd_stats->sse;
+      rd_stats->skip = 1;
       x->blk_skip[plane][blk_row * bw + blk_col] = 1;
       p->eobs[block] = 0;
     } else {
       x->blk_skip[plane][blk_row * bw + blk_col] = 0;
-      *skip = 0;
+      rd_stats->skip = 0;
     }
 
     if (tx_size > TX_4X4 && depth < MAX_VARTX_DEPTH)
-      *rate += av1_cost_bit(cpi->common.fc->txfm_partition_prob[ctx], 0);
-    this_rd = RDCOST(x->rdmult, x->rddiv, *rate, *dist);
+      rd_stats->rate +=
+          av1_cost_bit(cpi->common.fc->txfm_partition_prob[ctx], 0);
+    this_rd = RDCOST(x->rdmult, x->rddiv, rd_stats->rate, rd_stats->dist);
     tmp_eob = p->eobs[block];
   }
 
@@ -3125,10 +3125,7 @@
     const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
     const int bsl = tx_size_wide_unit[sub_txs];
     int sub_step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs];
-    int this_rate;
-    int64_t this_dist;
-    int64_t this_bsse;
-    int this_skip;
+    RD_STATS this_rd_stats;
     int this_cost_valid = 1;
     int64_t tmp_rd = 0;
 
@@ -3141,12 +3138,12 @@
       int offsetc = (i & 0x01) * bsl;
       select_tx_block(cpi, x, blk_row + offsetr, blk_col + offsetc, plane,
                       block + i * sub_step, sub_txs, depth + 1, plane_bsize, ta,
-                      tl, tx_above, tx_left, &this_rate, &this_dist, &this_bsse,
-                      &this_skip, ref_best_rd - tmp_rd, &this_cost_valid);
-      sum_rate += this_rate;
-      sum_dist += this_dist;
-      sum_bsse += this_bsse;
-      all_skip &= this_skip;
+                      tl, tx_above, tx_left, &this_rd_stats,
+                      ref_best_rd - tmp_rd, &this_cost_valid);
+      sum_rate += this_rd_stats.rate;
+      sum_dist += this_rd_stats.dist;
+      sum_bsse += this_rd_stats.sse;
+      all_skip &= this_rd_stats.skip;
       tmp_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
       if (this_rd < tmp_rd) break;
     }
@@ -3165,29 +3162,29 @@
         inter_tx_size[idy][idx] = tx_size;
     mbmi->tx_size = tx_size;
     if (this_rd == INT64_MAX) *is_cost_valid = 0;
-    x->blk_skip[plane][blk_row * bw + blk_col] = *skip;
+    x->blk_skip[plane][blk_row * bw + blk_col] = rd_stats->skip;
   } else {
-    *rate = sum_rate;
-    *dist = sum_dist;
-    *bsse = sum_bsse;
-    *skip = all_skip;
+    rd_stats->rate = sum_rate;
+    rd_stats->dist = sum_dist;
+    rd_stats->sse = sum_bsse;
+    rd_stats->skip = all_skip;
     if (sum_rd == INT64_MAX) *is_cost_valid = 0;
   }
 }
 
-static void inter_block_yrd(const AV1_COMP *cpi, MACROBLOCK *x, int *rate,
-                            int64_t *distortion, int *skippable, int64_t *sse,
-                            BLOCK_SIZE bsize, int64_t ref_best_rd) {
+static void inter_block_yrd(const AV1_COMP *cpi, MACROBLOCK *x,
+                            RD_STATS *rd_stats, BLOCK_SIZE bsize,
+                            int64_t ref_best_rd) {
   MACROBLOCKD *const xd = &x->e_mbd;
   int is_cost_valid = 1;
   int64_t this_rd = 0;
 
   if (ref_best_rd < 0) is_cost_valid = 0;
 
-  *rate = 0;
-  *distortion = 0;
-  *sse = 0;
-  *skippable = 1;
+  rd_stats->rate = 0;
+  rd_stats->dist = 0;
+  rd_stats->sse = 0;
+  rd_stats->skip = 1;
 
   if (is_cost_valid) {
     const struct macroblockd_plane *const pd = &xd->plane[0];
@@ -3205,8 +3202,11 @@
     TXFM_CONTEXT tx_above[MAX_MIB_SIZE];
     TXFM_CONTEXT tx_left[MAX_MIB_SIZE];
 
-    int pnrate = 0, pnskip = 1;
-    int64_t pndist = 0, pnsse = 0;
+    RD_STATS pn_rd_stats;
+    pn_rd_stats.rate = 0;
+    pn_rd_stats.skip = 1;
+    pn_rd_stats.dist = 0;
+    pn_rd_stats.sse = 0;
 
     av1_get_entropy_contexts(bsize, TX_4X4, pd, ctxa, ctxl);
     memcpy(tx_above, xd->above_txfm_context,
@@ -3218,35 +3218,35 @@
       for (idx = 0; idx < mi_width; idx += bw) {
         select_tx_block(cpi, x, idy, idx, 0, block, max_tx_size,
                         mi_height != mi_width, plane_bsize, ctxa, ctxl,
-                        tx_above, tx_left, &pnrate, &pndist, &pnsse, &pnskip,
-                        ref_best_rd - this_rd, &is_cost_valid);
-        *rate += pnrate;
-        *distortion += pndist;
-        *sse += pnsse;
-        *skippable &= pnskip;
-        this_rd += AOMMIN(RDCOST(x->rdmult, x->rddiv, pnrate, pndist),
-                          RDCOST(x->rdmult, x->rddiv, 0, pnsse));
+                        tx_above, tx_left, &pn_rd_stats, ref_best_rd - this_rd,
+                        &is_cost_valid);
+        rd_stats->rate += pn_rd_stats.rate;
+        rd_stats->dist += pn_rd_stats.dist;
+        rd_stats->sse += pn_rd_stats.sse;
+        rd_stats->skip &= pn_rd_stats.skip;
+        this_rd += AOMMIN(
+            RDCOST(x->rdmult, x->rddiv, pn_rd_stats.rate, pn_rd_stats.dist),
+            RDCOST(x->rdmult, x->rddiv, 0, pn_rd_stats.sse));
         block += step;
       }
     }
   }
 
-  this_rd = AOMMIN(RDCOST(x->rdmult, x->rddiv, *rate, *distortion),
-                   RDCOST(x->rdmult, x->rddiv, 0, *sse));
+  this_rd = AOMMIN(RDCOST(x->rdmult, x->rddiv, rd_stats->rate, rd_stats->dist),
+                   RDCOST(x->rdmult, x->rddiv, 0, rd_stats->sse));
   if (this_rd > ref_best_rd) is_cost_valid = 0;
 
   if (!is_cost_valid) {
     // reset cost value
-    *rate = INT_MAX;
-    *distortion = INT64_MAX;
-    *sse = INT64_MAX;
-    *skippable = 0;
+    rd_stats->rate = INT_MAX;
+    rd_stats->dist = INT64_MAX;
+    rd_stats->sse = INT64_MAX;
+    rd_stats->skip = 0;
   }
 }
 
 static int64_t select_tx_size_fix_type(const AV1_COMP *cpi, MACROBLOCK *x,
-                                       int *rate, int64_t *dist, int *skippable,
-                                       int64_t *sse, BLOCK_SIZE bsize,
+                                       RD_STATS *rd_stats, BLOCK_SIZE bsize,
                                        int64_t ref_best_rd, TX_TYPE tx_type) {
   const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
@@ -3258,55 +3258,52 @@
   int64_t rd;
 
   mbmi->tx_type = tx_type;
-  inter_block_yrd(cpi, x, rate, dist, skippable, sse, bsize, ref_best_rd);
+  inter_block_yrd(cpi, x, rd_stats, bsize, ref_best_rd);
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
   if (is_rect_tx_allowed(xd, mbmi)) {
-    int rate_rect_tx, skippable_rect_tx = 0;
-    int64_t dist_rect_tx, sse_rect_tx, rd_rect_tx;
+    RD_STATS rect_rd_stats;
+    int64_t rd_rect_tx;
     int tx_size_cat = inter_tx_size_cat_lookup[bsize];
     TX_SIZE tx_size = max_txsize_rect_lookup[bsize];
     TX_SIZE var_tx_size = mbmi->tx_size;
 
-    txfm_rd_in_plane(x, cpi, &rate_rect_tx, &dist_rect_tx, &skippable_rect_tx,
-                     &sse_rect_tx, ref_best_rd, 0, bsize, tx_size,
-                     cpi->sf.use_fast_coef_costing);
+    txfm_rd_in_plane(x, cpi, &rect_rd_stats.rate, &rect_rd_stats.dist,
+                     &rect_rd_stats.skip, &rect_rd_stats.sse, ref_best_rd, 0,
+                     bsize, tx_size, cpi->sf.use_fast_coef_costing);
 
-    if (*rate != INT_MAX) {
-      *rate += av1_cost_bit(cm->fc->rect_tx_prob[tx_size_cat], 0);
-      if (*skippable) {
-        rd = RDCOST(x->rdmult, x->rddiv, s1, *sse);
+    if (rd_stats->rate != INT_MAX) {
+      rd_stats->rate += av1_cost_bit(cm->fc->rect_tx_prob[tx_size_cat], 0);
+      if (rd_stats->skip) {
+        rd = RDCOST(x->rdmult, x->rddiv, s1, rd_stats->sse);
       } else {
-        rd = RDCOST(x->rdmult, x->rddiv, *rate + s0, *dist);
+        rd = RDCOST(x->rdmult, x->rddiv, rd_stats->rate + s0, rd_stats->dist);
         if (is_inter && !xd->lossless[xd->mi[0]->mbmi.segment_id] &&
-            !(*skippable))
-          rd = AOMMIN(rd, RDCOST(x->rdmult, x->rddiv, s1, *sse));
+            !rd_stats->skip)
+          rd = AOMMIN(rd, RDCOST(x->rdmult, x->rddiv, s1, rd_stats->sse));
       }
     } else {
       rd = INT64_MAX;
     }
 
-    if (rate_rect_tx != INT_MAX) {
-      rate_rect_tx += av1_cost_bit(cm->fc->rect_tx_prob[tx_size_cat], 1);
-      if (skippable_rect_tx) {
-        rd_rect_tx = RDCOST(x->rdmult, x->rddiv, s1, sse_rect_tx);
+    if (rect_rd_stats.rate != INT_MAX) {
+      rect_rd_stats.rate += av1_cost_bit(cm->fc->rect_tx_prob[tx_size_cat], 1);
+      if (rect_rd_stats.skip) {
+        rd_rect_tx = RDCOST(x->rdmult, x->rddiv, s1, rect_rd_stats.sse);
       } else {
-        rd_rect_tx =
-            RDCOST(x->rdmult, x->rddiv, rate_rect_tx + s0, dist_rect_tx);
+        rd_rect_tx = RDCOST(x->rdmult, x->rddiv, rect_rd_stats.rate + s0,
+                            rect_rd_stats.dist);
         if (is_inter && !xd->lossless[xd->mi[0]->mbmi.segment_id] &&
-            !(skippable_rect_tx))
-          rd_rect_tx =
-              AOMMIN(rd_rect_tx, RDCOST(x->rdmult, x->rddiv, s1, sse_rect_tx));
+            !(rect_rd_stats.skip))
+          rd_rect_tx = AOMMIN(
+              rd_rect_tx, RDCOST(x->rdmult, x->rddiv, s1, rect_rd_stats.sse));
       }
     } else {
       rd_rect_tx = INT64_MAX;
     }
 
     if (rd_rect_tx < rd) {
-      *rate = rate_rect_tx;
-      *dist = dist_rect_tx;
-      *sse = sse_rect_tx;
-      *skippable = skippable_rect_tx;
-      if (!xd->lossless[mbmi->segment_id]) x->blk_skip[0][0] = *skippable;
+      *rd_stats = rect_rd_stats;
+      if (!xd->lossless[mbmi->segment_id]) x->blk_skip[0][0] = rd_stats->skip;
       mbmi->tx_size = tx_size;
       mbmi->inter_tx_size[0][0] = mbmi->tx_size;
     } else {
@@ -3315,7 +3312,7 @@
   }
 #endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
 
-  if (*rate == INT_MAX) return INT64_MAX;
+  if (rd_stats->rate == INT_MAX) return INT64_MAX;
 
 #if CONFIG_EXT_TX
   if (get_ext_tx_types(mbmi->tx_size, bsize, is_inter) > 1 &&
@@ -3323,41 +3320,41 @@
     int ext_tx_set = get_ext_tx_set(mbmi->tx_size, bsize, is_inter);
     if (is_inter) {
       if (ext_tx_set > 0)
-        *rate +=
+        rd_stats->rate +=
             cpi->inter_tx_type_costs[ext_tx_set][txsize_sqr_map[mbmi->tx_size]]
                                     [mbmi->tx_type];
     } else {
       if (ext_tx_set > 0 && ALLOW_INTRA_EXT_TX)
-        *rate += cpi->intra_tx_type_costs[ext_tx_set][mbmi->tx_size][mbmi->mode]
-                                         [mbmi->tx_type];
+        rd_stats->rate += cpi->intra_tx_type_costs[ext_tx_set][mbmi->tx_size]
+                                                  [mbmi->mode][mbmi->tx_type];
     }
   }
 #else   // CONFIG_EXT_TX
   if (mbmi->tx_size < TX_32X32 && !xd->lossless[xd->mi[0]->mbmi.segment_id]) {
     if (is_inter)
-      *rate += cpi->inter_tx_type_costs[mbmi->tx_size][mbmi->tx_type];
+      rd_stats->rate += cpi->inter_tx_type_costs[mbmi->tx_size][mbmi->tx_type];
     else
-      *rate +=
+      rd_stats->rate +=
           cpi->intra_tx_type_costs[mbmi->tx_size]
                                   [intra_mode_to_tx_type_context[mbmi->mode]]
                                   [mbmi->tx_type];
   }
 #endif  // CONFIG_EXT_TX
 
-  if (*skippable)
-    rd = RDCOST(x->rdmult, x->rddiv, s1, *sse);
+  if (rd_stats->skip)
+    rd = RDCOST(x->rdmult, x->rddiv, s1, rd_stats->sse);
   else
-    rd = RDCOST(x->rdmult, x->rddiv, *rate + s0, *dist);
+    rd = RDCOST(x->rdmult, x->rddiv, rd_stats->rate + s0, rd_stats->dist);
 
-  if (is_inter && !xd->lossless[xd->mi[0]->mbmi.segment_id] && !(*skippable))
-    rd = AOMMIN(rd, RDCOST(x->rdmult, x->rddiv, s1, *sse));
+  if (is_inter && !xd->lossless[xd->mi[0]->mbmi.segment_id] &&
+      !(rd_stats->skip))
+    rd = AOMMIN(rd, RDCOST(x->rdmult, x->rddiv, s1, rd_stats->sse));
 
   return rd;
 }
 
-static void select_tx_type_yrd(const AV1_COMP *cpi, MACROBLOCK *x, int *rate,
-                               int64_t *distortion, int *skippable,
-                               int64_t *sse, BLOCK_SIZE bsize,
+static void select_tx_type_yrd(const AV1_COMP *cpi, MACROBLOCK *x,
+                               RD_STATS *rd_stats, BLOCK_SIZE bsize,
                                int64_t ref_best_rd) {
   const TX_SIZE max_tx_size = max_txsize_lookup[bsize];
   MACROBLOCKD *const xd = &x->e_mbd;
@@ -3383,16 +3380,17 @@
     prune = prune_tx_types(cpi, bsize, x, xd, 0);
 #endif
 
-  *distortion = INT64_MAX;
-  *rate = INT_MAX;
-  *skippable = 0;
-  *sse = INT64_MAX;
+  rd_stats->dist = INT64_MAX;
+  rd_stats->rate = INT_MAX;
+  rd_stats->skip = 0;
+  rd_stats->sse = INT64_MAX;
 
   for (tx_type = DCT_DCT; tx_type < TX_TYPES; ++tx_type) {
-    int this_rate = 0;
-    int this_skip = 1;
-    int64_t this_dist = 0;
-    int64_t this_sse = 0;
+    RD_STATS this_rd_stats;
+    this_rd_stats.rate = 0;
+    this_rd_stats.skip = 1;
+    this_rd_stats.dist = 0;
+    this_rd_stats.sse = 0;
 #if CONFIG_EXT_TX
     if (is_inter) {
       if (!ext_tx_used_inter[ext_tx_set][tx_type]) continue;
@@ -3415,15 +3413,12 @@
         tx_type != get_default_tx_type(0, xd, 0, max_tx_size))
       continue;
 
-    rd = select_tx_size_fix_type(cpi, x, &this_rate, &this_dist, &this_skip,
-                                 &this_sse, bsize, ref_best_rd, tx_type);
+    rd = select_tx_size_fix_type(cpi, x, &this_rd_stats, bsize, ref_best_rd,
+                                 tx_type);
 
     if (rd < best_rd) {
       best_rd = rd;
-      *distortion = this_dist;
-      *rate = this_rate;
-      *skippable = this_skip;
-      *sse = this_sse;
+      *rd_stats = this_rd_stats;
       best_tx_type = mbmi->tx_type;
       best_tx = mbmi->tx_size;
       memcpy(best_blk_skip, x->blk_skip[0], sizeof(best_blk_skip[0]) * n4);
@@ -3444,8 +3439,7 @@
 static void tx_block_rd(const AV1_COMP *cpi, MACROBLOCK *x, int blk_row,
                         int blk_col, int plane, int block, TX_SIZE tx_size,
                         BLOCK_SIZE plane_bsize, ENTROPY_CONTEXT *above_ctx,
-                        ENTROPY_CONTEXT *left_ctx, int *rate, int64_t *dist,
-                        int64_t *bsse, int *skip) {
+                        ENTROPY_CONTEXT *left_ctx, RD_STATS *rd_stats) {
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   struct macroblock_plane *const p = &x->plane[plane];
@@ -3473,7 +3467,7 @@
     ENTROPY_CONTEXT *tl = left_ctx + blk_row;
     coeff_ctx = get_entropy_context(tx_size, ta, tl);
     av1_tx_block_rd_b(cpi, x, tx_size, blk_row, blk_col, plane, block,
-                      plane_bsize, coeff_ctx, rate, dist, bsse, skip);
+                      plane_bsize, coeff_ctx, rd_stats);
 
     for (i = 0; i < tx_size_wide_unit[tx_size]; ++i)
       ta[i] = !(p->eobs[block] == 0);
@@ -3492,16 +3486,16 @@
       int offsetc = (i & 0x01) * bsl;
       tx_block_rd(cpi, x, blk_row + offsetr, blk_col + offsetc, plane,
                   block + i * step, sub_txs, plane_bsize, above_ctx, left_ctx,
-                  rate, dist, bsse, skip);
+                  rd_stats);
     }
   }
 }
 
 // Return value 0: early termination triggered, no valid rd cost available;
 //              1: rd cost values are valid.
-static int inter_block_uvrd(const AV1_COMP *cpi, MACROBLOCK *x, int *rate,
-                            int64_t *distortion, int *skippable, int64_t *sse,
-                            BLOCK_SIZE bsize, int64_t ref_best_rd) {
+static int inter_block_uvrd(const AV1_COMP *cpi, MACROBLOCK *x,
+                            RD_STATS *rd_stats, BLOCK_SIZE bsize,
+                            int64_t ref_best_rd) {
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   int plane;
@@ -3510,14 +3504,15 @@
 
   if (ref_best_rd < 0) is_cost_valid = 0;
 
-  *rate = 0;
-  *distortion = 0;
-  *sse = 0;
-  *skippable = 1;
+  rd_stats->rate = 0;
+  rd_stats->dist = 0;
+  rd_stats->sse = 0;
+  rd_stats->skip = 1;
 
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
   if (is_rect_tx(mbmi->tx_size)) {
-    return super_block_uvrd(cpi, x, rate, distortion, skippable, sse, bsize,
+    return super_block_uvrd(cpi, x, &rd_stats->rate, &rd_stats->dist,
+                            &rd_stats->skip, &rd_stats->sse, bsize,
                             ref_best_rd);
   }
 #endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -3538,33 +3533,37 @@
     int idx, idy;
     int block = 0;
     const int step = bh * bw;
-    int pnrate = 0, pnskip = 1;
-    int64_t pndist = 0, pnsse = 0;
     ENTROPY_CONTEXT ta[2 * MAX_MIB_SIZE];
     ENTROPY_CONTEXT tl[2 * MAX_MIB_SIZE];
+    RD_STATS pn_rd_stats;
+    pn_rd_stats.rate = 0;
+    pn_rd_stats.skip = 1;
+    pn_rd_stats.dist = 0;
+    pn_rd_stats.sse = 0;
 
     av1_get_entropy_contexts(bsize, TX_4X4, pd, ta, tl);
 
     for (idy = 0; idy < mi_height; idy += bh) {
       for (idx = 0; idx < mi_width; idx += bw) {
         tx_block_rd(cpi, x, idy, idx, plane, block, max_tx_size, plane_bsize,
-                    ta, tl, &pnrate, &pndist, &pnsse, &pnskip);
+                    ta, tl, &pn_rd_stats);
         block += step;
       }
     }
 
-    if (pnrate == INT_MAX) {
+    if (pn_rd_stats.rate == INT_MAX) {
       is_cost_valid = 0;
       break;
     }
 
-    *rate += pnrate;
-    *distortion += pndist;
-    *sse += pnsse;
-    *skippable &= pnskip;
+    rd_stats->rate += pn_rd_stats.rate;
+    rd_stats->dist += pn_rd_stats.dist;
+    rd_stats->sse += pn_rd_stats.sse;
+    rd_stats->skip &= pn_rd_stats.skip;
 
-    this_rd = AOMMIN(RDCOST(x->rdmult, x->rddiv, *rate, *distortion),
-                     RDCOST(x->rdmult, x->rddiv, 0, *sse));
+    this_rd =
+        AOMMIN(RDCOST(x->rdmult, x->rddiv, rd_stats->rate, rd_stats->dist),
+               RDCOST(x->rdmult, x->rddiv, 0, rd_stats->sse));
 
     if (this_rd > ref_best_rd) {
       is_cost_valid = 0;
@@ -3574,10 +3573,10 @@
 
   if (!is_cost_valid) {
     // reset cost value
-    *rate = INT_MAX;
-    *distortion = INT64_MAX;
-    *sse = INT64_MAX;
-    *skippable = 0;
+    rd_stats->rate = INT_MAX;
+    rd_stats->dist = INT64_MAX;
+    rd_stats->sse = INT64_MAX;
+    rd_stats->skip = 0;
   }
 
   return is_cost_valid;
@@ -7493,13 +7492,21 @@
       int skippable_y, skippable_uv;
       int64_t sseuv = INT64_MAX;
       int64_t rdcosty = INT64_MAX;
+      int is_cost_valid_uv = 0;
+#if CONFIG_VAR_TX
+      RD_STATS rd_stats_uv;
+#endif
 
       // Y cost and distortion
       av1_subtract_plane(x, bsize, 0);
 #if CONFIG_VAR_TX
       if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
-        select_tx_type_yrd(cpi, x, rate_y, &distortion_y, &skippable_y, psse,
-                           bsize, ref_best_rd);
+        RD_STATS rd_stats_y;
+        select_tx_type_yrd(cpi, x, &rd_stats_y, bsize, ref_best_rd);
+        *rate_y = rd_stats_y.rate;
+        distortion_y = rd_stats_y.dist;
+        skippable_y = rd_stats_y.skip;
+        *psse = rd_stats_y.sse;
       } else {
         int idx, idy;
         super_block_yrd(cpi, x, rate_y, &distortion_y, &skippable_y, psse,
@@ -7537,20 +7544,25 @@
       rdcosty = AOMMIN(rdcosty, RDCOST(x->rdmult, x->rddiv, 0, *psse));
 
 #if CONFIG_VAR_TX
-      if (!inter_block_uvrd(cpi, x, rate_uv, &distortion_uv, &skippable_uv,
-                            &sseuv, bsize, ref_best_rd - rdcosty))
+      is_cost_valid_uv =
+          inter_block_uvrd(cpi, x, &rd_stats_uv, bsize, ref_best_rd - rdcosty);
+      *rate_uv = rd_stats_uv.rate;
+      distortion_uv = rd_stats_uv.dist;
+      skippable_uv = rd_stats_uv.skip;
+      sseuv = rd_stats_uv.sse;
 #else
-    if (!super_block_uvrd(cpi, x, rate_uv, &distortion_uv, &skippable_uv,
-                          &sseuv, bsize, ref_best_rd - rdcosty))
+      is_cost_valid_uv =
+          super_block_uvrd(cpi, x, rate_uv, &distortion_uv, &skippable_uv,
+                           &sseuv, bsize, ref_best_rd - rdcosty);
 #endif  // CONFIG_VAR_TX
-      {
+      if (!is_cost_valid_uv) {
         *rate2 = INT_MAX;
         *distortion = INT64_MAX;
 #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
         continue;
 #else
-      restore_dst_buf(xd, orig_dst, orig_dst_stride);
-      return INT64_MAX;
+        restore_dst_buf(xd, orig_dst, orig_dst_stride);
+        return INT64_MAX;
 #endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
       }
 
@@ -9201,6 +9213,9 @@
     }
 
     if (is_inter_mode(mbmi->mode)) {
+#if CONFIG_VAR_TX
+      RD_STATS rd_stats_uv;
+#endif
       av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
 #if CONFIG_MOTION_VAR
       if (mbmi->motion_mode == OBMC_CAUSAL)
@@ -9210,8 +9225,12 @@
       av1_subtract_plane(x, bsize, 0);
 #if CONFIG_VAR_TX
       if (cm->tx_mode == TX_MODE_SELECT || xd->lossless[mbmi->segment_id]) {
-        select_tx_type_yrd(cpi, x, &rate_y, &dist_y, &skip_y, &sse_y, bsize,
-                           INT64_MAX);
+        RD_STATS rd_stats_y;
+        select_tx_type_yrd(cpi, x, &rd_stats_y, bsize, INT64_MAX);
+        rate_y = rd_stats_y.rate;
+        dist_y = rd_stats_y.dist;
+        sse_y = rd_stats_y.sse;
+        skip_y = rd_stats_y.skip;
       } else {
         int idx, idy;
         super_block_yrd(cpi, x, &rate_y, &dist_y, &skip_y, &sse_y, bsize,
@@ -9223,8 +9242,11 @@
                sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
       }
 
-      inter_block_uvrd(cpi, x, &rate_uv, &dist_uv, &skip_uv, &sse_uv, bsize,
-                       INT64_MAX);
+      inter_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
+      rate_uv = rd_stats_uv.rate;
+      dist_uv = rd_stats_uv.dist;
+      skip_uv = rd_stats_uv.skip;
+      sse_uv = rd_stats_uv.sse;
 #else
       super_block_yrd(cpi, x, &rate_y, &dist_y, &skip_y, &sse_y, bsize,
                       INT64_MAX);
@@ -9424,7 +9446,10 @@
 #endif  // CONFIG_REF_MV
 #if CONFIG_GLOBAL_MOTION
     zeromv[0].as_int = cm->global_motion[refs[0]].motion_params.wmmat[0].as_int;
-    zeromv[1].as_int = cm->global_motion[refs[1]].motion_params.wmmat[0].as_int;
+    if (comp_pred_mode) {
+      zeromv[1].as_int =
+          cm->global_motion[refs[1]].motion_params.wmmat[0].as_int;
+    }
 #else
     zeromv[0].as_int = 0;
     zeromv[1].as_int = 0;
@@ -10354,16 +10379,24 @@
       if (tmp_best_rdu > 0) {
         // If even the 'Y' rd value of split is higher than best so far
         // then dont bother looking at UV
+        int is_cost_valid_uv;
+#if CONFIG_VAR_TX
+        RD_STATS rd_stats_uv;
+#endif
         av1_build_inter_predictors_sbuv(&x->e_mbd, mi_row, mi_col, BLOCK_8X8);
 #if CONFIG_VAR_TX
-        if (!inter_block_uvrd(cpi, x, &rate_uv, &distortion_uv, &uv_skippable,
-                              &uv_sse, BLOCK_8X8, tmp_best_rdu))
-          continue;
+        is_cost_valid_uv =
+            inter_block_uvrd(cpi, x, &rd_stats_uv, BLOCK_8X8, tmp_best_rdu);
+        rate_uv = rd_stats_uv.rate;
+        distortion_uv = rd_stats_uv.dist;
+        uv_skippable = rd_stats_uv.skip;
+        uv_sse = rd_stats_uv.sse;
 #else
-        if (!super_block_uvrd(cpi, x, &rate_uv, &distortion_uv, &uv_skippable,
-                              &uv_sse, BLOCK_8X8, tmp_best_rdu))
-          continue;
+        is_cost_valid_uv =
+            super_block_uvrd(cpi, x, &rate_uv, &distortion_uv, &uv_skippable,
+                             &uv_sse, BLOCK_8X8, tmp_best_rdu);
 #endif
+        if (!is_cost_valid_uv) continue;
         rate2 += rate_uv;
         distortion2 += distortion_uv;
         skippable = skippable && uv_skippable;
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 5d9fc12..8c65770 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -26,6 +26,16 @@
 struct macroblock;
 struct RD_COST;
 
+#if CONFIG_VAR_TX
+// TODO(angiebird): Merge RD_COST and RD_STATS
+typedef struct RD_STATS {
+  int rate;
+  int64_t dist;
+  int64_t sse;
+  int skip;
+} RD_STATS;
+#endif
+
 int av1_cost_coeffs(const AV1_COMMON *const cm, MACROBLOCK *x, int plane,
                     int block, int coeff_ctx, TX_SIZE tx_size,
                     const int16_t *scan, const int16_t *nb,
@@ -77,8 +87,7 @@
 #if CONFIG_VAR_TX
 void av1_tx_block_rd_b(const AV1_COMP *cpi, MACROBLOCK *x, TX_SIZE tx_size,
                        int blk_row, int blk_col, int plane, int block,
-                       int plane_bsize, int coeff_ctx, int *rate, int64_t *dist,
-                       int64_t *bsse, int *skip);
+                       int plane_bsize, int coeff_ctx, RD_STATS *rd_stats);
 #endif
 
 void av1_txfm_rd_in_plane_supertx(MACROBLOCK *x, const AV1_COMP *cpi, int *rate,