Implement ERP tool in single patch
STATS_CHANGED for some changes outside config flags
Change-Id: Ia41604d01d6dcc95d8c010b2bca5c368ed05fdec
diff --git a/aom_dsp/aom_dsp_rtcd_defs.pl b/aom_dsp/aom_dsp_rtcd_defs.pl
index 9e6b5b1..d1d2b9a 100755
--- a/aom_dsp/aom_dsp_rtcd_defs.pl
+++ b/aom_dsp/aom_dsp_rtcd_defs.pl
@@ -107,6 +107,7 @@
specialize qw/aom_dc_left_predictor_8x8 neon msa sse2/;
specialize qw/aom_dc_left_predictor_8x16 sse2/;
specialize qw/aom_dc_left_predictor_8x32 sse2/;
+
specialize qw/aom_dc_left_predictor_16x4 sse2/;
specialize qw/aom_dc_left_predictor_16x8 sse2/;
specialize qw/aom_dc_left_predictor_16x16 neon msa sse2/;
@@ -195,9 +196,6 @@
specialize qw/aom_paeth_predictor_64x32 ssse3 avx2/;
specialize qw/aom_paeth_predictor_64x64 ssse3 avx2/;
specialize qw/aom_paeth_predictor_64x16 ssse3 avx2/;
-specialize qw/aom_paeth_predictor_16x8 ssse3/;
-specialize qw/aom_paeth_predictor_16x16 ssse3/;
-specialize qw/aom_paeth_predictor_16x32 ssse3/;
specialize qw/aom_paeth_predictor_32x16 ssse3/;
specialize qw/aom_paeth_predictor_32x32 ssse3/;
specialize qw/aom_smooth_predictor_4x4 neon ssse3/;
@@ -322,13 +320,13 @@
specialize qw/aom_highbd_dc_left_predictor_4x8 sse2/;
specialize qw/aom_highbd_dc_top_predictor_4x8 sse2/;
specialize qw/aom_highbd_dc_128_predictor_4x8 sse2/;
-specialize qw/aom_highbd_dc_left_predictor_8x4 sse2/;
specialize qw/aom_highbd_dc_top_predictor_8x4 sse2/;
specialize qw/aom_highbd_dc_128_predictor_8x4 sse2/;
+specialize qw/aom_highbd_dc_left_predictor_8x4 sse2/;
specialize qw/aom_highbd_dc_left_predictor_8x8 sse2/;
+specialize qw/aom_highbd_dc_left_predictor_8x16 sse2/;
specialize qw/aom_highbd_dc_top_predictor_8x8 sse2/;
specialize qw/aom_highbd_dc_128_predictor_8x8 sse2/;
-specialize qw/aom_highbd_dc_left_predictor_8x16 sse2/;
specialize qw/aom_highbd_dc_top_predictor_8x16 sse2/;
specialize qw/aom_highbd_dc_128_predictor_8x16 sse2/;
specialize qw/aom_highbd_dc_left_predictor_16x8 sse2/;
@@ -666,6 +664,7 @@
specialize qw/aom_sad16x32 msa sse2/;
specialize qw/aom_sad16x16 neon msa sse2/;
specialize qw/aom_sad16x8 neon msa sse2/;
+ specialize qw/aom_sad16x4 sse2/;
specialize qw/aom_sad8x16 neon msa sse2/;
specialize qw/aom_sad8x8 neon msa sse2/;
specialize qw/aom_sad8x4 msa sse2/;
@@ -673,7 +672,6 @@
specialize qw/aom_sad4x4 neon msa sse2/;
specialize qw/aom_sad4x16 sse2/;
- specialize qw/aom_sad16x4 sse2/;
specialize qw/aom_sad8x32 sse2/;
specialize qw/aom_sad32x8 sse2/;
specialize qw/aom_sad16x64 sse2/;
@@ -711,6 +709,7 @@
specialize qw/aom_sad16x32_avg msa sse2/;
specialize qw/aom_sad16x16_avg msa sse2/;
specialize qw/aom_sad16x8_avg msa sse2/;
+ specialize qw/aom_sad16x4_avg sse2/;
specialize qw/aom_sad8x16_avg msa sse2/;
specialize qw/aom_sad8x8_avg msa sse2/;
specialize qw/aom_sad8x4_avg msa sse2/;
@@ -718,7 +717,6 @@
specialize qw/aom_sad4x4_avg msa sse2/;
specialize qw/aom_sad4x16_avg sse2/;
- specialize qw/aom_sad16x4_avg sse2/;
specialize qw/aom_sad8x32_avg sse2/;
specialize qw/aom_sad32x8_avg sse2/;
specialize qw/aom_sad16x64_avg sse2/;
@@ -894,9 +892,9 @@
specialize qw/aom_sad32x16x4d avx2 msa sse2/;
specialize qw/aom_sad32x8x4d avx2 sse2/;
specialize qw/aom_sad16x64x4d sse2/;
- specialize qw/aom_sad16x32x4d msa sse2/;
- specialize qw/aom_sad16x16x4d neon msa sse2/;
- specialize qw/aom_sad16x8x4d msa sse2/;
+ specialize qw/aom_sad16x32x4d msa sse2/;
+ specialize qw/aom_sad16x8x4d msa sse2/;
+ specialize qw/aom_sad16x16x4d neon msa sse2/;
specialize qw/aom_sad8x16x4d msa sse2/;
specialize qw/aom_sad8x8x4d msa sse2/;
diff --git a/aom_dsp/x86/aom_convolve_copy_avx2.c b/aom_dsp/x86/aom_convolve_copy_avx2.c
index 39c6a40..d3ac810 100644
--- a/aom_dsp/x86/aom_convolve_copy_avx2.c
+++ b/aom_dsp/x86/aom_convolve_copy_avx2.c
@@ -27,7 +27,6 @@
void aom_convolve_copy_avx2(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride, int w, int h) {
if (w >= 16) {
- assert(!((intptr_t)dst % 16));
assert(!(dst_stride % 16));
}
@@ -71,9 +70,9 @@
src += src_stride;
s[1] = _mm_loadu_si128((__m128i *)src);
src += src_stride;
- _mm_store_si128((__m128i *)dst, s[0]);
+ _mm_storeu_si128((__m128i *)dst, s[0]);
dst += dst_stride;
- _mm_store_si128((__m128i *)dst, s[1]);
+ _mm_storeu_si128((__m128i *)dst, s[1]);
dst += dst_stride;
h -= 2;
} while (h);
@@ -157,7 +156,6 @@
uint16_t *dst, ptrdiff_t dst_stride, int w,
int h) {
if (w >= 16) {
- assert(!((intptr_t)dst % 16));
assert(!(dst_stride % 16));
}
@@ -191,9 +189,9 @@
src += src_stride;
s[1] = _mm_loadu_si128((__m128i *)src);
src += src_stride;
- _mm_store_si128((__m128i *)dst, s[0]);
+ _mm_storeu_si128((__m128i *)dst, s[0]);
dst += dst_stride;
- _mm_store_si128((__m128i *)dst, s[1]);
+ _mm_storeu_si128((__m128i *)dst, s[1]);
dst += dst_stride;
h -= 2;
} while (h);
diff --git a/aom_dsp/x86/aom_convolve_copy_sse2.c b/aom_dsp/x86/aom_convolve_copy_sse2.c
index f7b468a..9db91c3 100644
--- a/aom_dsp/x86/aom_convolve_copy_sse2.c
+++ b/aom_dsp/x86/aom_convolve_copy_sse2.c
@@ -35,7 +35,6 @@
void aom_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride, int w, int h) {
if (w >= 16) {
- assert(!((intptr_t)dst % 16));
assert(!(dst_stride % 16));
}
@@ -79,9 +78,9 @@
src += src_stride;
s[1] = _mm_loadu_si128((__m128i *)src);
src += src_stride;
- _mm_store_si128((__m128i *)dst, s[0]);
+ _mm_storeu_si128((__m128i *)dst, s[0]);
dst += dst_stride;
- _mm_store_si128((__m128i *)dst, s[1]);
+ _mm_storeu_si128((__m128i *)dst, s[1]);
dst += dst_stride;
h -= 2;
} while (h);
@@ -200,7 +199,6 @@
uint16_t *dst, ptrdiff_t dst_stride, int w,
int h) {
if (w >= 16) {
- assert(!((intptr_t)dst % 16));
assert(!(dst_stride % 16));
}
@@ -236,9 +234,9 @@
src += src_stride;
s[1] = _mm_loadu_si128((__m128i *)src);
src += src_stride;
- _mm_store_si128((__m128i *)dst, s[0]);
+ _mm_storeu_si128((__m128i *)dst, s[0]);
dst += dst_stride;
- _mm_store_si128((__m128i *)dst, s[1]);
+ _mm_storeu_si128((__m128i *)dst, s[1]);
dst += dst_stride;
h -= 2;
} while (h);
@@ -251,11 +249,11 @@
s[2] = _mm_loadu_si128((__m128i *)(src + 0 * 8));
s[3] = _mm_loadu_si128((__m128i *)(src + 1 * 8));
src += src_stride;
- _mm_store_si128((__m128i *)(dst + 0 * 8), s[0]);
- _mm_store_si128((__m128i *)(dst + 1 * 8), s[1]);
+ _mm_storeu_si128((__m128i *)(dst + 0 * 8), s[0]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * 8), s[1]);
dst += dst_stride;
- _mm_store_si128((__m128i *)(dst + 0 * 8), s[2]);
- _mm_store_si128((__m128i *)(dst + 1 * 8), s[3]);
+ _mm_storeu_si128((__m128i *)(dst + 0 * 8), s[2]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * 8), s[3]);
dst += dst_stride;
h -= 2;
} while (h);
@@ -272,15 +270,15 @@
s[6] = _mm_loadu_si128((__m128i *)(src + 2 * 8));
s[7] = _mm_loadu_si128((__m128i *)(src + 3 * 8));
src += src_stride;
- _mm_store_si128((__m128i *)(dst + 0 * 8), s[0]);
- _mm_store_si128((__m128i *)(dst + 1 * 8), s[1]);
- _mm_store_si128((__m128i *)(dst + 2 * 8), s[2]);
- _mm_store_si128((__m128i *)(dst + 3 * 8), s[3]);
+ _mm_storeu_si128((__m128i *)(dst + 0 * 8), s[0]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * 8), s[1]);
+ _mm_storeu_si128((__m128i *)(dst + 2 * 8), s[2]);
+ _mm_storeu_si128((__m128i *)(dst + 3 * 8), s[3]);
dst += dst_stride;
- _mm_store_si128((__m128i *)(dst + 0 * 8), s[4]);
- _mm_store_si128((__m128i *)(dst + 1 * 8), s[5]);
- _mm_store_si128((__m128i *)(dst + 2 * 8), s[6]);
- _mm_store_si128((__m128i *)(dst + 3 * 8), s[7]);
+ _mm_storeu_si128((__m128i *)(dst + 0 * 8), s[4]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * 8), s[5]);
+ _mm_storeu_si128((__m128i *)(dst + 2 * 8), s[6]);
+ _mm_storeu_si128((__m128i *)(dst + 3 * 8), s[7]);
dst += dst_stride;
h -= 2;
} while (h);
diff --git a/aom_dsp/x86/highbd_intrapred_asm_sse2.asm b/aom_dsp/x86/highbd_intrapred_asm_sse2.asm
index 91b3d12..a7aa55e 100644
--- a/aom_dsp/x86/highbd_intrapred_asm_sse2.asm
+++ b/aom_dsp/x86/highbd_intrapred_asm_sse2.asm
@@ -65,15 +65,15 @@
psrlw m0, 4
pshuflw m0, m0, 0x0
punpcklqdq m0, m0
- mova [dstq ], m0
- mova [dstq+strideq*2 ], m0
- mova [dstq+strideq*4 ], m0
- mova [dstq+stride3q*2], m0
+ movu [dstq ], m0
+ movu [dstq+strideq*2 ], m0
+ movu [dstq+strideq*4 ], m0
+ movu [dstq+stride3q*2], m0
lea dstq, [dstq+strideq*8]
- mova [dstq ], m0
- mova [dstq+strideq*2 ], m0
- mova [dstq+strideq*4 ], m0
- mova [dstq+stride3q*2], m0
+ movu [dstq ], m0
+ movu [dstq+strideq*2 ], m0
+ movu [dstq+strideq*4 ], m0
+ movu [dstq+stride3q*2], m0
RESTORE_GOT
RET
@@ -195,15 +195,15 @@
mova m0, [aboveq]
DEFINE_ARGS dst, stride, stride3
lea stride3q, [strideq*3]
- mova [dstq ], m0
- mova [dstq+strideq*2 ], m0
- mova [dstq+strideq*4 ], m0
- mova [dstq+stride3q*2], m0
+ movu [dstq ], m0
+ movu [dstq+strideq*2 ], m0
+ movu [dstq+strideq*4 ], m0
+ movu [dstq+stride3q*2], m0
lea dstq, [dstq+strideq*8]
- mova [dstq ], m0
- mova [dstq+strideq*2 ], m0
- mova [dstq+strideq*4 ], m0
- mova [dstq+stride3q*2], m0
+ movu [dstq ], m0
+ movu [dstq+strideq*2 ], m0
+ movu [dstq+strideq*4 ], m0
+ movu [dstq+stride3q*2], m0
RET
INIT_XMM sse2
diff --git a/aom_dsp/x86/highbd_intrapred_sse2.c b/aom_dsp/x86/highbd_intrapred_sse2.c
index 5a55736..e577190 100644
--- a/aom_dsp/x86/highbd_intrapred_sse2.c
+++ b/aom_dsp/x86/highbd_intrapred_sse2.c
@@ -54,13 +54,13 @@
const __m128i row3 = _mm_shufflelo_epi16(left_u16, 0xff);
(void)above;
(void)bd;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row0, row0));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row0, row0));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row1, row1));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row1, row1));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row2, row2));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row2, row2));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row3, row3));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row3, row3));
}
void aom_highbd_h_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t stride,
@@ -77,21 +77,21 @@
const __m128i row7 = _mm_shufflehi_epi16(left_u16, 0xff);
(void)above;
(void)bd;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row0, row0));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row0, row0));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row1, row1));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row1, row1));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row2, row2));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row2, row2));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpacklo_epi64(row3, row3));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpacklo_epi64(row3, row3));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpackhi_epi64(row4, row4));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpackhi_epi64(row4, row4));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpackhi_epi64(row5, row5));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpackhi_epi64(row5, row5));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpackhi_epi64(row6, row6));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpackhi_epi64(row6, row6));
dst += stride;
- _mm_store_si128((__m128i *)dst, _mm_unpackhi_epi64(row7, row7));
+ _mm_storeu_si128((__m128i *)dst, _mm_unpackhi_epi64(row7, row7));
}
void aom_highbd_h_predictor_8x16_sse2(uint16_t *dst, ptrdiff_t stride,
@@ -357,7 +357,7 @@
const __m128i dc_dup = _mm_unpacklo_epi64(dc_dup_lo, dc_dup_lo);
int i;
for (i = 0; i < height; ++i, dst += stride) {
- _mm_store_si128((__m128i *)dst, dc_dup);
+ _mm_storeu_si128((__m128i *)dst, dc_dup);
}
}
@@ -707,10 +707,10 @@
(void)left;
(void)bd;
const __m128i above_u16 = _mm_load_si128((const __m128i *)above);
- _mm_store_si128((__m128i *)dst, above_u16);
- _mm_store_si128((__m128i *)(dst + stride), above_u16);
- _mm_store_si128((__m128i *)(dst + 2 * stride), above_u16);
- _mm_store_si128((__m128i *)(dst + 3 * stride), above_u16);
+ _mm_storeu_si128((__m128i *)dst, above_u16);
+ _mm_storeu_si128((__m128i *)(dst + stride), above_u16);
+ _mm_storeu_si128((__m128i *)(dst + 2 * stride), above_u16);
+ _mm_storeu_si128((__m128i *)(dst + 3 * stride), above_u16);
}
void aom_highbd_v_predictor_8x16_sse2(uint16_t *dst, ptrdiff_t stride,
@@ -721,10 +721,10 @@
const __m128i above_u16 = _mm_load_si128((const __m128i *)above);
int i;
for (i = 0; i < 4; ++i) {
- _mm_store_si128((__m128i *)dst, above_u16);
- _mm_store_si128((__m128i *)(dst + stride), above_u16);
- _mm_store_si128((__m128i *)(dst + 2 * stride), above_u16);
- _mm_store_si128((__m128i *)(dst + 3 * stride), above_u16);
+ _mm_storeu_si128((__m128i *)dst, above_u16);
+ _mm_storeu_si128((__m128i *)(dst + stride), above_u16);
+ _mm_storeu_si128((__m128i *)(dst + 2 * stride), above_u16);
+ _mm_storeu_si128((__m128i *)(dst + 3 * stride), above_u16);
dst += stride << 2;
}
}
@@ -848,13 +848,13 @@
sum32 /= 12;
const __m128i row = _mm_set1_epi16((uint16_t)sum32);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
}
void aom_highbd_dc_predictor_8x16_sse2(uint16_t *dst, ptrdiff_t stride,
@@ -873,13 +873,13 @@
const __m128i row = _mm_set1_epi16((uint16_t)sum32);
int i;
for (i = 0; i < 4; ++i) {
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
}
}
diff --git a/aom_dsp/x86/highbd_sad4d_sse2.asm b/aom_dsp/x86/highbd_sad4d_sse2.asm
index 7ae1ca1..14ea419 100644
--- a/aom_dsp/x86/highbd_sad4d_sse2.asm
+++ b/aom_dsp/x86/highbd_sad4d_sse2.asm
@@ -98,7 +98,7 @@
; PROCESS_8x2x4 first, off_{first,second}_{src,ref}, advance_at_end
%macro HIGH_PROCESS_8x2x4 5-6 0
; 1st 8 px
- mova m0, [srcq +%2*2]
+ movu m0, [srcq +%2*2]
%if %1 == 1
movu m4, [ref1q+%3*2]
movu m5, [ref2q+%3*2]
@@ -156,7 +156,7 @@
%endif
; 2nd 8 px
- mova m0, [srcq +(%4)*2]
+ movu m0, [srcq +(%4)*2]
mova m3, m0
movu m2, [ref1q+(%5)*2]
psubusw m3, m2
diff --git a/aom_dsp/x86/highbd_sad_sse2.asm b/aom_dsp/x86/highbd_sad_sse2.asm
index 58f1ac9..a2510d5 100644
--- a/aom_dsp/x86/highbd_sad_sse2.asm
+++ b/aom_dsp/x86/highbd_sad_sse2.asm
@@ -20,20 +20,21 @@
; Arg 2: Height
; Arg 3: Number of general purpose registers: 5 for 32-bit build, 6 for 64-bit
; Arg 4: Type of function: if 0, normal sad; if 1, avg; if 2, skip rows
-%macro HIGH_SAD_FN 4
+; Arg 5: Number of xmm registers. 8xh needs 8, others only need 7
+%macro HIGH_SAD_FN 4-5 7
%if %4 == 0
%if %3 == 5
-cglobal highbd_sad%1x%2, 4, %3, 7, src, src_stride, ref, ref_stride, n_rows
+cglobal highbd_sad%1x%2, 4, %3, %5, src, src_stride, ref, ref_stride, n_rows
%else ; %3 == 7
-cglobal highbd_sad%1x%2, 4, %3, 7, src, src_stride, ref, ref_stride, \
+cglobal highbd_sad%1x%2, 4, %3, %5, src, src_stride, ref, ref_stride, \
src_stride3, ref_stride3, n_rows
%endif ; %3 == 5/7
%elif %4 == 1 ; avg
%if %3 == 5
-cglobal highbd_sad%1x%2_avg, 5, 1 + %3, 7, src, src_stride, ref, ref_stride, \
+cglobal highbd_sad%1x%2_avg, 5, 1 + %3, %5, src, src_stride, ref, ref_stride, \
second_pred, n_rows
%else ; %3 == 7
-cglobal highbd_sad%1x%2_avg, 5, ARCH_X86_64 + %3, 7, src, src_stride, \
+cglobal highbd_sad%1x%2_avg, 5, ARCH_X86_64 + %3, %5, src, src_stride, \
ref, ref_stride, \
second_pred, \
src_stride3, ref_stride3
@@ -356,7 +357,7 @@
; unsigned int aom_highbd_sad8x{4,8,16}_sse2(uint8_t *src, int src_stride,
; uint8_t *ref, int ref_stride);
%macro HIGH_SAD8XN 1-2 0
- HIGH_SAD_FN 8, %1, 7, %2
+ HIGH_SAD_FN 8, %1, 7, %2, 8
%if %2 == 2 ; skip rows, so divide number of rows by 2
mov n_rowsd, %1/8
%else
@@ -377,22 +378,30 @@
pavgw m4, [second_predq+mmsize*3]
lea second_predq, [second_predq+mmsize*4]
%endif
- mova m5, [srcq]
- psubusw m5, m1
- psubusw m1, [srcq]
+ mova m7, m1
+ movu m5, [srcq]
+ psubusw m1, m5
+ psubusw m5, m7
por m1, m5
- mova m5, [srcq+src_strideq*2]
- psubusw m5, m2
- psubusw m2, [srcq+src_strideq*2]
+
+ mova m7, m2
+ movu m5, [srcq+src_strideq*2]
+ psubusw m2, m5
+ psubusw m5, m7
por m2, m5
- mova m5, [srcq+src_strideq*4]
- psubusw m5, m3
- psubusw m3, [srcq+src_strideq*4]
+
+ mova m7, m3
+ movu m5, [srcq+src_strideq*4]
+ psubusw m3, m5
+ psubusw m5, m7
por m3, m5
- mova m5, [srcq+src_stride3q*2]
- psubusw m5, m4
- psubusw m4, [srcq+src_stride3q*2]
+
+ mova m7, m4
+ movu m5, [srcq+src_stride3q*2]
+ psubusw m4, m5
+ psubusw m5, m7
por m4, m5
+
paddw m1, m2
paddw m3, m4
movhlps m2, m1
diff --git a/aom_dsp/x86/highbd_subpel_variance_impl_sse2.asm b/aom_dsp/x86/highbd_subpel_variance_impl_sse2.asm
index 5c78933..c0b39ce 100644
--- a/aom_dsp/x86/highbd_subpel_variance_impl_sse2.asm
+++ b/aom_dsp/x86/highbd_subpel_variance_impl_sse2.asm
@@ -338,8 +338,8 @@
movu m1, [srcq+src_strideq*2]
movu m5, [srcq+src_strideq*4]
mova m4, m1
- mova m2, [dstq]
- mova m3, [dstq+dst_strideq*2]
+ movu m2, [dstq]
+ movu m3, [dstq+dst_strideq*2]
pmullw m1, filter_y_a
pmullw m5, filter_y_b
paddw m1, filter_rnd
@@ -404,8 +404,8 @@
movu m1, [srcq + src_strideq*2]
movu m4, [srcq + 2]
movu m5, [srcq + src_strideq*2 + 2]
- mova m2, [dstq]
- mova m3, [dstq + dst_strideq*2]
+ movu m2, [dstq]
+ movu m3, [dstq + dst_strideq*2]
pavgw m0, m4
pavgw m1, m5
%if %2 == 1 ; avg
@@ -476,8 +476,8 @@
pavgw m3, m5
pavgw m0, m2
pavgw m2, m3
- mova m4, [dstq]
- mova m5, [dstq + dst_strideq*2]
+ movu m4, [dstq]
+ movu m5, [dstq + dst_strideq*2]
%if %2 == 1 ; avg
pavgw m0, [secq]
add secq, sec_str
@@ -591,9 +591,9 @@
paddw m0, filter_rnd
psrlw m4, 4
paddw m0, m2
- mova m2, [dstq]
+ movu m2, [dstq]
psrlw m0, 4
- mova m3, [dstq+dst_strideq*2]
+ movu m3, [dstq+dst_strideq*2]
%if %2 == 1 ; avg
pavgw m0, [secq]
add secq, sec_str
@@ -682,8 +682,8 @@
movu m1, [srcq+src_strideq*2]
movu m2, [srcq+2]
movu m3, [srcq+src_strideq*2+2]
- mova m4, [dstq]
- mova m5, [dstq+dst_strideq*2]
+ movu m4, [dstq]
+ movu m5, [dstq+dst_strideq*2]
pmullw m1, filter_x_a
pmullw m3, filter_x_b
paddw m1, filter_rnd
@@ -817,8 +817,8 @@
paddw m3, filter_rnd
paddw m2, m4
paddw m3, m5
- mova m4, [dstq]
- mova m5, [dstq+dst_strideq*2]
+ movu m4, [dstq]
+ movu m5, [dstq+dst_strideq*2]
psrlw m2, 4
psrlw m3, 4
pavgw m0, m2
@@ -986,11 +986,11 @@
pmullw m3, filter_y_b
paddw m0, m2
paddw m4, filter_rnd
- mova m2, [dstq]
+ movu m2, [dstq]
paddw m4, m3
psrlw m0, 4
psrlw m4, 4
- mova m3, [dstq+dst_strideq*2]
+ movu m3, [dstq+dst_strideq*2]
%if %2 == 1 ; avg
pavgw m0, [secq]
add secq, sec_str
diff --git a/aom_dsp/x86/intrapred_asm_sse2.asm b/aom_dsp/x86/intrapred_asm_sse2.asm
index 0eb6323..e9182b1 100644
--- a/aom_dsp/x86/intrapred_asm_sse2.asm
+++ b/aom_dsp/x86/intrapred_asm_sse2.asm
@@ -226,10 +226,10 @@
punpcklqdq m0, m0
packuswb m0, m0
.loop:
- mova [dstq ], m0
- mova [dstq+strideq ], m0
- mova [dstq+strideq*2], m0
- mova [dstq+stride3q ], m0
+ movu [dstq ], m0
+ movu [dstq+strideq ], m0
+ movu [dstq+strideq*2], m0
+ movu [dstq+stride3q ], m0
lea dstq, [dstq+strideq*4]
dec lines4d
jnz .loop
@@ -285,10 +285,10 @@
punpcklqdq m0, m0
packuswb m0, m0
.loop:
- mova [dstq ], m0
- mova [dstq+strideq ], m0
- mova [dstq+strideq*2], m0
- mova [dstq+stride3q ], m0
+ movu [dstq ], m0
+ movu [dstq+strideq ], m0
+ movu [dstq+strideq*2], m0
+ movu [dstq+stride3q ], m0
lea dstq, [dstq+strideq*4]
dec lines4d
jnz .loop
@@ -486,10 +486,10 @@
lea stride3q, [strideq*3]
mov nlines4d, 4
.loop:
- mova [dstq ], m0
- mova [dstq+strideq ], m0
- mova [dstq+strideq*2], m0
- mova [dstq+stride3q ], m0
+ movu [dstq ], m0
+ movu [dstq+strideq ], m0
+ movu [dstq+strideq*2], m0
+ movu [dstq+stride3q ], m0
lea dstq, [dstq+strideq*4]
dec nlines4d
jnz .loop
@@ -567,12 +567,12 @@
punpcklbw m0, m0 ; l1 to l4 each repeated 4 times
pshufd m1, m0, 0x0 ; l1 repeated 16 times
pshufd m2, m0, 0x55 ; l2 repeated 16 times
- mova [dstq ], m1
- mova [dstq+strideq ], m2
+ movu [dstq ], m1
+ movu [dstq+strideq ], m2
pshufd m1, m0, 0xaa
pshufd m2, m0, 0xff
- mova [dstq+strideq*2], m1
- mova [dstq+stride3q ], m2
+ movu [dstq+strideq*2], m1
+ movu [dstq+stride3q ], m2
inc lineq
lea leftq, [leftq+4 ]
lea dstq, [dstq+strideq*4]
diff --git a/aom_dsp/x86/intrapred_avx2.c b/aom_dsp/x86/intrapred_avx2.c
index 23c5b2b..a7daefc 100644
--- a/aom_dsp/x86/intrapred_avx2.c
+++ b/aom_dsp/x86/intrapred_avx2.c
@@ -763,7 +763,7 @@
const __m256i l16 = _mm256_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm256_add_epi16(rep, one);
}
@@ -787,7 +787,7 @@
const __m256i l16 = _mm256_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm256_add_epi16(rep, one);
}
@@ -806,7 +806,7 @@
const __m256i l16 = _mm256_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm256_add_epi16(rep, one);
}
@@ -817,7 +817,7 @@
const __m256i l16 = _mm256_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm256_add_epi16(rep, one);
}
diff --git a/aom_dsp/x86/intrapred_sse2.c b/aom_dsp/x86/intrapred_sse2.c
index 5afef68..39a1d78 100644
--- a/aom_dsp/x86/intrapred_sse2.c
+++ b/aom_dsp/x86/intrapred_sse2.c
@@ -36,7 +36,7 @@
ptrdiff_t stride) {
int i;
for (i = 0; i < height; ++i) {
- _mm_store_si128((__m128i *)dst, *row);
+ _mm_storeu_si128((__m128i *)dst, *row);
dst += stride;
}
}
@@ -1171,7 +1171,7 @@
ptrdiff_t stride) {
int i;
for (i = 0; i < h; ++i) {
- _mm_store_si128((__m128i *)dst, row[i]);
+ _mm_storeu_si128((__m128i *)dst, row[i]);
dst += stride;
}
}
diff --git a/aom_dsp/x86/intrapred_ssse3.c b/aom_dsp/x86/intrapred_ssse3.c
index 5a34ea0..1094fdc 100644
--- a/aom_dsp/x86/intrapred_ssse3.c
+++ b/aom_dsp/x86/intrapred_ssse3.c
@@ -212,7 +212,7 @@
const __m128i l16 = _mm_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top0, &top1, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm_add_epi16(rep, one);
}
@@ -234,7 +234,7 @@
const __m128i l16 = _mm_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top0, &top1, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm_add_epi16(rep, one);
}
@@ -257,7 +257,7 @@
const __m128i l16 = _mm_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top0, &top1, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm_add_epi16(rep, one);
}
@@ -281,7 +281,7 @@
l16 = _mm_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top0, &top1, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm_add_epi16(rep, one);
}
@@ -292,7 +292,7 @@
l16 = _mm_shuffle_epi8(l, rep);
const __m128i row = paeth_16x1_pred(&l16, &top0, &top1, &tl16);
- _mm_store_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)dst, row);
dst += stride;
rep = _mm_add_epi16(rep, one);
}
diff --git a/aom_dsp/x86/sad4d_sse2.asm b/aom_dsp/x86/sad4d_sse2.asm
index b5a17c5..82b5125 100644
--- a/aom_dsp/x86/sad4d_sse2.asm
+++ b/aom_dsp/x86/sad4d_sse2.asm
@@ -210,7 +210,7 @@
%macro PROCESS_16x2x4 9
; 1st 16 px
HANDLE_FIRST_OFFSET %7, %2
- mova m0, [srcq + first_offset]
+ movu m0, [srcq + first_offset]
HANDLE_SECOND_OFFSET %7, %8, %4
%if %1 == 1
movu m4, [ref1q+%3]
@@ -256,7 +256,7 @@
%endif ; %1 == 1
; 2nd 16 px
- mova m0, [srcq + second_offset]
+ movu m0, [srcq + second_offset]
movu m1, [ref1q+%5]
movu m2, [ref2q+%5]
diff --git a/aom_dsp/x86/sad_sse2.asm b/aom_dsp/x86/sad_sse2.asm
index de9845a..86cf70a 100644
--- a/aom_dsp/x86/sad_sse2.asm
+++ b/aom_dsp/x86/sad_sse2.asm
@@ -270,25 +270,33 @@
pxor m0, m0
.loop:
+; Handle the first two rows
movu m1, [refq]
movu m2, [refq+ref_strideq]
- movu m3, [refq+ref_strideq*2]
- movu m4, [refq+ref_stride3q]
+ movu m3, [srcq]
+ movu m4, [srcq+src_strideq]
%if %2 == 1
pavgb m1, [second_predq+mmsize*0]
pavgb m2, [second_predq+mmsize*1]
+%endif
+ psadbw m1, m3
+ psadbw m2, m4
+; Then the next two rows
+ movu m3, [refq+ref_strideq*2]
+ paddd m2, m1
+ movu m4, [refq+ref_stride3q]
+ paddd m0, m2
+ movu m1, [srcq+src_strideq*2]
+ movu m2, [srcq+src_stride3q]
+%if %2 == 1
pavgb m3, [second_predq+mmsize*2]
pavgb m4, [second_predq+mmsize*3]
lea second_predq, [second_predq+mmsize*4]
%endif
- psadbw m1, [srcq]
- psadbw m2, [srcq+src_strideq]
- psadbw m3, [srcq+src_strideq*2]
- psadbw m4, [srcq+src_stride3q]
- paddd m1, m2
+ psadbw m3, m1
+ psadbw m4, m2
paddd m3, m4
lea refq, [refq+ref_strideq*4]
- paddd m0, m1
lea srcq, [srcq+src_strideq*4]
paddd m0, m3
dec n_rowsd
diff --git a/aom_dsp/x86/subpel_variance_sse2.asm b/aom_dsp/x86/subpel_variance_sse2.asm
index cbf2890..ce3592e 100644
--- a/aom_dsp/x86/subpel_variance_sse2.asm
+++ b/aom_dsp/x86/subpel_variance_sse2.asm
@@ -210,7 +210,7 @@
.x_zero_y_zero_loop:
%if %1 == 16
movu m0, [srcq]
- mova m1, [dstq]
+ movu m1, [dstq]
%if %2 == 1 ; avg
pavgb m0, [secq]
punpckhbw m3, m1, m5
@@ -286,7 +286,7 @@
%if %1 == 16
movu m0, [srcq]
movu m4, [srcq+src_strideq]
- mova m1, [dstq]
+ movu m1, [dstq]
pavgb m0, m4
punpckhbw m3, m1, m5
%if %2 == 1 ; avg
@@ -389,7 +389,7 @@
%if %1 == 16
movu m0, [srcq]
movu m4, [srcq+src_strideq]
- mova m1, [dstq]
+ movu m1, [dstq]
%if cpuflag(ssse3)
punpckhbw m2, m0, m4
punpcklbw m0, m4
@@ -507,7 +507,7 @@
%if %1 == 16
movu m0, [srcq]
movu m4, [srcq+1]
- mova m1, [dstq]
+ movu m1, [dstq]
pavgb m0, m4
punpckhbw m3, m1, m5
%if %2 == 1 ; avg
@@ -586,7 +586,7 @@
.x_half_y_half_loop:
movu m4, [srcq]
movu m3, [srcq+1]
- mova m1, [dstq]
+ movu m1, [dstq]
pavgb m4, m3
punpckhbw m3, m1, m5
pavgb m0, m4
@@ -716,7 +716,7 @@
.x_half_y_other_loop:
movu m4, [srcq]
movu m2, [srcq+1]
- mova m1, [dstq]
+ movu m1, [dstq]
pavgb m4, m2
%if cpuflag(ssse3)
punpckhbw m2, m0, m4
@@ -870,7 +870,7 @@
%if %1 == 16
movu m0, [srcq]
movu m4, [srcq+1]
- mova m1, [dstq]
+ movu m1, [dstq]
%if cpuflag(ssse3)
punpckhbw m2, m0, m4
punpcklbw m0, m4
@@ -1040,7 +1040,7 @@
movu m4, [srcq]
movu m3, [srcq+1]
%if cpuflag(ssse3)
- mova m1, [dstq]
+ movu m1, [dstq]
punpckhbw m2, m4, m3
punpcklbw m4, m3
pmaddubsw m2, filter_x_a
@@ -1066,7 +1066,7 @@
paddw m2, filter_rnd
paddw m4, m3
paddw m2, m1
- mova m1, [dstq]
+ movu m1, [dstq]
psraw m4, 4
psraw m2, 4
punpckhbw m3, m1, m5
@@ -1257,7 +1257,7 @@
%if cpuflag(ssse3)
movu m4, [srcq]
movu m3, [srcq+1]
- mova m1, [dstq]
+ movu m1, [dstq]
punpckhbw m2, m4, m3
punpcklbw m4, m3
pmaddubsw m2, filter_x_a
@@ -1303,7 +1303,7 @@
pmullw m0, filter_y_a
pmullw m3, filter_y_b
paddw m2, m1
- mova m1, [dstq]
+ movu m1, [dstq]
paddw m0, filter_rnd
psraw m2, 4
paddw m0, m3
diff --git a/aom_dsp/x86/subtract_sse2.asm b/aom_dsp/x86/subtract_sse2.asm
index af38022..a3fd3d5 100644
--- a/aom_dsp/x86/subtract_sse2.asm
+++ b/aom_dsp/x86/subtract_sse2.asm
@@ -38,10 +38,10 @@
je .case_64
%macro loop16 6
- mova m0, [srcq+%1]
- mova m4, [srcq+%2]
- mova m1, [predq+%3]
- mova m5, [predq+%4]
+ movu m0, [srcq+%1]
+ movu m4, [srcq+%2]
+ movu m1, [predq+%3]
+ movu m5, [predq+%4]
punpckhbw m2, m0, m7
punpckhbw m3, m1, m7
punpcklbw m0, m7
diff --git a/apps/aomenc.c b/apps/aomenc.c
index 88ba906..580ebe0 100644
--- a/apps/aomenc.c
+++ b/apps/aomenc.c
@@ -581,7 +581,11 @@
config->enable_rect_partitions = 1;
config->enable_1to4_partitions = 1;
config->disable_ml_transform_speed_features = 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ config->disable_ml_partition_speed_features = 1;
+#else
config->disable_ml_partition_speed_features = 0;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_SDP
config->enable_sdp = 1;
#endif
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index 6400e19..dabd2e5 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -386,11 +386,15 @@
0, // film_grain_table_filename
0, // motion_vector_unit_test
1, // CDF update mode
- 0, // disable ML based partition speed up features
- 1, // enable rectangular partitions
- 1, // enable ab shape partitions
- 1, // enable 1:4 and 4:1 partitions
- 0, // disable ml based transform speed features
+#if CONFIG_EXT_RECUR_PARTITIONS
+ 1, // disable ML based partition speed up features
+#else
+ 0, // disable ML based partition speed up features
+#endif
+ 1, // enable rectangular partitions
+ 1, // enable ab shape partitions
+ 1, // enable 1:4 and 4:1 partitions
+ 0, // disable ml based transform speed features
#if CONFIG_SDP
1, // enable semi-decoupled partitioning
#endif // CONFIG_SDP
@@ -1364,6 +1368,10 @@
#if CONFIG_SDP
part_cfg->enable_sdp = extra_cfg->enable_sdp;
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+ part_cfg->disable_ml_partition_speed_features =
+ extra_cfg->disable_ml_partition_speed_features;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
part_cfg->min_partition_size = extra_cfg->min_partition_size;
part_cfg->max_partition_size = extra_cfg->max_partition_size;
@@ -3976,7 +3984,13 @@
0, // use_fixed_qp_offsets
{ -1, -1, -1, -1, -1, -1 }, // fixed_qp_offsets
{
- 0, 128, 128, 4, 1, 1, 1, 0, 0,
+ 0, 128, 128, 4, 1, 1, 1,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ 1,
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ 0,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ 0,
#if CONFIG_SDP
1,
#endif // CONFIG_SDP
diff --git a/av1/common/alloccommon.c b/av1/common/alloccommon.c
index d11f8f7..f588e7d 100644
--- a/av1/common/alloccommon.c
+++ b/av1/common/alloccommon.c
@@ -174,8 +174,24 @@
above_contexts->num_planes = 0;
}
+static void free_sbi(CommonSBInfoParams *sbi_params) {
+ for (int i = 0; i < sbi_params->sbi_alloc_size; ++i) {
+#if CONFIG_SDP
+ av1_free_ptree_recursive(sbi_params->sbi_grid_base[i].ptree_root[0]);
+ av1_free_ptree_recursive(sbi_params->sbi_grid_base[i].ptree_root[1]);
+#else
+ av1_free_ptree_recursive(sbi_params->sbi_grid_base[i].ptree_root);
+#endif // CONFIG_SDP
+ }
+
+ aom_free(sbi_params->sbi_grid_base);
+ sbi_params->sbi_grid_base = NULL;
+ sbi_params->sbi_alloc_size = 0;
+}
+
void av1_free_context_buffers(AV1_COMMON *cm) {
cm->mi_params.free_mi(&cm->mi_params);
+ free_sbi(&cm->sbi_params);
av1_free_above_context_buffers(&cm->above_contexts);
@@ -274,10 +290,49 @@
return 0;
}
+static void set_sb_si(AV1_COMMON *cm) {
+ CommonSBInfoParams *const sbi_params = &cm->sbi_params;
+ const int mib_size_log2 = cm->seq_params.mib_size_log2;
+ sbi_params->sb_cols =
+ ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols, mib_size_log2) >> mib_size_log2;
+ sbi_params->sb_rows =
+ ALIGN_POWER_OF_TWO(cm->mi_params.mi_rows, mib_size_log2) >> mib_size_log2;
+ sbi_params->sbi_stride = cm->mi_params.mi_stride >> mib_size_log2;
+}
+
+static int alloc_sbi(CommonSBInfoParams *sbi_params) {
+ const int sbi_size =
+ sbi_params->sbi_stride * calc_mi_size(sbi_params->sb_rows);
+
+ if (sbi_params->sbi_alloc_size < sbi_size) {
+ free_sbi(sbi_params);
+ sbi_params->sbi_grid_base = aom_calloc(sbi_size, sizeof(SB_INFO));
+
+ if (!sbi_params->sbi_grid_base) return 1;
+
+ sbi_params->sbi_alloc_size = sbi_size;
+ for (int i = 0; i < sbi_size; ++i) {
+#if CONFIG_SDP
+ sbi_params->sbi_grid_base[i].ptree_root[0] = NULL;
+ sbi_params->sbi_grid_base[i].ptree_root[1] = NULL;
+#else
+ sbi_params->sbi_grid_base[i].ptree_root = NULL;
+#endif
+ }
+ }
+
+ return 0;
+}
+
int av1_alloc_context_buffers(AV1_COMMON *cm, int width, int height) {
CommonModeInfoParams *const mi_params = &cm->mi_params;
mi_params->set_mb_mi(mi_params, width, height);
if (alloc_mi(mi_params)) goto fail;
+
+ CommonSBInfoParams *const sbi_params = &cm->sbi_params;
+ set_sb_si(cm);
+ if (alloc_sbi(sbi_params)) goto fail;
+
return 0;
fail:
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index 0781160..96364ed 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -641,6 +641,33 @@
/**@}*/
};
+typedef struct CommonSBInfoParams CommonSBInfoParams;
+/*!
+ * \brief Params related to SB_INFO arrays and related info.
+ */
+struct CommonSBInfoParams {
+ /*!
+ * Grid of pointers to SB_INFO structs.
+ */
+ SB_INFO *sbi_grid_base;
+ /*!
+ * Stride for 'sbi_grid_base'.
+ */
+ int sbi_stride;
+ /*!
+ * Number of superblocks in the vertical direction.
+ */
+ int sb_rows;
+ /*!
+ * Number of superblocks in the horizontal direction.
+ */
+ int sb_cols;
+ /*!
+ * Number of SB_INFO structs that are currently allocated.
+ */
+ int sbi_alloc_size;
+};
+
typedef struct CommonQuantParams CommonQuantParams;
/*!
* \brief Parameters related to quantization at the frame level.
@@ -962,6 +989,11 @@
*/
CommonModeInfoParams mi_params;
+ /*!
+ * Params related to SB_INFO arrays and related info.
+ */
+ CommonSBInfoParams sbi_params;
+
#if CONFIG_ENTROPY_STATS
/*!
* Context type used by token CDFs, in the range 0 .. (TOKEN_CDF_Q_CTXS - 1).
@@ -1382,28 +1414,23 @@
}
static INLINE void set_entropy_context(MACROBLOCKD *xd, int mi_row, int mi_col,
- const int num_planes) {
- int i;
- int row_offset = mi_row;
- int col_offset = mi_col;
+ const int num_planes,
+ const CHROMA_REF_INFO *chr_ref_info) {
#if CONFIG_SDP
- for (i = (xd->tree_type == CHROMA_PART); i < num_planes; ++i) {
+ for (int i = (xd->tree_type == CHROMA_PART); i < num_planes; ++i) {
#else
- for (i = 0; i < num_planes; ++i) {
+ for (int i = 0; i < num_planes; ++i) {
#endif
struct macroblockd_plane *const pd = &xd->plane[i];
// Offset the buffer pointer
-#if CONFIG_SDP
- const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART];
-#else
- const BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-#endif
- if (pd->subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
- row_offset = mi_row - 1;
- if (pd->subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
- col_offset = mi_col - 1;
- int above_idx = col_offset;
- int left_idx = row_offset & MAX_MIB_MASK;
+ const int row_offset =
+ i && chr_ref_info ? chr_ref_info->mi_row_chroma_base : mi_row;
+ const int col_offset =
+ i && chr_ref_info ? chr_ref_info->mi_col_chroma_base : mi_col;
+ assert(row_offset >= 0);
+ assert(col_offset >= 0);
+ const int above_idx = col_offset;
+ const int left_idx = row_offset & MAX_MIB_MASK;
pd->above_entropy_context =
&xd->above_entropy_context[i][above_idx >> pd->subsampling_x];
pd->left_entropy_context =
@@ -1417,15 +1444,26 @@
}
static INLINE void set_plane_n4(MACROBLOCKD *const xd, int bw, int bh,
- const int num_planes) {
+ const int num_planes,
+ const CHROMA_REF_INFO *chr_ref_info) {
int i;
#if CONFIG_SDP
for (i = (xd->tree_type == CHROMA_PART); i < num_planes; i++) {
#else
for (i = 0; i < num_planes; i++) {
#endif
- xd->plane[i].width = (bw * MI_SIZE) >> xd->plane[i].subsampling_x;
- xd->plane[i].height = (bh * MI_SIZE) >> xd->plane[i].subsampling_y;
+ if (chr_ref_info && i > 0) {
+ const BLOCK_SIZE plane_bsize = chr_ref_info->bsize_base;
+ assert(plane_bsize < BLOCK_SIZES_ALL);
+
+ xd->plane[i].width =
+ block_size_wide[plane_bsize] >> xd->plane[i].subsampling_x;
+ xd->plane[i].height =
+ block_size_high[plane_bsize] >> xd->plane[i].subsampling_y;
+ } else {
+ xd->plane[i].width = (bw * MI_SIZE) >> xd->plane[i].subsampling_x;
+ xd->plane[i].height = (bh * MI_SIZE) >> xd->plane[i].subsampling_y;
+ }
xd->plane[i].width = AOMMAX(xd->plane[i].width, 4);
xd->plane[i].height = AOMMAX(xd->plane[i].height, 4);
@@ -1434,7 +1472,8 @@
static INLINE void set_mi_row_col(MACROBLOCKD *xd, const TileInfo *const tile,
int mi_row, int bh, int mi_col, int bw,
- int mi_rows, int mi_cols) {
+ int mi_rows, int mi_cols,
+ const CHROMA_REF_INFO *chr_ref_info) {
xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_row * MI_SIZE);
xd->mb_to_bottom_edge = GET_MV_SUBPEL((mi_rows - bh - mi_row) * MI_SIZE);
xd->mb_to_left_edge = -GET_MV_SUBPEL((mi_col * MI_SIZE));
@@ -1445,17 +1484,9 @@
// Are edges available for intra prediction?
xd->up_available = (mi_row > tile->mi_row_start);
-
- const int ss_x = xd->plane[1].subsampling_x;
- const int ss_y = xd->plane[1].subsampling_y;
-
xd->left_available = (mi_col > tile->mi_col_start);
xd->chroma_up_available = xd->up_available;
xd->chroma_left_available = xd->left_available;
- if (ss_x && bw < mi_size_wide[BLOCK_8X8])
- xd->chroma_left_available = (mi_col - 1) > tile->mi_col_start;
- if (ss_y && bh < mi_size_high[BLOCK_8X8])
- xd->chroma_up_available = (mi_row - 1) > tile->mi_row_start;
if (xd->up_available) {
xd->above_mbmi = xd->mi[-xd->mi_stride];
} else {
@@ -1468,28 +1499,38 @@
xd->left_mbmi = NULL;
}
- const int chroma_ref = ((mi_row & 0x01) || !(bh & 0x01) || !ss_y) &&
- ((mi_col & 0x01) || !(bw & 0x01) || !ss_x);
- xd->is_chroma_ref = chroma_ref;
- if (chroma_ref) {
- // To help calculate the "above" and "left" chroma blocks, note that the
- // current block may cover multiple luma blocks (eg, if partitioned into
- // 4x4 luma blocks).
- // First, find the top-left-most luma block covered by this chroma block
- MB_MODE_INFO **base_mi =
- &xd->mi[-(mi_row & ss_y) * xd->mi_stride - (mi_col & ss_x)];
+ if (chr_ref_info) {
+ xd->is_chroma_ref = chr_ref_info->is_chroma_ref;
+ xd->chroma_left_available =
+ chr_ref_info->mi_col_chroma_base > tile->mi_col_start;
+ xd->chroma_up_available =
+ chr_ref_info->mi_row_chroma_base > tile->mi_row_start;
+ if (xd->is_chroma_ref) {
+ // To help calculate the "above" and "left" chroma blocks, note that the
+ // current block may cover multiple luma blocks (eg, if partitioned into
+ // 4x4 luma blocks).
+ // First, find the top-left-most luma block covered by this chroma block
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+ const int mi_row_offset = mi_row - chr_ref_info->mi_row_chroma_base;
+ const int mi_col_offset = mi_col - chr_ref_info->mi_col_chroma_base;
+ MB_MODE_INFO **base_mi =
+ &xd->mi[-mi_row_offset * xd->mi_stride - mi_col_offset];
- // Then, we consider the luma region covered by the left or above 4x4 chroma
- // prediction. We want to point to the chroma reference block in that
- // region, which is the bottom-right-most mi unit.
- // This leads to the following offsets:
- MB_MODE_INFO *chroma_above_mi =
- xd->chroma_up_available ? base_mi[-xd->mi_stride + ss_x] : NULL;
- xd->chroma_above_mbmi = chroma_above_mi;
+ // Then, we consider the luma region covered by the left or above 4x4
+ // chroma prediction. We want to point to the chroma reference block in
+ // that region, which is the bottom-right-most mi unit. This leads to the
+ // following offsets:
+ MB_MODE_INFO *chroma_above_mi =
+ xd->chroma_up_available ? base_mi[-xd->mi_stride + ss_x] : NULL;
+ xd->chroma_above_mbmi = chroma_above_mi;
- MB_MODE_INFO *chroma_left_mi =
- xd->chroma_left_available ? base_mi[ss_y * xd->mi_stride - 1] : NULL;
- xd->chroma_left_mbmi = chroma_left_mi;
+ MB_MODE_INFO *chroma_left_mi =
+ xd->chroma_left_available ? base_mi[ss_y * xd->mi_stride - 1] : NULL;
+ xd->chroma_left_mbmi = chroma_left_mi;
+ }
+ } else {
+ xd->is_chroma_ref = 1;
}
xd->height = bh;
@@ -1497,9 +1538,16 @@
xd->is_last_vertical_rect = 0;
if (xd->width < xd->height) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // For PARTITION_VERT_3, it would be (0, 1, 1), because 2nd subpartition has
+ // ratio 1:2, so not enough top-right pixels are available.
+ // For other partitions, it would be (0, 1).
+ if (mi_col & (xd->height - 1)) xd->is_last_vertical_rect = 1;
+#else
if (!((mi_col + xd->width) & (xd->height - 1))) {
xd->is_last_vertical_rect = 1;
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
xd->is_first_horizontal_rect = 0;
@@ -1531,6 +1579,7 @@
PARTITION_CONTEXT *const left_ctx =
xd->left_partition_context + (mi_row & MAX_MIB_MASK);
#endif
+ assert(bsize < BLOCK_SIZES_ALL);
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
@@ -1561,10 +1610,14 @@
out[0] = CDF_PROB_TOP;
out[0] -= cdf_element_prob(in, PARTITION_HORZ);
out[0] -= cdf_element_prob(in, PARTITION_SPLIT);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (bsize != BLOCK_128X128) out[0] -= cdf_element_prob(in, PARTITION_HORZ_3);
+#else // CONFIG_EXT_RECUR_PARTITIONS
out[0] -= cdf_element_prob(in, PARTITION_HORZ_A);
out[0] -= cdf_element_prob(in, PARTITION_HORZ_B);
out[0] -= cdf_element_prob(in, PARTITION_VERT_A);
if (bsize != BLOCK_128X128) out[0] -= cdf_element_prob(in, PARTITION_HORZ_4);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
out[0] = AOM_ICDF(out[0]);
out[1] = AOM_ICDF(CDF_PROB_TOP);
}
@@ -1576,10 +1629,14 @@
out[0] = CDF_PROB_TOP;
out[0] -= cdf_element_prob(in, PARTITION_VERT);
out[0] -= cdf_element_prob(in, PARTITION_SPLIT);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (bsize != BLOCK_128X128) out[0] -= cdf_element_prob(in, PARTITION_VERT_3);
+#else // CONFIG_EXT_RECUR_PARTITIONS
out[0] -= cdf_element_prob(in, PARTITION_HORZ_A);
out[0] -= cdf_element_prob(in, PARTITION_VERT_A);
out[0] -= cdf_element_prob(in, PARTITION_VERT_B);
if (bsize != BLOCK_128X128) out[0] -= cdf_element_prob(in, PARTITION_VERT_4);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
out[0] = AOM_ICDF(out[0]);
out[1] = AOM_ICDF(CDF_PROB_TOP);
}
@@ -1588,9 +1645,13 @@
int mi_col, BLOCK_SIZE subsize,
BLOCK_SIZE bsize,
PARTITION_TYPE partition) {
- if (bsize >= BLOCK_8X8) {
+ if (is_partition_point(bsize)) {
const int hbs = mi_size_wide[bsize] / 2;
- BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int quarter_step = hbs / 2;
+#else
+ const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
case PARTITION_SPLIT:
if (bsize != BLOCK_8X8) break;
@@ -1598,10 +1659,28 @@
case PARTITION_NONE:
case PARTITION_HORZ:
case PARTITION_VERT:
- case PARTITION_HORZ_4:
- case PARTITION_VERT_4:
update_partition_context(xd, mi_row, mi_col, subsize, bsize);
break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3: {
+ const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_HORZ);
+ update_partition_context(xd, mi_row, mi_col, subsize, subsize);
+ update_partition_context(xd, mi_row + quarter_step, mi_col, bsize3,
+ bsize3);
+ update_partition_context(xd, mi_row + 3 * quarter_step, mi_col, subsize,
+ subsize);
+ break;
+ }
+ case PARTITION_VERT_3: {
+ const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_VERT);
+ update_partition_context(xd, mi_row, mi_col, subsize, subsize);
+ update_partition_context(xd, mi_row, mi_col + quarter_step, bsize3,
+ bsize3);
+ update_partition_context(xd, mi_row, mi_col + 3 * quarter_step, subsize,
+ subsize);
+ break;
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_A:
update_partition_context(xd, mi_row, mi_col, bsize2, subsize);
update_partition_context(xd, mi_row + hbs, mi_col, subsize, subsize);
@@ -1618,6 +1697,11 @@
update_partition_context(xd, mi_row, mi_col, subsize, subsize);
update_partition_context(xd, mi_row, mi_col + hbs, bsize2, subsize);
break;
+ case PARTITION_HORZ_4:
+ case PARTITION_VERT_4:
+ update_partition_context(xd, mi_row, mi_col, subsize, bsize);
+ break;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
default: assert(0 && "Invalid partition type");
}
}
@@ -1636,27 +1720,68 @@
const PARTITION_CONTEXT *left_ctx =
xd->left_partition_context + (mi_row & MAX_MIB_MASK);
#endif
- // Minimum partition point is 8x8. Offset the bsl accordingly.
- const int bsl = mi_size_wide_log2[bsize] - mi_size_wide_log2[BLOCK_8X8];
- int above = (*above_ctx >> bsl) & 1, left = (*left_ctx >> bsl) & 1;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (is_square_block(bsize)) {
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ // Minimum partition point is 8x8. Offset the bsl accordingly.
+ const int bsl = mi_size_wide_log2[bsize] - mi_size_wide_log2[BLOCK_8X8];
+ int above = (*above_ctx >> bsl) & 1, left = (*left_ctx >> bsl) & 1;
- assert(mi_size_wide_log2[bsize] == mi_size_high_log2[bsize]);
- assert(bsl >= 0);
+ assert(mi_size_wide_log2[bsize] == mi_size_high_log2[bsize]);
+ assert(bsl >= 0);
- return (left * 2 + above) + bsl * PARTITION_PLOFFSET;
+ return (left * 2 + above) + bsl * PARTITION_PLOFFSET;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ } else {
+ const int bsl_w = mi_size_wide_log2[bsize] - mi_size_wide_log2[BLOCK_8X8];
+ const int bsl_h = mi_size_high_log2[bsize] - mi_size_high_log2[BLOCK_8X8];
+
+ const int above = (*above_ctx >> AOMMAX(bsl_w, 0)) & 1;
+ const int left = (*left_ctx >> AOMMAX(bsl_h, 0)) & 1;
+
+ return (left * 2 + above) +
+ AOMMIN(bsl_w + 1, bsl_h + 1) * PARTITION_PLOFFSET;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
// Return the number of elements in the partition CDF when
// partitioning the (square) block with luma block size of bsize.
static INLINE int partition_cdf_length(BLOCK_SIZE bsize) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (bsize <= BLOCK_8X8 || bsize == BLOCK_128X128) return PARTITION_TYPES;
+#else // CONFIG_EXT_RECUR_PARTITIONS
if (bsize <= BLOCK_8X8)
return PARTITION_TYPES;
else if (bsize == BLOCK_128X128)
return EXT_PARTITION_TYPES - 2;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
else
return EXT_PARTITION_TYPES;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE int partition_rec_cdf_length(BLOCK_SIZE bsize) {
+ assert(block_size_wide[bsize] != block_size_high[bsize]);
+
+ switch (bsize) {
+ case BLOCK_4X8:
+ case BLOCK_8X4: return (PARTITION_LONG_SIDE_2_REC + 1);
+ case BLOCK_64X128:
+ case BLOCK_128X64: return (PARTITION_LONG_SIDE_3_REC + 1);
+ case BLOCK_8X16:
+ case BLOCK_16X8:
+ case BLOCK_16X32:
+ case BLOCK_32X16:
+ case BLOCK_32X64:
+ case BLOCK_64X32: return PARTITION_TYPES_REC;
+ default:
+ assert(0 && "Invalid splittable rectangular bsize");
+ return PARTITION_INVALID_REC;
+ }
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
static INLINE int max_block_wide(const MACROBLOCKD *xd, BLOCK_SIZE bsize,
int plane) {
assert(bsize < BLOCK_SIZES_ALL);
@@ -2130,30 +2255,52 @@
// Smaller height but same width. Is PARTITION_HORZ_4, PARTITION_HORZ or
// PARTITION_HORZ_B. To distinguish the latter two, check if the lower
// half was split.
- if (sshigh * 4 == bhigh) return PARTITION_HORZ_4;
+ if (sshigh * 4 == bhigh) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ return PARTITION_HORZ_3;
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ return PARTITION_HORZ_4;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ }
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(sshigh * 2 == bhigh);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_SDP
if (mbmi_below->sb_type[plane_type] == subsize)
#else
if (mbmi_below->sb_type == subsize)
-#endif
+#endif // CONFIG_SDP
return PARTITION_HORZ;
+
+#if !CONFIG_EXT_RECUR_PARTITIONS
else
return PARTITION_HORZ_B;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
} else if (sshigh == bhigh) {
// Smaller width but same height. Is PARTITION_VERT_4, PARTITION_VERT or
// PARTITION_VERT_B. To distinguish the latter two, check if the right
// half was split.
- if (sswide * 4 == bwide) return PARTITION_VERT_4;
+ if (sswide * 4 == bwide) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ return PARTITION_VERT_3;
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ return PARTITION_VERT_4;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ }
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(sswide * 2 == bhigh);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_SDP
if (mbmi_right->sb_type[plane_type] == subsize)
#else
if (mbmi_right->sb_type == subsize)
#endif
return PARTITION_VERT;
+
+#if !CONFIG_EXT_RECUR_PARTITIONS
else
return PARTITION_VERT_B;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
} else {
// Smaller width and smaller height. Might be PARTITION_SPLIT or could be
// PARTITION_HORZ_A or PARTITION_VERT_A. If subsize isn't halved in both
@@ -2162,6 +2309,18 @@
// PARTITION_VERT_A, the right block will have height bhigh; with
// PARTITION_HORZ_A, the lower block with have width bwide. Otherwise
// it's PARTITION_SPLIT.
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (sswide * 2 != bwide || sshigh * 2 != bhigh) {
+#if CONFIG_SDP
+ if (mi_size_wide[mbmi_below->sb_type[plane_type]] < bwide &&
+ mi_size_high[mbmi_right->sb_type[plane_type]] < bhigh)
+#else
+ if (mi_size_wide[mbmi_below->sb_type] < bwide &&
+ mi_size_high[mbmi_right->sb_type] < bhigh)
+#endif // CONFIG_SDP
+ return PARTITION_SPLIT;
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
if (sswide * 2 != bwide || sshigh * 2 != bhigh) return PARTITION_SPLIT;
#if CONFIG_SDP
if (mi_size_wide[mbmi_below->sb_type[plane_type]] == bwide)
@@ -2172,6 +2331,7 @@
if (mi_size_wide[mbmi_below->sb_type] == bwide) return PARTITION_HORZ_A;
if (mi_size_high[mbmi_right->sb_type] == bhigh) return PARTITION_VERT_A;
#endif
+#endif // CONFIG_EXT_RECUR_PARTITIONS
return PARTITION_SPLIT;
}
}
@@ -2194,6 +2354,22 @@
seq_params->mib_size_log2 = mi_size_wide_log2[seq_params->sb_size];
}
+static INLINE SB_INFO *av1_get_sb_info(const AV1_COMMON *cm, int mi_row,
+ int mi_col) {
+ const int sb_row = mi_row >> cm->seq_params.mib_size_log2;
+ const int sb_col = mi_col >> cm->seq_params.mib_size_log2;
+ return cm->sbi_params.sbi_grid_base + sb_row * cm->sbi_params.sbi_stride +
+ sb_col;
+}
+
+static INLINE void av1_set_sb_info(AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row,
+ int mi_col) {
+ xd->sbi = av1_get_sb_info(cm, mi_row, mi_col);
+
+ xd->sbi->mi_row = mi_row;
+ xd->sbi->mi_col = mi_col;
+}
+
// Returns true if the frame is fully lossless at the coded resolution.
// Note: If super-resolution is used, such a frame will still NOT be lossless at
// the upscaled resolution.
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 6bbb854..5be219d 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -196,29 +196,36 @@
}
static TX_SIZE get_transform_size(const MACROBLOCKD *const xd,
-#if CONFIG_SDP
- const AV1_COMMON *const cm,
-#endif
const MB_MODE_INFO *const mbmi,
const EDGE_DIR edge_dir, const int mi_row,
const int mi_col, const int plane,
+#if CONFIG_SDP
+ const TREE_TYPE tree_type,
+#endif
const struct macroblockd_plane *plane_ptr) {
assert(mbmi != NULL);
if (xd && xd->lossless[mbmi->segment_id]) return TX_4X4;
#if CONFIG_SDP
- const int plane_type =
- (frame_is_intra_only(cm) && plane > 0 && cm->seq_params.enable_sdp);
+ const int plane_type = av1_get_sdp_idx(tree_type);
#endif
- TX_SIZE tx_size = (plane == AOM_PLANE_Y)
- ? mbmi->tx_size
-#if CONFIG_SDP
- : av1_get_max_uv_txsize(mbmi->sb_type[plane_type],
- plane_ptr->subsampling_x,
- plane_ptr->subsampling_y);
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ const BLOCK_SIZE bsize_base =
+ get_bsize_base_from_tree_type(mbmi, tree_type, plane);
+#endif // CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+
+ TX_SIZE tx_size =
+ (plane == AOM_PLANE_Y)
+ ? mbmi->tx_size
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ : av1_get_max_uv_txsize(bsize_base, plane_ptr->subsampling_x,
+ plane_ptr->subsampling_y);
+#elif CONFIG_SDP
+ : av1_get_max_uv_txsize(mbmi->sb_type[plane_type],
+ plane_ptr->subsampling_x,
+ plane_ptr->subsampling_y);
#else
- : av1_get_max_uv_txsize(mbmi->sb_type,
- plane_ptr->subsampling_x,
- plane_ptr->subsampling_y);
+ : av1_get_max_uv_txsize(mbmi->sb_type, plane_ptr->subsampling_x,
+ plane_ptr->subsampling_y);
#endif
assert(tx_size < TX_SIZES_ALL);
#if CONFIG_SDP
@@ -266,9 +273,15 @@
params->filter_length = 0;
#if CONFIG_SDP
- const int plane_type =
- (frame_is_intra_only(cm) && plane > 0 && cm->seq_params.enable_sdp);
-#endif
+ TREE_TYPE tree_type = SHARED_PART;
+ const bool is_sdp_eligible = frame_is_intra_only(cm) &&
+ !cm->seq_params.monochrome &&
+ cm->seq_params.enable_sdp;
+ if (is_sdp_eligible) {
+ tree_type = (plane == AOM_PLANE_Y) ? LUMA_PART : CHROMA_PART;
+ }
+ const int plane_type = is_sdp_eligible && plane > 0;
+#endif // CONFIG_SDP
// no deblocking is required
const uint32_t width = plane_ptr->dst.width;
@@ -296,7 +309,7 @@
const TX_SIZE ts =
#if CONFIG_SDP
- get_transform_size(xd, cm, mi[0], edge_dir, mi_row, mi_col, plane,
+ get_transform_size(xd, mi[0], edge_dir, mi_row, mi_col, plane, tree_type,
plane_ptr);
#else
get_transform_size(xd, mi[0], edge_dir, mi_row, mi_col, plane, plane_ptr);
@@ -316,7 +329,7 @@
av1_get_filter_level(cm, &cm->lf_info, edge_dir, plane, mbmi);
#if CONFIG_SDP
const int curr_skipped =
- mbmi->skip_txfm[plane_type] && is_inter_block(mbmi, xd->tree_type);
+ mbmi->skip_txfm[plane_type] && is_inter_block(mbmi, tree_type);
#else
const int curr_skipped = mbmi->skip_txfm && is_inter_block(mbmi);
#endif
@@ -331,7 +344,8 @@
(VERT_EDGE == edge_dir) ? (mi_col - (1 << scale_horz)) : (mi_col);
const TX_SIZE pv_ts = get_transform_size(
#if CONFIG_SDP
- xd, cm, mi_prev, edge_dir, pv_row, pv_col, plane, plane_ptr);
+ xd, mi_prev, edge_dir, pv_row, pv_col, plane, tree_type,
+ plane_ptr);
#else
xd, mi_prev, edge_dir, pv_row, pv_col, plane, plane_ptr);
#endif
@@ -342,15 +356,24 @@
const int pv_skip_txfm =
#if CONFIG_SDP
mi_prev->skip_txfm[plane_type] &&
- is_inter_block(mi_prev, xd->tree_type);
+ is_inter_block(mi_prev, tree_type);
#else
mi_prev->skip_txfm && is_inter_block(mi_prev);
#endif
#if CONFIG_SDP
- const BLOCK_SIZE bsize = get_plane_block_size(
- mbmi->sb_type[plane > 0], plane_ptr->subsampling_x,
+ const BLOCK_SIZE bsize = get_mb_plane_block_size_from_tree_type(
+ mbmi, tree_type, plane, plane_ptr->subsampling_x,
plane_ptr->subsampling_y);
-#else
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(bsize == get_plane_block_size(mbmi->sb_type[plane_type],
+ plane_ptr->subsampling_x,
+ plane_ptr->subsampling_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#elif CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize =
+ get_mb_plane_block_size(xd, mbmi, plane, plane_ptr->subsampling_x,
+ plane_ptr->subsampling_y);
+#else // !CONFIG_EXT_RECUR_PARTITIONS && !CONFIG_SDP
const BLOCK_SIZE bsize =
get_plane_block_size(mbmi->sb_type, plane_ptr->subsampling_x,
plane_ptr->subsampling_y);
@@ -681,8 +704,7 @@
else if (plane == 2 && !(cm->lf.filter_level_v))
continue;
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, 0, 0,
- plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, 0, 0, plane, plane + 1, NULL);
av1_build_bitmask_vert_info(cm, &pd[plane], plane);
av1_build_bitmask_horz_info(cm, &pd[plane], plane);
@@ -690,19 +712,20 @@
// apply loop filtering which only goes through buffer once
for (mi_row = start; mi_row < stop; mi_row += MI_SIZE_64X64) {
for (mi_col = col_start; mi_col < col_end; mi_col += MI_SIZE_64X64) {
- av1_setup_dst_planes(pd, BLOCK_64X64, frame_buffer, mi_row, mi_col,
- plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_bitmask_vert(cm, &pd[plane], plane, mi_row,
mi_col);
if (mi_col - MI_SIZE_64X64 >= 0) {
- av1_setup_dst_planes(pd, BLOCK_64X64, frame_buffer, mi_row,
- mi_col - MI_SIZE_64X64, plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row,
+ mi_col - MI_SIZE_64X64, plane, plane + 1,
+ NULL);
av1_filter_block_plane_bitmask_horz(cm, &pd[plane], plane, mi_row,
mi_col - MI_SIZE_64X64);
}
}
- av1_setup_dst_planes(pd, BLOCK_64X64, frame_buffer, mi_row,
- mi_col - MI_SIZE_64X64, plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row, mi_col - MI_SIZE_64X64,
+ plane, plane + 1, NULL);
av1_filter_block_plane_bitmask_horz(cm, &pd[plane], plane, mi_row,
mi_col - MI_SIZE_64X64);
}
@@ -724,22 +747,21 @@
for (mi_row = start; mi_row < stop; mi_row += MAX_MIB_SIZE) {
for (mi_col = col_start; mi_col < col_end; mi_col += MAX_MIB_SIZE) {
// filter vertical edges
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_vert(cm, xd, plane, &pd[plane], mi_row,
mi_col);
// filter horizontal edges
if (mi_col - MAX_MIB_SIZE >= 0) {
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer,
- mi_row, mi_col - MAX_MIB_SIZE, plane,
- plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row,
+ mi_col - MAX_MIB_SIZE, plane, plane + 1, NULL);
av1_filter_block_plane_horz(cm, xd, plane, &pd[plane], mi_row,
mi_col - MAX_MIB_SIZE);
}
}
// filter horizontal edges
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col - MAX_MIB_SIZE, plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row, mi_col - MAX_MIB_SIZE,
+ plane, plane + 1, NULL);
av1_filter_block_plane_horz(cm, xd, plane, &pd[plane], mi_row,
mi_col - MAX_MIB_SIZE);
}
@@ -747,8 +769,8 @@
// filter all vertical edges in every 128x128 super block
for (mi_row = start; mi_row < stop; mi_row += MAX_MIB_SIZE) {
for (mi_col = col_start; mi_col < col_end; mi_col += MAX_MIB_SIZE) {
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_vert(cm, xd, plane, &pd[plane], mi_row,
mi_col);
}
@@ -757,8 +779,8 @@
// filter all horizontal edges in every 128x128 super block
for (mi_row = start; mi_row < stop; mi_row += MAX_MIB_SIZE) {
for (mi_col = col_start; mi_col < col_end; mi_col += MAX_MIB_SIZE) {
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(pd, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_horz(cm, xd, plane, &pd[plane], mi_row,
mi_col);
}
diff --git a/av1/common/blockd.c b/av1/common/blockd.c
index e8612f2..01e745b 100644
--- a/av1/common/blockd.c
+++ b/av1/common/blockd.c
@@ -15,6 +15,7 @@
#include "av1/common/av1_common_int.h"
#include "av1/common/blockd.h"
+#include "av1/common/enums.h"
PREDICTION_MODE av1_left_block_mode(const MB_MODE_INFO *left_mi) {
if (!left_mi) return DC_PRED;
@@ -38,6 +39,113 @@
return above_mi->mode;
}
+void av1_reset_is_mi_coded_map(MACROBLOCKD *xd, int stride) {
+ av1_zero(xd->is_mi_coded);
+ xd->is_mi_coded_stride = stride;
+}
+
+void av1_mark_block_as_coded(MACROBLOCKD *xd, BLOCK_SIZE bsize,
+ BLOCK_SIZE sb_size) {
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
+ const int sb_mi_size = mi_size_wide[sb_size];
+ const int mi_row_offset = mi_row & (sb_mi_size - 1);
+ const int mi_col_offset = mi_col & (sb_mi_size - 1);
+
+ for (int r = 0; r < mi_size_high[bsize]; ++r)
+ for (int c = 0; c < mi_size_wide[bsize]; ++c) {
+ const int pos =
+ (mi_row_offset + r) * xd->is_mi_coded_stride + mi_col_offset + c;
+#if CONFIG_SDP
+ switch (xd->tree_type) {
+ case SHARED_PART:
+ xd->is_mi_coded[0][pos] = 1;
+ xd->is_mi_coded[1][pos] = 1;
+ break;
+ case LUMA_PART: xd->is_mi_coded[0][pos] = 1; break;
+ case CHROMA_PART: xd->is_mi_coded[1][pos] = 1; break;
+ default: assert(0 && "Invalid tree type");
+ }
+#else
+ xd->is_mi_coded[pos] = 1;
+#endif // CONFIG_SDP
+ }
+}
+
+void av1_mark_block_as_not_coded(MACROBLOCKD *xd, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE sb_size) {
+ const int sb_mi_size = mi_size_wide[sb_size];
+ const int mi_row_offset = mi_row & (sb_mi_size - 1);
+ const int mi_col_offset = mi_col & (sb_mi_size - 1);
+
+ for (int r = 0; r < mi_size_high[bsize]; ++r) {
+ const int pos =
+ (mi_row_offset + r) * xd->is_mi_coded_stride + mi_col_offset;
+#if CONFIG_SDP
+ uint8_t *row_ptr_luma = &xd->is_mi_coded[0][pos];
+ uint8_t *row_ptr_chroma = &xd->is_mi_coded[1][pos];
+ switch (xd->tree_type) {
+ case SHARED_PART:
+ av1_zero_array(row_ptr_luma, mi_size_wide[bsize]);
+ av1_zero_array(row_ptr_chroma, mi_size_wide[bsize]);
+ break;
+ case LUMA_PART: av1_zero_array(row_ptr_luma, mi_size_wide[bsize]); break;
+ case CHROMA_PART:
+ av1_zero_array(row_ptr_chroma, mi_size_wide[bsize]);
+ break;
+ default: assert(0 && "Invalid tree type");
+ }
+#else
+ uint8_t *row_ptr = &xd->is_mi_coded[pos];
+ av1_zero_array(row_ptr, mi_size_wide[bsize]);
+#endif // CONFIG_SDP
+ }
+}
+
+PARTITION_TREE *av1_alloc_ptree_node(PARTITION_TREE *parent, int index) {
+ PARTITION_TREE *ptree = NULL;
+ struct aom_internal_error_info error;
+
+ AOM_CHECK_MEM_ERROR(&error, ptree, aom_calloc(1, sizeof(*ptree)));
+
+ ptree->parent = parent;
+ ptree->index = index;
+ ptree->partition = PARTITION_NONE;
+ ptree->is_settled = 0;
+ for (int i = 0; i < 4; ++i) ptree->sub_tree[i] = NULL;
+
+ return ptree;
+}
+
+void av1_free_ptree_recursive(PARTITION_TREE *ptree) {
+ if (ptree == NULL) return;
+
+ for (int i = 0; i < 4; ++i) {
+ av1_free_ptree_recursive(ptree->sub_tree[i]);
+ ptree->sub_tree[i] = NULL;
+ }
+
+ aom_free(ptree);
+}
+
+void av1_reset_ptree_in_sbi(SB_INFO *sbi
+#if CONFIG_SDP
+ ,
+ TREE_TYPE tree_type
+#endif // CONFIG_SDP
+) {
+#if CONFIG_SDP
+ const int idx = av1_get_sdp_idx(tree_type);
+ if (sbi->ptree_root[idx]) av1_free_ptree_recursive(sbi->ptree_root[idx]);
+
+ sbi->ptree_root[idx] = av1_alloc_ptree_node(NULL, 0);
+#else
+ if (sbi->ptree_root) av1_free_ptree_recursive(sbi->ptree_root);
+
+ sbi->ptree_root = av1_alloc_ptree_node(NULL, 0);
+#endif // CONFIG_SDP
+}
+
void av1_set_entropy_contexts(const MACROBLOCKD *xd,
struct macroblockd_plane *pd, int plane,
BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
@@ -67,14 +175,42 @@
memset(l, has_eob, sizeof(*l) * txs_high);
}
}
+
void av1_reset_entropy_context(MACROBLOCKD *xd, BLOCK_SIZE bsize,
const int num_planes) {
- assert(bsize < BLOCK_SIZES_ALL);
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ // TODO(chiyotsai): This part is needed to avoid encoder/decoder mismatch.
+ // Investigate why this is the case. It seems like on the decoder side, the
+ // decoder is failing to clear the context after encoding a skip_txfm chroma
+ // block.
+ const int plane_start = (xd->tree_type == CHROMA_PART);
+ int plane_end = 0;
+ switch (xd->tree_type) {
+ case LUMA_PART: plane_end = 1; break;
+ case CHROMA_PART: plane_end = num_planes; break;
+ case SHARED_PART:
+ plane_end = 1 + (num_planes - 1) * xd->is_chroma_ref;
+ break;
+ default: assert(0);
+ }
+ for (int i = plane_start; i < plane_end; ++i) {
+#else
const int nplanes = 1 + (num_planes - 1) * xd->is_chroma_ref;
for (int i = 0; i < nplanes; i++) {
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
struct macroblockd_plane *const pd = &xd->plane[i];
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, xd->mi[0], i, pd->subsampling_x, pd->subsampling_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize ==
+ get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+ (void)bsize;
+#else
const BLOCK_SIZE plane_bsize =
get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+#endif // CONFIG_SDP
const int txs_wide = mi_size_wide[plane_bsize];
const int txs_high = mi_size_high[plane_bsize];
memset(pd->above_entropy_context, 0, sizeof(ENTROPY_CONTEXT) * txs_wide);
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 97be296..63b40e0 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -237,6 +237,15 @@
COMPOUND_TYPE type;
} INTERINTER_COMPOUND_DATA;
+typedef struct CHROMA_REF_INFO {
+ int is_chroma_ref;
+ int offset_started;
+ int mi_row_chroma_base;
+ int mi_col_chroma_base;
+ BLOCK_SIZE bsize;
+ BLOCK_SIZE bsize_base;
+} CHROMA_REF_INFO;
+
#define INTER_TX_SIZE_BUF_LEN 16
#define TXK_TYPE_BUF_LEN 64
/*!\endcond */
@@ -377,6 +386,8 @@
uint8_t use_wedge_interintra : 1;
/*! \brief CDEF strength per BLOCK_64X64 */
int8_t cdef_strength : 4;
+ /*! \brief chroma block info for sub-8x8 cases */
+ CHROMA_REF_INFO chroma_ref_info;
#if CONFIG_CCSO
/*! \brief Whether to use cross-component sample offset for the U plane. */
uint8_t ccso_blk_u : 2;
@@ -401,6 +412,38 @@
/*!\cond */
+typedef struct PARTITION_TREE {
+ struct PARTITION_TREE *parent;
+ struct PARTITION_TREE *sub_tree[4];
+ PARTITION_TYPE partition;
+ BLOCK_SIZE bsize;
+ int is_settled;
+ int mi_row;
+ int mi_col;
+ int index;
+ CHROMA_REF_INFO chroma_ref_info;
+} PARTITION_TREE;
+
+PARTITION_TREE *av1_alloc_ptree_node(PARTITION_TREE *parent, int index);
+void av1_free_ptree_recursive(PARTITION_TREE *ptree);
+
+typedef struct SB_INFO {
+ int mi_row;
+ int mi_col;
+#if CONFIG_SDP
+ PARTITION_TREE *ptree_root[2];
+#else
+ PARTITION_TREE *ptree_root;
+#endif // CONFIG_SDP
+} SB_INFO;
+
+void av1_reset_ptree_in_sbi(SB_INFO *sbi
+#if CONFIG_SDP
+ ,
+ TREE_TYPE tree_type
+#endif // CONFIG_SDP
+);
+
#if CONFIG_SDP
static INLINE int is_intrabc_block(const MB_MODE_INFO *mbmi, int tree_type) {
return mbmi->use_intrabc[tree_type == CHROMA_PART];
@@ -444,6 +487,30 @@
}
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE PARTITION_TYPE get_partition_from_symbol_rec_block(
+ BLOCK_SIZE bsize, PARTITION_TYPE_REC partition_rec) {
+ if (block_size_wide[bsize] > block_size_high[bsize])
+ return partition_map_from_symbol_block_wgth[partition_rec];
+ else if (block_size_high[bsize] > block_size_wide[bsize])
+ return partition_map_from_symbol_block_hgtw[partition_rec];
+ else
+ return PARTITION_INVALID;
+}
+
+static INLINE PARTITION_TYPE_REC get_symbol_from_partition_rec_block(
+ BLOCK_SIZE bsize, PARTITION_TYPE partition) {
+ assert(bsize < BLOCK_SIZES_ALL);
+ assert(partition < EXT_PARTITION_TYPES);
+ if (block_size_wide[bsize] > block_size_high[bsize])
+ return symbol_map_from_partition_block_wgth[partition];
+ else if (block_size_high[bsize] > block_size_wide[bsize])
+ return symbol_map_from_partition_block_hgtw[partition];
+ else
+ return PARTITION_INVALID_REC;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
return mbmi->ref_frame[1] > INTRA_FRAME;
}
@@ -503,6 +570,356 @@
block_size_allowed;
}
+static INLINE int is_square_block(BLOCK_SIZE bsize) {
+ return block_size_high[bsize] == block_size_wide[bsize];
+}
+
+static INLINE int is_partition_point(BLOCK_SIZE bsize) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ return bsize != BLOCK_4X4 && bsize < BLOCK_SIZES;
+#else
+ return is_square_block(bsize) && bsize >= BLOCK_8X8 && bsize < BLOCK_SIZES;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+}
+
+static INLINE int get_sqr_bsize_idx(BLOCK_SIZE bsize) {
+ switch (bsize) {
+ case BLOCK_4X4: return 0;
+ case BLOCK_8X8: return 1;
+ case BLOCK_16X16: return 2;
+ case BLOCK_32X32: return 3;
+ case BLOCK_64X64: return 4;
+ case BLOCK_128X128: return 5;
+ default: return SQR_BLOCK_SIZES;
+ }
+}
+
+// For a square block size 'bsize', returns the size of the sub-blocks used by
+// the given partition type. If the partition produces sub-blocks of different
+// sizes, then the function returns the largest sub-block size.
+// Implements the Partition_Subsize lookup table in the spec (Section 9.3.
+// Conversion tables).
+// Note: the input block size should be square.
+// Otherwise it's considered invalid.
+static INLINE BLOCK_SIZE get_partition_subsize(BLOCK_SIZE bsize,
+ PARTITION_TYPE partition) {
+ if (partition == PARTITION_INVALID) {
+ return BLOCK_INVALID;
+ } else {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (is_partition_point(bsize))
+ return subsize_lookup[partition][bsize];
+ else
+ return partition == PARTITION_NONE ? bsize : BLOCK_INVALID;
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ const int sqr_bsize_idx = get_sqr_bsize_idx(bsize);
+ return sqr_bsize_idx >= SQR_BLOCK_SIZES
+ ? BLOCK_INVALID
+ : subsize_lookup[partition][sqr_bsize_idx];
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ }
+}
+
+static INLINE int is_partition_valid(BLOCK_SIZE bsize, PARTITION_TYPE p) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (p == PARTITION_SPLIT) return 0;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ if (is_partition_point(bsize))
+ return get_partition_subsize(bsize, p) < BLOCK_SIZES_ALL;
+ else
+ return p == PARTITION_NONE;
+}
+
+static INLINE void initialize_chr_ref_info(int mi_row, int mi_col,
+ BLOCK_SIZE bsize,
+ CHROMA_REF_INFO *info) {
+ info->is_chroma_ref = 1;
+ info->offset_started = 0;
+ info->mi_row_chroma_base = mi_row;
+ info->mi_col_chroma_base = mi_col;
+ info->bsize = bsize;
+ info->bsize_base = bsize;
+}
+
+// Decide whether a block needs coding multiple chroma coding blocks in it at
+// once to get around sub-4x4 coding.
+static INLINE int have_nz_chroma_ref_offset(BLOCK_SIZE bsize,
+ PARTITION_TYPE partition,
+ int subsampling_x,
+ int subsampling_y) {
+ const int bw = block_size_wide[bsize] >> subsampling_x;
+ const int bh = block_size_high[bsize] >> subsampling_y;
+ const int bw_less_than_4 = bw < 4;
+ const int bh_less_than_4 = bh < 4;
+ const int hbw_less_than_4 = bw < 8;
+ const int hbh_less_than_4 = bh < 8;
+ const int qbw_less_than_4 = bw < 16;
+ const int qbh_less_than_4 = bh < 16;
+ switch (partition) {
+ case PARTITION_NONE: return bw_less_than_4 || bh_less_than_4;
+ case PARTITION_HORZ: return bw_less_than_4 || hbh_less_than_4;
+ case PARTITION_VERT: return hbw_less_than_4 || bh_less_than_4;
+ case PARTITION_SPLIT: return hbw_less_than_4 || hbh_less_than_4;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3: return bw_less_than_4 || qbh_less_than_4;
+ case PARTITION_VERT_3: return qbw_less_than_4 || bh_less_than_4;
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_A:
+ case PARTITION_HORZ_B:
+ case PARTITION_VERT_A:
+ case PARTITION_VERT_B: return hbw_less_than_4 || hbh_less_than_4;
+ case PARTITION_HORZ_4: return bw_less_than_4 || qbh_less_than_4;
+ case PARTITION_VERT_4: return qbw_less_than_4 || bh_less_than_4;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ default:
+ assert(0 && "Invalid partition type!");
+ return 0;
+ break;
+ }
+}
+
+// Decide whether a subblock is the main chroma reference when its parent block
+// needs coding multiple chroma coding blocks at once. The function returns a
+// flag indicating whether the mode info used for the combined chroma block is
+// located in the subblock.
+static INLINE int is_sub_partition_chroma_ref(PARTITION_TYPE partition,
+ int index, BLOCK_SIZE bsize,
+ BLOCK_SIZE parent_bsize, int ss_x,
+ int ss_y, int is_offset_started) {
+ (void)is_offset_started;
+ (void)parent_bsize;
+ const int bw = block_size_wide[bsize];
+ const int bh = block_size_high[bsize];
+ const int pw = bw >> ss_x;
+ const int ph = bh >> ss_y;
+ const int pw_less_than_4 = pw < 4;
+ const int ph_less_than_4 = ph < 4;
+ switch (partition) {
+ case PARTITION_NONE: return 1;
+ case PARTITION_HORZ:
+ case PARTITION_VERT: return index == 1;
+ case PARTITION_SPLIT:
+ if (is_offset_started) {
+ return index == 3;
+ } else {
+ if (pw_less_than_4 && ph_less_than_4)
+ return index == 3;
+ else if (pw_less_than_4)
+ return index == 1 || index == 3;
+ else if (ph_less_than_4)
+ return index == 2 || index == 3;
+ else
+ return 1;
+ }
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_VERT_3:
+ case PARTITION_HORZ_3: return index == 2;
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_A:
+ case PARTITION_HORZ_B:
+ case PARTITION_VERT_A:
+ case PARTITION_VERT_B:
+ if (is_offset_started) {
+ return index == 2;
+ } else {
+ const int smallest_w = block_size_wide[parent_bsize] >> (ss_x + 1);
+ const int smallest_h = block_size_high[parent_bsize] >> (ss_y + 1);
+ const int smallest_w_less_than_4 = smallest_w < 4;
+ const int smallest_h_less_than_4 = smallest_h < 4;
+ if (smallest_w_less_than_4 && smallest_h_less_than_4) {
+ return index == 2;
+ } else if (smallest_w_less_than_4) {
+ if (partition == PARTITION_VERT_A || partition == PARTITION_VERT_B) {
+ return index == 2;
+ } else if (partition == PARTITION_HORZ_A) {
+ return index == 1 || index == 2;
+ } else {
+ return index == 0 || index == 2;
+ }
+ } else if (smallest_h_less_than_4) {
+ if (partition == PARTITION_HORZ_A || partition == PARTITION_HORZ_B) {
+ return index == 2;
+ } else if (partition == PARTITION_VERT_A) {
+ return index == 1 || index == 2;
+ } else {
+ return index == 0 || index == 2;
+ }
+ } else {
+ return 1;
+ }
+ }
+ case PARTITION_HORZ_4:
+ case PARTITION_VERT_4:
+ if (is_offset_started) {
+ return index == 3;
+ } else {
+ if ((partition == PARTITION_HORZ_4 && ph_less_than_4) ||
+ (partition == PARTITION_VERT_4 && pw_less_than_4)) {
+ return index == 1 || index == 3;
+ } else {
+ return 1;
+ }
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ default:
+ assert(0 && "Invalid partition type!");
+ return 0;
+ break;
+ }
+}
+
+static INLINE void set_chroma_ref_offset_size(
+ int mi_row, int mi_col, PARTITION_TYPE partition, BLOCK_SIZE bsize,
+ BLOCK_SIZE parent_bsize, int ss_x, int ss_y, CHROMA_REF_INFO *info,
+ const CHROMA_REF_INFO *parent_info) {
+ const int pw = block_size_wide[bsize] >> ss_x;
+ const int ph = block_size_high[bsize] >> ss_y;
+ const int pw_less_than_4 = pw < 4;
+ const int ph_less_than_4 = ph < 4;
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const int hppw = block_size_wide[parent_bsize] >> (ss_x + 1);
+ const int hpph = block_size_high[parent_bsize] >> (ss_y + 1);
+ const int hppw_less_than_4 = hppw < 4;
+ const int hpph_less_than_4 = hpph < 4;
+ const int mi_row_mid_point =
+ parent_info->mi_row_chroma_base + (mi_size_high[parent_bsize] >> 1);
+ const int mi_col_mid_point =
+ parent_info->mi_col_chroma_base + (mi_size_wide[parent_bsize] >> 1);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+ assert(parent_info->offset_started == 0);
+ switch (partition) {
+ case PARTITION_NONE:
+ case PARTITION_HORZ:
+ case PARTITION_VERT:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_VERT_3:
+ case PARTITION_HORZ_3:
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ info->bsize_base = parent_bsize;
+ break;
+ case PARTITION_SPLIT:
+ if (pw_less_than_4 && ph_less_than_4) {
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ info->bsize_base = parent_bsize;
+ } else if (pw_less_than_4) {
+ info->bsize_base = get_partition_subsize(parent_bsize, PARTITION_HORZ);
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ if (mi_row == parent_info->mi_row_chroma_base) {
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ } else {
+ info->mi_row_chroma_base =
+ parent_info->mi_row_chroma_base + mi_size_high[bsize];
+ }
+ } else {
+ assert(ph_less_than_4);
+ info->bsize_base = get_partition_subsize(parent_bsize, PARTITION_VERT);
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ if (mi_col == parent_info->mi_col_chroma_base) {
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ } else {
+ info->mi_col_chroma_base =
+ parent_info->mi_col_chroma_base + mi_size_wide[bsize];
+ }
+ }
+ break;
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_A:
+ case PARTITION_HORZ_B:
+ case PARTITION_VERT_A:
+ case PARTITION_VERT_B:
+ if ((hppw_less_than_4 && hpph_less_than_4) ||
+ (hppw_less_than_4 &&
+ (partition == PARTITION_VERT_A || partition == PARTITION_VERT_B)) ||
+ (hpph_less_than_4 &&
+ (partition == PARTITION_HORZ_A || partition == PARTITION_HORZ_B))) {
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ info->bsize_base = parent_bsize;
+ } else if (hppw_less_than_4) {
+ info->bsize_base = get_partition_subsize(parent_bsize, PARTITION_HORZ);
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ if (mi_row == parent_info->mi_row_chroma_base) {
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ } else {
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base +
+ (mi_size_high[parent_bsize] >> 1);
+ }
+ } else {
+ assert(hpph_less_than_4);
+ info->bsize_base = get_partition_subsize(parent_bsize, PARTITION_VERT);
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ if (mi_col == parent_info->mi_col_chroma_base) {
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ } else {
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base +
+ (mi_size_wide[parent_bsize] >> 1);
+ }
+ }
+ break;
+ case PARTITION_HORZ_4:
+ info->bsize_base = get_partition_subsize(parent_bsize, PARTITION_HORZ);
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ if (mi_row < mi_row_mid_point) {
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ } else {
+ info->mi_row_chroma_base = mi_row_mid_point;
+ }
+ break;
+ case PARTITION_VERT_4:
+ info->bsize_base = get_partition_subsize(parent_bsize, PARTITION_VERT);
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ if (mi_col < mi_col_mid_point) {
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ } else {
+ info->mi_col_chroma_base = mi_col_mid_point;
+ }
+ break;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+ default: assert(0 && "Invalid partition type!"); break;
+ }
+}
+
+static INLINE void set_chroma_ref_info(int mi_row, int mi_col, int index,
+ BLOCK_SIZE bsize, CHROMA_REF_INFO *info,
+ const CHROMA_REF_INFO *parent_info,
+ BLOCK_SIZE parent_bsize,
+ PARTITION_TYPE parent_partition,
+ int ss_x, int ss_y) {
+ assert(bsize < BLOCK_SIZES_ALL);
+ initialize_chr_ref_info(mi_row, mi_col, bsize, info);
+ if (parent_info == NULL) return;
+ if (parent_info->is_chroma_ref) {
+ if (parent_info->offset_started) {
+ if (is_sub_partition_chroma_ref(parent_partition, index, bsize,
+ parent_bsize, ss_x, ss_y, 1)) {
+ info->is_chroma_ref = 1;
+ } else {
+ info->is_chroma_ref = 0;
+ }
+ info->offset_started = 1;
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ info->bsize_base = parent_info->bsize_base;
+ } else if (have_nz_chroma_ref_offset(parent_bsize, parent_partition, ss_x,
+ ss_y)) {
+ info->offset_started = 1;
+ info->is_chroma_ref = is_sub_partition_chroma_ref(
+ parent_partition, index, bsize, parent_bsize, ss_x, ss_y, 0);
+ set_chroma_ref_offset_size(mi_row, mi_col, parent_partition, bsize,
+ parent_bsize, ss_x, ss_y, info, parent_info);
+ }
+ } else {
+ info->is_chroma_ref = 0;
+ info->offset_started = 1;
+ info->mi_row_chroma_base = parent_info->mi_row_chroma_base;
+ info->mi_col_chroma_base = parent_info->mi_col_chroma_base;
+ info->bsize_base = parent_info->bsize_base;
+ }
+}
+
#if CONFIG_MISMATCH_DEBUG
static INLINE void mi_to_pixel_loc(int *pixel_c, int *pixel_r, int mi_col,
int mi_row, int tx_blk_col, int tx_blk_row,
@@ -745,6 +1162,11 @@
MB_MODE_INFO *chroma_above_mbmi;
/*!
+ * SB_INFO for the superblock that the current coding block is located in
+ */
+ SB_INFO *sbi;
+
+ /*!
* Appropriate offset based on current 'mi_row' and 'mi_col', inside
* 'tx_type_map' in one of 'CommonModeInfoParams', 'PICK_MODE_CONTEXT' or
* 'MACROBLOCK' structs.
@@ -772,7 +1194,22 @@
* block shares the same tree or not.
*/
TREE_TYPE tree_type;
-#endif
+
+ /*!
+ * An array for recording whether an mi(4x4) is coded. Reset at sb level.
+ */
+ // TODO(any): Convert to bit field instead.
+ uint8_t is_mi_coded[2][MAX_MIB_SQUARE];
+#else
+ /*!
+ * An array for recording whether an mi(4x4) is coded. Reset at sb level.
+ */
+ uint8_t is_mi_coded[MAX_MIB_SQUARE];
+#endif // CONFIG_SDP
+ /*!
+ * Stride of the is_mi_coded array.
+ */
+ int is_mi_coded_stride;
/*!
* Scale factors for reference frames of the current block.
@@ -1061,37 +1498,6 @@
: buf16;
}
-static INLINE int get_sqr_bsize_idx(BLOCK_SIZE bsize) {
- switch (bsize) {
- case BLOCK_4X4: return 0;
- case BLOCK_8X8: return 1;
- case BLOCK_16X16: return 2;
- case BLOCK_32X32: return 3;
- case BLOCK_64X64: return 4;
- case BLOCK_128X128: return 5;
- default: return SQR_BLOCK_SIZES;
- }
-}
-
-// For a square block size 'bsize', returns the size of the sub-blocks used by
-// the given partition type. If the partition produces sub-blocks of different
-// sizes, then the function returns the largest sub-block size.
-// Implements the Partition_Subsize lookup table in the spec (Section 9.3.
-// Conversion tables).
-// Note: the input block size should be square.
-// Otherwise it's considered invalid.
-static INLINE BLOCK_SIZE get_partition_subsize(BLOCK_SIZE bsize,
- PARTITION_TYPE partition) {
- if (partition == PARTITION_INVALID) {
- return BLOCK_INVALID;
- } else {
- const int sqr_bsize_idx = get_sqr_bsize_idx(bsize);
- return sqr_bsize_idx >= SQR_BLOCK_SIZES
- ? BLOCK_INVALID
- : subsize_lookup[partition][sqr_bsize_idx];
- }
-}
-
static TX_TYPE intra_mode_to_tx_type(const MB_MODE_INFO *mbmi,
PLANE_TYPE plane_type) {
static const TX_TYPE _intra_mode_to_tx_type[INTRA_MODES] = {
@@ -1266,6 +1672,74 @@
return ss_size_lookup[bsize][subsampling_x][subsampling_y];
}
+#if CONFIG_SDP
+static INLINE int av1_get_sdp_idx(TREE_TYPE tree_type) {
+ switch (tree_type) {
+ case SHARED_PART:
+ case LUMA_PART: return 0;
+ case CHROMA_PART: return 1; break;
+ default: assert(0 && "Invalid tree type"); return 0;
+ }
+}
+#endif // CONFIG_SDP
+
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+static INLINE BLOCK_SIZE get_bsize_base(const MACROBLOCKD *xd,
+ const MB_MODE_INFO *mbmi, int plane) {
+ BLOCK_SIZE bsize_base = BLOCK_INVALID;
+#if CONFIG_SDP
+ if (xd->tree_type == SHARED_PART) {
+ bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base : mbmi->sb_type[PLANE_TYPE_Y];
+ } else {
+ bsize_base = mbmi->sb_type[av1_get_sdp_idx(xd->tree_type)];
+ }
+#else
+ bsize_base = plane ? mbmi->chroma_ref_info.bsize_base : mbmi->sb_type;
+ (void)xd;
+#endif // CONFIG_SDP
+ return bsize_base;
+}
+
+static INLINE BLOCK_SIZE get_mb_plane_block_size(const MACROBLOCKD *xd,
+ const MB_MODE_INFO *mbmi,
+ int plane, int subsampling_x,
+ int subsampling_y) {
+ assert(subsampling_x >= 0 && subsampling_x < 2);
+ assert(subsampling_y >= 0 && subsampling_y < 2);
+ const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
+ return get_plane_block_size(bsize_base, subsampling_x, subsampling_y);
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+
+#if CONFIG_SDP
+// These are only needed to support lpf multi-thread.
+// Because xd is shared among all the threads workers, xd->tree_type does not
+// contain the valid tree_type, so we are passing in the tree_type
+static INLINE BLOCK_SIZE get_bsize_base_from_tree_type(const MB_MODE_INFO *mbmi,
+ TREE_TYPE tree_type,
+ int plane) {
+ BLOCK_SIZE bsize_base = BLOCK_INVALID;
+ if (tree_type == SHARED_PART) {
+ bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base : mbmi->sb_type[PLANE_TYPE_Y];
+ } else {
+ bsize_base = mbmi->sb_type[av1_get_sdp_idx(tree_type)];
+ }
+ return bsize_base;
+}
+
+static INLINE BLOCK_SIZE get_mb_plane_block_size_from_tree_type(
+ const MB_MODE_INFO *mbmi, TREE_TYPE tree_type, int plane, int subsampling_x,
+ int subsampling_y) {
+ assert(subsampling_x >= 0 && subsampling_x < 2);
+ assert(subsampling_y >= 0 && subsampling_y < 2);
+ const BLOCK_SIZE bsize_base =
+ get_bsize_base_from_tree_type(mbmi, tree_type, plane);
+ return get_plane_block_size(bsize_base, subsampling_x, subsampling_y);
+}
+#endif // CONFIG_SDP
+
/*
* Logic to generate the lookup tables:
*
@@ -1471,7 +1945,7 @@
if (is_inter_block(mbmi, xd->tree_type)) {
#else
if (is_inter_block(mbmi)) {
-#endif // CONFIG_SDP
+#endif
// scale back to y plane's coordinate
const struct macroblockd_plane *const pd = &xd->plane[plane_type];
blk_row <<= pd->subsampling_y;
@@ -1492,7 +1966,7 @@
reduced_tx_set);
#else
av1_get_ext_tx_set_type(tx_size, is_inter_block(mbmi), reduced_tx_set);
-#endif // CONFIG_SDP
+#endif
if (!av1_ext_tx_used[tx_set_type][tx_type]) tx_type = DCT_DCT;
}
#if CONFIG_IST
@@ -1597,12 +2071,16 @@
if (xd->lossless[mbmi->segment_id]) return TX_4X4;
if (plane == 0) return mbmi->tx_size;
const MACROBLOCKD_PLANE *pd = &xd->plane[plane];
-#if CONFIG_SDP
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
+ return av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
+ pd->subsampling_y);
+#elif CONFIG_SDP
return av1_get_max_uv_txsize(mbmi->sb_type[PLANE_TYPE_UV], pd->subsampling_x,
pd->subsampling_y);
#else
- return av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x,
- pd->subsampling_y);
+ return av1_get_max_uv_txsize(mbmi->chroma_ref_info.bsize_base,
+ pd->subsampling_x, pd->subsampling_y);
#endif
}
@@ -1623,6 +2101,12 @@
BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
int has_eob, int aoff, int loff);
+void av1_reset_is_mi_coded_map(MACROBLOCKD *xd, int stride);
+void av1_mark_block_as_coded(MACROBLOCKD *xd, BLOCK_SIZE bsize,
+ BLOCK_SIZE sb_size);
+void av1_mark_block_as_not_coded(MACROBLOCKD *xd, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE sb_size);
+
#define MAX_INTERINTRA_SB_SQUARE 32 * 32
static INLINE int is_interintra_mode(const MB_MODE_INFO *mbmi) {
return (mbmi->ref_frame[0] > INTRA_FRAME &&
@@ -1677,9 +2161,27 @@
return av1_get_adjusted_tx_size(max_txsize); // chroma
}
-static INLINE int is_motion_variation_allowed_bsize(BLOCK_SIZE bsize) {
+static INLINE int is_motion_variation_allowed_bsize(BLOCK_SIZE bsize,
+ int mi_row, int mi_col) {
assert(bsize < BLOCK_SIZES_ALL);
- return AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8;
+
+ if (AOMMIN(block_size_wide[bsize], block_size_high[bsize]) < 8) {
+ return 0;
+ }
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // TODO(urvang): Enable this special case, if we make OBMC work.
+ // TODO(yuec): Enable this case when the alignment issue is fixed. There
+ // will be memory leak in global above_pred_buff and left_pred_buff if
+ // the restriction on mi_row and mi_col is removed.
+ if ((mi_row & 0x01) || (mi_col & 0x01)) {
+ return 0;
+ }
+#else
+ assert(!(mi_row & 0x01) && !(mi_col & 0x01));
+ (void)mi_row;
+ (void)mi_col;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ return 1;
}
static INLINE int is_motion_variation_allowed_compound(
@@ -1703,9 +2205,11 @@
if (is_global_mv_block(mbmi, gm_type)) return SIMPLE_TRANSLATION;
}
#if CONFIG_SDP
- if (is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y]) &&
+ if (is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y], xd->mi_row,
+ xd->mi_col) &&
#else
- if (is_motion_variation_allowed_bsize(mbmi->sb_type) &&
+ if (is_motion_variation_allowed_bsize(mbmi->sb_type, xd->mi_row,
+ xd->mi_col) &&
#endif
is_inter_mode(mbmi->mode) && mbmi->ref_frame[1] != INTRA_FRAME &&
is_motion_variation_allowed_compound(mbmi)) {
@@ -1752,6 +2256,7 @@
int *height,
int *rows_within_bounds,
int *cols_within_bounds) {
+ if (plane > 0) bsize = xd->mi[0]->chroma_ref_info.bsize_base;
const int block_height = block_size_high[bsize];
const int block_width = block_size_wide[bsize];
const int block_rows = (xd->mb_to_bottom_edge >= 0)
@@ -1842,6 +2347,18 @@
}
return tx_size_2d[tx_size];
}
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+static AOM_INLINE const PARTITION_TREE *get_partition_subtree_const(
+ const PARTITION_TREE *partition_tree, int idx) {
+ if (!partition_tree) {
+ return NULL;
+ }
+ return partition_tree->sub_tree[idx];
+}
+
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
/*!\endcond */
#ifdef __cplusplus
diff --git a/av1/common/ccso.c b/av1/common/ccso.c
index 5596ceb..5f8e44c 100644
--- a/av1/common/ccso.c
+++ b/av1/common/ccso.c
@@ -271,8 +271,7 @@
void ccso_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd,
uint16_t *ext_rec_y) {
const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, frame, 0, 0, 0, num_planes, NULL);
const uint8_t quant_sz[4] = { 16, 8, 32, 64 };
for (int plane = 1; plane < 3; plane++) {
diff --git a/av1/common/cdef.c b/av1/common/cdef.c
index ffb0159..14ec3bb 100644
--- a/av1/common/cdef.c
+++ b/av1/common/cdef.c
@@ -142,8 +142,7 @@
int coeff_shift = AOMMAX(cm->seq_params.bit_depth - 8, 0);
const int nvfb = (mi_params->mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
const int nhfb = (mi_params->mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, frame, 0, 0, 0, num_planes, NULL);
row_cdef = aom_malloc(sizeof(*row_cdef) * (nhfb + 2) * 2);
memset(row_cdef, 1, sizeof(*row_cdef) * (nhfb + 2) * 2);
prev_row_cdef = row_cdef + 1;
diff --git a/av1/common/cfl.c b/av1/common/cfl.c
index 718f6c0..1df05bb 100644
--- a/av1/common/cfl.c
+++ b/av1/common/cfl.c
@@ -372,41 +372,21 @@
}
}
-// Adjust the row and column of blocks smaller than 8X8, as chroma-referenced
-// and non-chroma-referenced blocks are stored together in the CfL buffer.
-static INLINE void sub8x8_adjust_offset(const CFL_CTX *cfl, int mi_row,
- int mi_col, int *row_out,
- int *col_out) {
- // Increment row index for bottom: 8x4, 16x4 or both bottom 4x4s.
- if ((mi_row & 0x01) && cfl->subsampling_y) {
- assert(*row_out == 0);
- (*row_out)++;
- }
-
- // Increment col index for right: 4x8, 4x16 or both right 4x4s.
- if ((mi_col & 0x01) && cfl->subsampling_x) {
- assert(*col_out == 0);
- (*col_out)++;
- }
-}
-
-void cfl_store_tx(MACROBLOCKD *const xd, int row, int col, TX_SIZE tx_size,
- BLOCK_SIZE bsize) {
+void cfl_store_tx(MACROBLOCKD *const xd, int row, int col, TX_SIZE tx_size) {
CFL_CTX *const cfl = &xd->cfl;
struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_Y];
uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];
+ const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
+ const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
+ const int row_offset = mi_row - xd->mi[0]->chroma_ref_info.mi_row_chroma_base;
+ const int col_offset = mi_col - xd->mi[0]->chroma_ref_info.mi_col_chroma_base;
- if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
- // Only dimensions of size 4 can have an odd offset.
- assert(!((col & 1) && tx_size_wide[tx_size] != 4));
- assert(!((row & 1) && tx_size_high[tx_size] != 4));
- sub8x8_adjust_offset(cfl, xd->mi_row, xd->mi_col, &row, &col);
- }
#if CONFIG_SDP
- cfl_store(xd, cfl, dst, pd->dst.stride, row, col, tx_size,
- is_cur_buf_hbd(xd));
+ cfl_store(xd, cfl, dst, pd->dst.stride, row + row_offset, col + col_offset,
+ tx_size, is_cur_buf_hbd(xd));
#else
- cfl_store(cfl, dst, pd->dst.stride, row, col, tx_size, is_cur_buf_hbd(xd));
+ cfl_store(cfl, dst, pd->dst.stride, row + row_offset, col + col_offset,
+ tx_size, is_cur_buf_hbd(xd));
#endif
}
@@ -429,21 +409,20 @@
void cfl_store_block(MACROBLOCKD *const xd, BLOCK_SIZE bsize, TX_SIZE tx_size) {
CFL_CTX *const cfl = &xd->cfl;
struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_Y];
- int row = 0;
- int col = 0;
-
- if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
- sub8x8_adjust_offset(cfl, xd->mi_row, xd->mi_col, &row, &col);
- }
const int width = max_intra_block_width(xd, bsize, AOM_PLANE_Y, tx_size);
const int height = max_intra_block_height(xd, bsize, AOM_PLANE_Y, tx_size);
+ const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
+ const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
+ const int row_offset = mi_row - xd->mi[0]->chroma_ref_info.mi_row_chroma_base;
+ const int col_offset = mi_col - xd->mi[0]->chroma_ref_info.mi_col_chroma_base;
+
tx_size = get_tx_size(width, height);
assert(tx_size != TX_INVALID);
#if CONFIG_SDP
- cfl_store(xd, cfl, pd->dst.buf, pd->dst.stride, row, col, tx_size,
- is_cur_buf_hbd(xd));
+ cfl_store(xd, cfl, pd->dst.buf, pd->dst.stride, row_offset, col_offset,
+ tx_size, is_cur_buf_hbd(xd));
#else
- cfl_store(cfl, pd->dst.buf, pd->dst.stride, row, col, tx_size,
+ cfl_store(cfl, pd->dst.buf, pd->dst.stride, row_offset, col_offset, tx_size,
is_cur_buf_hbd(xd));
#endif
}
diff --git a/av1/common/cfl.h b/av1/common/cfl.h
index 2463e2d..f9c11c6 100644
--- a/av1/common/cfl.h
+++ b/av1/common/cfl.h
@@ -20,9 +20,7 @@
const MB_MODE_INFO *mbmi = xd->mi[0];
#if CONFIG_SDP
if (xd->tree_type == LUMA_PART) return CFL_DISALLOWED;
- const BLOCK_SIZE bsize =
- mbmi->sb_type[xd->tree_type == SHARED_PART ? PLANE_TYPE_Y
- : PLANE_TYPE_UV];
+ const BLOCK_SIZE bsize = get_bsize_base(xd, mbmi, AOM_PLANE_U);
#else
const BLOCK_SIZE bsize = mbmi->sb_type;
#endif
@@ -82,8 +80,7 @@
void cfl_store_block(MACROBLOCKD *const xd, BLOCK_SIZE bsize, TX_SIZE tx_size);
-void cfl_store_tx(MACROBLOCKD *const xd, int row, int col, TX_SIZE tx_size,
- BLOCK_SIZE bsize);
+void cfl_store_tx(MACROBLOCKD *const xd, int row, int col, TX_SIZE tx_size);
void cfl_store_dc_pred(MACROBLOCKD *const xd, const uint8_t *input,
CFL_PRED_TYPE pred_plane, int width);
diff --git a/av1/common/common_data.h b/av1/common/common_data.h
index ca47b4a..88ce99a 100644
--- a/av1/common/common_data.h
+++ b/av1/common/common_data.h
@@ -12,6 +12,9 @@
#ifndef AOM_AV1_COMMON_COMMON_DATA_H_
#define AOM_AV1_COMMON_COMMON_DATA_H_
+#include <assert.h>
+#include <stdbool.h>
+
#include "av1/common/enums.h"
#include "aom/aom_integer.h"
#include "aom_dsp/aom_dsp_common.h"
@@ -65,6 +68,112 @@
4, 5, 5, 6, 7, 7, 8, 9, 9, 10, 11, 11, 12, 13, 13, 14, 6, 6, 8, 8, 10, 10
};
+#if CONFIG_EXT_RECUR_PARTITIONS
+static const PARTITION_TYPE
+ partition_map_from_symbol_block_wgth[PARTITION_TYPES_REC] = {
+ PARTITION_NONE,
+ PARTITION_VERT,
+ PARTITION_VERT_3,
+ PARTITION_HORZ,
+ };
+
+static const PARTITION_TYPE_REC
+ symbol_map_from_partition_block_wgth[EXT_PARTITION_TYPES] = {
+ PARTITION_NONE_REC, PARTITION_SHORT_SIDE_2_REC,
+ PARTITION_LONG_SIDE_2_REC, PARTITION_INVALID_REC,
+ PARTITION_LONG_SIDE_3_REC,
+ };
+
+static const PARTITION_TYPE
+ partition_map_from_symbol_block_hgtw[PARTITION_TYPES_REC] = {
+ PARTITION_NONE,
+ PARTITION_HORZ,
+ PARTITION_HORZ_3,
+ PARTITION_VERT,
+ };
+
+static const PARTITION_TYPE_REC
+ symbol_map_from_partition_block_hgtw[EXT_PARTITION_TYPES] = {
+ PARTITION_NONE_REC, PARTITION_LONG_SIDE_2_REC,
+ PARTITION_SHORT_SIDE_2_REC, PARTITION_LONG_SIDE_3_REC,
+ PARTITION_INVALID_REC,
+ };
+
+/* clang-format off */
+// This table covers all square blocks and 1:2/2:1 rectangular blocks
+static const BLOCK_SIZE
+ subsize_lookup[EXT_PARTITION_TYPES + 1][BLOCK_SIZES_ALL] = {
+ { // PARTITION_NONE
+ BLOCK_4X4, BLOCK_4X8, BLOCK_8X4, BLOCK_8X8, BLOCK_8X16, BLOCK_16X8,
+ BLOCK_16X16, BLOCK_16X32, BLOCK_32X16, BLOCK_32X32, BLOCK_32X64,
+ BLOCK_64X32, BLOCK_64X64, BLOCK_64X128, BLOCK_128X64, BLOCK_128X128,
+ BLOCK_4X16, BLOCK_16X4, BLOCK_8X32, BLOCK_32X8, BLOCK_16X64, BLOCK_64X16,
+ }, { // PARTITION_HORZ
+ BLOCK_INVALID, BLOCK_4X4, BLOCK_INVALID, BLOCK_8X4, BLOCK_8X8, BLOCK_16X4,
+ BLOCK_16X8, BLOCK_16X16, BLOCK_32X8, BLOCK_32X16, BLOCK_32X32, BLOCK_64X16,
+ BLOCK_64X32, BLOCK_64X64, BLOCK_INVALID, BLOCK_128X64,
+ BLOCK_4X8, BLOCK_INVALID, BLOCK_8X16, BLOCK_INVALID, BLOCK_16X32,
+ BLOCK_INVALID,
+ }, { // PARTITION_VERT
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_4X4, BLOCK_4X8, BLOCK_4X16, BLOCK_8X8,
+ BLOCK_8X16, BLOCK_8X32, BLOCK_16X16, BLOCK_16X32, BLOCK_16X64, BLOCK_32X32,
+ BLOCK_32X64, BLOCK_INVALID, BLOCK_64X64, BLOCK_64X128,
+ BLOCK_INVALID, BLOCK_8X4, BLOCK_INVALID, BLOCK_16X8, BLOCK_INVALID,
+ BLOCK_32X16,
+ }, { // PARTITION_HORZ_3
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, BLOCK_8X4,
+ BLOCK_INVALID, BLOCK_16X4, BLOCK_16X8,
+ BLOCK_INVALID,
+ BLOCK_32X8, BLOCK_32X16,
+ BLOCK_INVALID,
+ BLOCK_64X16, BLOCK_64X32, BLOCK_INVALID, BLOCK_INVALID,
+ BLOCK_4X4, BLOCK_INVALID, BLOCK_8X8, BLOCK_INVALID, BLOCK_16X16,
+ BLOCK_INVALID,
+ }, { // PARTITION_VERT_3
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
+ BLOCK_4X8, BLOCK_4X16,
+ BLOCK_INVALID,
+ BLOCK_8X16, BLOCK_8X32,
+ BLOCK_INVALID,
+ BLOCK_16X32, BLOCK_16X64, BLOCK_INVALID, BLOCK_32X64, BLOCK_INVALID,
+ BLOCK_INVALID, BLOCK_4X4, BLOCK_INVALID, BLOCK_8X8,
+ BLOCK_INVALID, BLOCK_16X16,
+ }, { // PARTITION_SPLIT
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, BLOCK_4X4, BLOCK_INVALID,
+ BLOCK_INVALID, BLOCK_8X8, BLOCK_INVALID, BLOCK_INVALID, BLOCK_16X16,
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_32X32, BLOCK_INVALID, BLOCK_INVALID,
+ BLOCK_64X64, BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
+ BLOCK_INVALID, BLOCK_INVALID,
+ },
+};
+
+#if CONFIG_SDP
+static AOM_INLINE PARTITION_TYPE sdp_chroma_part_from_luma(BLOCK_SIZE bsize,
+ PARTITION_TYPE luma_part, int ssx,
+ int ssy) {
+ const int bh_chr = block_size_high[bsize] >> ssy;
+ const int bw_chr = block_size_wide[bsize] >> ssx;
+
+ switch (luma_part) {
+ case PARTITION_NONE: return PARTITION_NONE;
+ case PARTITION_HORZ: return (bh_chr < 8) ? PARTITION_NONE : PARTITION_HORZ;
+ case PARTITION_HORZ_3:
+ if (bh_chr >= 16)
+ return PARTITION_HORZ_3;
+ else
+ return (bh_chr < 8) ? PARTITION_NONE : PARTITION_HORZ;
+ case PARTITION_VERT: return (bw_chr < 8) ? PARTITION_NONE : PARTITION_VERT;
+ case PARTITION_VERT_3:
+ if (bw_chr >= 16)
+ return PARTITION_VERT_3;
+ else
+ return (bw_chr < 8) ? PARTITION_NONE : PARTITION_VERT;
+ default: assert(0);
+ }
+ return PARTITION_INVALID;
+}
+#endif // CONFIG_SDP
+#else // CONFIG_EXT_RECUR_PARTITIONS
// A compressed version of the Partition_Subsize table in the spec (9.3.
// Conversion tables), for square block sizes only.
/* clang-format off */
@@ -101,6 +210,7 @@
BLOCK_8X32, BLOCK_16X64, BLOCK_INVALID
}
};
+#endif // CONFIG_EXT_RECUR_PARTITIONS
static const TX_SIZE max_txsize_lookup[BLOCK_SIZES_ALL] = {
// 4X4
@@ -468,6 +578,22 @@
{ 13, 3 },
};
+static AOM_INLINE bool is_bsize_geq(BLOCK_SIZE bsize1, BLOCK_SIZE bsize2) {
+ if (bsize1 == BLOCK_INVALID || bsize2 == BLOCK_INVALID) {
+ return false;
+ }
+ return block_size_wide[bsize1] >= block_size_wide[bsize2] &&
+ block_size_high[bsize1] >= block_size_high[bsize2];
+}
+
+static AOM_INLINE bool is_bsize_gt(BLOCK_SIZE bsize1, BLOCK_SIZE bsize2) {
+ if (bsize1 == BLOCK_INVALID || bsize2 == BLOCK_INVALID) {
+ return false;
+ }
+ return block_size_wide[bsize1] > block_size_wide[bsize2] &&
+ block_size_high[bsize1] > block_size_high[bsize2];
+}
+
#if CONFIG_IST
// Mapping of intra modes to IST kernel set
// Secondary transforms are enabled only intra modes < PAETH_PRED.
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 1396f9a..44c40e6 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -204,7 +204,64 @@
{ AOM_CDF14(3144, 5087, 7382, 7504, 7593, 7690, 7801, 8064, 8232, 9248,
9875, 10521, 29048) } }
};
-#if CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+static const aom_cdf_prob
+ default_partition_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][CDF_SIZE(
+ EXT_PARTITION_TYPES)] = { {
+ // 8x8
+ { AOM_CDF3(22187, 28914) },
+ { AOM_CDF3(17354, 25544) },
+ { AOM_CDF3(16287, 28824) },
+ { AOM_CDF3(15189, 27217) },
+ // 16x16
+ { AOM_CDF5(14665, 22357, 28960, 30645) },
+ { AOM_CDF5(7804, 13703, 27420, 29025) },
+ { AOM_CDF5(7508, 23180, 28044, 30882) },
+ { AOM_CDF5(5058, 16122, 25275, 28359) },
+ // 32x32
+ { AOM_CDF5(11795, 19886, 27120, 29401) },
+ { AOM_CDF5(5127, 12682, 26374, 28387) },
+ { AOM_CDF5(5522, 19614, 27318, 30668) },
+ { AOM_CDF5(3450, 12856, 24163, 28493) },
+ // 64x64
+ { AOM_CDF5(21562, 26118, 30872, 31711) },
+ { AOM_CDF5(5489, 14515, 28365, 29969) },
+ { AOM_CDF5(5873, 19195, 28209, 31603) },
+ { AOM_CDF5(1674, 15579, 28805, 31560) },
+ // 128x128
+ { AOM_CDF3(25710, 28640) },
+ { AOM_CDF3(7561, 14721) },
+ { AOM_CDF3(9603, 21021) },
+ { AOM_CDF3(1736, 12989) },
+ },
+ {
+ // 8x8
+ { AOM_CDF3(22187, 28914) },
+ { AOM_CDF3(17354, 25544) },
+ { AOM_CDF3(16287, 28824) },
+ { AOM_CDF3(15189, 27217) },
+ // 16x16
+ { AOM_CDF5(14665, 22357, 28960, 30645) },
+ { AOM_CDF5(7804, 13703, 27420, 29025) },
+ { AOM_CDF5(7508, 23180, 28044, 30882) },
+ { AOM_CDF5(5058, 16122, 25275, 28359) },
+ // 32x32
+ { AOM_CDF5(11795, 19886, 27120, 29401) },
+ { AOM_CDF5(5127, 12682, 26374, 28387) },
+ { AOM_CDF5(5522, 19614, 27318, 30668) },
+ { AOM_CDF5(3450, 12856, 24163, 28493) },
+ // 64x64
+ { AOM_CDF5(21562, 26118, 30872, 31711) },
+ { AOM_CDF5(5489, 14515, 28365, 29969) },
+ { AOM_CDF5(5873, 19195, 28209, 31603) },
+ { AOM_CDF5(1674, 15579, 28805, 31560) },
+ // 128x128
+ { AOM_CDF3(25710, 28640) },
+ { AOM_CDF3(7561, 14721) },
+ { AOM_CDF3(9603, 21021) },
+ { AOM_CDF3(1736, 12989) },
+ } };
+#elif CONFIG_SDP
static const aom_cdf_prob
default_partition_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][CDF_SIZE(
EXT_PARTITION_TYPES)] = {
@@ -277,7 +334,36 @@
{ AOM_CDF8(711, 966, 1172, 32448, 32538, 32617, 32664) },
}
};
-#else
+#elif CONFIG_EXT_RECUR_PARTITIONS
+static const aom_cdf_prob
+ default_partition_cdf[PARTITION_CONTEXTS][CDF_SIZE(EXT_PARTITION_TYPES)] = {
+ // 8x8
+ { AOM_CDF3(22187, 28914) },
+ { AOM_CDF3(17354, 25544) },
+ { AOM_CDF3(16287, 28824) },
+ { AOM_CDF3(15189, 27217) },
+ // 16x16
+ { AOM_CDF5(14665, 22357, 28960, 30645) },
+ { AOM_CDF5(7804, 13703, 27420, 29025) },
+ { AOM_CDF5(7508, 23180, 28044, 30882) },
+ { AOM_CDF5(5058, 16122, 25275, 28359) },
+ // 32x32
+ { AOM_CDF5(11795, 19886, 27120, 29401) },
+ { AOM_CDF5(5127, 12682, 26374, 28387) },
+ { AOM_CDF5(5522, 19614, 27318, 30668) },
+ { AOM_CDF5(3450, 12856, 24163, 28493) },
+ // 64x64
+ { AOM_CDF5(21562, 26118, 30872, 31711) },
+ { AOM_CDF5(5489, 14515, 28365, 29969) },
+ { AOM_CDF5(5873, 19195, 28209, 31603) },
+ { AOM_CDF5(1674, 15579, 28805, 31560) },
+ // 128x128
+ { AOM_CDF3(25710, 28640) },
+ { AOM_CDF3(7561, 14721) },
+ { AOM_CDF3(9603, 21021) },
+ { AOM_CDF3(1736, 12989) },
+ };
+#else // !CONFIG_EXT_RECUR_PARTITIONS && !CONFIG_SDP
static const aom_cdf_prob default_partition_cdf[PARTITION_CONTEXTS][CDF_SIZE(
EXT_PARTITION_TYPES)] = {
{ AOM_CDF4(19132, 25510, 30392) },
@@ -303,6 +389,38 @@
};
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+static const aom_cdf_prob
+ default_partition_rec_cdf[PARTITION_CONTEXTS_REC]
+ [CDF_SIZE(PARTITION_TYPES_REC)] = {
+ // 8x4, 4x8
+ { AOM_CDF2(30462) },
+ { AOM_CDF2(25506) },
+ { AOM_CDF2(27632) },
+ { AOM_CDF2(19443) },
+ // 16x8, 8x16
+ { AOM_CDF4(19986, 29676, 30790) },
+ { AOM_CDF4(12672, 24996, 30937) },
+ { AOM_CDF4(16895, 30097, 30155) },
+ { AOM_CDF4(10676, 22283, 25595) },
+ // 32x16, 16x32
+ { AOM_CDF4(13648, 24298, 31008) },
+ { AOM_CDF4(6941, 18823, 31326) },
+ { AOM_CDF4(8081, 19947, 30935) },
+ { AOM_CDF4(4728, 17352, 30577) },
+ // 64x32, 32x64
+ { AOM_CDF4(14004, 23614, 30662) },
+ { AOM_CDF4(5530, 18449, 30965) },
+ { AOM_CDF4(6144, 19185, 31435) },
+ { AOM_CDF4(7382, 19434, 30389) },
+ // 128x64, 64x128
+ { AOM_CDF3(15208, 24398) },
+ { AOM_CDF3(6597, 18232) },
+ { AOM_CDF3(9068, 21038) },
+ { AOM_CDF3(10923, 21845) },
+ };
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
static const aom_cdf_prob default_intra_ext_tx_cdf
[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES][CDF_SIZE(TX_TYPES)] = {
{
@@ -1399,6 +1517,9 @@
#endif
av1_copy(fc->switchable_interp_cdf, default_switchable_interp_cdf);
av1_copy(fc->partition_cdf, default_partition_cdf);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_copy(fc->partition_rec_cdf, default_partition_rec_cdf);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_copy(fc->intra_ext_tx_cdf, default_intra_ext_tx_cdf);
av1_copy(fc->inter_ext_tx_cdf, default_inter_ext_tx_cdf);
av1_copy(fc->skip_mode_cdfs, default_skip_mode_cdfs);
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 235542b..1711602 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -161,7 +161,11 @@
[CDF_SIZE(EXT_PARTITION_TYPES)];
#else
aom_cdf_prob partition_cdf[PARTITION_CONTEXTS][CDF_SIZE(EXT_PARTITION_TYPES)];
-#endif
+#endif // CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS
+ aom_cdf_prob partition_rec_cdf[PARTITION_CONTEXTS_REC]
+ [CDF_SIZE(PARTITION_TYPES_REC)];
+#endif // CONFIG_EXT_RECUR_PARTITIONS
aom_cdf_prob switchable_interp_cdf[SWITCHABLE_FILTER_CONTEXTS]
[CDF_SIZE(SWITCHABLE_FILTERS)];
/* kf_y_cdf is discarded after use, so does not require persistent storage.
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 697fdee..743a5dc 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -50,6 +50,8 @@
#define MAX_MIB_SIZE_LOG2 (MAX_SB_SIZE_LOG2 - MI_SIZE_LOG2)
#define MAX_MIB_SIZE (1 << MAX_MIB_SIZE_LOG2)
+#define MAX_MIB_SQUARE (MAX_MIB_SIZE * MAX_MIB_SIZE)
+
// MI-units per min superblock
#define MIN_MIB_SIZE_LOG2 (MIN_SB_SIZE_LOG2 - MI_SIZE_LOG2)
@@ -165,6 +167,10 @@
// 4X4, 8X8, 16X16, 32X32, 64X64, 128X128
#define SQR_BLOCK_SIZES 6
+#if CONFIG_EXT_RECUR_PARTITIONS
+#define KEEP_PARTITION_SPLIT 0
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// Partition types. R: Recursive
//
// NONE HORZ VERT SPLIT
@@ -174,6 +180,17 @@
// | | | | | | | | R | R |
// +-------+ +-------+ +---+---+ +---+---+
//
+#if CONFIG_EXT_RECUR_PARTITIONS
+// HORZ_3 VERT_3
+// +--------------+ +---+------+---+
+// | | | | | |
+// +--------------+ | | | |
+// | | | | | |
+// | | | | | |
+// +--------------+ | | | |
+// | | | | | |
+// +--------------+ +---+------+---+
+#else
// HORZ_A HORZ_B VERT_A VERT_B
// +---+---+ +-------+ +---+---+ +---+---+
// | | | | | | | | | | |
@@ -186,6 +203,20 @@
// +-----+ | | | |
// +-----+ | | | |
// +-----+ +-+-+-+
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+enum {
+ PARTITION_NONE,
+ PARTITION_HORZ,
+ PARTITION_VERT,
+ PARTITION_HORZ_3, // 3 horizontal sub-partitions with ratios 4:1, 2:1 and 4:1
+ PARTITION_VERT_3, // 3 vertical sub-partitions with ratios 4:1, 2:1 and 4:1
+ EXT_PARTITION_TYPES,
+ PARTITION_SPLIT = EXT_PARTITION_TYPES,
+ PARTITION_TYPES = PARTITION_VERT + 1,
+ PARTITION_INVALID = 255
+} UENUM1BYTE(PARTITION_TYPE);
+#else // CONFIG_EXT_RECUR_PARTITIONS
enum {
PARTITION_NONE,
PARTITION_HORZ,
@@ -201,12 +232,27 @@
PARTITION_TYPES = PARTITION_SPLIT + 1,
PARTITION_INVALID = 255
} UENUM1BYTE(PARTITION_TYPE);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
typedef char PARTITION_CONTEXT;
#define PARTITION_PLOFFSET 4 // number of probability models per block size
#define PARTITION_BLOCK_SIZES 5
#define PARTITION_CONTEXTS (PARTITION_BLOCK_SIZES * PARTITION_PLOFFSET)
+#if CONFIG_EXT_RECUR_PARTITIONS
+enum {
+ PARTITION_NONE_REC,
+ PARTITION_LONG_SIDE_2_REC,
+ PARTITION_LONG_SIDE_3_REC,
+ PARTITION_SHORT_SIDE_2_REC,
+ PARTITION_TYPES_REC = PARTITION_SHORT_SIDE_2_REC + 1,
+ PARTITION_INVALID_REC = 255
+} UENUM1BYTE(PARTITION_TYPE_REC);
+
+#define PARTITION_BLOCK_SIZES_REC 5 // 128x64, 64x32, 32x16, 16x8, 8x4
+#define PARTITION_CONTEXTS_REC (PARTITION_BLOCK_SIZES_REC * PARTITION_PLOFFSET)
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// block transform size
enum {
TX_4X4, // 4x4 transform
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index bd02cf3..de7eb9c 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -337,10 +337,14 @@
}
static AOM_INLINE void scan_row_mbmi(
- const AV1_COMMON *cm, const MACROBLOCKD *xd, int mi_col,
- const MV_REFERENCE_FRAME rf[2], int row_offset, CANDIDATE_MV *ref_mv_stack,
- uint16_t *ref_mv_weight, uint8_t *refmv_count, uint8_t *ref_match_count,
- uint8_t *newmv_count, int_mv *gm_mv_candidates, int max_row_offset,
+ const AV1_COMMON *cm, const MACROBLOCKD *xd,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int mi_row,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ int mi_col, const MV_REFERENCE_FRAME rf[2], int row_offset,
+ CANDIDATE_MV *ref_mv_stack, uint16_t *ref_mv_weight, uint8_t *refmv_count,
+ uint8_t *ref_match_count, uint8_t *newmv_count, int_mv *gm_mv_candidates,
+ int max_row_offset,
#if CONFIG_SMVP_IMPROVEMENT
int add_more_mvs, SINGLE_MV_CANDIDATE *single_mv, uint8_t *single_mv_count,
CANDIDATE_MV *derived_mv_stack, uint16_t *derived_mv_weight,
@@ -363,6 +367,24 @@
const int plane_type = (xd->tree_type == CHROMA_PART);
#endif
for (int i = 0; i < end_mi;) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
+ const int mask_row = mi_row & (sb_mi_size - 1);
+ const int mask_col = mi_col & (sb_mi_size - 1);
+ const int ref_mask_row = mask_row + row_offset;
+ const int ref_mask_col = mask_col + col_offset + i;
+ if (ref_mask_row >= 0) {
+ if (ref_mask_col >= sb_mi_size) break;
+
+ const int ref_offset =
+ ref_mask_row * xd->is_mi_coded_stride + ref_mask_col;
+#if CONFIG_SDP
+ if (!xd->is_mi_coded[0][ref_offset]) break;
+#else
+ if (!xd->is_mi_coded[ref_offset]) break;
+#endif // CONFIG_SDP
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
const MB_MODE_INFO *const candidate = candidate_mi0[col_offset + i];
#if CONFIG_SDP
const int candidate_bsize = candidate->sb_type[plane_type];
@@ -401,6 +423,9 @@
static AOM_INLINE void scan_col_mbmi(
const AV1_COMMON *cm, const MACROBLOCKD *xd, int mi_row,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int mi_col,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
const MV_REFERENCE_FRAME rf[2], int col_offset, CANDIDATE_MV *ref_mv_stack,
uint16_t *ref_mv_weight, uint8_t *refmv_count, uint8_t *ref_match_count,
uint8_t *newmv_count, int_mv *gm_mv_candidates, int max_col_offset,
@@ -423,6 +448,23 @@
const int use_step_16 = (xd->height >= 16);
for (i = 0; i < end_mi;) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
+ const int mask_row = mi_row & (sb_mi_size - 1);
+ const int mask_col = mi_col & (sb_mi_size - 1);
+ const int ref_mask_row = mask_row + row_offset + i;
+ const int ref_mask_col = mask_col + col_offset;
+ if (ref_mask_col >= 0) {
+ if (ref_mask_row >= sb_mi_size) break;
+ const int ref_offset =
+ ref_mask_row * xd->is_mi_coded_stride + ref_mask_col;
+#if CONFIG_SDP
+ if (!xd->is_mi_coded[0][ref_offset]) break;
+#else
+ if (!xd->is_mi_coded[ref_offset]) break;
+#endif // CONFIG_SDP
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
const MB_MODE_INFO *const candidate =
xd->mi[(row_offset + i) * xd->mi_stride + col_offset];
#if CONFIG_SDP
@@ -494,6 +536,44 @@
} // Analyze a single 8x8 block motion information.
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+ int mi_row, int mi_col, int n4_w) {
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
+ const int mask_row = mi_row & (sb_mi_size - 1);
+ const int mask_col = mi_col & (sb_mi_size - 1);
+
+ if (n4_w > mi_size_wide[BLOCK_64X64]) return 0;
+
+ const int tr_mask_row = mask_row - 1;
+ const int tr_mask_col = mask_col + n4_w;
+ int has_tr;
+
+ if (tr_mask_row < 0) {
+ // The top-right block is in a superblock above the current sb row. If it is
+ // in the current tile or a previously coded one, it has been coded.
+ // Otherwise later the tile boundary checker will figure out whether it is
+ // available.
+ has_tr = 1;
+ } else if (tr_mask_col >= sb_mi_size) {
+ // The top-right block is in the superblock on the right side, therefore it
+ // is not coded yet.
+ has_tr = 0;
+ } else {
+ // For a general case, we use is_mi_coded array for the current superblock
+ // to figure out the availability.
+ const int tr_offset = tr_mask_row * xd->is_mi_coded_stride + tr_mask_col;
+
+#if CONFIG_SDP
+ has_tr = xd->is_mi_coded[av1_get_sdp_idx(xd->tree_type)][tr_offset];
+#else
+ has_tr = xd->is_mi_coded[tr_offset];
+#endif // CONFIG_SDP
+ }
+
+ return has_tr;
+}
+#else
static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col, int bs) {
const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
@@ -545,6 +625,7 @@
return has_tr;
}
+#endif
static int check_sb_border(const int mi_row, const int mi_col,
const int row_offset, const int col_offset) {
@@ -719,8 +800,12 @@
uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE],
int_mv mv_ref_list[MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates,
int mi_row, int mi_col, int16_t *mode_context) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int has_tr = has_top_right(cm, xd, mi_row, mi_col, xd->width);
+#else
const int bs = AOMMAX(xd->width, xd->height);
const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs);
+#endif
MV_REFERENCE_FRAME rf[2];
const TileInfo *const tile = &xd->tile;
@@ -775,8 +860,12 @@
// Scan the first above row mode info. row_offset = -1;
if (abs(max_row_offset) >= 1)
- scan_row_mbmi(cm, xd, mi_col, rf, -1, ref_mv_stack, ref_mv_weight,
- refmv_count, &row_match_count, &newmv_count, gm_mv_candidates,
+ scan_row_mbmi(cm, xd,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ mi_row,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ mi_col, rf, -1, ref_mv_stack, ref_mv_weight, refmv_count,
+ &row_match_count, &newmv_count, gm_mv_candidates,
max_row_offset,
#if CONFIG_SMVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
@@ -786,8 +875,12 @@
// Scan the first left column mode info. col_offset = -1;
if (abs(max_col_offset) >= 1)
- scan_col_mbmi(cm, xd, mi_row, rf, -1, ref_mv_stack, ref_mv_weight,
- refmv_count, &col_match_count, &newmv_count, gm_mv_candidates,
+ scan_col_mbmi(cm, xd, mi_row,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ mi_col,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ rf, -1, ref_mv_stack, ref_mv_weight, refmv_count,
+ &col_match_count, &newmv_count, gm_mv_candidates,
max_col_offset,
#if CONFIG_SMVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
@@ -875,11 +968,15 @@
const int col_offset = -(idx << 1) + 1 + col_adj;
if (abs(col_offset) <= abs(max_col_offset) &&
abs(col_offset) > processed_cols) {
- scan_col_mbmi(cm, xd, mi_row, rf, col_offset, ref_mv_stack, ref_mv_weight,
- refmv_count, &col_match_count, &dummy_newmv_count,
- gm_mv_candidates, max_col_offset, 0, single_mv,
- &single_mv_count, derived_mv_stack, derived_mv_weight,
- &derived_mv_count, &processed_cols);
+ scan_col_mbmi(cm, xd, mi_row,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ mi_col,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ rf, col_offset, ref_mv_stack, ref_mv_weight, refmv_count,
+ &col_match_count, &dummy_newmv_count, gm_mv_candidates,
+ max_col_offset, 0, single_mv, &single_mv_count,
+ derived_mv_stack, derived_mv_weight, &derived_mv_count,
+ &processed_cols);
}
}
#else
@@ -889,15 +986,23 @@
if (abs(row_offset) <= abs(max_row_offset) &&
abs(row_offset) > processed_rows)
- scan_row_mbmi(cm, xd, mi_col, rf, row_offset, ref_mv_stack, ref_mv_weight,
+ scan_row_mbmi(cm, xd,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ mi_row,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ mi_col, rf, row_offset, ref_mv_stack, ref_mv_weight,
refmv_count, &row_match_count, &dummy_newmv_count,
gm_mv_candidates, max_row_offset, &processed_rows);
if (abs(col_offset) <= abs(max_col_offset) &&
abs(col_offset) > processed_cols)
- scan_col_mbmi(cm, xd, mi_row, rf, col_offset, ref_mv_stack, ref_mv_weight,
- refmv_count, &col_match_count, &dummy_newmv_count,
- gm_mv_candidates, max_col_offset, &processed_cols);
+ scan_col_mbmi(cm, xd, mi_row,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ mi_col,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ rf, col_offset, ref_mv_stack, ref_mv_weight, refmv_count,
+ &col_match_count, &dummy_newmv_count, gm_mv_candidates,
+ max_col_offset, &processed_cols);
}
#endif // CONFIG_SMVP_IMPROVEMENT
@@ -1815,8 +1920,12 @@
assert(np <= LEAST_SQUARES_SAMPLES_MAX);
// Top-right block
- if (do_tr &&
- has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->width, xd->height))) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (do_tr && has_top_right(cm, xd, mi_row, mi_col, xd->width)) {
+#else
+ const int bs = AOMMAX(xd->width, xd->height);
+ if (do_tr && has_top_right(cm, xd, mi_row, mi_col, bs)) {
+#endif
const POSITION trb_pos = { -1, xd->width };
const TileInfo *const tile = &xd->tile;
if (is_inside(tile, mi_col, mi_row, &trb_pos)) {
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index b03024e..b830750 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -765,27 +765,30 @@
// 2. At least one dimension is size 4 with subsampling
// 3. If sub-sampled, none of the previous blocks around the sub-sample
// are intrabc or inter-blocks
-static bool is_sub8x8_inter(const MACROBLOCKD *xd, int plane, BLOCK_SIZE bsize,
- int is_intrabc, int build_for_obmc) {
+static bool is_sub8x8_inter(const MACROBLOCKD *xd, const MB_MODE_INFO *mi,
+ int plane, int is_intrabc, int build_for_obmc) {
if (is_intrabc || build_for_obmc) {
return false;
}
- const struct macroblockd_plane *const pd = &xd->plane[plane];
- const int ss_x = pd->subsampling_x;
- const int ss_y = pd->subsampling_y;
- const int is_sub4_x = (block_size_wide[bsize] == 4) && ss_x;
- const int is_sub4_y = (block_size_high[bsize] == 4) && ss_y;
- if (!is_sub4_x && !is_sub4_y) {
+#if CONFIG_SDP
+ if (!(plane &&
+ (mi->sb_type[PLANE_TYPE_UV] != mi->chroma_ref_info.bsize_base)))
return false;
- }
+#else
+ if (!(plane && (mi->sb_type != mi->chroma_ref_info.bsize_base))) return false;
+#endif // CONFIG_SDP
// For sub8x8 chroma blocks, we may be covering more than one luma block's
// worth of pixels. Thus (mi_x, mi_y) may not be the correct coordinates for
// the top-left corner of the prediction source - the correct top-left corner
// is at (pre_x, pre_y).
- const int row_start = is_sub4_y ? -1 : 0;
- const int col_start = is_sub4_x ? -1 : 0;
+ const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
+ const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
+ const int row_start =
+ plane ? mi->chroma_ref_info.mi_row_chroma_base - mi_row : 0;
+ const int col_start =
+ plane ? mi->chroma_ref_info.mi_col_chroma_base - mi_col : 0;
for (int row = row_start; row <= 0; ++row) {
for (int col = col_start; col <= 0; ++col) {
@@ -816,11 +819,9 @@
const bool ss_y = pd->subsampling_y;
const int b4_w = block_size_wide[bsize] >> ss_x;
const int b4_h = block_size_high[bsize] >> ss_y;
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
- const int b8_w = block_size_wide[plane_bsize];
- const int b8_h = block_size_high[plane_bsize];
- const int is_compound = has_second_ref(mi);
- assert(!is_compound);
+ const BLOCK_SIZE plane_bsize = plane ? mi->chroma_ref_info.bsize_base : bsize;
+ const int b8_w = block_size_wide[plane_bsize] >> ss_x;
+ const int b8_h = block_size_high[plane_bsize] >> ss_y;
#if CONFIG_SDP
assert(!is_intrabc_block(mi, xd->tree_type));
#else
@@ -831,8 +832,10 @@
// worth of pixels. Thus (mi_x, mi_y) may not be the correct coordinates for
// the top-left corner of the prediction source - the correct top-left corner
// is at (pre_x, pre_y).
- const int row_start = (block_size_high[bsize] == 4) && ss_y ? -1 : 0;
- const int col_start = (block_size_wide[bsize] == 4) && ss_x ? -1 : 0;
+ const int row_start =
+ plane ? (mi->chroma_ref_info.mi_row_chroma_base - xd->mi_row) : 0;
+ const int col_start =
+ plane ? (mi->chroma_ref_info.mi_col_chroma_base - xd->mi_col) : 0;
const int pre_x = (mi_x + MI_SIZE * col_start) >> ss_x;
const int pre_y = (mi_y + MI_SIZE * row_start) >> ss_y;
@@ -841,6 +844,13 @@
int col = col_start;
for (int x = 0; x < b8_w; x += b4_w) {
MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // TODO(yuec): enabling compound prediction in none sub8x8 mbs in the
+ // group
+ bool is_compound = 0;
+#else
+ bool is_compound = has_second_ref(this_mbmi);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
struct buf_2d *const dst_buf = &pd->dst;
uint8_t *dst = dst_buf->buf + dst_buf->stride * y + x;
int ref = 0;
@@ -858,7 +868,6 @@
};
const MV mv = this_mbmi->mv[ref].as_mv;
-
InterPredParams inter_pred_params;
av1_init_inter_params(&inter_pred_params, b4_w, b4_h, pre_y + y,
pre_x + x, pd->subsampling_x, pd->subsampling_y,
@@ -881,9 +890,9 @@
&inter_pred_params, xd, mi_x + x, mi_y + y,
ref, mc_buf, calc_subpel_params_func);
- ++col;
+ col += mi_size_wide[bsize];
}
- ++row;
+ row += mi_size_high[bsize];
}
}
@@ -907,19 +916,17 @@
const WarpedMotionParams *const wm = &xd->global_motion[mi->ref_frame[ref]];
is_global[ref] = is_global_mv_block(mi, wm->wmtype);
}
-#if CONFIG_SDP
- const BLOCK_SIZE bsize = mi->sb_type[PLANE_TYPE_Y];
-#else
- const BLOCK_SIZE bsize = mi->sb_type;
-#endif
- const int ss_x = pd->subsampling_x;
- const int ss_y = pd->subsampling_y;
- const int row_start =
- (block_size_high[bsize] == 4) && ss_y && !build_for_obmc ? -1 : 0;
- const int col_start =
- (block_size_wide[bsize] == 4) && ss_x && !build_for_obmc ? -1 : 0;
- const int pre_x = (mi_x + MI_SIZE * col_start) >> ss_x;
- const int pre_y = (mi_y + MI_SIZE * row_start) >> ss_y;
+
+ int row_start = 0;
+ int col_start = 0;
+ if (!build_for_obmc) {
+ const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
+ const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
+ row_start = plane ? (mi->chroma_ref_info.mi_row_chroma_base - mi_row) : 0;
+ col_start = plane ? (mi->chroma_ref_info.mi_col_chroma_base - mi_col) : 0;
+ }
+ const int pre_x = (mi_x + MI_SIZE * col_start) >> pd->subsampling_x;
+ const int pre_y = (mi_y + MI_SIZE * row_start) >> pd->subsampling_y;
for (int ref = 0; ref < 1 + is_compound; ++ref) {
const struct scale_factors *const sf =
@@ -983,13 +990,14 @@
int mi_y, uint8_t **mc_buf,
CalcSubpelParamsFunc calc_subpel_params_func) {
#if CONFIG_SDP
- if (is_sub8x8_inter(xd, plane, mi->sb_type[PLANE_TYPE_Y],
- is_intrabc_block(mi, xd->tree_type), build_for_obmc)) {
-#else
- if (is_sub8x8_inter(xd, plane, mi->sb_type, is_intrabc_block(mi),
+ if (is_sub8x8_inter(xd, mi, plane, is_intrabc_block(mi, xd->tree_type),
build_for_obmc)) {
+#else
+ if (is_sub8x8_inter(xd, mi, plane, is_intrabc_block(mi), build_for_obmc)) {
#endif
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(bw < 8 || bh < 8);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
build_inter_predictors_sub8x8(cm, xd, plane, mi, mi_x, mi_y, mc_buf,
calc_subpel_params_func);
} else {
@@ -998,41 +1006,37 @@
calc_subpel_params_func);
}
}
-void av1_setup_dst_planes(struct macroblockd_plane *planes, BLOCK_SIZE bsize,
+
+void av1_setup_dst_planes(struct macroblockd_plane *planes,
const YV12_BUFFER_CONFIG *src, int mi_row, int mi_col,
- const int plane_start, const int plane_end) {
+ const int plane_start, const int plane_end,
+ const CHROMA_REF_INFO *chr_ref_info) {
// We use AOMMIN(num_planes, MAX_MB_PLANE) instead of num_planes to quiet
// the static analysis warnings.
for (int i = plane_start; i < AOMMIN(plane_end, MAX_MB_PLANE); ++i) {
struct macroblockd_plane *const pd = &planes[i];
const int is_uv = i > 0;
- setup_pred_plane(&pd->dst, bsize, src->buffers[i], src->crop_widths[is_uv],
+ setup_pred_plane(&pd->dst, src->buffers[i], src->crop_widths[is_uv],
src->crop_heights[is_uv], src->strides[is_uv], mi_row,
- mi_col, NULL, pd->subsampling_x, pd->subsampling_y);
+ mi_col, NULL, pd->subsampling_x, pd->subsampling_y,
+ chr_ref_info);
}
}
void av1_setup_pre_planes(MACROBLOCKD *xd, int idx,
const YV12_BUFFER_CONFIG *src, int mi_row, int mi_col,
- const struct scale_factors *sf,
- const int num_planes) {
+ const struct scale_factors *sf, const int num_planes,
+ const CHROMA_REF_INFO *chr_ref_info) {
if (src != NULL) {
// We use AOMMIN(num_planes, MAX_MB_PLANE) instead of num_planes to quiet
// the static analysis warnings.
for (int i = 0; i < AOMMIN(num_planes, MAX_MB_PLANE); ++i) {
struct macroblockd_plane *const pd = &xd->plane[i];
const int is_uv = i > 0;
-#if CONFIG_SDP
- setup_pred_plane(&pd->pre[idx], xd->mi[0]->sb_type[PLANE_TYPE_Y],
- src->buffers[i], src->crop_widths[is_uv],
+ setup_pred_plane(&pd->pre[idx], src->buffers[i], src->crop_widths[is_uv],
src->crop_heights[is_uv], src->strides[is_uv], mi_row,
- mi_col, sf, pd->subsampling_x, pd->subsampling_y);
-#else
- setup_pred_plane(&pd->pre[idx], xd->mi[0]->sb_type, src->buffers[i],
- src->crop_widths[is_uv], src->crop_heights[is_uv],
- src->strides[is_uv], mi_row, mi_col, sf,
- pd->subsampling_x, pd->subsampling_y);
-#endif
+ mi_col, sf, pd->subsampling_x, pd->subsampling_y,
+ chr_ref_info);
}
}
}
@@ -1093,9 +1097,12 @@
mbmi->overlappable_neighbors[0] = 0;
mbmi->overlappable_neighbors[1] = 0;
#if CONFIG_SDP
- if (!is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y])) return;
+ if (!is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y],
+ xd->mi_row, xd->mi_col))
+ return;
#else
- if (!is_motion_variation_allowed_bsize(mbmi->sb_type)) return;
+ if (!is_motion_variation_allowed_bsize(mbmi->sb_type, xd->mi_row, xd->mi_col))
+ return;
#endif
foreach_overlappable_nb_above(cm, xd, INT_MAX, increment_int_ptr,
@@ -1111,8 +1118,6 @@
int av1_skip_u4x4_pred_in_obmc(BLOCK_SIZE bsize,
const struct macroblockd_plane *pd, int dir) {
- assert(is_motion_variation_allowed_bsize(bsize));
-
const BLOCK_SIZE bsize_plane =
get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
switch (bsize_plane) {
@@ -1274,21 +1279,15 @@
MACROBLOCKD *xd, int rel_mi_col, uint8_t above_mi_width,
MB_MODE_INFO *above_mbmi, struct build_prediction_ctxt *ctxt,
const int num_planes) {
-#if CONFIG_SDP
- const BLOCK_SIZE a_bsize =
- AOMMAX(BLOCK_8X8, above_mbmi->sb_type[PLANE_TYPE_Y]);
-#else
- const BLOCK_SIZE a_bsize = AOMMAX(BLOCK_8X8, above_mbmi->sb_type);
-#endif
const int above_mi_col = xd->mi_col + rel_mi_col;
av1_modify_neighbor_predictor_for_obmc(above_mbmi);
for (int j = 0; j < num_planes; ++j) {
struct macroblockd_plane *const pd = &xd->plane[j];
- setup_pred_plane(&pd->dst, a_bsize, ctxt->tmp_buf[j], ctxt->tmp_width[j],
+ setup_pred_plane(&pd->dst, ctxt->tmp_buf[j], ctxt->tmp_width[j],
ctxt->tmp_height[j], ctxt->tmp_stride[j], 0, rel_mi_col,
- NULL, pd->subsampling_x, pd->subsampling_y);
+ NULL, pd->subsampling_x, pd->subsampling_y, NULL);
}
const int num_refs = 1 + has_second_ref(above_mbmi);
@@ -1304,7 +1303,7 @@
aom_internal_error(xd->error_info, AOM_CODEC_UNSUP_BITSTREAM,
"Reference frame has invalid dimensions");
av1_setup_pre_planes(xd, ref, &ref_buf->buf, xd->mi_row, above_mi_col, sf,
- num_planes);
+ num_planes, NULL);
}
xd->mb_to_left_edge = 8 * MI_SIZE * (-above_mi_col);
@@ -1318,21 +1317,15 @@
MB_MODE_INFO *left_mbmi,
struct build_prediction_ctxt *ctxt,
const int num_planes) {
-#if CONFIG_SDP
- const BLOCK_SIZE l_bsize =
- AOMMAX(BLOCK_8X8, left_mbmi->sb_type[PLANE_TYPE_Y]);
-#else
- const BLOCK_SIZE l_bsize = AOMMAX(BLOCK_8X8, left_mbmi->sb_type);
-#endif
const int left_mi_row = xd->mi_row + rel_mi_row;
av1_modify_neighbor_predictor_for_obmc(left_mbmi);
for (int j = 0; j < num_planes; ++j) {
struct macroblockd_plane *const pd = &xd->plane[j];
- setup_pred_plane(&pd->dst, l_bsize, ctxt->tmp_buf[j], ctxt->tmp_width[j],
+ setup_pred_plane(&pd->dst, ctxt->tmp_buf[j], ctxt->tmp_width[j],
ctxt->tmp_height[j], ctxt->tmp_stride[j], rel_mi_row, 0,
- NULL, pd->subsampling_x, pd->subsampling_y);
+ NULL, pd->subsampling_x, pd->subsampling_y, NULL);
}
const int num_refs = 1 + has_second_ref(left_mbmi);
@@ -1349,7 +1342,7 @@
aom_internal_error(xd->error_info, AOM_CODEC_UNSUP_BITSTREAM,
"Reference frame has invalid dimensions");
av1_setup_pre_planes(xd, ref, &ref_buf->buf, left_mi_row, xd->mi_col,
- ref_scale_factors, num_planes);
+ ref_scale_factors, num_planes, NULL);
}
xd->mb_to_top_edge = GET_MV_SUBPEL(MI_SIZE * (-left_mi_row));
@@ -1412,15 +1405,27 @@
bd);
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_build_intra_predictors_for_interintra(const AV1_COMMON *cm,
+ MACROBLOCKD *xd, int plane,
+ const BUFFER_SET *ctx,
+ uint8_t *dst, int dst_stride) {
+#else
void av1_build_intra_predictors_for_interintra(const AV1_COMMON *cm,
MACROBLOCKD *xd,
BLOCK_SIZE bsize, int plane,
const BUFFER_SET *ctx,
uint8_t *dst, int dst_stride) {
+#endif // CONFIG_EXT_RECUR_PARTITIONS
struct macroblockd_plane *const pd = &xd->plane[plane];
const int ssx = xd->plane[plane].subsampling_x;
const int ssy = xd->plane[plane].subsampling_y;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, xd->mi[0], plane, ssx, ssy);
+#else
BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ssx, ssy);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
PREDICTION_MODE mode = interintra_to_intra_mode[xd->mi[0]->interintra_mode];
assert(xd->mi[0]->angle_delta[PLANE_TYPE_Y] == 0);
assert(xd->mi[0]->angle_delta[PLANE_TYPE_UV] == 0);
@@ -1446,7 +1451,15 @@
const uint8_t *intra_pred, int intra_stride) {
const int ssx = xd->plane[plane].subsampling_x;
const int ssy = xd->plane[plane].subsampling_y;
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ssx, ssy);
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, xd->mi[0], plane, ssx, ssy);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize == get_plane_block_size(bsize, ssx, ssy));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#else
+ BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ssx, ssy);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (is_cur_buf_hbd(xd)) {
combine_interintra_highbd(
@@ -1472,15 +1485,25 @@
assert(bsize < BLOCK_SIZES_ALL);
if (is_cur_buf_hbd(xd)) {
DECLARE_ALIGNED(16, uint16_t, intrapredictor[MAX_SB_SQUARE]);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(
+ cm, xd, plane, ctx, CONVERT_TO_BYTEPTR(intrapredictor), MAX_SB_SIZE);
+#else
av1_build_intra_predictors_for_interintra(
cm, xd, bsize, plane, ctx, CONVERT_TO_BYTEPTR(intrapredictor),
MAX_SB_SIZE);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_combine_interintra(xd, bsize, plane, pred, stride,
CONVERT_TO_BYTEPTR(intrapredictor), MAX_SB_SIZE);
} else {
DECLARE_ALIGNED(16, uint8_t, intrapredictor[MAX_SB_SQUARE]);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, plane, ctx,
+ intrapredictor, MAX_SB_SIZE);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, plane, ctx,
intrapredictor, MAX_SB_SIZE);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_combine_interintra(xd, bsize, plane, pred, stride, intrapredictor,
MAX_SB_SIZE);
}
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index 6e6ab2c..323940f 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -298,16 +298,21 @@
return (int64_t)y * stride + x;
}
-static INLINE void setup_pred_plane(struct buf_2d *dst, BLOCK_SIZE bsize,
- uint8_t *src, int width, int height,
- int stride, int mi_row, int mi_col,
+static INLINE void setup_pred_plane(struct buf_2d *dst, uint8_t *src, int width,
+ int height, int stride, int mi_row,
+ int mi_col,
const struct scale_factors *scale,
- int subsampling_x, int subsampling_y) {
+ int subsampling_x, int subsampling_y,
+ const CHROMA_REF_INFO *chr_ref_info) {
// Offset the buffer pointer
- if (subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
- mi_row -= 1;
- if (subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
- mi_col -= 1;
+ /* if (subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
+ mi_row -= 1;
+ if (subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
+ mi_col -= 1;*/
+ if (chr_ref_info && (subsampling_x || subsampling_y)) {
+ mi_row = chr_ref_info->mi_row_chroma_base;
+ mi_col = chr_ref_info->mi_col_chroma_base;
+ }
const int x = (MI_SIZE * mi_col) >> subsampling_x;
const int y = (MI_SIZE * mi_row) >> subsampling_y;
@@ -318,13 +323,15 @@
dst->stride = stride;
}
-void av1_setup_dst_planes(struct macroblockd_plane *planes, BLOCK_SIZE bsize,
+void av1_setup_dst_planes(struct macroblockd_plane *planes,
const YV12_BUFFER_CONFIG *src, int mi_row, int mi_col,
- const int plane_start, const int plane_end);
+ const int plane_start, const int plane_end,
+ const CHROMA_REF_INFO *chr_ref_info);
void av1_setup_pre_planes(MACROBLOCKD *xd, int idx,
const YV12_BUFFER_CONFIG *src, int mi_row, int mi_col,
- const struct scale_factors *sf, const int num_planes);
+ const struct scale_factors *sf, const int num_planes,
+ const CHROMA_REF_INFO *chr_ref_info);
static INLINE void set_default_interp_filters(
MB_MODE_INFO *const mbmi, InterpFilter frame_interp_filter) {
@@ -393,11 +400,18 @@
const BUFFER_SET *ctx, int plane,
BLOCK_SIZE bsize);
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_build_intra_predictors_for_interintra(const AV1_COMMON *cm,
+ MACROBLOCKD *xd, int plane,
+ const BUFFER_SET *ctx,
+ uint8_t *dst, int dst_stride);
+#else
void av1_build_intra_predictors_for_interintra(const AV1_COMMON *cm,
MACROBLOCKD *xd,
BLOCK_SIZE bsize, int plane,
const BUFFER_SET *ctx,
uint8_t *dst, int dst_stride);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
void av1_combine_interintra(MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane,
const uint8_t *inter_pred, int inter_stride,
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index 73197b8..36f4288 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -65,6 +65,97 @@
NEED_LEFT | NEED_ABOVE | NEED_ABOVELEFT, // PAETH
};
+#if CONFIG_EXT_RECUR_PARTITIONS
+static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+ BLOCK_SIZE bsize, int mi_row, int mi_col,
+ int top_available, int right_available, TX_SIZE txsz,
+ int row_off, int col_off, int ss_x, int ss_y,
+ int px_to_right_edge, int *px_top_right,
+ int is_bsize_altered_for_chroma) {
+ if (!top_available || !right_available) return 0;
+
+ const int bw_unit = mi_size_wide[bsize];
+ const int plane_bw_unit = AOMMAX(bw_unit >> ss_x, 1);
+ const int top_right_count_unit = tx_size_wide_unit[txsz];
+ const int px_tr_common = AOMMIN(tx_size_wide[txsz], px_to_right_edge);
+
+ if (px_tr_common <= 0) return 0;
+
+ *px_top_right = px_tr_common;
+
+ if (row_off > 0) { // Just need to check if enough pixels on the right.
+ if (block_size_wide[bsize] > block_size_wide[BLOCK_64X64]) {
+ // Special case: For 128x128 blocks, the transform unit whose
+ // top-right corner is at the center of the block does in fact have
+ // pixels available at its top-right corner.
+ if (row_off == mi_size_high[BLOCK_64X64] >> ss_y &&
+ col_off + top_right_count_unit == mi_size_wide[BLOCK_64X64] >> ss_x) {
+ return 1;
+ }
+ const int plane_bw_unit_64 = mi_size_wide[BLOCK_64X64] >> ss_x;
+ const int col_off_64 = col_off % plane_bw_unit_64;
+ return col_off_64 + top_right_count_unit < plane_bw_unit_64;
+ }
+ return col_off + top_right_count_unit < plane_bw_unit;
+ } else {
+ // All top-right pixels are in the block above, which is already available.
+ if (col_off + top_right_count_unit < plane_bw_unit) return 1;
+
+ // Handle the top-right intra tx block of the coding block
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
+ const int mi_row_aligned =
+ is_bsize_altered_for_chroma
+ ? xd->mi[0]->chroma_ref_info.mi_row_chroma_base
+ : mi_row;
+ const int mi_col_aligned =
+ is_bsize_altered_for_chroma
+ ? xd->mi[0]->chroma_ref_info.mi_col_chroma_base
+ : mi_col;
+ const int tr_mask_row = (mi_row_aligned & (sb_mi_size - 1)) - 1;
+ const int tr_mask_col =
+ (mi_col_aligned & (sb_mi_size - 1)) + mi_size_wide[bsize];
+
+ if (tr_mask_row < 0) {
+ return 1;
+ } else if (tr_mask_col >= sb_mi_size) {
+ return 0;
+ } else { // Handle the general case: the top_right mi is in the same SB
+ const int tr_offset = tr_mask_row * xd->is_mi_coded_stride + tr_mask_col;
+ // As long as the first mi is available, we determine tr is available
+#if CONFIG_SDP
+ int has_tr = xd->is_mi_coded[av1_get_sdp_idx(xd->tree_type)][tr_offset];
+#else
+ int has_tr = xd->is_mi_coded[tr_offset];
+#endif // CONFIG_SDP
+
+ // Calculate px_top_right: how many top-right pixels are available. If it
+ // is less than tx_size_wide[txsz], px_top_right will be used to
+ // determine the location of the last available pixel, which will be used
+ // for padding.
+ if (has_tr) {
+ int mi_tr = 0;
+ for (int i = 0; i < top_right_count_unit << ss_x; ++i) {
+ if ((tr_mask_col + i) >= sb_mi_size ||
+#if CONFIG_SDP
+ !xd->is_mi_coded[av1_get_sdp_idx(xd->tree_type)][tr_offset + i]
+#else
+ !xd->is_mi_coded[tr_offset + i]
+#endif // CONFIG_SDP
+ ) {
+ break;
+ } else {
+ mi_tr++;
+ }
+ }
+
+ *px_top_right = AOMMIN((mi_tr << MI_SIZE_LOG2) >> ss_x, px_tr_common);
+ }
+
+ return has_tr;
+ }
+ }
+}
+#else
// Tables to store if the top-right reference pixels are available. The flags
// are represented with bits, packed into 8-bit integers. E.g., for the 32x32
// blocks in a 128x128 superblock, the index of the "o" block is 10 (in raster
@@ -260,142 +351,22 @@
return (has_tr_table[idx1] >> idx2) & 1;
}
}
+#endif
-// Similar to the has_tr_* tables, but store if the bottom-left reference
-// pixels are available.
-static uint8_t has_bl_4x4[128] = {
- 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85,
- 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 1, 0, 84, 85, 85, 85, 16, 17,
- 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84,
- 85, 85, 85, 0, 0, 0, 0, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85,
- 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 1,
- 0, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85,
- 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 0, 0,
-};
-static uint8_t has_bl_4x8[64] = {
- 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 1, 0,
- 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 0, 0,
- 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 1, 0,
- 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 0, 0,
-};
-static uint8_t has_bl_8x4[64] = {
- 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 1,
- 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 0,
- 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 1,
- 254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 0,
-};
-static uint8_t has_bl_8x8[32] = {
- 84, 85, 16, 17, 84, 85, 0, 1, 84, 85, 16, 17, 84, 85, 0, 0,
- 84, 85, 16, 17, 84, 85, 0, 1, 84, 85, 16, 17, 84, 85, 0, 0,
-};
-static uint8_t has_bl_8x16[16] = {
- 16, 17, 0, 1, 16, 17, 0, 0, 16, 17, 0, 1, 16, 17, 0, 0,
-};
-static uint8_t has_bl_16x8[16] = {
- 254, 84, 254, 16, 254, 84, 254, 0, 254, 84, 254, 16, 254, 84, 254, 0,
-};
-static uint8_t has_bl_16x16[8] = {
- 84, 16, 84, 0, 84, 16, 84, 0,
-};
-static uint8_t has_bl_16x32[4] = { 16, 0, 16, 0 };
-static uint8_t has_bl_32x16[4] = { 78, 14, 78, 14 };
-static uint8_t has_bl_32x32[2] = { 4, 4 };
-static uint8_t has_bl_32x64[1] = { 0 };
-static uint8_t has_bl_64x32[1] = { 34 };
-static uint8_t has_bl_64x64[1] = { 0 };
-static uint8_t has_bl_64x128[1] = { 0 };
-static uint8_t has_bl_128x64[1] = { 0 };
-static uint8_t has_bl_128x128[1] = { 0 };
-static uint8_t has_bl_4x16[32] = {
- 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0,
- 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0,
-};
-static uint8_t has_bl_16x4[32] = {
- 254, 254, 254, 84, 254, 254, 254, 16, 254, 254, 254, 84, 254, 254, 254, 0,
- 254, 254, 254, 84, 254, 254, 254, 16, 254, 254, 254, 84, 254, 254, 254, 0,
-};
-static uint8_t has_bl_8x32[8] = {
- 0, 1, 0, 0, 0, 1, 0, 0,
-};
-static uint8_t has_bl_32x8[8] = {
- 238, 78, 238, 14, 238, 78, 238, 14,
-};
-static uint8_t has_bl_16x64[2] = { 0, 0 };
-static uint8_t has_bl_64x16[2] = { 42, 42 };
-
-static const uint8_t *const has_bl_tables[BLOCK_SIZES_ALL] = {
- // 4X4
- has_bl_4x4,
- // 4X8, 8X4, 8X8
- has_bl_4x8, has_bl_8x4, has_bl_8x8,
- // 8X16, 16X8, 16X16
- has_bl_8x16, has_bl_16x8, has_bl_16x16,
- // 16X32, 32X16, 32X32
- has_bl_16x32, has_bl_32x16, has_bl_32x32,
- // 32X64, 64X32, 64X64
- has_bl_32x64, has_bl_64x32, has_bl_64x64,
- // 64x128, 128x64, 128x128
- has_bl_64x128, has_bl_128x64, has_bl_128x128,
- // 4x16, 16x4, 8x32
- has_bl_4x16, has_bl_16x4, has_bl_8x32,
- // 32x8, 16x64, 64x16
- has_bl_32x8, has_bl_16x64, has_bl_64x16
-};
-
-static uint8_t has_bl_vert_8x8[32] = {
- 254, 255, 16, 17, 254, 255, 0, 1, 254, 255, 16, 17, 254, 255, 0, 0,
- 254, 255, 16, 17, 254, 255, 0, 1, 254, 255, 16, 17, 254, 255, 0, 0,
-};
-static uint8_t has_bl_vert_16x16[8] = {
- 254, 16, 254, 0, 254, 16, 254, 0,
-};
-static uint8_t has_bl_vert_32x32[2] = { 14, 14 };
-static uint8_t has_bl_vert_64x64[1] = { 2 };
-
-// The _vert_* tables are like the ordinary tables above, but describe the
-// order we visit square blocks when doing a PARTITION_VERT_A or
-// PARTITION_VERT_B. This is the same order as normal except for on the last
-// split where we go vertically (TL, BL, TR, BR). We treat the rectangular block
-// as a pair of squares, which means that these tables work correctly for both
-// mixed vertical partition types.
-//
-// There are tables for each of the square sizes. Vertical rectangles (like
-// BLOCK_16X32) use their respective "non-vert" table
-static const uint8_t *const has_bl_vert_tables[BLOCK_SIZES] = {
- // 4X4
- NULL,
- // 4X8, 8X4, 8X8
- has_bl_4x8, NULL, has_bl_vert_8x8,
- // 8X16, 16X8, 16X16
- has_bl_8x16, NULL, has_bl_vert_16x16,
- // 16X32, 32X16, 32X32
- has_bl_16x32, NULL, has_bl_vert_32x32,
- // 32X64, 64X32, 64X64
- has_bl_32x64, NULL, has_bl_vert_64x64,
- // 64x128, 128x64, 128x128
- has_bl_64x128, NULL, has_bl_128x128
-};
-
-static const uint8_t *get_has_bl_table(PARTITION_TYPE partition,
- BLOCK_SIZE bsize) {
- const uint8_t *ret = NULL;
- // If this is a mixed vertical partition, look up bsize in orders_vert.
- if (partition == PARTITION_VERT_A || partition == PARTITION_VERT_B) {
- assert(bsize < BLOCK_SIZES);
- ret = has_bl_vert_tables[bsize];
- } else {
- ret = has_bl_tables[bsize];
- }
- assert(ret);
- return ret;
-}
-
-static int has_bottom_left(const AV1_COMMON *cm, BLOCK_SIZE bsize, int mi_row,
- int mi_col, int bottom_available, int left_available,
- PARTITION_TYPE partition, TX_SIZE txsz, int row_off,
- int col_off, int ss_x, int ss_y) {
+static int has_bottom_left(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+ BLOCK_SIZE bsize, int mi_row, int mi_col,
+ int bottom_available, int left_available,
+ TX_SIZE txsz, int row_off, int col_off, int ss_x,
+ int ss_y, int px_to_bottom_edge, int *px_bottom_left,
+ int is_bsize_altered_for_chroma) {
if (!bottom_available || !left_available) return 0;
+ const int px_bl_common = AOMMIN(tx_size_high[txsz], px_to_bottom_edge);
+
+ if (px_bl_common <= 0) return 0;
+
+ *px_bottom_left = px_bl_common;
+
// Special case for 128x* blocks, when col_off is half the block width.
// This is needed because 128x* superblocks are divided into 64x* blocks in
// raster order
@@ -425,37 +396,70 @@
// All bottom-left pixels are in the left block, which is already available.
if (row_off + bottom_left_count_unit < plane_bh_unit) return 1;
- const int bw_in_mi_log2 = mi_size_wide_log2[bsize];
- const int bh_in_mi_log2 = mi_size_high_log2[bsize];
+ // The general case: neither the leftmost column nor the bottom row. The
+ // bottom-left mi is in the same SB
const int sb_mi_size = mi_size_high[cm->seq_params.sb_size];
- const int blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2;
- const int blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2;
+ const int mi_row_aligned =
+ is_bsize_altered_for_chroma
+ ? xd->mi[0]->chroma_ref_info.mi_row_chroma_base
+ : mi_row;
+ const int mi_col_aligned =
+ is_bsize_altered_for_chroma
+ ? xd->mi[0]->chroma_ref_info.mi_col_chroma_base
+ : mi_col;
+ const int bl_mask_row =
+ (mi_row_aligned & (sb_mi_size - 1)) + mi_size_high[bsize];
+ const int bl_mask_col = (mi_col_aligned & (sb_mi_size - 1)) - 1;
- // Leftmost column of superblock: so bottom-left pixels maybe in the left
- // and/or bottom-left superblocks. But only the left superblock is
- // available, so check if all required pixels fall in that superblock.
- if (blk_col_in_sb == 0) {
- const int blk_start_row_off =
- blk_row_in_sb << (bh_in_mi_log2 + MI_SIZE_LOG2 - MI_SIZE_LOG2) >>
+ if (bl_mask_col < 0) {
+ const int plane_sb_height =
+ block_size_high[cm->seq_params.sb_size] >> ss_y;
+ const int plane_bottom_row =
+ (((mi_row_aligned & (sb_mi_size - 1)) << MI_SIZE_LOG2) +
+ block_size_high[bsize]) >>
ss_y;
- const int row_off_in_sb = blk_start_row_off + row_off;
- const int sb_height_unit = sb_mi_size >> ss_y;
- return row_off_in_sb + bottom_left_count_unit < sb_height_unit;
+ *px_bottom_left =
+ AOMMIN(plane_sb_height - plane_bottom_row, px_bl_common);
+
+ return *px_bottom_left > 0;
+ } else if (bl_mask_row >= sb_mi_size) {
+ return 0;
+ } else {
+ const int bl_offset = bl_mask_row * xd->is_mi_coded_stride + bl_mask_col;
+ // As long as there is one bottom-left mi available, we determine bl is
+ // available
+#if CONFIG_SDP
+ int has_bl = xd->is_mi_coded[av1_get_sdp_idx(xd->tree_type)][bl_offset];
+#else
+ int has_bl = xd->is_mi_coded[bl_offset];
+#endif // CONFIG_SDP
+
+ // Calculate px_bottom_left: how many bottom-left pixels are available. If
+ // it is less than tx_size_high[txsz], px_bottom_left will be used to
+ // determine the location of the last available pixel, which will be used
+ // for padding.
+ if (has_bl) {
+ int mi_bl = 0;
+ for (int i = 0; i < bottom_left_count_unit << ss_y; ++i) {
+ if ((bl_mask_row + i) >= sb_mi_size ||
+#if CONFIG_SDP
+ !xd->is_mi_coded[av1_get_sdp_idx(xd->tree_type)]
+ [bl_offset + i * xd->is_mi_coded_stride]
+#else
+ !xd->is_mi_coded[bl_offset + i * xd->is_mi_coded_stride]
+#endif // CONFIG_SDP
+ ) {
+ break;
+ } else {
+ mi_bl++;
+ }
+ }
+
+ *px_bottom_left = AOMMIN((mi_bl << MI_SIZE_LOG2) >> ss_y, px_bl_common);
+ }
+
+ return has_bl;
}
-
- // Bottom row of superblock (and not the leftmost column): so bottom-left
- // pixels fall in the bottom superblock, which is not available yet.
- if (((blk_row_in_sb + 1) << bh_in_mi_log2) >= sb_mi_size) return 0;
-
- // General case (neither leftmost column nor bottom row): check if the
- // bottom-left block is coded before the current block.
- const int this_blk_index =
- ((blk_row_in_sb + 0) << (MAX_MIB_SIZE_LOG2 - bw_in_mi_log2)) +
- blk_col_in_sb + 0;
- const int idx1 = this_blk_index / 8;
- const int idx2 = this_blk_index % 8;
- const uint8_t *has_bl_table = get_has_bl_table(partition, bsize);
- return (has_bl_table[idx1] >> idx2) & 1;
}
}
@@ -1838,56 +1842,8 @@
#endif
}
-static INLINE BLOCK_SIZE scale_chroma_bsize(BLOCK_SIZE bsize, int subsampling_x,
- int subsampling_y) {
- assert(subsampling_x >= 0 && subsampling_x < 2);
- assert(subsampling_y >= 0 && subsampling_y < 2);
- BLOCK_SIZE bs = bsize;
- switch (bsize) {
- case BLOCK_4X4:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X8;
- else if (subsampling_x == 1)
- bs = BLOCK_8X4;
- else if (subsampling_y == 1)
- bs = BLOCK_4X8;
- break;
- case BLOCK_4X8:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X8;
- else if (subsampling_x == 1)
- bs = BLOCK_8X8;
- else if (subsampling_y == 1)
- bs = BLOCK_4X8;
- break;
- case BLOCK_8X4:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X8;
- else if (subsampling_x == 1)
- bs = BLOCK_8X4;
- else if (subsampling_y == 1)
- bs = BLOCK_8X8;
- break;
- case BLOCK_4X16:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X16;
- else if (subsampling_x == 1)
- bs = BLOCK_8X16;
- else if (subsampling_y == 1)
- bs = BLOCK_4X16;
- break;
- case BLOCK_16X4:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_16X8;
- else if (subsampling_x == 1)
- bs = BLOCK_16X4;
- else if (subsampling_y == 1)
- bs = BLOCK_16X8;
- break;
- default: break;
- }
- return bs;
-}
+#define ARITHMETIC_LEFT_SHIFT(x, shift) \
+ (((x) >= 0) ? ((x) << (shift)) : (-((-(x)) << (shift))))
void av1_predict_intra_block(
const AV1_COMMON *cm, const MACROBLOCKD *xd, int wpx, int hpx,
@@ -1940,35 +1896,51 @@
col_off || (ss_x ? xd->chroma_left_available : xd->left_available);
const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
+#if CONFIG_SDP
+ BLOCK_SIZE bsize = mbmi->sb_type[plane > 0];
+#else // CONFIG_SDP
+ BLOCK_SIZE bsize = mbmi->sb_type;
+#endif // CONFIG_SDP
+ const int mi_wide = mi_size_wide[bsize];
+ const int mi_high = mi_size_high[bsize];
// Distance between the right edge of this prediction block to
- // the frame right edge
- const int xr = (xd->mb_to_right_edge >> (3 + ss_x)) + wpx - x - txwpx;
+ // the tile right edge
+ const int xr =
+ ARITHMETIC_LEFT_SHIFT(xd->tile.mi_col_end - mi_col - mi_wide, 2 - ss_x) +
+ wpx - x - txwpx;
// Distance between the bottom edge of this prediction block to
- // the frame bottom edge
- const int yd = (xd->mb_to_bottom_edge >> (3 + ss_y)) + hpx - y - txhpx;
+ // the tile bottom edge
+ const int yd =
+ ARITHMETIC_LEFT_SHIFT(xd->tile.mi_row_end - mi_row - mi_high, 2 - ss_y) +
+ hpx - y - txhpx;
const int right_available =
mi_col + ((col_off + txw) << ss_x) < xd->tile.mi_col_end;
const int bottom_available =
(yd > 0) && (mi_row + ((row_off + txh) << ss_y) < xd->tile.mi_row_end);
- const PARTITION_TYPE partition = mbmi->partition;
-#if CONFIG_SDP
- BLOCK_SIZE bsize = mbmi->sb_type[plane > 0];
-#else
- BLOCK_SIZE bsize = mbmi->sb_type;
-#endif
+ const BLOCK_SIZE init_bsize = bsize;
// force 4x4 chroma component block size.
if (ss_x || ss_y) {
- bsize = scale_chroma_bsize(bsize, ss_x, ss_y);
+ bsize = mbmi->chroma_ref_info.bsize_base;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int px_top_right = 0;
+ const int have_top_right = has_top_right(
+ cm, xd, bsize, mi_row, mi_col, have_top, right_available, tx_size,
+ row_off, col_off, ss_x, ss_y, xr, &px_top_right, bsize != init_bsize);
+#else
+ const PARTITION_TYPE partition = mbmi->partition;
const int have_top_right =
has_top_right(cm, bsize, mi_row, mi_col, have_top, right_available,
partition, tx_size, row_off, col_off, ss_x, ss_y);
- const int have_bottom_left =
- has_bottom_left(cm, bsize, mi_row, mi_col, bottom_available, have_left,
- partition, tx_size, row_off, col_off, ss_x, ss_y);
+#endif
+
+ int px_bottom_left = 0;
+ const int have_bottom_left = has_bottom_left(
+ cm, xd, bsize, mi_row, mi_col, bottom_available, have_left, tx_size,
+ row_off, col_off, ss_x, ss_y, yd, &px_bottom_left, bsize != init_bsize);
const int disable_edge_filter = !cm->seq_params.enable_intra_edge_filter;
@@ -1982,9 +1954,13 @@
xd, ref, ref_stride, dst, dst_stride, mode, angle_delta,
filter_intra_mode, tx_size, disable_edge_filter,
have_top ? AOMMIN(txwpx, xr + txwpx) : 0,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ have_top_right ? px_top_right : 0,
+#else
have_top_right ? AOMMIN(txwpx, xr) : 0,
+#endif
have_left ? AOMMIN(txhpx, yd + txhpx) : 0,
- have_bottom_left ? AOMMIN(txhpx, yd) : 0, plane
+ have_bottom_left ? px_bottom_left : 0, plane
#if CONFIG_MRLS
,
is_sb_boundary
@@ -2001,9 +1977,13 @@
xd, ref, ref_stride, dst, dst_stride, mode, angle_delta,
filter_intra_mode, tx_size, disable_edge_filter,
have_top ? AOMMIN(txwpx, xr + txwpx) : 0,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ have_top_right ? px_top_right : 0,
+#else
have_top_right ? AOMMIN(txwpx, xr) : 0,
+#endif
have_left ? AOMMIN(txhpx, yd + txhpx) : 0,
- have_bottom_left ? AOMMIN(txhpx, yd) : 0, plane
+ have_bottom_left ? px_bottom_left : 0, plane
#if CONFIG_MRLS
,
is_sb_boundary
@@ -2015,6 +1995,8 @@
);
}
+#undef ARITHMETIC_LEFT_SHIFT
+
void av1_predict_intra_block_facade(const AV1_COMMON *cm, MACROBLOCKD *xd,
int plane, int blk_col, int blk_row,
TX_SIZE tx_size) {
@@ -2062,13 +2044,18 @@
if (plane != AOM_PLANE_Y && mbmi->uv_mode == UV_CFL_PRED) {
#if CONFIG_DEBUG
assert(is_cfl_allowed(xd));
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, mbmi, plane, pd->subsampling_x, pd->subsampling_y);
+#else
const BLOCK_SIZE plane_bsize = get_plane_block_size(
#if CONFIG_SDP
mbmi->sb_type[xd->tree_type == CHROMA_PART], pd->subsampling_x,
pd->subsampling_y);
#else
- mbmi->sb_type, pd->subsampling_x, pd->subsampling_y);
-#endif
+ mbmi->chroma_ref_info.bsize_base, pd->subsampling_x, pd->subsampling_y);
+#endif // CONFIG_SDP
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
(void)plane_bsize;
assert(plane_bsize < BLOCK_SIZES_ALL);
if (!xd->lossless[mbmi->segment_id]) {
@@ -2102,8 +2089,7 @@
if (xd->tree_type == CHROMA_PART) {
const int luma_tx_size =
av1_get_max_uv_txsize(mbmi->sb_type[PLANE_TYPE_UV], 0, 0);
- cfl_store_tx(xd, blk_row, blk_col, luma_tx_size,
- mbmi->sb_type[PLANE_TYPE_UV]);
+ cfl_store_tx(xd, blk_row, blk_col, luma_tx_size);
}
#endif
cfl_predict_block(xd, dst, dst_stride, tx_size, plane);
diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h
index a0e6e9a..0ccac73 100644
--- a/av1/common/reconintra.h
+++ b/av1/common/reconintra.h
@@ -68,6 +68,7 @@
return mode >= V_PRED && mode <= D67_PRED;
}
+// TODO(any): Verify the correct behavior when we have BLOCK_4X16
static INLINE int av1_use_angle_delta(BLOCK_SIZE bsize) {
return bsize >= BLOCK_8X8;
}
diff --git a/av1/common/thread_common.c b/av1/common/thread_common.c
index f3c8795..88615c4 100644
--- a/av1/common/thread_common.c
+++ b/av1/common/thread_common.c
@@ -287,8 +287,8 @@
mi_col += MAX_MIB_SIZE) {
c = mi_col >> MAX_MIB_SIZE_LOG2;
- av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer,
- mi_row, mi_col, plane, plane + 1);
+ av1_setup_dst_planes(planes, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_vert(cm, xd, plane, &planes[plane], mi_row,
mi_col);
@@ -307,8 +307,8 @@
// completed
sync_read(lf_sync, r + 1, c, plane);
- av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer,
- mi_row, mi_col, plane, plane + 1);
+ av1_setup_dst_planes(planes, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_horz(cm, xd, plane, &planes[plane], mi_row,
mi_col);
}
@@ -354,8 +354,8 @@
mi_col += MI_SIZE_64X64) {
c = mi_col >> MIN_MIB_SIZE_LOG2;
- av1_setup_dst_planes(planes, BLOCK_64X64, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(planes, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_bitmask_vert(cm, &planes[plane], plane, mi_row,
mi_col);
@@ -374,8 +374,8 @@
// completed
sync_read(lf_sync, r + 1, c, plane);
- av1_setup_dst_planes(planes, BLOCK_64X64, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(planes, frame_buffer, mi_row, mi_col, plane,
+ plane + 1, NULL);
av1_filter_block_plane_bitmask_horz(cm, &planes[plane], plane, mi_row,
mi_col);
}
@@ -510,8 +510,7 @@
// TODO(chengchen): can we remove this?
struct macroblockd_plane *pd = xd->plane;
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame, 0, 0, plane,
- plane + 1);
+ av1_setup_dst_planes(pd, frame, 0, 0, plane, plane + 1, NULL);
av1_build_bitmask_vert_info(cm, &pd[plane], plane);
av1_build_bitmask_horz_info(cm, &pd[plane], plane);
diff --git a/av1/common/x86/convolve_2d_sse2.c b/av1/common/x86/convolve_2d_sse2.c
index a3a8857..e7cbb48 100644
--- a/av1/common/x86/convolve_2d_sse2.c
+++ b/av1/common/x86/convolve_2d_sse2.c
@@ -280,7 +280,7 @@
const __m128i res_8 =
_mm_packus_epi16(round_result_lo, round_result_hi);
- _mm_store_si128((__m128i *)(&dst0[j]), res_8);
+ _mm_storeu_si128((__m128i *)(&dst0[j]), res_8);
} else {
_mm_store_si128((__m128i *)(&dst[j]), res_unsigned_lo);
_mm_store_si128((__m128i *)(&dst[j + 8]), res_unsigned_hi);
diff --git a/av1/common/x86/highbd_convolve_2d_sse4.c b/av1/common/x86/highbd_convolve_2d_sse4.c
index 185bdd6..122bf73 100644
--- a/av1/common/x86/highbd_convolve_2d_sse4.c
+++ b/av1/common/x86/highbd_convolve_2d_sse4.c
@@ -90,7 +90,7 @@
_mm_packus_epi32(round_result_lo, round_result_hi);
const __m128i res_clip = _mm_min_epi16(res_16b, clip_pixel_to_bd);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_clip);
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_clip);
} else {
const __m128i res_unsigned_16b =
_mm_adds_epu16(res, offset_const_16b);
@@ -402,7 +402,7 @@
_mm_packus_epi32(round_result_lo, round_result_hi);
const __m128i res_clip = _mm_min_epi16(res_16b, clip_pixel_to_bd);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_clip);
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_clip);
} else {
const __m128i res_16b =
_mm_packus_epi32(res_unsigned_lo, res_unsigned_hi);
diff --git a/av1/common/x86/highbd_inv_txfm_sse4.c b/av1/common/x86/highbd_inv_txfm_sse4.c
index 7c32b49..876b9e6 100644
--- a/av1/common/x86/highbd_inv_txfm_sse4.c
+++ b/av1/common/x86/highbd_inv_txfm_sse4.c
@@ -1303,14 +1303,14 @@
round_shift_8x8(in, shift);
- v0 = _mm_load_si128((__m128i const *)(output + 0 * stride));
- v1 = _mm_load_si128((__m128i const *)(output + 1 * stride));
- v2 = _mm_load_si128((__m128i const *)(output + 2 * stride));
- v3 = _mm_load_si128((__m128i const *)(output + 3 * stride));
- v4 = _mm_load_si128((__m128i const *)(output + 4 * stride));
- v5 = _mm_load_si128((__m128i const *)(output + 5 * stride));
- v6 = _mm_load_si128((__m128i const *)(output + 6 * stride));
- v7 = _mm_load_si128((__m128i const *)(output + 7 * stride));
+ v0 = _mm_loadu_si128((__m128i const *)(output + 0 * stride));
+ v1 = _mm_loadu_si128((__m128i const *)(output + 1 * stride));
+ v2 = _mm_loadu_si128((__m128i const *)(output + 2 * stride));
+ v3 = _mm_loadu_si128((__m128i const *)(output + 3 * stride));
+ v4 = _mm_loadu_si128((__m128i const *)(output + 4 * stride));
+ v5 = _mm_loadu_si128((__m128i const *)(output + 5 * stride));
+ v6 = _mm_loadu_si128((__m128i const *)(output + 6 * stride));
+ v7 = _mm_loadu_si128((__m128i const *)(output + 7 * stride));
if (flipud) {
u0 = get_recon_8x8(v0, in[14], in[15], fliplr, bd);
@@ -1332,14 +1332,14 @@
u7 = get_recon_8x8(v7, in[14], in[15], fliplr, bd);
}
- _mm_store_si128((__m128i *)(output + 0 * stride), u0);
- _mm_store_si128((__m128i *)(output + 1 * stride), u1);
- _mm_store_si128((__m128i *)(output + 2 * stride), u2);
- _mm_store_si128((__m128i *)(output + 3 * stride), u3);
- _mm_store_si128((__m128i *)(output + 4 * stride), u4);
- _mm_store_si128((__m128i *)(output + 5 * stride), u5);
- _mm_store_si128((__m128i *)(output + 6 * stride), u6);
- _mm_store_si128((__m128i *)(output + 7 * stride), u7);
+ _mm_storeu_si128((__m128i *)(output + 0 * stride), u0);
+ _mm_storeu_si128((__m128i *)(output + 1 * stride), u1);
+ _mm_storeu_si128((__m128i *)(output + 2 * stride), u2);
+ _mm_storeu_si128((__m128i *)(output + 3 * stride), u3);
+ _mm_storeu_si128((__m128i *)(output + 4 * stride), u4);
+ _mm_storeu_si128((__m128i *)(output + 5 * stride), u5);
+ _mm_storeu_si128((__m128i *)(output + 6 * stride), u6);
+ _mm_storeu_si128((__m128i *)(output + 7 * stride), u7);
}
void av1_inv_txfm2d_add_8x8_sse4_1(const int32_t *input, uint16_t *output,
diff --git a/av1/common/x86/highbd_jnt_convolve_avx2.c b/av1/common/x86/highbd_jnt_convolve_avx2.c
index fa27571..0494c0a 100644
--- a/av1/common/x86/highbd_jnt_convolve_avx2.c
+++ b/av1/common/x86/highbd_jnt_convolve_avx2.c
@@ -93,7 +93,8 @@
_mm256_packus_epi32(round_result_lo, round_result_hi);
const __m256i res_clip = _mm256_min_epi16(res_16b, clip_pixel_to_bd);
- _mm256_store_si256((__m256i *)(&dst0[i * dst_stride0 + j]), res_clip);
+ _mm256_storeu_si256((__m256i *)(&dst0[i * dst_stride0 + j]),
+ res_clip);
} else {
const __m256i res_unsigned_16b =
_mm256_adds_epu16(res, offset_const_16b);
@@ -200,8 +201,8 @@
const __m128i res_0 = _mm256_castsi256_si128(res_clip);
const __m128i res_1 = _mm256_extracti128_si256(res_clip, 1);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
- _mm_store_si128(
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
+ _mm_storeu_si128(
(__m128i *)(&dst0[i * dst_stride0 + j + dst_stride0]), res_1);
} else {
const __m256i res_unsigned_16b =
@@ -209,9 +210,9 @@
const __m128i res_0 = _mm256_castsi256_si128(res_unsigned_16b);
const __m128i res_1 = _mm256_extracti128_si256(res_unsigned_16b, 1);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
- res_1);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
+ res_1);
}
}
}
@@ -425,8 +426,8 @@
const __m128i res_0 = _mm256_castsi256_si128(res_clip);
const __m128i res_1 = _mm256_extracti128_si256(res_clip, 1);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
- _mm_store_si128(
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
+ _mm_storeu_si128(
(__m128i *)(&dst0[i * dst_stride0 + j + dst_stride0]), res_1);
} else {
__m256i res_16b =
@@ -434,9 +435,9 @@
const __m128i res_0 = _mm256_castsi256_si128(res_16b);
const __m128i res_1 = _mm256_extracti128_si256(res_16b, 1);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
- res_1);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
+ res_1);
}
}
@@ -598,18 +599,18 @@
const __m128i res_0 = _mm256_castsi256_si128(res_clip);
const __m128i res_1 = _mm256_extracti128_si256(res_clip, 1);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j + dst_stride0]),
- res_1);
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
+ _mm_storeu_si128(
+ (__m128i *)(&dst0[i * dst_stride0 + j + dst_stride0]), res_1);
} else {
__m256i res_16b =
_mm256_packus_epi32(res_unsigned_lo, res_unsigned_hi);
const __m128i res_0 = _mm256_castsi256_si128(res_16b);
const __m128i res_1 = _mm256_extracti128_si256(res_16b, 1);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
- res_1);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
+ res_1);
}
}
}
@@ -809,8 +810,8 @@
const __m128i res_0 = _mm256_castsi256_si128(res_clip);
const __m128i res_1 = _mm256_extracti128_si256(res_clip, 1);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
- _mm_store_si128(
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
+ _mm_storeu_si128(
(__m128i *)(&dst0[i * dst_stride0 + j + dst_stride0]), res_1);
} else {
__m256i res_16b =
@@ -818,9 +819,9 @@
const __m128i res_0 = _mm256_castsi256_si128(res_16b);
const __m128i res_1 = _mm256_extracti128_si256(res_16b, 1);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
- res_1);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j]), res_0);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
+ res_1);
}
}
s[0] = s[1];
diff --git a/av1/common/x86/highbd_jnt_convolve_sse4.c b/av1/common/x86/highbd_jnt_convolve_sse4.c
index 00ff22f..7c0f90f 100644
--- a/av1/common/x86/highbd_jnt_convolve_sse4.c
+++ b/av1/common/x86/highbd_jnt_convolve_sse4.c
@@ -217,9 +217,9 @@
const __m128i res_clip_1 =
_mm_min_epi16(res_16b_1, clip_pixel_to_bd);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]),
- res_clip_0);
- _mm_store_si128(
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]),
+ res_clip_0);
+ _mm_storeu_si128(
(__m128i *)(&dst0[i * dst_stride0 + j + dst_stride0]),
res_clip_1);
} else {
@@ -227,9 +227,9 @@
_mm_packus_epi32(res_unsigned_lo_0, res_unsigned_hi_0);
__m128i res_16bit1 =
_mm_packus_epi32(res_unsigned_lo_1, res_unsigned_hi_1);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j]), res_16bit0);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
- res_16bit1);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j]), res_16bit0);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j + dst_stride]),
+ res_16bit1);
}
}
s[0] = s[1];
@@ -366,10 +366,10 @@
const __m128i res_16b =
_mm_packus_epi32(round_result_lo, round_result_hi);
const __m128i res_clip = _mm_min_epi16(res_16b, clip_pixel_to_bd);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_clip);
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_clip);
} else {
__m128i res_16b = _mm_packus_epi32(res_unsigned_lo, res_unsigned_hi);
- _mm_store_si128((__m128i *)(&dst[i * dst_stride + j]), res_16b);
+ _mm_storeu_si128((__m128i *)(&dst[i * dst_stride + j]), res_16b);
}
}
}
diff --git a/av1/common/x86/jnt_convolve_avx2.c b/av1/common/x86/jnt_convolve_avx2.c
index c42ebc1..586b3e4 100644
--- a/av1/common/x86/jnt_convolve_avx2.c
+++ b/av1/common/x86/jnt_convolve_avx2.c
@@ -369,8 +369,8 @@
const __m128i res_0 = _mm256_castsi256_si128(res_8);
const __m128i res_1 = _mm256_extracti128_si256(res_8, 1);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
- _mm_store_si128(
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
+ _mm_storeu_si128(
(__m128i *)((&dst0[i * dst_stride0 + j + dst_stride0])), res_1);
} else {
@@ -548,8 +548,8 @@
const __m128i res_0 = _mm256_castsi256_si128(res_8);
const __m128i res_1 = _mm256_extracti128_si256(res_8, 1);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
- _mm_store_si128(
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]), res_0);
+ _mm_storeu_si128(
(__m128i *)((&dst0[i * dst_stride0 + j + dst_stride0])), res_1);
} else {
@@ -840,8 +840,8 @@
const __m256i res_8 = _mm256_packus_epi16(round_result, round_result);
const __m256i res_0 = _mm256_permute4x64_epi64(res_8, 0xD8);
- _mm_store_si128((__m128i *)(&dst0[i * dst_stride0 + j]),
- _mm256_castsi256_si128(res_0));
+ _mm_storeu_si128((__m128i *)(&dst0[i * dst_stride0 + j]),
+ _mm256_castsi256_si128(res_0));
} else {
_mm256_store_si256((__m256i *)(&dst[i * dst_stride + j]),
res_unsigned);
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 5e25082..b43e0a9 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -12,6 +12,7 @@
#include <assert.h>
#include <stddef.h>
+#include "av1/common/blockd.h"
#include "config/aom_config.h"
#include "config/aom_dsp_rtcd.h"
#include "config/aom_scale_rtcd.h"
@@ -253,11 +254,7 @@
#else
if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) {
#endif
-#if CONFIG_SDP
- cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type[AOM_PLANE_Y]);
-#else
- cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type);
-#endif
+ cfl_store_tx(xd, row, col, tx_size);
}
}
@@ -307,7 +304,14 @@
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
+ const TX_SIZE plane_tx_size =
+ plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
+ pd->subsampling_y)
+ : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
+ blk_col)];
+#elif CONFIG_SDP
if (xd->tree_type == SHARED_PART)
assert(mbmi->sb_type[PLANE_TYPE_Y] == mbmi->sb_type[PLANE_TYPE_UV]);
const TX_SIZE plane_tx_size =
@@ -317,8 +321,8 @@
blk_col)];
#else
const TX_SIZE plane_tx_size =
- plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x,
- pd->subsampling_y)
+ plane ? av1_get_max_uv_txsize(mbmi->chroma_ref_info.bsize_base,
+ pd->subsampling_x, pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#endif
@@ -393,7 +397,8 @@
static AOM_INLINE void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
BLOCK_SIZE bsize, int mi_row, int mi_col,
- int bw, int bh, int x_mis, int y_mis) {
+ int bw, int bh, int x_mis, int y_mis,
+ PARTITION_TREE *parent, int index) {
const int num_planes = av1_num_planes(cm);
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const TileInfo *const tile = &xd->tile;
@@ -423,25 +428,31 @@
}
#endif
- set_plane_n4(xd, bw, bh, num_planes);
- set_entropy_context(xd, mi_row, mi_col, num_planes);
+ CHROMA_REF_INFO *chr_ref_info = &xd->mi[0]->chroma_ref_info;
+ set_chroma_ref_info(mi_row, mi_col, index, bsize, chr_ref_info,
+ parent ? &parent->chroma_ref_info : NULL,
+ parent ? parent->bsize : BLOCK_INVALID,
+ parent ? parent->partition : PARTITION_NONE,
+ xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
+ set_plane_n4(xd, bw, bh, num_planes, chr_ref_info);
+ set_entropy_context(xd, mi_row, mi_col, num_planes, chr_ref_info);
// Distance of Mb to the various image edges. These are specified to 8th pel
// as they are always compared to values that are in 1/8th pel units
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
- mi_params->mi_cols);
+ mi_params->mi_cols, chr_ref_info);
- av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, chr_ref_info);
}
static AOM_INLINE void decode_mbmi_block(AV1Decoder *const pbi,
DecoderCodingBlock *dcb, int mi_row,
int mi_col, aom_reader *r,
PARTITION_TYPE partition,
- BLOCK_SIZE bsize) {
+ BLOCK_SIZE bsize,
+ PARTITION_TREE *parent, int index) {
AV1_COMMON *const cm = &pbi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
const int x_mis = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);
@@ -451,18 +462,27 @@
#if CONFIG_ACCOUNTING
aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
#endif
- set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
+ set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis, parent,
+ index);
xd->mi[0]->partition = partition;
av1_read_mode_info(pbi, dcb, r, x_mis, y_mis);
- if (bsize >= BLOCK_8X8 &&
- (seq_params->subsampling_x || seq_params->subsampling_y)) {
- const BLOCK_SIZE uv_subsize =
- ss_size_lookup[bsize][seq_params->subsampling_x]
- [seq_params->subsampling_y];
- if (uv_subsize == BLOCK_INVALID)
+
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ if (xd->tree_type != LUMA_PART) {
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const struct macroblockd_plane *const pd_u = &xd->plane[1];
+ const BLOCK_SIZE chroma_bsize_base = xd->mi[0]->chroma_ref_info.bsize_base;
+ assert(chroma_bsize_base < BLOCK_SIZES_ALL);
+ if (get_plane_block_size(chroma_bsize_base, pd_u->subsampling_x,
+ pd_u->subsampling_y) == BLOCK_INVALID) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
- "Invalid block size.");
+ "Block size %dx%d invalid with this subsampling mode",
+ block_size_wide[chroma_bsize_base],
+ block_size_high[chroma_bsize_base]);
+ }
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
}
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
}
typedef struct PadBlock {
@@ -903,13 +923,8 @@
dst_stride2);
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
-#if CONFIG_SDP
- av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type[PLANE_TYPE_Y],
- &cm->cur_frame->buf, mi_row, mi_col, 0, num_planes);
-#else
- av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, &cm->cur_frame->buf,
- mi_row, mi_col, 0, num_planes);
-#endif
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, &xd->mi[0]->chroma_ref_info);
av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2,
dst_stride2);
}
@@ -955,7 +970,8 @@
xd->block_ref_scale_factors[ref] = ref_scale_factors;
av1_setup_pre_planes(xd, ref, &ref_buf->buf, mi_row, mi_col,
- ref_scale_factors, num_planes);
+ ref_scale_factors, num_planes,
+ &mbmi->chroma_ref_info);
}
}
@@ -969,9 +985,7 @@
int pixel_c, pixel_r;
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, pd->subsampling_x,
pd->subsampling_y);
- if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
- pd->subsampling_y))
- continue;
+ if (plane && !xd->is_chroma_ref) continue;
mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
cm->current_frame.order_hint, plane, pixel_c,
pixel_r, pd->width, pd->height,
@@ -1094,8 +1108,16 @@
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize == get_plane_block_size(bsize, ss_x, ss_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#else
const BLOCK_SIZE plane_bsize =
get_plane_block_size(bsize, ss_x, ss_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
const TX_SIZE max_tx_size =
get_vartx_max_txsize(xd, plane_bsize, plane);
const int bh_var_tx = tx_size_high_unit[max_tx_size];
@@ -1127,6 +1149,7 @@
}
av1_visit_palette(pbi, xd, r, set_color_index_map_offset);
+ av1_mark_block_as_coded(xd, bsize, cm->seq_params.sb_size);
}
static AOM_INLINE void set_inter_tx_size(MB_MODE_INFO *mbmi, int stride_log2,
@@ -1411,10 +1434,12 @@
ThreadData *const td, int mi_row,
int mi_col, aom_reader *r,
PARTITION_TYPE partition,
- BLOCK_SIZE bsize) {
+ BLOCK_SIZE bsize,
+ PARTITION_TREE *parent, int index) {
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
- decode_mbmi_block(pbi, dcb, mi_row, mi_col, r, partition, bsize);
+ decode_mbmi_block(pbi, dcb, mi_row, mi_col, r, partition, bsize, parent,
+ index);
av1_visit_palette(pbi, xd, r, av1_decode_palette_tokens);
@@ -1533,11 +1558,12 @@
}
}
#if CONFIG_SDP
+ assert(bsize == mbmi->sb_type[av1_get_sdp_idx(xd->tree_type)]);
if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART])
- av1_reset_entropy_context(xd, bsize, num_planes);
#else
- if (mbmi->skip_txfm) av1_reset_entropy_context(xd, bsize, num_planes);
-#endif
+ if (mbmi->skip_txfm)
+#endif // CONFIG_SDP
+ av1_reset_entropy_context(xd, bsize, num_planes);
#if CONFIG_SDP
decode_token_recon_block(pbi, td, r, partition, bsize);
#else
@@ -1587,10 +1613,9 @@
#endif
}
-static AOM_INLINE void set_offsets_for_pred_and_recon(AV1Decoder *const pbi,
- ThreadData *const td,
- int mi_row, int mi_col,
- BLOCK_SIZE bsize) {
+static AOM_INLINE void set_offsets_for_pred_and_recon(
+ AV1Decoder *const pbi, ThreadData *const td, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, PARTITION_TREE *parent, int index) {
AV1_COMMON *const cm = &pbi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
DecoderCodingBlock *const dcb = &td->dcb;
@@ -1607,23 +1632,29 @@
&mi_params->tx_type_map[mi_row * mi_params->mi_stride + mi_col];
xd->tx_type_map_stride = mi_params->mi_stride;
- set_plane_n4(xd, bw, bh, num_planes);
+ CHROMA_REF_INFO *chr_ref_info = &xd->mi[0]->chroma_ref_info;
+ set_chroma_ref_info(mi_row, mi_col, index, bsize, chr_ref_info,
+ parent ? &parent->chroma_ref_info : NULL,
+ parent ? parent->bsize : BLOCK_INVALID,
+ parent ? parent->partition : PARTITION_NONE,
+ xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
+ set_plane_n4(xd, bw, bh, num_planes, chr_ref_info);
// Distance of Mb to the various image edges. These are specified to 8th pel
// as they are always compared to values that are in 1/8th pel units
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
- mi_params->mi_cols);
+ mi_params->mi_cols, chr_ref_info);
- av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, chr_ref_info);
}
static AOM_INLINE void decode_block(AV1Decoder *const pbi, ThreadData *const td,
int mi_row, int mi_col, aom_reader *r,
- PARTITION_TYPE partition,
- BLOCK_SIZE bsize) {
+ PARTITION_TYPE partition, BLOCK_SIZE bsize,
+ PARTITION_TREE *parent, int index) {
(void)partition;
- set_offsets_for_pred_and_recon(pbi, td, mi_row, mi_col, bsize);
+ set_offsets_for_pred_and_recon(pbi, td, mi_row, mi_col, bsize, parent, index);
#if CONFIG_SDP
decode_token_recon_block(pbi, td, r, partition, bsize);
#else
@@ -1635,15 +1666,65 @@
static PARTITION_TYPE read_partition(const AV1_COMMON *const cm,
MACROBLOCKD *xd, int mi_row, int mi_col,
aom_reader *r, int has_rows, int has_cols,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ PARTITION_TREE *ptree_luma,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
BLOCK_SIZE bsize) {
#else
static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
aom_reader *r, int has_rows, int has_cols,
BLOCK_SIZE bsize) {
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (!is_partition_point(bsize)) return PARTITION_NONE;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
+#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_SDP
+ const int plane = xd->tree_type == CHROMA_PART;
+ if (plane == 1 && bsize == BLOCK_8X8) {
+ return PARTITION_NONE;
+ }
+ const int min_bsize_1d =
+ AOMMIN(block_size_high[bsize], block_size_wide[bsize]);
+ if (plane && min_bsize_1d >= SHARED_PART_SIZE) {
+ const int ssx = cm->seq_params.subsampling_x;
+ const int ssy = cm->seq_params.subsampling_y;
+ if (ptree_luma)
+ return sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ssx, ssy);
+ }
+#endif // CONFIG_SDP
+
+ if (is_square_block(bsize)) {
+ if (!has_rows && has_cols) return PARTITION_HORZ;
+ if (has_rows && !has_cols) return PARTITION_VERT;
+
+ assert(ctx >= 0);
+ if (has_rows && has_cols) {
+#if CONFIG_SDP
+ aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
+#else
+ aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx];
+#endif // CONFIG_SDP
+
+ return (PARTITION_TYPE)aom_read_symbol(
+ r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
+ } else { // !has_rows && !has_cols
+ aom_cdf_prob cdf[2] = { 16384, AOM_ICDF(CDF_PROB_TOP) };
+ return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_VERT
+ : PARTITION_HORZ;
+ }
+ } else {
+ aom_cdf_prob *partition_rec_cdf = ec_ctx->partition_rec_cdf[ctx];
+ const PARTITION_TYPE_REC symbol = (PARTITION_TYPE_REC)aom_read_symbol(
+ r, partition_rec_cdf, partition_rec_cdf_length(bsize), ACCT_STR);
+
+ return get_partition_from_symbol_rec_block(bsize, symbol);
+ }
+#else // !CONFIG_EXT_RECUR_PARTITIONS
if (!has_rows && !has_cols) return PARTITION_SPLIT;
#if CONFIG_SDP
@@ -1653,12 +1734,12 @@
}
int parent_block_width = block_size_wide[bsize];
const CommonModeInfoParams *const mi_params = &cm->mi_params;
- if (xd->tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) {
+ if (plane && parent_block_width >= SHARED_PART_SIZE) {
int luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
// if luma blocks uses smaller blocks, then chroma will also split
if (luma_split_flag > 3) return PARTITION_SPLIT;
}
-#endif
+#endif // CONFIG_SDP
assert(ctx >= 0);
#if CONFIG_SDP
@@ -1683,26 +1764,31 @@
assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
// TODO(slavarnway): eliminate bsize and subsize in future commits
static AOM_INLINE void decode_partition(AV1Decoder *const pbi,
ThreadData *const td, int mi_row,
int mi_col, aom_reader *reader,
- BLOCK_SIZE bsize,
+ BLOCK_SIZE bsize, PARTITION_TREE *ptree,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ PARTITION_TREE *ptree_luma,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
int parse_decode_flag) {
assert(bsize < BLOCK_SIZES_ALL);
AV1_COMMON *const cm = &pbi->common;
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
- const int bw = mi_size_wide[bsize];
- const int hbs = bw >> 1;
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+ const int hbs_w = mi_size_wide[bsize] / 2;
+ const int hbs_h = mi_size_high[bsize] / 2;
+ const int qbs_w = mi_size_wide[bsize] / 4;
+ const int qbs_h = mi_size_high[bsize] / 4;
PARTITION_TYPE partition;
- BLOCK_SIZE subsize;
- const int quarter_step = bw / 4;
- BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
- const int has_rows = (mi_row + hbs) < cm->mi_params.mi_rows;
- const int has_cols = (mi_col + hbs) < cm->mi_params.mi_cols;
+ const int has_rows = (mi_row + hbs_h) < cm->mi_params.mi_rows;
+ const int has_cols = (mi_col + hbs_w) < cm->mi_params.mi_cols;
if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols)
return;
@@ -1737,24 +1823,63 @@
}
}
#if CONFIG_SDP
- partition = (bsize < BLOCK_8X8)
- ? PARTITION_NONE
- : read_partition(cm, xd, mi_row, mi_col, reader, has_rows,
- has_cols, bsize);
-#else
- partition = (bsize < BLOCK_8X8) ? PARTITION_NONE
- : read_partition(xd, mi_row, mi_col, reader,
- has_rows, has_cols, bsize);
-#endif
- } else {
-#if CONFIG_SDP
partition =
- get_partition(cm, xd->tree_type == CHROMA_PART, mi_row, mi_col, bsize);
+ !is_partition_point(bsize)
+ ? PARTITION_NONE
+ : read_partition(cm, xd, mi_row, mi_col, reader, has_rows, has_cols,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ ptree_luma,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ bsize);
#else
- partition = get_partition(cm, mi_row, mi_col, bsize);
+ partition = !is_partition_point(bsize)
+ ? PARTITION_NONE
+ : read_partition(xd, mi_row, mi_col, reader, has_rows,
+ has_cols, bsize);
#endif
+
+ ptree->partition = partition;
+ ptree->bsize = bsize;
+ ptree->mi_row = mi_row;
+ ptree->mi_col = mi_col;
+ ptree->is_settled = 1;
+ PARTITION_TREE *parent = ptree->parent;
+ set_chroma_ref_info(
+ mi_row, mi_col, ptree->index, bsize, &ptree->chroma_ref_info,
+ parent ? &parent->chroma_ref_info : NULL,
+ parent ? parent->bsize : BLOCK_INVALID,
+ parent ? parent->partition : PARTITION_NONE, ss_x, ss_y);
+
+ switch (partition) {
+ case PARTITION_SPLIT:
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+ ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
+ ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
+ break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ:
+ case PARTITION_VERT:
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+ break;
+ case PARTITION_HORZ_3:
+ case PARTITION_VERT_3:
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+ ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
+ break;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ default: break;
+ }
+ } else {
+ partition = ptree->partition;
}
- subsize = get_partition_subsize(bsize, partition);
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ const int track_ptree_luma =
+ ptree_luma ? (partition == ptree_luma->partition) : 0;
+#endif // CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
if (subsize == BLOCK_INVALID) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Partition is invalid for block size %dx%d",
@@ -1772,63 +1897,115 @@
#define DEC_BLOCK_STX_ARG
#define DEC_BLOCK_EPT_ARG partition,
-#define DEC_BLOCK(db_r, db_c, db_subsize) \
- block_visit[parse_decode_flag](pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), \
- reader, DEC_BLOCK_EPT_ARG(db_subsize))
-#define DEC_PARTITION(db_r, db_c, db_subsize) \
+#define DEC_BLOCK(db_r, db_c, db_subsize, index) \
+ block_visit[parse_decode_flag](pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), \
+ reader, DEC_BLOCK_EPT_ARG(db_subsize), ptree, \
+ index)
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+#define DEC_PARTITION(db_r, db_c, db_subsize, index) \
+ decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
+ (db_subsize), ptree->sub_tree[(index)], \
+ track_ptree_luma ? ptree_luma->sub_tree[index] : NULL, \
+ parse_decode_flag)
+#else // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+#define DEC_PARTITION(db_r, db_c, db_subsize, index) \
decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
- (db_subsize), parse_decode_flag)
+ (db_subsize), ptree->sub_tree[(index)], parse_decode_flag)
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
- case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize); break;
+ case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize, 0); break;
case PARTITION_HORZ:
- DEC_BLOCK(mi_row, mi_col, subsize);
- if (has_rows) DEC_BLOCK(mi_row + hbs, mi_col, subsize);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ DEC_PARTITION(mi_row, mi_col, subsize, 0);
+ if ((mi_row + hbs_h) < cm->mi_params.mi_rows)
+ DEC_PARTITION(mi_row + hbs_h, mi_col, subsize, 1);
+#else
+ DEC_BLOCK(mi_row, mi_col, subsize, 0);
+ if (has_rows) DEC_BLOCK(mi_row + hbs_h, mi_col, subsize, 1);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
case PARTITION_VERT:
- DEC_BLOCK(mi_row, mi_col, subsize);
- if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs, subsize);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ DEC_PARTITION(mi_row, mi_col, subsize, 0);
+ if ((mi_col + hbs_w) < cm->mi_params.mi_cols)
+ DEC_PARTITION(mi_row, mi_col + hbs_w, subsize, 1);
+#else
+ DEC_BLOCK(mi_row, mi_col, subsize, 0);
+ if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs_w, subsize, 1);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3: {
+ const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_HORZ);
+ int this_mi_row = mi_row;
+ DEC_PARTITION(this_mi_row, mi_col, subsize, 0);
+ this_mi_row += qbs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, bsize3, 1);
+ this_mi_row += 2 * qbs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, subsize, 2);
+ break;
+ }
+ case PARTITION_VERT_3: {
+ const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_VERT);
+ int this_mi_col = mi_col;
+ DEC_PARTITION(mi_row, this_mi_col, subsize, 0);
+ this_mi_col += qbs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, bsize3, 1);
+ this_mi_col += 2 * qbs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, subsize, 2);
+ break;
+ }
+#else
case PARTITION_SPLIT:
- DEC_PARTITION(mi_row, mi_col, subsize);
- DEC_PARTITION(mi_row, mi_col + hbs, subsize);
- DEC_PARTITION(mi_row + hbs, mi_col, subsize);
- DEC_PARTITION(mi_row + hbs, mi_col + hbs, subsize);
+ DEC_PARTITION(mi_row, mi_col, subsize, 0);
+ DEC_PARTITION(mi_row, mi_col + hbs_w, subsize, 1);
+ DEC_PARTITION(mi_row + hbs_h, mi_col, subsize, 2);
+ DEC_PARTITION(mi_row + hbs_h, mi_col + hbs_w, subsize, 3);
break;
case PARTITION_HORZ_A:
- DEC_BLOCK(mi_row, mi_col, bsize2);
- DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
- DEC_BLOCK(mi_row + hbs, mi_col, subsize);
+ DEC_BLOCK(mi_row, mi_col, bsize2, 0);
+ DEC_BLOCK(mi_row, mi_col + hbs_w, bsize2, 1);
+ DEC_BLOCK(mi_row + hbs_h, mi_col, subsize, 2);
break;
case PARTITION_HORZ_B:
- DEC_BLOCK(mi_row, mi_col, subsize);
- DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
- DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
+ DEC_BLOCK(mi_row, mi_col, subsize, 0);
+ DEC_BLOCK(mi_row + hbs_h, mi_col, bsize2, 1);
+ DEC_BLOCK(mi_row + hbs_h, mi_col + hbs_w, bsize2, 2);
break;
case PARTITION_VERT_A:
- DEC_BLOCK(mi_row, mi_col, bsize2);
- DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
- DEC_BLOCK(mi_row, mi_col + hbs, subsize);
+ DEC_BLOCK(mi_row, mi_col, bsize2, 0);
+ DEC_BLOCK(mi_row + hbs_h, mi_col, bsize2, 1);
+ DEC_BLOCK(mi_row, mi_col + hbs_w, subsize, 2);
break;
case PARTITION_VERT_B:
- DEC_BLOCK(mi_row, mi_col, subsize);
- DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
- DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
+ DEC_BLOCK(mi_row, mi_col, subsize, 0);
+ DEC_BLOCK(mi_row, mi_col + hbs_w, bsize2, 1);
+ DEC_BLOCK(mi_row + hbs_h, mi_col + hbs_w, bsize2, 2);
break;
case PARTITION_HORZ_4:
for (int i = 0; i < 4; ++i) {
- int this_mi_row = mi_row + i * quarter_step;
+ int this_mi_row = mi_row + i * qbs_h;
if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
- DEC_BLOCK(this_mi_row, mi_col, subsize);
+ DEC_BLOCK(this_mi_row, mi_col, subsize, i);
}
break;
case PARTITION_VERT_4:
for (int i = 0; i < 4; ++i) {
- int this_mi_col = mi_col + i * quarter_step;
+ int this_mi_col = mi_col + i * qbs_w;
if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
- DEC_BLOCK(mi_row, this_mi_col, subsize);
+ DEC_BLOCK(mi_row, this_mi_col, subsize, i);
}
break;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
default: assert(0 && "Invalid partition type");
}
@@ -1875,10 +2052,26 @@
? 2
: 1;
xd->tree_type = (total_loop_num == 1 ? SHARED_PART : LUMA_PART);
- decode_partition(pbi, td, mi_row, mi_col, reader, bsize, parse_decode_flag);
+ if (parse_decode_flag & 1) {
+ av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
+ }
+ decode_partition(pbi, td, mi_row, mi_col, reader, bsize,
+ td->dcb.xd.sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#if CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ parse_decode_flag);
if (total_loop_num == 2) {
xd->tree_type = CHROMA_PART;
- decode_partition(pbi, td, mi_row, mi_col, reader, bsize, parse_decode_flag);
+ if (parse_decode_flag & 1) {
+ av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
+ }
+ decode_partition(pbi, td, mi_row, mi_col, reader, bsize,
+ td->dcb.xd.sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#if CONFIG_EXT_RECUR_PARTITIONS
+ td->dcb.xd.sbi->ptree_root[0],
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ parse_decode_flag);
xd->tree_type = SHARED_PART;
}
}
@@ -3099,6 +3292,8 @@
for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
mi_col += cm->seq_params.mib_size, sb_col_in_tile++) {
+ av1_reset_is_mi_coded_map(&td->dcb.xd, cm->seq_params.mib_size);
+ td->dcb.xd.sbi = av1_get_sb_info(cm, mi_row, mi_col);
set_cb_buffer(pbi, &td->dcb, pbi->cb_buffer_base, num_planes, mi_row,
mi_col);
@@ -3110,7 +3305,7 @@
cm->seq_params.sb_size, 0x2);
#else
decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
- cm->seq_params.sb_size, 0x2);
+ cm->seq_params.sb_size, td->dcb.xd.sbi->ptree_root, 0x2);
#endif
sync_write(&tile_data->dec_row_mt_sync, sb_row_in_tile, sb_col_in_tile,
@@ -3186,15 +3381,19 @@
for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
mi_col += cm->seq_params.mib_size) {
+ av1_reset_is_mi_coded_map(xd, cm->seq_params.mib_size);
+ av1_set_sb_info(cm, xd, mi_row, mi_col);
set_cb_buffer(pbi, dcb, &td->cb_buffer_base, num_planes, 0, 0);
#if CONFIG_SDP
decode_partition_sb(pbi, td, mi_row, mi_col, td->bit_reader,
cm->seq_params.sb_size, 0x3);
#else
+ av1_reset_ptree_in_sbi(xd->sbi);
// Bit-stream parsing and decoding of the superblock
decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
- cm->seq_params.sb_size, 0x3);
+ cm->seq_params.sb_size, xd->sbi->ptree_root, 0x3);
#endif
+
if (aom_reader_has_overflowed(td->bit_reader)) {
aom_merge_corrupted_flag(&dcb->corrupted, 1);
return;
@@ -3626,6 +3825,8 @@
for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
mi_col += cm->seq_params.mib_size) {
+ av1_reset_is_mi_coded_map(xd, cm->seq_params.mib_size);
+ av1_set_sb_info(cm, xd, mi_row, mi_col);
set_cb_buffer(pbi, dcb, pbi->cb_buffer_base, num_planes, mi_row, mi_col);
// Bit-stream parsing of the superblock
@@ -3633,8 +3834,9 @@
decode_partition_sb(pbi, td, mi_row, mi_col, td->bit_reader,
cm->seq_params.sb_size, 0x1);
#else
+ av1_reset_ptree_in_sbi(xd->sbi);
decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
- cm->seq_params.sb_size, 0x1);
+ cm->seq_params.sb_size, xd->sbi->ptree_root, 0x1);
#endif
if (aom_reader_has_overflowed(td->bit_reader)) {
@@ -5805,8 +6007,8 @@
(cm->ccso_info.ccso_enable[0] || cm->ccso_info.ccso_enable[1]);
uint16_t *ext_rec_y;
if (use_ccso) {
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size,
- &cm->cur_frame->buf, 0, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, 0, 0, 0, num_planes,
+ NULL);
const int ccso_stride_ext =
xd->plane[0].dst.width + (CCSO_PADDING_SIZE << 1);
ext_rec_y =
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 9509e18..3f11d5d 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -38,10 +38,11 @@
static void read_cdef(AV1_COMMON *cm, aom_reader *r, MACROBLOCKD *const xd) {
#if CONFIG_SDP
- const int skip_txfm = xd->mi[0]->skip_txfm[xd->tree_type == CHROMA_PART];
+ assert(xd->tree_type != CHROMA_PART);
+ const int skip_txfm = xd->mi[0]->skip_txfm[0];
#else
const int skip_txfm = xd->mi[0]->skip_txfm;
-#endif
+#endif // CONFIG_SDP
if (cm->features.coded_lossless) return;
if (cm->features.allow_intrabc) {
assert(cm->cdef_info.cdef_bits == 0);
@@ -68,6 +69,27 @@
const int index = (cm->seq_params.sb_size == BLOCK_128X128)
? cdef_unit_col_in_sb + 2 * cdef_unit_row_in_sb
: 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int second_index = index;
+ const int current_grid_idx =
+ get_mi_grid_idx(&cm->mi_params, xd->mi_row, xd->mi_col);
+ const MB_MODE_INFO *const current_mbmi =
+ cm->mi_params.mi_grid_base[current_grid_idx];
+#if CONFIG_SDP
+ const BLOCK_SIZE current_bsize = current_mbmi->sb_type[0];
+#else
+ const BLOCK_SIZE current_bsize = current_mbmi->sb_type;
+#endif // CONFIG_SDP
+ const int mi_row_end = xd->mi_row + mi_size_high[current_bsize] - 1;
+ const int mi_col_end = xd->mi_col + mi_size_wide[current_bsize] - 1;
+ if (cm->seq_params.sb_size == BLOCK_128X128 &&
+ block_size_wide[current_bsize] != 128 &&
+ block_size_high[current_bsize] != 128) {
+ const int second_cdef_unit_row_in_sb = ((mi_row_end & index_mask) != 0);
+ const int second_cdef_unit_col_in_sb = ((mi_col_end & index_mask) != 0);
+ second_index = second_cdef_unit_col_in_sb + 2 * second_cdef_unit_row_in_sb;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Read CDEF strength from the first non-skip coding block in this CDEF unit.
if (!xd->cdef_transmitted[index] && !skip_txfm) {
@@ -83,6 +105,42 @@
aom_read_literal(r, cm->cdef_info.cdef_bits, ACCT_STR);
xd->cdef_transmitted[index] = true;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (!xd->cdef_transmitted[second_index] && !skip_txfm) {
+ // CDEF strength for this CDEF unit needs to be read into the MB_MODE_INFO
+ // of the 1st block in this CDEF unit.
+ const int first_block_mask = ~(cdef_size - 1);
+ CommonModeInfoParams *const mi_params = &cm->mi_params;
+ const int grid_idx =
+ get_mi_grid_idx(mi_params, mi_row_end & first_block_mask,
+ mi_col_end & first_block_mask);
+#if CONFIG_SDP
+ assert(IMPLIES(!mi_params->mi_grid_base[grid_idx],
+ xd->tree_type == LUMA_PART));
+ if (!mi_params->mi_grid_base[grid_idx]) {
+ const int mi_alloc_idx =
+ get_alloc_mi_idx(mi_params, mi_row_end & first_block_mask,
+ mi_col_end & first_block_mask);
+ mi_params->mi_grid_base[grid_idx] = &mi_params->mi_alloc[mi_alloc_idx];
+ }
+#endif
+ MB_MODE_INFO *const mbmi = mi_params->mi_grid_base[grid_idx];
+ mbmi->cdef_strength =
+ aom_read_literal(r, cm->cdef_info.cdef_bits, ACCT_STR);
+ xd->cdef_transmitted[second_index] = true;
+#if CONFIG_SDP
+ for (int x = 0; x < mi_size_wide[current_bsize]; x++) {
+ for (int y = 0; y < mi_size_high[current_bsize]; y++) {
+ const int mi_x = xd->mi_col + x;
+ const int mi_y = xd->mi_row + y;
+ const int idx = get_alloc_mi_idx(mi_params, mi_y, mi_x);
+ if (mi_y < mi_params->mi_rows && mi_x < mi_params->mi_cols)
+ mi_params->mi_alloc[idx].cdef_strength = mbmi->cdef_strength;
+ }
+ }
+#endif // CONFIG_SDP
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if CONFIG_CCSO
@@ -1919,12 +1977,14 @@
mbmi->motion_mode = SIMPLE_TRANSLATION;
#if CONFIG_SDP
- if (is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y]) &&
+ if (is_motion_variation_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y], xd->mi_row,
+ xd->mi_col) &&
!mbmi->skip_mode && !has_second_ref(mbmi)) {
#else
- if (is_motion_variation_allowed_bsize(mbmi->sb_type) && !mbmi->skip_mode &&
- !has_second_ref(mbmi)) {
-#endif
+ if (is_motion_variation_allowed_bsize(mbmi->sb_type, xd->mi_row,
+ xd->mi_col) &&
+ !mbmi->skip_mode && !has_second_ref(mbmi)) {
+#endif // CONFIG_SDP
mbmi->num_proj_ref = av1_findSamples(cm, xd, pts, pts_inref);
}
av1_count_overlappable_neighbors(cm, xd);
diff --git a/av1/decoder/decoder.h b/av1/decoder/decoder.h
index 45355ad..7a1f9a4 100644
--- a/av1/decoder/decoder.h
+++ b/av1/decoder/decoder.h
@@ -417,7 +417,8 @@
typedef void (*block_visitor_fn_t)(AV1Decoder *const pbi, ThreadData *const td,
int mi_row, int mi_col, aom_reader *r,
- PARTITION_TYPE partition, BLOCK_SIZE bsize);
+ PARTITION_TYPE partition, BLOCK_SIZE bsize,
+ PARTITION_TREE *parent, int index);
/*!\endcond */
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 2f5c152..f95bc3e 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -380,14 +380,20 @@
MACROBLOCKD *const xd = &dcb->xd;
MB_MODE_INFO *const mbmi = xd->mi[0];
struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_SDP
- const BLOCK_SIZE bsize = mbmi->sb_type[plane > 0];
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, mbmi, plane, pd->subsampling_x, pd->subsampling_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize == get_plane_block_size(mbmi->sb_type[plane > 0],
+ pd->subsampling_x,
+ pd->subsampling_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
#else
const BLOCK_SIZE bsize = mbmi->sb_type;
-#endif
assert(bsize < BLOCK_SIZES_ALL);
const BLOCK_SIZE plane_bsize =
get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
TXB_CTX txb_ctx;
get_txb_ctx(plane_bsize, tx_size, plane, pd->above_entropy_context + col,
diff --git a/av1/encoder/aq_complexity.c b/av1/encoder/aq_complexity.c
index 4a45fc7..824b45f 100644
--- a/av1/encoder/aq_complexity.c
+++ b/av1/encoder/aq_complexity.c
@@ -161,7 +161,8 @@
aom_clear_system_state();
low_var_thresh = DEFAULT_LV_THRESH;
- av1_setup_src_planes(mb, cpi->source, mi_row, mi_col, num_planes, bs);
+ av1_setup_src_planes(mb, cpi->source, mi_row, mi_col, num_planes,
+ &mb->e_mbd.mi[0]->chroma_ref_info);
logvar = av1_log_block_var(cpi, mb, bs);
segment = AQ_C_SEGMENTS - 1; // Just in case no break out below.
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index d830a00..fc6d529 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -21,6 +21,7 @@
#include "aom_ports/bitops.h"
#include "aom_ports/mem_ops.h"
#include "aom_ports/system_state.h"
+#include "av1/common/blockd.h"
#if CONFIG_BITSTREAM_DEBUG
#include "aom_util/debug_util.h"
#endif // CONFIG_BITSTREAM_DEBUG
@@ -515,7 +516,14 @@
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_SDP
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
+ const TX_SIZE plane_tx_size =
+ plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
+ pd->subsampling_y)
+ : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
+ blk_col)];
+#elif CONFIG_SDP
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(mbmi->sb_type[plane > 0], pd->subsampling_x,
pd->subsampling_y)
@@ -523,8 +531,8 @@
blk_col)];
#else
const TX_SIZE plane_tx_size =
- plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x,
- pd->subsampling_y)
+ plane ? av1_get_max_uv_txsize(mbmi->chroma_ref_info.bsize_base,
+ pd->subsampling_x, pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#endif
@@ -1210,6 +1218,28 @@
const int index = (cm->seq_params.sb_size == BLOCK_128X128)
? cdef_unit_col_in_sb + 2 * cdef_unit_row_in_sb
: 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int second_index = index;
+ const int current_grid_idx =
+ get_mi_grid_idx(&cm->mi_params, xd->mi_row, xd->mi_col);
+ const MB_MODE_INFO *const current_mbmi =
+ cm->mi_params.mi_grid_base[current_grid_idx];
+#if CONFIG_SDP
+ assert(xd->tree_type != CHROMA_PART);
+ const BLOCK_SIZE current_bsize = current_mbmi->sb_type[0];
+#else
+ const BLOCK_SIZE current_bsize = current_mbmi->sb_type;
+#endif // CONFIG_SDP
+ const int mi_row_end = xd->mi_row + mi_size_high[current_bsize] - 1;
+ const int mi_col_end = xd->mi_col + mi_size_wide[current_bsize] - 1;
+ if (cm->seq_params.sb_size == BLOCK_128X128 &&
+ block_size_wide[current_bsize] != 128 &&
+ block_size_high[current_bsize] != 128) {
+ const int second_cdef_unit_row_in_sb = ((mi_row_end & index_mask) != 0);
+ const int second_cdef_unit_col_in_sb = ((mi_col_end & index_mask) != 0);
+ second_index = second_cdef_unit_col_in_sb + 2 * second_cdef_unit_row_in_sb;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Write CDEF strength to the first non-skip coding block in this CDEF unit.
if (!xd->cdef_transmitted[index] && !skip) {
@@ -1224,6 +1254,20 @@
aom_write_literal(w, mbmi->cdef_strength, cm->cdef_info.cdef_bits);
xd->cdef_transmitted[index] = true;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (!xd->cdef_transmitted[second_index] && !skip) {
+ // CDEF strength for this CDEF unit needs to be stored in the MB_MODE_INFO
+ // of the 1st block in this CDEF unit.
+ const int first_block_mask = ~(cdef_size - 1);
+ const CommonModeInfoParams *const mi_params = &cm->mi_params;
+ const int grid_idx =
+ get_mi_grid_idx(mi_params, mi_row_end & first_block_mask,
+ mi_col_end & first_block_mask);
+ const MB_MODE_INFO *const mbmi = mi_params->mi_grid_base[grid_idx];
+ aom_write_literal(w, mbmi->cdef_strength, cm->cdef_info.cdef_bits);
+ xd->cdef_transmitted[second_index] = true;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if CONFIG_CCSO
@@ -1903,16 +1947,21 @@
const int plane) {
MACROBLOCKD *const xd = &x->e_mbd;
const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_SDP
- const BLOCK_SIZE bsize = mbmi->sb_type[PLANE_TYPE_Y];
-#else
- const BLOCK_SIZE bsize = mbmi->sb_type;
-#endif
- assert(bsize < BLOCK_SIZES_ALL);
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize ==
+ get_plane_block_size(mbmi->sb_type[PLANE_TYPE_Y], ss_x, ss_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
assert(plane_bsize < BLOCK_SIZES_ALL);
+#else
+ const BLOCK_SIZE bsize = mbmi->sb_type;
+ assert(bsize < BLOCK_SIZES_ALL);
+ const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, plane);
const int step =
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
@@ -1943,7 +1992,9 @@
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
-#if CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ const BLOCK_SIZE bsize = get_bsize_base(xd, mbmi, AOM_PLANE_Y);
+#elif CONFIG_SDP
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
#else
const BLOCK_SIZE bsize = mbmi->sb_type;
@@ -2042,7 +2093,7 @@
const int bh = mi_size_high[bsize];
const int bw = mi_size_wide[bsize];
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
- mi_params->mi_cols);
+ mi_params->mi_cols, &mbmi->chroma_ref_info);
xd->above_txfm_context = cm->above_contexts.txfm[tile->tile_row] + mi_col;
xd->left_txfm_context =
@@ -2138,33 +2189,81 @@
#endif
write_tokens_b(cpi, w, tok, tok_end);
}
+
+ av1_mark_block_as_coded(xd, bsize, cm->seq_params.sb_size);
}
static AOM_INLINE void write_partition(const AV1_COMMON *const cm,
- const MACROBLOCKD *const xd, int hbs,
- int mi_row, int mi_col, PARTITION_TYPE p,
- BLOCK_SIZE bsize, aom_writer *w) {
- const int is_partition_point = bsize >= BLOCK_8X8;
-
- if (!is_partition_point) return;
+ const MACROBLOCKD *const xd, int mi_row,
+ int mi_col, PARTITION_TYPE p,
+ BLOCK_SIZE bsize,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ PARTITION_TREE *ptree_luma,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ aom_writer *w) {
+ if (!is_partition_point(bsize)) return;
#if CONFIG_SDP
const int plane = xd->tree_type == CHROMA_PART;
if (bsize == BLOCK_8X8 && plane > 0) return;
-#endif
+ const int parent_block_width = block_size_wide[bsize];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int min_bsize_1d = AOMMIN(block_size_high[bsize], parent_block_width);
+ if (xd->tree_type == CHROMA_PART && min_bsize_1d >= SHARED_PART_SIZE) {
+ const int ssx = cm->seq_params.subsampling_x;
+ const int ssy = cm->seq_params.subsampling_y;
+ (void)ssx;
+ (void)ssy;
+ if (ptree_luma) {
+ assert(p ==
+ sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ssx, ssy));
+ return;
+ }
+ }
+ (void)ptree_luma;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#endif // CONFIG_SDP
- const int has_rows = (mi_row + hbs) < cm->mi_params.mi_rows;
- const int has_cols = (mi_col + hbs) < cm->mi_params.mi_cols;
const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (is_square_block(bsize)) {
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ const int hbs_w = mi_size_wide[bsize] / 2;
+ const int hbs_h = mi_size_high[bsize] / 2;
+ const int has_rows = (mi_row + hbs_h) < cm->mi_params.mi_rows;
+ const int has_cols = (mi_col + hbs_w) < cm->mi_params.mi_cols;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (has_rows && has_cols) {
+#if CONFIG_SDP
+ aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
+#else
+ aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx];
+#endif // CONFIG_SDP
+ aom_write_symbol(w, p, partition_cdf, partition_cdf_length(bsize));
+ } else if (!has_rows && has_cols) {
+ assert(p == PARTITION_HORZ);
+ } else if (has_rows && !has_cols) {
+ assert(p == PARTITION_VERT);
+ } else {
+ assert(p == PARTITION_HORZ || p == PARTITION_VERT);
+ aom_cdf_prob cdf[2] = { 16384, AOM_ICDF(CDF_PROB_TOP) };
+ aom_write_cdf(w, p == PARTITION_VERT, cdf, 2);
+ }
+ } else { // 1:2 or 2:1 rectangular blocks
+ const PARTITION_TYPE_REC symbol =
+ get_symbol_from_partition_rec_block(bsize, p);
+ aom_write_symbol(w, symbol, ec_ctx->partition_rec_cdf[ctx],
+ partition_rec_cdf_length(bsize));
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
if (!has_rows && !has_cols) {
assert(p == PARTITION_SPLIT);
return;
}
#if CONFIG_SDP
- int parent_block_width = block_size_wide[bsize];
const CommonModeInfoParams *const mi_params = &cm->mi_params;
if (xd->tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) {
int luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
@@ -2206,25 +2305,27 @@
#endif
aom_write_cdf(w, p == PARTITION_SPLIT, cdf, 2);
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
static AOM_INLINE void write_modes_sb(
AV1_COMP *const cpi, const TileInfo *const tile, aom_writer *const w,
- const TokenExtra **tok, const TokenExtra *const tok_end, int mi_row,
- int mi_col, BLOCK_SIZE bsize) {
+ const TokenExtra **tok, const TokenExtra *const tok_end,
+ PARTITION_TREE *ptree,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ PARTITION_TREE *ptree_luma,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ int mi_row, int mi_col, BLOCK_SIZE bsize) {
const AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
assert(bsize < BLOCK_SIZES_ALL);
- const int hbs = mi_size_wide[bsize] / 2;
- const int quarter_step = mi_size_wide[bsize] / 4;
- int i;
-#if CONFIG_SDP
- const PARTITION_TYPE partition =
- get_partition(cm, xd->tree_type == CHROMA_PART, mi_row, mi_col, bsize);
-#else
- const PARTITION_TYPE partition = get_partition(cm, mi_row, mi_col, bsize);
-#endif
+ const int hbs_w = mi_size_wide[bsize] / 2;
+ const int hbs_h = mi_size_high[bsize] / 2;
+ const int qbs_w = mi_size_wide[bsize] / 4;
+ const int qbs_h = mi_size_high[bsize] / 4;
+ assert(ptree);
+ const PARTITION_TYPE partition = ptree->partition;
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
@@ -2253,65 +2354,145 @@
}
}
- write_partition(cm, xd, hbs, mi_row, mi_col, partition, bsize, w);
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ write_partition(cm, xd, mi_row, mi_col, partition, bsize, ptree_luma, w);
+ const int track_ptree_luma =
+ ptree_luma ? (partition == ptree_luma->partition) : 0;
+#else
+ write_partition(cm, xd, mi_row, mi_col, partition, bsize, w);
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
case PARTITION_NONE:
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
break;
case PARTITION_HORZ:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col, subsize);
+ if (mi_row + hbs_h < mi_params->mi_rows) {
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ mi_row + hbs_h, mi_col, subsize);
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
- if (mi_row + hbs < mi_params->mi_rows)
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col);
+ if (mi_row + hbs_h < mi_params->mi_rows)
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs_h, mi_col);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
case PARTITION_VERT:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col, subsize);
+ if (mi_col + hbs_w < mi_params->mi_cols) {
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col + hbs_w, subsize);
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
- if (mi_col + hbs < mi_params->mi_cols)
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs);
+ if (mi_col + hbs_w < mi_params->mi_cols)
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs_w);
+#endif
break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3:
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col, subsize);
+ if (mi_row + qbs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ mi_row + qbs_h, mi_col,
+ get_partition_subsize(bsize, PARTITION_HORZ));
+ if (mi_row + 3 * qbs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+#endif // CONFIG_SDP
+ mi_row + 3 * qbs_h, mi_col, subsize);
+ break;
+ case PARTITION_VERT_3:
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col, subsize);
+ if (mi_col + qbs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col + qbs_w,
+ get_partition_subsize(bsize, PARTITION_VERT));
+ if (mi_col + 3 * qbs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+#endif // CONFIG_SDP
+ mi_row, mi_col + 3 * qbs_w, subsize);
+ break;
+#else
case PARTITION_SPLIT:
- write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, subsize);
- write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs, subsize);
- write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col, subsize);
- write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs,
- subsize);
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0], mi_row,
+ mi_col, subsize);
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1], mi_row,
+ mi_col + hbs_w, subsize);
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+ mi_row + hbs_h, mi_col, subsize);
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[3],
+ mi_row + hbs_h, mi_col + hbs_w, subsize);
break;
case PARTITION_HORZ_A:
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs_w);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs_h, mi_col);
break;
case PARTITION_HORZ_B:
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs_h, mi_col);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs_h, mi_col + hbs_w);
break;
case PARTITION_VERT_A:
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs_h, mi_col);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs_w);
break;
case PARTITION_VERT_B:
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs);
- write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs_w);
+ write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs_h, mi_col + hbs_w);
break;
case PARTITION_HORZ_4:
- for (i = 0; i < 4; ++i) {
- int this_mi_row = mi_row + i * quarter_step;
+ for (int i = 0; i < 4; ++i) {
+ int this_mi_row = mi_row + i * qbs_h;
if (i > 0 && this_mi_row >= mi_params->mi_rows) break;
-
write_modes_b(cpi, tile, w, tok, tok_end, this_mi_row, mi_col);
}
break;
case PARTITION_VERT_4:
- for (i = 0; i < 4; ++i) {
- int this_mi_col = mi_col + i * quarter_step;
+ for (int i = 0; i < 4; ++i) {
+ int this_mi_col = mi_col + i * qbs_w;
if (i > 0 && this_mi_col >= mi_params->mi_cols) break;
-
write_modes_b(cpi, tile, w, tok, tok_end, mi_row, this_mi_col);
}
break;
- default: assert(0);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ default: assert(0); break;
}
// update partition context
@@ -2353,6 +2534,8 @@
for (int mi_col = mi_col_start; mi_col < mi_col_end;
mi_col += cm->seq_params.mib_size) {
+ av1_reset_is_mi_coded_map(xd, cm->seq_params.mib_size);
+ xd->sbi = av1_get_sb_info(cm, mi_row, mi_col);
cpi->td.mb.cb_coef_buff = av1_get_cb_coeff_buffer(cpi, mi_row, mi_col);
#if CONFIG_SDP
const int total_loop_num =
@@ -2361,17 +2544,26 @@
? 2
: 1;
xd->tree_type = (total_loop_num == 1 ? SHARED_PART : LUMA_PART);
-#endif
- write_modes_sb(cpi, tile, w, &tok, tok_end, mi_row, mi_col,
- cm->seq_params.sb_size);
-#if CONFIG_SDP
+ write_modes_sb(cpi, tile, w, &tok, tok_end,
+ xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#if CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ mi_row, mi_col, cm->seq_params.sb_size);
if (total_loop_num == 2) {
xd->tree_type = CHROMA_PART;
- write_modes_sb(cpi, tile, w, &tok, tok_end, mi_row, mi_col,
- cm->seq_params.sb_size);
+ write_modes_sb(cpi, tile, w, &tok, tok_end,
+ xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#if CONFIG_EXT_RECUR_PARTITIONS
+ xd->sbi->ptree_root[0],
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ mi_row, mi_col, cm->seq_params.sb_size);
xd->tree_type = SHARED_PART;
}
-#endif
+#else
+ write_modes_sb(cpi, tile, w, &tok, tok_end, xd->sbi->ptree_root, mi_row,
+ mi_col, cm->seq_params.sb_size);
+#endif // CONFIG_SDP
}
assert(tok == tok_end);
}
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 4bf2617..c18d28d 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -244,11 +244,7 @@
//! \copydoc MB_MODE_INFO_EXT::mode_context
int16_t mode_context;
//! Offset of current coding block's coeff buffer relative to the sb.
-#if CONFIG_SDP
int cb_offset[MAX_MB_PLANE];
-#else
- int cb_offset;
-#endif
} MB_MODE_INFO_EXT_FRAME;
/*! \brief Txfm search results for a partition
@@ -412,6 +408,101 @@
uint8_t *tmp_best_mask_buf;
} CompoundTypeRdBuffers;
+/*!\cond */
+/*! \brief MV cost types
+ */
+enum {
+ MV_COST_ENTROPY, // Use the entropy rate of the mv as the cost
+ MV_COST_L1_LOWRES, // Use the l1 norm of the mv as the cost (<480p)
+ MV_COST_L1_MIDRES, // Use the l1 norm of the mv as the cost (>=480p)
+ MV_COST_L1_HDRES, // Use the l1 norm of the mv as the cost (>=720p)
+ MV_COST_NONE // Use 0 as as cost irrespective of the current mv
+} UENUM1BYTE(MV_COST_TYPE);
+/*!\endcond */
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+/*! \brief max length of start Mv list
+ */
+#define kSMSMaxStartMVs 1
+/*! \brief Contains data for simple motion
+ */
+typedef struct SimpleMotionData {
+ MV mv_ref; /*!< mv reference */
+ MV fullmv; /*!< mv full */
+ MV submv; /*!< mv subpel */
+ unsigned int sse; /*!< sse */
+ unsigned int var; /*!< variance */
+ int64_t dist; /*!< distortion */
+ int rate; /*!< rate */
+ int64_t rdcost; /*!< rdcost */
+ int valid; /*!< whether valid */
+ BLOCK_SIZE bsize; /*!< blocksize */
+ int mi_row; /*!< row position in mi units */
+ int mi_col; /*!< col position in mi units */
+ MV_COST_TYPE mv_cost_type; /*!< mv cost type */
+ int sadpb; /*!< sad per bit */
+ int errorperbit; /*!< error per bit */
+ MV start_mv_list[kSMSMaxStartMVs]; /*!< start mv list */
+ int num_start_mvs; /*!< number of start mvs */
+ int has_prev_partition; /*!< has previous partition */
+ PARTITION_TYPE prev_partition; /*!< previous partition */
+ struct PICK_MODE_CONTEXT *mode_cache[1]; /*!< mode cache */
+} SimpleMotionData;
+
+/*!\cond */
+#define BLOCK_128_COUNT 1
+#define BLOCK_64_COUNT 3
+#define BLOCK_32_COUNT 7
+#define BLOCK_16_COUNT 15
+#define BLOCK_8_COUNT 31
+#define BLOCK_4_COUNT 32
+
+#define MAKE_SM_DATA_BUF(width, height) \
+ SimpleMotionData \
+ b_##width##x##height[BLOCK_##width##_COUNT * BLOCK_##height##_COUNT]
+/*!\endcond */
+
+/*! \brief Simple motion data buffers
+ */
+typedef struct SimpleMotionDataBufs {
+ /*!\cond */
+ // Square blocks
+ MAKE_SM_DATA_BUF(128, 128);
+ MAKE_SM_DATA_BUF(64, 64);
+ MAKE_SM_DATA_BUF(32, 32);
+ MAKE_SM_DATA_BUF(16, 16);
+ MAKE_SM_DATA_BUF(8, 8);
+ MAKE_SM_DATA_BUF(4, 4);
+
+ // 1:2 blocks
+ MAKE_SM_DATA_BUF(64, 128);
+ MAKE_SM_DATA_BUF(32, 64);
+ MAKE_SM_DATA_BUF(16, 32);
+ MAKE_SM_DATA_BUF(8, 16);
+ MAKE_SM_DATA_BUF(4, 8);
+
+ // 2:1 blocks
+ MAKE_SM_DATA_BUF(128, 64);
+ MAKE_SM_DATA_BUF(64, 32);
+ MAKE_SM_DATA_BUF(32, 16);
+ MAKE_SM_DATA_BUF(16, 8);
+ MAKE_SM_DATA_BUF(8, 4);
+
+ // 1:4 blocks
+ MAKE_SM_DATA_BUF(16, 64);
+ MAKE_SM_DATA_BUF(8, 32);
+ MAKE_SM_DATA_BUF(4, 16);
+
+ // 4:1 blocks
+ MAKE_SM_DATA_BUF(64, 16);
+ MAKE_SM_DATA_BUF(32, 8);
+ MAKE_SM_DATA_BUF(16, 4);
+ /*!\endcond */
+} SimpleMotionDataBufs;
+
+#undef MAKE_SM_DATA_BUF
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
/*! \brief Holds some parameters related to partitioning schemes in AV1.
*/
// TODO(chiyotsai@google.com): Consolidate this with SIMPLE_MOTION_DATA_TREE
@@ -606,7 +697,11 @@
[EXT_PARTITION_TYPES];
#else
int partition_cost[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
-#endif
+#endif // CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS
+ /*! Cost for coding the partition for rectangular blocks. */
+ int partition_rec_cost[PARTITION_CONTEXTS_REC][PARTITION_TYPES_REC];
+#endif // CONFIG_EXT_RECUR_PARTITIONS
/**@}*/
/*****************************************************************************
@@ -937,11 +1032,7 @@
*/
CB_COEFF_BUFFER *cb_coef_buff;
//! Offset of current coding block's coeff buffer relative to the sb.
-#if CONFIG_SDP
int cb_offset[MAX_MB_PLANE];
-#else
- uint16_t cb_offset;
-#endif
//! Modified source and masks used for fast OBMC search.
OBMCBuffer obmc_buffer;
@@ -1206,6 +1297,14 @@
unsigned int source_variance;
//! SSE of the current predictor.
unsigned int pred_sse[REF_FRAMES];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ /*! Simple motion search buffers. */
+ SimpleMotionDataBufs *sms_bufs;
+ /*! \brief Determines what encoding decision should be reused. */
+ int reuse_inter_mode_cache_type;
+ /*! \brief The mode to reuse during \ref av1_rd_pick_inter_mode_sb. */
+ MB_MODE_INFO *inter_mode_cache;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
/**@}*/
} MACROBLOCK;
#undef SINGLE_REF_MODES
@@ -1321,6 +1420,11 @@
return (txb_skip[blk_idx] >> plane) & 1;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE int should_reuse_mode(const MACROBLOCK *x, int mode_flag) {
+ return x->reuse_inter_mode_cache_type & mode_flag;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
/*!\endcond */
#ifdef __cplusplus
diff --git a/av1/encoder/compound_type.c b/av1/encoder/compound_type.c
index f33094d..0162b55 100644
--- a/av1/encoder/compound_type.c
+++ b/av1/encoder/compound_type.c
@@ -457,8 +457,12 @@
const int bw = block_size_wide[bsize];
mbmi->interintra_mode = interintra_mode;
int rmode = interintra_mode_cost[interintra_mode];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst, intrapred, bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_combine_interintra(xd, bsize, 0, tmp_buf, bw, intrapred, bw);
model_rd_sb_fn[MODELRD_TYPE_INTERINTRA](cpi, bsize, x, xd, 0, 0, &rate, &dist,
&skip_txfm_sb, &skip_sse_sb, NULL,
@@ -520,8 +524,13 @@
uint8_t *intrapred = get_buf_by_bd(xd, intrapred_);
for (INTERINTRA_MODE mode = 0; mode < INTERINTRA_MODES; ++mode) {
mbmi->interintra_mode = mode;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst, intrapred,
+ bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
int64_t rd = pick_interintra_wedge(cpi, x, bsize, intrapred_, tmp_buf_);
const int rate_overhead =
interintra_mode_cost[mode] +
@@ -575,8 +584,13 @@
*best_interintra_mode != INTERINTRA_MODES;
if (interintra_mode_reuse || *best_interintra_mode != INTERINTRA_MODES - 1) {
mbmi->interintra_mode = *best_interintra_mode;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst, intrapred,
+ bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_combine_interintra(xd, bsize, 0, tmp_buf, bw, intrapred, bw);
}
@@ -634,15 +648,25 @@
mbmi->interintra_mode = best_mode;
mbmi->interintra_wedge_index = best_wedge_index;
if (best_mode != INTERINTRA_MODES - 1) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst, intrapred,
+ bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
} else if (!try_smooth_interintra) {
if (*best_interintra_mode == INTERINTRA_MODES) {
mbmi->interintra_mode = INTERINTRA_MODES - 1;
*best_interintra_mode = INTERINTRA_MODES - 1;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst, intrapred,
+ bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Pick wedge mask based on INTERINTRA_MODES - 1
*best_rd = pick_interintra_wedge(cpi, x, bsize, intrapred_, tmp_buf_);
// Find the best interintra mode for the chosen wedge mask
@@ -657,14 +681,24 @@
// Recompute prediction if required
if (*best_interintra_mode != INTERINTRA_MODES - 1) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst,
+ intrapred, bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
} else {
// Pick wedge mask for the best interintra mode (reused)
mbmi->interintra_mode = *best_interintra_mode;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_build_intra_predictors_for_interintra(cm, xd, 0, orig_dst, intrapred,
+ bw);
+#else
av1_build_intra_predictors_for_interintra(cm, xd, bsize, 0, orig_dst,
intrapred, bw);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
*best_rd = pick_interintra_wedge(cpi, x, bsize, intrapred_, tmp_buf_);
}
} else {
diff --git a/av1/encoder/context_tree.c b/av1/encoder/context_tree.c
index 6d07ef2..028fd3d 100644
--- a/av1/encoder/context_tree.c
+++ b/av1/encoder/context_tree.c
@@ -11,6 +11,7 @@
#include "av1/encoder/context_tree.h"
#include "av1/encoder/encoder.h"
+#include "av1/encoder/rd.h"
static const BLOCK_SIZE square[MAX_SB_SIZE_LOG2 - 1] = {
BLOCK_4X4, BLOCK_8X8, BLOCK_16X16, BLOCK_32X32, BLOCK_64X64, BLOCK_128X128,
@@ -38,6 +39,12 @@
dst_ctx->rd_stats = src_ctx->rd_stats;
dst_ctx->rd_mode_is_ready = src_ctx->rd_mode_is_ready;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ for (int i = 0; i < 2; ++i) {
+ memcpy(dst_ctx->color_index_map[i], src_ctx->color_index_map[i],
+ sizeof(src_ctx->color_index_map[i][0]) * src_ctx->num_4x4_blk * 16);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
void av1_setup_shared_coeff_buffer(AV1_COMMON *cm,
@@ -64,13 +71,23 @@
}
}
-PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, BLOCK_SIZE bsize,
+PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, PC_TREE *parent,
+ PARTITION_TYPE parent_partition, int index,
+ int subsampling_x, int subsampling_y,
PC_TREE_SHARED_BUFFERS *shared_bufs) {
PICK_MODE_CONTEXT *ctx = NULL;
struct aom_internal_error_info error;
AOM_CHECK_MEM_ERROR(&error, ctx, aom_calloc(1, sizeof(*ctx)));
ctx->rd_mode_is_ready = 0;
+ ctx->parent = parent;
+ ctx->index = index;
+ set_chroma_ref_info(mi_row, mi_col, index, bsize, &ctx->chroma_ref_info,
+ parent ? &parent->chroma_ref_info : NULL,
+ parent ? parent->block_size : BLOCK_INVALID,
+ parent_partition, subsampling_x, subsampling_y);
+ ctx->mic.chroma_ref_info = ctx->chroma_ref_info;
const int num_planes = av1_num_planes(cm);
const int num_pix = block_size_wide[bsize] * block_size_high[bsize];
@@ -100,7 +117,7 @@
aom_memalign(32, num_pix * sizeof(*ctx->color_index_map[i])));
}
}
-
+ av1_invalid_rd_stats(&ctx->rd_stats);
return ctx;
}
@@ -128,30 +145,52 @@
aom_free(ctx);
}
-PC_TREE *av1_alloc_pc_tree_node(BLOCK_SIZE bsize) {
+PC_TREE *av1_alloc_pc_tree_node(int mi_row, int mi_col, BLOCK_SIZE bsize,
+ PC_TREE *parent,
+ PARTITION_TYPE parent_partition, int index,
+ int is_last, int subsampling_x,
+ int subsampling_y) {
PC_TREE *pc_tree = NULL;
struct aom_internal_error_info error;
AOM_CHECK_MEM_ERROR(&error, pc_tree, aom_calloc(1, sizeof(*pc_tree)));
+ pc_tree->mi_row = mi_row;
+ pc_tree->mi_col = mi_col;
+ pc_tree->parent = parent;
+ pc_tree->index = index;
pc_tree->partitioning = PARTITION_NONE;
pc_tree->block_size = bsize;
- pc_tree->index = 0;
+ pc_tree->is_last_subblock = is_last;
+ av1_invalid_rd_stats(&pc_tree->rd_cost);
+ set_chroma_ref_info(mi_row, mi_col, index, bsize, &pc_tree->chroma_ref_info,
+ parent ? &parent->chroma_ref_info : NULL,
+ parent ? parent->block_size : BLOCK_INVALID,
+ parent_partition, subsampling_x, subsampling_y);
pc_tree->none = NULL;
for (int i = 0; i < 2; ++i) {
pc_tree->horizontal[i] = NULL;
pc_tree->vertical[i] = NULL;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ for (int i = 0; i < 3; ++i) {
+ pc_tree->horizontal3[i] = NULL;
+ pc_tree->vertical3[i] = NULL;
+ }
+#else
for (int i = 0; i < 3; ++i) {
pc_tree->horizontala[i] = NULL;
pc_tree->horizontalb[i] = NULL;
pc_tree->verticala[i] = NULL;
pc_tree->verticalb[i] = NULL;
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
for (int i = 0; i < 4; ++i) {
+#if !CONFIG_EXT_RECUR_PARTITIONS
pc_tree->horizontal4[i] = NULL;
pc_tree->vertical4[i] = NULL;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
pc_tree->split[i] = NULL;
}
@@ -174,11 +213,38 @@
FREE_PMC_NODE(pc_tree->none);
for (int i = 0; i < 2; ++i) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if ((!keep_best || (partition != PARTITION_HORZ)) &&
+ pc_tree->horizontal[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal[i], num_planes, 0, 0);
+ pc_tree->horizontal[i] = NULL;
+ }
+ if ((!keep_best || (partition != PARTITION_VERT)) &&
+ pc_tree->vertical[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->vertical[i], num_planes, 0, 0);
+ pc_tree->vertical[i] = NULL;
+ }
+#else
if (!keep_best || (partition != PARTITION_HORZ))
FREE_PMC_NODE(pc_tree->horizontal[i]);
if (!keep_best || (partition != PARTITION_VERT))
FREE_PMC_NODE(pc_tree->vertical[i]);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ for (int i = 0; i < 3; ++i) {
+ if ((!keep_best || (partition != PARTITION_HORZ_3)) &&
+ pc_tree->horizontal3[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal3[i], num_planes, 0, 0);
+ pc_tree->horizontal3[i] = NULL;
+ }
+ if ((!keep_best || (partition != PARTITION_VERT_3)) &&
+ pc_tree->vertical3[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->vertical3[i], num_planes, 0, 0);
+ pc_tree->vertical3[i] = NULL;
+ }
+ }
+#else
for (int i = 0; i < 3; ++i) {
if (!keep_best || (partition != PARTITION_HORZ_A))
FREE_PMC_NODE(pc_tree->horizontala[i]);
@@ -195,6 +261,7 @@
if (!keep_best || (partition != PARTITION_VERT_4))
FREE_PMC_NODE(pc_tree->vertical4[i]);
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (!keep_best || (partition != PARTITION_SPLIT)) {
for (int i = 0; i < 4; ++i) {
@@ -208,6 +275,144 @@
if (!keep_best && !keep_none) aom_free(pc_tree);
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_copy_pc_tree_recursive(const AV1_COMMON *cm, PC_TREE *dst,
+ PC_TREE *src, int ss_x, int ss_y,
+ PC_TREE_SHARED_BUFFERS *shared_bufs,
+ int num_planes) {
+ // Copy the best partition type. For basic information like bsize and index,
+ // we assume they have been set properly when initializing the dst PC_TREE
+ dst->partitioning = src->partitioning;
+ dst->rd_cost = src->rd_cost;
+ const BLOCK_SIZE bsize = dst->block_size;
+ const BLOCK_SIZE subsize = get_partition_subsize(bsize, src->partitioning);
+ const int mi_row = src->mi_row;
+ const int mi_col = src->mi_col;
+
+ switch (src->partitioning) {
+ // PARTITION_NONE
+ case PARTITION_NONE:
+ if (dst->none) av1_free_pmc(dst->none, num_planes);
+ dst->none = NULL;
+ if (src->none) {
+ dst->none = av1_alloc_pmc(cm, mi_row, mi_col, bsize, dst,
+ PARTITION_NONE, 0, ss_x, ss_y, shared_bufs);
+ av1_copy_tree_context(dst->none, src->none);
+ }
+ break;
+ // PARTITION_SPLIT
+ case PARTITION_SPLIT:
+ if (is_partition_valid(bsize, PARTITION_SPLIT)) {
+ for (int i = 0; i < 4; ++i) {
+ if (dst->split[i]) {
+ av1_free_pc_tree_recursive(dst->split[i], num_planes, 0, 0);
+ dst->split[i] = NULL;
+ }
+ if (src->split[i]) {
+ const int x_idx = (i & 1) * (mi_size_wide[bsize] >> 1);
+ const int y_idx = (i >> 1) * (mi_size_high[bsize] >> 1);
+ dst->split[i] = av1_alloc_pc_tree_node(
+ mi_row + y_idx, mi_col + x_idx, subsize, dst, PARTITION_SPLIT,
+ i, i == 3, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->split[i], src->split[i], ss_x,
+ ss_y, shared_bufs, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_HORZ
+ case PARTITION_HORZ:
+ if (is_partition_valid(bsize, PARTITION_HORZ)) {
+ for (int i = 0; i < 2; ++i) {
+ if (dst->horizontal[i]) {
+ av1_free_pc_tree_recursive(dst->horizontal[i], num_planes, 0, 0);
+ dst->horizontal[i] = NULL;
+ }
+ if (src->horizontal[i]) {
+ const int this_mi_row = mi_row + i * (mi_size_high[bsize] >> 1);
+ dst->horizontal[i] =
+ av1_alloc_pc_tree_node(this_mi_row, mi_col, subsize, dst,
+ PARTITION_HORZ, i, i == 1, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->horizontal[i],
+ src->horizontal[i], ss_x, ss_y,
+ shared_bufs, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_VERT
+ case PARTITION_VERT:
+ if (is_partition_valid(bsize, PARTITION_VERT)) {
+ for (int i = 0; i < 2; ++i) {
+ if (dst->vertical[i]) {
+ av1_free_pc_tree_recursive(dst->vertical[i], num_planes, 0, 0);
+ dst->vertical[i] = NULL;
+ }
+ if (src->vertical[i]) {
+ const int this_mi_col = mi_col + i * (mi_size_wide[bsize] >> 1);
+ dst->vertical[i] =
+ av1_alloc_pc_tree_node(mi_row, this_mi_col, subsize, dst,
+ PARTITION_VERT, i, i == 1, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->vertical[i], src->vertical[i],
+ ss_x, ss_y, shared_bufs, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_HORZ_3
+ case PARTITION_HORZ_3:
+ if (is_partition_valid(bsize, PARTITION_HORZ_3)) {
+ const int mi_rows[3] = { mi_row, mi_row + (mi_size_high[bsize] >> 2),
+ mi_row + (mi_size_high[bsize] >> 2) * 3 };
+ const BLOCK_SIZE subsizes[3] = {
+ subsize, get_partition_subsize(bsize, PARTITION_HORZ), subsize
+ };
+
+ for (int i = 0; i < 3; ++i) {
+ if (dst->horizontal3[i]) {
+ av1_free_pc_tree_recursive(dst->horizontal3[i], num_planes, 0, 0);
+ dst->horizontal3[i] = NULL;
+ }
+ if (src->horizontal3[i]) {
+ dst->horizontal3[i] =
+ av1_alloc_pc_tree_node(mi_rows[i], mi_col, subsizes[i], dst,
+ PARTITION_HORZ_3, i, i == 2, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->horizontal3[i],
+ src->horizontal3[i], ss_x, ss_y,
+ shared_bufs, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_VERT_3
+ case PARTITION_VERT_3:
+ if (is_partition_valid(bsize, PARTITION_VERT_3)) {
+ const int mi_cols[3] = { mi_col, mi_col + (mi_size_wide[bsize] >> 2),
+ mi_col + (mi_size_wide[bsize] >> 2) * 3 };
+ const BLOCK_SIZE subsizes[3] = {
+ subsize, get_partition_subsize(bsize, PARTITION_VERT), subsize
+ };
+
+ for (int i = 0; i < 3; ++i) {
+ if (dst->vertical3[i]) {
+ av1_free_pc_tree_recursive(dst->vertical3[i], num_planes, 0, 0);
+ dst->vertical3[i] = NULL;
+ }
+ if (src->vertical3[i]) {
+ dst->vertical3[i] =
+ av1_alloc_pc_tree_node(mi_row, mi_cols[i], subsizes[i], dst,
+ PARTITION_VERT_3, i, i == 2, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->vertical3[i], src->vertical3[i],
+ ss_x, ss_y, shared_bufs, num_planes);
+ }
+ }
+ }
+ break;
+ default: assert(0 && "Not a valid partition."); break;
+ }
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
static AOM_INLINE int get_pc_tree_nodes(const int is_sb_size_128,
int stat_generation_stage) {
const int tree_nodes_inc = is_sb_size_128 ? 1024 : 0;
@@ -272,3 +477,68 @@
td->sms_tree = NULL;
}
}
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_setup_sms_bufs(AV1_COMMON *cm, ThreadData *td) {
+ CHECK_MEM_ERROR(cm, td->sms_bufs, aom_malloc(sizeof(*td->sms_bufs)));
+}
+
+void av1_free_sms_bufs(ThreadData *td) {
+ if (td->sms_bufs != NULL) {
+ aom_free(td->sms_bufs);
+ td->sms_bufs = NULL;
+ }
+}
+
+PC_TREE *counterpart_from_different_partition(PC_TREE *pc_tree,
+ PC_TREE *target);
+
+static PC_TREE *look_for_counterpart_helper(PC_TREE *cur, PC_TREE *target) {
+ if (cur == NULL || cur == target) return NULL;
+
+ BLOCK_SIZE current_bsize = cur->block_size;
+ BLOCK_SIZE target_bsize = target->block_size;
+ if (current_bsize == target_bsize) {
+ return cur;
+ } else {
+ if (mi_size_wide[current_bsize] >= mi_size_wide[target_bsize] &&
+ mi_size_high[current_bsize] >= mi_size_high[target_bsize]) {
+ return counterpart_from_different_partition(cur, target);
+ } else {
+ return NULL;
+ }
+ }
+}
+
+PC_TREE *counterpart_from_different_partition(PC_TREE *pc_tree,
+ PC_TREE *target) {
+ if (pc_tree == NULL || pc_tree == target) return NULL;
+
+ PC_TREE *result;
+ result = look_for_counterpart_helper(pc_tree->split[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->horizontal[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->vertical[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->horizontal3[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->vertical3[0], target);
+ if (result) return result;
+
+ return NULL;
+}
+
+PC_TREE *av1_look_for_counterpart_block(PC_TREE *pc_tree) {
+ if (!pc_tree) return 0;
+
+ // Find the highest possible common parent node
+ PC_TREE *current = pc_tree;
+ while (current->index == 0 && current->parent) {
+ current = current->parent;
+ }
+
+ // Search from the highest common ancester
+ return counterpart_from_different_partition(current, pc_tree);
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
diff --git a/av1/encoder/context_tree.h b/av1/encoder/context_tree.h
index f243233..f03414b 100644
--- a/av1/encoder/context_tree.h
+++ b/av1/encoder/context_tree.h
@@ -60,12 +60,21 @@
int rd_mode_is_ready; // Flag to indicate whether rd pick mode decision has
// been made.
+ CHROMA_REF_INFO chroma_ref_info;
+ struct PC_TREE *parent;
+ int index;
} PICK_MODE_CONTEXT;
typedef struct PC_TREE {
PARTITION_TYPE partitioning;
BLOCK_SIZE block_size;
PICK_MODE_CONTEXT *none;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ struct PC_TREE *horizontal[2];
+ struct PC_TREE *vertical[2];
+ struct PC_TREE *horizontal3[3];
+ struct PC_TREE *vertical3[3];
+#else
PICK_MODE_CONTEXT *horizontal[2];
PICK_MODE_CONTEXT *vertical[2];
PICK_MODE_CONTEXT *horizontala[3];
@@ -74,8 +83,15 @@
PICK_MODE_CONTEXT *verticalb[3];
PICK_MODE_CONTEXT *horizontal4[4];
PICK_MODE_CONTEXT *vertical4[4];
+#endif // CONFIG_EXT_RECUR_PARTITIONS
struct PC_TREE *split[4];
+ struct PC_TREE *parent;
+ int mi_row;
+ int mi_col;
int index;
+ int is_last_subblock;
+ CHROMA_REF_INFO chroma_ref_info;
+ RD_STATS rd_cost;
} PC_TREE;
typedef struct SIMPLE_MOTION_DATA_TREE {
@@ -91,15 +107,32 @@
int sms_rect_valid;
} SIMPLE_MOTION_DATA_TREE;
+#if CONFIG_EXT_RECUR_PARTITIONS
+PC_TREE *av1_look_for_counterpart_block(PC_TREE *pc_tree);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
void av1_setup_shared_coeff_buffer(AV1_COMMON *cm,
PC_TREE_SHARED_BUFFERS *shared_bufs);
void av1_free_shared_coeff_buffer(PC_TREE_SHARED_BUFFERS *shared_bufs);
-PC_TREE *av1_alloc_pc_tree_node(BLOCK_SIZE bsize);
+PC_TREE *av1_alloc_pc_tree_node(int mi_row, int mi_col, BLOCK_SIZE bsize,
+ PC_TREE *parent,
+ PARTITION_TYPE parent_partition, int index,
+ int is_last, int subsampling_x,
+ int subsampling_y);
void av1_free_pc_tree_recursive(PC_TREE *tree, int num_planes, int keep_best,
int keep_none);
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_copy_pc_tree_recursive(const AV1_COMMON *cm, PC_TREE *dst,
+ PC_TREE *src, int ss_x, int ss_y,
+ PC_TREE_SHARED_BUFFERS *shared_bufs,
+ int num_planes);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
-PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, BLOCK_SIZE bsize,
+PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, PC_TREE *parent,
+ PARTITION_TYPE parent_partition, int index,
+ int subsampling_x, int subsampling_y,
PC_TREE_SHARED_BUFFERS *shared_bufs);
void av1_free_pmc(PICK_MODE_CONTEXT *ctx, int num_planes);
void av1_copy_tree_context(PICK_MODE_CONTEXT *dst_ctx,
@@ -107,6 +140,10 @@
void av1_setup_sms_tree(struct AV1_COMP *const cpi, struct ThreadData *td);
void av1_free_sms_tree(struct ThreadData *td);
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_setup_sms_bufs(struct AV1Common *cm, struct ThreadData *td);
+void av1_free_sms_bufs(struct ThreadData *td);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#ifdef __cplusplus
} // extern "C"
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index 8adec1e..3c05fb6 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -881,7 +881,7 @@
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
- av1_setup_src_planes(x, src, 0, 0, num_planes, cm->seq_params.sb_size);
+ av1_setup_src_planes(x, src, 0, 0, num_planes, NULL);
av1_setup_block_planes(xd, cm->seq_params.subsampling_x,
cm->seq_params.subsampling_y, num_planes);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 0592a0b..86b7fcc 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -198,7 +198,7 @@
void av1_setup_src_planes(MACROBLOCK *x, const YV12_BUFFER_CONFIG *src,
int mi_row, int mi_col, const int num_planes,
- BLOCK_SIZE bsize) {
+ const CHROMA_REF_INFO *chr_ref_info) {
// Set current frame pointer.
x->e_mbd.cur_buf = src;
@@ -206,10 +206,10 @@
// the static analysis warnings.
for (int i = 0; i < AOMMIN(num_planes, MAX_MB_PLANE); i++) {
const int is_uv = i > 0;
- setup_pred_plane(
- &x->plane[i].src, bsize, src->buffers[i], src->crop_widths[is_uv],
- src->crop_heights[is_uv], src->strides[is_uv], mi_row, mi_col, NULL,
- x->e_mbd.plane[i].subsampling_x, x->e_mbd.plane[i].subsampling_y);
+ setup_pred_plane(&x->plane[i].src, src->buffers[i], src->crop_widths[is_uv],
+ src->crop_heights[is_uv], src->strides[is_uv], mi_row,
+ mi_col, NULL, x->e_mbd.plane[i].subsampling_x,
+ x->e_mbd.plane[i].subsampling_y, chr_ref_info);
}
}
@@ -240,7 +240,7 @@
const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
// Delta-q modulation based on variance
- av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, sb_size);
+ av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, NULL);
int current_qindex = cm->quant_params.base_qindex;
if (cpi->oxcf.q_cfg.deltaq_mode == DELTA_Q_PERCEPTUAL) {
@@ -287,7 +287,7 @@
assert(current_qindex > 0);
x->delta_qindex = current_qindex - cm->quant_params.base_qindex;
- av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size);
+ av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size, NULL);
xd->mi[0]->current_qindex = current_qindex;
av1_init_plane_quantizers(cpi, x, xd->mi[0]->segment_id);
@@ -483,6 +483,16 @@
reset_hash_records(&x->txfm_search_info, cpi->sf.tx_sf.use_inter_txb_hash);
av1_zero(x->picked_ref_frames_mask);
av1_invalid_rd_stats(rd_cost);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_init_sms_data_bufs(x->sms_bufs);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_SDP
+ if (x->e_mbd.tree_type == CHROMA_PART) {
+ assert(is_bsize_square(x->sb_enc.min_partition_size));
+ x->sb_enc.min_partition_size =
+ AOMMAX(x->sb_enc.min_partition_size, BLOCK_8X8);
+ }
+#endif // CONFIG_SDP
}
/*!\brief Encode a superblock (RD-search-based)
@@ -507,6 +517,11 @@
int64_t dummy_dist;
RD_STATS dummy_rdc;
SIMPLE_MOTION_DATA_TREE *const sms_root = td->sms_root;
+ const int ss_x = cm->seq_params.subsampling_x;
+ const int ss_y = cm->seq_params.subsampling_y;
+ (void)tile_info;
+ (void)num_planes;
+ (void)mi;
#if CONFIG_SDP
const int total_loop_num =
@@ -514,58 +529,110 @@
cm->seq_params.enable_sdp)
? 2
: 1;
+#endif // CONFIG_SDP
+#if CONFIG_SDP || CONFIG_EXT_RECUR_PARTITIONS
MACROBLOCKD *const xd = &x->e_mbd;
-#endif
+#endif // CONFIG_SDP || CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+ x->sms_bufs = td->sms_bufs;
+ x->reuse_inter_mode_cache_type = cpi->sf.inter_sf.reuse_erp_mode_flag;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row, mi_col,
1);
// Encode the superblock
if (sf->part_sf.partition_search_type == FIXED_PARTITION || seg_skip) {
// partition search by adjusting a fixed-size partition
- av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size);
+ av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size, NULL);
const BLOCK_SIZE bsize =
seg_skip ? sb_size : sf->part_sf.fixed_partition_size;
av1_set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize);
#if CONFIG_SDP
for (int loop_idx = 0; loop_idx < total_loop_num; loop_idx++) {
+ const BLOCK_SIZE min_partition_size = x->sb_enc.min_partition_size;
xd->tree_type =
(total_loop_num == 1 ? SHARED_PART
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row,
mi_col, 1);
#endif
- PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size);
+#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_SDP
+ av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
+ av1_build_partition_tree_fixed_partitioning(
+ cm, mi_row, mi_col, bsize,
+ xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)]);
+#else
+ av1_reset_ptree_in_sbi(xd->sbi);
+ av1_build_partition_tree_fixed_partitioning(cm, mi_row, mi_col, bsize,
+ xd->sbi->ptree_root);
+#endif // CONFIG_SDP
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ PC_TREE *const pc_root = av1_alloc_pc_tree_node(
+ mi_row, mi_col, sb_size, NULL, PARTITION_NONE, 0, 1, ss_x, ss_y);
av1_rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, sb_size,
- &dummy_rate, &dummy_dist, 1, pc_root);
+ &dummy_rate, &dummy_dist, 1,
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#elif CONFIG_EXT_RECUR_PARTITIONS
+ xd->sbi->ptree_root,
+#else // !CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ pc_root);
av1_free_pc_tree_recursive(pc_root, num_planes, 0, 0);
#if CONFIG_SDP
+ x->sb_enc.min_partition_size = min_partition_size;
}
xd->tree_type = SHARED_PART;
#endif
} else if (cpi->partition_search_skippable_frame) {
// partition search by adjusting a fixed-size partition for which the size
// is determined by the source variance
- av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size);
+ av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size, NULL);
const BLOCK_SIZE bsize =
get_rd_var_based_fixed_partition(cpi, x, mi_row, mi_col);
av1_set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize);
#if CONFIG_SDP
for (int loop_idx = 0; loop_idx < total_loop_num; loop_idx++) {
+ const BLOCK_SIZE min_partition_size = x->sb_enc.min_partition_size;
xd->tree_type =
(total_loop_num == 1 ? SHARED_PART
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row,
mi_col, 1);
#endif
- PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size);
+ PC_TREE *const pc_root = av1_alloc_pc_tree_node(
+ mi_row, mi_col, sb_size, NULL, PARTITION_NONE, 0, 1, ss_x, ss_y);
+#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_SDP
+ av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
+ av1_build_partition_tree_fixed_partitioning(
+ cm, mi_row, mi_col, bsize,
+ xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)]);
+#else
+ av1_reset_ptree_in_sbi(xd->sbi);
+ av1_build_partition_tree_fixed_partitioning(cm, mi_row, mi_col, bsize,
+ xd->sbi->ptree_root);
+#endif // CONFIG_SDP
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, sb_size,
- &dummy_rate, &dummy_dist, 1, pc_root);
+ &dummy_rate, &dummy_dist, 1,
+#if CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#elif CONFIG_EXT_RECUR_PARTITIONS
+ xd->sbi->ptree_root,
+#else // !CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_EXT_RECUR_PARTITIONS && CONFIG_SDP
+ pc_root);
av1_free_pc_tree_recursive(pc_root, num_planes, 0, 0);
#if CONFIG_SDP
+ x->sb_enc.min_partition_size = min_partition_size;
}
xd->tree_type = SHARED_PART;
-#endif
+#endif // CONFIG_SDP
} else {
// The most exhaustive recursive partition search
SuperBlockEnc *sb_enc = &x->sb_enc;
@@ -592,17 +659,24 @@
if (num_passes == 1) {
#if CONFIG_SDP
for (int loop_idx = 0; loop_idx < total_loop_num; loop_idx++) {
+ const BLOCK_SIZE min_partition_size = sb_enc->min_partition_size;
xd->tree_type =
(total_loop_num == 1 ? SHARED_PART
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row,
mi_col, 1);
#endif
- PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size);
- av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size,
- &dummy_rdc, dummy_rdc, pc_root, sms_root, NULL,
- SB_SINGLE_PASS, NULL);
+ PC_TREE *const pc_root = av1_alloc_pc_tree_node(
+ mi_row, mi_col, sb_size, NULL, PARTITION_NONE, 0, 1, ss_x, ss_y);
+ av1_rd_pick_partition(
+ cpi, td, tile_data, tp, mi_row, mi_col, sb_size, &dummy_rdc,
+ dummy_rdc, pc_root,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ xd->tree_type == CHROMA_PART ? xd->sbi->ptree_root[0] : NULL, NULL,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ sms_root, NULL, SB_SINGLE_PASS, NULL);
#if CONFIG_SDP
+ sb_enc->min_partition_size = min_partition_size;
}
xd->tree_type = SHARED_PART;
#endif
@@ -612,17 +686,24 @@
av1_backup_sb_state(&sb_fp_stats, cpi, td, tile_data, mi_row, mi_col);
#if CONFIG_SDP
for (int loop_idx = 0; loop_idx < total_loop_num; loop_idx++) {
+ const BLOCK_SIZE min_partition_size = sb_enc->min_partition_size;
xd->tree_type =
(total_loop_num == 1 ? SHARED_PART
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row,
mi_col, 1);
#endif
- PC_TREE *const pc_root_p0 = av1_alloc_pc_tree_node(sb_size);
- av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size,
- &dummy_rdc, dummy_rdc, pc_root_p0, sms_root, NULL,
- SB_DRY_PASS, NULL);
+ PC_TREE *const pc_root_p0 = av1_alloc_pc_tree_node(
+ mi_row, mi_col, sb_size, NULL, PARTITION_NONE, 0, 1, ss_x, ss_y);
+ av1_rd_pick_partition(
+ cpi, td, tile_data, tp, mi_row, mi_col, sb_size, &dummy_rdc,
+ dummy_rdc, pc_root_p0,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ xd->tree_type == CHROMA_PART ? xd->sbi->ptree_root[0] : NULL, NULL,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ sms_root, NULL, SB_DRY_PASS, NULL);
#if CONFIG_SDP
+ sb_enc->min_partition_size = min_partition_size;
}
xd->tree_type = SHARED_PART;
#endif
@@ -636,17 +717,25 @@
av1_restore_sb_state(&sb_fp_stats, cpi, td, tile_data, mi_row, mi_col);
#if CONFIG_SDP
for (int loop_idx = 0; loop_idx < total_loop_num; loop_idx++) {
+ const BLOCK_SIZE min_partition_size = sb_enc->min_partition_size;
xd->tree_type =
(total_loop_num == 1 ? SHARED_PART
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row,
mi_col, 1);
#endif
- PC_TREE *const pc_root_p1 = av1_alloc_pc_tree_node(sb_size);
- av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size,
- &dummy_rdc, dummy_rdc, pc_root_p1, sms_root, NULL,
- SB_WET_PASS, NULL);
+
+ PC_TREE *const pc_root_p1 = av1_alloc_pc_tree_node(
+ mi_row, mi_col, sb_size, NULL, PARTITION_NONE, 0, 1, ss_x, ss_y);
+ av1_rd_pick_partition(
+ cpi, td, tile_data, tp, mi_row, mi_col, sb_size, &dummy_rdc,
+ dummy_rdc, pc_root_p1,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ xd->tree_type == CHROMA_PART ? xd->sbi->ptree_root[0] : NULL, NULL,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ sms_root, NULL, SB_WET_PASS, NULL);
#if CONFIG_SDP
+ sb_enc->min_partition_size = min_partition_size;
}
xd->tree_type = SHARED_PART;
#endif
@@ -713,7 +802,9 @@
for (int mi_col = tile_info->mi_col_start, sb_col_in_tile = 0;
mi_col < tile_info->mi_col_end; mi_col += mib_size, sb_col_in_tile++) {
(*(enc_row_mt->sync_read_ptr))(row_mt_sync, sb_row, sb_col_in_tile);
+ av1_reset_is_mi_coded_map(xd, cm->seq_params.mib_size);
+ av1_set_sb_info(cm, xd, mi_row, mi_col);
if (tile_data->allow_update_cdf && row_mt_enabled &&
(tile_info->mi_row_start != mi_row)) {
if ((tile_info->mi_col_start == mi_col)) {
@@ -778,8 +869,7 @@
MACROBLOCKD *const xd = &x->e_mbd;
// Copy data over into macro block data structures.
- av1_setup_src_planes(x, cpi->source, 0, 0, num_planes,
- cm->seq_params.sb_size);
+ av1_setup_src_planes(x, cpi->source, 0, 0, num_planes, NULL);
av1_setup_block_planes(xd, cm->seq_params.subsampling_x,
cm->seq_params.subsampling_y, num_planes);
diff --git a/av1/encoder/encodeframe.h b/av1/encoder/encodeframe.h
index 36b38d5..f6f97b4 100644
--- a/av1/encoder/encodeframe.h
+++ b/av1/encoder/encodeframe.h
@@ -33,7 +33,8 @@
void av1_setup_src_planes(struct macroblock *x,
const struct yv12_buffer_config *src, int mi_row,
- int mi_col, const int num_planes, BLOCK_SIZE bsize);
+ int mi_col, const int num_planes,
+ const CHROMA_REF_INFO *chr_ref_info);
void av1_encode_frame(struct AV1_COMP *cpi);
@@ -43,6 +44,9 @@
int tile_col);
void av1_encode_sb_row(struct AV1_COMP *cpi, struct ThreadData *td,
int tile_row, int tile_col, int mi_row);
+void av1_enc_set_offsets(const struct AV1_COMP *cpi, const TileInfo *const tile,
+ struct macroblock *const x, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, CHROMA_REF_INFO *chr_ref_info);
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index eddfe72..6ef3968 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -682,9 +682,9 @@
}
}
-void av1_restore_context(MACROBLOCK *x, const RD_SEARCH_MACROBLOCK_CONTEXT *ctx,
- int mi_row, int mi_col, BLOCK_SIZE bsize,
- const int num_planes) {
+void av1_restore_context(const AV1_COMMON *cm, MACROBLOCK *x,
+ const RD_SEARCH_MACROBLOCK_CONTEXT *ctx, int mi_row,
+ int mi_col, BLOCK_SIZE bsize, const int num_planes) {
MACROBLOCKD *xd = &x->e_mbd;
int p;
const int num_4x4_blocks_wide = mi_size_wide[bsize];
@@ -727,6 +727,9 @@
sizeof(*xd->above_txfm_context) * mi_width);
memcpy(xd->left_txfm_context, ctx->tl,
sizeof(*xd->left_txfm_context) * mi_height);
+
+ av1_mark_block_as_not_coded(xd, mi_row, mi_col, bsize,
+ cm->seq_params.sb_size);
}
void av1_save_context(const MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *ctx,
@@ -1148,13 +1151,16 @@
void av1_update_picked_ref_frames_mask(MACROBLOCK *const x, int ref_type,
BLOCK_SIZE bsize, int mib_size,
int mi_row, int mi_col) {
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(mi_size_wide[bsize] == mi_size_high[bsize]);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
const int sb_size_mask = mib_size - 1;
const int mi_row_in_sb = mi_row & sb_size_mask;
const int mi_col_in_sb = mi_col & sb_size_mask;
- const int mi_size = mi_size_wide[bsize];
- for (int i = mi_row_in_sb; i < mi_row_in_sb + mi_size; ++i) {
- for (int j = mi_col_in_sb; j < mi_col_in_sb + mi_size; ++j) {
+ const int mi_size_h = mi_size_high[bsize];
+ const int mi_size_w = mi_size_wide[bsize];
+ for (int i = mi_row_in_sb; i < mi_row_in_sb + mi_size_h; ++i) {
+ for (int j = mi_col_in_sb; j < mi_col_in_sb + mi_size_w; ++j) {
x->picked_ref_frames_mask[i * 32 + j] |= 1 << ref_type;
}
}
@@ -1342,7 +1348,13 @@
CDF_SIZE(10));
}
}
-#endif
+#endif // CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS
+ for (int i = 0; i < PARTITION_CONTEXTS_REC; ++i) {
+ AVERAGE_CDF(ctx_left->partition_rec_cdf[i], ctx_tr->partition_rec_cdf[i],
+ 4);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
AVERAGE_CDF(ctx_left->switchable_interp_cdf, ctx_tr->switchable_interp_cdf,
SWITCHABLE_FILTERS);
AVERAGE_CDF(ctx_left->kf_y_cdf, ctx_tr->kf_y_cdf, INTRA_MODES);
@@ -1477,7 +1489,7 @@
const int num_planes = av1_num_planes(cm);
const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
- av1_restore_context(x, &sb_fp_stats->x_ctx, mi_row, mi_col, sb_size,
+ av1_restore_context(cm, x, &sb_fp_stats->x_ctx, mi_row, mi_col, sb_size,
num_planes);
cpi->td.rd_counts = sb_fp_stats->rd_count;
diff --git a/av1/encoder/encodeframe_utils.h b/av1/encoder/encodeframe_utils.h
index 5fde760..b39fe48 100644
--- a/av1/encoder/encodeframe_utils.h
+++ b/av1/encoder/encodeframe_utils.h
@@ -64,9 +64,13 @@
// This structure contains block size related
// variables for use in rd_pick_partition().
-typedef struct {
+typedef struct PartitionBlkParams {
// Half of block width to determine block edge.
int mi_step;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int mi_step_h;
+ int mi_step_w;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Block row and column indices.
int mi_row;
@@ -79,11 +83,18 @@
// Block width of current partition block.
int width;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // Minimum partition size allowed.
+ BLOCK_SIZE min_partition_size;
+#else
// Block width of minimum partition size allowed.
int min_partition_size_1d;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Flag to indicate if partition is 8x8 or higher size.
int bsize_at_least_8x8;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Indicates edge blocks in frame.
int has_rows;
@@ -100,7 +111,7 @@
} PartitionBlkParams;
// Structure holding state variables for partition search.
-typedef struct {
+typedef struct PartitionSearchState {
// Intra partitioning related info.
PartitionSearchInfo *intra_part_info;
@@ -118,6 +129,9 @@
// Array holding partition type cost.
int tmp_partition_cost[PARTITION_TYPES];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int partition_cost_table[EXT_PARTITION_TYPES];
+#endif
// Pointer to partition cost buffer
int *partition_cost;
@@ -130,6 +144,10 @@
// rect_part_rd[1][i] is the RD cost of ith partition index of PARTITION_VERT.
int64_t rect_part_rd[NUM_RECT_PARTS][SUB_PARTITIONS_RECT];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // New Simple Motion Result for PARTITION_NONE
+ SMSPartitionStats none_data;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Flags indicating if the corresponding partition was winner or not.
// Used to bypass similar blocks during AB partition evaluation.
int is_split_ctx_is_ready[2];
@@ -140,8 +158,11 @@
int partition_none_allowed;
int partition_rect_allowed[NUM_RECT_PARTS];
int do_rectangular_split;
+#if !CONFIG_EXT_RECUR_PARTITIONS
int do_square_split;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
int prune_rect_part[NUM_RECT_PARTS];
+ int is_block_splittable;
// Chroma subsampling in x and y directions.
int ss_x;
@@ -294,9 +315,9 @@
const MB_MODE_INFO *above_mi,
const MB_MODE_INFO *left_mi, const int intraonly);
-void av1_restore_context(MACROBLOCK *x, const RD_SEARCH_MACROBLOCK_CONTEXT *ctx,
- int mi_row, int mi_col, BLOCK_SIZE bsize,
- const int num_planes);
+void av1_restore_context(const AV1_COMMON *cm, MACROBLOCK *x,
+ const RD_SEARCH_MACROBLOCK_CONTEXT *ctx, int mi_row,
+ int mi_col, BLOCK_SIZE bsize, const int num_planes);
void av1_save_context(const MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *ctx,
int mi_row, int mi_col, BLOCK_SIZE bsize,
@@ -338,6 +359,12 @@
const TileInfo *const tile_info, const int mi_row,
const int mi_col);
+#ifndef NDEBUG
+static AOM_INLINE int is_bsize_square(BLOCK_SIZE bsize) {
+ return block_size_wide[bsize] == block_size_high[bsize];
+}
+#endif // NDEBUG
+
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index 4d67ab4..deae150 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -563,15 +563,24 @@
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
-#if CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
+ const TX_SIZE plane_tx_size =
+ plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
+ pd->subsampling_y)
+ : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
+ blk_col)];
+#elif CONFIG_SDP
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(mbmi->sb_type[xd->tree_type == CHROMA_PART],
pd->subsampling_x, pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#else
+ const BLOCK_SIZE bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base : mbmi->sb_type;
const TX_SIZE plane_tx_size =
- plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x,
+ plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
@@ -728,9 +737,8 @@
encode_block_pass1, &args);
}
-void av1_encode_sb(const struct AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
+void av1_encode_sb(const struct AV1_COMP *cpi, MACROBLOCK *x,
RUN_TYPE dry_run) {
- assert(bsize < BLOCK_SIZES_ALL);
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi = xd->mi[0];
#if CONFIG_SDP
@@ -765,8 +773,24 @@
const int subsampling_x = pd->subsampling_x;
const int subsampling_y = pd->subsampling_y;
if (plane && !xd->is_chroma_ref) break;
+
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsize, subsampling_x, subsampling_y);
+ get_mb_plane_block_size(xd, mbmi, plane, subsampling_x, subsampling_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base
+ : mbmi->sb_type[xd->tree_type == CHROMA_PART];
+ assert(plane_bsize ==
+ get_plane_block_size(bsize_base, subsampling_x, subsampling_y));
+ (void)bsize_base;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#else
+ const BLOCK_SIZE bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base : mbmi->sb_type;
+ const BLOCK_SIZE plane_bsize =
+ get_plane_block_size(bsize_base, subsampling_x, subsampling_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
assert(plane_bsize < BLOCK_SIZES_ALL);
const int mi_width = mi_size_wide[plane_bsize];
const int mi_height = mi_size_high[plane_bsize];
@@ -954,14 +978,13 @@
#else
if (plane == AOM_PLANE_Y && xd->cfl.store_y) {
#endif
- cfl_store_tx(xd, blk_row, blk_col, tx_size, plane_bsize);
+ cfl_store_tx(xd, blk_row, blk_col, tx_size);
}
}
void av1_encode_intra_block_plane(const struct AV1_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, int plane, RUN_TYPE dry_run,
TRELLIS_OPT_TYPE enable_optimize_b) {
- assert(bsize < BLOCK_SIZES_ALL);
const MACROBLOCKD *const xd = &x->e_mbd;
if (plane && !xd->is_chroma_ref) return;
@@ -971,21 +994,25 @@
ENTROPY_CONTEXT ta[MAX_MIB_SIZE] = { 0 };
ENTROPY_CONTEXT tl[MAX_MIB_SIZE] = { 0 };
#if CONFIG_SDP
- struct encode_b_args arg = {
- cpi,
- x,
- NULL,
- &(xd->mi[0]->skip_txfm[xd->tree_type == CHROMA_PART]),
+ int8_t *skip_txfm = &(xd->mi[0]->skip_txfm[xd->tree_type == CHROMA_PART]);
#else
- struct encode_b_args arg = {
- cpi, x, NULL, &(xd->mi[0]->skip_txfm),
-#endif
- ta,
- tl,
- dry_run,
- enable_optimize_b
- };
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
+ int8_t *skip_txfm = &(xd->mi[0]->skip_txfm);
+#endif // CONFIG_SDP
+
+ struct encode_b_args arg = { cpi, x, NULL, skip_txfm,
+ ta, tl, dry_run, enable_optimize_b };
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, xd->mi[0], plane, ss_x, ss_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize == get_plane_block_size(bsize, ss_x, ss_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+ (void)bsize;
+#else
+ const BLOCK_SIZE bsize_base =
+ plane ? xd->mi[0]->chroma_ref_info.bsize_base : bsize;
+ const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize_base, ss_x, ss_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
if (enable_optimize_b) {
av1_get_entropy_contexts(plane_bsize, pd, ta, tl);
}
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h
index 91b47cc..88274b7 100644
--- a/av1/encoder/encodemb.h
+++ b/av1/encoder/encodemb.h
@@ -63,8 +63,7 @@
TRELLIS_OPT_TYPE enable_optimize_b;
};
-void av1_encode_sb(const struct AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
- RUN_TYPE dry_run);
+void av1_encode_sb(const struct AV1_COMP *cpi, MACROBLOCK *x, RUN_TYPE dry_run);
void av1_foreach_transformed_block_in_plane(
const MACROBLOCKD *const xd, BLOCK_SIZE plane_bsize, int plane,
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 43ea020..24f4cde 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -1447,6 +1447,9 @@
thread_data->td->firstpass_ctx = NULL;
av1_free_shared_coeff_buffer(&thread_data->td->shared_coeff_buf);
av1_free_sms_tree(thread_data->td);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_free_sms_bufs(thread_data->td);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
aom_free(thread_data->td);
}
}
@@ -1965,6 +1968,9 @@
av1_free_context_buffers(cm);
av1_free_shared_coeff_buffer(&cpi->td.shared_coeff_buf);
av1_free_sms_tree(&cpi->td);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_free_sms_bufs(&cpi->td);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_free_pmc(cpi->td.firstpass_ctx, av1_num_planes(cm));
cpi->td.firstpass_ctx = NULL;
alloc_compressor_data(cpi);
@@ -2068,8 +2074,8 @@
const int use_ccso = !cm->features.coded_lossless && !cm->tiles.large_scale &&
cm->seq_params.enable_ccso;
const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, &cm->cur_frame->buf,
- 0, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, 0, 0, 0, num_planes,
+ NULL);
const int ccso_stride = xd->plane[0].dst.width;
const int ccso_stride_ext = xd->plane[0].dst.width + (CCSO_PADDING_SIZE << 1);
for (int pli = 0; pli < 2; pli++) {
@@ -2135,8 +2141,8 @@
#if CONFIG_CCSO
if (use_ccso) {
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, &cm->cur_frame->buf,
- 0, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, 0, 0, 0, num_planes,
+ NULL);
// Reading original and reconstructed chroma samples as input
for (int pli = 1; pli < 3; pli++) {
const int pic_height = xd->plane[pli].dst.height;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 71a1158..3cc21be 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -1157,6 +1157,9 @@
[PALETTE_COLOR_INDEX_CONTEXTS]
[PALETTE_COLORS];
unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ unsigned int partition_rec[PARTITION_CONTEXTS_REC][PARTITION_TYPES_REC];
+#endif // CONFIG_EXT_RECUR_PARTITIONS
unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[EOB_COEF_CONTEXTS][2];
@@ -1456,6 +1459,9 @@
PC_TREE_SHARED_BUFFERS shared_coeff_buf;
SIMPLE_MOTION_DATA_TREE *sms_tree;
SIMPLE_MOTION_DATA_TREE *sms_root;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ struct SimpleMotionDataBufs *sms_bufs;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
InterModesInfo *inter_modes_info;
uint32_t *hash_value_buffer[2][2];
OBMCBuffer obmc_buffer;
diff --git a/av1/encoder/encoder_alloc.h b/av1/encoder/encoder_alloc.h
index b4291d2..e458443 100644
--- a/av1/encoder/encoder_alloc.h
+++ b/av1/encoder/encoder_alloc.h
@@ -74,8 +74,14 @@
av1_setup_shared_coeff_buffer(&cpi->common, &cpi->td.shared_coeff_buf);
av1_setup_sms_tree(cpi, &cpi->td);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_setup_sms_bufs(&cpi->common, &cpi->td);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
cpi->td.firstpass_ctx =
- av1_alloc_pmc(cm, BLOCK_16X16, &cpi->td.shared_coeff_buf);
+ av1_alloc_pmc(cm, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
+ cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
+ &cpi->td.shared_coeff_buf);
}
static AOM_INLINE void realloc_segmentation_maps(AV1_COMP *cpi) {
@@ -295,6 +301,9 @@
av1_free_shared_coeff_buffer(&cpi->td.shared_coeff_buf);
av1_free_sms_tree(&cpi->td);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_free_sms_bufs(&cpi->td);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
aom_free(cpi->td.mb.palette_buffer);
release_compound_type_rd_buffers(&cpi->td.mb.comp_rd_buffer);
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 3bffabd..e506d2d 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -329,14 +329,8 @@
int block, TX_SIZE tx_size) {
MACROBLOCKD *xd = &x->e_mbd;
const CB_COEFF_BUFFER *cb_coef_buff = x->cb_coef_buff;
-#if CONFIG_SDP
const int txb_offset =
- x->mbmi_ext_frame->cb_offset[plane > 0 && xd->tree_type == CHROMA_PART] /
- (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
-#else
- const int txb_offset =
- x->mbmi_ext_frame->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
-#endif
+ x->mbmi_ext_frame->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
const uint16_t *eob_txb = cb_coef_buff->eobs[plane] + txb_offset;
const uint16_t eob = eob_txb[block];
const uint8_t *entropy_ctx = cb_coef_buff->entropy_ctx[plane] + txb_offset;
@@ -430,14 +424,8 @@
const int height = get_txb_high(tx_size);
uint8_t levels_buf[TX_PAD_2D];
uint8_t *const levels = set_levels(levels_buf, width);
-#if CONFIG_SDP
const tran_low_t *tcoeff_txb =
- cb_coef_buff->tcoeff[plane] +
- x->mbmi_ext_frame->cb_offset[plane > 0 && xd->tree_type == CHROMA_PART];
-#else
- const tran_low_t *tcoeff_txb =
- cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset;
-#endif
+ cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset[plane];
const tran_low_t *tcoeff = tcoeff_txb + BLOCK_OFFSET(block);
av1_txb_init_levels(tcoeff, width, height, levels);
const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type);
@@ -1594,15 +1582,8 @@
}
CB_COEFF_BUFFER *cb_coef_buff = x->cb_coef_buff;
-#if CONFIG_SDP
const int txb_offset =
- x->mbmi_ext_frame
- ->cb_offset[(plane > 0 && xd->tree_type == CHROMA_PART) ? 1 : 0] /
- (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
-#else
- const int txb_offset =
- x->mbmi_ext_frame->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
-#endif
+ x->mbmi_ext_frame->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
uint16_t *eob_txb = cb_coef_buff->eobs[plane] + txb_offset;
uint8_t *const entropy_ctx = cb_coef_buff->entropy_ctx[plane] + txb_offset;
entropy_ctx[block] = txb_ctx.txb_skip_ctx;
@@ -1615,14 +1596,8 @@
}
const int segment_id = mbmi->segment_id;
const int seg_eob = av1_get_tx_eob(&cpi->common.seg, segment_id, tx_size);
-#if CONFIG_SDP
tran_low_t *tcoeff_txb =
- cb_coef_buff->tcoeff[plane] +
- x->mbmi_ext_frame->cb_offset[plane > 0 && xd->tree_type == CHROMA_PART];
-#else
- tran_low_t *tcoeff_txb =
- cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset;
-#endif
+ cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset[plane];
tcoeff = tcoeff_txb + block_offset;
memcpy(tcoeff, qcoeff, sizeof(*tcoeff) * seg_eob);
@@ -1667,6 +1642,7 @@
if (allow_update_cdf) {
if (c == eob - 1) {
assert(coeff_ctx < 4);
+ assert(level > 0);
update_cdf(
ec_ctx->coeff_base_eob_cdf[txsize_ctx][plane_type][coeff_ctx],
AOMMIN(level, 3) - 1, 3);
@@ -1677,6 +1653,7 @@
}
if (c == eob - 1) {
assert(coeff_ctx < 4);
+ assert(level > 0);
#if CONFIG_ENTROPY_STATS
++td->counts->coeff_base_eob_multi[cdf_idx][txsize_ctx][plane_type]
[coeff_ctx][AOMMIN(level, 3) - 1];
@@ -1743,7 +1720,10 @@
if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
#else
if (mbmi->skip_txfm) {
-#endif
+#endif // CONFIG_SDP
+#if CONFIG_SDP
+ assert(bsize == mbmi->sb_type[av1_get_sdp_idx(xd->tree_type)]);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_reset_entropy_context(xd, bsize, num_planes);
return;
}
@@ -1758,7 +1738,15 @@
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize == get_plane_block_size(bsize, ss_x, ss_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#else
const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
av1_foreach_transformed_block_in_plane(
xd, plane_bsize, plane, av1_update_and_record_txb_context, &arg);
}
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 0f754b7..0e48e7e 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -550,6 +550,9 @@
if (i > 0) {
// Set up sms_tree.
av1_setup_sms_tree(cpi, thread_data->td);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_setup_sms_bufs(cm, thread_data->td);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
alloc_obmc_buffers(&thread_data->td->obmc_buffer, cm);
@@ -666,8 +669,10 @@
if (i > 0) {
// Set up firstpass PICK_MODE_CONTEXT.
- thread_data->td->firstpass_ctx =
- av1_alloc_pmc(cm, BLOCK_16X16, &thread_data->td->shared_coeff_buf);
+ thread_data->td->firstpass_ctx = av1_alloc_pmc(
+ cm, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
+ cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
+ &thread_data->td->shared_coeff_buf);
// Create threads
if (!winterface->reset(worker))
diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c
index 62e520b..f91c0c4 100644
--- a/av1/encoder/firstpass.c
+++ b/av1/encoder/firstpass.c
@@ -365,8 +365,8 @@
xd->mi[0]->ref_frame[0] = INTRA_FRAME;
set_mi_row_col(xd, tile, mb_row * mb_scale, mi_size_high[bsize],
mb_col * mb_scale, mi_size_wide[bsize], mi_params->mi_rows,
- mi_params->mi_cols);
- set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize], num_planes);
+ mi_params->mi_cols, NULL);
+ set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize], num_planes, NULL);
xd->mi[0]->segment_id = 0;
xd->lossless[xd->mi[0]->segment_id] = (qindex == 0);
xd->mi[0]->mode = DC_PRED;
@@ -952,6 +952,8 @@
AV1EncRowMultiThreadInfo *const enc_row_mt = &mt_info->enc_row_mt;
AV1EncRowMultiThreadSync *const row_mt_sync = &tile_data->row_mt_sync;
+ xd->tile = *tile;
+
const YV12_BUFFER_CONFIG *const last_frame =
get_ref_frame_yv12_buf(cm, LAST_FRAME);
const YV12_BUFFER_CONFIG *golden_frame =
@@ -1015,7 +1017,7 @@
cpi->oxcf.border_in_pixels);
av1_setup_src_planes(x, cpi->source, mb_row << FP_MIB_SIZE_LOG2,
- tile->mi_col_start, num_planes, fp_block_size);
+ tile->mi_col_start, num_planes, NULL);
// Fix - zero the 16x16 block first. This ensures correct this_intra_error for
// block sizes smaller than 16x16.
@@ -1133,12 +1135,11 @@
av1_setup_block_planes(xd, seq_params->subsampling_x,
seq_params->subsampling_y, num_planes);
- av1_setup_src_planes(x, cpi->source, 0, 0, num_planes, fp_block_size);
- av1_setup_dst_planes(xd->plane, seq_params->sb_size, this_frame, 0, 0, 0,
- num_planes);
+ av1_setup_src_planes(x, cpi->source, 0, 0, num_planes, NULL);
+ av1_setup_dst_planes(xd->plane, this_frame, 0, 0, 0, num_planes, NULL);
if (!frame_is_intra_only(cm)) {
- av1_setup_pre_planes(xd, 0, last_frame, 0, 0, NULL, num_planes);
+ av1_setup_pre_planes(xd, 0, last_frame, 0, 0, NULL, num_planes, NULL);
}
set_mi_offsets(mi_params, xd, 0, 0);
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c
index b40def7..9a48c09 100644
--- a/av1/encoder/intra_mode_search.c
+++ b/av1/encoder/intra_mode_search.c
@@ -238,7 +238,7 @@
int *best_angle_delta, int64_t *best_rd) {
MB_MODE_INFO *mbmi = x->e_mbd.mi[0];
#if CONFIG_SDP
- assert(!is_inter_block(mbmi, x->e_mbd.tree_type));
+ assert(!is_inter_block(mbmi, cpi->td.mb.e_mbd.tree_type));
#else
assert(!is_inter_block(mbmi));
#endif
@@ -246,8 +246,7 @@
int64_t this_rd;
RD_STATS tokenonly_rd_stats;
- if (!av1_txfm_uvrd(cpi, x, &tokenonly_rd_stats, bsize, best_rd_in))
- return INT64_MAX;
+ if (!av1_txfm_uvrd(cpi, x, &tokenonly_rd_stats, best_rd_in)) return INT64_MAX;
this_rate = tokenonly_rd_stats.rate +
intra_mode_info_cost_uv(cpi, x, mbmi, bsize, rate_overhead);
this_rd = RDCOST(x->rdmult, this_rate, tokenonly_rd_stats.dist);
@@ -338,19 +337,16 @@
MB_MODE_INFO *const mbmi = xd->mi[0];
const MACROBLOCKD_PLANE *pd = &xd->plane[AOM_PLANE_U];
const ModeCosts *mode_costs = &x->mode_costs;
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
#if CONFIG_SDP
assert(xd->tree_type != LUMA_PART);
- const BLOCK_SIZE plane_bsize = get_plane_block_size(
- mbmi->sb_type[PLANE_TYPE_UV], pd->subsampling_x, pd->subsampling_y);
-#else
+#endif // CONFIG_SDP
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, mbmi, PLANE_TYPE_UV, pd->subsampling_x, pd->subsampling_y);
+#else // !CONFIG_SDP && ! CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE plane_bsize =
-#if CONFIG_SDP
- get_plane_block_size(mbmi->sb_type[xd->tree_type == CHROMA_PART],
- pd->subsampling_x, pd->subsampling_y);
-#else
get_plane_block_size(mbmi->sb_type, pd->subsampling_x, pd->subsampling_y);
-#endif
-#endif
+#endif // CONFIG_SDP
assert(is_cfl_allowed(xd) && cpi->oxcf.intra_mode_cfg.enable_cfl_intra);
assert(plane_bsize < BLOCK_SIZES_ALL);
@@ -499,11 +495,6 @@
if (xd->tree_type == SHARED_PART) {
#endif
if (xd->cfl.store_y) {
- // Restore reconstructed luma values.
- // TODO(chiyotsai@google.com): right now we are re-computing the txfm in
- // this function everytime we search through uv modes. There is some
- // potential speed up here if we cache the result to avoid redundant
- // computation.
#if CONFIG_SDP
av1_encode_intra_block_plane(cpi, x, mbmi->sb_type[PLANE_TYPE_Y],
AOM_PLANE_Y, DRY_RUN_NORMAL,
@@ -512,7 +503,7 @@
av1_encode_intra_block_plane(cpi, x, mbmi->sb_type, AOM_PLANE_Y,
DRY_RUN_NORMAL,
cpi->optimize_seg_arr[mbmi->segment_id]);
-#endif
+#endif // CONFIG_SDP
xd->cfl.store_y = 0;
}
#if CONFIG_SDP
@@ -562,7 +553,7 @@
continue;
} else {
// Predict directly if we don't need to search for angle delta.
- if (!av1_txfm_uvrd(cpi, x, &tokenonly_rd_stats, bsize, best_rd)) {
+ if (!av1_txfm_uvrd(cpi, x, &tokenonly_rd_stats, best_rd)) {
continue;
}
}
@@ -918,6 +909,17 @@
best_rd_so_far = RDCOST(x->rdmult, tmp_rate, rd_stats_y->dist);
try_filter_intra = (best_rd_so_far / 2) <= best_rd;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const MB_MODE_INFO *cached_mode = x->inter_mode_cache;
+ const FILTER_INTRA_MODE_INFO *cached_fi_mode =
+ cached_mode ? &cached_mode->filter_intra_mode_info : NULL;
+ if (should_reuse_mode(x, REUSE_INTRA_MODE_IN_INTERFRAME_FLAG) &&
+ !frame_is_intra_only(cm) && cached_fi_mode &&
+ !cached_fi_mode->use_filter_intra) {
+ // assert(cached_mode->mode == DC_PRED);
+ try_filter_intra = 0;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (try_filter_intra) {
handle_filter_intra_mode(cpi, x, bsize, ctx, rd_stats_y, mode_cost,
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 8601b55..ad0f4d7 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -1912,7 +1912,7 @@
// motion search code to be used without additional modifications.
for (i = 0; i < MAX_MB_PLANE; i++) backup_yv12[i] = xd->plane[i].pre[0];
av1_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL,
- MAX_MB_PLANE);
+ MAX_MB_PLANE, NULL);
}
if (xd->bd != 8) {
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index 2519cc8..7d892f1 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -58,18 +58,6 @@
struct AV1_COMP;
struct SPEED_FEATURES;
-// =============================================================================
-// Cost functions
-// =============================================================================
-
-enum {
- MV_COST_ENTROPY, // Use the entropy rate of the mv as the cost
- MV_COST_L1_LOWRES, // Use the l1 norm of the mv as the cost (<480p)
- MV_COST_L1_MIDRES, // Use the l1 norm of the mv as the cost (>=480p)
- MV_COST_L1_HDRES, // Use the l1 norm of the mv as the cost (>=720p)
- MV_COST_NONE // Use 0 as as cost irrespective of the current mv
-} UENUM1BYTE(MV_COST_TYPE);
-
typedef struct {
// The reference mv used to compute the mv cost
const MV *ref_mv;
diff --git a/av1/encoder/motion_search_facade.c b/av1/encoder/motion_search_facade.c
index ca271ad..e33b577 100644
--- a/av1/encoder/motion_search_facade.c
+++ b/av1/encoder/motion_search_facade.c
@@ -72,7 +72,7 @@
backup_yv12[i] = xd->plane[i].pre[ref_idx];
}
av1_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL,
- num_planes);
+ num_planes, &mbmi->chroma_ref_info);
}
// Work out the size of the first step in the mv step search.
@@ -385,7 +385,7 @@
for (i = 0; i < num_planes; i++)
backup_yv12[ref][i] = xd->plane[i].pre[ref];
av1_setup_pre_planes(xd, ref, scaled_ref_frame[ref], mi_row, mi_col,
- NULL, num_planes);
+ NULL, num_planes, &mbmi->chroma_ref_info);
}
}
@@ -532,7 +532,7 @@
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
av1_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL,
- num_planes);
+ num_planes, &mbmi->chroma_ref_info);
}
int bestsme = INT_MAX;
@@ -764,12 +764,12 @@
int_mv best_mv;
av1_setup_pre_planes(xd, ref_idx, yv12, mi_row, mi_col,
- get_ref_scale_factors(cm, ref), num_planes);
+ get_ref_scale_factors(cm, ref), num_planes, NULL);
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
if (scaled_ref_frame) {
backup_yv12 = xd->plane[AOM_PLANE_Y].pre[ref_idx];
av1_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL,
- num_planes);
+ num_planes, NULL);
}
// Allow more mesh searches for screen content type on the ARF.
@@ -843,3 +843,120 @@
return best_mv;
}
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_set_offsets(const AV1_COMP *const cpi, const TileInfo *const tile,
+ MACROBLOCK *const x, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, const CHROMA_REF_INFO *chr_ref_info);
+int_mv av1_simple_motion_search_ext(AV1_COMP *const cpi,
+ const TileInfo *const tile, MACROBLOCK *x,
+ int mi_row, int mi_col, BLOCK_SIZE bsize,
+ int ref, FULLPEL_MV start_mv,
+ int num_planes, int use_subpixel,
+ SimpleMotionData *sms_data) {
+ assert(num_planes == 1 &&
+ "Currently simple_motion_search only supports luma plane");
+ assert(!frame_is_intra_only(&cpi->common) &&
+ "Simple motion search only enabled for non-key frames");
+ AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *xd = &x->e_mbd;
+
+ // TODO(debargha,chiyotsai): Can we use set_offsets_for_motion_search()
+ av1_set_offsets(cpi, tile, x, mi_row, mi_col, bsize, NULL);
+ // set_offsets_for_motion_search(cpi, x, mi_row, mi_col, bsize);
+
+ MB_MODE_INFO *mbmi = xd->mi[0];
+#if CONFIG_SDP
+ mbmi->sb_type[0] = mbmi->sb_type[1] = bsize;
+#else
+ mbmi->sb_type = bsize;
+#endif // CONFIG_SDP
+ mbmi->ref_frame[0] = ref;
+ mbmi->ref_frame[1] = NONE_FRAME;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_REMOVE_DUAL_FILTER
+ mbmi->interp_fltr = EIGHTTAP_REGULAR;
+#else
+ mbmi->interp_filters = av1_broadcast_interp_filter(EIGHTTAP_REGULAR);
+#endif // CONFIG_REMOVE_DUAL_FILTER
+
+ const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_yv12_buf(cm, ref);
+ const YV12_BUFFER_CONFIG *scaled_ref_frame =
+ av1_get_scaled_ref_frame(cpi, ref);
+ struct buf_2d backup_yv12;
+ // ref_mv is used to calculate the cost of the motion vector
+ const MV ref_mv = kZeroMv;
+ const int step_param =
+ AOMMIN(cpi->mv_search_params.mv_step_param +
+ cpi->sf.part_sf.simple_motion_search_reduce_search_steps,
+ MAX_MVSEARCH_STEPS - 2);
+ const search_site_config *src_search_sites =
+ cpi->mv_search_params.search_site_cfg[SS_CFG_SRC];
+ int cost_list[5];
+ const int ref_idx = 0;
+ int var;
+ int_mv best_mv;
+
+ av1_setup_pre_planes(xd, ref_idx, yv12, mi_row, mi_col,
+ get_ref_scale_factors(cm, ref), num_planes, NULL);
+ set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+ if (scaled_ref_frame) {
+ backup_yv12 = xd->plane[AOM_PLANE_Y].pre[ref_idx];
+ av1_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL,
+ num_planes, NULL);
+ }
+
+ // Allow more mesh searches for screen content type on the ARF.
+ const int fine_search_interval = use_fine_search_interval(cpi);
+ sms_data->sadpb = x->mv_costs.sadperbit;
+ sms_data->errorperbit = x->mv_costs.errorperbit;
+ FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+ av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
+ src_search_sites, fine_search_interval);
+
+ var = av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+ cond_cost_list(cpi, cost_list),
+ &best_mv.as_fullmv, NULL);
+
+ sms_data->fullmv = best_mv.as_mv;
+ const int use_subpel_search =
+ var < INT_MAX && !cpi->common.features.cur_frame_force_integer_mv &&
+ use_subpixel;
+ if (scaled_ref_frame) {
+ xd->plane[AOM_PLANE_Y].pre[ref_idx] = backup_yv12;
+ }
+ if (use_subpel_search) {
+ int not_used = 0;
+
+ SUBPEL_MOTION_SEARCH_PARAMS ms_params;
+ av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize, &ref_mv,
+ cost_list);
+ // TODO(yunqing): integrate this into av1_make_default_subpel_ms_params().
+ ms_params.forced_stop = cpi->sf.mv_sf.simple_motion_subpel_force_stop;
+
+ MV subpel_start_mv = get_mv_from_fullmv(&best_mv.as_fullmv);
+
+ cpi->mv_search_params.find_fractional_mv_step(
+ xd, cm, &ms_params, subpel_start_mv, &best_mv.as_mv, ¬_used,
+ &x->pred_sse[ref], NULL);
+ } else {
+ // Manually convert from units of pixel to 1/8-pixels if we are not doing
+ // subpel search
+ convert_fullmv_to_mv(&best_mv);
+ }
+ sms_data->submv = best_mv.as_mv;
+ mbmi->mv[0] = best_mv;
+
+ // Get a copy of the prediction output
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize,
+ AOM_PLANE_Y, AOM_PLANE_Y);
+
+ aom_clear_system_state();
+
+ if (scaled_ref_frame) {
+ xd->plane[AOM_PLANE_Y].pre[ref_idx] = backup_yv12;
+ }
+
+ return best_mv;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
diff --git a/av1/encoder/motion_search_facade.h b/av1/encoder/motion_search_facade.h
index e631c4e..c671211 100644
--- a/av1/encoder/motion_search_facade.h
+++ b/av1/encoder/motion_search_facade.h
@@ -70,7 +70,14 @@
int mi_row, int mi_col, BLOCK_SIZE bsize,
const FULLPEL_MV start_mv, int use_subpixel,
unsigned int *sse, unsigned int *var);
-
+#if CONFIG_EXT_RECUR_PARTITIONS
+int_mv av1_simple_motion_search_ext(AV1_COMP *const cpi,
+ const TileInfo *const tile, MACROBLOCK *x,
+ int mi_row, int mi_col, BLOCK_SIZE bsize,
+ int ref, FULLPEL_MV start_mv,
+ int num_planes, int use_subpixel,
+ SimpleMotionData *sms_data);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/mv_prec.c b/av1/encoder/mv_prec.c
index a923533..50d7c40 100644
--- a/av1/encoder/mv_prec.c
+++ b/av1/encoder/mv_prec.c
@@ -276,74 +276,126 @@
}
// Split block
+#if CONFIG_EXT_RECUR_PARTITIONS
+static AOM_INLINE void collect_mv_stats_sb(MV_STATS *mv_stats,
+ const AV1_COMP *cpi, int mi_row,
+ int mi_col, BLOCK_SIZE bsize,
+ PARTITION_TREE *ptree) {
+#else
static AOM_INLINE void collect_mv_stats_sb(MV_STATS *mv_stats,
const AV1_COMP *cpi, int mi_row,
int mi_col, BLOCK_SIZE bsize) {
+#endif // EXT_RECUR_PARTITIONS
assert(bsize < BLOCK_SIZES_ALL);
const AV1_COMMON *cm = &cpi->common;
if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols)
return;
-#if CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const PARTITION_TYPE partition = ptree->partition;
+#elif CONFIG_SDP
const PARTITION_TYPE partition =
get_partition(cm, SHARED_PART, mi_row, mi_col, bsize);
#else
- const PARTITION_TYPE partition = get_partition(cm, mi_row, mi_col, bsize);
+const PARTITION_TYPE partition = get_partition(cm, mi_row, mi_col, bsize);
#endif
+
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
- const int hbs = mi_size_wide[bsize] / 2;
- const int qbs = mi_size_wide[bsize] / 4;
+ const int hbs_w = mi_size_wide[bsize] / 2;
+ const int hbs_h = mi_size_high[bsize] / 2;
+ const int qbs_w = mi_size_wide[bsize] / 4;
+ const int qbs_h = mi_size_high[bsize] / 4;
switch (partition) {
case PARTITION_NONE:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
break;
case PARTITION_HORZ:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, subsize,
+ ptree->sub_tree[0]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + hbs_h, mi_col, subsize,
+ ptree->sub_tree[1]);
+#else
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row + hbs, mi_col);
+ collect_mv_stats_b(mv_stats, cpi, mi_row + hbs_h, mi_col);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
case PARTITION_VERT:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, subsize,
+ ptree->sub_tree[0]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + hbs_w, subsize,
+ ptree->sub_tree[1]);
+#else
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs);
+ collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs_w);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
+#if !CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, subsize);
- collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + hbs, subsize);
- collect_mv_stats_sb(mv_stats, cpi, mi_row + hbs, mi_col, subsize);
- collect_mv_stats_sb(mv_stats, cpi, mi_row + hbs, mi_col + hbs, subsize);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + hbs_w, subsize);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + hbs_h, mi_col, subsize);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + hbs_h, mi_col + hbs_w,
+ subsize);
break;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3: {
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, subsize,
+ ptree->sub_tree[0]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + qbs_h, mi_col,
+ get_partition_subsize(bsize, PARTITION_HORZ),
+ ptree->sub_tree[1]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + 3 * qbs_h, mi_col, subsize,
+ ptree->sub_tree[2]);
+ break;
+ }
+ case PARTITION_VERT_3: {
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, subsize,
+ ptree->sub_tree[0]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + qbs_w,
+ get_partition_subsize(bsize, PARTITION_VERT),
+ ptree->sub_tree[1]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + 3 * qbs_w, subsize,
+ ptree->sub_tree[2]);
+ break;
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_A:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs);
- collect_mv_stats_b(mv_stats, cpi, mi_row + hbs, mi_col);
+ collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs_w);
+ collect_mv_stats_b(mv_stats, cpi, mi_row + hbs_h, mi_col);
break;
case PARTITION_HORZ_B:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row + hbs, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row + hbs, mi_col + hbs);
+ collect_mv_stats_b(mv_stats, cpi, mi_row + hbs_h, mi_col);
+ collect_mv_stats_b(mv_stats, cpi, mi_row + hbs_h, mi_col + hbs_w);
break;
case PARTITION_VERT_A:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row + hbs, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs);
+ collect_mv_stats_b(mv_stats, cpi, mi_row + hbs_h, mi_col);
+ collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs_w);
break;
case PARTITION_VERT_B:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
- collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs);
- collect_mv_stats_b(mv_stats, cpi, mi_row + hbs, mi_col + hbs);
+ collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col + hbs_w);
+ collect_mv_stats_b(mv_stats, cpi, mi_row + hbs_h, mi_col + hbs_w);
break;
case PARTITION_HORZ_4:
for (int i = 0; i < 4; ++i) {
- const int this_mi_row = mi_row + i * qbs;
+ const int this_mi_row = mi_row + i * qbs_h;
collect_mv_stats_b(mv_stats, cpi, this_mi_row, mi_col);
}
break;
case PARTITION_VERT_4:
for (int i = 0; i < 4; ++i) {
- const int this_mi_col = mi_col + i * qbs;
+ const int this_mi_col = mi_col + i * qbs_w;
collect_mv_stats_b(mv_stats, cpi, mi_row, this_mi_col);
}
break;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
default: assert(0);
}
}
@@ -360,7 +412,18 @@
BLOCK_SIZE sb_size = cm->seq_params.sb_size;
for (int mi_row = mi_row_start; mi_row < mi_row_end; mi_row += sb_size_mi) {
for (int mi_col = mi_col_start; mi_col < mi_col_end; mi_col += sb_size_mi) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const SB_INFO *sb_info = av1_get_sb_info(cm, mi_row, mi_col);
+#if CONFIG_SDP
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, sb_size,
+ sb_info->ptree_root[0]);
+#else
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, sb_size,
+ sb_info->ptree_root);
+#endif // CONFIG_SDP
+#else
collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, sb_size);
+#endif // EXT_RECUR_PARTITIONS
}
}
}
diff --git a/av1/encoder/palette.c b/av1/encoder/palette.c
index fb483d0..e6af1dc 100644
--- a/av1/encoder/palette.c
+++ b/av1/encoder/palette.c
@@ -792,7 +792,7 @@
}
}
- av1_txfm_uvrd(cpi, x, &tokenonly_rd_stats, bsize, *best_rd);
+ av1_txfm_uvrd(cpi, x, &tokenonly_rd_stats, *best_rd);
if (tokenonly_rd_stats.rate == INT_MAX) continue;
this_rate = tokenonly_rd_stats.rate +
intra_mode_info_cost_uv(cpi, x, mbmi, bsize, dc_mode_cost);
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index 947dca1..7ca6495 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c
@@ -12,11 +12,13 @@
#include "aom_ports/system_state.h"
#include "av1/common/blockd.h"
+#include "av1/common/common_data.h"
#include "av1/common/enums.h"
#include "av1/common/reconintra.h"
#include "av1/encoder/aq_complexity.h"
#include "av1/encoder/aq_variance.h"
+#include "av1/encoder/block.h"
#include "av1/encoder/context_tree.h"
#include "av1/encoder/encoder.h"
#include "av1/encoder/encodeframe.h"
@@ -24,6 +26,7 @@
#include "av1/encoder/encodemv.h"
#include "av1/encoder/motion_search_facade.h"
#include "av1/encoder/partition_search.h"
+#include "av1/encoder/partition_strategy.h"
#include "av1/encoder/reconinter_enc.h"
#include "av1/encoder/tokenize.h"
@@ -383,7 +386,7 @@
for (int plane = plane_start; plane < plane_end; ++plane) {
#else
for (int plane = 0; plane < num_planes; ++plane) {
-#endif
+#endif // CONFIG_SDP
av1_encode_intra_block_plane(cpi, x, bsize, plane, dry_run,
cpi->optimize_seg_arr[mbmi->segment_id]);
}
@@ -435,7 +438,8 @@
assert(IMPLIES(!is_intrabc_block(mbmi), cfg));
#endif
av1_setup_pre_planes(xd, ref, cfg, mi_row, mi_col,
- xd->block_ref_scale_factors[ref], num_planes);
+ xd->block_ref_scale_factors[ref], num_planes,
+ &mbmi->chroma_ref_info);
}
int start_plane = 0;
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize,
@@ -452,9 +456,7 @@
int pixel_c, pixel_r;
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0,
pd->subsampling_x, pd->subsampling_y);
- if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
- pd->subsampling_y))
- continue;
+ if (plane && !xd->is_chroma_ref) continue;
mismatch_record_block_pre(pd->dst.buf, pd->dst.stride,
cm->current_frame.order_hint, plane, pixel_c,
pixel_r, pd->width, pd->height,
@@ -465,7 +467,7 @@
(void)num_planes;
#endif
- av1_encode_sb(cpi, x, bsize, dry_run);
+ av1_encode_sb(cpi, x, dry_run);
av1_tokenize_sb_vartx(cpi, td, dry_run, bsize, rate,
tile_data->allow_update_cdf);
}
@@ -616,11 +618,13 @@
}
}
#endif
+
+ av1_mark_block_as_coded(xd, bsize, cm->seq_params.sb_size);
}
-static void setup_block_rdmult(const AV1_COMP *const cpi, MACROBLOCK *const x,
- int mi_row, int mi_col, BLOCK_SIZE bsize,
- AQ_MODE aq_mode, MB_MODE_INFO *mbmi) {
+void setup_block_rdmult(const AV1_COMP *const cpi, MACROBLOCK *const x,
+ int mi_row, int mi_col, BLOCK_SIZE bsize,
+ AQ_MODE aq_mode, MB_MODE_INFO *mbmi) {
x->rdmult = cpi->rd.RDMULT;
#if CONFIG_SDP
MACROBLOCKD *const xd = &x->e_mbd;
@@ -667,7 +671,8 @@
void av1_set_offsets_without_segment_id(const AV1_COMP *const cpi,
const TileInfo *const tile,
MACROBLOCK *const x, int mi_row,
- int mi_col, BLOCK_SIZE bsize) {
+ int mi_col, BLOCK_SIZE bsize,
+ const CHROMA_REF_INFO *chr_ref_info) {
const AV1_COMMON *const cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
@@ -678,29 +683,32 @@
set_mode_info_offsets(&cpi->common.mi_params, &cpi->mbmi_ext_info, x, xd,
mi_row, mi_col);
- set_entropy_context(xd, mi_row, mi_col, num_planes);
+ set_entropy_context(xd, mi_row, mi_col, num_planes, chr_ref_info);
xd->above_txfm_context = cm->above_contexts.txfm[tile->tile_row] + mi_col;
xd->left_txfm_context =
xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
// Set up destination pointers.
- av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, chr_ref_info);
// Set up limit values for MV components.
// Mv beyond the range do not produce new/different prediction block.
av1_set_mv_limits(&cm->mi_params, &x->mv_limits, mi_row, mi_col, mi_height,
mi_width, cpi->oxcf.border_in_pixels);
- set_plane_n4(xd, mi_width, mi_height, num_planes);
+ set_plane_n4(xd, mi_width, mi_height, num_planes, chr_ref_info);
// Set up distance of MB to edge of frame in 1/8th pel units.
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(!(mi_col & (mi_width - 1)) && !(mi_row & (mi_height - 1)));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
set_mi_row_col(xd, tile, mi_row, mi_height, mi_col, mi_width,
- cm->mi_params.mi_rows, cm->mi_params.mi_cols);
+ cm->mi_params.mi_rows, cm->mi_params.mi_cols, chr_ref_info);
// Set up source buffers.
- av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, bsize);
+ av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes,
+ chr_ref_info);
// required by av1_append_sub8x8_mvs_for_idx() and av1_find_best_ref_mvs()
xd->tile = *tile;
@@ -708,13 +716,14 @@
void av1_set_offsets(const AV1_COMP *const cpi, const TileInfo *const tile,
MACROBLOCK *const x, int mi_row, int mi_col,
- BLOCK_SIZE bsize) {
+ BLOCK_SIZE bsize, const CHROMA_REF_INFO *chr_ref_info) {
const AV1_COMMON *const cm = &cpi->common;
const struct segmentation *const seg = &cm->seg;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi;
- av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize);
+ av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize,
+ chr_ref_info);
// Setup segment ID.
mbmi = xd->mi[0];
@@ -780,9 +789,14 @@
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
int plane_type = (xd->tree_type == CHROMA_PART);
+ assert(bsize < BLOCK_SIZES_ALL);
+ assert(IMPLIES(xd->tree_type == CHROMA_PART,
+ AOMMIN(block_size_wide[bsize], block_size_high[bsize]) > 4));
#endif
+ assert(is_bsize_geq(bsize, cpi->common.mi_params.mi_alloc_bsize));
- av1_set_offsets(cpi, &tile_data->tile_info, x, mi_row, mi_col, bsize);
+ av1_set_offsets(cpi, &tile_data->tile_info, x, mi_row, mi_col, bsize,
+ &ctx->chroma_ref_info);
if (ctx->rd_mode_is_ready) {
#if CONFIG_SDP
@@ -824,6 +838,7 @@
mbmi->sb_type = bsize;
#endif
mbmi->partition = partition;
+ mbmi->chroma_ref_info = ctx->chroma_ref_info;
#if CONFIG_RD_DEBUG
mbmi->mi_row = mi_row;
@@ -1440,13 +1455,15 @@
static void encode_b(const AV1_COMP *const cpi, TileDataEnc *tile_data,
ThreadData *td, TokenExtra **tp, int mi_row, int mi_col,
RUN_TYPE dry_run, BLOCK_SIZE bsize,
- PARTITION_TYPE partition, PICK_MODE_CONTEXT *const ctx,
- int *rate) {
+ PARTITION_TYPE partition,
+ const PICK_MODE_CONTEXT *const ctx, int *rate) {
+ const AV1_COMMON *const cm = &cpi->common;
TileInfo *const tile = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *xd = &x->e_mbd;
- av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize);
+ av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize,
+ &ctx->chroma_ref_info);
const int origin_mult = x->rdmult;
setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL);
MB_MODE_INFO *mbmi = xd->mi[0];
@@ -1454,36 +1471,47 @@
av1_update_state(cpi, td, ctx, mi_row, mi_col, bsize, dry_run);
#if CONFIG_SDP
- int plane_type = (xd->tree_type == CHROMA_PART);
-#endif
+ const int num_planes = av1_num_planes(cm);
+ const int plane_start = (xd->tree_type == CHROMA_PART);
+ const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes;
+#endif // CONFIG_SDP
if (!dry_run) {
#if CONFIG_SDP
- x->mbmi_ext_frame->cb_offset[plane_type] = x->cb_offset[plane_type];
- assert(x->cb_offset[plane_type] <
- (1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]));
+ for (int plane = plane_start; plane < plane_end; plane++) {
+ x->mbmi_ext_frame->cb_offset[plane] = x->cb_offset[plane];
+ assert(x->cb_offset[plane] <
+ (1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]));
+ }
#else
- x->mbmi_ext_frame->cb_offset = x->cb_offset;
- assert(x->cb_offset <
+ memcpy(x->mbmi_ext_frame->cb_offset, x->cb_offset, sizeof(x->cb_offset));
+ assert(x->cb_offset[0] <
(1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]));
-#endif
+#endif // CONFIG_SDP
}
encode_superblock(cpi, tile_data, td, tp, dry_run, bsize, rate);
if (!dry_run) {
- const AV1_COMMON *const cm = &cpi->common;
#if CONFIG_SDP
- x->cb_offset[plane_type] += block_size_wide[bsize] * block_size_high[bsize];
+ for (int plane = plane_start; plane < plane_end; ++plane) {
#else
- x->cb_offset += block_size_wide[bsize] * block_size_high[bsize];
-#endif
+ for (int plane = 0; plane < MAX_MB_PLANE; ++plane) {
+#endif // CONFIG_SDP
+ if (plane == 0) {
+ x->cb_offset[plane] += block_size_wide[bsize] * block_size_high[bsize];
+ } else if (xd->is_chroma_ref) {
+ const BLOCK_SIZE bsize_base = mbmi->chroma_ref_info.bsize_base;
+ x->cb_offset[plane] +=
+ block_size_wide[bsize_base] * block_size_high[bsize_base];
+ }
+ }
#if CONFIG_SDP
if (bsize == cpi->common.seq_params.sb_size &&
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] == 1 &&
#else
if (bsize == cpi->common.seq_params.sb_size && mbmi->skip_txfm == 1 &&
-#endif
+#endif // CONFIG_SDP
cm->delta_q_info.delta_lf_present_flag) {
const int frame_lf_count =
av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
@@ -1605,6 +1633,44 @@
x->rdmult = origin_mult;
}
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+/*!\brief Reconstructs a partition (may contain multiple coding blocks)
+ *
+ * \ingroup partition_search
+ * Reconstructs a sub-partition of the superblock by applying the chosen modes
+ * and partition trees stored in pc_tree.
+ *
+ * \param[in] cpi Top-level encoder structure
+ * \param[in] td Pointer to thread data
+ * \param[in] tile_data Pointer to struct holding adaptive
+ * data/contexts/models for the tile during encoding
+ * \param[in] tp Pointer to the starting token
+ * \param[in] mi_row Row coordinate of the block in a step size of
+ * MI_SIZE
+ * \param[in] mi_col Column coordinate of the block in a step size of
+ * MI_SIZE
+ * \param[in] dry_run A code indicating whether it is part of the final
+ * pass for reconstructing the superblock
+ * \param[in] bsize Current block size
+ * \param[in] pc_tree Pointer to the PC_TREE node storing the picked
+ * partitions and mode info for the current block
+ * \param[in] ptree Pointer to the PARTITION_TREE node holding the
+ * partition info for the current node and all of its
+ * descendants.
+ * \param[in] ptree_luma Pointer to the luma partition tree so that the
+ * encoder to estimate the
+ * partition type for chroma.
+ * \param[in] rate Pointer to the total rate for the current block
+ *
+ * \return Nothing is returned. Instead, reconstructions (w/o in-loop filters)
+ * will be updated in the pixel buffers in td->mb.e_mbd.
+ */
+static void encode_sb(const AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
+ int mi_col, RUN_TYPE dry_run, BLOCK_SIZE bsize,
+ const PC_TREE *pc_tree, PARTITION_TREE *ptree,
+ PARTITION_TREE *ptree_luma, int *rate) {
+#else
/*!\brief Reconstructs a partition (may contain multiple coding blocks)
*
* \ingroup partition_search
@@ -1624,6 +1690,9 @@
* \param[in] bsize Current block size
* \param[in] pc_tree Pointer to the PC_TREE node storing the picked
* partitions and mode info for the current block
+ * \param[in] ptree Pointer to the PARTITION_TREE node holding the
+ * partition info for the current node and all of its
+ * descendants.
* \param[in] rate Pointer to the total rate for the current block
*
* \return Nothing is returned. Instead, reconstructions (w/o in-loop filters)
@@ -1632,133 +1701,325 @@
static void encode_sb(const AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
int mi_col, RUN_TYPE dry_run, BLOCK_SIZE bsize,
- PC_TREE *pc_tree, int *rate) {
+ const PC_TREE *pc_tree, PARTITION_TREE *ptree,
+ int *rate) {
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
assert(bsize < BLOCK_SIZES_ALL);
const AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
+
+ if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
+
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
assert(bsize < BLOCK_SIZES_ALL);
- const int hbs = mi_size_wide[bsize] / 2;
- const int is_partition_root = bsize >= BLOCK_8X8;
+ const int hbs_w = mi_size_wide[bsize] / 2;
+ const int hbs_h = mi_size_high[bsize] / 2;
+ const int qbs_w = mi_size_wide[bsize] / 4;
+ const int qbs_h = mi_size_high[bsize] / 4;
+ const int is_partition_root = is_partition_point(bsize);
const int ctx = is_partition_root
? partition_plane_context(xd, mi_row, mi_col, bsize)
: -1;
const PARTITION_TYPE partition = pc_tree->partitioning;
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
- int quarter_step = mi_size_wide[bsize] / 4;
- int i;
- BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
- if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
if (subsize == BLOCK_INVALID) return;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ assert(partition != PARTITION_SPLIT);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (!dry_run && ctx >= 0) {
- const int has_rows = (mi_row + hbs) < mi_params->mi_rows;
- const int has_cols = (mi_col + hbs) < mi_params->mi_cols;
+ const int has_rows = (mi_row + hbs_h) < mi_params->mi_rows;
+ const int has_cols = (mi_col + hbs_w) < mi_params->mi_cols;
#if CONFIG_SDP
const int plane_index = xd->tree_type == CHROMA_PART;
-#endif
-
- if (has_rows && has_cols) {
+#endif // CONFIG_SDP
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (is_square_block(bsize)) {
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ if (has_rows && has_cols) {
#if CONFIG_ENTROPY_STATS
- td->counts->partition[ctx][partition]++;
+ td->counts->partition[ctx][partition]++;
#endif
-
- if (tile_data->allow_update_cdf) {
- FRAME_CONTEXT *fc = xd->tile_ctx;
+ if (tile_data->allow_update_cdf) {
+ FRAME_CONTEXT *fc = xd->tile_ctx;
#if CONFIG_SDP
- int luma_split_flag = 0;
- int parent_block_width = block_size_wide[bsize];
- if (xd->tree_type == CHROMA_PART &&
- parent_block_width >= SHARED_PART_SIZE) {
- luma_split_flag =
- get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
- }
- if (luma_split_flag <= 3) {
- update_cdf(fc->partition_cdf[plane_index][ctx], partition,
- partition_cdf_length(bsize));
- } else {
- // if luma blocks uses smaller blocks, then chroma will also split
- assert(partition == PARTITION_SPLIT);
- }
+ int parent_block_width = block_size_wide[bsize];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int min_bsize_1d =
+ AOMMIN(block_size_high[bsize], parent_block_width);
+ if (xd->tree_type == CHROMA_PART && ptree_luma &&
+ min_bsize_1d >= SHARED_PART_SIZE) {
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+ PARTITION_TYPE derived_partition_mode = sdp_chroma_part_from_luma(
+ bsize, ptree_luma->partition, ss_x, ss_y);
+ if (partition != derived_partition_mode)
+ assert(0 && "Chroma partition does not match the derived mode.");
+ } else {
+ update_cdf(fc->partition_cdf[plane_index][ctx], partition,
+ partition_cdf_length(bsize));
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ int luma_split_flag = 0;
+ if (xd->tree_type == CHROMA_PART &&
+ parent_block_width >= SHARED_PART_SIZE) {
+ luma_split_flag =
+ get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
+ }
+ if (luma_split_flag <= 3) {
+ update_cdf(fc->partition_cdf[plane_index][ctx], partition,
+ partition_cdf_length(bsize));
+ } else {
+ // if luma blocks uses smaller blocks, then chroma will also split
+ assert(partition == PARTITION_SPLIT);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#else
update_cdf(fc->partition_cdf[ctx], partition,
partition_cdf_length(bsize));
-#endif
+#endif // CONFIG_SDP
+ }
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ } else {
+#if CONFIG_SDP
+ int parent_block_width = block_size_wide[bsize];
+ const int min_bsize_1d =
+ AOMMIN(block_size_high[bsize], parent_block_width);
+ if (xd->tree_type == CHROMA_PART && ptree_luma &&
+ min_bsize_1d >= SHARED_PART_SIZE) {
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+ PARTITION_TYPE derived_partition_mode =
+ sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ss_x, ss_y);
+ assert(partition == derived_partition_mode);
+ (void)derived_partition_mode;
+ } else {
+#endif
+ const PARTITION_TYPE_REC p_rec =
+ get_symbol_from_partition_rec_block(bsize, partition);
+#if CONFIG_ENTROPY_STATS
+ td->counts->partition_rec[ctx][p_rec]++;
+#endif // CONFIG_ENTROPY_STATS
+
+ if (tile_data->allow_update_cdf) {
+ FRAME_CONTEXT *fc = xd->tile_ctx;
+ update_cdf(fc->partition_rec_cdf[ctx], p_rec,
+ partition_rec_cdf_length(bsize));
+ }
+#if CONFIG_SDP
+ }
+#endif
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
+ PARTITION_TREE *sub_tree[4] = { NULL, NULL, NULL, NULL };
+ if (!dry_run) {
+ assert(ptree);
+
+ ptree->partition = partition;
+ ptree->bsize = bsize;
+ ptree->mi_row = mi_row;
+ ptree->mi_col = mi_col;
+ PARTITION_TREE *parent = ptree->parent;
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+ set_chroma_ref_info(
+ mi_row, mi_col, ptree->index, bsize, &ptree->chroma_ref_info,
+ parent ? &parent->chroma_ref_info : NULL,
+ parent ? parent->bsize : BLOCK_INVALID,
+ parent ? parent->partition : PARTITION_NONE, ss_x, ss_y);
+
+ switch (partition) {
+ case PARTITION_SPLIT:
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+ ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
+ ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
+ break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ:
+ case PARTITION_VERT:
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+ break;
+ case PARTITION_HORZ_3:
+ case PARTITION_VERT_3:
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+ ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
+ break;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ default: break;
+ }
+ for (int i = 0; i < 4; ++i) sub_tree[i] = ptree->sub_tree[i];
+ }
+
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const int min_bsize_1d =
+ AOMMIN(block_size_high[bsize], block_size_wide[bsize]);
+ const int track_ptree_luma = xd->tree_type && ptree_luma &&
+ ptree_luma->partition == partition &&
+ min_bsize_1d >= SHARED_PART_SIZE;
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
case PARTITION_NONE:
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->none, rate);
break;
case PARTITION_VERT:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->vertical[0], sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ if (mi_col + hbs_w < cm->mi_params.mi_cols) {
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
+ subsize, pc_tree->vertical[1], sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->vertical[0], rate);
- if (mi_col + hbs < mi_params->mi_cols) {
- encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, subsize,
- partition, pc_tree->vertical[1], rate);
+ if (mi_col + hbs_w < mi_params->mi_cols) {
+ encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs_w, dry_run,
+ subsize, partition, pc_tree->vertical[1], rate);
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
case PARTITION_HORZ:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->horizontal[0], sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ if (mi_row + hbs_h < cm->mi_params.mi_rows) {
+ encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
+ subsize, pc_tree->horizontal[1], sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->horizontal[0], rate);
- if (mi_row + hbs < mi_params->mi_rows) {
- encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, subsize,
- partition, pc_tree->horizontal[1], rate);
+ if (mi_row + hbs_h < mi_params->mi_rows) {
+ encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col, dry_run,
+ subsize, partition, pc_tree->horizontal[1], rate);
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3: {
+ const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_HORZ);
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->horizontal3[0], sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ if (mi_row + qbs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + qbs_h, mi_col, dry_run, bsize3,
+ pc_tree->horizontal3[1], sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ if (mi_row + 3 * qbs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + 3 * qbs_h, mi_col, dry_run,
+ subsize, pc_tree->horizontal3[2], sub_tree[2],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ break;
+ }
+ case PARTITION_VERT_3: {
+ const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_VERT);
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->vertical3[0], sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ if (mi_col + qbs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + qbs_w, dry_run, bsize3,
+ pc_tree->vertical3[1], sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ if (mi_col + 3 * qbs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 3 * qbs_w, dry_run,
+ subsize, pc_tree->vertical3[2], sub_tree[2],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+#endif // CONFIG_SDP
+ rate);
+ break;
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
- pc_tree->split[0], rate);
- encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs, dry_run, subsize,
- pc_tree->split[1], rate);
- encode_sb(cpi, td, tile_data, tp, mi_row + hbs, mi_col, dry_run, subsize,
- pc_tree->split[2], rate);
- encode_sb(cpi, td, tile_data, tp, mi_row + hbs, mi_col + hbs, dry_run,
- subsize, pc_tree->split[3], rate);
+ pc_tree->split[0], sub_tree[0], rate);
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
+ subsize, pc_tree->split[1], sub_tree[1], rate);
+ encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
+ subsize, pc_tree->split[2], sub_tree[2], rate);
+ encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
+ subsize, pc_tree->split[3], sub_tree[3], rate);
break;
-
case PARTITION_HORZ_A:
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, bsize2,
partition, pc_tree->horizontala[0], rate);
- encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, bsize2,
+ encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs_w, dry_run, bsize2,
partition, pc_tree->horizontala[1], rate);
- encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, subsize,
+ encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col, dry_run, subsize,
partition, pc_tree->horizontala[2], rate);
break;
case PARTITION_HORZ_B:
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->horizontalb[0], rate);
- encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, bsize2,
+ encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col, dry_run, bsize2,
partition, pc_tree->horizontalb[1], rate);
- encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col + hbs, dry_run,
+ encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
bsize2, partition, pc_tree->horizontalb[2], rate);
break;
case PARTITION_VERT_A:
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, bsize2,
partition, pc_tree->verticala[0], rate);
- encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, bsize2,
+ encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col, dry_run, bsize2,
partition, pc_tree->verticala[1], rate);
- encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, subsize,
+ encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs_w, dry_run, subsize,
partition, pc_tree->verticala[2], rate);
break;
case PARTITION_VERT_B:
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->verticalb[0], rate);
- encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, bsize2,
+ encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs_w, dry_run, bsize2,
partition, pc_tree->verticalb[1], rate);
- encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col + hbs, dry_run,
+ encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
bsize2, partition, pc_tree->verticalb[2], rate);
break;
case PARTITION_HORZ_4:
- for (i = 0; i < SUB_PARTITIONS_PART4; ++i) {
- int this_mi_row = mi_row + i * quarter_step;
+ for (int i = 0; i < SUB_PARTITIONS_PART4; ++i) {
+ int this_mi_row = mi_row + i * qbs_h;
if (i > 0 && this_mi_row >= mi_params->mi_rows) break;
encode_b(cpi, tile_data, td, tp, this_mi_row, mi_col, dry_run, subsize,
@@ -1766,19 +2027,87 @@
}
break;
case PARTITION_VERT_4:
- for (i = 0; i < SUB_PARTITIONS_PART4; ++i) {
- int this_mi_col = mi_col + i * quarter_step;
+ for (int i = 0; i < SUB_PARTITIONS_PART4; ++i) {
+ int this_mi_col = mi_col + i * qbs_w;
if (i > 0 && this_mi_col >= mi_params->mi_cols) break;
encode_b(cpi, tile_data, td, tp, mi_row, this_mi_col, dry_run, subsize,
partition, pc_tree->vertical4[i], rate);
}
break;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
default: assert(0 && "Invalid partition type."); break;
}
+ if (ptree) ptree->is_settled = 1;
update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+static void build_one_split_tree(AV1_COMMON *const cm, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE final_bsize,
+ PARTITION_TREE *ptree) {
+ assert(block_size_high[bsize] == block_size_wide[bsize]);
+ if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols)
+ return;
+ if (bsize == BLOCK_4X4 || bsize == final_bsize) {
+ ptree->partition = PARTITION_NONE;
+ return;
+ }
+
+ const int hbs_w = mi_size_wide[bsize] >> 1;
+ const int hbs_h = mi_size_high[bsize] >> 1;
+ const BLOCK_SIZE subsize = subsize_lookup[PARTITION_SPLIT][bsize];
+
+ ptree->partition = PARTITION_HORZ;
+ ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+
+ ptree->sub_tree[0]->partition = PARTITION_VERT;
+ ptree->sub_tree[0]->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[0]->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+
+ ptree->sub_tree[1]->partition = PARTITION_VERT;
+ ptree->sub_tree[1]->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
+ ptree->sub_tree[1]->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
+
+ build_one_split_tree(cm, mi_row, mi_col, subsize, final_bsize,
+ ptree->sub_tree[0]->sub_tree[0]);
+ build_one_split_tree(cm, mi_row, mi_col + hbs_w, subsize, final_bsize,
+ ptree->sub_tree[0]->sub_tree[1]);
+ build_one_split_tree(cm, mi_row + hbs_h, mi_col, subsize, final_bsize,
+ ptree->sub_tree[1]->sub_tree[0]);
+ build_one_split_tree(cm, mi_row + hbs_h, mi_col + hbs_w, subsize, final_bsize,
+ ptree->sub_tree[1]->sub_tree[1]);
+}
+
+void av1_build_partition_tree_fixed_partitioning(AV1_COMMON *const cm,
+ int mi_row, int mi_col,
+ BLOCK_SIZE bsize,
+ PARTITION_TREE *ptree) {
+ const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+
+ build_one_split_tree(cm, mi_row, mi_col, sb_size, bsize, ptree);
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+static PARTITION_TYPE get_preset_partition(const AV1_COMMON *cm,
+#if CONFIG_SDP
+ int plane_type,
+#endif // CONFIG_SDP
+ int mi_row, int mi_col,
+ BLOCK_SIZE bsize,
+ PARTITION_TREE *ptree) {
+ if (ptree) return ptree->partition;
+ if (bsize >= BLOCK_8X8) {
+#if CONFIG_SDP
+ return get_partition(cm, plane_type, mi_row, mi_col, bsize);
+#else
+ return get_partition(cm, mi_row, mi_col, bsize);
+#endif // CONFIG_SDP
+ }
+ return PARTITION_NONE;
+}
+
/*!\brief AV1 block partition search (partition estimation and partial search).
*
* \ingroup partition_search
@@ -1795,7 +2124,8 @@
blocks starting from the first pixel of the current
block
* \param[in] tp Pointer to the starting token
-* \param[in] mi_row Row coordinate of the block in a step size of MI_SIZE
+* \param[in] mi_row Row coordinate of the block in a step size of
+MI_SIZE
* \param[in] mi_col Column coordinate of the block in a step size of
MI_SIZE
* \param[in] bsize Current block size
@@ -1805,6 +2135,8 @@
* \param[in] do_recon Whether the reconstruction function needs to be run,
either for finalizing a superblock or providing
reference for future sub-partitions
+* \param[in] ptree Pointer to the PARTITION_TREE node holding the
+pre-calculated partition tree (if any) for the current block
* \param[in] pc_tree Pointer to the PC_TREE node holding the picked
partitions and mode info for the current block
*
@@ -1815,42 +2147,50 @@
void av1_rd_use_partition(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data,
MB_MODE_INFO **mib, TokenExtra **tp, int mi_row,
int mi_col, BLOCK_SIZE bsize, int *rate,
- int64_t *dist, int do_recon, PC_TREE *pc_tree) {
+ int64_t *dist, int do_recon, PARTITION_TREE *ptree,
+ PC_TREE *pc_tree) {
AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int num_planes = av1_num_planes(cm);
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
const ModeCosts *mode_costs = &x->mode_costs;
const int bs = mi_size_wide[bsize];
const int hbs = bs / 2;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int hbh = mi_size_high[bsize] / 2;
+ const int hbw = mi_size_wide[bsize] / 2;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
const int pl = (bsize >= BLOCK_8X8)
? partition_plane_context(xd, mi_row, mi_col, bsize)
: 0;
- const PARTITION_TYPE partition =
#if CONFIG_SDP
- (bsize >= BLOCK_8X8) ? get_partition(cm, xd->tree_type == CHROMA_PART,
- mi_row, mi_col, bsize)
+ const int plane_type = (xd->tree_type == CHROMA_PART);
+ const PARTITION_TYPE partition =
+ get_preset_partition(cm, plane_type, mi_row, mi_col, bsize, ptree);
#else
- (bsize >= BLOCK_8X8) ? get_partition(cm, mi_row, mi_col, bsize)
-#endif
- : PARTITION_NONE;
+ const PARTITION_TYPE partition =
+ get_preset_partition(cm, mi_row, mi_col, bsize, ptree);
+#endif // CONFIG_SDP
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
RD_SEARCH_MACROBLOCK_CONTEXT x_ctx;
RD_STATS last_part_rdc, invalid_rdc;
-#if CONFIG_SDP
- int plane_type = (xd->tree_type == CHROMA_PART);
-#endif
if (pc_tree->none == NULL) {
- pc_tree->none = av1_alloc_pmc(cm, bsize, &td->shared_coeff_buf);
+ pc_tree->none =
+ av1_alloc_pmc(cm, mi_row, mi_col, bsize, pc_tree, PARTITION_NONE, 0,
+ ss_x, ss_y, &td->shared_coeff_buf);
}
PICK_MODE_CONTEXT *ctx_none = pc_tree->none;
if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(mi_size_wide[bsize] == mi_size_high[bsize]);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
av1_invalid_rd_stats(&last_part_rdc);
av1_invalid_rd_stats(&invalid_rdc);
@@ -1864,7 +2204,8 @@
av1_save_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes);
if (bsize == BLOCK_16X16 && cpi->vaq_refresh) {
- av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize);
+ av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize,
+ &pc_tree->chroma_ref_info);
x->mb_energy = av1_log_block_var(cpi, x, bsize);
}
@@ -1872,34 +2213,61 @@
const int orig_rdmult = x->rdmult;
setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE split_subsize =
+ get_partition_subsize(bsize, PARTITION_SPLIT);
for (int i = 0; i < SUB_PARTITIONS_SPLIT; ++i) {
- pc_tree->split[i] = av1_alloc_pc_tree_node(subsize);
- pc_tree->split[i]->index = i;
+ int x_idx = (i & 1) * hbs;
+ int y_idx = (i >> 1) * hbs;
+ pc_tree->split[i] =
+ av1_alloc_pc_tree_node(mi_row + y_idx, mi_col + x_idx, split_subsize,
+ pc_tree, PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
case PARTITION_NONE:
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
PARTITION_NONE, bsize, ctx_none, invalid_rdc);
break;
case PARTITION_HORZ:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ pc_tree->horizontal[0] = av1_alloc_pc_tree_node(
+ mi_row, mi_col, subsize, pc_tree, PARTITION_HORZ, 0, 0, ss_x, ss_y);
+ pc_tree->horizontal[1] =
+ av1_alloc_pc_tree_node(mi_row + hbh, mi_col, subsize, pc_tree,
+ PARTITION_HORZ, 1, 1, ss_x, ss_y);
+ av1_rd_use_partition(cpi, td, tile_data, mib, tp, mi_row, mi_col, subsize,
+ &last_part_rdc.rate, &last_part_rdc.dist, 1,
+ ptree ? ptree->sub_tree[0] : NULL,
+ pc_tree->horizontal[0]);
+#else // CONFIG_EXT_RECUR_PARTITIONS
for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
pc_tree->horizontal[i] =
- av1_alloc_pmc(cm, subsize, &td->shared_coeff_buf);
+ av1_alloc_pmc(cm, mi_row + hbs * i, mi_col, subsize, pc_tree,
+ PARTITION_HORZ, i, ss_x, ss_y, &td->shared_coeff_buf);
}
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
PARTITION_HORZ, subsize, pc_tree->horizontal[0],
invalid_rdc);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (last_part_rdc.rate != INT_MAX && bsize >= BLOCK_8X8 &&
mi_row + hbs < mi_params->mi_rows) {
RD_STATS tmp_rdc;
- const PICK_MODE_CONTEXT *const ctx_h = pc_tree->horizontal[0];
av1_init_rd_stats(&tmp_rdc);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_rd_use_partition(
+ cpi, td, tile_data, mib + hbh * mi_params->mi_stride, tp,
+ mi_row + hbh, mi_col, subsize, &tmp_rdc.rate, &tmp_rdc.dist, 0,
+ ptree ? ptree->sub_tree[1] : NULL, pc_tree->horizontal[1]);
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ const PICK_MODE_CONTEXT *const ctx_h = pc_tree->horizontal[0];
av1_update_state(cpi, td, ctx_h, mi_row, mi_col, subsize, 1);
encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize,
NULL);
pick_sb_modes(cpi, tile_data, x, mi_row + hbs, mi_col, &tmp_rdc,
PARTITION_HORZ, subsize, pc_tree->horizontal[1],
invalid_rdc);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) {
av1_invalid_rd_stats(&last_part_rdc);
break;
@@ -1910,23 +2278,43 @@
}
break;
case PARTITION_VERT:
+#if CONFIG_EXT_RECUR_PARTITIONS
+ pc_tree->vertical[0] = av1_alloc_pc_tree_node(
+ mi_row, mi_col, subsize, pc_tree, PARTITION_VERT, 0, 0, ss_x, ss_y);
+ pc_tree->vertical[1] =
+ av1_alloc_pc_tree_node(mi_row, mi_col + hbw, subsize, pc_tree,
+ PARTITION_VERT, 1, 1, ss_x, ss_y);
+ av1_rd_use_partition(cpi, td, tile_data, mib, tp, mi_row, mi_col, subsize,
+ &last_part_rdc.rate, &last_part_rdc.dist, 1,
+ ptree ? ptree->sub_tree[0] : NULL,
+ pc_tree->vertical[0]);
+#else // CONFIG_EXT_RECUR_PARTITIONS
for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
pc_tree->vertical[i] =
- av1_alloc_pmc(cm, subsize, &td->shared_coeff_buf);
+ av1_alloc_pmc(cm, mi_row, mi_col + hbs * i, subsize, pc_tree,
+ PARTITION_VERT, i, ss_x, ss_y, &td->shared_coeff_buf);
}
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
PARTITION_VERT, subsize, pc_tree->vertical[0], invalid_rdc);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (last_part_rdc.rate != INT_MAX && bsize >= BLOCK_8X8 &&
mi_col + hbs < mi_params->mi_cols) {
RD_STATS tmp_rdc;
- const PICK_MODE_CONTEXT *const ctx_v = pc_tree->vertical[0];
av1_init_rd_stats(&tmp_rdc);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_rd_use_partition(
+ cpi, td, tile_data, mib + hbw, tp, mi_row, mi_col + hbw, subsize,
+ &tmp_rdc.rate, &tmp_rdc.dist, 0, ptree ? ptree->sub_tree[1] : NULL,
+ pc_tree->vertical[1]);
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ const PICK_MODE_CONTEXT *const ctx_v = pc_tree->vertical[0];
av1_update_state(cpi, td, ctx_v, mi_row, mi_col, subsize, 1);
encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize,
NULL);
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col + hbs, &tmp_rdc,
PARTITION_VERT, subsize,
pc_tree->vertical[bsize > BLOCK_8X8], invalid_rdc);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) {
av1_invalid_rd_stats(&last_part_rdc);
break;
@@ -1936,6 +2324,10 @@
last_part_rdc.rdcost += tmp_rdc.rdcost;
}
break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3:
+ case PARTITION_VERT_3:
+#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
last_part_rdc.rate = 0;
last_part_rdc.dist = 0;
@@ -1950,11 +2342,12 @@
continue;
av1_init_rd_stats(&tmp_rdc);
- av1_rd_use_partition(
- cpi, td, tile_data,
- mib + jj * hbs * mi_params->mi_stride + ii * hbs, tp,
- mi_row + y_idx, mi_col + x_idx, subsize, &tmp_rdc.rate,
- &tmp_rdc.dist, i != (SUB_PARTITIONS_SPLIT - 1), pc_tree->split[i]);
+ av1_rd_use_partition(cpi, td, tile_data,
+ mib + jj * hbs * mi_params->mi_stride + ii * hbs,
+ tp, mi_row + y_idx, mi_col + x_idx, subsize,
+ &tmp_rdc.rate, &tmp_rdc.dist,
+ i != (SUB_PARTITIONS_SPLIT - 1), NULL,
+ pc_tree->split[i]);
if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) {
av1_invalid_rd_stats(&last_part_rdc);
break;
@@ -1969,6 +2362,7 @@
case PARTITION_HORZ_B:
case PARTITION_HORZ_4:
case PARTITION_VERT_4:
+#endif // CONFIG_EXT_RECUR_PARTITIONS
assert(0 && "Cannot handle extended partition types");
default: assert(0); break;
}
@@ -1992,7 +2386,7 @@
#endif
if (bsize >= BLOCK_8X8) pc_tree->partitioning = partition;
- av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes);
+ av1_restore_context(cm, x, &x_ctx, mi_row, mi_col, bsize, num_planes);
// We must have chosen a partitioning and encoding or we'll fail later on.
// No other opportunities for success.
@@ -2006,15 +2400,31 @@
// encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_COSTCOEFFS,
// bsize, pc_tree, &rate_coeffs);
#if CONFIG_SDP
- x->cb_offset[plane_type] = 0;
-#else
- x->cb_offset = 0;
-#endif
+ const int plane_start = (xd->tree_type == CHROMA_PART);
+ const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes;
+ for (int plane = plane_start; plane < plane_end; plane++) {
+ x->cb_offset[plane] = 0;
+ }
+ av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, OUTPUT_ENABLED, bsize,
- pc_tree, NULL);
+ pc_tree, xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#if CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ NULL);
+#else
+ memset(x->cb_offset, 0, sizeof(x->cb_offset));
+ av1_reset_ptree_in_sbi(xd->sbi);
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, OUTPUT_ENABLED, bsize,
+ pc_tree, xd->sbi->ptree_root, NULL);
+#endif // CONFIG_SDP
} else {
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
- pc_tree, NULL);
+ pc_tree, NULL,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ NULL);
}
}
@@ -2023,6 +2433,7 @@
x->rdmult = orig_rdmult;
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Try searching for an encoding for the given subblock. Returns zero if the
// rdcost is already too high (to tell the caller not to bother searching for
// encodings of further subblocks).
@@ -2106,29 +2517,71 @@
pc_tree->partitioning = partition;
return true;
}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE int check_is_chroma_size_valid(PARTITION_TYPE partition,
+ BLOCK_SIZE bsize, int mi_row,
+ int mi_col, int ss_x, int ss_y,
+ const PC_TREE *pc_tree) {
+ const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
+ int is_valid = 0;
+ if (subsize < BLOCK_SIZES_ALL) {
+ CHROMA_REF_INFO tmp_chr_ref_info = {
+ 1, 0, mi_row, mi_col, subsize, subsize
+ };
+ set_chroma_ref_info(mi_row, mi_col, 0, subsize, &tmp_chr_ref_info,
+ &pc_tree->chroma_ref_info, bsize, partition, ss_x,
+ ss_y);
+ is_valid = get_plane_block_size(tmp_chr_ref_info.bsize_base, ss_x, ss_y) !=
+ BLOCK_INVALID;
+ }
+ return is_valid;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Initialize state variables of partition search used in
// av1_rd_pick_partition().
static void init_partition_search_state_params(
MACROBLOCK *x, AV1_COMP *const cpi, PartitionSearchState *part_search_state,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ PC_TREE *pc_tree,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
int mi_row, int mi_col, BLOCK_SIZE bsize) {
MACROBLOCKD *const xd = &x->e_mbd;
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
const CommonModeInfoParams *const mi_params = &cpi->common.mi_params;
+ assert(bsize < BLOCK_SIZES_ALL);
+
// Initialization of block size related parameters.
blk_params->mi_step = mi_size_wide[bsize] / 2;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->mi_step_h = mi_size_high[bsize] / 2;
+ blk_params->mi_step_w = mi_size_wide[bsize] / 2;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
blk_params->mi_row = mi_row;
blk_params->mi_col = mi_col;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->mi_row_edge = mi_row + blk_params->mi_step_h;
+ blk_params->mi_col_edge = mi_col + blk_params->mi_step_w;
+#else // CONFIG_EXT_RECUR_PARTITIONS
blk_params->mi_row_edge = mi_row + blk_params->mi_step;
blk_params->mi_col_edge = mi_col + blk_params->mi_step;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
blk_params->width = block_size_wide[bsize];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->min_partition_size = x->sb_enc.min_partition_size;
+#else
blk_params->min_partition_size_1d =
block_size_wide[x->sb_enc.min_partition_size];
+#endif // CONFIG_EXT_RECUR_PARTITIONS
blk_params->subsize = get_partition_subsize(bsize, PARTITION_SPLIT);
blk_params->split_bsize2 = blk_params->subsize;
+#if !CONFIG_EXT_RECUR_PARTITIONS
blk_params->bsize_at_least_8x8 = (bsize >= BLOCK_8X8);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
blk_params->bsize = bsize;
// Check if the partition corresponds to edge block.
@@ -2145,17 +2598,42 @@
// Set partition plane context index.
part_search_state->pl_ctx_idx =
+#if CONFIG_EXT_RECUR_PARTITIONS
+ is_partition_point(bsize)
+#else
blk_params->bsize_at_least_8x8
+#endif // CONFIG_EXT_RECUR_PARTITIONS
? partition_plane_context(xd, mi_row, mi_col, bsize)
: 0;
// Partition cost buffer update
ModeCosts *mode_costs = &x->mode_costs;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int pl = part_search_state->pl_ctx_idx;
+ if (is_square_block(bsize)) {
#if CONFIG_SDP
+ part_search_state->partition_cost =
+ mode_costs->partition_cost[xd->tree_type == CHROMA_PART][pl];
+#else
+ part_search_state->partition_cost = mode_costs->partition_cost[pl];
+#endif // CONFIG_SDP
+ } else {
+ for (PARTITION_TYPE p = PARTITION_NONE; p < EXT_PARTITION_TYPES; ++p) {
+ PARTITION_TYPE_REC p_rec = get_symbol_from_partition_rec_block(bsize, p);
+
+ if (p_rec != PARTITION_INVALID_REC)
+ part_search_state->partition_cost_table[p] =
+ mode_costs->partition_rec_cost[pl][p_rec];
+ else
+ part_search_state->partition_cost_table[p] = INT_MAX;
+ }
+ part_search_state->partition_cost = part_search_state->partition_cost_table;
+ }
+#elif CONFIG_SDP
part_search_state->partition_cost =
mode_costs->partition_cost[xd->tree_type == CHROMA_PART]
[part_search_state->pl_ctx_idx];
-#else
+#else // !CONFIG_EXT_RECUR_PARTITIONS && !CONFIG_SDP
part_search_state->partition_cost =
mode_costs->partition_cost[part_search_state->pl_ctx_idx];
#endif
@@ -2185,55 +2663,144 @@
// Initialize partition search flags to defaults.
part_search_state->terminate_partition_search = 0;
+
+ av1_zero(part_search_state->prune_rect_part);
+
#if CONFIG_SDP
+#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split =
blk_params->bsize_at_least_8x8 &&
(xd->tree_type != CHROMA_PART || bsize > BLOCK_8X8);
part_search_state->do_rectangular_split =
cpi->oxcf.part_cfg.enable_rect_partitions &&
(xd->tree_type != CHROMA_PART || bsize > BLOCK_8X8);
+#else
+ part_search_state->do_rectangular_split =
+ cpi->oxcf.part_cfg.enable_rect_partitions &&
+ (xd->tree_type != CHROMA_PART || is_bsize_gt(bsize, BLOCK_8X8));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
- av1_zero(part_search_state->prune_rect_part);
+ const BLOCK_SIZE horz_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE vert_subsize = get_partition_subsize(bsize, PARTITION_VERT);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // TODO(chiyotsai,yuec@google.com): Fix the rect_allowed condition when both
+ // SDP and ERP are on.
+ const int is_horz_size_valid =
+ is_partition_valid(bsize, PARTITION_HORZ) &&
+ IMPLIES(xd->tree_type == SHARED_PART,
+ check_is_chroma_size_valid(PARTITION_HORZ, bsize, mi_row, mi_col,
+ part_search_state->ss_x,
+ part_search_state->ss_y, pc_tree));
+
+ const int is_vert_size_valid =
+ is_partition_valid(bsize, PARTITION_VERT) &&
+ IMPLIES(xd->tree_type == SHARED_PART,
+ check_is_chroma_size_valid(PARTITION_VERT, bsize, mi_row, mi_col,
+ part_search_state->ss_x,
+ part_search_state->ss_y, pc_tree));
+#else
+ const int is_horz_size_valid =
+ horz_subsize != BLOCK_INVALID &&
+ get_plane_block_size(horz_subsize, part_search_state->ss_x,
+ part_search_state->ss_y) != BLOCK_INVALID;
+ const int is_vert_size_valid =
+ vert_subsize != BLOCK_INVALID &&
+ get_plane_block_size(vert_subsize, part_search_state->ss_x,
+ part_search_state->ss_y) != BLOCK_INVALID;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const bool no_sub_16_chroma_part =
+ xd->tree_type != CHROMA_PART ||
+ (block_size_wide[bsize] > 8 && block_size_high[bsize] > 8);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Initialize allowed partition types for the partition block.
+ part_search_state->is_block_splittable = is_partition_point(bsize);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ part_search_state->partition_none_allowed =
+ (xd->tree_type == CHROMA_PART && bsize == BLOCK_8X8) ||
+ (blk_params->has_rows && blk_params->has_cols &&
+ is_bsize_geq(blk_params->bsize, blk_params->min_partition_size));
+#else
part_search_state->partition_none_allowed =
blk_params->has_rows && blk_params->has_cols;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
part_search_state->partition_rect_allowed[HORZ] =
- blk_params->has_cols && blk_params->bsize_at_least_8x8 &&
- cpi->oxcf.part_cfg.enable_rect_partitions &&
- (xd->tree_type != CHROMA_PART || bsize > BLOCK_8X8) &&
- get_plane_block_size(get_partition_subsize(bsize, PARTITION_HORZ),
- part_search_state->ss_x,
- part_search_state->ss_y) != BLOCK_INVALID;
- part_search_state->partition_rect_allowed[VERT] =
- blk_params->has_rows && blk_params->bsize_at_least_8x8 &&
- (xd->tree_type != CHROMA_PART || bsize > BLOCK_8X8) &&
- cpi->oxcf.part_cfg.enable_rect_partitions &&
- get_plane_block_size(get_partition_subsize(bsize, PARTITION_VERT),
- part_search_state->ss_x,
- part_search_state->ss_y) != BLOCK_INVALID;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (blk_params->has_cols || !blk_params->has_rows) &&
#else
+ blk_params->has_cols &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->bsize_at_least_8x8 && no_sub_16_chroma_part &&
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+ cpi->oxcf.part_cfg.enable_rect_partitions &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ is_bsize_geq(horz_subsize, blk_params->min_partition_size) &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ is_horz_size_valid;
+ part_search_state->partition_rect_allowed[VERT] =
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (blk_params->has_rows || !blk_params->has_cols) &&
+#else
+ blk_params->has_rows &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->bsize_at_least_8x8 && no_sub_16_chroma_part &&
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+ cpi->oxcf.part_cfg.enable_rect_partitions &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ is_bsize_geq(vert_subsize, blk_params->min_partition_size) &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ is_vert_size_valid;
+#else // !CONFIG_SDP
+#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split = blk_params->bsize_at_least_8x8;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_rectangular_split =
cpi->oxcf.part_cfg.enable_rect_partitions;
- av1_zero(part_search_state->prune_rect_part);
// Initialize allowed partition types for the partition block.
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int is_chroma_size_valid_horz = check_is_chroma_size_valid(
+ PARTITION_HORZ, bsize, mi_row, mi_col, part_search_state->ss_x,
+ part_search_state->ss_y, pc_tree);
+
+ int is_chroma_size_valid_vert = check_is_chroma_size_valid(
+ PARTITION_VERT, bsize, mi_row, mi_col, part_search_state->ss_x,
+ part_search_state->ss_y, pc_tree);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+ part_search_state->is_block_splittable = is_partition_point(bsize);
part_search_state->partition_none_allowed =
blk_params->has_rows && blk_params->has_cols;
part_search_state->partition_rect_allowed[HORZ] =
- blk_params->has_cols && blk_params->bsize_at_least_8x8 &&
- cpi->oxcf.part_cfg.enable_rect_partitions &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (blk_params->has_cols || !blk_params->has_rows) &&
+ is_partition_valid(bsize, PARTITION_HORZ) && is_chroma_size_valid_horz &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ),
+ blk_params->min_partition_size) &&
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->has_cols && is_partition_valid(bsize, PARTITION_HORZ) &&
get_plane_block_size(get_partition_subsize(bsize, PARTITION_HORZ),
part_search_state->ss_x,
- part_search_state->ss_y) != BLOCK_INVALID;
+ part_search_state->ss_y) != BLOCK_INVALID &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ cpi->oxcf.part_cfg.enable_rect_partitions;
part_search_state->partition_rect_allowed[VERT] =
- blk_params->has_rows && blk_params->bsize_at_least_8x8 &&
- cpi->oxcf.part_cfg.enable_rect_partitions &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (blk_params->has_rows || !blk_params->has_cols) &&
+ is_partition_valid(bsize, PARTITION_VERT) && is_chroma_size_valid_vert &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT),
+ blk_params->min_partition_size) &&
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ blk_params->has_rows && is_partition_valid(bsize, PARTITION_VERT) &&
get_plane_block_size(get_partition_subsize(bsize, PARTITION_VERT),
part_search_state->ss_x,
- part_search_state->ss_y) != BLOCK_INVALID;
-#endif
+ part_search_state->ss_y) != BLOCK_INVALID &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ cpi->oxcf.part_cfg.enable_rect_partitions;
+#endif // CONFIG_SDP
// Reset the flag indicating whether a partition leading to a rdcost lower
// than the bound best_rdc has been found.
@@ -2247,8 +2814,29 @@
PartitionSearchState *part_search_state) {
#else
AV1_COMMON const *cm, PartitionSearchState *part_search_state) {
-#endif
+#endif // CONFIG_SDP
PartitionBlkParams blk_params = part_search_state->part_blk_params;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int has_rows = blk_params.has_rows;
+ const int has_cols = blk_params.has_cols;
+ (void)cm;
+ if (!(has_rows && has_cols)) {
+ if (!has_rows && !has_cols) {
+ // At the bottom right, horz or vert
+ aom_cdf_prob binary_cdf[2] = { 16384, AOM_ICDF(CDF_PROB_TOP) };
+ static const int binary_inv_map[2] = { PARTITION_HORZ, PARTITION_VERT };
+ av1_cost_tokens_from_cdf(part_search_state->tmp_partition_cost,
+ binary_cdf, binary_inv_map);
+ } else {
+ for (int i = 0; i < PARTITION_TYPES; ++i)
+ part_search_state->tmp_partition_cost[i] = 0;
+ }
+ part_search_state->partition_cost = part_search_state->tmp_partition_cost;
+ }
+#if CONFIG_SDP
+ (void)xd;
+#endif // CONFIG_SDP
+#else // CONFIG_EXT_RECUR_PARTITIONS
assert(blk_params.bsize_at_least_8x8 && part_search_state->pl_ctx_idx >= 0);
#if CONFIG_SDP
const int plane = xd->tree_type == CHROMA_PART;
@@ -2281,36 +2869,108 @@
}
// Override the partition cost buffer.
part_search_state->partition_cost = part_search_state->tmp_partition_cost;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
// Reset the partition search state flags when
// must_find_valid_partition is equal to 1.
static AOM_INLINE void reset_part_limitations(
- AV1_COMP *const cpi, PartitionSearchState *part_search_state) {
+ AV1_COMP *const cpi,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ TREE_TYPE tree_type,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+ PC_TREE *pc_tree,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ PartitionSearchState *part_search_state) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
- const int is_rect_part_allowed =
- blk_params.bsize_at_least_8x8 &&
- cpi->oxcf.part_cfg.enable_rect_partitions &&
- (blk_params.width > blk_params.min_partition_size_1d);
+#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split =
blk_params.bsize_at_least_8x8 &&
(blk_params.width > blk_params.min_partition_size_1d);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ part_search_state->partition_none_allowed =
+ (tree_type == CHROMA_PART && blk_params.bsize == BLOCK_8X8) ||
+ (blk_params.has_rows && blk_params.has_cols &&
+ is_bsize_geq(blk_params.bsize, blk_params.min_partition_size));
+#else
part_search_state->partition_none_allowed =
blk_params.has_rows && blk_params.has_cols &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ is_bsize_geq(blk_params.bsize, blk_params.min_partition_size);
+#else
(blk_params.width >= blk_params.min_partition_size_1d);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+
+ // Initialize allowed partition types for the partition block.
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE horz_subsize =
+ get_partition_subsize(blk_params.bsize, PARTITION_HORZ);
+ const BLOCK_SIZE vert_subsize =
+ get_partition_subsize(blk_params.bsize, PARTITION_VERT);
+ const int is_chroma_size_valid_horz = check_is_chroma_size_valid(
+ PARTITION_HORZ, blk_params.bsize, blk_params.mi_row, blk_params.mi_col,
+ part_search_state->ss_x, part_search_state->ss_y, pc_tree);
+ const int is_chroma_size_valid_vert = check_is_chroma_size_valid(
+ PARTITION_VERT, blk_params.bsize, blk_params.mi_row, blk_params.mi_col,
+ part_search_state->ss_x, part_search_state->ss_y, pc_tree);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
part_search_state->partition_rect_allowed[HORZ] =
- blk_params.has_cols && is_rect_part_allowed &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (blk_params.has_cols || !blk_params.has_rows) &&
+ is_partition_valid(blk_params.bsize, PARTITION_HORZ) &&
+ is_chroma_size_valid_horz &&
+ is_bsize_geq(horz_subsize, blk_params.min_partition_size) &&
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ blk_params.has_cols &&
+ is_partition_valid(blk_params.bsize, PARTITION_HORZ) &&
get_plane_block_size(
get_partition_subsize(blk_params.bsize, PARTITION_HORZ),
- part_search_state->ss_x, part_search_state->ss_y) != BLOCK_INVALID;
+ part_search_state->ss_x, part_search_state->ss_y) != BLOCK_INVALID &&
+ (blk_params.width > blk_params.min_partition_size_1d) &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ cpi->oxcf.part_cfg.enable_rect_partitions;
part_search_state->partition_rect_allowed[VERT] =
- blk_params.has_rows && is_rect_part_allowed &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (blk_params.has_rows || !blk_params.has_cols) &&
+ is_partition_valid(blk_params.bsize, PARTITION_VERT) &&
+ is_chroma_size_valid_vert &&
+ is_bsize_geq(vert_subsize, blk_params.min_partition_size) &&
+#else // CONFIG_EXT_RECUR_PARTITIONS
+ blk_params.has_rows &&
+ is_partition_valid(blk_params.bsize, PARTITION_VERT) &&
get_plane_block_size(
get_partition_subsize(blk_params.bsize, PARTITION_VERT),
- part_search_state->ss_x, part_search_state->ss_y) != BLOCK_INVALID;
+ part_search_state->ss_x, part_search_state->ss_y) != BLOCK_INVALID &&
+ (blk_params.width > blk_params.min_partition_size_1d) &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ cpi->oxcf.part_cfg.enable_rect_partitions;
part_search_state->terminate_partition_search = 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (!is_square_block(blk_params.bsize)) {
+ if (!part_search_state->partition_rect_allowed[HORZ] &&
+ !part_search_state->partition_rect_allowed[VERT] &&
+ !part_search_state->partition_none_allowed) {
+ if (block_size_wide[blk_params.bsize] >
+ block_size_high[blk_params.bsize]) {
+ if (is_bsize_geq(vert_subsize, blk_params.min_partition_size)) {
+ part_search_state->partition_rect_allowed[VERT] = 1;
+ }
+ } else {
+ if (is_bsize_geq(horz_subsize, blk_params.min_partition_size)) {
+ part_search_state->partition_rect_allowed[HORZ] = 1;
+ }
+ }
+ }
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
+static const int rect_partition_type[NUM_RECT_PARTS] = { PARTITION_HORZ,
+ PARTITION_VERT };
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Rectangular partitions evaluation at sub-block level.
static void rd_pick_rect_partition(AV1_COMP *const cpi, TileDataEnc *tile_data,
MACROBLOCK *x,
@@ -2343,9 +3003,86 @@
part_search_state->rect_part_rd[rect_part][idx] =
part_search_state->this_rdc.rdcost;
}
+#else
+static void rd_pick_rect_partition(
+ AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
+ TokenExtra **tp, MACROBLOCK *x, PC_TREE *pc_tree,
+ PartitionSearchState *part_search_state, RD_STATS *best_rdc,
+ RECT_PART_TYPE rect_type,
+ const int mi_pos_rect[NUM_RECT_PARTS][SUB_PARTITIONS_RECT][2],
+ BLOCK_SIZE bsize, const int is_not_edge_block[NUM_RECT_PARTS],
+ SB_MULTI_PASS_MODE multi_pass_mode
+#if CONFIG_SDP
+ ,
+ const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree
+#endif // CONFIG_SDP
+) {
+ const PARTITION_TYPE partition_type = rect_partition_type[rect_type];
+ RD_STATS *sum_rdc = &part_search_state->sum_rdc;
+
+ sum_rdc->rate = part_search_state->partition_cost[partition_type];
+ sum_rdc->rdcost = RDCOST(x->rdmult, sum_rdc->rate, 0);
+
+ RD_STATS this_rdc;
+ RD_STATS best_remain_rdcost;
+ PC_TREE **sub_tree =
+ (rect_type == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
+#if CONFIG_SDP
+ const int track_ptree_luma =
+ ptree_luma && ptree_luma->partition == partition_type;
+#endif // CONFIG_SDP
+ av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
+ bool partition_found = av1_rd_pick_partition(
+ cpi, td, tile_data, tp, mi_pos_rect[rect_type][0][0],
+ mi_pos_rect[rect_type][0][1], bsize, &this_rdc, best_remain_rdcost,
+ sub_tree[0],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+ get_partition_subtree_const(template_tree, 0),
+#endif // CONFIG_SDP
+ NULL, NULL, multi_pass_mode, NULL);
+ av1_rd_cost_update(x->rdmult, &this_rdc);
+ if (!partition_found) {
+ av1_invalid_rd_stats(sum_rdc);
+ return;
+ } else {
+ sum_rdc->rate += this_rdc.rate;
+ sum_rdc->dist += this_rdc.dist;
+ av1_rd_cost_update(x->rdmult, sum_rdc);
+ }
+ part_search_state->rect_part_rd[rect_type][0] = this_rdc.rdcost;
+
+ if (sum_rdc->rdcost < best_rdc->rdcost && is_not_edge_block[rect_type]) {
+ av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
+ partition_found = av1_rd_pick_partition(
+ cpi, td, tile_data, tp, mi_pos_rect[rect_type][1][0],
+ mi_pos_rect[rect_type][1][1], bsize, &this_rdc, best_remain_rdcost,
+ sub_tree[1],
+#if CONFIG_SDP
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL,
+ get_partition_subtree_const(template_tree, 1),
+#endif // CONFIG_SDP
+ NULL, NULL, multi_pass_mode, NULL);
+ av1_rd_cost_update(x->rdmult, &this_rdc);
+ part_search_state->rect_part_rd[rect_type][1] = this_rdc.rdcost;
+
+ if (!partition_found) {
+ av1_invalid_rd_stats(sum_rdc);
+ return;
+ } else {
+ sum_rdc->rate += this_rdc.rate;
+ sum_rdc->dist += this_rdc.dist;
+ av1_rd_cost_update(x->rdmult, sum_rdc);
+ }
+ }
+}
+#endif
typedef int (*active_edge_info)(const AV1_COMP *cpi, int mi_col, int mi_step);
+#define IS_FORCED_PARTITION_TYPE(cur_partition) \
+ (forced_partition == PARTITION_INVALID || forced_partition == (cur_partition))
+
// Checks if HORZ / VERT partition search is allowed.
static AOM_INLINE int is_rect_part_allowed(
const AV1_COMP *cpi, PartitionSearchState *part_search_state,
@@ -2355,23 +3092,75 @@
(!part_search_state->terminate_partition_search &&
part_search_state->partition_rect_allowed[rect_part] &&
!part_search_state->prune_rect_part[rect_part] &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ is_partition_valid(blk_params.bsize, rect_partition_type[rect_part]) &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
(part_search_state->do_rectangular_split ||
active_edge[rect_part](cpi, mi_pos, blk_params.mi_step)));
return is_part_allowed;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE int is_bsize_pruning_cand(BLOCK_SIZE bsize) {
+ if (bsize == BLOCK_INVALID) {
+ return 0;
+ }
+
+ const int avg_bsize = (block_size_wide[bsize] + block_size_high[bsize]) / 2;
+ return avg_bsize <= 32;
+}
+
+static AOM_INLINE PARTITION_TYPE get_forced_partition_type(
+ const AV1_COMMON *const cm, MACROBLOCK *x, int mi_row, int mi_col,
+ BLOCK_SIZE bsize
+#if CONFIG_SDP
+ ,
+ const PARTITION_TREE *template_tree
+#endif // CONFIG_SDP
+) {
+#if CONFIG_SDP
+ if (template_tree) {
+ return template_tree->partition;
+ }
+#endif // CONFIG_SDP
+
+ if (should_reuse_mode(x, REUSE_PARTITION_MODE_FLAG)) {
+ return av1_get_prev_partition(x, mi_row, mi_col, bsize,
+ cm->seq_params.sb_size);
+ }
+ return PARTITION_INVALID;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// Rectangular partition types search function.
static void rectangular_partition_search(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, PC_TREE *pc_tree,
RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ SB_MULTI_PASS_MODE multi_pass_mode,
+#if CONFIG_SDP
+ const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
+#endif // CONFIG_SDP
+#endif // CONFIG_EXT_RECUR_PARTITIONS
RD_RECT_PART_WIN_INFO *rect_part_win_info) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ MACROBLOCKD *const xd = &x->e_mbd;
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+#if CONFIG_SDP
+ const PARTITION_TYPE forced_partition =
+ get_forced_partition_type(cm, x, blk_params.mi_row, blk_params.mi_col,
+ blk_params.bsize, template_tree);
+#else
+ const PARTITION_TYPE forced_partition = get_forced_partition_type(
+ cm, x, blk_params.mi_row, blk_params.mi_col, blk_params.bsize);
+#endif // CONFIG_SDP
+#endif // CONFIG_EXT_RECUR_PARTITIONS
RD_STATS *sum_rdc = &part_search_state->sum_rdc;
- const int rect_partition_type[NUM_RECT_PARTS] = { PARTITION_HORZ,
- PARTITION_VERT };
// mi_pos_rect[NUM_RECT_PARTS][SUB_PARTITIONS_RECT][0]: mi_row postion of
// HORZ and VERT partition types.
@@ -2392,12 +3181,14 @@
// Indicates edge blocks for HORZ and VERT partition types.
const int is_not_edge_block[NUM_RECT_PARTS] = { blk_params.has_rows,
blk_params.has_cols };
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Initialize pc tree context for HORZ and VERT partition types.
PICK_MODE_CONTEXT **cur_ctx[NUM_RECT_PARTS][SUB_PARTITIONS_RECT] = {
{ &pc_tree->horizontal[0], &pc_tree->horizontal[1] },
{ &pc_tree->vertical[0], &pc_tree->vertical[1] }
};
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Loop over rectangular partition types.
for (RECT_PART_TYPE i = HORZ; i < NUM_RECT_PARTS; i++) {
@@ -2410,16 +3201,67 @@
continue;
// Sub-partition idx.
- int sub_part_idx = 0;
- PARTITION_TYPE partition_type = rect_partition_type[i];
+ const PARTITION_TYPE partition_type = rect_partition_type[i];
blk_params.subsize =
get_partition_subsize(blk_params.bsize, partition_type);
+ const int part_hv_rate = part_search_state->partition_cost[partition_type];
+ if (part_hv_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_hv_rate, 0) >= best_rdc->rdcost) {
+ continue;
+ }
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(blk_params.subsize <= BLOCK_LARGEST);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
av1_init_rd_stats(sum_rdc);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (!IS_FORCED_PARTITION_TYPE(partition_type)) {
+ continue;
+ }
+
+ if (cpi->sf.part_sf.enable_fast_erp && !frame_is_intra_only(cm) &&
+ !x->must_find_valid_partition &&
+ is_bsize_pruning_cand(blk_params.bsize)) {
+ if (av1_prune_part_hv_with_sms(cpi, tile_data, x, part_search_state,
+ best_rdc, &blk_params, i, part_hv_rate)) {
+ continue;
+ }
+ }
+
+ PC_TREE **sub_tree = (i == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
+
+ const int num_planes = av1_num_planes(cm);
+ for (int idx = 0; idx < SUB_PARTITIONS_RECT; idx++) {
+ if (sub_tree[idx]) {
+ av1_free_pc_tree_recursive(sub_tree[idx], num_planes, 0, 0);
+ sub_tree[idx] = NULL;
+ }
+ }
+ sub_tree[0] = av1_alloc_pc_tree_node(
+ mi_pos_rect[i][0][0], mi_pos_rect[i][0][1], blk_params.subsize, pc_tree,
+ partition_type, 0, 0, ss_x, ss_y);
+ sub_tree[1] = av1_alloc_pc_tree_node(
+ mi_pos_rect[i][1][0], mi_pos_rect[i][1][1], blk_params.subsize, pc_tree,
+ partition_type, 1, 1, ss_x, ss_y);
+
+#if CONFIG_SDP
+ rd_pick_rect_partition(cpi, td, tile_data, tp, x, pc_tree,
+ part_search_state, best_rdc, i, mi_pos_rect,
+ blk_params.subsize, is_not_edge_block,
+ multi_pass_mode, ptree_luma, template_tree);
+#else
+ rd_pick_rect_partition(
+ cpi, td, tile_data, tp, x, pc_tree, part_search_state, best_rdc, i,
+ mi_pos_rect, blk_params.subsize, is_not_edge_block, multi_pass_mode);
+#endif // CONFIG_SDP
+#else
+ int sub_part_idx = 0;
for (int j = 0; j < SUB_PARTITIONS_RECT; j++) {
+ assert(cur_ctx[i][j] != NULL);
if (cur_ctx[i][j][0] == NULL) {
- cur_ctx[i][j][0] =
- av1_alloc_pmc(cm, blk_params.subsize, &td->shared_coeff_buf);
+ cur_ctx[i][j][0] = av1_alloc_pmc(
+ cm, mi_pos_rect[i][j][0], mi_pos_rect[i][j][1], blk_params.subsize,
+ pc_tree, partition_type, j, part_search_state->ss_x,
+ part_search_state->ss_y, &td->shared_coeff_buf);
}
}
sum_rdc->rate = part_search_state->partition_cost[partition_type];
@@ -2462,6 +3304,7 @@
best_rdc, 1, mi_pos_rect[i][sub_part_idx][0],
mi_pos_rect[i][sub_part_idx][1], blk_params.subsize, partition_type);
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_COLLECT_PARTITION_STATS
if (partition_timer_on) {
aom_usec_timer_mark(&partition_timer);
@@ -2483,11 +3326,12 @@
if (rect_part_win_info != NULL)
rect_part_win_info->rect_part_win[i] = false;
}
- av1_restore_context(x, x_ctx, blk_params.mi_row, blk_params.mi_col,
+ av1_restore_context(cm, x, x_ctx, blk_params.mi_row, blk_params.mi_col,
blk_params.bsize, av1_num_planes(cm));
}
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
// AB partition type evaluation.
static void rd_pick_ab_part(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
@@ -2530,7 +3374,7 @@
partition_timer_on = 0;
}
#endif
- av1_restore_context(x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
}
// Check if AB partitions search is allowed.
@@ -2647,9 +3491,13 @@
blk_params.subsize = get_partition_subsize(bsize, part_type);
for (int i = 0; i < SUB_PARTITIONS_AB; i++) {
+ assert(cur_part_ctxs[ab_part_type] != NULL);
// Set AB partition context.
- cur_part_ctxs[ab_part_type][i] =
- av1_alloc_pmc(cm, ab_subsize[ab_part_type][i], &td->shared_coeff_buf);
+ cur_part_ctxs[ab_part_type][i] = av1_alloc_pmc(
+ cm, ab_mi_pos[ab_part_type][i][0], ab_mi_pos[ab_part_type][i][1],
+ ab_subsize[ab_part_type][i], pc_tree, part_type, i,
+ part_search_state->ss_x, part_search_state->ss_y,
+ &td->shared_coeff_buf);
// Set mode as not ready.
cur_part_ctxs[ab_part_type][i]->rd_mode_is_ready = 0;
}
@@ -2691,7 +3539,7 @@
MACROBLOCK *x, const AV1_COMMON *const cm, ThreadData *td,
PICK_MODE_CONTEXT *cur_part_ctx[SUB_PARTITIONS_PART4],
PartitionSearchState *part_search_state, PARTITION_TYPE partition_type,
- BLOCK_SIZE bsize) {
+ BLOCK_SIZE bsize, int mi_pos[SUB_PARTITIONS_PART4][2], PC_TREE *pc_tree) {
// Initialize sum_rdc RD cost structure.
av1_init_rd_stats(&part_search_state->sum_rdc);
const int subsize = get_partition_subsize(bsize, partition_type);
@@ -2699,8 +3547,12 @@
part_search_state->partition_cost[partition_type];
part_search_state->sum_rdc.rdcost =
RDCOST(x->rdmult, part_search_state->sum_rdc.rate, 0);
- for (PART4_TYPES i = 0; i < SUB_PARTITIONS_PART4; ++i)
- cur_part_ctx[i] = av1_alloc_pmc(cm, subsize, &td->shared_coeff_buf);
+ for (PART4_TYPES i = 0; i < SUB_PARTITIONS_PART4; ++i) {
+ cur_part_ctx[i] =
+ av1_alloc_pmc(cm, mi_pos[i][0], mi_pos[i][1], subsize, pc_tree,
+ partition_type, i, part_search_state->ss_x,
+ part_search_state->ss_y, &td->shared_coeff_buf);
+ }
}
// Partition search of HORZ4 / VERT4 partition types.
@@ -2719,11 +3571,11 @@
int mi_pos[SUB_PARTITIONS_PART4][2];
blk_params.subsize = get_partition_subsize(blk_params.bsize, partition_type);
- // Set partition context and RD cost.
- set_4_part_ctx_and_rdcost(x, cm, td, cur_part_ctx, part_search_state,
- partition_type, blk_params.bsize);
// Set mi positions for sub-block sizes.
set_mi_pos_partition4(inc_step, mi_pos, blk_params.mi_row, blk_params.mi_col);
+ // Set partition context and RD cost.
+ set_4_part_ctx_and_rdcost(x, cm, td, cur_part_ctx, part_search_state,
+ partition_type, blk_params.bsize, mi_pos, pc_tree);
#if CONFIG_COLLECT_PARTITION_STATS
if (best_rdc.rdcost - part_search_state->sum_rdc.rdcost >= 0) {
partition_attempts[partition_type] += 1;
@@ -2761,7 +3613,7 @@
partition_timer_on = 0;
}
#endif
- av1_restore_context(x, x_ctx, blk_params.mi_row, blk_params.mi_col,
+ av1_restore_context(cm, x, x_ctx, blk_params.mi_row, blk_params.mi_col,
blk_params.bsize, av1_num_planes(cm));
}
@@ -2822,7 +3674,8 @@
part_search_state->ss_x,
part_search_state->ss_y) != BLOCK_INVALID;
}
- // Pruning: pruning out 4-way partitions based on the current best partition.
+ // Pruning: pruning out 4-way partitions based on the current best
+ // partition.
if (cpi->sf.part_sf.prune_ext_partition_types_search_level == 2) {
part4_search_allowed[HORZ4] &= (pc_tree->partitioning == PARTITION_HORZ ||
pc_tree->partitioning == PARTITION_HORZ_A ||
@@ -2848,18 +3701,34 @@
pb_source_variance, mi_row, mi_col);
}
- // Pruning: pruning out 4-way partitions based on the number of horz/vert wins
- // in the current block and sub-blocks in PARTITION_SPLIT.
+ // Pruning: pruning out 4-way partitions based on the number of horz/vert
+ // wins in the current block and sub-blocks in PARTITION_SPLIT.
prune_4_partition_using_split_info(cpi, x, part_search_state,
part4_search_allowed);
}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE allowed flag.
static AOM_INLINE void set_part_none_allowed_flag(
- AV1_COMP *const cpi, PartitionSearchState *part_search_state) {
+ const AV1_COMP *const cpi,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ TREE_TYPE tree_type,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ PartitionSearchState *part_search_state) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ if (tree_type == CHROMA_PART && blk_params.bsize == BLOCK_8X8) {
+ part_search_state->partition_none_allowed = 1;
+ return;
+ }
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (is_bsize_geq(blk_params.min_partition_size, blk_params.bsize) &&
+ blk_params.has_rows && blk_params.has_cols)
+#else
if ((blk_params.width <= blk_params.min_partition_size_1d) &&
blk_params.has_rows && blk_params.has_cols)
+#endif // CONFIG_EXT_RECUR_PARTITIONS
part_search_state->partition_none_allowed = 1;
assert(part_search_state->terminate_partition_search == 0);
@@ -2887,11 +3756,14 @@
RD_STATS partition_rdcost;
// Set PARTITION_NONE context.
if (pc_tree->none == NULL)
- pc_tree->none = av1_alloc_pmc(cm, blk_params.bsize, &td->shared_coeff_buf);
+ pc_tree->none = av1_alloc_pmc(
+ cm, blk_params.mi_row, blk_params.mi_col, blk_params.bsize, pc_tree,
+ PARTITION_NONE, 0, part_search_state->ss_x, part_search_state->ss_y,
+ &td->shared_coeff_buf);
// Set PARTITION_NONE type cost.
if (part_search_state->partition_none_allowed) {
- if (blk_params.bsize_at_least_8x8) {
+ if (part_search_state->is_block_splittable) {
*pt_cost = part_search_state->partition_cost[PARTITION_NONE] < INT_MAX
? part_search_state->partition_cost[PARTITION_NONE]
: 0;
@@ -2916,22 +3788,37 @@
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
+#if !CONFIG_EXT_RECUR_PARTITIONS
const CommonModeInfoParams *const mi_params = &cm->mi_params;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
RD_STATS *this_rdc = &part_search_state->this_rdc;
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (void)sms_tree;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+
if (!frame_is_intra_only(cm) &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ part_search_state->do_rectangular_split &&
+#else
(part_search_state->do_square_split ||
part_search_state->do_rectangular_split) &&
+#endif
!x->e_mbd.lossless[xd->mi[0]->segment_id] && ctx_none->skippable) {
const int use_ml_based_breakout =
bsize <= cpi->sf.part_sf.use_square_partition_only_threshold &&
+#if CONFIG_EXT_RECUR_PARTITIONS
+ is_square_block(bsize) &&
+#endif // CONFIG_EXT_RECUR_PARTITIONS
bsize > BLOCK_4X4 && xd->bd == 8;
if (use_ml_based_breakout) {
if (av1_ml_predict_breakout(cpi, bsize, x, this_rdc,
*pb_source_variance)) {
+#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split = 0;
+#endif
part_search_state->do_rectangular_split = 0;
}
}
@@ -2951,11 +3838,14 @@
// disable the early termination at that speed.
if (best_rdc->dist < dist_breakout_thr &&
best_rdc->rate < rate_breakout_thr) {
+#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split = 0;
+#endif
part_search_state->do_rectangular_split = 0;
}
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Early termination: using simple_motion_search features and the
// rate, distortion, and rdcost of PARTITION_NONE, a DNN will make a
// decision on early terminating at PARTITION_NONE.
@@ -2971,8 +3861,10 @@
cpi, x, sms_tree, blk_params.mi_row, blk_params.mi_col, bsize, this_rdc,
&part_search_state->terminate_partition_search);
}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Decide early termination and rectangular partition pruning
// based on PARTITION_NONE and PARTITION_SPLIT costs.
static void prune_partitions_after_split(
@@ -2986,6 +3878,13 @@
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (void)sms_tree;
+ (void)part_none_rd;
+ (void)part_split_rd;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Early termination: using the rd costs of PARTITION_NONE and subblocks
// from PARTITION_SPLIT to determine an early breakout.
if (cpi->sf.part_sf.ml_early_term_after_part_split_level &&
@@ -2999,6 +3898,7 @@
part_search_state->split_rd, mi_row, mi_col,
&part_search_state->terminate_partition_search);
}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Use the rd costs of PARTITION_NONE and subblocks from PARTITION_SPLIT
// to prune out rectangular partitions in some directions.
@@ -3010,13 +3910,14 @@
part_search_state->prune_rect_part[VERT]) &&
!part_search_state->terminate_partition_search) {
av1_setup_src_planes(x, cpi->source, mi_row, mi_col, av1_num_planes(cm),
- bsize);
+ NULL);
av1_ml_prune_rect_partition(
cpi, x, bsize, best_rdc->rdcost, part_search_state->none_rd,
part_search_state->split_rd, &part_search_state->prune_rect_part[HORZ],
&part_search_state->prune_rect_part[VERT]);
}
}
+#endif
// PARTITION_NONE search.
static void none_partition_search(
@@ -3033,8 +3934,15 @@
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (void)part_none_rd;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE allowed flag.
- set_part_none_allowed_flag(cpi, part_search_state);
+ set_part_none_allowed_flag(cpi,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ x->e_mbd.tree_type,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ part_search_state);
if (!part_search_state->partition_none_allowed) return;
int pt_cost = 0;
@@ -3052,9 +3960,21 @@
partition_timer_on = 1;
}
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+ SimpleMotionData *sms_data = av1_get_sms_data_entry(
+ x->sms_bufs, mi_row, mi_col, bsize, cm->seq_params.sb_size);
+ av1_set_best_mode_cache(x, sms_data->mode_cache);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// PARTITION_NONE evaluation and cost update.
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, this_rdc, PARTITION_NONE,
bsize, pc_tree->none, best_remain_rdcost);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ x->inter_mode_cache = NULL;
+ if (this_rdc->rate != INT_MAX) {
+ av1_add_mode_search_context_to_cache(sms_data, pc_tree->none);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_rd_cost_update(x->rdmult, this_rdc);
#if CONFIG_COLLECT_PARTITION_STATS
@@ -3078,17 +3998,23 @@
}
// Calculate the total cost and update the best partition.
- if (blk_params.bsize_at_least_8x8) {
+ if (part_search_state->is_block_splittable) {
this_rdc->rate += pt_cost;
this_rdc->rdcost = RDCOST(x->rdmult, this_rdc->rate, this_rdc->dist);
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
*part_none_rd = this_rdc->rdcost;
+#endif
if (this_rdc->rdcost < best_rdc->rdcost) {
*best_rdc = *this_rdc;
part_search_state->found_best_partition = true;
+#if !CONFIG_EXT_RECUR_PARTITIONS
if (blk_params.bsize_at_least_8x8) {
pc_tree->partitioning = PARTITION_NONE;
}
+#else
+ pc_tree->partitioning = PARTITION_NONE;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Disable split and rectangular partition search
// based on PARTITION_NONE cost.
@@ -3097,9 +4023,10 @@
pb_source_variance);
}
}
- av1_restore_context(x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
// PARTITION_SPLIT search.
static void split_partition_search(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
@@ -3122,12 +4049,6 @@
!part_search_state->do_square_split)
return;
- for (int i = 0; i < SUB_PARTITIONS_SPLIT; ++i) {
- if (pc_tree->split[i] == NULL)
- pc_tree->split[i] = av1_alloc_pc_tree_node(subsize);
- pc_tree->split[i]->index = i;
- }
-
// Initialization of this partition RD stats.
av1_init_rd_stats(&sum_rdc);
sum_rdc.rate = part_search_state->partition_cost[PARTITION_SPLIT];
@@ -3151,7 +4072,11 @@
mi_col + x_idx >= mi_params->mi_cols)
continue;
- pc_tree->split[idx]->index = idx;
+ if (pc_tree->split[idx] == NULL) {
+ pc_tree->split[idx] = av1_alloc_pc_tree_node(
+ mi_row + y_idx, mi_col + x_idx, subsize, pc_tree, PARTITION_SPLIT,
+ idx, idx == 3, part_search_state->ss_x, part_search_state->ss_y);
+ }
int64_t *p_split_rd = &part_search_state->split_rd[idx];
RD_STATS best_remain_rdcost;
av1_rd_stats_subtraction(x->rdmult, best_rdc, &sum_rdc,
@@ -3224,9 +4149,453 @@
!(partition_none_valid && partition_none_better);
}
}
- av1_restore_context(x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
+}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+/*!\cond */
+typedef struct {
+ SIMPLE_MOTION_DATA_TREE *sms_tree;
+ PC_TREE *pc_tree;
+#if CONFIG_SDP
+ const PARTITION_TREE *ptree_luma;
+ const PARTITION_TREE *template_tree;
+#endif // CONFIG_SDP
+ PICK_MODE_CONTEXT *ctx;
+ int mi_row;
+ int mi_col;
+ BLOCK_SIZE bsize;
+ PARTITION_TYPE partition;
+ int is_last_subblock;
+ int is_splittable;
+} SUBBLOCK_RDO_DATA;
+/*!\endcond */
+
+// Try searching for an encoding for the given subblock. Returns zero if the
+// rdcost is already too high (to tell the caller not to bother searching for
+// encodings of further subblocks)
+static int rd_try_subblock_new(AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp,
+ SUBBLOCK_RDO_DATA *rdo_data,
+ RD_STATS best_rdcost, RD_STATS *sum_rdc,
+ SB_MULTI_PASS_MODE multi_pass_mode) {
+ MACROBLOCK *const x = &td->mb;
+ const int orig_mult = x->rdmult;
+ const int mi_row = rdo_data->mi_row;
+ const int mi_col = rdo_data->mi_col;
+ const BLOCK_SIZE bsize = rdo_data->bsize;
+
+ setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL);
+
+ av1_rd_cost_update(x->rdmult, &best_rdcost);
+
+ RD_STATS rdcost_remaining;
+ av1_rd_stats_subtraction(x->rdmult, &best_rdcost, sum_rdc, &rdcost_remaining);
+ RD_STATS this_rdc;
+
+ if (rdo_data->is_splittable) {
+ if (!av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, bsize,
+ &this_rdc, rdcost_remaining, rdo_data->pc_tree,
+#if CONFIG_SDP
+ rdo_data->ptree_luma, rdo_data->template_tree,
+#endif // CONFIG_SDP
+ rdo_data->sms_tree, NULL, multi_pass_mode,
+ NULL)) {
+ av1_invalid_rd_stats(sum_rdc);
+ return 0;
+ }
+ } else {
+ const BLOCK_SIZE sb_size = cpi->common.seq_params.sb_size;
+ SimpleMotionData *sms_data =
+ av1_get_sms_data_entry(x->sms_bufs, mi_row, mi_col, bsize, sb_size);
+ av1_set_best_mode_cache(x, sms_data->mode_cache);
+
+ pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &this_rdc,
+ rdo_data->partition, bsize, rdo_data->ctx, rdcost_remaining);
+
+ x->inter_mode_cache = NULL;
+ if (this_rdc.rate != INT_MAX) {
+ av1_add_mode_search_context_to_cache(sms_data, rdo_data->ctx);
+ }
+ }
+
+ if (this_rdc.rate == INT_MAX) {
+ sum_rdc->rdcost = INT64_MAX;
+ } else {
+ sum_rdc->rate += this_rdc.rate;
+ sum_rdc->dist += this_rdc.dist;
+ av1_rd_cost_update(x->rdmult, sum_rdc);
+ }
+
+ if (sum_rdc->rdcost >= best_rdcost.rdcost) {
+ x->rdmult = orig_mult;
+ return 0;
+ }
+
+ if (!rdo_data->is_last_subblock && !rdo_data->is_splittable) {
+ av1_update_state(cpi, td, rdo_data->ctx, mi_row, mi_col, bsize, 1);
+ encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, bsize, NULL);
+ }
+
+ x->rdmult = orig_mult;
+ return 1;
}
+static INLINE void search_partition_horz_3(
+ PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+ PC_TREE *pc_tree,
+#if CONFIG_SDP
+ const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
+#endif // CONFIG_SDP
+ RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx, SB_MULTI_PASS_MODE multi_pass_mode) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &td->mb;
+ const int num_planes = av1_num_planes(cm);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ MACROBLOCKD *const xd = &x->e_mbd;
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+ const PartitionBlkParams *blk_params = &search_state->part_blk_params;
+ const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
+ const BLOCK_SIZE bsize = blk_params->bsize;
+
+ const BLOCK_SIZE sml_subsize = get_partition_subsize(bsize, PARTITION_HORZ_3);
+ const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
+
+ if (search_state->terminate_partition_search || !blk_params->has_rows ||
+ !is_partition_valid(bsize, PARTITION_HORZ_3) ||
+ !(search_state->do_rectangular_split ||
+ av1_active_h_edge(cpi, mi_row, blk_params->mi_step_h))) {
+ return;
+ }
+
+ const int part_h3_rate = search_state->partition_cost[PARTITION_HORZ_3];
+ if (part_h3_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_h3_rate, 0) >= best_rdc->rdcost) {
+ return;
+ }
+ RD_STATS sum_rdc;
+ av1_init_rd_stats(&sum_rdc);
+ const int quarter_step = mi_size_high[bsize] / 4;
+
+ sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_3];
+ sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
+
+ const int step_multipliers[3] = { 0, 1, 2 };
+ const BLOCK_SIZE subblock_sizes[3] = { sml_subsize, big_subsize,
+ sml_subsize };
+
+ for (int idx = 0; idx < 3; idx++) {
+ if (pc_tree->horizontal3[idx]) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal3[idx], num_planes, 0, 0);
+ pc_tree->horizontal3[idx] = NULL;
+ }
+ }
+ pc_tree->horizontal3[0] =
+ av1_alloc_pc_tree_node(mi_row, mi_col, subblock_sizes[0], pc_tree,
+ PARTITION_HORZ_3, 0, 0, ss_x, ss_y);
+ pc_tree->horizontal3[1] =
+ av1_alloc_pc_tree_node(mi_row + quarter_step, mi_col, subblock_sizes[1],
+ pc_tree, PARTITION_HORZ_3, 1, 0, ss_x, ss_y);
+ pc_tree->horizontal3[2] = av1_alloc_pc_tree_node(
+ mi_row + quarter_step * 3, mi_col, subblock_sizes[2], pc_tree,
+ PARTITION_HORZ_3, 2, 1, ss_x, ss_y);
+
+ if (cpi->sf.part_sf.enable_fast_erp && !frame_is_intra_only(cm) &&
+ !x->must_find_valid_partition && is_bsize_pruning_cand(bsize)) {
+ const SimpleMotionData *up = av1_get_sms_data(
+ cpi, &tile_data->tile_info, x, mi_row, mi_col, subblock_sizes[0]);
+ const SimpleMotionData *middle =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, mi_row + quarter_step,
+ mi_col, subblock_sizes[1]);
+ const SimpleMotionData *down =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x,
+ mi_row + 3 * quarter_step, mi_col, subblock_sizes[2]);
+
+ SMSPartitionStats part_data;
+ part_data.sms_data[0] = up;
+ part_data.sms_data[1] = middle;
+ part_data.sms_data[2] = down;
+ part_data.num_sub_parts = 3;
+ part_data.part_rate = part_h3_rate;
+
+ if (best_rdc->rdcost < INT64_MAX &&
+ (blk_params->mi_row + 2 * (blk_params->mi_step_h) <=
+ cm->mi_params.mi_rows) &&
+ (blk_params->mi_col + 2 * (blk_params->mi_step_w) <=
+ cm->mi_params.mi_cols) &&
+ av1_prune_new_part(&search_state->none_data, &part_data, x->rdmult,
+ blk_params->bsize, &cpi->sf)) {
+ const BLOCK_SIZE midsize = subblock_sizes[1];
+ const BLOCK_SIZE subsubsize =
+ get_partition_subsize(midsize, PARTITION_VERT);
+ if (subsubsize == BLOCK_INVALID) {
+ return;
+ }
+
+ // Do one more check to deal with recursion
+ SMSPartitionStats subpart_data;
+ const SimpleMotionData *midleft =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, mi_row + quarter_step,
+ mi_col + 2 * quarter_step, subsubsize);
+ const SimpleMotionData *midright =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, mi_row + quarter_step,
+ mi_col + 2 * quarter_step, subsubsize);
+ subpart_data.sms_data[0] = up;
+ subpart_data.sms_data[1] = midleft;
+ subpart_data.sms_data[2] = midright;
+ subpart_data.sms_data[3] = down;
+ subpart_data.num_sub_parts = 4;
+ subpart_data.part_rate = 0;
+ if (av1_prune_new_part(&search_state->none_data, &subpart_data, x->rdmult,
+ bsize, &cpi->sf)) {
+ return;
+ }
+ }
+ }
+
+ int this_mi_row = mi_row;
+ for (int i = 0; i < 3; ++i) {
+ this_mi_row += quarter_step * step_multipliers[i];
+
+ if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
+
+ SUBBLOCK_RDO_DATA rdo_data = {
+ NULL,
+ pc_tree->horizontal3[i],
+#if CONFIG_SDP
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree, i),
+#endif // CONFIG_SDP
+ NULL,
+ this_mi_row,
+ mi_col,
+ subblock_sizes[i],
+ PARTITION_HORZ_3,
+ i == 2,
+ 1
+ };
+ if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
+ &sum_rdc, multi_pass_mode)) {
+ av1_invalid_rd_stats(&sum_rdc);
+ break;
+ }
+ }
+
+ av1_rd_cost_update(x->rdmult, &sum_rdc);
+ if (sum_rdc.rdcost < best_rdc->rdcost) {
+ *best_rdc = sum_rdc;
+ search_state->found_best_partition = true;
+ pc_tree->partitioning = PARTITION_HORZ_3;
+ }
+
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+}
+
+static INLINE void search_partition_vert_3(
+ PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+ PC_TREE *pc_tree,
+#if CONFIG_SDP
+ const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
+#endif // CONFIG_SDP
+ RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx, SB_MULTI_PASS_MODE multi_pass_mode) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &td->mb;
+ const int num_planes = av1_num_planes(cm);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ MACROBLOCKD *const xd = &x->e_mbd;
+ const int ss_x = xd->plane[1].subsampling_x;
+ const int ss_y = xd->plane[1].subsampling_y;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+ const PartitionBlkParams *blk_params = &search_state->part_blk_params;
+ const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
+ const BLOCK_SIZE bsize = blk_params->bsize;
+
+ const BLOCK_SIZE sml_subsize = get_partition_subsize(bsize, PARTITION_VERT_3);
+ const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_VERT);
+
+ if (search_state->terminate_partition_search || !blk_params->has_cols ||
+ !is_partition_valid(bsize, PARTITION_VERT_3) ||
+ !(search_state->do_rectangular_split ||
+ av1_active_v_edge(cpi, mi_row, blk_params->mi_step_h))) {
+ return;
+ }
+
+ const int part_v3_rate = search_state->partition_cost[PARTITION_VERT_3];
+ if (part_v3_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_v3_rate, 0) >= best_rdc->rdcost) {
+ return;
+ }
+
+ RD_STATS sum_rdc;
+ av1_init_rd_stats(&sum_rdc);
+ const int quarter_step = mi_size_wide[bsize] / 4;
+
+ sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_3];
+ sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
+
+ const int step_multipliers[3] = { 0, 1, 2 };
+ const BLOCK_SIZE subblock_sizes[3] = { sml_subsize, big_subsize,
+ sml_subsize };
+
+ for (int idx = 0; idx < 3; idx++) {
+ if (pc_tree->vertical3[idx]) {
+ av1_free_pc_tree_recursive(pc_tree->vertical3[idx], num_planes, 0, 0);
+ pc_tree->vertical3[idx] = NULL;
+ }
+ }
+ pc_tree->vertical3[0] =
+ av1_alloc_pc_tree_node(mi_row, mi_col, subblock_sizes[0], pc_tree,
+ PARTITION_VERT_3, 0, 0, ss_x, ss_y);
+ pc_tree->vertical3[1] =
+ av1_alloc_pc_tree_node(mi_row, mi_col + quarter_step, subblock_sizes[1],
+ pc_tree, PARTITION_VERT_3, 1, 0, ss_x, ss_y);
+ pc_tree->vertical3[2] = av1_alloc_pc_tree_node(
+ mi_row, mi_col + quarter_step * 3, subblock_sizes[2], pc_tree,
+ PARTITION_VERT_3, 2, 1, ss_x, ss_y);
+
+ if (cpi->sf.part_sf.enable_fast_erp && !frame_is_intra_only(cm) &&
+ !x->must_find_valid_partition && is_bsize_pruning_cand(bsize)) {
+ const SimpleMotionData *left = av1_get_sms_data(
+ cpi, &tile_data->tile_info, x, mi_row, mi_col, subblock_sizes[0]);
+ const SimpleMotionData *middle =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, mi_row,
+ mi_col + quarter_step, subblock_sizes[1]);
+ const SimpleMotionData *right =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, mi_row,
+ mi_col + 3 * quarter_step, subblock_sizes[2]);
+
+ SMSPartitionStats part_data;
+ part_data.sms_data[0] = left;
+ part_data.sms_data[1] = middle;
+ part_data.sms_data[2] = right;
+ part_data.num_sub_parts = 3;
+ part_data.part_rate = part_v3_rate;
+
+ if (best_rdc->rdcost < INT64_MAX &&
+ (blk_params->mi_row + 2 * blk_params->mi_step_h <=
+ cm->mi_params.mi_rows) &&
+ (blk_params->mi_col + 2 * blk_params->mi_step_w <=
+ cm->mi_params.mi_cols) &&
+ av1_prune_new_part(&search_state->none_data, &part_data, x->rdmult,
+ blk_params->bsize, &cpi->sf)) {
+ const BLOCK_SIZE midsize = subblock_sizes[1];
+ const BLOCK_SIZE subsubsize =
+ get_partition_subsize(midsize, PARTITION_HORZ);
+ if (subsubsize == BLOCK_INVALID) {
+ return;
+ }
+
+ // Do one more check to deal with recursion
+ SMSPartitionStats subpart_data;
+ const SimpleMotionData *leftmid =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, mi_row,
+ mi_col + quarter_step, subsubsize);
+ const SimpleMotionData *rightmid = av1_get_sms_data(
+ cpi, &tile_data->tile_info, x, mi_row + 2 * quarter_step,
+ mi_col + quarter_step, subsubsize);
+ subpart_data.sms_data[0] = left;
+ subpart_data.sms_data[1] = leftmid;
+ subpart_data.sms_data[2] = rightmid;
+ subpart_data.sms_data[3] = right;
+ subpart_data.num_sub_parts = 4;
+ subpart_data.part_rate = 0;
+ if (av1_prune_new_part(&search_state->none_data, &subpart_data, x->rdmult,
+ bsize, &cpi->sf)) {
+ return;
+ }
+ }
+ }
+
+ int this_mi_col = mi_col;
+ for (int i = 0; i < 3; ++i) {
+ this_mi_col += quarter_step * step_multipliers[i];
+
+ if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
+
+ SUBBLOCK_RDO_DATA rdo_data = {
+ NULL,
+ pc_tree->vertical3[i],
+#if CONFIG_SDP
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree, i),
+#endif // CONFIG_SDP
+ NULL,
+ mi_row,
+ this_mi_col,
+ subblock_sizes[i],
+ PARTITION_VERT_3,
+ i == 2,
+ 1
+ };
+ if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
+ &sum_rdc, multi_pass_mode)) {
+ av1_invalid_rd_stats(&sum_rdc);
+ break;
+ }
+ }
+
+ av1_rd_cost_update(x->rdmult, &sum_rdc);
+ if (sum_rdc.rdcost < best_rdc->rdcost) {
+ *best_rdc = sum_rdc;
+ search_state->found_best_partition = true;
+ pc_tree->partitioning = PARTITION_VERT_3;
+ }
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+/*!\brief AV1 block partition search (full search).
+*
+* \ingroup partition_search
+* \callgraph
+* Searches for the best partition pattern for a block based on the
+* rate-distortion cost, and returns a bool value to indicate whether a valid
+* partition pattern is found. The partition can recursively go down to the
+* smallest block size.
+*
+* \param[in] cpi Top-level encoder structure
+* \param[in] td Pointer to thread data
+* \param[in] tile_data Pointer to struct holding adaptive
+data/contexts/models for the tile during
+encoding
+* \param[in] tp Pointer to the starting token
+* \param[in] mi_row Row coordinate of the block in a step size
+of MI_SIZE
+* \param[in] mi_col Column coordinate of the block in a step
+size of MI_SIZE
+* \param[in] bsize Current block size
+* \param[in] rd_cost Pointer to the final rd cost of the block
+* \param[in] best_rdc Upper bound of rd cost of a valid partition
+* \param[in] pc_tree Pointer to the PC_TREE node storing the
+picked partitions and mode info for the
+current block
+* \param[in] ptree_luma Pointer to the luma partition tree so that the
+* encoder to estimate the partition type for chroma.
+* \param[in] template_tree A partial tree that contains the partition
+* structure to be used as a template.
+* \param[in] sms_tree Pointer to struct holding simple motion
+search data for the current block
+* \param[in] none_rd Pointer to the rd cost in the case of not
+splitting the current block
+* \param[in] multi_pass_mode SB_SINGLE_PASS/SB_DRY_PASS/SB_WET_PASS
+* \param[in] rect_part_win_info Pointer to struct storing whether horz/vert
+partition outperforms previously tested
+partitions
+*
+* \return A bool value is returned indicating if a valid partition is found.
+* The pc_tree struct is modified to store the picked partition and modes.
+* The rd_cost struct is also updated with the RD stats corresponding to the
+* best partition found.
+*/
+#else
/*!\brief AV1 block partition search (full search).
*
* \ingroup partition_search
@@ -3266,10 +4635,15 @@
* The rd_cost struct is also updated with the RD stats corresponding to the
* best partition found.
*/
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
bool av1_rd_pick_partition(AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
int mi_col, BLOCK_SIZE bsize, RD_STATS *rd_cost,
RD_STATS best_rdc, PC_TREE *pc_tree,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
SIMPLE_MOTION_DATA_TREE *sms_tree, int64_t *none_rd,
SB_MULTI_PASS_MODE multi_pass_mode,
RD_RECT_PART_WIN_INFO *rect_part_win_info) {
@@ -3282,15 +4656,57 @@
const TokenExtra *const tp_orig = *tp;
PartitionSearchState part_search_state;
// Initialization of state variables used in partition search.
- init_partition_search_state_params(x, cpi, &part_search_state, mi_row, mi_col,
- bsize);
+ init_partition_search_state_params(x, cpi, &part_search_state,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ pc_tree,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ mi_row, mi_col, bsize);
PartitionBlkParams blk_params = part_search_state.part_blk_params;
-
- sms_tree->partitioning = PARTITION_NONE;
+#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_SDP
+ const PARTITION_TYPE forced_partition =
+ get_forced_partition_type(cm, x, mi_row, mi_col, bsize, template_tree);
+#else
+ const PARTITION_TYPE forced_partition =
+ get_forced_partition_type(cm, x, mi_row, mi_col, bsize);
+#endif // CONFIG_SDP
+ if (sms_tree != NULL)
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ sms_tree->partitioning = PARTITION_NONE;
if (best_rdc.rdcost < 0) {
av1_invalid_rd_stats(rd_cost);
return part_search_state.found_best_partition;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // Check whether there is a counterpart pc_tree node with the same size
+ // and the same neighboring context at the same location but from a
+ // different partition path. If yes directly copy the RDO decision made for
+ // the counterpart.
+ PC_TREE *counterpart_block = av1_look_for_counterpart_block(pc_tree);
+ if (counterpart_block) {
+ if (counterpart_block->rd_cost.rate != INT_MAX) {
+ av1_copy_pc_tree_recursive(cm, pc_tree, counterpart_block,
+ part_search_state.ss_x, part_search_state.ss_y,
+ &td->shared_coeff_buf, num_planes);
+ *rd_cost = pc_tree->rd_cost;
+ assert(bsize != cm->seq_params.sb_size);
+ if (bsize == cm->seq_params.sb_size) exit(0);
+
+ if (!pc_tree->is_last_subblock) {
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
+ pc_tree, NULL,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ NULL);
+ }
+ return true;
+ } else {
+ av1_invalid_rd_stats(rd_cost);
+ return false;
+ }
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (bsize == cm->seq_params.sb_size) x->must_find_valid_partition = 0;
// Override skipping rectangular partition operations for edge blocks.
@@ -3334,10 +4750,14 @@
sizeof(x->txfm_search_info.blk_skip));
#endif // NDEBUG
+ assert(bsize < BLOCK_SIZES_ALL);
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(mi_size_wide[bsize] == mi_size_high[bsize]);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Set buffers and offsets.
- av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize);
+ av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize,
+ &pc_tree->chroma_ref_info);
// Save rdmult before it might be changed, so it can be restored later.
const int orig_rdmult = x->rdmult;
@@ -3358,6 +4778,7 @@
int *partition_horz_allowed = &part_search_state.partition_rect_allowed[HORZ];
int *partition_vert_allowed = &part_search_state.partition_rect_allowed[VERT];
+#if !CONFIG_EXT_RECUR_PARTITIONS
int *prune_horz = &part_search_state.prune_rect_part[HORZ];
int *prune_vert = &part_search_state.prune_rect_part[VERT];
// Pruning: before searching any partition type, using source and simple
@@ -3367,17 +4788,45 @@
&part_search_state.partition_none_allowed, partition_horz_allowed,
partition_vert_allowed, &part_search_state.do_rectangular_split,
&part_search_state.do_square_split, prune_horz, prune_vert);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
- // Pruning: eliminating partition types leading to coding block sizes outside
- // the min and max bsize limitations set from the encoder.
+ // Pruning: eliminating partition types leading to coding block sizes
+ // outside the min and max bsize limitations set from the encoder.
av1_prune_partitions_by_max_min_bsize(
&x->sb_enc, bsize, blk_params.has_rows && blk_params.has_cols,
&part_search_state.partition_none_allowed, partition_horz_allowed,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ partition_vert_allowed, NULL);
+#else
partition_vert_allowed, &part_search_state.do_square_split);
+#endif
#if CONFIG_SDP
int luma_split_flag = 0;
- int parent_block_width = block_size_wide[bsize];
+ const int parent_block_width = block_size_wide[bsize];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int min_bsize_1d = AOMMIN(block_size_high[bsize], parent_block_width);
+ int horz_3_allowed_sdp = 1;
+ int vert_3_allowed_sdp = 1;
+ if (xd->tree_type == CHROMA_PART && min_bsize_1d >= SHARED_PART_SIZE &&
+ ptree_luma) {
+ PARTITION_TYPE derived_partition_mode = sdp_chroma_part_from_luma(
+ bsize, ptree_luma->partition, part_search_state.ss_x,
+ part_search_state.ss_y);
+
+ if (derived_partition_mode != PARTITION_NONE)
+ part_search_state.partition_none_allowed = BLOCK_INVALID;
+ if (derived_partition_mode != PARTITION_HORZ)
+ part_search_state.partition_rect_allowed[HORZ] = 0;
+ if (derived_partition_mode != PARTITION_VERT)
+ part_search_state.partition_rect_allowed[VERT] = 0;
+ if (derived_partition_mode != PARTITION_HORZ_3) horz_3_allowed_sdp = 0;
+ if (derived_partition_mode != PARTITION_VERT_3) vert_3_allowed_sdp = 0;
+
+ // TODO(yuec): Need to make sure there is at least one valid partition
+ // mode
+ }
+#else // CONFIG_EXT_RECUR_PARTITIONS
const CommonModeInfoParams *const mi_params = &cm->mi_params;
if (xd->tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) {
luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
@@ -3388,25 +4837,50 @@
part_search_state.partition_rect_allowed[HORZ] = 0;
part_search_state.partition_rect_allowed[VERT] = 0;
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#endif
// Partition search
BEGIN_PARTITION_SEARCH:
- // If a valid partition is required, usually when the first round cannot find
- // a valid one under the cost limit after pruning, reset the limitations on
- // partition types.
+ // If a valid partition is required, usually when the first round cannot
+ // find a valid one under the cost limit after pruning, reset the
+ // limitations on partition types.
if (x->must_find_valid_partition)
- reset_part_limitations(cpi, &part_search_state);
+ reset_part_limitations(cpi,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ xd->tree_type,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+ pc_tree,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ &part_search_state);
// Partition block source pixel variance.
unsigned int pb_source_variance = UINT_MAX;
// PARTITION_NONE search stage.
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (cpi->sf.part_sf.enable_fast_erp && !frame_is_intra_only(cm)) {
+ const SimpleMotionData *whole =
+ av1_get_sms_data(cpi, tile_info, x, mi_row, mi_col, bsize);
+ part_search_state.none_data.sms_data[0] = whole;
+ part_search_state.none_data.num_sub_parts = 1;
+ part_search_state.none_data.part_rate =
+ part_search_state.partition_cost[PARTITION_NONE];
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
int64_t part_none_rd = INT64_MAX;
- none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
- &part_search_state, &best_rdc, &pb_source_variance,
- none_rd, &part_none_rd);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (IS_FORCED_PARTITION_TYPE(PARTITION_NONE)) {
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
+ &part_search_state, &best_rdc, &pb_source_variance,
+ none_rd, &part_none_rd);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
// PARTITION_SPLIT search stage.
int64_t part_split_rd = INT64_MAX;
split_partition_search(cpi, td, tile_data, tp, x, pc_tree, sms_tree, &x_ctx,
@@ -3424,14 +4898,21 @@
// Prune partitions based on PARTITION_NONE and PARTITION_SPLIT.
prune_partitions_after_split(cpi, x, sms_tree, &part_search_state, &best_rdc,
part_none_rd, part_split_rd);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Rectangular partitions search stage.
rectangular_partition_search(cpi, td, tile_data, tp, x, pc_tree, &x_ctx,
&part_search_state, &best_rdc,
+#if CONFIG_EXT_RECUR_PARTITIONS
+ multi_pass_mode,
+#if CONFIG_SDP
+ ptree_luma, template_tree,
+#endif // CONFIG_SDP
+#endif // CONFIG_EXT_RECUR_PARTITIONS
rect_part_win_info);
if (pb_source_variance == UINT_MAX) {
- av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, bsize);
+ av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, NULL);
if (is_cur_buf_hbd(xd)) {
pb_source_variance = av1_high_get_sby_perpixel_variance(
cpi, &x->plane[0].src, bsize, xd->bd);
@@ -3444,6 +4925,7 @@
assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
!part_search_state.do_rectangular_split));
+#if !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_SDP
const int ext_partition_allowed =
part_search_state.do_rectangular_split &&
@@ -3454,7 +4936,7 @@
part_search_state.do_rectangular_split &&
bsize > cpi->sf.part_sf.ext_partition_eval_thresh &&
blk_params.has_rows && blk_params.has_cols;
-#endif
+#endif // CONFIG_SDP
// AB partitions search stage.
ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
@@ -3464,18 +4946,13 @@
// 4-way partitions search stage.
int part4_search_allowed[NUM_PART4_TYPES] = { 1, 1 };
- // Disable 4-way partition search flags for width less than twice the minimum
- // width.
-#if CONFIG_SDP
+ // Disable 4-way partition search flags for width less than twice the
+ // minimum width.
#if CONFIG_SDP
if (blk_params.width < (blk_params.min_partition_size_1d << 2) ||
(xd->tree_type == CHROMA_PART && bsize <= BLOCK_16X16) ||
(luma_split_flag > 3)) {
#else
- if (blk_params.width < (blk_params.min_partition_size_1d << 2) ||
- (xd->tree_type == CHROMA_PART && bsize <= BLOCK_16X16)) {
-#endif
-#else
if (blk_params.width < (blk_params.min_partition_size_1d << 2)) {
#endif
part4_search_allowed[HORZ4] = 0;
@@ -3516,6 +4993,69 @@
pc_tree->vertical4, &part_search_state, &best_rdc,
inc_step, PARTITION_VERT_4);
}
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int ext_partition_allowed =
+ (blk_params.has_rows && blk_params.has_cols) || !is_square_block(bsize);
+ const int partition_3_allowed =
+ ext_partition_allowed && bsize != BLOCK_128X128;
+ const int is_wide_block = block_size_wide[bsize] > block_size_high[bsize];
+ const int is_tall_block = block_size_wide[bsize] < block_size_high[bsize];
+ const int horz_3_allowed =
+ partition_3_allowed && (is_square_block(bsize) || is_tall_block) &&
+#if CONFIG_SDP
+ horz_3_allowed_sdp &&
+#endif // CONFIG_SDP
+ check_is_chroma_size_valid(PARTITION_HORZ_3, bsize, mi_row, mi_col,
+ part_search_state.ss_x, part_search_state.ss_y,
+ pc_tree) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_3),
+ blk_params.min_partition_size) &&
+ IMPLIES(cpi->sf.part_sf.prune_part_3_with_part_none,
+ frame_is_intra_only(cm) || forced_partition == PARTITION_HORZ_3 ||
+ pc_tree->partitioning != PARTITION_NONE);
+
+ const int vert_3_allowed =
+ partition_3_allowed && (is_square_block(bsize) || is_wide_block) &&
+#if CONFIG_SDP
+ vert_3_allowed_sdp &&
+#endif // CONFIG_SDP
+ check_is_chroma_size_valid(PARTITION_VERT_3, bsize, mi_row, mi_col,
+ part_search_state.ss_x, part_search_state.ss_y,
+ pc_tree) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_3),
+ blk_params.min_partition_size) &&
+ IMPLIES(cpi->sf.part_sf.prune_part_3_with_part_none,
+ frame_is_intra_only(cm) || forced_partition == PARTITION_VERT_3 ||
+ pc_tree->partitioning != PARTITION_NONE);
+
+ // PARTITION_HORZ_3
+ if (IS_FORCED_PARTITION_TYPE(PARTITION_HORZ_3) && horz_3_allowed) {
+ search_partition_horz_3(
+ &part_search_state, cpi, td, tile_data, tp, &best_rdc, pc_tree,
+#if CONFIG_SDP
+ (ptree_luma && ptree_luma->partition == PARTITION_HORZ_3) ? ptree_luma
+ : NULL,
+
+ template_tree,
+#endif // CONFIG_SDP
+ &x_ctx, multi_pass_mode);
+ }
+
+ // PARTITION_VERT_3
+ if (IS_FORCED_PARTITION_TYPE(PARTITION_VERT_3) && vert_3_allowed) {
+ search_partition_vert_3(
+ &part_search_state, cpi, td, tile_data, tp, &best_rdc, pc_tree,
+#if CONFIG_SDP
+ (ptree_luma && ptree_luma->partition == PARTITION_VERT_3) ? ptree_luma
+ : NULL,
+
+ template_tree,
+#endif // CONFIG_SDP
+ &x_ctx, multi_pass_mode);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (bsize == cm->seq_params.sb_size &&
!part_search_state.found_best_partition) {
@@ -3530,10 +5070,22 @@
// Store the final rd cost
*rd_cost = best_rdc;
+ pc_tree->rd_cost = best_rdc;
+ if (!part_search_state.found_best_partition) {
+ av1_invalid_rd_stats(&pc_tree->rd_cost);
+ } else {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, bsize,
+ cm->seq_params.sb_size, pc_tree->partitioning);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ }
// Also record the best partition in simple motion data tree because it is
// necessary for the related speed features.
- sms_tree->partitioning = pc_tree->partitioning;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (sms_tree)
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ sms_tree->partitioning = pc_tree->partitioning;
#if CONFIG_SDP
if (luma_split_flag > 3) {
@@ -3566,8 +5118,9 @@
#endif
#if CONFIG_COLLECT_PARTITION_STATS == 2
- // If CONFIG_COLLECTION_PARTITION_STATS is 2, then we print out the stats for
- // the whole clip. So we need to pass the information upstream to the encoder.
+ // If CONFIG_COLLECTION_PARTITION_STATS is 2, then we print out the stats
+ // for the whole clip. So we need to pass the information upstream to the
+ // encoder.
const int bsize_idx = av1_get_bsize_idx_for_part_stats(bsize);
int *agg_attempts = part_stats->partition_attempts[bsize_idx];
int *agg_decisions = part_stats->partition_decisions[bsize_idx];
@@ -3585,31 +5138,57 @@
// If a valid partition is found and reconstruction is required for future
// sub-blocks in the same group.
if (part_search_state.found_best_partition && pc_tree->index != 3) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ assert(pc_tree->partitioning != PARTITION_SPLIT);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (bsize == cm->seq_params.sb_size) {
// Encode the superblock.
const int emit_output = multi_pass_mode != SB_DRY_PASS;
const RUN_TYPE run_type = emit_output ? OUTPUT_ENABLED : DRY_RUN_NORMAL;
#if CONFIG_SDP
- x->cb_offset[xd->tree_type == CHROMA_PART] = 0;
-#else
- x->cb_offset = 0;
-#endif
+ const int plane_start = (xd->tree_type == CHROMA_PART);
+ const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes;
+ for (int plane = plane_start; plane < plane_end; plane++) {
+ x->cb_offset[plane] = 0;
+ }
+ av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, run_type, bsize,
- pc_tree, NULL);
- // Dealloc the whole PC_TREE after a superblock is done.
+ pc_tree, xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
+#if CONFIG_EXT_RECUR_PARTITIONS
+ xd->tree_type == CHROMA_PART ? xd->sbi->ptree_root[0] : NULL,
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ NULL);
+#else
+ memset(x->cb_offset, 0, sizeof(x->cb_offset));
+ av1_reset_ptree_in_sbi(xd->sbi);
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, run_type, bsize,
+ pc_tree, xd->sbi->ptree_root, NULL);
+#endif // CONFIG_SDP
+ // Dealloc the whole PC_TREE after a superblock is done.
av1_free_pc_tree_recursive(pc_tree, num_planes, 0, 0);
pc_tree_dealloc = 1;
} else {
// Encode the smaller blocks in DRY_RUN mode.
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
- pc_tree, NULL);
+ pc_tree, NULL,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ NULL,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ NULL);
}
}
+ int keep_tree = 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ keep_tree = should_reuse_mode(x, REUSE_INTER_MODE_IN_INTERFRAME_FLAG |
+ REUSE_INTRA_MODE_IN_INTERFRAME_FLAG);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// If the tree still exists (non-superblock), dealloc most nodes, only keep
// nodes for the best partition and PARTITION_NONE.
- if (pc_tree_dealloc == 0)
+ if (!pc_tree_dealloc && !keep_tree) {
av1_free_pc_tree_recursive(pc_tree, num_planes, 1, 1);
+ }
if (bsize == cm->seq_params.sb_size) {
assert(best_rdc.rate < INT_MAX);
diff --git a/av1/encoder/partition_search.h b/av1/encoder/partition_search.h
index 9d1aa2d..8f5c342a 100644
--- a/av1/encoder/partition_search.h
+++ b/av1/encoder/partition_search.h
@@ -15,25 +15,41 @@
#include "av1/encoder/block.h"
#include "av1/encoder/encoder.h"
#include "av1/encoder/encodeframe.h"
+#include "av1/encoder/encodeframe_utils.h"
#include "av1/encoder/tokenize.h"
void av1_set_offsets_without_segment_id(const AV1_COMP *const cpi,
const TileInfo *const tile,
MACROBLOCK *const x, int mi_row,
- int mi_col, BLOCK_SIZE bsize);
+ int mi_col, BLOCK_SIZE bsize,
+ const CHROMA_REF_INFO *chr_ref_info);
void av1_set_offsets(const AV1_COMP *const cpi, const TileInfo *const tile,
MACROBLOCK *const x, int mi_row, int mi_col,
- BLOCK_SIZE bsize);
+ BLOCK_SIZE bsize, const CHROMA_REF_INFO *chr_ref_info);
void av1_rd_use_partition(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data,
MB_MODE_INFO **mib, TokenExtra **tp, int mi_row,
int mi_col, BLOCK_SIZE bsize, int *rate,
- int64_t *dist, int do_recon, PC_TREE *pc_tree);
+ int64_t *dist, int do_recon, PARTITION_TREE *ptree,
+ PC_TREE *pc_tree);
bool av1_rd_pick_partition(AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
int mi_col, BLOCK_SIZE bsize, RD_STATS *rd_cost,
RD_STATS best_rdc, PC_TREE *pc_tree,
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree,
+#endif // CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
SIMPLE_MOTION_DATA_TREE *sms_tree, int64_t *none_rd,
SB_MULTI_PASS_MODE multi_pass_mode,
RD_RECT_PART_WIN_INFO *rect_part_win_info);
+#if CONFIG_EXT_RECUR_PARTITIONS
+void av1_build_partition_tree_fixed_partitioning(AV1_COMMON *const cm,
+ int mi_row, int mi_col,
+ BLOCK_SIZE bsize,
+ PARTITION_TREE *ptree);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+void setup_block_rdmult(const AV1_COMP *const cpi, MACROBLOCK *const x,
+ int mi_row, int mi_col, BLOCK_SIZE bsize,
+ AQ_MODE aq_mode, MB_MODE_INFO *mbmi);
#endif // AOM_AV1_ENCODER_PARTITION_SEARCH_H_
diff --git a/av1/encoder/partition_strategy.c b/av1/encoder/partition_strategy.c
index 7499e87..bd36b38 100644
--- a/av1/encoder/partition_strategy.c
+++ b/av1/encoder/partition_strategy.c
@@ -24,8 +24,12 @@
#include "av1/encoder/encoder.h"
#include "av1/encoder/motion_search_facade.h"
-#include "av1/encoder/partition_strategy.h"
+#include "av1/encoder/partition_search.h"
#include "av1/encoder/rdopt.h"
+#if CONFIG_EXT_RECUR_PARTITIONS
+#include "av1/common/idct.h"
+#include "av1/encoder/hybrid_fwd_txfm.h"
+#endif // CONFIG_EXT_RECUR_PARTITIONS
static AOM_INLINE void simple_motion_search_prune_part_features(
AV1_COMP *const cpi, MACROBLOCK *x, SIMPLE_MOTION_DATA_TREE *sms_tree,
@@ -834,9 +838,11 @@
get_min_bsize(sms_tree->split[i], min_bw, min_bh);
}
} else {
+#if !CONFIG_EXT_RECUR_PARTITIONS
if (part_type == PARTITION_HORZ_A || part_type == PARTITION_HORZ_B ||
part_type == PARTITION_VERT_A || part_type == PARTITION_VERT_B)
part_type = PARTITION_SPLIT;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE subsize = get_partition_subsize(bsize, part_type);
if (subsize != BLOCK_INVALID) {
*min_bw = AOMMIN(*min_bw, mi_size_wide_log2[subsize]);
@@ -1192,10 +1198,15 @@
unsigned int horz_4_source_var[SUB_PARTITIONS_PART4] = { 0 };
unsigned int vert_4_source_var[SUB_PARTITIONS_PART4] = { 0 };
{
+#if CONFIG_EXT_RECUR_PARTITIONS
+ BLOCK_SIZE horz_4_bs = get_partition_subsize(bsize, PARTITION_HORZ_3);
+ BLOCK_SIZE vert_4_bs = get_partition_subsize(bsize, PARTITION_VERT_3);
+#else // CONFIG_EXT_RECUR_PARTITIONS
BLOCK_SIZE horz_4_bs = get_partition_subsize(bsize, PARTITION_HORZ_4);
BLOCK_SIZE vert_4_bs = get_partition_subsize(bsize, PARTITION_VERT_4);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_setup_src_planes(x, cpi->source, mi_row, mi_col,
- av1_num_planes(&cpi->common), bsize);
+ av1_num_planes(&cpi->common), NULL);
const int src_stride = x->plane[0].src.stride;
uint8_t *src = x->plane[0].src.buf;
const MACROBLOCKD *const xd = &x->e_mbd;
@@ -1410,12 +1421,6 @@
}
}
-#ifndef NDEBUG
-static AOM_INLINE int is_bsize_square(BLOCK_SIZE bsize) {
- return block_size_wide[bsize] == block_size_high[bsize];
-}
-#endif // NDEBUG
-
void av1_prune_partitions_by_max_min_bsize(
SuperBlockEnc *sb_enc, BLOCK_SIZE bsize, int is_not_edge_block,
int *partition_none_allowed, int *partition_horz_allowed,
@@ -1423,19 +1428,38 @@
assert(is_bsize_square(sb_enc->max_partition_size));
assert(is_bsize_square(sb_enc->min_partition_size));
assert(sb_enc->min_partition_size <= sb_enc->max_partition_size);
+#if !CONFIG_EXT_RECUR_PARTITIONS
assert(is_bsize_square(bsize));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
const int max_partition_size_1d = block_size_wide[sb_enc->max_partition_size];
const int min_partition_size_1d = block_size_wide[sb_enc->min_partition_size];
const int bsize_1d = block_size_wide[bsize];
assert(min_partition_size_1d <= max_partition_size_1d);
const int is_le_min_sq_part = bsize_1d <= min_partition_size_1d;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int block_height = block_size_high[bsize];
+ const int block_width = block_size_wide[bsize];
+ const int is_gt_max_sq_part = (block_height > max_partition_size_1d) ||
+ (block_width > max_partition_size_1d);
+#else // CONFIG_EXT_RECUR_PARTITIONS
const int is_gt_max_sq_part = bsize_1d > max_partition_size_1d;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+ (void)do_square_split;
+ (void)is_not_edge_block;
+#endif
if (is_gt_max_sq_part) {
// If current block size is larger than max, only allow split.
*partition_none_allowed = 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ *partition_horz_allowed = 1;
+ *partition_vert_allowed = 1;
+#else // CONFIG_EXT_RECUR_PARTITIONS
*partition_horz_allowed = 0;
*partition_vert_allowed = 0;
*do_square_split = 1;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
} else if (is_le_min_sq_part) {
// If current block size is less or equal to min, only allow none if valid
// block large enough; only allow split otherwise.
@@ -1443,8 +1467,12 @@
*partition_vert_allowed = 0;
// only disable square split when current block is not at the picture
// boundary. otherwise, inherit the square split flag from previous logic
+#if CONFIG_EXT_RECUR_PARTITIONS
+ *partition_none_allowed = 1;
+#else // CONFIG_EXT_RECUR_PARTITIONS
if (is_not_edge_block) *do_square_split = 0;
*partition_none_allowed = !(*do_square_split);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
}
@@ -1626,3 +1654,378 @@
pc_tree, PARTITION_VERT, rect_part_win_info, x->qindex, 1, 3);
}
}
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+// Gets the number of sms data in a single dimension
+static INLINE int get_sms_count_from_length(int mi_length) {
+ switch (mi_length) {
+ case 32: return BLOCK_128_COUNT;
+ case 16: return BLOCK_64_COUNT;
+ case 8: return BLOCK_32_COUNT;
+ case 4: return BLOCK_16_COUNT;
+ case 2: return BLOCK_8_COUNT;
+ case 1: return BLOCK_4_COUNT;
+ default: assert(0 && "Invalid mi_width"); return -1;
+ }
+}
+
+// Gets the linear index corresponds to the current block.
+static INLINE int get_sms_arr_1d_idx(int mi_bsize, int mi_in_sb) {
+ int idx = -1;
+ if (mi_bsize == 1) {
+ idx = mi_in_sb;
+ } else {
+ assert(mi_in_sb % (mi_bsize / 2) == 0);
+ idx = mi_in_sb / (mi_bsize / 2);
+ }
+ assert(idx >= 0 && idx < get_sms_count_from_length(mi_bsize));
+
+ return idx;
+}
+
+#define MAKE_SMS_ARR_SWITCH_CASE(width, height) \
+ case BLOCK_##width##X##height: { \
+ return sms_bufs->b_##width##x##height; \
+ }
+
+// Returns the buffer in SimpleMotionDataBufs that correspond to bsize.
+static INLINE SimpleMotionData *get_sms_arr(SimpleMotionDataBufs *sms_bufs,
+ BLOCK_SIZE bsize) {
+ switch (bsize) {
+ // Square blocks
+ MAKE_SMS_ARR_SWITCH_CASE(128, 128);
+ MAKE_SMS_ARR_SWITCH_CASE(64, 64);
+ MAKE_SMS_ARR_SWITCH_CASE(32, 32);
+ MAKE_SMS_ARR_SWITCH_CASE(16, 16);
+ MAKE_SMS_ARR_SWITCH_CASE(8, 8);
+ MAKE_SMS_ARR_SWITCH_CASE(4, 4);
+
+ // 1:2 blocks
+ MAKE_SMS_ARR_SWITCH_CASE(64, 128);
+ MAKE_SMS_ARR_SWITCH_CASE(32, 64);
+ MAKE_SMS_ARR_SWITCH_CASE(16, 32);
+ MAKE_SMS_ARR_SWITCH_CASE(8, 16);
+ MAKE_SMS_ARR_SWITCH_CASE(4, 8);
+
+ // 2:1 blocks
+ MAKE_SMS_ARR_SWITCH_CASE(128, 64);
+ MAKE_SMS_ARR_SWITCH_CASE(64, 32);
+ MAKE_SMS_ARR_SWITCH_CASE(32, 16);
+ MAKE_SMS_ARR_SWITCH_CASE(16, 8);
+ MAKE_SMS_ARR_SWITCH_CASE(8, 4);
+
+ // 1:4 blocks
+ MAKE_SMS_ARR_SWITCH_CASE(16, 64);
+ MAKE_SMS_ARR_SWITCH_CASE(8, 32);
+ MAKE_SMS_ARR_SWITCH_CASE(4, 16);
+
+ // 4:1 blocks
+ MAKE_SMS_ARR_SWITCH_CASE(64, 16);
+ MAKE_SMS_ARR_SWITCH_CASE(32, 8);
+ MAKE_SMS_ARR_SWITCH_CASE(16, 4);
+
+ default: assert(0 && "Invalid bsize"); return NULL;
+ }
+}
+#undef MAKE_SMS_ARR_SWITCH_CASE
+
+// Retrieves the SimpleMotionData from SimpleMotionDataBufs
+SimpleMotionData *av1_get_sms_data_entry(SimpleMotionDataBufs *sms_bufs,
+ int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE sb_size) {
+ assert(mi_size_high[sb_size] == mi_size_wide[sb_size]);
+ const int mi_in_sb = mi_size_high[sb_size];
+ const int mi_row_in_sb = mi_row % mi_in_sb;
+ const int mi_col_in_sb = mi_col % mi_in_sb;
+ const int mi_high = mi_size_high[bsize];
+ const int mi_wide = mi_size_wide[bsize];
+ const int idx_row_in_sb = get_sms_arr_1d_idx(mi_high, mi_row_in_sb);
+ const int idx_col_in_sb = get_sms_arr_1d_idx(mi_wide, mi_col_in_sb);
+ const int arr_stride = get_sms_count_from_length(mi_wide);
+ SimpleMotionData *sms_arr = get_sms_arr(sms_bufs, bsize);
+ return &sms_arr[idx_row_in_sb * arr_stride + idx_col_in_sb];
+}
+
+void av1_cache_best_partition(SimpleMotionDataBufs *sms_bufs, int mi_row,
+ int mi_col, BLOCK_SIZE bsize, BLOCK_SIZE sb_size,
+ PARTITION_TYPE partition) {
+ SimpleMotionData *cur_block =
+ av1_get_sms_data_entry(sms_bufs, mi_row, mi_col, bsize, sb_size);
+ cur_block->has_prev_partition = 1;
+ cur_block->prev_partition = partition;
+}
+
+// Performs a simple motion search and store the result in sms_data.
+static void compute_sms_data(AV1_COMP *const cpi, const TileInfo *const tile,
+ MACROBLOCK *x, SimpleMotionData *sms_data,
+ int mi_row, int mi_col, BLOCK_SIZE bsize) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const int ref_frame =
+ cpi->rc.is_src_frame_alt_ref ? ALTREF_FRAME : LAST_FRAME;
+ if (mi_col >= cm->mi_params.mi_cols || mi_row >= cm->mi_params.mi_rows) {
+ // If the whole block is outside of the image, set the var and sse to 0.
+ sms_data->sse = 0;
+ sms_data->var = 0;
+ sms_data->dist = 0;
+ sms_data->rate = 0;
+ sms_data->rdcost = 0;
+ sms_data->valid = 1;
+ return;
+ }
+ av1_set_offsets(cpi, tile, x, mi_row, mi_col, bsize, NULL);
+ // We need to update the rd-mult here to in case we are doing simple motion
+ // search on a subblock of the current coding block.
+ const int orig_rdmult = x->rdmult;
+ const AQ_MODE aq_mode = cpi->oxcf.q_cfg.aq_mode;
+ MB_MODE_INFO *mbmi = x->e_mbd.mi[0];
+ setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, aq_mode, mbmi);
+ // Set error per bit for current rdmult
+ av1_set_error_per_bit(&x->mv_costs, x->rdmult);
+ if (cpi->ref_frame_flags & av1_ref_frame_flag_list[ref_frame]) {
+ const MACROBLOCKD *xd = &x->e_mbd;
+ const uint8_t *src_buf = x->plane[0].src.buf;
+ const uint8_t *dst_buf = xd->plane[0].dst.buf;
+ const int src_stride = x->plane[0].src.stride;
+ const int dst_stride = xd->plane[0].dst.stride;
+ if (sms_data->num_start_mvs == 0) {
+ sms_data->start_mv_list[sms_data->num_start_mvs++] = kZeroMv;
+ }
+ sms_data->rdcost = INT64_MAX;
+ SimpleMotionData best_data = *sms_data;
+ for (int idx = 0; idx < sms_data->num_start_mvs; idx++) {
+ const MV start_mv = sms_data->start_mv_list[idx];
+ const FULLPEL_MV start_mv_full = get_fullmv_from_mv(&start_mv);
+ av1_simple_motion_search_ext(cpi, tile, x, mi_row, mi_col, bsize,
+ ref_frame, start_mv_full, 1, 1, sms_data);
+ sms_data->var = cpi->fn_ptr[bsize].vf(src_buf, src_stride, dst_buf,
+ dst_stride, &sms_data->sse);
+ sms_data->dist = 16 * sms_data->sse;
+ sms_data->rate = 0;
+ sms_data->rdcost = RDCOST(x->rdmult, sms_data->rate, sms_data->dist);
+ if (sms_data->rdcost <= best_data.rdcost) {
+ best_data = *sms_data;
+ }
+ }
+ *sms_data = best_data;
+ }
+ sms_data->valid = 1;
+ sms_data->bsize = bsize;
+ sms_data->mi_row = mi_row;
+ sms_data->mi_col = mi_col;
+ x->rdmult = orig_rdmult;
+ return;
+}
+
+#if CONFIG_DEBUG
+static INLINE void print_sms(const SimpleMotionData *sms_data, char *prefix) {
+ BLOCK_SIZE bsize = sms_data->bsize;
+ MV fullmv = sms_data->fullmv;
+ MV submv = sms_data->submv;
+ printf("%s:: bsize: (%d, %d), mi_row: %d, mi_col: %d, rd: %ld\n", prefix,
+ block_size_wide[bsize], block_size_high[bsize], sms_data->mi_row,
+ sms_data->mi_col, sms_data->rdcost);
+ printf("%s:: fullmv: (%d, %d), submv: (%d, %d),\n", prefix, fullmv.row,
+ fullmv.col, submv.row, submv.col);
+ printf("%s:: mv_cost_type: %d, sadpb: %d, errpb: %d\n", prefix,
+ sms_data->mv_cost_type, sms_data->sadpb, sms_data->errorperbit);
+}
+#endif
+
+static INLINE void add_start_mv_to_block(SimpleMotionData *block, MV start_mv) {
+ if (block->num_start_mvs == kSMSMaxStartMVs) {
+ return;
+ }
+ for (int idx = 0; idx < block->num_start_mvs; idx++) {
+ const int_mv *cur_mv = (int_mv *)&block->start_mv_list[idx];
+ if (((int_mv *)&start_mv)->as_int == cur_mv->as_int) {
+ return;
+ }
+ }
+ block->start_mv_list[block->num_start_mvs++] = start_mv;
+}
+
+static INLINE void add_start_mv_to_partition(
+ SimpleMotionDataBufs *sms_bufs, int mi_row, int mi_col, BLOCK_SIZE bsize,
+ BLOCK_SIZE sb_size, PARTITION_TYPE partition, MV start_mv) {
+ assert(bsize < BLOCK_SIZES_ALL);
+ const int quarter_step_h = block_size_high[bsize] / 4;
+ const int quarter_step_w = block_size_wide[bsize] / 4;
+ static const int subblock_count[EXT_PARTITION_TYPES] = {
+ 1, // PARTITION_NONE
+ 2, // PARTITION_HORZ
+ 2, // PARTITION_VERT
+ 3, // PARTITION_HORZ_3
+ 3, // PARTITION_VERT_3
+ };
+ // PARTITION x NUM_SUBBLOCKS x (ROW and COL)
+ static const int step_multiplier[EXT_PARTITION_TYPES][3][2] = {
+ { { 0, 0 }, { 0, 0 }, { 0, 0 } }, // PARTITION_NONE
+ { { 0, 0 }, { 2, 0 }, { 0, 0 } }, // PARTITION_HORZ
+ { { 0, 0 }, { 0, 2 }, { 0, 0 } }, // PARTITION_VERT
+ { { 0, 0 }, { 1, 0 }, { 3, 0 } }, // PARTITION_HORZ_3
+ { { 0, 0 }, { 0, 1 }, { 0, 3 } }, // PARTITION_VERT_3
+ };
+ for (int idx = 0; idx < subblock_count[partition]; idx++) {
+ BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
+ if (subsize == BLOCK_INVALID) {
+ return;
+ } else if (partition == PARTITION_HORZ_3 && idx == 1) {
+ subsize = get_partition_subsize(bsize, PARTITION_HORZ);
+ } else if (partition == PARTITION_VERT_3 && idx == 1) {
+ subsize = get_partition_subsize(bsize, PARTITION_VERT);
+ }
+ const int sub_row =
+ mi_row + step_multiplier[partition][idx][0] * quarter_step_h / 4;
+ const int sub_col =
+ mi_col + step_multiplier[partition][idx][1] * quarter_step_w / 4;
+ SimpleMotionData *subblock =
+ av1_get_sms_data_entry(sms_bufs, sub_row, sub_col, subsize, sb_size);
+ add_start_mv_to_block(subblock, start_mv);
+ }
+}
+
+// Computes and stores the simple motion search data for the block at mi_row,
+// mi_col with block size bsize.
+SimpleMotionData *av1_get_sms_data(AV1_COMP *const cpi,
+ const TileInfo *const tile, MACROBLOCK *x,
+ int mi_row, int mi_col, BLOCK_SIZE bsize) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ SimpleMotionDataBufs *sms_bufs = x->sms_bufs;
+ SimpleMotionData *cur_block =
+ av1_get_sms_data_entry(sms_bufs, mi_row, mi_col, bsize, sb_size);
+ const int valid = cur_block->valid;
+ if (!valid) {
+ compute_sms_data(cpi, tile, x, cur_block, mi_row, mi_col, bsize);
+ for (PARTITION_TYPE partition = PARTITION_NONE;
+ partition < EXT_PARTITION_TYPES; partition++) {
+ add_start_mv_to_partition(sms_bufs, mi_row, mi_col, bsize, sb_size,
+ partition, cur_block->fullmv);
+ }
+ }
+ return cur_block;
+}
+
+PARTITION_TYPE av1_get_prev_partition(MACROBLOCK *x, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE sb_size) {
+ SimpleMotionDataBufs *sms_bufs = x->sms_bufs;
+ const SimpleMotionData *cur_block =
+ av1_get_sms_data_entry(sms_bufs, mi_row, mi_col, bsize, sb_size);
+ if (cur_block->has_prev_partition) {
+ return cur_block->prev_partition;
+ } else {
+ return PARTITION_INVALID;
+ }
+}
+
+static INLINE void gather_part_rd_stats(RD_STATS *rd_stats,
+ const SMSPartitionStats *stat,
+ int rdmult) {
+ av1_init_rd_stats(rd_stats);
+ if (stat->part_rate < INT_MAX) {
+ // rd_stats->rate += part_rate;
+ } else {
+ rd_stats->rate = INT_MAX;
+ rd_stats->rdcost = INT64_MAX;
+ return;
+ }
+ for (int idx = 0; idx < stat->num_sub_parts; idx++) {
+ rd_stats->rate += stat->sms_data[idx]->rate;
+ rd_stats->dist += stat->sms_data[idx]->dist;
+ }
+ rd_stats->rdcost = RDCOST(rdmult, rd_stats->rate, rd_stats->dist);
+}
+
+/*! \brief Checks if the average linear dimension of bsize is greater than or
+ * equal to dim. */
+static INLINE int is_avg_dim_greater_than(BLOCK_SIZE bsize, int dim) {
+ if (bsize == BLOCK_INVALID) {
+ return 0;
+ }
+ const int avg_dim = (block_size_wide[bsize] + block_size_high[bsize]) / 2;
+ return avg_dim > dim;
+}
+
+int av1_prune_new_part(const SMSPartitionStats *old_part,
+ const SMSPartitionStats *new_part, int rdmult,
+ BLOCK_SIZE bsize, const SPEED_FEATURES *sf) {
+ RD_STATS old_rd_stat, new_rd_stat;
+ gather_part_rd_stats(&old_rd_stat, old_part, rdmult);
+ gather_part_rd_stats(&new_rd_stat, new_part, rdmult);
+ if (sf->part_sf.enable_fast_erp < 2 && is_avg_dim_greater_than(bsize, 32)) {
+ return old_rd_stat.rdcost < new_rd_stat.rdcost;
+ }
+ return old_rd_stat.rdcost < (int)(1.001 * new_rd_stat.rdcost);
+}
+
+bool av1_prune_part_hv_with_sms(AV1_COMP *const cpi, TileDataEnc *tile_data,
+ MACROBLOCK *x,
+ const PartitionSearchState *part_search_state,
+ const RD_STATS *best_rdc,
+ const PartitionBlkParams *blk_params,
+ RECT_PART_TYPE rect_type, int part_rate) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const int blk_offsets[NUM_RECT_PARTS][2] = { // HORZ
+ { blk_params->mi_step_h, 0 },
+ // VERT
+ { 0, blk_params->mi_step_w }
+ };
+
+ SMSPartitionStats part_data;
+ const SimpleMotionData *blk1 =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, blk_params->mi_row,
+ blk_params->mi_col, blk_params->subsize);
+ const SimpleMotionData *blk2 = av1_get_sms_data(
+ cpi, &tile_data->tile_info, x,
+ blk_params->mi_row + blk_offsets[rect_type][0],
+ blk_params->mi_col + blk_offsets[rect_type][1], blk_params->subsize);
+ part_data.sms_data[0] = blk1;
+ part_data.sms_data[1] = blk2;
+ part_data.num_sub_parts = 2;
+ part_data.part_rate = part_rate;
+
+ if (best_rdc->rdcost < INT64_MAX &&
+ (blk_params->mi_row + 2 * blk_params->mi_step_h <=
+ cm->mi_params.mi_rows) &&
+ (blk_params->mi_col + 2 * blk_params->mi_step_w <=
+ cm->mi_params.mi_cols) &&
+ av1_prune_new_part(&part_search_state->none_data, &part_data, x->rdmult,
+ blk_params->bsize, &cpi->sf)) {
+ const PARTITION_TYPE second_level_part =
+ (rect_type == HORZ) ? PARTITION_VERT : PARTITION_HORZ;
+ const BLOCK_SIZE subsubsize =
+ get_partition_subsize(blk_params->subsize, second_level_part);
+ if (subsubsize == BLOCK_INVALID) {
+ return true;
+ }
+
+ // Do one more check to deal with recursion
+ SMSPartitionStats subpart_data;
+ const SimpleMotionData *upleft =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x, blk_params->mi_row,
+ blk_params->mi_col, subsubsize);
+ const SimpleMotionData *upright = av1_get_sms_data(
+ cpi, &tile_data->tile_info, x, blk_params->mi_row,
+ blk_params->mi_col + blk_params->mi_step_w, subsubsize);
+ const SimpleMotionData *downleft =
+ av1_get_sms_data(cpi, &tile_data->tile_info, x,
+ blk_params->mi_row + blk_params->mi_step_h,
+ blk_params->mi_col, subsubsize);
+ const SimpleMotionData *downright = av1_get_sms_data(
+ cpi, &tile_data->tile_info, x,
+ blk_params->mi_row + blk_params->mi_step_h,
+ blk_params->mi_col + blk_params->mi_step_w, subsubsize);
+ subpart_data.sms_data[0] = upleft;
+ subpart_data.sms_data[1] = upright;
+ subpart_data.sms_data[2] = downleft;
+ subpart_data.sms_data[3] = downright;
+ subpart_data.num_sub_parts = 4;
+ subpart_data.part_rate = 0;
+ if (av1_prune_new_part(&part_search_state->none_data, &subpart_data,
+ x->rdmult, blk_params->bsize, &cpi->sf)) {
+ return true;
+ }
+ }
+ return false;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
diff --git a/av1/encoder/partition_strategy.h b/av1/encoder/partition_strategy.h
index a386bf9..1587b67 100644
--- a/av1/encoder/partition_strategy.h
+++ b/av1/encoder/partition_strategy.h
@@ -12,6 +12,7 @@
#ifndef AOM_AV1_ENCODER_PARTITION_STRATEGY_H_
#define AOM_AV1_ENCODER_PARTITION_STRATEGY_H_
+#include "av1/encoder/block.h"
#include "av1/encoder/encodeframe.h"
#include "av1/encoder/encodemb.h"
#include "av1/encoder/encoder.h"
@@ -191,6 +192,67 @@
int *horza_partition_allowed, int *horzb_partition_allowed,
int *verta_partition_allowed, int *vertb_partition_allowed);
+#if CONFIG_EXT_RECUR_PARTITIONS
+SimpleMotionData *av1_get_sms_data_entry(SimpleMotionDataBufs *sms_bufs,
+ int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE sb_size);
+SimpleMotionData *av1_get_sms_data(AV1_COMP *const cpi,
+ const TileInfo *const tile, MACROBLOCK *x,
+ int mi_row, int mi_col, BLOCK_SIZE bsize);
+
+static AOM_INLINE void av1_add_mode_search_context_to_cache(
+ SimpleMotionData *sms_data, PICK_MODE_CONTEXT *ctx) {
+ if (!sms_data->mode_cache[0] ||
+ sms_data->mode_cache[0]->rd_stats.rdcost > ctx->rd_stats.rdcost) {
+ sms_data->mode_cache[0] = ctx;
+ }
+}
+
+static INLINE void av1_set_best_mode_cache(MACROBLOCK *x,
+ PICK_MODE_CONTEXT *mode_cache[1]) {
+ if (mode_cache[0] && mode_cache[0]->rd_stats.rate != INT_MAX) {
+ x->inter_mode_cache = &mode_cache[0]->mic;
+ } else {
+ x->inter_mode_cache = NULL;
+ }
+}
+
+typedef struct SMSPartitionStats {
+ const SimpleMotionData *sms_data[4];
+ int num_sub_parts;
+ int part_rate;
+} SMSPartitionStats;
+
+static INLINE void av1_init_sms_partition_stats(SMSPartitionStats *stats) {
+ memset(stats->sms_data, 0, sizeof(stats->sms_data));
+ stats->num_sub_parts = 0;
+ stats->part_rate = INT_MAX;
+}
+
+// Returns 1 if we think the old part is better and we should prune new
+// partition, 0 otherwise.
+int av1_prune_new_part(const SMSPartitionStats *old_part,
+ const SMSPartitionStats *new_part, int rdmult,
+ BLOCK_SIZE bsize, const SPEED_FEATURES *sf);
+
+void av1_cache_best_partition(SimpleMotionDataBufs *sms_bufs, int mi_row,
+ int mi_col, BLOCK_SIZE bsize, BLOCK_SIZE sb_size,
+ PARTITION_TYPE partition);
+
+void av1_copy_sms_part(const SimpleMotionData **part_dst, int *part_size_dst,
+ int *part_rate_dst,
+ const SimpleMotionData *const *part_src,
+ int part_size_src, int part_rate_src);
+
+struct PartitionBlkParams;
+struct PartitionSearchState;
+bool av1_prune_part_hv_with_sms(
+ AV1_COMP *const cpi, TileDataEnc *tile_data, MACROBLOCK *x,
+ const struct PartitionSearchState *part_search_state,
+ const RD_STATS *best_rdc, const struct PartitionBlkParams *blk_params,
+ RECT_PART_TYPE rect_type, int part_rate);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// A simplified version of set_offsets meant to be used for
// simple_motion_search.
static INLINE void set_offsets_for_motion_search(const AV1_COMP *const cpi,
@@ -208,15 +270,15 @@
mi_row, mi_col);
// Set up destination pointers.
- av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, NULL);
// Set up limit values for MV components.
// Mv beyond the range do not produce new/different prediction block.
av1_set_mv_limits(mi_params, &x->mv_limits, mi_row, mi_col, mi_height,
mi_width, cpi->oxcf.border_in_pixels);
- set_plane_n4(xd, mi_width, mi_height, num_planes);
+ set_plane_n4(xd, mi_width, mi_height, num_planes, NULL);
xd->mi_row = mi_row;
xd->mi_col = mi_col;
@@ -231,7 +293,7 @@
GET_MV_SUBPEL((mi_params->mi_cols - mi_width - mi_col) * MI_SIZE);
// Set up source buffers.
- av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, bsize);
+ av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, NULL);
}
static INLINE void init_simple_motion_search_mvs(
@@ -250,6 +312,15 @@
}
}
+PARTITION_TYPE av1_get_prev_partition(MACROBLOCK *x, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, BLOCK_SIZE sb_size);
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE void av1_init_sms_data_bufs(SimpleMotionDataBufs *data_bufs) {
+ memset(data_bufs, 0, sizeof(*data_bufs));
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
static INLINE int is_full_sb(const CommonModeInfoParams *const mi_params,
int mi_row, int mi_col, BLOCK_SIZE sb_size) {
const int sb_mi_wide = mi_size_wide[sb_size];
diff --git a/av1/encoder/pickccso.c b/av1/encoder/pickccso.c
index 3b90267..b744b4d 100644
--- a/av1/encoder/pickccso.c
+++ b/av1/encoder/pickccso.c
@@ -448,8 +448,8 @@
int64_t rdmult_temp = (int64_t)rdmult * (int64_t)rdmult_weight;
if (rdmult_temp < INT_MAX) rdmult = (int)rdmult_temp;
const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, &cm->cur_frame->buf,
- 0, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, 0, 0, 0, num_planes,
+ NULL);
ccso_stride = xd->plane[0].dst.width;
ccso_stride_ext = xd->plane[0].dst.width + (CCSO_PADDING_SIZE << 1);
derive_ccso_filter(cm, AOM_PLANE_U, xd, org_uv[AOM_PLANE_U - 1], ext_rec_y,
diff --git a/av1/encoder/pickcdef.c b/av1/encoder/pickcdef.c
index e88cf87..2fb36b0 100644
--- a/av1/encoder/pickcdef.c
+++ b/av1/encoder/pickcdef.c
@@ -431,8 +431,7 @@
const int total_strengths = nb_cdef_strengths[pick_method];
DECLARE_ALIGNED(32, uint16_t, tmp_dst[1 << (MAX_SB_SIZE_LOG2 * 2)]);
const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0,
- num_planes);
+ av1_setup_dst_planes(xd->plane, frame, 0, 0, 0, num_planes, NULL);
uint64_t(*mse[2])[TOTAL_STRENGTHS];
mse[0] = aom_malloc(sizeof(**mse) * nvfb * nhfb);
mse[1] = aom_malloc(sizeof(**mse) * nvfb * nhfb);
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 0e4e0a0..9da1e9e 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -114,6 +114,12 @@
fc->partition_cdf[i], NULL);
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+ for (i = 0; i < PARTITION_CONTEXTS_REC; ++i)
+ av1_cost_tokens_from_cdf(mode_costs->partition_rec_cost[i],
+ fc->partition_rec_cdf[i], NULL);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
if (cm->current_frame.skip_mode_info.skip_mode_flag) {
for (i = 0; i < SKIP_MODE_CONTEXTS; ++i) {
av1_cost_tokens_from_cdf(mode_costs->skip_mode_cost[i],
@@ -1269,19 +1275,11 @@
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
for (int i = 0; i < num_planes; ++i) {
-#if CONFIG_SDP
- setup_pred_plane(dst + i, xd->mi[0]->sb_type[i > 0 ? 1 : 0], dst[i].buf,
- i ? src->uv_crop_width : src->y_crop_width,
- i ? src->uv_crop_height : src->y_crop_height,
- dst[i].stride, mi_row, mi_col, i ? scale_uv : scale,
- xd->plane[i].subsampling_x, xd->plane[i].subsampling_y);
-#else
- setup_pred_plane(dst + i, xd->mi[0]->sb_type, dst[i].buf,
- i ? src->uv_crop_width : src->y_crop_width,
- i ? src->uv_crop_height : src->y_crop_height,
- dst[i].stride, mi_row, mi_col, i ? scale_uv : scale,
- xd->plane[i].subsampling_x, xd->plane[i].subsampling_y);
-#endif
+ setup_pred_plane(
+ dst + i, dst[i].buf, i ? src->uv_crop_width : src->y_crop_width,
+ i ? src->uv_crop_height : src->y_crop_height, dst[i].stride, mi_row,
+ mi_col, i ? scale_uv : scale, xd->plane[i].subsampling_x,
+ xd->plane[i].subsampling_y, &xd->mi[0]->chroma_ref_info);
}
}
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 5a8b113..4c39cc3 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -755,10 +755,15 @@
if (plane && !xd->is_chroma_ref) break;
const struct macroblock_plane *const p = &x->plane[plane];
const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_SDP
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bs = get_mb_plane_block_size(
+ xd, mbmi, plane, pd->subsampling_x, pd->subsampling_y);
+#elif CONFIG_SDP
const BLOCK_SIZE bs = get_plane_block_size(
mbmi->sb_type[plane > 0], pd->subsampling_x, pd->subsampling_y);
#else
+ // TODO(chiyotsai, yuec): This appears to be wrong when EXT_RECUR_PARTITIONS
+ // is on?
const BLOCK_SIZE bs = get_plane_block_size(mbmi->sb_type, pd->subsampling_x,
pd->subsampling_y);
#endif
@@ -3983,7 +3988,7 @@
}
if (num_planes > 1) {
- av1_txfm_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
+ av1_txfm_uvrd(cpi, x, &rd_stats_uv, INT64_MAX);
} else {
av1_init_rd_stats(&rd_stats_uv);
}
@@ -4242,6 +4247,37 @@
return 0;
}
+static AOM_INLINE int is_ref_frame_used_by_compound_ref(
+ int ref_frame, int skip_ref_frame_mask) {
+ for (int r = ALTREF_FRAME + 1; r < MODE_CTX_REF_FRAMES; ++r) {
+ if (!(skip_ref_frame_mask & (1 << r))) {
+ const MV_REFERENCE_FRAME *rf = ref_frame_map[r - REF_FRAMES];
+ if (rf[0] == ref_frame || rf[1] == ref_frame) {
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+static AOM_INLINE int is_ref_frame_used_in_cache(MV_REFERENCE_FRAME ref_frame,
+ const MB_MODE_INFO *mi_cache) {
+ if (!mi_cache) {
+ return 0;
+ }
+
+ if (ref_frame < REF_FRAMES) {
+ return (ref_frame == mi_cache->ref_frame[0] ||
+ ref_frame == mi_cache->ref_frame[1]);
+ }
+
+ // if we are here, then the current mode is compound.
+ MV_REFERENCE_FRAME cached_ref_type = av1_ref_frame_type(mi_cache->ref_frame);
+ return ref_frame == cached_ref_type;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// Please add/modify parameter setting in this function, making it consistent
// and easy to read and maintain.
static AOM_INLINE void set_params_rd_pick_inter_mode(
@@ -4271,18 +4307,14 @@
if (cpi->ref_frame_flags & av1_ref_frame_flag_list[ref_frame]) {
if (mbmi->partition != PARTITION_NONE &&
mbmi->partition != PARTITION_SPLIT) {
- if (skip_ref_frame_mask & (1 << ref_frame)) {
- int skip = 1;
- for (int r = ALTREF_FRAME + 1; r < MODE_CTX_REF_FRAMES; ++r) {
- if (!(skip_ref_frame_mask & (1 << r))) {
- const MV_REFERENCE_FRAME *rf = ref_frame_map[r - REF_FRAMES];
- if (rf[0] == ref_frame || rf[1] == ref_frame) {
- skip = 0;
- break;
- }
- }
- }
- if (skip) continue;
+ if (skip_ref_frame_mask & (1 << ref_frame) &&
+ !is_ref_frame_used_by_compound_ref(ref_frame, skip_ref_frame_mask)
+#if CONFIG_EXT_RECUR_PARTITIONS
+ && !(should_reuse_mode(x, REUSE_INTER_MODE_IN_INTERFRAME_FLAG) &&
+ is_ref_frame_used_in_cache(ref_frame, x->inter_mode_cache))
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ ) {
+ continue;
}
}
assert(get_ref_frame_yv12_buf(cm, ref_frame) != NULL);
@@ -4308,7 +4340,12 @@
if (mbmi->partition != PARTITION_NONE &&
mbmi->partition != PARTITION_SPLIT) {
- if (skip_ref_frame_mask & (1 << ref_frame)) {
+ if (skip_ref_frame_mask & (1 << ref_frame)
+#if CONFIG_EXT_RECUR_PARTITIONS
+ && !(should_reuse_mode(x, REUSE_INTER_MODE_IN_INTERFRAME_FLAG) &&
+ is_ref_frame_used_in_cache(ref_frame, x->inter_mode_cache))
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ ) {
continue;
}
}
@@ -4332,7 +4369,7 @@
if (cpi->oxcf.motion_mode_cfg.enable_obmc && !cpi->sf.inter_sf.disable_obmc &&
!prune_obmc) {
if (check_num_overlappable_neighbors(mbmi) &&
- is_motion_variation_allowed_bsize(bsize)) {
+ is_motion_variation_allowed_bsize(bsize, mi_row, mi_col)) {
int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
MAX_SB_SIZE >> 1 };
@@ -4346,8 +4383,8 @@
dst_width2, dst_height2,
args->left_pred_stride);
const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row,
- mi_col, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, &mbmi->chroma_ref_info);
calc_target_weighted_pred(
cm, x, xd, args->above_pred_buf[0], args->above_pred_stride[0],
args->left_pred_buf[0], args->left_pred_stride[0]);
@@ -4523,6 +4560,84 @@
return picked_ref_frames_mask;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE int is_mode_intra(PREDICTION_MODE mode) {
+ return mode < INTRA_MODE_END;
+}
+
+// Reuse the prediction mode in cache.
+// Returns 0 if no pruning is done, 1 if we are skipping the current mod
+// completely, 2 if we skip compound only, but still try single motion modes
+static INLINE int skip_inter_mode_with_cached_mode(
+ const MACROBLOCK *x, PREDICTION_MODE mode,
+ const MV_REFERENCE_FRAME *ref_frame) {
+ const MB_MODE_INFO *cached_mi = x->inter_mode_cache;
+
+ // If there is no cache, then no pruning is possible.
+ if (!cached_mi) {
+ return 0;
+ }
+
+ const PREDICTION_MODE cached_mode = cached_mi->mode;
+ const MV_REFERENCE_FRAME *cached_frame = cached_mi->ref_frame;
+ const int cached_mode_is_single = cached_frame[1] <= INTRA_FRAME;
+
+ // If the cached mode is intra, then we just need to match the mode.
+ if (should_reuse_mode(x, REUSE_INTRA_MODE_IN_INTERFRAME_FLAG) &&
+ is_mode_intra(cached_mode) && mode != cached_mode) {
+ return 1;
+ }
+
+ // Returns 0 here if we are not reusing inter_modes
+ if (!should_reuse_mode(x, REUSE_INTER_MODE_IN_INTERFRAME_FLAG) ||
+ !cached_mi) {
+ return 0;
+ }
+
+ // If the cached mode is single inter mode, then we match the mode and
+ // reference frame.
+ if (cached_mode_is_single) {
+ if (mode != cached_mode || ref_frame[0] != cached_frame[0]) {
+ return 1;
+ }
+ } else {
+ // If the cached mode is compound, then we need to consider several cases.
+ const int mode_is_single = ref_frame[1] <= INTRA_FRAME;
+ if (mode_is_single) {
+ // If the mode is single, we know the modes can't match. But we might
+ // still want to search it if compound mode depends on the current mode.
+ int skip_motion_mode_only = 0;
+#if CONFIG_NEW_INTER_MODES
+ if (cached_mode == NEW_NEARMV) {
+#else
+ if (cached_mode == NEW_NEARMV || cached_mode == NEW_NEARESTMV) {
+#endif
+ skip_motion_mode_only = (ref_frame[0] == cached_frame[0]);
+#if CONFIG_NEW_INTER_MODES
+ } else if (cached_mode == NEAR_NEWMV) {
+#else
+ } else if (cached_mode == NEAR_NEWMV || cached_mode == NEAREST_NEWMV) {
+#endif
+ skip_motion_mode_only = (ref_frame[0] == cached_frame[1]);
+ } else if (cached_mode == NEW_NEWMV) {
+ skip_motion_mode_only = (ref_frame[0] == cached_frame[0] ||
+ ref_frame[0] == cached_frame[1]);
+ }
+
+ return 1 + skip_motion_mode_only;
+ } else {
+ // If both modes are compound, then everything must match.
+ if (mode != cached_mode || ref_frame[0] != cached_frame[0] ||
+ ref_frame[1] != cached_frame[1]) {
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// Case 1: return 0, means don't skip this mode
// Case 2: return 1, means skip this mode completely
// Case 3: return 2, means skip compound only, but still try single motion modes
@@ -4546,6 +4661,13 @@
if (skip_repeated_mv(cm, x, mode, ref_frame, search_state)) {
return 1;
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int cached_skip_ret =
+ skip_inter_mode_with_cached_mode(x, mode, ref_frame);
+ if (cached_skip_ret > 0) {
+ return cached_skip_ret;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
const MB_MODE_INFO *const mbmi = x->e_mbd.mi[0];
// If no valid mode has been found so far in PARTITION_NONE when finding a
@@ -4576,6 +4698,18 @@
}
}
}
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // If we are reusing the prediction from cache, and the current frame is
+ // required by the cache, then we cannot prune it.
+ if (should_reuse_mode(x, REUSE_INTER_MODE_IN_INTERFRAME_FLAG) &&
+ is_ref_frame_used_in_cache(ref_type, x->inter_mode_cache)) {
+ skip_ref = 0;
+ // If the cache only needs the current reference type for compound
+ // prediction, then we can skip motion mode search.
+ skip_motion_mode = (ref_type <= ALTREF_FRAME &&
+ x->inter_mode_cache->ref_frame[1] > INTRA_FRAME);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (skip_ref) return 1;
}
@@ -5899,17 +6033,26 @@
// Only try palette mode when the best mode so far is an intra mode.
#if CONFIG_SDP
- const int try_palette =
- cpi->oxcf.tool_cfg.enable_palette &&
- av1_allow_palette(features->allow_screen_content_tools,
- mbmi->sb_type[PLANE_TYPE_Y]) &&
- !is_inter_mode(search_state.best_mbmode.mode);
+ int try_palette = cpi->oxcf.tool_cfg.enable_palette &&
+ av1_allow_palette(features->allow_screen_content_tools,
+ mbmi->sb_type[PLANE_TYPE_Y]) &&
+ !is_inter_mode(search_state.best_mbmode.mode) &&
+ rd_cost->rate < INT_MAX;
#else
- const int try_palette =
+ int try_palette =
cpi->oxcf.tool_cfg.enable_palette &&
av1_allow_palette(features->allow_screen_content_tools, mbmi->sb_type) &&
- !is_inter_mode(search_state.best_mbmode.mode);
+ !is_inter_mode(search_state.best_mbmode.mode) && rd_cost->rate < INT_MAX;
#endif
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const MB_MODE_INFO *cached_mode = x->inter_mode_cache;
+ if (should_reuse_mode(x, REUSE_INTRA_MODE_IN_INTERFRAME_FLAG) &&
+ cached_mode &&
+ !(cached_mode->mode == DC_PRED &&
+ cached_mode->palette_mode_info.palette_size[0] > 0)) {
+ try_palette = 0;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
RD_STATS this_rd_cost;
int this_skippable = 0;
if (try_palette) {
@@ -6110,7 +6253,8 @@
mbmi->motion_mode = SIMPLE_TRANSLATION;
av1_count_overlappable_neighbors(cm, xd);
- if (is_motion_variation_allowed_bsize(bsize) && !has_second_ref(mbmi)) {
+ if (is_motion_variation_allowed_bsize(bsize, mi_row, mi_col) &&
+ !has_second_ref(mbmi)) {
int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
mbmi->num_proj_ref = av1_findSamples(cm, xd, pts, pts_inref);
// Select the samples according to motion vector difference
diff --git a/av1/encoder/reconinter_enc.c b/av1/encoder/reconinter_enc.c
index 288ab4c..4514c5e 100644
--- a/av1/encoder/reconinter_enc.c
+++ b/av1/encoder/reconinter_enc.c
@@ -43,32 +43,54 @@
(void)mc_buf;
const struct scale_factors *sf = inter_pred_params->scale_factors;
-
struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
- int ssx = inter_pred_params->subsampling_x;
- int ssy = inter_pred_params->subsampling_y;
- int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
- orig_pos_y += src_mv->row * (1 << (1 - ssy));
- int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
- orig_pos_x += src_mv->col * (1 << (1 - ssx));
- int pos_y = sf->scale_value_y(orig_pos_y, sf);
- int pos_x = sf->scale_value_x(orig_pos_x, sf);
- pos_x += SCALE_EXTRA_OFF;
- pos_y += SCALE_EXTRA_OFF;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ const int is_scaled = av1_is_scaled(sf);
+ if (is_scaled || !xd) {
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ int ssx = inter_pred_params->subsampling_x;
+ int ssy = inter_pred_params->subsampling_y;
+ int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
+ orig_pos_y += src_mv->row * (1 << (1 - ssy));
+ int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
+ orig_pos_x += src_mv->col * (1 << (1 - ssx));
+ int pos_y = sf->scale_value_y(orig_pos_y, sf);
+ int pos_x = sf->scale_value_x(orig_pos_x, sf);
+ pos_x += SCALE_EXTRA_OFF;
+ pos_y += SCALE_EXTRA_OFF;
- const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);
- const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);
- const int bottom = (pre_buf->height + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
- const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
- pos_y = clamp(pos_y, top, bottom);
- pos_x = clamp(pos_x, left, right);
+ const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);
+ const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);
+ const int bottom = (pre_buf->height + AOM_INTERP_EXTEND)
+ << SCALE_SUBPEL_BITS;
+ const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
+ pos_y = clamp(pos_y, top, bottom);
+ pos_x = clamp(pos_x, left, right);
- subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;
- subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
- subpel_params->xs = sf->x_step_q4;
- subpel_params->ys = sf->y_step_q4;
- *pre = pre_buf->buf0 + (pos_y >> SCALE_SUBPEL_BITS) * pre_buf->stride +
- (pos_x >> SCALE_SUBPEL_BITS);
+ subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;
+ subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
+ subpel_params->xs = sf->x_step_q4;
+ subpel_params->ys = sf->y_step_q4;
+ *pre = pre_buf->buf0 + (pos_y >> SCALE_SUBPEL_BITS) * pre_buf->stride +
+ (pos_x >> SCALE_SUBPEL_BITS);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ } else {
+ int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
+ int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
+ const int bw = inter_pred_params->block_width;
+ const int bh = inter_pred_params->block_height;
+ const MV mv_q4 = clamp_mv_to_umv_border_sb(
+ xd, src_mv, bw, bh, inter_pred_params->subsampling_x,
+ inter_pred_params->subsampling_y);
+ subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS;
+ subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS;
+ subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;
+ pos_x += mv_q4.col;
+ pos_y += mv_q4.row;
+ *pre = pre_buf->buf0 + (pos_y >> SUBPEL_BITS) * pre_buf->stride +
+ (pos_x >> SUBPEL_BITS);
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
*src_stride = pre_buf->stride;
}
@@ -147,21 +169,15 @@
int mi_col_offset, MB_MODE_INFO *ref_mbmi,
struct build_prediction_ctxt *ctxt,
const int num_planes) {
-#if CONFIG_SDP
- const BLOCK_SIZE ref_bsize =
- AOMMAX(BLOCK_8X8, ref_mbmi->sb_type[PLANE_TYPE_Y]);
-#else
- const BLOCK_SIZE ref_bsize = AOMMAX(BLOCK_8X8, ref_mbmi->sb_type);
-#endif
const int ref_mi_row = xd->mi_row + mi_row_offset;
const int ref_mi_col = xd->mi_col + mi_col_offset;
for (int plane = 0; plane < num_planes; ++plane) {
struct macroblockd_plane *const pd = &xd->plane[plane];
- setup_pred_plane(&pd->dst, ref_bsize, ctxt->tmp_buf[plane],
- ctxt->tmp_width[plane], ctxt->tmp_height[plane],
- ctxt->tmp_stride[plane], mi_row_offset, mi_col_offset,
- NULL, pd->subsampling_x, pd->subsampling_y);
+ setup_pred_plane(&pd->dst, ctxt->tmp_buf[plane], ctxt->tmp_width[plane],
+ ctxt->tmp_height[plane], ctxt->tmp_stride[plane],
+ mi_row_offset, mi_col_offset, NULL, pd->subsampling_x,
+ pd->subsampling_y, NULL);
}
const MV_REFERENCE_FRAME frame = ref_mbmi->ref_frame[0];
@@ -176,7 +192,7 @@
"Reference frame has invalid dimensions");
av1_setup_pre_planes(xd, 0, &ref_buf->buf, ref_mi_row, ref_mi_col, sf,
- num_planes);
+ num_planes, NULL);
}
static INLINE void build_obmc_prediction(MACROBLOCKD *xd, int rel_mi_row,
@@ -291,13 +307,8 @@
dst_stride1);
av1_build_prediction_by_left_preds(cm, xd, dst_buf2, dst_width2, dst_height2,
dst_stride2);
-#if CONFIG_SDP
- av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type[PLANE_TYPE_Y],
- &cm->cur_frame->buf, mi_row, mi_col, 0, num_planes);
-#else
- av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, &cm->cur_frame->buf,
- mi_row, mi_col, 0, num_planes);
-#endif
+ av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
+ num_planes, &xd->mi[0]->chroma_ref_info);
av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2,
dst_stride2);
}
@@ -305,7 +316,6 @@
void av1_build_inter_predictors_for_planes_single_buf(
MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane_from, int plane_to, int ref,
uint8_t *ext_dst[3], int ext_dst_stride[3]) {
- assert(bsize < BLOCK_SIZES_ALL);
const MB_MODE_INFO *mi = xd->mi[0];
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
@@ -318,8 +328,18 @@
for (int plane = plane_from; plane <= plane_to; ++plane) {
const struct macroblockd_plane *pd = &xd->plane[plane];
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, mi, plane, pd->subsampling_x, pd->subsampling_y);
+#if CONFIG_SDP
+ assert(plane_bsize ==
+ get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y));
+#endif // CONFIG_SDP
+ (void)bsize;
+#else
const BLOCK_SIZE plane_bsize =
get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
const int bw = block_size_wide[plane_bsize];
const int bh = block_size_high[plane_bsize];
@@ -443,10 +463,21 @@
uint8_t *ext_dst1[3],
int ext_dst_stride1[3]) {
int plane;
- assert(bsize < BLOCK_SIZES_ALL);
for (plane = plane_from; plane <= plane_to; ++plane) {
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, xd->mi[0], plane, xd->plane[plane].subsampling_x,
+ xd->plane[plane].subsampling_y);
+#if CONFIG_SDP
+ assert(plane_bsize == get_plane_block_size(bsize,
+ xd->plane[plane].subsampling_x,
+ xd->plane[plane].subsampling_y));
+#endif // CONFIG_SDP
+ (void)bsize;
+#else
const BLOCK_SIZE plane_bsize = get_plane_block_size(
bsize, xd->plane[plane].subsampling_x, xd->plane[plane].subsampling_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
const int bw = block_size_wide[plane_bsize];
const int bh = block_size_high[plane_bsize];
build_wedge_inter_predictor_from_buf(
diff --git a/av1/encoder/reconinter_enc.h b/av1/encoder/reconinter_enc.h
index fdc1f31..9347523 100644
--- a/av1/encoder/reconinter_enc.h
+++ b/av1/encoder/reconinter_enc.h
@@ -54,6 +54,7 @@
void av1_build_obmc_inter_predictors_sb(const AV1_COMMON *cm, MACROBLOCKD *xd);
+// TODO(any): Refactor bsize out of the function signature
void av1_build_inter_predictors_for_planes_single_buf(
MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane_from, int plane_to, int ref,
uint8_t *ext_dst[3], int ext_dst_stride[3]);
diff --git a/av1/encoder/segmentation.c b/av1/encoder/segmentation.c
index a240b59..66b206c 100644
--- a/av1/encoder/segmentation.c
+++ b/av1/encoder/segmentation.c
@@ -53,8 +53,9 @@
if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
xd->mi = mi;
+ assert(xd->mi && xd->mi[0]);
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
- mi_params->mi_cols);
+ mi_params->mi_cols, &xd->mi[0]->chroma_ref_info);
// Count the number of hits on each segment with no prediction
const int segment_id = xd->mi[0]->segment_id;
@@ -124,6 +125,19 @@
CSEGS(hbs, bs, 0, 0);
CSEGS(hbs, bs, 0, hbs);
break;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ case PARTITION_HORZ_3:
+ CSEGS(bs, qbs, 0, 0);
+ CSEGS(bs, hbs, qbs, 0);
+ if (mi_row + 3 * qbs < mi_params->mi_rows) CSEGS(bs, qbs, 3 * qbs, 0);
+ break;
+
+ case PARTITION_VERT_3:
+ CSEGS(qbs, bs, 0, 0);
+ CSEGS(hbs, bs, 0, qbs);
+ if (mi_col + 3 * qbs < mi_params->mi_cols) CSEGS(qbs, bs, 0, 3 * qbs);
+ break;
+#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_A:
CSEGS(hbs, hbs, 0, 0);
CSEGS(hbs, hbs, 0, hbs);
@@ -150,14 +164,13 @@
CSEGS(bs, qbs, 2 * qbs, 0);
if (mi_row + 3 * qbs < mi_params->mi_rows) CSEGS(bs, qbs, 3 * qbs, 0);
break;
-
case PARTITION_VERT_4:
CSEGS(qbs, bs, 0, 0);
CSEGS(qbs, bs, 0, qbs);
CSEGS(qbs, bs, 0, 2 * qbs);
if (mi_col + 3 * qbs < mi_params->mi_cols) CSEGS(qbs, bs, 0, 3 * qbs);
break;
-
+#endif // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT: {
const BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_SPLIT);
int n;
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index cc42808..c47861d 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -153,7 +153,11 @@
else
sf->part_sf.auto_max_partition_based_on_simple_motion = RELAXED_PRED;
} else {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128;
+#else // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.auto_max_partition_based_on_simple_motion = DIRECT_PRED;
}
@@ -181,9 +185,17 @@
if (is_720p_or_larger) {
sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128;
} else if (is_480p_or_larger) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128;
+#else // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
} else {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128;
+#else // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.use_square_partition_only_threshold = BLOCK_32X32;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
if (!is_720p_or_larger) {
@@ -197,6 +209,9 @@
}
if (speed >= 2) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128;
+#else // CONFIG_EXT_RECUR_PARTITIONS
if (is_720p_or_larger) {
sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64;
} else if (is_480p_or_larger) {
@@ -204,6 +219,7 @@
} else {
sf->part_sf.use_square_partition_only_threshold = BLOCK_32X32;
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
if (is_720p_or_larger) {
sf->part_sf.partition_search_breakout_dist_thr = (1 << 24);
@@ -309,12 +325,25 @@
sf->gm_sf.gm_search_type = GM_REDUCED_REF_SEARCH_SKIP_L2_L3;
sf->part_sf.less_rectangular_check_level = 1;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->part_sf.enable_fast_erp = 0;
+ sf->part_sf.ml_prune_4_partition = 0;
+ sf->part_sf.ml_prune_ab_partition = 0;
+
+ sf->part_sf.prune_part_3_with_part_none = 1;
+#else // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.ml_prune_4_partition = 1;
sf->part_sf.ml_prune_ab_partition = 1;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.ml_prune_rect_partition = 1;
sf->part_sf.prune_ext_partition_types_search_level = 1;
sf->part_sf.simple_motion_search_prune_rect = 1;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->inter_sf.reuse_erp_mode_flag =
+ (REUSE_PARTITION_MODE_FLAG | REUSE_INTER_MODE_IN_INTERFRAME_FLAG |
+ REUSE_INTRA_MODE_IN_INTERFRAME_FLAG);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
sf->inter_sf.disable_wedge_search_var_thresh = 0;
// TODO(debargha): Test, tweak and turn on either 1 or 2
sf->inter_sf.inter_mode_rd_model_estimation = 1;
@@ -362,7 +391,11 @@
sf->gm_sf.gm_search_type = GM_REDUCED_REF_SEARCH_SKIP_L2_L3_ARF2;
sf->gm_sf.prune_ref_frame_for_gm_search = boosted ? 0 : 1;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ sf->part_sf.intra_cnn_split = 0;
+#else // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.intra_cnn_split = 1;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
sf->part_sf.simple_motion_search_early_term_none = 1;
// TODO(Venkat): Clean-up frame type dependency for
// simple_motion_search_split in partition search function and set the
@@ -705,6 +738,10 @@
part_sf->prune_4_partition_using_split_info = 0;
part_sf->prune_ab_partition_using_split_info = 0;
part_sf->early_term_after_none_split = 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ part_sf->enable_fast_erp = 0;
+ part_sf->prune_part_3_with_part_none = 1;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
static AOM_INLINE void init_mv_sf(MV_SPEED_FEATURES *mv_sf) {
@@ -771,6 +808,9 @@
inter_sf->txfm_rd_gate_level = 0;
inter_sf->prune_inter_modes_if_skippable = 0;
inter_sf->disable_masked_comp = 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ inter_sf->reuse_erp_mode_flag = 0;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
}
static AOM_INLINE void init_interp_sf(INTERP_FILTER_SPEED_FEATURES *interp_sf) {
@@ -897,7 +937,9 @@
part_sf->ml_prune_ab_partition = 0;
part_sf->ml_prune_rect_partition = 0;
part_sf->ml_early_term_after_part_split_level = 0;
+#if !CONFIG_EXT_RECUR_PARTITIONS
part_sf->auto_max_partition_based_on_simple_motion = NOT_IN_USE;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
part_sf->intra_cnn_split = 0;
part_sf->simple_motion_search_split = 0;
part_sf->simple_motion_search_prune_rect = 0;
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index d52d2fc..eb7db43 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -310,6 +310,25 @@
} UENUM1BYTE(SUPERRES_AUTO_SEARCH_TYPE);
/*!\endcond */
+#if CONFIG_EXT_RECUR_PARTITIONS
+/*! \brief Used with \ref MACROBLOCK::reuse_inter_mode_cache_type to determine
+ * whether partition mode is reused. */
+#define REUSE_PARTITION_MODE_FLAG (1 << 0)
+
+/*! \brief Used with \ref MACROBLOCK::reuse_inter_mode_cache_type to determine
+ * whether the intra prediction_mode is reused. */
+#define REUSE_INTRA_MODE_IN_INTERFRAME_FLAG (1 << 1)
+
+/*! \brief Used with \ref MACROBLOCK::reuse_inter_mode_cache_type to determine
+ * whether the inter prediction_mode and ref frame are reused. */
+#define REUSE_INTER_MODE_IN_INTERFRAME_FLAG (1 << 2)
+
+/*! \brief Used with \ref MACROBLOCK::reuse_inter_mode_cache_type to signal
+ * reuse of inter and intra prediction_modes, as well as ref frame. */
+#define REUSE_INTERFRAME_FLAG \
+ (REUSE_INTRA_MODE_IN_INTERFRAME_FLAG | REUSE_INTER_MODE_IN_INTERFRAME_FLAG)
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
/*!
* \brief Sequence/frame level speed vs quality features
*/
@@ -508,6 +527,13 @@
// Terminate partition search for child partition,
// when NONE and SPLIT partition rd_costs are INT64_MAX.
int early_term_after_none_split;
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int enable_fast_erp;
+
+ // Prunes PARTITION_3 if PARTITION_NONE is used instead of PARTITION_HORZ|VERT
+ int prune_part_3_with_part_none;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
} PARTITION_SPEED_FEATURES;
typedef struct MV_SPEED_FEATURES {
@@ -758,6 +784,13 @@
// Enable/disable masked compound.
int disable_masked_comp;
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+ // Under ERP, determines whether to reuse partition mode and prediction mode
+ // if a block with the same (mi_row, mi_col, bsize) is visited more than one
+ // by the encoder.
+ int reuse_erp_mode_flag;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
} INTER_MODE_SPEED_FEATURES;
typedef struct INTERP_FILTER_SPEED_FEATURES {
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 1613bf8..de7a189 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -141,7 +141,14 @@
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
-#if CONFIG_SDP
+#if CONFIG_SDP && CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
+ const TX_SIZE plane_tx_size =
+ plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
+ pd->subsampling_y)
+ : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
+ blk_col)];
+#elif CONFIG_SDP
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(mbmi->sb_type[xd->tree_type == CHROMA_PART],
pd->subsampling_x, pd->subsampling_y)
@@ -149,24 +156,27 @@
blk_col)];
#else
const TX_SIZE plane_tx_size =
- plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x,
- pd->subsampling_y)
+ plane ? av1_get_max_uv_txsize(mbmi->chroma_ref_info.bsize_base,
+ pd->subsampling_x, pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#endif
if (tx_size == plane_tx_size || plane) {
-#if CONFIG_SDP
- plane_bsize =
- get_plane_block_size(mbmi->sb_type[xd->tree_type == CHROMA_PART],
- pd->subsampling_x, pd->subsampling_y);
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ plane_bsize = get_mb_plane_block_size(xd, mbmi, plane, pd->subsampling_x,
+ pd->subsampling_y);
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ assert(plane_bsize ==
+ get_plane_block_size(mbmi->sb_type[xd->tree_type == CHROMA_PART],
+ pd->subsampling_x, pd->subsampling_y));
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
#else
plane_bsize = get_plane_block_size(mbmi->sb_type, pd->subsampling_x,
pd->subsampling_y);
-#endif
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
av1_update_and_record_txb_context(plane, block, blk_row, blk_col,
plane_bsize, tx_size, arg);
-
} else {
#if CONFIG_NEW_TX_PARTITION
TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
@@ -240,8 +250,12 @@
#if CONFIG_SDP
if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
#else
+ assert(mbmi->sb_type < BLOCK_SIZES_ALL);
if (mbmi->skip_txfm) {
#endif
+#if CONFIG_SDP
+ assert(bsize == mbmi->sb_type[av1_get_sdp_idx(xd->tree_type)]);
+#endif // CONFIG_SDP
av1_reset_entropy_context(xd, bsize, num_planes);
return;
}
@@ -256,7 +270,20 @@
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE plane_bsize =
+ get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
+#if CONFIG_SDP
+ const BLOCK_SIZE bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base : bsize;
+ assert(plane_bsize == get_plane_block_size(bsize_base, ss_x, ss_y));
+ (void)bsize_base;
+#endif // CONFIG_SDP
+#else
+ const BLOCK_SIZE bsize_base =
+ plane ? mbmi->chroma_ref_info.bsize_base : bsize;
+ const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize_base, ss_x, ss_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
assert(plane_bsize < BLOCK_SIZES_ALL);
const int mi_width = mi_size_wide[plane_bsize];
const int mi_height = mi_size_high[plane_bsize];
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index 6a2e5cc..3928c62 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -275,9 +275,9 @@
set_mode_info_offsets(&cpi->common.mi_params, &cpi->mbmi_ext_info, x, xd,
mi_row, mi_col);
set_mi_row_col(xd, &xd->tile, mi_row, mi_height, mi_col, mi_width,
- cm->mi_params.mi_rows, cm->mi_params.mi_cols);
- set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize],
- av1_num_planes(cm));
+ cm->mi_params.mi_rows, cm->mi_params.mi_cols, NULL);
+ set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize], av1_num_planes(cm),
+ NULL);
#if CONFIG_SDP
xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART] = bsize;
#else
@@ -783,6 +783,12 @@
tpl_reset_src_ref_frames(tpl_data);
av1_tile_init(&xd->tile, cm, 0, 0);
+ // TODO(any): The tiles are not being set correctly by av1_tile_init above as
+ // it always assumes the first tile is used. We set the tile size here as a
+ // hack.
+ xd->tile.mi_row_end = cm->mi_params.mi_rows;
+ xd->tile.mi_col_end = cm->mi_params.mi_cols;
+
// Setup scaling factor
av1_setup_scale_factors_for_frame(
&tpl_data->sf, this_frame->y_crop_width, this_frame->y_crop_height,
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c
index 9b7ae7f..f109006 100644
--- a/av1/encoder/tx_search.c
+++ b/av1/encoder/tx_search.c
@@ -9,6 +9,7 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
+#include "av1/common/blockd.h"
#include "av1/common/cfl.h"
#include "av1/common/reconintra.h"
#include "av1/encoder/block.h"
@@ -907,8 +908,13 @@
for (int plane = 0; plane < num_planes; ++plane) {
const struct macroblock_plane *const p = &x->plane[plane];
const struct macroblockd_plane *const pd = &xd->plane[plane];
+#if CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
+ const BLOCK_SIZE bs = get_mb_plane_block_size(
+ xd, mbmi, plane, pd->subsampling_x, pd->subsampling_y);
+#else
const BLOCK_SIZE bs = get_plane_block_size(mbmi->sb_type, pd->subsampling_x,
pd->subsampling_y);
+#endif // CONFIG_EXT_RECUR_PARTITIONS || CONFIG_SDP
unsigned int sse;
if (x->skip_chroma_rd && plane) continue;
@@ -1337,7 +1343,12 @@
tx_size_wide[tx_size] == tx_size_high[tx_size]);
#else
assert(cpi->sf.tx_sf.use_intra_txb_hash &&
+#if CONFIG_SDP
+ frame_is_intra_only(&cpi->common) &&
+ !is_inter_block(xd->mi[0], xd->tree_type) &&
+#else
frame_is_intra_only(&cpi->common) && !is_inter_block(xd->mi[0]) &&
+#endif
plane == 0 && tx_size_wide[tx_size] == tx_size_high[tx_size]);
#endif
const uint32_t intra_hash =
@@ -2421,6 +2432,11 @@
// Therefore transform domain distortion is not valid for these
// transform sizes.
(txsize_sqr_up_map[tx_size] != TX_64X64) &&
+#if CONFIG_IST
+ // Use pixel domain distortion for IST
+ // TODO(any): Make IST compatible with tx domain distortion
+ !cm->seq_params.enable_ist &&
+#endif
// Use pixel domain distortion for DC only blocks
!dc_only_blk;
// Flag to indicate if an extra calculation of distortion in the pixel domain
@@ -3482,7 +3498,7 @@
if (plane == AOM_PLANE_Y && xd->cfl.store_y) {
#endif
assert(!is_inter || plane_bsize < BLOCK_8X8);
- cfl_store_tx(xd, blk_row, blk_col, tx_size, plane_bsize);
+ cfl_store_tx(xd, blk_row, blk_col, tx_size);
}
#if CONFIG_RD_DEBUG
@@ -4086,7 +4102,7 @@
}
int av1_txfm_uvrd(const AV1_COMP *const cpi, MACROBLOCK *x, RD_STATS *rd_stats,
- BLOCK_SIZE bsize, int64_t ref_best_rd) {
+ int64_t ref_best_rd) {
av1_init_rd_stats(rd_stats);
if (ref_best_rd < 0) return 0;
if (!x->e_mbd.is_chroma_ref) return 1;
@@ -4100,8 +4116,13 @@
const int is_inter = is_inter_block(mbmi);
#endif
int64_t this_rd = 0, skip_txfm_rd = 0;
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+#if CONFIG_SDP || CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE plane_bsize = get_mb_plane_block_size(
+ xd, mbmi, AOM_PLANE_U, pd->subsampling_x, pd->subsampling_y);
+#else
+ const BLOCK_SIZE plane_bsize = get_plane_block_size(
+ mbmi->chroma_ref_info.bsize_base, pd->subsampling_x, pd->subsampling_y);
+#endif // CONFIG_SDP || CONFIG_EXT_RECUR_PARTITIONS
if (is_inter) {
for (int plane = 1; plane < MAX_MB_PLANE; ++plane)
@@ -4273,7 +4294,7 @@
AOMMIN(non_skip_txfm_rdcosty, skip_txfm_rdcosty));
}
const int is_cost_valid_uv =
- av1_txfm_uvrd(cpi, x, rd_stats_uv, bsize, ref_best_chroma_rd);
+ av1_txfm_uvrd(cpi, x, rd_stats_uv, ref_best_chroma_rd);
if (!is_cost_valid_uv) return 0;
av1_merge_rd_stats(rd_stats, rd_stats_uv);
}
diff --git a/av1/encoder/tx_search.h b/av1/encoder/tx_search.h
index 5a5d259..f5d145f 100644
--- a/av1/encoder/tx_search.h
+++ b/av1/encoder/tx_search.h
@@ -213,13 +213,12 @@
* \param[in] x Pointer to structure holding the data for the
current encoding macroblock
* \param[in] rd_stats Pointer to struct to keep track of the RD stats
- * \param[in] bsize Current macroblock size
* \param[in] ref_best_rd Best RD cost seen for this block so far
* \return An integer value is returned. 0: early termination triggered,
no valid rd cost available; 1: rd cost values are valid.
*/
int av1_txfm_uvrd(const AV1_COMP *const cpi, MACROBLOCK *x, RD_STATS *rd_stats,
- BLOCK_SIZE bsize, int64_t ref_best_rd);
+ int64_t ref_best_rd);
/*!\brief Transform type search with fixed transform size.
*
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index ddab3cc..3399929 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -139,7 +139,8 @@
"AV2 experiment flag to remove dist_wtd_comp tool.")
set_aom_config_var(CONFIG_REMOVE_DUAL_FILTER 1
"AV2 experiment flag to remove dual filter.")
-
+set_aom_config_var(CONFIG_EXT_RECUR_PARTITIONS 0 NUMBER
+ "AV2 Fully recursive partitions experiment flag")
set_aom_config_var(CONFIG_SDP 1 NUMBER "AV2 Semi-Decoupled Partitioning.")
set_aom_config_var(CONFIG_EXTQUANT 1
"AV2 extended quantization experiment flag")
diff --git a/test/intrabc_test.cc b/test/intrabc_test.cc
index b57eb6f..2081f8b 100644
--- a/test/intrabc_test.cc
+++ b/test/intrabc_test.cc
@@ -159,9 +159,7 @@
for (const DvTestCase &dv_case : kDvCases) {
const int mi_row = xd.tile.mi_row_start + dv_case.mi_row_offset;
const int mi_col = xd.tile.mi_col_start + dv_case.mi_col_offset;
- xd.is_chroma_ref = is_chroma_reference(mi_row, mi_col, dv_case.bsize,
- xd.plane[1].subsampling_x,
- xd.plane[1].subsampling_y);
+ xd.is_chroma_ref = 1;
EXPECT_EQ(static_cast<int>(dv_case.valid),
av1_is_dv_valid(dv_case.dv, &cm, &xd, mi_row, mi_col,
dv_case.bsize, MAX_MIB_SIZE_LOG2));
diff --git a/test/sad_test.cc b/test/sad_test.cc
index 963098e..c734789 100644
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -2077,8 +2077,8 @@
make_tuple(32, 32, &aom_sad32x32x4d_sse2, -1),
make_tuple(32, 16, &aom_sad32x16x4d_sse2, -1),
make_tuple(16, 32, &aom_sad16x32x4d_sse2, -1),
- make_tuple(16, 16, &aom_sad16x16x4d_sse2, -1),
make_tuple(16, 8, &aom_sad16x8x4d_sse2, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_sse2, -1),
make_tuple(8, 16, &aom_sad8x16x4d_sse2, -1),
make_tuple(8, 8, &aom_sad8x8x4d_sse2, -1),
make_tuple(8, 4, &aom_sad8x4x4d_sse2, -1),
diff --git a/test/test_intra_pred_speed.cc b/test/test_intra_pred_speed.cc
index 2fb783d..56a3686 100644
--- a/test/test_intra_pred_speed.cc
+++ b/test/test_intra_pred_speed.cc
@@ -624,15 +624,15 @@
aom_dc_top_predictor_16x32_sse2,
aom_dc_128_predictor_16x32_sse2, aom_v_predictor_16x32_sse2,
aom_h_predictor_16x32_sse2, NULL, NULL, NULL, NULL)
+INTRA_PRED_TEST(SSE2_5, TX_16X4, aom_dc_predictor_16x4_sse2,
+ aom_dc_left_predictor_16x4_sse2, aom_dc_top_predictor_16x4_sse2,
+ aom_dc_128_predictor_16x4_sse2, aom_v_predictor_16x4_sse2,
+ aom_h_predictor_16x4_sse2, NULL, NULL, NULL, NULL)
INTRA_PRED_TEST(SSE2_4, TX_16X64, aom_dc_predictor_16x64_sse2,
aom_dc_left_predictor_16x64_sse2,
aom_dc_top_predictor_16x64_sse2,
aom_dc_128_predictor_16x64_sse2, aom_v_predictor_16x64_sse2,
aom_h_predictor_16x64_sse2, NULL, NULL, NULL, NULL)
-INTRA_PRED_TEST(SSE2_5, TX_16X4, aom_dc_predictor_16x4_sse2,
- aom_dc_left_predictor_16x4_sse2, aom_dc_top_predictor_16x4_sse2,
- aom_dc_128_predictor_16x4_sse2, aom_v_predictor_16x4_sse2,
- aom_h_predictor_16x4_sse2, NULL, NULL, NULL, NULL)
#endif // HAVE_SSE2
#if HAVE_SSSE3
diff --git a/test/variance_test.cc b/test/variance_test.cc
index e566f8f..3cc76cd 100644
--- a/test/variance_test.cc
+++ b/test/variance_test.cc
@@ -2583,8 +2583,8 @@
SubpelAvgVarianceParams(6, 6, &aom_sub_pixel_avg_variance64x64_avx2, 0),
SubpelAvgVarianceParams(6, 5, &aom_sub_pixel_avg_variance64x32_avx2, 0),
SubpelAvgVarianceParams(5, 6, &aom_sub_pixel_avg_variance32x64_avx2, 0),
- SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_avx2, 0),
- SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_avx2,
+ SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_avx2, 0),
+ SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_avx2,
0)));
#endif // HAVE_AVX2
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index ff5ab22..ab279c2 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -326,14 +326,34 @@
/* block partition */
cts_each_dim[0] = PARTITION_CONTEXTS;
cts_each_dim[1] = EXT_PARTITION_TYPES;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ int part_types_each_ctx[PARTITION_CONTEXTS] = {
+ 3, 3, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 3
+ };
+#else
int part_types_each_ctx[PARTITION_CONTEXTS] = { 4, 4, 4, 4, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10,
10, 10, 8, 8, 8, 8 };
+#endif // CONFIG_EXT_RECUR_PARTITIONS
optimize_cdf_table_var_modes_2d(
&fc.partition[0][0], probsfile, 2, cts_each_dim, part_types_each_ctx,
"static const aom_cdf_prob default_partition_cdf[PARTITION_CONTEXTS]"
"[CDF_SIZE(EXT_PARTITION_TYPES)]");
+#if CONFIG_EXT_RECUR_PARTITIONS
+ cts_each_dim[0] = PARTITION_CONTEXTS_REC;
+ cts_each_dim[1] = PARTITION_TYPES_REC;
+ int part_types_each_ctx_rec[PARTITION_CONTEXTS_REC] = { 2, 2, 2, 2, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 3, 3, 3, 3 };
+ optimize_cdf_table_var_modes_2d(
+ &fc.partition_rec[0][0], probsfile, 2, cts_each_dim,
+ part_types_each_ctx_rec,
+ "static const aom_cdf_prob "
+ "default_partition_rec_cdf[PARTITION_CONTEXTS_REC]"
+ "[CDF_SIZE(PARTITION_TYPES_REC)]");
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
/* tx type */
cts_each_dim[0] = EXT_TX_SETS_INTRA;
cts_each_dim[1] = EXT_TX_SIZES;
