Remove lpf_sb

As loopfilter is not needed for intrabc, clean up related code.

Change-Id: If89d4969a7795cd8993e6add8fd03ef1296699ef

av1/common/av1_loopfilter.c

@@ -2208,18 +2208,8 @@ static void av1_filter_block_plane_vert(
   const uint32_t scale_vert = plane_ptr->subsampling_y;
   uint8_t *const dst_ptr = plane_ptr->dst.buf;
   const int dst_stride = plane_ptr->dst.stride;
-#if CONFIG_LPF_SB
-  int y_range = mi_row ? MAX_MIB_SIZE : MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET;
-  y_range = AOMMIN(y_range, cm->mi_rows);
-  y_range >>= scale_vert;
-
-  int x_range = mi_col ? MAX_MIB_SIZE : MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET;
-  x_range = AOMMIN(x_range, cm->mi_cols);
-  x_range >>= scale_horz;
-#else
   const int y_range = (MAX_MIB_SIZE >> scale_vert);
   const int x_range = (MAX_MIB_SIZE >> scale_horz);
-#endif  // CONFIG_LPF_SB
   for (int y = 0; y < y_range; y += row_step) {
     uint8_t *p = dst_ptr + y * MI_SIZE * dst_stride;
     for (int x = 0; x < x_range; x += col_step) {
@@ -2329,18 +2319,8 @@ static void av1_filter_block_plane_horz(
   const uint32_t scale_vert = plane_ptr->subsampling_y;
   uint8_t *const dst_ptr = plane_ptr->dst.buf;
   const int dst_stride = plane_ptr->dst.stride;
-#if CONFIG_LPF_SB
-  int y_range = mi_row ? MAX_MIB_SIZE : MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET;
-  y_range = AOMMIN(y_range, cm->mi_rows);
-  y_range >>= scale_vert;
-
-  int x_range = mi_col ? MAX_MIB_SIZE : MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET;
-  x_range = AOMMIN(x_range, cm->mi_cols);
-  x_range >>= scale_horz;
-#else
   const int y_range = (MAX_MIB_SIZE >> scale_vert);
   const int x_range = (MAX_MIB_SIZE >> scale_horz);
-#endif  // CONFIG_LPF_SB
   for (int y = 0; y < y_range; y += row_step) {
     uint8_t *p = dst_ptr + y * MI_SIZE * dst_stride;
     for (int x = 0; x < x_range; x += col_step) {
@@ -2443,9 +2423,6 @@ static void av1_filter_block_plane_horz(
 
 void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
                           struct macroblockd_plane *planes, int start, int stop,
-#if CONFIG_LPF_SB
-                          int col_start, int col_end,
-#endif
                           int y_only) {
 #if CONFIG_LOOPFILTER_LEVEL
   // y_only no longer has its original meaning.
@@ -2459,12 +2436,10 @@ void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
   const int plane_start = 0;
   const int plane_end = num_planes;
 #endif  // CONFIG_LOOPFILTER_LEVEL
-#if !CONFIG_LPF_SB
 #if CONFIG_PARALLEL_DEBLOCKING
   const int col_start = 0;
   const int col_end = cm->mi_cols;
 #endif
-#endif  // CONFIG_LPF_SB
   int mi_row, mi_col;
   int plane;
 
@@ -2516,12 +2491,7 @@ void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
 #if CONFIG_LOOPFILTER_LEVEL
                            int frame_filter_level_r,
 #endif
-                           int y_only, int partial_frame
-#if CONFIG_LPF_SB
-                           ,
-                           int mi_row, int mi_col
-#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_LOOPFILTER_LEVEL
@@ -2536,30 +2506,6 @@ void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
 #else
   if (!frame_filter_level) return;
 #endif
-#if CONFIG_LPF_SB
-  int start_mi_col;
-  int end_mi_col;
-
-  // In the experiment of deblocking filtering per superblock.
-  // When partial_frame is 1, it indicates we are searching for the best filter
-  // level for current superblock. We reuse frame_filter_level as filter level
-  // for superblock, no longer for the whole frame.
-  // When partial_frame is 0, it's in the actual filtering stage for the frame
-  if (partial_frame) {
-    start_mi_row = AOMMAX(0, mi_row - FILT_BOUNDARY_MI_OFFSET);
-    start_mi_col = AOMMAX(0, mi_col - FILT_BOUNDARY_MI_OFFSET);
-    const int mi_row_range = mi_row - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE;
-    const int mi_col_range = mi_col - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE;
-    end_mi_row = AOMMIN(mi_row_range, cm->mi_rows);
-    end_mi_col = AOMMIN(mi_col_range, cm->mi_cols);
-  } else {
-    start_mi_row = 0;
-    mi_rows_to_filter = cm->mi_rows;
-    end_mi_row = start_mi_row + mi_rows_to_filter;
-    start_mi_col = 0;
-    end_mi_col = cm->mi_cols;
-  }
-#else
   start_mi_row = 0;
   mi_rows_to_filter = cm->mi_rows;
   if (partial_frame && cm->mi_rows > 8) {
@@ -2576,7 +2522,6 @@ void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
 #else
   av1_loop_filter_frame_init(cm, frame_filter_level, frame_filter_level);
 #endif
-#endif  // CONFIG_LPF_SB
 
 #if CONFIG_EXT_DELTA_Q
 #if CONFIG_LOOPFILTER_LEVEL
@@ -2587,12 +2532,7 @@ void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
 #endif
 #endif
 
-#if CONFIG_LPF_SB
-  av1_loop_filter_rows(frame, cm, xd->plane, start_mi_row, end_mi_row,
-                       start_mi_col, end_mi_col, y_only);
-#else
   av1_loop_filter_rows(frame, cm, xd->plane, start_mi_row, end_mi_row, y_only);
-#endif  // CONFIG_LPF_SB
 
 #if CONFIG_EXT_DELTA_Q
 #if CONFIG_LOOPFILTER_LEVEL
@@ -2618,11 +2558,7 @@ void av1_loop_filter_data_reset(LFWorkerData *lf_data,
 
 int av1_loop_filter_worker(LFWorkerData *const lf_data, void *unused) {
   (void)unused;
-#if !CONFIG_LPF_SB
   av1_loop_filter_rows(lf_data->frame_buffer, lf_data->cm, lf_data->planes,
                        lf_data->start, lf_data->stop, lf_data->y_only);
-#else
-  (void)lf_data;
-#endif  // CONFIG_LPF_SB
   return 1;
 }

av1/common/av1_loopfilter.h

@@ -145,27 +145,6 @@ void av1_loop_filter_frame_init(struct AV1Common *cm, int default_filt_lvl,
 #endif
                                 );
 
-#if CONFIG_LPF_SB
-void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
-                           struct macroblockd *mbd, int filter_level,
-#if CONFIG_LOOPFILTER_LEVEL
-                           int frame_filter_level_r,
-#endif
-                           int y_only, int partial_frame, int mi_row,
-                           int mi_col);
-
-// Apply the loop filter to [start, stop) macro block rows in frame_buffer.
-void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer,
-                          struct AV1Common *cm,
-                          struct macroblockd_plane *planes, int start, int stop,
-                          int col_start, int col_end, int y_only);
-
-void av1_loop_filter_sb_level_init(struct AV1Common *cm, int mi_row, int mi_col,
-#if CONFIG_LOOPFILTER_LEVEL
-                                   int plane, int dir,
-#endif
-                                   int lvl);
-#else
 void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
                            struct macroblockd *mbd, int filter_level,
 #if CONFIG_LOOPFILTER_LEVEL
@@ -178,7 +157,6 @@ void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer,
                           struct AV1Common *cm,
                           struct macroblockd_plane *planes, int start, int stop,
                           int y_only);
-#endif  // CONFIG_LPF_SB
 
 typedef struct LoopFilterWorkerData {
   YV12_BUFFER_CONFIG *frame_buffer;

av1/common/blockd.h

@@ -320,20 +320,6 @@ typedef struct MB_MODE_INFO {
 #endif
 
   BOUNDARY_TYPE boundary_info;
-#if CONFIG_LPF_SB
-#if CONFIG_LOOPFILTER_LEVEL
-  // 0: y plane vert, 1: y plane horz, 2: u plane, 3: v plane
-  uint8_t filt_lvl[4];
-  int reuse_sb_lvl[4];
-  int sign[4];
-  int delta[4];
-#else
-  uint8_t filt_lvl;
-  int reuse_sb_lvl;
-  int sign;
-  int delta;
-#endif  // CONFIG_LOOPFILTER_LEVEL
-#endif  // CONFIG_LPF_SB
 
 #if CONFIG_JNT_COMP
   int compound_idx;

av1/common/enums.h

@@ -96,12 +96,6 @@ extern "C" {
 #define DEFAULT_DELTA_LF_MULTI 0
 #endif  // CONFIG_LOOPFILTER_LEVEL
 
-#if CONFIG_LPF_SB
-// Half of maximum loop filter length (15-tap)
-#define FILT_BOUNDARY_OFFSET 0
-#define FILT_BOUNDARY_MI_OFFSET (FILT_BOUNDARY_OFFSET >> MI_SIZE_LOG2)
-#endif  // CONFIG_LPF_SB
-
 #if CONFIG_JNT_COMP
 typedef enum COMPOUND_DIST_WEIGHT_MODE {
   DIST,

av1/common/mvref_common.h

@@ -461,9 +461,6 @@ int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
 #define INTRABC_DELAY_PIXELS 256  //  Delay of 256 pixels
 #define INTRABC_DELAY_SB64 (INTRABC_DELAY_PIXELS / 64)
 #define USE_WAVE_FRONT 1  // Use only top left area of frame for reference.
-#if CONFIG_LPF_SB
-#define INTRABC_FILTER_DELAY 8  // Delay of 8 pixels
-#endif                          // CONFIG_LPF_SB
 
 static INLINE void av1_find_ref_dv(int_mv *ref_dv, const TileInfo *const tile,
                                    int mib_size, int mi_row, int mi_col) {
@@ -497,24 +494,11 @@ static INLINE int av1_is_dv_valid(const MV dv, const TileInfo *const tile,
   const int src_left_edge = mi_col * MI_SIZE * SCALE_PX_TO_MV + dv.col;
   const int tile_left_edge = tile->mi_col_start * MI_SIZE * SCALE_PX_TO_MV;
   if (src_left_edge < tile_left_edge) return 0;
-// Is the bottom right inside the current tile?
-#if CONFIG_LPF_SB
-  // Because of loop filter, the bottom 8 rows and the rightmost 8 cols of
-  // IntraBC area now is invalid. It is equal to let the valid region add an
-  // offset of the filter delay
-  const int src_bottom_edge =
-      (mi_row * MI_SIZE + bh + INTRABC_FILTER_DELAY) * SCALE_PX_TO_MV + dv.row;
-#else
+  // Is the bottom right inside the current tile?
   const int src_bottom_edge = (mi_row * MI_SIZE + bh) * SCALE_PX_TO_MV + dv.row;
-#endif  // CONFIG_LPF_SB
   const int tile_bottom_edge = tile->mi_row_end * MI_SIZE * SCALE_PX_TO_MV;
   if (src_bottom_edge > tile_bottom_edge) return 0;
-#if CONFIG_LPF_SB
-  const int src_right_edge =
-      (mi_col * MI_SIZE + bw + INTRABC_FILTER_DELAY) * SCALE_PX_TO_MV + dv.col;
-#else
   const int src_right_edge = (mi_col * MI_SIZE + bw) * SCALE_PX_TO_MV + dv.col;
-#endif  // CONFIG_LPF_SB
   const int tile_right_edge = tile->mi_col_end * MI_SIZE * SCALE_PX_TO_MV;
   if (src_right_edge > tile_right_edge) return 0;
 

av1/decoder/decodeframe.c

@@ -992,9 +992,9 @@ static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
 #endif  // CONFIG_LOOP_RESTORATION
 
 static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-#if CONFIG_INTRABC && !CONFIG_LPF_SB
+#if CONFIG_INTRABC
   if (cm->allow_intrabc && NO_FILTER_FOR_IBC) return;
-#endif  // CONFIG_INTRABC && !CONFIG_LPF_SB
+#endif  // CONFIG_INTRABC
   struct loopfilter *lf = &cm->lf;
 #if CONFIG_LOOPFILTER_LEVEL
   lf->filter_level[0] = aom_rb_read_literal(rb, 6);
@@ -2098,27 +2098,6 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
 #endif
           decode_partition(pbi, &td->xd, mi_row, mi_col, &td->bit_reader,
                            cm->sb_size);
-#if CONFIG_LPF_SB
-          if (cm->allow_screen_content_tools) {
-#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, 1, mi_row,
-                                    mi_col);
-              av1_loop_filter_frame(
-                  get_frame_new_buffer(cm), cm, &pbi->mb, cm->lf.filter_level_u,
-                  cm->lf.filter_level_u, 1, 1, mi_row, mi_col);
-              av1_loop_filter_frame(
-                  get_frame_new_buffer(cm), cm, &pbi->mb, cm->lf.filter_level_v,
-                  cm->lf.filter_level_v, 2, 1, mi_row, mi_col);
-            }
-#else
-            av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb,
-                                  cm->lf.filter_level, 0, 1, mi_row, mi_col);
-#endif  // CONFIG_LOOPFILTER_LEVEL
-          }
-#endif  // CONFIG_LPF_SB
         }
         aom_merge_corrupted_flag(&pbi->mb.corrupted, td->xd.corrupted);
         if (pbi->mb.corrupted)
@@ -2137,12 +2116,11 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
       av1_frameworker_broadcast(pbi->cur_buf, mi_row << cm->mib_size_log2);
   }
 
-#if CONFIG_INTRABC && !CONFIG_LPF_SB
+#if CONFIG_INTRABC
   if (!(cm->allow_intrabc && NO_FILTER_FOR_IBC))
-#endif  // CONFIG_INTRABC && !CONFIG_LPF_SB
+#endif  // CONFIG_INTRABC
   {
 // Loopfilter the whole frame.
-#if !CONFIG_LPF_SB
 #if CONFIG_OBU
     if (endTile == cm->tile_rows * cm->tile_cols - 1)
 #endif
@@ -2162,7 +2140,6 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
     av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb,
                           cm->lf.filter_level, 0, 0);
 #endif  // CONFIG_LOOPFILTER_LEVEL
-#endif  // CONFIG_LPF_SB
   }
   if (cm->frame_parallel_decode)
     av1_frameworker_broadcast(pbi->cur_buf, INT_MAX);

av1/encoder/bitstream.c

@@ -2439,9 +2439,9 @@ static void loop_restoration_write_sb_coeffs(const AV1_COMMON *const cm,
 #endif  // CONFIG_LOOP_RESTORATION
 
 static void encode_loopfilter(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) {
-#if CONFIG_INTRABC && !CONFIG_LPF_SB
+#if CONFIG_INTRABC
   if (cm->allow_intrabc && NO_FILTER_FOR_IBC) return;
-#endif  // CONFIG_INTRABC && !CONFIG_LPF_SB
+#endif  // CONFIG_INTRABC
   int i;
   struct loopfilter *lf = &cm->lf;
 

av1/encoder/encodeframe.c

@@ -56,9 +56,6 @@
 #endif
 #include "av1/encoder/ethread.h"
 #include "av1/encoder/extend.h"
-#if CONFIG_LPF_SB
-#include "av1/encoder/picklpf.h"
-#endif
 #include "av1/encoder/rd.h"
 #include "av1/encoder/rdopt.h"
 #include "av1/encoder/segmentation.h"
@@ -3096,34 +3093,6 @@ static void encode_rd_sb_row(AV1_COMP *cpi, ThreadData *td,
       rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, cm->sb_size,
                         &dummy_rdc, INT64_MAX, pc_root, NULL);
     }
-#if CONFIG_LPF_SB
-    // TODO(chengchen): change to allow intraBC. It requires to store the
-    // unfiltered frame to a buffer and process later.
-    if (cm->allow_screen_content_tools) {
-#if CONFIG_LOOPFILTER_LEVEL
-      int filter_lvl[4];
-
-      struct loopfilter *lf = &cpi->common.lf;
-      filter_lvl[0] = lf->filter_level[0];
-      filter_lvl[1] = lf->filter_level[1];
-      filter_lvl[2] = lf->filter_level_u;
-      filter_lvl[3] = lf->filter_level_v;
-      av1_loop_filter_frame(cm->frame_to_show, cm, xd, filter_lvl[0],
-                            filter_lvl[1], 0, 1, mi_row, mi_col);
-      av1_loop_filter_frame(cm->frame_to_show, cm, xd, filter_lvl[2],
-                            filter_lvl[2], 1, 1, mi_row, mi_col);
-      av1_loop_filter_frame(cm->frame_to_show, cm, xd, filter_lvl[3],
-                            filter_lvl[3], 2, 1, mi_row, mi_col);
-#else
-      int filter_lvl;
-
-      struct loopfilter *lf = &cpi->common.lf;
-      filter_lvl = lf->filter_level;
-      av1_loop_filter_frame(get_frame_new_buffer(cm), cm, xd, filter_lvl, 0, 1,
-                            mi_row, mi_col);
-#endif  // CONFIG_LOOPFILTER_LEVEL
-    }
-#endif  // CONFIG_LPF_SB
   }
 }
 
@@ -3296,11 +3265,6 @@ static void encode_tiles(AV1_COMP *cpi) {
 
   av1_init_tile_data(cpi);
 
-#if CONFIG_LPF_SB
-  cm->frame_to_show = get_frame_new_buffer(cm);
-  av1_pick_filter_level(cpi->source, cpi, LPF_PICK_FROM_Q);
-#endif
-
   for (tile_row = 0; tile_row < cm->tile_rows; ++tile_row)
     for (tile_col = 0; tile_col < cm->tile_cols; ++tile_col)
       av1_encode_tile(cpi, &cpi->td, tile_row, tile_col);

av1/encoder/encoder.c

@@ -5291,11 +5291,7 @@ static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
       || cm->large_scale_tile
 #endif  // CONFIG_EXT_TILE
       ) {
-#if CONFIG_LPF_SB
-    if (!cm->allow_screen_content_tools) no_loopfilter = 1;
-#else
     no_loopfilter = 1;
-#endif  // CONFIG_LPF_SB
 #if CONFIG_LOOP_RESTORATION
     no_restoration = 1;
 #endif  // CONFIG_LOOP_RESTORATION
@@ -5327,26 +5323,18 @@ static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
 
     aom_usec_timer_start(&timer);
 
-#if !CONFIG_LPF_SB
     av1_pick_filter_level(cpi->source, cpi, cpi->sf.lpf_pick);
-#endif
 
     aom_usec_timer_mark(&timer);
     cpi->time_pick_lpf += aom_usec_timer_elapsed(&timer);
   }
 
-#if !CONFIG_LPF_SB
 #if CONFIG_LOOPFILTER_LEVEL
   if (lf->filter_level[0] || lf->filter_level[1])
 #else
   if (lf->filter_level > 0)
 #endif
-#endif  // CONFIG_LPF_SB
   {
-#if CONFIG_LPF_SB && !CONFIG_LOOPFILTER_LEVEL
-    av1_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0, 0,
-                          0);
-#elif !CONFIG_LPF_SB
 #if CONFIG_LOOPFILTER_LEVEL
     av1_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level[0],
                           lf->filter_level[1], 0, 0);
@@ -5358,7 +5346,6 @@ 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_LOOPFILTER_LEVEL
-#endif  // CONFIG_LPF_SB
   }
 
 #if CONFIG_STRIPED_LOOP_RESTORATION

av1/encoder/picklpf.c

@@ -27,7 +27,6 @@
 #include "av1/encoder/encoder.h"
 #include "av1/encoder/picklpf.h"
 
-#if !CONFIG_LPF_SB
 static void yv12_copy_plane(const YV12_BUFFER_CONFIG *src_bc,
                             YV12_BUFFER_CONFIG *dst_bc, int plane) {
   switch (plane) {
@@ -37,7 +36,6 @@ static void yv12_copy_plane(const YV12_BUFFER_CONFIG *src_bc,
     default: assert(plane >= 0 && plane <= 2); break;
   }
 }
-#endif  // CONFIG_LPF_SB
 
 int av1_get_max_filter_level(const AV1_COMP *cpi) {
   if (cpi->oxcf.pass == 2) {
@@ -48,7 +46,6 @@ int av1_get_max_filter_level(const AV1_COMP *cpi) {
   }
 }
 
-#if !CONFIG_LPF_SB