diff --git a/vp9/encoder/vp9_picklpf.c b/vp9/encoder/vp9_picklpf.c
index 4ca85ee62eaf860853691051fdd03b11a5781a44..a4ceabdf1f5df285587bde2864dc17d0090184eb 100644
--- a/vp9/encoder/vp9_picklpf.c
+++ b/vp9/encoder/vp9_picklpf.c
@@ -20,65 +20,43 @@
 #include "vp9/common/vp9_loopfilter.h"
 #include "./vpx_scale_rtcd.h"
 
-// Enforce a minimum filter level based upon baseline Q
 static int get_min_filter_level(VP9_COMP *cpi, int base_qindex) {
-  int min_filter_level;
-  min_filter_level = 0;
-
-  return min_filter_level;
+  return 0;
 }
 
-// Enforce a maximum filter level based upon baseline Q
 static int get_max_filter_level(VP9_COMP *cpi, int base_qindex) {
-  int max_filter_level = MAX_LOOP_FILTER;
-  (void)base_qindex;
-
-  if (cpi->twopass.section_intra_rating > 8)
-    max_filter_level = MAX_LOOP_FILTER * 3 / 4;
-
-  return max_filter_level;
+  return cpi->twopass.section_intra_rating > 8 ? MAX_LOOP_FILTER * 3 / 4
+                                               : MAX_LOOP_FILTER;
 }
 
-
 // Stub function for now Alt LF not used
 void vp9_set_alt_lf_level(VP9_COMP *cpi, int filt_val) {
 }
 
 void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) {
+  MACROBLOCKD *const xd = &cpi->mb.e_mbd;
   VP9_COMMON *const cm = &cpi->common;
   struct loopfilter *const lf = &cm->lf;
-
-  int best_err = 0;
-  int filt_err = 0;
   const int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);
   const int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);
-
-  int filter_step;
-  int filt_high = 0;
-  // Start search at previous frame filter level
-  int filt_mid = lf->filter_level;
-  int filt_low = 0;
+  int best_err = 0;
+  int filt_err = 0;
   int filt_best;
   int filt_direction = 0;
-
-  int Bias = 0;  // Bias against raising loop filter in favor of lowering it.
-
-  //  Make a copy of the unfiltered / processed recon buffer
-  vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
+  // Start the search at the previous frame filter level unless it is now out of
+  // range.
+  int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level);
+  int filter_step = filt_mid < 16 ? 4 : filt_mid / 4;
 
   lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0
                                                     : cpi->oxcf.sharpness;
 
-  // Start the search at the previous frame filter level unless it is now out of
-  // range.
-  filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level);
-
-  // Define the initial step size
-  filter_step = filt_mid < 16 ? 4 : filt_mid / 4;
+  //  Make a copy of the unfiltered / processed recon buffer
+  vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
 
   // Get baseline error score
   vp9_set_alt_lf_level(cpi, filt_mid);
-  vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_mid, 1, partial);
+  vp9_loop_filter_frame(cm, xd, filt_mid, 1, partial);
 
   best_err = vp9_calc_ss_err(sd, cm->frame_to_show);
   filt_best = filt_mid;
@@ -87,35 +65,32 @@ void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) {
   vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
 
   while (filter_step > 0) {
-    Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step;
+    const int filt_high = MIN(filt_mid + filter_step, max_filter_level);
+    const int filt_low = MAX(filt_mid - filter_step, min_filter_level);
+
+    // Bias against raising loop filter in favor of lowering it.
+    int bias = (best_err >> (15 - (filt_mid / 8))) * filter_step;
 
     if (cpi->twopass.section_intra_rating < 20)
-      Bias = Bias * cpi->twopass.section_intra_rating / 20;
+      bias = bias * cpi->twopass.section_intra_rating / 20;
 
     // yx, bias less for large block size
-    if (cpi->common.tx_mode != ONLY_4X4)
-      Bias >>= 1;
-
-    filt_high = ((filt_mid + filter_step) > max_filter_level)
-                    ? max_filter_level
-                    : (filt_mid + filter_step);
-    filt_low = ((filt_mid - filter_step) < min_filter_level)
-                   ? min_filter_level
-                   : (filt_mid - filter_step);
+    if (cm->tx_mode != ONLY_4X4)
+      bias >>= 1;
 
-    if ((filt_direction <= 0) && (filt_low != filt_mid)) {
+    if (filt_direction <= 0 && filt_low != filt_mid) {
       // Get Low filter error score
       vp9_set_alt_lf_level(cpi, filt_low);
-      vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_low, 1, partial);
+      vp9_loop_filter_frame(cm, xd, filt_low, 1, partial);
 
       filt_err = vp9_calc_ss_err(sd, cm->frame_to_show);
 
-      //  Re-instate the unfiltered frame
+      // Re-instate the unfiltered frame
       vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
 
       // If value is close to the best so far then bias towards a lower loop
       // filter value.
-      if ((filt_err - Bias) < best_err) {
+      if ((filt_err - bias) < best_err) {
         // Was it actually better than the previous best?
         if (filt_err < best_err)
           best_err = filt_err;
@@ -125,9 +100,9 @@ void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) {
     }
 
     // Now look at filt_high
-    if ((filt_direction >= 0) && (filt_high != filt_mid)) {
+    if (filt_direction >= 0 && filt_high != filt_mid) {
       vp9_set_alt_lf_level(cpi, filt_high);
-      vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_high, 1, partial);
+      vp9_loop_filter_frame(cm, xd, filt_high, 1, partial);
 
       filt_err = vp9_calc_ss_err(sd, cm->frame_to_show);
 
@@ -135,7 +110,7 @@ void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) {
       vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
 
       // Was it better than the previous best?
-      if (filt_err < (best_err - Bias)) {
+      if (filt_err < (best_err - bias)) {
         best_err = filt_err;
         filt_best = filt_high;
       }