Change CDEF block skip condition and move signalling
Previously CDEF was implicitly disabled for a filter block if all its
sub-blocks were skip, and no bits for that block was signalled. That
required the CDEF signal to be transmitted at the end of the block,
and it was not possible to begin the filtering of the block before
that.
This patch moves the signalling to just after the first zero skip bit
within a 64x64, 128x64, 64x128 or 128x128 block. If sub-blocks are
skip, then no CDEF bits will be signalled, as before. Also, the skip
condition flag has been removed so it's always known at the skip flag
whether a coding block is to be filtered or not.
Change-Id: I3adfa3d2d01e288b7db876198aa9985ee9f53917
diff --git a/av1/common/cdef.c b/av1/common/cdef.c
index 277f9f8..d1f5eaa 100644
--- a/av1/common/cdef.c
+++ b/av1/common/cdef.c
@@ -50,8 +50,14 @@
return is_skip;
}
+#if CONFIG_EXT_PARTITION
int sb_compute_cdef_list(const AV1_COMMON *const cm, int mi_row, int mi_col,
- cdef_list *dlist, int filter_skip) {
+ cdef_list *dlist, BLOCK_SIZE bs)
+#else
+int sb_compute_cdef_list(const AV1_COMMON *const cm, int mi_row, int mi_col,
+ cdef_list *dlist)
+#endif
+{
int r, c;
int maxc, maxr;
MODE_INFO **grid;
@@ -60,8 +66,19 @@
maxc = cm->mi_cols - mi_col;
maxr = cm->mi_rows - mi_row;
+#if CONFIG_EXT_PARTITION
+ if (bs == BLOCK_128X128 || bs == BLOCK_128X64 || bs == BLOCK_128X32)
+ maxc = AOMMIN(maxc, MI_SIZE_128X128);
+ else
+ maxc = AOMMIN(maxc, MI_SIZE_64X64);
+ if (bs == BLOCK_128X128 || bs == BLOCK_64X128 || bs == BLOCK_32X128)
+ maxr = AOMMIN(maxr, MI_SIZE_128X128);
+ else
+ maxr = AOMMIN(maxr, MI_SIZE_64X64);
+#else
maxr = AOMMIN(maxr, MI_SIZE_64X64);
maxc = AOMMIN(maxc, MI_SIZE_64X64);
+#endif
const int r_step = mi_size_high[BLOCK_8X8];
const int c_step = mi_size_wide[BLOCK_8X8];
@@ -71,27 +88,15 @@
assert(r_step == 1 || r_step == 2);
assert(c_step == 1 || c_step == 2);
- if (filter_skip) {
- for (r = 0; r < maxr; r += r_step) {
- for (c = 0; c < maxc; c += c_step) {
+ for (r = 0; r < maxr; r += r_step) {
+ for (c = 0; c < maxc; c += c_step) {
+ if (!is_8x8_block_skip(grid, mi_row + r, mi_col + c, cm->mi_stride)) {
dlist[count].by = r >> r_shift;
dlist[count].bx = c >> c_shift;
- dlist[count].skip =
- is_8x8_block_skip(grid, mi_row + r, mi_col + c, cm->mi_stride);
+ dlist[count].skip = 0;
count++;
}
}
- } else {
- for (r = 0; r < maxr; r += r_step) {
- for (c = 0; c < maxc; c += c_step) {
- if (!is_8x8_block_skip(grid, mi_row + r, mi_col + c, cm->mi_stride)) {
- dlist[count].by = r >> r_shift;
- dlist[count].bx = c >> c_shift;
- dlist[count].skip = 0;
- count++;
- }
- }
- }
}
return count;
}
@@ -259,12 +264,13 @@
uv_sec_strength += uv_sec_strength == 3;
if ((level == 0 && sec_strength == 0 && uv_level == 0 &&
uv_sec_strength == 0) ||
- (cdef_count = sb_compute_cdef_list(
- cm, fbr * MI_SIZE_64X64, fbc * MI_SIZE_64X64, dlist,
-#if CONFIG_CDEF_SINGLEPASS
- (level & 1) || (uv_level & 1))) == 0)
+#if CONFIG_EXT_PARTITION
+ (cdef_count = sb_compute_cdef_list(cm, fbr * MI_SIZE_64X64,
+ fbc * MI_SIZE_64X64, dlist,
+ BLOCK_64X64)) == 0)
#else
- get_filter_skip(level) || get_filter_skip(uv_level))) == 0)
+ (cdef_count = sb_compute_cdef_list(cm, fbr * MI_SIZE_64X64,
+ fbc * MI_SIZE_64X64, dlist)) == 0)
#endif
{
cdef_left = 0;
@@ -425,14 +431,14 @@
#if CONFIG_CDEF_SINGLEPASS
NULL, xd->plane[pli].dst.stride,
#else
- xd->plane[pli].dst.stride, dst,
+ xd->plane[pli].dst.stride, dst,
#endif
&src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], xdec[pli],
ydec[pli], dir, NULL, var, pli, dlist, cdef_count, level,
#if CONFIG_CDEF_SINGLEPASS
sec_strength, pri_damping, sec_damping, coeff_shift);
#else
- sec_strength, sec_damping, pri_damping, coeff_shift, 0, 0);
+ sec_strength, sec_damping, pri_damping, coeff_shift, 0, 0);
#endif
#if CONFIG_HIGHBITDEPTH
diff --git a/av1/common/cdef.h b/av1/common/cdef.h
index 9de24bf..d95b103 100644
--- a/av1/common/cdef.h
+++ b/av1/common/cdef.h
@@ -11,9 +11,9 @@
#ifndef AV1_COMMON_CDEF_H_
#define AV1_COMMON_CDEF_H_
-#define CDEF_STRENGTH_BITS 7
+#define CDEF_STRENGTH_BITS 6
-#define CDEF_PRI_STRENGTHS 32
+#define CDEF_PRI_STRENGTHS 16
#define CDEF_SEC_STRENGTHS 4
#include "./aom_config.h"
@@ -37,8 +37,13 @@
#endif
int sb_all_skip(const AV1_COMMON *const cm, int mi_row, int mi_col);
+#if CONFIG_EXT_PARTITION
int sb_compute_cdef_list(const AV1_COMMON *const cm, int mi_row, int mi_col,
- cdef_list *dlist, int filter_skip);
+ cdef_list *dlist, BLOCK_SIZE bsize);
+#else
+int sb_compute_cdef_list(const AV1_COMMON *const cm, int mi_row, int mi_col,
+ cdef_list *dlist);
+#endif
void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd);
void av1_cdef_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref,
diff --git a/av1/common/cdef_block.c b/av1/common/cdef_block.c
index b4d45aa..063461a 100644
--- a/av1/common/cdef_block.c
+++ b/av1/common/cdef_block.c
@@ -394,12 +394,6 @@
}
}
-int get_filter_skip(int level) {
- int filter_skip = level & 1;
- if (level == 1) filter_skip = 0;
- return filter_skip;
-}
-
void cdef_filter_fb(uint8_t *dst, int dstride, uint16_t *y, uint16_t *in,
int xdec, int ydec, int dir[CDEF_NBLOCKS][CDEF_NBLOCKS],
int *dirinit, int var[CDEF_NBLOCKS][CDEF_NBLOCKS], int pli,
@@ -421,17 +415,10 @@
int bsize, bsizex, bsizey;
#if CONFIG_CDEF_SINGLEPASS
- int pri_strength = (level >> 1) << coeff_shift;
- int filter_skip = level & 1;
+ int pri_strength = level << coeff_shift;
sec_strength <<= coeff_shift;
- if (!pri_strength && !sec_strength && filter_skip) {
- pri_strength = 19 << coeff_shift;
- sec_strength = 7 << coeff_shift;
- }
#else
- int threshold = (level >> 1) << coeff_shift;
- int filter_skip = get_filter_skip(level);
- if (level == 1) threshold = 31 << coeff_shift;
+ int threshold = level << coeff_shift;
cdef_direction_func cdef_direction[] = { cdef_direction_4x4,
cdef_direction_8x8 };
@@ -474,7 +461,7 @@
if (threshold != 0) {
assert(bsize == BLOCK_8X8 || bsize == BLOCK_4X4);
for (bi = 0; bi < cdef_count; bi++) {
- int t = !filter_skip && dlist[bi].skip ? 0 : threshold;
+ int t = dlist[bi].skip ? 0 : threshold;
by = dlist[bi].by;
bx = dlist[bi].bx;
(cdef_direction[bsize == BLOCK_8X8])(
@@ -495,7 +482,7 @@
int py = by << bsizey;
int px = bx << bsizex;
- if (!filter_skip && dlist[bi].skip) continue;
+ if (dlist[bi].skip) continue;
if (!dst || hbd) {
// 16 bit destination if high bitdepth or 8 bit destination not given
(!threshold || (dir[by][bx] < 4 && dir[by][bx]) ? aom_clpf_block_hbd
@@ -561,8 +548,8 @@
assert(bsize == BLOCK_8X8 || bsize == BLOCK_4X4);
for (bi = 0; bi < cdef_count; bi++) {
- int t = !filter_skip && dlist[bi].skip ? 0 : pri_strength;
- int s = !filter_skip && dlist[bi].skip ? 0 : sec_strength;
+ int t = dlist[bi].skip ? 0 : pri_strength;
+ int s = dlist[bi].skip ? 0 : sec_strength;
by = dlist[bi].by;
bx = dlist[bi].bx;
if (dst8)
diff --git a/av1/common/cdef_block.h b/av1/common/cdef_block.h
index b642107..bf93802 100644
--- a/av1/common/cdef_block.h
+++ b/av1/common/cdef_block.h
@@ -16,7 +16,7 @@
#define CDEF_BLOCKSIZE 64
#define CDEF_BLOCKSIZE_LOG2 6
-#define CDEF_NBLOCKS (CDEF_BLOCKSIZE / 8)
+#define CDEF_NBLOCKS ((1 << MAX_SB_SIZE_LOG2) / 8)
#if CONFIG_CDEF_SINGLEPASS
#define CDEF_SB_SHIFT (MAX_SB_SIZE_LOG2 - CDEF_BLOCKSIZE_LOG2)
#endif
@@ -26,10 +26,12 @@
/* We only need to buffer three horizontal pixels too, but let's align to
16 bytes (8 x 16 bits) to make vectorization easier. */
#define CDEF_HBORDER (8)
-#define CDEF_BSTRIDE ALIGN_POWER_OF_TWO(CDEF_BLOCKSIZE + 2 * CDEF_HBORDER, 3)
+#define CDEF_BSTRIDE \
+ ALIGN_POWER_OF_TWO((1 << MAX_SB_SIZE_LOG2) + 2 * CDEF_HBORDER, 3)
#define CDEF_VERY_LARGE (30000)
-#define CDEF_INBUF_SIZE (CDEF_BSTRIDE * (CDEF_BLOCKSIZE + 2 * CDEF_VBORDER))
+#define CDEF_INBUF_SIZE \
+ (CDEF_BSTRIDE * ((1 << MAX_SB_SIZE_LOG2) + 2 * CDEF_VBORDER))
#if CONFIG_CDEF_SINGLEPASS
// Filter configuration
@@ -70,7 +72,6 @@
const uint16_t *in, int threshold, int dir,
int damping);
-int get_filter_skip(int level);
#endif
#if CONFIG_CDEF_SINGLEPASS
diff --git a/av1/common/enums.h b/av1/common/enums.h
index db553a4..8b97cd3 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -71,6 +71,9 @@
#define MAX_VARTX_DEPTH 2
#define MI_SIZE_64X64 (64 >> MI_SIZE_LOG2)
+#if CONFIG_EXT_PARTITION
+#define MI_SIZE_128X128 (128 >> MI_SIZE_LOG2)
+#endif
#define MIN_PALETTE_BSIZE BLOCK_8X8
#define MAX_PALETTE_BSIZE BLOCK_64X64
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 21c785c..2faac10 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -538,6 +538,11 @@
int cdef_strengths[CDEF_MAX_STRENGTHS];
int cdef_uv_strengths[CDEF_MAX_STRENGTHS];
int cdef_bits;
+#if CONFIG_EXT_PARTITION
+ int cdef_preset[4];
+#else
+ int cdef_preset;
+#endif
int delta_q_present_flag;
// Resolution of delta quant
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 1d62c41..65b3ddf 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -903,24 +903,6 @@
}
#endif
- if (bsize == cm->sb_size) {
- int width_step = mi_size_wide[BLOCK_64X64];
- int height_step = mi_size_wide[BLOCK_64X64];
- int w, h;
- for (h = 0; (h < mi_size_high[cm->sb_size]) && (mi_row + h < cm->mi_rows);
- h += height_step) {
- for (w = 0; (w < mi_size_wide[cm->sb_size]) && (mi_col + w < cm->mi_cols);
- w += width_step) {
- if (!cm->all_lossless && !sb_all_skip(cm, mi_row + h, mi_col + w))
- cm->mi_grid_visible[(mi_row + h) * cm->mi_stride + (mi_col + w)]
- ->mbmi.cdef_strength =
- aom_read_literal(r, cm->cdef_bits, ACCT_STR);
- else
- cm->mi_grid_visible[(mi_row + h) * cm->mi_stride + (mi_col + w)]
- ->mbmi.cdef_strength = -1;
- }
- }
- }
#if CONFIG_LOOP_RESTORATION
for (int plane = 0; plane < av1_num_planes(cm); ++plane) {
int rcol0, rcol1, rrow0, rrow1, tile_tl_idx;
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index ee84d27..aab0470 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -41,6 +41,40 @@
return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR);
}
+static void read_cdef(AV1_COMMON *cm, aom_reader *r, MB_MODE_INFO *const mbmi,
+ int mi_col, int mi_row) {
+ if (cm->all_lossless) return;
+
+ const int m = ~((1 << (6 - MI_SIZE_LOG2)) - 1);
+ if (!(mi_col & (cm->mib_size - 1)) &&
+ !(mi_row & (cm->mib_size - 1))) { // Top left?
+#if CONFIG_EXT_PARTITION
+ cm->cdef_preset[0] = cm->cdef_preset[1] = cm->cdef_preset[2] =
+ cm->cdef_preset[3] = -1;
+#else
+ cm->cdef_preset = -1;
+#endif
+ }
+// Read CDEF param at first a non-skip coding block
+#if CONFIG_EXT_PARTITION
+ const int mask = 1 << (6 - MI_SIZE_LOG2);
+ const int index = cm->sb_size == BLOCK_128X128
+ ? !!(mi_col & mask) + 2 * !!(mi_row & mask)
+ : 0;
+ cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]
+ ->mbmi.cdef_strength = cm->cdef_preset[index] =
+ cm->cdef_preset[index] == -1 && !mbmi->skip
+ ? aom_read_literal(r, cm->cdef_bits, ACCT_STR)
+ : cm->cdef_preset[index];
+#else
+ cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]
+ ->mbmi.cdef_strength = cm->cdef_preset =
+ cm->cdef_preset == -1 && !mbmi->skip
+ ? aom_read_literal(r, cm->cdef_bits, ACCT_STR)
+ : cm->cdef_preset;
+#endif
+}
+
static int read_delta_qindex(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r,
MB_MODE_INFO *const mbmi, int mi_col, int mi_row) {
FRAME_COUNTS *counts = xd->counts;
@@ -1047,10 +1081,13 @@
mbmi->segment_id = read_intra_segment_id(cm, xd, mi_offset, x_mis, y_mis, r);
mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
+
#if CONFIG_Q_SEGMENTATION
mbmi->q_segment_id = read_q_segment_id(cm, xd, mi_row, mi_col, r);
#endif
+ read_cdef(cm, r, mbmi, mi_col, mi_row);
+
if (cm->delta_q_present_flag) {
xd->current_qindex =
xd->prev_qindex +
@@ -2249,6 +2286,8 @@
mbmi->q_segment_id = read_q_segment_id(cm, xd, mi_row, mi_col, r);
#endif // CONFIG_Q_SEGMENTATION
+ read_cdef(cm, r, mbmi, mi_col, mi_row);
+
if (cm->delta_q_present_flag) {
xd->current_qindex =
xd->prev_qindex +
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 31cff4e..7b953c9 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1177,6 +1177,42 @@
}
#endif
+static void write_cdef(AV1_COMMON *cm, aom_writer *w, int skip, int mi_col,
+ int mi_row) {
+ if (cm->all_lossless) return;
+
+ const int m = ~((1 << (6 - MI_SIZE_LOG2)) - 1);
+ const MB_MODE_INFO *mbmi =
+ &cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]->mbmi;
+ // Initialise when at top left part of the superblock
+ if (!(mi_row & (cm->mib_size - 1)) &&
+ !(mi_col & (cm->mib_size - 1))) { // Top left?
+#if CONFIG_EXT_PARTITION
+ cm->cdef_preset[0] = cm->cdef_preset[1] = cm->cdef_preset[2] =
+ cm->cdef_preset[3] = -1;
+#else
+ cm->cdef_preset = -1;
+#endif
+ }
+
+// Emit CDEF param at first non-skip coding block
+#if CONFIG_EXT_PARTITION
+ const int mask = 1 << (6 - MI_SIZE_LOG2);
+ const int index = cm->sb_size == BLOCK_128X128
+ ? !!(mi_col & mask) + 2 * !!(mi_row & mask)
+ : 0;
+ if (cm->cdef_preset[index] == -1 && !skip) {
+ aom_write_literal(w, mbmi->cdef_strength, cm->cdef_bits);
+ cm->cdef_preset[index] = mbmi->cdef_strength;
+ }
+#else
+ if (cm->cdef_preset == -1 && !skip) {
+ aom_write_literal(w, mbmi->cdef_strength, cm->cdef_bits);
+ cm->cdef_preset = mbmi->cdef_strength;
+ }
+#endif
+}
+
static void pack_inter_mode_mvs(AV1_COMP *cpi, const int mi_row,
const int mi_col, aom_writer *w) {
AV1_COMMON *const cm = &cpi->common;
@@ -1227,6 +1263,8 @@
write_q_segment_id(cm, skip, mbmi, w, seg, segp, bsize, mi_row, mi_col);
#endif // CONFIG_Q_SEGMENTATION
+ write_cdef(cm, w, skip, mi_col, mi_row);
+
if (cm->delta_q_present_flag) {
int super_block_upper_left = ((mi_row & (cm->mib_size - 1)) == 0) &&
((mi_col & (cm->mib_size - 1)) == 0);
@@ -1494,9 +1532,13 @@
if (seg->update_map) write_segment_id(w, seg, segp, mbmi->segment_id);
const int skip = write_skip(cm, xd, mbmi->segment_id, mi, w);
+
#if CONFIG_Q_SEGMENTATION
write_q_segment_id(cm, skip, mbmi, w, seg, segp, bsize, mi_row, mi_col);
#endif
+
+ write_cdef(cm, w, skip, mi_col, mi_row);
+
if (cm->delta_q_present_flag) {
int super_block_upper_left = ((mi_row & (cm->mib_size - 1)) == 0) &&
((mi_col & (cm->mib_size - 1)) == 0);
@@ -2243,26 +2285,6 @@
}
#endif
- if (bsize == cm->sb_size && cm->cdef_bits != 0 && !cm->all_lossless) {
- int width_step = mi_size_wide[BLOCK_64X64];
- int height_step = mi_size_high[BLOCK_64X64];
- int width, height;
- for (height = 0; (height < mi_size_high[cm->sb_size]) &&
- (mi_row + height < cm->mi_rows);
- height += height_step) {
- for (width = 0; (width < mi_size_wide[cm->sb_size]) &&
- (mi_col + width < cm->mi_cols);
- width += width_step) {
- if (!sb_all_skip(cm, mi_row + height, mi_col + width))
- aom_write_literal(
- w,
- cm->mi_grid_visible[(mi_row + height) * cm->mi_stride +
- (mi_col + width)]
- ->mbmi.cdef_strength,
- cm->cdef_bits);
- }
- }
- }
#if CONFIG_LOOP_RESTORATION
for (int plane = 0; plane < av1_num_planes(cm); ++plane) {
int rcol0, rcol1, rrow0, rrow1, tile_tl_idx;
diff --git a/av1/encoder/pickcdef.c b/av1/encoder/pickcdef.c
index c9c8ca9..0b35d97 100644
--- a/av1/encoder/pickcdef.c
+++ b/av1/encoder/pickcdef.c
@@ -23,7 +23,7 @@
#define REDUCED_TOTAL_STRENGTHS (REDUCED_PRI_STRENGTHS * CDEF_SEC_STRENGTHS)
#define TOTAL_STRENGTHS (CDEF_PRI_STRENGTHS * CDEF_SEC_STRENGTHS)
-static int priconv[REDUCED_PRI_STRENGTHS] = { 0, 1, 2, 3, 4, 7, 12, 25 };
+static int priconv[REDUCED_PRI_STRENGTHS] = { 0, 1, 2, 3, 5, 7, 10, 13 };
/* Search for the best strength to add as an option, knowing we
already selected nb_strengths options. */
@@ -290,7 +290,11 @@
int fbr, fbc;
uint16_t *src[3];
uint16_t *ref_coeff[3];
+#if CONFIG_EXT_PARTITION
+ static cdef_list dlist[MI_SIZE_128X128 * MI_SIZE_128X128];
+#else
cdef_list dlist[MI_SIZE_64X64 * MI_SIZE_64X64];
+#endif
int dir[CDEF_NBLOCKS][CDEF_NBLOCKS] = { { 0 } };
int var[CDEF_NBLOCKS][CDEF_NBLOCKS] = { { 0 } };
int stride[3];
@@ -325,7 +329,7 @@
const int total_strengths = fast ? REDUCED_TOTAL_STRENGTHS : TOTAL_STRENGTHS;
DECLARE_ALIGNED(32, uint16_t, inbuf[CDEF_INBUF_SIZE]);
uint16_t *in;
- DECLARE_ALIGNED(32, uint16_t, tmp_dst[CDEF_BLOCKSIZE * CDEF_BLOCKSIZE]);
+ DECLARE_ALIGNED(32, uint16_t, tmp_dst[1 << (MAX_SB_SIZE_LOG2 * 2)]);
int chroma_cdef = xd->plane[1].subsampling_x == xd->plane[1].subsampling_y &&
xd->plane[2].subsampling_x == xd->plane[2].subsampling_y;
quantizer =
@@ -397,12 +401,37 @@
int dirinit = 0;
nhb = AOMMIN(MI_SIZE_64X64, cm->mi_cols - MI_SIZE_64X64 * fbc);
nvb = AOMMIN(MI_SIZE_64X64, cm->mi_rows - MI_SIZE_64X64 * fbr);
- cm->mi_grid_visible[MI_SIZE_64X64 * fbr * cm->mi_stride +
- MI_SIZE_64X64 * fbc]
- ->mbmi.cdef_strength = -1;
+#if CONFIG_EXT_PARTITION
+ BLOCK_SIZE bs = BLOCK_64X64;
+ MB_MODE_INFO *const mbmi =
+ &cm->mi_grid_visible[MI_SIZE_64X64 * fbr * cm->mi_stride +
+ MI_SIZE_64X64 * fbc]
+ ->mbmi;
+ if (((fbc & 1) &&
+ (mbmi->sb_type == BLOCK_128X128 || mbmi->sb_type == BLOCK_128X64 ||
+ mbmi->sb_type == BLOCK_128X32)) ||
+ ((fbr & 1) &&
+ (mbmi->sb_type == BLOCK_128X128 || mbmi->sb_type == BLOCK_64X128 ||
+ mbmi->sb_type == BLOCK_32X128)))
+ continue;
+ if (mbmi->sb_type == BLOCK_128X128 || mbmi->sb_type == BLOCK_128X64 ||
+ mbmi->sb_type == BLOCK_128X32 || mbmi->sb_type == BLOCK_64X128 ||
+ mbmi->sb_type == BLOCK_32X128)
+ bs = mbmi->sb_type;
+ if (bs == BLOCK_128X128 || bs == BLOCK_128X64 || bs == BLOCK_128X32)
+ nhb = AOMMIN(MI_SIZE_128X128, cm->mi_cols - MI_SIZE_64X64 * fbc);
+ if (bs == BLOCK_128X128 || bs == BLOCK_64X128 || bs == BLOCK_32X128)
+ nvb = AOMMIN(MI_SIZE_128X128, cm->mi_rows - MI_SIZE_64X64 * fbr);
+#endif
+ // No filtering if the entire filter block is skipped
if (sb_all_skip(cm, fbr * MI_SIZE_64X64, fbc * MI_SIZE_64X64)) continue;
+#if CONFIG_EXT_PARTITION
cdef_count = sb_compute_cdef_list(cm, fbr * MI_SIZE_64X64,
- fbc * MI_SIZE_64X64, dlist, 1);
+ fbc * MI_SIZE_64X64, dlist, bs);
+#else
+ cdef_count = sb_compute_cdef_list(cm, fbr * MI_SIZE_64X64,
+ fbc * MI_SIZE_64X64, dlist);
+#endif
for (pli = 0; pli < nplanes; pli++) {
for (i = 0; i < CDEF_INBUF_SIZE; i++) inbuf[i] = CDEF_VERY_LARGE;
for (gi = 0; gi < total_strengths; gi++) {
