Change experimental flag name

CONFIG_UV_LVL --> CONFIG_LOOPFILTER_LEVEL
Change name because the experiment combines filter level search
in U, V plane, and horizontal, vertical search in Y plane.

Change-Id: Ia05b8f80cd93b60a0305eb94e5783559ef904c13

av1/common/av1_loopfilter.c

@@ -595,7 +595,7 @@ static void update_sharpness(loop_filter_info_n *lfi, int sharpness_lvl) {
 #if CONFIG_EXT_DELTA_Q
 static uint8_t get_filter_level(const AV1_COMMON *cm,
                                 const loop_filter_info_n *lfi_n,
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                                 const int dir_idx,
 #endif
                                 const MB_MODE_INFO *mbmi) {
@@ -609,7 +609,7 @@ static uint8_t get_filter_level(const AV1_COMMON *cm,
   const int segment_id = mbmi->segment_id;
 #endif  // CONFIG_SUPERTX
   if (cm->delta_lf_present_flag) {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     int lvl_seg =
         clamp(mbmi->current_delta_lf_from_base + cm->lf.filter_level[dir_idx],
               0, MAX_LOOP_FILTER);
@@ -633,7 +633,7 @@ static uint8_t get_filter_level(const AV1_COMMON *cm,
     }
     return lvl_seg;
   } else {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     return lfi_n
         ->lvl[segment_id][dir_idx][mbmi->ref_frame[0]][mode_lf_lut[mbmi->mode]];
 #else
@@ -704,7 +704,7 @@ void av1_loop_filter_frame_init(AV1_COMMON *cm, int default_filt_lvl,
       memset(lfi->lvl[seg_id], lvl_seg, sizeof(lfi->lvl[seg_id]));
     } else {
       int ref, mode;
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
       for (int dir = 0; dir < 2; ++dir) {
         lvl_seg = (dir == 0) ? default_filt_lvl : default_filt_lvl_r;
         scale = 1 << (lvl_seg >> 5);
@@ -1430,7 +1430,7 @@ static void build_masks(AV1_COMMON *const cm,
   const TX_SIZE tx_size_uv_above =
       txsize_vert_map[uv_txsize_lookup[block_size][mbmi->tx_size][1][1]];
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   const int filter_level = get_filter_level(cm, lfi_n, 0, mbmi);
 #else
   const int filter_level = get_filter_level(cm, lfi_n, mbmi);
@@ -1528,7 +1528,7 @@ static void build_y_mask(AV1_COMMON *const cm,
   const BLOCK_SIZE block_size = mbmi->sb_type;
 #endif
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   const int filter_level = get_filter_level(cm, lfi_n, 0, mbmi);
 #else
   const int filter_level = get_filter_level(cm, lfi_n, mbmi);
@@ -2137,7 +2137,7 @@ static void get_filter_level_and_masks_non420(
 
 // Filter level can vary per MI
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     if (!(lfl_r[c_step] = get_filter_level(cm, &cm->lf_info, 0, mbmi)))
       continue;
 #else
@@ -2835,7 +2835,7 @@ static void set_lpf_parameters(
                                plane_ptr, scale_horz, scale_vert);
 
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     const uint32_t curr_level =
         get_filter_level(cm, &cm->lf_info, edge_dir, mbmi);
 #else
@@ -2872,7 +2872,7 @@ static void set_lpf_parameters(
                                      plane_ptr, scale_horz, scale_vert);
 
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
           const uint32_t pv_lvl =
               get_filter_level(cm, &cm->lf_info, edge_dir, &mi_prev->mbmi);
 #else
@@ -3317,7 +3317,7 @@ static void av1_filter_block_plane_horz(
 void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
                           struct macroblockd_plane planes[MAX_MB_PLANE],
                           int start, int stop, int y_only) {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   // y_only no longer has its original meaning.
   // Here it means which plane to filter
   // when y_only = {0, 1, 2}, it means we are searching for filter level for
@@ -3328,7 +3328,7 @@ void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
   const int num_planes = y_only ? 1 : MAX_MB_PLANE;
   const int plane_start = 0;
   const int plane_end = num_planes;
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
   int mi_row, mi_col;
   int plane;
 
@@ -3452,20 +3452,20 @@ void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
 
 void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
                            MACROBLOCKD *xd, int frame_filter_level,
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                            int frame_filter_level_r,
 #endif
                            int y_only, int partial_frame) {
   int start_mi_row, end_mi_row, mi_rows_to_filter;
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   int orig_filter_level[2] = { cm->lf.filter_level[0], cm->lf.filter_level[1] };
 #else
   int orig_filter_level = cm->lf.filter_level;
 #endif
 #endif
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   if (!frame_filter_level && !frame_filter_level_r) return;
 #else
   if (!frame_filter_level) return;
@@ -3478,14 +3478,14 @@ void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
     mi_rows_to_filter = AOMMAX(cm->mi_rows / 8, 8);
   }
   end_mi_row = start_mi_row + mi_rows_to_filter;
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   av1_loop_filter_frame_init(cm, frame_filter_level, frame_filter_level_r);
 #else
   av1_loop_filter_frame_init(cm, frame_filter_level, frame_filter_level);
 #endif
 
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   cm->lf.filter_level[0] = frame_filter_level;
   cm->lf.filter_level[1] = frame_filter_level_r;
 #else
@@ -3494,7 +3494,7 @@ void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
 #endif
   av1_loop_filter_rows(frame, cm, xd->plane, start_mi_row, end_mi_row, y_only);
 #if CONFIG_EXT_DELTA_Q
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   cm->lf.filter_level[0] = orig_filter_level[0];
   cm->lf.filter_level[1] = orig_filter_level[1];
 #else

av1/common/av1_loopfilter.h

@@ -36,7 +36,7 @@ enum lf_path {
 };
 
 struct loopfilter {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   int filter_level[2];
   int filter_level_u;
   int filter_level_v;
@@ -71,7 +71,7 @@ typedef struct {
 
 typedef struct {
   loop_filter_thresh lfthr[MAX_LOOP_FILTER + 1];
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   uint8_t lvl[MAX_SEGMENTS][2][TOTAL_REFS_PER_FRAME][MAX_MODE_LF_DELTAS];
 #else
   uint8_t lvl[MAX_SEGMENTS][TOTAL_REFS_PER_FRAME][MAX_MODE_LF_DELTAS];
@@ -143,7 +143,7 @@ void av1_loop_filter_frame_init(struct AV1Common *cm, int default_filt_lvl,
 
 void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
                            struct macroblockd *mbd, int filter_level,
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                            int filter_level_r,
 #endif
                            int y_only, int partial_frame);

av1/common/thread_common.c

@@ -417,7 +417,7 @@ static void loop_filter_rows_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
 void av1_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
                               struct macroblockd_plane planes[MAX_MB_PLANE],
                               int frame_filter_level,
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                               int frame_filter_level_r,
 #endif
                               int y_only, int partial_frame, AVxWorker *workers,
@@ -434,11 +434,11 @@ void av1_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
     mi_rows_to_filter = AOMMAX(cm->mi_rows / 8, 8);
   }
   end_mi_row = start_mi_row + mi_rows_to_filter;
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   av1_loop_filter_frame_init(cm, frame_filter_level, frame_filter_level_r);
 #else
   av1_loop_filter_frame_init(cm, frame_filter_level, frame_filter_level);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
   loop_filter_rows_mt(frame, cm, planes, start_mi_row, end_mi_row, y_only,
                       workers, num_workers, lf_sync);
 }

av1/common/thread_common.h

@@ -51,7 +51,7 @@ void av1_loop_filter_dealloc(AV1LfSync *lf_sync);
 void av1_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
                               struct macroblockd_plane planes[MAX_MB_PLANE],
                               int frame_filter_level,
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                               int frame_filter_level_r,
 #endif
                               int y_only, int partial_frame, AVxWorker *workers,

av1/decoder/decodeframe.c

@@ -2842,7 +2842,7 @@ static void decode_restoration(AV1_COMMON *cm, aom_reader *rb) {
 
 static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
   struct loopfilter *lf = &cm->lf;
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   lf->filter_level[0] = aom_rb_read_literal(rb, 6);
   lf->filter_level[1] = aom_rb_read_literal(rb, 6);
   if (lf->filter_level[0] || lf->filter_level[1]) {
@@ -3810,7 +3810,7 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
 
 #if CONFIG_VAR_TX || CONFIG_CB4X4
 // Loopfilter the whole frame.
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   if (cm->lf.filter_level[0] || cm->lf.filter_level[1]) {
     av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb,
                           cm->lf.filter_level[0], cm->lf.filter_level[1], 0, 0);
@@ -3822,7 +3822,7 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
 #else
   av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb,
                         cm->lf.filter_level, 0, 0);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
 #else
 #if CONFIG_PARALLEL_DEBLOCKING
   // Loopfilter all rows in the frame in the frame.
@@ -4343,7 +4343,7 @@ static size_t read_uncompressed_header(AV1Decoder *pbi,
     ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show);
     unlock_buffer_pool(pool);
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     cm->lf.filter_level[0] = 0;
     cm->lf.filter_level[1] = 0;
 #else
@@ -5273,7 +5273,7 @@ void av1_decode_frame(AV1Decoder *pbi, const uint8_t *data,
     aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
                        "Decode failed. Frame data header is corrupted.");
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   if ((cm->lf.filter_level[0] || cm->lf.filter_level[1]) &&
       !cm->skip_loop_filter) {
     av1_loop_filter_frame_init(cm, cm->lf.filter_level[0],
@@ -5321,7 +5321,7 @@ void av1_decode_frame(AV1Decoder *pbi, const uint8_t *data,
       if (!cm->skip_loop_filter) {
 // If multiple threads are used to decode tiles, then we use those
 // threads to do parallel loopfiltering.
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
         av1_loop_filter_frame_mt(new_fb, cm, pbi->mb.plane,
                                  cm->lf.filter_level[0], cm->lf.filter_level[1],
                                  0, 0, pbi->tile_workers, pbi->num_tile_workers,
@@ -5330,7 +5330,7 @@ void av1_decode_frame(AV1Decoder *pbi, const uint8_t *data,
         av1_loop_filter_frame_mt(new_fb, cm, pbi->mb.plane, cm->lf.filter_level,
                                  0, 0, pbi->tile_workers, pbi->num_tile_workers,
                                  &pbi->lf_row_sync);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
       }
     } else {
       aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,

av1/decoder/dthread.c

@@ -181,7 +181,7 @@ void av1_frameworker_copy_context(AVxWorker *const dst_worker,
   memcpy(dst_cm->lf_info.lfthr, src_cm->lf_info.lfthr,
          (MAX_LOOP_FILTER + 1) * sizeof(loop_filter_thresh));
   dst_cm->lf.last_sharpness_level = src_cm->lf.sharpness_level;
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   dst_cm->lf.filter_level[0] = src_cm->lf.filter_level[0];
   dst_cm->lf.filter_level[1] = src_cm->lf.filter_level[1];
 #else

av1/encoder/bitstream.c

@@ -3419,7 +3419,7 @@ static void encode_loopfilter(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) {
   struct loopfilter *lf = &cm->lf;
 
 // Encode the loop filter level and type
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   aom_wb_write_literal(wb, lf->filter_level[0], 6);
   aom_wb_write_literal(wb, lf->filter_level[1], 6);
   if (lf->filter_level[0] || lf->filter_level[1]) {

av1/encoder/encoder.c

@@ -4134,7 +4134,7 @@ static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
 #endif  // CONFIG_EXT_TILE
 
   if (no_loopfilter) {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     lf->filter_level[0] = 0;
     lf->filter_level[1] = 0;
 #else
@@ -4153,14 +4153,14 @@ static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
     cpi->time_pick_lpf += aom_usec_timer_elapsed(&timer);
   }
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   if (lf->filter_level[0] || lf->filter_level[1])
 #else
   if (lf->filter_level > 0)
 #endif
   {
 #if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     av1_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level[0],
                           lf->filter_level[1], 0, 0);
     av1_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level_u,
@@ -4170,7 +4170,7 @@ static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
 
 #else
     av1_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
 #else
     if (cpi->num_workers > 1)
       av1_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,

av1/encoder/picklpf.c

@@ -49,7 +49,7 @@ int av1_get_max_filter_level(const AV1_COMP *cpi) {
 static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
                                 AV1_COMP *const cpi, int filt_level,
                                 int partial_frame
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                                 ,
                                 int plane, int dir
 #endif
@@ -58,7 +58,7 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
   int64_t filt_err;
 
 #if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   assert(plane >= 0 && plane <= 2);
   int filter_level[2] = { filt_level, filt_level };
   if (plane == 0 && dir == 0) filter_level[1] = cm->lf.filter_level[1];
@@ -69,7 +69,7 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
 #else
   av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1,
                         partial_frame);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
 #else
   if (cpi->num_workers > 1)
     av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane,
@@ -85,7 +85,7 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
   highbd = cm->use_highbitdepth;
 #endif  // CONFIG_HIGHBITDEPTH
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   filt_err = aom_get_sse_plane(sd, cm->frame_to_show, plane, highbd);
 
   // Re-instate the unfiltered frame
@@ -95,14 +95,14 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
 
   // Re-instate the unfiltered frame
   yv12_copy_plane(&cpi->last_frame_uf, cm->frame_to_show, 0);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
 
   return filt_err;
 }
 
 int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
                             int partial_frame, double *best_cost_ret
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
                             ,
                             int plane, int dir
 #endif
@@ -118,7 +118,7 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
 
 // Start the search at the previous frame filter level unless it is now out of
 // range.
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   int lvl;
   switch (plane) {
     case 0: lvl = (dir == 1) ? lf->filter_level[1] : lf->filter_level[0]; break;
@@ -129,7 +129,7 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
   int filt_mid = clamp(lvl, min_filter_level, max_filter_level);
 #else
   int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
   int filter_step = filt_mid < 16 ? 4 : filt_mid / 4;
   // Sum squared error at each filter level
   int64_t ss_err[MAX_LOOP_FILTER + 1];
@@ -137,18 +137,18 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
   // Set each entry to -1
   memset(ss_err, 0xFF, sizeof(ss_err));
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   yv12_copy_plane(cm->frame_to_show, &cpi->last_frame_uf, plane);
 #else
   //  Make a copy of the unfiltered / processed recon buffer
   aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
 
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
   best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame, plane, dir);
 #else
   best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
   filt_best = filt_mid;
   ss_err[filt_mid] = best_err;
 
@@ -168,12 +168,12 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
     if (filt_direction <= 0 && filt_low != filt_mid) {
       // Get Low filter error score
       if (ss_err[filt_low] < 0) {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
         ss_err[filt_low] =
             try_filter_frame(sd, cpi, filt_low, partial_frame, plane, dir);
 #else
         ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
       }
       // If value is close to the best so far then bias towards a lower loop
       // filter value.
@@ -189,12 +189,12 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
     // Now look at filt_high
     if (filt_direction >= 0 && filt_high != filt_mid) {
       if (ss_err[filt_high] < 0) {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
         ss_err[filt_high] =
             try_filter_frame(sd, cpi, filt_high, partial_frame, plane, dir);
 #else
         ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
       }
       // If value is significantly better than previous best, bias added against
       // raising filter value
@@ -229,7 +229,7 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
   lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 : cpi->oxcf.sharpness;
 
   if (method == LPF_PICK_MINIMAL_LPF) {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     lf->filter_level[0] = 0;
     lf->filter_level[1] = 0;
 #else
@@ -263,14 +263,14 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
     int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18);
 #endif  // CONFIG_HIGHBITDEPTH
     if (cm->frame_type == KEY_FRAME) filt_guess -= 4;
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     lf->filter_level[0] = clamp(filt_guess, min_filter_level, max_filter_level);
     lf->filter_level[1] = clamp(filt_guess, min_filter_level, max_filter_level);
 #else
     lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level);
 #endif
   } else {
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
     lf->filter_level[0] = lf->filter_level[1] = av1_search_filter_level(
         sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 2);
     lf->filter_level[0] = av1_search_filter_level(
@@ -285,6 +285,6 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
 #else
     lf->filter_level = av1_search_filter_level(
         sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL);
-#endif  // CONFIG_UV_LVL
+#endif  // CONFIG_LOOPFILTER_LEVEL
   }
 }

av1/encoder/picklpf.h

@@ -21,7 +21,7 @@ extern "C" {
 struct yv12_buffer_config;
 struct AV1_COMP;
 int av1_get_max_filter_level(const AV1_COMP *cpi);
-#if CONFIG_UV_LVL
+#if CONFIG_LOOPFILTER_LEVEL
 int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi,
                             int partial_frame, double *err, int plane, int dir);
 #else

build/cmake/aom_config_defaults.cmake

@@ -199,7 +199,7 @@ set(CONFIG_TX64X64 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_TXK_SEL 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_TXMG 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_UNPOISON_PARTITION_CTX 0 CACHE NUMBER "AV1 experiment flag.")
-set(CONFIG_UV_LVL 0 CACHE NUMBER "AV1 experiment flag.")
+set(CONFIG_LOOPFILTER_LEVEL 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_VAR_REFS 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_VAR_TX 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_VAR_TX_NO_TX_MODE 0 CACHE NUMBER "AV1 experiment flag.")

configure

@@ -338,7 +338,7 @@ EXPERIMENT_LIST="
     var_tx_no_tx_mode
     mrc_tx
     lpf_direct
-    uv_lvl
+    loopfilter_level
     no_frame_context_signaling
     txmg
     hash_me