Remove smooth_hv experiment flag.

This experiment has been cleared by Tapas.

Also, fix a couple of hash signatures in the test while we are at it.

Change-Id: I1658bcb07913cf8bd47cfffadd729e16d5c55fc3

aom_dsp/aom_dsp_rtcd_defs.pl

@@ -67,10 +67,7 @@ foreach $w (@tx_dims) {
   }
 }
 
-@pred_names = qw/dc dc_top dc_left dc_128 v h d207e d63e d45e d117 d135 d153 paeth smooth/;
-if (aom_config("CONFIG_SMOOTH_HV") eq "yes") {
-  push @pred_names, qw/smooth_v smooth_h/;
-}
+@pred_names = qw/dc dc_top dc_left dc_128 v h d207e d63e d45e d117 d135 d153 paeth smooth smooth_v smooth_h/;
 
 #
 # Intra prediction

aom_dsp/intrapred.c

@@ -250,7 +250,6 @@ static INLINE void smooth_predictor(uint8_t *dst, ptrdiff_t stride, int bw,
   }
 }
 
-#if CONFIG_SMOOTH_HV
 static INLINE void smooth_v_predictor(uint8_t *dst, ptrdiff_t stride, int bw,
                                       int bh, const uint8_t *above,
                                       const uint8_t *left) {
@@ -308,7 +307,6 @@ static INLINE void smooth_h_predictor(uint8_t *dst, ptrdiff_t stride, int bw,
     dst += stride;
   }
 }
-#endif  // CONFIG_SMOOTH_HV
 
 static INLINE void dc_128_predictor(uint8_t *dst, ptrdiff_t stride, int bw,
                                     int bh, const uint8_t *above,
@@ -791,7 +789,6 @@ static INLINE void highbd_smooth_predictor(uint16_t *dst, ptrdiff_t stride,
   }
 }
 
-#if CONFIG_SMOOTH_HV
 static INLINE void highbd_smooth_v_predictor(uint16_t *dst, ptrdiff_t stride,
                                              int bw, int bh,
                                              const uint16_t *above,
@@ -851,7 +848,6 @@ static INLINE void highbd_smooth_h_predictor(uint16_t *dst, ptrdiff_t stride,
     dst += stride;
   }
 }
-#endif  // CONFIG_SMOOTH_HV
 
 static INLINE void highbd_dc_128_predictor(uint16_t *dst, ptrdiff_t stride,
                                            int bw, int bh,
@@ -1059,10 +1055,8 @@ intra_pred_above_4x4(d153)
 intra_pred_allsizes(v)
 intra_pred_allsizes(h)
 intra_pred_allsizes(smooth)
-#if CONFIG_SMOOTH_HV
 intra_pred_allsizes(smooth_v)
 intra_pred_allsizes(smooth_h)
-#endif  // CONFIG_SMOOTH_HV
 intra_pred_allsizes(paeth)
 intra_pred_allsizes(dc_128)
 intra_pred_allsizes(dc_left)

av1/common/av1_loopfilter.c

@@ -314,12 +314,8 @@ static const uint16_t left_border_uv = 0x1111;
 static const uint16_t above_border_uv = 0x000f;
 
 static const int mode_lf_lut[] = {
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // INTRA_MODES
-  0,
-#if CONFIG_SMOOTH_HV
-  0, 0,
-#endif         // CONFIG_SMOOTH_HV
-  1, 1, 0, 1,  // INTER_MODES (GLOBALMV == 0)
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // INTRA_MODES
+  1, 1, 0, 1,                             // INTER_MODES (GLOBALMV == 0)
 #if CONFIG_COMPOUND_SINGLEREF
   // 1, 1, 1, 1, 1,       // INTER_SINGLEREF_COMP_MODES
   // NOTE(zoeliu): Remove SR_NEAREST_NEWMV

av1/common/blockd.h

@@ -102,10 +102,8 @@ static INLINE PREDICTION_MODE compound_ref0_mode(PREDICTION_MODE mode) {
     MB_MODE_COUNT,  // D207_PRED
     MB_MODE_COUNT,  // D63_PRED
     MB_MODE_COUNT,  // SMOOTH_PRED
-#if CONFIG_SMOOTH_HV
     MB_MODE_COUNT,  // SMOOTH_V_PRED
     MB_MODE_COUNT,  // SMOOTH_H_PRED
-#endif              // CONFIG_SMOOTH_HV
     MB_MODE_COUNT,  // PAETH_PRED
     MB_MODE_COUNT,  // NEARESTMV
     MB_MODE_COUNT,  // NEARMV
@@ -148,10 +146,8 @@ static INLINE PREDICTION_MODE compound_ref1_mode(PREDICTION_MODE mode) {
     MB_MODE_COUNT,  // D207_PRED
     MB_MODE_COUNT,  // D63_PRED
     MB_MODE_COUNT,  // SMOOTH_PRED
-#if CONFIG_SMOOTH_HV
     MB_MODE_COUNT,  // SMOOTH_V_PRED
     MB_MODE_COUNT,  // SMOOTH_H_PRED
-#endif              // CONFIG_SMOOTH_HV
     MB_MODE_COUNT,  // PAETH_PRED
     MB_MODE_COUNT,  // NEARESTMV
     MB_MODE_COUNT,  // NEARMV
@@ -422,20 +418,18 @@ static INLINE PREDICTION_MODE get_y_mode(const MODE_INFO *mi, int block) {
 #if CONFIG_CFL
 static INLINE PREDICTION_MODE get_uv_mode(UV_PREDICTION_MODE mode) {
   static const PREDICTION_MODE uv2y[UV_INTRA_MODES] = {
-    DC_PRED,      // UV_DC_PRED
-    V_PRED,       // UV_V_PRED
-    H_PRED,       // UV_H_PRED
-    D45_PRED,     // UV_D45_PRED
-    D135_PRED,    // UV_D135_PRED
-    D117_PRED,    // UV_D117_PRED
-    D153_PRED,    // UV_D153_PRED
-    D207_PRED,    // UV_D207_PRED
-    D63_PRED,     // UV_D63_PRED
-    SMOOTH_PRED,  // UV_SMOOTH_PRED
-#if CONFIG_SMOOTH_HV
+    DC_PRED,        // UV_DC_PRED
+    V_PRED,         // UV_V_PRED
+    H_PRED,         // UV_H_PRED
+    D45_PRED,       // UV_D45_PRED
+    D135_PRED,      // UV_D135_PRED
+    D117_PRED,      // UV_D117_PRED
+    D153_PRED,      // UV_D153_PRED
+    D207_PRED,      // UV_D207_PRED
+    D63_PRED,       // UV_D63_PRED
+    SMOOTH_PRED,    // UV_SMOOTH_PRED
     SMOOTH_V_PRED,  // UV_SMOOTH_V_PRED
     SMOOTH_H_PRED,  // UV_SMOOTH_H_PRED
-#endif              // CONFIG_SMOOTH_HV
     PAETH_PRED,     // UV_PAETH_PRED
     DC_PRED,        // CFL_PRED
   };
@@ -785,10 +779,8 @@ static const TX_TYPE intra_mode_to_tx_type_context[INTRA_MODES] = {
   DCT_ADST,   // D207
   ADST_DCT,   // D63
   ADST_ADST,  // SMOOTH
-#if CONFIG_SMOOTH_HV
   ADST_DCT,   // SMOOTH_V
   DCT_ADST,   // SMOOTH_H
-#endif        // CONFIG_SMOOTH_HV
   ADST_ADST,  // PAETH
 };
 
@@ -1069,10 +1061,7 @@ static INLINE TX_SIZE tx_size_from_tx_mode(BLOCK_SIZE bsize, TX_MODE tx_mode,
 #if CONFIG_EXT_INTRA
 extern const int16_t dr_intra_derivative[90];
 static const uint8_t mode_to_angle_map[] = {
-  0, 90, 180, 45, 135, 113, 157, 203, 67, 0, 0,
-#if CONFIG_SMOOTH_HV
-  0, 0,
-#endif  // CONFIG_SMOOTH_HV
+  0, 90, 180, 45, 135, 113, 157, 203, 67, 0, 0, 0, 0,
 };
 #endif  // CONFIG_EXT_INTRA
 

av1/common/common_data.h

@@ -1793,11 +1793,7 @@ static const struct {
 
 #if CONFIG_KF_CTX
 static const int intra_mode_context[INTRA_MODES] = {
-  0, 1, 2, 3, 4, 4, 4, 4, 3, 0,
-#if CONFIG_SMOOTH_HV
-  1, 2,
-#endif
-  0,
+  0, 1, 2, 3, 4, 4, 4, 4, 3, 0, 1, 2, 0,
 };
 #endif
 

av1/common/enums.h

@@ -481,20 +481,18 @@ typedef enum ATTRIBUTE_PACKED {
 // Note: All directional predictors must be between V_PRED and D63_PRED (both
 // inclusive).
 typedef enum ATTRIBUTE_PACKED {
-  DC_PRED,      // Average of above and left pixels
-  V_PRED,       // Vertical
-  H_PRED,       // Horizontal
-  D45_PRED,     // Directional 45  deg = round(arctan(1/1) * 180/pi)
-  D135_PRED,    // Directional 135 deg = 180 - 45
-  D117_PRED,    // Directional 117 deg = 180 - 63
-  D153_PRED,    // Directional 153 deg = 180 - 27
-  D207_PRED,    // Directional 207 deg = 180 + 27
-  D63_PRED,     // Directional 63  deg = round(arctan(2/1) * 180/pi)
-  SMOOTH_PRED,  // Combination of horizontal and vertical interpolation
-#if CONFIG_SMOOTH_HV
+  DC_PRED,        // Average of above and left pixels
+  V_PRED,         // Vertical
+  H_PRED,         // Horizontal
+  D45_PRED,       // Directional 45  deg = round(arctan(1/1) * 180/pi)
+  D135_PRED,      // Directional 135 deg = 180 - 45
+  D117_PRED,      // Directional 117 deg = 180 - 63
+  D153_PRED,      // Directional 153 deg = 180 - 27
+  D207_PRED,      // Directional 207 deg = 180 + 27
+  D63_PRED,       // Directional 63  deg = round(arctan(2/1) * 180/pi)
+  SMOOTH_PRED,    // Combination of horizontal and vertical interpolation
   SMOOTH_V_PRED,  // Vertical interpolation
   SMOOTH_H_PRED,  // Horizontal interpolation
-#endif            // CONFIG_SMOOTH_HV
   PAETH_PRED,     // Predict from the direction of smallest gradient
   NEARESTMV,
   NEARMV,
@@ -526,20 +524,18 @@ typedef enum ATTRIBUTE_PACKED {
 // TODO(ltrudeau) Do we really want to pack this?
 // TODO(ltrudeau) Do we match with PREDICTION_MODE?
 typedef enum ATTRIBUTE_PACKED {
-  UV_DC_PRED,      // Average of above and left pixels
-  UV_V_PRED,       // Vertical
-  UV_H_PRED,       // Horizontal
-  UV_D45_PRED,     // Directional 45  deg = round(arctan(1/1) * 180/pi)
-  UV_D135_PRED,    // Directional 135 deg = 180 - 45
-  UV_D117_PRED,    // Directional 117 deg = 180 - 63
-  UV_D153_PRED,    // Directional 153 deg = 180 - 27
-  UV_D207_PRED,    // Directional 207 deg = 180 + 27
-  UV_D63_PRED,     // Directional 63  deg = round(arctan(2/1) * 180/pi)
-  UV_SMOOTH_PRED,  // Combination of horizontal and vertical interpolation
-#if CONFIG_SMOOTH_HV
+  UV_DC_PRED,        // Average of above and left pixels
+  UV_V_PRED,         // Vertical
+  UV_H_PRED,         // Horizontal
+  UV_D45_PRED,       // Directional 45  deg = round(arctan(1/1) * 180/pi)
+  UV_D135_PRED,      // Directional 135 deg = 180 - 45
+  UV_D117_PRED,      // Directional 117 deg = 180 - 63
+  UV_D153_PRED,      // Directional 153 deg = 180 - 27
+  UV_D207_PRED,      // Directional 207 deg = 180 + 27
+  UV_D63_PRED,       // Directional 63  deg = round(arctan(2/1) * 180/pi)
+  UV_SMOOTH_PRED,    // Combination of horizontal and vertical interpolation
   UV_SMOOTH_V_PRED,  // Vertical interpolation
   UV_SMOOTH_H_PRED,  // Horizontal interpolation
-#endif               // CONFIG_SMOOTH_HV
   UV_PAETH_PRED,     // Predict from the direction of smallest gradient
   UV_CFL_PRED,       // Chroma-from-Luma
   UV_INTRA_MODES,

av1/common/mvref_common.h

@@ -54,15 +54,13 @@ static const int mode_2_counter[] = {
   9,  // D207_PRED
   9,  // D63_PRED
   9,  // SMOOTH_PRED
-#if CONFIG_SMOOTH_HV
-  9,    // SMOOTH_V_PRED
-  9,    // SMOOTH_H_PRED
-#endif  // CONFIG_SMOOTH_HV
-  9,    // PAETH_PRED
-  0,    // NEARESTMV
-  0,    // NEARMV
-  3,    // GLOBALMV
-  1,    // NEWMV
+  9,  // SMOOTH_V_PRED
+  9,  // SMOOTH_H_PRED
+  9,  // PAETH_PRED
+  0,  // NEARESTMV
+  0,  // NEARMV
+  3,  // GLOBALMV
+  1,  // NEWMV
 #if CONFIG_COMPOUND_SINGLEREF
   0,    // SR_NEAREST_NEARMV
         //  1,    // SR_NEAREST_NEWMV

av1/common/reconintra.c

@@ -58,10 +58,8 @@ static const uint8_t extend_modes[INTRA_MODES] = {
   NEED_LEFT | NEED_BOTTOMLEFT,              // D207
   NEED_ABOVE | NEED_ABOVERIGHT,             // D63
   NEED_LEFT | NEED_ABOVE,                   // SMOOTH
-#if CONFIG_SMOOTH_HV
   NEED_LEFT | NEED_ABOVE,                   // SMOOTH_V
   NEED_LEFT | NEED_ABOVE,                   // SMOOTH_H
-#endif                                      // CONFIG_SMOOTH_HV
   NEED_LEFT | NEED_ABOVE | NEED_ABOVELEFT,  // PAETH
 };
 
@@ -717,10 +715,8 @@ static void av1_init_intra_predictors_internal(void) {
 
   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);
   INIT_ALL_SIZES(pred[SMOOTH_H_PRED], smooth_h);
-#endif  // CONFIG_SMOOTH_HV
 
   INIT_ALL_SIZES(dc_pred[0][0], dc_128);
   INIT_ALL_SIZES(dc_pred[0][1], dc_top);
@@ -739,10 +735,8 @@ static void av1_init_intra_predictors_internal(void) {
 
   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);
   INIT_ALL_SIZES(pred_high[SMOOTH_H_PRED], highbd_smooth_h);
-#endif  // CONFIG_SMOOTH_HV
 
   INIT_ALL_SIZES(dc_pred_high[0][0], highbd_dc_128);
   INIT_ALL_SIZES(dc_pred_high[0][1], highbd_dc_top);
@@ -1472,12 +1466,8 @@ static void highbd_filter_intra_predictors(FILTER_INTRA_MODE mode,
 
 #if CONFIG_INTRA_EDGE
 static int is_smooth(MB_MODE_INFO *mbmi) {
-#if CONFIG_SMOOTH_HV
   return (mbmi->mode == SMOOTH_PRED || mbmi->mode == SMOOTH_V_PRED ||
           mbmi->mode == SMOOTH_H_PRED);
-#else
-  return mbmi->mode == SMOOTH_PRED;
-#endif
 }
 
 static int get_filt_type(const MACROBLOCKD *xd) {

av1/encoder/encodeframe.c

@@ -603,11 +603,9 @@ static void update_state(const AV1_COMP *const cpi, TileDataEnc *tile_data,
         THR_D153_PRED /*D153_PRED*/,
         THR_D207_PRED /*D207_PRED*/,
         THR_D63_PRED /*D63_PRED*/,
-        THR_SMOOTH, /*SMOOTH_PRED*/
-#if CONFIG_SMOOTH_HV
+        THR_SMOOTH,   /*SMOOTH_PRED*/
         THR_SMOOTH_V, /*SMOOTH_V_PRED*/
         THR_SMOOTH_H, /*SMOOTH_H_PRED*/
-#endif                // CONFIG_SMOOTH_HV
         THR_PAETH /*PAETH_PRED*/,
       };
       ++mode_chosen_counts[kf_mode_index[mbmi->mode]];

av1/encoder/rd.h

@@ -143,10 +143,8 @@ typedef enum {
   THR_PAETH,
 
   THR_SMOOTH,
-#if CONFIG_SMOOTH_HV
   THR_SMOOTH_V,
   THR_SMOOTH_H,
-#endif  // CONFIG_SMOOTH_HV
 
   THR_COMP_NEAR_NEARLA,
   THR_COMP_NEW_NEARESTLA,

av1/encoder/rdopt.c

@@ -255,10 +255,8 @@ static const MODE_DEFINITION av1_mode_order[MAX_MODES] = {
   { PAETH_PRED, { INTRA_FRAME, NONE_FRAME } },
 
   { SMOOTH_PRED, { INTRA_FRAME, NONE_FRAME } },
-#if CONFIG_SMOOTH_HV
   { SMOOTH_V_PRED, { INTRA_FRAME, NONE_FRAME } },
   { SMOOTH_H_PRED, { INTRA_FRAME, NONE_FRAME } },
-#endif  // CONFIG_SMOOTH_HV
 
   { NEAR_NEARMV, { LAST_FRAME, ALTREF_FRAME } },
   { NEW_NEARESTMV, { LAST_FRAME, ALTREF_FRAME } },
@@ -437,21 +435,16 @@ static const MODE_DEFINITION av1_mode_order[MAX_MODES] = {
 
 static const PREDICTION_MODE intra_rd_search_mode_order[INTRA_MODES] = {
   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,
+  SMOOTH_V_PRED, SMOOTH_H_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_PAETH_PRED,
-#if CONFIG_SMOOTH_HV
-  UV_SMOOTH_V_PRED, UV_SMOOTH_H_PRED,
-#endif  // CONFIG_SMOOTH_HV
-  UV_D135_PRED,     UV_D207_PRED,     UV_D153_PRED,
-  UV_D63_PRED,      UV_D117_PRED,     UV_D45_PRED,
+  UV_DC_PRED,     UV_CFL_PRED,   UV_H_PRED,        UV_V_PRED,
+  UV_SMOOTH_PRED, UV_PAETH_PRED, UV_SMOOTH_V_PRED, UV_SMOOTH_H_PRED,
+  UV_D135_PRED,   UV_D207_PRED,  UV_D153_PRED,     UV_D63_PRED,
+  UV_D117_PRED,   UV_D45_PRED,
 };
 #else
 #define uv_rd_search_mode_order intra_rd_search_mode_order

av1/encoder/speed_features.h

@@ -22,20 +22,14 @@ enum {
   INTRA_ALL = (1 << DC_PRED) | (1 << V_PRED) | (1 << H_PRED) | (1 << D45_PRED) |
               (1 << D135_PRED) | (1 << D117_PRED) | (1 << D153_PRED) |
               (1 << D207_PRED) | (1 << D63_PRED) | (1 << SMOOTH_PRED) |
-#if CONFIG_SMOOTH_HV
-              (1 << SMOOTH_V_PRED) | (1 << SMOOTH_H_PRED) |
-#endif  // CONFIG_SMOOTH_HV
-              (1 << PAETH_PRED),
+              (1 << SMOOTH_V_PRED) | (1 << SMOOTH_H_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) |
-                 (1 << UV_D117_PRED) | (1 << UV_D153_PRED) |
-                 (1 << UV_D207_PRED) | (1 << UV_D63_PRED) |
-                 (1 << UV_SMOOTH_PRED) |
-#if CONFIG_SMOOTH_HV
-                 (1 << UV_SMOOTH_V_PRED) | (1 << UV_SMOOTH_H_PRED) |
-#endif  // CONFIG_SMOOTH_HV
-                 (1 << UV_PAETH_PRED) | (1 << UV_CFL_PRED),
+  UV_INTRA_ALL =
+      (1 << UV_DC_PRED) | (1 << UV_V_PRED) | (1 << UV_H_PRED) |
+      (1 << UV_D45_PRED) | (1 << UV_D135_PRED) | (1 << UV_D117_PRED) |
+      (1 << UV_D153_PRED) | (1 << UV_D207_PRED) | (1 << UV_D63_PRED) |
+      (1 << UV_SMOOTH_PRED) | (1 << UV_SMOOTH_V_PRED) |
+      (1 << UV_SMOOTH_H_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_PAETH_PRED),

build/cmake/aom_config_defaults.cmake

@@ -188,7 +188,6 @@ set(CONFIG_SEGMENT_GLOBALMV 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_SHORT_FILTER 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_SIMPLE_BWD_ADAPT 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_SIMPLIFY_TX_MODE 0 CACHE NUMBER "AV1 experiment flag.")
-set(CONFIG_SMOOTH_HV 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_STRIPED_LOOP_RESTORATION 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_TEMPMV_SIGNALING 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_TMV 1 CACHE NUMBER "AV1 experiment flag.")

configure

@@ -311,7 +311,6 @@ EXPERIMENT_LIST="
     aom_qm
     ext_qm
     ext_comp_refs
-    smooth_hv
     bgsprite
     var_tx_no_tx_mode
     simplify_tx_mode
@@ -513,7 +512,6 @@ post_process_cmdline() {
       soft_enable reference_buffer
       soft_enable loopfiltering_across_tiles
       soft_enable palette_throughput
-      soft_enable smooth_hv
       soft_enable tempmv_signaling
       soft_enable ext_comp_refs
       soft_enable ext_delta_q
@@ -547,7 +545,6 @@ post_process_cmdline() {
     enabled compound_round && soft_enable convolve_round
     enabled ext_intra_mod && enable_feature intra_edge
     enabled intra_edge && enable_feature ext_intra
-    enabled cfl && enable_feature smooth_hv
     enabled cdef_singlepass && enable_feature cdef
     enabled mfmv && enable_feature frame_marker
     enabled jnt_comp && enable_feature frame_marker

examples/inspect.c

@@ -207,18 +207,15 @@ const map_entry dual_filter_map[] = { ENUM(REG_REG),       ENUM(REG_SMOOTH),
 #endif
 
 const map_entry prediction_mode_map[] = {
-  ENUM(DC_PRED),       ENUM(V_PRED),        ENUM(H_PRED),
-  ENUM(D45_PRED),      ENUM(D135_PRED),     ENUM(D117_PRED),
-  ENUM(D153_PRED),     ENUM(D207_PRED),     ENUM(D63_PRED),
-  ENUM(SMOOTH_PRED),
-#if CONFIG_SMOOTH_HV
-  ENUM(SMOOTH_V_PRED), ENUM(SMOOTH_H_PRED),
-#endif  // CONFIG_SMOOTH_HV
-  ENUM(PAETH_PRED),    ENUM(NEARESTMV),     ENUM(NEARMV),
-  ENUM(GLOBALMV),      ENUM(NEWMV),         ENUM(NEAREST_NEARESTMV),
-  ENUM(NEAR_NEARMV),   ENUM(NEAREST_NEWMV), ENUM(NEW_NEARESTMV),
-  ENUM(NEAR_NEWMV),    ENUM(NEW_NEARMV),    ENUM(GLOBAL_GLOBALMV),
-  ENUM(NEW_NEWMV),     ENUM(INTRA_INVALID), LAST_ENUM
+  ENUM(DC_PRED),     ENUM(V_PRED),        ENUM(H_PRED),
+  ENUM(D45_PRED),    ENUM(D135_PRED),     ENUM(D117_PRED),
+  ENUM(D153_PRED),   ENUM(D207_PRED),     ENUM(D63_PRED),
+  ENUM(SMOOTH_PRED), ENUM(SMOOTH_V_PRED), ENUM(SMOOTH_H_PRED),
+  ENUM(PAETH_PRED),  ENUM(NEARESTMV),     ENUM(NEARMV),
+  ENUM(GLOBALMV),    ENUM(NEWMV),         ENUM(NEAREST_NEARESTMV),
+  ENUM(NEAR_NEARMV), ENUM(NEAREST_NEWMV), ENUM(NEW_NEARESTMV),
+  ENUM(NEAR_NEWMV),  ENUM(NEW_NEARMV),    ENUM(GLOBAL_GLOBALMV),
+  ENUM(NEW_NEWMV),   ENUM(INTRA_INVALID), LAST_ENUM
 };
 
 #if CONFIG_CFL
@@ -228,9 +225,7 @@ const map_entry uv_prediction_mode_map[] = {
   ENUM(UV_D135_PRED),     ENUM(UV_D117_PRED),
   ENUM(UV_D153_PRED),     ENUM(UV_D207_PRED),
   ENUM(UV_D63_PRED),      ENUM(UV_SMOOTH_PRED),
-#if CONFIG_SMOOTH_HV
   ENUM(UV_SMOOTH_V_PRED), ENUM(UV_SMOOTH_H_PRED),
-#endif  // CONFIG_SMOOTH_HV
   ENUM(UV_PAETH_PRED),
 #if CONFIG_CFL
   ENUM(UV_CFL_PRED),

tools/aom_entropy_optimizer.c

@@ -28,7 +28,6 @@
 #include "./aom_config.h"
 #include "av1/common/entropymode.h"
 
-#if CONFIG_SMOOTH_HV
 const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
   -DC_PRED,
   2, /* 0 = DC_NODE */
@@ -55,20 +54,6 @@ const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
   -SMOOTH_V_PRED,
   -SMOOTH_H_PRED /* 11 = SMOOTH_V_NODE */
 };
-#else
-const aom_tree_index av1_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
-  -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
 
 #define SPACES_PER_TAB 2