diff --git a/aom/aom_external_partition.h b/aom/aom_external_partition.h
index 19c23cb..1bb31c4 100644
--- a/aom/aom_external_partition.h
+++ b/aom/aom_external_partition.h
@@ -43,55 +43,55 @@
 /*!\brief Number of features to determine whether to skip partition none and
  * do partition split directly. The same as "FEATURE_SIZE_SMS_SPLIT".
  */
-#define SIZE_DIRECT_SPLIT 17
+#define AOM_EXT_PART_SIZE_DIRECT_SPLIT 17
 
 /*!\brief Number of features to use simple motion search to prune out
  * rectangular partition in some direction. The same as
  * "FEATURE_SIZE_SMS_PRUNE_PART".
  */
-#define SIZE_PRUNE_PART 25
+#define AOM_EXT_PART_SIZE_PRUNE_PART 25
 
 /*!\brief Number of features to prune split and rectangular partition
  * after PARTITION_NONE.
  */
-#define SIZE_PRUNE_NONE 4
+#define AOM_EXT_PART_SIZE_PRUNE_NONE 4
 
 /*!\brief Number of features to terminates partition after partition none using
  * simple_motion_search features and the rate, distortion, and rdcost of
  * PARTITION_NONE. The same as "FEATURE_SIZE_SMS_TERM_NONE".
  */
-#define SIZE_TERM_NONE 28
+#define AOM_EXT_PART_SIZE_TERM_NONE 28
 
 /*!\brief Number of features to terminates partition after partition split.
  */
-#define SIZE_TERM_SPLIT 31
+#define AOM_EXT_PART_SIZE_TERM_SPLIT 31
 
 /*!\brief Number of features to prune rectangular partition using stats
  * collected after partition split.
  */
-#define SIZE_PRUNE_RECT 9
+#define AOM_EXT_PART_SIZE_PRUNE_RECT 9
 
 /*!\brief Number of features to prune AB partition using stats
  * collected after rectangular partition..
  */
-#define SIZE_PRUNE_AB 10
+#define AOM_EXT_PART_SIZE_PRUNE_AB 10
 
 /*!\brief Number of features to prune 4-way partition using stats
  * collected after AB partition.
  */
-#define SIZE_PRUNE_4_WAY 18
+#define AOM_EXT_PART_SIZE_PRUNE_4_WAY 18
 
 /*!\brief Decision mode of the external partition model.
- * WHOLE_TREE_DECISION: the external partition model should provide the
+ * AOM_EXT_PART_WHOLE_TREE: the external partition model should provide the
  * whole partition tree for the superblock.
  *
- * RECURSIVE_DECISION: the external partition model provides the partition
+ * AOM_EXT_PART_RECURSIVE: the external partition model provides the partition
  * decision of the current block only. The decision process starts from
  * the superblock size, down to the smallest block size (4x4) recursively.
  */
 typedef enum aom_ext_part_decision_mode {
-  WHOLE_TREE_DECISION = 0,
-  RECURSIVE_DECISION = 1,
+  AOM_EXT_PART_WHOLE_TREE = 0,
+  AOM_EXT_PART_RECURSIVE = 1,
 } aom_ext_part_decision_mode_t;
 
 /*!\brief Config information sent to the external partition model.
@@ -99,7 +99,7 @@
  * For example, the maximum superblock size determined by the sequence header.
  */
 typedef struct aom_ext_part_config {
-  int superblock_size; /**< super block size (either 64x64 or 128x128) */
+  int superblock_size;  ///< super block size (either 64x64 or 128x128)
 } aom_ext_part_config_t;
 
 /*!\brief Features pass to the external model to make partition decisions.
@@ -111,37 +111,38 @@
  * prune_horz, prune_vert.
  */
 typedef struct aom_partition_features_before_none {
-  float f[SIZE_DIRECT_SPLIT]; /**< features to determine whether skip partition
-                                 none and do split directly */
-  float f_part2[SIZE_PRUNE_PART]; /**< features to determine whether to prune
-                                     rectangular partition */
+  /*! features to determine whether skip partition none and do split directly */
+  float f[AOM_EXT_PART_SIZE_DIRECT_SPLIT];
+  /*! features to determine whether to prune rectangular partition */
+  float f_part2[AOM_EXT_PART_SIZE_PRUNE_PART];
 } aom_partition_features_before_none_t;
 
 /*!\brief Features pass to the external model to make partition decisions.
  * Specifically, features collected after NONE partition.
  */
 typedef struct aom_partition_features_none {
-  float f[SIZE_PRUNE_NONE]; /**< features to prune split and rectangular
-                               partition*/
-  float f_terminate[SIZE_TERM_NONE]; /**< features to determine termination of
-                                        partition */
+  /*! features to prune split and rectangular partition */
+  float f[AOM_EXT_PART_SIZE_PRUNE_NONE];
+  /*! features to determine termination of partition */
+  float f_terminate[AOM_EXT_PART_SIZE_TERM_NONE];
 } aom_partition_features_none_t;
 
 /*!\brief Features pass to the external model to make partition decisions.
  * Specifically, features collected after SPLIT partition.
  */
 typedef struct aom_partition_features_split {
-  float f_terminate[SIZE_TERM_SPLIT];  /**< features to determine termination of
-                                          partition */
-  float f_prune_rect[SIZE_PRUNE_RECT]; /**< features to determine pruning rect
-                                          partition */
+  /*! features to determine termination of  partition */
+  float f_terminate[AOM_EXT_PART_SIZE_TERM_SPLIT];
+  /*! features to determine pruning rect partition */
+  float f_prune_rect[AOM_EXT_PART_SIZE_PRUNE_RECT];
 } aom_partition_features_split_t;
 
 /*!\brief Features pass to the external model to make partition decisions.
  * Specifically, features collected after RECTANGULAR partition.
  */
 typedef struct aom_partition_features_rect {
-  float f[SIZE_PRUNE_AB]; /**< features to determine pruning AB partition */
+  /*! features to determine pruning AB partition */
+  float f[AOM_EXT_PART_SIZE_PRUNE_AB];
 } aom_partition_features_rect_t;
 
 /*!\brief Features pass to the external model to make partition decisions.
@@ -149,23 +150,23 @@
  * VERT_B.
  */
 typedef struct aom_partition_features_ab {
-  float
-      f[SIZE_PRUNE_4_WAY]; /**< features to determine pruning 4-way partition */
+  /*! features to determine pruning 4-way partition */
+  float f[AOM_EXT_PART_SIZE_PRUNE_4_WAY];
 } aom_partition_features_ab_t;
 
 /*!\brief Feature id to tell the external model the current stage in partition
  * pruning and what features to use to make decisions accordingly.
  */
 typedef enum {
-  FEATURE_BEFORE_PART_NONE,
-  FEATURE_BEFORE_PART_NONE_PART2,
-  FEATURE_AFTER_PART_NONE,
-  FEATURE_AFTER_PART_NONE_PART2,
-  FEATURE_AFTER_PART_SPLIT,
-  FEATURE_AFTER_PART_SPLIT_PART2,
-  FEATURE_AFTER_PART_RECT,
-  FEATURE_AFTER_PART_AB
-} PART_FEATURE_ID;
+  AOM_EXT_PART_FEATURE_BEFORE_NONE,
+  AOM_EXT_PART_FEATURE_BEFORE_NONE_PART2,
+  AOM_EXT_PART_FEATURE_AFTER_NONE,
+  AOM_EXT_PART_FEATURE_AFTER_NONE_PART2,
+  AOM_EXT_PART_FEATURE_AFTER_SPLIT,
+  AOM_EXT_PART_FEATURE_AFTER_SPLIT_PART2,
+  AOM_EXT_PART_FEATURE_AFTER_RECT,
+  AOM_EXT_PART_FEATURE_AFTER_AB
+} AOM_EXT_PART_FEATURE_ID;
 
 /*!\brief Features collected from the tpl process.
  *
@@ -176,12 +177,12 @@
  * 128x128 / (16x16) = 64. Change it if the tpl process changes.
  */
 typedef struct aom_sb_tpl_features {
-  int available;       /**< If tpl stats are available */
-  int tpl_unit_length; /**< The block length of tpl process */
-  int num_units;       /**< The number of units inside the current superblock */
-  int64_t intra_cost[64];  /**< The intra cost of each unit */
-  int64_t inter_cost[64];  /**< The inter cost of each unit */
-  int64_t mc_dep_cost[64]; /**< The motion compensated dependency cost */
+  int available;        ///< If tpl stats are available
+  int tpl_unit_length;  ///< The block length of tpl process
+  int num_units;        ///< The number of units inside the current superblock
+  int64_t intra_cost[64];   ///< The intra cost of each unit
+  int64_t inter_cost[64];   ///< The inter cost of each unit
+  int64_t mc_dep_cost[64];  ///< The motion compensated dependency cost
 } aom_sb_tpl_features_t;
 
 /*!\brief Features collected from the simple motion process.
@@ -192,10 +193,10 @@
  * comments and the array size here.
  */
 typedef struct aom_sb_simple_motion_features {
-  int unit_length;   /**< The block length of the simple motion process */
-  int num_units;     /**< The number of units inside the current superblock */
-  int block_sse[64]; /**< Sum of squared error of each unit */
-  int block_var[64]; /**< Variance of each unit */
+  int unit_length;    ///< The block length of the simple motion process
+  int num_units;      ///< The number of units inside the current superblock
+  int block_sse[64];  ///< Sum of squared error of each unit
+  int block_var[64];  ///< Variance of each unit
 } aom_sb_simple_motion_features_t;
 
 /*!\brief Features of each super block.
@@ -203,9 +204,10 @@
  * Features collected for each super block before partition search.
  */
 typedef struct aom_sb_features {
-  aom_sb_simple_motion_features_t
-      motion_features;                /**< Features from motion search*/
-  aom_sb_tpl_features_t tpl_features; /**< Features from tpl process */
+  /*! Features from motion search */
+  aom_sb_simple_motion_features_t motion_features;
+  /*! Features from tpl process */
+  aom_sb_tpl_features_t tpl_features;
 } aom_sb_features_t;
 
 /*!\brief Features pass to the external model to make partition decisions.
@@ -218,25 +220,26 @@
  */
 typedef struct aom_partition_features {
   // Features for the current supervised multi-stage ML model.
-  PART_FEATURE_ID id; /**< Feature ID to indicate active features */
-  aom_partition_features_before_none_t
-      before_part_none; /**< Features collected before NONE partition */
-  aom_partition_features_none_t
-      after_part_none; /**< Features collected after NONE partition */
-  aom_partition_features_split_t
-      after_part_split; /**< Features collected after SPLIT partition */
-  aom_partition_features_rect_t
-      after_part_rect; /**< Features collected after RECTANGULAR partition */
-  aom_partition_features_ab_t
-      after_part_ab; /**< Features collected after AB partition */
+  /*! Feature ID to indicate active features */
+  AOM_EXT_PART_FEATURE_ID id;
+  /*! Features collected before NONE partition */
+  aom_partition_features_before_none_t before_part_none;
+  /*! Features collected after NONE partition */
+  aom_partition_features_none_t after_part_none;
+  /*! Features collected after SPLIT partition */
+  aom_partition_features_split_t after_part_split;
+  /*! Features collected after RECTANGULAR partition */
+  aom_partition_features_rect_t after_part_rect;
+  /*! Features collected after AB partition */
+  aom_partition_features_ab_t after_part_ab;
 
   // Features for a new ML model.
-  aom_sb_features_t sb_features; /**< Features collected for the super block */
-  int mi_row;                    /**< Mi_row position of the block */
-  int mi_col;                    /**< Mi_col position of the block */
-  int frame_width;               /**< Frame width */
-  int frame_height;              /**< Frame height */
-  int block_size;                /**< As "BLOCK_SIZE" in av1/common/enums.h */
+  aom_sb_features_t sb_features;  ///< Features collected for the super block
+  int mi_row;                     ///< Mi_row position of the block
+  int mi_col;                     ///< Mi_col position of the block
+  int frame_width;                ///< Frame width
+  int frame_height;               ///< Frame height
+  int block_size;                 ///< As "BLOCK_SIZE" in av1/common/enums.h
 } aom_partition_features_t;
 
 /*!\brief Partition decisions received from the external model.
@@ -250,24 +253,24 @@
  */
 typedef struct aom_partition_decision {
   // Decisions for directly set partition types
-  int is_final_decision; /**< The flag whether it is the final decision */
-  int num_nodes;         /**< The number of leaf nodes */
-  int partition_decision[2048]; /**< Partition decisions */
-  int current_decision;         /**< Partition decision for the current block */
+  int is_final_decision;         ///< The flag whether it's the final decision
+  int num_nodes;                 ///< The number of leaf nodes
+  int partition_decision[2048];  ///< Partition decisions
+  int current_decision;          ///< Partition decision for the current block
 
   // Decisions for partition type pruning
-  int terminate_partition_search; /**< Terminate further partition search */
-  int partition_none_allowed;     /**< Allow partition none type */
-  int partition_rect_allowed[2];  /**< Allow rectangular partitions */
-  int do_rectangular_split;       /**< Try rectangular split partition */
-  int do_square_split;            /**< Try square split partition */
-  int prune_rect_part[2];         /**< Prune rectangular partition */
-  int horza_partition_allowed;    /**< Allow HORZ_A partitioin */
-  int horzb_partition_allowed;    /**< Allow HORZ_B partitioin */
-  int verta_partition_allowed;    /**< Allow VERT_A partitioin */
-  int vertb_partition_allowed;    /**< Allow VERT_B partitioin */
-  int partition_horz4_allowed;    /**< Allow HORZ4 partition */
-  int partition_vert4_allowed;    /**< Allow VERT4 partition */
+  int terminate_partition_search;  ///< Terminate further partition search
+  int partition_none_allowed;      ///< Allow partition none type
+  int partition_rect_allowed[2];   ///< Allow rectangular partitions
+  int do_rectangular_split;        ///< Try rectangular split partition
+  int do_square_split;             ///< Try square split partition
+  int prune_rect_part[2];          ///< Prune rectangular partition
+  int horza_partition_allowed;     ///< Allow HORZ_A partitioin
+  int horzb_partition_allowed;     ///< Allow HORZ_B partitioin
+  int verta_partition_allowed;     ///< Allow VERT_A partitioin
+  int vertb_partition_allowed;     ///< Allow VERT_B partitioin
+  int partition_horz4_allowed;     ///< Allow HORZ4 partition
+  int partition_vert4_allowed;     ///< Allow VERT4 partition
 } aom_partition_decision_t;
 
 /*!\brief Encoding stats for the given partition decision.
@@ -278,17 +281,17 @@
  * or inference though "func()" defined in ....
  */
 typedef struct aom_partition_stats {
-  int rate;       /**< Rate cost of the block */
-  int64_t dist;   /**< Distortion of the block */
-  int64_t rdcost; /**< Rate-distortion cost of the block */
+  int rate;        ///< Rate cost of the block
+  int64_t dist;    ///< Distortion of the block
+  int64_t rdcost;  ///< Rate-distortion cost of the block
 } aom_partition_stats_t;
 
 /*!\brief Enum for return status.
  */
 typedef enum aom_ext_part_status {
-  AOM_EXT_PART_OK = 0,    /**< Status of success */
-  AOM_EXT_PART_ERROR = 1, /**< Status of failure */
-  AOM_EXT_PART_TEST = 2,  /**< Status used for tests */
+  AOM_EXT_PART_OK = 0,     ///< Status of success
+  AOM_EXT_PART_ERROR = 1,  ///< Status of failure
+  AOM_EXT_PART_TEST = 2,   ///< Status used for tests
 } aom_ext_part_status_t;
 
 /*!\brief Callback of creating an external partition model.
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index b6c15ca..7582517 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c
@@ -4348,10 +4348,10 @@
     bool valid_search = true;
     const aom_ext_part_decision_mode_t decision_mode =
         av1_get_ext_part_decision_mode(&cpi->ext_part_controller);
-    if (decision_mode == WHOLE_TREE_DECISION) {
+    if (decision_mode == AOM_EXT_PART_WHOLE_TREE) {
       valid_search = ml_partition_search_whole_tree(
           cpi, td, tile_data, tp, sms_root, mi_row, mi_col, bsize);
-    } else if (decision_mode == RECURSIVE_DECISION) {
+    } else if (decision_mode == AOM_EXT_PART_RECURSIVE) {
       valid_search = ml_partition_search_partial(
           cpi, td, tile_data, tp, sms_root, mi_row, mi_col, bsize);
     } else {
diff --git a/av1/encoder/partition_strategy.c b/av1/encoder/partition_strategy.c
index 376393a..9e9e8eb 100644
--- a/av1/encoder/partition_strategy.c
+++ b/av1/encoder/partition_strategy.c
@@ -1950,7 +1950,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_BEFORE_PART_NONE;
+  features.id = AOM_EXT_PART_FEATURE_BEFORE_NONE;
   for (int i = 0; i < FEATURE_SIZE_SMS_SPLIT; ++i) {
     features.before_part_none.f[i] = features_from_motion[i];
   }
@@ -1987,7 +1987,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_BEFORE_PART_NONE_PART2;
+  features.id = AOM_EXT_PART_FEATURE_BEFORE_NONE_PART2;
   for (int i = 0; i < FEATURE_SIZE_SMS_PRUNE_PART; ++i) {
     features.before_part_none.f_part2[i] = features_from_motion[i];
   }
@@ -2020,7 +2020,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_AFTER_PART_NONE;
+  features.id = AOM_EXT_PART_FEATURE_AFTER_NONE;
   for (int i = 0; i < 4; ++i) {
     features.after_part_none.f[i] = features_after_none[i];
   }
@@ -2053,7 +2053,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_AFTER_PART_NONE_PART2;
+  features.id = AOM_EXT_PART_FEATURE_AFTER_NONE_PART2;
   for (int i = 0; i < FEATURE_SIZE_SMS_TERM_NONE; ++i) {
     features.after_part_none.f_terminate[i] = features_terminate[i];
   }
@@ -2087,7 +2087,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_AFTER_PART_SPLIT;
+  features.id = AOM_EXT_PART_FEATURE_AFTER_SPLIT;
   for (int i = 0; i < 31; ++i) {
     features.after_part_split.f_terminate[i] = features_terminate[i];
   }
@@ -2121,7 +2121,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_AFTER_PART_SPLIT_PART2;
+  features.id = AOM_EXT_PART_FEATURE_AFTER_SPLIT_PART2;
   for (int i = 0; i < 9; ++i) {
     features.after_part_split.f_prune_rect[i] = features_prune[i];
   }
@@ -2157,7 +2157,7 @@
 
   // Setup features.
   aom_partition_features_t features;
-  features.id = FEATURE_AFTER_PART_RECT;
+  features.id = AOM_EXT_PART_FEATURE_AFTER_RECT;
   for (int i = 0; i < 10; ++i) {
     features.after_part_rect.f[i] = features_after_rect[i];
   }
@@ -2196,7 +2196,7 @@
   if (!frame_is_intra_only(cm) && ext_part_controller->ready) {
     // Setup features.
     aom_partition_features_t features;
-    features.id = FEATURE_AFTER_PART_AB;
+    features.id = AOM_EXT_PART_FEATURE_AFTER_AB;
     prepare_features_after_part_ab(cpi, x, bsize, part_ctx, best_rd,
                                    rect_part_rd, split_rd, pb_source_variance,
                                    mi_row, mi_col, &features);
diff --git a/test/av1_external_partition_test.cc b/test/av1_external_partition_test.cc
index 9cbf491..177c9d9 100644
--- a/test/av1_external_partition_test.cc
+++ b/test/av1_external_partition_test.cc
@@ -287,10 +287,10 @@
   virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                                   ::libaom_test::Encoder *encoder) {
     if (video->frame() == 0) {
-      if (decision_mode_ == WHOLE_TREE_DECISION) {
+      if (decision_mode_ == AOM_EXT_PART_WHOLE_TREE) {
         aom_ext_part_funcs_t ext_part_funcs;
         ext_part_funcs.priv = reinterpret_cast<void *>(&test_data_);
-        ext_part_funcs.decision_mode = WHOLE_TREE_DECISION;
+        ext_part_funcs.decision_mode = AOM_EXT_PART_WHOLE_TREE;
         ext_part_funcs.create_model = ext_part_create_model;
         ext_part_funcs.send_features = ext_part_send_features;
         ext_part_funcs.get_partition_decision =
@@ -319,10 +319,10 @@
             default: assert(0 && "Invalid partition control mode."); break;
           }
         }
-      } else if (decision_mode_ == RECURSIVE_DECISION) {
+      } else if (decision_mode_ == AOM_EXT_PART_RECURSIVE) {
         aom_ext_part_funcs_t ext_part_funcs;
         ext_part_funcs.priv = reinterpret_cast<void *>(&test_data_);
-        ext_part_funcs.decision_mode = RECURSIVE_DECISION;
+        ext_part_funcs.decision_mode = AOM_EXT_PART_RECURSIVE;
         ext_part_funcs.create_model = ext_part_create_model;
         ext_part_funcs.send_features = ext_part_send_features;
         ext_part_funcs.get_partition_decision =
@@ -379,13 +379,13 @@
   ::libaom_test::Y4mVideoSource video("paris_352_288_30.y4m", 0, kFrameNum);
   SetExternalPartition(false);
   SetPartitionControlMode(2);
-  SetDecisionMode(WHOLE_TREE_DECISION);
+  SetDecisionMode(AOM_EXT_PART_WHOLE_TREE);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   const double psnr = GetAveragePsnr();
 
   SetExternalPartition(true);
   SetPartitionControlMode(2);
-  SetDecisionMode(WHOLE_TREE_DECISION);
+  SetDecisionMode(AOM_EXT_PART_WHOLE_TREE);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   const double psnr2 = GetAveragePsnr();
 
@@ -396,13 +396,13 @@
   ::libaom_test::Y4mVideoSource video("paris_352_288_30.y4m", 0, kFrameNum);
   SetExternalPartition(false);
   SetPartitionControlMode(1);
-  SetDecisionMode(RECURSIVE_DECISION);
+  SetDecisionMode(AOM_EXT_PART_RECURSIVE);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   const double psnr = GetAveragePsnr();
 
   SetExternalPartition(true);
   SetPartitionControlMode(1);
-  SetDecisionMode(RECURSIVE_DECISION);
+  SetDecisionMode(AOM_EXT_PART_RECURSIVE);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   const double psnr2 = GetAveragePsnr();
 
@@ -492,28 +492,30 @@
     aom_ext_part_model_t ext_part_model,
     const aom_partition_features_t *part_features) {
   (void)ext_part_model;
-  if (part_features->id == FEATURE_BEFORE_PART_NONE) {
-    write_features_to_file(part_features->before_part_none.f, SIZE_DIRECT_SPLIT,
-                           0);
-  } else if (part_features->id == FEATURE_BEFORE_PART_NONE_PART2) {
+  if (part_features->id == AOM_EXT_PART_FEATURE_BEFORE_NONE) {
+    write_features_to_file(part_features->before_part_none.f,
+                           AOM_EXT_PART_SIZE_DIRECT_SPLIT, 0);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_BEFORE_NONE_PART2) {
     write_features_to_file(part_features->before_part_none.f_part2,
-                           SIZE_PRUNE_PART, 1);
-  } else if (part_features->id == FEATURE_AFTER_PART_NONE) {
-    write_features_to_file(part_features->after_part_none.f, SIZE_PRUNE_NONE,
-                           2);
-  } else if (part_features->id == FEATURE_AFTER_PART_NONE_PART2) {
+                           AOM_EXT_PART_SIZE_PRUNE_PART, 1);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_AFTER_NONE) {
+    write_features_to_file(part_features->after_part_none.f,
+                           AOM_EXT_PART_SIZE_PRUNE_NONE, 2);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_AFTER_NONE_PART2) {
     write_features_to_file(part_features->after_part_none.f_terminate,
-                           SIZE_TERM_NONE, 3);
-  } else if (part_features->id == FEATURE_AFTER_PART_SPLIT) {
+                           AOM_EXT_PART_SIZE_TERM_NONE, 3);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_AFTER_SPLIT) {
     write_features_to_file(part_features->after_part_split.f_terminate,
-                           SIZE_TERM_SPLIT, 4);
-  } else if (part_features->id == FEATURE_AFTER_PART_SPLIT_PART2) {
+                           AOM_EXT_PART_SIZE_TERM_SPLIT, 4);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_AFTER_SPLIT_PART2) {
     write_features_to_file(part_features->after_part_split.f_prune_rect,
-                           SIZE_PRUNE_RECT, 5);
-  } else if (part_features->id == FEATURE_AFTER_PART_RECT) {
-    write_features_to_file(part_features->after_part_rect.f, SIZE_PRUNE_AB, 6);
-  } else if (part_features->id == FEATURE_AFTER_PART_AB) {
-    write_features_to_file(part_features->after_part_ab.f, SIZE_PRUNE_4_WAY, 7);
+                           AOM_EXT_PART_SIZE_PRUNE_RECT, 5);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_AFTER_RECT) {
+    write_features_to_file(part_features->after_part_rect.f,
+                           AOM_EXT_PART_SIZE_PRUNE_AB, 6);
+  } else if (part_features->id == AOM_EXT_PART_FEATURE_AFTER_AB) {
+    write_features_to_file(part_features->after_part_ab.f,
+                           AOM_EXT_PART_SIZE_PRUNE_4_WAY, 7);
   }
   return AOM_EXT_PART_TEST;
 }