diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index e82bb87..0ed92bb 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -2728,8 +2728,8 @@
 #if CONFIG_FRAME_PARALLEL_ENCODE
       cpi->num_frame_recode =
           (cpi->num_frame_recode < (NUM_RECODES_PER_FRAME - 1))
-              ? ++cpi->num_frame_recode
-              : NUM_RECODES_PER_FRAME - 1;
+              ? (cpi->num_frame_recode + 1)
+              : (NUM_RECODES_PER_FRAME - 1);
 #endif
 #if CONFIG_INTERNAL_STATS
       ++cpi->frame_recode_hits;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 11ff93b..b183209 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -2245,7 +2245,15 @@
    * Loopfilter levels of the previous encoded frame.
    */
   int filter_level[2];
+
+  /*!
+   * Chrominance component loopfilter level of the previous encoded frame.
+   */
   int filter_level_u;
+
+  /*!
+   * Chrominance component loopfilter level of the previous encoded frame.
+   */
   int filter_level_v;
 
   /*!
@@ -2815,16 +2823,34 @@
   FrameProbInfo frame_probs;
 
 #if CONFIG_FRAME_PARALLEL_ENCODE
-  // Number of recodes in the frame.
+  /*!
+   * Number of recodes in the frame.
+   */
   int num_frame_recode;
 
-  // Current frame probability of parallel frames, across recodes.
+  /*!
+   * Current frame probability of parallel frames, across recodes.
+   */
   FrameProbInfo frame_new_probs[NUM_RECODES_PER_FRAME];
 
-  // Retain condition for frame_probability calculation
+  /*!
+   * Retain condition for transform type frame_probability calculation
+   */
   int do_update_frame_probs_txtype[NUM_RECODES_PER_FRAME];
+
+  /*!
+   * Retain condition for obmc frame_probability calculation
+   */
   int do_update_frame_probs_obmc[NUM_RECODES_PER_FRAME];
+
+  /*!
+   * Retain condition for warped motion frame_probability calculation
+   */
   int do_update_frame_probs_warp[NUM_RECODES_PER_FRAME];
+
+  /*!
+   * Retain condition for interpolation filter frame_probability calculation
+   */
   int do_update_frame_probs_interpfilter[NUM_RECODES_PER_FRAME];
 #endif
   /*!
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c
index 55a58d1..c114b6d 100644
--- a/av1/encoder/pass2_strategy.c
+++ b/av1/encoder/pass2_strategy.c
@@ -4156,8 +4156,6 @@
       &cpi->ppi->temp_frame_probs_simulation;
   FrameProbInfo *const temp_frame_probs = &cpi->ppi->temp_frame_probs;
   int i, j, loop;
-  AV1_COMMON *const cm = &cpi->common;
-  FeatureFlags *const features = &cm->features;
   // Sequentially do average on temp_frame_probs_simulation which holds
   // probabilities of last frame before parallel encode
   for (loop = 0; loop <= cpi->num_frame_recode; loop++) {
@@ -4167,7 +4165,6 @@
       const FRAME_UPDATE_TYPE update_type =
           get_frame_update_type(&cpi->ppi->gf_group, cpi->gf_frame_index);
       for (i = 0; i < TX_SIZES_ALL; i++) {
-        int j;
         int left = 1024;
 
         for (j = TX_TYPES - 1; j >= 0; j--) {
@@ -4249,7 +4246,6 @@
           get_frame_update_type(&cpi->ppi->gf_group, cpi->gf_frame_index);
 
       for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
-        int j;
         int left = 1536;
 
         for (j = SWITCHABLE_FILTERS - 1; j >= 0; j--) {
diff --git a/av1/encoder/ratectrl.c b/av1/encoder/ratectrl.c
index 499c7b2..bd1a263 100644
--- a/av1/encoder/ratectrl.c
+++ b/av1/encoder/ratectrl.c
@@ -597,7 +597,7 @@
 static void set_rate_correction_factor(AV1_COMP *cpi,
 #if CONFIG_FRAME_PARALLEL_ENCODE
                                        int is_encode_stage,
-#endif
+#endif  // CONFIG_FRAME_PARALLEL_ENCODE
                                        double factor, int width, int height) {
   RATE_CONTROL *const rc = &cpi->rc;
   const RefreshFrameFlagsInfo *const refresh_frame_flags = &cpi->refresh_frame;
diff --git a/av1/encoder/ratectrl.h b/av1/encoder/ratectrl.h
index b1c159f..72166ee 100644
--- a/av1/encoder/ratectrl.h
+++ b/av1/encoder/ratectrl.h
@@ -521,7 +521,7 @@
 void av1_rc_update_rate_correction_factors(struct AV1_COMP *cpi,
 #if CONFIG_FRAME_PARALLEL_ENCODE
                                            int is_encode_stage,
-#endif
+#endif  // CONFIG_FRAME_PARALLEL_ENCODE
                                            int width, int height);
 /*!\cond */
 
