Rename TM_PRED --> PAETH_PRED.

Change-Id: Ic4e04ef959e10b60dae6de8d6da50e7a281e654c
diff --git a/aom_dsp/x86/intrapred_avx2.c b/aom_dsp/x86/intrapred_avx2.c
index 6b8922b..a6cc528 100644
--- a/aom_dsp/x86/intrapred_avx2.c
+++ b/aom_dsp/x86/intrapred_avx2.c
@@ -219,7 +219,7 @@
 }
 
 // -----------------------------------------------------------------------------
-// TM_PRED
+// PAETH_PRED
 
 // Return 16 16-bit pixels in one row (__m256i)
 static INLINE __m256i paeth_pred(const __m256i *left, const __m256i *top,
diff --git a/aom_dsp/x86/intrapred_ssse3.c b/aom_dsp/x86/intrapred_ssse3.c
index 85b8274..99ea23e 100644
--- a/aom_dsp/x86/intrapred_ssse3.c
+++ b/aom_dsp/x86/intrapred_ssse3.c
@@ -15,7 +15,7 @@
 #include "aom_dsp/intrapred_common.h"
 
 // -----------------------------------------------------------------------------
-// TM_PRED
+// PAETH_PRED
 
 // Return 8 16-bit pixels in one row
 static INLINE __m128i paeth_8x1_pred(const __m128i *left, const __m128i *top,
diff --git a/av1/common/av1_rtcd_defs.pl b/av1/common/av1_rtcd_defs.pl
index 203426e..12a9072 100755
--- a/av1/common/av1_rtcd_defs.pl
+++ b/av1/common/av1_rtcd_defs.pl
@@ -191,7 +191,7 @@
   add_proto qw/void av1_d153_filter_predictor/, "uint8_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint8_t *above, const uint8_t *left";
   add_proto qw/void av1_d207_filter_predictor/, "uint8_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint8_t *above, const uint8_t *left";
   add_proto qw/void av1_d63_filter_predictor/, "uint8_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint8_t *above, const uint8_t *left";
-  add_proto qw/void av1_tm_filter_predictor/, "uint8_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint8_t *above, const uint8_t *left";
+  add_proto qw/void av1_paeth_filter_predictor/, "uint8_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint8_t *above, const uint8_t *left";
   # High bitdepth functions
   if (aom_config("CONFIG_HIGHBITDEPTH") eq "yes") {
     add_proto qw/void av1_highbd_dc_filter_predictor/, "uint16_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint16_t *above, const uint16_t *left, int bd";
@@ -203,7 +203,7 @@
     add_proto qw/void av1_highbd_d153_filter_predictor/, "uint16_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint16_t *above, const uint16_t *left, int bd";
     add_proto qw/void av1_highbd_d207_filter_predictor/, "uint16_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint16_t *above, const uint16_t *left, int bd";
     add_proto qw/void av1_highbd_d63_filter_predictor/, "uint16_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint16_t *above, const uint16_t *left, int bd";
-    add_proto qw/void av1_highbd_tm_filter_predictor/, "uint16_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint16_t *above, const uint16_t *left, int bd";
+    add_proto qw/void av1_highbd_paeth_filter_predictor/, "uint16_t *dst, ptrdiff_t stride, TX_SIZE tx_size, const uint16_t *above, const uint16_t *left, int bd";
   }
 }
 
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 01a449a..b1ea9ad 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -160,7 +160,7 @@
     MB_MODE_COUNT,  // SMOOTH_V_PRED
     MB_MODE_COUNT,  // SMOOTH_H_PRED
 #endif              // CONFIG_SMOOTH_HV
-    MB_MODE_COUNT,  // TM_PRED
+    MB_MODE_COUNT,  // PAETH_PRED
     MB_MODE_COUNT,  // NEARESTMV
     MB_MODE_COUNT,  // NEARMV
     MB_MODE_COUNT,  // ZEROMV
@@ -206,7 +206,7 @@
     MB_MODE_COUNT,  // SMOOTH_V_PRED
     MB_MODE_COUNT,  // SMOOTH_H_PRED
 #endif              // CONFIG_SMOOTH_HV
-    MB_MODE_COUNT,  // TM_PRED
+    MB_MODE_COUNT,  // PAETH_PRED
     MB_MODE_COUNT,  // NEARESTMV
     MB_MODE_COUNT,  // NEARMV
     MB_MODE_COUNT,  // ZEROMV
@@ -511,7 +511,7 @@
     SMOOTH_V_PRED,  // UV_SMOOTH_V_PRED
     SMOOTH_H_PRED,  // UV_SMOOTH_H_PRED
 #endif              // CONFIG_SMOOTH_HV
-    TM_PRED,        // UV_TM_PRED
+    PAETH_PRED,     // UV_PAETH_PRED
     DC_PRED,        // CFL_PRED
   };
   return uv2y[mode];
@@ -878,7 +878,7 @@
   ADST_DCT,   // SMOOTH_V
   DCT_ADST,   // SMOOTH_H
 #endif        // CONFIG_SMOOTH_HV
-  ADST_ADST,  // TM
+  ADST_ADST,  // PAETH
 };
 
 #if CONFIG_SUPERTX
@@ -1080,7 +1080,7 @@
       return tx_size_high[tx_size] <= 8;
     case DC_PRED:
     case SMOOTH_PRED: return 0;
-    case TM_PRED:
+    case PAETH_PRED:
     default: return tx_size_wide[tx_size] <= 8 || tx_size_high[tx_size] <= 8;
   }
 }
diff --git a/av1/common/enums.h b/av1/common/enums.h
index d04914e..6f3fdd2 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -498,7 +498,7 @@
   SMOOTH_V_PRED,  // Vertical interpolation
   SMOOTH_H_PRED,  // Horizontal interpolation
 #endif            // CONFIG_SMOOTH_HV
-  TM_PRED,        // True-motion
+  PAETH_PRED,     // Predict from the direction of smallest gradient
   NEARESTMV,
   NEARMV,
   ZEROMV,
@@ -521,7 +521,7 @@
   ZERO_ZEROMV,
   NEW_NEWMV,
   MB_MODE_COUNT,
-  INTRA_MODES = TM_PRED + 1,     // TM_PRED has to be the last intra mode.
+  INTRA_MODES = PAETH_PRED + 1,  // PAETH_PRED has to be the last intra mode.
   INTRA_INVALID = MB_MODE_COUNT  // For uv_mode in inter blocks
 } PREDICTION_MODE;
 
@@ -543,7 +543,7 @@
   UV_SMOOTH_V_PRED,  // Vertical interpolation
   UV_SMOOTH_H_PRED,  // Horizontal interpolation
 #endif               // CONFIG_SMOOTH_HV
-  UV_TM_PRED,        // True-motion
+  UV_PAETH_PRED,     // Predict from the direction of smallest gradient
   UV_CFL_PRED,       // Chroma-from-Luma
   UV_INTRA_MODES,
   UV_MODE_INVALID,  // For uv_mode in inter blocks
@@ -606,7 +606,7 @@
   FILTER_D153_PRED,
   FILTER_D207_PRED,
   FILTER_D63_PRED,
-  FILTER_TM_PRED,
+  FILTER_PAETH_PRED,
   FILTER_INTRA_MODES,
 } FILTER_INTRA_MODE;
 #endif  // CONFIG_FILTER_INTRA
diff --git a/av1/common/idct.c b/av1/common/idct.c
index 53c2ba1..0c79b45 100644
--- a/av1/common/idct.c
+++ b/av1/common/idct.c
@@ -352,7 +352,7 @@
     case SMOOTH_PRED:
       // predition is good for both directions: large SLs for row and col
       return 3;
-    case TM_PRED: return 0;
+    case PAETH_PRED: return 0;
 #if CONFIG_SMOOTH_HV
     case SMOOTH_H_PRED:
 #endif
@@ -422,8 +422,8 @@
     // typically yields very smooth residues so having the break point
     // does not usually improve the RD result.
     return;
-  } else if (mode == TM_PRED) {
-    // TM_PRED: use both 1D top boundary and 1D left boundary
+  } else if (mode == PAETH_PRED) {
+    // PAETH_PRED: use both 1D top boundary and 1D left boundary
     if (is_col)
       for (int i = 0; i < 4; ++i) arr[i] = dst[i * stride];
     else
@@ -455,7 +455,7 @@
   } else if (mode == D135_PRED || mode == D153_PRED || mode == D207_PRED) {
     // directional modes closer to horizontal
     if (is_col) get_discontinuity_2d(dst, stride, 4, 1, &bp, ntx);
-  } else if (mode > TM_PRED) {
+  } else if (mode > PAETH_PRED) {
     // inter
     get_discontinuity_2d(dst, stride, 4, is_col, &bp, ntx);
   }
@@ -495,7 +495,7 @@
 
   if (mode == DC_PRED || mode == SMOOTH_PRED) {
     return;
-  } else if (mode == TM_PRED) {
+  } else if (mode == PAETH_PRED) {
     if (is_col)
       for (int i = 0; i < 8; ++i) arr[i] = dst[i * stride];
     else
@@ -523,7 +523,7 @@
     if (!is_col) get_discontinuity_2d(dst, stride, 8, 0, &bp, ntx);
   } else if (mode == D135_PRED || mode == D153_PRED || mode == D207_PRED) {
     if (is_col) get_discontinuity_2d(dst, stride, 8, 1, &bp, ntx);
-  } else if (mode > TM_PRED) {
+  } else if (mode > PAETH_PRED) {
     get_discontinuity_2d(dst, stride, 8, is_col, &bp, ntx);
   }
 
@@ -551,7 +551,7 @@
 
   switch (mode) {
     case DC_PRED:
-    case TM_PRED:
+    case PAETH_PRED:
     case SMOOTH_PRED:
       // prediction from both top and left -> ADST
       lgtmtx[0] = adstmtx;
diff --git a/av1/common/mvref_common.h b/av1/common/mvref_common.h
index 348887e..67ea981 100644
--- a/av1/common/mvref_common.h
+++ b/av1/common/mvref_common.h
@@ -58,7 +58,7 @@
   9,    // SMOOTH_V_PRED
   9,    // SMOOTH_H_PRED
 #endif  // CONFIG_SMOOTH_HV
-  9,    // TM_PRED
+  9,    // PAETH_PRED
   0,    // NEARESTMV
   0,    // NEARMV
   3,    // ZEROMV
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index c6d57b7..382d8de 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -63,7 +63,7 @@
   NEED_LEFT | NEED_ABOVE,                   // SMOOTH_V
   NEED_LEFT | NEED_ABOVE,                   // SMOOTH_H
 #endif                                      // CONFIG_SMOOTH_HV
-  NEED_LEFT | NEED_ABOVE | NEED_ABOVELEFT,  // TM
+  NEED_LEFT | NEED_ABOVE | NEED_ABOVELEFT,  // PAETH
 };
 
 static const uint16_t orders_128x128[1] = { 0 };
@@ -727,7 +727,7 @@
   INIT_ALL_SIZES(pred[D135_PRED], d135);
   INIT_ALL_SIZES(pred[D153_PRED], d153);
 
-  INIT_ALL_SIZES(pred[TM_PRED], paeth);
+  INIT_ALL_SIZES(pred[PAETH_PRED], paeth);
   INIT_ALL_SIZES(pred[SMOOTH_PRED], smooth);
 #if CONFIG_SMOOTH_HV
   INIT_ALL_SIZES(pred[SMOOTH_V_PRED], smooth_v);
@@ -749,7 +749,7 @@
   INIT_ALL_SIZES(pred_high[D135_PRED], highbd_d135);
   INIT_ALL_SIZES(pred_high[D153_PRED], highbd_d153);
 
-  INIT_ALL_SIZES(pred_high[TM_PRED], highbd_paeth);
+  INIT_ALL_SIZES(pred_high[PAETH_PRED], highbd_paeth);
   INIT_ALL_SIZES(pred_high[SMOOTH_PRED], highbd_smooth);
 #if CONFIG_SMOOTH_HV
   INIT_ALL_SIZES(pred_high[SMOOTH_V_PRED], highbd_smooth_v);
@@ -1867,14 +1867,15 @@
 #endif
 }
 
-void av1_tm_filter_predictor_c(uint8_t *dst, ptrdiff_t stride, TX_SIZE tx_size,
-                               const uint8_t *above, const uint8_t *left) {
+void av1_paeth_filter_predictor_c(uint8_t *dst, ptrdiff_t stride,
+                                  TX_SIZE tx_size, const uint8_t *above,
+                                  const uint8_t *left) {
 #if USE_3TAP_INTRA_FILTER
   filter_intra_predictors_3tap(dst, stride, tx_size, above, left,
-                               FILTER_TM_PRED);
+                               FILTER_PAETH_PRED);
 #else
   filter_intra_predictors_4tap(dst, stride, tx_size, above, left,
-                               FILTER_TM_PRED);
+                               FILTER_PAETH_PRED);
 #endif
 }
 
@@ -1909,8 +1910,8 @@
     case FILTER_D63_PRED:
       av1_d63_filter_predictor(dst, stride, tx_size, above, left);
       break;
-    case FILTER_TM_PRED:
-      av1_tm_filter_predictor(dst, stride, tx_size, above, left);
+    case FILTER_PAETH_PRED:
+      av1_paeth_filter_predictor(dst, stride, tx_size, above, left);
       break;
     default: assert(0);
   }
@@ -2121,15 +2122,15 @@
 #endif
 }
 
-void av1_highbd_tm_filter_predictor_c(uint16_t *dst, ptrdiff_t stride,
-                                      TX_SIZE tx_size, const uint16_t *above,
-                                      const uint16_t *left, int bd) {
+void av1_highbd_paeth_filter_predictor_c(uint16_t *dst, ptrdiff_t stride,
+                                         TX_SIZE tx_size, const uint16_t *above,
+                                         const uint16_t *left, int bd) {
 #if USE_3TAP_INTRA_FILTER
   highbd_filter_intra_predictors_3tap(dst, stride, tx_size, above, left,
-                                      FILTER_TM_PRED, bd);
+                                      FILTER_PAETH_PRED, bd);
 #else
   highbd_filter_intra_predictors_4tap(dst, stride, tx_size, above, left,
-                                      FILTER_TM_PRED, bd);
+                                      FILTER_PAETH_PRED, bd);
 #endif
 }
 
@@ -2166,8 +2167,8 @@
     case FILTER_D63_PRED:
       av1_highbd_d63_filter_predictor(dst, stride, tx_size, above, left, bd);
       break;
-    case FILTER_TM_PRED:
-      av1_highbd_tm_filter_predictor(dst, stride, tx_size, above, left, bd);
+    case FILTER_PAETH_PRED:
+      av1_highbd_paeth_filter_predictor(dst, stride, tx_size, above, left, bd);
       break;
     default: assert(0);
   }
diff --git a/av1/common/x86/filterintra_sse4.c b/av1/common/x86/filterintra_sse4.c
index 4f77da4..038c58f 100644
--- a/av1/common/x86/filterintra_sse4.c
+++ b/av1/common/x86/filterintra_sse4.c
@@ -574,10 +574,11 @@
   FilterPrediction(above, left, bs, prm, dst, stride);
 }
 
-void av1_tm_filter_predictor_sse4_1(uint8_t *dst, ptrdiff_t stride, int bs,
-                                    const uint8_t *above, const uint8_t *left) {
+void av1_paeth_filter_predictor_sse4_1(uint8_t *dst, ptrdiff_t stride, int bs,
+                                       const uint8_t *above,
+                                       const uint8_t *left) {
   __m128i prm[5];
-  GetIntraFilterParams(bs, TM_PRED, &prm[0]);
+  GetIntraFilterParams(bs, PAETH_PRED, &prm[0]);
   FilterPrediction(above, left, bs, prm, dst, stride);
 }
 
@@ -886,11 +887,11 @@
   HighbdFilterPrediction(above, left, bs, bd, prm, dst, stride);
 }
 
-void av1_highbd_tm_filter_predictor_sse4_1(uint16_t *dst, ptrdiff_t stride,
-                                           int bs, const uint16_t *above,
-                                           const uint16_t *left, int bd) {
+void av1_highbd_paeth_filter_predictor_sse4_1(uint16_t *dst, ptrdiff_t stride,
+                                              int bs, const uint16_t *above,
+                                              const uint16_t *left, int bd) {
   __m128i prm[5];
-  GetIntraFilterParams(bs, TM_PRED, &prm[0]);
+  GetIntraFilterParams(bs, PAETH_PRED, &prm[0]);
   HighbdFilterPrediction(above, left, bs, bd, prm, dst, stride);
 }
 #endif  // CONFIG_HIGHBITDEPTH
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 4a3f30b..502957d 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -696,7 +696,7 @@
         THR_SMOOTH_V, /*SMOOTH_V_PRED*/
         THR_SMOOTH_H, /*SMOOTH_H_PRED*/
 #endif                // CONFIG_SMOOTH_HV
-        THR_TM /*TM_PRED*/,
+        THR_PAETH /*PAETH_PRED*/,
       };
       ++mode_chosen_counts[kf_mode_index[mbmi->mode]];
     } else {
diff --git a/av1/encoder/mbgraph.c b/av1/encoder/mbgraph.c
index 7d2510a..eb0e103 100644
--- a/av1/encoder/mbgraph.c
+++ b/av1/encoder/mbgraph.c
@@ -144,7 +144,7 @@
 
   // calculate SATD for each intra prediction mode;
   // we're intentionally not doing 4x4, we just want a rough estimate
-  for (mode = DC_PRED; mode <= TM_PRED; mode++) {
+  for (mode = DC_PRED; mode <= PAETH_PRED; mode++) {
     unsigned int err;
 
     xd->mi[0]->mbmi.mode = mode;
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 5dd4853..c417f41 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -1314,7 +1314,7 @@
   rd->thresh_mult[THR_ZEROG] += 2000;
   rd->thresh_mult[THR_ZEROA] += 2000;
 
-  rd->thresh_mult[THR_TM] += 1000;
+  rd->thresh_mult[THR_PAETH] += 1000;
 
 #if CONFIG_COMPOUND_SINGLEREF
   rd->thresh_mult[THR_SR_NEAREST_NEARMV] += 1200;
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index 35ada8e..f57a8de 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -162,7 +162,7 @@
 #endif  // CONFIG_EXT_COMP_REFS
 #endif  // CONFIG_EXT_REFS
 
-  THR_TM,
+  THR_PAETH,
 
   THR_SMOOTH,
 #if CONFIG_SMOOTH_HV
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 607db9b..dac41b7 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -295,7 +295,7 @@
 #endif  // CONFIG_EXT_COMP_REFS
 #endif  // CONFIG_EXT_REFS
 
-  { TM_PRED, { INTRA_FRAME, NONE_FRAME } },
+  { PAETH_PRED, { INTRA_FRAME, NONE_FRAME } },
 
   { SMOOTH_PRED, { INTRA_FRAME, NONE_FRAME } },
 #if CONFIG_SMOOTH_HV
@@ -487,17 +487,17 @@
 };
 
 static const PREDICTION_MODE intra_rd_search_mode_order[INTRA_MODES] = {
-  DC_PRED,       H_PRED,        V_PRED,    SMOOTH_PRED, TM_PRED,
+  DC_PRED,       H_PRED,        V_PRED,    SMOOTH_PRED, PAETH_PRED,
 #if CONFIG_SMOOTH_HV
   SMOOTH_V_PRED, SMOOTH_H_PRED,
 #endif  // CONFIG_SMOOTH_HV
-  D135_PRED,     D207_PRED,     D153_PRED, D63_PRED,    D117_PRED, D45_PRED,
+  D135_PRED,     D207_PRED,     D153_PRED, D63_PRED,    D117_PRED,  D45_PRED,
 };
 
 #if CONFIG_CFL
 static const UV_PREDICTION_MODE uv_rd_search_mode_order[UV_INTRA_MODES] = {
   UV_DC_PRED,       UV_CFL_PRED,      UV_H_PRED,
-  UV_V_PRED,        UV_SMOOTH_PRED,   UV_TM_PRED,
+  UV_V_PRED,        UV_SMOOTH_PRED,   UV_PAETH_PRED,
 #if CONFIG_SMOOTH_HV
   UV_SMOOTH_V_PRED, UV_SMOOTH_H_PRED,
 #endif  // CONFIG_SMOOTH_HV
@@ -3293,7 +3293,7 @@
 #if CONFIG_PVQ
     od_encode_checkpoint(&x->daala_enc, &pre_buf);
 #endif
-    for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
+    for (mode = DC_PRED; mode <= PAETH_PRED; ++mode) {
       int64_t this_rd;
       int ratey = 0;
       int64_t distortion = 0;
@@ -3502,7 +3502,7 @@
   od_encode_checkpoint(&x->daala_enc, &pre_buf);
 #endif  // CONFIG_PVQ
 
-  for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
+  for (mode = DC_PRED; mode <= PAETH_PRED; ++mode) {
     int64_t this_rd;
     int ratey = 0;
     int64_t distortion = 0;
@@ -4286,7 +4286,7 @@
   const MODE_INFO *left_mi = xd->left_mi;
   const PREDICTION_MODE A = av1_above_block_mode(mic, above_mi, 0);
   const PREDICTION_MODE L = av1_left_block_mode(mic, left_mi, 0);
-  const PREDICTION_MODE FINAL_MODE_SEARCH = TM_PRED + 1;
+  const PREDICTION_MODE FINAL_MODE_SEARCH = PAETH_PRED + 1;
 #if CONFIG_PVQ
   od_rollback_buffer pre_buf, post_buf;
 
@@ -10944,7 +10944,7 @@
         // Only search the oblique modes if the best so far is
         // one of the neighboring directional modes
         if ((mode_search_skip_flags & FLAG_SKIP_INTRA_BESTINTER) &&
-            (this_mode >= D45_PRED && this_mode <= TM_PRED)) {
+            (this_mode >= D45_PRED && this_mode <= PAETH_PRED)) {
           if (best_mode_index >= 0 && best_mbmode.ref_frame[0] > INTRA_FRAME)
             continue;
         }
@@ -11151,7 +11151,7 @@
               mbmi->filter_intra_mode_info.filter_intra_mode[1]);
       }
 #endif  // CONFIG_FILTER_INTRA
-      if (mbmi->mode != DC_PRED && mbmi->mode != TM_PRED)
+      if (mbmi->mode != DC_PRED && mbmi->mode != PAETH_PRED)
         rate2 += intra_cost_penalty;
       distortion2 = distortion_y + distortion_uv;
     } else {
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index edd79cd..907170e 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -25,7 +25,7 @@
 #if CONFIG_SMOOTH_HV
               (1 << SMOOTH_V_PRED) | (1 << SMOOTH_H_PRED) |
 #endif  // CONFIG_SMOOTH_HV
-              (1 << TM_PRED),
+              (1 << PAETH_PRED),
 #if CONFIG_CFL
   UV_INTRA_ALL = (1 << UV_DC_PRED) | (1 << UV_V_PRED) | (1 << UV_H_PRED) |
                  (1 << UV_D45_PRED) | (1 << UV_D135_PRED) |
@@ -35,26 +35,26 @@
 #if CONFIG_SMOOTH_HV
                  (1 << UV_SMOOTH_V_PRED) | (1 << UV_SMOOTH_H_PRED) |
 #endif  // CONFIG_SMOOTH_HV
-                 (1 << UV_TM_PRED) | (1 << UV_CFL_PRED),
+                 (1 << UV_PAETH_PRED) | (1 << UV_CFL_PRED),
   UV_INTRA_DC = (1 << UV_DC_PRED),
   UV_INTRA_DC_CFL = (1 << UV_DC_PRED) | (1 << UV_CFL_PRED),
-  UV_INTRA_DC_TM = (1 << UV_DC_PRED) | (1 << UV_TM_PRED),
-  UV_INTRA_DC_TM_CFL =
-      (1 << UV_DC_PRED) | (1 << UV_TM_PRED) | (1 << UV_CFL_PRED),
+  UV_INTRA_DC_TM = (1 << UV_DC_PRED) | (1 << UV_PAETH_PRED),
+  UV_INTRA_DC_PAETH_CFL =
+      (1 << UV_DC_PRED) | (1 << UV_PAETH_PRED) | (1 << UV_CFL_PRED),
   UV_INTRA_DC_H_V = (1 << UV_DC_PRED) | (1 << UV_V_PRED) | (1 << UV_H_PRED),
   UV_INTRA_DC_H_V_CFL = (1 << UV_DC_PRED) | (1 << UV_V_PRED) |
                         (1 << UV_H_PRED) | (1 << UV_CFL_PRED),
-  UV_INTRA_DC_TM_H_V = (1 << UV_DC_PRED) | (1 << UV_TM_PRED) |
-                       (1 << UV_V_PRED) | (1 << UV_H_PRED),
-  UV_INTRA_DC_TM_H_V_CFL = (1 << UV_DC_PRED) | (1 << UV_TM_PRED) |
-                           (1 << UV_V_PRED) | (1 << UV_H_PRED) |
-                           (1 << UV_CFL_PRED),
+  UV_INTRA_DC_PAETH_H_V = (1 << UV_DC_PRED) | (1 << UV_PAETH_PRED) |
+                          (1 << UV_V_PRED) | (1 << UV_H_PRED),
+  UV_INTRA_DC_PAETH_H_V_CFL = (1 << UV_DC_PRED) | (1 << UV_PAETH_PRED) |
+                              (1 << UV_V_PRED) | (1 << UV_H_PRED) |
+                              (1 << UV_CFL_PRED),
 #endif  // CONFIG_CFL
   INTRA_DC = (1 << DC_PRED),
-  INTRA_DC_TM = (1 << DC_PRED) | (1 << TM_PRED),
+  INTRA_DC_TM = (1 << DC_PRED) | (1 << PAETH_PRED),
   INTRA_DC_H_V = (1 << DC_PRED) | (1 << V_PRED) | (1 << H_PRED),
-  INTRA_DC_TM_H_V =
-      (1 << DC_PRED) | (1 << TM_PRED) | (1 << V_PRED) | (1 << H_PRED)
+  INTRA_DC_PAETH_H_V =
+      (1 << DC_PRED) | (1 << PAETH_PRED) | (1 << V_PRED) | (1 << H_PRED)
 };
 
 enum {
diff --git a/examples/inspect.c b/examples/inspect.c
index 74e770b..595cb02 100644
--- a/examples/inspect.c
+++ b/examples/inspect.c
@@ -202,7 +202,7 @@
 #if CONFIG_SMOOTH_HV
   ENUM(SMOOTH_V_PRED), ENUM(SMOOTH_H_PRED),
 #endif  // CONFIG_SMOOTH_HV
-  ENUM(TM_PRED),       ENUM(NEARESTMV),     ENUM(NEARMV),
+  ENUM(PAETH_PRED),    ENUM(NEARESTMV),     ENUM(NEARMV),
   ENUM(ZEROMV),        ENUM(NEWMV),         ENUM(NEAREST_NEARESTMV),
   ENUM(NEAR_NEARMV),   ENUM(NEAREST_NEWMV), ENUM(NEW_NEARESTMV),
   ENUM(NEAR_NEWMV),    ENUM(NEW_NEARMV),    ENUM(ZERO_ZEROMV),
@@ -219,7 +219,7 @@
 #if CONFIG_SMOOTH_HV
   ENUM(UV_SMOOTH_V_PRED), ENUM(UV_SMOOTH_H_PRED),
 #endif  // CONFIG_SMOOTH_HV
-  ENUM(UV_TM_PRED),
+  ENUM(UV_PAETH_PRED),
 #if CONFIG_CFL
   ENUM(UV_CFL_PRED),
 #endif
diff --git a/test/filterintra_predictors_test.cc b/test/filterintra_predictors_test.cc
index 5c6b56d..671d371 100644
--- a/test/filterintra_predictors_test.cc
+++ b/test/filterintra_predictors_test.cc
@@ -284,8 +284,8 @@
              D207_PRED),
   make_tuple(av1_d63_filter_predictor_c, av1_d63_filter_predictor_sse4_1,
              D63_PRED),
-  make_tuple(av1_tm_filter_predictor_c, av1_tm_filter_predictor_sse4_1,
-             TM_PRED),
+  make_tuple(av1_paeth_filter_predictor_c, av1_paeth_filter_predictor_sse4_1,
+             PAETH_PRED),
 };
 
 const int kBlkSize[] = { 4, 8, 16, 32 };
@@ -315,8 +315,8 @@
              av1_highbd_d207_filter_predictor_sse4_1, D207_PRED),
   make_tuple(av1_highbd_d63_filter_predictor_c,
              av1_highbd_d63_filter_predictor_sse4_1, D63_PRED),
-  make_tuple(av1_highbd_tm_filter_predictor_c,
-             av1_highbd_tm_filter_predictor_sse4_1, TM_PRED),
+  make_tuple(av1_highbd_paeth_filter_predictor_c,
+             av1_highbd_paeth_filter_predictor_sse4_1, PAETH_PRED),
 };
 
 const int kBd[] = { 10, 12 };
diff --git a/test/test_intra_pred_speed.cc b/test/test_intra_pred_speed.cc
index 2528944..013ff03 100644
--- a/test/test_intra_pred_speed.cc
+++ b/test/test_intra_pred_speed.cc
@@ -37,7 +37,7 @@
 const char *kAv1IntraPredNames[kNumAv1IntraFuncs] = {
   "DC_PRED",       "DC_LEFT_PRED",  "DC_TOP_PRED", "DC_128_PRED", "V_PRED",
   "H_PRED",        "D45_PRED",      "D135_PRED",   "D117_PRED",   "D153_PRED",
-  "D207_PRED",     "D63_PRED",      "TM_PRED",     "SMOOTH_PRED",
+  "D207_PRED",     "D63_PRED",      "PAETH_PRED",  "SMOOTH_PRED",
 #if CONFIG_SMOOTH_HV
   "SMOOTH_V_PRED", "SMOOTH_H_PRED",
 #endif  // CONFIG_SMOOTH_HV
@@ -367,15 +367,15 @@
 
 // Defines a test case for |arch| (e.g., C, SSE2, ...) passing the predictors
 // to |test_func|. The test name is 'arch.test_func', e.g., C.TestIntraPred4.
-#define INTRA_PRED_TEST(arch, test_func, blk, dc, dc_left, dc_top, dc_128, v, \
-                        h, d45e, d135, d117, d153, d207e, d63e, tm, smooth,   \
-                        smooth_v, smooth_h)                                   \
-  TEST(arch, DISABLED_##test_func) {                                          \
-    static const AvxPredFunc aom_intra_pred[] = {                             \
-      dc,   dc_left, dc_top, dc_128, v,  h,      d45e,     d135,              \
-      d117, d153,    d207e,  d63e,   tm, smooth, smooth_v, smooth_h           \
-    };                                                                        \
-    test_func(blk, aom_intra_pred);                                           \
+#define INTRA_PRED_TEST(arch, test_func, blk, dc, dc_left, dc_top, dc_128, v,  \
+                        h, d45e, d135, d117, d153, d207e, d63e, paeth, smooth, \
+                        smooth_v, smooth_h)                                    \
+  TEST(arch, DISABLED_##test_func) {                                           \
+    static const AvxPredFunc aom_intra_pred[] = {                              \
+      dc,   dc_left, dc_top, dc_128, v,     h,      d45e,     d135,            \
+      d117, d153,    d207e,  d63e,   paeth, smooth, smooth_v, smooth_h         \
+    };                                                                         \
+    test_func(blk, aom_intra_pred);                                            \
   }
 
 // -----------------------------------------------------------------------------
@@ -1106,15 +1106,15 @@
 
 }  // namespace
 
-#define HIGHBD_INTRA_PRED_TEST(arch, test_func, block_size, dc, dc_left,     \
-                               dc_top, dc_128, v, h, d45e, d135, d117, d153, \
-                               d207e, d63e, tm, smooth, smooth_v, smooth_h)  \
-  TEST(arch, DISABLED_##test_func) {                                         \
-    static const AvxHighbdPredFunc aom_intra_pred[] = {                      \
-      dc,   dc_left, dc_top, dc_128, v,  h,      d45e,     d135,             \
-      d117, d153,    d207e,  d63e,   tm, smooth, smooth_v, smooth_h          \
-    };                                                                       \
-    test_func(block_size, aom_intra_pred);                                   \
+#define HIGHBD_INTRA_PRED_TEST(arch, test_func, block_size, dc, dc_left,       \
+                               dc_top, dc_128, v, h, d45e, d135, d117, d153,   \
+                               d207e, d63e, paeth, smooth, smooth_v, smooth_h) \
+  TEST(arch, DISABLED_##test_func) {                                           \
+    static const AvxHighbdPredFunc aom_intra_pred[] = {                        \
+      dc,   dc_left, dc_top, dc_128, v,     h,      d45e,     d135,            \
+      d117, d153,    d207e,  d63e,   paeth, smooth, smooth_v, smooth_h         \
+    };                                                                         \
+    test_func(block_size, aom_intra_pred);                                     \
   }
 
 // -----------------------------------------------------------------------------
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index 962c1af..de69667 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -32,8 +32,8 @@
 const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
   -DC_PRED,
   2, /* 0 = DC_NODE */
-  -TM_PRED,
-  4, /* 1 = TM_NODE */
+  -PAETH_PRED,
+  4, /* 1 = PAETH_NODE */
   -V_PRED,
   6, /* 2 = V_NODE */
   8,
@@ -57,16 +57,16 @@
 };
 #else
 const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
-  -DC_PRED,   2,            /* 0 = DC_NODE */
-  -TM_PRED,   4,            /* 1 = TM_NODE */
-  -V_PRED,    6,            /* 2 = V_NODE */
-  8,          12,           /* 3 = COM_NODE */
-  -H_PRED,    10,           /* 4 = H_NODE */
-  -D135_PRED, -D117_PRED,   /* 5 = D135_NODE */
-  -D45_PRED,  14,           /* 6 = D45_NODE */
-  -D63_PRED,  16,           /* 7 = D63_NODE */
-  -D153_PRED, 18,           /* 8 = D153_NODE */
-  -D207_PRED, -SMOOTH_PRED, /* 9 = D207_NODE */
+  -DC_PRED,    2,            /* 0 = DC_NODE */
+  -PAETH_PRED, 4,            /* 1 = PAETH_NODE */
+  -V_PRED,     6,            /* 2 = V_NODE */
+  8,           12,           /* 3 = COM_NODE */
+  -H_PRED,     10,           /* 4 = H_NODE */
+  -D135_PRED,  -D117_PRED,   /* 5 = D135_NODE */
+  -D45_PRED,   14,           /* 6 = D45_NODE */
+  -D63_PRED,   16,           /* 7 = D63_NODE */
+  -D153_PRED,  18,           /* 8 = D153_NODE */
+  -D207_PRED,  -SMOOTH_PRED, /* 9 = D207_NODE */
 };
 #endif  // CONFIG_SMOOTH_HV