Merge v5 anchor into research-block256
Performance relative to v5 anchor:
| CONFIG | b2 | PSNR_YUV | Enc Time | Dec Time |
| :----: | :--: | :------: | :------: | :------: |
| AI | w/o | +0.04% | 102% | 109% |
| | only | +0.02% | 104% | 109% |
| | | | | |
| RA | w/o | -0.47% | 116% | 105% |
| | only | -0.16% | 132% | 104% |
| | | | | |
| LD | w/o | -0.41% | 118% | 107% |
| | only | -0.47% | 129% | 103% |
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 4ea7422..7b4fbe2 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -39,13 +39,23 @@
# Run clang-format check.
for f in $(git diff --diff-filter=ACMR --name-only $DIFF_REF '*.[hc]pp' '*.cc' '*.[ch]' \
| grep -v third_party); do
- clang-format -i --style=file $f -n -Werror
+ clang-format -i --style=file $f -n -Werror || exit_code=$?
+ if [ ${exit_code} -ne 0 ]; then
+ echo "Please format your code by following instructions here:"
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#style-check"
+ exit 1
+ fi
done
- |
# Run cmake-format check.
for f in $(git diff --diff-filter=ACMR --name-only $DIFF_REF '*.cmake' 'CMakeLists.txt' \
| grep -v third_party); do
- cmake-format --check $f
+ cmake-format --check $f || exit_code=$?
+ if [ ${exit_code} -ne 0 ]; then
+ echo "Please format your code by following instructions here:"
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#style-check"
+ exit 1
+ fi
done
rules:
- if: '$CI_PIPELINE_SOURCE == "schedule"'
@@ -237,7 +247,16 @@
echo "Extra CMake Flags: $EXTRA_CMAKE_FLAGS"
echo "Configuration: $AOM_BUILD_CONFIG"
- cmake -B aom_build -S . -GNinja -DCMAKE_BUILD_TYPE=Release $CMAKE_FLAGS $EXTRA_CMAKE_FLAGS
- - cmake --build aom_build -j 2
+ - cmake --build aom_build -j 2 || exit_code=$?
+ - |
+ if [ ${exit_code} -ne 0 ]; then
+ echo "You may reproduce the compile failure by following instructions here:"
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#build-avm-in-various-configurations"
+ echo "Using following values:"
+ echo "CMAKE_FLAGS = ${CMAKE_FLAGS}"
+ echo "EXTRA_CMAKE_FLAGS = ${EXTRA_CMAKE_FLAGS}"
+ exit 1
+ fi
- cmake --build aom_build --target dist
- DESTDIR="${CI_PROJECT_DIR}/${INSTALLROOT_FOLDER}" cmake --build aom_build --target install/strip
needs: []
@@ -549,14 +568,20 @@
- |
# Looking for sanitizer output in log...
grep -q "\(ERROR\|WARNING\): \(Address\|Thread\|Memory\|Leak\)Sanitizer:" sanitizer.log && {
- echo "Found sanitizer errors or warnings, check the log:"
+ echo "Found sanitizer errors or warnings, check the log below:"
cat sanitizer.log
+ echo "You may reproduce sanitizer builds and tests by following instructions below: "
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#build-unit-tests-with-sanitizers and"
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#run-unit-tests-with-sanitizers"
exit 1
}
# Looking for UBSan output in log (differs from the common format)
grep -q ":[[:digit:]]\+:[[:digit:]]\+: runtime error:" sanitizer.log && {
- echo "Found sanitizer errors or warnings, check the log:"
+ echo "Found sanitizer errors or warnings, check the log below:"
cat sanitizer.log
+ echo "You may reproduce sanitizer builds and tests by following instructions below: "
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#build-unit-tests-with-sanitizers and"
+ echo "https://gitlab.com/AOMediaCodec/avm/-/wikis/Reproducing-CI-Test-Failures-Locally#run-unit-tests-with-sanitizers"
exit 1
}
echo "No sanitizer errors found"
@@ -621,7 +646,7 @@
interruptible: true
variables:
AOMENC_LIMIT: 30
- AOMENC_QP: 128
+ AOMENC_QP: 210
AOMENC_INPUT: Vertical_Bayshore_270x480_2997.y4m
AOMENC: installroot/usr/local/bin/aomenc
before_script:
@@ -757,6 +782,67 @@
needs:
- 'Previous Build (x86_64-linux-gcc): [encode-only]'
+# Decode encoded streams and verify that number of frames is as expected.
+.dec-run-common:
+ stage: test
+ interruptible: true
+ variables:
+ AOMENC_LIMIT: 30 # Should match the same variable in `.enc-run-common`
+ AOMDEC: installroot/usr/local/bin/aomdec
+ script:
+ - ${AOMDEC} ${AOMENC_OUTPUT}.obu -o ${AOMDEC_OUTPUT}.decoded.y4m --summary
+ 2>&1 | tee "${AOMDEC_OUTPUT}.summary.log"
+ - '[ -f "${AOMDEC_OUTPUT}.decoded.y4m" ] || exit 1'
+ - '[ -f "${AOMDEC_OUTPUT}.summary.log" ] || exit 1'
+ - |
+ for str in 'decoded frames' 'showed frames'; do
+ frame_count=$(grep -E -o "[0-9]+ ${str}" "${AOMDEC_OUTPUT}.summary.log" | sed -E "s/([0-9]+) ${str}/\1/g")
+ echo "${str} = ${frame_count}"
+ if [[ ${frame_count} -ne ${AOMENC_LIMIT} ]]; then
+ echo "ERROR: Unexpected number of ${str}. Got ${frame_count}, expected ${AOMENC_LIMIT}"
+ exit 1
+ fi
+ done
+ artifacts:
+ when: always
+ paths:
+ - ${AOMDEC_OUTPUT}.*
+ rules:
+ - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+ - if: '$CI_PIPELINE_SOURCE == "schedule"'
+ when: never
+
+
+Dec Run (All-intra):
+ extends: .dec-run-common
+ variables:
+ AOMENC_OUTPUT: all-intra
+ AOMDEC_OUTPUT: dec-all-intra
+ needs:
+ - 'Enc Run (All-intra)'
+ - 'Build (x86_64-linux-gcc): [decode-only]'
+
+
+Dec Run (Random Access):
+ extends: .dec-run-common
+ variables:
+ AOMENC_OUTPUT: random-access
+ AOMDEC_OUTPUT: dec-random-access
+ needs:
+ - 'Enc Run (Random Access)'
+ - 'Build (x86_64-linux-gcc): [decode-only]'
+
+
+Dec Run (Low-delay):
+ extends: .dec-run-common
+ variables:
+ AOMENC_OUTPUT: low-delay
+ AOMDEC_OUTPUT: dec-low-delay
+ needs:
+ - 'Enc Run (Low-delay)'
+ - 'Build (x86_64-linux-gcc): [decode-only]'
+
+
Enc compare:
stage: report
interruptible: true
diff --git a/.gitlab/UBSan.supp b/.gitlab/UBSan.supp
index b0000e8..357d7d1 100644
--- a/.gitlab/UBSan.supp
+++ b/.gitlab/UBSan.supp
@@ -38,8 +38,6 @@
implicit-signed-integer-truncation:av1_fdct8x64_new_sse2
# nullptr-with-offset warnings.
-pointer-overflow:file_read
-pointer-overflow:av1_pack_bitstream
pointer-overflow:vfilter8
pointer-overflow:highbd_vfilter8
diff --git a/.gitlab/ci_nightly.yml b/.gitlab/ci_nightly.yml
index d5adad8..fd0544d 100644
--- a/.gitlab/ci_nightly.yml
+++ b/.gitlab/ci_nightly.yml
@@ -261,6 +261,7 @@
Linux Sanitizer (thread) Test Nightly:
extends: .sanitizer-common-nigtly
+ parallel: 16
variables:
AOM_SANITIZER_TYPE: thread
needs:
diff --git a/aom/aom_encoder.h b/aom/aom_encoder.h
index 63aa16c..b544fa3 100644
--- a/aom/aom_encoder.h
+++ b/aom/aom_encoder.h
@@ -122,8 +122,12 @@
int partition_id;
/*!\brief size of the visible frame in this packet */
size_t vis_frame_size;
- } frame; /**< data for compressed frame packet */
- aom_fixed_buf_t twopass_stats; /**< data for two-pass packet */
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ /*!\brief the number of frames in this packet */
+ int frame_count;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ } frame; /**< data for compressed frame packet */
+ aom_fixed_buf_t twopass_stats; /**< data for two-pass packet */
aom_fixed_buf_t firstpass_mb_stats; /**< first pass mb packet */
struct aom_psnr_pkt {
unsigned int samples[4]; /**< Number of samples, total/y/u/v */
@@ -324,6 +328,18 @@
*/
unsigned int enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ /*!\brief enable compound weighted prediction
+ *
+ */
+ unsigned int enable_cwp;
+#endif // CONFIG_BAWP
+#if CONFIG_D071_IMP_MSK_BLD
+ /*!\brief enable implicit maksed blending
+ *
+ */
+ unsigned int enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
/*!\brief enable Forward skip coding
*
*/
@@ -334,6 +350,12 @@
*/
unsigned int enable_orip;
#endif // CONFIG_ORIP
+#if CONFIG_IDIF
+ /*!\brief enable Intra Directional Interpolation Filter
+ *
+ */
+ unsigned int enable_idif;
+#endif // CONFIG_IDIF
/*!\brief enable Intra secondary transform
*
*/
@@ -372,6 +394,13 @@
*/
unsigned int enable_joint_mvd;
#endif
+#if CONFIG_REFINEMV
+ /*!\brief enable refine MV mode
+ *
+ */
+ unsigned int enable_refinemv;
+#endif // CONFIG_REFINEMV
+
/*!\brief enable flip and identity transform type
*
*/
@@ -539,6 +568,12 @@
*
*/
unsigned int explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ /*!\brief enable frame output order derivation based on order hint
+ *
+ */
+ unsigned int enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
/*!\brief use reduced transform type set
*
*/
diff --git a/aom/aomcx.h b/aom/aomcx.h
index 3d1150f..d8ed487 100644
--- a/aom/aomcx.h
+++ b/aom/aomcx.h
@@ -1261,6 +1261,11 @@
/*!\brief Control to get frame info
*/
AV1E_GET_FRAME_INFO = 165,
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ /*!\brief Control to set frame output order derivation method
+ */
+ AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION = 166,
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
};
/*!\brief aom 1-D scaling mode
@@ -1751,6 +1756,11 @@
AOM_CTRL_USE_TYPE(AV1E_SET_SUBGOP_CONFIG_PATH, const char *)
#define AOM_CTRL_AV1E_SET_SUBGOP_CONFIG_PATH
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+AOM_CTRL_USE_TYPE(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, int)
+#define AOM_CTRL_AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+
/*!\endcond */
/*! @} - end defgroup aom_encoder */
#ifdef __cplusplus
diff --git a/aom/aomdx.h b/aom/aomdx.h
index d8f3579..3755132 100644
--- a/aom/aomdx.h
+++ b/aom/aomdx.h
@@ -63,8 +63,10 @@
* context.
*/
typedef struct aom_inspect_init {
- /*! Inspection callback. */
+ /*! Inspection callback (per frame). */
aom_inspect_cb inspect_cb;
+ /*! Inspection callback (per superblock). */
+ aom_inspect_cb inspect_sb_cb;
/*! Inspection context. */
void *inspect_ctx;
diff --git a/aom_dsp/aom_dsp_rtcd_defs.pl b/aom_dsp/aom_dsp_rtcd_defs.pl
index e340390..89b6b7b 100755
--- a/aom_dsp/aom_dsp_rtcd_defs.pl
+++ b/aom_dsp/aom_dsp_rtcd_defs.pl
@@ -263,6 +263,22 @@
specialize "aom_highbd_sad8x8", qw/sse2/;
specialize qw/aom_highbd_sad8x8 sse2/;
+add_proto qw/unsigned int/, "aom_highbd_sad8x16", "const uint16_t *src_ptr, int src_stride, const uint16_t *ref_ptr, int ref_stride";
+specialize "aom_highbd_sad8x16", qw/sse2/;
+specialize qw/aom_highbd_sad8x16 sse2/;
+
+add_proto qw/unsigned int/, "aom_highbd_sad16x8", "const uint16_t *src_ptr, int src_stride, const uint16_t *ref_ptr, int ref_stride";
+if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+specialize "aom_highbd_sad16x8", qw/sse2/;
+specialize qw/aom_highbd_sad16x8 sse2/;
+}
+
+add_proto qw/unsigned int/, "aom_highbd_sad16x16", "const uint16_t *src_ptr, int src_stride, const uint16_t *ref_ptr, int ref_stride";
+if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+specialize "aom_highbd_sad16x16", qw/sse2/;
+specialize qw/aom_highbd_sad16x16 sse2/;
+}
+
if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
add_proto qw/void/, "aom_get_blk_sse_sum", "const int16_t *data, int stride, int bw, int bh, int *x_sum, int64_t *x2_sum";
specialize qw/aom_get_blk_sse_sum sse2 avx2/;
@@ -296,8 +312,15 @@
add_proto qw/unsigned int/, "aom_highbd_sad_skip_${w}x${h}", "const uint16_t *src_ptr, int src_stride, const uint16_t *ref_ptr, int ref_stride";
add_proto qw/unsigned int/, "aom_highbd_sad${w}x${h}_avg", "const uint16_t *src_ptr, int src_stride, const uint16_t *ref_ptr, int ref_stride, const uint16_t *second_pred";
if ($w != 128 && $h != 128 && $w != 4 && $w != 256 && $h != 256) {
- specialize "aom_highbd_sad${w}x${h}", qw/sse2/;
- specialize "aom_highbd_sad${w}x${h}_avg", qw/sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ if (!($w == 16 && $h == 16) && !($w == 16 && $h == 8) && !($w == 16 && $h == 4)) {
+ specialize "aom_highbd_sad${w}x${h}", qw/sse2/;
+ specialize "aom_highbd_sad${w}x${h}_avg", qw/sse2/;
+ }
+ } else {
+ specialize "aom_highbd_sad${w}x${h}", qw/sse2/;
+ specialize "aom_highbd_sad${w}x${h}_avg", qw/sse2/;
+ } # CONFIG_UNEVEN_4WAY
}
add_proto qw/unsigned int/, "aom_highbd_dist_wtd_sad${w}x${h}_avg", "const uint16_t *src_ptr, int src_stride, const uint16_t *ref_ptr, int ref_stride, const uint16_t *second_pred, const DIST_WTD_COMP_PARAMS* jcp_param";
}
@@ -313,8 +336,15 @@
specialize qw/aom_highbd_sad32x32 avx2 sse2/;
specialize qw/aom_highbd_sad32x16 avx2 sse2/;
specialize qw/aom_highbd_sad16x32 avx2 sse2/;
- specialize qw/aom_highbd_sad16x16 avx2 sse2/;
- specialize qw/aom_highbd_sad16x8 avx2 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_sad16x16 avx2/;
+ specialize qw/aom_highbd_sad16x8 avx2/;
+ specialize qw/aom_highbd_sad16x4 avx2/;
+ } else {
+ specialize qw/aom_highbd_sad16x16 avx2 sse2/;
+ specialize qw/aom_highbd_sad16x8 avx2 sse2/;
+ specialize qw/aom_highbd_sad16x4 avx2 sse2/;
+ } # CONFIG_UNEVEN_4WAY
specialize qw/aom_highbd_sad8x16 sse2/;
specialize qw/aom_highbd_sad8x8 sse2/;
specialize qw/aom_highbd_sad8x4 sse2/;
@@ -322,7 +352,6 @@
specialize qw/aom_highbd_sad4x4 sse2/;
specialize qw/aom_highbd_sad4x16 sse2/;
- specialize qw/aom_highbd_sad16x4 avx2 sse2/;
specialize qw/aom_highbd_sad8x32 sse2/;
specialize qw/aom_highbd_sad32x8 avx2 sse2/;
specialize qw/aom_highbd_sad16x64 avx2 sse2/;
@@ -340,8 +369,13 @@
specialize qw/aom_highbd_sad_skip_32x32 avx2 sse2/;
specialize qw/aom_highbd_sad_skip_32x16 avx2 sse2/;
specialize qw/aom_highbd_sad_skip_16x32 avx2 sse2/;
- specialize qw/aom_highbd_sad_skip_16x16 avx2 sse2/;
- specialize qw/aom_highbd_sad_skip_16x8 avx2 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_sad_skip_16x16 avx2/;
+ specialize qw/aom_highbd_sad_skip_16x8 avx2/;
+ } else {
+ specialize qw/aom_highbd_sad_skip_16x16 avx2 sse2/;
+ specialize qw/aom_highbd_sad_skip_16x8 avx2 sse2/;
+ }
specialize qw/aom_highbd_sad_skip_8x16 sse2/;
specialize qw/aom_highbd_sad_skip_8x8 sse2/;
specialize qw/aom_highbd_sad_skip_4x8 sse2/;
@@ -364,8 +398,13 @@
specialize qw/aom_highbd_sad32x32_avg avx2 sse2/;
specialize qw/aom_highbd_sad32x16_avg avx2 sse2/;
specialize qw/aom_highbd_sad16x32_avg avx2 sse2/;
- specialize qw/aom_highbd_sad16x16_avg avx2 sse2/;
- specialize qw/aom_highbd_sad16x8_avg avx2 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_sad16x16_avg avx2/;
+ specialize qw/aom_highbd_sad16x8_avg avx2/;
+ } else {
+ specialize qw/aom_highbd_sad16x16_avg avx2 sse2/;
+ specialize qw/aom_highbd_sad16x8_avg avx2 sse2/;
+ }
specialize qw/aom_highbd_sad8x4_avg sse2/;
specialize qw/aom_highbd_sad4x8_avg sse2/;
specialize qw/aom_highbd_sad4x4_avg sse2/;
@@ -558,14 +597,22 @@
# TODO(rachelbarker): When ext-partition-types is enabled, we currently
# don't have vectorized 4x16 highbd variance functions
if ($w == 4 && $h == 4) {
- specialize "aom_highbd_${bd}_variance${w}x${h}", "sse4_1";
+ specialize "aom_highbd_${bd}_variance${w}x${h}", "sse4_1";
specialize "aom_highbd_${bd}_sub_pixel_variance${w}x${h}", "sse4_1";
specialize "aom_highbd_${bd}_sub_pixel_avg_variance${w}x${h}", "sse4_1";
}
- if ($w != 128 && $h != 128 && $w != 4 && $w != 256 && $h != 256) {
- specialize "aom_highbd_${bd}_sub_pixel_variance${w}x${h}", qw/sse2/;
- specialize "aom_highbd_${bd}_sub_pixel_avg_variance${w}x${h}", qw/sse2/;
- }
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ if ($w != 128 && $h != 128 && $w != 4 && !($w == 16 && $h == 16) &&
+ !($w == 16 && $h == 8) && !($w == 16 && $h == 4) && $w != 256 && $h != 256) {
+ specialize "aom_highbd_${bd}_sub_pixel_variance${w}x${h}", qw/sse2/;
+ specialize "aom_highbd_${bd}_sub_pixel_avg_variance${w}x${h}", qw/sse2/;
+ }
+ } else {
+ if ($w != 128 && $h != 128 && $w != 4 && $w != 256 && $h != 256) {
+ specialize "aom_highbd_${bd}_sub_pixel_variance${w}x${h}", qw/sse2/;
+ specialize "aom_highbd_${bd}_sub_pixel_avg_variance${w}x${h}", qw/sse2/;
+ }
+ } # CONFIG_UNEVEN_4WAY
add_proto qw/uint32_t/, "aom_highbd_${bd}_dist_wtd_sub_pixel_avg_variance${w}x${h}", "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred, const DIST_WTD_COMP_PARAMS* jcp_param";
}
@@ -874,11 +921,19 @@
specialize qw/aom_highbd_12_sub_pixel_variance16x32 sse2/;
add_proto qw/uint32_t aom_highbd_12_sub_pixel_variance16x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- # specialize qw/aom_highbd_12_sub_pixel_variance16x16 sse2 avx2/;
- specialize qw/aom_highbd_12_sub_pixel_variance16x16 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ # specialize qw/aom_highbd_12_sub_pixel_variance16x16 sse2/;
+ } else {
+ # specialize qw/aom_highbd_12_sub_pixel_variance16x16 sse2 avx2/;
+ specialize qw/aom_highbd_12_sub_pixel_variance16x16 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_12_sub_pixel_variance16x8/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_12_sub_pixel_variance16x8 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_12_sub_pixel_variance16x8 avx2/;
+ } else {
+ specialize qw/aom_highbd_12_sub_pixel_variance16x8 sse2 avx2/;
+ }
add_proto qw/uint32_t aom_highbd_12_sub_pixel_variance8x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
specialize qw/aom_highbd_12_sub_pixel_variance8x16 sse2/;
@@ -906,8 +961,11 @@
specialize qw/aom_highbd_12_sub_pixel_variance32x8 sse2/;
add_proto qw/uint32_t aom_highbd_12_sub_pixel_variance16x4/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_12_sub_pixel_variance16x4 sse2 avx2/;
-
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_12_sub_pixel_variance16x4 avx2/;
+ } else {
+ specialize qw/aom_highbd_12_sub_pixel_variance16x4 sse2 avx2/;
+ }
if (aom_config("CONFIG_BLOCK_256") eq "yes"){
specialize qw/aom_highbd_10_sub_pixel_variance256x256 avx2/;
@@ -943,10 +1001,18 @@
specialize qw/aom_highbd_10_sub_pixel_variance16x32 sse2 avx2/;
add_proto qw/uint32_t aom_highbd_10_sub_pixel_variance16x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_10_sub_pixel_variance16x16 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_10_sub_pixel_variance16x16 avx2/;
+ } else {
+ specialize qw/aom_highbd_10_sub_pixel_variance16x16 sse2 avx2/;
+ }
add_proto qw/uint32_t aom_highbd_10_sub_pixel_variance16x8/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_10_sub_pixel_variance16x8 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_10_sub_pixel_variance16x8 avx2/;
+ } else {
+ specialize qw/aom_highbd_10_sub_pixel_variance16x8 sse2 avx2/;
+ }
add_proto qw/uint32_t aom_highbd_10_sub_pixel_variance8x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
specialize qw/aom_highbd_10_sub_pixel_variance8x16 sse2/;
@@ -971,7 +1037,11 @@
specialize qw/aom_highbd_10_sub_pixel_variance32x8 sse2 avx2/;
add_proto qw/uint32_t aom_highbd_10_sub_pixel_variance16x4/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_10_sub_pixel_variance16x4 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_10_sub_pixel_variance16x4 avx2/;
+ } else {
+ specialize qw/aom_highbd_10_sub_pixel_variance16x4 sse2 avx2/;
+ }
if (aom_config("CONFIG_BLOCK_256") eq "yes"){
@@ -1008,10 +1078,18 @@
specialize qw/aom_highbd_8_sub_pixel_variance16x32 sse2 avx2/;
add_proto qw/uint32_t aom_highbd_8_sub_pixel_variance16x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_8_sub_pixel_variance16x16 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_8_sub_pixel_variance16x16 avx2/;
+ } else {
+ specialize qw/aom_highbd_8_sub_pixel_variance16x16 sse2 avx2/;
+ }
add_proto qw/uint32_t aom_highbd_8_sub_pixel_variance16x8/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_8_sub_pixel_variance16x8 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_8_sub_pixel_variance16x8 avx2/;
+ } else {
+ specialize qw/aom_highbd_8_sub_pixel_variance16x8 sse2 avx2/;
+ }
add_proto qw/uint32_t aom_highbd_8_sub_pixel_variance8x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
specialize qw/aom_highbd_8_sub_pixel_variance8x16 sse2/;
@@ -1036,7 +1114,11 @@
specialize qw/aom_highbd_8_sub_pixel_variance32x8 sse2 avx2/;
add_proto qw/uint32_t aom_highbd_8_sub_pixel_variance16x4/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse";
- specialize qw/aom_highbd_8_sub_pixel_variance16x4 sse2 avx2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") eq "yes") {
+ specialize qw/aom_highbd_8_sub_pixel_variance16x4 avx2/;
+ } else {
+ specialize qw/aom_highbd_8_sub_pixel_variance16x4 sse2 avx2/;
+ }
#
# Subpixel Avg Variance
@@ -1061,10 +1143,14 @@
specialize qw/aom_highbd_12_sub_pixel_avg_variance16x32 sse2/;
add_proto qw/uint32_t aom_highbd_12_sub_pixel_avg_variance16x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
- specialize qw/aom_highbd_12_sub_pixel_avg_variance16x16 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+ specialize qw/aom_highbd_12_sub_pixel_avg_variance16x16 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_12_sub_pixel_avg_variance16x8/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
- specialize qw/aom_highbd_12_sub_pixel_avg_variance16x8 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+ specialize qw/aom_highbd_12_sub_pixel_avg_variance16x8 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_12_sub_pixel_avg_variance8x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
specialize qw/aom_highbd_12_sub_pixel_avg_variance8x16 sse2/;
@@ -1097,10 +1183,14 @@
specialize qw/aom_highbd_10_sub_pixel_avg_variance16x32 sse2/;
add_proto qw/uint32_t aom_highbd_10_sub_pixel_avg_variance16x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
- specialize qw/aom_highbd_10_sub_pixel_avg_variance16x16 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+ specialize qw/aom_highbd_10_sub_pixel_avg_variance16x16 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_10_sub_pixel_avg_variance16x8/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
- specialize qw/aom_highbd_10_sub_pixel_avg_variance16x8 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+ specialize qw/aom_highbd_10_sub_pixel_avg_variance16x8 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_10_sub_pixel_avg_variance8x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
specialize qw/aom_highbd_10_sub_pixel_avg_variance8x16 sse2/;
@@ -1133,10 +1223,14 @@
specialize qw/aom_highbd_8_sub_pixel_avg_variance16x32 sse2/;
add_proto qw/uint32_t aom_highbd_8_sub_pixel_avg_variance16x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
- specialize qw/aom_highbd_8_sub_pixel_avg_variance16x16 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+ specialize qw/aom_highbd_8_sub_pixel_avg_variance16x16 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_8_sub_pixel_avg_variance16x8/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
- specialize qw/aom_highbd_8_sub_pixel_avg_variance16x8 sse2/;
+ if (aom_config("CONFIG_UNEVEN_4WAY") ne "yes") {
+ specialize qw/aom_highbd_8_sub_pixel_avg_variance16x8 sse2/;
+ }
add_proto qw/uint32_t aom_highbd_8_sub_pixel_avg_variance8x16/, "const uint16_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint16_t *ref_ptr, int ref_stride, uint32_t *sse, const uint16_t *second_pred";
specialize qw/aom_highbd_8_sub_pixel_avg_variance8x16 sse2/;
diff --git a/aom_dsp/binary_codes_reader.c b/aom_dsp/binary_codes_reader.c
index b9172b0..486b623 100644
--- a/aom_dsp/binary_codes_reader.c
+++ b/aom_dsp/binary_codes_reader.c
@@ -15,18 +15,18 @@
#include "av1/common/common.h"
uint16_t aom_read_primitive_quniform_(aom_reader *r,
- uint16_t n ACCT_STR_PARAM) {
+ uint16_t n ACCT_INFO_PARAM) {
if (n <= 1) return 0;
const int l = get_msb(n) + 1;
const int m = (1 << l) - n;
- const int v = aom_read_literal(r, l - 1, ACCT_STR_NAME);
- return v < m ? v : (v << 1) - m + aom_read_bit(r, ACCT_STR_NAME);
+ const int v = aom_read_literal(r, l - 1, ACCT_INFO_NAME);
+ return v < m ? v : (v << 1) - m + aom_read_bit(r, ACCT_INFO_NAME);
}
// Decode finite subexponential code that for a symbol v in [0, n-1] with
// parameter k
uint16_t aom_read_primitive_subexpfin_(aom_reader *r, uint16_t n,
- uint16_t k ACCT_STR_PARAM) {
+ uint16_t k ACCT_INFO_PARAM) {
int i = 0;
int mk = 0;
@@ -35,11 +35,11 @@
int a = (1 << b);
if (n <= mk + 3 * a) {
- return aom_read_primitive_quniform(r, n - mk, ACCT_STR_NAME) + mk;
+ return aom_read_primitive_quniform(r, n - mk, ACCT_INFO_NAME) + mk;
}
- if (!aom_read_bit(r, ACCT_STR_NAME)) {
- return aom_read_literal(r, b, ACCT_STR_NAME) + mk;
+ if (!aom_read_bit(r, ACCT_INFO_NAME)) {
+ return aom_read_literal(r, b, ACCT_INFO_NAME) + mk;
}
i = i + 1;
@@ -51,7 +51,7 @@
}
uint16_t aom_read_primitive_refsubexpfin_(aom_reader *r, uint16_t n, uint16_t k,
- uint16_t ref ACCT_STR_PARAM) {
+ uint16_t ref ACCT_INFO_PARAM) {
return inv_recenter_finite_nonneg(
- n, ref, aom_read_primitive_subexpfin(r, n, k, ACCT_STR_NAME));
+ n, ref, aom_read_primitive_subexpfin(r, n, k, ACCT_INFO_NAME));
}
diff --git a/aom_dsp/binary_codes_reader.h b/aom_dsp/binary_codes_reader.h
index 4559ff2..4e35483 100644
--- a/aom_dsp/binary_codes_reader.h
+++ b/aom_dsp/binary_codes_reader.h
@@ -25,18 +25,19 @@
#include "aom_dsp/bitreader.h"
#include "aom_dsp/bitreader_buffer.h"
-#define aom_read_primitive_quniform(r, n, ACCT_STR_NAME) \
- aom_read_primitive_quniform_(r, n ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_primitive_subexpfin(r, n, k, ACCT_STR_NAME) \
- aom_read_primitive_subexpfin_(r, n, k ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_primitive_refsubexpfin(r, n, k, ref, ACCT_STR_NAME) \
- aom_read_primitive_refsubexpfin_(r, n, k, ref ACCT_STR_ARG(ACCT_STR_NAME))
+#define aom_read_primitive_quniform(r, n, ACCT_INFO_NAME) \
+ aom_read_primitive_quniform_(r, n ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_primitive_subexpfin(r, n, k, ACCT_INFO_NAME) \
+ aom_read_primitive_subexpfin_(r, n, k ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_primitive_refsubexpfin(r, n, k, ref, ACCT_INFO_NAME) \
+ aom_read_primitive_refsubexpfin_(r, n, k, ref ACCT_INFO_ARG(ACCT_INFO_NAME))
-uint16_t aom_read_primitive_quniform_(aom_reader *r, uint16_t n ACCT_STR_PARAM);
+uint16_t aom_read_primitive_quniform_(aom_reader *r,
+ uint16_t n ACCT_INFO_PARAM);
uint16_t aom_read_primitive_subexpfin_(aom_reader *r, uint16_t n,
- uint16_t k ACCT_STR_PARAM);
+ uint16_t k ACCT_INFO_PARAM);
uint16_t aom_read_primitive_refsubexpfin_(aom_reader *r, uint16_t n, uint16_t k,
- uint16_t ref ACCT_STR_PARAM);
+ uint16_t ref ACCT_INFO_PARAM);
#ifdef __cplusplus
} // extern "C"
diff --git a/aom_dsp/bitreader.c b/aom_dsp/bitreader.c
index 96fc999..b1c346e 100644
--- a/aom_dsp/bitreader.c
+++ b/aom_dsp/bitreader.c
@@ -31,7 +31,7 @@
uint32_t aom_reader_tell(const aom_reader *r) { return od_ec_dec_tell(&r->ec); }
-uint32_t aom_reader_tell_frac(const aom_reader *r) {
+uint64_t aom_reader_tell_frac(const aom_reader *r) {
return od_ec_dec_tell_frac(&r->ec);
}
diff --git a/aom_dsp/bitreader.h b/aom_dsp/bitreader.h
index ee999ba..1a03823 100644
--- a/aom_dsp/bitreader.h
+++ b/aom_dsp/bitreader.h
@@ -33,41 +33,42 @@
#if CONFIG_ACCOUNTING
#include "av1/decoder/accounting.h"
-#define ACCT_STR_NAME acct_str
-#define ACCT_STR_PARAM , const char *ACCT_STR_NAME
-#define ACCT_STR_ARG(s) , s
+#define ACCT_INFO_NAME acct_info
+#define ACCT_INFO_PARAM , AccountingSymbolInfo acct_info
+#define ACCT_INFO_ARG(s) , s
#else
-#define ACCT_STR_PARAM
-#define ACCT_STR_ARG(s)
+#define ACCT_INFO_PARAM
+#define ACCT_INFO_ARG(s)
#endif
-#define aom_read(r, prob, ACCT_STR_NAME) \
- aom_read_(r, prob ACCT_STR_ARG(ACCT_STR_NAME))
+#define aom_read(r, prob, ACCT_INFO_NAME) \
+ aom_read_(r, prob ACCT_INFO_ARG(ACCT_INFO_NAME))
#if CONFIG_BYPASS_IMPROVEMENT
-#define aom_read_bypass(r, ACCT_STR_NAME) \
- aom_read_bypass_(r ACCT_STR_ARG(ACCT_STR_NAME))
+#define aom_read_bypass(r, ACCT_INFO_NAME) \
+ aom_read_bypass_(r ACCT_INFO_ARG(ACCT_INFO_NAME))
#endif // CONFIG_BYPASS_IMPROVEMENT
-#define aom_read_bit(r, ACCT_STR_NAME) \
- aom_read_bit_(r ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_tree(r, tree, probs, ACCT_STR_NAME) \
- aom_read_tree_(r, tree, probs ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_literal(r, bits, ACCT_STR_NAME) \
- aom_read_literal_(r, bits ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_cdf(r, cdf, nsymbs, ACCT_STR_NAME) \
- aom_read_cdf_(r, cdf, nsymbs ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_symbol(r, cdf, nsymbs, ACCT_STR_NAME) \
- aom_read_symbol_(r, cdf, nsymbs ACCT_STR_ARG(ACCT_STR_NAME))
+#define aom_read_bit(r, ACCT_INFO_NAME) \
+ aom_read_bit_(r ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_tree(r, tree, probs, ACCT_INFO_NAME) \
+ aom_read_tree_(r, tree, probs ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_literal(r, bits, ACCT_INFO_NAME) \
+ aom_read_literal_(r, bits ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_cdf(r, cdf, nsymbs, ACCT_INFO_NAME) \
+ aom_read_cdf_(r, cdf, nsymbs ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_symbol(r, cdf, nsymbs, ACCT_INFO_NAME) \
+ aom_read_symbol_(r, cdf, nsymbs ACCT_INFO_ARG(ACCT_INFO_NAME))
#if CONFIG_BYPASS_IMPROVEMENT
-#define aom_read_unary(r, bits, ACCT_STR_NAME) \
- aom_read_unary_(r, bits ACCT_STR_ARG(ACCT_STR_NAME))
+#define aom_read_unary(r, bits, ACCT_INFO_NAME) \
+ aom_read_unary_(r, bits ACCT_INFO_ARG(ACCT_INFO_NAME))
#endif // CONFIG_BYPASS_IMPROVEMENT
#if ENABLE_LR_4PART_CODE
-#define aom_read_4part(r, cdf, nsymb_bits, ACCT_STR_NAME) \
- aom_read_4part_(r, cdf, nsymb_bits ACCT_STR_ARG(ACCT_STR_NAME))
-#define aom_read_4part_wref(r, ref_symb, cdf, nsymb_bits, ACCT_STR_NAME) \
- aom_read_4part_wref_(r, ref_symb, cdf, nsymb_bits ACCT_STR_ARG(ACCT_STR_NAME))
+#define aom_read_4part(r, cdf, nsymb_bits, ACCT_INFO_NAME) \
+ aom_read_4part_(r, cdf, nsymb_bits ACCT_INFO_ARG(ACCT_INFO_NAME))
+#define aom_read_4part_wref(r, ref_symb, cdf, nsymb_bits, ACCT_INFO_NAME) \
+ aom_read_4part_wref_(r, ref_symb, cdf, \
+ nsymb_bits ACCT_INFO_ARG(ACCT_INFO_NAME))
#endif // ENABLE_LR_4PART_CODE
#ifdef __cplusplus
@@ -99,15 +100,17 @@
// Returns the position in the bit reader in bits.
uint32_t aom_reader_tell(const aom_reader *r);
-// Returns the position in the bit reader in 1/8th bits.
-uint32_t aom_reader_tell_frac(const aom_reader *r);
+// Returns the position in the bit reader in 1/65536th bits.
+uint64_t aom_reader_tell_frac(const aom_reader *r);
#if CONFIG_ACCOUNTING
-static INLINE void aom_process_accounting(const aom_reader *r ACCT_STR_PARAM) {
+static INLINE void aom_process_accounting(const aom_reader *r, int value,
+ SYMBOL_CODING_MODE coding_mode
+ ACCT_INFO_PARAM) {
if (r->accounting != NULL) {
- uint32_t tell_frac;
+ uint64_t tell_frac;
tell_frac = aom_reader_tell_frac(r);
- aom_accounting_record(r->accounting, ACCT_STR_NAME,
+ aom_accounting_record(r->accounting, value, coding_mode, ACCT_INFO_NAME,
tell_frac - r->accounting->last_tell_frac);
r->accounting->last_tell_frac = tell_frac;
}
@@ -134,7 +137,7 @@
}
#endif
-static INLINE int aom_read_(aom_reader *r, int prob ACCT_STR_PARAM) {
+static INLINE int aom_read_(aom_reader *r, int prob ACCT_INFO_PARAM) {
int p = (0x7FFFFF - (prob << 15) + prob) >> 8;
int bit = od_ec_decode_bool_q15(&r->ec, p);
@@ -173,7 +176,8 @@
#endif // CONFIG_BITSTREAM_DEBUG
#if CONFIG_ACCOUNTING
- if (ACCT_STR_NAME) aom_process_accounting(r, ACCT_STR_NAME);
+ if (ACCT_INFO_NAME.c_file)
+ aom_process_accounting(r, bit, SYMBOL_BIT, ACCT_INFO_NAME);
#if CONFIG_THROUGHPUT_ANALYSIS
aom_update_symb_counts(r, 1, 0, 1);
#else
@@ -223,13 +227,14 @@
#endif // CONFIG_BITSTREAM_DEBUG
#if CONFIG_BYPASS_IMPROVEMENT
-static INLINE int aom_read_bypass_(aom_reader *r ACCT_STR_PARAM) {
+static INLINE int aom_read_bypass_(aom_reader *r ACCT_INFO_PARAM) {
int ret = od_ec_decode_literal_bypass(&r->ec, 1);
#if CONFIG_BITSTREAM_DEBUG
bitstream_queue_pop_literal(ret, 1);
#endif // CONFIG_BITSTREAM_DEBUG
#if CONFIG_ACCOUNTING
- if (ACCT_STR_NAME) aom_process_accounting(r, ACCT_STR_NAME);
+ if (ACCT_INFO_NAME.c_file)
+ aom_process_accounting(r, ret, SYMBOL_BIT_BYPASS, ACCT_INFO_NAME);
#if CONFIG_THROUGHPUT_ANALYSIS
aom_update_symb_counts(r, 1, 0, 1);
#else
@@ -240,20 +245,21 @@
}
#endif // CONFIG_BYPASS_IMPROVEMENT
-static INLINE int aom_read_bit_(aom_reader *r ACCT_STR_PARAM) {
+static INLINE int aom_read_bit_(aom_reader *r ACCT_INFO_PARAM) {
int ret;
#if CONFIG_BYPASS_IMPROVEMENT
- ret = aom_read_bypass(r, NULL);
+ ret = aom_read_bypass(r, ACCT_INFO_NAME);
#else
- ret = aom_read(r, 128, NULL); // aom_prob_half
+ ret = aom_read(r, 128, ACCT_INFO_NAME); // aom_prob_half
#endif // CONFIG_BYPASS_IMPROVEMENT
#if CONFIG_ACCOUNTING
- if (ACCT_STR_NAME) aom_process_accounting(r, ACCT_STR_NAME);
+ if (ACCT_INFO_NAME.c_file)
+ aom_process_accounting(r, ret, SYMBOL_BIT_BYPASS, ACCT_INFO_NAME);
#endif
return ret;
}
-static INLINE int aom_read_literal_(aom_reader *r, int bits ACCT_STR_PARAM) {
+static INLINE int aom_read_literal_(aom_reader *r, int bits ACCT_INFO_PARAM) {
#if CONFIG_BYPASS_IMPROVEMENT
int literal = 0;
int n_bits = bits;
@@ -268,7 +274,8 @@
bitstream_queue_pop_literal(literal, bits);
#endif // CONFIG_BITSTREAM_DEBUG
#if CONFIG_ACCOUNTING
- if (ACCT_STR_NAME) aom_process_accounting(r, ACCT_STR_NAME);
+ if (ACCT_INFO_NAME.c_file)
+ aom_process_accounting(r, literal, SYMBOL_LITERAL_BYPASS, ACCT_INFO_NAME);
#if CONFIG_THROUGHPUT_ANALYSIS
aom_update_symb_counts(r, 1, 0, bits);
#else
@@ -285,7 +292,8 @@
#if CONFIG_BYPASS_IMPROVEMENT
// Deocode unary coded symbol with truncation at max_nbits.
-static INLINE int aom_read_unary_(aom_reader *r, int max_nbits ACCT_STR_PARAM) {
+static INLINE int aom_read_unary_(aom_reader *r,
+ int max_nbits ACCT_INFO_PARAM) {
int ret = od_ec_decode_unary_bypass(&r->ec, max_nbits);
#if CONFIG_BITSTREAM_DEBUG
int nbits = ret < max_nbits ? ret + 1 : max_nbits;
@@ -294,7 +302,8 @@
#endif // CONFIG_BITSTREAM_DEBUG
#if CONFIG_ACCOUNTING
int n_bits = ret < max_nbits ? ret + 1 : max_nbits;
- if (ACCT_STR_NAME) aom_process_accounting(r, ACCT_STR_NAME);
+ if (ACCT_INFO_NAME.c_file)
+ aom_process_accounting(r, ret, SYMBOL_UNARY, ACCT_INFO_NAME);
#if CONFIG_THROUGHPUT_ANALYSIS
aom_update_symb_counts(r, 1, 0, n_bits);
#else
@@ -306,7 +315,7 @@
#endif // CONFIG_BYPASS_IMPROVEMENT
static INLINE int aom_read_cdf_(aom_reader *r, const aom_cdf_prob *cdf,
- int nsymbs ACCT_STR_PARAM) {
+ int nsymbs ACCT_INFO_PARAM) {
int symb;
assert(cdf != NULL);
symb = od_ec_decode_cdf_q15(&r->ec, cdf, nsymbs);
@@ -351,7 +360,8 @@
#endif // CONFIG_BITSTREAM_DEBUG
#if CONFIG_ACCOUNTING
- if (ACCT_STR_NAME) aom_process_accounting(r, ACCT_STR_NAME);
+ if (ACCT_INFO_NAME.c_file)
+ aom_process_accounting(r, symb, SYMBOL_CDF, ACCT_INFO_NAME);
#if CONFIG_THROUGHPUT_ANALYSIS
aom_update_symb_counts(r, (nsymbs == 2), 1, 1);
#else
@@ -362,9 +372,9 @@
}
static INLINE int aom_read_symbol_(aom_reader *r, aom_cdf_prob *cdf,
- int nsymbs ACCT_STR_PARAM) {
+ int nsymbs ACCT_INFO_PARAM) {
int ret;
- ret = aom_read_cdf(r, cdf, nsymbs, ACCT_STR_NAME);
+ ret = aom_read_cdf(r, cdf, nsymbs, ACCT_INFO_NAME);
if (r->allow_update_cdf) update_cdf(cdf, ret, nsymbs);
return ret;
}
@@ -378,22 +388,22 @@
// (nsymb_bits - 3), (nsymb_bits - 3), (nsymb_bits - 2) or (nsymb_bits - 1)
// bits, depending on the part.
static INLINE int aom_read_4part_(aom_reader *r, aom_cdf_prob *cdf,
- int nsymb_bits ACCT_STR_PARAM) {
+ int nsymb_bits ACCT_INFO_PARAM) {
assert(nsymb_bits >= 3);
int part_bits[4] = { (nsymb_bits - 3), (nsymb_bits - 3), (nsymb_bits - 2),
(nsymb_bits - 1) };
int part_offs[4] = { 0, 1 << (nsymb_bits - 3), 1 << (nsymb_bits - 2),
1 << (nsymb_bits - 1) };
- const int part = aom_read_symbol(r, cdf, 4, ACCT_STR_NAME);
- return aom_read_literal(r, part_bits[part], ACCT_STR_NAME) + part_offs[part];
+ const int part = aom_read_symbol(r, cdf, 4, ACCT_INFO_NAME);
+ return aom_read_literal(r, part_bits[part], ACCT_INFO_NAME) + part_offs[part];
}
// Implements a nsymb_bits bit 4-part code that codes a symbol symb given a
// reference ref_symb after recentering symb around ref_symb.
static INLINE int aom_read_4part_wref_(aom_reader *r, int ref_symb,
aom_cdf_prob *cdf,
- int nsymb_bits ACCT_STR_PARAM) {
- const int symb = aom_read_4part(r, cdf, nsymb_bits, ACCT_STR_NAME);
+ int nsymb_bits ACCT_INFO_PARAM) {
+ const int symb = aom_read_4part(r, cdf, nsymb_bits, ACCT_INFO_NAME);
return inv_recenter_finite_nonneg(1 << nsymb_bits, ref_symb, symb);
}
#endif // ENABLE_LR_4PART_CODE
diff --git a/aom_dsp/bitwriter_buffer.c b/aom_dsp/bitwriter_buffer.c
index 7e41949..5f76f15 100644
--- a/aom_dsp/bitwriter_buffer.c
+++ b/aom_dsp/bitwriter_buffer.c
@@ -92,6 +92,13 @@
void aom_wb_write_primitive_quniform(struct aom_write_bit_buffer *wb,
uint16_t n, uint16_t v) {
if (n <= 1) return;
+ assert(v < n);
+ // Split the valid range into two.
+ // The encoded value is in the range [0, n), but in order to map a range
+ // which may not be a power of 2 onto a binary code, we split into the
+ // sub-ranges [0, m) and [m, n), where m is an intermediate point.
+ // Values in the range [0, m) then use one fewer bit than values in
+ // the range [m, n).
const int l = get_msb(n) + 1;
const int m = (1 << l) - n;
if (v < m) {
diff --git a/aom_dsp/entcode.c b/aom_dsp/entcode.c
index c794edb..a49ae0d 100644
--- a/aom_dsp/entcode.c
+++ b/aom_dsp/entcode.c
@@ -21,9 +21,9 @@
Return: The number of bits scaled by 2**OD_BITRES.
This will always be slightly larger than the exact value (e.g., all
rounding error is in the positive direction).*/
-uint32_t od_ec_tell_frac(uint32_t nbits_total, uint32_t rng) {
- uint32_t nbits;
- int l;
+uint64_t od_ec_tell_frac(uint32_t nbits_total, uint32_t rng) {
+ uint64_t nbits;
+ int64_t l;
int i;
/*To handle the non-integral number of bits still left in the encoder/decoder
state, we compute the worst-case number of bits of val that must be
@@ -37,7 +37,7 @@
probability of 1/(1 << n) might sometimes appear to use more than n bits.
This may help explain the surprising result that a newly initialized
encoder or decoder claims to have used 1 bit.*/
- nbits = nbits_total << OD_BITRES;
+ nbits = (uint64_t)nbits_total << OD_BITRES;
l = 0;
for (i = OD_BITRES; i-- > 0;) {
int b;
diff --git a/aom_dsp/entcode.h b/aom_dsp/entcode.h
index 0227c52..2e95945 100644
--- a/aom_dsp/entcode.h
+++ b/aom_dsp/entcode.h
@@ -33,14 +33,14 @@
#define OD_EC_WINDOW_SIZE ((int)sizeof(od_ec_window) * CHAR_BIT)
/*The resolution of fractional-precision bit usage measurements, i.e.,
- 3 => 1/8th bits.*/
-#define OD_BITRES (3)
+ 16 => 1/65536th bits.*/
+#define OD_BITRES (16)
#define OD_ICDF AOM_ICDF
/*See entcode.c for further documentation.*/
-OD_WARN_UNUSED_RESULT uint32_t od_ec_tell_frac(uint32_t nbits_total,
+OD_WARN_UNUSED_RESULT uint64_t od_ec_tell_frac(uint32_t nbits_total,
uint32_t rng);
#endif // AOM_AOM_DSP_ENTCODE_H_
diff --git a/aom_dsp/entdec.c b/aom_dsp/entdec.c
index 02188ec..8cfb826 100644
--- a/aom_dsp/entdec.c
+++ b/aom_dsp/entdec.c
@@ -352,6 +352,6 @@
Return: The number of bits scaled by 2**OD_BITRES.
This will always be slightly larger than the exact value (e.g., all
rounding error is in the positive direction).*/
-uint32_t od_ec_dec_tell_frac(const od_ec_dec *dec) {
+uint64_t od_ec_dec_tell_frac(const od_ec_dec *dec) {
return od_ec_tell_frac(od_ec_dec_tell(dec), dec->rng);
}
diff --git a/aom_dsp/entdec.h b/aom_dsp/entdec.h
index 7ca2f29..442ae2e 100644
--- a/aom_dsp/entdec.h
+++ b/aom_dsp/entdec.h
@@ -82,7 +82,7 @@
OD_WARN_UNUSED_RESULT int od_ec_dec_tell(const od_ec_dec *dec)
OD_ARG_NONNULL(1);
-OD_WARN_UNUSED_RESULT uint32_t od_ec_dec_tell_frac(const od_ec_dec *dec)
+OD_WARN_UNUSED_RESULT uint64_t od_ec_dec_tell_frac(const od_ec_dec *dec)
OD_ARG_NONNULL(1);
#ifdef __cplusplus
diff --git a/aom_dsp/entenc.c b/aom_dsp/entenc.c
index 8517cee..5f19c0e 100644
--- a/aom_dsp/entenc.c
+++ b/aom_dsp/entenc.c
@@ -467,7 +467,7 @@
Return: The number of bits scaled by 2**OD_BITRES.
This will always be slightly larger than the exact value (e.g., all
rounding error is in the positive direction).*/
-uint32_t od_ec_enc_tell_frac(const od_ec_enc *enc) {
+uint64_t od_ec_enc_tell_frac(const od_ec_enc *enc) {
return od_ec_tell_frac(od_ec_enc_tell(enc), enc->rng);
}
diff --git a/aom_dsp/entenc.h b/aom_dsp/entenc.h
index fbb35a0..9831601 100644
--- a/aom_dsp/entenc.h
+++ b/aom_dsp/entenc.h
@@ -78,7 +78,7 @@
OD_WARN_UNUSED_RESULT int od_ec_enc_tell(const od_ec_enc *enc)
OD_ARG_NONNULL(1);
-OD_WARN_UNUSED_RESULT uint32_t od_ec_enc_tell_frac(const od_ec_enc *enc)
+OD_WARN_UNUSED_RESULT uint64_t od_ec_enc_tell_frac(const od_ec_enc *enc)
OD_ARG_NONNULL(1);
void od_ec_enc_checkpoint(od_ec_enc *dst, const od_ec_enc *src);
diff --git a/aom_dsp/intrapred.c b/aom_dsp/intrapred.c
index 5d39cd0..225d5a4 100644
--- a/aom_dsp/intrapred.c
+++ b/aom_dsp/intrapred.c
@@ -296,11 +296,51 @@
}
}
+#if CONFIG_BLEND_MODE
+#define BLEND_WEIGHT_MAX 32
+static const uint8_t blk_size_log2[65] = {
+ 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6
+};
+#endif // CONFIG_BLEND_MODE
+
static INLINE void highbd_smooth_predictor(uint16_t *dst, ptrdiff_t stride,
int bw, int bh,
const uint16_t *above,
const uint16_t *left, int bd) {
(void)bd;
+#if CONFIG_BLEND_MODE
+ const uint16_t bl = left[bh]; // estimated by bottom-left pixel
+ const uint16_t tr = above[bw]; // estimated by top-right pixel
+
+ uint16_t *pred = dst;
+ const int scale =
+ ROUND_POWER_OF_TWO((blk_size_log2[bh] - 2 + blk_size_log2[bw] - 2), 2);
+ assert(scale >= 0 && scale <= BLEND_WEIGHT_MAX - 1);
+ for (int r = 0; r < bh; r++) {
+ const int s_top =
+ BLEND_WEIGHT_MAX >>
+ AOMMIN(blk_size_log2[BLEND_WEIGHT_MAX << 1], ((r << 1) >> scale));
+ const uint32_t l = left[r];
+ for (int c = 0; c < bw; c++) {
+ const int s_left =
+ BLEND_WEIGHT_MAX >>
+ AOMMIN(blk_size_log2[BLEND_WEIGHT_MAX << 1], ((c << 1) >> scale));
+ const uint32_t top = above[c];
+ uint32_t predv = (above[c] * (bh - 1 - r) + bl * (r + 1)) * bw;
+ uint32_t predh = (left[r] * (bw - 1 - c) + tr * (c + 1)) * bh;
+ predv = (s_top * top * bw * bh + (BLEND_WEIGHT_MAX * 2 - s_top) * predv);
+ assert(predv < UINT_MAX);
+ predh = (s_left * l * bw * bh + (BLEND_WEIGHT_MAX * 2 - s_left) * predh);
+ assert(predh < UINT_MAX);
+
+ const int bits = 1 + 6 + blk_size_log2[bh] + blk_size_log2[bw];
+ pred[c] = divide_round((predv + predh), bits);
+ }
+ pred += stride;
+ }
+#else
const uint16_t below_pred = left[bh - 1]; // estimated by bottom-left pixel
const uint16_t right_pred = above[bw - 1]; // estimated by top-right pixel
const uint8_t *const sm_weights_w = sm_weight_arrays + bw;
@@ -327,6 +367,7 @@
}
dst += stride;
}
+#endif // CONFIG_BLEND_MODE
}
static INLINE void highbd_smooth_v_predictor(uint16_t *dst, ptrdiff_t stride,
@@ -334,6 +375,29 @@
const uint16_t *above,
const uint16_t *left, int bd) {
(void)bd;
+#if CONFIG_BLEND_MODE
+ const uint16_t bl = left[bh]; // estimated by bottom-left pixel
+
+ uint16_t *pred = dst;
+ const int scale =
+ ROUND_POWER_OF_TWO((blk_size_log2[bh] - 2 + blk_size_log2[bw] - 2), 2);
+ assert(scale >= 0 && scale <= BLEND_WEIGHT_MAX - 1);
+ for (int r = 0; r < bh; ++r) {
+ const int s_top =
+ BLEND_WEIGHT_MAX >>
+ AOMMIN(blk_size_log2[BLEND_WEIGHT_MAX << 1], ((r << 1) >> scale));
+ for (int c = 0; c < bw; ++c) {
+ const uint32_t top = above[c];
+ uint32_t predv = (above[c] * (bh - 1 - r) + bl * (r + 1)) * bw;
+ assert(predv < UINT_MAX);
+ const int bits = 6 + blk_size_log2[bh] + blk_size_log2[bw];
+ pred[c] = divide_round(
+ (s_top * top * bw * bh + (BLEND_WEIGHT_MAX * 2 - s_top) * predv),
+ bits);
+ }
+ pred += stride;
+ }
+#else
const uint16_t below_pred = left[bh - 1]; // estimated by bottom-left pixel
const uint8_t *const sm_weights = sm_weight_arrays + bh;
// scale = 2^sm_weight_log2_scale
@@ -358,6 +422,7 @@
}
dst += stride;
}
+#endif // CONFIG_BLEND_MODE
}
static INLINE void highbd_smooth_h_predictor(uint16_t *dst, ptrdiff_t stride,
@@ -365,6 +430,29 @@
const uint16_t *above,
const uint16_t *left, int bd) {
(void)bd;
+#if CONFIG_BLEND_MODE
+ const uint16_t tr = above[bw]; // estimated by top-right pixel
+
+ uint16_t *pred = dst;
+ const int scale =
+ ROUND_POWER_OF_TWO((blk_size_log2[bh] - 2 + blk_size_log2[bw] - 2), 2);
+ assert(scale >= 0 && scale <= BLEND_WEIGHT_MAX - 1);
+ for (int r = 0; r < bh; r++) {
+ const uint32_t l = left[r];
+ for (int c = 0; c < bw; c++) {
+ const int s_left =
+ BLEND_WEIGHT_MAX >>
+ AOMMIN(blk_size_log2[BLEND_WEIGHT_MAX << 1], ((c << 1) >> scale));
+ uint32_t predh = (left[r] * (bw - 1 - c) + tr * (c + 1)) * bh;
+ assert(predh < UINT_MAX);
+ const int bits = 6 + blk_size_log2[bh] + blk_size_log2[bw];
+ pred[c] = divide_round(
+ (s_left * l * (bw * bh) + (BLEND_WEIGHT_MAX * 2 - s_left) * predh),
+ bits);
+ }
+ pred += stride;
+ }
+#else
const uint16_t right_pred = above[bw - 1]; // estimated by top-right pixel
const uint8_t *const sm_weights = sm_weight_arrays + bw;
// scale = 2^sm_weight_log2_scale
@@ -389,6 +477,7 @@
}
dst += stride;
}
+#endif // CONFIG_BLEND_MODE
}
static INLINE void highbd_dc_128_predictor(uint16_t *dst, ptrdiff_t stride,
diff --git a/aom_dsp/psnr.c b/aom_dsp/psnr.c
index d6241e5..3220358 100644
--- a/aom_dsp/psnr.c
+++ b/aom_dsp/psnr.c
@@ -18,13 +18,15 @@
#include "aom_dsp/psnr.h"
#include "aom_scale/yv12config.h"
+#define MIN_SSE 0.5
+
double aom_sse_to_psnr(double samples, double peak, double sse) {
- if (sse > 0.0) {
- const double psnr = 10.0 * log10(samples * peak * peak / sse);
- return psnr > MAX_PSNR ? MAX_PSNR : psnr;
- } else {
- return MAX_PSNR;
- }
+ const bool zero_sse = (sse < MIN_SSE);
+ if (zero_sse) sse = MIN_SSE;
+ assert(sse > 0.0);
+ double psnr = 10.0 * log10(samples * peak * peak / sse);
+ if (zero_sse) psnr = ceil(psnr);
+ return psnr;
}
static void encoder_highbd_variance64(const uint16_t *a, int a_stride,
diff --git a/aom_dsp/x86/highbd_intrapred_asm_sse2.asm b/aom_dsp/x86/highbd_intrapred_asm_sse2.asm
index 8ea91d2..022c60e 100644
--- a/aom_dsp/x86/highbd_intrapred_asm_sse2.asm
+++ b/aom_dsp/x86/highbd_intrapred_asm_sse2.asm
@@ -106,14 +106,14 @@
pshuflw m0, m0, 0x0
punpcklqdq m0, m0
.loop:
- mova [dstq ], m0
- mova [dstq +16], m0
- mova [dstq+strideq*2 ], m0
- mova [dstq+strideq*2 +16], m0
- mova [dstq+strideq*4 ], m0
- mova [dstq+strideq*4 +16], m0
- mova [dstq+stride3q*2 ], m0
- mova [dstq+stride3q*2+16], m0
+ movu [dstq ], m0
+ movu [dstq +16], m0
+ movu [dstq+strideq*2 ], m0
+ movu [dstq+strideq*2 +16], m0
+ movu [dstq+strideq*4 ], m0
+ movu [dstq+strideq*4 +16], m0
+ movu [dstq+stride3q*2 ], m0
+ movu [dstq+stride3q*2+16], m0
lea dstq, [dstq+strideq*8]
dec lines4d
jnz .loop
@@ -214,14 +214,14 @@
lea stride3q, [strideq*3]
mov nlines4d, 4
.loop:
- mova [dstq ], m0
- mova [dstq +16], m1
- mova [dstq+strideq*2 ], m0
- mova [dstq+strideq*2 +16], m1
- mova [dstq+strideq*4 ], m0
- mova [dstq+strideq*4 +16], m1
- mova [dstq+stride3q*2 ], m0
- mova [dstq+stride3q*2+16], m1
+ movu [dstq ], m0
+ movu [dstq +16], m1
+ movu [dstq+strideq*2 ], m0
+ movu [dstq+strideq*2 +16], m1
+ movu [dstq+strideq*4 ], m0
+ movu [dstq+strideq*4 +16], m1
+ movu [dstq+stride3q*2 ], m0
+ movu [dstq+stride3q*2+16], m1
lea dstq, [dstq+strideq*8]
dec nlines4d
jnz .loop
diff --git a/aom_dsp/x86/highbd_intrapred_sse2.c b/aom_dsp/x86/highbd_intrapred_sse2.c
index 4cc07a9..da7d2f3 100644
--- a/aom_dsp/x86/highbd_intrapred_sse2.c
+++ b/aom_dsp/x86/highbd_intrapred_sse2.c
@@ -107,16 +107,16 @@
static INLINE void h_store_16_unpacklo(uint16_t **dst, const ptrdiff_t stride,
const __m128i *row) {
const __m128i val = _mm_unpacklo_epi64(*row, *row);
- _mm_store_si128((__m128i *)*dst, val);
- _mm_store_si128((__m128i *)(*dst + 8), val);
+ _mm_storeu_si128((__m128i *)*dst, val);
+ _mm_storeu_si128((__m128i *)(*dst + 8), val);
*dst += stride;
}
static INLINE void h_store_16_unpackhi(uint16_t **dst, const ptrdiff_t stride,
const __m128i *row) {
const __m128i val = _mm_unpackhi_epi64(*row, *row);
- _mm_store_si128((__m128i *)(*dst), val);
- _mm_store_si128((__m128i *)(*dst + 8), val);
+ _mm_storeu_si128((__m128i *)(*dst), val);
+ _mm_storeu_si128((__m128i *)(*dst + 8), val);
*dst += stride;
}
@@ -483,8 +483,8 @@
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_store_si128((__m128i *)(dst + 8), dc_dup);
+ _mm_storeu_si128((__m128i *)dst, dc_dup);
+ _mm_storeu_si128((__m128i *)(dst + 8), dc_dup);
}
}
@@ -739,17 +739,17 @@
const __m128i above1_u16 = _mm_load_si128((const __m128i *)(above + 8));
int i;
for (i = 0; i < 2; ++i) {
- _mm_store_si128((__m128i *)dst, above0_u16);
- _mm_store_si128((__m128i *)(dst + 8), above1_u16);
+ _mm_storeu_si128((__m128i *)dst, above0_u16);
+ _mm_storeu_si128((__m128i *)(dst + 8), above1_u16);
dst += stride;
- _mm_store_si128((__m128i *)dst, above0_u16);
- _mm_store_si128((__m128i *)(dst + 8), above1_u16);
+ _mm_storeu_si128((__m128i *)dst, above0_u16);
+ _mm_storeu_si128((__m128i *)(dst + 8), above1_u16);
dst += stride;
- _mm_store_si128((__m128i *)dst, above0_u16);
- _mm_store_si128((__m128i *)(dst + 8), above1_u16);
+ _mm_storeu_si128((__m128i *)dst, above0_u16);
+ _mm_storeu_si128((__m128i *)(dst + 8), above1_u16);
dst += stride;
- _mm_store_si128((__m128i *)dst, above0_u16);
- _mm_store_si128((__m128i *)(dst + 8), above1_u16);
+ _mm_storeu_si128((__m128i *)dst, above0_u16);
+ _mm_storeu_si128((__m128i *)(dst + 8), above1_u16);
dst += stride;
}
}
@@ -901,17 +901,17 @@
const __m128i row = _mm_set1_epi16((uint16_t)sum32);
int i;
for (i = 0; i < 2; ++i) {
- _mm_store_si128((__m128i *)dst, row);
- _mm_store_si128((__m128i *)(dst + 8), row);
+ _mm_storeu_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)(dst + 8), row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
- _mm_store_si128((__m128i *)(dst + 8), row);
+ _mm_storeu_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)(dst + 8), row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
- _mm_store_si128((__m128i *)(dst + 8), row);
+ _mm_storeu_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)(dst + 8), row);
dst += stride;
- _mm_store_si128((__m128i *)dst, row);
- _mm_store_si128((__m128i *)(dst + 8), row);
+ _mm_storeu_si128((__m128i *)dst, row);
+ _mm_storeu_si128((__m128i *)(dst + 8), row);
dst += stride;
}
}
diff --git a/aom_dsp/x86/highbd_variance_sse2.c b/aom_dsp/x86/highbd_variance_sse2.c
index 1e29924..d288ef7 100644
--- a/aom_dsp/x86/highbd_variance_sse2.c
+++ b/aom_dsp/x86/highbd_variance_sse2.c
@@ -251,6 +251,7 @@
const uint16_t *src, ptrdiff_t src_stride, int x_offset, int y_offset, \
const uint16_t *dst, ptrdiff_t dst_stride, int height, \
unsigned int *sse, void *unused0, void *unused);
+
#define DECLS(opt) \
DECL(8, opt); \
DECL(16, opt)
@@ -394,6 +395,26 @@
return (var >= 0) ? (uint32_t)var : 0; \
}
+#if CONFIG_UNEVEN_4WAY
+// TODO(any): Add back 16X16, 16X8, 16X4 after fixing alignment issues.
+#define FNS(opt) \
+ FN(128, 128, 16, 7, 7, opt, (int64_t)); \
+ FN(128, 64, 16, 7, 6, opt, (int64_t)); \
+ FN(64, 128, 16, 6, 7, opt, (int64_t)); \
+ FN(64, 64, 16, 6, 6, opt, (int64_t)); \
+ FN(64, 32, 16, 6, 5, opt, (int64_t)); \
+ FN(32, 64, 16, 5, 6, opt, (int64_t)); \
+ FN(32, 32, 16, 5, 5, opt, (int64_t)); \
+ FN(32, 16, 16, 5, 4, opt, (int64_t)); \
+ FN(16, 32, 16, 4, 5, opt, (int64_t)); \
+ FN(8, 16, 8, 3, 4, opt, (int64_t)); \
+ FN(8, 8, 8, 3, 3, opt, (int64_t)); \
+ FN(8, 4, 8, 3, 2, opt, (int64_t)); \
+ FN(8, 32, 8, 3, 5, opt, (int64_t)); \
+ FN(32, 8, 16, 5, 3, opt, (int64_t)); \
+ FN(16, 64, 16, 4, 6, opt, (int64_t)); \
+ FN(64, 16, 16, 6, 4, opt, (int64_t))
+#else
#define FNS(opt) \
FN(128, 128, 16, 7, 7, opt, (int64_t)); \
FN(128, 64, 16, 7, 6, opt, (int64_t)); \
@@ -414,6 +435,7 @@
FN(32, 8, 16, 5, 3, opt, (int64_t)); \
FN(16, 64, 16, 4, 6, opt, (int64_t)); \
FN(64, 16, 16, 6, 4, opt, (int64_t))
+#endif // CONFIG_UNEVEN_4WAY
FNS(sse2);
@@ -552,6 +574,23 @@
return (var >= 0) ? (uint32_t)var : 0; \
}
+#if CONFIG_UNEVEN_4WAY
+// TODO(any): Add back 16X16, 16X8, 16X4 after fixing alignment issues.
+#define FNS(opt) \
+ FN(64, 64, 16, 6, 6, opt, (int64_t)); \
+ FN(64, 32, 16, 6, 5, opt, (int64_t)); \
+ FN(32, 64, 16, 5, 6, opt, (int64_t)); \
+ FN(32, 32, 16, 5, 5, opt, (int64_t)); \
+ FN(32, 16, 16, 5, 4, opt, (int64_t)); \
+ FN(16, 32, 16, 4, 5, opt, (int64_t)); \
+ FN(8, 16, 8, 3, 4, opt, (int64_t)); \
+ FN(8, 8, 8, 3, 3, opt, (int64_t)); \
+ FN(8, 4, 8, 3, 2, opt, (int64_t)); \
+ FN(8, 32, 8, 3, 5, opt, (int64_t)); \
+ FN(32, 8, 16, 5, 3, opt, (int64_t)); \
+ FN(16, 64, 16, 4, 6, opt, (int64_t)); \
+ FN(64, 16, 16, 6, 4, opt, (int64_t));
+#else
#define FNS(opt) \
FN(64, 64, 16, 6, 6, opt, (int64_t)); \
FN(64, 32, 16, 6, 5, opt, (int64_t)); \
@@ -569,6 +608,7 @@
FN(32, 8, 16, 5, 3, opt, (int64_t)); \
FN(16, 64, 16, 4, 6, opt, (int64_t)); \
FN(64, 16, 16, 6, 4, opt, (int64_t));
+#endif // CONFIG_UNEVEN_4WAY
FNS(sse2);
diff --git a/aom_dsp/x86/intrapred_avx2.c b/aom_dsp/x86/intrapred_avx2.c
index bbc2d51..aeb08e3 100644
--- a/aom_dsp/x86/intrapred_avx2.c
+++ b/aom_dsp/x86/intrapred_avx2.c
@@ -15,6 +15,9 @@
#include "config/aom_dsp_rtcd.h"
#include "aom_dsp/x86/intrapred_x86.h"
#include "aom_dsp/x86/lpf_common_sse2.h"
+#if CONFIG_IDIF
+#include "av1/common/reconintra.h"
+#endif // CONFIG_IDIF
static DECLARE_ALIGNED(16, uint8_t, HighbdLoadMaskx[8][16]) = {
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
@@ -2692,3 +2695,2059 @@
}
return;
}
+
+#if CONFIG_IDIF
+
+static INLINE __m256i highbd_clamp_epi16_avx2(__m256i u, int bd) {
+ const __m256i zero = _mm256_setzero_si256();
+ const int max_i = ((1 << bd) - 1) << POWER_DR_INTERP_FILTER;
+ const __m256i max = _mm256_set1_epi16(max_i);
+ __m256i t, clamped;
+
+ t = _mm256_max_epi16(u, zero);
+ clamped = _mm256_min_epi16(t, max);
+
+ return clamped;
+}
+
+static INLINE __m256i highbd_clamp_epi32_avx2(__m256i u, int bd) {
+ const __m256i zero = _mm256_setzero_si256();
+ const int max_i = ((1 << bd) - 1) << POWER_DR_INTERP_FILTER;
+ const __m256i max = _mm256_set1_epi32(max_i);
+ __m256i t, clamped;
+
+ t = _mm256_max_epi32(u, zero);
+ clamped = _mm256_min_epi32(t, max);
+
+ return clamped;
+}
+
+static AOM_FORCE_INLINE void highbd_dr_prediction_z1_4xN_internal_idif_avx2(
+ int N, __m128i *dst, const uint16_t *above, int dx, int mrl_index, int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((N + 4) - 1 + (mrl_index << 1));
+
+ assert(dx > 0);
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m128i a_mbase_x, max_base_x128, base_inc128, mask128;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm_set1_epi16(above[max_base_x]);
+ max_base_x128 = _mm_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ __m128i res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dst[i] = a_mbase_x; // save 4 values
+ }
+ return;
+ }
+
+ // load refs
+ a0 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base - 1)));
+ a1 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base)));
+ a2 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base + 1)));
+ a3 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base + 2)));
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][3]);
+
+ // multiply and sum
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0, f0),
+ _mm256_mullo_epi16(a1, f1));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2, f2),
+ _mm256_mullo_epi16(a3, f3));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ val0 = _mm256_adds_epi16(val0, rnding);
+ val0 = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+
+ // discard values
+ res1 = _mm256_castsi256_si128(val0);
+ base_inc128 = _mm_setr_epi16(base, base + 1, base + 2, base + 3, base + 4,
+ base + 5, base + 6, base + 7);
+ mask128 = _mm_cmpgt_epi16(max_base_x128, base_inc128);
+ dst[r] = _mm_blendv_epi8(a_mbase_x, res1, mask128);
+ x += dx;
+ }
+}
+
+static AOM_FORCE_INLINE void
+highbd_dr_prediction_32bit_z1_4xN_internal_idif_avx2(int N, __m128i *dst,
+ const uint16_t *above,
+ int dx, int mrl_index,
+ int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((N + 4) - 1 + (mrl_index << 1));
+
+ assert(dx > 0);
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m128i a_mbase_x, max_base_x128, base_inc128, mask128;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi32(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm_set1_epi16(above[max_base_x]);
+ max_base_x128 = _mm_set1_epi32(max_base_x);
+
+ int x = dx * (1 + mrl_index);
+ int shift_i;
+ for (int r = 0; r < N; r++) {
+ __m128i res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dst[i] = a_mbase_x; // save 4 values
+ }
+ return;
+ }
+
+ // load refs
+ a0 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base - 1)));
+ a1 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base)));
+ a2 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 1)));
+ a3 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 2)));
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][3]);
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ // discard values
+ res1 = _mm256_castsi256_si128(val0);
+ res1 = _mm_packus_epi32(res1, res1);
+
+ base_inc128 = _mm_setr_epi32(base, base + 1, base + 2, base + 3);
+ mask128 = _mm_cmpgt_epi32(max_base_x128, base_inc128);
+ mask128 = _mm_packs_epi32(mask128, mask128); // goto 16 bit
+ dst[r] = _mm_blendv_epi8(a_mbase_x, res1, mask128);
+ x += dx;
+ }
+}
+
+static void highbd_dr_prediction_z1_4xN_idif_avx2(
+ uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above,
+ const uint16_t *left, int dx, int dy, int bd, int mrl_index) {
+ (void)dy;
+ (void)left;
+ (void)bw;
+ assert(bw == 4);
+ int N = bh;
+ __m128i dstvec[16];
+
+ if (bd < 10) {
+ highbd_dr_prediction_z1_4xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_4xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < N; i++) {
+ _mm_storel_epi64((__m128i *)(dst + stride * i), dstvec[i]);
+ }
+}
+
+static AOM_FORCE_INLINE void highbd_dr_prediction_z1_8xN_internal_idif_avx2(
+ int N, __m128i *dst, const uint16_t *above, int dx, int mrl_index, int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((N + 8) - 1 + (mrl_index << 1));
+
+ assert(dx > 0);
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ __m256i res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dst[i] = _mm256_castsi256_si128(a_mbase_x); // save 8 values
+ }
+ return;
+ }
+
+ // load refs
+ a0 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base - 1)));
+ a1 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base)));
+ a2 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base + 1)));
+ a3 = _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(above + base + 2)));
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][3]);
+
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0, f0),
+ _mm256_mullo_epi16(a1, f1));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2, f2),
+ _mm256_mullo_epi16(a3, f3));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ // round-shift
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ val0 = _mm256_adds_epi16(val0, rnding);
+ val0 = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+
+ base_inc256 =
+ _mm256_setr_epi16(base, base + 1, base + 2, base + 3, base + 4,
+ base + 5, base + 6, base + 7, 0, 0, 0, 0, 0, 0, 0, 0);
+
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ res1 = _mm256_blendv_epi8(a_mbase_x, val0, mask256);
+ dst[r] = _mm256_castsi256_si128(res1);
+ x += dx;
+ }
+}
+
+static AOM_FORCE_INLINE void
+highbd_dr_prediction_32bit_z1_8xN_internal_idif_avx2(int N, __m128i *dst,
+ const uint16_t *above,
+ int dx, int mrl_index,
+ int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((N + 8) - 1 + (mrl_index << 1));
+
+ assert(dx > 0);
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi32(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi32(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ __m256i res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dst[i] = _mm256_castsi256_si128(a_mbase_x); // save 8 values
+ }
+ return;
+ }
+
+ // load refs
+ a0 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base - 1)));
+ a1 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base)));
+ a2 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 1)));
+ a3 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 2)));
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][3]);
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res1 = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+
+ base_inc256 = _mm256_setr_epi32(base, base + 1, base + 2, base + 3,
+ base + 4, base + 5, base + 6, base + 7);
+
+ mask256 = _mm256_cmpgt_epi32(max_base_x256, base_inc256);
+ mask256 = _mm256_packs_epi32(
+ mask256, _mm256_castsi128_si256(
+ _mm256_extracti128_si256(mask256, 1))); // go to 16 bit
+ res1 = _mm256_blendv_epi8(a_mbase_x, res1, mask256);
+ dst[r] = _mm256_castsi256_si128(res1);
+ x += dx;
+ }
+}
+
+void highbd_dr_prediction_z1_8xN_idif_avx2(uint16_t *dst, ptrdiff_t stride,
+ int bw, int bh,
+ const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ (void)left;
+ (void)dy;
+ (void)bw;
+ assert(bw == 8);
+ int N = bh;
+ __m128i dstvec[32];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_8xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_8xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < N; i++) {
+ _mm_storeu_si128((__m128i *)(dst + stride * i), dstvec[i]);
+ }
+}
+
+static AOM_FORCE_INLINE void highbd_dr_prediction_z1_16xN_internal_idif_avx2(
+ int N, __m256i *dstvec, const uint16_t *above, int dx, int mrl_index,
+ int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((16 + N) - 1 + (mrl_index << 1));
+
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dstvec[i] = a_mbase_x; // save 16 values
+ }
+ return;
+ }
+
+ // load refs
+ a0 = _mm256_loadu_si256((__m256i *)(above + base - 1));
+ a1 = _mm256_loadu_si256((__m256i *)(above + base));
+ a2 = _mm256_loadu_si256((__m256i *)(above + base + 1));
+ a3 = _mm256_loadu_si256((__m256i *)(above + base + 2));
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][3]);
+
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0, f0),
+ _mm256_mullo_epi16(a1, f1));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2, f2),
+ _mm256_mullo_epi16(a3, f3));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ // clamp and round-shift
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ val0 = _mm256_adds_epi16(val0, rnding);
+ val0 = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+
+ base_inc256 = _mm256_setr_epi16(base, base + 1, base + 2, base + 3,
+ base + 4, base + 5, base + 6, base + 7,
+ base + 8, base + 9, base + 10, base + 11,
+ base + 12, base + 13, base + 14, base + 15);
+
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ dstvec[r] = _mm256_blendv_epi8(a_mbase_x, val0, mask256);
+ x += dx;
+ }
+}
+
+static AOM_FORCE_INLINE void
+highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(int N, __m256i *dstvec,
+ const uint16_t *above,
+ int dx, int mrl_index,
+ int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((16 + N) - 1 + (mrl_index << 1));
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i f0, f1, f2, f3;
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+
+ __m256i rnding = _mm256_set1_epi32(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ __m256i res[2], res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dstvec[i] = a_mbase_x; // save 16 values
+ }
+ return;
+ }
+
+ a0 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base - 1)));
+ a1 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base)));
+ a2 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 1)));
+ a3 = _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 2)));
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][3]);
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res[0] = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+
+ int mdif = max_base_x - base;
+ if (mdif > 8) {
+ a0 =
+ _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 7)));
+ a1 =
+ _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 8)));
+ a2 =
+ _mm256_cvtepu16_epi32(_mm_loadu_si128((__m128i *)(above + base + 9)));
+ a3 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 10)));
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res[1] = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+ } else {
+ res[1] = a_mbase_x;
+ }
+ res1 = _mm256_inserti128_si256(res[0], _mm256_castsi256_si128(res[1]),
+ 1); // 16 16bit values
+
+ base_inc256 = _mm256_setr_epi16(base, base + 1, base + 2, base + 3,
+ base + 4, base + 5, base + 6, base + 7,
+ base + 8, base + 9, base + 10, base + 11,
+ base + 12, base + 13, base + 14, base + 15);
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ dstvec[r] = _mm256_blendv_epi8(a_mbase_x, res1, mask256);
+ x += dx;
+ }
+}
+
+static void highbd_dr_prediction_z1_16xN_idif_avx2(
+ uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above,
+ const uint16_t *left, int dx, int dy, int bd, int mrl_index) {
+ (void)left;
+ (void)dy;
+ (void)bw;
+ assert(bw == 16);
+ int N = bh;
+ __m256i dstvec[64];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_16xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < N; i++) {
+ _mm256_storeu_si256((__m256i *)(dst + stride * i), dstvec[i]);
+ }
+}
+
+static AOM_FORCE_INLINE void highbd_dr_prediction_z1_32xN_internal_idif_avx2(
+ int N, __m256i *dstvec, const uint16_t *above, int dx, int mrl_index,
+ int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((32 + N) - 1 + (mrl_index << 1));
+
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ __m256i res;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dstvec[i] = a_mbase_x; // save 32 values
+ dstvec[i + N] = a_mbase_x;
+ }
+ return;
+ }
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][3]);
+
+ for (int j = 0; j < 32; j += 16) {
+ int mdif = max_base_x - (base + j);
+ if (mdif <= 0) {
+ res = a_mbase_x;
+ } else {
+ // load refs
+ a0 = _mm256_loadu_si256((__m256i *)(above + base - 1 + j));
+ a1 = _mm256_loadu_si256((__m256i *)(above + base + j));
+ a2 = _mm256_loadu_si256((__m256i *)(above + base + 1 + j));
+ a3 = _mm256_loadu_si256((__m256i *)(above + base + 2 + j));
+
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0, f0),
+ _mm256_mullo_epi16(a1, f1));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2, f2),
+ _mm256_mullo_epi16(a3, f3));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ // clamp and round-shift
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ val0 = _mm256_adds_epi16(val0, rnding);
+ val0 = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+
+ base_inc256 = _mm256_setr_epi16(
+ base + j, base + j + 1, base + j + 2, base + j + 3, base + j + 4,
+ base + j + 5, base + j + 6, base + j + 7, base + j + 8,
+ base + j + 9, base + j + 10, base + j + 11, base + j + 12,
+ base + j + 13, base + j + 14, base + j + 15);
+
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ res = _mm256_blendv_epi8(a_mbase_x, val0, mask256);
+ }
+ if (!j) {
+ dstvec[r] = res;
+ } else {
+ dstvec[r + N] = res;
+ }
+ }
+ x += dx;
+ }
+}
+
+static AOM_FORCE_INLINE void
+highbd_dr_prediction_32bit_z1_32xN_internal_idif_avx2(int N, __m256i *dstvec,
+ const uint16_t *above,
+ int dx, int mrl_index,
+ int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((32 + N) - 1 + (mrl_index << 1));
+
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi32(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++) {
+ __m256i res[2], res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ dstvec[i] = a_mbase_x; // save 32 values
+ dstvec[i + N] = a_mbase_x;
+ }
+ return;
+ }
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][3]);
+
+ for (int j = 0; j < 32; j += 16) {
+ int mdif = max_base_x - (base + j);
+ if (mdif <= 0) {
+ res1 = a_mbase_x;
+ } else {
+ a0 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base - 1 + j)));
+ a1 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + j)));
+ a2 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 1 + j)));
+ a3 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 2 + j)));
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res[0] = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+
+ if (mdif > 8) {
+ a0 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 7 + j)));
+ a1 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 8 + j)));
+ a2 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 9 + j)));
+ a3 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 10 + j)));
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res[1] = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+ } else {
+ res[1] = a_mbase_x;
+ }
+ res1 = _mm256_inserti128_si256(res[0], _mm256_castsi256_si128(res[1]),
+ 1); // 16 16bit values
+ base_inc256 = _mm256_setr_epi16(
+ base + j, base + j + 1, base + j + 2, base + j + 3, base + j + 4,
+ base + j + 5, base + j + 6, base + j + 7, base + j + 8,
+ base + j + 9, base + j + 10, base + j + 11, base + j + 12,
+ base + j + 13, base + j + 14, base + j + 15);
+
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ res1 = _mm256_blendv_epi8(a_mbase_x, res1, mask256);
+ }
+ if (!j) {
+ dstvec[r] = res1;
+ } else {
+ dstvec[r + N] = res1;
+ }
+ }
+ x += dx;
+ }
+}
+
+static void highbd_dr_prediction_z1_32xN_idif_avx2(int N, uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *above,
+ int dx, int bd,
+ int mrl_index) {
+ __m256i dstvec[128];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_32xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_32xN_internal_idif_avx2(N, dstvec, above, dx,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < N; i++) {
+ _mm256_storeu_si256((__m256i *)(dst + stride * i), dstvec[i]);
+ _mm256_storeu_si256((__m256i *)(dst + stride * i + 16), dstvec[i + N]);
+ }
+}
+
+static void highbd_dr_prediction_z1_64xN_internal_idif_avx2(
+ int N, uint16_t *dst, ptrdiff_t stride, const uint16_t *above, int dx,
+ int mrl_index, int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((64 + N) - 1 + (mrl_index << 1));
+
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+
+ __m256i a0, a1, a2, a3;
+ __m256i val0, val1;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++, dst += stride) {
+ __m256i res;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ _mm256_storeu_si256((__m256i *)dst, a_mbase_x); // save 32 values
+ _mm256_storeu_si256((__m256i *)(dst + 16), a_mbase_x);
+ _mm256_storeu_si256((__m256i *)(dst + 32), a_mbase_x);
+ _mm256_storeu_si256((__m256i *)(dst + 48), a_mbase_x);
+ dst += stride;
+ }
+ return;
+ }
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][3]);
+
+ for (int j = 0; j < 64; j += 16) {
+ int mdif = max_base_x - (base + j);
+ if (mdif <= 0) {
+ _mm256_storeu_si256((__m256i *)(dst + j), a_mbase_x);
+ } else {
+ // load refs
+ a0 = _mm256_loadu_si256((__m256i *)(above + base - 1 + j));
+ a1 = _mm256_loadu_si256((__m256i *)(above + base + j));
+ a2 = _mm256_loadu_si256((__m256i *)(above + base + 1 + j));
+ a3 = _mm256_loadu_si256((__m256i *)(above + base + 2 + j));
+
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0, f0),
+ _mm256_mullo_epi16(a1, f1));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2, f2),
+ _mm256_mullo_epi16(a3, f3));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ // clamp and round-shift
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ val0 = _mm256_adds_epi16(val0, rnding);
+ val0 = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+
+ base_inc256 = _mm256_setr_epi16(
+ base + j, base + j + 1, base + j + 2, base + j + 3, base + j + 4,
+ base + j + 5, base + j + 6, base + j + 7, base + j + 8,
+ base + j + 9, base + j + 10, base + j + 11, base + j + 12,
+ base + j + 13, base + j + 14, base + j + 15);
+
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ res = _mm256_blendv_epi8(a_mbase_x, val0, mask256);
+ _mm256_storeu_si256((__m256i *)(dst + j), res); // 16 16bit values
+ }
+ }
+ x += dx;
+ }
+}
+
+static void highbd_dr_prediction_32bit_z1_64xN_internal_idif_avx2(
+ int N, uint16_t *dst, ptrdiff_t stride, const uint16_t *above, int dx,
+ int mrl_index, int bd) {
+ const int frac_bits = 6;
+ const int max_base_x = ((64 + N) - 1 + (mrl_index << 1));
+
+ __m256i a0, a1, a2, a3;
+
+ __m256i a_mbase_x, max_base_x256, base_inc256, mask256;
+
+ __m256i val0, val1;
+ __m256i f0, f1, f2, f3;
+
+ __m256i rnding = _mm256_set1_epi32(1 << (POWER_DR_INTERP_FILTER - 1));
+
+ a_mbase_x = _mm256_set1_epi16(above[max_base_x]);
+ max_base_x256 = _mm256_set1_epi16(max_base_x);
+
+ int shift_i;
+ int x = dx * (1 + mrl_index);
+ for (int r = 0; r < N; r++, dst += stride) {
+ __m256i res[2], res1;
+
+ int base = x >> frac_bits;
+ if (base >= max_base_x) {
+ for (int i = r; i < N; ++i) {
+ _mm256_storeu_si256((__m256i *)dst, a_mbase_x); // save 32 values
+ _mm256_storeu_si256((__m256i *)(dst + 16), a_mbase_x);
+ _mm256_storeu_si256((__m256i *)(dst + 32), a_mbase_x);
+ _mm256_storeu_si256((__m256i *)(dst + 48), a_mbase_x);
+ dst += stride;
+ }
+ return;
+ }
+
+ // load filter
+ shift_i = (x & 0x3F) >> 1;
+ f0 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][0]);
+ f1 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][1]);
+ f2 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][2]);
+ f3 = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][3]);
+
+ for (int j = 0; j < 64; j += 16) {
+ int mdif = max_base_x - (base + j);
+ if (mdif <= 0) {
+ _mm256_storeu_si256((__m256i *)(dst + j), a_mbase_x);
+ } else {
+ a0 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base - 1 + j)));
+ a1 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + j)));
+ a2 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 1 + j)));
+ a3 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 2 + j)));
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res[0] = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+
+ if (mdif > 8) {
+ a0 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 7 + j)));
+ a1 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 8 + j)));
+ a2 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 9 + j)));
+ a3 = _mm256_cvtepu16_epi32(
+ _mm_loadu_si128((__m128i *)(above + base + 10 + j)));
+
+ // multiply and sum
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0, f0),
+ _mm256_mullo_epi32(a1, f1));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2, f2),
+ _mm256_mullo_epi32(a3, f3));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ res[1] = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+ } else {
+ res[1] = a_mbase_x;
+ }
+ res1 = _mm256_inserti128_si256(res[0], _mm256_castsi256_si128(res[1]),
+ 1); // 16 16bit values
+ base_inc256 = _mm256_setr_epi16(
+ base + j, base + j + 1, base + j + 2, base + j + 3, base + j + 4,
+ base + j + 5, base + j + 6, base + j + 7, base + j + 8,
+ base + j + 9, base + j + 10, base + j + 11, base + j + 12,
+ base + j + 13, base + j + 14, base + j + 15);
+
+ mask256 = _mm256_cmpgt_epi16(max_base_x256, base_inc256);
+ res1 = _mm256_blendv_epi8(a_mbase_x, res1, mask256);
+ _mm256_storeu_si256((__m256i *)(dst + j), res1);
+ }
+ }
+ x += dx;
+ }
+}
+
+static void highbd_dr_prediction_z1_64xN_idif_avx2(
+ uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above,
+ const uint16_t *left, int dx, int dy, int bd, int mrl_index) {
+ (void)left;
+ (void)dy;
+ (void)bw;
+ assert(bw == 64);
+ if (bd < 10) {
+ highbd_dr_prediction_z1_64xN_internal_idif_avx2(bh, dst, stride, above, dx,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_64xN_internal_idif_avx2(
+ bh, dst, stride, above, dx, mrl_index, bd);
+ }
+}
+
+void av1_highbd_dr_prediction_z1_idif_avx2(uint16_t *dst, ptrdiff_t stride,
+ int bw, int bh,
+ const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ switch (bw) {
+ case 4:
+ highbd_dr_prediction_z1_4xN_idif_avx2(dst, stride, bw, bh, above, left,
+ dx, dy, bd, mrl_index);
+ break;
+ case 8:
+ highbd_dr_prediction_z1_8xN_idif_avx2(dst, stride, bw, bh, above, left,
+ dx, dy, bd, mrl_index);
+ break;
+ case 16:
+ highbd_dr_prediction_z1_16xN_idif_avx2(dst, stride, bw, bh, above, left,
+ dx, dy, bd, mrl_index);
+ break;
+ case 32:
+ highbd_dr_prediction_z1_32xN_idif_avx2(bh, dst, stride, above, dx, bd,
+ mrl_index);
+ break;
+ case 64:
+ highbd_dr_prediction_z1_64xN_idif_avx2(dst, stride, bw, bh, above, left,
+ dx, dy, bd, mrl_index);
+ break;
+ default: break;
+ }
+ return;
+}
+
+static AOM_FORCE_INLINE __m256i highbd_dr_row8_idif_avx2(const uint16_t *above,
+ const __m256i *filter,
+ int base_x,
+ int base_shift,
+ int bd) {
+ // load refs
+ __m128i a0_x128, a1_x128, a2_x128, a3_x128;
+ a0_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift - 1));
+ a1_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift));
+ a2_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift + 1));
+ a3_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift + 2));
+
+ // load mask
+ a0_x128 = _mm_shuffle_epi8(a0_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a1_x128 = _mm_shuffle_epi8(a1_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a2_x128 = _mm_shuffle_epi8(a2_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a3_x128 = _mm_shuffle_epi8(a3_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+
+ __m256i a0_x, a1_x, a2_x, a3_x;
+ a0_x = _mm256_castsi128_si256(a0_x128);
+ a1_x = _mm256_castsi128_si256(a1_x128);
+ a2_x = _mm256_castsi128_si256(a2_x128);
+ a3_x = _mm256_castsi128_si256(a3_x128);
+
+ // multiply and sum
+ __m256i val0, val1;
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0_x, filter[0]),
+ _mm256_mullo_epi16(a1_x, filter[1]));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2_x, filter[2]),
+ _mm256_mullo_epi16(a3_x, filter[3]));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ const __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+ val0 = _mm256_adds_epi16(val0, rnding);
+ val0 = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+
+ return val0;
+}
+
+static AOM_FORCE_INLINE __m256i
+highbd_dr_row8_32bit_idif_avx2(const uint16_t *above, const __m256i *filter,
+ int base_x, int base_shift, int bd) {
+ // load refs
+ __m128i a0_x128, a1_x128, a2_x128, a3_x128;
+ a0_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift - 1));
+ a1_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift));
+ a2_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift + 1));
+ a3_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift + 2));
+
+ // load mask
+ a0_x128 = _mm_shuffle_epi8(a0_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a1_x128 = _mm_shuffle_epi8(a1_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a2_x128 = _mm_shuffle_epi8(a2_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a3_x128 = _mm_shuffle_epi8(a3_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+
+ __m256i a0_x, a1_x, a2_x, a3_x;
+ a0_x = _mm256_cvtepu16_epi32(a0_x128);
+ a1_x = _mm256_cvtepu16_epi32(a1_x128);
+ a2_x = _mm256_cvtepu16_epi32(a2_x128);
+ a3_x = _mm256_cvtepu16_epi32(a3_x128);
+
+ // multiply and sum
+ __m256i val0, val1;
+ val0 = _mm256_add_epi32(_mm256_mullo_epi32(a0_x, filter[0]),
+ _mm256_mullo_epi32(a1_x, filter[1]));
+ val1 = _mm256_add_epi32(_mm256_mullo_epi32(a2_x, filter[2]),
+ _mm256_mullo_epi32(a3_x, filter[3]));
+ val0 = _mm256_add_epi32(val0, val1);
+
+ // round shift
+ val0 = highbd_clamp_epi32_avx2(val0, bd);
+ __m256i rnding = _mm256_set1_epi32(1 << (POWER_DR_INTERP_FILTER - 1));
+ val0 = _mm256_add_epi32(val0, rnding);
+ val0 = _mm256_srli_epi32(val0, POWER_DR_INTERP_FILTER);
+
+ __m256i resx = _mm256_packus_epi32(
+ val0, _mm256_castsi128_si256(_mm256_extracti128_si256(val0, 1)));
+ return resx;
+}
+
+static INLINE void highbd_dr_z2_8x8_idif_avx2(int H, int W,
+ const uint16_t *above,
+ __m128i *dest, int r, int j,
+ int dx, int mrl_index, int bd) {
+ const int min_base_x = -((1 + mrl_index));
+ const int frac_bits_x = 6;
+
+ __m256i res;
+ __m128i resx;
+ int min_h = (H == 4) ? 4 : 8;
+ int min_w = (W == 4) ? 4 : 8;
+
+ for (int i = r; i < r + min_h; i++) {
+ assert(i < H);
+ assert(j < W);
+
+ int y = i + 1;
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_shift = 0;
+ if (base_x < (min_base_x - 1)) {
+ base_shift = (min_base_x - base_x - 1);
+ }
+
+ if (base_shift > min_w - 1) {
+ resx = _mm_setzero_si128();
+ } else {
+ // load filter
+ int shift_i = ((-(y + mrl_index) * dx) & 0x3F) >> 1;
+ __m256i f[4];
+ f[0] = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][0]);
+ f[1] = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][1]);
+ f[2] = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][2]);
+ f[3] = _mm256_set1_epi16(av1_dr_interp_filter[shift_i][3]);
+
+ res = highbd_dr_row8_idif_avx2(above, f, base_x, base_shift, bd);
+ resx = _mm256_castsi256_si128(res);
+ }
+ dest[i - r] = resx;
+ }
+}
+
+static INLINE void highbd_dr_z2_32bit_8x8_idif_avx2(int H, int W,
+ const uint16_t *above,
+ __m128i *dest, int r, int j,
+ int dx, int mrl_index,
+ int bd) {
+ const int min_base_x = -((1 + mrl_index));
+ const int frac_bits_x = 6;
+
+ __m256i res;
+ __m128i resx;
+ // adapt if size is 4
+ int min_h = (H == 4) ? 4 : 8;
+ int min_w = (W == 4) ? 4 : 8;
+
+ for (int i = r; i < r + min_h; i++) {
+ assert(i < H);
+ assert(j < W);
+
+ int y = i + 1;
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_shift = 0;
+ if (base_x < (min_base_x - 1)) {
+ base_shift = (min_base_x - base_x - 1);
+ }
+
+ if (base_shift > min_w - 1) {
+ resx = _mm_setzero_si128();
+ } else {
+ // load filter
+ int shift_i = ((-(y + mrl_index) * dx) & 0x3F) >> 1;
+ __m256i f[4];
+ f[0] = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][0]);
+ f[1] = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][1]);
+ f[2] = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][2]);
+ f[3] = _mm256_set1_epi32(av1_dr_interp_filter[shift_i][3]);
+
+ res = highbd_dr_row8_32bit_idif_avx2(above, f, base_x, base_shift, bd);
+ resx = _mm256_castsi256_si128(res);
+ }
+ dest[i - r] = resx;
+ }
+}
+
+static void highbd_dr_32bit_z2_8x8_tiling_idif_avx2(
+ int H, int W, uint16_t *dst, ptrdiff_t stride, const uint16_t *above,
+ const uint16_t *left, int dx, int dy, int mrl_index, int bd) {
+ // Directional prediction in a 8x8 tile.
+ // Sizes of 4x4, 4x8 and 8x4 are supported as well.
+ // Step 1. Predict from above.
+ // Step 2. Predict from left and transpose.
+ // Step 3. Merge results.
+
+ const int min_base_x = -((1 + mrl_index));
+ const int frac_bits_x = 6;
+
+ __m128i x_pred[8];
+ __m128i y_pred[8];
+ __m128i _y_pred[8];
+
+ for (int i = 0; i < 8; i++) {
+ x_pred[i] = _mm_setzero_si128();
+ y_pred[i] = _mm_setzero_si128();
+ _y_pred[i] = _mm_setzero_si128();
+ }
+
+ int min_h = (H == 4) ? 4 : 8;
+ int min_w = (W == 4) ? 4 : 8;
+
+ for (int r = 0; r < H; r += 8) {
+ for (int j = 0; j < W; j += min_w) {
+ assert((W - j) >= min_w);
+ assert((H - r) >= min_h);
+
+ if (bd < 10) {
+ highbd_dr_z2_8x8_idif_avx2(H, W, above, x_pred, r, j, dx, mrl_index,
+ bd);
+ highbd_dr_z2_8x8_idif_avx2(W, H, left, _y_pred, j, r, dy, mrl_index,
+ bd);
+ } else {
+ highbd_dr_z2_32bit_8x8_idif_avx2(H, W, above, x_pred, r, j, dx,
+ mrl_index, bd);
+ highbd_dr_z2_32bit_8x8_idif_avx2(W, H, left, _y_pred, j, r, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose8x8_sse2(&_y_pred[0], &_y_pred[1], &_y_pred[2],
+ &_y_pred[3], &_y_pred[4], &_y_pred[5],
+ &_y_pred[6], &_y_pred[7], &y_pred[0], &y_pred[1],
+ &y_pred[2], &y_pred[3], &y_pred[4], &y_pred[5],
+ &y_pred[6], &y_pred[7]);
+
+ for (int k = 0; k < min_h; ++k) {
+ int y = r + k + 1;
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_min_diff = (min_base_x - base_x);
+ if (base_min_diff > min_w) {
+ base_min_diff = min_w;
+ } else {
+ if (base_min_diff < 0) base_min_diff = 0;
+ }
+
+ __m128i resx, resy, resxy;
+ resx = x_pred[k];
+ resy = y_pred[k];
+
+ resxy = _mm_blendv_epi8(resx, resy,
+ *(__m128i *)HighbdBaseMask[base_min_diff]);
+
+ if (min_w == 8) {
+ _mm_storeu_si128((__m128i *)(dst + k * stride + j), resxy);
+ } else {
+ _mm_storel_epi64((__m128i *)(dst + k * stride + j), resxy);
+ }
+ }
+ }
+ if (r + 8 < H) dst += 8 * stride;
+ }
+}
+
+static void highbd_dr_z2_16x16_idif_avx2(int H, int W, const uint16_t *above,
+ __m256i *dest, int r, int j, int dx,
+ int mrl_index, int bd) {
+ (void)H;
+ (void)W;
+
+ const int min_base_x = -(1 + mrl_index);
+ const int frac_bits_x = 6;
+
+ __m128i a0_x128, a1_x128, a2_x128, a3_x128;
+ __m256i a0_x, a1_x, a2_x, a3_x;
+ __m256i f0_x, f1_x, f2_x, f3_x;
+ __m256i rnding = _mm256_set1_epi16(1 << (POWER_DR_INTERP_FILTER - 1));
+ __m256i val0, val1;
+
+ for (int i = r; i < r + 16; ++i) {
+ assert(i < H);
+ assert(j < W);
+ int y = i + 1;
+
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_shift = 0;
+ if ((base_x) < (min_base_x - 1)) {
+ base_shift = (min_base_x - (base_x)-1);
+ }
+
+ if (base_shift < 8) {
+ a0_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift - 1));
+ a1_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift));
+ a2_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift + 1));
+ a3_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift + 2));
+
+ a0_x128 =
+ _mm_shuffle_epi8(a0_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a1_x128 =
+ _mm_shuffle_epi8(a1_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a2_x128 =
+ _mm_shuffle_epi8(a2_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+ a3_x128 =
+ _mm_shuffle_epi8(a3_x128, *(__m128i *)HighbdLoadMaskx[base_shift]);
+
+ a0_x = _mm256_castsi128_si256(a0_x128);
+ a1_x = _mm256_castsi128_si256(a1_x128);
+ a2_x = _mm256_castsi128_si256(a2_x128);
+ a3_x = _mm256_castsi128_si256(a3_x128);
+ } else {
+ a0_x = _mm256_setzero_si256();
+ a1_x = _mm256_setzero_si256();
+ a2_x = _mm256_setzero_si256();
+ a3_x = _mm256_setzero_si256();
+ }
+
+ int base_shift1 = 0;
+ if (base_shift > 8) {
+ base_shift1 = base_shift - 8;
+ }
+ if (base_shift1 < 8) {
+ a0_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift1 + 7));
+ a1_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift1 + 8));
+ a2_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift1 + 9));
+ a3_x128 = _mm_loadu_si128((__m128i *)(above + base_x + base_shift1 + 10));
+
+ a0_x128 =
+ _mm_shuffle_epi8(a0_x128, *(__m128i *)HighbdLoadMaskx[base_shift1]);
+ a1_x128 =
+ _mm_shuffle_epi8(a1_x128, *(__m128i *)HighbdLoadMaskx[base_shift1]);
+ a2_x128 =
+ _mm_shuffle_epi8(a2_x128, *(__m128i *)HighbdLoadMaskx[base_shift1]);
+ a3_x128 =
+ _mm_shuffle_epi8(a3_x128, *(__m128i *)HighbdLoadMaskx[base_shift1]);
+
+ a0_x = _mm256_inserti128_si256(a0_x, a0_x128, 1);
+ a1_x = _mm256_inserti128_si256(a1_x, a1_x128, 1);
+ a2_x = _mm256_inserti128_si256(a2_x, a2_x128, 1);
+ a3_x = _mm256_inserti128_si256(a3_x, a3_x128, 1);
+ }
+ if ((base_shift < 8) || base_shift1 < 8) {
+ // load filter
+ int shift_x = ((-(i + 1 + mrl_index) * dx) & 0x3F) >> 1;
+ f0_x = _mm256_set1_epi16(av1_dr_interp_filter[shift_x][0]);
+ f1_x = _mm256_set1_epi16(av1_dr_interp_filter[shift_x][1]);
+ f2_x = _mm256_set1_epi16(av1_dr_interp_filter[shift_x][2]);
+ f3_x = _mm256_set1_epi16(av1_dr_interp_filter[shift_x][3]);
+
+ val0 = _mm256_adds_epi16(_mm256_mullo_epi16(a0_x, f0_x),
+ _mm256_mullo_epi16(a1_x, f1_x));
+ val1 = _mm256_adds_epi16(_mm256_mullo_epi16(a2_x, f2_x),
+ _mm256_mullo_epi16(a3_x, f3_x));
+ val0 = _mm256_adds_epi16(val0, val1);
+
+ val0 = highbd_clamp_epi16_avx2(val0, bd);
+ val0 = _mm256_adds_epi16(val0, rnding);
+ dest[i - r] = _mm256_srli_epi16(val0, POWER_DR_INTERP_FILTER);
+ } else {
+ dest[i - r] = _mm256_setzero_si256();
+ }
+ }
+}
+
+static void highbd_dr_prediction_z2_HxW_idif_avx2(
+ int H, int W, uint16_t *dst, ptrdiff_t stride, const uint16_t *above,
+ const uint16_t *left, int dx, int dy, int mrl_index, int bd) {
+ // Directional prediction in 16x16 tiles.
+ // Step 1. Predict from above.
+ // Step 2. Predict from left and transpose.
+ // Step 3. Merge results.
+
+ const int min_base_x = -(1 + mrl_index);
+ const int frac_bits_x = 6;
+
+ __m256i x_pred[16];
+ __m256i y_pred[16];
+
+ for (int r = 0; r < H; r += 16) {
+ for (int j = 0; j < W; j += 16) {
+ assert((W - j) >= 16);
+ assert((H - r) >= 16);
+ // x calc
+ highbd_dr_z2_16x16_idif_avx2(H, W, above, x_pred, r, j, dx, mrl_index,
+ bd);
+
+ // y calc
+ highbd_dr_z2_16x16_idif_avx2(W, H, left, y_pred, j, r, dy, mrl_index, bd);
+ highbd_transpose16x16_avx2(y_pred, y_pred);
+
+ // merge results
+ for (int k = 0; k < 16; ++k) {
+ int y = k + r + 1;
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_min_diff = (min_base_x - base_x);
+ if (base_min_diff > 16) {
+ base_min_diff = 16;
+ } else {
+ if (base_min_diff < 0) base_min_diff = 0;
+ }
+
+ __m256i resx, resy, resxy;
+ resx = x_pred[k];
+ resy = y_pred[k];
+
+ resxy = _mm256_blendv_epi8(resx, resy,
+ *(__m256i *)HighbdBaseMask[base_min_diff]);
+ _mm256_storeu_si256((__m256i *)(dst + k * stride + j), resxy);
+ }
+ } // for j
+ if (r + 16 < H) dst += 16 * stride;
+ }
+}
+
+static void highbd_dr_z2_16x16_32bit_idif_avx2(int H, int W,
+ const uint16_t *above,
+ __m256i *dest, int r, int j,
+ int dx, int mrl_index, int bd) {
+ (void)H;
+ (void)W;
+ const int min_base_x = -(1 + mrl_index);
+ const int frac_bits_x = 6;
+ __m256i resx[2];
+
+ for (int i = r; i < r + 16; ++i) {
+ assert(i < H);
+ assert(j < W);
+
+ int y = i + 1;
+
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_shift = 0;
+ if ((base_x) < (min_base_x - 1)) {
+ base_shift = (min_base_x - (base_x)-1);
+ }
+
+ // load filter
+ int shift_x = ((-(i + 1 + mrl_index) * dx) & 0x3F) >> 1;
+ __m256i f[4];
+ f[0] = _mm256_set1_epi32(av1_dr_interp_filter[shift_x][0]);
+ f[1] = _mm256_set1_epi32(av1_dr_interp_filter[shift_x][1]);
+ f[2] = _mm256_set1_epi32(av1_dr_interp_filter[shift_x][2]);
+ f[3] = _mm256_set1_epi32(av1_dr_interp_filter[shift_x][3]);
+
+ if (base_shift < 8) {
+ resx[0] =
+ highbd_dr_row8_32bit_idif_avx2(above, f, base_x, base_shift, bd);
+
+ } else {
+ resx[0] = _mm256_setzero_si256();
+ }
+
+ int base_shift1 = 0;
+ if (base_shift > 8) {
+ base_shift1 = base_shift - 8;
+ }
+ if (base_shift1 < 8) {
+ resx[1] =
+ highbd_dr_row8_32bit_idif_avx2(above, f, base_x + 8, base_shift1, bd);
+ }
+ if ((base_shift < 8) || base_shift1 < 8) {
+ dest[i - r] =
+ _mm256_inserti128_si256(resx[0], _mm256_castsi256_si128(resx[1]),
+ 1); // 16 16bit values
+ } else {
+ dest[i - r] = _mm256_setzero_si256();
+ }
+ }
+}
+
+static void highbd_dr_prediction_32bit_z2_HxW_idif_avx2(
+ int H, int W, uint16_t *dst, ptrdiff_t stride, const uint16_t *above,
+ const uint16_t *left, int dx, int dy, int mrl_index, int bd) {
+ // Directional prediction in 16x16 tiles.
+ // Step 1. Predict from above.
+ // Step 2. Predict from left and transpose.
+ // Step 3. Merge results.
+
+ const int min_base_x = -(1 + mrl_index);
+ const int frac_bits_x = 6;
+
+ __m256i x_pred[16];
+ __m256i y_pred[16];
+
+ for (int r = 0; r < H; r += 16) {
+ for (int j = 0; j < W; j += 16) {
+ assert((W - j) >= 16);
+ assert((H - r) >= 16);
+
+ // x calc
+ highbd_dr_z2_16x16_32bit_idif_avx2(H, W, above, x_pred, r, j, dx,
+ mrl_index, bd);
+
+ // y calc
+ highbd_dr_z2_16x16_32bit_idif_avx2(W, H, left, y_pred, j, r, dy,
+ mrl_index, bd);
+ highbd_transpose16x16_avx2(y_pred, y_pred);
+ // merge results
+ for (int k = 0; k < 16; ++k) {
+ int y = k + r + 1;
+ int base_x = ((j << 6) - (y + mrl_index) * dx) >> frac_bits_x;
+ int base_min_diff = (min_base_x - base_x);
+ if (base_min_diff > 16) {
+ base_min_diff = 16;
+ } else {
+ if (base_min_diff < 0) base_min_diff = 0;
+ }
+
+ __m256i resx, resy, resxy;
+ resx = x_pred[k];
+ resy = y_pred[k];
+
+ resxy = _mm256_blendv_epi8(resx, resy,
+ *(__m256i *)HighbdBaseMask[base_min_diff]);
+ _mm256_storeu_si256((__m256i *)(dst + k * stride + j), resxy);
+ }
+ } // for j
+ if (r + 16 < H) dst += 16 * stride;
+ }
+}
+
+// Directional prediction, zone 2: 90 < angle < 180 using IDIF
+void av1_highbd_dr_prediction_z2_idif_avx2(uint16_t *dst, ptrdiff_t stride,
+ int bw, int bh,
+ const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ assert(dx > 0);
+ assert(dy > 0);
+ switch (bw) {
+ case 4:
+ highbd_dr_32bit_z2_8x8_tiling_idif_avx2(bh, bw, dst, stride, above, left,
+ dx, dy, mrl_index, bd);
+ break;
+ case 8:
+ highbd_dr_32bit_z2_8x8_tiling_idif_avx2(bh, bw, dst, stride, above, left,
+ dx, dy, mrl_index, bd);
+ break;
+ default:
+ if (bh < 16) {
+ highbd_dr_32bit_z2_8x8_tiling_idif_avx2(bh, bw, dst, stride, above,
+ left, dx, dy, mrl_index, bd);
+ } else {
+ if (bd < 10) {
+ highbd_dr_prediction_z2_HxW_idif_avx2(bh, bw, dst, stride, above,
+ left, dx, dy, mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z2_HxW_idif_avx2(
+ bh, bw, dst, stride, above, left, dx, dy, mrl_index, bd);
+ }
+ }
+ break;
+ }
+}
+
+// Directional prediction, zone 3 functions
+static void highbd_dr_prediction_z3_4x4_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[4], d[4];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_4xN_internal_idif_avx2(4, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_4xN_internal_idif_avx2(4, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose4x8_8x4_low_sse2(&dstvec[0], &dstvec[1], &dstvec[2],
+ &dstvec[3], &d[0], &d[1], &d[2], &d[3]);
+ _mm_storel_epi64((__m128i *)(dst + 0 * stride), d[0]);
+ _mm_storel_epi64((__m128i *)(dst + 1 * stride), d[1]);
+ _mm_storel_epi64((__m128i *)(dst + 2 * stride), d[2]);
+ _mm_storel_epi64((__m128i *)(dst + 3 * stride), d[3]);
+ return;
+}
+
+static void highbd_dr_prediction_z3_8x8_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[8], d[8];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_8xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_8xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose8x8_sse2(&dstvec[0], &dstvec[1], &dstvec[2], &dstvec[3],
+ &dstvec[4], &dstvec[5], &dstvec[6], &dstvec[7],
+ &d[0], &d[1], &d[2], &d[3], &d[4], &d[5], &d[6],
+ &d[7]);
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + i * stride), d[i]);
+ }
+}
+
+static void highbd_dr_prediction_z3_16x16_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ __m256i dstvec[16], d[16];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_16xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ }
+
+ highbd_transpose16x16_avx2(dstvec, d);
+
+ for (int i = 0; i < 16; i++) {
+ _mm256_storeu_si256((__m256i *)(dst + i * stride), d[i]);
+ }
+}
+
+static void highbd_dr_prediction_z3_32x32_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ __m256i dstvec[64], d[16];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_32xN_internal_idif_avx2(32, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_32xN_internal_idif_avx2(32, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose16x16_avx2(dstvec, d);
+ for (int j = 0; j < 16; j++) {
+ _mm256_storeu_si256((__m256i *)(dst + j * stride), d[j]);
+ }
+ highbd_transpose16x16_avx2(dstvec + 16, d);
+ for (int j = 0; j < 16; j++) {
+ _mm256_storeu_si256((__m256i *)(dst + j * stride + 16), d[j]);
+ }
+ highbd_transpose16x16_avx2(dstvec + 32, d);
+ for (int j = 0; j < 16; j++) {
+ _mm256_storeu_si256((__m256i *)(dst + (j + 16) * stride), d[j]);
+ }
+ highbd_transpose16x16_avx2(dstvec + 48, d);
+ for (int j = 0; j < 16; j++) {
+ _mm256_storeu_si256((__m256i *)(dst + (j + 16) * stride + 16), d[j]);
+ }
+}
+
+static void highbd_dr_prediction_z3_64x64_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ DECLARE_ALIGNED(16, uint16_t, dstT[64 * 64]);
+ if (bd < 10) {
+ highbd_dr_prediction_z1_64xN_internal_idif_avx2(64, dstT, 64, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_64xN_internal_idif_avx2(64, dstT, 64, left,
+ dy, mrl_index, bd);
+ }
+ highbd_transpose(dstT, 64, dst, stride, 64, 64);
+}
+
+static void highbd_dr_prediction_z3_4x8_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[4], d[8];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_8xN_internal_idif_avx2(4, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_8xN_internal_idif_avx2(4, dstvec, left, dy,
+ mrl_index, bd);
+ }
+
+ highbd_transpose4x8_8x4_sse2(&dstvec[0], &dstvec[1], &dstvec[2], &dstvec[3],
+ &d[0], &d[1], &d[2], &d[3], &d[4], &d[5], &d[6],
+ &d[7]);
+ for (int i = 0; i < 8; i++) {
+ _mm_storel_epi64((__m128i *)(dst + i * stride), d[i]);
+ }
+}
+
+static void highbd_dr_prediction_z3_8x4_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[8], d[4];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_4xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_4xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ }
+
+ highbd_transpose8x8_low_sse2(&dstvec[0], &dstvec[1], &dstvec[2], &dstvec[3],
+ &dstvec[4], &dstvec[5], &dstvec[6], &dstvec[7],
+ &d[0], &d[1], &d[2], &d[3]);
+ _mm_storeu_si128((__m128i *)(dst + 0 * stride), d[0]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * stride), d[1]);
+ _mm_storeu_si128((__m128i *)(dst + 2 * stride), d[2]);
+ _mm_storeu_si128((__m128i *)(dst + 3 * stride), d[3]);
+}
+
+static void highbd_dr_prediction_z3_8x16_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m256i dstvec[8], d[8];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_16xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose8x16_16x8_avx2(dstvec, d);
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + i * stride),
+ _mm256_castsi256_si128(d[i]));
+ }
+ for (int i = 8; i < 16; i++) {
+ _mm_storeu_si128((__m128i *)(dst + i * stride),
+ _mm256_extracti128_si256(d[i - 8], 1));
+ }
+}
+
+static void highbd_dr_prediction_z3_16x8_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[16], d[16];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_8xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_8xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < 16; i += 8) {
+ highbd_transpose8x8_sse2(&dstvec[0 + i], &dstvec[1 + i], &dstvec[2 + i],
+ &dstvec[3 + i], &dstvec[4 + i], &dstvec[5 + i],
+ &dstvec[6 + i], &dstvec[7 + i], &d[0 + i],
+ &d[1 + i], &d[2 + i], &d[3 + i], &d[4 + i],
+ &d[5 + i], &d[6 + i], &d[7 + i]);
+ }
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + i * stride), d[i]);
+ _mm_storeu_si128((__m128i *)(dst + i * stride + 8), d[i + 8]);
+ }
+}
+
+static void highbd_dr_prediction_z3_4x16_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m256i dstvec[4], d[4], d1;
+ if (bd < 10) {
+ highbd_dr_prediction_z1_16xN_internal_idif_avx2(4, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(4, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose4x16_avx2(dstvec, d);
+ for (int i = 0; i < 4; i++) {
+ _mm_storel_epi64((__m128i *)(dst + i * stride),
+ _mm256_castsi256_si128(d[i]));
+ d1 = _mm256_bsrli_epi128(d[i], 8);
+ _mm_storel_epi64((__m128i *)(dst + (i + 4) * stride),
+ _mm256_castsi256_si128(d1));
+ _mm_storel_epi64((__m128i *)(dst + (i + 8) * stride),
+ _mm256_extracti128_si256(d[i], 1));
+ _mm_storel_epi64((__m128i *)(dst + (i + 12) * stride),
+ _mm256_extracti128_si256(d1, 1));
+ }
+}
+
+static void highbd_dr_prediction_z3_16x4_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[16], d[8];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_4xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_4xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ highbd_transpose16x4_8x8_sse2(dstvec, d);
+
+ _mm_storeu_si128((__m128i *)(dst + 0 * stride), d[0]);
+ _mm_storeu_si128((__m128i *)(dst + 0 * stride + 8), d[1]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * stride), d[2]);
+ _mm_storeu_si128((__m128i *)(dst + 1 * stride + 8), d[3]);
+ _mm_storeu_si128((__m128i *)(dst + 2 * stride), d[4]);
+ _mm_storeu_si128((__m128i *)(dst + 2 * stride + 8), d[5]);
+ _mm_storeu_si128((__m128i *)(dst + 3 * stride), d[6]);
+ _mm_storeu_si128((__m128i *)(dst + 3 * stride + 8), d[7]);
+}
+
+static void highbd_dr_prediction_z3_8x32_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m256i dstvec[16], d[16];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_32xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_32xN_internal_idif_avx2(8, dstvec, left, dy,
+ mrl_index, bd);
+ }
+
+ for (int i = 0; i < 16; i += 8) {
+ highbd_transpose8x16_16x8_avx2(dstvec + i, d + i);
+ }
+
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + i * stride),
+ _mm256_castsi256_si128(d[i]));
+ }
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + (i + 8) * stride),
+ _mm256_extracti128_si256(d[i], 1));
+ }
+ for (int i = 8; i < 16; i++) {
+ _mm_storeu_si128((__m128i *)(dst + (i + 8) * stride),
+ _mm256_castsi256_si128(d[i]));
+ }
+ for (int i = 8; i < 16; i++) {
+ _mm_storeu_si128((__m128i *)(dst + (i + 16) * stride),
+ _mm256_extracti128_si256(d[i], 1));
+ }
+}
+
+static void highbd_dr_prediction_z3_32x8_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left, int dy,
+ int bd, int mrl_index) {
+ __m128i dstvec[32], d[32];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_8xN_internal_idif_avx2(32, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_8xN_internal_idif_avx2(32, dstvec, left, dy,
+ mrl_index, bd);
+ }
+
+ for (int i = 0; i < 32; i += 8) {
+ highbd_transpose8x8_sse2(&dstvec[0 + i], &dstvec[1 + i], &dstvec[2 + i],
+ &dstvec[3 + i], &dstvec[4 + i], &dstvec[5 + i],
+ &dstvec[6 + i], &dstvec[7 + i], &d[0 + i],
+ &d[1 + i], &d[2 + i], &d[3 + i], &d[4 + i],
+ &d[5 + i], &d[6 + i], &d[7 + i]);
+ }
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + i * stride), d[i]);
+ _mm_storeu_si128((__m128i *)(dst + i * stride + 8), d[i + 8]);
+ _mm_storeu_si128((__m128i *)(dst + i * stride + 16), d[i + 16]);
+ _mm_storeu_si128((__m128i *)(dst + i * stride + 24), d[i + 24]);
+ }
+}
+
+static void highbd_dr_prediction_z3_16x32_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ __m256i dstvec[32], d[32];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_32xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_32xN_internal_idif_avx2(16, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < 32; i += 8) {
+ highbd_transpose8x16_16x8_avx2(dstvec + i, d + i);
+ }
+ // store
+ for (int j = 0; j < 32; j += 16) {
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + (i + j) * stride),
+ _mm256_castsi256_si128(d[(i + j)]));
+ }
+ for (int i = 0; i < 8; i++) {
+ _mm_storeu_si128((__m128i *)(dst + (i + j) * stride + 8),
+ _mm256_castsi256_si128(d[(i + j) + 8]));
+ }
+ for (int i = 8; i < 16; i++) {
+ _mm256_storeu_si256(
+ (__m256i *)(dst + (i + j) * stride),
+ _mm256_inserti128_si256(
+ d[(i + j)], _mm256_extracti128_si256(d[(i + j) - 8], 1), 0));
+ }
+ }
+}
+
+static void highbd_dr_prediction_z3_32x16_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ __m256i dstvec[32], d[16];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_16xN_internal_idif_avx2(32, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(32, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < 32; i += 16) {
+ highbd_transpose16x16_avx2((dstvec + i), d);
+ for (int j = 0; j < 16; j++) {
+ _mm256_storeu_si256((__m256i *)(dst + j * stride + i), d[j]);
+ }
+ }
+}
+
+static void highbd_dr_prediction_z3_32x64_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ uint16_t dstT[64 * 32];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_64xN_internal_idif_avx2(32, dstT, 64, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_64xN_internal_idif_avx2(32, dstT, 64, left,
+ dy, mrl_index, bd);
+ }
+ highbd_transpose(dstT, 64, dst, stride, 32, 64);
+}
+
+static void highbd_dr_prediction_z3_64x32_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ DECLARE_ALIGNED(16, uint16_t, dstT[32 * 64]);
+ highbd_dr_prediction_z1_32xN_idif_avx2(64, dstT, 32, left, dy, bd, mrl_index);
+ highbd_transpose(dstT, 32, dst, stride, 64, 32);
+ return;
+}
+
+static void highbd_dr_prediction_z3_16x64_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ DECLARE_ALIGNED(16, uint16_t, dstT[64 * 16]);
+ if (bd < 10) {
+ highbd_dr_prediction_z1_64xN_internal_idif_avx2(16, dstT, 64, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_64xN_internal_idif_avx2(16, dstT, 64, left,
+ dy, mrl_index, bd);
+ }
+ highbd_transpose(dstT, 64, dst, stride, 16, 64);
+}
+
+static void highbd_dr_prediction_z3_64x16_idif_avx2(uint16_t *dst,
+ ptrdiff_t stride,
+ const uint16_t *left,
+ int dy, int bd,
+ int mrl_index) {
+ __m256i dstvec[64], d[16];
+ if (bd < 10) {
+ highbd_dr_prediction_z1_16xN_internal_idif_avx2(64, dstvec, left, dy,
+ mrl_index, bd);
+ } else {
+ highbd_dr_prediction_32bit_z1_16xN_internal_idif_avx2(64, dstvec, left, dy,
+ mrl_index, bd);
+ }
+ for (int i = 0; i < 64; i += 16) {
+ highbd_transpose16x16_avx2((dstvec + i), d);
+ for (int j = 0; j < 16; j++) {
+ _mm256_storeu_si256((__m256i *)(dst + j * stride + i), d[j]);
+ }
+ }
+}
+
+void av1_highbd_dr_prediction_z3_idif_avx2(uint16_t *dst, ptrdiff_t stride,
+ int bw, int bh,
+ const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ (void)above;
+ (void)dx;
+
+ assert(dx == 1);
+ assert(dy > 0);
+
+ if (bw == bh) {
+ switch (bw) {
+ case 4:
+ highbd_dr_prediction_z3_4x4_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 8:
+ highbd_dr_prediction_z3_8x8_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 16:
+ highbd_dr_prediction_z3_16x16_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 32:
+ highbd_dr_prediction_z3_32x32_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 64:
+ highbd_dr_prediction_z3_64x64_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ }
+ } else {
+ if (bw < bh) {
+ if (bw + bw == bh) {
+ switch (bw) {
+ case 4:
+ highbd_dr_prediction_z3_4x8_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 8:
+ highbd_dr_prediction_z3_8x16_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 16:
+ highbd_dr_prediction_z3_16x32_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 32:
+ highbd_dr_prediction_z3_32x64_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ }
+ } else {
+ switch (bw) {
+ case 4:
+ highbd_dr_prediction_z3_4x16_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 8:
+ highbd_dr_prediction_z3_8x32_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 16:
+ highbd_dr_prediction_z3_16x64_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ }
+ }
+ } else {
+ if (bh + bh == bw) {
+ switch (bh) {
+ case 4:
+ highbd_dr_prediction_z3_8x4_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 8:
+ highbd_dr_prediction_z3_16x8_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 16:
+ highbd_dr_prediction_z3_32x16_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 32:
+ highbd_dr_prediction_z3_64x32_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ }
+ } else {
+ switch (bh) {
+ case 4:
+ highbd_dr_prediction_z3_16x4_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 8:
+ highbd_dr_prediction_z3_32x8_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ case 16:
+ highbd_dr_prediction_z3_64x16_idif_avx2(dst, stride, left, dy, bd,
+ mrl_index);
+ break;
+ }
+ }
+ }
+ }
+ return;
+}
+#endif // CONFIG_IDIF
diff --git a/aom_dsp/x86/sad_highbd_avx2.c b/aom_dsp/x86/sad_highbd_avx2.c
index 3fc91d8..bae6691 100644
--- a/aom_dsp/x86/sad_highbd_avx2.c
+++ b/aom_dsp/x86/sad_highbd_avx2.c
@@ -20,7 +20,8 @@
#include "aom_ports/mem.h"
// SAD
-static INLINE unsigned int get_sad_from_mm256_epi32(const __m256i *v) {
+static AOM_FORCE_INLINE unsigned int get_sad_from_mm256_epi32(
+ const __m256i *v) {
// input 8 32-bit summation
__m128i lo128, hi128;
__m256i u = _mm256_srli_si256(*v, 8);
@@ -38,8 +39,8 @@
return (unsigned int)_mm_cvtsi128_si32(lo128);
}
-static INLINE void highbd_sad16x4_core_avx2(__m256i *s, __m256i *r,
- __m256i *sad_acc) {
+static AOM_FORCE_INLINE void highbd_sad16x4_core_avx2(__m256i *s, __m256i *r,
+ __m256i *sad_acc) {
const __m256i zero = _mm256_setzero_si256();
int i;
for (i = 0; i < 4; i++) {
@@ -59,9 +60,10 @@
}
// If sec_ptr = 0, calculate regular SAD. Otherwise, calculate average SAD.
-static INLINE void sad16x4(const uint16_t *src_ptr, int src_stride,
- const uint16_t *ref_ptr, int ref_stride,
- const uint16_t *sec_ptr, __m256i *sad_acc) {
+static AOM_FORCE_INLINE void sad16x4(const uint16_t *src_ptr, int src_stride,
+ const uint16_t *ref_ptr, int ref_stride,
+ const uint16_t *sec_ptr,
+ __m256i *sad_acc) {
__m256i s[4], r[4];
s[0] = _mm256_loadu_si256((const __m256i *)src_ptr);
s[1] = _mm256_loadu_si256((const __m256i *)(src_ptr + src_stride));
@@ -98,9 +100,10 @@
return (unsigned int)get_sad_from_mm256_epi32(&sad);
}
-static void sad32x4(const uint16_t *src_ptr, int src_stride,
- const uint16_t *ref_ptr, int ref_stride,
- const uint16_t *sec_ptr, __m256i *sad_acc) {
+static AOM_FORCE_INLINE void sad32x4(const uint16_t *src_ptr, int src_stride,
+ const uint16_t *ref_ptr, int ref_stride,
+ const uint16_t *sec_ptr,
+ __m256i *sad_acc) {
__m256i s[4], r[4];
int row_sections = 0;
@@ -149,9 +152,10 @@
return get_sad_from_mm256_epi32(&sad);
}
-static void sad64x2(const uint16_t *src_ptr, int src_stride,
- const uint16_t *ref_ptr, int ref_stride,
- const uint16_t *sec_ptr, __m256i *sad_acc) {
+static AOM_FORCE_INLINE void sad64x2(const uint16_t *src_ptr, int src_stride,
+ const uint16_t *ref_ptr, int ref_stride,
+ const uint16_t *sec_ptr,
+ __m256i *sad_acc) {
__m256i s[4], r[4];
int i;
for (i = 0; i < 2; i++) {
@@ -589,8 +593,8 @@
// SAD 4D
// Combine 4 __m256i input vectors v to uint32_t result[4]
-static INLINE void get_4d_sad_from_mm256_epi32(const __m256i *v,
- uint32_t *res) {
+static AOM_FORCE_INLINE void get_4d_sad_from_mm256_epi32(const __m256i *v,
+ uint32_t *res) {
__m256i u0, u1, u2, u3;
const __m256i mask = yy_set1_64_from_32i(UINT32_MAX);
__m128i sad;
@@ -628,7 +632,7 @@
_mm_storeu_si128((__m128i *)res, sad);
}
-static void init_sad(__m256i *s) {
+static AOM_FORCE_INLINE void init_sad(__m256i *s) {
s[0] = _mm256_setzero_si256();
s[1] = _mm256_setzero_si256();
s[2] = _mm256_setzero_si256();
diff --git a/apps/aomdec.c b/apps/aomdec.c
index b9f3981..f8de253 100644
--- a/apps/aomdec.c
+++ b/apps/aomdec.c
@@ -889,6 +889,11 @@
got_data = 0;
while ((img = aom_codec_get_frame(&decoder, &iter))) {
++frame_out;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (frame_in < frame_out) { // No OBUs for show_existing_frame.
+ frame_in = frame_out;
+ }
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
got_data = 1;
if (AOM_CODEC_CONTROL_TYPECHECKED(&decoder, AOMD_GET_FRAME_CORRUPTED,
diff --git a/apps/aomenc.c b/apps/aomenc.c
index a3f88e8..88a8da3 100644
--- a/apps/aomenc.c
+++ b/apps/aomenc.c
@@ -221,6 +221,9 @@
#endif
AV1E_SET_SUBGOP_CONFIG_STR,
AV1E_SET_SUBGOP_CONFIG_PATH,
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION,
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
0 };
const arg_def_t *main_args[] = { &g_av1_codec_arg_defs.help,
@@ -443,16 +446,28 @@
#if CONFIG_BAWP
&g_av1_codec_arg_defs.enable_bawp,
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ &g_av1_codec_arg_defs.enable_cwp,
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ &g_av1_codec_arg_defs.enable_imp_msk_bld,
+#endif // CONFIG_D071_IMP_MSK_BLD
&g_av1_codec_arg_defs.enable_fsc,
#if CONFIG_ORIP
&g_av1_codec_arg_defs.enable_orip,
#endif
+#if CONFIG_IDIF
+ &g_av1_codec_arg_defs.enable_idif,
+#endif // CONFIG_IDIF
&g_av1_codec_arg_defs.enable_ist,
#if CONFIG_CROSS_CHROMA_TX
&g_av1_codec_arg_defs.enable_cctx,
#endif // CONFIG_CROSS_CHROMA_TX
&g_av1_codec_arg_defs.enable_ibp,
&g_av1_codec_arg_defs.explicit_ref_frame_map,
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ &g_av1_codec_arg_defs.enable_frame_output_order,
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
&g_av1_codec_arg_defs.max_drl_refmvs,
#if CONFIG_REF_MV_BANK
&g_av1_codec_arg_defs.enable_refmvbank,
@@ -481,6 +496,9 @@
#if CONFIG_JOINT_MVD
&g_av1_codec_arg_defs.enable_joint_mvd,
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ &g_av1_codec_arg_defs.enable_refinemv,
+#endif // CONFIG_REFINEMV
#if CONFIG_PAR_HIDING
&g_av1_codec_arg_defs.enable_parity_hiding,
#endif // CONFIG_PAR_HIDING
@@ -632,11 +650,7 @@
#if CONFIG_EXT_RECUR_PARTITIONS
config->erp_pruning_level = 5;
config->use_ml_erp_pruning = 0;
-#if CONFIG_H_PARTITION
config->enable_ext_partitions = 1;
-#else
- config->enable_ext_partitions = 0;
-#endif // CONFIG_H_PARTITION
#endif // CONFIG_EXT_RECUR_PARTITIONS
config->enable_sdp = 1;
config->enable_mrls = 1;
@@ -646,10 +660,19 @@
#if CONFIG_BAWP
config->enable_bawp = 1;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ config->enable_cwp = 1;
+#endif // CONFIG_BAWP
+#if CONFIG_D071_IMP_MSK_BLD
+ config->enable_imp_msk_bld = 1;
+#endif // CONFIG_D071_IMP_MSK_BLD
config->enable_fsc = 1;
#if CONFIG_ORIP
config->enable_orip = 1;
#endif
+#if CONFIG_IDIF
+ config->enable_idif = 1;
+#endif // CONFIG_IDIF
config->enable_ist = 1;
#if CONFIG_CROSS_CHROMA_TX
config->enable_cctx = 1;
@@ -667,6 +690,9 @@
#if CONFIG_JOINT_MVD
config->enable_joint_mvd = 1;
#endif
+#if CONFIG_REFINEMV
+ config->enable_refinemv = 1;
+#endif // CONFIG_REFINEMV
config->enable_flip_idtx = 1;
config->enable_deblocking = 1;
config->enable_cdef = 1;
@@ -710,6 +736,9 @@
config->enable_opfl_refine = 1;
#endif // CONFIG_OPTFLOW_REFINEMENT
config->explicit_ref_frame_map = 0;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ config->enable_frame_output_order = 1;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
config->enable_intra_edge_filter = 1;
config->enable_tx64 = 1;
config->enable_smooth_interintra = 1;
@@ -1513,6 +1542,9 @@
#if CONFIG_ORIP
", ORIP(%d)"
#endif // CONFIG_CONFIG_ORIP
+#if CONFIG_IDIF
+ ", IDIF(%d)"
+#endif // CONFIG_IDIF
", IBP(%d)"
"\n",
encoder_cfg->enable_intra_edge_filter,
@@ -1522,8 +1554,18 @@
,
encoder_cfg->enable_orip
#endif // CONFIG_ORIP
+#if CONFIG_IDIF
+ ,
+ encoder_cfg->enable_idif
+#endif // CONFIG_IDIF
,
encoder_cfg->enable_ibp);
+#if CONFIG_ADAPTIVE_DS_FILTER
+ fprintf(
+ stdout,
+ " : Adaptive Down sample filter: (%d)\n",
+ encoder_cfg->enable_cfl_ds_filter);
+#endif // CONFIG_ADAPTIVE_DS_FILTER
fprintf(stdout,
"Tool setting (Inter) : InterIntra (%d), OBMC (%d), "
@@ -1549,6 +1591,15 @@
fprintf(stdout, " : BAWP (%d)\n",
encoder_cfg->enable_bawp);
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ fprintf(stdout, " : CWP (%d)\n",
+ encoder_cfg->enable_cwp);
+#endif // CONFIG_CWP
+
+#if CONFIG_D071_IMP_MSK_BLD
+ fprintf(stdout, " : ImpMskBld (%d)\n",
+ encoder_cfg->enable_imp_msk_bld);
+#endif // CONFIG_D071_IMP_MSK_BLD
fprintf(stdout,
" : GlobalMotion (%d), "
@@ -1570,16 +1621,14 @@
" : Flexible MV precisions: (%d)\n",
encoder_cfg->enable_flex_mvres);
#endif // CONFIG_FLEX_MVRES
-#if CONFIG_ADAPTIVE_DS_FILTER
- fprintf(
- stdout,
- " : Adaptive Down sample filter: (%d)\n",
- encoder_cfg->enable_cfl_ds_filter);
-#endif // CONFIG_ADAPTIVE_DS_FILTER
#if CONFIG_JOINT_MVD
fprintf(stdout, " : Joint MVD coding: (%d)\n",
encoder_cfg->enable_joint_mvd);
#endif
+#if CONFIG_REFINEMV
+ fprintf(stdout, " : RefineMV mode: (%d)\n",
+ encoder_cfg->enable_refinemv);
+#endif // CONFIG_REFINEMV
fprintf(stdout,
" : InterInterWedge (%d), "
"InterIntraWedge (%d), RefFrameMv (%d)\n",
@@ -1926,7 +1975,11 @@
switch (pkt->kind) {
case AOM_CODEC_CX_FRAME_PKT:
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ stream->frames_out += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
++stream->frames_out;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
update_rate_histogram(stream->rate_hist, cfg, pkt);
#if CONFIG_WEBM_IO
if (stream->config.write_webm) {
@@ -2358,7 +2411,11 @@
}
// Keep track of the total number of frames passed to the encoder.
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ unsigned int seen_frames = 0;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
int seen_frames = 0;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
// Does the encoder have queued data that needs retrieval?
int got_data = 0;
// Is there a frame available for processing?
@@ -2425,6 +2482,11 @@
}
}
fflush(stdout);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ FOREACH_STREAM(stream, streams) {
+ if (stream->frames_out < seen_frames) got_data = 1;
+ }
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
if (stream_cnt > 1) fprintf(stderr, "\n");
diff --git a/av1/arg_defs.c b/av1/arg_defs.c
index ca367cb..b34a95b 100644
--- a/av1/arg_defs.c
+++ b/av1/arg_defs.c
@@ -410,6 +410,16 @@
"Enable block adaptive weighted prediction (BAWP)"
"(0: false, 1: true (default))"),
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ .enable_cwp = ARG_DEF(NULL, "enable-cwp", 1,
+ "Enable compound weighted prediction (CWP)"
+ "(0: false, 1: true (default))"),
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ .enable_imp_msk_bld = ARG_DEF(NULL, "enable-imp-msk-bld", 1,
+ "Enable implicit maksed blending"
+ "(0:false), 1:true (default)"),
+#endif // CONFIG_D071_IMP_MSK_BLD
.enable_fsc = ARG_DEF(NULL, "enable-fsc", 1,
"Enable forward skip coding"
"(0: false, 1: true (default))"),
@@ -418,6 +428,11 @@
"Enable Offset Based refinement of intra prediction"
"(0: false, 1: true (default))"),
#endif
+#if CONFIG_IDIF
+ .enable_idif = ARG_DEF(NULL, "enable-idif", 1,
+ "Enable Intra Directional Interpolation Filter"
+ "(0: false, 1: true (default))"),
+#endif // CONFIG_IDIF
.enable_ist = ARG_DEF(NULL, "enable-ist", 1,
"Enable intra secondary transform"
"(0: false, 1: true (default))"),
@@ -452,6 +467,12 @@
"Enable joint MVD coding"
"(0: false, 1: true (default))"),
#endif // CONFIG_JOINT_MVD
+
+#if CONFIG_REFINEMV
+ .enable_refinemv = ARG_DEF(NULL, "enable-refinemv", 1,
+ "Enable RefineMV mode"
+ "(0: false, 1: true (default))"),
+#endif // CONFIG_REFINEMV
.min_partition_size =
ARG_DEF(NULL, "min-partition-size", 1,
"Set min partition size "
@@ -511,7 +532,7 @@
"(0: false, 1: true (default))"),
.enable_global_motion = ARG_DEF(NULL, "enable-global-motion", 1,
"Enable global motion "
- "(0: false, 1: true (default))"),
+ "(0: false (default), 1: true)"),
.enable_warped_motion = ARG_DEF(NULL, "enable-warped-motion", 1,
"Enable local warped motion "
"(0: false, 1: true (default))"),
@@ -679,6 +700,12 @@
ARG_DEF(NULL, "explicit-ref-frame-map", 1,
"Explicitly signal the reference frame mapping (0: off "
"(default), 1: on)"),
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ .enable_frame_output_order =
+ ARG_DEF(NULL, "enable-frame-output-order", 1,
+ "Enable frame output order derivation based on order hint"
+ "(0: off, 1: on (default))"),
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
.target_seq_level_idx = ARG_DEF(
NULL, "target-seq-level-idx", 1,
"Target sequence level index. "
diff --git a/av1/arg_defs.h b/av1/arg_defs.h
index ecc6d6b..0d6389a 100644
--- a/av1/arg_defs.h
+++ b/av1/arg_defs.h
@@ -163,10 +163,19 @@
#if CONFIG_BAWP
arg_def_t enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ arg_def_t enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ arg_def_t enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
arg_def_t enable_fsc;
#if CONFIG_ORIP
arg_def_t enable_orip;
#endif
+#if CONFIG_IDIF
+ arg_def_t enable_idif;
+#endif // CONFIG_IDIF
arg_def_t enable_ist;
#if CONFIG_CROSS_CHROMA_TX
arg_def_t enable_cctx;
@@ -184,6 +193,9 @@
#if CONFIG_JOINT_MVD
arg_def_t enable_joint_mvd;
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ arg_def_t enable_refinemv;
+#endif // CONFIG_REFINEMV
arg_def_t min_partition_size;
arg_def_t max_partition_size;
arg_def_t enable_chroma_deltaq;
@@ -261,6 +273,9 @@
arg_def_t max_reference_frames;
arg_def_t reduced_reference_set;
arg_def_t explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ arg_def_t enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
arg_def_t target_seq_level_idx;
arg_def_t set_min_cr;
arg_def_t input_color_primaries;
diff --git a/av1/av1.cmake b/av1/av1.cmake
index 87796e5..409084b 100644
--- a/av1/av1.cmake
+++ b/av1/av1.cmake
@@ -283,7 +283,11 @@
"${AOM_ROOT}/third_party/vector/vector.c"
"${AOM_ROOT}/third_party/vector/vector.h"
"${AOM_ROOT}/av1/encoder/dwt.c"
- "${AOM_ROOT}/av1/encoder/dwt.h")
+ "${AOM_ROOT}/av1/encoder/dwt.h"
+ "${AOM_ROOT}/common/md5_utils.c"
+ "${AOM_ROOT}/common/md5_utils.h"
+ "${AOM_ROOT}/common/rawenc.c"
+ "${AOM_ROOT}/common/rawenc.h")
if(CONFIG_TUNE_VMAF)
list(APPEND AOM_AV1_ENCODER_SOURCES "${AOM_ROOT}/av1/encoder/tune_vmaf.c"
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index e9a969f..f949c19 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -137,10 +137,19 @@
#if CONFIG_BAWP
int enable_bawp; // enable block adaptive weighted prediction
#endif // CONFIG_BAWP
- int enable_fsc; // enable forward skip coding
+#if CONFIG_CWP
+ int enable_cwp; // enable compound weighted prediction
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ int enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
+ int enable_fsc; // enable forward skip coding
#if CONFIG_ORIP
int enable_orip; // enable ORIP
#endif // CONFIG_ORIP
+#if CONFIG_IDIF
+ int enable_idif; // enable IDIF
+#endif // CONFIG_IDIF
int enable_ist; // enable intra secondary transform
#if CONFIG_CROSS_CHROMA_TX
int enable_cctx; // enable cross-chroma component transform
@@ -159,8 +168,11 @@
#endif // CONFIG_ADAPTIVE_DS_FILTER
#if CONFIG_JOINT_MVD
- int enable_joint_mvd; // enable joint MVD coding
-#endif // CONFIG_ADAPTIVE_MVD
+ int enable_joint_mvd; // enable joint MVD coding
+#endif // CONFIG_ADAPTIVE_MVD
+#if CONFIG_REFINEMV
+ int enable_refinemv; // enable refineMV mode
+#endif // CONFIG_REFINEMV
int min_partition_size; // min partition size [4,8,16,32,64,128]
int max_partition_size; // max partition size [4,8,16,32,64,128]
int enable_intra_edge_filter; // enable intra-edge filter for sequence
@@ -169,18 +181,22 @@
int enable_flip_idtx; // enable flip and identity transform types
int max_reference_frames; // maximum number of references per frame
int enable_reduced_reference_set; // enable reduced set of references
- int explicit_ref_frame_map; // explicitly signal reference frame mapping
- int enable_ref_frame_mvs; // sequence level
- int allow_ref_frame_mvs; // frame level
- int enable_masked_comp; // enable masked compound for sequence
- int enable_onesided_comp; // enable one sided compound for sequence
- int enable_interintra_comp; // enable interintra compound for sequence
- int enable_smooth_interintra; // enable smooth interintra mode usage
- int enable_diff_wtd_comp; // enable diff-wtd compound usage
- int enable_interinter_wedge; // enable interinter-wedge compound usage
- int enable_interintra_wedge; // enable interintra-wedge compound usage
- int enable_global_motion; // enable global motion usage for sequence
- int enable_warped_motion; // enable local warped motion for sequence
+ int explicit_ref_frame_map; // explicitly signal reference frame mapping
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ int enable_frame_output_order; // enable frame output order derivation based
+ // on order hint value
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ int enable_ref_frame_mvs; // sequence level
+ int allow_ref_frame_mvs; // frame level
+ int enable_masked_comp; // enable masked compound for sequence
+ int enable_onesided_comp; // enable one sided compound for sequence
+ int enable_interintra_comp; // enable interintra compound for sequence
+ int enable_smooth_interintra; // enable smooth interintra mode usage
+ int enable_diff_wtd_comp; // enable diff-wtd compound usage
+ int enable_interinter_wedge; // enable interinter-wedge compound usage
+ int enable_interintra_wedge; // enable interintra-wedge compound usage
+ int enable_global_motion; // enable global motion usage for sequence
+ int enable_warped_motion; // enable local warped motion for sequence
#if CONFIG_EXTENDED_WARP_PREDICTION
int enable_warped_causal; // enable spatial warp prediction for sequence
int enable_warp_delta; // enable explicit warp models for sequence
@@ -448,12 +464,8 @@
1, // disable ML based partition speed up features
5, // aggressiveness for erp pruning
0, // use ml model for erp pruning
-#if CONFIG_H_PARTITION
1, // enable extended partitions
#else
- 0, // enable extended partitions
-#endif
-#else
0, // disable ML based partition speed up features
#endif
1, // enable rectangular partitions
@@ -468,10 +480,19 @@
#if CONFIG_BAWP
1, // enable block adaptive weighted prediction (BAWP)
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ 1, // enable compound weighted prediction (CWP)
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ 1, // eanble implicit maksed blending
+#endif // CONFIG_D071_IMP_MSK_BLD
1, // enable forward skip coding
#if CONFIG_ORIP
1, // enable ORIP
#endif // CONFIG_ORIP
+#if CONFIG_IDIF
+ 1, // enable IDIF
+#endif // CONFIG_IDIF
1, // enable intra secondary transform
#if CONFIG_CROSS_CHROMA_TX
1, // enable cross-chroma component transform
@@ -489,6 +510,9 @@
#if CONFIG_JOINT_MVD
1, // enable joint mvd coding
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ 1, // enable refineMV mode
+#endif // CONFIG_REFINEMV
4, // min_partition_size
#if CONFIG_BLOCK_256
256, // max_partition_size
@@ -503,17 +527,20 @@
7, // max_reference_frames
0, // enable_reduced_reference_set
0, // explicit_ref_frame_map
- 1, // enable_ref_frame_mvs sequence level
- 1, // allow ref_frame_mvs frame level
- 1, // enable masked compound at sequence level
- 1, // enable one sided compound at sequence level
- 1, // enable interintra compound at sequence level
- 1, // enable smooth interintra mode
- 1, // enable difference-weighted compound
- 1, // enable interinter wedge compound
- 1, // enable interintra wedge compound
- 1, // enable_global_motion usage
- 1, // enable_warped_motion at sequence level
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ 1, // enable frame output order derivation based on order hint value
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ 1, // enable_ref_frame_mvs sequence level
+ 1, // allow ref_frame_mvs frame level
+ 1, // enable masked compound at sequence level
+ 1, // enable one sided compound at sequence level
+ 1, // enable interintra compound at sequence level
+ 1, // enable smooth interintra mode
+ 1, // enable difference-weighted compound
+ 1, // enable interinter wedge compound
+ 1, // enable interintra wedge compound
+ 0, // enable_global_motion usage
+ 1, // enable_warped_motion at sequence level
#if CONFIG_EXTENDED_WARP_PREDICTION
1, // enable_warped_causal at sequence level
1, // enable_warp_delta at sequence level
@@ -831,6 +858,9 @@
RANGE_CHECK(extra_cfg, max_reference_frames, 3, 7);
RANGE_CHECK(extra_cfg, enable_reduced_reference_set, 0, 1);
RANGE_CHECK(extra_cfg, explicit_ref_frame_map, 0, 1);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ RANGE_CHECK(extra_cfg, enable_frame_output_order, 0, 1);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
RANGE_CHECK_HI(extra_cfg, chroma_subsampling_x, 1);
RANGE_CHECK_HI(extra_cfg, chroma_subsampling_y, 1);
@@ -974,10 +1004,19 @@
#if CONFIG_BAWP
cfg->enable_bawp = extra_cfg->enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ cfg->enable_cwp = extra_cfg->enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ cfg->enable_imp_msk_bld = extra_cfg->enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
cfg->enable_fsc = extra_cfg->enable_fsc;
#if CONFIG_ORIP
cfg->enable_orip = extra_cfg->enable_orip;
#endif
+#if CONFIG_IDIF
+ cfg->enable_idif = extra_cfg->enable_idif;
+#endif // CONFIG_IDIF
cfg->enable_ist = extra_cfg->enable_ist;
#if CONFIG_CROSS_CHROMA_TX
cfg->enable_cctx = extra_cfg->enable_cctx;
@@ -997,6 +1036,9 @@
#if CONFIG_JOINT_MVD
cfg->enable_joint_mvd = extra_cfg->enable_joint_mvd;
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ cfg->enable_refinemv = extra_cfg->enable_refinemv;
+#endif // CONFIG_REFINEMV
cfg->max_partition_size = extra_cfg->max_partition_size;
cfg->min_partition_size = extra_cfg->min_partition_size;
cfg->enable_intra_edge_filter = extra_cfg->enable_intra_edge_filter;
@@ -1029,6 +1071,9 @@
cfg->enable_onesided_comp = extra_cfg->enable_onesided_comp;
cfg->enable_reduced_reference_set = extra_cfg->enable_reduced_reference_set;
cfg->explicit_ref_frame_map = extra_cfg->explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ cfg->enable_frame_output_order = extra_cfg->enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
cfg->reduced_tx_type_set = extra_cfg->reduced_tx_type_set;
cfg->max_drl_refmvs = extra_cfg->max_drl_refmvs;
#if CONFIG_REF_MV_BANK
@@ -1088,10 +1133,19 @@
#if CONFIG_BAWP
extra_cfg->enable_bawp = cfg->enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ extra_cfg->enable_cwp = cfg->enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ extra_cfg->enable_imp_msk_bld = cfg->enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
extra_cfg->enable_fsc = cfg->enable_fsc;
#if CONFIG_ORIP
extra_cfg->enable_orip = cfg->enable_orip;
#endif
+#if CONFIG_IDIF
+ extra_cfg->enable_idif = cfg->enable_idif;
+#endif // CONFIG_IDIF
extra_cfg->enable_ist = cfg->enable_ist;
#if CONFIG_CROSS_CHROMA_TX
extra_cfg->enable_cctx = cfg->enable_cctx;
@@ -1111,6 +1165,10 @@
#if CONFIG_JOINT_MVD
extra_cfg->enable_joint_mvd = cfg->enable_joint_mvd;
#endif // CONFIG_JOINT_MVD
+
+#if CONFIG_REFINEMV
+ extra_cfg->enable_refinemv = cfg->enable_refinemv;
+#endif // CONFIG_REFINEMV
extra_cfg->max_partition_size = cfg->max_partition_size;
extra_cfg->min_partition_size = cfg->min_partition_size;
extra_cfg->enable_intra_edge_filter = cfg->enable_intra_edge_filter;
@@ -1142,6 +1200,9 @@
extra_cfg->enable_onesided_comp = cfg->enable_onesided_comp;
extra_cfg->enable_reduced_reference_set = cfg->enable_reduced_reference_set;
extra_cfg->explicit_ref_frame_map = cfg->explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ extra_cfg->enable_frame_output_order = cfg->enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
extra_cfg->reduced_tx_type_set = cfg->reduced_tx_type_set;
extra_cfg->max_drl_refmvs = cfg->max_drl_refmvs;
#if CONFIG_REF_MV_BANK
@@ -1390,6 +1451,9 @@
#if CONFIG_JOINT_MVD
tool_cfg->enable_joint_mvd = extra_cfg->enable_joint_mvd;
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ tool_cfg->enable_refinemv = extra_cfg->enable_refinemv;
+#endif // CONFIG_REFINEMV
#if CONFIG_TIP
tool_cfg->enable_tip = extra_cfg->enable_tip;
if (tool_cfg->enable_tip) {
@@ -1405,6 +1469,12 @@
#if CONFIG_BAWP
tool_cfg->enable_bawp = extra_cfg->enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ tool_cfg->enable_cwp = extra_cfg->enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ tool_cfg->enable_imp_msk_bld = extra_cfg->enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
tool_cfg->force_video_mode = extra_cfg->force_video_mode;
tool_cfg->enable_palette = extra_cfg->enable_palette;
// FIXME(debargha): Should this be:
@@ -1601,6 +1671,16 @@
extra_cfg->enable_reduced_reference_set;
oxcf->ref_frm_cfg.enable_onesided_comp = extra_cfg->enable_onesided_comp;
oxcf->ref_frm_cfg.explicit_ref_frame_map = extra_cfg->explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // Disable the implicit derivation of frame output order
+ // when order_hint is not available, S-frame is used or error resilience mode
+ // is used.
+ oxcf->ref_frm_cfg.enable_frame_output_order =
+ (!tool_cfg->enable_order_hint || kf_cfg->enable_sframe ||
+ tool_cfg->error_resilient_mode)
+ ? 0
+ : extra_cfg->enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
oxcf->row_mt = extra_cfg->row_mt;
@@ -1662,6 +1742,9 @@
#if CONFIG_ORIP
intra_mode_cfg->enable_orip = extra_cfg->enable_orip;
#endif
+#if CONFIG_IDIF
+ intra_mode_cfg->enable_idif = extra_cfg->enable_idif;
+#endif // CONFIG_IDIF
intra_mode_cfg->enable_ibp = extra_cfg->enable_ibp;
// Set transform size/type configuration.
@@ -1673,7 +1756,7 @@
txfm_cfg->use_intra_default_tx_only = extra_cfg->use_intra_default_tx_only;
txfm_cfg->disable_ml_transform_speed_features =
extra_cfg->disable_ml_transform_speed_features;
- txfm_cfg->enable_ist = extra_cfg->enable_ist;
+ txfm_cfg->enable_ist = extra_cfg->enable_ist && !extra_cfg->lossless;
#if CONFIG_CROSS_CHROMA_TX
txfm_cfg->enable_cctx =
tool_cfg->enable_monochrome ? 0 : extra_cfg->enable_cctx;
@@ -2666,6 +2749,15 @@
return AOM_CODEC_OK;
}
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+static aom_codec_err_t ctrl_set_frame_output_order(aom_codec_alg_priv_t *ctx,
+ va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.enable_frame_output_order =
+ CAST(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
static aom_codec_err_t create_stats_buffer(FIRSTPASS_STATS **frame_stats_buffer,
STATS_BUFFER_CTX *stats_buf_context,
int num_lap_buffers) {
@@ -3205,7 +3297,20 @@
index_size = MAG_SIZE * (ctx->pending_frame_count - 1) + 2;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (cpi->oxcf.ref_frm_cfg.enable_frame_output_order) {
+ if (cpi->common.current_frame.frame_type == KEY_FRAME ||
+ !cpi->common.show_existing_frame) {
+ is_frame_visible = cpi->common.show_frame;
+ } else {
+ is_frame_visible = 0;
+ }
+ } else {
+ is_frame_visible = cpi->common.show_frame;
+ }
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
is_frame_visible = cpi->common.show_frame;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
has_no_show_keyframe |=
(!is_frame_visible &&
@@ -3215,6 +3320,13 @@
report_stats(cpi, frame_size, cx_time);
}
}
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (cpi->oxcf.ref_frm_cfg.enable_frame_output_order &&
+ cpi->common.show_frame && cpi->common.show_existing_frame) {
+ cpi->frames_left = AOMMAX(0, cpi->frames_left - 1);
+ break;
+ }
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
if (is_frame_visible) {
// Add the frame packet to the list of returned packets.
@@ -3244,6 +3356,9 @@
pkt.data.frame.sz = ctx->pending_cx_data_sz;
pkt.data.frame.partition_id = -1;
pkt.data.frame.vis_frame_size = frame_size;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ pkt.data.frame.frame_count = ctx->pending_frame_count;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
pkt.data.frame.pts =
ticks_to_timebase_units(timestamp_ratio, dst_time_stamp) +
@@ -3818,6 +3933,16 @@
err_string)) {
extra_cfg.enable_bawp = arg_parse_int_helper(&arg, err_string);
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_cwp, argv,
+ err_string)) {
+ extra_cfg.enable_cwp = arg_parse_int_helper(&arg, err_string);
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_imp_msk_bld,
+ argv, err_string)) {
+ extra_cfg.enable_imp_msk_bld = arg_parse_uint_helper(&arg, err_string);
+#endif // CONFIG_D071_IMP_MSK_BLD
} else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_fsc, argv,
err_string)) {
extra_cfg.enable_fsc = arg_parse_int_helper(&arg, err_string);
@@ -3826,6 +3951,11 @@
err_string)) {
extra_cfg.enable_orip = arg_parse_int_helper(&arg, err_string);
#endif
+#if CONFIG_IDIF
+ } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_idif, argv,
+ err_string)) {
+ extra_cfg.enable_idif = arg_parse_int_helper(&arg, err_string);
+#endif // CONFIG_IDIF
} else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_ist, argv,
err_string)) {
extra_cfg.enable_ist = arg_parse_int_helper(&arg, err_string);
@@ -3857,6 +3987,12 @@
argv, err_string)) {
extra_cfg.enable_joint_mvd = arg_parse_int_helper(&arg, err_string);
#endif // CONFIG_JOINT_MVD
+
+#if CONFIG_REFINEMV
+ } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_refinemv, argv,
+ err_string)) {
+ extra_cfg.enable_refinemv = arg_parse_int_helper(&arg, err_string);
+#endif // CONFIG_REFINEMV
} else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.min_partition_size,
argv, err_string)) {
extra_cfg.min_partition_size = arg_parse_int_helper(&arg, err_string);
@@ -3888,6 +4024,13 @@
&g_av1_codec_arg_defs.explicit_ref_frame_map,
argv, err_string)) {
extra_cfg.explicit_ref_frame_map = arg_parse_int_helper(&arg, err_string);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ } else if (arg_match_helper(&arg,
+ &g_av1_codec_arg_defs.enable_frame_output_order,
+ argv, err_string)) {
+ extra_cfg.enable_frame_output_order =
+ arg_parse_int_helper(&arg, err_string);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
} else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_ref_frame_mvs,
argv, err_string)) {
extra_cfg.enable_ref_frame_mvs = arg_parse_int_helper(&arg, err_string);
@@ -4198,6 +4341,9 @@
{ AV1E_SET_VBR_CORPUS_COMPLEXITY_LAP, ctrl_set_vbr_corpus_complexity_lap },
{ AV1E_ENABLE_SB_MULTIPASS_UNIT_TEST, ctrl_enable_sb_multipass_unit_test },
{ AV1E_ENABLE_SUBGOP_STATS, ctrl_enable_subgop_stats },
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ { AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, ctrl_set_frame_output_order },
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
// Getters
{ AOME_GET_LAST_QUANTIZER, ctrl_get_quantizer },
@@ -4288,14 +4434,10 @@
1,
5, // aggressiveness for erp pruning
0, // use ml model for erp pruning
-#if CONFIG_H_PARTITION
1, // enable extended partitions
-#else
- 0, // enable extended partitions
-#endif
-#else // CONFIG_EXT_RECUR_PARTITIONS
+#else // CONFIG_EXT_RECUR_PARTITIONS
0,
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+#endif // CONFIG_EXT_RECUR_PARTITIONS
0, 1, 1,
#if CONFIG_TIP
1,
@@ -4303,10 +4445,19 @@
#if CONFIG_BAWP
1,
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ 1,
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ 1,
+#endif // CONFIG_D071_IMP_MSK_BLD
1,
#if CONFIG_ORIP
1,
#endif
+#if CONFIG_IDIF
+ 1,
+#endif // CONFIG_IDIF
1, // IST
#if CONFIG_CROSS_CHROMA_TX
1,
@@ -4324,6 +4475,9 @@
#if CONFIG_JOINT_MVD
1,
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ 1,
+#endif // CONFIG_REFINEMV
1, 1, 1, 1, 1, 1,
#if CONFIG_PC_WIENER
1,
@@ -4349,7 +4503,11 @@
#if CONFIG_OPTFLOW_REFINEMENT
1,
#endif // CONFIG_OPTFLOW_REFINEMENT
- 1, 1, 1, 1, 1, 1, 3, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 3, 1, 1, 0,
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ 1,
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ 0, 0,
#if CONFIG_REF_MV_BANK
1,
#endif // CONFIG_REF_MV_BANK
diff --git a/av1/av1_dx_iface.c b/av1/av1_dx_iface.c
index 0609e84..c5f1323 100644
--- a/av1/av1_dx_iface.c
+++ b/av1/av1_dx_iface.c
@@ -76,6 +76,7 @@
unsigned int enable_subgop_stats;
#if CONFIG_INSPECTION
aom_inspect_cb inspect_cb;
+ aom_inspect_cb inspect_sb_cb;
void *inspect_ctx;
#endif
};
@@ -566,6 +567,7 @@
AV1Decoder *const pbi = frame_worker_data->pbi;
AV1_COMMON *const cm = &pbi->common;
frame_worker_data->pbi->inspect_cb = ctx->inspect_cb;
+ frame_worker_data->pbi->inspect_sb_cb = ctx->inspect_sb_cb;
frame_worker_data->pbi->inspect_ctx = ctx->inspect_ctx;
res = av1_receive_compressed_data(frame_worker_data->pbi, data_sz, &data);
check_resync(ctx, frame_worker_data->pbi);
@@ -610,9 +612,21 @@
struct AV1Decoder *pbi = frame_worker_data->pbi;
if (ctx->enable_subgop_stats)
memset(&pbi->subgop_stats, 0, sizeof(pbi->subgop_stats));
- for (size_t j = 0; j < pbi->num_output_frames; j++) {
- decrease_ref_count(pbi->output_frames[j], pool);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // When multiple layers are enabled, use the mechanism of
+ // show_existing_frame
+ if (pbi->common.seq_params.order_hint_info.enable_order_hint &&
+ pbi->common.seq_params.enable_frame_output_order) {
+ if (!pbi->common.show_existing_frame)
+ decrease_ref_count(pbi->output_frames[0], pool);
+ } else {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ for (size_t j = 0; j < pbi->num_output_frames; j++) {
+ decrease_ref_count(pbi->output_frames[j], pool);
+ }
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
pbi->num_output_frames = 0;
unlock_buffer_pool(pool);
for (size_t j = 0; j < ctx->num_grain_image_frame_buffers; j++) {
@@ -1590,6 +1604,7 @@
#else
aom_inspect_init *init = va_arg(args, aom_inspect_init *);
ctx->inspect_cb = init->inspect_cb;
+ ctx->inspect_sb_cb = init->inspect_sb_cb;
ctx->inspect_ctx = init->inspect_ctx;
return AOM_CODEC_OK;
#endif
diff --git a/av1/common/alloccommon.c b/av1/common/alloccommon.c
index 1716e87..4256369 100644
--- a/av1/common/alloccommon.c
+++ b/av1/common/alloccommon.c
@@ -129,6 +129,9 @@
}
aom_free_frame_buffer(&cm->rst_frame);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ aom_free_frame_buffer(&cm->pre_rst_frame);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
void av1_free_above_context_buffers(CommonContexts *above_contexts) {
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index 5cd51ec..978e300 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -257,6 +257,12 @@
// Frame's level within the hierarchical structure
unsigned int pyramid_level;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // How many ref frames did this frame use?
+ // This is set to 0 for intra frames
+ int num_ref_frames;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
MV_REF *mvs;
uint8_t *seg_map;
struct segmentation seg;
@@ -410,7 +416,11 @@
int mib_size; // Size of the superblock in units of MI blocks
int mib_size_log2; // Log 2 of above.
int explicit_ref_frame_map; // Explicitly signal the reference frame mapping
- int max_reference_frames; // Number of reference frames allowed
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ int enable_frame_output_order; // Enable frame output order derivation based
+ // on order hint value
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ int max_reference_frames; // Number of reference frames allowed
#if CONFIG_ALLOW_SAME_REF_COMPOUND
int num_same_ref_compound; // Number of the allowed same reference frames for
// the compound mode
@@ -435,13 +445,23 @@
#if CONFIG_BAWP
uint8_t enable_bawp; // enables/disables block adaptive weighted prediction
#endif // CONFIG_BAWP
- uint8_t enable_fsc; // enables/disables forward skip coding
+#if CONFIG_CWP
+ uint8_t enable_cwp; // enables/disables compound weighted prediction
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ uint8_t enable_imp_msk_bld; // enable implicit maksed blending
+#endif // CONFIG_D071_IMP_MSK_BLD
+ uint8_t enable_fsc; // enables/disables forward skip coding
uint8_t enable_filter_intra; // enables/disables filterintra
uint8_t enable_intra_edge_filter; // enables/disables edge upsampling
#if CONFIG_ORIP
uint8_t enable_orip; // To turn on/off sub-block based ORIP
#endif
+#if CONFIG_IDIF
+ uint8_t
+ enable_idif; // enables/disables Intra Directional Interpolation Filter
+#endif // CONFIG_IDIF
uint8_t enable_ist; // enables/disables intra secondary transform
#if CONFIG_CROSS_CHROMA_TX
uint8_t enable_cctx; // enables/disables cross-chroma component transform
@@ -462,6 +482,10 @@
uint8_t enable_joint_mvd; // enables/disables joint MVD coding
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ uint8_t enable_refinemv; // enables/disables refineMV mode
+#endif // CONFIG_REFINEMV
+
#if CONFIG_EXTENDED_WARP_PREDICTION
int seq_enabled_motion_modes; // Bit mask of enabled motion modes for
// sequence
@@ -509,6 +533,9 @@
#if CONFIG_EXT_RECUR_PARTITIONS
uint8_t enable_ext_partitions; // enable extended partitions
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ bool enable_global_motion;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
BITSTREAM_PROFILE profile;
// Color config.
@@ -604,12 +631,7 @@
*/
bool use_pb_mv_precision;
#endif // CONFIG_FLEX_MVRES
-#if DS_FRAME_LEVEL
- /*!
- * Dowsample filter type
- */
- int ds_filter_type;
-#endif // DS_FRAME_LEVEl
+
/*!
* If true, palette tool and/or intra block copy tools may be used.
*/
@@ -624,6 +646,9 @@
#if !CONFIG_EXTENDED_WARP_PREDICTION
bool allow_warped_motion; /*!< If true, frame may use warped motion mode. */
#endif
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ bool allow_warpmv_mode; /*!< If true, frame may use WARPMV mode. */
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
/*!
* If true, using previous frames' motion vectors for prediction is allowed.
*/
@@ -715,6 +740,18 @@
*/
bool enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ /*!
+ * Enables/disables compound weighted prediction
+ */
+ bool enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ /*!
+ * Enables/disables implicit masked blending.
+ */
+ bool enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
#if CONFIG_EXTENDED_WARP_PREDICTION
/*!
* Bit mask of enabled motion modes for this frame
@@ -1537,6 +1574,11 @@
int32_t *rst_tmpbuf; /*!< Scratch buffer for self-guided restoration */
RestorationLineBuffers *rlbs; /*!< Line buffers needed by loop restoration */
YV12_BUFFER_CONFIG rst_frame; /*!< Stores the output of loop restoration */
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ YV12_BUFFER_CONFIG pre_rst_frame; /*!< Stores the reconstructed frame before
+ loop restoration, only used by encoder,
+ to be moved to encoder buffer */
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
/**@}*/
/*!
@@ -1561,6 +1603,18 @@
*/
DeltaQInfo delta_q_info;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ /*!
+ * Base model used for delta-coding global motion parameters
+ */
+ WarpedMotionParams base_global_motion_model;
+
+ /*!
+ * Temporal length of `base_global_motion_model`
+ */
+ int base_global_motion_distance;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
/*!
* Global motion parameters for each reference frame.
*/
@@ -1632,12 +1686,12 @@
* TODO(jingning): This can be combined with sign_bias later.
*/
int8_t ref_frame_side[INTER_REFS_PER_FRAME];
-#if CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
/*!
* relative distance between reference 'k' and current frame.
*/
- int8_t ref_frame_relative_dist[REF_FRAMES];
-#endif // CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+ int ref_frame_relative_dist[REF_FRAMES];
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
/*!
* Number of temporal layers: may be > 1 for SVC (scalable vector coding).
*/
@@ -1733,6 +1787,11 @@
* Log2 of the size of the superblock in units of MI.
*/
int mib_size_log2;
+
+#if CONFIG_INSPECTION
+ YV12_BUFFER_CONFIG predicted_pixels;
+ YV12_BUFFER_CONFIG prefiltered_pixels;
+#endif // CONFIG_INSPECTION
} AV1_COMMON;
/*!\cond */
@@ -2136,6 +2195,10 @@
xd->mi_col = mi_col;
xd->mi[0]->mi_row_start = mi_row;
xd->mi[0]->mi_col_start = mi_col;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ xd->mi[0]->chroma_mi_row_start = mi_row;
+ xd->mi[0]->chroma_mi_col_start = mi_col;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXTENDED_WARP_PREDICTION
xd->tile.mi_col_start = tile->mi_col_start;
@@ -2225,7 +2288,7 @@
if (xd->width > xd->height)
if (!(mi_row & (xd->width - 1))) xd->is_first_horizontal_rect = 1;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
xd->is_last_horizontal_rect = 0;
if (xd->width > xd->height) {
if (!((mi_row + xd->height) & (xd->width - 1))) {
@@ -2236,10 +2299,29 @@
xd->is_first_vertical_rect = 0;
if (xd->width < xd->height)
if (!(mi_col & (xd->height - 1))) xd->is_first_vertical_rect = 1;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#endif // !CONFIG_EXT_RECUR_PARTITIONS
}
+#if CONFIG_ATC_DCTX_ALIGNED
+// Return the inter TX context based on last position value.
+static INLINE int get_lp2tx_ctx(TX_SIZE tx_size, int bwl, int eob) {
+ assert(eob != 0);
+ const int lim = 2;
+ const int eoby = (eob - 1) >> bwl;
+ const int eobx = (eob - 1) - (eoby << bwl);
+ const int diag = eobx + eoby;
+ const int max_diag = tx_size_wide[tx_size] + tx_size_high[tx_size] - 2;
+ int ctx_idx = 0;
+ if (diag < lim) {
+ ctx_idx = 1;
+ } else if (diag > (max_diag - lim)) {
+ ctx_idx = 2;
+ }
+ return ctx_idx;
+}
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
static INLINE int get_fsc_mode_ctx(const MACROBLOCKD *xd, const int is_key) {
int ctx = 0;
if (is_key) {
@@ -2281,6 +2363,19 @@
}
#endif // !CONFIG_AIMC
+#if CONFIG_EXT_DIR
+static INLINE int get_mrl_index_ctx(const MB_MODE_INFO *neighbor0,
+ const MB_MODE_INFO *neighbor1) {
+ int ctx0 = neighbor0 && !is_inter_block(neighbor0, SHARED_PART) &&
+ !is_intrabc_block(neighbor0, SHARED_PART) &&
+ neighbor0->mrl_index != 0;
+ int ctx1 = neighbor1 && !is_inter_block(neighbor1, SHARED_PART) &&
+ !is_intrabc_block(neighbor1, SHARED_PART) &&
+ neighbor1->mrl_index != 0;
+ return ctx0 + ctx1;
+}
+#endif // CONFIG_EXT_DIR
+
static INLINE void update_partition_context(MACROBLOCKD *xd, int mi_row,
int mi_col, BLOCK_SIZE subsize,
BLOCK_SIZE bsize) {
@@ -2708,8 +2803,9 @@
if (subsize < BLOCK_SIZES_ALL) {
CHROMA_REF_INFO tmp_chroma_ref_info = { 1, 0, mi_row,
mi_col, subsize, subsize };
- set_chroma_ref_info(mi_row, mi_col, 0, subsize, &tmp_chroma_ref_info,
- parent_chroma_ref_info, bsize, partition, ss_x, ss_y);
+ set_chroma_ref_info(tree_type, mi_row, mi_col, 0, subsize,
+ &tmp_chroma_ref_info, parent_chroma_ref_info, bsize,
+ partition, ss_x, ss_y);
is_valid = get_plane_block_size(tmp_chroma_ref_info.bsize_base, ss_x,
ss_y) != BLOCK_INVALID;
}
@@ -2806,6 +2902,38 @@
return is_implied;
}
+static AOM_INLINE PARTITION_TYPE av1_get_normative_forced_partition_type(
+ const CommonModeInfoParams *const mi_params, TREE_TYPE tree_type, int ss_x,
+ int ss_y, int mi_row, int mi_col, BLOCK_SIZE bsize,
+ const PARTITION_TREE *ptree_luma, const CHROMA_REF_INFO *chroma_ref_info) {
+ // Return NONE if this block size is not splittable
+ if (!is_partition_point(bsize)) {
+ return PARTITION_NONE;
+ }
+
+ // Special case where 8x8 chroma blocks are not splittable.
+ // TODO(chiyotsai@google.com): This should be moved into `is_partition_point`,
+ // but this will require too many lines of change to do right now.
+ if (tree_type == CHROMA_PART && bsize == BLOCK_8X8) {
+ return PARTITION_NONE;
+ }
+
+ // Partitions forced by SDP
+ if (is_luma_chroma_share_same_partition(tree_type, ptree_luma, bsize)) {
+ assert(ptree_luma);
+ return sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ss_x, ss_y);
+ }
+
+ // Partitions forced by boundary
+ PARTITION_TYPE implied_partition;
+ const bool is_part_implied = is_partition_implied_at_boundary(
+ mi_params, tree_type, ss_x, ss_y, mi_row, mi_col, bsize, chroma_ref_info,
+ &implied_partition);
+ if (is_part_implied) return implied_partition;
+
+ // No forced partitions
+ return PARTITION_INVALID;
+}
#else
// Return the number of sub-blocks whose width and height are
// less than half of the parent block.
@@ -3101,11 +3229,13 @@
// PARTITION_HORZ_B. To distinguish the latter two, check if the lower
// half was split.
if (sshigh * 4 == bhigh) {
-#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_UNEVEN_4WAY
+ return PARTITION_HORZ_4A;
+#elif CONFIG_EXT_RECUR_PARTITIONS
return PARTITION_HORZ_3;
-#else // CONFIG_EXT_RECUR_PARTITIONS
+#else // !CONFIG_UNEVEN_4WAY && !CONFIG_EXT_RECUR_PARTITIONS
return PARTITION_HORZ_4;
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+#endif // CONFIG_UNEVEN_4WAY
}
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(sshigh * 2 == bhigh);
@@ -3120,11 +3250,13 @@
// PARTITION_VERT_B. To distinguish the latter two, check if the right
// half was split.
if (sswide * 4 == bwide) {
-#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_UNEVEN_4WAY
+ return PARTITION_VERT_4A;
+#elif CONFIG_EXT_RECUR_PARTITIONS
return PARTITION_VERT_3;
-#else // CONFIG_EXT_RECUR_PARTITIONS
+#else // !CONFIG_UNEVEN_4WAY && !CONFIG_EXT_RECUR_PARTITIONS
return PARTITION_VERT_4;
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+#endif // CONFIG_UNEVEN_4WAY
}
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(sswide * 2 == bhigh);
@@ -3279,8 +3411,73 @@
seq_level_idx != SEQ_LEVEL_7_2 && seq_level_idx != SEQ_LEVEL_7_3);
}
-// Intra derivative for second directional predictor of IBP
+// Intra derivative for directional predictions.
// second_dr_intra_derivative[x] = 64*64/dr_intra_derivative[x]
+#if CONFIG_EXT_DIR
+static const int16_t dr_intra_derivative[90] = {
+ // Angle in degrees.
+ // Starred (*) values are unused.
+ 0, 4096, 2048, // *, 0.9, 1.8,
+ 1365, 1024, 819, // 2.7, 3.6, 4.5,
+ 682, 585, 512, // 5.4, 6.2, 7.1,
+ 455, 409, 409, 409, 372, // 8.0, 8.9, *, *, 9.8,
+ 341, 292, 273, // 10.6, 12.4, 13.2,
+ 256, 227, 215, // 14.0, 15.7, 16.6,
+ 204, 186, 178, // 17.4, 19.0, 19.8,
+ 170, 157, 151, // 20.6, 22.2, 23.0,
+ 146, 136, 132, // 23.7, 25.2, 25.9,
+ 128, 117, 110, // 26.6, 28.7, 30.2,
+ 107, 99, 97, 97, // 30.9, 32.9, *, 33.4,
+ 93, 87, 83, // 34.5, 36.3, 37.6,
+ 81, 77, 74, // 38.3, 39.7, 40.9,
+ 73, 69, 66, // 41.2, 42.8, 44.1,
+ 64, 62, 59, // 45.0, 45.9, 47.3,
+ 56, 55, 53, // 48.8, 49.3, 50.4,
+ 50, 49, 47, // 52.0, 52.6, 53.7,
+ 44, 42, 42, 41, // 55.5, 56.7, *, 57.4,
+ 38, 37, 35, // 59.3, 60.0, 61.3,
+ 32, 31, 30, // 63.4, 64.2, 64.9,
+ 28, 27, 26, // 66.4, 67.1, 67.9,
+ 24, 23, 22, // 69.4, 70.2, 71.0,
+ 20, 19, 18, // 72.6, 73.5, 74.3,
+ 16, 15, 14, // 76.0, 76.8, 77.7,
+ 12, 11, 10, 10, 10, // 79.4, 80.2, *, *, 81.1,
+ 9, 8, 7, // 82.0, 82.9, 83.8,
+ 6, 5, 4, // 84.6, 85.5, 86.4,
+ 3, 2, 1, // 87.3, 88.2, 89.1,
+};
+#elif CONFIG_IMPROVED_ANGULAR_INTRA
+static const int16_t second_dr_intra_derivative[90] = {
+ 0, 0, 0, //
+ 2, 0, 0, // 3, ...
+ 4, 0, 0, // 6, ...
+ 8, 0, 0, 0, 0, // 9, ...
+ 12, 0, 0, // 14, ...
+ 16, 0, 0, // 17, ...
+ 20, 0, 0, // 20, ...
+ 24, 0, 0, // 23, ... (113 & 203 are base angles)
+ 28, 0, 0, // 26, ...
+ 32, 0, 0, // 29, ...
+ 38, 0, 0, 0, // 32, ...
+ 44, 0, 0, // 36, ...
+ 50, 0, 0, // 39, ...
+ 56, 0, 0, // 42, ...
+ 64, 0, 0, // 45, ... (45 & 135 are base angles)
+ 72, 0, 0, // 48, ...
+ 82, 0, 0, // 51, ...
+ 92, 0, 0, 0, // 54, ...
+ 106, 0, 0, // 58, ...
+ 128, 0, 0, // 61, ...
+ 146, 0, 0, // 64, ...
+ 170, 0, 0, // 67, ... (67 & 157 are base angles)
+ 204, 0, 0, // 70, ...
+ 256, 0, 0, // 73, ...
+ 340, 0, 0, 0, 0, // 76, ...
+ 512, 0, 0, // 81, ...
+ 1024, 0, 0, // 84, ...
+ 2048, 0, 0, // 87, ...
+};
+#else
static const int16_t second_dr_intra_derivative[90] = {
0, 0, 0, //
4, 0, 0, // 3, ...
@@ -3311,6 +3508,7 @@
585, 0, 0, // 84, ...
1365, 0, 0, // 87, ...
};
+#endif // CONFIG_EXT_DIR
// Generate the weights per pixel position for IBP
static void av1_dr_prediction_z1_info(uint8_t *weights, int bw, int bh,
@@ -3393,7 +3591,11 @@
int delta, int txw, int txh, int txw_log2, int txh_log2) {
const int angle = mode_to_angle_map[mode] + delta * 3;
const int mode_idx = angle_to_mode_index[angle];
+#if CONFIG_EXT_DIR
+ const int dy = dr_intra_derivative[90 - angle];
+#else
const int dy = second_dr_intra_derivative[angle];
+#endif // CONFIG_EXT_DIR
weights[block_idx][mode_idx] =
(uint8_t *)(aom_malloc(txw * txh * sizeof(uint8_t)));
av1_dr_prediction_z1_info(weights[block_idx][mode_idx], txw, txh, txw_log2,
@@ -3410,7 +3612,11 @@
const int txh = tx_size_high[iblock];
const int txw_log2 = tx_size_wide_log2[iblock];
const int txh_log2 = tx_size_high_log2[iblock];
+#if CONFIG_IMPROVED_ANGULAR_INTRA
+ for (int delta = -2; delta < 0; delta += 2) {
+#else
for (int delta = -3; delta < 0; delta++) {
+#endif // CONFIG_IMPROVED_ANGULAR_INTRA
init_ibp_info_per_mode(weights, iblock, V_PRED, delta, txw, txh, txw_log2,
txh_log2);
init_ibp_info_per_mode(weights, iblock, D67_PRED, delta, txw, txh,
@@ -3418,7 +3624,11 @@
init_ibp_info_per_mode(weights, iblock, D45_PRED, delta, txw, txh,
txw_log2, txh_log2);
}
+#if CONFIG_IMPROVED_ANGULAR_INTRA
+ for (int delta = 0; delta <= 2; delta += 2) {
+#else
for (int delta = 0; delta <= 3; delta++) {
+#endif // CONFIG_IMPROVED_ANGULAR_INTRA
init_ibp_info_per_mode(weights, iblock, D67_PRED, delta, txw, txh,
txw_log2, txh_log2);
init_ibp_info_per_mode(weights, iblock, D45_PRED, delta, txw, txh,
diff --git a/av1/common/av1_rtcd_defs.pl b/av1/common/av1_rtcd_defs.pl
index 4d53661..e0efb4e 100644
--- a/av1/common/av1_rtcd_defs.pl
+++ b/av1/common/av1_rtcd_defs.pl
@@ -229,6 +229,15 @@
add_proto qw/void av1_highbd_dr_prediction_z3/, "uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above, const uint16_t *left, int upsample_left, int dx, int dy, int bd, int mrl_index";
specialize qw/av1_highbd_dr_prediction_z3 avx2/;
+if (aom_config("CONFIG_IDIF") eq "yes") {
+ add_proto qw/void av1_highbd_dr_prediction_z1_idif/ , "uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above, const uint16_t *left, int dx, int dy, int bd, int mrl_index";
+ specialize qw/av1_highbd_dr_prediction_z1_idif avx2/;
+ add_proto qw/void av1_highbd_dr_prediction_z2_idif/ , "uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above, const uint16_t *left, int dx, int dy, int bd, int mrl_index";
+ specialize qw/av1_highbd_dr_prediction_z2_idif avx2/;
+ add_proto qw/void av1_highbd_dr_prediction_z3_idif/ , "uint16_t *dst, ptrdiff_t stride, int bw, int bh, const uint16_t *above, const uint16_t *left, int dx, int dy, int bd, int mrl_index";
+ specialize qw/av1_highbd_dr_prediction_z3_idif avx2/
+}
+
add_proto qw / void av1_highbd_ibp_dr_prediction_z1 /,
"uint8_t* weights, uint16_t *dst, ptrdiff_t stride, uint16_t* second_pred, ptrdiff_t second_stride, int bw, int bh";
add_proto qw / void av1_highbd_ibp_dr_prediction_z3 /,
@@ -334,10 +343,14 @@
# txb
add_proto qw/void av1_txb_init_levels_skip/, "const tran_low_t *const coeff, const int width, const int height, uint8_t *const levels";
specialize qw/av1_txb_init_levels_skip sse4_1 avx2/;
- add_proto qw/void av1_get_nz_map_contexts_skip/, "const uint8_t *const levels, const int16_t *const scan, const uint16_t eob, const TX_SIZE tx_size, int8_t *const coeff_contexts";
- specialize qw/av1_get_nz_map_contexts_skip sse2/;
+ if (aom_config("CONFIG_ATC_DCTX_ALIGNED") eq "yes") {
+ add_proto qw/void av1_get_nz_map_contexts_skip/, "const uint8_t *const levels, const int16_t *const scan, const uint16_t bob, const uint16_t eob, const TX_SIZE tx_size, int8_t *const coeff_contexts";
+ } else {
+ add_proto qw/void av1_get_nz_map_contexts_skip/, "const uint8_t *const levels, const int16_t *const scan, const uint16_t eob, const TX_SIZE tx_size, int8_t *const coeff_contexts";
+ specialize qw/av1_get_nz_map_contexts_skip sse2/;
+ }
- if (aom_config("CONFIG_ATC_COEFCODING") eq "yes") {
+ if (aom_config("CONFIG_ATC") eq "yes") {
add_proto qw/void av1_get_nz_map_contexts/, "const uint8_t *const levels, const int16_t *const scan, const uint16_t eob, const TX_SIZE tx_size, const TX_CLASS tx_class, int8_t *const coeff_contexts, const int plane";
} else {
add_proto qw/void av1_get_nz_map_contexts/, "const uint8_t *const levels, const int16_t *const scan, const uint16_t eob, const TX_SIZE tx_size, const TX_CLASS tx_class, int8_t *const coeff_contexts";
diff --git a/av1/common/blockd.c b/av1/common/blockd.c
index c629834..26c05fd 100644
--- a/av1/common/blockd.c
+++ b/av1/common/blockd.c
@@ -203,18 +203,27 @@
#endif // CONFIG_WIENER_NONSEP
) {
for (int p = plane_start; p < plane_end; ++p) {
- av1_reset_wiener_bank(&xd->wiener_info[p]);
+ av1_reset_wiener_bank(&xd->wiener_info[p], p != AOM_PLANE_Y);
av1_reset_sgrproj_bank(&xd->sgrproj_info[p]);
#if CONFIG_WIENER_NONSEP
av1_reset_wienerns_bank(&xd->wienerns_info[p], xd->current_base_qindex,
- num_filter_classes[p], p != AOM_PLANE_Y);
+ num_filter_classes[p], p != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ 0
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ av1_reset_wienerns_bank(&xd->wienerns_cross_info[p],
+ xd->current_base_qindex, 1, p != AOM_PLANE_Y, 1);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#endif // CONFIG_WIENER_NONSEP
}
}
// Initialize bank
-void av1_reset_wiener_bank(WienerInfoBank *bank) {
- set_default_wiener(&bank->filter[0]);
+void av1_reset_wiener_bank(WienerInfoBank *bank, int chroma) {
+ set_default_wiener(&bank->filter[0], chroma);
bank->bank_size = 0;
bank->bank_ptr = 0;
}
@@ -262,19 +271,6 @@
memcpy(av1_ref_from_wiener_bank(bank, ndx), info, sizeof(*info));
}
-// Convenience function to fill the provided info structure with
-// filter at given index
-void av1_get_from_wiener_bank(WienerInfoBank *bank, int ndx, WienerInfo *info) {
- if (bank->bank_size == 0) {
- set_default_wiener(info);
- } else {
- assert(ndx < bank->bank_size);
- const int ptr =
- bank->bank_ptr - ndx + (bank->bank_ptr < ndx ? LR_BANK_SIZE : 0);
- memcpy(info, &bank->filter[ptr], sizeof(*info));
- }
-}
-
// Initialize bank
void av1_reset_sgrproj_bank(SgrprojInfoBank *bank) {
set_default_sgrproj(&bank->filter[0]);
@@ -325,29 +321,25 @@
memcpy(av1_ref_from_sgrproj_bank(bank, ndx), info, sizeof(*info));
}
-// Convenience function to fill the provided info structure with
-// filter at given index
-void av1_get_from_sgrproj_bank(SgrprojInfoBank *bank, int ndx,
- SgrprojInfo *info) {
- if (bank->bank_size == 0) {
- set_default_sgrproj(info);
- } else {
- assert(ndx < bank->bank_size);
- const int ptr =
- bank->bank_ptr - ndx + (bank->bank_ptr < ndx ? LR_BANK_SIZE : 0);
- memcpy(info, &bank->filter[ptr], sizeof(*info));
- }
-}
-
#if CONFIG_WIENER_NONSEP
// Initialize bank
void av1_reset_wienerns_bank(WienerNonsepInfoBank *bank, int qindex,
- int num_classes, int chroma) {
+ int num_classes, int chroma
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ int is_cross
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+) {
for (int i = 0; i < LR_BANK_SIZE; ++i) {
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ set_default_wienerns(&bank->filter[i], qindex, num_classes, chroma,
+ is_cross);
+#else
set_default_wienerns(&bank->filter[i], qindex, num_classes, chroma);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
for (int c_id = 0; c_id < num_classes; ++c_id) {
- bank->bank_size_for_class[c_id] = 1;
+ bank->bank_size_for_class[c_id] = 0;
bank->bank_ptr_for_class[c_id] = 0;
}
}
@@ -379,26 +371,30 @@
WienerNonsepInfo *av1_ref_from_wienerns_bank(WienerNonsepInfoBank *bank,
int ndx, int wiener_class_id) {
assert(wiener_class_id != ALL_WIENERNS_CLASSES);
- assert(bank->bank_size_for_class[wiener_class_id] > 0);
-
- assert(ndx < bank->bank_size_for_class[wiener_class_id]);
- const int ptr =
- bank->bank_ptr_for_class[wiener_class_id] - ndx +
- (bank->bank_ptr_for_class[wiener_class_id] < ndx ? LR_BANK_SIZE : 0);
- return &bank->filter[ptr];
+ if (bank->bank_size_for_class[wiener_class_id] == 0) {
+ return &bank->filter[0];
+ } else {
+ assert(ndx < bank->bank_size_for_class[wiener_class_id]);
+ const int ptr =
+ bank->bank_ptr_for_class[wiener_class_id] - ndx +
+ (bank->bank_ptr_for_class[wiener_class_id] < ndx ? LR_BANK_SIZE : 0);
+ return &bank->filter[ptr];
+ }
}
// Get a const reference to a filter given the index
const WienerNonsepInfo *av1_constref_from_wienerns_bank(
const WienerNonsepInfoBank *bank, int ndx, int wiener_class_id) {
assert(wiener_class_id != ALL_WIENERNS_CLASSES);
- assert(bank->bank_size_for_class[wiener_class_id] > 0);
-
- assert(ndx < bank->bank_size_for_class[wiener_class_id]);
- const int ptr =
- bank->bank_ptr_for_class[wiener_class_id] - ndx +
- (bank->bank_ptr_for_class[wiener_class_id] < ndx ? LR_BANK_SIZE : 0);
- return &bank->filter[ptr];
+ if (bank->bank_size_for_class[wiener_class_id] == 0) {
+ return &bank->filter[0];
+ } else {
+ assert(ndx < bank->bank_size_for_class[wiener_class_id]);
+ const int ptr =
+ bank->bank_ptr_for_class[wiener_class_id] - ndx +
+ (bank->bank_ptr_for_class[wiener_class_id] < ndx ? LR_BANK_SIZE : 0);
+ return &bank->filter[ptr];
+ }
}
// Directly replace a filter in the bank at given index
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index d934852..eab428b 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -365,6 +365,40 @@
DIFFWTD_MASK_TYPE mask_type;
COMPOUND_TYPE type;
} INTERINTER_COMPOUND_DATA;
+#if CONFIG_D071_IMP_MSK_BLD
+// This structure is used for the position check of the implicit masked blending
+typedef struct BacpBlockData {
+ int x0; // top left sample horizontal cood.
+ int x1; // x0 + bw
+ int y0; // top left sample vertical cood.
+ int y1; // y0 + bh
+} BacpBlockData;
+// This struct contains enable flag and date for implicit masked blending mode
+typedef struct {
+ uint8_t enable_bacp; // enable boundary aware compound prediction
+ BacpBlockData *bacp_block_data;
+} INTERINTER_COMPOUND_BORDER_DATA;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+#if CONFIG_REFINEMV
+#define REF_BUFFER_WIDTH \
+ (REFINEMV_SUBBLOCK_WIDTH + (AOM_INTERP_EXTEND - 1) + AOM_INTERP_EXTEND)
+#define REF_BUFFER_HEIGHT \
+ (REFINEMV_SUBBLOCK_HEIGHT + (AOM_INTERP_EXTEND - 1) + AOM_INTERP_EXTEND)
+typedef struct PadBlock {
+ int x0;
+ int x1;
+ int y0;
+ int y1;
+} PadBlock;
+
+typedef struct PadArea {
+ PadBlock pad_block;
+ uint16_t paded_ref_buf[(REF_BUFFER_WIDTH) * (REF_BUFFER_HEIGHT)];
+ int paded_ref_buf_stride;
+} ReferenceArea;
+
+#endif // CONFIG_REFINEMV
#if CONFIG_OPTFLOW_REFINEMENT
// Macros for optical flow experiment where offsets are added in nXn blocks
@@ -420,6 +454,12 @@
int mi_row_start;
/*! \brief Starting mi_col of current coding block */
int mi_col_start;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ /*! \brief Starting chroma mi_row of current coding block */
+ int chroma_mi_row_start;
+ /*! \brief Starting chroma mi_col of current coding block */
+ int chroma_mi_col_start;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
/*! \brief The partition type of the current coding block. */
PARTITION_TYPE partition;
/*! \brief The prediction mode used */
@@ -464,6 +504,11 @@
*/
uint8_t mb_precision_set;
#endif
+#if CONFIG_REFINEMV
+ /*! \brief The flag to signal if DMVR is used for the inter prediction. */
+ uint8_t refinemv_flag;
+#endif // CONFIG_REFINEMV
+
/*! \brief The motion mode used by the inter prediction. */
MOTION_MODE motion_mode;
/*! \brief Number of samples used by spatial warp prediction */
@@ -491,6 +536,11 @@
/*! \brief The bawp parameters offset*/
int32_t bawp_beta[3][2]; //[yuv][ref0/1], current only [0][0] is used.
#endif // CONFIG_BAWP
+
+#if CONFIG_CWP
+ //! Index for compound weighted prediction parameters.
+ int8_t cwp_idx;
+#endif // CONFIG_CWP
/**@}*/
/*****************************************************************************
@@ -561,7 +611,11 @@
/*! \brief Only valid when temporal update if off. */
uint8_t seg_id_predicted : 1;
/*! \brief Which ref_mv to use */
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx[2];
+#else
uint8_t ref_mv_idx : 3;
+#endif // CONFIG_SEP_COMP_DRL
/*! \brief Inter skip mode */
#if CONFIG_SKIP_MODE_ENHANCEMENT
uint8_t skip_mode : 2;
@@ -570,14 +624,14 @@
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
/*! \brief Whether intrabc is used. */
uint8_t use_intrabc[PARTITION_STRUCTURE_NUM];
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
/*! \brief Intrabc BV prediction mode. */
uint8_t intrabc_mode;
/*! \brief Index of ref_bv. */
uint8_t intrabc_drl_idx;
/*! \brief Which ref_bv to use. */
int_mv ref_bv;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
/*! \brief Which index to use for warp base parameter. */
@@ -585,6 +639,10 @@
/*! \brief Maximum number of warp reference indices to use for warp base
* parameter. */
uint8_t max_num_warp_candidates;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ /*! \brief warpmv_with_mvd_flag. */
+ uint8_t warpmv_with_mvd_flag;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
/*! \brief Indicates if masked compound is used(1) or not (0). */
@@ -634,6 +692,15 @@
} SUBMB_INFO;
#endif // CONFIG_C071_SUBBLK_WARPMV
+#if CONFIG_REFINEMV
+/*! \brief Stores the subblock refinemv motion info of the current coding block
+ */
+typedef struct REFINEMV_SUBMB_INFO {
+ /*! \brief Stored subblock mv for reference. */
+ int_mv refinemv[2];
+} REFINEMV_SUBMB_INFO;
+#endif // CONFIG_REFINEMV
+
/*!\cond */
// Get the start plane for semi-decoupled partitioning
static INLINE int get_partition_plane_start(int tree_type) {
@@ -750,7 +817,7 @@
if (bsize > BLOCK_64X64) {
return false;
}
- // At bsize \leq 8X8, extended partitions will lead to dimension < 2.
+ // At bsize <= 8X8, extended partitions will lead to dimension < 2.
if (bsize <= BLOCK_8X8) {
return false;
}
@@ -771,7 +838,7 @@
return false;
}
// A splittable wide block has ratio 2:1. If it performs HORZ_3 split, then
- // we'll get a block ratio of 2:0.5 == 4:1, which is illegal. So extended
+ // we'll get a block ratio of 2:0.25 == 8:1, which is illegal. So extended
// partition is disabled. The same goes for tall block.
if ((is_wide_block(bsize) && rect_type == HORZ) ||
(is_tall_block(bsize) && rect_type == VERT)) {
@@ -780,6 +847,25 @@
return true;
}
+#if CONFIG_UNEVEN_4WAY
+/*!\brief Checks whether uneven 4-way partition is allowed for current bsize and
+ * rect_type. */
+static AOM_INLINE bool is_uneven_4way_partition_allowed(
+ BLOCK_SIZE bsize, RECT_PART_TYPE rect_type, TREE_TYPE tree_type) {
+ assert(is_ext_partition_allowed(bsize, rect_type, tree_type));
+
+ if (rect_type == HORZ) {
+ if (bsize == BLOCK_32X64) return true;
+ if (bsize == BLOCK_16X32 && tree_type != CHROMA_PART) return true;
+ } else {
+ assert(rect_type == VERT);
+ if (bsize == BLOCK_64X32) return true;
+ if (bsize == BLOCK_32X16 && tree_type != CHROMA_PART) return true;
+ }
+ return false;
+}
+#endif // CONFIG_UNEVEN_4WAY
+
/*!\brief Returns the rect_type that's implied by the bsize. If the rect_type
* cannot be derived from bsize, returns RECT_INVALID. */
static AOM_INLINE RECT_PART_TYPE
@@ -807,18 +893,24 @@
/*!\brief Returns whether square split is allowed for current bsize. */
static AOM_INLINE bool is_square_split_eligible(BLOCK_SIZE bsize,
BLOCK_SIZE sb_size) {
- if (sb_size != BLOCK_256X256) {
- return false;
- }
+ (void)sb_size;
return bsize == BLOCK_128X128 || bsize == BLOCK_256X256;
}
-/*!\brief Returns whether the current partition is horizontal type for vertical
+/*!\brief Returns whether the current partition is horizontal type or vertical
* type. */
static AOM_INLINE RECT_PART_TYPE get_rect_part_type(PARTITION_TYPE partition) {
- if (partition == PARTITION_HORZ || partition == PARTITION_HORZ_3) {
+ if (partition == PARTITION_HORZ || partition == PARTITION_HORZ_3
+#if CONFIG_UNEVEN_4WAY
+ || partition == PARTITION_HORZ_4A || partition == PARTITION_HORZ_4B
+#endif // CONFIG_UNEVEN_4WAY
+ ) {
return HORZ;
- } else if (partition == PARTITION_VERT || partition == PARTITION_VERT_3) {
+ } else if (partition == PARTITION_VERT || partition == PARTITION_VERT_3
+#if CONFIG_UNEVEN_4WAY
+ || partition == PARTITION_VERT_4A || partition == PARTITION_VERT_4B
+#endif // CONFIG_UNEVEN_4WAY
+ ) {
return VERT;
}
assert(0 && "Rectangular partition expected!");
@@ -830,6 +922,20 @@
return is_inter_ref_frame(mbmi->ref_frame[1]);
}
+#if CONFIG_SEP_COMP_DRL
+/*!\brief Return whether the current coding block has two separate DRLs */
+static INLINE int has_second_drl(const MB_MODE_INFO *mbmi) {
+ int ret = (mbmi->mode == NEAR_NEARMV || mbmi->mode == NEAR_NEWMV) &&
+ !is_tip_ref_frame(mbmi->ref_frame[0]) && !mbmi->skip_mode;
+ return ret;
+}
+
+/*!\brief Return the mv_ref_idx of the current coding block based on ref_idx */
+static INLINE int get_ref_mv_idx(const MB_MODE_INFO *mbmi, int ref_idx) {
+ return has_second_drl(mbmi) ? mbmi->ref_mv_idx[ref_idx] : mbmi->ref_mv_idx[0];
+}
+#endif // CONFIG_SEP_COMP_DRL
+
#if CONFIG_AIMC
PREDICTION_MODE av1_get_joint_mode(const MB_MODE_INFO *mi);
#else
@@ -893,7 +999,7 @@
}
}
-#if CONFIG_H_PARTITION
+#if CONFIG_EXT_RECUR_PARTITIONS
// Get the block size of the ith sub-block in a block partitioned via an
// h-partition mode.
static INLINE BLOCK_SIZE get_h_partition_subsize(BLOCK_SIZE bsize, int index,
@@ -981,7 +1087,7 @@
}
}
}
-#endif // CONFIG_H_PARTITION
+#endif // CONFIG_EXT_RECUR_PARTITIONS
static INLINE int is_partition_valid(BLOCK_SIZE bsize, PARTITION_TYPE p) {
if (is_partition_point(bsize))
@@ -1009,25 +1115,36 @@
int subsampling_y) {
const int bw = block_size_wide[bsize] >> subsampling_x;
const int bh = block_size_high[bsize] >> subsampling_y;
+ // Check if block width/height is less than 4.
const int bw_less_than_4 = bw < 4;
const int bh_less_than_4 = bh < 4;
+ // Check if half block width/height is less than 8.
const int hbw_less_than_4 = bw < 8;
const int hbh_less_than_4 = bh < 8;
+#if !CONFIG_UNEVEN_4WAY || CONFIG_EXT_RECUR_PARTITIONS
+ // Check if quarter block width/height is less than 16.
const int qbw_less_than_4 = bw < 16;
const int qbh_less_than_4 = bh < 16;
+#endif // !CONFIG_UNEVEN_4WAY || CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_UNEVEN_4WAY
+ // Check if one-eighth block width/height is less than 32.
+ const int ebw_less_than_4 = bw < 32;
+ const int ebh_less_than_4 = bh < 32;
+#endif // CONFIG_UNEVEN_4WAY
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
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B: return bw_less_than_4 || ebh_less_than_4;
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B: return ebw_less_than_4 || bh_less_than_4;
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3: return hbw_less_than_4 || qbh_less_than_4;
case PARTITION_VERT_3: return qbw_less_than_4 || hbh_less_than_4;
-#else
- 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;
-#endif // CONFIG_H_PARTITION
#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_A:
case PARTITION_HORZ_B:
@@ -1077,13 +1194,14 @@
return 1;
}
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B:
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B: return index == 3;
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_VERT_3:
case PARTITION_HORZ_3: return index == 3;
-#else
- case PARTITION_VERT_3:
- case PARTITION_HORZ_3: return index == 2;
-#endif // CONFIG_H_PARTITION
#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_A:
case PARTITION_HORZ_B:
@@ -1162,6 +1280,12 @@
case PARTITION_HORZ:
case PARTITION_VERT:
#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B:
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B:
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_VERT_3:
case PARTITION_HORZ_3:
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -1252,14 +1376,23 @@
}
}
-static INLINE void set_chroma_ref_info(int mi_row, int mi_col, int index,
- BLOCK_SIZE bsize, CHROMA_REF_INFO *info,
+static INLINE void set_chroma_ref_info(TREE_TYPE tree_type, 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_chroma_ref_info(mi_row, mi_col, bsize, info);
+ if (tree_type == LUMA_PART) {
+ info->is_chroma_ref = 0;
+ return;
+ }
+ if (tree_type == CHROMA_PART) {
+ info->is_chroma_ref = 1;
+ return;
+ }
if (parent_info == NULL) return;
if (parent_info->is_chroma_ref) {
if (parent_info->offset_started) {
@@ -1290,7 +1423,7 @@
}
}
-#if CONFIG_MISMATCH_DEBUG
+#if CONFIG_MISMATCH_DEBUG || CONFIG_INSPECTION
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,
int subsampling_x, int subsampling_y) {
@@ -1318,8 +1451,21 @@
typedef struct {
DECLARE_ALIGNED(32, tran_low_t, dqcoeff[MAX_MB_PLANE][MAX_SB_SQUARE]);
+#if CONFIG_INSPECTION
+ // dqcoeff gets clobbered before the inspect callback happens, so keep a
+ // copy here.
+ DECLARE_ALIGNED(32, tran_low_t, dqcoeff_copy[MAX_MB_PLANE][MAX_SB_SQUARE]);
+ DECLARE_ALIGNED(32, tran_low_t, qcoeff[MAX_MB_PLANE][MAX_SB_SQUARE]);
+ DECLARE_ALIGNED(32, tran_low_t, dequant_values[MAX_MB_PLANE][MAX_SB_SQUARE]);
+#endif
+ // keeps the index that corresponds to end-of-block (eob)
eob_info eob_data[MAX_MB_PLANE]
[MAX_SB_SQUARE / (TX_SIZE_W_MIN * TX_SIZE_H_MIN)];
+#if CONFIG_ATC_DCTX_ALIGNED
+ // keeps the index that corresponds to beginning-of-block (bob)
+ eob_info bob_data[MAX_MB_PLANE]
+ [MAX_SB_SQUARE / (TX_SIZE_W_MIN * TX_SIZE_H_MIN)];
+#endif // CONFIG_ATC_DCTX_ALIGNED
DECLARE_ALIGNED(16, uint8_t, color_index_map[2][MAX_SB_SQUARE]);
} CB_BUFFER;
@@ -1351,6 +1497,9 @@
qm_val_t *seg_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL];
qm_val_t *seg_qmatrix[MAX_SEGMENTS][TX_SIZES_ALL];
+#if CONFIG_INSPECTION
+ DECLARE_ALIGNED(32, int16_t, predicted_pixels[MAX_SB_SQUARE]);
+#endif
} MACROBLOCKD_PLANE;
#define BLOCK_OFFSET(i) ((i) << 4)
@@ -1360,7 +1509,6 @@
#else
#define LR_BANK_SIZE 1
#endif // CONFIG_LR_MERGE_COEFFS
-
/*!\endcond */
/*!\brief Parameters related to Wiener Filter */
@@ -1456,7 +1604,12 @@
*/
DECLARE_ALIGNED(16, int16_t,
allfiltertaps[WIENERNS_MAX_CLASSES * WIENERNS_YUV_MAX]);
-
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ /*!
+ * Whether this is a cross-filter, temporaly used
+ */
+ int is_cross_filter;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#if CONFIG_LR_MERGE_COEFFS
/*!
* Best Reference from dynamic bank for each class.
@@ -1599,7 +1752,7 @@
} WARP_PARAM_BANK;
#endif // CONFIG_WARP_REF_LIST
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
/*! \brief Variables related to mvp list of skip mode.*/
typedef struct {
//! MV list
@@ -1617,7 +1770,7 @@
//! Global mvs
int_mv global_mvs[2];
} SKIP_MODE_MVP_LIST;
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
/*! \brief Variables related to current coding block.
*
@@ -1644,7 +1797,7 @@
* \name Reference MV bank info.
*/
/**@{*/
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
REF_MV_BANK *ref_mv_bank_pt; /*!< Pointer to bank to refer to */
#endif
REF_MV_BANK ref_mv_bank; /*!< Ref mv bank to update */
@@ -1902,6 +2055,13 @@
* Nonseparable Wiener filter information for all planes.
*/
WienerNonsepInfoBank wienerns_info[MAX_MB_PLANE];
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ /*!
+ * Nonseparable Wiener cross filter information for all planes, only Cb and Cr
+ * are applied
+ */
+ WienerNonsepInfoBank wienerns_cross_info[MAX_MB_PLANE];
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#endif // CONFIG_WIENER_NONSEP
/**@}*/
@@ -1930,9 +2090,9 @@
/*!
* skip_mvp_candidate_list is the MVP list for skip mode.
*/
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
SKIP_MODE_MVP_LIST skip_mvp_candidate_list;
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_WARP_REF_LIST
/*!
@@ -1958,7 +2118,7 @@
*/
bool is_first_horizontal_rect;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
/*!
* True if this is the last horizontal rectangular block in a HORIZONTAL or
* HORIZONTAL_4 partition.
@@ -1969,7 +2129,7 @@
* VERTICAL_4 partition.
*/
bool is_first_vertical_rect;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#endif // !CONFIG_EXT_RECUR_PARTITIONS
/*!
@@ -2132,6 +2292,11 @@
/** variable to store eob_u flag */
uint8_t eob_u_flag;
#endif // CONFIG_CONTEXT_DERIVATION
+
+#if CONFIG_REFINEMV
+ /** block level storage to store luma refined MVs for chroma use */
+ REFINEMV_SUBMB_INFO refinemv_subinfo[MAX_MIB_SIZE * MAX_MIB_SIZE];
+#endif // CONFIG_REFINEMV
} MACROBLOCKD;
/*!\cond */
@@ -2180,14 +2345,14 @@
// Number of transform types in each set type for intra blocks
static const int av1_num_ext_tx_set_intra[EXT_TX_SET_TYPES] = { 1, 1, 4,
6, 11, 15,
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
7
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
};
-#if CONFIG_ATC_NEWTXSETS && CONFIG_ATC_REDUCED_TXSET
+#if CONFIG_ATC && CONFIG_ATC_REDUCED_TXSET
static const int av1_num_reduced_tx_set = 2;
-#endif // CONFIG_ATC_NEWTXSETS && CONFIG_ATC_REDUCED_TXSET
+#endif // CONFIG_ATC && CONFIG_ATC_REDUCED_TXSET
// Number of transform types in each set type
static const int av1_num_ext_tx_set[EXT_TX_SET_TYPES] = {
@@ -2201,12 +2366,12 @@
{ 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
};
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
static const int av1_mdtx_used_flag[EXT_TX_SIZES][INTRA_MODES][TX_TYPES] = {
{
{ 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0 },
@@ -2269,7 +2434,7 @@
{ 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
}, // size_class: 3
};
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
static const uint16_t av1_reduced_intra_tx_used_flag[INTRA_MODES] = {
0x080F, // DC_PRED: 0000 1000 0000 1111
@@ -2294,12 +2459,12 @@
0x0E0F, // 0000 1110 0000 1111
0x0FFF, // 0000 1111 1111 1111
0xFFFF, // 1111 1111 1111 1111
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
0xFFFF,
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
};
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
static const uint16_t av1_md_trfm_used_flag[EXT_TX_SIZES][INTRA_MODES] = {
{
0x218F,
@@ -2362,7 +2527,7 @@
0x0000,
}, // size_class: 3
};
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
static const TxSetType av1_ext_tx_set_lookup[2][2] = {
{ EXT_TX_SET_DTT4_IDTX_1DDCT, EXT_TX_SET_DTT4_IDTX },
@@ -2374,14 +2539,18 @@
const TX_SIZE tx_size_sqr_up = txsize_sqr_up_map[tx_size];
if (tx_size_sqr_up > TX_32X32) return EXT_TX_SET_DCTONLY;
if (tx_size_sqr_up == TX_32X32)
+#if CONFIG_ATC_DCTX_ALIGNED
+ return EXT_TX_SET_DCT_IDTX;
+#else
return is_inter ? EXT_TX_SET_DCT_IDTX : EXT_TX_SET_DCTONLY;
+#endif // CONFIG_ATC_DCTX_ALIGNED
#if CONFIG_ATC_REDUCED_TXSET
if (use_reduced_set) return is_inter ? EXT_TX_SET_DCT_IDTX : EXT_NEW_TX_SET;
#else
if (use_reduced_set)
return is_inter ? EXT_TX_SET_DCT_IDTX : EXT_TX_SET_DTT4_IDTX;
#endif // CONFIG_ATC_REDUCED_TXSET
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
if (is_inter) {
const TX_SIZE tx_size_sqr = txsize_sqr_map[tx_size];
return av1_ext_tx_set_lookup[is_inter][tx_size_sqr == TX_16X16];
@@ -2391,17 +2560,17 @@
#else
const TX_SIZE tx_size_sqr = txsize_sqr_map[tx_size];
return av1_ext_tx_set_lookup[is_inter][tx_size_sqr == TX_16X16];
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
}
// Maps tx set types to the indices.
static const int ext_tx_set_index[2][EXT_TX_SET_TYPES] = {
{ // Intra
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
0, -1, -1, -1, -1, -1, 1 },
#else
0, -1, 2, 1, -1, -1 },
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
{ // Inter
0, 3, -1, -1, 2, 1 },
};
@@ -2466,7 +2635,11 @@
int is_screen_content_type) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
if (is_inter_block(mbmi, xd->tree_type) || plane_type != PLANE_TYPE_Y ||
+#if CONFIG_ATC_DCTX_ALIGNED
+ xd->lossless[mbmi->segment_id] || tx_size > TX_32X32 ||
+#else
xd->lossless[mbmi->segment_id] || tx_size >= TX_32X32 ||
+#endif // CONFIG_ATC_DCTX_ALIGNED
is_screen_content_type)
return DCT_DCT;
@@ -2846,6 +3019,9 @@
const int code_stx =
(primary_tx_type == DCT_DCT || primary_tx_type == ADST_ADST) &&
(intra_dir < PAETH_PRED) &&
+#if CONFIG_ATC_DCTX_ALIGNED
+ (eob != 1) &&
+#endif // CONFIG_ATC_DCTX_ALIGNED
!(mbmi->filter_intra_mode_info.use_filter_intra) && is_depth0 && ist_eob;
return code_stx;
}
@@ -2990,14 +3166,13 @@
void av1_reset_loop_filter_delta(MACROBLOCKD *xd, int num_planes);
-void av1_reset_wiener_bank(WienerInfoBank *bank);
+void av1_reset_wiener_bank(WienerInfoBank *bank, int chroma);
void av1_add_to_wiener_bank(WienerInfoBank *bank, const WienerInfo *info);
WienerInfo *av1_ref_from_wiener_bank(WienerInfoBank *bank, int ndx);
const WienerInfo *av1_constref_from_wiener_bank(const WienerInfoBank *bank,
int ndx);
void av1_upd_to_wiener_bank(WienerInfoBank *bank, int ndx,
const WienerInfo *info);
-void av1_get_from_wiener_bank(WienerInfoBank *bank, int ndx, WienerInfo *info);
void av1_reset_sgrproj_bank(SgrprojInfoBank *bank);
void av1_add_to_sgrproj_bank(SgrprojInfoBank *bank, const SgrprojInfo *info);
@@ -3006,14 +3181,17 @@
int ndx);
void av1_upd_to_sgrproj_bank(SgrprojInfoBank *bank, int ndx,
const SgrprojInfo *info);
-void av1_get_from_sgrproj_bank(SgrprojInfoBank *bank, int ndx,
- SgrprojInfo *info);
#if CONFIG_WIENER_NONSEP
// Resets the bank data structure holding LR_BANK_SIZE nonseparable Wiener
// filters. The bank holds a rootating buffer of filters.
void av1_reset_wienerns_bank(WienerNonsepInfoBank *bank, int qindex,
- int num_classes, int chroma);
+ int num_classes, int chroma
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ int is_cross
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+);
// Adds the nonseparable Wiener filter in info into the bank of rotating
// filters. The add is so that once the bank has LR_BANK_SIZE filters the first
@@ -3149,6 +3327,7 @@
return 0;
}
#if CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_UNEVEN_4WAY
// 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
@@ -3156,11 +3335,13 @@
if ((mi_row & 0x01) || (mi_col & 0x01)) {
return 0;
}
+#endif // !CONFIG_UNEVEN_4WAY
#else
assert(!(mi_row & 0x01) && !(mi_col & 0x01));
+#endif // CONFIG_EXT_RECUR_PARTITIONS
(void)mi_row;
(void)mi_col;
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+
return 1;
}
@@ -3276,10 +3457,10 @@
[PALETTE_COLORS];
/* clang-format on */
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
typedef aom_cdf_prob (*IdentityRowCdf)[CDF_SIZE(2)];
typedef const int (*IdentityRowCost)[PALETTE_ROW_FLAG_CONTEXTS][2];
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
typedef struct {
int rows;
@@ -3290,10 +3471,10 @@
uint8_t *color_map;
MapCdf map_cdf;
ColorCost color_cost;
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
IdentityRowCdf identity_row_cdf;
IdentityRowCost identity_row_cost;
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
} Av1ColorMapParam;
static INLINE int is_nontrans_global_motion(const MACROBLOCKD *xd,
@@ -3337,6 +3518,29 @@
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_CWP
+// check whether compound weighted prediction can be allowed
+static INLINE int is_cwp_allowed(const MB_MODE_INFO *mbmi) {
+#if CONFIG_REFINEMV
+ if (mbmi->refinemv_flag) return 0;
+#endif // CONFIG_REFINEMV
+
+ if (mbmi->skip_mode) return 1;
+ int use_cwp = has_second_ref(mbmi) && mbmi->mode < NEAR_NEARMV_OPTFLOW &&
+ mbmi->interinter_comp.type == COMPOUND_AVERAGE &&
+ mbmi->motion_mode == SIMPLE_TRANSLATION;
+ use_cwp &=
+ (mbmi->mode == NEAR_NEARMV || is_joint_mvd_coding_mode(mbmi->mode));
+ use_cwp &= (mbmi->jmvd_scale_mode == 0);
+ return use_cwp;
+}
+// Return the index for compound weighted prediction
+static INLINE int8_t get_cwp_idx(const MB_MODE_INFO *mbmi) {
+ assert(mbmi->cwp_idx <= CWP_MAX && mbmi->cwp_idx >= CWP_MIN);
+ return mbmi->cwp_idx;
+}
+#endif
+
/*!\endcond */
#ifdef __cplusplus
diff --git a/av1/common/cfl.c b/av1/common/cfl.c
index b244669..7f1f66f 100644
--- a/av1/common/cfl.c
+++ b/av1/common/cfl.c
@@ -218,17 +218,19 @@
for (int i = 0; i < width; i += 2) {
const int bot = i + input_stride;
#if CONFIG_ADAPTIVE_DS_FILTER
-#if DS_FRAME_LEVEL
- const int filter_type = cm->features.ds_filter_type;
-#else
const int filter_type = cm->seq_params.enable_cfl_ds_filter;
-#endif // DS_FRAME_LEVEL
if (filter_type == 1) {
output_q3[i >> 1] = input[AOMMAX(0, i - 1)] + 2 * input[i] +
input[i + 1] + input[bot + AOMMAX(-1, -i)] +
2 * input[bot] + input[bot + 1];
} else if (filter_type == 2) {
+#if CONFIG_CFL_IMPROVEMENTS
+ const int top = i - input_stride;
+ output_q3[i >> 1] = input[AOMMAX(0, i - 1)] + 4 * input[i] +
+ input[i + 1] + input[top] + input[bot];
+#else
output_q3[i >> 1] = input[i] * 8;
+#endif // CONFIG_CFL_IMPROVEMENTS
} else {
output_q3[i >> 1] =
(input[i] + input[i + 1] + input[bot] + input[bot + 1] + 2) << 1;
@@ -244,6 +246,25 @@
#endif
#endif // CONFIG_ADAPTIVE_DS_FILTER
}
+#if CONFIG_ADPTIVE_DS_422
+ } else if (sub_x) {
+ uint16_t *input = dst - input_stride;
+ for (int i = 0; i < width; i += 2) {
+#if CONFIG_ADAPTIVE_DS_FILTER
+ const int filter_type = cm->seq_params.enable_cfl_ds_filter;
+ if (filter_type == 1) {
+ output_q3[i >> 1] =
+ (input[AOMMAX(0, i - 1)] + 2 * input[i] + input[i + 1]) << 1;
+ } else if (filter_type == 2) {
+ output_q3[i >> 1] = input[i] << 3;
+ } else {
+ output_q3[i >> 1] = (input[i] + input[i + 1]) << 2;
+ }
+#else
+ output_q3[i >> 1] = input[i] << 3;
+#endif // CONFIG_ADAPTIVE_DS_FILTER
+ }
+#endif // CONFIG_ADPTIVE_DS_422
} else if (sub_y) {
uint16_t *input = dst - 2 * input_stride;
for (int i = 0; i < width; ++i) {
@@ -277,16 +298,18 @@
for (int j = 0; j < height; j += 2) {
const int bot = input_stride;
#if CONFIG_ADAPTIVE_DS_FILTER
-#if DS_FRAME_LEVEL
- const int filter_type = cm->features.ds_filter_type;
-#else
const int filter_type = cm->seq_params.enable_cfl_ds_filter;
-#endif // DS_FRAME_LEVEL
if (filter_type == 1) {
output_q3[j >> 1] = input[-1] + 2 * input[0] + input[1] +
input[bot - 1] + 2 * input[bot] + input[bot + 1];
} else if (filter_type == 2) {
+#if CONFIG_CFL_IMPROVEMENTS
+ const int top = (j == 0) ? 0 : (0 - input_stride);
+ output_q3[j >> 1] =
+ input[-1] + 4 * input[0] + input[1] + input[top] + input[bot];
+#else
output_q3[j >> 1] = input[0] * 8;
+#endif // CONFIG_CFL_IMPROVEMENTS
} else {
output_q3[j >> 1] =
(input[0] + input[1] + input[bot] + input[bot + 1]) << 1;
@@ -302,6 +325,25 @@
#endif // CONFIG_ADAPTIVE_DS_FILTER
input += input_stride * 2;
}
+#if CONFIG_ADPTIVE_DS_422
+ } else if (sub_x) {
+ uint16_t *input = dst - 2;
+ for (int j = 0; j < height; ++j) {
+#if CONFIG_ADAPTIVE_DS_FILTER
+ const int filter_type = cm->seq_params.enable_cfl_ds_filter;
+ if (filter_type == 1) {
+ output_q3[j] = (input[-1] + 2 * input[0] + input[1]) << 1;
+ } else if (filter_type == 2) {
+ output_q3[j] = input[0] << 3;
+ } else {
+ output_q3[j] = (input[0] + input[1]) << 2;
+ }
+#else
+ output_q3[j] = input[0] << 3;
+#endif // CONFIG_ADAPTIVE_DS_FILTER
+ input += input_stride;
+ }
+#endif // CONFIG_ADPTIVE_DS_422
} else if (sub_y) {
uint16_t *input = dst - 1;
for (int j = 0; j < height; ++j) {
@@ -609,7 +651,14 @@
int height) {
for (int j = 0; j < height; j += 2) {
for (int i = 0; i < width; i += 2) {
+#if CONFIG_CFL_IMPROVEMENTS
+ const int top = (j == 0) ? i : (i - input_stride);
+ const int bot = i + input_stride;
+ output_q3[i >> 1] = input[AOMMAX(0, i - 1)] + 4 * input[i] +
+ input[i + 1] + input[top] + input[bot];
+#else
output_q3[i >> 1] = input[i] * 8;
+#endif // CONFIG_CFL_IMPROVEMENTS
}
input += input_stride << 1;
output_q3 += CFL_BUF_LINE;
@@ -631,6 +680,45 @@
}
}
+#if CONFIG_ADPTIVE_DS_422
+#if CONFIG_ADAPTIVE_DS_FILTER
+void cfl_adaptive_luma_subsampling_422_hbd_c(const uint16_t *input,
+ int input_stride,
+ uint16_t *output_q3, int width,
+ int height, int filter_type) {
+ assert((height - 1) * CFL_BUF_LINE + width <= CFL_BUF_SQUARE);
+ for (int j = 0; j < height; j++) {
+ for (int i = 0; i < width; i += 2) {
+ if (filter_type == 1) {
+ output_q3[i >> 1] =
+ (input[AOMMAX(0, i - 1)] + 2 * input[i] + input[i + 1]) << 1;
+ } else if (filter_type == 2) {
+ output_q3[i >> 1] = (input[i]) << 3;
+ } else {
+ output_q3[i >> 1] = (input[i] + input[i + 1]) << 2;
+ }
+ }
+ input += input_stride;
+ output_q3 += CFL_BUF_LINE;
+ }
+}
+#else
+void cfl_luma_subsampling_422_hbd_colocated(const uint16_t *input,
+ int input_stride,
+ uint16_t *output_q3, int width,
+ int height) {
+ assert((height - 1) * CFL_BUF_LINE + width <= CFL_BUF_SQUARE);
+ for (int j = 0; j < height; j++) {
+ for (int i = 0; i < width; i += 2) {
+ output_q3[i >> 1] = (input[i]) << 3;
+ }
+ input += input_stride;
+ output_q3 += CFL_BUF_LINE;
+ }
+}
+#endif // CONFIG_ADAPTIVE_DS_FILTER
+#endif // CONFIG_ADPTIVE_DS_422
+
static void cfl_luma_subsampling_444_hbd_c(const uint16_t *input,
int input_stride,
uint16_t *output_q3, int width,
@@ -706,7 +794,14 @@
uint16_t *recon_buf_q3 =
cfl->recon_buf_q3 + (store_row * CFL_BUF_LINE + store_col);
#if CONFIG_ADAPTIVE_DS_FILTER
+#if CONFIG_ADPTIVE_DS_422
+ if (sub_x == 1 && sub_y == 0) {
+ cfl_adaptive_luma_subsampling_422_hbd_c(input, input_stride, recon_buf_q3,
+ width, height, filter_type);
+ } else if (filter_type == 1) {
+#else
if (filter_type == 1) {
+#endif // CONFIG_ADPTIVE_DS_422
if (sub_x && sub_y)
cfl_luma_subsampling_420_hbd_121_c(input, input_stride, recon_buf_q3,
width, height);
@@ -729,6 +824,11 @@
if (sub_x && sub_y)
cfl_luma_subsampling_420_hbd_121_c(input, input_stride, recon_buf_q3, width,
height);
+#if CONFIG_ADPTIVE_DS_422
+ else if (sub_x == 1 && sub_y == 0)
+ cfl_luma_subsampling_422_hbd_colocated(input, input_stride, recon_buf_q3,
+ width, height);
+#endif // CONFIG_ADPTIVE_DS_422
else
#endif
cfl_subsampling_hbd(tx_size, sub_x, sub_y)(input, input_stride,
diff --git a/av1/common/cfl.h b/av1/common/cfl.h
index 53cfc7c..2115a19 100644
--- a/av1/common/cfl.h
+++ b/av1/common/cfl.h
@@ -96,13 +96,27 @@
int input_stride,
uint16_t *output_q3, int width,
int height);
+#if CONFIG_ADPTIVE_DS_422
+void cfl_adaptive_luma_subsampling_422_hbd_c(const uint16_t *input,
+ int input_stride,
+ uint16_t *output_q3, int width,
+ int height, int filter_type);
+#endif // CONFIG_ADPTIVE_DS_422
#endif // CONFIG_ADAPTIVE_DS_FILTER
+#if CONFIG_ADPTIVE_DS_422 && !CONFIG_ADAPTIVE_DS_FILTER
+void cfl_luma_subsampling_422_hbd_colocated(const uint16_t *input,
+ int input_stride,
+ uint16_t *output_q3, int width,
+ int height);
+#endif // CONFIG_ADPTIVE_DS_422 && !CONFIG_ADAPTIVE_DS_FILTER
+
#if CONFIG_IMPROVED_CFL
// 121 subsample filter
void cfl_luma_subsampling_420_hbd_121_c(const uint16_t *input, int input_stride,
uint16_t *output_q3, int width,
int height);
+
// Get neighbor luma reconstruction pixels
void cfl_implicit_fetch_neighbor_luma(const AV1_COMMON *cm,
MACROBLOCKD *const xd, int row, int col,
diff --git a/av1/common/common_data.h b/av1/common/common_data.h
index ada0d89..6b08776 100644
--- a/av1/common/common_data.h
+++ b/av1/common/common_data.h
@@ -68,7 +68,19 @@
};
static const uint8_t fsc_bsize_groups[BLOCK_SIZES_ALL] = {
- 0, 1, 1, 2, 3, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 5, 5, 5, 5
+#if CONFIG_ATC_DCTX_ALIGNED
+ 0, 1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6,
+#if CONFIG_BLOCK_256
+ 6, 6, 6,
+#endif // CONFIG_BLOCK_256
+ 3, 3, 4, 4, 6, 6
+#else
+ 0, 1, 1, 2, 3, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+#if CONFIG_BLOCK_256
+ 5, 5, 5,
+#endif // CONFIG_BLOCK_256
+ 3, 3, 5, 5, 5, 5
+#endif // CONFIG_ATC_DCTX_ALIGNED
};
static const uint8_t num_pels_log2_lookup[BLOCK_SIZES_ALL] = {
@@ -76,11 +88,19 @@
13, 13, 14, 15, 15, 16, 6, 6, 8, 8, 10, 10
};
+#if CONFIG_CWP
+// Supported weighting factor for compound weighted prediction
+static const int8_t cwp_weighting_factor[2][MAX_CWP_NUM] = {
+ { 8, 12, 4, 10, 6 },
+ { 8, 12, 4, 20, -4 },
+};
+#endif // CONFIG_CWP
+
#if CONFIG_EXT_RECUR_PARTITIONS
/* 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] = { {
+ subsize_lookup[ALL_PARTITION_TYPES][BLOCK_SIZES_ALL] = { {
// PARTITION_NONE
BLOCK_4X4, // 4
BLOCK_4X8, BLOCK_8X4, BLOCK_8X8, // 8
@@ -140,6 +160,52 @@
BLOCK_INVALID, BLOCK_4X4, // 4,16
BLOCK_INVALID, BLOCK_8X8, // 8,32
BLOCK_INVALID, BLOCK_16X16, // 32,64
+#if CONFIG_UNEVEN_4WAY
+ }, { // PARTITION_HORZ_4A
+ BLOCK_INVALID, // 4
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 8
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 16
+ BLOCK_16X4, BLOCK_INVALID, BLOCK_INVALID, // 32
+ BLOCK_32X8, BLOCK_INVALID, BLOCK_INVALID, // 64
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 128
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 256
+ BLOCK_INVALID, BLOCK_INVALID, // 4,16
+ BLOCK_INVALID, BLOCK_INVALID, // 8,32
+ BLOCK_INVALID, BLOCK_INVALID, // 32,64
+ }, { // PARTITION_HORZ_4B
+ BLOCK_INVALID, // 4
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 8
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 16
+ BLOCK_16X4, BLOCK_INVALID, BLOCK_INVALID, // 32
+ BLOCK_32X8, BLOCK_INVALID, BLOCK_INVALID, // 64
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 128
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 256
+ BLOCK_INVALID, BLOCK_INVALID, // 4,16
+ BLOCK_INVALID, BLOCK_INVALID, // 8,32
+ BLOCK_INVALID, BLOCK_INVALID, // 32,64
+ }, { // PARTITION_VERT_4A
+ BLOCK_INVALID, // 4
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 8
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 16
+ BLOCK_INVALID, BLOCK_4X16, BLOCK_INVALID, // 32
+ BLOCK_INVALID, BLOCK_8X32, BLOCK_INVALID, // 64
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 128
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 256
+ BLOCK_INVALID, BLOCK_INVALID, // 4,16
+ BLOCK_INVALID, BLOCK_INVALID, // 8,32
+ BLOCK_INVALID, BLOCK_INVALID, // 32,64
+ }, { // PARTITION_VERT_4B
+ BLOCK_INVALID, // 4
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 8
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 16
+ BLOCK_INVALID, BLOCK_4X16, BLOCK_INVALID, // 32
+ BLOCK_INVALID, BLOCK_8X32, BLOCK_INVALID, // 64
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 128
+ BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID, // 256
+ BLOCK_INVALID, BLOCK_INVALID, // 4,16
+ BLOCK_INVALID, BLOCK_INVALID, // 8,32
+ BLOCK_INVALID, BLOCK_INVALID, // 32,64
+#endif // CONFIG_UNEVEN_4WAY
}, {
// PARTITION_SPLIT
BLOCK_INVALID, // 4
@@ -160,16 +226,52 @@
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;
+ assert(bh_chr >= 16 && bw_chr >= 16 &&
+ "Current implementation cannot handle SDP for sub 16x16 blocks!");
switch (luma_part) {
case PARTITION_NONE: return PARTITION_NONE;
case PARTITION_HORZ: return (bh_chr < 8) ? PARTITION_NONE : PARTITION_HORZ;
+ case PARTITION_VERT: return (bw_chr < 8) ? PARTITION_NONE : PARTITION_VERT;
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ if (bh_chr >= 32) {
+ return PARTITION_HORZ_4A;
+ } else if (bh_chr >= 8) {
+ return PARTITION_HORZ;
+ } else {
+ return PARTITION_NONE;
+ }
+ case PARTITION_HORZ_4B:
+ if (bh_chr >= 32) {
+ return PARTITION_HORZ_4B;
+ } else if (bh_chr >= 8) {
+ return PARTITION_HORZ;
+ } else {
+ return PARTITION_NONE;
+ }
+ case PARTITION_VERT_4A:
+ if (bw_chr >= 32) {
+ return PARTITION_VERT_4A;
+ } else if (bw_chr >= 8) {
+ return PARTITION_VERT;
+ } else {
+ return PARTITION_NONE;
+ }
+ case PARTITION_VERT_4B:
+ if (bw_chr >= 32) {
+ return PARTITION_VERT_4B;
+ } else if (bw_chr >= 8) {
+ return PARTITION_VERT;
+ } else {
+ return PARTITION_NONE;
+ }
+#endif // CONFIG_UNEVEN_4WAY
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;
@@ -632,17 +734,17 @@
{ 13, 3 },
};
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
// Mapping of mode dependent TX based on intra modes.
static const int av1_md_class[INTRA_MODES] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
};
// Mapping between mode dependent TX size groups based on allowed TX sizes.
-static const int av1_size_class[MODE_DEPTX_TXSIZES] = {
- 0, 1, 2, 3, 3, 0, 0, 1, 1, 2, 2, 3, 3, 0, 0, 1, 1, 2, 2,
+static const int av1_size_class[TX_SIZES_ALL] = {
+ 0, 1, 2, 3, 3, 0, 0, 1, 1, 3, 3, 3, 3, 0, 0, 3, 3, 3, 3,
};
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
static AOM_INLINE bool is_bsize_geq(BLOCK_SIZE bsize1, BLOCK_SIZE bsize2) {
if (bsize1 == BLOCK_INVALID || bsize2 == BLOCK_INVALID) {
diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 2016bc1..bf459eb 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -45,13 +45,13 @@
av1_copy(cm->fc->v_dc_sign_cdf, av1_default_v_dc_sign_cdfs[index]);
av1_copy(cm->fc->v_ac_sign_cdf, av1_default_v_ac_sign_cdfs[index]);
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
av1_copy(cm->fc->coeff_base_lf_cdf,
av1_default_coeff_base_lf_multi_cdfs[index]);
av1_copy(cm->fc->coeff_base_lf_eob_cdf,
av1_default_coeff_base_lf_eob_multi_cdfs[index]);
av1_copy(cm->fc->coeff_br_lf_cdf, av1_default_coeff_lps_lf_multi_cdfs[index]);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
av1_copy(cm->fc->coeff_br_cdf, av1_default_coeff_lps_multi_cdfs[index]);
av1_copy(cm->fc->coeff_base_cdf, av1_default_coeff_base_multi_cdfs[index]);
av1_copy(cm->fc->idtx_sign_cdf, av1_default_idtx_sign_cdfs[index]);
@@ -72,6 +72,10 @@
av1_copy(cm->fc->coeff_base_ph_cdf, av1_default_coeff_base_ph_cdfs[index]);
av1_copy(cm->fc->coeff_br_ph_cdf, av1_default_coeff_br_ph_cdfs[index]);
#endif // CONFIG_PAR_HIDING
+#if CONFIG_ATC_DCTX_ALIGNED
+ av1_copy(cm->fc->coeff_base_bob_cdf,
+ av1_default_coeff_base_bob_multi_cdfs[index]);
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
static AOM_INLINE void reset_cdf_symbol_counter(aom_cdf_prob *cdf_ptr,
@@ -129,19 +133,22 @@
RESET_CDF_COUNTER(fc->v_dc_sign_cdf, 2);
RESET_CDF_COUNTER(fc->v_ac_sign_cdf, 2);
#endif // CONFIG_CONTEXT_DERIVATION
- RESET_CDF_COUNTER(fc->eob_flag_cdf16, 5);
- RESET_CDF_COUNTER(fc->eob_flag_cdf32, 6);
- RESET_CDF_COUNTER(fc->eob_flag_cdf64, 7);
- RESET_CDF_COUNTER(fc->eob_flag_cdf128, 8);
- RESET_CDF_COUNTER(fc->eob_flag_cdf256, 9);
- RESET_CDF_COUNTER(fc->eob_flag_cdf512, 10);
- RESET_CDF_COUNTER(fc->eob_flag_cdf1024, 11);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf16, EOB_MAX_SYMS - 6);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf32, EOB_MAX_SYMS - 5);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf64, EOB_MAX_SYMS - 4);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf128, EOB_MAX_SYMS - 3);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf256, EOB_MAX_SYMS - 2);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf512, EOB_MAX_SYMS - 1);
+ RESET_CDF_COUNTER(fc->eob_flag_cdf1024, EOB_MAX_SYMS);
RESET_CDF_COUNTER(fc->coeff_base_eob_cdf, 3);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC_DCTX_ALIGNED
+ RESET_CDF_COUNTER(fc->coeff_base_bob_cdf, 3);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+#if CONFIG_ATC
RESET_CDF_COUNTER(fc->coeff_base_lf_cdf, LF_BASE_SYMBOLS);
RESET_CDF_COUNTER(fc->coeff_base_lf_eob_cdf, LF_BASE_SYMBOLS - 1);
RESET_CDF_COUNTER(fc->coeff_br_lf_cdf, BR_CDF_SIZE);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
RESET_CDF_COUNTER(fc->coeff_base_cdf, 4);
RESET_CDF_COUNTER(fc->idtx_sign_cdf, 2);
RESET_CDF_COUNTER(fc->coeff_base_cdf_idtx, 4);
@@ -154,15 +161,19 @@
RESET_CDF_COUNTER(fc->drl_cdf[0], 2);
RESET_CDF_COUNTER(fc->drl_cdf[1], 2);
RESET_CDF_COUNTER(fc->drl_cdf[2], 2);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
RESET_CDF_COUNTER(fc->skip_drl_cdf, 2);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_OPTFLOW_REFINEMENT
RESET_CDF_COUNTER(fc->use_optflow_cdf, 2);
RESET_CDF_COUNTER(fc->inter_compound_mode_cdf, INTER_COMPOUND_REF_TYPES);
#else
RESET_CDF_COUNTER(fc->inter_compound_mode_cdf, INTER_COMPOUND_MODES);
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_CWP
+ RESET_CDF_COUNTER(fc->cwp_idx_cdf, 2);
+#endif
#if CONFIG_IMPROVED_JMVD
RESET_CDF_COUNTER(fc->jmvd_scale_mode_cdf, JOINT_NEWMV_SCALE_FACTOR_CNT);
RESET_CDF_COUNTER(fc->jmvd_amvd_scale_mode_cdf, JOINT_AMVD_SCALE_FACTOR_CNT);
@@ -180,6 +191,11 @@
RESET_CDF_COUNTER(fc->interintra_cdf, 2);
RESET_CDF_COUNTER(fc->wedge_interintra_cdf, 2);
RESET_CDF_COUNTER(fc->interintra_mode_cdf, INTERINTRA_MODES);
+
+#if CONFIG_REFINEMV
+ RESET_CDF_COUNTER(fc->refinemv_flag_cdf, REFINEMV_NUM_MODES);
+#endif // CONFIG_REFINEMV
+
#if CONFIG_EXTENDED_WARP_PREDICTION
RESET_CDF_COUNTER(fc->obmc_cdf, 2);
RESET_CDF_COUNTER(fc->warped_causal_cdf, 2);
@@ -191,6 +207,9 @@
RESET_CDF_COUNTER(fc->warp_ref_idx_cdf[0], 2);
RESET_CDF_COUNTER(fc->warp_ref_idx_cdf[1], 2);
RESET_CDF_COUNTER(fc->warp_ref_idx_cdf[2], 2);
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ RESET_CDF_COUNTER(fc->warpmv_with_mvd_flag_cdf, 2);
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
RESET_CDF_COUNTER(fc->warp_delta_param_cdf, WARP_DELTA_NUM_SYMBOLS);
RESET_CDF_COUNTER(fc->warp_extend_cdf, 2);
@@ -206,10 +225,10 @@
#endif // CONFIG_TIP
RESET_CDF_COUNTER(fc->palette_y_size_cdf, PALETTE_SIZES);
RESET_CDF_COUNTER(fc->palette_uv_size_cdf, PALETTE_SIZES);
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
RESET_CDF_COUNTER(fc->identity_row_cdf_y, 2);
RESET_CDF_COUNTER(fc->identity_row_cdf_uv, 2);
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
for (int j = 0; j < PALETTE_SIZES; j++) {
int nsymbs = j + PALETTE_MIN_SIZE;
RESET_CDF_COUNTER_STRIDE(fc->palette_y_color_index_cdf[j], nsymbs,
@@ -234,20 +253,20 @@
#endif // CONFIG_NEW_TX_PARTITION
RESET_CDF_COUNTER(fc->comp_group_idx_cdf, 2);
RESET_CDF_COUNTER(fc->skip_mode_cdfs, 2);
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
RESET_CDF_COUNTER(fc->intra_inter_cdf[0], 2);
RESET_CDF_COUNTER(fc->intra_inter_cdf[1], 2);
#else
RESET_CDF_COUNTER(fc->intra_inter_cdf, 2);
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
RESET_CDF_COUNTER(fc->skip_txfm_cdfs, 2);
reset_nmv_counter(&fc->nmvc);
reset_nmv_counter(&fc->ndvc);
RESET_CDF_COUNTER(fc->intrabc_cdf, 2);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
RESET_CDF_COUNTER(fc->intrabc_mode_cdf, 2);
RESET_CDF_COUNTER(fc->intrabc_drl_idx_cdf, 2);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
RESET_CDF_COUNTER(fc->seg.tree_cdf, MAX_SEGMENTS);
RESET_CDF_COUNTER(fc->seg.pred_cdf, 2);
RESET_CDF_COUNTER(fc->seg.spatial_pred_seg_cdf, MAX_SEGMENTS);
@@ -294,6 +313,7 @@
RESET_CDF_COUNTER_STRIDE(fc->uv_mode_cdf[0], UV_INTRA_MODES - 1,
CDF_SIZE(UV_INTRA_MODES));
RESET_CDF_COUNTER(fc->uv_mode_cdf[1], UV_INTRA_MODES);
+
#if CONFIG_EXT_RECUR_PARTITIONS
for (int plane_index = 0; plane_index < PARTITION_STRUCTURE_NUM;
plane_index++) {
@@ -318,6 +338,13 @@
for (RECT_PART_TYPE rect = 0; rect < NUM_RECT_PARTS; rect++) {
for (int i = 0; i < PARTITION_CONTEXTS; i++) {
RESET_CDF_COUNTER(fc->do_ext_partition_cdf[plane_index][rect][i], 2);
+#if CONFIG_UNEVEN_4WAY
+ RESET_CDF_COUNTER(
+ fc->do_uneven_4way_partition_cdf[plane_index][rect][i], 2);
+ RESET_CDF_COUNTER(
+ fc->uneven_4way_partition_type_cdf[plane_index][rect][i],
+ NUM_UNEVEN_4WAY_PARTS);
+#endif // CONFIG_UNEVEN_4WAY
}
}
}
@@ -361,10 +388,10 @@
}
RESET_CDF_COUNTER_STRIDE(fc->intra_ext_tx_cdf[1], INTRA_TX_SET1,
CDF_SIZE(TX_TYPES));
-#if !(CONFIG_ATC_NEWTXSETS && !CONFIG_ATC_REDUCED_TXSET)
+#if !(CONFIG_ATC && !CONFIG_ATC_REDUCED_TXSET)
RESET_CDF_COUNTER_STRIDE(fc->intra_ext_tx_cdf[2], INTRA_TX_SET2,
CDF_SIZE(TX_TYPES));
-#endif // !(CONFIG_ATC_NEWTXSETS && !CONFIG_ATC_REDUCED_TXSET)
+#endif // !(CONFIG_ATC && !CONFIG_ATC_REDUCED_TXSET)
RESET_CDF_COUNTER_STRIDE(fc->inter_ext_tx_cdf[1], 16, CDF_SIZE(TX_TYPES));
RESET_CDF_COUNTER_STRIDE(fc->inter_ext_tx_cdf[2], 12, CDF_SIZE(TX_TYPES));
RESET_CDF_COUNTER_STRIDE(fc->inter_ext_tx_cdf[3], 2, CDF_SIZE(TX_TYPES));
diff --git a/av1/common/entropy.h b/av1/common/entropy.h
index e6319aa..8efd218 100644
--- a/av1/common/entropy.h
+++ b/av1/common/entropy.h
@@ -41,13 +41,18 @@
#define IDTX_LEVEL_CONTEXTS 14
#define EOB_COEF_CONTEXTS 9
+#if CONFIG_ATC_DCTX_ALIGNED
+#define SIG_COEF_CONTEXTS_BOB 3
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
+#define EOB_MAX_SYMS 11
#if CONFIG_PAR_HIDING
#define COEFF_BASE_PH_CONTEXTS 5
#define COEFF_BR_PH_CONTEXTS 7
#endif // CONFIG_PAR_HIDING
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// Number of coefficient coding contexts for the low-frequency region
// for 2D and 1D transforms
#define LF_SIG_COEF_CONTEXTS_2D 21
@@ -79,7 +84,7 @@
#define SIG_COEF_CONTEXTS_1D 16
#define SIG_COEF_CONTEXTS_EOB 4
#define SIG_COEF_CONTEXTS (SIG_COEF_CONTEXTS_2D + SIG_COEF_CONTEXTS_1D)
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#define COEFF_BASE_CONTEXTS (SIG_COEF_CONTEXTS)
#define DC_SIGN_CONTEXTS 3
@@ -132,23 +137,28 @@
switch (size) {
case 4: return ctx[0] != 0;
case 8:
-#if CONFIG_H_PARTITION
+#if CONFIG_EXT_RECUR_PARTITIONS
return ctx[0] != 0 || ctx[1] != 0;
#else
return !!*(const uint16_t *)ctx;
-#endif // CONFIG_H_PARTITION
+#endif // CONFIG_EXT_RECUR_PARTITIONS
case 16:
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ return ctx[0] != 0 || ctx[1] != 0 || ctx[2] != 0 || ctx[3] != 0;
+#elif CONFIG_EXT_RECUR_PARTITIONS
return !!(*(const uint16_t *)ctx | *(const uint16_t *)(ctx + 2));
#else
return !!*(const uint32_t *)ctx;
-#endif // CONFIG_H_PARTITION
+#endif // CONFIG_UNEVEN_4WAY
case 32:
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ return !!(*(const uint16_t *)ctx | *(const uint16_t *)(ctx + 2) |
+ *(const uint16_t *)(ctx + 4) | *(const uint16_t *)(ctx + 6));
+#elif CONFIG_EXT_RECUR_PARTITIONS
return !!(*(const uint32_t *)ctx | *(const uint32_t *)(ctx + 4));
#else
- return !*(const uint64_t *)ctx;
-#endif // CONFIG_H_PARTITION
+ return !!*(const uint64_t *)ctx;
+#endif // CONFIG_UNEVEN_4WAY
case 64: return !!(*(const uint64_t *)ctx | *(const uint64_t *)(ctx + 8));
default: assert(0 && "Invalid transform 1d size."); break;
}
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index abfc9de..693ed11 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -77,11 +77,48 @@
};
#endif
+#if CONFIG_EXT_DIR
+static const aom_cdf_prob
+ default_mrl_index_cdf[MRL_INDEX_CONTEXTS][CDF_SIZE(MRL_LINE_NUMBER)] = {
+ { AOM_CDF4(27852, 29491, 31129) },
+ { AOM_CDF4(23920, 27852, 30474) },
+ { AOM_CDF4(20316, 26542, 29818) },
+ };
+#else
static const aom_cdf_prob default_mrl_index_cdf[CDF_SIZE(MRL_LINE_NUMBER)] = {
AOM_CDF4(24756, 29049, 31092)
};
+#endif // CONFIG_EXT_DIR
#if CONFIG_NEW_CONTEXT_MODELING
+#if CONFIG_ATC_DCTX_ALIGNED
+static const aom_cdf_prob
+ default_fsc_mode_cdf[FSC_MODE_CONTEXTS][FSC_BSIZE_CONTEXTS]
+ [CDF_SIZE(FSC_MODES)] = { { { AOM_CDF2(29360) },
+ { AOM_CDF2(31501) },
+ { AOM_CDF2(32278) },
+ { AOM_CDF2(32371) },
+ { AOM_CDF2(32560) },
+ { AOM_CDF2(32531) } },
+ { { AOM_CDF2(24973) },
+ { AOM_CDF2(24385) },
+ { AOM_CDF2(24145) },
+ { AOM_CDF2(26258) },
+ { AOM_CDF2(21038) },
+ { AOM_CDF2(15313) } },
+ { { AOM_CDF2(20868) },
+ { AOM_CDF2(16117) },
+ { AOM_CDF2(12254) },
+ { AOM_CDF2(14424) },
+ { AOM_CDF2(5350) },
+ { AOM_CDF2(2348) } },
+ { { AOM_CDF2(31265) },
+ { AOM_CDF2(31284) },
+ { AOM_CDF2(32247) },
+ { AOM_CDF2(32253) },
+ { AOM_CDF2(32560) },
+ { AOM_CDF2(32533) } } };
+#else
static const aom_cdf_prob
default_fsc_mode_cdf[FSC_MODE_CONTEXTS][FSC_BSIZE_CONTEXTS]
[CDF_SIZE(FSC_MODES)] = { { { AOM_CDF2(29802) },
@@ -104,6 +141,7 @@
{ AOM_CDF2(32027) },
{ AOM_CDF2(32272) },
{ AOM_CDF2(32317) } } };
+#endif // CONFIG_ATC_DCTX_ALIGNED
#else
static const aom_cdf_prob
default_fsc_mode_cdf[FSC_MODE_CONTEXTS][FSC_BSIZE_CONTEXTS]
@@ -349,7 +387,6 @@
}
};
-
static aom_cdf_prob
default_rect_type_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][CDF_SIZE(2)] = {
// Luma
@@ -440,6 +477,9 @@
}
};
+// Note: For the partition CDFs below, most entries are unused. An optimized
+// implementation could create smaller arrays with only used values + some
+// mapping tables.
static aom_cdf_prob default_do_ext_partition_cdf
[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS][PARTITION_CONTEXTS]
[CDF_SIZE(2)] = {
@@ -623,7 +663,6 @@
}
};
-
static aom_cdf_prob
default_do_square_split_cdf[PARTITION_STRUCTURE_NUM][SQUARE_SPLIT_CONTEXTS][CDF_SIZE(2)] = {
// Luma
@@ -642,6 +681,373 @@
},
};
+#if CONFIG_UNEVEN_4WAY
+static aom_cdf_prob default_do_uneven_4way_partition_cdf
+ [PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS][PARTITION_CONTEXTS]
+ [CDF_SIZE(2)] = {
+ // Luma
+ {
+ // HORZ
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32,
+ { AOM_CDF2(23888) }, { AOM_CDF2(26675) }, { AOM_CDF2(18213) }, { AOM_CDF2(21839) },
+ // BLOCK_32X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64,
+ { AOM_CDF2(18156) }, { AOM_CDF2(22434) }, { AOM_CDF2(17065) }, { AOM_CDF2(23048) },
+ // BLOCK_64X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ },
+ // VERT
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X16,
+ { AOM_CDF2(18858) }, { AOM_CDF2(14975) }, { AOM_CDF2(21057) }, { AOM_CDF2(19369) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X32,
+ { AOM_CDF2(12384) }, { AOM_CDF2(11622) }, { AOM_CDF2(17504) }, { AOM_CDF2(17608) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ }
+ },
+ // Chroma
+ {
+ // HORZ
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64,
+ { AOM_CDF2(16705) }, { AOM_CDF2(20904) }, { AOM_CDF2(18601) }, { AOM_CDF2(22088) },
+ // BLOCK_64X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ },
+ // VERT
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X32,
+ { AOM_CDF2(15452) }, { AOM_CDF2(15654) }, { AOM_CDF2(20986) }, { AOM_CDF2(20924) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ }
+ },
+ };
+
+static aom_cdf_prob default_uneven_4way_partition_type_cdf
+ [PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS][PARTITION_CONTEXTS]
+ [CDF_SIZE(NUM_UNEVEN_4WAY_PARTS)] = {
+ // Luma
+ {
+ // HORZ
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32,
+ { AOM_CDF2(20372) }, { AOM_CDF2(19885) }, { AOM_CDF2(20532) }, { AOM_CDF2(18382) },
+ // BLOCK_32X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64,
+ { AOM_CDF2(20219) }, { AOM_CDF2(19289) }, { AOM_CDF2(18815) }, { AOM_CDF2(21548) },
+ // BLOCK_64X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ },
+ // VERT
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X16,
+ { AOM_CDF2(18025) }, { AOM_CDF2(18978) }, { AOM_CDF2(18146) }, { AOM_CDF2(20127) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X32,
+ { AOM_CDF2(17700) }, { AOM_CDF2(17721) }, { AOM_CDF2(18585) }, { AOM_CDF2(17912) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ }
+ },
+ // Chroma
+ {
+ // HORZ
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64,
+ { AOM_CDF2(17990) }, { AOM_CDF2(23831) }, { AOM_CDF2(17318) }, { AOM_CDF2(18155) },
+ // BLOCK_64X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ },
+ // VERT
+ {
+ // BLOCK_4X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_4X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X4, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_8X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X8, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_16X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X16, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X32, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_32X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X32,
+ { AOM_CDF2(15888) }, { AOM_CDF2(18079) }, { AOM_CDF2(21845) }, { AOM_CDF2(18507) },
+ // BLOCK_64X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_64X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X64, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_128X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#if CONFIG_BLOCK_256
+ // BLOCK_128X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X128, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ // BLOCK_256X256, unused
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+#endif // CONFIG_BLOCK_256
+ }
+ },
+ };
+#endif // CONFIG_UNEVEN_4WAY
// clang-format on
#else
static const aom_cdf_prob
@@ -782,7 +1188,7 @@
{ 0 },
},
},
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
{
{
{ AOM_CDF7(3368, 14670, 18533, 22660, 26441, 30407) },
@@ -1034,9 +1440,121 @@
{ AOM_CDF4(8192, 16384, 24576) },
},
}
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
};
+#if CONFIG_ATC_DCTX_ALIGNED
+static const aom_cdf_prob default_inter_ext_tx_cdf
+ [EXT_TX_SETS_INTER][EOB_TX_CTXS][EXT_TX_SIZES][CDF_SIZE(TX_TYPES)] = {
+ {
+ {
+ { 0 },
+ { 0 },
+ { 0 },
+ { 0 },
+ },
+ {
+ { 0 },
+ { 0 },
+ { 0 },
+ { 0 },
+ },
+ {
+ { 0 },
+ { 0 },
+ { 0 },
+ { 0 },
+ },
+ },
+ {
+ {
+ { AOM_CDF16(10569, 11484, 12610, 14058, 15880, 17184, 18929,
+ 19803, 20702, 21995, 22642, 23795, 26269, 28128,
+ 30321) },
+ { AOM_CDF16(2184, 3028, 4033, 5127, 6410, 7400, 8605, 13222,
+ 15760, 18377, 20510, 22737, 25720, 27841, 30221) },
+ { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+ 18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+ { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+ 18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+ },
+ {
+ { AOM_CDF16(3919, 4527, 5261, 6289, 7251, 8118, 9179, 12234,
+ 12471, 12730, 12785, 13079, 18477, 21441, 26844) },
+ { AOM_CDF16(307, 498, 725, 1194, 1577, 1962, 2378, 26001, 26439,
+ 26880, 27109, 27393, 29418, 30271, 31374) },
+ { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+ 18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+ { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+ 18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+ },
+ {
+ { AOM_CDF16(18553, 19114, 19866, 21300, 23396, 24613, 26561,
+ 26686, 26933, 27441, 27579, 27906, 29437, 30176,
+ 31237) },
+ { AOM_CDF16(14114, 15409, 17116, 18125, 19579, 20544, 21927,
+ 24115, 25337, 26585, 27781, 28994, 29938, 30846,
+ 31760) },
+ { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+ 18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+ { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+ 18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+ },
+ },
+ {
+ {
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ { AOM_CDF12(847, 1837, 2897, 8379, 12029, 15839, 18755, 21734,
+ 25244, 27430, 30001) },
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ },
+ {
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ { AOM_CDF12(56, 370, 765, 27899, 28744, 29465, 30060, 30562,
+ 31471, 31806, 32229) },
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ },
+ {
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ { AOM_CDF12(25781, 26621, 27994, 28993, 29530, 30097, 30597,
+ 31182, 31622, 32019, 32396) },
+ { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+ 24576, 27307, 30037) },
+ },
+ },
+ {
+ {
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(2100) },
+ { AOM_CDF2(1066) },
+ { AOM_CDF2(938) },
+ },
+ {
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(37) },
+ { AOM_CDF2(15) },
+ { AOM_CDF2(12) },
+ },
+ {
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(29478) },
+ { AOM_CDF2(29184) },
+ { AOM_CDF2(27781) },
+ },
+ },
+ };
+#else
static const aom_cdf_prob
default_inter_ext_tx_cdf[EXT_TX_SETS_INTER][EXT_TX_SIZES][CDF_SIZE(
TX_TYPES)] = {
@@ -1073,6 +1591,7 @@
{ AOM_CDF2(748) },
},
};
+#endif // CONFIG_ATC_DCTX_ALIGNED
#if CONFIG_CROSS_CHROMA_TX
static const aom_cdf_prob
@@ -1095,7 +1614,17 @@
static const aom_cdf_prob default_cfl_sign_cdf[CDF_SIZE(CFL_JOINT_SIGNS)] = {
AOM_CDF8(1418, 2123, 13340, 18405, 26972, 28343, 32294)
};
-
+#if CONFIG_CFL_IMPROVEMENTS
+static const aom_cdf_prob
+ default_cfl_alpha_cdf[CFL_ALPHA_CONTEXTS][CDF_SIZE(CFL_ALPHABET_SIZE)] = {
+ { AOM_CDF8(7650, 20740, 31430, 32520, 32700, 32730, 32740) },
+ { AOM_CDF8(14400, 23680, 28230, 31270, 32290, 32530, 32640) },
+ { AOM_CDF8(11560, 22430, 28510, 31430, 32430, 32610, 32680) },
+ { AOM_CDF8(27000, 31430, 32310, 32610, 32730, 32740, 32750) },
+ { AOM_CDF8(17320, 26210, 29100, 30820, 31550, 32150, 32430) },
+ { AOM_CDF8(14990, 22180, 26430, 28600, 29820, 31200, 31980) }
+ };
+#else
static const aom_cdf_prob
default_cfl_alpha_cdf[CFL_ALPHA_CONTEXTS][CDF_SIZE(CFL_ALPHABET_SIZE)] = {
{ AOM_CDF16(7637, 20719, 31401, 32481, 32657, 32688, 32692, 32696, 32700,
@@ -1111,7 +1640,7 @@
{ AOM_CDF16(14738, 21678, 25779, 27901, 29024, 30302, 30980, 31843, 32144,
32413, 32520, 32594, 32622, 32656, 32660) }
};
-
+#endif // CONFIG_CFL_IMPROVEMENTS
static const aom_cdf_prob
default_switchable_interp_cdf[SWITCHABLE_FILTER_CONTEXTS][CDF_SIZE(
SWITCHABLE_FILTERS)] = {
@@ -1281,6 +1810,21 @@
{ AOM_CDF2(16618) }, { AOM_CDF2(14980) }, { AOM_CDF2(15963) }
};
#endif // CONFIG_C076_INTER_MOD_CTX
+
+#if CONFIG_CWP
+static const aom_cdf_prob default_cwp_idx_cdf[MAX_CWP_CONTEXTS][MAX_CWP_NUM - 1]
+ [CDF_SIZE(2)] = {
+ { { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) } },
+ { { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) } },
+ };
+#endif // CONFIG_CWP
+
#if CONFIG_IMPROVED_JMVD
static const aom_cdf_prob
default_jmvd_scale_mode_cdf[CDF_SIZE(JOINT_NEWMV_SCALE_FACTOR_CNT)] = {
@@ -1292,13 +1836,13 @@
};
#endif // CONFIG_IMPROVED_JMVD
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
static const aom_cdf_prob default_skip_drl_cdf[3][CDF_SIZE(2)] = {
{ AOM_CDF2(24394) },
{ AOM_CDF2(22637) },
{ AOM_CDF2(21474) },
};
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_C076_INTER_MOD_CTX
#if CONFIG_OPTFLOW_REFINEMENT
@@ -1634,6 +2178,20 @@
};
#endif // CONFIG_WARPMV
+#if CONFIG_REFINEMV
+static const aom_cdf_prob default_refinemv_flag_cdf[NUM_REFINEMV_CTX][CDF_SIZE(
+ REFINEMV_NUM_MODES)] = {
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }
+};
+#endif // CONFIG_REFINEMV
+
static const aom_cdf_prob default_warp_delta_cdf[BLOCK_SIZES_ALL][CDF_SIZE(
2)] = { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
{ AOM_CDF2(4015) }, { AOM_CDF2(5407) }, { AOM_CDF2(4988) },
@@ -1652,6 +2210,19 @@
2)] = { { AOM_CDF2(15903) } };
static const aom_cdf_prob default_warp_ref_idx2_cdf[WARP_REF_CONTEXTS][CDF_SIZE(
2)] = { { AOM_CDF2(18242) } };
+#if CONFIG_CWG_D067_IMPROVED_WARP
+static const aom_cdf_prob
+ default_warpmv_with_mvd_flag_cdf[BLOCK_SIZES_ALL][CDF_SIZE(2)] = {
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+ { AOM_CDF2(16384) }
+ };
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
static const aom_cdf_prob
default_warp_delta_param_cdf[2][CDF_SIZE(WARP_DELTA_NUM_SYMBOLS)] = {
@@ -1721,7 +2292,7 @@
static const aom_cdf_prob default_bawp_cdf[CDF_SIZE(2)] = { AOM_CDF2(23664) };
#endif // CONFIG_BAWP
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
#if CONFIG_NEW_CONTEXT_MODELING
static const aom_cdf_prob default_intra_inter_cdf
[INTRA_INTER_SKIP_TXFM_CONTEXTS][INTRA_INTER_CONTEXTS][CDF_SIZE(2)] = {
@@ -1753,7 +2324,7 @@
{ AOM_CDF2(20186) },
{ AOM_CDF2(26538) }
};
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
#if CONFIG_TIP
static const aom_cdf_prob default_tip_cdf[TIP_CONTEXTS][CDF_SIZE(2)] = {
@@ -2047,7 +2618,7 @@
{ AOM_CDF2(32461) }, { AOM_CDF2(21488) }
};
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
static const aom_cdf_prob
default_identity_row_cdf_y[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(2)] = {
{ AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }
@@ -2280,7 +2851,7 @@
{ AOM_CDF8(31190, 31329, 31516, 31679, 31825, 32026, 32322) },
},
};
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
#if CONFIG_NEW_TX_PARTITION
static const aom_cdf_prob default_inter_4way_txfm_partition_cdf
@@ -2392,14 +2963,14 @@
30531) };
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
static const aom_cdf_prob default_intrabc_mode_cdf[CDF_SIZE(2)] = { AOM_CDF2(
16384) };
static const aom_cdf_prob
default_intrabc_drl_idx_cdf[MAX_REF_BV_STACK_SIZE - 1][CDF_SIZE(2)] = {
{ AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }
};
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
static const aom_cdf_prob default_filter_intra_mode_cdf[CDF_SIZE(
FILTER_INTRA_MODES)] = { AOM_CDF5(8949, 12776, 17211, 29558) };
@@ -2625,10 +3196,10 @@
int av1_get_palette_color_index_context(const uint8_t *color_map, int stride,
int r, int c, int palette_size,
uint8_t *color_order, int *color_idx
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
,
int row_flag, int prev_row_flag
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
) {
assert(palette_size <= PALETTE_MAX_SIZE);
assert(r > 0 || c > 0);
@@ -2687,12 +3258,12 @@
if (color_idx != NULL)
*color_idx = inverse_color_order[color_map[r * stride + c]];
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
// Special context value for the first (and only) index of an identity row and
// when the previous row is also an identity row.
if (c == 0 && row_flag && prev_row_flag)
return PALETTE_COLOR_INDEX_CONTEXTS - 1;
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
// Get hash value of context.
int color_index_ctx_hash = 0;
@@ -2713,10 +3284,10 @@
int av1_fast_palette_color_index_context(const uint8_t *color_map, int stride,
int r, int c, int *color_idx
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
,
int row_flag, int prev_row_flag
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
) {
assert(r > 0 || c > 0);
@@ -2806,12 +3377,12 @@
}
}
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
// Special context value for the first (and only) index of an identity row and
// when the previous row is also an identity row.
if (c == 0 && row_flag && prev_row_flag)
return PALETTE_COLOR_INDEX_CONTEXTS - 1;
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
// Get hash value of context.
int color_index_ctx_hash = 0;
@@ -2837,10 +3408,10 @@
(void)seq_params;
av1_copy(fc->palette_y_size_cdf, default_palette_y_size_cdf);
av1_copy(fc->palette_uv_size_cdf, default_palette_uv_size_cdf);
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
av1_copy(fc->identity_row_cdf_y, default_identity_row_cdf_y);
av1_copy(fc->identity_row_cdf_uv, default_identity_row_cdf_uv);
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
av1_copy(fc->palette_y_color_index_cdf, default_palette_y_color_index_cdf);
av1_copy(fc->palette_uv_color_index_cdf, default_palette_uv_color_index_cdf);
#if !CONFIG_AIMC
@@ -2886,6 +3457,10 @@
av1_copy(fc->drl_cdf[1], default_drl1_cdf);
av1_copy(fc->drl_cdf[2], default_drl2_cdf);
#endif // CONFIG_REF_MV_BANK
+#if CONFIG_REFINEMV
+ av1_copy(fc->refinemv_flag_cdf, default_refinemv_flag_cdf);
+#endif // CONFIG_REFINEMV
+
#if CONFIG_EXTENDED_WARP_PREDICTION
av1_copy(fc->obmc_cdf, default_obmc_cdf);
av1_copy(fc->warped_causal_cdf, default_warped_causal_cdf);
@@ -2897,6 +3472,9 @@
av1_copy(fc->warp_ref_idx_cdf[0], default_warp_ref_idx0_cdf);
av1_copy(fc->warp_ref_idx_cdf[1], default_warp_ref_idx1_cdf);
av1_copy(fc->warp_ref_idx_cdf[2], default_warp_ref_idx2_cdf);
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ av1_copy(fc->warpmv_with_mvd_flag_cdf, default_warpmv_with_mvd_flag_cdf);
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
av1_copy(fc->warp_delta_param_cdf, default_warp_delta_param_cdf);
av1_copy(fc->warp_extend_cdf, default_warp_extend_cdf);
@@ -2904,15 +3482,19 @@
av1_copy(fc->motion_mode_cdf, default_motion_mode_cdf);
av1_copy(fc->obmc_cdf, default_obmc_cdf);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
av1_copy(fc->skip_drl_cdf, default_skip_drl_cdf);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_BAWP
av1_copy(fc->bawp_cdf, default_bawp_cdf);
#endif // CONFIG_BAWP
#if CONFIG_OPTFLOW_REFINEMENT
av1_copy(fc->use_optflow_cdf, default_use_optflow_cdf);
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_CWP
+ av1_copy(fc->cwp_idx_cdf, default_cwp_idx_cdf);
+#endif // CONFIG_CWP
#if CONFIG_IMPROVED_JMVD
av1_copy(fc->jmvd_scale_mode_cdf, default_jmvd_scale_mode_cdf);
av1_copy(fc->jmvd_amvd_scale_mode_cdf, default_jmvd_amvd_scale_mode_cdf);
@@ -2980,6 +3562,12 @@
av1_copy(fc->do_square_split_cdf, default_do_square_split_cdf);
av1_copy(fc->rect_type_cdf, default_rect_type_cdf);
av1_copy(fc->do_ext_partition_cdf, default_do_ext_partition_cdf);
+#if CONFIG_UNEVEN_4WAY
+ av1_copy(fc->do_uneven_4way_partition_cdf,
+ default_do_uneven_4way_partition_cdf);
+ av1_copy(fc->uneven_4way_partition_type_cdf,
+ default_uneven_4way_partition_type_cdf);
+#endif // CONFIG_UNEVEN_4WAY
#else
av1_copy(fc->partition_cdf, default_partition_cdf);
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -2987,12 +3575,12 @@
av1_copy(fc->inter_ext_tx_cdf, default_inter_ext_tx_cdf);
av1_copy(fc->skip_mode_cdfs, default_skip_mode_cdfs);
av1_copy(fc->skip_txfm_cdfs, default_skip_txfm_cdfs);
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
av1_copy(fc->intra_inter_cdf[0], default_intra_inter_cdf[0]);
av1_copy(fc->intra_inter_cdf[1], default_intra_inter_cdf[1]);
#else
av1_copy(fc->intra_inter_cdf, default_intra_inter_cdf);
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
for (int i = 0; i < SPATIAL_PREDICTION_PROBS; i++)
av1_copy(fc->seg.spatial_pred_seg_cdf[i],
default_spatial_pred_seg_tree_cdf[i]);
@@ -3010,10 +3598,10 @@
av1_copy(fc->cfl_sign_cdf, default_cfl_sign_cdf);
av1_copy(fc->cfl_alpha_cdf, default_cfl_alpha_cdf);
av1_copy(fc->intrabc_cdf, default_intrabc_cdf);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
av1_copy(fc->intrabc_mode_cdf, default_intrabc_mode_cdf);
av1_copy(fc->intrabc_drl_idx_cdf, default_intrabc_drl_idx_cdf);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
av1_copy(fc->stx_cdf, default_stx_cdf);
#if CONFIG_FLEX_MVRES
av1_copy(fc->pb_mv_precision_cdf, default_pb_mv_precision_cdf);
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 7875226..15fb5d9 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -31,7 +31,7 @@
#define INTER_OFFSET(mode) ((mode)-NEARMV)
#define INTER_COMPOUND_OFFSET(mode) (uint8_t)((mode)-NEAR_NEARMV)
// Number of possible contexts for a color index.
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
// As can be seen from av1_get_palette_color_index_context(), the possible
// contexts are (2,0,0), (2,2,1), (3,2,0), (4,1,0), (5,0,0) pluss one
// extra case for the first element of an identity row. These are mapped to
@@ -43,7 +43,7 @@
// contexts are (2,0,0), (2,2,1), (3,2,0), (4,1,0), (5,0,0). These are mapped to
// a value from 0 to 4 using 'palette_color_index_context_lookup' table.
#define PALETTE_COLOR_INDEX_CONTEXTS 5
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
// Palette Y mode context for a block is determined by number of neighboring
// blocks (top and/or left) using a palette for Y plane. So, possible Y mode'
@@ -69,7 +69,15 @@
#define KF_MODE_CONTEXTS 5
#define FSC_MODE_CONTEXTS 4
+#if CONFIG_ATC_DCTX_ALIGNED
+#define FSC_BSIZE_CONTEXTS 6
+#else
#define FSC_BSIZE_CONTEXTS 5
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
+#if CONFIG_EXT_DIR
+#define MRL_INDEX_CONTEXTS 3
+#endif // CONFIG_EXT_DIR
#define COMPREF_BIT_TYPES 2
#define RANKED_REF0_TO_PRUNE 3
@@ -114,6 +122,11 @@
#define WARP_EXTEND_CTXS2 5
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_REFINEMV
+#define NUM_REFINEMV_CTX 24
+#define REFINEMV_NUM_MODES 2
+#endif // CONFIG_REFINEMV
+
struct AV1Common;
typedef struct {
@@ -134,6 +147,16 @@
[CDF_SIZE(2)];
aom_cdf_prob v_ac_sign_cdf[CROSS_COMPONENT_CONTEXTS][CDF_SIZE(2)];
#endif // CONFIG_CONTEXT_DERIVATION
+#if CONFIG_ATC_DCTX_ALIGNED
+ aom_cdf_prob coeff_base_bob_cdf[SIG_COEF_CONTEXTS_BOB][CDF_SIZE(3)];
+ aom_cdf_prob eob_flag_cdf16[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 6)];
+ aom_cdf_prob eob_flag_cdf32[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 5)];
+ aom_cdf_prob eob_flag_cdf64[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 4)];
+ aom_cdf_prob eob_flag_cdf128[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 3)];
+ aom_cdf_prob eob_flag_cdf256[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 2)];
+ aom_cdf_prob eob_flag_cdf512[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 1)];
+ aom_cdf_prob eob_flag_cdf1024[PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS)];
+#else
aom_cdf_prob eob_flag_cdf16[PLANE_TYPES][2][CDF_SIZE(5)];
aom_cdf_prob eob_flag_cdf32[PLANE_TYPES][2][CDF_SIZE(6)];
aom_cdf_prob eob_flag_cdf64[PLANE_TYPES][2][CDF_SIZE(7)];
@@ -141,6 +164,7 @@
aom_cdf_prob eob_flag_cdf256[PLANE_TYPES][2][CDF_SIZE(9)];
aom_cdf_prob eob_flag_cdf512[PLANE_TYPES][2][CDF_SIZE(10)];
aom_cdf_prob eob_flag_cdf1024[PLANE_TYPES][2][CDF_SIZE(11)];
+#endif // CONFIG_ATC_DCTX_ALIGNED
aom_cdf_prob coeff_base_eob_cdf[TX_SIZES][PLANE_TYPES][SIG_COEF_CONTEXTS_EOB]
[CDF_SIZE(3)];
aom_cdf_prob coeff_base_cdf[TX_SIZES][PLANE_TYPES][SIG_COEF_CONTEXTS]
@@ -148,7 +172,7 @@
aom_cdf_prob idtx_sign_cdf[IDTX_SIGN_CONTEXTS][CDF_SIZE(2)];
aom_cdf_prob coeff_base_cdf_idtx[IDTX_SIG_COEF_CONTEXTS][CDF_SIZE(4)];
aom_cdf_prob coeff_br_cdf_idtx[IDTX_LEVEL_CONTEXTS][CDF_SIZE(BR_CDF_SIZE)];
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
aom_cdf_prob coeff_base_lf_cdf[TX_SIZES][PLANE_TYPES][LF_SIG_COEF_CONTEXTS]
[CDF_SIZE(LF_BASE_SYMBOLS)];
aom_cdf_prob coeff_base_lf_eob_cdf[TX_SIZES][PLANE_TYPES]
@@ -160,7 +184,7 @@
#else
aom_cdf_prob coeff_br_cdf[TX_SIZES][PLANE_TYPES][LEVEL_CONTEXTS]
[CDF_SIZE(BR_CDF_SIZE)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#if CONFIG_PAR_HIDING
aom_cdf_prob coeff_base_ph_cdf[COEFF_BASE_PH_CONTEXTS]
[CDF_SIZE(NUM_BASE_LEVELS + 2)];
@@ -174,9 +198,14 @@
#endif // CONFIG_WARPMV
aom_cdf_prob drl_cdf[3][DRL_MODE_CONTEXTS][CDF_SIZE(2)];
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
aom_cdf_prob skip_drl_cdf[3][CDF_SIZE(2)];
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+
+#if CONFIG_REFINEMV
+ aom_cdf_prob refinemv_flag_cdf[NUM_REFINEMV_CTX]
+ [CDF_SIZE(REFINEMV_NUM_MODES)];
+#endif // CONFIG_REFINEMV
#if CONFIG_OPTFLOW_REFINEMENT
aom_cdf_prob use_optflow_cdf[INTER_COMPOUND_MODE_CONTEXTS][CDF_SIZE(2)];
@@ -186,6 +215,10 @@
aom_cdf_prob inter_compound_mode_cdf[INTER_COMPOUND_MODE_CONTEXTS]
[CDF_SIZE(INTER_COMPOUND_MODES)];
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_CWP
+ aom_cdf_prob cwp_idx_cdf[MAX_CWP_CONTEXTS][MAX_CWP_NUM - 1][CDF_SIZE(2)];
+#endif // CONFIG_CWP
#if CONFIG_IMPROVED_JMVD
aom_cdf_prob jmvd_scale_mode_cdf[CDF_SIZE(JOINT_NEWMV_SCALE_FACTOR_CNT)];
aom_cdf_prob jmvd_amvd_scale_mode_cdf[CDF_SIZE(JOINT_AMVD_SCALE_FACTOR_CNT)];
@@ -214,6 +247,9 @@
#endif // CONFIG_WARPMV
#if CONFIG_WARP_REF_LIST
aom_cdf_prob warp_ref_idx_cdf[3][WARP_REF_CONTEXTS][CDF_SIZE(2)];
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ aom_cdf_prob warpmv_with_mvd_flag_cdf[BLOCK_SIZES_ALL][CDF_SIZE(2)];
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
aom_cdf_prob warp_delta_param_cdf[2][CDF_SIZE(WARP_DELTA_NUM_SYMBOLS)];
@@ -231,10 +267,10 @@
#endif // CONFIG_TIP
aom_cdf_prob palette_y_size_cdf[PALATTE_BSIZE_CTXS][CDF_SIZE(PALETTE_SIZES)];
aom_cdf_prob palette_uv_size_cdf[PALATTE_BSIZE_CTXS][CDF_SIZE(PALETTE_SIZES)];
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
aom_cdf_prob identity_row_cdf_y[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(2)];
aom_cdf_prob identity_row_cdf_uv[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(2)];
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
aom_cdf_prob palette_y_color_index_cdf[PALETTE_SIZES]
[PALETTE_COLOR_INDEX_CONTEXTS]
[CDF_SIZE(PALETTE_COLORS)];
@@ -268,12 +304,12 @@
aom_cdf_prob comp_group_idx_cdf[COMP_GROUP_IDX_CONTEXTS][CDF_SIZE(2)];
aom_cdf_prob skip_mode_cdfs[SKIP_MODE_CONTEXTS][CDF_SIZE(2)];
aom_cdf_prob skip_txfm_cdfs[SKIP_CONTEXTS][CDF_SIZE(2)];
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
aom_cdf_prob intra_inter_cdf[INTRA_INTER_SKIP_TXFM_CONTEXTS]
[INTRA_INTER_CONTEXTS][CDF_SIZE(2)];
#else
aom_cdf_prob intra_inter_cdf[INTRA_INTER_CONTEXTS][CDF_SIZE(2)];
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
nmv_context nmvc;
nmv_context ndvc;
#if CONFIG_NEW_CONTEXT_MODELING
@@ -281,10 +317,10 @@
#else
aom_cdf_prob intrabc_cdf[CDF_SIZE(2)];
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
aom_cdf_prob intrabc_mode_cdf[CDF_SIZE(2)];
aom_cdf_prob intrabc_drl_idx_cdf[MAX_REF_BV_STACK_SIZE - 1][CDF_SIZE(2)];
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
struct segmentation_probs seg;
aom_cdf_prob filter_intra_cdfs[BLOCK_SIZES_ALL][CDF_SIZE(2)];
aom_cdf_prob filter_intra_mode_cdf[CDF_SIZE(FILTER_INTRA_MODES)];
@@ -324,7 +360,11 @@
aom_cdf_prob uv_mode_cdf[CFL_ALLOWED_TYPES][INTRA_MODES]
[CDF_SIZE(UV_INTRA_MODES)];
#endif // !CONFIG_AIMC
+#if CONFIG_EXT_DIR
+ aom_cdf_prob mrl_index_cdf[MRL_INDEX_CONTEXTS][CDF_SIZE(MRL_LINE_NUMBER)];
+#else
aom_cdf_prob mrl_index_cdf[CDF_SIZE(MRL_LINE_NUMBER)];
+#endif // CONFIG_EXT_DIR
aom_cdf_prob fsc_mode_cdf[FSC_MODE_CONTEXTS][FSC_BSIZE_CONTEXTS]
[CDF_SIZE(FSC_MODES)];
#if CONFIG_IMPROVED_CFL
@@ -348,7 +388,17 @@
[CDF_SIZE(2)];
aom_cdf_prob do_ext_partition_cdf[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
[PARTITION_CONTEXTS][CDF_SIZE(2)];
+#if CONFIG_UNEVEN_4WAY
+ aom_cdf_prob do_uneven_4way_partition_cdf[PARTITION_STRUCTURE_NUM]
+ [NUM_RECT_PARTS][PARTITION_CONTEXTS]
+ [CDF_SIZE(2)];
+ aom_cdf_prob uneven_4way_partition_type_cdf[PARTITION_STRUCTURE_NUM]
+ [NUM_RECT_PARTS]
+ [PARTITION_CONTEXTS]
+ [CDF_SIZE(NUM_UNEVEN_4WAY_PARTS)];
+#endif // CONFIG_UNEVEN_4WAY
#else
+ // Partition type for a square block, without limitations.
aom_cdf_prob partition_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
[CDF_SIZE(EXT_PARTITION_TYPES)];
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -378,8 +428,13 @@
aom_cdf_prob delta_lf_cdf[CDF_SIZE(DELTA_LF_PROBS + 1)];
aom_cdf_prob intra_ext_tx_cdf[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
[CDF_SIZE(TX_TYPES)];
+#if CONFIG_ATC_DCTX_ALIGNED
+ aom_cdf_prob inter_ext_tx_cdf[EXT_TX_SETS_INTER][EOB_TX_CTXS][EXT_TX_SIZES]
+ [CDF_SIZE(TX_TYPES)];
+#else
aom_cdf_prob inter_ext_tx_cdf[EXT_TX_SETS_INTER][EXT_TX_SIZES]
[CDF_SIZE(TX_TYPES)];
+#endif // CONFIG_ATC_DCTX_ALIGNED
aom_cdf_prob cfl_sign_cdf[CDF_SIZE(CFL_JOINT_SIGNS)];
aom_cdf_prob cfl_alpha_cdf[CFL_ALPHA_CONTEXTS][CDF_SIZE(CFL_ALPHABET_SIZE)];
aom_cdf_prob stx_cdf[TX_SIZES][CDF_SIZE(STX_TYPES)];
@@ -432,7 +487,7 @@
{ 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 4, 5, 3, 6, 7, 8 },
};
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
static const int av1_md_type2idx[EXT_TX_SIZES][INTRA_MODES][TX_TYPES] = {
{
{ 0, 2, 3, 1, 0, 0, 0, 4, 5, 0, 0, 0, 0, 6, 0, 0 }, // mode_class: 0
@@ -572,7 +627,7 @@
? av1_md_idx2type[size_idx][av1_md_class[intra_mode]][tx_idx]
: av1_ext_tx_inv[tx_set_type][tx_idx];
}
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
void av1_set_default_ref_deltas(int8_t *ref_deltas);
void av1_set_default_mode_deltas(int8_t *mode_deltas);
@@ -674,7 +729,7 @@
int av1_get_palette_color_index_context(const uint8_t *color_map, int stride,
int r, int c, int palette_size,
uint8_t *color_order, int *color_idx
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
,
int row_flag, int prev_row_flag
#endif
@@ -683,7 +738,7 @@
// exploiting the fact that the encoder does not need to maintain a color order.
int av1_fast_palette_color_index_context(const uint8_t *color_map, int stride,
int r, int c, int *color_idx
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
,
int row_flag, int prev_row_flag
#endif
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 7876d29..a86f03e 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -28,6 +28,15 @@
/*!\cond */
#undef MAX_SB_SIZE
+#define BAWP_BUGFIX 1
+
+#if CONFIG_REFINEMV
+#define SINGLE_STEP_SEARCH 0
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_D071_IMP_MSK_BLD
+#define DEFAULT_IMP_MSK_WT 0 // default implict masked blending weight
+#endif // CONFIG_D071_IMP_MSK_BLD
#if CONFIG_WEDGE_MOD_EXT
/*WEDGE_0 is defined in the three o'clock direciton, the angles are defined in
@@ -59,17 +68,20 @@
#define H_WEDGE_ANGLES 10
#define NUM_WEDGE_DIST 4
#define MAX_WEDGE_TYPES 68
+#define WEDGE_BLD_SIG 1 // 0 for linear blending, 1 for sigmoid blending
+#define WEDGE_BLD_LUT_SIZE 128
#endif // CONFIG_WEDGE_MOD_EXT
-#if CONFIG_ADAPTIVE_DS_FILTER
-#define DS_FRAME_LEVEL 1 // Signal at key frame
-#endif
-
-#if CONFIG_WARP_REF_LIST && CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_WARP_REF_LIST && CONFIG_MVP_IMPROVEMENT
#define WARP_CU_BANK 1
#else
#define WARP_CU_BANK 0
-#endif // CONFIG_WARP_REF_LIST && CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_WARP_REF_LIST && CONFIG_MVP_IMPROVEMENT
+
+#if CONFIG_REFINEMV
+#define REFINEMV_SUBBLOCK_WIDTH 16
+#define REFINEMV_SUBBLOCK_HEIGHT 16
+#endif // CONFIG_REFINEMV
// Cross-Component Sample Offset (CCSO)
#if CONFIG_CCSO
@@ -179,14 +191,14 @@
#define IST_8x8_WIDTH 64
#define IST_8x8_HEIGHT 32
-#if CONFIG_ATC_NEWTXSETS
-// TX sizes used for mode dependent TX sets
-#define MODE_DEPTX_TXSIZES 19
-#endif // CONFIG_ATC_NEWTXSETS
-
#define FSC_MODES 2
+#if CONFIG_ATC_DCTX_ALIGNED
+#define FSC_MAXWIDTH 32
+#define FSC_MAXHEIGHT 32
+#else
#define FSC_MAXWIDTH 16
#define FSC_MAXHEIGHT 16
+#endif // CONFIG_ATC_DCTX_ALIGNED
#define FSC_MINWIDTH 4
#define FSC_MINHEIGHT 4
@@ -303,14 +315,37 @@
//
#if CONFIG_EXT_RECUR_PARTITIONS
// HORZ_3 VERT_3
-// +--------------+ +---+------+---+
-// | | | | | |
-// +--------------+ | | | |
-// | | | | | |
-// | | | | | |
-// +--------------+ | | | |
-// | | | | | |
-// +--------------+ +---+------+---+
+// +---------------+ +---+------+---+
+// | | | | | |
+// +---------------+ | | | |
+// | | | | |______| |
+// | | | | | | |
+// +---------------+ | | | |
+// | | | | | |
+// +---------------+ +---+------+---+
+#if CONFIG_UNEVEN_4WAY
+// HORZ_4A HORZ_4B
+// +---------------+ +---------------+
+// | | | |
+// +---------------+ +---------------+
+// | | | |
+// | | | |
+// +---------------+ | |
+// | | | |
+// | | +---------------+
+// | | | |
+// | | | |
+// +---------------+ +---------------+
+// | | | |
+// +---------------+ +---------------+
+//
+// VERT_4A VERT_4B
+// +-------------------------+ +-------------------------+
+// | | | | | | | | | |
+// | | | | | | | | | |
+// | | | | | | | | | |
+// +-------------------------+ +-------------------------+
+#endif // CONFIG_UNEVEN_4WAY
#else
// HORZ_A HORZ_B VERT_A VERT_B
// +---+---+ +-------+ +---+---+ +---+---+
@@ -332,10 +367,20 @@
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
+#if CONFIG_UNEVEN_4WAY
+ PARTITION_HORZ_4A, // 4 horizontal uneven sub-partitions (1:2:4:1).
+ PARTITION_HORZ_4B, // 4 horizontal uneven sub-partitions (1:4:2:1).
+ PARTITION_VERT_4A, // 4 vertical uneven sub-partitions (1:2:4:1).
+ PARTITION_VERT_4B, // 4 vertical uneven sub-partitions (1:4:2:1).
+#endif // CONFIG_UNEVEN_4WAY
PARTITION_SPLIT,
+ EXT_PARTITION_TYPES = PARTITION_SPLIT,
+ ALL_PARTITION_TYPES = EXT_PARTITION_TYPES + 1,
PARTITION_TYPES = PARTITION_VERT + 1,
- EXT_PARTITION_TYPES = PARTITION_VERT_3 + 1,
- ALL_PARTITION_TYPES = PARTITION_SPLIT + 1,
+#if !CONFIG_UNEVEN_4WAY
+ LIMITED_PARTITION_TYPES = PARTITION_TYPES - 1,
+ LIMITED_EXT_PARTITION_TYPES = EXT_PARTITION_TYPES - 1,
+#endif // !CONFIG_UNEVEN_4WAY
PARTITION_INVALID = 255
} UENUM1BYTE(PARTITION_TYPE);
#else // CONFIG_EXT_RECUR_PARTITIONS
@@ -355,6 +400,7 @@
PARTITION_INVALID = 255
} UENUM1BYTE(PARTITION_TYPE);
#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// Rectangular partition types.
enum {
HORZ = 0,
@@ -362,6 +408,16 @@
NUM_RECT_PARTS,
RECT_INVALID = NUM_RECT_PARTS
} UENUM1BYTE(RECT_PART_TYPE);
+
+#if CONFIG_UNEVEN_4WAY
+// Uneven 4-way partition types.
+enum {
+ UNEVEN_4A = 0,
+ UNEVEN_4B,
+ NUM_UNEVEN_4WAY_PARTS,
+} UENUM1BYTE(UNEVEN_4WAY_PART_TYPE);
+#endif // CONFIG_UNEVEN_4WAY
+
typedef char PARTITION_CONTEXT;
#define PARTITION_PLOFFSET 4 // number of probability models per block size
@@ -568,21 +624,24 @@
EXT_TX_SET_DTT9_IDTX_1DDCT,
// Discrete Trig transforms w/ flip (9) + Identity (1) + 1D Hor/Ver (6)
EXT_TX_SET_ALL16,
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
EXT_NEW_TX_SET,
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
EXT_TX_SET_TYPES
} UENUM1BYTE(TxSetType);
+#if CONFIG_ATC_DCTX_ALIGNED
+#define EOB_TX_CTXS 3
+#endif // CONFIG_ATC_DCTX_ALIGNED
#define EXT_TX_SIZES 4 // number of sizes that use extended transforms
#define EXT_TX_SETS_INTER 4 // Sets of transform selections for INTER
-#if CONFIG_ATC_NEWTXSETS && !CONFIG_ATC_REDUCED_TXSET
+#if CONFIG_ATC && !CONFIG_ATC_REDUCED_TXSET
#define EXT_TX_SETS_INTRA 2 // Sets of transform selections for INTRA
#else
#define EXT_TX_SETS_INTRA 3 // Sets of transform selections for INTRA
-#endif // CONFIG_ATC_NEWTXSETS && !CONFIG_ATC_REDUCED_TXSET
+#endif // CONFIG_ATC && !CONFIG_ATC_REDUCED_TXSET
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
#define INTRA_TX_SET1 7
#if CONFIG_ATC_REDUCED_TXSET
#define INTRA_TX_SET2 2
@@ -590,7 +649,7 @@
#else
#define INTRA_TX_SET1 6
#define INTRA_TX_SET2 4
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
enum {
UNIDIR_COMP_REFERENCE,
@@ -600,7 +659,11 @@
enum { PLANE_TYPE_Y, PLANE_TYPE_UV, PLANE_TYPES } UENUM1BYTE(PLANE_TYPE);
+#if CONFIG_CFL_IMPROVEMENTS
+#define CFL_ALPHABET_SIZE_LOG2 3
+#else
#define CFL_ALPHABET_SIZE_LOG2 4
+#endif // CONFIG_CFL_IMPROVEMENTS
#define CFL_ALPHABET_SIZE (1 << CFL_ALPHABET_SIZE_LOG2)
#define CFL_MAGS_SIZE ((2 << CFL_ALPHABET_SIZE_LOG2) + 1)
#define CFL_IDX_U(idx) (idx >> CFL_ALPHABET_SIZE_LOG2)
@@ -636,6 +699,10 @@
#define CFL_CONTEXT_V(js) \
(CFL_SIGN_V(js) * CFL_SIGNS + CFL_SIGN_U(js) - CFL_SIGNS)
+#if CONFIG_SEP_COMP_DRL
+#define SEP_COMP_DRL_SIZE 3
+#endif // CONFIG_SEP_COMP_DRL
+
enum {
PALETTE_MAP,
COLOR_MAP_TYPES,
@@ -897,9 +964,9 @@
#define WARPMV_MODE_CONTEXT 10
#endif // CONFIG_WARPMV
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
#define MAX_REF_BV_STACK_SIZE 4
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
#define GLOBALMV_OFFSET 3
#define REFMV_OFFSET 4
@@ -915,6 +982,19 @@
#define INTER_COMPOUND_MODE_CONTEXTS 8
#endif // CONFIG_C076_INTER_MOD_CTX
+#if CONFIG_CWP
+// Number of supported factors for compound weighted prediction
+#define MAX_CWP_NUM 5
+// maximum value for the supported factors
+#define CWP_MAX 20
+// minimum value for the supported factors
+#define CWP_MIN -4
+// Weighting factor for simple averge prediction
+#define CWP_EQUAL 8
+#define CWP_WEIGHT_BITS 4
+#define MAX_CWP_CONTEXTS 2
+#endif
+
#define DELTA_Q_SMALL 3
#define DELTA_Q_PROBS (DELTA_Q_SMALL)
#define DEFAULT_DELTA_Q_RES_PERCEPTUAL 4
@@ -1089,7 +1169,7 @@
PROJ_SPATIAL, /**< Project from spatial neighborhood */
PROJ_PARAM_BANK, /**< Project from circular buffer */
PROJ_DEFAULT, /**< Default values */
- WARP_PROJ_TYPES = 5, /**< Num projection types */
+ WARP_PROJ_TYPES = 4, /**< Num projection types */
} WarpProjectionType;
#endif // CONFIG_WARP_REF_LIST
diff --git a/av1/common/idct.c b/av1/common/idct.c
index a9a3f1f..4462ef6 100644
--- a/av1/common/idct.c
+++ b/av1/common/idct.c
@@ -318,8 +318,9 @@
}
#endif // CONFIG_CROSS_CHROMA_TX
-void av1_inverse_transform_block(const MACROBLOCKD *xd, tran_low_t *dqcoeff,
- int plane, TX_TYPE tx_type, TX_SIZE tx_size,
+void av1_inverse_transform_block(const MACROBLOCKD *xd,
+ const tran_low_t *dqcoeff, int plane,
+ TX_TYPE tx_type, TX_SIZE tx_size,
uint16_t *dst, int stride, int eob,
int reduced_tx_set) {
if (!eob) return;
@@ -338,9 +339,14 @@
assert(((intra_mode >= PAETH_PRED || filter) && txfm_param.sec_tx_type) == 0);
(void)intra_mode;
(void)filter;
- av1_inv_stxfm(dqcoeff, &txfm_param);
- av1_highbd_inv_txfm_add(dqcoeff, dst, stride, &txfm_param);
+ // Work buffer for secondary transform
+ DECLARE_ALIGNED(32, tran_low_t, temp_dqcoeff[MAX_SB_SQUARE]);
+ memcpy(temp_dqcoeff, dqcoeff, sizeof(tran_low_t) * tx_size_2d[tx_size]);
+
+ av1_inv_stxfm(temp_dqcoeff, &txfm_param);
+
+ av1_highbd_inv_txfm_add(temp_dqcoeff, dst, stride, &txfm_param);
}
// Inverse secondary transform
diff --git a/av1/common/idct.h b/av1/common/idct.h
index b50d972..2652f7c 100644
--- a/av1/common/idct.h
+++ b/av1/common/idct.h
@@ -39,8 +39,9 @@
CctxType cctx_type);
#endif // CONFIG_CROSS_CHROMA_TX
-void av1_inverse_transform_block(const MACROBLOCKD *xd, tran_low_t *dqcoeff,
- int plane, TX_TYPE tx_type, TX_SIZE tx_size,
+void av1_inverse_transform_block(const MACROBLOCKD *xd,
+ const tran_low_t *dqcoeff, int plane,
+ TX_TYPE tx_type, TX_SIZE tx_size,
uint16_t *dst, int stride, int eob,
int reduced_tx_set);
void av1_highbd_iwht4x4_add(const tran_low_t *input, uint16_t *dest, int stride,
diff --git a/av1/common/mv.h b/av1/common/mv.h
index 42cac87..472c9bd 100644
--- a/av1/common/mv.h
+++ b/av1/common/mv.h
@@ -391,7 +391,7 @@
#define SUBEXPFIN_K 3
-#if CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_EXTENDED_WARP_PREDICTION || CONFIG_IMPROVED_GLOBAL_MOTION
#define GM_TRANS_PREC_BITS 3
#define GM_ABS_TRANS_BITS 14
#define GM_ABS_TRANS_ONLY_BITS (GM_ABS_TRANS_BITS - GM_TRANS_PREC_BITS + 3)
@@ -401,7 +401,11 @@
#define GM_TRANS_ONLY_DECODE_FACTOR (1 << GM_TRANS_ONLY_PREC_DIFF)
#define GM_ALPHA_PREC_BITS 10
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+#define GM_ABS_ALPHA_BITS 8
+#else
#define GM_ABS_ALPHA_BITS 7
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
#define GM_ALPHA_PREC_DIFF (WARPEDMODEL_PREC_BITS - GM_ALPHA_PREC_BITS)
#define GM_ALPHA_DECODE_FACTOR (1 << GM_ALPHA_PREC_DIFF)
#else
@@ -417,7 +421,7 @@
#define GM_ABS_ALPHA_BITS 12
#define GM_ALPHA_PREC_DIFF (WARPEDMODEL_PREC_BITS - GM_ALPHA_PREC_BITS)
#define GM_ALPHA_DECODE_FACTOR (1 << GM_ALPHA_PREC_DIFF)
-#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#endif // CONFIG_EXTENDED_WARP_PREDICTION || CONFIG_IMPROVED_GLOBAL_MOTION
#define GM_ROW3HOMO_PREC_BITS 16
#define GM_ABS_ROW3HOMO_BITS 11
@@ -425,7 +429,11 @@
(WARPEDMODEL_ROW3HOMO_PREC_BITS - GM_ROW3HOMO_PREC_BITS)
#define GM_ROW3HOMO_DECODE_FACTOR (1 << GM_ROW3HOMO_PREC_DIFF)
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+#define GM_TRANS_MAX ((1 << GM_ABS_TRANS_BITS) - 1)
+#else
#define GM_TRANS_MAX (1 << GM_ABS_TRANS_BITS)
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
#define GM_ALPHA_MAX (1 << GM_ABS_ALPHA_BITS)
#define GM_ROW3HOMO_MAX (1 << GM_ABS_ROW3HOMO_BITS)
@@ -533,6 +541,10 @@
// candidate, and so does not allow WARP_EXTEND
int row_offset;
int col_offset;
+#if CONFIG_CWP
+ // Record the cwp index of the neighboring blocks
+ int8_t cwp_idx;
+#endif // CONFIG_CWP
#endif // CONFIG_EXTENDED_WARP_PREDICTION
} CANDIDATE_MV;
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index 64ca39e..f22423d 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -20,12 +20,12 @@
#endif // CONFIG_TIP
#include "av1/common/warped_motion.h"
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
typedef struct single_mv_candidate {
int_mv mv;
MV_REFERENCE_FRAME ref_frame;
} SINGLE_MV_CANDIDATE;
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#define MFMV_STACK_SIZE 3
@@ -145,7 +145,7 @@
mv->mv.as_int = 0;
#endif // CONFIG_TIP
-#if CONFIG_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
if (is_inter_ref_frame(mi->ref_frame[0]) &&
mi->ref_frame[1] == NONE_FRAME) {
if ((abs(mi->mv[0].as_mv.row) <= REFMVS_LIMIT) &&
@@ -159,7 +159,7 @@
#endif // CONFIG_TIP
}
} else {
-#endif // CONFIG_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
for (int idx = 0; idx < 2; ++idx) {
MV_REFERENCE_FRAME ref_frame = mi->ref_frame[idx];
if (is_inter_ref_frame(ref_frame)) {
@@ -177,9 +177,9 @@
#endif // CONFIG_TIP
}
}
-#if CONFIG_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
}
-#endif // CONFIG_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
mv++;
}
@@ -187,25 +187,25 @@
}
}
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
// Fetch MVP candidates from derived SMVP into MVP candidate list
// when there is no enough MVP candidates.
static AOM_INLINE void fill_mvp_from_derived_smvp(
const MV_REFERENCE_FRAME rf[2], CANDIDATE_MV *ref_mv_stack,
uint16_t *ref_mv_weight, uint8_t *refmv_count,
CANDIDATE_MV *derived_mv_stack, uint8_t derived_mv_count,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
const MB_MODE_INFO *mbmi, MV_REFERENCE_FRAME *ref_frame_idx0,
MV_REFERENCE_FRAME *ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
const int max_ref_mv_count) {
int index = 0;
int derived_idx = 0;
if (rf[1] == NONE_FRAME) {
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
assert(!mbmi->skip_mode);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
for (derived_idx = 0; derived_idx < derived_mv_count; ++derived_idx) {
for (index = 0; index < *refmv_count; ++index) {
@@ -222,6 +222,9 @@
ref_mv_stack[index].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[index].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[index].cwp_idx = derived_mv_stack[derived_idx].cwp_idx;
+#endif // CONFIG_CWP
ref_mv_weight[index] = REF_CAT_LEVEL;
++(*refmv_count);
}
@@ -233,10 +236,10 @@
derived_mv_stack[derived_idx].this_mv.as_int) &&
(ref_mv_stack[index].comp_mv.as_int ==
derived_mv_stack[derived_idx].comp_mv.as_int)) {
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (!mbmi->skip_mode || (ref_frame_idx0[index] == rf[0] &&
ref_frame_idx1[index] == rf[1]))
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
break;
}
}
@@ -249,19 +252,22 @@
ref_mv_stack[index].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[index].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_CWP
+ ref_mv_stack[index].cwp_idx = derived_mv_stack[derived_idx].cwp_idx;
+#endif // CONFIG_CWP
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) {
ref_frame_idx0[index] = rf[0];
ref_frame_idx1[index] = rf[1];
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
ref_mv_weight[index] = REF_CAT_LEVEL;
++(*refmv_count);
}
}
}
}
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_TIP
static AOM_INLINE void derive_ref_mv_candidate_from_tip_mode(
@@ -323,6 +329,9 @@
ref_mv_stack[index].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[index].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[index].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
++(*refmv_count);
}
if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
@@ -374,9 +383,9 @@
static AOM_INLINE void add_ref_mv_candidate(
#if CONFIG_TIP
-#if !CONFIG_SMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
const AV1_COMMON *cm,
-#endif // !CONFIG_SMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
int mi_row, int mi_col, int mi_row_cand, int mi_col_cand,
#endif // CONFIG_TIP
const MB_MODE_INFO *const candidate,
@@ -387,16 +396,16 @@
uint8_t *ref_match_count, uint8_t *newmv_count, CANDIDATE_MV *ref_mv_stack,
uint16_t *ref_mv_weight, int_mv *gm_mv_candidates,
const WarpedMotionParams *gm_params,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
const MB_MODE_INFO *mbmi,
MV_REFERENCE_FRAME ref_frame_idx0[MAX_REF_MV_STACK_SIZE],
MV_REFERENCE_FRAME ref_frame_idx1[MAX_REF_MV_STACK_SIZE],
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
const AV1_COMMON *cm, int add_more_mvs, SINGLE_MV_CANDIDATE *single_mv,
uint8_t *single_mv_count, CANDIDATE_MV *derived_mv_stack,
uint16_t *derived_mv_weight, uint8_t *derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_IBC_SR_EXT
uint8_t is_intrabc,
#endif // CONFIG_IBC_SR_EXT
@@ -425,7 +434,7 @@
const TIP *tip_ref = &cm->tip_ref;
#endif // CONFIG_TIP
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) {
#if CONFIG_TIP
if (!is_tip_ref_frame(candidate->ref_frame[0]) &&
@@ -464,18 +473,21 @@
ref_mv_stack[index].comp_mv = this_refmv[1];
ref_frame_idx0[index] = candidate->ref_frame[0];
ref_frame_idx1[index] = candidate->ref_frame[1];
+#if CONFIG_CWP
+ ref_mv_stack[index].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
ref_mv_weight[index] = weight;
++(*refmv_count);
}
}
return;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
if (rf[1] == NONE_FRAME) {
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
assert(!mbmi->skip_mode);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
// single reference frame
for (ref = 0; ref < 2; ++ref) {
@@ -523,13 +535,16 @@
ref_mv_stack[index].row_offset = row_offset;
ref_mv_stack[index].col_offset = col_offset;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[index].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
ref_mv_weight[index] = weight;
++(*refmv_count);
}
if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
++*ref_match_count;
}
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
else if (add_more_mvs && is_inter_ref_frame(candidate->ref_frame[ref]) &&
#if CONFIG_IBC_SR_EXT
rf[0] != INTRA_FRAME &&
@@ -586,11 +601,14 @@
*derived_mv_count < MAX_REF_MV_STACK_SIZE) {
derived_mv_stack[index].this_mv = this_refmv;
derived_mv_weight[index] = weight;
+#if CONFIG_CWP
+ derived_mv_stack[index].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
++(*derived_mv_count);
}
}
}
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
}
} else {
#if CONFIG_TIP
@@ -606,9 +624,9 @@
// compound reference frame
if (candidate->ref_frame[0] == rf[0] &&
candidate->ref_frame[1] == rf[1]) {
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) return;
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
int_mv this_refmv[2];
@@ -640,25 +658,31 @@
ref_mv_stack[index].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[index].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[index].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
++(*refmv_count);
}
if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
++*ref_match_count;
}
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
else if (add_more_mvs) {
// Compound reference frame, but only have one reference frame
// is the same as the reference frame of the neighboring block
int candidate_ref_idx0 = -1;
int candidate_ref_idx1 = -1;
+ int which_cand_ref = -1;
if (candidate->ref_frame[0] == rf[0] ||
candidate->ref_frame[1] == rf[0]) {
candidate_ref_idx0 = 0;
candidate_ref_idx1 = 1;
+ which_cand_ref = (candidate->ref_frame[0] == rf[0]) ? 0 : 1;
} else if (candidate->ref_frame[0] == rf[1] ||
candidate->ref_frame[1] == rf[1]) {
candidate_ref_idx0 = 1;
candidate_ref_idx1 = 0;
+ which_cand_ref = (candidate->ref_frame[0] == rf[1]) ? 0 : 1;
}
if (candidate_ref_idx0 != -1 && candidate_ref_idx1 != -1) {
@@ -671,7 +695,7 @@
#if CONFIG_C071_SUBBLK_WARPMV
submi,
#endif // CONFIG_C071_SUBBLK_WARPMV
- candidate_ref_idx0);
+ which_cand_ref);
int cand_idx = 0;
for (cand_idx = 0; cand_idx < *single_mv_count; ++cand_idx) {
@@ -700,6 +724,9 @@
derived_mv_stack[index].this_mv = this_refmv[0];
derived_mv_stack[index].comp_mv = this_refmv[1];
derived_mv_weight[index] = weight;
+#if CONFIG_CWP
+ derived_mv_stack[index].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
++(*derived_mv_count);
}
}
@@ -722,7 +749,7 @@
}
}
}
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
}
#if CONFIG_TIP
}
@@ -805,9 +832,8 @@
}
}
#endif // CONFIG_WARP_REF_LIST
-// both CONFIG_SMVP_IMPROVEMENT and CONFIG_C043_MVP_IMPROVEMENTS are ture case,
-// scan_row_mbmi does not called
-#if !(CONFIG_SMVP_IMPROVEMENT && CONFIG_C043_MVP_IMPROVEMENTS)
+// when CONFIG_MVP_IMPROVEMENT is ture, scan_row_mbmi does not called
+#if !CONFIG_MVP_IMPROVEMENT
static AOM_INLINE void scan_row_mbmi(
const AV1_COMMON *cm, const MACROBLOCKD *xd,
#if CONFIG_TIP || CONFIG_EXT_RECUR_PARTITIONS
@@ -817,14 +843,14 @@
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_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
MV_REFERENCE_FRAME *ref_frame_idx0, MV_REFERENCE_FRAME *ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_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,
uint8_t *derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
WARP_CANDIDATE warp_param_stack[MAX_WARP_REF_CANDIDATES],
int max_num_of_warp_candidates, uint8_t *valid_num_warp_candidates,
@@ -853,6 +879,7 @@
const int plane_type = (xd->tree_type == CHROMA_PART);
for (int i = 0; i < end_mi;) {
#if CONFIG_EXT_RECUR_PARTITIONS
+ if (xd->mi_col + col_offset + i >= cm->mi_params.mi_cols) break;
const int sb_mi_size = mi_size_wide[cm->sb_size];
const int mask_row = mi_row & (sb_mi_size - 1);
const int mask_col = mi_col & (sb_mi_size - 1);
@@ -867,6 +894,7 @@
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
const MB_MODE_INFO *const candidate = candidate_mi0[col_offset + i];
+ assert(candidate != NULL);
#if CONFIG_C071_SUBBLK_WARPMV
const SUBMB_INFO *const submi = submi_mi0[col_offset + i];
#endif // CONFIG_C071_SUBBLK_WARPMV
@@ -878,7 +906,7 @@
else if (abs(row_offset) > 1)
len = AOMMAX(len, width_8x8);
-#if CONFIG_COMPLEXITY_SCALABLE_MVP
+#if CONFIG_MVP_IMPROVEMENT
// Don't add weight to row_offset < -1 which is in the outer area
uint16_t weight = row_offset < -1 ? 0 : 2;
#else
@@ -887,7 +915,7 @@
if (xd->width >= width_8x8 && xd->width <= n4_w) {
uint16_t inc = AOMMIN(-max_row_offset + row_offset + 1,
mi_size_high[candidate_bsize]);
-#if !CONFIG_COMPLEXITY_SCALABLE_MVP
+#if !CONFIG_MVP_IMPROVEMENT
// Obtain range used in weight calculation.
weight = AOMMAX(weight, inc);
#endif
@@ -911,9 +939,9 @@
add_ref_mv_candidate(
#if CONFIG_TIP
-#if !CONFIG_SMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
cm,
-#endif // !CONFIG_SMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
mi_row, mi_col, cand_mi_row, cand_mi_col,
#endif // CONFIG_TIP
candidate,
@@ -922,13 +950,13 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
rf, refmv_count, ref_match_count, newmv_count, ref_mv_stack,
ref_mv_weight, gm_mv_candidates, cm->global_motion,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
xd->mi[0], ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
cm, add_more_mvs, single_mv, single_mv_count, derived_mv_stack,
derived_mv_weight, derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_IBC_SR_EXT
xd->mi[0]->use_intrabc[xd->tree_type == CHROMA_PART],
#endif // CONFIG_IBC_SR_EXT
@@ -945,9 +973,9 @@
i += len;
}
}
-#endif // !(CONFIG_SMVP_IMPROVEMENT && CONFIG_C043_MVP_IMPROVEMENTS)
+#endif // !CONFIG_MVP_IMPROVEMENT
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
// update processed_cols variable, when scan_col_mbmi() is not used for adjacent
// neigbhors
static AOM_INLINE void update_processed_cols(const MACROBLOCKD *xd, int mi_row,
@@ -971,7 +999,7 @@
}
}
}
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
static AOM_INLINE void scan_col_mbmi(
const AV1_COMMON *cm, const MACROBLOCKD *xd, int mi_row,
@@ -981,14 +1009,14 @@
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,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
MV_REFERENCE_FRAME *ref_frame_idx0, MV_REFERENCE_FRAME *ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_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,
uint8_t *derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
WARP_CANDIDATE warp_param_stack[MAX_WARP_REF_CANDIDATES],
int max_num_of_warp_candidates, uint8_t *valid_num_warp_candidates,
@@ -1012,6 +1040,7 @@
for (i = 0; i < end_mi;) {
#if CONFIG_EXT_RECUR_PARTITIONS
+ if (xd->mi_row + row_offset + i >= cm->mi_params.mi_rows) break;
const int sb_mi_size = mi_size_wide[cm->sb_size];
const int mask_row = mi_row & (sb_mi_size - 1);
const int mask_col = mi_col & (sb_mi_size - 1);
@@ -1026,6 +1055,7 @@
#endif // CONFIG_EXT_RECUR_PARTITIONS
const MB_MODE_INFO *const candidate =
xd->mi[(row_offset + i) * xd->mi_stride + col_offset];
+ assert(candidate != NULL);
#if CONFIG_C071_SUBBLK_WARPMV
const SUBMB_INFO *const submi =
xd->submi[(row_offset + i) * xd->mi_stride + col_offset];
@@ -1039,7 +1069,7 @@
else if (abs(col_offset) > 1)
len = AOMMAX(len, n8_h_8);
-#if CONFIG_COMPLEXITY_SCALABLE_MVP
+#if CONFIG_MVP_IMPROVEMENT
// Don't add weight to col_offset < -1 which is in the outer area
uint16_t weight = col_offset < -1 ? 0 : 2;
#else
@@ -1048,7 +1078,7 @@
if (xd->height >= n8_h_8 && xd->height <= n4_h) {
int inc = AOMMIN(-max_col_offset + col_offset + 1,
mi_size_wide[candidate_bsize]);
-#if !CONFIG_COMPLEXITY_SCALABLE_MVP
+#if !CONFIG_MVP_IMPROVEMENT
// Obtain range used in weight calculation.
weight = AOMMAX(weight, inc);
#endif
@@ -1072,9 +1102,9 @@
add_ref_mv_candidate(
#if CONFIG_TIP
-#if !CONFIG_SMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
cm,
-#endif // !CONFIG_SMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
mi_row, mi_col, cand_mi_row, cand_mi_col,
#endif // CONFIG_TIP
candidate,
@@ -1083,13 +1113,13 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
rf, refmv_count, ref_match_count, newmv_count, ref_mv_stack,
ref_mv_weight, gm_mv_candidates, cm->global_motion,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
xd->mi[0], ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
cm, add_more_mvs, single_mv, single_mv_count, derived_mv_stack,
derived_mv_weight, derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_IBC_SR_EXT
xd->mi[0]->use_intrabc[xd->tree_type == CHROMA_PART],
#endif // CONFIG_IBC_SR_EXT
@@ -1130,14 +1160,14 @@
const int mi_col, const MV_REFERENCE_FRAME rf[2], int row_offset,
int col_offset, CANDIDATE_MV *ref_mv_stack, uint16_t *ref_mv_weight,
uint8_t *ref_match_count, uint8_t *newmv_count, int_mv *gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
MV_REFERENCE_FRAME *ref_frame_idx0, MV_REFERENCE_FRAME *ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_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,
uint8_t *derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
WARP_CANDIDATE warp_param_stack[MAX_WARP_REF_CANDIDATES],
int max_num_of_warp_candidates, uint8_t *valid_num_warp_candidates,
@@ -1162,7 +1192,7 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
const int len = mi_size_wide[BLOCK_8X8];
-#if CONFIG_COMPLEXITY_SCALABLE_MVP
+#if CONFIG_MVP_IMPROVEMENT
// Don't add weight to (-1,-1) which is in the outer area
uint16_t weight = row_offset == -1 && col_offset == -1 ? 0 : 2;
#endif
@@ -1183,9 +1213,9 @@
add_ref_mv_candidate(
#if CONFIG_TIP
-#if !CONFIG_SMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
cm,
-#endif // !CONFIG_SMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
mi_row, mi_col, cand_mi_row, cand_mi_col,
#endif // CONFIG_TIP
candidate,
@@ -1194,20 +1224,20 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
rf, refmv_count, ref_match_count, newmv_count, ref_mv_stack,
ref_mv_weight, gm_mv_candidates, cm->global_motion,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
xd->mi[0], ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
cm, add_more_mvs, single_mv, single_mv_count, derived_mv_stack,
derived_mv_weight, derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_IBC_SR_EXT
xd->mi[0]->use_intrabc[xd->tree_type == CHROMA_PART],
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_EXTENDED_WARP_PREDICTION
row_offset, col_offset,
#endif // CONFIG_EXTENDED_WARP_PREDICTION
-#if CONFIG_COMPLEXITY_SCALABLE_MVP
+#if CONFIG_MVP_IMPROVEMENT
weight * len
#else
2 * len
@@ -1254,7 +1284,7 @@
return has_tr;
}
-#if CONFIG_C043_MVP_IMPROVEMENTS || CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_EXTENDED_WARP_PREDICTION
static int has_bottom_left(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col, int n4_h) {
const int sb_mi_size = mi_size_wide[cm->sb_size];
@@ -1284,7 +1314,7 @@
return xd->is_mi_coded[av1_get_sdp_idx(xd->tree_type)][bl_offset];
}
}
-#endif // CONFIG_C043_MVP_IMPROVEMENTS || CONFIG_EXTENDED_WARP_PREDICTION
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_EXTENDED_WARP_PREDICTION
#else
static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col, int bs) {
@@ -1292,9 +1322,9 @@
const int mask_row = mi_row & (sb_mi_size - 1);
const int mask_col = mi_col & (sb_mi_size - 1);
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
if (bs > mi_size_wide[BLOCK_64X64]) return 0;
-#endif // !CONFIG_C043_MVP_IMPROVEMENTS
+#endif // !CONFIG_MVP_IMPROVEMENT
// In a split partition all apart from the bottom right has a top right
int has_tr = !((mask_row & bs) && (mask_col & bs));
@@ -1340,7 +1370,7 @@
return has_tr;
}
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
static int has_bottom_left(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col, int bs) {
const int sb_mi_size = mi_size_wide[cm->sb_size];
@@ -1396,10 +1426,10 @@
return has_bl;
}
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#endif // CONFIG_EXT_RECUR_PARTITIONS
-#if !CONFIG_C063_TMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
static int check_sb_border(const int mi_row, const int mi_col,
const int row_offset, const int col_offset) {
const int sb_mi_size = mi_size_wide[BLOCK_64X64];
@@ -1412,7 +1442,7 @@
return 1;
}
-#endif // !CONFIG_C063_TMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
static int add_tpl_ref_mv(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame,
@@ -1423,16 +1453,16 @@
#endif // !CONFIG_C076_INTER_MOD_CTX
,
uint8_t *const refmv_count,
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
int *added_tmvp_cnt,
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE],
uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE]
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
,
MV_REFERENCE_FRAME *ref_frame_idx0,
MV_REFERENCE_FRAME *ref_frame_idx1
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if !CONFIG_C076_INTER_MOD_CTX
,
int16_t *mode_context
@@ -1469,9 +1499,17 @@
#endif // CONFIG_TIP
const uint16_t weight_unit = 1; // mi_size_wide[BLOCK_8X8];
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int cur_frame_index = cm->cur_frame->display_order_hint;
+#else
const int cur_frame_index = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const RefCntBuffer *const buf_0 = get_ref_frame_buf(cm, rf[0]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int frame0_index = buf_0->display_order_hint;
+#else
const int frame0_index = buf_0->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int cur_offset_0 = get_relative_dist(&cm->seq_params.order_hint_info,
cur_frame_index, frame0_index);
int idx;
@@ -1505,9 +1543,9 @@
}
#endif // !CONFIG_C076_INTER_MOD_CTX
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
assert(!xd->mi[0]->skip_mode);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
for (idx = 0; idx < *refmv_count; ++idx)
if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break;
@@ -1520,16 +1558,23 @@
ref_mv_stack[idx].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[idx].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[idx].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
ref_mv_weight[idx] = 2 * weight_unit;
++(*refmv_count);
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
++(*added_tmvp_cnt);
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
}
} else {
// Process compound inter mode
const RefCntBuffer *const buf_1 = get_ref_frame_buf(cm, rf[1]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int frame1_index = buf_1->display_order_hint;
+#else
const int frame1_index = buf_1->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int cur_offset_1 = get_relative_dist(&cm->seq_params.order_hint_info,
cur_frame_index, frame1_index);
int_mv comp_refmv;
@@ -1554,7 +1599,7 @@
}
#endif // !CONFIG_C076_INTER_MOD_CTX
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode) {
for (idx = 0; idx < *refmv_count; ++idx) {
if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int &&
@@ -1568,16 +1613,19 @@
if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int;
+#if CONFIG_CWP
+ ref_mv_stack[idx].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
ref_frame_idx0[idx] = rf[0];
ref_frame_idx1[idx] = rf[1];
ref_mv_weight[idx] = 2 * weight_unit;
++(*refmv_count);
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
++(*added_tmvp_cnt);
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
}
} else {
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
for (idx = 0; idx < *refmv_count; ++idx) {
if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int &&
comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int)
@@ -1594,15 +1642,18 @@
ref_mv_stack[idx].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[idx].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[idx].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
ref_mv_weight[idx] = 2 * weight_unit;
++(*refmv_count);
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
++(*added_tmvp_cnt);
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
}
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
return 1;
@@ -1691,6 +1742,9 @@
ref_mv_stack[stack_idx].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[stack_idx].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[stack_idx].cwp_idx = candidate->cwp_idx;
+#endif // CONFIG_CWP
// TODO(jingning): Set an arbitrary small number here. The weight
// doesn't matter as long as it is properly initialized.
@@ -1736,13 +1790,16 @@
ref_mv_stack[*refmv_count].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[*refmv_count].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[*refmv_count].cwp_idx = cand_mv.cwp_idx;
+#endif // CONFIG_CWP
++*refmv_count;
return true;
}
#endif // CONFIG_REF_MV_BANK
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
// Add a BV candidate to ref MV stack without duplicate check
static AOM_INLINE bool add_to_ref_bv_list(CANDIDATE_MV cand_mv,
CANDIDATE_MV *ref_mv_stack,
@@ -1750,20 +1807,23 @@
uint8_t *refmv_count) {
ref_mv_stack[*refmv_count] = cand_mv;
ref_mv_weight[*refmv_count] = REF_CAT_LEVEL;
+#if CONFIG_CWP
+ ref_mv_stack[*refmv_count].cwp_idx = cand_mv.cwp_idx;
+#endif // CONFIG_CWP
++*refmv_count;
return true;
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
static AOM_INLINE void setup_ref_mv_list(
const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame,
uint8_t *const refmv_count,
CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE],
uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE],
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
MV_REFERENCE_FRAME *ref_frame_idx0, MV_REFERENCE_FRAME *ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
int_mv mv_ref_list[MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates,
int mi_row, int mi_col
#if !CONFIG_C076_INTER_MOD_CTX
@@ -1779,15 +1839,15 @@
) {
#if CONFIG_EXT_RECUR_PARTITIONS
const int has_tr = has_top_right(cm, xd, mi_row, mi_col, xd->width);
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
const int has_bl = has_bottom_left(cm, xd, mi_row, mi_col, xd->height);
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#else
const int bs = AOMMAX(xd->width, xd->height);
const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs);
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
const int has_bl = has_bottom_left(cm, xd, mi_row, mi_col, bs);
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#endif // CONFIG_EXT_RECUR_PARTITIONS
MV_REFERENCE_FRAME rf[2];
@@ -1795,11 +1855,10 @@
int max_row_offset = 0, max_col_offset = 0;
const int row_adj = (xd->height < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01);
const int col_adj = (xd->width < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01);
- // both CONFIG_SMVP_IMPROVEMENT and CONFIG_C043_MVP_IMPROVEMENTS are ture
- // case, processed_rows does not needed
-#if !(CONFIG_SMVP_IMPROVEMENT && CONFIG_C043_MVP_IMPROVEMENTS)
+ // when CONFIG_MVP_IMPROVEMENT is true, processed_rows does not needed
+#if !CONFIG_MVP_IMPROVEMENT
int processed_rows = 0;
-#endif // !(CONFIG_SMVP_IMPROVEMENT && CONFIG_C043_MVP_IMPROVEMENTS)
+#endif // !CONFIG_MVP_IMPROVEMENT
int processed_cols = 0;
av1_set_ref_frame(rf, ref_frame);
@@ -1812,16 +1871,42 @@
for (int k = 0; k < MAX_REF_MV_STACK_SIZE; k++) {
ref_mv_stack[k].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[k].col_offset = OFFSET_NONSPATIAL;
+#if CONFIG_CWP
+ ref_mv_stack[k].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
}
#endif
+#if CONFIG_WARP_REF_LIST && CONFIG_CWG_D067_IMPROVED_WARP
+ // derive a warp model from the 3 corner MVs
+ if (warp_param_stack && valid_num_warp_candidates &&
+ *valid_num_warp_candidates < max_num_of_warp_candidates) {
+ int mvs_32[2 * 3];
+ int pts[2 * 3];
+ int np = 0;
+ WarpedMotionParams cand_warp_param = default_warp_params;
+ const int valid_points =
+ generate_points_from_corners(xd, pts, mvs_32, &np, ref_frame);
+ const int valid_model =
+ get_model_from_corner_mvs(&cand_warp_param, pts, valid_points, mvs_32,
+ xd->mi[0]->sb_type[PLANE_TYPE_Y]);
+ if (valid_model && !cand_warp_param.invalid &&
+ !is_this_param_already_in_list(*valid_num_warp_candidates,
+ warp_param_stack, cand_warp_param)) {
+ insert_neighbor_warp_candidate(warp_param_stack, &cand_warp_param,
+ *valid_num_warp_candidates, PROJ_SPATIAL);
+ (*valid_num_warp_candidates)++;
+ }
+ }
+#endif // CONFIG_WARP_REF_LIST && CONFIG_CWG_D067_IMPROVED_WARP
+
// Find valid maximum row/col offset.
if (xd->up_available) {
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
max_row_offset = -(MVREF_ROWS << 1) + row_adj;
#else
max_row_offset = -(MVREF_ROW_COLS << 1) + row_adj;
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
if (xd->height < mi_size_high[BLOCK_8X8])
max_row_offset = -(2 << 1) + row_adj;
@@ -1830,11 +1915,11 @@
}
if (xd->left_available) {
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
max_col_offset = -(MVREF_COLS << 1) + col_adj;
#else
max_col_offset = -(MVREF_ROW_COLS << 1) + col_adj;
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
if (xd->width < mi_size_wide[BLOCK_8X8])
max_col_offset = -(2 << 1) + col_adj;
@@ -1846,26 +1931,26 @@
uint8_t row_match_count = 0;
uint8_t newmv_count = 0;
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
SINGLE_MV_CANDIDATE single_mv[MAX_REF_MV_STACK_SIZE];
uint8_t single_mv_count = 0;
CANDIDATE_MV derived_mv_stack[MAX_REF_MV_STACK_SIZE];
uint16_t derived_mv_weight[MAX_REF_MV_STACK_SIZE];
uint8_t derived_mv_count = 0;
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
if (xd->left_available) {
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, (xd->height - 1), -1,
ref_mv_stack, ref_mv_weight, &col_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1878,13 +1963,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, (xd->width - 1), ref_mv_stack,
ref_mv_weight, &row_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1895,13 +1980,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, 0, -1, ref_mv_stack,
ref_mv_weight, &col_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1914,13 +1999,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, 0, ref_mv_stack,
ref_mv_weight, &row_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1931,13 +2016,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, xd->height, -1, ref_mv_stack,
ref_mv_weight, &col_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1948,13 +2033,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->width, ref_mv_stack,
ref_mv_weight, &row_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1967,13 +2052,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack,
ref_mv_weight, &dummy_ref_match_count, &dummy_new_mv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -1984,13 +2069,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, (xd->height >> 1), -1,
ref_mv_stack, ref_mv_weight, &col_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -2003,13 +2088,13 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, (xd->width >> 1),
ref_mv_stack, ref_mv_weight, &row_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -2026,13 +2111,13 @@
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_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -2048,13 +2133,13 @@
rf, -1, ref_mv_stack, ref_mv_weight, refmv_count,
&col_match_count, &newmv_count, gm_mv_candidates,
max_col_offset,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -2066,19 +2151,19 @@
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->width, ref_mv_stack,
ref_mv_weight, &row_match_count, &newmv_count,
gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
1, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
#endif // CONFIG_WARP_REF_LIST
refmv_count);
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if !CONFIG_C076_INTER_MOD_CTX
const uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0);
@@ -2098,13 +2183,13 @@
#if !CONFIG_C076_INTER_MOD_CTX
int is_available = 0;
#endif //! CONFIG_C076_INTER_MOD_CTX
-#if !CONFIG_C063_TMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
const int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->height);
const int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->width);
-#endif // !CONFIG_C063_TMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
const int blk_row_end = AOMMIN(xd->height, mi_size_high[BLOCK_64X64]);
const int blk_col_end = AOMMIN(xd->width, mi_size_wide[BLOCK_64X64]);
-#if !CONFIG_C063_TMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
const int tpl_sample_pos[3][2] = {
{ voffset, -2 },
{ voffset, hoffset },
@@ -2114,7 +2199,7 @@
(xd->height < mi_size_high[BLOCK_64X64]) &&
(xd->width >= mi_size_wide[BLOCK_8X8]) &&
(xd->width < mi_size_wide[BLOCK_64X64]);
-#endif // !CONFIG_C063_TMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
const int step_h = (xd->height >= mi_size_high[BLOCK_64X64])
? mi_size_high[BLOCK_16X16]
@@ -2123,11 +2208,11 @@
? mi_size_wide[BLOCK_16X16]
: mi_size_wide[BLOCK_8X8];
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
int added_tmvp_cnt = 0;
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
// Use reversed horizontal scan order to check TMVP candidates
for (int blk_row = blk_row_end - step_h; blk_row >= 0; blk_row -= step_h) {
for (int blk_col = blk_col_end - step_w; blk_col >= 0;
@@ -2136,7 +2221,7 @@
#else
for (int blk_row = 0; blk_row < blk_row_end; blk_row += step_h) {
for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) {
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if !CONFIG_C076_INTER_MOD_CTX
int ret =
#endif //! CONFIG_C076_INTER_MOD_CTX
@@ -2147,25 +2232,25 @@
#endif //! CONFIG_C076_INTER_MOD_CTX
,
refmv_count,
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
&added_tmvp_cnt,
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
ref_mv_stack, ref_mv_weight
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
,
ref_frame_idx0, ref_frame_idx1
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if !CONFIG_C076_INTER_MOD_CTX
,
mode_context
#endif // !CONFIG_C076_INTER_MOD_CTX
);
#if !CONFIG_C076_INTER_MOD_CTX
-#if CONFIG_C063_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
if (added_tmvp_cnt) is_available = ret;
#else
if (blk_row == 0 && blk_col == 0) is_available = ret;
-#endif // CONFIG_C063_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#endif //! CONFIG_C076_INTER_MOD_CTX
}
}
@@ -2173,7 +2258,7 @@
#if !CONFIG_C076_INTER_MOD_CTX
if (is_available == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
#endif //! CONFIG_C076_INTER_MOD_CTX
-#if !CONFIG_C063_TMVP_IMPROVEMENT
+#if !CONFIG_MVP_IMPROVEMENT
for (int i = 0; i < 3 && allow_extension; ++i) {
const int blk_row = tpl_sample_pos[i][0];
const int blk_col = tpl_sample_pos[i][1];
@@ -2184,39 +2269,39 @@
gm_mv_candidates,
#endif //! CONFIG_C076_INTER_MOD_CTX
refmv_count, ref_mv_stack, ref_mv_weight,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0,
ref_frame_idx1
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if !CONFIG_C076_INTER_MOD_CTX
mode_context
#endif //! CONFIG_C076_INTER_MOD_CTX
);
}
-#endif // !CONFIG_C063_TMVP_IMPROVEMENT
+#endif // !CONFIG_MVP_IMPROVEMENT
}
uint8_t dummy_newmv_count = 0;
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
// Scan the second outer area.
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack, ref_mv_weight,
&row_match_count, &dummy_newmv_count, gm_mv_candidates,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
-#if CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_MVP_IMPROVEMENT
0, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
#endif // CONFIG_WARP_REF_LIST
refmv_count);
-#endif // !CONFIG_C043_MVP_IMPROVEMENTS
+#endif // !CONFIG_MVP_IMPROVEMENT
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
for (int idx = 2; idx <= MVREF_COLS; ++idx) {
const int col_offset = -(idx << 1) + 1 + col_adj;
if (abs(col_offset) <= abs(max_col_offset) &&
@@ -2228,9 +2313,9 @@
rf, col_offset, ref_mv_stack, ref_mv_weight, refmv_count,
&col_match_count, &dummy_newmv_count, gm_mv_candidates,
max_col_offset,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
0, single_mv, &single_mv_count, derived_mv_stack,
derived_mv_weight, &derived_mv_count,
#if CONFIG_WARP_REF_LIST
@@ -2254,9 +2339,9 @@
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,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -2273,9 +2358,9 @@
rf, col_offset, ref_mv_stack, ref_mv_weight, refmv_count,
&col_match_count, &dummy_newmv_count, gm_mv_candidates,
max_col_offset,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_WARP_REF_LIST
warp_param_stack, max_num_of_warp_candidates,
valid_num_warp_candidates, ref_frame,
@@ -2283,10 +2368,10 @@
&processed_cols);
}
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if !CONFIG_C076_INTER_MOD_CTX
-#if CONFIG_COMPLEXITY_SCALABLE_MVP
+#if CONFIG_MVP_IMPROVEMENT
// These contexts are independent of the outer area search
int new_ctx = 2 * nearest_match + (newmv_count > 0);
int ref_ctx = 2 * nearest_match + (newmv_count < 3);
@@ -2335,7 +2420,7 @@
ref_mv_stack[idx] = tmp_mv;
ref_mv_weight[idx - 1] = ref_mv_weight[idx];
ref_mv_weight[idx] = tmp_ref_mv_weight;
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode) {
const MV_REFERENCE_FRAME temp_ref0 = ref_frame_idx0[idx - 1];
const MV_REFERENCE_FRAME temp_ref1 = ref_frame_idx1[idx - 1];
@@ -2345,14 +2430,14 @@
ref_frame_idx1[idx - 1] = ref_frame_idx1[idx];
ref_frame_idx1[idx] = temp_ref1;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
nr_len = idx;
}
}
len = nr_len;
}
-#if !CONFIG_COMPLEXITY_SCALABLE_MVP
+#if !CONFIG_MVP_IMPROVEMENT
len = *refmv_count;
while (len > nearest_refmv_count) {
int nr_len = nearest_refmv_count;
@@ -2371,15 +2456,16 @@
}
#endif
-#if (CONFIG_REF_MV_BANK && CONFIG_C043_MVP_IMPROVEMENTS)
+#if (CONFIG_REF_MV_BANK && CONFIG_MVP_IMPROVEMENT)
if (cm->seq_params.enable_refmvbank) {
const int ref_mv_limit =
AOMMIN(cm->features.max_drl_bits + 1, MAX_REF_MV_STACK_SIZE);
+
// If open slots are available, fetch reference MVs from the ref mv banks.
if (*refmv_count < ref_mv_limit
-#if !CONFIG_BVP_IMPROVEMENT
+#if !CONFIG_IBC_BV_IMPROVEMENT
&& ref_frame != INTRA_FRAME
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
) {
const REF_MV_BANK *ref_mv_bank = &xd->ref_mv_bank;
const CANDIDATE_MV *queue = ref_mv_bank->rmb_buffer[ref_frame];
@@ -2393,40 +2479,40 @@
++idx_bank) {
const int idx = (start_idx + count - 1 - idx_bank) % REF_MV_BANK_SIZE;
const CANDIDATE_MV cand_mv = queue[idx];
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
bool rmb_candi_exist =
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
check_rmb_cand(cand_mv, ref_mv_stack, ref_mv_weight, refmv_count,
is_comp, xd->mi_row, xd->mi_col, block_width,
block_height, cm->width, cm->height);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode && rmb_candi_exist) {
ref_frame_idx0[*refmv_count - 1] = rf[0];
ref_frame_idx1[*refmv_count - 1] = rf[1];
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
}
}
-#endif // (CONFIG_REF_MV_BANK && CONFIG_C043_MVP_IMPROVEMENTS)
+#endif // (CONFIG_REF_MV_BANK && CONFIG_MVP_IMPROVEMENT)
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
const int max_ref_mv_count =
AOMMIN(cm->features.max_drl_bits + 1, MAX_REF_MV_STACK_SIZE);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode) derived_mv_count = 0;
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
if (*refmv_count < max_ref_mv_count && derived_mv_count > 0) {
fill_mvp_from_derived_smvp(rf, ref_mv_stack, ref_mv_weight, refmv_count,
derived_mv_stack, derived_mv_count,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
xd->mi[0], ref_frame_idx0, ref_frame_idx1,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
max_ref_mv_count);
}
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->width);
mi_width = AOMMIN(mi_width, cm->mi_params.mi_cols - mi_col);
@@ -2495,6 +2581,9 @@
ref_mv_stack[*refmv_count].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[*refmv_count].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[*refmv_count].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
} else {
ref_mv_stack[*refmv_count].this_mv = comp_list[0][0];
ref_mv_stack[*refmv_count].comp_mv = comp_list[0][1];
@@ -2502,13 +2591,16 @@
ref_mv_stack[*refmv_count].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[*refmv_count].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[*refmv_count].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
}
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode) {
ref_frame_idx0[*refmv_count] = rf[0];
ref_frame_idx1[*refmv_count] = rf[1];
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
ref_mv_weight[*refmv_count] = 2;
++*refmv_count;
} else {
@@ -2519,12 +2611,15 @@
ref_mv_stack[*refmv_count].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[*refmv_count].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_CWP
+ ref_mv_stack[*refmv_count].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode) {
ref_frame_idx0[*refmv_count] = rf[0];
ref_frame_idx1[*refmv_count] = rf[1];
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
ref_mv_weight[*refmv_count] = 2;
++*refmv_count;
}
@@ -2541,9 +2636,9 @@
}
} else {
// Handle single reference frame extension
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
assert(!xd->mi[0]->skip_mode);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_IBC_SR_EXT
if (!xd->mi[0]->use_intrabc[xd->tree_type == CHROMA_PART]) {
#endif // CONFIG_IBC_SR_EXT
@@ -2597,9 +2692,9 @@
// If there is extra space in the stack, copy the GLOBALMV vector into it.
// This also guarantees the existence of at least one vector to search.
if (*refmv_count < MAX_REF_MV_STACK_SIZE
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
&& !xd->mi[0]->use_intrabc[xd->tree_type == CHROMA_PART]
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
) {
int stack_idx;
for (stack_idx = 0; stack_idx < *refmv_count; ++stack_idx) {
@@ -2613,20 +2708,23 @@
ref_mv_stack[*refmv_count].row_offset = OFFSET_NONSPATIAL;
ref_mv_stack[*refmv_count].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ ref_mv_stack[*refmv_count].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
ref_mv_weight[*refmv_count] = REF_CAT_LEVEL;
(*refmv_count)++;
}
}
}
-#if CONFIG_REF_MV_BANK && !CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_REF_MV_BANK && !CONFIG_MVP_IMPROVEMENT
if (!cm->seq_params.enable_refmvbank) return;
const int ref_mv_limit =
AOMMIN(cm->features.max_drl_bits + 1, MAX_REF_MV_STACK_SIZE);
// If open slots are available, fetch reference MVs from the ref mv banks.
if (*refmv_count < ref_mv_limit
-#if !CONFIG_BVP_IMPROVEMENT
+#if !CONFIG_IBC_BV_IMPROVEMENT
&& ref_frame != INTRA_FRAME
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
) {
const REF_MV_BANK *ref_mv_bank = xd->ref_mv_bank_pt;
const CANDIDATE_MV *queue = ref_mv_bank->rmb_buffer[ref_frame];
@@ -2640,21 +2738,21 @@
++idx_bank) {
const int idx = (start_idx + count - 1 - idx_bank) % REF_MV_BANK_SIZE;
const CANDIDATE_MV cand_mv = queue[idx];
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
bool rmb_candi_exist =
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
check_rmb_cand(cand_mv, ref_mv_stack, ref_mv_weight, refmv_count,
is_comp, xd->mi_row, xd->mi_col, block_width,
block_height, cm->width, cm->height);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode && rmb_candi_exist) {
ref_frame_idx0[*refmv_count - 1] = rf[0];
ref_frame_idx1[*refmv_count - 1] = rf[1];
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
}
-#endif // CONFIG_REF_MV_BANK && !CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_REF_MV_BANK && !CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
if (warp_param_stack && valid_num_warp_candidates &&
@@ -2715,7 +2813,7 @@
#endif // CONFIG_WARP_REF_LIST
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
// If there are open slots in reference BV candidate list
// fetch reference BVs from the default BVPs
if (xd->mi[0]->use_intrabc[xd->tree_type == CHROMA_PART]) {
@@ -2740,7 +2838,7 @@
add_to_ref_bv_list(tmp_mv, ref_mv_stack, ref_mv_weight, refmv_count);
}
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#if CONFIG_WARP_REF_LIST
@@ -2870,6 +2968,10 @@
bool derive_wrl = (warp_param_stack && valid_num_warp_candidates &&
max_num_of_warp_candidates);
derive_wrl &= (ref_frame < INTER_REFS_PER_FRAME);
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mi)) derive_wrl = 0;
+#endif // CONFIG_SEP_COMP_DRL
+
derive_wrl &= is_motion_variation_allowed_bsize(mi->sb_type[PLANE_TYPE_Y],
mi_row, mi_col);
if (derive_wrl && valid_num_warp_candidates) {
@@ -2878,7 +2980,7 @@
}
#endif // CONFIG_WARP_REF_LIST
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mi->skip_mode) {
SKIP_MODE_MVP_LIST *skip_list =
(SKIP_MODE_MVP_LIST *)&(xd->skip_mvp_candidate_list);
@@ -2896,6 +2998,73 @@
#endif // CONFIG_WARP_REF_LIST
);
} else {
+#if CONFIG_SEP_COMP_DRL
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame);
+ if (!has_second_drl(mi))
+ rf[0] = ref_frame;
+ else {
+ const BLOCK_SIZE bsize = mi->sb_type[PLANE_TYPE_Y];
+#if CONFIG_FLEX_MVRES
+ const int fr_mv_precision = cm->features.fr_mv_precision;
+ gm_mv[0] = get_warp_motion_vector(xd, &cm->global_motion[rf[0]],
+ fr_mv_precision, bsize, mi_col, mi_row);
+#else
+ gm_mv[0] = get_warp_motion_vector(xd, &cm->global_motion[ref_frame],
+ allow_high_precision_mv, bsize, mi_col,
+ mi_row, force_integer_mv);
+#endif
+ gm_mv[1].as_int = 0;
+ }
+ setup_ref_mv_list(cm, xd, rf[0], &ref_mv_count[rf[0]], ref_mv_stack[rf[0]],
+ ref_mv_weight[rf[0]], NULL, NULL,
+ mv_ref_list ? mv_ref_list[rf[0]] : NULL, gm_mv, mi_row,
+ mi_col
+#if !CONFIG_C076_INTER_MOD_CTX
+ ,
+ mode_context
+#endif //! CONFIG_C076_INTER_MOD_CTX
+#if CONFIG_WARP_REF_LIST
+ ,
+ derive_wrl ? warp_param_stack[rf[0]] : NULL,
+ derive_wrl ? max_num_of_warp_candidates : 0,
+ derive_wrl ? &valid_num_warp_candidates[rf[0]] : NULL
+#endif // CONFIG_WARP_REF_LIST
+ );
+
+ if (has_second_drl(mi)) {
+ assert(rf[0] == mi->ref_frame[0]);
+ assert(rf[1] == mi->ref_frame[1]);
+ const BLOCK_SIZE bsize = mi->sb_type[PLANE_TYPE_Y];
+#if CONFIG_FLEX_MVRES
+ const int fr_mv_precision = cm->features.fr_mv_precision;
+ gm_mv[0] = get_warp_motion_vector(xd, &cm->global_motion[rf[1]],
+ fr_mv_precision, bsize, mi_col, mi_row);
+#else
+ gm_mv[0] = get_warp_motion_vector(xd, &cm->global_motion[ref_frame],
+ allow_high_precision_mv, bsize, mi_col,
+ mi_row, force_integer_mv);
+#endif
+ gm_mv[1].as_int = 0;
+
+ setup_ref_mv_list(cm, xd, rf[1], &ref_mv_count[rf[1]],
+ ref_mv_stack[rf[1]], ref_mv_weight[rf[1]], NULL, NULL,
+ mv_ref_list ? mv_ref_list[rf[1]] : NULL, gm_mv, mi_row,
+ mi_col
+#if !CONFIG_C076_INTER_MOD_CTX
+ ,
+ mode_context
+#endif //! CONFIG_C076_INTER_MOD_CTX
+#if CONFIG_WARP_REF_LIST
+ ,
+ derive_wrl ? warp_param_stack[rf[1]] : NULL,
+ derive_wrl ? max_num_of_warp_candidates : 0,
+ derive_wrl ? &valid_num_warp_candidates[rf[1]] : NULL
+#endif // CONFIG_WARP_REF_LIST
+ );
+ }
+ if (derive_wrl) assert(rf[0] == ref_frame);
+#else
setup_ref_mv_list(cm, xd, ref_frame, &ref_mv_count[ref_frame],
ref_mv_stack[ref_frame], ref_mv_weight[ref_frame], NULL,
NULL, mv_ref_list ? mv_ref_list[ref_frame] : NULL, gm_mv,
@@ -2912,6 +3081,7 @@
#endif // CONFIG_WARP_REF_LIST
);
+#endif // CONFIG_SEP_COMP_DRL
}
#else
setup_ref_mv_list(cm, xd, ref_frame, &ref_mv_count[ref_frame],
@@ -2929,7 +3099,7 @@
derive_wrl ? &valid_num_warp_candidates[ref_frame] : NULL
#endif // CONFIG_WARP_REF_LIST
);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
#if CONFIG_FLEX_MVRES
@@ -3018,6 +3188,57 @@
}
#endif // !CONFIG_TIP
+#if CONFIG_MF_IMPROVEMENT
+// Get the temporal distance of start_frame to its closest ref frame
+// that has interpolation property relative to current frame. Interpolation
+// means start_frame and its ref frame are on two sides of current frame
+static INLINE int get_dist_to_closest_interp_ref(const AV1_COMMON *const cm,
+ MV_REFERENCE_FRAME start_frame,
+ const int find_forward_ref) {
+ if (start_frame == -1) return INT_MAX;
+ const OrderHintInfo *const order_hint_info = &cm->seq_params.order_hint_info;
+
+ const RefCntBuffer *const start_frame_buf =
+ get_ref_frame_buf(cm, start_frame);
+
+ if (!is_ref_motion_field_eligible(cm, start_frame_buf)) return INT_MAX;
+
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int start_frame_order_hint = start_frame_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
+ const int start_frame_order_hint = start_frame_buf->order_hint;
+ const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ int abs_closest_ref_offset = INT_MAX;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints =
+ &start_frame_buf->ref_display_order_hint[0];
+#else
+ const int *const ref_order_hints = &start_frame_buf->ref_order_hints[0];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ for (MV_REFERENCE_FRAME ref = 0; ref < INTER_REFS_PER_FRAME; ++ref) {
+ if (ref_order_hints[ref] != -1) {
+ const int start_to_ref_offset = get_relative_dist(
+ order_hint_info, start_frame_order_hint, ref_order_hints[ref]);
+ const int cur_to_ref_offset = get_relative_dist(
+ order_hint_info, cur_order_hint, ref_order_hints[ref]);
+ const int abs_start_to_ref_offset = abs(start_to_ref_offset);
+ const int is_two_sides =
+ (start_to_ref_offset > 0 && cur_to_ref_offset > 0 &&
+ find_forward_ref == 1) ||
+ (start_to_ref_offset < 0 && cur_to_ref_offset < 0 &&
+ find_forward_ref == 0);
+ if (is_two_sides && abs_start_to_ref_offset < abs_closest_ref_offset) {
+ abs_closest_ref_offset = abs_start_to_ref_offset;
+ }
+ }
+ }
+
+ return abs_closest_ref_offset;
+}
+#endif // CONFIG_MF_IMPROVEMENT
+
#if CONFIG_TIP
// Note: motion_filed_projection finds motion vectors of current frame's
// reference frame, and projects them to current frame. To make it clear,
@@ -3035,8 +3256,13 @@
get_ref_frame_buf(cm, start_frame);
if (!is_ref_motion_field_eligible(cm, start_frame_buf)) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int start_frame_order_hint = start_frame_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int start_frame_order_hint = start_frame_buf->order_hint;
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int start_to_current_frame_offset = get_relative_dist(
&cm->seq_params.order_hint_info, start_frame_order_hint, cur_order_hint);
@@ -3053,7 +3279,12 @@
assert(start_frame_buf->width == cm->width &&
start_frame_buf->height == cm->height);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints =
+ &start_frame_buf->ref_display_order_hint[0];
+#else
const int *const ref_order_hints = &start_frame_buf->ref_order_hints[0];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
for (MV_REFERENCE_FRAME rf = 0; rf < INTER_REFS_PER_FRAME; ++rf) {
if (ref_order_hints[rf] != -1) {
ref_offset[rf] =
@@ -3126,8 +3357,13 @@
get_ref_frame_buf(cm, start_frame);
if (!is_ref_motion_field_eligible(cm, start_frame_buf)) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int start_frame_order_hint = start_frame_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int start_frame_order_hint = start_frame_buf->order_hint;
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int start_to_current_frame_offset = get_relative_dist(
&cm->seq_params.order_hint_info, start_frame_order_hint, cur_order_hint);
@@ -3143,7 +3379,12 @@
assert(start_frame_buf->width == cm->width &&
start_frame_buf->height == cm->height);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints =
+ &start_frame_buf->ref_display_order_hint[0];
+#else
const int *const ref_order_hints = &start_frame_buf->ref_order_hints[0];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
for (MV_REFERENCE_FRAME rf = 0; rf < INTER_REFS_PER_FRAME; ++rf) {
if (ref_order_hints[rf] != -1) {
ref_offset[rf] =
@@ -3206,7 +3447,7 @@
// Call Start frame's reference frames as reference frames.
// Call ref_offset as frame distances between start frame and its reference
// frames.
-#if CONFIG_TMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
static int motion_field_projection_bwd(AV1_COMMON *cm,
MV_REFERENCE_FRAME start_frame, int dir,
int overwrite_mv) {
@@ -3217,15 +3458,25 @@
get_ref_frame_buf(cm, start_frame);
if (!is_ref_motion_field_eligible(cm, start_frame_buf)) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int start_frame_order_hint = start_frame_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int start_frame_order_hint = start_frame_buf->order_hint;
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int start_to_current_frame_offset = get_relative_dist(
&cm->seq_params.order_hint_info, start_frame_order_hint, cur_order_hint);
assert(start_frame_buf->width == cm->width &&
start_frame_buf->height == cm->height);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints =
+ &start_frame_buf->ref_display_order_hint[0];
+#else
const int *const ref_order_hints = &start_frame_buf->ref_order_hints[0];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
for (MV_REFERENCE_FRAME rf = 0; rf < INTER_REFS_PER_FRAME; ++rf) {
if (ref_order_hints[rf] != -1)
ref_offset[rf] =
@@ -3280,7 +3531,7 @@
return 1;
}
-#endif // CONFIG_TMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
static int motion_field_projection(AV1_COMMON *cm,
MV_REFERENCE_FRAME start_frame, int dir,
@@ -3292,15 +3543,25 @@
get_ref_frame_buf(cm, start_frame);
if (!is_ref_motion_field_eligible(cm, start_frame_buf)) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int start_frame_order_hint = start_frame_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int start_frame_order_hint = start_frame_buf->order_hint;
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int start_to_current_frame_offset = get_relative_dist(
&cm->seq_params.order_hint_info, start_frame_order_hint, cur_order_hint);
assert(start_frame_buf->width == cm->width &&
start_frame_buf->height == cm->height);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints =
+ &start_frame_buf->ref_display_order_hint[0];
+#else
const int *const ref_order_hints = &start_frame_buf->ref_order_hints[0];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
for (MV_REFERENCE_FRAME rf = 0; rf < INTER_REFS_PER_FRAME; ++rf) {
if (ref_order_hints[rf] != -1)
ref_offset[rf] =
@@ -3360,6 +3621,16 @@
if (!order_hint_info->enable_order_hint) return -1;
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref);
if (buf == NULL) return -1;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = buf->display_order_hint;
+ for (int r = 0; r < INTER_REFS_PER_FRAME; ++r) {
+ if (buf->ref_display_order_hint[r] == -1) continue;
+ const int ref_ref_order_hint = buf->ref_display_order_hint[r];
+ if (get_relative_dist(order_hint_info, ref_order_hint,
+ ref_ref_order_hint) == 0)
+ return 1;
+ }
+#else
const int ref_order_hint = buf->order_hint;
for (int r = 0; r < INTER_REFS_PER_FRAME; ++r) {
if (buf->ref_order_hints[r] == -1) continue;
@@ -3368,6 +3639,7 @@
ref_ref_order_hint) == 0)
return 1;
}
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
return 0;
}
@@ -3405,33 +3677,51 @@
cm->ref_frame_side[ref_frame] = 0;
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
ref_buf[ref_frame] = buf;
-#if CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int relative_dist =
+ get_relative_dist(order_hint_info, buf->display_order_hint,
+ cm->cur_frame->display_order_hint);
+#else
const int relative_dist = get_relative_dist(
order_hint_info, buf->order_hint, cm->cur_frame->order_hint);
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
cm->ref_frame_relative_dist[ref_frame] = abs(relative_dist);
-#endif // CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
}
for (int index = 0; index < cm->ref_frames_info.num_future_refs; index++) {
const int ref_frame = cm->ref_frames_info.future_refs[index];
cm->ref_frame_side[ref_frame] = 1;
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
ref_buf[ref_frame] = buf;
-#if CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int relative_dist =
+ get_relative_dist(order_hint_info, buf->display_order_hint,
+ cm->cur_frame->display_order_hint);
+#else
const int relative_dist = get_relative_dist(
order_hint_info, buf->order_hint, cm->cur_frame->order_hint);
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
cm->ref_frame_relative_dist[ref_frame] = abs(relative_dist);
-#endif // CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
}
for (int index = 0; index < cm->ref_frames_info.num_cur_refs; index++) {
const int ref_frame = cm->ref_frames_info.cur_refs[index];
cm->ref_frame_side[ref_frame] = -1;
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
ref_buf[ref_frame] = buf;
-#if CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int relative_dist =
+ get_relative_dist(order_hint_info, buf->display_order_hint,
+ cm->cur_frame->display_order_hint);
+#else
const int relative_dist = get_relative_dist(
order_hint_info, buf->order_hint, cm->cur_frame->order_hint);
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
cm->ref_frame_relative_dist[ref_frame] = abs(relative_dist);
-#endif // CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
}
#if CONFIG_TIP
@@ -3468,7 +3758,51 @@
closest_ref[dir][1] = ref_frame;
}
}
-#if CONFIG_TMVP_IMPROVEMENT || CONFIG_TIP
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_TIP
+#if CONFIG_MF_IMPROVEMENT
+ // Do projection on group 0 (closest past (backward MV), closest future),
+ // group 1(second closest future, second closest past (backward MV)),
+ // closest past (forward MV), and then second closest past (forward MVs),
+ // without overwriting the MVs.
+ // The projection order of the ref frames in group 0 and group 1 depends
+ // on the ref frame to its own first ref frame that has interpolation
+ // property relative to current frame. Interpolation means two frames are on
+ // two sides of current frame
+ for (int group_idx = 0; group_idx < 2; ++group_idx) {
+ const int past_ref_to_its_ref_dist =
+ get_dist_to_closest_interp_ref(cm, closest_ref[0][group_idx], 0);
+ const int future_ref_to_its_ref_dist =
+ get_dist_to_closest_interp_ref(cm, closest_ref[1][group_idx], 1);
+ if (future_ref_to_its_ref_dist < past_ref_to_its_ref_dist) {
+ if (closest_ref[1][group_idx] != -1 && n_refs_used < MFMV_STACK_SIZE) {
+ n_refs_used +=
+ motion_field_projection(cm, closest_ref[1][group_idx], 0, 0);
+ }
+
+ if (closest_ref[0][group_idx] != -1 && n_refs_used < MFMV_STACK_SIZE) {
+ n_refs_used +=
+ motion_field_projection_bwd(cm, closest_ref[0][group_idx], 2, 0);
+ }
+ } else {
+ if (closest_ref[0][group_idx] != -1 && n_refs_used < MFMV_STACK_SIZE) {
+ n_refs_used +=
+ motion_field_projection_bwd(cm, closest_ref[0][group_idx], 2, 0);
+ }
+ if (closest_ref[1][group_idx] != -1 && n_refs_used < MFMV_STACK_SIZE) {
+ n_refs_used +=
+ motion_field_projection(cm, closest_ref[1][group_idx], 0, 0);
+ }
+ }
+ }
+
+ if (closest_ref[0][0] != -1 && n_refs_used < MFMV_STACK_SIZE) {
+ n_refs_used += motion_field_projection(cm, closest_ref[0][0], 2, 0);
+ }
+
+ if (closest_ref[0][1] != -1 && n_refs_used < MFMV_STACK_SIZE) {
+ motion_field_projection(cm, closest_ref[0][1], 2, 0);
+ }
+#else
// Do projection on closest past (backward MV), closest future, second
// closest future, second closest past (backward MV), closest path (forward
// MV), and then second closest past (forward MVs), without overwriting
@@ -3496,6 +3830,7 @@
if (closest_ref[0][1] != -1 && n_refs_used < MFMV_STACK_SIZE) {
motion_field_projection(cm, closest_ref[0][1], 2, 0);
}
+#endif // CONFIG_MF_IMPROVEMENT
#else
// Do projection on closest past and future refs if they exist
if (closest_ref[0][0] != -1) {
@@ -3516,24 +3851,32 @@
const int ret = motion_field_projection(cm, closest_ref[0][1], 2, 1);
n_refs_used += ret;
}
-#endif // CONFIG_TMVP_IMPROVEMENT || CONFIG_TIP
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_TIP
}
-#if CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#if CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
void av1_setup_ref_frame_sides(AV1_COMMON *cm) {
const OrderHintInfo *const order_hint_info = &cm->seq_params.order_hint_info;
memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side));
if (!order_hint_info->enable_order_hint) return;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
for (int ref_frame = 0; ref_frame < cm->ref_frames_info.num_total_refs;
ref_frame++) {
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
int order_hint = 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ if (buf != NULL) order_hint = buf->display_order_hint;
+#else
if (buf != NULL) order_hint = buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int relative_dist =
get_relative_dist(order_hint_info, order_hint, cur_order_hint);
if (relative_dist > 0) {
@@ -3544,7 +3887,7 @@
cm->ref_frame_relative_dist[ref_frame] = abs(relative_dist);
}
}
-#endif // CONFIG_SMVP_IMPROVEMENT || CONFIG_JOINT_MVD
+#endif // CONFIG_MVP_IMPROVEMENT || CONFIG_JOINT_MVD
static INLINE void record_samples(const MB_MODE_INFO *mbmi,
#if CONFIG_COMPOUND_WARP_SAMPLES
@@ -3847,7 +4190,11 @@
skip_mode_info->ref_frame_idx_0 = 0;
}
#else
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int cur_order_hint = cm->current_frame.display_order_hint;
+#else
const int cur_order_hint = cm->current_frame.order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int ref_order_hints[2] = { -1, INT_MAX };
int ref_idx[2] = { INVALID_IDX, INVALID_IDX };
@@ -3856,7 +4203,11 @@
const RefCntBuffer *const buf = get_ref_frame_buf(cm, i);
if (buf == NULL) continue;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = buf->display_order_hint;
+#else
const int ref_order_hint = buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
if (get_relative_dist(order_hint_info, ref_order_hint, cur_order_hint) <
0) {
// Forward reference
@@ -3896,7 +4247,11 @@
const RefCntBuffer *const buf = get_ref_frame_buf(cm, i);
if (buf == NULL) continue;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = buf->display_order_hint;
+#else
const int ref_order_hint = buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
if ((ref_order_hints[0] != -1 &&
get_relative_dist(order_hint_info, ref_order_hint,
ref_order_hints[0]) < 0) &&
@@ -3966,6 +4321,9 @@
const int idx = (start_idx + count) % REF_MV_BANK_SIZE;
queue[idx].this_mv = mbmi->mv[0];
if (is_comp) queue[idx].comp_mv = mbmi->mv[1];
+#if CONFIG_CWP
+ queue[idx].cwp_idx = mbmi->cwp_idx;
+#endif // CONFIG_CWP
if (count < REF_MV_BANK_SIZE) {
++ref_mv_bank->rmb_count[ref_frame];
} else {
@@ -4011,8 +4369,8 @@
clamp(mv_row, MV_LOW + 1, MV_UPP - 1);
submi[mi_y * mi_stride + mi_x]->mv[0].as_mv.col =
clamp(mv_col, MV_LOW + 1, MV_UPP - 1);
- span_submv(cm, (submi + mi_y * mi_stride + mi_x), mi_row, mi_col,
- BLOCK_8X8);
+ span_submv(cm, (submi + mi_y * mi_stride + mi_x), mi_row + mi_y,
+ mi_col + mi_x, BLOCK_8X8);
}
}
}
@@ -4136,7 +4494,14 @@
num_wrl_cand * sizeof(wrl_list[0]));
if (p_valid_num_candidates) {
// for NEARMV mode, the maximum number of candidates is 1
- *p_valid_num_candidates = (mbmi->mode == NEARMV) ? 1 : num_wrl_cand;
+ *p_valid_num_candidates = (mbmi->mode == NEARMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || mbmi->mode == AMVDNEWMV
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+ )
+ ? 1
+ : num_wrl_cand;
}
}
@@ -4472,3 +4837,98 @@
return ctx;
}
#endif // CONFIG_WARPMV
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+// return 1 if valid point is found
+// return 0 if the point is not valid
+static int fill_warp_corner_projected_point(const MB_MODE_INFO *neighbor_mi,
+ MV_REFERENCE_FRAME this_ref,
+ const int pos_col,
+ const int pos_row, int *pts,
+ int *mvs, int *n_points) {
+ // return if the source point is invalid
+ if (pos_col < 0 || pos_row < 0) return 0;
+
+ if (!is_inter_ref_frame(neighbor_mi->ref_frame[0])) return 0;
+ if (neighbor_mi->ref_frame[0] != this_ref) return 0;
+ int mv_row;
+ int mv_col;
+ if (is_warp_mode(neighbor_mi->motion_mode)) {
+ int_mv warp_mv =
+ get_warp_motion_vector_xy_pos(&neighbor_mi->wm_params[0], pos_col,
+ pos_row, MV_PRECISION_ONE_EIGHTH_PEL);
+ mv_row = warp_mv.as_mv.row;
+ mv_col = warp_mv.as_mv.col;
+ } else {
+ mv_row = neighbor_mi->mv[0].as_mv.row;
+ mv_col = neighbor_mi->mv[0].as_mv.col;
+ }
+ pts[2 * (*n_points)] = pos_col;
+ pts[2 * (*n_points) + 1] = pos_row;
+ mvs[2 * (*n_points)] = mv_col;
+ mvs[2 * (*n_points) + 1] = mv_row;
+ ++(*n_points);
+ return 1;
+}
+// Check all 3 neighbors to generate projected points
+int generate_points_from_corners(const MACROBLOCKD *xd, int *pts, int *mvs,
+ int *np, MV_REFERENCE_FRAME ref_frame) {
+ const TileInfo *const tile = &xd->tile;
+ POSITION mi_pos;
+ int valid_points = 0;
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame);
+ MV_REFERENCE_FRAME this_ref = rf[0];
+ const int bw = xd->width * MI_SIZE;
+ const int bh = xd->height * MI_SIZE;
+
+ // top-left
+ mi_pos.row = -1;
+ mi_pos.col = -1;
+ if (is_inside(tile, xd->mi_col, xd->mi_row, &mi_pos) && xd->up_available &&
+ xd->left_available) {
+ const MB_MODE_INFO *neighbor_mi =
+ xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col];
+ int pos_row = xd->mi_row * MI_SIZE;
+ int pos_col = xd->mi_col * MI_SIZE;
+ int valid = fill_warp_corner_projected_point(neighbor_mi, this_ref, pos_col,
+ pos_row, pts, mvs, np);
+ if (valid) {
+ valid_points++;
+ }
+ }
+
+ // top-right
+ mi_pos.row = -1;
+ mi_pos.col = xd->width - 1;
+ if (is_inside(tile, xd->mi_col, xd->mi_row, &mi_pos) && xd->up_available) {
+ const MB_MODE_INFO *neighbor_mi =
+ xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col];
+ int pos_row = xd->mi_row * MI_SIZE;
+ int pos_col = xd->mi_col * MI_SIZE + bw;
+ int valid = fill_warp_corner_projected_point(neighbor_mi, this_ref, pos_col,
+ pos_row, pts, mvs, np);
+ if (valid) {
+ valid_points++;
+ }
+ }
+
+ // bottom-left
+ mi_pos.row = xd->height - 1;
+ mi_pos.col = -1;
+ if (is_inside(tile, xd->mi_col, xd->mi_row, &mi_pos) && xd->left_available) {
+ const MB_MODE_INFO *neighbor_mi =
+ xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col];
+ int pos_row = xd->mi_row * MI_SIZE + bh;
+ int pos_col = xd->mi_col * MI_SIZE;
+ int valid = fill_warp_corner_projected_point(neighbor_mi, this_ref, pos_col,
+ pos_row, pts, mvs, np);
+ if (valid) {
+ valid_points++;
+ }
+ }
+
+ assert(valid_points <= 3);
+ return valid_points;
+}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
diff --git a/av1/common/mvref_common.h b/av1/common/mvref_common.h
index 831869a..41f3452 100644
--- a/av1/common/mvref_common.h
+++ b/av1/common/mvref_common.h
@@ -22,12 +22,12 @@
extern "C" {
#endif
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
#define MVREF_ROWS 1
#define MVREF_COLS 3
#else
#define MVREF_ROW_COLS 3
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
// Set the upper limit of the motion vector component magnitude.
// This would make a motion vector fit in 26 bits. Plus 3 bits for the
@@ -48,14 +48,26 @@
static AOM_INLINE int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c,
int blk_row, int blk_col, MV mv,
int sign_bias) {
+#if CONFIG_MF_IMPROVEMENT
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ const int sb_size = block_size_high[seq_params->sb_size];
+ const int mf_sb_size_log2 = (sb_size <= 64 ? mi_size_high_log2[BLOCK_64X64]
+ : seq_params->mib_size_log2) +
+ MI_SIZE_LOG2;
+ const int mf_sb_size = (1 << mf_sb_size_log2);
+ const int sb_tmvp_size = (mf_sb_size >> TMVP_MI_SZ_LOG2);
+ const int sb_tmvp_size_log2 = mf_sb_size_log2 - TMVP_MI_SZ_LOG2;
+ const int base_blk_row = (blk_row >> sb_tmvp_size_log2) << sb_tmvp_size_log2;
+ const int base_blk_col = (blk_col >> sb_tmvp_size_log2) << sb_tmvp_size_log2;
+#else
const int base_blk_row = (blk_row >> TMVP_MI_SZ_LOG2) << TMVP_MI_SZ_LOG2;
const int base_blk_col = (blk_col >> TMVP_MI_SZ_LOG2) << TMVP_MI_SZ_LOG2;
+#endif // CONFIG_MF_IMPROVEMENT
// The motion vector in units of 1/8-pel
const int shift = (3 + TMVP_MI_SZ_LOG2);
const int row_offset =
(mv.row >= 0) ? (mv.row >> shift) : -((-mv.row) >> shift);
-
const int col_offset =
(mv.col >= 0) ? (mv.col >> shift) : -((-mv.col) >> shift);
@@ -68,10 +80,17 @@
col >= (cm->mi_params.mi_cols >> TMVP_SHIFT_BITS))
return 0;
+#if CONFIG_MF_IMPROVEMENT
+ if (row < base_blk_row - MAX_OFFSET_HEIGHT_LOG2 ||
+ row >= base_blk_row + sb_tmvp_size + MAX_OFFSET_HEIGHT_LOG2 ||
+ col < base_blk_col - sb_tmvp_size ||
+ col >= base_blk_col + (sb_tmvp_size << 1))
+#else
if (row < base_blk_row - MAX_OFFSET_HEIGHT_LOG2 ||
row >= base_blk_row + TMVP_MI_SIZE + MAX_OFFSET_HEIGHT_LOG2 ||
col < base_blk_col - MAX_OFFSET_WIDTH_LOG2 ||
col >= base_blk_col + TMVP_MI_SIZE + MAX_OFFSET_WIDTH_LOG2)
+#endif // CONFIG_MF_IMPROVEMENT
return 0;
*mi_r = row;
@@ -84,15 +103,24 @@
// clamp_mv_ref
#define MV_BORDER (16 << 3) // Allow 16 pels in 1/8th pel units
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+#define DISPLAY_ORDER_HINT_BITS 31
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+
static INLINE int get_relative_dist(const OrderHintInfo *oh, int a, int b) {
if (!oh->enable_order_hint) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ assert(a >= 0);
+ assert(b >= 0);
+ const int bits = DISPLAY_ORDER_HINT_BITS;
+#else
const int bits = oh->order_hint_bits_minus_1 + 1;
assert(bits >= 1);
assert(a >= 0 && a < (1 << bits));
assert(b >= 0 && b < (1 << bits));
-
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int diff = a - b;
const int m = 1 << (bits - 1);
diff = (diff & (m - 1)) - (diff & m);
@@ -399,6 +427,31 @@
}
}
+#if CONFIG_SEP_COMP_DRL
+/*!\brief Return ref_mv_idx_type of the current coding block
+ * conversion of two ref_mv_idx(s) into one value when there are two DRLs */
+static INLINE int av1_ref_mv_idx_type(const MB_MODE_INFO *mbmi,
+ const int *ref_mv_idx) {
+ assert(ref_mv_idx[0] < MAX_REF_MV_STACK_SIZE);
+ assert(ref_mv_idx[1] < MAX_REF_MV_STACK_SIZE);
+ if (has_second_drl(mbmi)) {
+ return ref_mv_idx[1] * MAX_REF_MV_STACK_SIZE + ref_mv_idx[0];
+ } else {
+ assert(0 == ref_mv_idx[1]);
+ return ref_mv_idx[0];
+ }
+}
+
+/*!\brief Reset ref_mv_idx(s) based on the ref_mv_idx_type value */
+static INLINE void av1_set_ref_mv_idx(int *ref_mv_idx, int ref_mv_idx_type) {
+ assert(ref_mv_idx_type >= 0 &&
+ ref_mv_idx_type < MAX_REF_MV_STACK_SIZE * MAX_REF_MV_STACK_SIZE);
+ ref_mv_idx[1] = ref_mv_idx_type / MAX_REF_MV_STACK_SIZE;
+ ref_mv_idx[0] = ref_mv_idx_type - ref_mv_idx[1] * MAX_REF_MV_STACK_SIZE;
+ return;
+}
+#endif // CONFIG_SEP_COMP_DRL
+
static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf,
MV_REFERENCE_FRAME ref_frame_type) {
if (ref_frame_type == INTRA_FRAME ||
@@ -496,9 +549,9 @@
void av1_setup_frame_sign_bias(AV1_COMMON *cm);
void av1_setup_skip_mode_allowed(AV1_COMMON *cm);
void av1_setup_motion_field(AV1_COMMON *cm);
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
void av1_setup_ref_frame_sides(AV1_COMMON *cm);
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
static INLINE void av1_collect_neighbors_ref_counts(MACROBLOCKD *const xd) {
av1_zero(xd->neighbors_ref_counts);
@@ -760,12 +813,32 @@
// Special case for sub 8x8 chroma cases, to prevent referring to chroma
// pixels outside current tile.
- if (xd->is_chroma_ref && av1_num_planes(cm) > 1) {
- const struct macroblockd_plane *const pd = &xd->plane[1];
- if (bw < 8 && pd->subsampling_x)
- if (src_left_edge < tile_left_edge + 4 * SCALE_PX_TO_MV) return 0;
- if (bh < 8 && pd->subsampling_y)
- if (src_top_edge < tile_top_edge + 4 * SCALE_PX_TO_MV) return 0;
+ if (!cm->seq_params.enable_sdp || !frame_is_intra_only(cm)) {
+ if (xd->is_chroma_ref && av1_num_planes(cm) > 1) {
+ const struct macroblockd_plane *const pd = &xd->plane[1];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (xd->mi && xd->mi[0]) {
+ const CHROMA_REF_INFO *chroma_ref_info = &xd->mi[0]->chroma_ref_info;
+ const int src_left_edge_chroma =
+ chroma_ref_info->mi_col_chroma_base * MI_SIZE * SCALE_PX_TO_MV +
+ dv.col;
+ const int src_top_edge_chroma =
+ chroma_ref_info->mi_row_chroma_base * MI_SIZE * SCALE_PX_TO_MV +
+ dv.row;
+ if (bw < 8 && pd->subsampling_x)
+ if (src_left_edge_chroma < tile_left_edge) return 0;
+ if (bh < 8 && pd->subsampling_y)
+ if (src_top_edge_chroma < tile_top_edge) return 0;
+ } else {
+#endif
+ if (bw < 8 && pd->subsampling_x)
+ if (src_left_edge < tile_left_edge + 4 * SCALE_PX_TO_MV) return 0;
+ if (bh < 8 && pd->subsampling_y)
+ if (src_top_edge < tile_top_edge + 4 * SCALE_PX_TO_MV) return 0;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ }
+#endif
+ }
}
#if CONFIG_IBC_SR_EXT
@@ -1134,6 +1207,13 @@
return 1;
}
+#if CONFIG_CWG_D067_IMPROVED_WARP
+// Check all 3 neighbors to generate projected points
+int generate_points_from_corners(const MACROBLOCKD *xd, int *pts, int *mvs,
+ int *np, MV_REFERENCE_FRAME ref_frame);
+
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/common/obmc.h b/av1/common/obmc.h
index a51820b..dfa5357 100644
--- a/av1/common/obmc.h
+++ b/av1/common/obmc.h
@@ -21,12 +21,14 @@
static INLINE void foreach_overlappable_nb_above(const AV1_COMMON *cm,
MACROBLOCKD *xd, int nb_max,
overlappable_nb_visitor_t fun,
- void *fun_ctxt) {
+ void *fun_ctxt,
+ bool count_only) {
if (!xd->up_available) return;
const int num_planes = av1_num_planes(cm);
int nb_count = 0;
const int mi_col = xd->mi_col;
+
// prev_row_mi points into the mi array, starting at the beginning of the
// previous row.
MB_MODE_INFO **prev_row_mi = xd->mi - mi_col - 1 * xd->mi_stride;
@@ -35,8 +37,41 @@
for (int above_mi_col = mi_col; above_mi_col < end_col && nb_count < nb_max;
above_mi_col += mi_step) {
MB_MODE_INFO **above_mi = prev_row_mi + above_mi_col;
- mi_step = AOMMIN(mi_size_wide[above_mi[0]->sb_type[PLANE_TYPE_Y]],
- mi_size_wide[BLOCK_64X64]);
+ mi_step = mi_size_wide[above_mi[0]->sb_type[PLANE_TYPE_Y]];
+#if CONFIG_UNEVEN_4WAY
+ if (count_only) {
+ // In this case, we may only be parsing without decoding (e.g. in case of
+ // row-baed multi-threading). Hence, we do not have access to variables
+ // `above_mi[0]->chroma_ref_info` and `above_mi[0]->mi_col_start`.
+ // Also, if mi_step = 1, it must be a non-chroma ref block. So, we use
+ // mi_step = 2.
+ if (mi_step == 1) {
+ mi_step = 2;
+ }
+ } else {
+ // If we're considering a block that is NOT a chroma ref:
+ // - Move above_mi_col back to the base mi col,
+ // - Set above_mbmi to point at the block with chroma information, and
+ // - Set mi_step to step over all blocks that the chroma block covers.
+ const CHROMA_REF_INFO *chroma_ref_info = &above_mi[0]->chroma_ref_info;
+ if (!chroma_ref_info->is_chroma_ref) {
+ above_mi_col = chroma_ref_info->mi_col_chroma_base;
+ mi_step = mi_size_wide[chroma_ref_info->bsize_base];
+ if (above_mi_col < mi_col) continue;
+ above_mi = prev_row_mi + above_mi_col;
+ assert(above_mi[0]->chroma_ref_info.bsize_base ==
+ chroma_ref_info->bsize_base);
+ }
+ // If above block's left boundary is to the left of current block's left
+ // boundary, we need to find the common overlap.
+ if (above_mi[0]->mi_col_start < above_mi_col) {
+ const int extra_cols = above_mi_col - above_mi[0]->mi_col_start;
+ mi_step -= extra_cols;
+ assert(mi_step > 0);
+ }
+ }
+#else
+ (void)count_only;
// If we're considering a block with width 4, it should be treated as
// half of a pair of blocks with chroma information in the second. Move
// above_mi_col back to the start of the pair if needed, set above_mbmi
@@ -47,11 +82,25 @@
above_mi = prev_row_mi + above_mi_col + 1;
mi_step = 2;
}
+#endif // CONFIG_UNEVEN_4WAY
+ mi_step = AOMMIN(mi_step, mi_size_wide[BLOCK_64X64]);
+ int overlapped_mi_width = AOMMIN(xd->width, mi_step);
+#if CONFIG_UNEVEN_4WAY
+ if (!IS_POWER_OF_TWO(overlapped_mi_width)) {
+ assert(!IS_POWER_OF_TWO(mi_step));
+ const int mi_step_pow2 = 1 << get_msb(mi_step);
+ above_mi_col += (mi_step - mi_step_pow2);
+ mi_step = mi_step_pow2;
+ overlapped_mi_width = AOMMIN(xd->width, mi_step);
+ }
+#endif // CONFIG_UNEVEN_4WAY
+ assert(IS_POWER_OF_TWO(overlapped_mi_width));
if (is_neighbor_overlappable(*above_mi, xd->tree_type)) {
++nb_count;
- fun(xd, 0, above_mi_col - mi_col, AOMMIN(xd->width, mi_step), 0,
- *above_mi, fun_ctxt, num_planes);
+ assert(above_mi_col >= mi_col);
+ fun(xd, 0, above_mi_col - mi_col, overlapped_mi_width, 0, *above_mi,
+ fun_ctxt, num_planes);
}
}
}
@@ -73,17 +122,52 @@
for (int left_mi_row = mi_row; left_mi_row < end_row && nb_count < nb_max;
left_mi_row += mi_step) {
MB_MODE_INFO **left_mi = prev_col_mi + left_mi_row * xd->mi_stride;
- mi_step = AOMMIN(mi_size_high[left_mi[0]->sb_type[PLANE_TYPE_Y]],
- mi_size_high[BLOCK_64X64]);
+ mi_step = mi_size_high[left_mi[0]->sb_type[PLANE_TYPE_Y]];
+#if CONFIG_UNEVEN_4WAY
+ // If we're considering a block that is NOT a chroma ref:
+ // - Move left_mi_col back to the base mi col,
+ // - Set left_mbmi to point at the block with chroma information, and
+ // - Set mi_step to step over all blocks that the chroma block covers.
+ const CHROMA_REF_INFO *chroma_ref_info = &left_mi[0]->chroma_ref_info;
+ if (!chroma_ref_info->is_chroma_ref) {
+ left_mi_row = chroma_ref_info->mi_row_chroma_base;
+ mi_step = mi_size_high[chroma_ref_info->bsize_base];
+ if (left_mi_row < mi_row) continue;
+ left_mi = prev_col_mi + left_mi_row * xd->mi_stride;
+ assert(left_mi[0]->chroma_ref_info.bsize_base ==
+ chroma_ref_info->bsize_base);
+ }
+ // If left block's top boundary is above current block's top boundary, we
+ // need to find the common overlap.
+ if (left_mi[0]->mi_row_start < left_mi_row) {
+ const int extra_cols = left_mi_row - left_mi[0]->mi_row_start;
+ mi_step -= extra_cols;
+ assert(mi_step > 0);
+ }
+#else
if (mi_step == 1) {
left_mi_row &= ~1;
left_mi = prev_col_mi + (left_mi_row + 1) * xd->mi_stride;
mi_step = 2;
}
+#endif // CONFIG_UNEVEN_4WAY
+ mi_step = AOMMIN(mi_step, mi_size_high[BLOCK_64X64]);
+ int overlapped_mi_height = AOMMIN(xd->height, mi_step);
+#if CONFIG_UNEVEN_4WAY
+ if (!IS_POWER_OF_TWO(overlapped_mi_height)) {
+ assert(!IS_POWER_OF_TWO(mi_step));
+ const int mi_step_pow2 = 1 << get_msb(mi_step);
+ left_mi_row += (mi_step - mi_step_pow2);
+ mi_step = mi_step_pow2;
+ overlapped_mi_height = AOMMIN(xd->height, mi_step);
+ }
+#endif // CONFIG_UNEVEN_4WAY
+ assert(IS_POWER_OF_TWO(overlapped_mi_height));
if (is_neighbor_overlappable(*left_mi, xd->tree_type)) {
++nb_count;
- fun(xd, left_mi_row - mi_row, 0, AOMMIN(xd->height, mi_step), 1, *left_mi,
+ assert(left_mi_row >= mi_row);
+ fun(xd, left_mi_row - mi_row, 0, overlapped_mi_height, 1, *left_mi,
fun_ctxt, num_planes);
}
}
diff --git a/av1/common/pef.c b/av1/common/pef.c
index b84222c..c5587dd 100644
--- a/av1/common/pef.c
+++ b/av1/common/pef.c
@@ -169,6 +169,9 @@
// setup PEF input structure
void setup_pef_input(MACROBLOCKD *xd, int pef_mode, int plane, uint16_t *dst,
int dst_stride, int bw, int bh, int_mv *mv_refined,
+#if CONFIG_REFINEMV
+ REFINEMV_SUBMB_INFO *refinemv_subinfo,
+#endif // CONFIG_REFINEMV
PefFuncInput *pef_input) {
pef_input->pef_mode = pef_mode;
pef_input->plane = plane;
@@ -180,6 +183,9 @@
pef_input->dst = dst;
pef_input->dst_stride = dst_stride;
pef_input->mv_refined = mv_refined;
+#if CONFIG_REFINEMV
+ pef_input->refinemv_subinfo = refinemv_subinfo;
+#endif // CONFIG_REFINEMV
}
#if CONFIG_OPTFLOW_REFINEMENT
@@ -191,8 +197,17 @@
// check if the neighboring mvs are the same
void check_mv(bool *diff_mv, int pef_mode, int mv_rows, int mv_cols,
int mvs_stride, const TPL_MV_REF *tpl_mvs, int tip_step,
- int n_blocks, int_mv *mv_refined, int opfl_step) {
+ int n_blocks, int_mv *mv_refined, int opfl_step
+#if CONFIG_REFINEMV
+ ,
+ REFINEMV_SUBMB_INFO *refinemv_subinfo, int refinemv_step
+#endif // CONFIG_REFINEMV
+) {
+#if CONFIG_REFINEMV
+ if (pef_mode < 0 || pef_mode > 3) return;
+#else
if (pef_mode < 0 || pef_mode > 2) return;
+#endif // CONFIG_REFINEMV
if (pef_mode == 0) { // opfl mv
const int_mv *cur_mv_refined_ref0 = &mv_refined[n_blocks * 2 + 0];
const int_mv *cur_mv_refined_ref1 = &mv_refined[n_blocks * 2 + 1];
@@ -200,6 +215,17 @@
cur_mv_refined_ref0[0].as_int != cur_mv_refined_ref0[-opfl_step].as_int;
*diff_mv |=
cur_mv_refined_ref1[0].as_int != cur_mv_refined_ref1[-opfl_step].as_int;
+#if CONFIG_REFINEMV
+ } else if (pef_mode == 3) { // refinemv mv
+ const int_mv *cur_mv_refined_ref0 = &refinemv_subinfo->refinemv[0];
+ const int_mv *cur_mv_refined_ref1 = &refinemv_subinfo->refinemv[1];
+ const int_mv *prev_mv_refined_ref0 =
+ &refinemv_subinfo[-refinemv_step].refinemv[0];
+ const int_mv *prev_mv_refined_ref1 =
+ &refinemv_subinfo[-refinemv_step].refinemv[1];
+ *diff_mv = cur_mv_refined_ref0[0].as_int != prev_mv_refined_ref0[0].as_int;
+ *diff_mv |= cur_mv_refined_ref1[0].as_int != prev_mv_refined_ref1[0].as_int;
+#endif // CONFIG_REFINEMV
} else { // tip mv
const TPL_MV_REF *cur_tpl_mv = tpl_mvs + mv_rows * mvs_stride + mv_cols;
const TPL_MV_REF *prev_tpl_mv = cur_tpl_mv - tip_step;
@@ -344,7 +370,16 @@
AOMMIN(prev_x_step, x_step) >= filt_len) {
bool diff_mv = 0;
check_mv(&diff_mv, pef_mode, mv_rows, mv_cols, mvs_stride, tpl_mvs, 1,
- n_blocks, pef_input->mv_refined, 2);
+ n_blocks, pef_input->mv_refined, 2
+#if CONFIG_REFINEMV
+ ,
+ (pef_mode == 3) ? (pef_input->refinemv_subinfo +
+ (j >> MI_SIZE_LOG2) * MAX_MIB_SIZE +
+ (i >> MI_SIZE_LOG2))
+ : NULL,
+ 1
+#endif // CONFIG_REFINEMV
+ );
if (diff_mv) {
filt_func filt_vert_func =
(y_step == PEF_MCU_SZ && x_step == PEF_MCU_SZ)
@@ -359,7 +394,16 @@
AOMMIN(prev_y_step, y_step) >= filt_len) {
bool diff_mv = 0;
check_mv(&diff_mv, pef_mode, mv_rows, mv_cols, mvs_stride, tpl_mvs,
- mvs_stride, n_blocks, pef_input->mv_refined, wn);
+ mvs_stride, n_blocks, pef_input->mv_refined, wn
+#if CONFIG_REFINEMV
+ ,
+ (pef_mode == 3) ? (pef_input->refinemv_subinfo +
+ (j >> MI_SIZE_LOG2) * MAX_MIB_SIZE +
+ (i >> MI_SIZE_LOG2))
+ : NULL,
+ MAX_MIB_SIZE
+#endif // CONFIG_REFINEMV
+ );
if (diff_mv) {
filt_func filt_horz_func = x_step == PEF_MCU_SZ
? highbd_filt_horz_pred
@@ -425,7 +469,12 @@
const int dst_stride = dst_buf->stride;
PefFuncInput pef_input;
setup_pef_input(xd, 2, plane, dst, dst_stride, dst_buf->width,
- dst_buf->height, NULL, &pef_input);
+ dst_buf->height, NULL,
+#if CONFIG_REFINEMV
+
+ NULL,
+#endif // CONFIG_REFINEMV
+ &pef_input);
enhance_sub_prediction_blocks(cm, xd, &pef_input);
}
}
@@ -437,6 +486,10 @@
,
int_mv *const mv_refined, int use_opfl
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ ,
+ int use_refinemv, REFINEMV_SUBMB_INFO *refinemv_subinfo
+#endif // CONFIG_REFINEMV
) {
if (!cm->seq_params.enable_pef) return;
if (!cm->features.allow_pef) return;
@@ -445,7 +498,11 @@
const int use_tip = is_tip_ref_frame(mbmi->ref_frame[0]);
if (use_tip) {
PefFuncInput pef_input;
- setup_pef_input(xd, 1, plane, dst, dst_stride, bw, bh, NULL, &pef_input);
+ setup_pef_input(xd, 1, plane, dst, dst_stride, bw, bh, NULL,
+#if CONFIG_REFINEMV
+ NULL,
+#endif // CONFIG_REFINEMV
+ &pef_input);
enhance_sub_prediction_blocks(cm, xd, &pef_input);
return;
}
@@ -455,10 +512,22 @@
if (use_opfl) {
PefFuncInput pef_input;
setup_pef_input(xd, 0, plane, dst, dst_stride, bw, bh, mv_refined,
+#if CONFIG_REFINEMV
+ NULL,
+#endif // CONFIG_REFINEMV
&pef_input);
enhance_sub_prediction_blocks(cm, xd, &pef_input);
return;
}
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ if (use_refinemv) {
+ PefFuncInput pef_input;
+ setup_pef_input(xd, 3, plane, dst, dst_stride, bw, bh, mv_refined,
+ refinemv_subinfo, &pef_input);
+ enhance_sub_prediction_blocks(cm, xd, &pef_input);
+ return;
+ }
+#endif // CONFIG_REFINEMV
return;
}
diff --git a/av1/common/pef.h b/av1/common/pef.h
index 1363c0f..1258970 100644
--- a/av1/common/pef.h
+++ b/av1/common/pef.h
@@ -53,7 +53,8 @@
// Structure for PEF function input
typedef struct {
- // 0 for OPFL prediciton, 1 for TIP prediciton, 2 for TIP frame
+ // 0 for OPFL prediciton, 1 for TIP prediciton, 2 for TIP frame, 3 for
+ // refinemv prediction
int pef_mode;
int plane;
int bw;
@@ -64,6 +65,9 @@
uint16_t *dst;
int dst_stride;
int_mv *mv_refined;
+#if CONFIG_REFINEMV
+ REFINEMV_SUBMB_INFO *refinemv_subinfo;
+#endif // CONFIG_REFINEMV
} PefFuncInput;
typedef void (*filt_func)(uint16_t *s, int stride, int bd, uint16_t q_thresh,
@@ -84,6 +88,10 @@
,
int_mv *const mv_refined, int use_opfl
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ ,
+ int use_refinemv, REFINEMV_SUBMB_INFO *refinemv_subinfo
+#endif // CONFIG_REFINEMV
);
#ifdef __cplusplus
diff --git a/av1/common/pred_common.c b/av1/common/pred_common.c
index 39f5548..f90946b 100644
--- a/av1/common/pred_common.c
+++ b/av1/common/pred_common.c
@@ -256,9 +256,9 @@
static void palette_add_to_cache(uint16_t *cache, int *n, uint16_t val) {
// Do not add an already existing value
-#if !CONFIG_INDEP_PALETTE_PARSING
+#if !CONFIG_PALETTE_IMPROVEMENTS
if (*n > 0 && val == cache[*n - 1]) return;
-#endif //! CONFIG_INDEP_PALETTE_PARSING
+#endif //! CONFIG_PALETTE_IMPROVEMENTS
cache[(*n)++] = val;
}
@@ -286,7 +286,7 @@
while (above_n > 0 && left_n > 0) {
uint16_t v_above = above_colors[above_idx];
uint16_t v_left = left_colors[left_idx];
-#if CONFIG_INDEP_PALETTE_PARSING
+#if CONFIG_PALETTE_IMPROVEMENTS
palette_add_to_cache(cache, &n, v_above);
++above_idx, --above_n;
palette_add_to_cache(cache, &n, v_left);
@@ -300,7 +300,7 @@
++above_idx, --above_n;
if (v_left == v_above) ++left_idx, --left_n;
}
-#endif // CONFIG_INDEP_PALETTE_PARSING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
}
while (above_n-- > 0) {
uint16_t val = above_colors[above_idx++];
diff --git a/av1/common/pred_common.h b/av1/common/pred_common.h
index dc4eebb..3917992 100644
--- a/av1/common/pred_common.h
+++ b/av1/common/pred_common.h
@@ -283,11 +283,17 @@
const RefCntBuffer *const bck_buf = get_ref_frame_buf(cm, mbmi->ref_frame[0]);
const RefCntBuffer *const fwd_buf = get_ref_frame_buf(cm, mbmi->ref_frame[1]);
int bck_frame_index = 0, fwd_frame_index = 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ int cur_frame_index = cm->cur_frame->display_order_hint;
+
+ if (bck_buf != NULL) bck_frame_index = bck_buf->display_order_hint;
+ if (fwd_buf != NULL) fwd_frame_index = fwd_buf->display_order_hint;
+#else
int cur_frame_index = cm->cur_frame->order_hint;
if (bck_buf != NULL) bck_frame_index = bck_buf->order_hint;
if (fwd_buf != NULL) fwd_frame_index = fwd_buf->order_hint;
-
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int fwd = abs(get_relative_dist(&cm->seq_params.order_hint_info,
fwd_frame_index, cur_frame_index));
int bck = abs(get_relative_dist(&cm->seq_params.order_hint_info,
@@ -517,31 +523,34 @@
// The prediction flags in these dummy entries are initialized to 0.
static INLINE int get_tx_size_context(const MACROBLOCKD *xd) {
const MB_MODE_INFO *mbmi = xd->mi[0];
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
const TX_SIZE max_tx_size =
max_txsize_rect_lookup[mbmi->sb_type[PLANE_TYPE_Y]];
const int max_tx_wide = tx_size_wide[max_tx_size];
const int max_tx_high = tx_size_high[max_tx_size];
- const int default_ctx[MAX_NUM_NEIGHBORS] = {
- xd->above_txfm_context[0] >= max_tx_wide,
- xd->left_txfm_context[0] >= max_tx_high
- };
+ const int has_above = xd->up_available;
+ const int has_left = xd->left_available;
- const int max_tx_threshold[MAX_NUM_NEIGHBORS] = { max_tx_wide, max_tx_high };
+ int above = xd->above_txfm_context[0] >= max_tx_wide;
+ int left = xd->left_txfm_context[0] >= max_tx_high;
- int ctx = 0;
- for (int i = 0; i < MAX_NUM_NEIGHBORS; ++i) {
- const MB_MODE_INFO *const neighbor = xd->neighbors[i];
- if (neighbor != NULL) {
- if (is_inter_block(neighbor, xd->tree_type)) {
- const int block_size = neighbor->sb_type[PLANE_TYPE_Y];
- ctx += (block_size_wide[block_size] >= max_tx_threshold[i]);
- } else {
- ctx += default_ctx[i];
- }
- }
- }
+ if (has_above)
+ if (is_inter_block(above_mbmi, xd->tree_type))
+ above = block_size_wide[above_mbmi->sb_type[PLANE_TYPE_Y]] >= max_tx_wide;
- return ctx;
+ if (has_left)
+ if (is_inter_block(left_mbmi, xd->tree_type))
+ left = block_size_high[left_mbmi->sb_type[PLANE_TYPE_Y]] >= max_tx_high;
+
+ if (has_above && has_left)
+ return (above + left);
+ else if (has_above)
+ return above;
+ else if (has_left)
+ return left;
+ else
+ return 0;
}
#ifdef __cplusplus
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index 2825186..99759b2 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -81,6 +81,12 @@
inter_pred_params->orig_block_width = block_width;
inter_pred_params->orig_block_height = block_height;
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_REFINEMV
+ inter_pred_params->original_pu_width = block_width;
+ inter_pred_params->original_pu_height = block_height;
+#endif // CONFIG_REFINEMV
+
inter_pred_params->pix_row = pix_row;
inter_pred_params->pix_col = pix_col;
inter_pred_params->subsampling_x = subsampling_x;
@@ -92,6 +98,16 @@
inter_pred_params->mode = TRANSLATION_PRED;
inter_pred_params->comp_mode = UNIFORM_SINGLE;
+#if CONFIG_REFINEMV
+ inter_pred_params->use_ref_padding = 0;
+ inter_pred_params->ref_area = NULL;
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params->border_data.enable_bacp = 0;
+ inter_pred_params->border_data.bacp_block_data = NULL;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
if (is_intrabc) {
inter_pred_params->interp_filter_params[0] = &av1_intrabc_filter_params;
inter_pred_params->interp_filter_params[1] = &av1_intrabc_filter_params;
@@ -119,6 +135,12 @@
if (is_tip_ref_frame(mi->ref_frame[ref])) return;
#endif // CONFIG_TIP
+#if CONFIG_REFINEMV
+ // We do not do refineMV for warp blocks
+ // We may need to return from here.
+ if (mi->refinemv_flag) return;
+#endif // CONFIG_REFINEMV
+
if (xd->cur_frame_force_integer_mv) return;
if (av1_allow_warp(mi, warp_types, &xd->global_motion[mi->ref_frame[ref]],
@@ -179,6 +201,68 @@
};
#else
/* clang-format off */
+#if WEDGE_BLD_SIG
+// rounded cosine and sine look-up tables given by round(32*cos(i))
+static const int8_t wedge_cos_lut[WEDGE_ANGLES] = {
+ // 0, 1, 2, 4, 6,
+ 32, 31, 29, 23, 14,
+ // 8, 10, 12, 14, 15,
+ 0,-14,-23,-29,-31,
+ // 16, 17, 18, 20, 22,
+ -32,-31,-29,-23,-14,
+ // 24, 26, 28, 30, 31
+ 0, 14, 23, 29, 31
+};
+static const int8_t wedge_sin_lut[WEDGE_ANGLES] = {
+ // 0, 1, 2, 4, 6,
+ 0, -8,-14,-23,-29,
+ // 8, 10, 12, 14, 15,
+ -32,-29,-23,-14, -8,
+ // 16, 17, 18, 20, 22,
+ 0, 8, 14, 23, 29,
+ // 24, 26, 28, 30, 31
+ 32, 29, 23, 14, 8
+};
+
+// rounded sigmoid function look-up talbe given by round(1/(1+exp(-x)))
+static const int8_t pos_dist_2_bld_weight[WEDGE_BLD_LUT_SIZE]={
+ 32, 32, 33, 33, 34, 34, 35, 35,
+ 36, 36, 37, 37, 38, 38, 39, 39,
+ 40, 40, 41, 41, 42, 42, 43, 43,
+ 43, 44, 44, 45, 45, 46, 46, 46,
+ 47, 47, 48, 48, 48, 49, 49, 49,
+ 50, 50, 50, 51, 51, 51, 52, 52,
+ 52, 53, 53, 53, 53, 54, 54, 54,
+ 55, 55, 55, 55, 55, 56, 56, 56,
+ 56, 57, 57, 57, 57, 57, 58, 58,
+ 58, 58, 58, 58, 59, 59, 59, 59,
+ 59, 59, 59, 60, 60, 60, 60, 60,
+ 60, 60, 60, 60, 61, 61, 61, 61,
+ 61, 61, 61, 61, 61, 61, 61, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62,
+ 63, 63, 63, 63, 63, 63, 63, 64
+};
+
+static const int8_t neg_dist_2_bld_weight[WEDGE_BLD_LUT_SIZE]={
+ 32, 32, 31, 31, 30, 30, 29, 29,
+ 28, 28, 27, 27, 26, 26, 25, 25,
+ 24, 24, 23, 23, 22, 22, 21, 21,
+ 21, 20, 20, 19, 19, 18, 18, 18,
+ 17, 17, 16, 16, 16, 15, 15, 15,
+ 14, 14, 14, 13, 13, 13, 12, 12,
+ 12, 11, 11, 11, 11, 10, 10, 10,
+ 9, 9, 9, 9, 9, 8, 8, 8,
+ 8, 7, 7, 7, 7, 7, 6, 6,
+ 6, 6, 6, 6, 5, 5, 5, 5,
+ 5, 5, 5, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2,
+ 1, 1, 1, 1, 1, 1, 1, 0
+};
+#else
static const int8_t wedge_cos_lut[WEDGE_ANGLES] = {
// 0, 1, 2, 4, 6,
8, 8, 8, 4, 4,
@@ -199,6 +283,7 @@
// 24, 26, 28, 30, 31
8, 8, 4, 4, 2
};
+#endif
/* clang-format on */
#endif // !CONFIG_WEDGE_MOD_EXT
@@ -273,6 +358,10 @@
smooth_interintra_mask_buf[INTERINTRA_MODES][BLOCK_SIZES_ALL]
[MAX_WEDGE_SQUARE]);
+#if CONFIG_CWP
+DECLARE_ALIGNED(16, static int8_t, cwp_mask[2][MAX_CWP_NUM][MAX_SB_SQUARE]);
+#endif // CONFIG_CWP
+
static wedge_masks_type wedge_masks[BLOCK_SIZES_ALL][2];
#if CONFIG_WEDGE_MOD_EXT
@@ -403,6 +492,34 @@
};
#endif
+#if CONFIG_CWP
+// Init the cwp masks, called by init_cwp_masks
+static AOM_INLINE void build_cwp_mask(int8_t *mask, int stride,
+ BLOCK_SIZE plane_bsize, int8_t w) {
+ const int bw = block_size_wide[plane_bsize];
+ const int bh = block_size_high[plane_bsize];
+ for (int i = 0; i < bh; ++i) {
+ for (int j = 0; j < bw; ++j) mask[j] = w;
+ mask += stride;
+ }
+}
+// Init the cwp masks
+void init_cwp_masks() {
+ const int bs = BLOCK_128X128;
+ const int bw = block_size_wide[bs];
+ for (int list_idx = 0; list_idx < 2; ++list_idx) {
+ for (int idx = 0; idx < MAX_CWP_NUM; ++idx) {
+ int8_t weight = cwp_weighting_factor[list_idx][idx] * 4;
+ build_cwp_mask(cwp_mask[list_idx][idx], bw, bs, weight);
+ }
+ }
+}
+// Return the associated cwp mask
+const int8_t *av1_get_cwp_mask(int list_idx, int idx) {
+ return cwp_mask[list_idx][idx];
+}
+#endif // CONFIG_CWP
+
static const uint8_t *get_wedge_mask_inplace(int wedge_index, int neg,
BLOCK_SIZE sb_type) {
const uint8_t *master;
@@ -433,12 +550,17 @@
const uint8_t *av1_get_compound_type_mask(
const INTERINTER_COMPOUND_DATA *const comp_data, BLOCK_SIZE sb_type) {
+#if !CONFIG_D071_IMP_MSK_BLD
assert(is_masked_compound_type(comp_data->type));
+#endif // !CONFIG_D071_IMP_MSK_BLD
(void)sb_type;
switch (comp_data->type) {
case COMPOUND_WEDGE:
return av1_get_contiguous_soft_mask(comp_data->wedge_index,
comp_data->wedge_sign, sb_type);
+#if CONFIG_D071_IMP_MSK_BLD
+ case COMPOUND_AVERAGE:
+#endif // CONFIG_D071_IMP_MSK_BLD
case COMPOUND_DIFFWTD: return comp_data->seg_mask;
default: assert(0); return NULL;
}
@@ -569,7 +691,14 @@
int y = ((n << 1) - h + 1) * wedge_sin_lut[angle];
for (int m = 0; m < w; m++, idx++) {
int d = ((m << 1) - w + 1) * wedge_cos_lut[angle] + y;
+#if WEDGE_BLD_SIG
+ const int clamp_d = clamp(d, -127, 127);
+ wedge_master_mask[0][angle][idx] =
+ clamp_d >= 0 ? pos_dist_2_bld_weight[clamp_d]
+ : neg_dist_2_bld_weight[-clamp_d];
+#else
wedge_master_mask[0][angle][idx] = clamp((d + 32), 0, 64);
+#endif
wedge_master_mask[1][angle][idx] =
64 - wedge_master_mask[0][angle][idx];
}
@@ -722,6 +851,14 @@
}
}
+#if CONFIG_REFINEMV
+// Compute the SAD values for refineMV modes
+int get_refinemv_sad(uint16_t *src1, uint16_t *src2, int width, int height,
+ int bd) {
+ return get_highbd_sad(src1, width, src2, width, bd, width, height);
+}
+#endif // CONFIG_REFINEMV
+
#if CONFIG_OPTFLOW_REFINEMENT
// Restrict MV delta to 1 or 2 pixels. This restriction would reduce complexity
// in hardware.
@@ -745,7 +882,12 @@
const AV1_COMMON *cm, MACROBLOCKD *xd, int plane, const MB_MODE_INFO *mi,
int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,
InterPredParams *inter_pred_params,
- CalcSubpelParamsFunc calc_subpel_params_func, int ref, uint16_t *pred_dst) {
+ CalcSubpelParamsFunc calc_subpel_params_func, int ref, uint16_t *pred_dst
+#if CONFIG_REFINEMV
+ ,
+ const MV *const src_mv, int pu_width, int pu_height
+#endif // CONFIG_REFINEMV
+) {
assert(cm->seq_params.order_hint_info.enable_order_hint);
const int is_intrabc = is_intrabc_block(mi, xd->tree_type);
#if CONFIG_OPTFLOW_ON_TIP
@@ -769,11 +911,18 @@
const struct scale_factors *const sf =
is_intrabc ? &cm->sf_identity : xd->block_ref_scale_factors[ref];
#endif // CONFIG_OPTFLOW_ON_TIP
- const BLOCK_SIZE bsize = mi->sb_type[PLANE_TYPE_Y];
+
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
+#if CONFIG_REFINEMV
+ const int row_start = (bw == 4) && ss_y ? -1 : 0;
+ const int col_start = (bh == 4) && ss_x ? -1 : 0;
+#else
+ const BLOCK_SIZE bsize = mi->sb_type[PLANE_TYPE_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;
+#endif // CONFIG_REFINEMV
+
const int pre_x = (mi_x + MI_SIZE * col_start) >> ss_x;
const int pre_y = (mi_y + MI_SIZE * row_start) >> ss_y;
@@ -788,6 +937,10 @@
av1_init_inter_params(inter_pred_params, bw, bh, pre_y, pre_x,
pd->subsampling_x, pd->subsampling_y, xd->bd,
mi->use_intrabc[0], sf, pre_buf, mi->interp_fltr);
+#if CONFIG_REFINEMV
+ inter_pred_params->original_pu_width = pu_width;
+ inter_pred_params->original_pu_height = pu_height;
+#endif // CONFIG_REFINEMV
#if CONFIG_TIP
const int width = (cm->mi_params.mi_cols << MI_SIZE_LOG2);
@@ -805,7 +958,13 @@
if (inter_pred_params->mode == WARP_PRED) return;
assert(mi->interinter_comp.type == COMPOUND_AVERAGE);
- av1_build_one_inter_predictor(pred_dst, bw, &mi->mv[ref].as_mv,
+
+ av1_build_one_inter_predictor(pred_dst, bw,
+#if CONFIG_REFINEMV
+ src_mv,
+#else
+ &mi->mv[ref].as_mv,
+#endif // CONFIG_REFINEMV
inter_pred_params, xd, mi_x, mi_y, ref, mc_buf,
calc_subpel_params_func);
}
@@ -1222,6 +1381,10 @@
,
int do_pred, int use_4x4
#endif // CONFIG_OPTFLOW_ON_TIP
+#if CONFIG_REFINEMV
+ ,
+ MV *best_mv_ref, int pu_width, int pu_height
+#endif // CONFIG_REFINEMV
) {
const int target_prec = MV_REFINE_PREC_BITS;
const int n = opfl_get_subblock_size(bw, bh, plane
@@ -1252,10 +1415,19 @@
get_ref_frame_buf(cm, mbmi->ref_frame[0]);
const RefCntBuffer *const r1_buf =
get_ref_frame_buf(cm, mbmi->ref_frame[1]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
d0 = get_relative_dist(&cm->seq_params.order_hint_info,
- cm->cur_frame->order_hint, r0_buf->order_hint);
+ cm->cur_frame->display_order_hint,
+ r0_buf->display_order_hint);
d1 = get_relative_dist(&cm->seq_params.order_hint_info,
- cm->cur_frame->order_hint, r1_buf->order_hint);
+ cm->cur_frame->display_order_hint,
+ r1_buf->display_order_hint);
+#else
+ d0 = get_relative_dist(&cm->seq_params.order_hint_info,
+ cm->cur_frame->order_hint, r0_buf->order_hint);
+ d1 = get_relative_dist(&cm->seq_params.order_hint_info,
+ cm->cur_frame->order_hint, r1_buf->order_hint);
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
#if CONFIG_OPTFLOW_ON_TIP
}
#endif // CONFIG_OPTFLOW_ON_TIP
@@ -1268,10 +1440,20 @@
InterPredParams params0, params1;
av1_opfl_build_inter_predictor(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,
mc_buf, ¶ms0, calc_subpel_params_func, 0,
- dst0);
+ dst0
+#if CONFIG_REFINEMV
+ ,
+ &best_mv_ref[0], pu_width, pu_height
+#endif // CONFIG_REFINEMV
+ );
av1_opfl_build_inter_predictor(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,
mc_buf, ¶ms1, calc_subpel_params_func, 1,
- dst1);
+ dst1
+#if CONFIG_REFINEMV
+ ,
+ &best_mv_ref[1], pu_width, pu_height
+#endif // CONFIG_REFINEMV
+ );
#if CONFIG_OPTFLOW_ON_TIP
}
#endif // CONFIG_OPTFLOW_ON_TIP
@@ -1356,7 +1538,26 @@
return target_prec;
}
+#if CONFIG_D071_IMP_MSK_BLD
+int is_out_of_frame_block(const InterPredParams *inter_pred_params,
+ int frame_width, int frame_height, int sub_block_id) {
+ for (int ref = 0; ref < 2; ref++) {
+ const BacpBlockData *const b_data =
+ &inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + ref];
+ if (b_data->x0 < 0 || b_data->x0 > frame_width - 1 || b_data->x1 < 0 ||
+ b_data->x1 > frame_width
+ || b_data->y0 < 0 || b_data->y0 > frame_height - 1 || b_data->y1 < 0 ||
+ b_data->y1 > frame_height) {
+ return 1;
+ }
+ }
+ return 0;
+}
+
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+#if !CONFIG_D071_IMP_MSK_BLD
// Makes the interpredictor for the region by dividing it up into nxn blocks
// and running the interpredictor code on each one.
void make_inter_pred_of_nxn(uint16_t *dst, int dst_stride,
@@ -1383,6 +1584,7 @@
calc_subpel_params_func(&(mv_refined[n_blocks * 2 + ref].as_mv),
inter_pred_params, xd, mi_x + i, mi_y + j, ref, 1,
mc_buf, &pre, subpel_params, &src_stride);
+
av1_make_inter_predictor(pre, src_stride, dst, dst_stride,
inter_pred_params, subpel_params);
n_blocks++;
@@ -1427,6 +1629,7 @@
&subpel_params);
}
#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // !CONFIG_D071_IMP_MSK_BLD
// Equation of line: f(x, y) = a[0]*(x - a[2]*w/8) + a[1]*(y - a[3]*h/8) = 0
void av1_init_wedge_masks() {
@@ -1440,8 +1643,19 @@
const CONV_BUF_TYPE *src1, int src1_stride,
const INTERINTER_COMPOUND_DATA *const comp_data, BLOCK_SIZE sb_type, int h,
int w, InterPredParams *inter_pred_params) {
+#if CONFIG_D071_IMP_MSK_BLD
+ const int ssy = (inter_pred_params->conv_params.plane &&
+ comp_data->type == COMPOUND_AVERAGE)
+ ? 0
+ : inter_pred_params->subsampling_y;
+ const int ssx = (inter_pred_params->conv_params.plane &&
+ comp_data->type == COMPOUND_AVERAGE)
+ ? 0
+ : inter_pred_params->subsampling_x;
+#else
const int ssy = inter_pred_params->subsampling_y;
const int ssx = inter_pred_params->subsampling_x;
+#endif // CONFIG_D071_IMP_MSK_BLD
const uint8_t *mask = av1_get_compound_type_mask(comp_data, sb_type);
const int mask_stride = block_size_wide[sb_type];
aom_highbd_blend_a64_d16_mask(dst, dst_stride, src0, src0_stride, src1,
@@ -1449,11 +1663,19 @@
&inter_pred_params->conv_params,
inter_pred_params->bit_depth);
}
-
-static void make_masked_inter_predictor(const uint16_t *pre, int pre_stride,
- uint16_t *dst, int dst_stride,
- InterPredParams *inter_pred_params,
- const SubpelParams *subpel_params) {
+#if !CONFIG_D071_IMP_MSK_BLD
+static
+#endif
+ void
+ make_masked_inter_predictor(const uint16_t *pre, int pre_stride,
+ uint16_t *dst, int dst_stride,
+ InterPredParams *inter_pred_params,
+ const SubpelParams *subpel_params
+#if CONFIG_D071_IMP_MSK_BLD
+ ,
+ int use_bacp, int sub_block_id
+#endif // CONFIG_D071_IMP_MSK_BLD
+ ) {
const INTERINTER_COMPOUND_DATA *comp_data = &inter_pred_params->mask_comp;
BLOCK_SIZE sb_type = inter_pred_params->sb_type;
@@ -1482,12 +1704,183 @@
inter_pred_params->block_width, &inter_pred_params->conv_params,
inter_pred_params->bit_depth);
}
+
+#if CONFIG_D071_IMP_MSK_BLD
+ // Mask is generated from luma and reuse for chroma
+ const int generate_mask_for_this_plane =
+ (!inter_pred_params->conv_params.plane ||
+ comp_data->type == COMPOUND_AVERAGE);
+ if (use_bacp && generate_mask_for_this_plane) {
+ uint8_t *mask = comp_data->seg_mask;
+ int mask_stride = block_size_wide[sb_type];
+ BacpBlockData *b_data_0 =
+ &inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + 0];
+ BacpBlockData *b_data_1 =
+ &inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + 1];
+
+ for (int i = 0; i < inter_pred_params->block_height; ++i) {
+ for (int j = 0; j < inter_pred_params->block_width; ++j) {
+ int x = b_data_0->x0 + j;
+ int y = b_data_0->y0 + i;
+
+ int p0_available =
+ (x >= 0 && x < inter_pred_params->ref_frame_buf.width && y >= 0 &&
+ y < inter_pred_params->ref_frame_buf.height);
+
+ x = b_data_1->x0 + j;
+ y = b_data_1->y0 + i;
+ int p1_available =
+ (x >= 0 && x < inter_pred_params->ref_frame_buf.width && y >= 0 &&
+ y < inter_pred_params->ref_frame_buf.height);
+
+ if (p0_available && !p1_available) {
+ mask[j] = AOM_BLEND_A64_MAX_ALPHA - DEFAULT_IMP_MSK_WT;
+ } else if (!p0_available && p1_available) {
+ mask[j] = DEFAULT_IMP_MSK_WT;
+ } else if (comp_data->type == COMPOUND_AVERAGE) {
+ mask[j] = AOM_BLEND_A64_MAX_ALPHA >> 1;
+ }
+ }
+ mask += mask_stride;
+ }
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+
build_masked_compound_no_round(
dst, dst_stride, org_dst, org_dst_stride, tmp_buf16, tmp_buf_stride,
comp_data, sb_type, inter_pred_params->block_height,
inter_pred_params->block_width, inter_pred_params);
+
+#if CONFIG_D071_IMP_MSK_BLD
+ // restore to previous state
+ inter_pred_params->conv_params.dst = org_dst;
+ inter_pred_params->conv_params.dst_stride = org_dst_stride;
+#endif // CONFIG_D071_IMP_MSK_BLD
}
+#if CONFIG_D071_IMP_MSK_BLD && CONFIG_OPTFLOW_REFINEMENT
+// Makes the interpredictor for the region by dividing it up into nxn blocks
+// and running the interpredictor code on each one.
+void make_inter_pred_of_nxn(uint16_t *dst, int dst_stride,
+ int_mv *const mv_refined,
+ InterPredParams *inter_pred_params, MACROBLOCKD *xd,
+ int mi_x, int mi_y, int ref, uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func, int n,
+ SubpelParams *subpel_params) {
+ int n_blocks = 0;
+ int w = inter_pred_params->orig_block_width;
+ int h = inter_pred_params->orig_block_height;
+ assert(w % n == 0);
+ assert(h % n == 0);
+ CONV_BUF_TYPE *orig_conv_dst = inter_pred_params->conv_params.dst;
+ inter_pred_params->block_width = n;
+ inter_pred_params->block_height = n;
+
+ uint16_t *pre;
+ int src_stride = 0;
+
+ // Process whole nxn blocks.
+ for (int j = 0; j <= h - n; j += n) {
+ for (int i = 0; i <= w - n; i += n) {
+ calc_subpel_params_func(&(mv_refined[n_blocks * 2 + ref].as_mv),
+ inter_pred_params, xd, mi_x + i, mi_y + j, ref, 1,
+ mc_buf, &pre, subpel_params, &src_stride);
+
+#if CONFIG_D071_IMP_MSK_BLD
+ int use_bacp = 0;
+ assert(inter_pred_params->mask_comp.type == COMPOUND_AVERAGE);
+ assert(inter_pred_params->comp_mode == UNIFORM_COMP);
+ int stored_do_average = inter_pred_params->conv_params.do_average;
+ InterCompMode stored_comp_mode = inter_pred_params->comp_mode;
+ uint8_t *stored_seg_mask = inter_pred_params->mask_comp.seg_mask;
+
+ if (inter_pred_params->border_data.enable_bacp) {
+ inter_pred_params->border_data.bacp_block_data[n_blocks * 2 + ref].x0 =
+ subpel_params->x0;
+ inter_pred_params->border_data.bacp_block_data[n_blocks * 2 + ref].x1 =
+ subpel_params->x1;
+ inter_pred_params->border_data.bacp_block_data[n_blocks * 2 + ref].y0 =
+ subpel_params->y0;
+ inter_pred_params->border_data.bacp_block_data[n_blocks * 2 + ref].y1 =
+ subpel_params->y1;
+ if (ref == 1) {
+ use_bacp = is_out_of_frame_block(
+ inter_pred_params, inter_pred_params->ref_frame_buf.width,
+ inter_pred_params->ref_frame_buf.height, n_blocks);
+
+ if (use_bacp &&
+ inter_pred_params->mask_comp.type == COMPOUND_AVERAGE) {
+ inter_pred_params->conv_params.do_average = 0;
+ inter_pred_params->comp_mode = MASK_COMP;
+ inter_pred_params->mask_comp.seg_mask = xd->seg_mask;
+ }
+ }
+ }
+
+ assert(IMPLIES(ref == 0, !use_bacp));
+ if (use_bacp) {
+ assert(inter_pred_params->comp_mode == MASK_COMP);
+ make_masked_inter_predictor(pre, src_stride, dst, dst_stride,
+ inter_pred_params, subpel_params, use_bacp,
+ n_blocks);
+
+ } else {
+#endif
+
+ av1_make_inter_predictor(pre, src_stride, dst, dst_stride,
+ inter_pred_params, subpel_params);
+#if CONFIG_D071_IMP_MSK_BLD
+ }
+
+ // Restored to original inter_pred_params
+ if (use_bacp && inter_pred_params->mask_comp.type == COMPOUND_AVERAGE) {
+ inter_pred_params->conv_params.do_average = stored_do_average;
+ inter_pred_params->comp_mode = stored_comp_mode;
+ inter_pred_params->mask_comp.seg_mask = stored_seg_mask;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+ n_blocks++;
+ dst += n;
+ inter_pred_params->conv_params.dst += n;
+ inter_pred_params->pix_col += n;
+ }
+ dst -= w;
+ inter_pred_params->conv_params.dst -= w;
+ inter_pred_params->pix_col -= w;
+
+ dst += n * dst_stride;
+ inter_pred_params->conv_params.dst +=
+ n * inter_pred_params->conv_params.dst_stride;
+ inter_pred_params->pix_row += n;
+ }
+
+ inter_pred_params->conv_params.dst = orig_conv_dst;
+}
+// Use a second pass of motion compensation to rebuild inter predictor
+void av1_opfl_rebuild_inter_predictor(
+ uint16_t *dst, int dst_stride, int plane, int_mv *const mv_refined,
+ InterPredParams *inter_pred_params, MACROBLOCKD *xd, int mi_x, int mi_y,
+ int ref, uint16_t **mc_buf, CalcSubpelParamsFunc calc_subpel_params_func
+#if CONFIG_OPTFLOW_ON_TIP
+ ,
+ int use_4x4
+#endif // CONFIG_OPTFLOW_ON_TIP
+) {
+ SubpelParams subpel_params;
+ int w = inter_pred_params->block_width;
+ int h = inter_pred_params->block_height;
+ int n = opfl_get_subblock_size(w, h, plane
+#if CONFIG_OPTFLOW_ON_TIP
+ ,
+ use_4x4
+#endif // CONFIG_OPTFLOW_ON_TIP
+ );
+ make_inter_pred_of_nxn(dst, dst_stride, mv_refined, inter_pred_params, xd,
+ mi_x, mi_y, ref, mc_buf, calc_subpel_params_func, n,
+ &subpel_params);
+}
+#endif // CONFIG_D071_IMP_MSK_BLD && CONFIG_OPTFLOW_REFINEMENT
+
void av1_build_one_inter_predictor(
uint16_t *dst, int dst_stride, const MV *const src_mv,
InterPredParams *inter_pred_params, MACROBLOCKD *xd, int mi_x, int mi_y,
@@ -1501,13 +1894,52 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
mc_buf, &src, &subpel_params, &src_stride);
+#if CONFIG_D071_IMP_MSK_BLD
+ int use_bacp = 0;
+ int sub_block_id = 0;
+ if (inter_pred_params->border_data.enable_bacp) {
+ inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + ref].x0 =
+ subpel_params.x0;
+ inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + ref].x1 =
+ subpel_params.x1;
+ inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + ref].y0 =
+ subpel_params.y0;
+ inter_pred_params->border_data.bacp_block_data[2 * sub_block_id + ref].y1 =
+ subpel_params.y1;
+ if (ref == 1) {
+ use_bacp = is_out_of_frame_block(
+ inter_pred_params, inter_pred_params->ref_frame_buf.width,
+ inter_pred_params->ref_frame_buf.height, sub_block_id);
+ if (use_bacp && inter_pred_params->mask_comp.type == COMPOUND_AVERAGE) {
+ inter_pred_params->conv_params.do_average = 0;
+ inter_pred_params->comp_mode = MASK_COMP;
+ inter_pred_params->mask_comp.seg_mask = xd->seg_mask;
+ }
+ }
+ }
+
+ assert(IMPLIES(ref == 0, !use_bacp));
+#endif // CONFIG_D071_IMP_MSK_BLD
+
if (inter_pred_params->comp_mode == UNIFORM_SINGLE ||
inter_pred_params->comp_mode == UNIFORM_COMP) {
av1_make_inter_predictor(src, src_stride, dst, dst_stride,
inter_pred_params, &subpel_params);
+#if CONFIG_D071_IMP_MSK_BLD
+ assert(IMPLIES(use_bacp, ref == 0));
+ assert(use_bacp == 0);
+#endif // CONFIG_D071_IMP_MSK_BLD
} else {
make_masked_inter_predictor(src, src_stride, dst, dst_stride,
- inter_pred_params, &subpel_params);
+ inter_pred_params, &subpel_params
+#if CONFIG_D071_IMP_MSK_BLD
+ ,
+ use_bacp, 0
+#endif // CONFIG_D071_IMP_MSK_BLD
+ );
+#if CONFIG_D071_IMP_MSK_BLD
+ assert(IMPLIES(inter_pred_params->border_data.enable_bacp, ref == 1));
+#endif // CONFIG_D071_IMP_MSK_BLD
}
}
@@ -1595,7 +2027,12 @@
inter_pred_params, &subpel_params);
} else {
make_masked_inter_predictor(src, src_stride, dst, dst_stride,
- inter_pred_params, &subpel_params);
+ inter_pred_params, &subpel_params
+#if CONFIG_D071_IMP_MSK_BLD
+ ,
+ 0, 0
+#endif // CONFIG_D071_IMP_MSK_BLD
+ );
}
int shift = 8;
@@ -1754,13 +2191,1088 @@
}
}
+#if CONFIG_REFINEMV
+// Padding if the pixel position falls outside of the defined reference area
+static void refinemv_highbd_pad_mc_border(const uint16_t *src, int src_stride,
+ uint16_t *dst, int dst_stride, int x0,
+ int y0, int b_w, int b_h,
+ const ReferenceArea *ref_area) {
+ // Get a pointer to the start of the real data for this row.
+ const uint16_t *ref_row = src - x0 - y0 * src_stride;
+
+ if (y0 >= ref_area->pad_block.y1)
+ ref_row += (ref_area->pad_block.y1 - 1) * src_stride;
+ else if (y0 >= ref_area->pad_block.y0)
+ ref_row += y0 * src_stride;
+ else
+ ref_row += ref_area->pad_block.y0 * src_stride;
+
+ do {
+ int right = 0, copy;
+ int left = x0 < ref_area->pad_block.x0 ? ref_area->pad_block.x0 - x0 : 0;
+
+ if (left > b_w) left = b_w;
+
+ if (x0 + b_w > ref_area->pad_block.x1)
+ right = x0 + b_w - ref_area->pad_block.x1;
+
+ if (right > b_w) right = b_w;
+
+ copy = b_w - left - right;
+
+ if (left) aom_memset16(dst, ref_row[0], left);
+
+ if (copy) memcpy(dst + left, ref_row + x0 + left, copy * sizeof(uint16_t));
+
+ if (right)
+ aom_memset16(dst + left + copy, ref_row[ref_area->pad_block.x1 - 1],
+ right);
+
+ dst += dst_stride;
+ ++y0;
+
+ if (y0 > ref_area->pad_block.y0 && y0 < ref_area->pad_block.y1)
+ ref_row += src_stride;
+ } while (--b_h);
+}
+// check if padding is required during motion compensation
+// return 1 means reference pixel is outside of the reference range and padding
+// is required return 0 means no padding.
+int update_extend_mc_border_params(const struct scale_factors *const sf,
+ struct buf_2d *const pre_buf, MV32 scaled_mv,
+ PadBlock *block, int subpel_x_mv,
+ int subpel_y_mv, int do_warp, int is_intrabc,
+ int *x_pad, int *y_pad,
+ const ReferenceArea *ref_area) {
+ // Get reference width and height.
+ int frame_width = pre_buf->width;
+ int frame_height = pre_buf->height;
+
+ // Do border extension if there is motion or
+ // width/height is not a multiple of 8 pixels.
+#if CONFIG_OPTFLOW_REFINEMENT || CONFIG_TIP
+ // Extension is needed in optical flow refinement to obtain MV offsets
+ (void)scaled_mv;
+ if (!is_intrabc && !do_warp) {
+#else
+ const int is_scaled = av1_is_scaled(sf);
+ if ((!is_intrabc) && (!do_warp) &&
+ (is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) ||
+ (frame_height & 0x7))) {
+#endif // CONFIG_OPTFLOW_REFINEMENT || CONFIG_TIP
+ if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) {
+ block->x0 -= AOM_INTERP_EXTEND - 1;
+ block->x1 += AOM_INTERP_EXTEND;
+ *x_pad = 1;
+ }
+
+ if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) {
+ block->y0 -= AOM_INTERP_EXTEND - 1;
+ block->y1 += AOM_INTERP_EXTEND;
+ *y_pad = 1;
+ }
+
+ // Skip border extension if block is inside the frame.
+ if (block->x0 < 0 || block->x1 > frame_width - 1 || block->y0 < 0 ||
+ block->y1 > frame_height - 1) {
+ return 1;
+ }
+
+ if (ref_area) {
+ // Skip border extension if block is in the reference area.
+ if (block->x0 < ref_area->pad_block.x0 ||
+ block->x1 > ref_area->pad_block.x1 ||
+ block->y0 < ref_area->pad_block.y0 ||
+ block->y1 > ref_area->pad_block.y1) {
+ return 1;
+ }
+ }
+ }
+ return 0;
+};
+
+// perform padding of the motion compensated block if requires.
+// Padding is performed if the motion compensated block is partially out of the
+// reference area.
+static void refinemv_extend_mc_border(
+ const struct scale_factors *const sf, struct buf_2d *const pre_buf,
+ MV32 scaled_mv, PadBlock block, int subpel_x_mv, int subpel_y_mv,
+ int do_warp, int is_intrabc, uint16_t *paded_ref_buf,
+ int paded_ref_buf_stride, uint16_t **pre, int *src_stride,
+ const ReferenceArea *ref_area) {
+ int x_pad = 0, y_pad = 0;
+ if (update_extend_mc_border_params(sf, pre_buf, scaled_mv, &block,
+ subpel_x_mv, subpel_y_mv, do_warp,
+ is_intrabc, &x_pad, &y_pad, ref_area)) {
+ // printf(" Out of border \n");
+ // Get reference block pointer.
+ const uint16_t *const buf_ptr =
+ pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
+ int buf_stride = pre_buf->stride;
+ const int b_w = block.x1 - block.x0;
+ const int b_h = block.y1 - block.y0;
+
+ refinemv_highbd_pad_mc_border(buf_ptr, buf_stride, paded_ref_buf,
+ paded_ref_buf_stride, block.x0, block.y0, b_w,
+ b_h, ref_area);
+ *src_stride = paded_ref_buf_stride;
+ *pre = paded_ref_buf +
+ y_pad * (AOM_INTERP_EXTEND - 1) * paded_ref_buf_stride +
+ x_pad * (AOM_INTERP_EXTEND - 1);
+ }
+}
+
+#if CONFIG_TIP
+// Derive the sub-pixel related parameters of TIP blocks
+// Sub-pel related parameters are stored in the structures pointed by
+// "subpel_params" and "block"
+void tip_dec_calc_subpel_params(const MV *const src_mv,
+ InterPredParams *const inter_pred_params,
+ int mi_x, int mi_y, uint16_t **pre,
+ SubpelParams *subpel_params, int *src_stride,
+ PadBlock *block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ MV32 *scaled_mv, int *subpel_x_mv,
+ int *subpel_y_mv) {
+ const struct scale_factors *sf = inter_pred_params->scale_factors;
+ struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
+
+#if CONFIG_REFINEMV
+ const int bw = inter_pred_params->original_pu_width;
+ const int bh = inter_pred_params->original_pu_height;
+#else
+#if CONFIG_OPTFLOW_REFINEMENT
+ // Use original block size to clamp MV and to extend block boundary
+ const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
+ : inter_pred_params->block_width;
+ const int bh = use_optflow_refinement ? inter_pred_params->orig_block_height
+ : inter_pred_params->block_height;
+#else
+ const int bw = inter_pred_params->block_width;
+ const int bh = inter_pred_params->block_height;
+#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // CONFIG_REFINEMV
+
+ const int is_scaled = av1_is_scaled(sf);
+ if (is_scaled) {
+ const int ssx = inter_pred_params->subsampling_x;
+ const int ssy = inter_pred_params->subsampling_y;
+ int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
+ int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
+#if CONFIG_OPTFLOW_REFINEMENT
+ if (use_optflow_refinement) {
+ orig_pos_y += ROUND_POWER_OF_TWO_SIGNED(src_mv->row * (1 << SUBPEL_BITS),
+ MV_REFINE_PREC_BITS + ssy);
+ orig_pos_x += ROUND_POWER_OF_TWO_SIGNED(src_mv->col * (1 << SUBPEL_BITS),
+ MV_REFINE_PREC_BITS + ssx);
+ } else {
+ orig_pos_y += src_mv->row * (1 << (1 - ssy));
+ orig_pos_x += src_mv->col * (1 << (1 - ssx));
+ }
+#else
+ orig_pos_y += src_mv->row * (1 << (1 - ssy));
+ orig_pos_x += src_mv->col * (1 << (1 - ssx));
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ 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);
+
+ 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;
+
+ // Get reference block top left coordinate.
+ block->x0 = pos_x >> SCALE_SUBPEL_BITS;
+ block->y0 = pos_y >> SCALE_SUBPEL_BITS;
+
+#if CONFIG_D071_IMP_MSK_BLD
+ block->x1 =
+ ((pos_x + (inter_pred_params->block_width - 1) * subpel_params->xs) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+ block->y1 =
+ ((pos_y + (inter_pred_params->block_height - 1) * subpel_params->ys) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+#else
+ // Get reference block bottom right coordinate.
+ block->x1 =
+ ((pos_x + (bw - 1) * subpel_params->xs) >> SCALE_SUBPEL_BITS) + 1;
+ block->y1 =
+ ((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+ MV temp_mv;
+ temp_mv = tip_clamp_mv_to_umv_border_sb(inter_pred_params, src_mv, bw, bh,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ inter_pred_params->subsampling_x,
+ inter_pred_params->subsampling_y);
+ *scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf);
+ scaled_mv->row += SCALE_EXTRA_OFF;
+ scaled_mv->col += SCALE_EXTRA_OFF;
+
+ *subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;
+ *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;
+ } else {
+ // Get block position in current frame.
+ int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
+ int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
+
+ const MV mv_q4 = tip_clamp_mv_to_umv_border_sb(
+ inter_pred_params, src_mv, bw, bh,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ 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;
+
+ // Get reference block top left coordinate.
+ pos_x += mv_q4.col;
+ pos_y += mv_q4.row;
+ pos_x = (pos_x >> SUBPEL_BITS);
+ pos_y = (pos_y >> SUBPEL_BITS);
+ block->x0 = pos_x;
+ block->y0 = pos_y;
+
+ // Get reference block bottom right coordinate.
+#if CONFIG_D071_IMP_MSK_BLD
+ block->x1 = pos_x + inter_pred_params->block_width;
+ block->y1 = pos_y + inter_pred_params->block_height;
+#else
+ block->x1 = pos_x + bw;
+ block->y1 = pos_y + bh;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+ scaled_mv->row = mv_q4.row;
+ scaled_mv->col = mv_q4.col;
+ *subpel_x_mv = scaled_mv->col & SUBPEL_MASK;
+ *subpel_y_mv = scaled_mv->row & SUBPEL_MASK;
+ }
+ *pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
+ *src_stride = pre_buf->stride;
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ subpel_params->x0 = block->x0;
+ subpel_params->x1 = block->x1;
+ subpel_params->y0 = block->y0;
+ subpel_params->y1 = block->y1;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+}
+
+void tip_common_calc_subpel_params_and_extend(
+ const MV *const src_mv, InterPredParams *const inter_pred_params,
+ MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride) {
+ (void)ref;
+ (void)mc_buf;
+ (void)xd;
+
+ PadBlock block;
+ MV32 scaled_mv;
+ int subpel_x_mv, subpel_y_mv;
+ assert(inter_pred_params->use_ref_padding);
+
+ tip_dec_calc_subpel_params(src_mv, inter_pred_params, mi_x, mi_y, pre,
+ subpel_params, src_stride, &block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ &scaled_mv, &subpel_x_mv, &subpel_y_mv);
+
+ const int paded_ref_buf_stride =
+ inter_pred_params->ref_area->paded_ref_buf_stride;
+ refinemv_extend_mc_border(
+ inter_pred_params->scale_factors, &inter_pred_params->ref_frame_buf,
+ scaled_mv, block, subpel_x_mv, subpel_y_mv,
+ inter_pred_params->mode == WARP_PRED, inter_pred_params->is_intrabc,
+ &inter_pred_params->ref_area->paded_ref_buf[0], paded_ref_buf_stride, pre,
+ src_stride, inter_pred_params->ref_area);
+}
+#endif
+
+void dec_calc_subpel_params(const MV *const src_mv,
+ InterPredParams *const inter_pred_params,
+ const MACROBLOCKD *const xd, int mi_x, int mi_y,
+ uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride, PadBlock *block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ MV32 *scaled_mv, int *subpel_x_mv,
+ int *subpel_y_mv) {
+ const struct scale_factors *sf = inter_pred_params->scale_factors;
+ struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
+
+#if CONFIG_REFINEMV
+ const int bw = inter_pred_params->original_pu_width;
+ const int bh = inter_pred_params->original_pu_height;
+#else
+
+#if CONFIG_OPTFLOW_REFINEMENT
+ // Use original block size to clamp MV and to extend block boundary
+ const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
+ : inter_pred_params->block_width;
+ const int bh = use_optflow_refinement ? inter_pred_params->orig_block_height
+ : inter_pred_params->block_height;
+#else
+ const int bw = inter_pred_params->block_width;
+ const int bh = inter_pred_params->block_height;
+#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // CONFIG_REFINEMV
+
+ const int is_scaled = av1_is_scaled(sf);
+ if (is_scaled) {
+ 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;
+ int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
+#if CONFIG_OPTFLOW_REFINEMENT
+ if (use_optflow_refinement) {
+ orig_pos_y += ROUND_POWER_OF_TWO_SIGNED(src_mv->row * (1 << SUBPEL_BITS),
+ MV_REFINE_PREC_BITS + ssy);
+ orig_pos_x += ROUND_POWER_OF_TWO_SIGNED(src_mv->col * (1 << SUBPEL_BITS),
+ MV_REFINE_PREC_BITS + ssx);
+ } else {
+ orig_pos_y += src_mv->row * (1 << (1 - ssy));
+ orig_pos_x += src_mv->col * (1 << (1 - ssx));
+ }
+#else
+ orig_pos_y += src_mv->row * (1 << (1 - ssy));
+ orig_pos_x += src_mv->col * (1 << (1 - ssx));
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ 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);
+
+ 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;
+
+ // Get reference block top left coordinate.
+ block->x0 = pos_x >> SCALE_SUBPEL_BITS;
+ block->y0 = pos_y >> SCALE_SUBPEL_BITS;
+
+ // Get reference block bottom right coordinate.
+ block->x1 =
+ ((pos_x + (inter_pred_params->block_width - 1) * subpel_params->xs) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+ block->y1 =
+ ((pos_y + (inter_pred_params->block_height - 1) * subpel_params->ys) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+
+ MV temp_mv;
+ temp_mv = clamp_mv_to_umv_border_sb(xd, src_mv, bw, bh,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ inter_pred_params->subsampling_x,
+ inter_pred_params->subsampling_y);
+ *scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf);
+ scaled_mv->row += SCALE_EXTRA_OFF;
+ scaled_mv->col += SCALE_EXTRA_OFF;
+
+ *subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;
+ *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;
+ } else {
+ // Get block position in current frame.
+ int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
+ int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
+
+ const MV mv_q4 = clamp_mv_to_umv_border_sb(
+ xd, src_mv, bw, bh,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ 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;
+
+ // Get reference block top left coordinate.
+ pos_x += mv_q4.col;
+ pos_y += mv_q4.row;
+ block->x0 = pos_x >> SUBPEL_BITS;
+ block->y0 = pos_y >> SUBPEL_BITS;
+
+ // Get reference block bottom right coordinate.
+ block->x1 =
+ (pos_x >> SUBPEL_BITS) + (inter_pred_params->block_width - 1) + 1;
+ block->y1 =
+ (pos_y >> SUBPEL_BITS) + (inter_pred_params->block_height - 1) + 1;
+
+ scaled_mv->row = mv_q4.row;
+ scaled_mv->col = mv_q4.col;
+ *subpel_x_mv = scaled_mv->col & SUBPEL_MASK;
+ *subpel_y_mv = scaled_mv->row & SUBPEL_MASK;
+ }
+ *pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
+ *src_stride = pre_buf->stride;
+
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ subpel_params->x0 = block->x0;
+ subpel_params->x1 = block->x1;
+ subpel_params->y0 = block->y0;
+ subpel_params->y1 = block->y1;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+}
+
+void common_calc_subpel_params_and_extend(
+ const MV *const src_mv, InterPredParams *const inter_pred_params,
+ MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride) {
+ (void)ref;
+ (void)mc_buf;
+
+ PadBlock block;
+ MV32 scaled_mv;
+ int subpel_x_mv, subpel_y_mv;
+ assert(inter_pred_params->use_ref_padding);
+ dec_calc_subpel_params(src_mv, inter_pred_params, xd, mi_x, mi_y, pre,
+ subpel_params, src_stride, &block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ &scaled_mv, &subpel_x_mv, &subpel_y_mv);
+
+ // printf(" Use ref padding \n");
+ const int paded_ref_buf_stride =
+ inter_pred_params->ref_area->paded_ref_buf_stride;
+ refinemv_extend_mc_border(
+ inter_pred_params->scale_factors, &inter_pred_params->ref_frame_buf,
+ scaled_mv, block, subpel_x_mv, subpel_y_mv,
+ inter_pred_params->mode == WARP_PRED, inter_pred_params->is_intrabc,
+ &inter_pred_params->ref_area->paded_ref_buf[0], paded_ref_buf_stride, pre,
+ src_stride, inter_pred_params->ref_area);
+}
+
+static void get_ref_area_info(const MV *const src_mv,
+ InterPredParams *const inter_pred_params,
+ MACROBLOCKD *const xd, int mi_x, int mi_y,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride, ReferenceArea *ref_area,
+ int is_tip) {
+ PadBlock block;
+ MV32 scaled_mv;
+ int subpel_x_mv, subpel_y_mv;
+
+ if (is_tip) {
+ tip_dec_calc_subpel_params(src_mv, inter_pred_params, mi_x, mi_y, pre,
+ subpel_params, src_stride, &block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ &scaled_mv, &subpel_x_mv, &subpel_y_mv);
+
+ } else {
+ dec_calc_subpel_params(src_mv, inter_pred_params, xd, mi_x, mi_y, pre,
+ subpel_params, src_stride, &block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ &scaled_mv, &subpel_x_mv, &subpel_y_mv);
+ }
+
+ struct buf_2d *const pre_buf = &inter_pred_params->ref_frame_buf;
+ int frame_height = pre_buf->height;
+ int frame_width = pre_buf->width;
+ block.x0 -= REF_LEFT_BORDER;
+ block.x1 += REF_RIGHT_BORDER;
+ block.y0 -= REF_TOP_BORDER;
+ block.y1 += REF_BOTTOM_BORDER;
+
+ ref_area->pad_block.x0 = CLIP(block.x0, 0, frame_width - 1);
+ ref_area->pad_block.y0 = CLIP(block.y0, 0, frame_height - 1);
+ ref_area->pad_block.x1 = CLIP(block.x1, 0, frame_width);
+ ref_area->pad_block.y1 = CLIP(block.y1, 0, frame_height);
+}
+
+void av1_get_reference_area_with_padding(const AV1_COMMON *cm, MACROBLOCKD *xd,
+ int plane, MB_MODE_INFO *mi, int bw,
+ int bh, int mi_x, int mi_y,
+ ReferenceArea ref_area[2],
+ const int comp_pixel_x,
+ const int comp_pixel_y) {
+ const int is_tip = mi->ref_frame[0] == TIP_FRAME;
+ assert(IMPLIES(!is_tip, has_second_ref(mi)));
+ assert(!is_intrabc_block(mi, xd->tree_type));
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+
+ int row_start = 0;
+ int col_start = 0;
+ const int mi_row = -xd->mb_to_top_edge >> MI_SUBPEL_SIZE_LOG2;
+ const int mi_col = -xd->mb_to_left_edge >> MI_SUBPEL_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 = is_tip
+ ? comp_pixel_x
+ : ((mi_x + MI_SIZE * col_start) >> pd->subsampling_x);
+ const int pre_y = is_tip
+ ? comp_pixel_y
+ : ((mi_y + MI_SIZE * row_start) >> pd->subsampling_y);
+
+ for (int ref = 0; ref < 2; ++ref) {
+ const struct scale_factors *const sf =
+ is_tip ? cm->tip_ref.ref_scale_factor[ref]
+ : xd->block_ref_scale_factors[ref];
+ const struct buf_2d *const pre_buf =
+ is_tip ? &cm->tip_ref.tip_plane[plane].pred[ref] : &pd->pre[ref];
+
+ // initialize the reference buffer
+ ref_area[ref].pad_block.x0 = 0;
+ ref_area[ref].pad_block.y0 = 0;
+ ref_area[ref].pad_block.x1 = cm->width;
+ ref_area[ref].pad_block.y1 = cm->height;
+ ref_area[ref].paded_ref_buf_stride = REF_BUFFER_WIDTH;
+
+ InterPredParams inter_pred_params;
+ av1_init_inter_params(&inter_pred_params, bw, bh, pre_y, pre_x,
+ pd->subsampling_x, pd->subsampling_y, xd->bd,
+ mi->use_intrabc[0], sf, pre_buf,
+ is_tip ? MULTITAP_SHARP : mi->interp_fltr);
+
+ inter_pred_params.original_pu_width = bw;
+ inter_pred_params.original_pu_height = bh;
+
+#if CONFIG_TIP
+ const int width = (cm->mi_params.mi_cols << MI_SIZE_LOG2);
+ const int height = (cm->mi_params.mi_rows << MI_SIZE_LOG2);
+ inter_pred_params.dist_to_top_edge = -GET_MV_SUBPEL(pre_y);
+ inter_pred_params.dist_to_bottom_edge = GET_MV_SUBPEL(height - bh - pre_y);
+ inter_pred_params.dist_to_left_edge = -GET_MV_SUBPEL(pre_x);
+ inter_pred_params.dist_to_right_edge = GET_MV_SUBPEL(width - bw - pre_x);
+#endif
+
+ SubpelParams subpel_params;
+ uint16_t *src;
+ int src_stride;
+
+ assert(!inter_pred_params.use_ref_padding);
+
+ MV *src_mv = ref == 0 ? &mi->mv[0].as_mv : &mi->mv[1].as_mv;
+ get_ref_area_info(src_mv, &inter_pred_params, xd, mi_x, mi_y,
+#if CONFIG_OPTFLOW_REFINEMENT
+ 0, /* use_optflow_refinement */
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ &src, &subpel_params, &src_stride, &ref_area[ref],
+ is_tip);
+ }
+}
+
+int av1_refinemv_build_predictors_and_get_sad(
+ MACROBLOCKD *xd, int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func, uint16_t *dst_ref0,
+ uint16_t *dst_ref1, MV mv0, MV mv1, InterPredParams *inter_pred_params) {
+ for (int ref = 0; ref < 2; ref++) {
+ SubpelParams subpel_params;
+ uint16_t *src;
+ int src_stride;
+ uint16_t *dst_ref = ref == 0 ? dst_ref0 : dst_ref1;
+ MV *src_mv = ref == 0 ? &mv0 : &mv1;
+ calc_subpel_params_func(src_mv, &inter_pred_params[ref], xd, mi_x, mi_y,
+ ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ 0, /* use_optflow_refinement */
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ mc_buf, &src, &subpel_params, &src_stride);
+ assert(inter_pred_params[ref].comp_mode == UNIFORM_SINGLE ||
+ inter_pred_params[ref].comp_mode == UNIFORM_COMP);
+ av1_make_inter_predictor(src, src_stride, dst_ref, bw,
+ &inter_pred_params[ref], &subpel_params);
+ }
+
+ return get_refinemv_sad(dst_ref0, dst_ref1, bw, bh, xd->bd);
+}
+void apply_mv_refinement(const AV1_COMMON *cm, MACROBLOCKD *xd, int plane,
+ MB_MODE_INFO *mi, int bw, int bh, int mi_x, int mi_y,
+ uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func,
+ int pre_x, int pre_y, uint16_t *dst_ref0,
+ uint16_t *dst_ref1, MV *best_mv_ref, int pu_width,
+ int pu_height) {
+ // initialize basemv as best MV
+ best_mv_ref[0] = mi->mv[0].as_mv;
+ best_mv_ref[1] = mi->mv[1].as_mv;
+
+ const MV center_mvs[2] = { best_mv_ref[0], best_mv_ref[1] };
+ assert(mi->refinemv_flag < REFINEMV_NUM_MODES);
+ assert(cm->seq_params.enable_refinemv);
+
+ // Generate MV independent inter_pred_params for both references
+ InterPredParams inter_pred_params[2];
+ for (int ref = 0; ref < 2; ref++) {
+ const int is_compound = 0;
+ const int is_intrabc = is_intrabc_block(mi, xd->tree_type);
+ const int is_tip = mi->ref_frame[0] == TIP_FRAME;
+
+ assert(is_intrabc == 0);
+ assert(plane == 0);
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+ struct buf_2d *const dst_buf = &pd->dst;
+
+ const struct scale_factors *const sf =
+ is_tip ? cm->tip_ref.ref_scale_factor[ref]
+ : (is_intrabc ? &cm->sf_identity
+ : xd->block_ref_scale_factors[ref]);
+ const struct buf_2d *const pre_buf =
+ is_tip ? &cm->tip_ref.tip_plane[plane].pred[ref]
+ : (is_intrabc ? dst_buf : &pd->pre[ref]);
+
+ av1_init_inter_params(&inter_pred_params[ref], bw, bh, pre_y, pre_x,
+ pd->subsampling_x, pd->subsampling_y, xd->bd,
+ mi->use_intrabc[0], sf, pre_buf, BILINEAR);
+
+#if CONFIG_REFINEMV
+ inter_pred_params[ref].original_pu_width = pu_width;
+ inter_pred_params[ref].original_pu_height = pu_height;
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_TIP
+ const int width = (cm->mi_params.mi_cols << MI_SIZE_LOG2);
+ const int height = (cm->mi_params.mi_rows << MI_SIZE_LOG2);
+ inter_pred_params[ref].dist_to_top_edge = -GET_MV_SUBPEL(pre_y);
+ inter_pred_params[ref].dist_to_bottom_edge =
+ GET_MV_SUBPEL(height - bh - pre_y);
+ inter_pred_params[ref].dist_to_left_edge = -GET_MV_SUBPEL(pre_x);
+ inter_pred_params[ref].dist_to_right_edge =
+ GET_MV_SUBPEL(width - bw - pre_x);
+#endif
+
+ inter_pred_params[ref].conv_params = get_conv_params_no_round(
+ 0, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
+
+ assert(inter_pred_params[ref].mode == TRANSLATION_PRED);
+ assert(inter_pred_params[ref].comp_mode == UNIFORM_SINGLE);
+ assert(inter_pred_params[ref].conv_params.is_compound == 0);
+ assert(inter_pred_params[ref].conv_params.do_average == 0);
+ assert(mi->interinter_comp.type == COMPOUND_AVERAGE);
+ }
+
+#if !SINGLE_STEP_SEARCH
+ // Search integer-delta values
+ int search_range = 2;
+#endif
+
+ int switchable_refinemv_flags =
+ (mi->ref_frame[0] != TIP_FRAME) && switchable_refinemv_flag(cm, mi);
+ assert(mi->refinemv_flag);
+
+ // If we signal the refinemv_flags we do not select sad0
+ // Set sad0 a large value so that it does not be selected
+ int sad0 = switchable_refinemv_flags
+ ? (INT32_MAX >> 1)
+ : av1_refinemv_build_predictors_and_get_sad(
+ xd, bw, bh, mi_x, mi_y, mc_buf, calc_subpel_params_func,
+ dst_ref0, dst_ref1, center_mvs[0], center_mvs[1],
+ inter_pred_params);
+
+ assert(IMPLIES(mi->ref_frame[0] == TIP_FRAME, bw == 8 && bh == 8));
+ if (mi->ref_frame[0] == TIP_FRAME) {
+ const int tip_sad_thres = bw * bh;
+ if (!switchable_refinemv_flags && sad0 < tip_sad_thres) return;
+ }
+
+ if (!switchable_refinemv_flags) {
+ int shift = 3;
+ int th = (bw * bh) << 1;
+ sad0 -= (sad0 >> shift);
+ assert(sad0 >= 0);
+ if (sad0 < th) return;
+ }
+
+ int min_sad = sad0;
+ MV refined_mv0, refined_mv1;
+ refined_mv0 = center_mvs[0];
+ refined_mv1 = center_mvs[1];
+ int et_sad_th = (bw * bh) << 1;
+
+#if !SINGLE_STEP_SEARCH
+ uint8_t already_searched[5][5];
+ for (int i = 0; i < 5; i++) {
+ for (int j = 0; j < 5; j++) {
+ already_searched[i][j] = 0;
+ }
+ }
+#endif
+
+ MV best_offset = { 0, 0 };
+
+#if SINGLE_STEP_SEARCH
+ const int num_neighbors = 24;
+ static const MV neighbors[24] = {
+ { -1, -1 }, { -1, 0 }, { -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 },
+ { 1, -1 }, { 0, -1 }, { 0, -2 }, { -1, -2 }, { -2, -2 }, { -2, -1 },
+ { -2, 0 }, { -2, 1 }, { -2, 2 }, { -1, 2 }, { 0, 2 }, { 1, 2 },
+ { 2, 2 }, { 2, 1 }, { 2, 0 }, { 2, -1 }, { 2, -2 }, { 1, -2 }
+
+ };
+
+#else
+ const int num_neighbors = 8;
+ // Apply two-step full pel refinement
+ static const MV neighbors[8] = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 },
+ { 1, -1 }, { 1, 1 }, { -1, -1 }, { -1, 1 } };
+
+ const int num_iterations = search_range;
+ already_searched[0 + search_range][0 + search_range] =
+ 1; // center point is already searched before
+ for (int ite = 0; ite < num_iterations; ++ite) {
+#endif // SINGLE_STEP_SEARCH
+
+ int best_idx = -1;
+
+ for (int idx = 0; idx < num_neighbors; ++idx) {
+ MV offset = { best_offset.row + neighbors[idx].row,
+ best_offset.col + neighbors[idx].col };
+#if !SINGLE_STEP_SEARCH
+ if (already_searched[offset.row + search_range][offset.col + search_range])
+ continue;
+#endif
+ refined_mv0.row = center_mvs[0].row + 8 * offset.row;
+ refined_mv0.col = center_mvs[0].col + 8 * offset.col;
+ refined_mv1.row = center_mvs[1].row - 8 * offset.row;
+ refined_mv1.col = center_mvs[1].col - 8 * offset.col;
+
+ int this_sad = av1_refinemv_build_predictors_and_get_sad(
+ xd, bw, bh, mi_x, mi_y, mc_buf, calc_subpel_params_func, dst_ref0,
+ dst_ref1, refined_mv0, refined_mv1, inter_pred_params);
+
+#if !SINGLE_STEP_SEARCH
+ already_searched[offset.row + search_range][offset.col + search_range] = 1;
+#endif
+
+ if (this_sad < min_sad) {
+ min_sad = this_sad;
+ best_idx = idx;
+ // if the SAD is less than predefined threshold consider this candidate
+ // as good enough to skip rest of the search.
+ if (min_sad < et_sad_th) {
+ best_mv_ref[0] = refined_mv0;
+ best_mv_ref[1] = refined_mv1;
+ return;
+ }
+ }
+ }
+
+ // if the center is best, skip rest of the search.
+ if (best_idx == -1) {
+ best_mv_ref[0].row = center_mvs[0].row + 8 * best_offset.row;
+ best_mv_ref[0].col = center_mvs[0].col + 8 * best_offset.col;
+ best_mv_ref[1].row = center_mvs[1].row - 8 * best_offset.row;
+ best_mv_ref[1].col = center_mvs[1].col - 8 * best_offset.col;
+
+ return;
+ }
+
+ if (best_idx >= 0) {
+ best_offset.row += neighbors[best_idx].row;
+ best_offset.col += neighbors[best_idx].col;
+ }
+#if !SINGLE_STEP_SEARCH
+}
+#endif
+
+best_mv_ref[0].row = center_mvs[0].row + 8 * best_offset.row;
+best_mv_ref[0].col = center_mvs[0].col + 8 * best_offset.col;
+best_mv_ref[1].row = center_mvs[1].row - 8 * best_offset.row;
+best_mv_ref[1].col = center_mvs[1].col - 8 * best_offset.col;
+
+assert(min_sad <= sad0);
+
+assert(IMPLIES(switchable_refinemv_flags,
+ !(best_mv_ref[0].row == center_mvs[0].row &&
+ best_mv_ref[0].col == center_mvs[0].col &&
+ best_mv_ref[1].row == center_mvs[1].row &&
+ best_mv_ref[1].col == center_mvs[1].col)));
+}
+
+static void build_inter_predictors_8x8_and_bigger_refinemv(
+ const AV1_COMMON *cm, MACROBLOCKD *xd, int plane, MB_MODE_INFO *mi,
+ int build_for_obmc, int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func, uint16_t *dst, int dst_stride,
+ int pu_width, int pu_height, uint16_t *dst0_16_refinemv,
+ uint16_t *dst1_16_refinemv, int16_t *opt_gx0, int16_t *opt_gx1,
+ int row_start, int col_start, MV *sb_refined_mv, MV *chroma_refined_mv,
+ int build_for_refine_mv_only, ReferenceArea ref_area[2]) {
+ const int is_compound = has_second_ref(mi);
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+ assert(!is_intrabc_block(mi, xd->tree_type));
+ assert(is_compound);
+ assert(!mi->bawp_flag);
+ assert(!build_for_obmc);
+ assert(!is_masked_compound_type(mi->interinter_comp.type));
+ assert(!is_tip_ref_frame(mi->ref_frame[0]));
+
+#if CONFIG_CWP
+ assert(mi->cwp_idx == CWP_EQUAL);
+#endif
+
+ int is_global[2] = { 0, 0 };
+ for (int ref = 0; ref < 1 + is_compound; ++ref) {
+#if CONFIG_TIP
+ if (!is_tip_ref_frame(mi->ref_frame[ref])) {
+#endif // CONFIG_TIP
+ const WarpedMotionParams *const wm =
+ &xd->global_motion[mi->ref_frame[ref]];
+ is_global[ref] = is_global_mv_block(mi, wm->wmtype);
+#if CONFIG_TIP
+ }
+#endif // CONFIG_TIP
+ }
+
+ assert(!is_global[0] && !is_global[1]);
+
+ 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;
+
+ int apply_refinemv = (plane == 0);
+
+ MV best_mv_ref[2] = { { mi->mv[0].as_mv.row, mi->mv[0].as_mv.col },
+ { mi->mv[1].as_mv.row, mi->mv[1].as_mv.col } };
+ if (apply_refinemv) {
+ uint16_t *dst_ref0 = NULL, *dst_ref1 = NULL;
+ dst_ref0 = &dst0_16_refinemv[0];
+ dst_ref1 = &dst1_16_refinemv[0];
+
+ assert(IMPLIES(!mi->skip_mode,
+ is_refinemv_allowed(cm, mi, mi->sb_type[PLANE_TYPE_Y])));
+ assert(IMPLIES(mi->skip_mode, is_refinemv_allowed_skip_mode(cm, mi)));
+ apply_mv_refinement(cm, xd, plane, mi, bw, bh, mi_x, mi_y, mc_buf,
+ calc_subpel_params_func, pre_x, pre_y, dst_ref0,
+ dst_ref1, best_mv_ref, pu_width, pu_height);
+ if (sb_refined_mv) {
+ // store the DMVR refined MV so that chroma can use it
+ sb_refined_mv[0] = best_mv_ref[0];
+ sb_refined_mv[1] = best_mv_ref[1];
+ }
+ assert(IMPLIES(plane, !build_for_refine_mv_only));
+ // if build_for_refine_mv_only is non-zero, we build only to get the
+ // refinemv values The actual prediction values are not necessary
+ if (build_for_refine_mv_only) {
+ return;
+ }
+ } else {
+ best_mv_ref[0] = chroma_refined_mv[0];
+ best_mv_ref[1] = chroma_refined_mv[1];
+ }
+
+#if CONFIG_OPTFLOW_REFINEMENT
+ int_mv mv_refined[2 * N_OF_OFFSETS];
+ const int use_optflow_refinement =
+ (mi->mode >= NEAR_NEARMV_OPTFLOW ||
+ (cm->features.opfl_refine_type == REFINE_ALL &&
+ mi->mode != GLOBAL_GLOBALMV &&
+ mi->interinter_comp.type == COMPOUND_AVERAGE)) &&
+ is_compound && is_opfl_refine_allowed(cm, mi);
+ assert(IMPLIES(use_optflow_refinement,
+ cm->features.opfl_refine_type != REFINE_NONE));
+ assert(IMPLIES(use_optflow_refinement, !build_for_obmc));
+
+ // Optical flow refinement with masked comp types or with non-sharp
+ // interpolation filter should only exist in REFINE_ALL.
+ assert(IMPLIES(
+ use_optflow_refinement && mi->interinter_comp.type != COMPOUND_AVERAGE,
+ cm->features.opfl_refine_type == REFINE_ALL));
+ assert(IMPLIES(use_optflow_refinement && mi->interp_fltr != MULTITAP_SHARP,
+ cm->features.opfl_refine_type == REFINE_ALL));
+
+ // Arrays to hold optical flow offsets.
+ int vx0[N_OF_OFFSETS] = { 0 };
+ int vx1[N_OF_OFFSETS] = { 0 };
+ int vy0[N_OF_OFFSETS] = { 0 };
+ int vy1[N_OF_OFFSETS] = { 0 };
+
+ // Pointers to gradient and dst buffers
+ int16_t *gx0, *gy0, *gx1, *gy1;
+ uint16_t *dst0 = NULL, *dst1 = NULL;
+
+ if (use_optflow_refinement && plane == 0) {
+ // Allocate gradient and dst buffers
+ // gx0 = aom_memalign(32, 2 * MAX_SB_SIZE * MAX_SB_SIZE * sizeof(*gx0));
+ // gx1 = aom_memalign(32, 2 * MAX_SB_SIZE * MAX_SB_SIZE * sizeof(*gx1));
+ gx0 = &opt_gx0[0];
+ gx1 = &opt_gx1[0];
+ gy0 = gx0 + (REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT);
+ gy1 = gx1 + (REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT);
+
+ // Initialize refined mv
+ const MV mv0 = best_mv_ref[0];
+ const MV mv1 = best_mv_ref[1];
+
+ for (int mvi = 0; mvi < N_OF_OFFSETS; mvi++) {
+ mv_refined[mvi * 2].as_mv = mv0;
+ mv_refined[mvi * 2 + 1].as_mv = mv1;
+ }
+ // Refine MV using optical flow. The final output MV will be in 1/16
+ // precision.
+ dst0 = &dst0_16_refinemv[0];
+ dst1 = &dst1_16_refinemv[0];
+ // dst0 = aom_calloc(1, MAX_SB_SIZE * MAX_SB_SIZE * sizeof(uint16_t));
+ // dst1 = aom_calloc(1, MAX_SB_SIZE * MAX_SB_SIZE * sizeof(uint16_t));
+
+ av1_get_optflow_based_mv_highbd(cm, xd, plane, mi, mv_refined, bw, bh, mi_x,
+ mi_y, mc_buf, calc_subpel_params_func, gx0,
+ gy0, gx1, gy1, vx0, vy0, vx1, vy1, dst0,
+ dst1
+#if CONFIG_OPTFLOW_ON_TIP
+ ,
+ 1, 1
+#endif // CONFIG_OPTFLOW_ON_TIP
+ ,
+ best_mv_ref, pu_width, pu_height);
+ }
+#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_D071_IMP_MSK_BLD
+ BacpBlockData bacp_block_data[2 * N_OF_OFFSETS];
+ uint8_t use_bacp = !build_for_obmc && use_border_aware_compound(cm, mi) &&
+ mi->cwp_idx == CWP_EQUAL &&
+ cm->features.enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+ for (int ref = 0; ref < 1 + is_compound; ++ref) {
+ const struct scale_factors *const sf = xd->block_ref_scale_factors[ref];
+ struct buf_2d *const pre_buf = &pd->pre[ref];
+
+ const MV mv = best_mv_ref[ref];
+ const WarpTypesAllowed warp_types = { is_global[ref],
+ is_warp_mode(mi->motion_mode) };
+ InterPredParams inter_pred_params;
+ av1_init_inter_params(&inter_pred_params, bw, bh, pre_y, pre_x,
+ pd->subsampling_x, pd->subsampling_y, xd->bd,
+ mi->use_intrabc[0], sf, pre_buf, mi->interp_fltr);
+
+#if CONFIG_REFINEMV
+ inter_pred_params.use_ref_padding = 1;
+ inter_pred_params.ref_area = &ref_area[ref];
+#endif // CONFIG_REFINEMV
+
+ inter_pred_params.original_pu_width = pu_width;
+ inter_pred_params.original_pu_height = pu_height;
+
+ if (is_compound) av1_init_comp_mode(&inter_pred_params);
+#if CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params.border_data.enable_bacp = use_bacp;
+ inter_pred_params.border_data.bacp_block_data =
+ &bacp_block_data[0]; // Always point to the first ref
+#endif // CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params.conv_params = get_conv_params_no_round(
+ ref, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
+
+ if (!build_for_obmc)
+ av1_init_warp_params(&inter_pred_params, &warp_types, ref, xd, mi);
+
+#if CONFIG_D071_IMP_MSK_BLD
+ if (is_compound) {
+ inter_pred_params.sb_type = mi->sb_type[PLANE_TYPE_Y];
+ inter_pred_params.mask_comp = mi->interinter_comp;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+#if CONFIG_OPTFLOW_REFINEMENT
+ if (use_optflow_refinement && plane == 0) {
+ int n = opfl_get_subblock_size(bw, bh, plane
+#if CONFIG_OPTFLOW_ON_TIP
+ ,
+ 1
+#endif // CONFIG_OPTFLOW_ON_TIP
+ );
+ inter_pred_params.interp_filter_params[0] =
+ av1_get_interp_filter_params_with_block_size(mi->interp_fltr, n);
+
+ inter_pred_params.interp_filter_params[1] =
+ av1_get_interp_filter_params_with_block_size(mi->interp_fltr, n);
+
+ av1_opfl_rebuild_inter_predictor(dst, dst_stride, plane, mv_refined,
+ &inter_pred_params, xd, mi_x, mi_y, ref,
+ mc_buf, calc_subpel_params_func
+#if CONFIG_OPTFLOW_ON_TIP
+ ,
+ 1
+#endif // CONFIG_OPTFLOW_ON_TIP
+ );
+ continue;
+ }
+#endif // CONFIG_OPTFLOW_REFINEMENT
+
+ av1_build_one_inter_predictor(dst, dst_stride, &mv, &inter_pred_params, xd,
+ mi_x, mi_y, ref, mc_buf,
+ calc_subpel_params_func);
+ }
+
+#if CONFIG_PEF
+ if (use_optflow_refinement && plane == 0) {
+ enhance_prediction(cm, xd, plane, dst, dst_stride, bw, bh
+#if CONFIG_OPTFLOW_REFINEMENT
+ ,
+ mv_refined, use_optflow_refinement
+#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_REFINEMV
+ ,
+ 0, NULL
+#endif // CONFIG_REFINEMV
+ );
+ }
+#endif // CONFIG_PEF
+}
+
+#endif // CONFIG_REFINEMV
+
static void build_inter_predictors_8x8_and_bigger(
const AV1_COMMON *cm, MACROBLOCKD *xd, int plane, MB_MODE_INFO *mi,
#if CONFIG_BAWP
const BUFFER_SET *dst_orig,
#endif // CONFIG_BAWP
int build_for_obmc, int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,
- CalcSubpelParamsFunc calc_subpel_params_func) {
+ CalcSubpelParamsFunc calc_subpel_params_func
+#if CONFIG_REFINEMV
+ ,
+ int build_for_refine_mv_only
+#endif // CONFIG_REFINEMV
+) {
const int is_compound = has_second_ref(mi);
const int is_intrabc = is_intrabc_block(mi, xd->tree_type);
assert(IMPLIES(is_intrabc, !is_compound));
@@ -1768,6 +3280,115 @@
struct buf_2d *const dst_buf = &pd->dst;
uint16_t *const dst = dst_buf->buf;
+#if CONFIG_REFINEMV
+ assert(IMPLIES(mi->refinemv_flag, !is_intrabc));
+ assert(IMPLIES(mi->refinemv_flag && !build_for_obmc, is_compound));
+ assert(IMPLIES(
+ !build_for_obmc && mi->refinemv_flag && switchable_refinemv_flag(cm, mi),
+ mi->interinter_comp.type == COMPOUND_AVERAGE));
+ assert(IMPLIES(mi->refinemv_flag, mi->bawp_flag == 0));
+ assert(IMPLIES(mi->refinemv_flag, mi->interp_fltr == MULTITAP_SHARP));
+
+ int apply_sub_block_refinemv = mi->refinemv_flag && (!build_for_obmc) &&
+ !is_tip_ref_frame(mi->ref_frame[0]);
+
+ if (apply_sub_block_refinemv && default_refinemv_modes(mi))
+ apply_sub_block_refinemv &= (mi->comp_group_idx == 0 &&
+ mi->interinter_comp.type == COMPOUND_AVERAGE);
+
+ if (apply_sub_block_refinemv) {
+#if CONFIG_CWP
+ assert(IMPLIES(mi->refinemv_flag, mi->cwp_idx == CWP_EQUAL));
+#endif
+ int refinemv_sb_size_width =
+ AOMMIN((REFINEMV_SUBBLOCK_WIDTH >> pd->subsampling_x), bw);
+ int refinemv_sb_size_height =
+ AOMMIN(REFINEMV_SUBBLOCK_HEIGHT >> pd->subsampling_y, bh);
+ uint16_t
+ dst0_16_refinemv[REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT];
+ uint16_t
+ dst1_16_refinemv[REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT];
+ DECLARE_ALIGNED(
+ 32, int16_t,
+ opt_gx0[2 * REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT]);
+ DECLARE_ALIGNED(
+ 32, int16_t,
+ opt_gx1[2 * REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT]);
+
+ ReferenceArea ref_area[2];
+ av1_get_reference_area_with_padding(cm, xd, plane, mi, bw, bh, mi_x, mi_y,
+ ref_area, 0, 0);
+
+ int dst_stride = dst_buf->stride;
+ CONV_BUF_TYPE *tmp_conv_dst = xd->tmp_conv_dst;
+ assert(bw % refinemv_sb_size_width == 0);
+ assert(bh % refinemv_sb_size_height == 0);
+ for (int h = 0; h < bh; h += refinemv_sb_size_height) {
+ for (int w = 0; w < bw; w += refinemv_sb_size_width) {
+ dst_buf->buf = dst + h * dst_stride + w;
+ xd->tmp_conv_dst = tmp_conv_dst + h * MAX_SB_SIZE + w;
+
+ const int mi_row = -xd->mb_to_top_edge >> MI_SUBPEL_SIZE_LOG2;
+ const int mi_col = -xd->mb_to_left_edge >> MI_SUBPEL_SIZE_LOG2;
+ int row_start =
+ plane ? (mi->chroma_ref_info.mi_row_chroma_base - mi_row) : 0;
+ int col_start =
+ plane ? (mi->chroma_ref_info.mi_col_chroma_base - mi_col) : 0;
+ MV luma_refined_mv[2] = { { mi->mv[0].as_mv.row, mi->mv[0].as_mv.col },
+ { mi->mv[1].as_mv.row,
+ mi->mv[1].as_mv.col } };
+
+ MV chroma_refined_mv[2] = {
+ { mi->mv[0].as_mv.row, mi->mv[0].as_mv.col },
+ { mi->mv[1].as_mv.row, mi->mv[1].as_mv.col }
+ };
+
+ if (plane != 0) {
+ int luma_h = (h << pd->subsampling_y);
+ int luma_w = (w << pd->subsampling_x);
+ REFINEMV_SUBMB_INFO *refinemv_subinfo =
+ &xd->refinemv_subinfo[(luma_h >> MI_SIZE_LOG2) * MAX_MIB_SIZE +
+ (luma_w >> MI_SIZE_LOG2)];
+ chroma_refined_mv[0] = refinemv_subinfo->refinemv[0].as_mv;
+ chroma_refined_mv[1] = refinemv_subinfo->refinemv[1].as_mv;
+ }
+ // mi_x, and mi_y are the top-left position of the luma samples of the
+ // sub-block
+ build_inter_predictors_8x8_and_bigger_refinemv(
+ cm, xd, plane, mi, build_for_obmc, refinemv_sb_size_width,
+ refinemv_sb_size_height, mi_x + w * (1 << pd->subsampling_x),
+ mi_y + h * (1 << pd->subsampling_y), mc_buf,
+ calc_subpel_params_func, dst_buf->buf, dst_stride, bw, bh,
+ dst0_16_refinemv, dst1_16_refinemv, opt_gx0, opt_gx1, row_start,
+ col_start, plane == 0 ? luma_refined_mv : NULL, chroma_refined_mv,
+ build_for_refine_mv_only, ref_area);
+
+ if (plane == 0) {
+ REFINEMV_SUBMB_INFO *refinemv_subinfo =
+ &xd->refinemv_subinfo[(h >> MI_SIZE_LOG2) * MAX_MIB_SIZE +
+ (w >> MI_SIZE_LOG2)];
+ fill_subblock_refine_mv(refinemv_subinfo, refinemv_sb_size_width,
+ refinemv_sb_size_height, luma_refined_mv[0],
+ luma_refined_mv[1]);
+ }
+ }
+ }
+
+#if CONFIG_PEF
+ enhance_prediction(cm, xd, plane, dst, dst_stride, bw, bh
+#if CONFIG_OPTFLOW_REFINEMENT
+ ,
+ NULL, 0
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ ,
+ apply_sub_block_refinemv, &xd->refinemv_subinfo[0]);
+#endif // CONFIG_PEF
+ dst_buf->buf = dst;
+ xd->tmp_conv_dst = tmp_conv_dst;
+ return;
+ }
+#endif // CONFIG_REFINEMV
+
int is_global[2] = { 0, 0 };
for (int ref = 0; ref < 1 + is_compound; ++ref) {
#if CONFIG_TIP
@@ -1791,17 +3412,23 @@
}
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;
-
+#if CONFIG_REFINEMV
+ MV best_mv_ref[2] = { { mi->mv[0].as_mv.row, mi->mv[0].as_mv.col },
+ { mi->mv[1].as_mv.row, mi->mv[1].as_mv.col } };
+#endif // CONFIG_REFINEMV
#if CONFIG_OPTFLOW_REFINEMENT
int_mv mv_refined[2 * N_OF_OFFSETS];
const int use_optflow_refinement =
(mi->mode >= NEAR_NEARMV_OPTFLOW ||
(cm->features.opfl_refine_type == REFINE_ALL &&
mi->mode != GLOBAL_GLOBALMV &&
+#if CONFIG_CWP
+ mi->cwp_idx == CWP_EQUAL &&
+#endif // CONFIG_CWP
mi->interinter_comp.type == COMPOUND_AVERAGE)) &&
is_compound && is_opfl_refine_allowed(cm, mi);
assert(IMPLIES(use_optflow_refinement,
- cm->features.opfl_refine_type == REFINE_SWITCHABLE));
+ cm->features.opfl_refine_type != REFINE_NONE));
assert(IMPLIES(use_optflow_refinement, !build_for_obmc));
// Optical flow refinement with masked comp types or with non-sharp
@@ -1838,8 +3465,13 @@
gy1 = g1_buf + MAX_SB_SQUARE;
// Initialize refined mv
- const MV mv0 = mi->mv[0].as_mv;
- const MV mv1 = mi->mv[1].as_mv;
+#if CONFIG_REFINEMV
+ const MV mv0 = best_mv_ref[0];
+ const MV mv1 = best_mv_ref[1];
+#else
+ const MV mv0 = mi->mv[0].as_mv;
+ const MV mv1 = mi->mv[1].as_mv;
+#endif // CONFIG_REFINEMV
for (int mvi = 0; mvi < n_blocks; mvi++) {
mv_refined[mvi * 2].as_mv = mv0;
mv_refined[mvi * 2 + 1].as_mv = mv1;
@@ -1855,10 +3487,21 @@
,
1, 1
#endif // CONFIG_OPTFLOW_ON_TIP
+#if CONFIG_REFINEMV
+ ,
+ best_mv_ref, bw, bh
+#endif // CONFIG_REFINEMV
);
}
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_D071_IMP_MSK_BLD
+ BacpBlockData bacp_block_data[2 * N_OF_OFFSETS];
+ uint8_t use_bacp = !build_for_obmc && use_border_aware_compound(cm, mi) &&
+ mi->cwp_idx == CWP_EQUAL &&
+ cm->features.enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
for (int ref = 0; ref < 1 + is_compound; ++ref) {
const struct scale_factors *const sf =
is_intrabc ? &cm->sf_identity : xd->block_ref_scale_factors[ref];
@@ -1872,15 +3515,31 @@
pd->subsampling_x, pd->subsampling_y, xd->bd,
mi->use_intrabc[0], sf, pre_buf, mi->interp_fltr);
if (is_compound) av1_init_comp_mode(&inter_pred_params);
+#if CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params.border_data.enable_bacp = use_bacp;
+ inter_pred_params.border_data.bacp_block_data =
+ &bacp_block_data[0]; // Always point to the first ref
+#endif // CONFIG_D071_IMP_MSK_BLD
+
inter_pred_params.conv_params = get_conv_params_no_round(
ref, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
if (!build_for_obmc)
av1_init_warp_params(&inter_pred_params, &warp_types, ref, xd, mi);
- if (is_masked_compound_type(mi->interinter_comp.type)) {
+#if CONFIG_D071_IMP_MSK_BLD
+ if (is_compound) {
inter_pred_params.sb_type = mi->sb_type[PLANE_TYPE_Y];
inter_pred_params.mask_comp = mi->interinter_comp;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+ if (is_masked_compound_type(mi->interinter_comp.type)) {
+#if !CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params.sb_type = mi->sb_type[PLANE_TYPE_Y];
+ inter_pred_params.mask_comp = mi->interinter_comp;
+#endif // !CONFIG_D071_IMP_MSK_BLD
+
if (ref == 1) {
inter_pred_params.conv_params.do_average = 0;
inter_pred_params.comp_mode = MASK_COMP;
@@ -1889,6 +3548,18 @@
inter_pred_params.mask_comp.seg_mask = xd->seg_mask;
}
+#if CONFIG_CWP
+ if (ref == 1 && inter_pred_params.conv_params.do_average == 1) {
+ if (get_cwp_idx(mi) != CWP_EQUAL) {
+ int8_t weight = get_cwp_idx(mi);
+ assert(mi->cwp_idx >= CWP_MIN && mi->cwp_idx <= CWP_MAX);
+ inter_pred_params.conv_params.fwd_offset = weight;
+ inter_pred_params.conv_params.bck_offset =
+ (1 << CWP_WEIGHT_BITS) - weight;
+ }
+ }
+#endif // CONFIG_CWP
+
#if CONFIG_OPTFLOW_REFINEMENT
if (use_optflow_refinement && plane == 0) {
const int n = opfl_get_subblock_size(bw, bh, plane
@@ -1930,6 +3601,10 @@
,
mv_refined, use_optflow_refinement
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ ,
+ 0, NULL
+#endif // CONFIG_REFINEMV
);
#endif // CONFIG_PEF
}
@@ -1939,6 +3614,9 @@
#if CONFIG_BAWP
const BUFFER_SET *dst_orig,
#endif
+#if CONFIG_REFINEMV
+ int build_for_refine_mv_only,
+#endif // CONFIG_REFINEMV
int build_for_obmc, int bw, int bh, int mi_x,
int mi_y, uint16_t **mc_buf,
CalcSubpelParamsFunc calc_subpel_params_func) {
@@ -1946,7 +3624,12 @@
// just for debugging purpose
// Can be removed later on
if (mi->mode == WARPMV) {
- assert(mi->ref_mv_idx == 0);
+#if CONFIG_SEP_COMP_DRL
+ assert(mi->ref_mv_idx[0] == 0);
+ assert(mi->ref_mv_idx[1] == 0);
+#else
+ assert(mi->ref_mv_idx == 0);
+#endif // CONFIG_SEP_COMP_DRL
assert(mi->motion_mode == WARP_DELTA || mi->motion_mode == WARPED_CAUSAL);
}
#endif // CONFIG_WARPMV
@@ -1963,7 +3646,12 @@
dst_orig,
#endif
build_for_obmc, bw, bh, mi_x, mi_y,
- mc_buf, calc_subpel_params_func);
+ mc_buf, calc_subpel_params_func
+#if CONFIG_REFINEMV
+ ,
+ build_for_refine_mv_only
+#endif // CONFIG_REFINEMV
+ );
}
}
@@ -2061,7 +3749,7 @@
return;
foreach_overlappable_nb_above(cm, xd, INT_MAX, increment_uint8_t_ptr,
- &mbmi->overlappable_neighbors[0]);
+ &mbmi->overlappable_neighbors[0], true);
if (mbmi->overlappable_neighbors[0]) return;
foreach_overlappable_nb_left(cm, xd, INT_MAX, increment_uint8_t_ptr,
&mbmi->overlappable_neighbors[1]);
@@ -2174,9 +3862,9 @@
// handle above row
struct obmc_inter_pred_ctxt ctxt_above = { above, above_stride };
- foreach_overlappable_nb_above(cm, xd,
- max_neighbor_obmc[mi_size_wide_log2[bsize]],
- build_obmc_inter_pred_above, &ctxt_above);
+ foreach_overlappable_nb_above(
+ cm, xd, max_neighbor_obmc[mi_size_wide_log2[bsize]],
+ build_obmc_inter_pred_above, &ctxt_above, false);
// handle left column
struct obmc_inter_pred_ctxt ctxt_left = { left, left_stride };
@@ -2387,6 +4075,18 @@
return (above_mpp_flag + left_mpp_flag);
}
+#if CONFIG_REFINEMV
+// Derive the context index for refinemv flag
+int av1_get_refinemv_context(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+ BLOCK_SIZE bsize) {
+ (void)cm;
+ (void)bsize;
+ const MB_MODE_INFO *const mbmi = xd->mi[0];
+ if (mbmi->skip_mode) return 0;
+ return (1 + (mbmi->mode - NEAR_NEARMV));
+}
+#endif // CONFIG_REFINEMV
+
int av1_get_pb_mv_precision_down_context(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
(void)cm;
@@ -2480,7 +4180,11 @@
}
void set_precision_set(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
MB_MODE_INFO *mbmi, const BLOCK_SIZE bsize,
- uint8_t ref_mv_idx) {
+#if CONFIG_SEP_COMP_DRL
+ int *ref_mv_idx) {
+#else
+ uint8_t ref_mv_idx) {
+#endif // CONFIG_SEP_COMP_DRL
(void)bsize;
(void)cm;
(void)xd;
@@ -2527,5 +4231,22 @@
cm->features.use_pb_mv_precision &&
have_newmv_in_inter_mode(mbmi->mode);
}
-
#endif
+
+#if CONFIG_REFINEMV
+// Copy mv0 and mv1 to the sub-blocks
+// submi is the top-left corner of the sub-block need to fill
+// bw is the block width in the unit of pixel
+// bh is the block height in unit of pixel
+void fill_subblock_refine_mv(REFINEMV_SUBMB_INFO *refinemv_subinfo, int bw,
+ int bh, MV mv0, MV mv1) {
+ const int stride = MAX_MIB_SIZE;
+ for (int y = 0; y < (bh >> MI_SIZE_LOG2); y++) {
+ for (int x = 0; x < (bw >> MI_SIZE_LOG2); x++) {
+ refinemv_subinfo[x].refinemv[0].as_mv = mv0;
+ refinemv_subinfo[x].refinemv[1].as_mv = mv1;
+ }
+ refinemv_subinfo += stride;
+ }
+}
+#endif // CONFIG_REFINEMV
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index 18ea840..5a5a146 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -167,6 +167,13 @@
int ys;
int subpel_x;
int subpel_y;
+#if CONFIG_D071_IMP_MSK_BLD
+ int x0; // top left sample horizontal cood.
+ int y0; // top left sample vertical cood.
+ int x1; // x0 + bw
+ int y1; // y0 + bh
+#endif // CONFIG_D071_IMP_MSK_BLD
+
} SubpelParams;
struct build_prediction_ctxt {
@@ -179,6 +186,14 @@
void *dcb; // Decoder-only coding block.
};
+#if CONFIG_REFINEMV
+#define REFINE_MV_MAX_OFFSET 1
+#define REF_TOP_BORDER (AOM_INTERP_EXTEND - 1 + REFINE_MV_MAX_OFFSET)
+#define REF_LEFT_BORDER (AOM_INTERP_EXTEND - 1 + REFINE_MV_MAX_OFFSET)
+#define REF_RIGHT_BORDER (AOM_INTERP_EXTEND + REFINE_MV_MAX_OFFSET)
+#define REF_BOTTOM_BORDER (AOM_INTERP_EXTEND + REFINE_MV_MAX_OFFSET)
+#endif // CONFIG_REFINEMV
+
typedef enum InterPredMode {
TRANSLATION_PRED,
WARP_PRED,
@@ -206,6 +221,15 @@
int orig_block_width;
int orig_block_height;
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_REFINEMV
+ // In refinemV, the prediction is generated maximum 16x16 sub-block basis
+ // original_pu_width and original_pu_height represents the width and height
+ // of the original block.
+ int original_pu_width;
+ int original_pu_height;
+#endif // CONFIG_REFINEMV
+
int pix_row;
int pix_col;
struct buf_2d ref_frame_buf;
@@ -226,6 +250,15 @@
int dist_to_top_edge; /*!< Distance from top edge */
int dist_to_bottom_edge; /*!< Distance from bottom edge */
#endif // CONFIG_TIP
+
+#if CONFIG_REFINEMV
+ int use_ref_padding;
+ ReferenceArea *ref_area;
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_D071_IMP_MSK_BLD
+ INTERINTER_COMPOUND_BORDER_DATA border_data;
+#endif // CONFIG_D071_IMP_MSK_BLD
} InterPredParams;
#if CONFIG_OPTFLOW_REFINEMENT
@@ -300,15 +333,49 @@
#if CONFIG_WARP_REF_LIST
// Check if the signaling of the warp delta parameters are allowed
-static INLINE int allow_warp_parameter_signaling(const MB_MODE_INFO *mbmi) {
+static INLINE int allow_warp_parameter_signaling(
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ const AV1_COMMON *const cm,
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ const MB_MODE_INFO *mbmi) {
return (
#if CONFIG_WARPMV
mbmi->mode != WARPMV &&
#endif // CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ cm->features.allow_warpmv_mode &&
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
mbmi->motion_mode == WARP_DELTA && mbmi->warp_ref_idx == 1);
}
#endif // CONFIG_WARP_REF_LIST
+#if CONFIG_CWP
+// Map the index to weighting factor for compound weighted prediction
+static INLINE int get_cwp_coding_idx(int val, int encode,
+ const AV1_COMMON *const cm,
+ const MB_MODE_INFO *const mbmi) {
+ int is_same_side = 0;
+ int cur_ref_side = 0;
+ int other_ref_side = 0;
+ if (has_second_ref(mbmi)) {
+ cur_ref_side = cm->ref_frame_side[mbmi->ref_frame[0]];
+ other_ref_side = cm->ref_frame_side[mbmi->ref_frame[1]];
+
+ is_same_side = (cur_ref_side > 0 && other_ref_side > 0) ||
+ (cur_ref_side == 0 && other_ref_side == 0);
+ }
+
+ if (encode) {
+ for (int i = 0; i < MAX_CWP_NUM; i++) {
+ if (cwp_weighting_factor[is_same_side][i] == val) return i;
+ }
+ return 0;
+ } else {
+ return cwp_weighting_factor[is_same_side][val];
+ }
+}
+#endif // CONFIG_CWP
+
#if CONFIG_ADAPTIVE_MVD
static INLINE int enable_adaptive_mvd_resolution(const AV1_COMMON *const cm,
const MB_MODE_INFO *mbmi) {
@@ -474,10 +541,316 @@
#if CONFIG_BAWP
const BUFFER_SET *dst_orig,
#endif
+#if CONFIG_REFINEMV
+ int build_for_refine_mv_only,
+#endif // CONFIG_REFINEMV
int build_for_obmc, int bw, int bh, int mi_x,
int mi_y, uint16_t **mc_buf,
CalcSubpelParamsFunc calc_subpel_params_func);
+#if CONFIG_REFINEMV
+// Generate one prediction signal for a TIP block
+void tip_build_one_inter_predictor(
+ uint16_t *dst, int dst_stride, const MV *const src_mv,
+ InterPredParams *inter_pred_params, MACROBLOCKD *xd, int mi_x, int mi_y,
+ int ref, uint16_t **mc_buf, CalcSubpelParamsFunc calc_subpel_params_func);
+
+// Compute the SAD between the two predictors when refinemv is ON
+int get_refinemv_sad(uint16_t *src1, uint16_t *src2, int width, int height,
+ int bd);
+// Genrate two prediction signals and compute SAD of a given mv0 and mv1
+int av1_refinemv_build_predictors_and_get_sad(
+ MACROBLOCKD *xd, int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func, uint16_t *dst_ref0,
+ uint16_t *dst_ref1, MV mv0, MV mv1, InterPredParams *inter_pred_params);
+
+// Get the context index to code refinemv flag
+int av1_get_refinemv_context(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+ BLOCK_SIZE bsize);
+
+// Full blocks refine MVs are stored in 4x4 grid so that the MVs can be reused
+// for chroma
+void fill_subblock_refine_mv(REFINEMV_SUBMB_INFO *refinemv_subinfo, int bw,
+ int bh, MV mv0, MV mv1);
+
+// Generate the reference area ( bounding box) based on the signaled MV
+void av1_get_reference_area_with_padding(const AV1_COMMON *cm, MACROBLOCKD *xd,
+ int plane, MB_MODE_INFO *mi, int bw,
+ int bh, int mi_x, int mi_y,
+ ReferenceArea ref_area[2],
+ const int comp_pixel_x,
+ const int comp_pixel_y);
+
+// Derive the sub-pixel related parameters of TIP blocks
+// Sub-pel related parameters are stored in the structures pointed by
+// "subpel_params" and "block"
+void tip_dec_calc_subpel_params(const MV *const src_mv,
+ InterPredParams *const inter_pred_params,
+ int mi_x, int mi_y, uint16_t **pre,
+ SubpelParams *subpel_params, int *src_stride,
+ PadBlock *block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ MV32 *scaled_mv, int *subpel_x_mv,
+ int *subpel_y_mv);
+
+// Derive the sub-pixel related parameters of non-TIP blocks
+// Sub-pel related parameters are stored in the structures pointed by
+// "subpel_params" and "block"
+void dec_calc_subpel_params(const MV *const src_mv,
+ InterPredParams *const inter_pred_params,
+ const MACROBLOCKD *const xd, int mi_x, int mi_y,
+ uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride, PadBlock *block,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ MV32 *scaled_mv, int *subpel_x_mv,
+ int *subpel_y_mv);
+
+// check if the refinemv mode is allwed for a given blocksize
+static INLINE int is_refinemv_allowed_bsize(BLOCK_SIZE bsize) {
+ assert(bsize < BLOCK_SIZES_ALL);
+ return (block_size_wide[bsize] >= 16 || block_size_high[bsize] >= 16);
+}
+
+// check if the refinemv mode is allwed for a given mode and precision
+static INLINE int is_refinemv_allowed_mode_precision(
+ PREDICTION_MODE mode, MvSubpelPrecision precision,
+ const AV1_COMMON *const cm) {
+ (void)precision;
+ if (mode == GLOBAL_GLOBALMV) return 0;
+ if (cm->features.opfl_refine_type == REFINE_SWITCHABLE &&
+ (mode == JOINT_NEWMV || mode == JOINT_AMVDNEWMV || mode == NEAR_NEWMV ||
+ mode == NEW_NEARMV || mode == NEW_NEWMV))
+ return 0;
+ return (mode >= NEAR_NEARMV && mode <= JOINT_AMVDNEWMV_OPTFLOW);
+}
+// check if the prediction mode infered to refimemv to always 1.
+static INLINE int default_refinemv_modes(const MB_MODE_INFO *mbmi) {
+ return (mbmi->skip_mode || mbmi->mode == NEAR_NEARMV ||
+ mbmi->mode == NEAR_NEARMV_OPTFLOW ||
+ mbmi->mode == JOINT_NEWMV_OPTFLOW);
+}
+// Check if the compound and equal distance references
+static INLINE int is_refinemv_allowed_reference(const AV1_COMMON *cm,
+ const MB_MODE_INFO *mbmi) {
+ if (!cm->seq_params.enable_refinemv) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const unsigned int cur_index = cm->cur_frame->display_order_hint;
+#else
+ const unsigned int cur_index = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ int d0, d1;
+ int is_tip = (mbmi->ref_frame[0] == TIP_FRAME);
+
+ if (is_tip) {
+ d0 = cm->tip_ref.ref_offset[0];
+ d1 = cm->tip_ref.ref_offset[1];
+ } else {
+ if (!mbmi->ref_frame[1]) return 0;
+ const RefCntBuffer *const ref0 = get_ref_frame_buf(cm, mbmi->ref_frame[0]);
+ const RefCntBuffer *const ref1 = get_ref_frame_buf(cm, mbmi->ref_frame[1]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ d0 = get_relative_dist(&cm->seq_params.order_hint_info, cur_index,
+ ref0->display_order_hint);
+ d1 = get_relative_dist(&cm->seq_params.order_hint_info, cur_index,
+ ref1->display_order_hint);
+#else
+ d0 = (int)cur_index - (int)ref0->order_hint;
+ d1 = (int)cur_index - (int)ref1->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ }
+
+ // reference frame has to be both sides to apply dmvr
+ if (!((d0 <= 0) ^ (d1 <= 0))) return 0;
+
+ // Current implementation only supports when both has the same distance
+ if (abs(d0) != abs(d1)) return 0;
+
+ return 1;
+}
+
+// check if the refinemv mode is allowed for a given block
+static INLINE int is_refinemv_allowed(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi,
+ BLOCK_SIZE bsize) {
+ if (!cm->seq_params.enable_refinemv ||
+ cm->superres_scale_denominator != SCALE_NUMERATOR)
+ return 0;
+ int is_tip = is_tip_ref_frame(mbmi->ref_frame[0]);
+ if (is_tip) return 0;
+ assert(!mbmi->skip_mode);
+ int is_compound = has_second_ref(mbmi);
+ return is_compound && is_refinemv_allowed_bsize(bsize) &&
+ is_refinemv_allowed_mode_precision(mbmi->mode, mbmi->pb_mv_precision,
+ cm) &&
+ is_refinemv_allowed_reference(cm, mbmi);
+}
+
+// check if the refinemv mode is allowed for a given block for TIP mode
+static INLINE int is_refinemv_allowed_tip_blocks(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi) {
+ assert(is_tip_ref_frame(mbmi->ref_frame[0]));
+ return cm->seq_params.enable_refinemv &&
+ cm->superres_scale_denominator == SCALE_NUMERATOR &&
+ is_refinemv_allowed_reference(cm, mbmi);
+}
+
+// check if the refinemv mode is allowed for a given block for skip mode
+static INLINE int is_refinemv_allowed_skip_mode(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi) {
+ assert(mbmi->skip_mode);
+ return cm->seq_params.enable_refinemv &&
+ cm->superres_scale_denominator == SCALE_NUMERATOR &&
+ is_refinemv_allowed_bsize(mbmi->sb_type[PLANE_TYPE_Y]) &&
+ is_refinemv_allowed_reference(cm, mbmi);
+}
+static INLINE int get_default_refinemv_flag(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi) {
+ if (!cm->seq_params.enable_refinemv ||
+ cm->superres_scale_denominator != SCALE_NUMERATOR)
+ return 0;
+ int is_refinemv =
+ (mbmi->skip_mode
+ ? is_refinemv_allowed_skip_mode(cm, mbmi)
+ : is_refinemv_allowed(cm, mbmi, mbmi->sb_type[PLANE_TYPE_Y]));
+ if (is_refinemv) {
+ if (default_refinemv_modes(mbmi)) return 1;
+ }
+ return 0;
+}
+
+// check if the refinemv mode is switchable for a given block
+static INLINE int switchable_refinemv_flag(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi) {
+ if (!cm->seq_params.enable_refinemv) return 0;
+ int is_refinemv =
+ (mbmi->skip_mode
+ ? is_refinemv_allowed_skip_mode(cm, mbmi)
+ : is_refinemv_allowed(cm, mbmi, mbmi->sb_type[PLANE_TYPE_Y]));
+ if (is_refinemv && !is_tip_ref_frame(mbmi->ref_frame[0])) {
+ if (default_refinemv_modes(mbmi)) return 0;
+ return 1;
+ }
+
+ return 0;
+}
+
+// Precision of refined MV returned, 0 being integer pel. For now, only 1/8 or
+// 1/16-pel can be used.
+#define MV_REFINE_PREC_BITS 4 // (1/16-pel)
+
+// Clamp MV to UMV border based on its distance to left/right/top/bottom edge
+static AOM_INLINE MV tip_clamp_mv_to_umv_border_sb(
+ InterPredParams *const inter_pred_params, const MV *src_mv, int bw, int bh,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ int ss_x, int ss_y) {
+ // If the MV points so far into the UMV border that no visible pixels
+ // are used for reconstruction, the subpel part of the MV can be
+ // discarded and the MV limited to 16 pixels with equivalent results.
+ const int spel_left = (AOM_INTERP_EXTEND + bw) << SUBPEL_BITS;
+ const int spel_right = spel_left - SUBPEL_SHIFTS;
+ const int spel_top = (AOM_INTERP_EXTEND + bh) << SUBPEL_BITS;
+ const int spel_bottom = spel_top - SUBPEL_SHIFTS;
+#if CONFIG_OPTFLOW_REFINEMENT
+ MV clamped_mv;
+ if (use_optflow_refinement) {
+ // optflow refinement always returns MVs with 1/16 precision so it is not
+ // necessary to shift the MV before clamping
+ // Here it should be:
+ // clamped_mv.row = (int16_t)ROUND_POWER_OF_TWO_SIGNED(
+ // src_mv->row * (1 << SUBPEL_BITS), MV_REFINE_PREC_BITS + ss_y);
+ // But currently SUBPEL_BITS == MV_REFINE_PREC_BITS
+ assert(SUBPEL_BITS == MV_REFINE_PREC_BITS);
+
+ if (ss_y || ss_x) {
+ clamped_mv.row = (int16_t)ROUND_POWER_OF_TWO_SIGNED(
+ src_mv->row * (1 << SUBPEL_BITS), MV_REFINE_PREC_BITS + ss_y);
+ clamped_mv.col = (int16_t)ROUND_POWER_OF_TWO_SIGNED(
+ src_mv->col * (1 << SUBPEL_BITS), MV_REFINE_PREC_BITS + ss_x);
+ } else {
+ clamped_mv = *src_mv;
+ }
+ } else {
+ clamped_mv.row = (int16_t)(src_mv->row * (1 << (1 - ss_y)));
+ clamped_mv.col = (int16_t)(src_mv->col * (1 << (1 - ss_x)));
+ }
+#else
+ MV clamped_mv = { (int16_t)(src_mv->row * (1 << (1 - ss_y))),
+ (int16_t)(src_mv->col * (1 << (1 - ss_x))) };
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ assert(ss_x <= 1);
+ assert(ss_y <= 1);
+ const SubpelMvLimits mv_limits = {
+ inter_pred_params->dist_to_left_edge * (1 << (1 - ss_x)) - spel_left,
+ inter_pred_params->dist_to_right_edge * (1 << (1 - ss_x)) + spel_right,
+ inter_pred_params->dist_to_top_edge * (1 << (1 - ss_y)) - spel_top,
+ inter_pred_params->dist_to_bottom_edge * (1 << (1 - ss_y)) + spel_bottom
+ };
+
+ clamp_mv(&clamped_mv, &mv_limits);
+
+ return clamped_mv;
+}
+
+// This function conduct the SAD search between two predictors and find the best
+// MVs
+void apply_mv_refinement(const AV1_COMMON *cm, MACROBLOCKD *xd, int plane,
+ MB_MODE_INFO *mi, int bw, int bh, int mi_x, int mi_y,
+ uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func,
+ int pre_x, int pre_y, uint16_t *dst_ref0,
+ uint16_t *dst_ref1, MV *best_mv_ref, int pu_width,
+ int pu_height);
+
+// check if padding is required during motion compensation
+// return 1 means reference pixel is outside of the reference range and padding
+// is required return 0 means no padding.
+int update_extend_mc_border_params(const struct scale_factors *const sf,
+ struct buf_2d *const pre_buf, MV32 scaled_mv,
+ PadBlock *block, int subpel_x_mv,
+ int subpel_y_mv, int do_warp, int is_intrabc,
+ int *x_pad, int *y_pad,
+ const ReferenceArea *ref_area);
+
+// Derive the sub-pixel related parameters of refinemv non-TIP blocks
+// Sub-pel related parameters are stored in the structures pointed by
+// "subpel_params" Also do padding if required This function is used for both
+// encoder and decoder
+void common_calc_subpel_params_and_extend(
+ const MV *const src_mv, InterPredParams *const inter_pred_params,
+ MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride);
+
+// Derive the sub-pixel related parameters of refinemv TIP blocks
+// Sub-pel related parameters are stored in the structures pointed by
+// "subpel_params" Also do padding if required This function is used for both
+// encoder and decoder
+void tip_common_calc_subpel_params_and_extend(
+ const MV *const src_mv, InterPredParams *const inter_pred_params,
+ MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ int use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
+ int *src_stride);
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_REFINEMV || CONFIG_OPTFLOW_ON_TIP
+
+unsigned int get_highbd_sad(const uint16_t *src_ptr, int source_stride,
+ const uint16_t *ref_ptr, int ref_stride, int bd,
+ int bw, int bh);
+#endif // CONFIG_REFINEMV || CONFIG_OPTFLOW_ON_TIP
+
#if CONFIG_OPTFLOW_REFINEMENT
// This parameter k=OPFL_DIST_RATIO_THR is used to prune MV refinement for the
// case where d0 and d1 are very different. Assuming a = max(|d0|, |d1|) and
@@ -497,9 +870,11 @@
#define OPFL_COV_CLAMP_BITS 28
#define OPFL_COV_CLAMP_VAL (1 << OPFL_COV_CLAMP_BITS)
+#if !CONFIG_REFINEMV
// Precision of refined MV returned, 0 being integer pel. For now, only 1/8 or
// 1/16-pel can be used.
#define MV_REFINE_PREC_BITS 4 // (1/16-pel)
+#endif //! CONFIG_REFINEMV
void av1_opfl_mv_refinement_highbd(const uint16_t *p0, int pstride0,
const uint16_t *p1, int pstride1,
const int16_t *gx0, const int16_t *gy0,
@@ -512,14 +887,23 @@
const AV1_COMMON *cm, MACROBLOCKD *xd, int plane, const MB_MODE_INFO *mi,
int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,
InterPredParams *inter_pred_params,
- CalcSubpelParamsFunc calc_subpel_params_func, int ref, uint16_t *pred_dst);
+ CalcSubpelParamsFunc calc_subpel_params_func, int ref, uint16_t *pred_dst
+#if CONFIG_REFINEMV
+ ,
+ const MV *const src_mv, int pu_width, int pu_height
+#endif // CONFIG_REFINEMV
+);
static INLINE int is_opfl_refine_allowed(const AV1_COMMON *cm,
const MB_MODE_INFO *mbmi) {
if (cm->seq_params.enable_opfl_refine == AOM_OPFL_REFINE_NONE ||
cm->features.opfl_refine_type == REFINE_NONE)
return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const unsigned int cur_index = cm->cur_frame->display_order_hint;
+#else
const unsigned int cur_index = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int d0, d1;
#if CONFIG_OPTFLOW_ON_TIP
if (mbmi->ref_frame[0] == TIP_FRAME) {
@@ -530,8 +914,15 @@
if (!mbmi->ref_frame[1]) return 0;
const RefCntBuffer *const ref0 = get_ref_frame_buf(cm, mbmi->ref_frame[0]);
const RefCntBuffer *const ref1 = get_ref_frame_buf(cm, mbmi->ref_frame[1]);
- d0 = (int)cur_index - (int)ref0->order_hint;
- d1 = (int)cur_index - (int)ref1->order_hint;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ d0 = get_relative_dist(&cm->seq_params.order_hint_info, cur_index,
+ ref0->display_order_hint);
+ d1 = get_relative_dist(&cm->seq_params.order_hint_info, cur_index,
+ ref1->display_order_hint);
+#else
+ d0 = (int)cur_index - (int)ref0->order_hint;
+ d1 = (int)cur_index - (int)ref1->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
#if CONFIG_OPTFLOW_ON_TIP
}
#endif // CONFIG_OPTFLOW_ON_TIP
@@ -553,6 +944,10 @@
,
int do_pred, int use_4x4
#endif // CONFIG_OPTFLOW_ON_TIP
+#if CONFIG_REFINEMV
+ ,
+ MV *best_mv_ref, int pu_width, int pu_height
+#endif // CONFIG_REFINEMV
);
// With the refined MVs, generate the inter prediction for the block.
@@ -669,6 +1064,30 @@
return clamped_mv;
}
+#if CONFIG_D071_IMP_MSK_BLD
+void make_masked_inter_predictor(const uint16_t *pre, int pre_stride,
+ uint16_t *dst, int dst_stride,
+ InterPredParams *inter_pred_params,
+ const SubpelParams *subpel_params,
+ int use_bacp, int sub_block_id);
+
+static INLINE int use_border_aware_compound(const AV1_COMMON *cm,
+ const MB_MODE_INFO *mbmi) {
+ if (is_masked_compound_type(mbmi->interinter_comp.type) ||
+ mbmi->mode == GLOBAL_GLOBALMV)
+ return 0;
+
+ (void)cm;
+ return has_second_ref(mbmi) &&
+ (mbmi->mode >= COMP_INTER_MODE_START &&
+ mbmi->mode < COMP_INTER_MODE_END) &&
+ (mbmi->interinter_comp.type == COMPOUND_DIFFWTD ||
+ mbmi->interinter_comp.type == COMPOUND_AVERAGE);
+}
+int is_out_of_frame_block(InterPredParams const *inter_pred_params,
+ int frame_width, int frame_height, int sub_block_id);
+#endif // CONFIG_D071_IMP_MSK_BLD
+
static INLINE int64_t scaled_buffer_offset(int x_offset, int y_offset,
int stride,
const struct scale_factors *sf) {
@@ -725,7 +1144,11 @@
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_OPTFLOW_REFINEMENT
mbmi->interp_fltr =
- (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
+ (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)
+#if CONFIG_REFINEMV
+ || mbmi->refinemv_flag
+#endif // CONFIG_REFINEMV
+ )
? MULTITAP_SHARP
: av1_unswitchable_filter(frame_interp_filter);
#else
@@ -748,6 +1171,12 @@
if (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
return 0;
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#if CONFIG_REFINEMV
+ // No interpolation filter search when MV refinement is used.
+ if (mbmi->refinemv_flag) return 0;
+#endif // CONFIG_REFINEMV
+
if (is_warp_mode(mbmi->motion_mode)) return 0;
if (is_nontrans_global_motion(xd, xd->mi[0])) return 0;
return 1;
@@ -790,6 +1219,13 @@
const uint8_t *av1_get_compound_type_mask(
const INTERINTER_COMPOUND_DATA *const comp_data, BLOCK_SIZE sb_type);
+#if CONFIG_CWP
+// Init the masks for compound weighted prediction
+void init_cwp_masks();
+// Get the mask for compound weighted prediction
+const int8_t *av1_get_cwp_mask(int list_idx, int idx);
+#endif // CONFIG_CWP
+
// build interintra_predictors for one plane
void av1_build_interintra_predictor(const AV1_COMMON *cm, MACROBLOCKD *xd,
uint16_t *pred, int stride,
@@ -852,7 +1288,11 @@
// Set the precision set of the block. Currently, the value is 0.
void set_precision_set(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
MB_MODE_INFO *mbmi, const BLOCK_SIZE bsize,
+#if CONFIG_SEP_COMP_DRL
+ int *ref_mv_idx);
+#else
uint8_t ref_mv_idx);
+#endif // CONFIG_SEP_COMP_DRL
// Get the index of the precision
// this index is signalled when precision is not same as the most probable
// precision
@@ -874,7 +1314,6 @@
// check if pb_mv_precision is allowed or not
int is_pb_mv_precision_active(const AV1_COMMON *const cm,
const MB_MODE_INFO *mbmi, const BLOCK_SIZE bsize);
-
#endif
#if CONFIG_WARPMV
@@ -888,17 +1327,31 @@
static INLINE int is_warpmv_mode_allowed(const AV1_COMMON *const cm,
const MB_MODE_INFO *mbmi,
BLOCK_SIZE bsize) {
- if (has_second_ref(mbmi) || !cm->features.enabled_motion_modes
+ int frame_warp_delta_allowed =
+ (cm->features.enabled_motion_modes & (1 << WARP_DELTA)) != 0;
+
+ if (has_second_ref(mbmi) || !frame_warp_delta_allowed
#if CONFIG_TIP
|| is_tip_ref_frame(mbmi->ref_frame[0])
#endif // CONFIG_TIP
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || !cm->features.allow_warpmv_mode
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
)
return 0;
- int frame_warp_delta_allowed =
- cm->features.enabled_motion_modes & (1 << WARP_DELTA);
return frame_warp_delta_allowed && is_warpmv_allowed_bsize(bsize);
}
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+// check if warpmv with mvd is allowed or not
+static INLINE int allow_warpmv_with_mvd_coding(const AV1_COMMON *const cm,
+ const MB_MODE_INFO *mbmi) {
+ if (!cm->features.allow_warpmv_mode) return 0;
+ return (mbmi->mode == WARPMV && mbmi->warp_ref_idx < 2);
+}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#endif // CONFIG_WARPMV
#ifdef __cplusplus
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index 6f4b4b0..36206f3 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -56,9 +56,20 @@
#if CONFIG_ORIP
| NEED_ABOVELEFT
#endif
- , // SMOOTH
- NEED_LEFT | NEED_ABOVE, // SMOOTH_V
- NEED_LEFT | NEED_ABOVE, // SMOOTH_H
+#if CONFIG_BLEND_MODE
+ | NEED_ABOVERIGHT | NEED_BOTTOMLEFT
+#endif // CONFIG_BLEND_MODE
+ , // SMOOTH
+ NEED_LEFT | NEED_ABOVE
+#if CONFIG_BLEND_MODE
+ | NEED_BOTTOMLEFT
+#endif // CONFIG_BLEND_MODE
+ , // SMOOTH_V
+ NEED_LEFT | NEED_ABOVE
+#if CONFIG_BLEND_MODE
+ | NEED_ABOVERIGHT
+#endif // CONFIG_BLEND_MODE
+ , // SMOOTH_H
NEED_LEFT | NEED_ABOVE | NEED_ABOVELEFT, // PAETH
};
@@ -793,6 +804,210 @@
}
}
+#if CONFIG_IDIF
+// Directional prediction, zone 1: 0 < angle < 90 using IDIF
+void av1_highbd_dr_prediction_z1_idif_c(uint16_t *dst, ptrdiff_t stride, int bw,
+ int bh, const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ int r, c, x, base, shift, val;
+
+ uint16_t ref[4] = { 0 };
+
+ (void)left;
+ (void)dy;
+ (void)bd;
+ assert(dy == 1);
+ assert(dx > 0);
+
+ const int max_base_x = (bw + bh) - 1 + (mrl_index << 1);
+ const int frac_bits = 6;
+ const int base_inc = 1;
+
+ x = dx * (1 + mrl_index);
+ for (r = 0; r < bh; ++r, dst += stride, x += dx) {
+ base = x >> frac_bits;
+ shift = (x & 0x3F) >> 1;
+
+ if (base >= max_base_x) {
+ for (int i = r; i < bh; ++i) {
+ aom_memset16(dst, above[max_base_x], bw);
+ dst += stride;
+ }
+ return;
+ }
+
+ for (c = 0; c < bw; ++c, base += base_inc) {
+ if (base < max_base_x) {
+ // 4-tap filter
+ ref[0] = above[base - 1];
+ ref[1] = above[base];
+ ref[2] = above[base + 1];
+ ref[3] = above[base + 2];
+
+ val = av1_dr_interp_filter[shift][0] * ref[0] +
+ av1_dr_interp_filter[shift][1] * ref[1] +
+ av1_dr_interp_filter[shift][2] * ref[2] +
+ av1_dr_interp_filter[shift][3] * ref[3];
+
+ dst[c] = clip_pixel_highbd(
+ ROUND_POWER_OF_TWO(val, POWER_DR_INTERP_FILTER), bd);
+ } else {
+ dst[c] = above[max_base_x];
+ }
+ }
+ }
+}
+
+// Directional prediction, zone 2: 90 < angle < 180 using IDIF
+void av1_highbd_dr_prediction_z2_idif_c(uint16_t *dst, ptrdiff_t stride, int bw,
+ int bh, const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ (void)bd;
+ assert(dx > 0);
+ assert(dy > 0);
+
+ const int min_base_x = -1 - mrl_index;
+ const int min_base_y = -1 - mrl_index;
+
+ (void)min_base_y;
+ const int frac_bits_x = 6;
+ const int frac_bits_y = 6;
+
+ uint16_t ref[4] = { 0 };
+
+ for (int r = 0; r < bh; ++r) {
+ for (int c = 0; c < bw; ++c) {
+ int val;
+ int y = r + 1;
+ int x = (c << 6) - (y + mrl_index) * dx;
+ const int base_x = x >> frac_bits_x;
+ if (base_x >= min_base_x) {
+ const int shift = (x & 0x3F) >> 1;
+ // 4-tap filter
+ ref[0] = above[base_x - 1];
+ ref[1] = above[base_x];
+ ref[2] = above[base_x + 1];
+ ref[3] = above[base_x + 2];
+
+ val = av1_dr_interp_filter[shift][0] * ref[0] +
+ av1_dr_interp_filter[shift][1] * ref[1] +
+ av1_dr_interp_filter[shift][2] * ref[2] +
+ av1_dr_interp_filter[shift][3] * ref[3];
+
+ val = clip_pixel_highbd(ROUND_POWER_OF_TWO(val, POWER_DR_INTERP_FILTER),
+ bd);
+ } else {
+ x = c + 1;
+ y = (r << 6) - (x + mrl_index) * dy;
+ const int base_y = y >> frac_bits_y;
+ assert(base_y >= min_base_y);
+ const int shift = (y & 0x3F) >> 1;
+ // 4-tap filter
+ ref[0] = left[base_y - 1];
+ ref[1] = left[base_y];
+ ref[2] = left[base_y + 1];
+ ref[3] = left[base_y + 2];
+
+ val = av1_dr_interp_filter[shift][0] * ref[0] +
+ av1_dr_interp_filter[shift][1] * ref[1] +
+ av1_dr_interp_filter[shift][2] * ref[2] +
+ av1_dr_interp_filter[shift][3] * ref[3];
+
+ val = clip_pixel_highbd(ROUND_POWER_OF_TWO(val, POWER_DR_INTERP_FILTER),
+ bd);
+ }
+ dst[c] = val;
+ }
+ dst += stride;
+ }
+}
+
+// Directional prediction, zone 3: 180 < angle < 270 using IDIF
+void av1_highbd_dr_prediction_z3_idif_c(uint16_t *dst, ptrdiff_t stride, int bw,
+ int bh, const uint16_t *above,
+ const uint16_t *left, int dx, int dy,
+ int bd, int mrl_index) {
+ int r, c, y, base, shift, val;
+
+ (void)above;
+ (void)dx;
+ (void)bd;
+ assert(dx == 1);
+ assert(dy > 0);
+
+ uint16_t ref[4] = { 0 };
+
+ const int max_base_y = (bw + bh) - 1 + (mrl_index << 1);
+ const int frac_bits = 6;
+ const int base_inc = 1;
+
+ y = dy * (1 + mrl_index);
+ for (c = 0; c < bw; ++c, y += dy) {
+ base = y >> frac_bits;
+ shift = (y & 0x3F) >> 1;
+
+ for (r = 0; r < bh; ++r, base += base_inc) {
+ if (base < max_base_y) {
+ // 4-tap filter
+ ref[0] = left[base - 1];
+ ref[1] = left[base];
+ ref[2] = left[base + 1];
+ ref[3] = left[base + 2];
+
+ val = av1_dr_interp_filter[shift][0] * ref[0] +
+ av1_dr_interp_filter[shift][1] * ref[1] +
+ av1_dr_interp_filter[shift][2] * ref[2] +
+ av1_dr_interp_filter[shift][3] * ref[3];
+
+ dst[r * stride + c] = clip_pixel_highbd(
+ ROUND_POWER_OF_TWO(val, POWER_DR_INTERP_FILTER), bd);
+ } else {
+ for (; r < bh; ++r) dst[r * stride + c] = left[max_base_y];
+ break;
+ }
+ }
+ }
+}
+
+static void highbd_dr_predictor_idif(uint16_t *dst, ptrdiff_t stride,
+ TX_SIZE tx_size, uint16_t *above,
+ uint16_t *left, int angle, int bd,
+ int mrl_index) {
+ const int dx = av1_get_dx(angle);
+ const int dy = av1_get_dy(angle);
+ const int bw = tx_size_wide[tx_size];
+ const int bh = tx_size_high[tx_size];
+ assert(angle > 0 && angle < 270);
+
+ const int min_base = -((1 + mrl_index));
+ const int max_base = ((bw + bh) - 1 + (mrl_index << 1));
+
+ if (angle > 0 && angle < 90) {
+ above[max_base + 1] = above[max_base];
+ av1_highbd_dr_prediction_z1_idif(dst, stride, bw, bh, above, left, dx, dy,
+ bd, mrl_index);
+
+ } else if (angle > 90 && angle < 180) {
+ above[min_base - 1] = above[min_base];
+ left[min_base - 1] = left[min_base];
+ av1_highbd_dr_prediction_z2_idif(dst, stride, bw, bh, above, left, dx, dy,
+ bd, mrl_index);
+
+ } else if (angle > 180 && angle < 270) {
+ left[max_base + 1] = left[max_base];
+ av1_highbd_dr_prediction_z3_idif(dst, stride, bw, bh, above, left, dx, dy,
+ bd, mrl_index);
+
+ } else if (angle == 90) {
+ pred_high[V_PRED][tx_size](dst, stride, above, left, bd);
+ } else if (angle == 180) {
+ pred_high[H_PRED][tx_size](dst, stride, above, left, bd);
+ }
+}
+#endif // CONFIG_IDIF
+
static void highbd_dr_predictor(uint16_t *dst, ptrdiff_t stride,
TX_SIZE tx_size, const uint16_t *above,
const uint16_t *left, int upsample_above,
@@ -830,18 +1045,60 @@
const int bh = tx_size_high[tx_size];
if (angle > 0 && angle < 90) {
+#if CONFIG_EXT_DIR
+ int dy = dr_intra_derivative[90 - angle];
+#else
int dy = second_dr_intra_derivative[angle];
+#endif // CONFIG_EXT_DIR
int dx = 1;
av1_highbd_dr_prediction_z3(dst, stride, bw, bh, above, left, upsample_left,
dx, dy, bd, 0);
} else if (angle > 180 && angle < 270) {
+#if CONFIG_EXT_DIR
+ int dx = dr_intra_derivative[angle - 180];
+#else
int dx = second_dr_intra_derivative[270 - angle];
+#endif // CONFIG_EXT_DIR
int dy = 1;
av1_highbd_dr_prediction_z1(dst, stride, bw, bh, above, left,
upsample_above, dx, dy, bd, 0);
}
}
+#if CONFIG_IDIF
+// Generate the second directional predictor for IBP
+static void highbd_second_dr_predictor_idif(uint16_t *dst, ptrdiff_t stride,
+ TX_SIZE tx_size, uint16_t *above,
+ uint16_t *left, int angle, int bd) {
+ const int bw = tx_size_wide[tx_size];
+ const int bh = tx_size_high[tx_size];
+
+ const int max_base = ((bw + bh) - 1);
+
+ if (angle > 0 && angle < 90) {
+#if CONFIG_EXT_DIR
+ int dy = dr_intra_derivative[90 - angle];
+#else
+ int dy = second_dr_intra_derivative[angle];
+#endif // CONFIG_EXT_DIR
+ int dx = 1;
+ left[max_base + 1] = left[max_base];
+ av1_highbd_dr_prediction_z3_idif(dst, stride, bw, bh, above, left, dx, dy,
+ bd, 0);
+ } else if (angle > 180 && angle < 270) {
+#if CONFIG_EXT_DIR
+ int dx = dr_intra_derivative[angle - 180];
+#else
+ int dx = second_dr_intra_derivative[270 - angle];
+#endif // CONFIG_EXT_DIR
+ int dy = 1;
+ above[max_base + 1] = above[max_base];
+ av1_highbd_dr_prediction_z1_idif(dst, stride, bw, bh, above, left, dx, dy,
+ bd, 0);
+ }
+}
+#endif // CONFIG_IDIF
+
DECLARE_ALIGNED(16, const int8_t,
av1_filter_intra_taps[FILTER_INTRA_MODES][8][8]) = {
{
@@ -1174,7 +1431,12 @@
#endif
,
const int seq_ibp_flag,
- uint8_t *const ibp_weights[TX_SIZES_ALL][DIR_MODES_0_90]) {
+ uint8_t *const ibp_weights[TX_SIZES_ALL][DIR_MODES_0_90]
+#if CONFIG_IDIF
+ ,
+ const int enable_idif
+#endif // CONFIG_IDIF
+) {
int i;
DECLARE_ALIGNED(16, uint16_t, left_data[NUM_INTRA_NEIGHBOUR_PIXELS]);
DECLARE_ALIGNED(16, uint16_t, above_data[NUM_INTRA_NEIGHBOUR_PIXELS]);
@@ -1219,6 +1481,11 @@
if (is_dr_mode) {
p_angle = mode_to_angle_map[mode] + angle_delta;
+#if CONFIG_EXT_DIR
+ const int mrl_index_to_delta[4] = { 0, 1, -1, 0 };
+ p_angle += mrl_index_to_delta[mrl_index];
+ assert(p_angle > 0 && p_angle < 270);
+#endif // CONFIG_EXT_DIR
if (p_angle <= 90)
need_above = 1, need_left = 0, need_above_left = 1;
else if (p_angle < 180)
@@ -1266,9 +1533,16 @@
if (is_dr_mode)
need_bottom =
seq_ibp_flag ? (p_angle < 90) || (p_angle > 180) : p_angle > 180;
-
+#if CONFIG_IDIF
+ int num_left_pixels_needed =
+ txhpx + (need_bottom ? txwpx : 3) + (mrl_index << 1) + 1;
+ if (enable_idif && (p_angle > 90 && p_angle < 180)) {
+ num_left_pixels_needed += 1;
+ }
+#else
const int num_left_pixels_needed =
txhpx + (need_bottom ? txwpx : 3) + (mrl_index << 1);
+#endif // CONFIG_IDIF
i = 0;
if (n_left_px > 0) {
for (; i < n_left_px; i++) left_col[i] = left_ref[i * ref_stride];
@@ -1291,9 +1565,16 @@
if (is_dr_mode)
need_right =
seq_ibp_flag ? (p_angle < 90) || (p_angle > 180) : p_angle < 90;
-
+#if CONFIG_IDIF
+ int num_top_pixels_needed =
+ txwpx + (need_right ? txhpx : 0) + (mrl_index << 1);
+ if (enable_idif && (p_angle > 90 && p_angle < 180)) {
+ num_top_pixels_needed += 1;
+ }
+#else
const int num_top_pixels_needed =
txwpx + (need_right ? txhpx : 0) + (mrl_index << 1);
+#endif // CONFIG_IDIF
if (n_top_px > 0) {
memcpy(above_row, above_ref, n_top_px * sizeof(above_ref[0]));
i = n_top_px;
@@ -1377,31 +1658,63 @@
av1_filter_intra_edge_high(left_col - ab_le, n_px, strength);
}
}
- upsample_above = av1_use_intra_edge_upsample(txwpx, txhpx, angle_above,
- filt_type_above);
- if (need_above && upsample_above) {
- const int n_px = txwpx + (need_right ? txhpx : 0);
- av1_upsample_intra_edge_high(above_row, n_px, xd->bd);
+#if CONFIG_IDIF
+ if (!enable_idif) {
+#endif // CONFIG_IDIF
+ upsample_above = av1_use_intra_edge_upsample(txwpx, txhpx, angle_above,
+ filt_type_above);
+ if (need_above && upsample_above) {
+ const int n_px = txwpx + (need_right ? txhpx : 0);
+ av1_upsample_intra_edge_high(above_row, n_px, xd->bd);
+ }
+ upsample_left = av1_use_intra_edge_upsample(txhpx, txwpx, angle_left,
+ filt_type_left);
+ if (need_left && upsample_left) {
+ const int n_px = txhpx + (need_bottom ? txwpx : 0);
+ av1_upsample_intra_edge_high(left_col, n_px, xd->bd);
+ }
+#if CONFIG_IDIF
}
- upsample_left =
- av1_use_intra_edge_upsample(txhpx, txwpx, angle_left, filt_type_left);
- if (need_left && upsample_left) {
- const int n_px = txhpx + (need_bottom ? txwpx : 0);
- av1_upsample_intra_edge_high(left_col, n_px, xd->bd);
- }
+#endif // CONFIG_IDIF
}
+#if CONFIG_IDIF
+ if (enable_idif) {
+ highbd_dr_predictor_idif(dst, dst_stride, tx_size, above_row, left_col,
+ p_angle, xd->bd, mrl_index);
+ } else {
+ highbd_dr_predictor(dst, dst_stride, tx_size, above_row, left_col,
+ upsample_above, upsample_left, p_angle, xd->bd,
+ mrl_index);
+ }
+#else
highbd_dr_predictor(dst, dst_stride, tx_size, above_row, left_col,
upsample_above, upsample_left, p_angle, xd->bd,
mrl_index);
-
+#endif // CONFIG_IDIF
if (seq_ibp_flag) {
- if (mrl_index == 0) {
+ if (mrl_index == 0
+#if CONFIG_IMPROVED_ANGULAR_INTRA
+ && (angle_delta % 2 == 0)
+#endif // CONFIG_IMPROVED_ANGULAR_INTRA
+ ) {
if (p_angle > 0 && p_angle < 90) {
int mode_index = angle_to_mode_index[p_angle];
uint8_t *weights = ibp_weights[tx_size][mode_index];
+#if CONFIG_IDIF
+ if (enable_idif) {
+ highbd_second_dr_predictor_idif(second_pred, txwpx, tx_size,
+ above_row, left_col, p_angle,
+ xd->bd);
+ } else {
+ highbd_second_dr_predictor(second_pred, txwpx, tx_size, above_row,
+ left_col, upsample_above, upsample_left,
+ p_angle, xd->bd);
+ }
+#else
highbd_second_dr_predictor(second_pred, txwpx, tx_size, above_row,
left_col, upsample_above, upsample_left,
p_angle, xd->bd);
+#endif // CONFIG_IDIF
av1_highbd_ibp_dr_prediction_z1_c(weights, dst, dst_stride,
second_pred, txwpx, txwpx, txhpx);
}
@@ -1409,9 +1722,21 @@
int mode_index = angle_to_mode_index[270 - p_angle];
int transpose_tsize = transpose_tx_size[tx_size];
uint8_t *weights = ibp_weights[transpose_tsize][mode_index];
+#if CONFIG_IDIF
+ if (enable_idif) {
+ highbd_second_dr_predictor_idif(second_pred, txwpx, tx_size,
+ above_row, left_col, p_angle,
+ xd->bd);
+ } else {
+ highbd_second_dr_predictor(second_pred, txwpx, tx_size, above_row,
+ left_col, upsample_above, upsample_left,
+ p_angle, xd->bd);
+ }
+#else
highbd_second_dr_predictor(second_pred, txwpx, tx_size, above_row,
left_col, upsample_above, upsample_left,
p_angle, xd->bd);
+#endif // CONFIG_IDIF
av1_highbd_ibp_dr_prediction_z3_c(weights, dst, dst_stride,
second_pred, txwpx, txwpx, txhpx);
}
@@ -1551,6 +1876,9 @@
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;
+#if CONFIG_IDIF
+ const int enable_idif = cm->seq_params.enable_idif;
+#endif // CONFIG_IDIF
const int is_sb_boundary =
(mi_row % cm->mib_size == 0 && row_off == 0) ? 1 : 0;
@@ -1571,7 +1899,12 @@
cm->seq_params.enable_orip
#endif
,
- cm->seq_params.enable_ibp, cm->ibp_directional_weights);
+ cm->seq_params.enable_ibp, cm->ibp_directional_weights
+#if CONFIG_IDIF
+ ,
+ enable_idif
+#endif // CONFIG_IDIF
+ );
return;
}
@@ -1636,11 +1969,7 @@
av1_get_max_uv_txsize(mbmi->sb_type[PLANE_TYPE_UV], 0, 0);
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_tx(xd, blk_row, blk_col, luma_tx_size,
-#if DS_FRAME_LEVEL
- cm->features.ds_filter_type);
-#else
cm->seq_params.enable_cfl_ds_filter);
-#endif // DS_FRAME_LEVEL
#else
cfl_store_tx(xd, blk_row, blk_col, luma_tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h
index efd6533..0df6103 100644
--- a/av1/common/reconintra.h
+++ b/av1/common/reconintra.h
@@ -14,6 +14,7 @@
#define AOM_AV1_COMMON_RECONINTRA_H_
#include <stdlib.h>
+#include <math.h>
#include "aom/aom_integer.h"
#include "av1/common/av1_common_int.h"
@@ -124,7 +125,9 @@
PLANE_TYPE plane_type, TX_TYPE tx_type,
int is_inter) {
bool allow_fsc = cm->seq_params.enable_fsc &&
+#if !CONFIG_ATC_DCTX_ALIGNED
cm->features.allow_screen_content_tools &&
+#endif // !CONFIG_ATC_DCTX_ALIGNED
plane_type == PLANE_TYPE_Y && is_inter && tx_type == IDTX;
return allow_fsc;
}
@@ -213,6 +216,44 @@
extern const int8_t av1_filter_intra_taps[FILTER_INTRA_MODES][8][8];
+#if CONFIG_EXT_DIR
+// moved to av1_common_int.h
+#elif CONFIG_IMPROVED_ANGULAR_INTRA
+static const int16_t dr_intra_derivative[90] = {
+ // Angles are dense around vertical and horizontal directions, and coarse
+ // close to
+ // diagonal directions.
+ // Approx angle
+ 0, 0, 0, //
+ 2048, 0, 0, // 3, ...
+ 1024, 0, 0, // 6, ...
+ 512, 0, 0, 0, 0, // 9, ...
+ 340, 0, 0, // 14, ...
+ 256, 0, 0, // 17, ...
+ 204, 0, 0, // 20, ...
+ 170, 0, 0, // 23, ... (113 & 203 are base angles)
+ 146, 0, 0, // 26, ...
+ 128, 0, 0, // 29, ...
+ 106, 0, 0, 0, // 32, ...
+ 92, 0, 0, // 36, ...
+ 82, 0, 0, // 39, ...
+ 72, 0, 0, // 42, ...
+ 64, 0, 0, // 45, ... (45 & 135 are base angles)
+ 56, 0, 0, // 48, ...
+ 50, 0, 0, // 51, ...
+ 44, 0, 0, 0, // 54, ...
+ 38, 0, 0, // 58, ...
+ 32, 0, 0, // 61, ...
+ 28, 0, 0, // 64, ...
+ 24, 0, 0, // 67, ... (67 & 157 are base angles)
+ 20, 0, 0, // 70, ...
+ 16, 0, 0, // 73, ...
+ 12, 0, 0, 0, 0, // 76, ...
+ 8, 0, 0, // 81, ...
+ 4, 0, 0, // 84, ...
+ 2, 0, 0, // 87, ...
+};
+#else
static const int16_t dr_intra_derivative[90] = {
// More evenly spread out angles and limited to 10-bit
// Values that are 0 will never be used
@@ -246,6 +287,7 @@
7, 0, 0, // 84, ...
3, 0, 0, // 87, ...
};
+#endif // CONFIG_EXT_DIR
// Get the shift (up-scaled by 256) in X w.r.t a unit change in Y.
// If angle > 0 && angle < 90, dx = -((int)(256 / t));
@@ -301,6 +343,24 @@
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_IDIF
+#define POWER_DR_INTERP_FILTER 7
+
+DECLARE_ALIGNED(16, static const int16_t, av1_dr_interp_filter[32][4]) = {
+ { 0, 128, 0, 0 }, { -2, 127, 4, -1 }, { -3, 125, 8, -2 },
+ { -5, 123, 13, -3 }, { -6, 121, 17, -4 }, { -7, 118, 22, -5 },
+ { -9, 116, 27, -6 }, { -9, 112, 32, -7 }, { -10, 109, 37, -8 },
+ { -11, 106, 41, -8 }, { -11, 102, 46, -9 }, { -12, 98, 52, -10 },
+ { -12, 94, 56, -10 }, { -12, 90, 61, -11 }, { -12, 85, 66, -11 },
+ { -12, 81, 71, -12 }, { -12, 76, 76, -12 }, { -12, 71, 81, -12 },
+ { -11, 66, 85, -12 }, { -11, 61, 90, -12 }, { -10, 56, 94, -12 },
+ { -10, 52, 98, -12 }, { -9, 46, 102, -11 }, { -8, 41, 106, -11 },
+ { -8, 37, 109, -10 }, { -7, 32, 112, -9 }, { -6, 27, 116, -9 },
+ { -5, 22, 118, -7 }, { -4, 17, 121, -6 }, { -3, 13, 123, -5 },
+ { -2, 8, 125, -3 }, { -1, 4, 127, -2 }
+};
+#endif // CONFIG_IDIF
+
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index 219b507..c307424 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -91,6 +91,15 @@
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
};
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+// Filter configuration of cross component weiner filter
+const int wienerns_config_uv_from_y_cross[][3] = {
+ { 1, 0, 0 }, { -1, 0, 0 }, { 0, 1, 1 }, { 0, -1, 1 },
+ { 1, 1, 2 }, { -1, -1, 2 }, { -1, 1, 3 }, { 1, -1, 3 },
+ { 2, 0, 4 }, { -2, 0, 4 }, { 0, 2, 5 }, { 0, -2, 5 },
+};
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
#define WIENERNS_PREC_BITS_Y 7
const int wienerns_coeff_y[][WIENERNS_COEFCFG_LEN] = {
#if ENABLE_LR_4PART_CODE
@@ -163,14 +172,43 @@
#endif // ENABLE_LR_4PART_CODE
};
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+const int wienerns_coeff_uv_from_y[][WIENERNS_COEFCFG_LEN] = {
+#if ENABLE_LR_4PART_CODE
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 5, -12, 0),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 5, -12, 0),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -7, 1),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -7, 1),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -8, 1),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -8, 1),
+#else
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 5, -12, 3),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 5, -12, 3),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -7, 3),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -7, 3),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -8, 3),
+ AOM_WIENERNS_COEFF(WIENERNS_PREC_BITS_UV, 4, -8, 3),
+#endif // ENABLE_LR_4PART_CODE
+};
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
const WienernsFilterParameters wienerns_filter_y = AOM_MAKE_WIENERNS_CONFIG(
WIENERNS_PREC_BITS_Y, wienerns_config_y, wienerns_coeff_y);
const WienernsFilterParameters wienerns_filter_uv =
AOM_MAKE_WIENERNS_CONFIG2(WIENERNS_PREC_BITS_UV, wienerns_config_uv_from_uv,
wienerns_config_uv_from_y, wienerns_coeff_uv);
-
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+const WienernsFilterParameters wienerns_cross_filter_uv =
+ AOM_MAKE_WIENERNS_CONFIG(WIENERNS_PREC_BITS_UV,
+ wienerns_config_uv_from_y_cross,
+ wienerns_coeff_uv_from_y);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
const WienernsFilterPairParameters wienerns_filters_midqp = {
&wienerns_filter_y, &wienerns_filter_uv
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ &wienerns_cross_filter_uv
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
};
// Configs for the first set of filters for the case without subtract center.
@@ -263,6 +301,10 @@
const WienernsFilterPairParameters wienerns_filters_highqp = {
&wienerns_filter_y2, &wienerns_filter_uv
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ &wienerns_cross_filter_uv
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
};
///////////////////////////////////////////////////////////////////////////
@@ -343,6 +385,10 @@
const WienernsFilterPairParameters wienerns_filters_lowqp = {
&wienerns_filter_y3, &wienerns_filter_uv
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ &wienerns_cross_filter_uv
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
};
#endif // CONFIG_WIENER_NONSEP
@@ -496,6 +542,36 @@
#endif
}
+#if CONFIG_FLEXIBLE_RU_SIZE
+// set up the Minimum and maximum RU size for enacoder search
+// As normative regulation:
+// minimum RU size is equal to RESTORATION_UNITSIZE_MAX >> 2,
+// maximum RU size is equal to RESTORATION_UNITSIZE_MAX
+// The setting here is also for encoder search.
+void set_restoration_unit_size(int width, int height, int sx, int sy,
+ RestorationInfo *rst) {
+ int s = AOMMIN(sx, sy);
+
+ rst[0].max_restoration_unit_size = RESTORATION_UNITSIZE_MAX >> 0;
+ rst[0].min_restoration_unit_size = RESTORATION_UNITSIZE_MAX >> 2;
+
+ // For large resolution, the minimum RU size is set to
+ // RESTORATION_UNITSIZE_MAX >> 1 to reduce the encode complexity.
+ if (width * height > 1920 * 1080 * 2)
+ rst[0].min_restoration_unit_size = RESTORATION_UNITSIZE_MAX >> 1;
+
+ rst[1].max_restoration_unit_size = rst[0].max_restoration_unit_size >> s;
+ rst[1].min_restoration_unit_size = rst[0].min_restoration_unit_size >> s;
+
+ rst[2].max_restoration_unit_size = rst[1].max_restoration_unit_size;
+ rst[2].min_restoration_unit_size = rst[1].min_restoration_unit_size;
+
+ rst[0].restoration_unit_size = rst[0].min_restoration_unit_size;
+ rst[1].restoration_unit_size = rst[1].min_restoration_unit_size;
+ rst[2].restoration_unit_size = rst[2].min_restoration_unit_size;
+}
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+
static void extend_frame_highbd(uint16_t *data, int width, int height,
int stride, int border_horz, int border_vert) {
uint16_t *data_p;
@@ -527,8 +603,12 @@
extend_frame_highbd(data, width, height, stride, border_horz, border_vert);
}
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+void copy_tile(int width, int height, const uint16_t *src,
+#else
static void copy_tile(int width, int height, const uint16_t *src,
- int src_stride, uint16_t *dst, int dst_stride) {
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ int src_stride, uint16_t *dst, int dst_stride) {
copy_tile_highbd(width, height, src, src_stride, dst, dst_stride);
}
@@ -1822,6 +1902,7 @@
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
const int block_size = 4;
+
for (int r = 0; r < height; r += block_size) {
const int h = AOMMIN(block_size, height - r);
const uint16_t *dgd_row = dgd + r * stride;
@@ -1852,7 +1933,11 @@
int is_uv = rui->plane != AOM_PLANE_Y;
const NonsepFilterConfig *orig_config =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ get_wienerns_config(rui->base_qindex, is_uv, 0);
+#else
get_wienerns_config(rui->base_qindex, is_uv);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#if ADD_CENTER_TAP_TO_WIENERNS
NonsepFilterConfig adjusted_config;
WienerNonsepInfo adjusted_info;
@@ -1890,12 +1975,111 @@
}
}
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+// Convolving process of cross-component wiener filter for a 4x4 unit
+void av1_convolve_nonsep_cross_highbd_c(const uint16_t *dgd, int width,
+ int height, int stride,
+ const uint16_t *dgd2, int stride2,
+ const NonsepFilterConfig *config,
+ const int16_t *filter, uint16_t *dst,
+ int dst_stride, int bit_depth) {
+ (void)dgd;
+ (void)stride;
+ for (int i = 0; i < height; ++i) {
+ for (int j = 0; j < width; ++j) {
+ const int dgd2_id = i * stride2 + j;
+ const int dst_id = i * dst_stride + j;
+ int32_t tmp = (int32_t)dst[dst_id] * (1 << config->prec_bits);
+
+ for (int k = 0; k < config->num_pixels; ++k) {
+ const int pos = config->config[k][NONSEP_BUF_POS];
+ const int r = config->config[k][NONSEP_ROW_ID];
+ const int c = config->config[k][NONSEP_COL_ID];
+ const int ir = config->strict_bounds
+ ? AOMMAX(AOMMIN(i + r, height - 1), 0)
+ : i + r;
+ const int jc =
+ config->strict_bounds ? AOMMAX(AOMMIN(j + c, width - 1), 0) : j + c;
+ int16_t diff =
+ clip_base(dgd2[(ir)*stride2 + (jc)] - dgd2[dgd2_id], bit_depth);
+ diff = k % 2 ? -diff : diff;
+ tmp += filter[pos] * diff;
+ }
+ tmp = ROUND_POWER_OF_TWO_SIGNED(tmp, config->prec_bits);
+ dst[dst_id] = clip_pixel_highbd(tmp, bit_depth);
+ }
+ }
+}
+
+// Cross-component wiener filtering for a process unit
+void apply_cross_wienerns_class_id_highbd(
+ const uint16_t *dgd, int width, int height, int stride,
+ const WienerNonsepInfo *wienerns_info,
+ const NonsepFilterConfig *nsfilter_config, uint16_t *dst, int dst_stride,
+ int plane, const uint16_t *luma, int luma_stride, int bit_depth) {
+ assert(plane != AOM_PLANE_Y);
+ (void)plane;
+ assert(nsfilter_config->num_pixels2 == 0);
+ assert(wienerns_info->num_classes == 1);
+
+ const int16_t *filter = const_nsfilter_taps(wienerns_info, 0);
+
+ const int block_size = 4;
+ for (int r = 0; r < height; r += block_size) {
+ const int h = AOMMIN(block_size, height - r);
+ const uint16_t *dgd_row = dgd + r * stride;
+ const uint16_t *luma_row = luma + r * luma_stride;
+ uint16_t *dst_row = dst + r * dst_stride;
+
+ for (int c = 0; c < width; c += block_size) {
+ const int w = AOMMIN(block_size, width - c);
+ av1_convolve_nonsep_cross_highbd_c(
+ dgd_row + c, w, h, stride, luma_row + c, luma_stride, nsfilter_config,
+ filter, dst_row + c, dst_stride, bit_depth);
+ }
+ }
+}
+
+// Cross-component wiener filtering for a stripe of process units
+static void wiener_ns_cross_filter_stripe_highbd(
+ const RestorationUnitInfo *rui, int stripe_width, int stripe_height,
+ int procunit_width, const uint16_t *src, int src_stride, uint16_t *dst,
+ int dst_stride, int32_t *tmpbuf, int bit_depth) {
+ (void)tmpbuf;
+ (void)bit_depth;
+
+ assert(rui->wienerns_cross_info.num_classes == 1);
+
+ int is_uv = rui->plane != AOM_PLANE_Y;
+
+ assert(is_uv);
+ const NonsepFilterConfig *orig_config =
+ get_wienerns_config(rui->base_qindex, is_uv, 1);
+
+ const NonsepFilterConfig *nsfilter_config = orig_config;
+ const WienerNonsepInfo *nsfilter_info = &rui->wienerns_cross_info;
+
+ for (int j = 0; j < stripe_width; j += procunit_width) {
+ int w = AOMMIN(procunit_width, stripe_width - j);
+ apply_cross_wienerns_class_id_highbd(
+ src + j, w, stripe_height, src_stride, nsfilter_info, nsfilter_config,
+ dst + j, dst_stride, rui->plane, rui->luma + j, rui->luma_stride,
+ bit_depth);
+ }
+}
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
#if CONFIG_WIENER_NONSEP_CROSS_FILT
uint16_t *wienerns_copy_luma_highbd(const uint16_t *dgd, int height_y,
int width_y, int in_stride,
uint16_t **luma_hbd, int height_uv,
int width_uv, int border, int out_stride,
- int bd) {
+ int bd
+#if WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ ,
+ int ds_type
+#endif
+) {
(void)bd;
uint16_t *aug_luma = (uint16_t *)malloc(
sizeof(uint16_t) * (width_uv + 2 * border) * (height_uv + 2 * border));
@@ -1973,6 +2157,25 @@
} else {
assert(0 && "Invalid dimensions");
}
+#elif WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ const int ss_x = (((width_y + 1) >> 1) == width_uv);
+ const int ss_y = (((height_y + 1) >> 1) == height_uv);
+ if (ss_x && ss_y && ds_type == 1) {
+ for (int r = 0; r < height_uv; ++r) {
+ for (int c = 0; c < width_uv; ++c) {
+ (*luma)[r * out_stride + c] = (dgd[2 * r * in_stride + 2 * c] +
+ dgd[(2 * r + 1) * in_stride + 2 * c]) /
+ 2;
+ }
+ }
+ } else {
+ for (int r = 0; r < height_uv; ++r) {
+ for (int c = 0; c < width_uv; ++c) {
+ (*luma)[r * out_stride + c] =
+ dgd[(1 + ss_y) * r * in_stride + (1 + ss_x) * c];
+ }
+ }
+ }
#else
av1_highbd_resize_plane(dgd, height_y, width_y, in_stride, *luma, height_uv,
width_uv, out_stride, bd);
@@ -2054,16 +2257,18 @@
#elif CONFIG_PC_WIENER
#define NUM_STRIPE_FILTERS 3
-static const stripe_filter_fun stripe_filters[NUM_STRIPE_FILTERS] = {
- wiener_filter_stripe_highbd,
- sgrproj_filter_stripe_highbd,
- pc_wiener_stripe_highbd,
-};
+ static const stripe_filter_fun
+ stripe_filters[NUM_STRIPE_FILTERS] = {
+ wiener_filter_stripe_highbd,
+ sgrproj_filter_stripe_highbd,
+ pc_wiener_stripe_highbd,
+ };
#else
#define NUM_STRIPE_FILTERS 2
-static const stripe_filter_fun stripe_filters[NUM_STRIPE_FILTERS] = {
- wiener_filter_stripe_highbd, sgrproj_filter_stripe_highbd
-};
+ static const stripe_filter_fun
+ stripe_filters[NUM_STRIPE_FILTERS] = {
+ wiener_filter_stripe_highbd, sgrproj_filter_stripe_highbd
+ };
#endif // CONFIG_WIENER_NONSEP && CONFIG_PC_WIENER
// Filter one restoration unit
@@ -2104,6 +2309,7 @@
const uint16_t *luma_in_ru = NULL;
const int enable_cross_buffers =
unit_rtype == RESTORE_WIENER_NONSEP && rui->plane != AOM_PLANE_Y;
+
if (enable_cross_buffers)
luma_in_ru =
rui->luma + limits->v_start * rui->luma_stride + limits->h_start;
@@ -2195,6 +2401,86 @@
#endif // CONFIG_PC_WIENER
}
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+// Cross-component fFiltering for one restoration unit
+void av1_wiener_ns_cross_filter_unit(
+ const RestorationTileLimits *limits, const RestorationUnitInfo *rui,
+ const RestorationStripeBoundaries *rsb, RestorationLineBuffers *rlbs,
+ const AV1PixelRect *tile_rect, int tile_stripe0, int ss_x, int ss_y,
+ int bit_depth, uint16_t *data, int stride, uint16_t *dst, int dst_stride,
+ int32_t *tmpbuf, int optimized_lr) {
+ (void)rsb;
+ (void)rlbs;
+ (void)optimized_lr;
+ (void)tile_stripe0;
+
+ RestorationType unit_cross_rtype = rui->cross_restoration_type;
+
+ const int unit_h = limits->v_end - limits->v_start;
+ const int unit_w = limits->h_end - limits->h_start;
+ uint16_t *data_tl = data + limits->v_start * stride + limits->h_start;
+ uint16_t *dst_tl = dst + limits->v_start * dst_stride + limits->h_start;
+
+ if (unit_cross_rtype == RESTORE_NONE) {
+ return;
+ }
+
+ assert(unit_cross_rtype == RESTORE_WIENER_NONSEP);
+
+ const stripe_filter_fun stripe_filter = wiener_ns_cross_filter_stripe_highbd;
+
+ const int procunit_width = RESTORATION_PROC_UNIT_SIZE >> ss_x;
+
+ // rui is a pointer to a const but we modify its contents when calling
+ // stripe_filter(). Use a temporary for now and refactor the datastructure
+ // later.
+ RestorationUnitInfo rui_contents = *rui;
+ RestorationUnitInfo *tmp_rui = &rui_contents;
+
+ const uint16_t *luma_in_plane = rui->luma;
+ const uint16_t *luma_in_ru =
+ luma_in_plane + limits->v_start * rui->luma_stride + limits->h_start;
+
+ // Convolve the whole tile one stripe at a time
+ RestorationTileLimits remaining_stripes = *limits;
+ int i = 0;
+ while (i < unit_h) {
+ int copy_above, copy_below;
+ remaining_stripes.v_start = limits->v_start + i;
+
+ get_stripe_boundary_info(&remaining_stripes, tile_rect, ss_y, ©_above,
+ ©_below);
+
+ const int full_stripe_height = RESTORATION_PROC_UNIT_SIZE >> ss_y;
+ const int runit_offset = RESTORATION_UNIT_OFFSET >> ss_y;
+
+ // Work out where this stripe's boundaries are within
+ // rsb->stripe_boundary_{above,below}
+ const int tile_stripe =
+ (remaining_stripes.v_start - tile_rect->top + runit_offset) /
+ full_stripe_height;
+ // const int frame_stripe = tile_stripe0 + tile_stripe;
+ // const int rsb_row = RESTORATION_CTX_VERT * frame_stripe;
+
+ // Calculate this stripe's height, based on two rules:
+ // * The topmost stripe in each tile is 8 luma pixels shorter than usual.
+ // * We can't extend past the end of the current restoration unit
+ const int nominal_stripe_height =
+ full_stripe_height - ((tile_stripe == 0) ? runit_offset : 0);
+ const int h = AOMMIN(nominal_stripe_height,
+ remaining_stripes.v_end - remaining_stripes.v_start);
+
+ tmp_rui->luma = luma_in_ru + i * rui->luma_stride;
+
+ stripe_filter(tmp_rui, unit_w, h, procunit_width, data_tl + i * stride,
+ stride, dst_tl + i * dst_stride, dst_stride, tmpbuf,
+ bit_depth);
+
+ i += h;
+ }
+}
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
static void filter_frame_on_unit(const RestorationTileLimits *limits,
const AV1PixelRect *tile_rect,
int rest_unit_idx, int rest_unit_idx_seq,
@@ -2227,6 +2513,15 @@
ctxt->tile_stripe0, ctxt->ss_x, ctxt->ss_y, ctxt->bit_depth, ctxt->data8,
ctxt->data_stride, ctxt->dst8, ctxt->dst_stride, tmpbuf,
rsi->optimized_lr);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ const int is_uv = (ctxt->plane != AOM_PLANE_Y);
+ if (is_uv)
+ av1_wiener_ns_cross_filter_unit(
+ limits, &rsi->unit_info[rest_unit_idx], &rsi->boundaries, rlbs,
+ tile_rect, ctxt->tile_stripe0, ctxt->ss_x, ctxt->ss_y, ctxt->bit_depth,
+ ctxt->data8, ctxt->data_stride, ctxt->dst8, ctxt->dst_stride, tmpbuf,
+ rsi->optimized_lr);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
void av1_loop_restoration_filter_frame_init(AV1LrStruct *lr_ctxt,
@@ -2251,9 +2546,16 @@
for (int plane = 0; plane < num_planes; ++plane) {
RestorationInfo *rsi = &cm->rst_info[plane];
RestorationType rtype = rsi->frame_restoration_type;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ RestorationType cross_rtype = rsi->frame_cross_restoration_type;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
rsi->optimized_lr = optimized_lr;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rtype == RESTORE_NONE && cross_rtype == RESTORE_NONE) {
+#else
if (rtype == RESTORE_NONE) {
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
continue;
}
@@ -2289,7 +2591,13 @@
aom_yv12_partial_coloc_copy_v };
assert(num_planes <= 3);
for (int plane = 0; plane < num_planes; ++plane) {
- if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) continue;
+ if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ && cm->rst_info[plane].frame_cross_restoration_type == RESTORE_NONE
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ )
+ continue;
+
AV1PixelRect tile_rect = loop_rest_ctxt->ctxt[plane].tile_rect;
copy_funs[plane](loop_rest_ctxt->dst, loop_rest_ctxt->frame, tile_rect.left,
tile_rect.right, tile_rect.top, tile_rect.bottom);
@@ -2308,14 +2616,22 @@
dgd->buffers[AOM_PLANE_Y], dgd->crop_heights[AOM_PLANE_Y],
dgd->crop_widths[AOM_PLANE_Y], dgd->strides[AOM_PLANE_Y], &luma,
dgd->crop_heights[1], dgd->crop_widths[1], WIENERNS_UV_BRD, luma_stride,
- cm->seq_params.bit_depth);
+ cm->seq_params.bit_depth
+#if WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ ,
+ cm->seq_params.enable_cfl_ds_filter == 1
+#endif
+ );
assert(luma_buf != NULL);
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
for (int plane = 0; plane < num_planes; ++plane) {
- if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) {
+ if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ && cm->rst_info[plane].frame_cross_restoration_type == RESTORE_NONE
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ )
continue;
- }
#if CONFIG_WIENER_NONSEP || CONFIG_PC_WIENER
ctxt[plane].plane = plane;
diff --git a/av1/common/restoration.h b/av1/common/restoration.h
index 8091597..f66987d 100644
--- a/av1/common/restoration.h
+++ b/av1/common/restoration.h
@@ -82,7 +82,11 @@
(RESTORATION_PROC_UNIT_SIZE + RESTORATION_BORDER_VERT * 2 + \
RESTORATION_PADDING))
+#if CONFIG_FLEXIBLE_RU_SIZE
+#define RESTORATION_UNITSIZE_MAX 512
+#else
#define RESTORATION_UNITSIZE_MAX 256
+#endif // CONFIG_FLEXIBLE_RU_SIZE
#define RESTORATION_UNITPELS_HORZ_MAX \
(RESTORATION_UNITSIZE_MAX * 3 / 2 + 2 * RESTORATION_BORDER_HORZ + 16)
#define RESTORATION_UNITPELS_VERT_MAX \
@@ -203,6 +207,9 @@
typedef struct {
const WienernsFilterParameters *y;
const WienernsFilterParameters *uv;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ const WienernsFilterParameters *uv_cross;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
} WienernsFilterPairParameters;
extern const WienernsFilterPairParameters wienerns_filters_lowqp;
@@ -212,17 +219,33 @@
#define USE_CENTER_WIENER_NONSEP 0
static INLINE const WienernsFilterParameters *get_wienerns_parameters(
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ int qindex, int is_uv, int is_cross) {
+#else
int qindex, int is_uv) {
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
const WienernsFilterPairParameters *pair_nsfilter_params = NULL;
(void)qindex;
pair_nsfilter_params = &wienerns_filters_midqp;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (is_cross) return pair_nsfilter_params->uv_cross;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
return is_uv ? pair_nsfilter_params->uv : pair_nsfilter_params->y;
}
static INLINE const NonsepFilterConfig *get_wienerns_config(int qindex,
- int is_uv) {
+ int is_uv
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ int is_cross
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+) {
const WienernsFilterParameters *base_nsfilter_params =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ get_wienerns_parameters(qindex, is_uv, is_cross);
+#else
get_wienerns_parameters(qindex, is_uv);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
return &base_nsfilter_params->nsfilter_config;
}
#endif // CONFIG_WIENER_NONSEP
@@ -258,6 +281,11 @@
*/
RestorationType restoration_type;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ /*! Cross restoration type*/
+ RestorationType cross_restoration_type;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
/*!
* Wiener filter parameters if restoration_type indicates Wiener
*/
@@ -324,6 +352,17 @@
*/
PcwienerBuffers *pcwiener_buffers;
#endif // CONFIG_PC_WIENER
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ /*!
+ * Nonseparable Wiener cross filter information.
+ */
+ WienerNonsepInfo wienerns_cross_info;
+
+ /*!
+ * wienerns cross filter idx of the current RU
+ */
+ int wienerns_cross_filter_idx;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
} RestorationUnitInfo;
/*!\cond */
@@ -382,6 +421,16 @@
*/
int restoration_unit_size;
+#if CONFIG_FLEXIBLE_RU_SIZE
+ /*!
+ * Maximum restoration unit size
+ */
+ int max_restoration_unit_size;
+ /*!
+ * Minimum restoration unit size
+ */
+ int min_restoration_unit_size;
+#endif // CONFIG_FLEXIBLE_RU_SIZE
/**
* \name Fields allocated and initialised by av1_alloc_restoration_struct.
* (horz_)units_per_tile give the number of restoration units in
@@ -413,6 +462,11 @@
*/
RestorationUnitInfo *unit_info;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ /*! Cross restoration type for frame*/
+ RestorationType frame_cross_restoration_type;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
/*!
* Restoration Stripe boundary info
*/
@@ -446,24 +500,33 @@
sgrproj_info->xqd[1] = (SGRPROJ_PRJ_MIN1 + SGRPROJ_PRJ_MAX1) / 2;
}
-static INLINE void set_default_wiener(WienerInfo *wiener_info) {
- wiener_info->vfilter[0] = wiener_info->hfilter[0] = WIENER_FILT_TAP0_MIDV;
+static INLINE void set_default_wiener(WienerInfo *wiener_info, int chroma) {
+ const int wiener_filt_tap0_midv = chroma ? 0 : WIENER_FILT_TAP0_MIDV;
+ wiener_info->vfilter[0] = wiener_info->hfilter[0] = wiener_filt_tap0_midv;
wiener_info->vfilter[1] = wiener_info->hfilter[1] = WIENER_FILT_TAP1_MIDV;
wiener_info->vfilter[2] = wiener_info->hfilter[2] = WIENER_FILT_TAP2_MIDV;
wiener_info->vfilter[WIENER_HALFWIN] = wiener_info->hfilter[WIENER_HALFWIN] =
-2 *
- (WIENER_FILT_TAP2_MIDV + WIENER_FILT_TAP1_MIDV + WIENER_FILT_TAP0_MIDV);
+ (WIENER_FILT_TAP2_MIDV + WIENER_FILT_TAP1_MIDV + wiener_filt_tap0_midv);
wiener_info->vfilter[4] = wiener_info->hfilter[4] = WIENER_FILT_TAP2_MIDV;
wiener_info->vfilter[5] = wiener_info->hfilter[5] = WIENER_FILT_TAP1_MIDV;
- wiener_info->vfilter[6] = wiener_info->hfilter[6] = WIENER_FILT_TAP0_MIDV;
+ wiener_info->vfilter[6] = wiener_info->hfilter[6] = wiener_filt_tap0_midv;
}
#if CONFIG_WIENER_NONSEP
static INLINE void set_default_wienerns(WienerNonsepInfo *wienerns_info,
- int qindex, int num_classes,
- int chroma) {
+ int qindex, int num_classes, int chroma
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ int is_cross
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+) {
const WienernsFilterParameters *nsfilter_params =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ get_wienerns_parameters(qindex, chroma, is_cross);
+#else
get_wienerns_parameters(qindex, chroma);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
wienerns_info->num_classes = num_classes;
for (int c_id = 0; c_id < wienerns_info->num_classes; ++c_id) {
#if CONFIG_LR_MERGE_COEFFS
@@ -482,13 +545,24 @@
// 0: Skip luma pixels to scale down to chroma (simplest)
// 1: Average 4 or 2 luma pixels to scale down to chroma
-// 2: Use 8-tap downsampling filter
+// 2: Average 2 (top and down) luma pixels to scale down to chroma for 420,
+// could be based on the luma downsampling type from CFL tool 3: Use 8-tap
+// downsampling filter
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+#define WIENERNS_CROSS_FILT_LUMA_TYPE 2
+#else
#define WIENERNS_CROSS_FILT_LUMA_TYPE 0
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
uint16_t *wienerns_copy_luma_highbd(const uint16_t *dgd, int height_y,
int width_y, int in_stride, uint16_t **luma,
int height_uv, int width_uv, int border,
- int out_stride, int bd);
+ int out_stride, int bd
+#if WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ ,
+ int ds_type
+#endif
+);
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
#endif // CONFIG_WIENER_NONSEP
@@ -533,6 +607,9 @@
FilterFrameCtxt ctxt[MAX_MB_PLANE];
YV12_BUFFER_CONFIG *frame;
YV12_BUFFER_CONFIG *dst;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ YV12_BUFFER_CONFIG *pre_filter_frame;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
} AV1LrStruct;
extern const sgr_params_type av1_sgr_params[SGRPROJ_PARAMS];
@@ -587,6 +664,18 @@
int bit_depth, uint16_t *data, int stride, uint16_t *dst, int dst_stride,
int32_t *tmpbuf, int optimized_lr);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+/*!\brief Function for applying cross wienerns filter to a single unit.
+ * The inputs are same as those of av1_loop_restoration_filter_unit
+ */
+void av1_wiener_ns_cross_filter_unit(
+ const RestorationTileLimits *limits, const RestorationUnitInfo *rui,
+ const RestorationStripeBoundaries *rsb, RestorationLineBuffers *rlbs,
+ const AV1PixelRect *tile_rect, int tile_stripe0, int ss_x, int ss_y,
+ int bit_depth, uint16_t *data, int stride, uint16_t *dst, int dst_stride,
+ int32_t *tmpbuf, int optimized_lr);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
/*!\brief Function for applying loop restoration filter to a frame
*
* \ingroup in_loop_restoration
@@ -687,7 +776,15 @@
void av1_lr_sync_read_dummy(void *const lr_sync, int r, int c, int plane);
void av1_lr_sync_write_dummy(void *const lr_sync, int r, int c,
const int sb_cols, int plane);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+void copy_tile(int width, int height, const uint16_t *src, int src_stride,
+ uint16_t *dst, int dst_stride);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+#if CONFIG_FLEXIBLE_RU_SIZE
+void set_restoration_unit_size(int width, int height, int sx, int sy,
+ RestorationInfo *rst);
+#endif // CONFIG_FLEXIBLE_RU_SIZE
/*!\endcond */
#ifdef __cplusplus
diff --git a/av1/common/scan.c b/av1/common/scan.c
index af2d30e..96bae5e 100644
--- a/av1/common/scan.c
+++ b/av1/common/scan.c
@@ -15,7 +15,7 @@
#include "av1/common/common_data.h"
#include "av1/common/scan.h"
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_4x4[16]) = {
0, 4, 1, 8, 5, 2, 12, 9, 6, 3, 13, 10, 7, 14, 11, 15,
};
@@ -23,7 +23,7 @@
DECLARE_ALIGNED(16, static const int16_t,
default_scan_4x4[16]) = { 0, 1, 4, 8, 5, 2, 3, 6,
9, 12, 13, 10, 7, 11, 14, 15 };
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, mcol_scan_4x4[16]) = {
0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15,
@@ -33,7 +33,7 @@
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_4x8[32]) = {
0, 4, 1, 8, 5, 2, 12, 9, 6, 3, 16, 13, 10, 7, 20, 17,
14, 11, 24, 21, 18, 15, 28, 25, 22, 19, 29, 26, 23, 30, 27, 31,
@@ -43,7 +43,7 @@
0, 1, 4, 2, 5, 8, 3, 6, 9, 12, 7, 10, 13, 16, 11, 14,
17, 20, 15, 18, 21, 24, 19, 22, 25, 28, 23, 26, 29, 27, 30, 31,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, mcol_scan_4x8[32]) = {
0, 4, 8, 12, 16, 20, 24, 28, 1, 5, 9, 13, 17, 21, 25, 29,
@@ -70,7 +70,7 @@
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_4x16[64]) = {
0, 4, 1, 8, 5, 2, 12, 9, 6, 3, 16, 13, 10, 7, 20, 17,
14, 11, 24, 21, 18, 15, 28, 25, 22, 19, 32, 29, 26, 23, 36, 33,
@@ -84,7 +84,7 @@
33, 36, 31, 34, 37, 40, 35, 38, 41, 44, 39, 42, 45, 48, 43, 46,
49, 52, 47, 50, 53, 56, 51, 54, 57, 60, 55, 58, 61, 59, 62, 63,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_16x4[64]) = {
0, 16, 1, 32, 17, 2, 48, 33, 18, 3, 49, 34, 19, 4, 50, 35,
@@ -121,7 +121,7 @@
12, 28, 44, 60, 13, 29, 45, 61, 14, 30, 46, 62, 15, 31, 47, 63,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_8x32[256]) = {
0, 8, 1, 16, 9, 2, 24, 17, 10, 3, 32, 25, 18, 11, 4,
40, 33, 26, 19, 12, 5, 48, 41, 34, 27, 20, 13, 6, 56, 49,
@@ -163,7 +163,7 @@
250, 223, 230, 237, 244, 251, 231, 238, 245, 252, 239, 246, 253, 247, 254,
255,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_32x8[256]) = {
0, 32, 1, 64, 33, 2, 96, 65, 34, 3, 128, 97, 66, 35, 4,
@@ -268,7 +268,7 @@
30, 62, 94, 126, 158, 190, 222, 254, 31, 63, 95, 127, 159, 191, 223, 255,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_8x8[64]) = {
0, 8, 1, 16, 9, 2, 24, 17, 10, 3, 32, 25, 18, 11, 4, 40,
33, 26, 19, 12, 5, 48, 41, 34, 27, 20, 13, 6, 56, 49, 42, 35,
@@ -282,7 +282,7 @@
35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, mcol_scan_8x8[64]) = {
0, 8, 16, 24, 32, 40, 48, 56, 1, 9, 17, 25, 33, 41, 49, 57,
@@ -298,7 +298,7 @@
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_8x16[128]) = {
0, 8, 1, 16, 9, 2, 24, 17, 10, 3, 32, 25, 18, 11, 4, 40,
33, 26, 19, 12, 5, 48, 41, 34, 27, 20, 13, 6, 56, 49, 42, 35,
@@ -321,7 +321,7 @@
114, 121, 87, 94, 101, 108, 115, 122, 95, 102, 109, 116, 123, 103, 110,
117, 124, 111, 118, 125, 119, 126, 127,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_16x8[128]) = {
0, 16, 1, 32, 17, 2, 48, 33, 18, 3, 64, 49, 34, 19, 4, 80,
@@ -380,7 +380,7 @@
120, 121, 122, 123, 124, 125, 126, 127,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_16x32[512]) = {
0, 16, 1, 32, 17, 2, 48, 33, 18, 3, 64, 49, 34, 19, 4,
80, 65, 50, 35, 20, 5, 96, 81, 66, 51, 36, 21, 6, 112, 97,
@@ -456,7 +456,7 @@
491, 506, 447, 462, 477, 492, 507, 463, 478, 493, 508, 479, 494, 509, 495,
510, 511,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_32x16[512]) = {
0, 32, 1, 64, 33, 2, 96, 65, 34, 3, 128, 97, 66, 35, 4,
@@ -645,7 +645,7 @@
510, 511,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_16x16[256]) = {
0, 16, 1, 32, 17, 2, 48, 33, 18, 3, 64, 49, 34, 19, 4,
80, 65, 50, 35, 20, 5, 96, 81, 66, 51, 36, 21, 6, 112, 97,
@@ -687,7 +687,7 @@
250, 251, 236, 221, 206, 191, 207, 222, 237, 252, 253, 238, 223, 239, 254,
255
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, mcol_scan_16x16[256]) = {
0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240,
@@ -888,7 +888,7 @@
1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, default_scan_32x32[1024]) = {
0, 32, 1, 64, 33, 2, 96, 65, 34, 3, 128, 97, 66, 35,
4, 160, 129, 98, 67, 36, 5, 192, 161, 130, 99, 68, 37, 6,
@@ -1047,9 +1047,9 @@
862, 831, 863, 894, 925, 956, 987, 1018, 1019, 988, 957, 926, 895,
927, 958, 989, 1020, 1021, 990, 959, 991, 1022, 1023
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t,
av1_default_iscan_4x4[16]) = { 0, 2, 5, 9, 1, 4, 8, 12,
3, 7, 11, 14, 6, 10, 13, 15 };
@@ -1057,7 +1057,7 @@
DECLARE_ALIGNED(16, static const int16_t,
av1_default_iscan_4x4[16]) = { 0, 1, 5, 6, 2, 4, 7, 12,
3, 8, 11, 13, 9, 10, 14, 15 };
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_mcol_iscan_4x4[16]) = {
0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15,
@@ -1067,7 +1067,7 @@
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_4x8[32]) = {
0, 2, 5, 9, 1, 4, 8, 13, 3, 7, 12, 17, 6, 11, 16, 21,
10, 15, 20, 25, 14, 19, 24, 28, 18, 23, 27, 30, 22, 26, 29, 31
@@ -1077,7 +1077,7 @@
0, 1, 3, 6, 2, 4, 7, 10, 5, 8, 11, 14, 9, 12, 15, 18,
13, 16, 19, 22, 17, 20, 23, 26, 21, 24, 27, 29, 25, 28, 30, 31,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_mcol_iscan_4x8[32]) = {
0, 8, 16, 24, 1, 9, 17, 25, 2, 10, 18, 26, 3, 11, 19, 27,
@@ -1104,7 +1104,7 @@
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_4x16[64]) = {
0, 2, 5, 9, 1, 4, 8, 13, 3, 7, 12, 17, 6, 11, 16, 21,
10, 15, 20, 25, 14, 19, 24, 29, 18, 23, 28, 33, 22, 27, 32, 37,
@@ -1118,7 +1118,7 @@
29, 32, 35, 38, 33, 36, 39, 42, 37, 40, 43, 46, 41, 44, 47, 50,
45, 48, 51, 54, 49, 52, 55, 58, 53, 56, 59, 61, 57, 60, 62, 63,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_16x4[64]) = {
0, 2, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57,
@@ -1155,7 +1155,7 @@
3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_8x32[256]) = {
0, 2, 5, 9, 14, 20, 27, 35, 1, 4, 8, 13, 19, 26, 34,
43, 3, 7, 12, 18, 25, 33, 42, 51, 6, 11, 17, 24, 32, 41,
@@ -1197,7 +1197,7 @@
219, 226, 233, 239, 244, 248, 251, 253, 227, 234, 240, 245, 249, 252, 254,
255,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_32x8[256]) = {
0, 2, 5, 9, 14, 20, 27, 35, 43, 51, 59, 67, 75, 83, 91,
@@ -1316,7 +1316,7 @@
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_8x8[64]) = {
0, 2, 5, 9, 14, 20, 27, 35, 1, 4, 8, 13, 19, 26, 34, 42,
3, 7, 12, 18, 25, 33, 41, 48, 6, 11, 17, 24, 32, 40, 47, 53,
@@ -1330,9 +1330,9 @@
10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60,
21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_8x16[128]) = {
0, 2, 5, 9, 14, 20, 27, 35, 1, 4, 8, 13, 19, 26, 34, 43,
3, 7, 12, 18, 25, 33, 42, 51, 6, 11, 17, 24, 32, 41, 50, 59,
@@ -1354,7 +1354,7 @@
75, 82, 89, 96, 103, 109, 114, 118, 83, 90, 97, 104, 110, 115, 119, 122,
91, 98, 105, 111, 116, 120, 123, 125, 99, 106, 112, 117, 121, 124, 126, 127,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_16x8[128]) = {
0, 2, 5, 9, 14, 20, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99,
@@ -1413,7 +1413,7 @@
120, 121, 122, 123, 124, 125, 126, 127,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_16x32[512]) = {
0, 2, 5, 9, 14, 20, 27, 35, 44, 54, 65, 77, 90, 104, 119,
135, 1, 4, 8, 13, 19, 26, 34, 43, 53, 64, 76, 89, 103, 118,
@@ -1489,7 +1489,7 @@
509, 391, 406, 420, 433, 445, 456, 466, 475, 483, 490, 496, 501, 505, 508,
510, 511,
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_32x16[512]) = {
0, 2, 5, 9, 14, 20, 27, 35, 44, 54, 65, 77, 90, 104, 119,
@@ -1718,7 +1718,7 @@
255,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_16x16[256]) = {
0, 2, 5, 9, 14, 20, 27, 35, 44, 54, 65, 77, 90, 104, 119,
135, 1, 4, 8, 13, 19, 26, 34, 43, 53, 64, 76, 89, 103, 118,
@@ -1760,7 +1760,7 @@
135, 136, 164, 165, 189, 190, 210, 211, 227, 228, 240, 241, 249, 250, 254,
255
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_mcol_iscan_32x32[1024]) = {
0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416,
@@ -1921,7 +1921,7 @@
1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023,
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
DECLARE_ALIGNED(16, static const int16_t, av1_default_iscan_32x32[1024]) = {
0, 2, 5, 9, 14, 20, 27, 35, 44, 54, 65, 77, 90,
104, 119, 135, 152, 170, 189, 209, 230, 252, 275, 299, 324, 350,
@@ -2085,7 +2085,7 @@
748, 792, 793, 833, 834, 870, 871, 903, 904, 932, 933, 957, 958,
978, 979, 995, 996, 1008, 1009, 1017, 1018, 1022, 1023
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
const SCAN_ORDER av1_default_scan_orders[TX_SIZES] = {
{ default_scan_4x4, av1_default_iscan_4x4 },
diff --git a/av1/common/thread_common.c b/av1/common/thread_common.c
index 31e1c30..9be67cb 100644
--- a/av1/common/thread_common.c
+++ b/av1/common/thread_common.c
@@ -708,7 +708,13 @@
lr_sync->jobs_dequeued = 0;
for (int plane = 0; plane < num_planes; plane++) {
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE &&
+ cm->rst_info[plane].frame_cross_restoration_type == RESTORE_NONE)
+ continue;
+#else
if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) continue;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
num_even_lr_jobs =
num_even_lr_jobs + ((ctxt[plane].rsi->vert_units_per_tile + 1) >> 1);
}
@@ -716,7 +722,12 @@
lr_job_counter[1] = num_even_lr_jobs;
for (int plane = 0; plane < num_planes; plane++) {
- if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) continue;
+ if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ && cm->rst_info[plane].frame_cross_restoration_type == RESTORE_NONE
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ )
+ continue;
const int is_uv = plane > 0;
const int ss_y = is_uv && cm->seq_params.subsampling_y;
@@ -865,7 +876,12 @@
dgd->buffers[AOM_PLANE_Y], dgd->crop_heights[AOM_PLANE_Y],
dgd->crop_widths[AOM_PLANE_Y], dgd->strides[AOM_PLANE_Y], &luma,
dgd->crop_heights[1], dgd->crop_widths[1], WIENERNS_UV_BRD, luma_stride,
- cm->seq_params.bit_depth);
+ cm->seq_params.bit_depth
+#if WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ ,
+ cm->seq_params.enable_cfl_ds_filter == 1
+#endif
+ );
assert(luma_buf != NULL);
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
@@ -875,7 +891,12 @@
int num_rows_lr = 0;
for (int plane = 0; plane < num_planes; plane++) {
- if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) continue;
+ if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ && cm->rst_info[plane].frame_cross_restoration_type == RESTORE_NONE
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ )
+ continue;
#if CONFIG_WIENER_NONSEP || CONFIG_PC_WIENER
ctxt[plane].plane = plane;
diff --git a/av1/common/tip.c b/av1/common/tip.c
index 6e175d6..c427a4e 100644
--- a/av1/common/tip.c
+++ b/av1/common/tip.c
@@ -37,14 +37,22 @@
if (!order_hint_info->enable_order_hint || frame_is_intra_only(cm)) return;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int cur_order_hint = cm->current_frame.display_order_hint;
+#else
const int cur_order_hint = cm->current_frame.order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
// Identify the nearest forward and backward references.
for (int i = 0; i < INTER_REFS_PER_FRAME; i++) {
const RefCntBuffer *const buf = get_ref_frame_buf(cm, i);
if (buf == NULL) continue;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = buf->display_order_hint;
+#else
const int ref_order_hint = buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int ref_to_cur_dist =
get_relative_dist(order_hint_info, ref_order_hint, cur_order_hint);
if (ref_to_cur_dist < 0) {
@@ -72,7 +80,12 @@
const RefCntBuffer *const start_frame_buf =
get_ref_frame_buf(cm, start_frame);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints =
+ &start_frame_buf->ref_display_order_hint[0];
+#else
const int *const ref_order_hints = &start_frame_buf->ref_order_hints[0];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
for (MV_REFERENCE_FRAME rf = 0; rf < INTER_REFS_PER_FRAME; ++rf) {
if (ref_order_hints[rf] == target_frame_order) {
return 1;
@@ -111,13 +124,21 @@
get_ref_frame_buf(cm, start_frame);
if (!is_ref_motion_field_eligible(cm, start_frame_buf)) return 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int start_frame_order_hint = start_frame_buf->display_order_hint;
+#else
const int start_frame_order_hint = start_frame_buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
assert(start_frame_buf->width == cm->width &&
start_frame_buf->height == cm->height);
-
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int *const ref_order_hints = start_frame_buf->ref_display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int *const ref_order_hints = start_frame_buf->ref_order_hints;
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int start_to_current_frame_offset = get_relative_dist(
order_hint_info, start_frame_order_hint, cur_order_hint);
@@ -461,7 +482,11 @@
}
const OrderHintInfo *const order_hint_info = &cm->seq_params.order_hint_info;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
MV_REFERENCE_FRAME nearest_rf[2] = { tip_ref->ref_frame[0],
tip_ref->ref_frame[1] };
@@ -477,12 +502,20 @@
if (cm->features.tip_frame_mode) {
cm->features.allow_tip_hole_fill = cm->seq_params.enable_tip_hole_fill;
RefCntBuffer *ref0_frame_buf = get_ref_frame_buf(cm, nearest_rf[0]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref0_frame_order_hint = ref0_frame_buf->display_order_hint;
+#else
const int ref0_frame_order_hint = ref0_frame_buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int cur_to_ref0_offset = get_relative_dist(
order_hint_info, cur_order_hint, ref0_frame_order_hint);
RefCntBuffer *ref1_frame_buf = get_ref_frame_buf(cm, nearest_rf[1]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref1_frame_order_hint = ref1_frame_buf->display_order_hint;
+#else
const int ref1_frame_order_hint = ref1_frame_buf->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int cur_to_ref1_offset = get_relative_dist(
order_hint_info, cur_order_hint, ref1_frame_order_hint);
@@ -569,10 +602,15 @@
}
}
-static AOM_INLINE void tip_build_one_inter_predictor(
- uint16_t *dst, int dst_stride, const MV *const src_mv,
- InterPredParams *inter_pred_params, MACROBLOCKD *xd, int mi_x, int mi_y,
- int ref, uint16_t **mc_buf, CalcSubpelParamsFunc calc_subpel_params_func) {
+#if !CONFIG_REFINEMV
+static AOM_INLINE
+#endif //! CONFIG_REFINEMV
+ void
+ tip_build_one_inter_predictor(
+ uint16_t *dst, int dst_stride, const MV *const src_mv,
+ InterPredParams *inter_pred_params, MACROBLOCKD *xd, int mi_x, int mi_y,
+ int ref, uint16_t **mc_buf,
+ CalcSubpelParamsFunc calc_subpel_params_func) {
SubpelParams subpel_params;
uint16_t *src;
int src_stride;
@@ -582,15 +620,55 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
mc_buf, &src, &subpel_params, &src_stride);
- tip_highbd_inter_predictor(
- src, src_stride, dst, dst_stride, &subpel_params,
- inter_pred_params->block_width, inter_pred_params->block_height,
- &inter_pred_params->conv_params, inter_pred_params->interp_filter_params,
- inter_pred_params->bit_depth);
+#if CONFIG_D071_IMP_MSK_BLD
+ int use_bacp = 0;
+ int n_blocks = 0;
+ if (inter_pred_params->border_data.enable_bacp) {
+ const int sub_blk_idx = n_blocks * 2 + ref;
+ inter_pred_params->border_data.bacp_block_data[sub_blk_idx].x0 =
+ subpel_params.x0;
+ inter_pred_params->border_data.bacp_block_data[sub_blk_idx].x1 =
+ subpel_params.x1;
+ inter_pred_params->border_data.bacp_block_data[sub_blk_idx].y0 =
+ subpel_params.y0;
+ inter_pred_params->border_data.bacp_block_data[sub_blk_idx].y1 =
+ subpel_params.y1;
+ if (ref == 1) {
+ use_bacp = is_out_of_frame_block(
+ inter_pred_params, inter_pred_params->ref_frame_buf.width,
+ inter_pred_params->ref_frame_buf.height, n_blocks);
+
+ if (use_bacp && inter_pred_params->mask_comp.type == COMPOUND_AVERAGE) {
+ inter_pred_params->conv_params.do_average = 0;
+ inter_pred_params->comp_mode = MASK_COMP;
+ inter_pred_params->mask_comp.seg_mask = xd->seg_mask;
+ }
+ }
+ }
+
+ assert(IMPLIES(ref == 0, !use_bacp));
+
+ if (use_bacp) {
+ assert(inter_pred_params->comp_mode == MASK_COMP);
+ make_masked_inter_predictor(src, src_stride, dst, dst_stride,
+ inter_pred_params, &subpel_params, use_bacp,
+ n_blocks);
+
+ } else {
+#endif // CONFIG_D071_IMP_MSK_BLD
+
+ tip_highbd_inter_predictor(
+ src, src_stride, dst, dst_stride, &subpel_params,
+ inter_pred_params->block_width, inter_pred_params->block_height,
+ &inter_pred_params->conv_params,
+ inter_pred_params->interp_filter_params, inter_pred_params->bit_depth);
+#if CONFIG_D071_IMP_MSK_BLD
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
}
-#if CONFIG_OPTFLOW_ON_TIP
-#define MAKE_BFP_SAD_WRAPPER_COMMON(fnname) \
+#if CONFIG_OPTFLOW_ON_TIP || CONFIG_REFINEMV
+#define MAKE_BFP_SAD_WRAPPER_COMMON8x8(fnname) \
static unsigned int fnname##_8(const uint16_t *src_ptr, int source_stride, \
const uint16_t *ref_ptr, int ref_stride) { \
return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
@@ -604,31 +682,119 @@
return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
}
-MAKE_BFP_SAD_WRAPPER_COMMON(aom_highbd_sad8x8)
+MAKE_BFP_SAD_WRAPPER_COMMON8x8(aom_highbd_sad8x8)
+#define MAKE_BFP_SAD_WRAPPER_COMMON16x8(fnname) \
+ static unsigned int fnname##_8(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
+ } \
+ static unsigned int fnname##_10(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \
+ } \
+ static unsigned int fnname##_12(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
+ }
-// Get the proper sad calculation function for an 8x8 block
-static unsigned int get_highbd_sad_8X8(const uint16_t *src_ptr,
- int source_stride,
- const uint16_t *ref_ptr, int ref_stride,
- int bd) {
+ MAKE_BFP_SAD_WRAPPER_COMMON16x8(aom_highbd_sad16x8)
+
+#define MAKE_BFP_SAD_WRAPPER_COMMON8x16(fnname) \
+ static unsigned int fnname##_8(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
+ } \
+ static unsigned int fnname##_10(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \
+ } \
+ static unsigned int fnname##_12(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
+ }
+
+ MAKE_BFP_SAD_WRAPPER_COMMON8x16(aom_highbd_sad8x16)
+
+#define MAKE_BFP_SAD_WRAPPER_COMMON16x16(fnname) \
+ static unsigned int fnname##_8(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
+ } \
+ static unsigned int fnname##_10(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \
+ } \
+ static unsigned int fnname##_12(const uint16_t *src_ptr, int source_stride, \
+ const uint16_t *ref_ptr, int ref_stride) { \
+ return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
+ }
+
+ MAKE_BFP_SAD_WRAPPER_COMMON16x16(aom_highbd_sad16x16)
+
+ unsigned int get_highbd_sad(const uint16_t *src_ptr,
+ int source_stride,
+ const uint16_t *ref_ptr,
+ int ref_stride, int bd, int bw,
+ int bh) {
if (bd == 8) {
- return aom_highbd_sad8x8_8(src_ptr, source_stride, ref_ptr, ref_stride);
+ if (bw == 8 && bh == 8)
+ return aom_highbd_sad8x8_8(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 16 && bh == 8)
+ return aom_highbd_sad16x8_8(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 8 && bh == 16)
+ return aom_highbd_sad8x16_8(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 16 && bh == 16)
+ return aom_highbd_sad16x16_8(src_ptr, source_stride, ref_ptr, ref_stride);
+ else {
+ assert(0);
+ return 0;
+ }
} else if (bd == 10) {
- return aom_highbd_sad8x8_10(src_ptr, source_stride, ref_ptr, ref_stride);
+ if (bw == 8 && bh == 8)
+ return aom_highbd_sad8x8_10(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 16 && bh == 8)
+ return aom_highbd_sad16x8_10(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 8 && bh == 16)
+ return aom_highbd_sad8x16_10(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 16 && bh == 16)
+ return aom_highbd_sad16x16_10(src_ptr, source_stride, ref_ptr,
+ ref_stride);
+ else {
+ assert(0);
+ return 0;
+ }
} else if (bd == 12) {
- return aom_highbd_sad8x8_12(src_ptr, source_stride, ref_ptr, ref_stride);
+ if (bw == 8 && bh == 8)
+ return aom_highbd_sad8x8_12(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 16 && bh == 8)
+ return aom_highbd_sad16x8_12(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 8 && bh == 16)
+ return aom_highbd_sad8x16_12(src_ptr, source_stride, ref_ptr, ref_stride);
+ else if (bw == 16 && bh == 16)
+ return aom_highbd_sad16x16_12(src_ptr, source_stride, ref_ptr,
+ ref_stride);
+ else {
+ assert(0);
+ return 0;
+ }
} else {
assert(0);
return 0;
}
}
-
// Build an 8x8 block in the TIP frame
static AOM_INLINE void tip_build_inter_predictors_8x8(
const AV1_COMMON *cm, MACROBLOCKD *xd, int plane, TIP_PLANE *tip_plane,
const MV mv[2], int mi_x, int mi_y, uint16_t **mc_buf,
CONV_BUF_TYPE *tmp_conv_dst, CalcSubpelParamsFunc calc_subpel_params_func,
- uint16_t *dst, int dst_stride) {
+ uint16_t *dst, int dst_stride
+#if CONFIG_REFINEMV
+ ,
+ uint16_t *dst0_16_refinemv, uint16_t *dst1_16_refinemv,
+ ReferenceArea ref_area[2]
+#endif // CONFIG_REFINEMV
+
+) {
// TODO(any): currently this only works for y plane
assert(plane == 0);
@@ -664,6 +830,29 @@
mbmi->motion_mode = SIMPLE_TRANSLATION;
mbmi->sb_type[PLANE_TYPE_Y] = BLOCK_8X8;
mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+#if CONFIG_FLEX_MVRES
+ mbmi->max_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;
+ mbmi->pb_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;
+#endif
+
+#if CONFIG_REFINEMV
+ MV best_mv_ref[2] = { { mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col },
+ { mbmi->mv[1].as_mv.row, mbmi->mv[1].as_mv.col } };
+
+ int apply_refinemv = (is_refinemv_allowed_tip_blocks(cm, mbmi) && plane == 0);
+
+ if (apply_refinemv) {
+ uint16_t *dst_ref0 = NULL, *dst_ref1 = NULL;
+ dst_ref0 = &dst0_16_refinemv[0];
+ dst_ref1 = &dst1_16_refinemv[0];
+ mbmi->refinemv_flag = 1;
+
+ apply_mv_refinement(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y, mc_buf,
+ calc_subpel_params_func, comp_pixel_x, comp_pixel_y,
+ dst_ref0, dst_ref1, best_mv_ref, bw, bh);
+ }
+
+#endif // CONFIG_REFINEMV
// Arrays to hold optical flow offsets.
int vx0[4] = { 0 };
@@ -688,12 +877,22 @@
InterPredParams params0, params1;
av1_opfl_build_inter_predictor(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,
mc_buf, ¶ms0, calc_subpel_params_func, 0,
- dst0);
+ dst0
+#if CONFIG_REFINEMV
+ ,
+ &best_mv_ref[0], bw, bh
+#endif // CONFIG_REFINEMV
+ );
av1_opfl_build_inter_predictor(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,
mc_buf, ¶ms1, calc_subpel_params_func, 1,
- dst1);
- const unsigned int sad = get_highbd_sad_8X8(dst0, bw, dst1, bw, bd);
+ dst1
+#if CONFIG_REFINEMV
+ ,
+ &best_mv_ref[1], bw, bh
+#endif // CONFIG_REFINEMV
+ );
+ const unsigned int sad = get_highbd_sad(dst0, bw, dst1, bw, bd, 8, 8);
if (sad < sad_thres) {
do_opfl = 0;
}
@@ -701,8 +900,13 @@
if (do_opfl) {
// Initialize refined mv
+#if CONFIG_REFINEMV
+ const MV mv0 = best_mv_ref[0];
+ const MV mv1 = best_mv_ref[1];
+#else
const MV mv0 = mv[0];
const MV mv1 = mv[1];
+#endif // CONFIG_REFINEMV
for (int mvi = 0; mvi < 4; mvi++) {
mv_refined[mvi * 2].as_mv = mv0;
mv_refined[mvi * 2 + 1].as_mv = mv1;
@@ -712,9 +916,20 @@
av1_get_optflow_based_mv_highbd(cm, xd, plane, mbmi, mv_refined, bw, bh,
mi_x, mi_y, mc_buf, calc_subpel_params_func,
gx0, gy0, gx1, gy1, vx0, vy0, vx1, vy1,
- dst0, dst1, 0, use_4x4);
+ dst0, dst1, 0, use_4x4
+
+#if CONFIG_REFINEMV
+ ,
+ best_mv_ref, bw, bh
+#endif // CONFIG_REFINEMV
+ );
}
+#if CONFIG_D071_IMP_MSK_BLD
+ BacpBlockData bacp_block_data[2 * N_OF_OFFSETS];
+ uint8_t use_bacp = cm->features.enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
for (int ref = 0; ref < 2; ++ref) {
const struct scale_factors *const sf = cm->tip_ref.ref_scale_factor[ref];
struct buf_2d *const pred_buf = &tip->pred[ref];
@@ -724,8 +939,23 @@
comp_pixel_x, ss_x, ss_y, bd, 0, sf, pred_buf,
MULTITAP_SHARP);
+#if CONFIG_REFINEMV
+ if (apply_refinemv) {
+ inter_pred_params.use_ref_padding = 1;
+ inter_pred_params.ref_area = &ref_area[ref];
+ }
+#endif // CONFIG_REFINEMV
+
inter_pred_params.comp_mode = UNIFORM_COMP;
+#if CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params.border_data.enable_bacp = use_bacp;
+ inter_pred_params.border_data.bacp_block_data =
+ &bacp_block_data[0]; // Always point to the first ref
+ inter_pred_params.sb_type = mbmi->sb_type[PLANE_TYPE_Y];
+ inter_pred_params.mask_comp = mbmi->interinter_comp;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
const int width = (cm->mi_params.mi_cols << MI_SIZE_LOG2);
const int height = (cm->mi_params.mi_rows << MI_SIZE_LOG2);
inter_pred_params.dist_to_top_edge = -GET_MV_SUBPEL(mi_y);
@@ -741,7 +971,12 @@
dst, dst_stride, plane, mv_refined, &inter_pred_params, xd, mi_x,
mi_y, ref, mc_buf, calc_subpel_params_func, use_4x4);
} else {
- tip_build_one_inter_predictor(dst, dst_stride, &mv[ref],
+ tip_build_one_inter_predictor(dst, dst_stride,
+#if CONFIG_REFINEMV
+ &best_mv_ref[ref],
+#else
+ &mv[ref],
+#endif // CONFIG_REFINEMV
&inter_pred_params, xd, mi_x, mi_y, ref,
mc_buf, calc_subpel_params_func);
}
@@ -749,7 +984,7 @@
xd->tmp_conv_dst = org_buf;
}
-#endif // CONFIG_OPTFLOW_ON_TIP
+#endif // CONFIG_OPTFLOW_ON_TIP || CONFIG_REFINEMV
static AOM_INLINE void tip_build_inter_predictors_8x8_and_bigger(
const AV1_COMMON *cm, MACROBLOCKD *xd, int plane, TIP_PLANE *tip_plane,
@@ -759,9 +994,44 @@
struct buf_2d *const dst_buf = &tip->dst;
uint16_t *const dst = dst_buf->buf;
-#if CONFIG_OPTFLOW_ON_TIP
+#if CONFIG_REFINEMV || CONFIG_OPTFLOW_ON_TIP
+#if CONFIG_REFINEMV
+ uint16_t dst0_16_refinemv[REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT];
+ uint16_t dst1_16_refinemv[REFINEMV_SUBBLOCK_WIDTH * REFINEMV_SUBBLOCK_HEIGHT];
+ int apply_refinemv = (plane == 0);
+ ReferenceArea ref_area[2];
+ if (apply_refinemv) {
+ MB_MODE_INFO *mbmi = aom_calloc(1, sizeof(*mbmi));
+ mbmi->mv[0].as_mv = mv[0];
+ mbmi->mv[1].as_mv = mv[1];
+ mbmi->ref_frame[0] = TIP_FRAME;
+ mbmi->ref_frame[1] = NONE_FRAME;
+ mbmi->interp_fltr = EIGHTTAP_REGULAR;
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
+ mbmi->use_intrabc[0] = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->sb_type[PLANE_TYPE_Y] = BLOCK_8X8;
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+#if CONFIG_FLEX_MVRES
+ mbmi->max_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;
+ mbmi->pb_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;
+#endif
+ const int ss_x = plane ? cm->seq_params.subsampling_x : 0;
+ const int ss_y = plane ? cm->seq_params.subsampling_y : 0;
+ const int comp_pixel_x = (mi_x >> ss_x);
+ const int comp_pixel_y = (mi_y >> ss_y);
+ av1_get_reference_area_with_padding(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,
+ ref_area, comp_pixel_x, comp_pixel_y);
+ aom_free(mbmi);
+ }
+#endif // CONFIG_REFINEMV
+
int dst_stride = dst_buf->stride;
- if (plane == 0 && cm->features.use_optflow_tip) {
+ if (plane == 0 && (cm->features.use_optflow_tip
+#if CONFIG_REFINEMV
+ || apply_refinemv
+#endif // CONFIG_REFINEMV
+ )) {
if (bw != 8 || bh != 8) {
for (int h = 0; h < bh; h += 8) {
for (int w = 0; w < bw; w += 8) {
@@ -776,10 +1046,15 @@
}
tip_build_inter_predictors_8x8(cm, xd, plane, tip_plane, mv, mi_x, mi_y,
mc_buf, tmp_conv_dst,
- calc_subpel_params_func, dst, dst_stride);
+ calc_subpel_params_func, dst, dst_stride
+#if CONFIG_REFINEMV
+ ,
+ dst0_16_refinemv, dst1_16_refinemv, ref_area
+#endif // CONFIG_REFINEMV
+ );
return;
}
-#endif // CONFIG_OPTFLOW_ON_TIP
+#endif // CONFIG_OPTFLOW_ON_TIP || CONFIG_REFINEMV
const int bd = cm->seq_params.bit_depth;
@@ -789,6 +1064,12 @@
const int comp_pixel_y = (mi_y >> ss_y);
const int comp_bw = bw >> ss_x;
const int comp_bh = bh >> ss_y;
+
+#if CONFIG_D071_IMP_MSK_BLD
+ BacpBlockData bacp_block_data[2 * N_OF_OFFSETS];
+ uint8_t use_bacp = cm->features.enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
for (int ref = 0; ref < 2; ++ref) {
const struct scale_factors *const sf = cm->tip_ref.ref_scale_factor[ref];
struct buf_2d *const pred_buf = &tip->pred[ref];
@@ -800,6 +1081,16 @@
inter_pred_params.comp_mode = UNIFORM_COMP;
+#if CONFIG_D071_IMP_MSK_BLD
+ inter_pred_params.border_data.enable_bacp = use_bacp;
+ inter_pred_params.border_data.bacp_block_data =
+ &bacp_block_data[0]; // Always point to the first ref
+ inter_pred_params.sb_type = BLOCK_8X8;
+ assert(bw == 8 &&
+ bh == 8); // Currently BACP is supported only for 8x8 block
+ inter_pred_params.mask_comp.type = COMPOUND_AVERAGE;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
const int width = (cm->mi_params.mi_cols << MI_SIZE_LOG2);
const int height = (cm->mi_params.mi_rows << MI_SIZE_LOG2);
inter_pred_params.dist_to_top_edge = -GET_MV_SUBPEL(mi_y);
diff --git a/av1/common/tip.h b/av1/common/tip.h
index c199d06..d5c50d6 100644
--- a/av1/common/tip.h
+++ b/av1/common/tip.h
@@ -118,6 +118,7 @@
*mv = get_mv_from_fullmv(&fullmv);
}
+#if !CONFIG_REFINEMV
// Clamp MV to UMV border based on its distance to left/right/top/bottom edge
static AOM_INLINE MV tip_clamp_mv_to_umv_border_sb(
InterPredParams *const inter_pred_params, const MV *src_mv, int bw, int bh,
@@ -172,7 +173,7 @@
return clamped_mv;
}
-
+#endif //! CONFIG_REFINEMV
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/common/token_cdfs.h b/av1/common/token_cdfs.h
index 546dd7a..b70a2dd 100644
--- a/av1/common/token_cdfs.h
+++ b/av1/common/token_cdfs.h
@@ -398,6 +398,24 @@
} };
#endif // CONFIG_CONTEXT_DERIVATION
+#if CONFIG_ATC_DCTX_ALIGNED
+static const aom_cdf_prob av1_default_coeff_base_bob_multi_cdfs
+ [TOKEN_CDF_Q_CTXS][SIG_COEF_CONTEXTS_BOB][CDF_SIZE(NUM_BASE_LEVELS + 1)] = {
+ { { AOM_CDF3(10923, 21845) },
+ { AOM_CDF3(10923, 21845) },
+ { AOM_CDF3(10923, 21845) } },
+ { { AOM_CDF3(18786, 24298) },
+ { AOM_CDF3(24159, 27856) },
+ { AOM_CDF3(25533, 28778) } },
+ { { AOM_CDF3(19757, 25371) },
+ { AOM_CDF3(20834, 26403) },
+ { AOM_CDF3(20013, 26339) } },
+ { { AOM_CDF3(21974, 28446) },
+ { AOM_CDF3(23020, 29244) },
+ { AOM_CDF3(23858, 29893) } }
+ };
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
static const aom_cdf_prob
av1_default_eob_extra_cdfs[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[EOB_COEF_CONTEXTS][CDF_SIZE(2)] = {
@@ -843,6 +861,110 @@
} } }
};
+#if CONFIG_ATC_DCTX_ALIGNED
+static const aom_cdf_prob
+ av1_default_eob_multi16_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS - 6)] = { { { AOM_CDF5(6554, 13107, 19661, 26214) },
+ { AOM_CDF5(6554, 13107, 19661, 26214) } },
+ { { AOM_CDF5(222, 339, 759, 2493) },
+ { AOM_CDF5(4613, 6877, 12106, 18380) } },
+ { { AOM_CDF5(1418, 2074, 4194, 10380) },
+ { AOM_CDF5(14420, 18173, 23582, 28265) } },
+ { { AOM_CDF5(2817, 4572, 9636, 19946) },
+ { AOM_CDF5(18618, 21512, 26133, 29765) } } };
+
+static const aom_cdf_prob
+ av1_default_eob_multi32_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS - 5)] = {
+ { { AOM_CDF6(5461, 10923, 16384, 21845, 27307) },
+ { AOM_CDF6(5461, 10923, 16384, 21845, 27307) } },
+ { { AOM_CDF6(169, 487, 1046, 1986, 4403) },
+ { AOM_CDF6(4144, 7636, 13889, 20369, 26338) } },
+ { { AOM_CDF6(1365, 1804, 3348, 6966, 13052) },
+ { AOM_CDF6(12169, 14967, 19396, 23910, 28156) } },
+ { { AOM_CDF6(2394, 3348, 6277, 12419, 20179) },
+ { AOM_CDF6(16608, 19308, 23841, 28108, 31336) } }
+ };
+
+static const aom_cdf_prob
+ av1_default_eob_multi64_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS - 4)] = {
+ { { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+ { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) } },
+ { { AOM_CDF7(100, 388, 969, 2002, 4280, 9308) },
+ { AOM_CDF7(4333, 8167, 14492, 20418, 26250, 29955) } },
+ { { AOM_CDF7(1148, 1569, 2970, 5924, 10850, 20433) },
+ { AOM_CDF7(11727, 14694, 19634, 24043, 27541, 30259) } },
+ { { AOM_CDF7(2471, 3361, 6306, 11907, 19426, 28048) },
+ { AOM_CDF7(16268, 19103, 23823, 27751, 30728, 32149) } }
+ };
+
+static const aom_cdf_prob
+ av1_default_eob_multi128_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS - 3)] = {
+ { { AOM_CDF8(4096, 8192, 12288, 16384, 20480, 24576, 28672) },
+ { AOM_CDF8(4096, 8192, 12288, 16384, 20480, 24576, 28672) } },
+ { { AOM_CDF8(34, 889, 2098, 3797, 6595, 10857, 15412) },
+ { AOM_CDF8(2654, 4900, 10162, 15197, 21643, 27251, 31178) } },
+ { { AOM_CDF8(1804, 2359, 3999, 7338, 12798, 19374, 26178) },
+ { AOM_CDF8(12268, 15216, 20355, 24508, 27905, 29986, 31541) } },
+ { { AOM_CDF8(3169, 4356, 7874, 13681, 20866, 27270, 30960) },
+ { AOM_CDF8(17157, 19749, 24432, 27880, 30345, 31718, 32514) } }
+ };
+
+static const aom_cdf_prob
+ av1_default_eob_multi256_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS - 2)] = {
+ { { AOM_CDF9(3641, 7282, 10923, 14564, 18204, 21845, 25486, 29127) },
+ { AOM_CDF9(3641, 7282, 10923, 14564, 18204, 21845, 25486, 29127) } },
+ { { AOM_CDF9(33, 670, 2335, 4307, 7421, 13364, 18212, 24272) },
+ { AOM_CDF9(4218, 6101, 11211, 14560, 18294, 23147, 29103, 31965) } },
+ { { AOM_CDF9(2847, 3904, 6472, 10515, 16418, 23542, 27413, 30171) },
+ { AOM_CDF9(10704, 13812, 18880, 22949, 26500, 29132, 31028, 31981) } },
+ { { AOM_CDF9(3871, 5381, 9315, 15338, 22376, 28297, 31018, 32233) },
+ { AOM_CDF9(16748, 19447, 24213, 27658, 30076, 31428, 32280, 32665) } }
+ };
+
+static const aom_cdf_prob
+ av1_default_eob_multi512_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS - 1)] = {
+ { { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, 26214,
+ 29491) },
+ { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, 26214,
+ 29491) } },
+ { { AOM_CDF10(210, 734, 3354, 8943, 13834, 20297, 25921, 28366, 28820) },
+ { AOM_CDF10(7846, 10783, 17565, 23721, 26809, 28393, 30689, 32349,
+ 32667) } },
+ { { AOM_CDF10(4390, 7204, 11548, 15823, 20831, 26069, 28315, 30071,
+ 31063) },
+ { AOM_CDF10(9109, 12852, 19233, 23707, 27291, 29681, 31403, 32259,
+ 32589) } },
+ { { AOM_CDF10(7299, 9302, 13207, 18796, 25134, 30084, 31270, 32095,
+ 32513) },
+ { AOM_CDF10(18536, 20753, 25277, 28762, 31002, 31931, 32489, 32703,
+ 32707) } }
+ };
+
+static const aom_cdf_prob
+ av1_default_eob_multi1024_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(
+ EOB_MAX_SYMS)] = { { { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873,
+ 20852, 23831, 26810, 29789) },
+ { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873,
+ 20852, 23831, 26810, 29789) } },
+ { { AOM_CDF11(401, 535, 3344, 6821, 8426, 13375,
+ 14043, 17788, 19527, 21667) },
+ { AOM_CDF11(4161, 8108, 14066, 17761, 20706, 21700,
+ 22771, 26741, 31827, 32653) } },
+ { { AOM_CDF11(4252, 6240, 9718, 13784, 19105, 24225,
+ 26454, 28321, 29757, 30648) },
+ { AOM_CDF11(11539, 14807, 19777, 22884, 26491,
+ 28818, 30433, 31677, 32422, 32654) } },
+ { { AOM_CDF11(8416, 10839, 15261, 20667, 26077,
+ 30169, 31223, 31886, 32276, 32527) },
+ { AOM_CDF11(21740, 24160, 28114, 30490, 31733,
+ 32248, 32571, 32700, 32704,
+ 32708) } } };
+#else
static const aom_cdf_prob
av1_default_eob_multi16_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][CDF_SIZE(
5)] = { { { { AOM_CDF5(840, 1039, 1980, 4895) },
@@ -1013,6 +1135,7 @@
29486, 29724, 29807, 32570) },
{ AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
23831, 26810, 29789) } } } };
+#endif // CONFIG_ATC_DCTX_ALIGNED
static const aom_cdf_prob
av1_default_coeff_lps_multi_cdfs_idtx[TOKEN_CDF_Q_CTXS][IDTX_LEVEL_CONTEXTS]
@@ -1075,7 +1198,7 @@
{ AOM_CDF4(13384, 20248, 26029) } }
};
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
static const aom_cdf_prob
av1_default_coeff_lps_multi_cdfs[TOKEN_CDF_Q_CTXS][PLANE_TYPES]
[LEVEL_CONTEXTS][CDF_SIZE(BR_CDF_SIZE)] = {
@@ -1901,7 +2024,7 @@
{ AOM_CDF4(8192, 16384, 24576) }, { AOM_CDF4(8192, 16384, 24576) },
{ AOM_CDF4(8192, 16384, 24576) } } } }
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
static const aom_cdf_prob av1_default_coeff_base_multi_cdfs_idtx
[TOKEN_CDF_Q_CTXS][IDTX_SIG_COEF_CONTEXTS]
@@ -1962,7 +2085,7 @@
{ AOM_CDF4(2674, 5476, 12215) },
{ AOM_CDF4(1568, 3054, 5228) } } };
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
static const aom_cdf_prob av1_default_coeff_base_lf_multi_cdfs
[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES][LF_SIG_COEF_CONTEXTS]
[CDF_SIZE(LF_BASE_SYMBOLS)] = {
@@ -6461,7 +6584,7 @@
{ AOM_CDF3(10923, 21845) },
{ AOM_CDF3(10923, 21845) },
{ AOM_CDF3(10923, 21845) } } } } };
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#if CONFIG_PAR_HIDING
static const aom_cdf_prob
av1_default_coeff_base_ph_cdfs[TOKEN_CDF_Q_CTXS][COEFF_BASE_PH_CONTEXTS]
diff --git a/av1/common/txb_common.h b/av1/common/txb_common.h
index 79f6929..0b82352 100644
--- a/av1/common/txb_common.h
+++ b/av1/common/txb_common.h
@@ -109,16 +109,16 @@
AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE) +
AOMMIN(levels[pos + 1 + stride], MAX_BASE_BR_RANGE);
mag = AOMMIN((mag + 1) >> 1, 6);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
return mag;
#else
//((row | col) < 2) is equivalent to ((row < 2) && (col < 2))
if ((row | col) < 2) return mag + 7;
return mag + 14;
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// This function returns the low range context index for
// the low-frequency region for the EOB coefficient.
static AOM_FORCE_INLINE int get_br_ctx_lf_eob(const int c, // raster order
@@ -139,9 +139,9 @@
return 7;
return 14;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// This function returns the low range context index/increment for the
// coefficients residing in the low-frequency region for 2D transforms.
// Not used for the DC term.
@@ -251,9 +251,9 @@
return mag + 14;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
static const uint8_t clip_max5[256] = {
0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
@@ -266,7 +266,7 @@
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
};
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
static const uint8_t clip_max3[256] = {
0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
@@ -321,7 +321,7 @@
return sign_ctx;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// This function returns the template sum of absolute values
// for coefficient coding for the low-frequency region.
static AOM_FORCE_INLINE int get_nz_mag_lf(const uint8_t *const levels,
@@ -346,7 +346,7 @@
}
return mag;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
// This function returns the template sum of absolute values
// for coefficient coding for the higher-frequency default region.
@@ -399,7 +399,7 @@
return ctx + 7;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// This function returns the base range context index/increment for the
// coefficients residing in the low-frequency region for 1D/2D transforms.
static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats_lf(
@@ -449,7 +449,7 @@
}
return 0;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
// This function returns the base range context index/increment for the
// coefficients residing in the higher-frequency region for 1D/2D transforms.
@@ -457,9 +457,9 @@
const int stats,
const int coeff_idx, // raster order
const int bwl,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
const TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
const TX_CLASS tx_class) {
// tx_class == 0(TX_CLASS_2D)
if ((tx_class | coeff_idx) == 0) return 0;
@@ -467,7 +467,7 @@
ctx = AOMMIN(ctx, 4);
switch (tx_class) {
case TX_CLASS_2D: {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = coeff_idx >> bwl;
const int col = coeff_idx - (row << bwl);
if (row + col < 6) return ctx;
@@ -486,33 +486,33 @@
// if (row + col < 4) return 5 + ctx + 1;
// return 21 + ctx;
return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
case TX_CLASS_HORIZ: {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
return ctx + 15;
#else
const int row = coeff_idx >> bwl;
const int col = coeff_idx - (row << bwl);
return ctx + nz_map_ctx_offset_1d[col];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
case TX_CLASS_VERT: {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
return ctx + 15;
#else
const int row = coeff_idx >> bwl;
return ctx + nz_map_ctx_offset_1d[row];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
default: break;
}
return 0;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
typedef aom_cdf_prob (*base_lf_cdf_arr)[CDF_SIZE(LF_BASE_SYMBOLS)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
typedef aom_cdf_prob (*base_cdf_arr)[CDF_SIZE(4)];
typedef aom_cdf_prob (*br_cdf_arr)[CDF_SIZE(BR_CDF_SIZE)];
#if CONFIG_PAR_HIDING
@@ -563,6 +563,15 @@
return 3;
}
+#if CONFIG_ATC_DCTX_ALIGNED
+// Return context index for first position.
+static INLINE int get_lower_levels_ctx_bob(int bwl, int height, int scan_idx) {
+ if (scan_idx <= (height << bwl) / 8) return 0;
+ if (scan_idx <= (height << bwl) / 4) return 1;
+ return 2;
+}
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
static INLINE int get_upper_levels_ctx_2d(const uint8_t *levels, int coeff_idx,
int bwl) {
int mag;
@@ -576,7 +585,7 @@
return ctx + 7;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// This function returns the base range context index/increment for the
// coefficients residing in the low-frequency region for 2D transforms.
static INLINE int get_lower_levels_ctx_lf_2d(const uint8_t *levels,
@@ -612,14 +621,14 @@
get_nz_mag_lf(levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
return get_nz_map_ctx_from_stats_lf(stats, coeff_idx, bwl, tx_class);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
static INLINE int get_lower_levels_ctx_2d(const uint8_t *levels, int coeff_idx,
int bwl
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
,
TX_SIZE tx_size
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
) {
assert(coeff_idx > 0);
int mag;
@@ -632,7 +641,7 @@
mag += AOMMIN(levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)], 3); // { 2, 0 }
const int ctx = AOMMIN((mag + 1) >> 1, 4);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = coeff_idx >> bwl;
const int col = coeff_idx - (row << bwl);
if (row + col < 6) return ctx;
@@ -640,10 +649,10 @@
return ctx + 10;
#else
return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// This function determines the limits to separate the low-frequency
// coefficient coding region from the higher-frequency default
// region. It is based on the diagonal sum (row+col) or row, columns
@@ -661,35 +670,35 @@
}
return limits;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
static AOM_FORCE_INLINE int get_lower_levels_ctx(const uint8_t *levels,
int coeff_idx, int bwl,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
TX_CLASS tx_class) {
const int stats =
get_nz_mag(levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
return get_nz_map_ctx_from_stats(stats, coeff_idx, bwl, tx_class);
#else
return get_nz_map_ctx_from_stats(stats, coeff_idx, bwl, tx_size, tx_class);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
static INLINE int get_lower_levels_ctx_general(int is_last, int scan_idx,
int bwl, int height,
const uint8_t *levels,
int coeff_idx,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
TX_CLASS tx_class
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
int plane
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
) {
if (is_last) {
if (scan_idx == 0) return 0;
@@ -697,7 +706,7 @@
if (scan_idx <= (height << bwl) >> 2) return 2;
return 3;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = coeff_idx >> bwl;
const int col = coeff_idx - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -708,7 +717,7 @@
}
#else
return get_lower_levels_ctx(levels, coeff_idx, bwl, tx_size, tx_class);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
static INLINE void set_dc_sign(int *cul_level, int dc_val) {
diff --git a/av1/common/warped_motion.c b/av1/common/warped_motion.c
index 1293edf..6fa6b52 100644
--- a/av1/common/warped_motion.c
+++ b/av1/common/warped_motion.c
@@ -983,3 +983,188 @@
return 0;
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+// From the warp model, derive the MV in (x,y) position.
+// (x,y) is the horizontal and vertical position of the frame
+//(0,0) is the top-left co-ordinate of the frame
+int_mv get_warp_motion_vector_xy_pos(const WarpedMotionParams *model,
+ const int x, const int y,
+ MvSubpelPrecision precision) {
+ int_mv res;
+
+ if (model->wmtype == IDENTITY) {
+ res.as_int = 0;
+ return res;
+ }
+
+ if (model->wmtype == TRANSLATION) {
+ // All global motion vectors are stored with WARPEDMODEL_PREC_BITS (16)
+ // bits of fractional precision. The offset for a translation is stored in
+ // entries 0 and 1. For translations, all but the top three (two if
+ // precision < MV_SUBPEL_EIGHTH) fractional bits are always
+ // zero.
+ //
+#if CONFIG_FLEX_MVRES
+ // After the right shifts, there are 3 fractional bits of precision. If
+ // precision < MV_SUBPEL_EIGHTH is false, the bottom bit is always zero
+ // (so we don't need a call to convert_to_trans_prec here)
+ res.as_mv.col = model->wmmat[0] >> GM_TRANS_ONLY_PREC_DIFF;
+ res.as_mv.row = model->wmmat[1] >> GM_TRANS_ONLY_PREC_DIFF;
+
+ // When extended warp prediction is enabled, the warp model can be derived
+ // from the neighbor. Neighbor may have different MV precision than current
+ // block. Therefore, this assertion is not valid when
+ // CONFIG_EXTENDED_WARP_PREDICTION is enabled
+#if !CONFIG_EXTENDED_WARP_PREDICTION
+ assert(IMPLIES(1 & (res.as_mv.row | res.as_mv.col),
+ precision == MV_PRECISION_ONE_EIGHTH_PEL));
+#endif
+#if CONFIG_C071_SUBBLK_WARPMV
+ if (precision < MV_PRECISION_HALF_PEL)
+#endif // CONFIG_C071_SUBBLK_WARPMV
+ lower_mv_precision(&res.as_mv, precision);
+#else
+ // After the right shifts, there are 3 fractional bits of precision. If
+ // allow_hp is false, the bottom bit is always zero (so we don't need a
+ // call to convert_to_trans_prec here)
+ res.as_mv.col = model->wmmat[0] >> GM_TRANS_ONLY_PREC_DIFF;
+ res.as_mv.row = model->wmmat[1] >> GM_TRANS_ONLY_PREC_DIFF;
+ assert(IMPLIES(1 & (res.as_mv.row | res.as_mv.col), allow_hp));
+ if (is_integer) {
+ integer_mv_precision(&res.as_mv);
+ }
+#endif
+ return res;
+ }
+
+ const int32_t *mat = model->wmmat;
+ int tx, ty;
+
+ if (model->wmtype == ROTZOOM) {
+ assert(model->wmmat[5] == model->wmmat[2]);
+ assert(model->wmmat[4] == -model->wmmat[3]);
+ }
+
+ int xc =
+ (mat[2] * x + mat[3] * y + mat[0]) - (1 << WARPEDMODEL_PREC_BITS) * x;
+ int yc =
+ (mat[4] * x + mat[5] * y + mat[1]) - (1 << WARPEDMODEL_PREC_BITS) * y;
+
+#if CONFIG_FLEX_MVRES
+ tx = convert_to_trans_prec(precision, xc);
+ ty = convert_to_trans_prec(precision, yc);
+#else
+ tx = convert_to_trans_prec(allow_hp, xc);
+ ty = convert_to_trans_prec(allow_hp, yc);
+#endif
+
+ res.as_mv.row = ty;
+ res.as_mv.col = tx;
+
+#if CONFIG_FLEX_MVRES
+#if CONFIG_C071_SUBBLK_WARPMV
+ if (precision < MV_PRECISION_HALF_PEL)
+#endif // CONFIG_C071_SUBBLK_WARPMV
+ lower_mv_precision(&res.as_mv, precision);
+#else
+ if (is_integer) {
+ integer_mv_precision(&res.as_mv);
+ }
+#endif
+ return res;
+}
+
+// return 0 if the model is invalid
+// pts (col, row) is the array of source points in the unit of integer pixel
+// mvs are the array of the MVs corresponding to the source points
+// for nth point,
+// pts[2*n] is the col value of the source position. pts[2*n + 1] is the row
+// value of the source position mvs[2*n] is the col value of mv. mvs[2*n + 1]
+// is the row value of mv pts_inref[2*n] is the col value of the projected
+// position. pts_inref[2*n + 1] is the row value of the projected position
+int get_model_from_corner_mvs(WarpedMotionParams *derive_model, int *pts,
+ int np, int *mvs, const BLOCK_SIZE bsize) {
+ // In order to derive the warp model we need 3 projected points
+ // If the number of projected points (np) is not equal to 3, model is not
+ // valid.
+ if (np != 3) {
+ derive_model->invalid = 1;
+ return 0;
+ }
+
+ int x0, y0;
+ int ref_x0, ref_x1, ref_x2, ref_y0, ref_y1, ref_y2;
+ int pts_inref[2 * 3];
+ const int width_log2 = mi_size_wide_log2[bsize] + MI_SIZE_LOG2;
+ const int height_log2 = mi_size_high_log2[bsize] + MI_SIZE_LOG2;
+
+ assert(derive_model != NULL);
+
+ for (int n = 0; n < np; n++) {
+ pts_inref[2 * n] = pts[2 * n] * (1 << WARPEDMODEL_PREC_BITS) +
+ mvs[2 * n] * (1 << GM_TRANS_ONLY_PREC_DIFF);
+ pts_inref[2 * n + 1] = pts[2 * n + 1] * (1 << WARPEDMODEL_PREC_BITS) +
+ mvs[2 * n + 1] * (1 << GM_TRANS_ONLY_PREC_DIFF);
+ int valid_point = (pts[2 * n] >= 0 && pts[2 * n + 1] >= 0 &&
+ pts_inref[2 * n] >= 0 && pts_inref[2 * n + 1] >= 0);
+ if (!valid_point) return 0;
+ }
+
+ int all_mvs_same = 1;
+ for (int k = 1; k < np; k++) {
+ all_mvs_same &= (mvs[0] == mvs[2 * k]) & (mvs[1] == mvs[2 * k + 1]);
+ }
+ if (all_mvs_same) {
+ derive_model->invalid = 1;
+ return 0;
+ }
+
+ // Top-left point
+ x0 = pts[2 * 0];
+ y0 = pts[2 * 0 + 1];
+ ref_x0 = pts_inref[2 * 0];
+ ref_y0 = pts_inref[2 * 0 + 1];
+
+ // Top-right point
+ ref_x1 = pts_inref[2 * 1];
+ ref_y1 = pts_inref[2 * 1 + 1];
+
+ // Bottom-left point
+ ref_x2 = pts_inref[2 * 2];
+ ref_y2 = pts_inref[2 * 2 + 1];
+
+ derive_model->wmmat[2] = (ref_x1 - ref_x0) >> width_log2;
+ derive_model->wmmat[4] = (ref_y1 - ref_y0) >> width_log2;
+
+ derive_model->wmmat[3] = (ref_x2 - ref_x0) >> height_log2;
+ derive_model->wmmat[5] = (ref_y2 - ref_y0) >> height_log2;
+
+ int64_t wmmat0 = (int64_t)ref_x0 -
+ (int64_t)derive_model->wmmat[2] * (int64_t)x0 -
+ (int64_t)derive_model->wmmat[3] * (int64_t)y0;
+ int64_t wmmat1 = (int64_t)ref_y0 -
+ (int64_t)derive_model->wmmat[4] * (int64_t)x0 -
+ (int64_t)derive_model->wmmat[5] * (int64_t)y0;
+
+ derive_model->wmtype = AFFINE;
+ derive_model->invalid = 0;
+
+ av1_reduce_warp_model(derive_model);
+
+ // check compatibility with the fast warp filter
+ if (!av1_get_shear_params(derive_model)) {
+ derive_model->invalid = 1;
+ return 0;
+ }
+
+ derive_model->wmmat[0] = (int32_t)clamp64(wmmat0, -WARPEDMODEL_TRANS_CLAMP,
+ WARPEDMODEL_TRANS_CLAMP - 1);
+ derive_model->wmmat[1] = (int32_t)clamp64(wmmat1, -WARPEDMODEL_TRANS_CLAMP,
+ WARPEDMODEL_TRANS_CLAMP - 1);
+
+ derive_model->wmmat[6] = derive_model->wmmat[7] = 0;
+
+ return 1;
+}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
diff --git a/av1/common/warped_motion.h b/av1/common/warped_motion.h
index 444ce88..9722b22 100644
--- a/av1/common/warped_motion.h
+++ b/av1/common/warped_motion.h
@@ -302,4 +302,86 @@
WarpedMotionParams *wm_params);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+// Given a warp model which was initially used at a temporal distance of
+// `in_distance`, rescale it to a new temporal distance of `out_distance`.
+// Both distances are allowed to be negative, but they must be nonzero.
+//
+// The mathematically ideal way to rescale a warp model from one temporal
+// distance to another would be to use a matrix exponential: If we write the
+// input model as a 3x3 matrix M, then the output model should be
+//
+// ideal output = M ^ (out_distance / in_distance)
+//
+// However, computing a matrix exponential is complicated, especially in
+// fixed point, and so would not be very hardware friendly. In addition,
+// this function is mainly used to predict global motion parameters, with
+// the true values being coded as a delta from this prediction. As the
+// global motion will not be perfectly consistent, there's a limit to how
+// accurate our prediction can be.
+//
+// For these reasons, we approximate the matrix exponential using its
+// first-order Taylor series:
+//
+// output = I + (M - I) * (out_distance / in_distance)
+//
+// This is far easier to compute, and provides a "good enough" approximation
+// for the models we use in practice, which are all reasonably near to the
+// identity model (all parameters except for the translational part are
+// within +/- 1/2 of the identity).
+static INLINE void av1_scale_warp_model(const WarpedMotionParams *in_params,
+ int in_distance,
+ WarpedMotionParams *out_params,
+ int out_distance) {
+ static int param_shift[MAX_PARAMDIM - 1] = {
+ GM_TRANS_PREC_DIFF, GM_TRANS_PREC_DIFF, GM_ALPHA_PREC_DIFF,
+ GM_ALPHA_PREC_DIFF, GM_ALPHA_PREC_DIFF, GM_ALPHA_PREC_DIFF,
+ GM_ROW3HOMO_PREC_DIFF, GM_ROW3HOMO_PREC_DIFF
+ };
+
+ static int param_min[MAX_PARAMDIM - 1] = { GM_TRANS_MIN, GM_TRANS_MIN,
+ GM_ALPHA_MIN, GM_ALPHA_MIN,
+ GM_ALPHA_MIN, GM_ALPHA_MIN,
+ GM_ROW3HOMO_MIN, GM_ROW3HOMO_MIN };
+
+ static int param_max[MAX_PARAMDIM - 1] = { GM_TRANS_MAX, GM_TRANS_MAX,
+ GM_ALPHA_MAX, GM_ALPHA_MAX,
+ GM_ALPHA_MAX, GM_ALPHA_MAX,
+ GM_ROW3HOMO_MAX, GM_ROW3HOMO_MAX };
+
+ assert(in_distance != 0);
+ assert(out_distance != 0);
+
+ // Flip signs so that in_distance is positive.
+ // We do this because
+ // scaled_value = (... + divisor/2) / divisor
+ // is the simplest way to implement division with round-to-nearest in C,
+ // but it only works correctly if the divisor is positive
+ if (in_distance < 0) {
+ in_distance = -in_distance;
+ out_distance = -out_distance;
+ }
+
+ out_params->wmtype = in_params->wmtype;
+ for (int param = 0; param < MAX_PARAMDIM - 1; param++) {
+ int center = default_warp_params.wmmat[param];
+
+ int input = in_params->wmmat[param] - center;
+ int divisor = in_distance * (1 << param_shift[param]);
+ int output = (int)(((int64_t)input * out_distance + divisor / 2) / divisor);
+ output = clamp(output, param_min[param], param_max[param]) *
+ (1 << param_shift[param]);
+
+ out_params->wmmat[param] = center + output;
+ }
+}
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+int_mv get_warp_motion_vector_xy_pos(const WarpedMotionParams *model,
+ const int x, const int y,
+ MvSubpelPrecision precision);
+int get_model_from_corner_mvs(WarpedMotionParams *derive_model, int *pts,
+ int np, int *mvs, const BLOCK_SIZE bsize);
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // AOM_AV1_COMMON_WARPED_MOTION_H_
diff --git a/av1/common/x86/av1_inv_txfm_ssse3.h b/av1/common/x86/av1_inv_txfm_ssse3.h
index 25b45bd..7704498 100644
--- a/av1/common/x86/av1_inv_txfm_ssse3.h
+++ b/av1/common/x86/av1_inv_txfm_ssse3.h
@@ -68,11 +68,11 @@
};
DECLARE_ALIGNED(16, static const int16_t, av1_eob_to_eobxy_8x16_default[16]) = {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
0x0707, 0x0707, 0x0707, 0x0707, 0x0f07, 0x0f07, 0x0f07, 0x0f07,
#else
0x0707, 0x0707, 0x0707, 0x0707, 0x0707, 0x0f07, 0x0f07, 0x0f07,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x0f07,
};
@@ -83,11 +83,11 @@
DECLARE_ALIGNED(16, static const int16_t,
av1_eob_to_eobxy_16x32_default[32]) = {
0x0707, 0x0707, 0x0f0f, 0x0f0f, 0x0f0f, 0x0f0f, 0x0f0f, 0x0f0f,
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f,
#else
0x0f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f,
0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f, 0x1f0f,
};
@@ -99,13 +99,13 @@
};
DECLARE_ALIGNED(16, static const int16_t, av1_eob_to_eobxy_8x32_default[32]) = {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
0x0707, 0x0707, 0x0707, 0x0707, 0x0f07, 0x0f07, 0x0f07, 0x0f07,
0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07,
#else
0x0707, 0x0707, 0x0707, 0x0707, 0x0707, 0x0f07, 0x0f07, 0x0f07,
0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x0f07, 0x1f07, 0x1f07, 0x1f07,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07,
0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07, 0x1f07,
};
diff --git a/av1/decoder/accounting.c b/av1/decoder/accounting.c
index b8c1e5a..0062189 100644
--- a/av1/decoder/accounting.c
+++ b/av1/decoder/accounting.c
@@ -18,26 +18,51 @@
#include "aom/aom_integer.h"
#include "av1/decoder/accounting.h"
-static int accounting_hash(const char *str) {
+static int accounting_hash(AccountingSymbolInfo *acct_info) {
uint32_t val;
const unsigned char *ustr;
val = 0;
- ustr = (const unsigned char *)str;
+ ustr = (const unsigned char *)acct_info->c_file;
/* This is about the worst hash one can design, but it should be good enough
here. */
while (*ustr) val += *ustr++;
+
+ for (int i = 0; i < AOM_ACCOUNTING_MAX_TAGS; i++) {
+ if (acct_info->tags[i] == NULL) break;
+ ustr = (const unsigned char *)acct_info->tags[i];
+ while (*ustr) val += *ustr++;
+ }
+ val += acct_info->c_line;
return val % AOM_ACCOUNTING_HASH_SIZE;
}
+int tags_equal(AccountingSymbolInfo *a, AccountingSymbolInfo *b) {
+ for (int i = 0; i < AOM_ACCOUNTING_MAX_TAGS; i++) {
+ if (a->tags[i] == NULL && b->tags[i] != NULL) return 0;
+ if (a->tags[i] != NULL && b->tags[i] == NULL) return 0;
+ if (a->tags[i] != b->tags[i]) {
+ if (strcmp(a->tags[i], b->tags[i]) != 0) {
+ return 0;
+ }
+ }
+ }
+ return 1;
+}
+
/* Dictionary lookup based on an open-addressing hash table. */
-int aom_accounting_dictionary_lookup(Accounting *accounting, const char *str) {
+int aom_accounting_dictionary_lookup(Accounting *accounting,
+ AccountingSymbolInfo *acct_info) {
int hash;
- size_t len;
AccountingDictionary *dictionary;
dictionary = &accounting->syms.dictionary;
- hash = accounting_hash(str);
+ hash = accounting_hash(acct_info);
while (accounting->hash_dictionary[hash] != -1) {
- if (strcmp(dictionary->strs[accounting->hash_dictionary[hash]], str) == 0) {
+ if (strcmp(dictionary->acct_infos[accounting->hash_dictionary[hash]].c_file,
+ acct_info->c_file) == 0 &&
+ dictionary->acct_infos[accounting->hash_dictionary[hash]].c_line ==
+ acct_info->c_line &&
+ tags_equal(&dictionary->acct_infos[accounting->hash_dictionary[hash]],
+ acct_info)) {
return accounting->hash_dictionary[hash];
}
hash++;
@@ -46,9 +71,8 @@
/* No match found. */
assert(dictionary->num_strs + 1 < MAX_SYMBOL_TYPES);
accounting->hash_dictionary[hash] = dictionary->num_strs;
- len = strlen(str);
- dictionary->strs[dictionary->num_strs] = malloc(len + 1);
- snprintf(dictionary->strs[dictionary->num_strs], len + 1, "%s", str);
+ dictionary->acct_infos[dictionary->num_strs] = *acct_info;
+
dictionary->num_strs++;
return dictionary->num_strs - 1;
}
@@ -77,42 +101,25 @@
}
void aom_accounting_clear(Accounting *accounting) {
- int i;
- AccountingDictionary *dictionary;
free(accounting->syms.syms);
- dictionary = &accounting->syms.dictionary;
- for (i = 0; i < dictionary->num_strs; i++) {
- free(dictionary->strs[i]);
- }
}
-void aom_accounting_set_context(Accounting *accounting, int16_t x, int16_t y) {
+void aom_accounting_set_context(Accounting *accounting, int16_t x, int16_t y,
+ TREE_TYPE tree_type) {
accounting->context.x = x;
accounting->context.y = y;
+ accounting->context.tree_type = tree_type;
}
-void aom_accounting_record(Accounting *accounting, const char *str,
- uint32_t bits) {
+void aom_accounting_record(Accounting *accounting, int value,
+ SYMBOL_CODING_MODE coding_mode,
+ AccountingSymbolInfo acct_info, uint64_t bits) {
AccountingSymbol sym;
- // Reuse previous symbol if it has the same context and symbol id.
- if (accounting->syms.num_syms) {
- AccountingSymbol *last_sym;
- last_sym = &accounting->syms.syms[accounting->syms.num_syms - 1];
- if (memcmp(&last_sym->context, &accounting->context,
- sizeof(AccountingSymbolContext)) == 0) {
- uint32_t id;
- id = aom_accounting_dictionary_lookup(accounting, str);
- if (id == last_sym->id) {
- last_sym->bits += bits;
- last_sym->samples++;
- return;
- }
- }
- }
sym.context = accounting->context;
- sym.samples = 1;
+ sym.value = value;
+ sym.coding_mode = coding_mode;
sym.bits = bits;
- sym.id = aom_accounting_dictionary_lookup(accounting, str);
+ sym.id = aom_accounting_dictionary_lookup(accounting, &acct_info);
assert(sym.id <= 255);
if (accounting->syms.num_syms == accounting->num_syms_allocated) {
accounting->num_syms_allocated *= 2;
@@ -134,8 +141,21 @@
accounting->syms.num_binary_syms);
for (i = 0; i < accounting->syms.num_syms; i++) {
sym = &accounting->syms.syms[i];
- printf("%s x: %d, y: %d bits: %f samples: %d\n",
- accounting->syms.dictionary.strs[sym->id], sym->context.x,
- sym->context.y, (float)sym->bits / 8.0, sym->samples);
+ printf("%s x: %d, y: %d, tree: %d, bits: %f value: %d\n",
+ accounting->syms.dictionary.acct_infos[sym->id].c_func,
+ sym->context.x, sym->context.y, sym->context.tree_type,
+ (double)sym->bits / (double)(1 << AOM_ACCT_BITRES), 1);
}
}
+
+AccountingSymbolInfo aom_accounting_make_info(
+ const char *c_func, const char *c_file, int c_line, const char *tag0,
+ const char *tag1, const char *tag2, const char *tag3) {
+ AccountingSymbolInfo info = {
+ .c_func = c_func,
+ .c_file = c_file,
+ .c_line = c_line,
+ .tags = { tag0, tag1, tag2, tag3 },
+ };
+ return info;
+}
diff --git a/av1/decoder/accounting.h b/av1/decoder/accounting.h
index e4d3037..26cc0d9 100644
--- a/av1/decoder/accounting.h
+++ b/av1/decoder/accounting.h
@@ -13,6 +13,7 @@
#define AOM_AV1_DECODER_ACCOUNTING_H_
#include <stdlib.h>
#include "aom/aomdx.h"
+#include "av1/common/enums.h"
#ifdef __cplusplus
extern "C" {
@@ -25,25 +26,66 @@
#define MAX_SYMBOL_TYPES (256)
/*The resolution of fractional-precision bit usage measurements, i.e.,
- 3 => 1/8th bits.*/
-#define AOM_ACCT_BITRES (3)
+ 16 => 1/65536th bits.*/
+#define AOM_ACCT_BITRES (16)
+
+#define AOM_ACCOUNTING_MAX_TAGS (4)
+
+enum {
+ SYMBOL_BIT = 0,
+ SYMBOL_BIT_BYPASS = 1,
+ SYMBOL_LITERAL_BYPASS = 2,
+ SYMBOL_UNARY = 3,
+ SYMBOL_CDF = 4,
+} UENUM1BYTE(SYMBOL_CODING_MODE);
typedef struct {
int16_t x;
int16_t y;
+ TREE_TYPE tree_type;
} AccountingSymbolContext;
typedef struct {
AccountingSymbolContext context;
uint32_t id;
- /** Number of bits in units of 1/8 bit. */
- uint32_t bits;
- uint32_t samples;
+ /** Number of bits in units of 1/65536 bit. */
+ uint64_t bits;
+ int value;
+ SYMBOL_CODING_MODE coding_mode;
+ int coding_type;
} AccountingSymbol;
+typedef struct {
+ const char *c_func;
+ const char *c_file;
+ int c_line;
+ const char *tags[AOM_ACCOUNTING_MAX_TAGS];
+} AccountingSymbolInfo;
+
+AccountingSymbolInfo aom_accounting_make_info(
+ const char *c_func, const char *c_file, int c_line, const char *tag0,
+ const char *tag1, const char *tag2, const char *tag3);
+
+#define ACCT_INFO0() \
+ aom_accounting_make_info(__func__, __FILE__, __LINE__, NULL, NULL, NULL, NULL)
+#define ACCT_INFO1(tag0) \
+ aom_accounting_make_info(__func__, __FILE__, __LINE__, tag0, NULL, NULL, NULL)
+#define ACCT_INFO2(tag0, tag1) \
+ aom_accounting_make_info(__func__, __FILE__, __LINE__, tag0, tag1, NULL, NULL)
+#define ACCT_INFO3(tag0, tag1, tag2) \
+ aom_accounting_make_info(__func__, __FILE__, __LINE__, tag0, tag1, tag2, NULL)
+#define ACCT_INFO4(tag0, tag1, tag2, tag3) \
+ aom_accounting_make_info(__func__, __FILE__, __LINE__, tag0, tag1, tag2, tag3)
+
+#define GET_ACCT_INFO_MACRO(_0, _1, _2, _3, _4, NAME, ...) NAME
+#define ACCT_INFO(...) \
+ GET_ACCT_INFO_MACRO(_0 __VA_OPT__(, ) __VA_ARGS__, ACCT_INFO4, ACCT_INFO3, \
+ ACCT_INFO2, ACCT_INFO1, ACCT_INFO0) \
+ (__VA_ARGS__)
+
/** Dictionary for translating strings into id. */
typedef struct {
- char *strs[MAX_SYMBOL_TYPES];
+ AccountingSymbolInfo acct_infos[MAX_SYMBOL_TYPES];
int num_strs;
} AccountingDictionary;
@@ -70,16 +112,20 @@
int num_syms_allocated;
int16_t hash_dictionary[AOM_ACCOUNTING_HASH_SIZE];
AccountingSymbolContext context;
- uint32_t last_tell_frac;
+ uint64_t last_tell_frac;
};
void aom_accounting_init(Accounting *accounting);
void aom_accounting_reset(Accounting *accounting);
void aom_accounting_clear(Accounting *accounting);
-void aom_accounting_set_context(Accounting *accounting, int16_t x, int16_t y);
-int aom_accounting_dictionary_lookup(Accounting *accounting, const char *str);
-void aom_accounting_record(Accounting *accounting, const char *str,
- uint32_t bits);
+
+void aom_accounting_set_context(Accounting *accounting, int16_t x, int16_t y,
+ TREE_TYPE tree_type);
+int aom_accounting_dictionary_lookup(Accounting *accounting,
+ AccountingSymbolInfo *acct_info);
+void aom_accounting_record(Accounting *accounting, int value,
+ SYMBOL_CODING_MODE coding_mode,
+ AccountingSymbolInfo acct_info, uint64_t bits);
void aom_accounting_dump(Accounting *accounting);
#ifdef __cplusplus
} // extern "C"
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index e59c8f5..dd52456 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -72,8 +72,6 @@
#include "av1/decoder/decodetxb.h"
#include "av1/decoder/detokenize.h"
-#define ACCT_STR __func__
-
#define AOM_MIN_THREADS_PER_TILE 1
#define AOM_MAX_THREADS_PER_TILE 2
@@ -128,7 +126,11 @@
}
static AOM_INLINE void loop_restoration_read_sb_coeffs(
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane,
+#else
const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane,
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
int runit_idx);
static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
@@ -247,6 +249,37 @@
PLANE_TYPE plane_type = get_plane_type(plane);
av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);
+#if CONFIG_INSPECTION
+ {
+ const int txwpx = tx_size_wide[tx_size];
+ const int txhpx = tx_size_high[tx_size];
+
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int dst_stride = pd->dst.stride;
+ uint16_t *dst = &pd->dst.buf[(row * dst_stride + col) << MI_SIZE_LOG2];
+ for (int i = 0; i < txhpx; i++) {
+ for (int j = 0; j < txwpx; j++) {
+ uint16_t pixel = dst[i * dst_stride + j];
+ int stride = cm->predicted_pixels.strides[plane > 0];
+ int pixel_c, pixel_r;
+
+ if (plane) {
+ mi_to_pixel_loc(&pixel_c, &pixel_r,
+ mbmi->chroma_ref_info.mi_col_chroma_base,
+ mbmi->chroma_ref_info.mi_row_chroma_base, col, row,
+ pd->subsampling_x, pd->subsampling_y);
+ } else {
+ mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, col, row,
+ pd->subsampling_x, pd->subsampling_y);
+ }
+
+ pixel_c += j;
+ pixel_r += i;
+ cm->predicted_pixels.buffers[plane][pixel_r * stride + pixel_c] = pixel;
+ }
+ }
+ }
+#endif // CONFIG_INSPECTION
#if CONFIG_MISMATCH_DEBUG
const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
@@ -267,8 +300,12 @@
pd->subsampling_x, pd->subsampling_y);
}
mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
- cm->current_frame.order_hint, plane, pixel_c,
- pixel_r, blk_w, blk_h);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ plane, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
@@ -317,7 +354,12 @@
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, col, row,
pd->subsampling_x, pd->subsampling_y);
}
- mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
+ mismatch_check_block_tx(dst, pd->dst.stride,
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
plane, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
@@ -325,12 +367,7 @@
if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd) &&
xd->tree_type == SHARED_PART) {
#if CONFIG_ADAPTIVE_DS_FILTER
- cfl_store_tx(xd, row, col, tx_size,
-#if DS_FRAME_LEVEL
- cm->features.ds_filter_type);
-#else
- cm->seq_params.enable_cfl_ds_filter);
-#endif // DS_FRAME_LEVEL
+ cfl_store_tx(xd, row, col, tx_size, cm->seq_params.enable_cfl_ds_filter);
#else
cfl_store_tx(xd, row, col, tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
@@ -394,7 +431,12 @@
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row,
pd->subsampling_x, pd->subsampling_y);
}
- mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
+ mismatch_check_block_tx(dst, pd->dst.stride,
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
plane, pixel_c, pixel_r, blk_w, blk_h);
#endif // CONFIG_MISMATCH_DEBUG
}
@@ -561,8 +603,8 @@
}
CHROMA_REF_INFO *chroma_ref_info = &xd->mi[0]->chroma_ref_info;
- set_chroma_ref_info(mi_row, mi_col, index, bsize, chroma_ref_info,
- parent ? &parent->chroma_ref_info : NULL,
+ set_chroma_ref_info(xd->tree_type, mi_row, mi_col, index, bsize,
+ chroma_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);
@@ -578,12 +620,14 @@
num_planes, chroma_ref_info);
}
+#if !CONFIG_REFINEMV
typedef struct PadBlock {
int x0;
int x1;
int y0;
int y1;
} PadBlock;
+#endif //! CONFIG_REFINEMV
static AOM_INLINE void highbd_build_mc_border(const uint16_t *src,
int src_stride, uint16_t *dst,
@@ -622,10 +666,12 @@
} while (--b_h);
}
-static INLINE int update_extend_mc_border_params(
- const struct scale_factors *const sf, struct buf_2d *const pre_buf,
- MV32 scaled_mv, PadBlock *block, int subpel_x_mv, int subpel_y_mv,
- int do_warp, int is_intrabc, int *x_pad, int *y_pad) {
+#if !CONFIG_REFINEMV
+int update_extend_mc_border_params(const struct scale_factors *const sf,
+ struct buf_2d *const pre_buf, MV32 scaled_mv,
+ PadBlock *block, int subpel_x_mv,
+ int subpel_y_mv, int do_warp, int is_intrabc,
+ int *x_pad, int *y_pad) {
// Get reference width and height.
int frame_width = pre_buf->width;
int frame_height = pre_buf->height;
@@ -662,6 +708,7 @@
}
return 0;
}
+#endif //! CONFIG_REFINEMV
static INLINE void extend_mc_border(const struct scale_factors *const sf,
struct buf_2d *const pre_buf,
@@ -673,7 +720,13 @@
int x_pad = 0, y_pad = 0;
if (update_extend_mc_border_params(sf, pre_buf, scaled_mv, &block,
subpel_x_mv, subpel_y_mv, do_warp,
- is_intrabc, &x_pad, &y_pad)) {
+ is_intrabc, &x_pad, &y_pad
+#if CONFIG_REFINEMV
+ ,
+ NULL
+#endif // CONFIG_REFINEMV
+
+ )) {
// Get reference block pointer.
const uint16_t *const buf_ptr =
pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
@@ -690,7 +743,7 @@
x_pad * (AOM_INTERP_EXTEND - 1);
}
}
-
+#if !CONFIG_REFINEMV
static void dec_calc_subpel_params(
const MV *const src_mv, InterPredParams *const inter_pred_params,
const MACROBLOCKD *const xd, int mi_x, int mi_y, uint16_t **pre,
@@ -810,8 +863,17 @@
}
*pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
*src_stride = pre_buf->stride;
-}
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ subpel_params->x0 = block->x0;
+ subpel_params->x1 = block->x1;
+ subpel_params->y0 = block->y0;
+ subpel_params->y1 = block->y1;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+}
+#endif //! CONFIG_REFINEMV
static void dec_calc_subpel_params_and_extend(
const MV *const src_mv, InterPredParams *const inter_pred_params,
MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
@@ -820,6 +882,19 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
int *src_stride) {
+
+#if CONFIG_REFINEMV
+ if (inter_pred_params->use_ref_padding) {
+ common_calc_subpel_params_and_extend(
+ src_mv, inter_pred_params, xd, mi_x, mi_y, ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ mc_buf, pre, subpel_params, src_stride);
+ return;
+ }
+#endif
+
PadBlock block;
MV32 scaled_mv;
int subpel_x_mv, subpel_y_mv;
@@ -837,6 +912,7 @@
}
#if CONFIG_TIP
+#if !CONFIG_REFINEMV
static AOM_INLINE void tip_dec_calc_subpel_params(
const MV *const src_mv, InterPredParams *const inter_pred_params, int mi_x,
int mi_y, uint16_t **pre, SubpelParams *subpel_params, int *src_stride,
@@ -847,6 +923,11 @@
MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) {
const struct scale_factors *sf = inter_pred_params->scale_factors;
struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
+
+#if CONFIG_REFINEMV
+ const int bw = inter_pred_params->original_pu_width;
+ const int bh = inter_pred_params->original_pu_height;
+#else
#if CONFIG_OPTFLOW_REFINEMENT
// Use original block size to clamp MV and to extend block boundary
const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
@@ -857,6 +938,8 @@
const int bw = inter_pred_params->block_width;
const int bh = inter_pred_params->block_height;
#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // CONFIG_REFINEMV
+
const int is_scaled = av1_is_scaled(sf);
if (is_scaled) {
const int ssx = inter_pred_params->subsampling_x;
@@ -900,10 +983,21 @@
block->y0 = pos_y >> SCALE_SUBPEL_BITS;
// Get reference block bottom right coordinate.
+#if CONFIG_D071_IMP_MSK_BLD
+ block->x1 =
+ ((pos_x + (inter_pred_params->block_width - 1) * subpel_params->xs) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+ block->y1 =
+ ((pos_y + (inter_pred_params->block_height - 1) * subpel_params->ys) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+#else
block->x1 =
((pos_x + (bw - 1) * subpel_params->xs) >> SCALE_SUBPEL_BITS) + 1;
block->y1 =
((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1;
+#endif // CONFIG_D071_IMP_MSK_BLD
MV temp_mv;
temp_mv = tip_clamp_mv_to_umv_border_sb(inter_pred_params, src_mv, bw, bh,
@@ -942,8 +1036,13 @@
block->y0 = pos_y;
// Get reference block bottom right coordinate.
+#if CONFIG_D071_IMP_MSK_BLD
+ block->x1 = pos_x + inter_pred_params->block_width;
+ block->y1 = pos_y + inter_pred_params->block_height;
+#else
block->x1 = pos_x + bw;
block->y1 = pos_y + bh;
+#endif // CONFIG_D071_IMP_MSK_BLD
scaled_mv->row = mv_q4.row;
scaled_mv->col = mv_q4.col;
@@ -952,8 +1051,17 @@
}
*pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
*src_stride = pre_buf->stride;
-}
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ subpel_params->x0 = block->x0;
+ subpel_params->x1 = block->x1;
+ subpel_params->y0 = block->y0;
+ subpel_params->y1 = block->y1;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+}
+#endif
static void tip_dec_calc_subpel_params_and_extend(
const MV *const src_mv, InterPredParams *const inter_pred_params,
MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
@@ -962,7 +1070,22 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
int *src_stride) {
+
+#if CONFIG_REFINEMV
+ if (inter_pred_params->use_ref_padding) {
+ // printf(" used pading in the decoder \n");
+ tip_common_calc_subpel_params_and_extend(
+ src_mv, inter_pred_params, xd, mi_x, mi_y, ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ mc_buf, pre, subpel_params, src_stride);
+ return;
+ }
+#else
+
(void)xd;
+#endif // CONFIG_REFINEMV
PadBlock block;
MV32 scaled_mv;
int subpel_x_mv, subpel_y_mv;
@@ -1083,7 +1206,7 @@
MACROBLOCKD *const xd = &dcb->xd;
#if CONFIG_ACCOUNTING
- aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
+ aom_accounting_set_context(&pbi->accounting, mi_col, mi_row, xd->tree_type);
#endif
set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis, parent,
index);
@@ -1158,11 +1281,19 @@
static void dec_build_inter_predictors(const AV1_COMMON *cm,
DecoderCodingBlock *dcb, int plane,
MB_MODE_INFO *mi, int build_for_obmc,
- int bw, int bh, int mi_x, int mi_y) {
+ int bw, int bh, int mi_x, int mi_y
+#if CONFIG_REFINEMV
+ ,
+ int build_for_refine_mv_only
+#endif // CONFIG_REFINEMV
+) {
av1_build_inter_predictors(cm, &dcb->xd, plane, mi,
#if CONFIG_BAWP
NULL,
#endif
+#if CONFIG_REFINEMV
+ build_for_refine_mv_only,
+#endif // CONFIG_REFINEMV
build_for_obmc, bw, bh, mi_x, mi_y, dcb->mc_buf,
dec_calc_subpel_params_and_extend);
}
@@ -1173,13 +1304,35 @@
BLOCK_SIZE bsize) {
MACROBLOCKD *const xd = &dcb->xd;
const int num_planes = av1_num_planes(cm);
+
+#if CONFIG_REFINEMV
+ MB_MODE_INFO *mbmi = xd->mi[0];
+ int need_subblock_mvs = xd->is_chroma_ref && mbmi->refinemv_flag &&
+ !is_intrabc_block(mbmi, xd->tree_type);
+ assert(IMPLIES(need_subblock_mvs, !is_interintra_pred(mbmi)));
+ if (need_subblock_mvs && default_refinemv_modes(mbmi))
+ need_subblock_mvs &= (mbmi->comp_group_idx == 0 &&
+ mbmi->interinter_comp.type == COMPOUND_AVERAGE);
+ if (need_subblock_mvs) {
+ fill_subblock_refine_mv(xd->refinemv_subinfo, xd->plane[0].width,
+ xd->plane[0].height, mbmi->mv[0].as_mv,
+ mbmi->mv[1].as_mv);
+ }
+#endif // CONFIG_REFINEMV
+
for (int plane = 0; plane < num_planes; ++plane) {
if (plane && !xd->is_chroma_ref) break;
const int mi_x = mi_col * MI_SIZE;
const int mi_y = mi_row * MI_SIZE;
dec_build_inter_predictors(cm, dcb, plane, xd->mi[0], 0,
xd->plane[plane].width, xd->plane[plane].height,
- mi_x, mi_y);
+ mi_x, mi_y
+#if CONFIG_REFINEMV
+ ,
+ 0
+#endif // CONFIG_REFINEMV
+ );
+
if (is_interintra_pred(xd->mi[0])) {
BUFFER_SET ctx = { { xd->plane[0].dst.buf, xd->plane[1].dst.buf,
xd->plane[2].dst.buf },
@@ -1217,7 +1370,12 @@
if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 0)) continue;
dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,
- &backup_mbmi, 1, bw, bh, mi_x, mi_y);
+ &backup_mbmi, 1, bw, bh, mi_x, mi_y
+#if CONFIG_REFINEMV
+ ,
+ 0
+#endif // CONFIG_REFINEMV
+ );
}
}
@@ -1238,9 +1396,9 @@
cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_right_edge, dcb
};
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y];
- foreach_overlappable_nb_above(cm, xd,
- max_neighbor_obmc[mi_size_wide_log2[bsize]],
- dec_build_prediction_by_above_pred, &ctxt);
+ foreach_overlappable_nb_above(
+ cm, xd, max_neighbor_obmc[mi_size_wide_log2[bsize]],
+ dec_build_prediction_by_above_pred, &ctxt, false);
xd->mb_to_left_edge = -GET_MV_SUBPEL(xd->mi_col * MI_SIZE);
xd->mb_to_right_edge = ctxt.mb_to_far_edge;
@@ -1272,7 +1430,12 @@
if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 1)) continue;
dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,
- &backup_mbmi, 1, bw, bh, mi_x, mi_y);
+ &backup_mbmi, 1, bw, bh, mi_x, mi_y
+#if CONFIG_REFINEMV
+ ,
+ 0
+#endif // CONFIG_REFINEMV
+ );
}
}
@@ -1335,12 +1498,7 @@
if (store_cfl_required(cm, xd) && xd->tree_type == SHARED_PART) {
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_block(xd, mbmi->sb_type[PLANE_TYPE_Y], mbmi->tx_size,
-#if DS_FRAME_LEVEL
- cm->features.ds_filter_type
-#else
- cm->seq_params.enable_cfl_ds_filter
-#endif
- );
+ cm->seq_params.enable_cfl_ds_filter);
#else
cfl_store_block(xd, mbmi->sb_type[PLANE_TYPE_Y], mbmi->tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
@@ -1394,10 +1552,44 @@
pd->subsampling_x, pd->subsampling_y);
}
mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
- cm->current_frame.order_hint, plane, pixel_c,
- pixel_r, pd->width, pd->height);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ plane, pixel_c, pixel_r, pd->width, pd->height);
}
#endif // CONFIG_MISMATCH_DEBUG
+
+#if CONFIG_INSPECTION
+ for (int plane = 0; plane < num_planes; plane++) {
+ struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int dst_stride = pd->dst.stride;
+ const int plane_block_size =
+ get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+ const int plane_width = mi_size_wide[plane_block_size];
+ const int plane_height = mi_size_high[plane_block_size];
+ for (int i = 0; i < plane_height * MI_SIZE; i++) {
+ for (int j = 0; j < plane_width * MI_SIZE; j++) {
+ uint16_t pixel = pd->dst.buf[i * dst_stride + j];
+ int stride = cm->predicted_pixels.strides[plane > 0];
+ int pixel_c, pixel_r;
+ if (plane) {
+ mi_to_pixel_loc(&pixel_c, &pixel_r,
+ mbmi->chroma_ref_info.mi_col_chroma_base,
+ mbmi->chroma_ref_info.mi_row_chroma_base, 0, 0,
+ pd->subsampling_x, pd->subsampling_y);
+ } else {
+ mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, 0, 0,
+ pd->subsampling_x, pd->subsampling_y);
+ }
+ pixel_c += j;
+ pixel_r += i;
+ cm->predicted_pixels.buffers[plane][pixel_r * stride + pixel_c] = pixel;
+ }
+ }
+ }
+#endif // CONFIG_INSPECTION
}
static AOM_INLINE void set_color_index_map_offset(MACROBLOCKD *const xd,
@@ -1672,7 +1864,7 @@
is_inter ? ec_ctx->inter_4way_txfm_partition_cdf[is_rect][split4_ctx]
: ec_ctx->intra_4way_txfm_partition_cdf[is_rect][split4_ctx];
const TX_PARTITION_TYPE split4_partition =
- aom_read_symbol(r, split4_cdf, 4, ACCT_STR);
+ aom_read_symbol(r, split4_cdf, 4, ACCT_INFO("split4_partition"));
partition = split4_partition;
/*
If only one split type (horizontal or vertical) is allowed for this block,
@@ -1684,7 +1876,8 @@
// Read bit to indicate if there is any split at all
aom_cdf_prob *split2_cdf = is_inter ? ec_ctx->inter_2way_txfm_partition_cdf
: ec_ctx->intra_2way_txfm_partition_cdf;
- const int has_first_split = aom_read_symbol(r, split2_cdf, 2, ACCT_STR);
+ const int has_first_split =
+ aom_read_symbol(r, split2_cdf, 2, ACCT_INFO("has_first_split"));
partition = has_first_split
? (allow_horz ? TX_PARTITION_HORZ : TX_PARTITION_VERT)
: TX_PARTITION_NONE;
@@ -1751,7 +1944,8 @@
const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row,
mbmi->sb_type[plane_type], tx_size);
- is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
+ is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2,
+ ACCT_INFO("is_split"));
if (is_split) {
const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
@@ -1817,7 +2011,7 @@
const int ctx = get_tx_size_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
- max_depths + 1, ACCT_STR);
+ max_depths + 1, ACCT_INFO("depth"));
assert(depth >= 0 && depth <= max_depths);
const TX_SIZE tx_size = depth_to_tx_size(depth, bsize);
return tx_size;
@@ -2023,8 +2217,8 @@
#endif // CONFIG_CROSS_CHROMA_TX
CHROMA_REF_INFO *chroma_ref_info = &xd->mi[0]->chroma_ref_info;
- set_chroma_ref_info(mi_row, mi_col, index, bsize, chroma_ref_info,
- parent ? &parent->chroma_ref_info : NULL,
+ set_chroma_ref_info(xd->tree_type, mi_row, mi_col, index, bsize,
+ chroma_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);
@@ -2049,6 +2243,46 @@
}
#if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_UNEVEN_4WAY
+/*!\brief Maps (ext_part, 4way, 4way_type, rect_type) to partition_type. */
+static PARTITION_TYPE
+ rect_part_table[2][2][NUM_UNEVEN_4WAY_PARTS][NUM_RECT_PARTS] = {
+ {
+ // !do_ext_partition
+ {
+ // !do_4way
+ { // UNEVEN_4A
+ PARTITION_HORZ, PARTITION_VERT },
+ { // UNEVEN_4B
+ PARTITION_HORZ, PARTITION_VERT },
+ },
+ {
+ // do_4way
+ { // UNEVEN_4A
+ PARTITION_HORZ, PARTITION_VERT },
+ { // UNEVEN_4B
+ PARTITION_HORZ, PARTITION_VERT },
+ },
+ },
+ {
+ // do_ext_partition
+ {
+ // !do_4way
+ { // UNEVEN_4A
+ PARTITION_HORZ_3, PARTITION_VERT_3 },
+ { // UNEVEN_4B
+ PARTITION_HORZ_3, PARTITION_VERT_3 },
+ },
+ {
+ // do_4way
+ { // UNEVEN_4A
+ PARTITION_HORZ_4A, PARTITION_VERT_4A },
+ { // UNEVEN_4B
+ PARTITION_HORZ_4B, PARTITION_VERT_4B },
+ },
+ },
+ };
+#else
/*!\brief Maps (ext_part, rect_type) to partition_type. */
static PARTITION_TYPE rect_part_table[2][NUM_RECT_PARTS] = {
// !do_ext_partition
@@ -2056,6 +2290,7 @@
// do_ext_partition
{ PARTITION_HORZ_3, PARTITION_VERT_3 },
};
+#endif // CONFIG_UNEVEN_4WAY
#endif // CONFIG_EXT_RECUR_PARTITIONS
static PARTITION_TYPE read_partition(const AV1_COMMON *const cm,
@@ -2066,11 +2301,8 @@
const PARTITION_TREE *ptree_luma,
#endif // CONFIG_EXT_RECUR_PARTITIONS
BLOCK_SIZE bsize) {
-#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);
+ assert(ctx >= 0);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_EXT_RECUR_PARTITIONS
@@ -2079,28 +2311,24 @@
const int plane = xd->tree_type == CHROMA_PART;
const int ssx = cm->seq_params.subsampling_x;
const int ssy = cm->seq_params.subsampling_y;
- if (plane == 1 && bsize == BLOCK_8X8) {
- return PARTITION_NONE;
- }
- if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
- return sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ssx, ssy);
+ const PARTITION_TYPE derived_partition =
+ av1_get_normative_forced_partition_type(
+ &cm->mi_params, xd->tree_type, ssx, ssy, mi_row, mi_col, bsize,
+ ptree_luma, &ptree->chroma_ref_info);
+ if (derived_partition != PARTITION_INVALID) {
+ return derived_partition;
}
- PARTITION_TYPE implied_partition;
- const bool is_part_implied = is_partition_implied_at_boundary(
- &cm->mi_params, xd->tree_type, ssx, ssy, mi_row, mi_col, bsize,
- &ptree->chroma_ref_info, &implied_partition);
- if (is_part_implied) return implied_partition;
-
- const bool do_split =
- aom_read_symbol(r, ec_ctx->do_split_cdf[plane][ctx], 2, ACCT_STR);
+ const bool do_split = aom_read_symbol(r, ec_ctx->do_split_cdf[plane][ctx], 2,
+ ACCT_INFO("do_split"));
if (!do_split) {
return PARTITION_NONE;
}
const int square_split_ctx = square_split_context(xd, mi_row, mi_col, bsize);
if (is_square_split_eligible(bsize, cm->sb_size)) {
- const bool do_square_split = aom_read_symbol(
- r, ec_ctx->do_square_split_cdf[plane][square_split_ctx], 2, ACCT_STR);
+ const bool do_square_split =
+ aom_read_symbol(r, ec_ctx->do_square_split_cdf[plane][square_split_ctx],
+ 2, ACCT_INFO("do_square_split"));
if (do_square_split) {
return PARTITION_SPLIT;
}
@@ -2108,20 +2336,46 @@
RECT_PART_TYPE rect_type = rect_type_implied_by_bsize(bsize, xd->tree_type);
if (rect_type == RECT_INVALID) {
- rect_type =
- aom_read_symbol(r, ec_ctx->rect_type_cdf[plane][ctx], 2, ACCT_STR);
+ rect_type = aom_read_symbol(r, ec_ctx->rect_type_cdf[plane][ctx],
+ NUM_RECT_PARTS, ACCT_INFO("rect_type"));
}
- const bool disable_ext_part = !cm->seq_params.enable_ext_partitions;
- const bool ext_partition_allowed =
- !disable_ext_part &&
- is_ext_partition_allowed(bsize, rect_type, xd->tree_type);
bool do_ext_partition = false;
+#if CONFIG_UNEVEN_4WAY
+ bool do_uneven_4way_partition = false;
+ UNEVEN_4WAY_PART_TYPE uneven_4way_partition_type = UNEVEN_4A;
+#endif // CONFIG_UNEVEN_4WAY
+
+ const bool ext_partition_allowed =
+ cm->seq_params.enable_ext_partitions &&
+ is_ext_partition_allowed(bsize, rect_type, xd->tree_type);
if (ext_partition_allowed) {
- do_ext_partition = aom_read_symbol(
- r, ec_ctx->do_ext_partition_cdf[plane][rect_type][ctx], 2, ACCT_STR);
+ do_ext_partition =
+ aom_read_symbol(r, ec_ctx->do_ext_partition_cdf[plane][rect_type][ctx],
+ 2, ACCT_INFO("do_ext_partition"));
+#if CONFIG_UNEVEN_4WAY
+ if (do_ext_partition) {
+ const bool uneven_4way_partition_allowed =
+ is_uneven_4way_partition_allowed(bsize, rect_type, xd->tree_type);
+ if (uneven_4way_partition_allowed) {
+ do_uneven_4way_partition = aom_read_symbol(
+ r, ec_ctx->do_uneven_4way_partition_cdf[plane][rect_type][ctx], 2,
+ ACCT_INFO("do_uneven_4way_partition"));
+ if (do_uneven_4way_partition) {
+ uneven_4way_partition_type = aom_read_symbol(
+ r, ec_ctx->uneven_4way_partition_type_cdf[plane][rect_type][ctx],
+ NUM_UNEVEN_4WAY_PARTS, ACCT_INFO("uneven_4way_partition_type"));
+ }
+ }
+ }
+#endif // CONFIG_UNEVEN_4WAY
}
+#if CONFIG_UNEVEN_4WAY
+ return rect_part_table[do_ext_partition][do_uneven_4way_partition]
+ [uneven_4way_partition_type][rect_type];
+#else
return rect_part_table[do_ext_partition][rect_type];
+#endif // CONFIG_UNEVEN_4WAY
#else // !CONFIG_EXT_RECUR_PARTITIONS
if (!has_rows && !has_cols) return PARTITION_SPLIT;
@@ -2141,20 +2395,22 @@
aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
if (has_rows && has_cols) {
return (PARTITION_TYPE)aom_read_symbol(
- r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
+ r, partition_cdf, partition_cdf_length(bsize), ACCT_INFO());
} else if (!has_rows && has_cols) {
assert(bsize > BLOCK_8X8);
aom_cdf_prob cdf[2];
partition_gather_vert_alike(cdf, partition_cdf, bsize);
assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
- return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ;
+ return aom_read_cdf(r, cdf, 2, ACCT_INFO()) ? PARTITION_SPLIT
+ : PARTITION_HORZ;
} else {
assert(has_rows && !has_cols);
assert(bsize > BLOCK_8X8);
aom_cdf_prob cdf[2];
partition_gather_horz_alike(cdf, partition_cdf, bsize);
assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
- return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
+ return aom_read_cdf(r, cdf, 2, ACCT_INFO()) ? PARTITION_SPLIT
+ : PARTITION_VERT;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
@@ -2185,12 +2441,19 @@
MACROBLOCKD *const xd = &dcb->xd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
+ // Half block width/height.
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
-#if !CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ // One-eighth block width/height.
+ const int ebs_w = mi_size_wide[bsize] / 8;
+ const int ebs_h = mi_size_high[bsize] / 8;
+#endif // CONFIG_UNEVEN_4WAY
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ // Quarter block width/height.
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
-#endif // !CONFIG_H_PARTITION
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
PARTITION_TYPE partition;
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;
@@ -2220,7 +2483,11 @@
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
for (int plane = plane_start; plane < plane_end; ++plane) {
int rcol0, rcol1, rrow0, rrow1;
- if (cm->rst_info[plane].frame_restoration_type != RESTORE_NONE &&
+ if ((cm->rst_info[plane].frame_restoration_type != RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ || cm->rst_info[plane].frame_cross_restoration_type != RESTORE_NONE
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ) &&
av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
&rcol0, &rcol1, &rrow0, &rrow1)) {
const int rstride = cm->rst_info[plane].horz_units_per_tile;
@@ -2239,8 +2506,8 @@
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,
+ xd->tree_type, 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);
@@ -2263,6 +2530,12 @@
ptree->partition = partition;
switch (partition) {
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B:
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B:
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_SPLIT:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
@@ -2280,9 +2553,7 @@
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);
-#if CONFIG_H_PARTITION
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
-#endif // CONFIG_H_PARTITION
break;
#endif // CONFIG_EXT_RECUR_PARTITIONS
default: break;
@@ -2310,7 +2581,8 @@
const int index =
(partition == PARTITION_HORZ || partition == PARTITION_VERT) +
(partition == PARTITION_HORZ_3 || partition == PARTITION_VERT_3);
- set_chroma_ref_info(mi_row, mi_col, index, bsize, &chroma_ref_info,
+ set_chroma_ref_info(xd->tree_type, mi_row, mi_col, index, bsize,
+ &chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
parent ? parent->partition : PARTITION_NONE,
@@ -2391,7 +2663,81 @@
#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ int this_mi_row = mi_row;
+ DEC_PARTITION(this_mi_row, mi_col, subsize, 0);
+ this_mi_row += ebs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, bsize_med, 1);
+ this_mi_row += 2 * ebs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, bsize_big, 2);
+ this_mi_row += 4 * ebs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, subsize, 3);
+ break;
+ }
+ case PARTITION_HORZ_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ int this_mi_row = mi_row;
+ DEC_PARTITION(this_mi_row, mi_col, subsize, 0);
+ this_mi_row += ebs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, bsize_big, 1);
+ this_mi_row += 4 * ebs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, bsize_med, 2);
+ this_mi_row += 2 * ebs_h;
+ if (this_mi_row >= cm->mi_params.mi_rows) break;
+ DEC_PARTITION(this_mi_row, mi_col, subsize, 3);
+ break;
+ }
+ case PARTITION_VERT_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ int this_mi_col = mi_col;
+ DEC_PARTITION(mi_row, this_mi_col, subsize, 0);
+ this_mi_col += ebs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, bsize_med, 1);
+ this_mi_col += 2 * ebs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, bsize_big, 2);
+ this_mi_col += 4 * ebs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, subsize, 3);
+ break;
+ }
+ case PARTITION_VERT_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ int this_mi_col = mi_col;
+ DEC_PARTITION(mi_row, this_mi_col, subsize, 0);
+ this_mi_col += ebs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, bsize_big, 1);
+ this_mi_col += 4 * ebs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, bsize_med, 2);
+ this_mi_col += 2 * ebs_w;
+ if (this_mi_col >= cm->mi_params.mi_cols) break;
+ DEC_PARTITION(mi_row, this_mi_col, subsize, 3);
+ break;
+ }
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3:
case PARTITION_VERT_3: {
for (int i = 0; i < 4; ++i) {
@@ -2414,39 +2760,13 @@
}
break;
}
-#else
- 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;
- }
-#endif // CONFIG_H_PARTITION
case PARTITION_SPLIT:
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;
-#else
+#else // !CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
DEC_PARTITION(mi_row, mi_col, subsize, 0);
DEC_PARTITION(mi_row, mi_col + hbs_w, subsize, 1);
@@ -2561,6 +2881,11 @@
parse_decode_flag);
xd->tree_type = SHARED_PART;
}
+#if CONFIG_INSPECTION
+ if (pbi->inspect_sb_cb != NULL) {
+ (*pbi->inspect_sb_cb)(pbi, pbi->inspect_ctx);
+ }
+#endif // CONFIG_INSPECTION
}
static AOM_INLINE void setup_segmentation(AV1_COMMON *const cm,
@@ -2652,7 +2977,7 @@
#if CONFIG_LR_FLEX_SYNTAX
// Converts decoded index to frame restoration type depending on lr tools
-// thta are enabled for the frame for a given plane.
+// that are enabled for the frame for a given plane.
static RestorationType index_to_frame_restoration_type(
const AV1_COMMON *const cm, int plane, int ndx) {
RestorationType r = RESTORE_NONE;
@@ -2671,8 +2996,19 @@
struct aom_read_bit_buffer *rb) {
assert(!cm->features.all_lossless);
const int num_planes = av1_num_planes(cm);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ for (int p = 0; p < num_planes; ++p) {
+ RestorationInfo *rsi = &cm->rst_info[p];
+ rsi->frame_restoration_type = RESTORE_NONE;
+ rsi->frame_cross_restoration_type = RESTORE_NONE;
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
if (is_global_intrabc_allowed(cm)) return;
+#if CONFIG_FLEXIBLE_RU_SIZE
+ int luma_none = 1, chroma_none = 1;
+#else
int all_none = 1, chroma_none = 1;
+#endif // CONFIG_FLEXIBLE_RU_SIZE
for (int p = 0; p < num_planes; ++p) {
RestorationInfo *rsi = &cm->rst_info[p];
#if CONFIG_LR_FLEX_SYNTAX
@@ -2690,9 +3026,16 @@
if (rsi->frame_restoration_type == RESTORE_SWITCHABLE &&
cm->features.lr_tools_count[p] > 2) {
if (aom_rb_read_bit(rb)) {
+ int tools_count = cm->features.lr_tools_count[p];
for (int i = 1; i < RESTORE_SWITCHABLE_TYPES; ++i) {
- if (!(plane_lr_tools_disable_mask & (1 << i)))
- plane_lr_tools_disable_mask |= (aom_rb_read_bit(rb) << i);
+ if (!(plane_lr_tools_disable_mask & (1 << i))) {
+ const int disable_tool = aom_rb_read_bit(rb);
+ plane_lr_tools_disable_mask |= (disable_tool << i);
+ tools_count -= disable_tool;
+ // if tools_count becomes 2 break from the loop since we
+ // do not allow any other tool to be disabled.
+ if (tools_count == 2) break;
+ }
}
av1_set_lr_tools(plane_lr_tools_disable_mask, p, &cm->features);
}
@@ -2728,8 +3071,23 @@
}
}
#endif // CONFIG_LR_FLEX_SYNTAX
+
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (p > 0) {
+ if (aom_rb_read_bit(rb)) {
+ rsi->frame_cross_restoration_type = RESTORE_WIENER_NONSEP;
+ }
+ }
+ if (rsi->frame_restoration_type != RESTORE_NONE ||
+ rsi->frame_cross_restoration_type != RESTORE_NONE) {
+#else
if (rsi->frame_restoration_type != RESTORE_NONE) {
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+#if CONFIG_FLEXIBLE_RU_SIZE
+ luma_none &= p > 0;
+#else
all_none = 0;
+#endif // CONFIG_FLEXIBLE_RU_SIZE
chroma_none &= p == 0;
}
#if CONFIG_WIENER_NONSEP
@@ -2742,6 +3100,44 @@
: NUM_WIENERNS_CLASS_INIT_CHROMA;
#endif // CONFIG_WIENER_NONSEP
}
+#if CONFIG_FLEXIBLE_RU_SIZE
+ const int frame_width = cm->superres_upscaled_width;
+ const int frame_height = cm->superres_upscaled_height;
+ set_restoration_unit_size(frame_width, frame_height,
+ cm->seq_params.subsampling_x,
+ cm->seq_params.subsampling_y, cm->rst_info);
+ int size = cm->rst_info[0].max_restoration_unit_size;
+
+ cm->rst_info[0].restoration_unit_size =
+ cm->rst_info[0].max_restoration_unit_size;
+ if (!luma_none) {
+ if (aom_rb_read_bit(rb))
+ cm->rst_info[0].restoration_unit_size = size >> 1;
+ else {
+ if (aom_rb_read_bit(rb))
+ cm->rst_info[0].restoration_unit_size = size;
+ else
+ cm->rst_info[0].restoration_unit_size = size >> 2;
+ }
+ }
+ if (num_planes > 1) {
+ cm->rst_info[1].restoration_unit_size =
+ cm->rst_info[1].max_restoration_unit_size;
+ if (!chroma_none) {
+ size = cm->rst_info[1].max_restoration_unit_size;
+ if (aom_rb_read_bit(rb))
+ cm->rst_info[1].restoration_unit_size = size >> 1;
+ else {
+ if (aom_rb_read_bit(rb))
+ cm->rst_info[1].restoration_unit_size = size;
+ else
+ cm->rst_info[1].restoration_unit_size = size >> 2;
+ }
+ }
+ cm->rst_info[2].restoration_unit_size =
+ cm->rst_info[1].restoration_unit_size;
+ }
+#else
if (!all_none) {
#if CONFIG_BLOCK_256
assert(cm->sb_size == BLOCK_64X64 || cm->sb_size == BLOCK_128X128 ||
@@ -2796,6 +3192,7 @@
cm->rst_info[2].restoration_unit_size =
cm->rst_info[1].restoration_unit_size;
}
+#endif // CONFIG_FLEXIBLE_RU_SIZE
}
static AOM_INLINE void read_wiener_filter(MACROBLOCKD *xd, int wiener_win,
@@ -2803,11 +3200,11 @@
WienerInfoBank *bank,
aom_reader *rb) {
#if CONFIG_LR_MERGE_COEFFS
- const int exact_match =
- aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2, ACCT_STR);
+ const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2,
+ ACCT_INFO("exact_match"));
int k;
for (k = 0; k < bank->bank_size - 1; ++k) {
- if (aom_read_literal(rb, 1, ACCT_STR)) break;
+ if (aom_read_literal(rb, 1, ACCT_INFO("bank_size"))) break;
}
const int ref = k;
if (exact_match) {
@@ -2830,7 +3227,8 @@
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
WIENER_FILT_TAP0_SUBEXP_K,
- ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
+ ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV,
+ ACCT_INFO("vfilter[0]")) +
WIENER_FILT_TAP0_MINV;
else
wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] = 0;
@@ -2838,13 +3236,15 @@
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
WIENER_FILT_TAP1_SUBEXP_K,
- ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
+ ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV,
+ ACCT_INFO("vfilter[1]")) +
WIENER_FILT_TAP1_MINV;
wiener_info->vfilter[2] = wiener_info->vfilter[WIENER_WIN - 3] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
WIENER_FILT_TAP2_SUBEXP_K,
- ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
+ ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV,
+ ACCT_INFO("vfilter[2]")) +
WIENER_FILT_TAP2_MINV;
// The central element has an implicit +WIENER_FILT_STEP
wiener_info->vfilter[WIENER_HALFWIN] =
@@ -2856,7 +3256,8 @@
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
WIENER_FILT_TAP0_SUBEXP_K,
- ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
+ ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV,
+ ACCT_INFO("hfilter[0]")) +
WIENER_FILT_TAP0_MINV;
else
wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = 0;
@@ -2864,13 +3265,15 @@
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
WIENER_FILT_TAP1_SUBEXP_K,
- ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
+ ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV,
+ ACCT_INFO("hfilter[1]")) +
WIENER_FILT_TAP1_MINV;
wiener_info->hfilter[2] = wiener_info->hfilter[WIENER_WIN - 3] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
WIENER_FILT_TAP2_SUBEXP_K,
- ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
+ ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV,
+ ACCT_INFO("hfilter[2]")) +
WIENER_FILT_TAP2_MINV;
// The central element has an implicit +WIENER_FILT_STEP
wiener_info->hfilter[WIENER_HALFWIN] =
@@ -2884,11 +3287,11 @@
SgrprojInfoBank *bank,
aom_reader *rb) {
#if CONFIG_LR_MERGE_COEFFS
- const int exact_match =
- aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2, ACCT_STR);
+ const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2,
+ ACCT_INFO("exact_match"));
int k;
for (k = 0; k < bank->bank_size - 1; ++k) {
- if (aom_read_literal(rb, 1, ACCT_STR)) break;
+ if (aom_read_literal(rb, 1, ACCT_INFO("bank"))) break;
}
const int ref = k;
if (exact_match) {
@@ -2904,7 +3307,7 @@
#endif // CONFIG_LR_MERGE_COEFFS
SgrprojInfo *ref_sgrproj_info = av1_ref_from_sgrproj_bank(bank, ref);
- sgrproj_info->ep = aom_read_literal(rb, SGRPROJ_PARAMS_BITS, ACCT_STR);
+ sgrproj_info->ep = aom_read_literal(rb, SGRPROJ_PARAMS_BITS, ACCT_INFO("ep"));
const sgr_params_type *params = &av1_sgr_params[sgrproj_info->ep];
if (params->r[0] == 0) {
@@ -2912,13 +3315,13 @@
sgrproj_info->xqd[1] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
- ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
+ ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_INFO()) +
SGRPROJ_PRJ_MIN1;
} else if (params->r[1] == 0) {
sgrproj_info->xqd[0] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
- ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
+ ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_INFO()) +
SGRPROJ_PRJ_MIN0;
sgrproj_info->xqd[1] = clamp((1 << SGRPROJ_PRJ_BITS) - sgrproj_info->xqd[0],
SGRPROJ_PRJ_MIN1, SGRPROJ_PRJ_MAX1);
@@ -2926,12 +3329,12 @@
sgrproj_info->xqd[0] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
- ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
+ ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_INFO()) +
SGRPROJ_PRJ_MIN0;
sgrproj_info->xqd[1] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
- ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
+ ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_INFO()) +
SGRPROJ_PRJ_MIN1;
}
@@ -2948,11 +3351,11 @@
assert(num_classes <= WIENERNS_MAX_CLASSES);
#if CONFIG_LR_MERGE_COEFFS
for (int c_id = 0; c_id < num_classes; ++c_id) {
- const int exact_match =
- aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2, ACCT_STR);
+ const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf,
+ 2, ACCT_INFO("exact_match"));
int ref;
for (ref = 0; ref < bank->bank_size_for_class[c_id] - 1; ++ref) {
- if (aom_read_literal(rb, 1, ACCT_STR)) break;
+ if (aom_read_literal(rb, 1, ACCT_INFO("bank"))) break;
}
if (exact_match) {
copy_nsfilter_taps_for_class(
@@ -2967,7 +3370,12 @@
(void)xd;
#endif // CONFIG_LR_MERGE_COEFFS
const WienernsFilterParameters *nsfilter_params =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ get_wienerns_parameters(xd->current_base_qindex, is_uv,
+ wienerns_info->is_cross_filter);
+#else
get_wienerns_parameters(xd->current_base_qindex, is_uv);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
const int beg_feat = 0;
const int end_feat = nsfilter_params->ncoeffs;
const int(*wienerns_coeffs)[WIENERNS_COEFCFG_LEN] = nsfilter_params->coeffs;
@@ -2997,28 +3405,33 @@
const int rodd = is_uv ? 0 : (end_feat & 1);
for (int i = beg_feat; i < end_feat; ++i) {
if (rodd && i == end_feat - 5 && i != beg_feat) {
- reduce_step[0] = aom_read_symbol(
- rb, xd->tile_ctx->wienerns_reduce_cdf[0], 2, ACCT_STR);
+ reduce_step[0] =
+ aom_read_symbol(rb, xd->tile_ctx->wienerns_reduce_cdf[0], 2,
+ ACCT_INFO("wienerns_reduce_cdf0"));
if (reduce_step[0]) break;
}
if (!rodd && i == end_feat - 4 && i != beg_feat) {
- reduce_step[1] = aom_read_symbol(
- rb, xd->tile_ctx->wienerns_reduce_cdf[1], 2, ACCT_STR);
+ reduce_step[1] =
+ aom_read_symbol(rb, xd->tile_ctx->wienerns_reduce_cdf[1], 2,
+ ACCT_INFO("wienerns_reduce_cdf1"));
if (reduce_step[1]) break;
}
if (rodd && i == end_feat - 3 && i != beg_feat) {
- reduce_step[2] = aom_read_symbol(
- rb, xd->tile_ctx->wienerns_reduce_cdf[2], 2, ACCT_STR);
+ reduce_step[2] =
+ aom_read_symbol(rb, xd->tile_ctx->wienerns_reduce_cdf[2], 2,
+ ACCT_INFO("wienerns_reduce_cdf2"));
if (reduce_step[2]) break;
}
if (!rodd && i == end_feat - 2 && i != beg_feat) {
- reduce_step[3] = aom_read_symbol(
- rb, xd->tile_ctx->wienerns_reduce_cdf[3], 2, ACCT_STR);
+ reduce_step[3] =
+ aom_read_symbol(rb, xd->tile_ctx->wienerns_reduce_cdf[3], 2,
+ ACCT_INFO("wienerns_reduce_cdf3"));
if (reduce_step[3]) break;
}
if (rodd && i == end_feat - 1 && i != beg_feat) {
- reduce_step[4] = aom_read_symbol(
- rb, xd->tile_ctx->wienerns_reduce_cdf[4], 2, ACCT_STR);
+ reduce_step[4] =
+ aom_read_symbol(rb, xd->tile_ctx->wienerns_reduce_cdf[4], 2,
+ ACCT_INFO("wienerns_reduce_cdf4"));
if (reduce_step[4]) break;
}
#if ENABLE_LR_4PART_CODE
@@ -3029,7 +3442,8 @@
wienerns_coeffs[i - beg_feat][WIENERNS_MIN_ID],
xd->tile_ctx->wienerns_4part_cdf
[wienerns_coeffs[i - beg_feat][WIENERNS_PAR_ID]],
- wienerns_coeffs[i - beg_feat][WIENERNS_BIT_ID], ACCT_STR) +
+ wienerns_coeffs[i - beg_feat][WIENERNS_BIT_ID],
+ ACCT_INFO("wienerns_info_nsfilter")) +
wienerns_coeffs[i - beg_feat][WIENERNS_MIN_ID];
#else
wienerns_info_nsfilter[i] =
@@ -3038,7 +3452,7 @@
wienerns_coeffs[i - beg_feat][WIENERNS_PAR_ID],
ref_wienerns_info_nsfilter[i] -
wienerns_coeffs[i - beg_feat][WIENERNS_MIN_ID],
- ACCT_STR) +
+ ACCT_INFO("wienerns_info_nsfilter")) +
wienerns_coeffs[i - beg_feat][WIENERNS_MIN_ID];
#endif // ENABLE_LR_4PART_CODE
}
@@ -3048,17 +3462,39 @@
#endif // CONFIG_WIENER_NONSEP
static AOM_INLINE void loop_restoration_read_sb_coeffs(
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane,
+#else
const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane,
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
int runit_idx) {
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ RestorationInfo *rsi = &cm->rst_info[plane];
+#else
const RestorationInfo *rsi = &cm->rst_info[plane];
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
RestorationUnitInfo *rui = &rsi->unit_info[runit_idx];
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ assert(rsi->frame_restoration_type != RESTORE_NONE ||
+ rsi->frame_cross_restoration_type != RESTORE_NONE);
+ rui->restoration_type = RESTORE_NONE;
+ rui->cross_restoration_type = RESTORE_NONE;
+#else
assert(rsi->frame_restoration_type != RESTORE_NONE);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
assert(!cm->features.all_lossless);
const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN;
#if CONFIG_WIENER_NONSEP
rui->wienerns_info.num_classes = rsi->num_filter_classes;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ rui->wienerns_cross_info.num_classes =
+ xd->wienerns_cross_info[plane].filter[0].num_classes;
+
+ rui->wienerns_info.is_cross_filter = 0;
+ rui->wienerns_cross_info.is_cross_filter = 1;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#endif // CONFIG_WIENER_NONSEP
if (rsi->frame_restoration_type == RESTORE_SWITCHABLE) {
@@ -3067,16 +3503,17 @@
for (int re = 0; re <= cm->features.lr_last_switchable_ndx[plane]; re++) {
if (cm->features.lr_tools_disable_mask[plane] & (1 << re)) continue;
const int found = aom_read_symbol(
- r, xd->tile_ctx->switchable_flex_restore_cdf[re][plane], 2, ACCT_STR);
+ r, xd->tile_ctx->switchable_flex_restore_cdf[re][plane], 2,
+ ACCT_INFO("found"));
if (found) {
rui->restoration_type = re;
break;
}
}
#else
- rui->restoration_type =
- aom_read_symbol(r, xd->tile_ctx->switchable_restore_cdf,
- RESTORE_SWITCHABLE_TYPES, ACCT_STR);
+ rui->restoration_type = aom_read_symbol(
+ r, xd->tile_ctx->switchable_restore_cdf, RESTORE_SWITCHABLE_TYPES,
+ ACCT_INFO("restoration_type"));
#endif // CONFIG_LR_FLEX_SYNTAX
switch (rui->restoration_type) {
case RESTORE_WIENER:
@@ -3101,7 +3538,8 @@
default: assert(rui->restoration_type == RESTORE_NONE); break;
}
} else if (rsi->frame_restoration_type == RESTORE_WIENER) {
- if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2, ACCT_STR)) {
+ if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2,
+ ACCT_INFO("wiener_restore_cdf"))) {
rui->restoration_type = RESTORE_WIENER;
read_wiener_filter(xd, wiener_win, &rui->wiener_info,
&xd->wiener_info[plane], r);
@@ -3109,7 +3547,8 @@
rui->restoration_type = RESTORE_NONE;
}
} else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) {
- if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2, ACCT_STR)) {
+ if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2,
+ ACCT_INFO("sgrproj_restore_cdf"))) {
rui->restoration_type = RESTORE_SGRPROJ;
read_sgrproj_filter(xd, &rui->sgrproj_info, &xd->sgrproj_info[plane], r);
} else {
@@ -3117,7 +3556,8 @@
}
#if CONFIG_WIENER_NONSEP
} else if (rsi->frame_restoration_type == RESTORE_WIENER_NONSEP) {
- if (aom_read_symbol(r, xd->tile_ctx->wienerns_restore_cdf, 2, ACCT_STR)) {
+ if (aom_read_symbol(r, xd->tile_ctx->wienerns_restore_cdf, 2,
+ ACCT_INFO("wienerns_restore_cdf"))) {
rui->restoration_type = RESTORE_WIENER_NONSEP;
read_wienerns_filter(xd, plane != AOM_PLANE_Y, &rui->wienerns_info,
&xd->wienerns_info[plane], r);
@@ -3127,7 +3567,8 @@
#endif // CONFIG_WIENER_NONSEP
#if CONFIG_PC_WIENER
} else if (rsi->frame_restoration_type == RESTORE_PC_WIENER) {
- if (aom_read_symbol(r, xd->tile_ctx->pc_wiener_restore_cdf, 2, ACCT_STR)) {
+ if (aom_read_symbol(r, xd->tile_ctx->pc_wiener_restore_cdf, 2,
+ ACCT_INFO("pc_wiener_restore_cdf"))) {
rui->restoration_type = RESTORE_PC_WIENER;
// No side-information for now.
} else {
@@ -3135,6 +3576,18 @@
}
#endif // CONFIG_PC_WIENER
}
+
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsi->frame_cross_restoration_type == RESTORE_WIENER_NONSEP) {
+ if (aom_read_symbol(r, xd->tile_ctx->wienerns_restore_cdf, 2,
+ ACCT_INFO())) {
+ rui->cross_restoration_type = RESTORE_WIENER_NONSEP;
+ read_wienerns_filter(xd, plane != AOM_PLANE_Y, &rui->wienerns_cross_info,
+ &xd->wienerns_cross_info[plane], r);
+ }
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
#if CONFIG_LR_FLEX_SYNTAX
assert(((cm->features.lr_tools_disable_mask[plane] >> rui->restoration_type) &
1) == 0);
@@ -3790,6 +4243,11 @@
cdef_info->cdef_strengths[0] == 0 &&
cdef_info->cdef_uv_strengths[0] == 0;
const int no_restoration =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ rst_info[0].frame_cross_restoration_type == RESTORE_NONE &&
+ rst_info[1].frame_cross_restoration_type == RESTORE_NONE &&
+ rst_info[2].frame_cross_restoration_type == RESTORE_NONE &&
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
rst_info[0].frame_restoration_type == RESTORE_NONE &&
rst_info[1].frame_restoration_type == RESTORE_NONE &&
rst_info[2].frame_restoration_type == RESTORE_NONE;
@@ -4065,7 +4523,15 @@
for (int plane = 0; plane < num_planes; ++plane) {
dcb->dqcoeff_block[plane] = cb_buffer->dqcoeff[plane];
+#if CONFIG_INSPECTION
+ dcb->dqcoeff_block_copy[plane] = cb_buffer->dqcoeff_copy[plane];
+ dcb->qcoeff_block[plane] = cb_buffer->qcoeff[plane];
+ dcb->dequant_values[plane] = cb_buffer->dequant_values[plane];
+#endif // CONFIG_INSPECTION
dcb->eob_data[plane] = cb_buffer->eob_data[plane];
+#if CONFIG_ATC_DCTX_ALIGNED
+ dcb->bob_data[plane] = cb_buffer->bob_data[plane];
+#endif // CONFIG_ATC_DCTX_ALIGNED
dcb->cb_offset[plane] = 0;
dcb->txb_offset[plane] = 0;
}
@@ -4344,7 +4810,7 @@
av1_zero_left_context(xd);
#if CONFIG_REF_MV_BANK
av1_zero(xd->ref_mv_bank);
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
xd->ref_mv_bank_pt = &td->ref_mv_bank;
#endif
#endif // CONFIG_REF_MV_BANK
@@ -4366,9 +4832,9 @@
// for MV referencing during decoding the tile.
// xd->ref_mv_bank is updated as decoding goes.
xd->ref_mv_bank.rmb_sb_hits = 0;
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
td->ref_mv_bank = xd->ref_mv_bank;
-#endif // !CONFIG_C043_MVP_IMPROVEMENTS
+#endif // !CONFIG_MVP_IMPROVEMENT
#endif // CONFIG_REF_MV_BANK
#if CONFIG_WARP_REF_LIST
@@ -4865,7 +5331,7 @@
av1_zero_left_context(xd);
#if CONFIG_REF_MV_BANK
av1_zero(xd->ref_mv_bank);
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
xd->ref_mv_bank_pt = &td->ref_mv_bank;
#endif
#endif // CONFIG_REF_MV_BANK
@@ -4885,9 +5351,9 @@
#if CONFIG_REF_MV_BANK
xd->ref_mv_bank.rmb_sb_hits = 0;
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
td->ref_mv_bank = xd->ref_mv_bank;
-#endif // !CONFIG_C043_MVP_IMPROVEMENTS
+#endif // !CONFIG_MVP_IMPROVEMENT
#endif // CONFIG_REF_MV_BANK
#if CONFIG_WARP_REF_LIST
@@ -6003,7 +6469,7 @@
if (aom_rb_read_bit(rb)) {
seq_params->lr_tools_disable_mask[1] = DEF_UV_LR_TOOLS_DISABLE_MASK;
for (int i = 1; i < RESTORE_SWITCHABLE_TYPES; ++i) {
- if (DEF_UV_LR_TOOLS_DISABLE_MASK | (1 << i)) continue;
+ if (DEF_UV_LR_TOOLS_DISABLE_MASK & (1 << i)) continue;
seq_params->lr_tools_disable_mask[1] |= (aom_rb_read_bit(rb) << i);
}
} else {
@@ -6016,10 +6482,15 @@
void av1_read_sequence_header_beyond_av1(struct aom_read_bit_buffer *rb,
SequenceHeader *seq_params) {
+ // printf("print sps\n");
#if CONFIG_REF_MV_BANK
seq_params->enable_refmvbank = aom_rb_read_bit(rb);
#endif // CONFIG_REF_MV_BANK
seq_params->explicit_ref_frame_map = aom_rb_read_bit(rb);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // 0 : use show_existing_frame, 1: use implicit derivation
+ seq_params->enable_frame_output_order = aom_rb_read_bit(rb);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
// A bit is sent here to indicate if the max number of references is 7. If
// this bit is 0, then two more bits are sent to indicate the exact number
// of references allowed (range: 3 to 6).
@@ -6048,6 +6519,12 @@
#if CONFIG_BAWP
seq_params->enable_bawp = aom_rb_read_bit(rb);
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ seq_params->enable_cwp = aom_rb_read_bit(rb);
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ seq_params->enable_imp_msk_bld = aom_rb_read_bit(rb);
+#endif // CONFIG_D071_IMP_MSK_BLD
seq_params->enable_fsc = aom_rb_read_bit(rb);
#if CONFIG_CCSO
seq_params->enable_ccso = aom_rb_read_bit(rb);
@@ -6058,6 +6535,9 @@
#if CONFIG_ORIP
seq_params->enable_orip = aom_rb_read_bit(rb);
#endif
+#if CONFIG_IDIF
+ seq_params->enable_idif = aom_rb_read_bit(rb);
+#endif // CONFIG_IDIF
#if CONFIG_OPTFLOW_REFINEMENT
seq_params->enable_opfl_refine = seq_params->order_hint_info.enable_order_hint
? aom_rb_read_literal(rb, 2)
@@ -6067,6 +6547,10 @@
#if CONFIG_ADAPTIVE_MVD
seq_params->enable_adaptive_mvd = aom_rb_read_bit(rb);
#endif // CONFIG_ADAPTIVE_MVD
+
+#if CONFIG_REFINEMV
+ seq_params->enable_refinemv = aom_rb_read_bit(rb);
+#endif // CONFIG_REFINEMV
#if CONFIG_FLEX_MVRES
seq_params->enable_flex_mvres = aom_rb_read_bit(rb);
#endif // CONFIG_FLEX_MVRES
@@ -6081,6 +6565,13 @@
#if CONFIG_EXT_RECUR_PARTITIONS
seq_params->enable_ext_partitions = aom_rb_read_bit(rb);
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ if (seq_params->reduced_still_picture_hdr) {
+ seq_params->enable_global_motion = 0;
+ } else {
+ seq_params->enable_global_motion = aom_rb_read_bit(rb);
+ }
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
static int read_global_motion_params(WarpedMotionParams *params,
@@ -6088,16 +6579,27 @@
struct aom_read_bit_buffer *rb,
#if !CONFIG_FLEX_MVRES
int allow_hp) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ (void)allow_hp;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
#else
MvSubpelPrecision precision) {
const int precision_loss = get_gm_precision_loss(precision);
-#endif
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ (void)precision_loss;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+#endif // !CONFIG_FLEX_MVRES
TransformationType type = aom_rb_read_bit(rb);
if (type != IDENTITY) {
- if (aom_rb_read_bit(rb))
+ if (aom_rb_read_bit(rb)) {
type = ROTZOOM;
- else
+ } else {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ type = AFFINE;
+#else
type = aom_rb_read_bit(rb) ? TRANSLATION : AFFINE;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+ }
}
*params = default_warp_params;
@@ -6133,6 +6635,11 @@
}
if (type >= TRANSLATION) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ const int trans_dec_factor = GM_TRANS_DECODE_FACTOR;
+ const int trans_prec_diff = GM_TRANS_PREC_DIFF;
+ const int trans_max = GM_TRANS_MAX;
+#else
const int trans_bits = (type == TRANSLATION)
#if CONFIG_FLEX_MVRES
? GM_ABS_TRANS_ONLY_BITS - precision_loss
@@ -6155,13 +6662,15 @@
? GM_TRANS_ONLY_PREC_DIFF + !allow_hp
#endif
: GM_TRANS_PREC_DIFF;
+ const int trans_max = (1 << trans_bits);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
params->wmmat[0] = aom_rb_read_signed_primitive_refsubexpfin(
- rb, (1 << trans_bits) + 1, SUBEXPFIN_K,
+ rb, trans_max + 1, SUBEXPFIN_K,
(ref_params->wmmat[0] >> trans_prec_diff)) *
trans_dec_factor;
params->wmmat[1] = aom_rb_read_signed_primitive_refsubexpfin(
- rb, (1 << trans_bits) + 1, SUBEXPFIN_K,
+ rb, trans_max + 1, SUBEXPFIN_K,
(ref_params->wmmat[1] >> trans_prec_diff)) *
trans_dec_factor;
}
@@ -6179,10 +6688,86 @@
static AOM_INLINE void read_global_motion(AV1_COMMON *cm,
struct aom_read_bit_buffer *rb) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ int num_total_refs = cm->ref_frames_info.num_total_refs;
+ bool use_global_motion = false;
+ if (seq_params->enable_global_motion) {
+ use_global_motion = aom_rb_read_bit(rb);
+ }
+ if (!use_global_motion) {
+ for (int frame = 0; frame < INTER_REFS_PER_FRAME; ++frame) {
+ cm->global_motion[frame] = default_warp_params;
+ cm->cur_frame->global_motion[frame] = default_warp_params;
+ }
+ return;
+ }
+
+ int our_ref = aom_rb_read_primitive_quniform(rb, num_total_refs + 1);
+ if (our_ref == num_total_refs) {
+ // Special case: Use IDENTITY model
+ cm->base_global_motion_model = default_warp_params;
+ cm->base_global_motion_distance = 1;
+ } else {
+ RefCntBuffer *buf = get_ref_frame_buf(cm, our_ref);
+ assert(buf);
+ int their_num_refs = buf->num_ref_frames;
+ if (their_num_refs == 0) {
+ // Special case: if an intra/key frame is used as a ref, use an
+ // IDENTITY model
+ cm->base_global_motion_model = default_warp_params;
+ cm->base_global_motion_distance = 1;
+ } else {
+ int their_ref = aom_rb_read_primitive_quniform(rb, their_num_refs);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int our_ref_order_hint = buf->display_order_hint;
+ const int their_ref_order_hint = buf->ref_display_order_hint[their_ref];
+#else
+ const int our_ref_order_hint = buf->order_hint;
+ const int their_ref_order_hint = buf->ref_order_hints[their_ref];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->base_global_motion_model = buf->global_motion[their_ref];
+ cm->base_global_motion_distance =
+ get_relative_dist(&seq_params->order_hint_info, our_ref_order_hint,
+ their_ref_order_hint);
+ }
+ }
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
for (int frame = 0; frame < cm->ref_frames_info.num_total_refs; ++frame) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ int temporal_distance;
+ if (seq_params->order_hint_info.enable_order_hint) {
+ const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, frame);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = ref_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
+ const int ref_order_hint = ref_buf->order_hint;
+ const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ temporal_distance = get_relative_dist(&seq_params->order_hint_info,
+ cur_order_hint, ref_order_hint);
+ } else {
+ temporal_distance = 1;
+ }
+
+ if (temporal_distance == 0) {
+ // Don't code global motion for frames at the same temporal instant
+ cm->global_motion[frame] = default_warp_params;
+ continue;
+ }
+
+ WarpedMotionParams ref_params_;
+ av1_scale_warp_model(&cm->base_global_motion_model,
+ cm->base_global_motion_distance, &ref_params_,
+ temporal_distance);
+ WarpedMotionParams *ref_params = &ref_params_;
+#else
const WarpedMotionParams *ref_params =
cm->prev_frame ? &cm->prev_frame->global_motion[frame]
: &default_warp_params;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
int good_params =
#if !CONFIG_FLEX_MVRES
read_global_motion_params(&cm->global_motion[frame], ref_params, rb,
@@ -6291,6 +6876,10 @@
continue;
}
frame_bufs[i].order_hint = 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ frame_bufs[i].display_order_hint = 0;
+ av1_zero(frame_bufs[i].ref_display_order_hint);
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
av1_zero(frame_bufs[i].ref_order_hints);
}
av1_zero_unused_internal_frame_buffers(&cm->buffer_pool->int_frame_buffers);
@@ -6336,6 +6925,33 @@
return cur_disp_order_hint;
}
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+static INLINE int get_ref_frame_disp_order_hint(AV1_COMMON *const cm,
+ const RefCntBuffer *const buf) {
+ // Find the reference frame with the largest order_hint
+ int max_disp_order_hint = 0;
+ for (int map_idx = 0; map_idx < INTER_REFS_PER_FRAME; map_idx++) {
+ if ((int)buf->ref_display_order_hint[map_idx] > max_disp_order_hint)
+ max_disp_order_hint = buf->ref_display_order_hint[map_idx];
+ }
+
+ // If the order_hint is above the threshold distance of 35 frames (largest
+ // possible lag_in_frames) from the found reference frame, we assume it was
+ // modified using:
+ // order_hint = display_order_hint % display_order_hint_factor
+ // Here, the actual display_order_hint is recovered.
+ const int display_order_hint_factor =
+ 1 << (cm->seq_params.order_hint_info.order_hint_bits_minus_1 + 1);
+ int disp_order_hint = buf->order_hint;
+ while (abs(max_disp_order_hint - disp_order_hint) > 35) {
+ if (disp_order_hint > max_disp_order_hint) return disp_order_hint;
+
+ disp_order_hint += display_order_hint_factor;
+ }
+ return disp_order_hint;
+}
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+
// On success, returns 0. On failure, calls aom_internal_error and does not
// return.
static int read_uncompressed_header(AV1Decoder *pbi,
@@ -6507,11 +7123,7 @@
}
}
features->disable_cdf_update = aom_rb_read_bit(rb);
-#if DS_FRAME_LEVEL
- if (current_frame->frame_type == KEY_FRAME) {
- features->ds_filter_type = aom_rb_read_literal(rb, 2);
- }
-#endif // DS_FRAME_LEVEL
+
if (seq_params->force_screen_content_tools == 2) {
features->allow_screen_content_tools = aom_rb_read_bit(rb);
} else {
@@ -6707,7 +7319,11 @@
buf->order_hint = order_hint;
// TODO(kslu) This is a workaround for error resilient mode. Make
// it more consistent with get_disp_order_hint().
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ buf->display_order_hint = get_ref_frame_disp_order_hint(cm, buf);
+#else
buf->display_order_hint = order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
}
}
}
@@ -6736,17 +7352,21 @@
features->allow_global_intrabc = aom_rb_read_bit(rb);
features->allow_local_intrabc =
features->allow_global_intrabc ? aom_rb_read_bit(rb) : 1;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
features->max_drl_bits =
aom_rb_read_primitive_quniform(
rb, MAX_MAX_DRL_BITS - MIN_MAX_DRL_BITS + 1) +
MIN_MAX_DRL_BITS;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#endif // CONFIG_IBC_SR_EXT
features->allow_ref_frame_mvs = 0;
cm->prev_frame = NULL;
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = 0;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
} else {
features->allow_ref_frame_mvs = 0;
#if CONFIG_TIP
@@ -6763,15 +7383,19 @@
features->allow_global_intrabc = aom_rb_read_bit(rb);
features->allow_local_intrabc =
features->allow_global_intrabc ? aom_rb_read_bit(rb) : 1;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
features->max_drl_bits =
aom_rb_read_primitive_quniform(
rb, MAX_MAX_DRL_BITS - MIN_MAX_DRL_BITS + 1) +
MIN_MAX_DRL_BITS;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#endif // CONFIG_IBC_SR_EXT
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = 0;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
} else if (pbi->need_resync != 1) { /* Skip if need resync */
// Implicitly derive the reference mapping
RefFrameMapPair ref_frame_map_pairs[REF_FRAMES];
@@ -6852,6 +7476,9 @@
}
av1_get_past_future_cur_ref_lists(cm, scores);
}
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = cm->ref_frames_info.num_total_refs;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
if (!features->error_resilient_mode && frame_size_override_flag) {
setup_frame_size_with_refs(cm, rb);
@@ -6975,7 +7602,7 @@
if (!(current_frame->frame_type == INTRA_ONLY_FRAME) &&
pbi->need_resync != 1) {
- for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
+ for (int i = 0; i < cm->ref_frames_info.num_total_refs; ++i) {
const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, i);
if (!ref_buf) continue;
struct scale_factors *const ref_scale_factors =
@@ -7066,6 +7693,11 @@
cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[0].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[1].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[2].frame_cross_restoration_type = RESTORE_NONE;
+#endif
}
#if CONFIG_TIP
@@ -7182,6 +7814,11 @@
cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[0].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[1].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[2].frame_cross_restoration_type = RESTORE_NONE;
+#endif
}
setup_loopfilter(cm, rb);
@@ -7225,6 +7862,21 @@
features->enable_bawp = 0;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ features->enable_cwp = seq_params->enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ features->allow_warpmv_mode = 0;
+ if (!frame_is_intra_only(cm) &&
+ (features->enabled_motion_modes & (1 << WARP_DELTA)) != 0) {
+ features->allow_warpmv_mode = aom_rb_read_bit(rb);
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+#if CONFIG_D071_IMP_MSK_BLD
+ features->enable_imp_msk_bld = seq_params->enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
+
features->reduced_tx_set_used = aom_rb_read_bit(rb);
if (features->allow_ref_frame_mvs && !frame_might_allow_ref_frame_mvs(cm)) {
@@ -7385,10 +8037,10 @@
cm->mi_params.setup_mi(&cm->mi_params);
if (cm->features.allow_ref_frame_mvs) av1_setup_motion_field(cm);
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
else
av1_setup_ref_frame_sides(cm);
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_PEF
if (cm->seq_params.enable_pef && cm->features.allow_pef) {
@@ -7426,7 +8078,13 @@
if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
- cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
+ cm->rst_info[2].frame_restoration_type != RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ || cm->rst_info[0].frame_cross_restoration_type != RESTORE_NONE ||
+ cm->rst_info[1].frame_cross_restoration_type != RESTORE_NONE ||
+ cm->rst_info[2].frame_cross_restoration_type != RESTORE_NONE
+#endif
+ ) {
av1_alloc_restoration_buffers(cm);
}
const int buf_size = MC_TEMP_BUF_PELS << 1;
@@ -7450,7 +8108,16 @@
#if CONFIG_LPF_MASK
av1_loop_filter_frame_init(cm, 0, num_planes);
#endif
-
+#if CONFIG_INSPECTION
+ aom_realloc_frame_buffer(
+ &cm->predicted_pixels, cm->width, cm->height,
+ cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
+ AOM_DEC_BORDER_IN_PIXELS, cm->features.byte_alignment, NULL, NULL, NULL);
+ aom_realloc_frame_buffer(
+ &cm->prefiltered_pixels, cm->width, cm->height,
+ cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
+ AOM_DEC_BORDER_IN_PIXELS, cm->features.byte_alignment, NULL, NULL, NULL);
+#endif // CONFIG_INSPECTION
if (pbi->max_threads > 1 && !(tiles->large_scale && !pbi->ext_tile_debug) &&
pbi->row_mt)
*p_data_end =
@@ -7466,6 +8133,11 @@
set_planes_to_neutral_grey(&cm->seq_params, xd->cur_buf, 1);
}
+#if CONFIG_INSPECTION
+ memcpy(cm->prefiltered_pixels.buffer_alloc, cm->cur_frame->buf.buffer_alloc,
+ cm->prefiltered_pixels.frame_size);
+#endif // CONFIG_INSPECTION
+
if (end_tile != tiles->rows * tiles->cols - 1) {
return;
}
@@ -7539,6 +8211,11 @@
#endif
const int do_loop_restoration =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[0].frame_cross_restoration_type != RESTORE_NONE ||
+ cm->rst_info[1].frame_cross_restoration_type != RESTORE_NONE ||
+ cm->rst_info[2].frame_cross_restoration_type != RESTORE_NONE ||
+#endif
cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
cm->rst_info[2].frame_restoration_type != RESTORE_NONE;
@@ -7633,7 +8310,7 @@
if (pbi->inspect_cb != NULL) {
(*pbi->inspect_cb)(pbi, pbi->inspect_ctx);
}
-#endif
+#endif // CONFIG_INSPECTION
// Non frame parallel update frame context here.
if (!tiles->large_scale) {
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 7467a62..6c8ce50 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -17,6 +17,9 @@
#include "av1/common/cdef_block.h"
#include "av1/common/cfl.h"
#include "av1/common/common.h"
+#if CONFIG_ATC_DCTX_ALIGNED
+#include "av1/common/txb_common.h"
+#endif // CONFIG_ATC_DCTX_ALIGNED
#include "av1/common/entropy.h"
#include "av1/common/entropymode.h"
#include "av1/common/entropymv.h"
@@ -32,13 +35,11 @@
#include "aom_dsp/aom_dsp_common.h"
-#define ACCT_STR __func__
-
#define DEC_MISMATCH_DEBUG 0
#if !CONFIG_AIMC
static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
- return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR);
+ return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_INFO());
}
#endif // !CONFIG_AIMC
@@ -83,8 +84,8 @@
get_mi_grid_idx(mi_params, xd->mi_row & first_block_mask,
xd->mi_col & first_block_mask);
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);
+ mbmi->cdef_strength = aom_read_literal(r, cm->cdef_info.cdef_bits,
+ ACCT_INFO("cdef_strength"));
xd->cdef_transmitted[index] = true;
}
}
@@ -105,7 +106,7 @@
if (!(mi_row & blk_size_y) && !(mi_col & blk_size_x) &&
cm->ccso_info.ccso_enable[0]) {
const int blk_idc =
- aom_read_symbol(r, xd->tile_ctx->ccso_cdf[0], 2, ACCT_STR);
+ aom_read_symbol(r, xd->tile_ctx->ccso_cdf[0], 2, ACCT_INFO("blk_idc"));
xd->ccso_blk_y = blk_idc;
mi_params
->mi_grid_base[(mi_row & ~blk_size_y) * mi_params->mi_stride +
@@ -118,10 +119,10 @@
#if CONFIG_CCSO_EXT
cm->ccso_info.ccso_enable[1]) {
const int blk_idc =
- aom_read_symbol(r, xd->tile_ctx->ccso_cdf[1], 2, ACCT_STR);
+ aom_read_symbol(r, xd->tile_ctx->ccso_cdf[1], 2, ACCT_INFO("blk_idc"));
#else
cm->ccso_info.ccso_enable[0]) {
- const int blk_idc = aom_read_bit(r, ACCT_STR);
+ const int blk_idc = aom_read_bit(r, ACCT_INFO("blk_idc"));
#endif
xd->ccso_blk_u = blk_idc;
mi_params
@@ -134,10 +135,10 @@
#if CONFIG_CCSO_EXT
cm->ccso_info.ccso_enable[2]) {
const int blk_idc =
- aom_read_symbol(r, xd->tile_ctx->ccso_cdf[2], 2, ACCT_STR);
+ aom_read_symbol(r, xd->tile_ctx->ccso_cdf[2], 2, ACCT_INFO("blk_idc"));
#else
cm->ccso_info.ccso_enable[1]) {
- const int blk_idc = aom_read_bit(r, ACCT_STR);
+ const int blk_idc = aom_read_bit(r, ACCT_INFO("blk_idc"));
#endif
xd->ccso_blk_v = blk_idc;
mi_params
@@ -159,17 +160,18 @@
if ((bsize != cm->sb_size ||
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] == 0) &&
read_delta_q_flag) {
- abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
+ abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1,
+ ACCT_INFO("abs"));
const int smallval = (abs < DELTA_Q_SMALL);
if (!smallval) {
- const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
+ const int rem_bits = aom_read_literal(r, 3, ACCT_INFO("rem_bits")) + 1;
const int thr = (1 << rem_bits) + 1;
- abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
+ abs = aom_read_literal(r, rem_bits, ACCT_INFO("abs")) + thr;
}
if (abs) {
- sign = aom_read_bit(r, ACCT_STR);
+ sign = aom_read_bit(r, ACCT_INFO("sign"));
} else {
sign = 1;
}
@@ -190,34 +192,47 @@
const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
if ((bsize != cm->sb_size || mbmi->skip_txfm[plane_type] == 0) &&
read_delta_lf_flag) {
- int abs = aom_read_symbol(r, cdf, DELTA_LF_PROBS + 1, ACCT_STR);
+ int abs = aom_read_symbol(r, cdf, DELTA_LF_PROBS + 1, ACCT_INFO("abs"));
const int smallval = (abs < DELTA_LF_SMALL);
if (!smallval) {
- const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
+ const int rem_bits = aom_read_literal(r, 3, ACCT_INFO("rem_bits")) + 1;
const int thr = (1 << rem_bits) + 1;
- abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
+ abs = aom_read_literal(r, rem_bits, ACCT_INFO("abs")) + thr;
}
- const int sign = abs ? aom_read_bit(r, ACCT_STR) : 1;
+ const int sign = abs ? aom_read_bit(r, ACCT_INFO("sign")) : 1;
reduced_delta_lflevel = sign ? -abs : abs;
}
return reduced_delta_lflevel;
}
-static uint8_t read_mrl_index(FRAME_CONTEXT *ec_ctx, aom_reader *r) {
+static uint8_t read_mrl_index(FRAME_CONTEXT *ec_ctx, aom_reader *r
+#if CONFIG_EXT_DIR
+ ,
+ const MB_MODE_INFO *neighbor0,
+ const MB_MODE_INFO *neighbor1
+#endif // CONFIG_EXT_DIR
+) {
+#if CONFIG_EXT_DIR
+ int ctx = get_mrl_index_ctx(neighbor0, neighbor1);
+ aom_cdf_prob *mrl_cdf = ec_ctx->mrl_index_cdf[ctx];
const uint8_t mrl_index =
- aom_read_symbol(r, ec_ctx->mrl_index_cdf, MRL_LINE_NUMBER, ACCT_STR);
+ aom_read_symbol(r, mrl_cdf, MRL_LINE_NUMBER, ACCT_INFO());
+#else
+ const uint8_t mrl_index =
+ aom_read_symbol(r, ec_ctx->mrl_index_cdf, MRL_LINE_NUMBER, ACCT_INFO());
+#endif // CONFIG_EXT_DIR
return mrl_index;
}
static uint8_t read_fsc_mode(aom_reader *r, aom_cdf_prob *fsc_cdf) {
- const uint8_t fsc_mode = aom_read_symbol(r, fsc_cdf, FSC_MODES, ACCT_STR);
+ const uint8_t fsc_mode = aom_read_symbol(r, fsc_cdf, FSC_MODES, ACCT_INFO());
return fsc_mode;
}
#if CONFIG_IMPROVED_CFL
static uint8_t read_cfl_index(FRAME_CONTEXT *ec_ctx, aom_reader *r) {
uint8_t cfl_index =
- aom_read_symbol(r, ec_ctx->cfl_index_cdf, CFL_TYPE_COUNT, ACCT_STR);
+ aom_read_symbol(r, ec_ctx->cfl_index_cdf, CFL_TYPE_COUNT, ACCT_INFO());
return cfl_index;
}
#endif
@@ -229,25 +244,27 @@
PREDICTION_MODE y_mode) {
const UV_PREDICTION_MODE uv_mode =
aom_read_symbol(r, ec_ctx->uv_mode_cdf[cfl_allowed][y_mode],
- UV_INTRA_MODES - !cfl_allowed, ACCT_STR);
+ UV_INTRA_MODES - !cfl_allowed, ACCT_INFO());
return uv_mode;
}
#endif // !CONFIG_AIMC
static uint8_t read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r,
int8_t *signs_out) {
- const int8_t joint_sign =
- aom_read_symbol(r, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS, "cfl:signs");
+ const int8_t joint_sign = aom_read_symbol(
+ r, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS, ACCT_INFO("cfl:signs"));
uint8_t idx = 0;
// Magnitudes are only coded for nonzero values
if (CFL_SIGN_U(joint_sign) != CFL_SIGN_ZERO) {
aom_cdf_prob *cdf_u = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_U(joint_sign)];
- idx = (uint8_t)aom_read_symbol(r, cdf_u, CFL_ALPHABET_SIZE, "cfl:alpha_u")
+ idx = (uint8_t)aom_read_symbol(r, cdf_u, CFL_ALPHABET_SIZE,
+ ACCT_INFO("cfl:alpha_u"))
<< CFL_ALPHABET_SIZE_LOG2;
}
if (CFL_SIGN_V(joint_sign) != CFL_SIGN_ZERO) {
aom_cdf_prob *cdf_v = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_V(joint_sign)];
- idx += (uint8_t)aom_read_symbol(r, cdf_v, CFL_ALPHABET_SIZE, "cfl:alpha_v");
+ idx += (uint8_t)aom_read_symbol(r, cdf_v, CFL_ALPHABET_SIZE,
+ ACCT_INFO("cfl:alpha_v"));
}
*signs_out = joint_sign;
return idx;
@@ -257,7 +274,7 @@
int size_group) {
const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol(
r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES,
- ACCT_STR);
+ ACCT_INFO());
return ii_mode;
}
@@ -277,8 +294,9 @@
int is_warpmv = 0;
if (is_warpmv_mode_allowed(cm, mbmi, bsize)) {
const int16_t iswarpmvmode_ctx = inter_warpmv_mode_ctx(cm, xd, mbmi);
- is_warpmv = aom_read_symbol(
- r, ec_ctx->inter_warp_mode_cdf[iswarpmvmode_ctx], 2, ACCT_STR);
+ is_warpmv =
+ aom_read_symbol(r, ec_ctx->inter_warp_mode_cdf[iswarpmvmode_ctx], 2,
+ ACCT_INFO("is_warpmv"));
if (is_warpmv) {
return WARPMV;
}
@@ -287,7 +305,7 @@
return SINGLE_INTER_MODE_START +
aom_read_symbol(r, ec_ctx->inter_single_mode_cdf[ismode_ctx],
- INTER_SINGLE_MODES, ACCT_STR);
+ INTER_SINGLE_MODES, ACCT_INFO("inter_single_mode"));
}
static void read_drl_idx(int max_drl_bits, const int16_t mode_ctx,
@@ -295,50 +313,87 @@
MB_MODE_INFO *mbmi, aom_reader *r) {
MACROBLOCKD *const xd = &dcb->xd;
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
+ assert(!mbmi->skip_mode);
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+ // if (has_second_drl(mbmi))
+ if (has_second_drl(mbmi)) {
+ if (mbmi->mode == NEAR_NEWMV)
+ max_drl_bits = AOMMIN(max_drl_bits, SEP_COMP_DRL_SIZE);
+ else
+ assert(mbmi->mode == NEAR_NEARMV);
+ }
+ for (int ref = 0; ref < 1 + has_second_drl(mbmi); ref++) {
+ for (int idx = 0; idx < max_drl_bits; ++idx) {
+ const uint16_t *weight = has_second_drl(mbmi)
+ ? xd->weight[mbmi->ref_frame[ref]]
+ : xd->weight[ref_frame_type];
+ aom_cdf_prob *drl_cdf =
+#if CONFIG_SKIP_MODE_ENHANCEMENT
+ mbmi->skip_mode ? ec_ctx->skip_drl_cdf[AOMMIN(idx, 2)]
+ : av1_get_drl_cdf(ec_ctx, weight, mode_ctx, idx);
+#else
+ av1_get_drl_cdf(ec_ctx, xd->weight[ref_frame_type], mode_ctx, idx);
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+ int drl_idx = aom_read_symbol(r, drl_cdf, 2, ACCT_INFO("drl_idx"));
+ mbmi->ref_mv_idx[ref] = idx + drl_idx;
+ if (!drl_idx) break;
+ }
+ assert(mbmi->ref_mv_idx[ref] < max_drl_bits + 1);
+ }
+#else
mbmi->ref_mv_idx = 0;
#if !CONFIG_SKIP_MODE_ENHANCEMENT
assert(!mbmi->skip_mode);
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf =
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
mbmi->skip_mode ? ec_ctx->skip_drl_cdf[AOMMIN(idx, 2)]
: av1_get_drl_cdf(ec_ctx, xd->weight[ref_frame_type],
mode_ctx, idx);
#else
av1_get_drl_cdf(ec_ctx, xd->weight[ref_frame_type], mode_ctx, idx);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
- int drl_idx = aom_read_symbol(r, drl_cdf, 2, ACCT_STR);
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+ int drl_idx = aom_read_symbol(r, drl_cdf, 2, ACCT_INFO("drl_idx"));
mbmi->ref_mv_idx = idx + drl_idx;
if (!drl_idx) break;
}
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
+#endif // CONFIG_SEP_COMP_DRL
}
#if CONFIG_WEDGE_MOD_EXT
static int8_t read_wedge_mode(aom_reader *r, FRAME_CONTEXT *ec_ctx,
const BLOCK_SIZE bsize) {
- int wedge_angle_dir =
- aom_read_symbol(r, ec_ctx->wedge_angle_dir_cdf[bsize], 2, ACCT_STR);
+ int wedge_angle_dir = aom_read_symbol(r, ec_ctx->wedge_angle_dir_cdf[bsize],
+ 2, ACCT_INFO("wedge_angle_dir"));
int wedge_angle = WEDGE_ANGLES;
if (wedge_angle_dir == 0) {
- wedge_angle = aom_read_symbol(r, ec_ctx->wedge_angle_0_cdf[bsize],
- H_WEDGE_ANGLES, ACCT_STR);
+ wedge_angle =
+ aom_read_symbol(r, ec_ctx->wedge_angle_0_cdf[bsize], H_WEDGE_ANGLES,
+ ACCT_INFO("wedge_angle", "wedge_angle_0_cdf"));
} else {
wedge_angle =
- H_WEDGE_ANGLES + aom_read_symbol(r, ec_ctx->wedge_angle_1_cdf[bsize],
- H_WEDGE_ANGLES, ACCT_STR);
+ H_WEDGE_ANGLES +
+ aom_read_symbol(r, ec_ctx->wedge_angle_1_cdf[bsize], H_WEDGE_ANGLES,
+ ACCT_INFO("wedge_angle", "wedge_angle_1_cdf"));
}
int wedge_dist = 0;
if ((wedge_angle >= H_WEDGE_ANGLES) ||
(wedge_angle == WEDGE_90 || wedge_angle == WEDGE_180)) {
- wedge_dist = aom_read_symbol(r, ec_ctx->wedge_dist_cdf2[bsize],
- NUM_WEDGE_DIST - 1, ACCT_STR) +
- 1;
+ wedge_dist =
+ aom_read_symbol(r, ec_ctx->wedge_dist_cdf2[bsize], NUM_WEDGE_DIST - 1,
+ ACCT_INFO("wedge_dist", "wedge_dist_cdf2")) +
+ 1;
} else {
assert(wedge_angle < H_WEDGE_ANGLES);
- wedge_dist = aom_read_symbol(r, ec_ctx->wedge_dist_cdf[bsize],
- NUM_WEDGE_DIST, ACCT_STR);
+ wedge_dist =
+ aom_read_symbol(r, ec_ctx->wedge_dist_cdf[bsize], NUM_WEDGE_DIST,
+ ACCT_INFO("wedge_dist", "wedge_dist_cdf"));
}
return wedge_angle_dist_2_index[wedge_angle][wedge_dist];
}
@@ -356,11 +411,22 @@
int max_idx_bits = mbmi->max_num_warp_candidates - 1;
for (int bit_idx = 0; bit_idx < max_idx_bits; ++bit_idx) {
aom_cdf_prob *warp_ref_idx_cdf = av1_get_warp_ref_idx_cdf(ec_ctx, bit_idx);
- int warp_idx = aom_read_symbol(r, warp_ref_idx_cdf, 2, ACCT_STR);
+ int warp_idx =
+ aom_read_symbol(r, warp_ref_idx_cdf, 2, ACCT_INFO("warp_idx"));
mbmi->warp_ref_idx = bit_idx + warp_idx;
if (!warp_idx) break;
}
}
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+static void read_warpmv_with_mvd_flag(FRAME_CONTEXT *ec_ctx, MB_MODE_INFO *mbmi,
+ aom_reader *r) {
+ mbmi->warpmv_with_mvd_flag = aom_read_symbol(
+ r, ec_ctx->warpmv_with_mvd_flag_cdf[mbmi->sb_type[PLANE_TYPE_Y]], 2,
+ ACCT_INFO("warpmv_with_mvd_flag"));
+}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#endif // CONFIG_WARP_REF_LIST
// Read the delta for a single warp parameter
// Each delta is coded as a symbol in the range
@@ -372,7 +438,7 @@
int coded_value =
aom_read_symbol(r, xd->tile_ctx->warp_delta_param_cdf[index_type],
- WARP_DELTA_NUM_SYMBOLS, ACCT_STR);
+ WARP_DELTA_NUM_SYMBOLS, ACCT_INFO());
return (coded_value - WARP_DELTA_CODED_MAX) * WARP_DELTA_STEP;
}
@@ -414,7 +480,11 @@
// TODO(rachelbarker): Allow signaling warp type?
#if CONFIG_WARP_REF_LIST
- if (allow_warp_parameter_signaling(mbmi)) {
+ if (allow_warp_parameter_signaling(
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ cm,
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi)) {
#endif // CONFIG_WARP_REF_LIST
params->wmtype = ROTZOOM;
params->wmmat[2] = base_params.wmmat[2] + read_warp_delta_param(xd, 2, r);
@@ -455,8 +525,9 @@
#if CONFIG_WARPMV
if (mbmi->mode == WARPMV) {
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
- int use_warped_causal = aom_read_symbol(
- r, xd->tile_ctx->warped_causal_warpmv_cdf[bsize], 2, ACCT_STR);
+ int use_warped_causal =
+ aom_read_symbol(r, xd->tile_ctx->warped_causal_warpmv_cdf[bsize], 2,
+ ACCT_INFO("use_warped_causal"));
return use_warped_causal ? WARPED_CAUSAL : WARP_DELTA;
}
return WARP_DELTA;
@@ -466,8 +537,9 @@
mbmi->use_wedge_interintra = 0;
if (allowed_motion_modes & (1 << INTERINTRA)) {
const int bsize_group = size_group_lookup[bsize];
- const int use_interintra = aom_read_symbol(
- r, xd->tile_ctx->interintra_cdf[bsize_group], 2, ACCT_STR);
+ const int use_interintra =
+ aom_read_symbol(r, xd->tile_ctx->interintra_cdf[bsize_group], 2,
+ ACCT_INFO("use_interintra"));
assert(mbmi->ref_frame[1] == NONE_FRAME);
if (use_interintra) {
const INTERINTRA_MODE interintra_mode =
@@ -478,8 +550,9 @@
mbmi->angle_delta[PLANE_TYPE_UV] = 0;
mbmi->filter_intra_mode_info.use_filter_intra = 0;
if (av1_is_wedge_used(bsize)) {
- mbmi->use_wedge_interintra = aom_read_symbol(
- r, xd->tile_ctx->wedge_interintra_cdf[bsize], 2, ACCT_STR);
+ mbmi->use_wedge_interintra =
+ aom_read_symbol(r, xd->tile_ctx->wedge_interintra_cdf[bsize], 2,
+ ACCT_INFO("use_wedge_interintra"));
if (mbmi->use_wedge_interintra) {
#if CONFIG_WEDGE_MOD_EXT
mbmi->interintra_wedge_index =
@@ -487,7 +560,8 @@
assert(mbmi->interintra_wedge_index != -1);
#else
mbmi->interintra_wedge_index = (int8_t)aom_read_symbol(
- r, xd->tile_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR);
+ r, xd->tile_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES,
+ ACCT_INFO("interintra_wedge_index"));
#endif
}
}
@@ -496,8 +570,8 @@
}
if (allowed_motion_modes & (1 << OBMC_CAUSAL)) {
- int use_obmc =
- aom_read_symbol(r, xd->tile_ctx->obmc_cdf[bsize], 2, ACCT_STR);
+ int use_obmc = aom_read_symbol(r, xd->tile_ctx->obmc_cdf[bsize], 2,
+ ACCT_INFO("use_obmc"));
if (use_obmc) {
return OBMC_CAUSAL;
}
@@ -506,8 +580,9 @@
if (allowed_motion_modes & (1 << WARP_EXTEND)) {
const int ctx1 = av1_get_warp_extend_ctx1(xd, mbmi);
const int ctx2 = av1_get_warp_extend_ctx2(xd, mbmi);
- int use_warp_extend = aom_read_symbol(
- r, xd->tile_ctx->warp_extend_cdf[ctx1][ctx2], 2, ACCT_STR);
+ int use_warp_extend =
+ aom_read_symbol(r, xd->tile_ctx->warp_extend_cdf[ctx1][ctx2], 2,
+ ACCT_INFO("use_warp_extend"));
if (use_warp_extend) {
return WARP_EXTEND;
}
@@ -515,15 +590,16 @@
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
int use_warped_causal =
- aom_read_symbol(r, xd->tile_ctx->warped_causal_cdf[bsize], 2, ACCT_STR);
+ aom_read_symbol(r, xd->tile_ctx->warped_causal_cdf[bsize], 2,
+ ACCT_INFO("use_warped_causal"));
if (use_warped_causal) {
return WARPED_CAUSAL;
}
}
if (allowed_motion_modes & (1 << WARP_DELTA)) {
- int use_warp_delta =
- aom_read_symbol(r, xd->tile_ctx->warp_delta_cdf[bsize], 2, ACCT_STR);
+ int use_warp_delta = aom_read_symbol(r, xd->tile_ctx->warp_delta_cdf[bsize],
+ 2, ACCT_INFO("use_warp_delta"));
if (use_warp_delta) {
mbmi->motion_mode = WARP_DELTA;
#if !CONFIG_WARPMV
@@ -569,13 +645,14 @@
if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
if (last_motion_mode_allowed == OBMC_CAUSAL) {
- motion_mode = aom_read_symbol(
- r, xd->tile_ctx->obmc_cdf[mbmi->sb_type[PLANE_TYPE_Y]], 2, ACCT_STR);
+ motion_mode =
+ aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type[PLANE_TYPE_Y]],
+ 2, ACCT_INFO("motion_mode", "obmc_cdf"));
return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
} else {
motion_mode = aom_read_symbol(
r, xd->tile_ctx->motion_mode_cdf[mbmi->sb_type[PLANE_TYPE_Y]],
- MOTION_MODES, ACCT_STR);
+ MOTION_MODES, ACCT_INFO("motion_mode", "motion_mode_cdf"));
return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
}
}
@@ -593,17 +670,38 @@
: xd->tile_ctx->jmvd_scale_mode_cdf;
const int jmvd_scale_cnt = is_joint_amvd_mode ? JOINT_AMVD_SCALE_FACTOR_CNT
: JOINT_NEWMV_SCALE_FACTOR_CNT;
- const int jmvd_scale_mode =
- aom_read_symbol(r, jmvd_scale_mode_cdf, jmvd_scale_cnt, ACCT_STR);
+ const int jmvd_scale_mode = aom_read_symbol(
+ r, jmvd_scale_mode_cdf, jmvd_scale_cnt, ACCT_INFO("jmvd_scale_mode"));
#else
- const int jmvd_scale_mode =
- aom_read_symbol(r, xd->tile_ctx->jmvd_scale_mode_cdf,
- JOINT_NEWMV_SCALE_FACTOR_CNT, ACCT_STR);
+ const int jmvd_scale_mode = aom_read_symbol(
+ r, xd->tile_ctx->jmvd_scale_mode_cdf, JOINT_NEWMV_SCALE_FACTOR_CNT,
+ ACCT_INFO("jmvd_scale_mode"));
#endif // CONFIG_ADAPTIVE_MVD
return jmvd_scale_mode;
}
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
+#if CONFIG_CWP
+// Read index for the weighting factor of compound weighted prediction
+static int read_cwp_idx(MACROBLOCKD *xd, aom_reader *r, const AV1_COMMON *cm,
+ MB_MODE_INFO *const mbmi) {
+ int8_t cwp_idx = 0;
+ int bit_cnt = 0;
+ const int ctx = 0;
+ for (int idx = 0; idx < MAX_CWP_NUM - 1; ++idx) {
+ const int tmp_idx = aom_read_symbol(
+ r, xd->tile_ctx->cwp_idx_cdf[ctx][bit_cnt], 2, ACCT_INFO());
+ cwp_idx = idx + tmp_idx;
+ if (!tmp_idx) break;
+ ++bit_cnt;
+ }
+ assert(cwp_idx <= CWP_MAX);
+
+ // convert index to weight
+ return get_cwp_coding_idx(cwp_idx, 0, cm, mbmi);
+}
+#endif // CONFIG_CWP
+
static PREDICTION_MODE read_inter_compound_mode(MACROBLOCKD *xd, aom_reader *r,
#if CONFIG_OPTFLOW_REFINEMENT
const AV1_COMMON *cm,
@@ -614,17 +712,19 @@
int use_optical_flow = 0;
if (cm->features.opfl_refine_type == REFINE_SWITCHABLE &&
is_opfl_refine_allowed(cm, mbmi)) {
- use_optical_flow =
- aom_read_symbol(r, xd->tile_ctx->use_optflow_cdf[ctx], 2, ACCT_STR);
+ use_optical_flow = aom_read_symbol(r, xd->tile_ctx->use_optflow_cdf[ctx], 2,
+ ACCT_INFO("use_optical_flow"));
}
#endif // CONFIG_OPTFLOW_REFINEMENT
const int mode =
#if CONFIG_OPTFLOW_REFINEMENT
aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
- INTER_COMPOUND_REF_TYPES, ACCT_STR);
+ INTER_COMPOUND_REF_TYPES,
+ ACCT_INFO("inter_compound_mode_cdf"));
#else
aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
- INTER_COMPOUND_MODES, ACCT_STR);
+ INTER_COMPOUND_MODES,
+ ACCT_INFO("inter_compound_mode_cdf"));
#endif // CONFIG_OPTFLOW_REFINEMENT
#if CONFIG_OPTFLOW_REFINEMENT
if (use_optical_flow) {
@@ -668,7 +768,8 @@
struct segmentation *const seg = &cm->seg;
struct segmentation_probs *const segp = &ec_ctx->seg;
aom_cdf_prob *pred_cdf = segp->spatial_pred_seg_cdf[cdf_num];
- const int coded_id = aom_read_symbol(r, pred_cdf, MAX_SEGMENTS, ACCT_STR);
+ const int coded_id =
+ aom_read_symbol(r, pred_cdf, MAX_SEGMENTS, ACCT_INFO("coded_id"));
const int segment_id =
av1_neg_deinterleave(coded_id, pred, seg->last_active_segid + 1);
@@ -789,7 +890,8 @@
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
struct segmentation_probs *const segp = &ec_ctx->seg;
aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx];
- mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR);
+ mbmi->seg_id_predicted =
+ aom_read_symbol(r, pred_cdf, 2, ACCT_INFO("seg_id_predicted"));
if (mbmi->seg_id_predicted) {
segment_id = get_predicted_segment_id(cm, mi_offset, x_inside_boundary,
y_inside_boundary);
@@ -823,8 +925,8 @@
const int ctx = av1_get_skip_mode_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
- const int skip_mode =
- aom_read_symbol(r, ec_ctx->skip_mode_cdfs[ctx], 2, ACCT_STR);
+ const int skip_mode = aom_read_symbol(r, ec_ctx->skip_mode_cdfs[ctx], 2,
+ ACCT_INFO("skip_mode"));
return skip_mode;
}
@@ -835,13 +937,13 @@
} else {
const int ctx = av1_get_skip_txfm_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
- const int skip_txfm =
- aom_read_symbol(r, ec_ctx->skip_txfm_cdfs[ctx], 2, ACCT_STR);
+ const int skip_txfm = aom_read_symbol(r, ec_ctx->skip_txfm_cdfs[ctx], 2,
+ ACCT_INFO("skip_txfm"));
return skip_txfm;
}
}
-#if !CONFIG_INDEP_PALETTE_PARSING
+#if !CONFIG_PALETTE_IMPROVEMENTS
// Merge the sorted list of cached colors(cached_colors[0...n_cached_colors-1])
// and the sorted list of transmitted colors(colors[n_cached_colors...n-1]) into
// one single sorted list(colors[...]).
@@ -860,27 +962,29 @@
}
}
}
-#endif //! CONFIG_INDEP_PALETTE_PARSING
+#endif //! CONFIG_PALETTE_IMPROVEMENTS
static void read_palette_colors_y(MACROBLOCKD *const xd, int bit_depth,
PALETTE_MODE_INFO *const pmi, aom_reader *r) {
-#if CONFIG_INDEP_PALETTE_PARSING
+#if CONFIG_PALETTE_IMPROVEMENTS
uint16_t color_cache[2 * PALETTE_MAX_SIZE];
const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
const int n = pmi->palette_size[0];
int idx = 0;
for (int i = 0; i < n_cache && idx < n; ++i) {
- if (aom_read_bit(r, ACCT_STR)) pmi->palette_colors[idx++] = color_cache[i];
+ if (aom_read_bit(r, ACCT_INFO("color_cache")))
+ pmi->palette_colors[idx++] = color_cache[i];
}
if (idx < n) {
- pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
+ pmi->palette_colors[idx++] =
+ aom_read_literal(r, bit_depth, ACCT_INFO("palette_colors"));
if (idx < n) {
const int min_bits = bit_depth - 3;
- int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
+ int bits = min_bits + aom_read_literal(r, 2, ACCT_INFO("bits"));
int range = (1 << bit_depth) - pmi->palette_colors[idx - 1] - 1;
for (; idx < n; ++idx) {
assert(range >= 0);
- const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
+ const int delta = aom_read_literal(r, bits, ACCT_INFO("delta")) + 1;
pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
0, (1 << bit_depth) - 1);
range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
@@ -905,17 +1009,19 @@
const int n = pmi->palette_size[0];
int idx = 0;
for (int i = 0; i < n_cache && idx < n; ++i)
- if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
+ if (aom_read_bit(r, ACCT_INFO("color_cache")))
+ cached_colors[idx++] = color_cache[i];
if (idx < n) {
const int n_cached_colors = idx;
- pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
+ pmi->palette_colors[idx++] =
+ aom_read_literal(r, bit_depth, ACCT_INFO("palette_colors"));
if (idx < n) {
const int min_bits = bit_depth - 3;
- int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
+ int bits = min_bits + aom_read_literal(r, 2, ACCT_INFO("bits"));
int range = (1 << bit_depth) - pmi->palette_colors[idx - 1] - 1;
for (; idx < n; ++idx) {
assert(range >= 0);
- const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
+ const int delta = aom_read_literal(r, bits, ACCT_INFO("delta")) + 1;
pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
0, (1 << bit_depth) - 1);
range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
@@ -926,29 +1032,31 @@
} else {
memcpy(pmi->palette_colors, cached_colors, n * sizeof(cached_colors[0]));
}
-#endif // CONFIG_INDEP_PALETTE_PARSING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
}
static void read_palette_colors_uv(MACROBLOCKD *const xd, int bit_depth,
PALETTE_MODE_INFO *const pmi,
aom_reader *r) {
-#if CONFIG_INDEP_PALETTE_PARSING
+#if CONFIG_PALETTE_IMPROVEMENTS
const int n = pmi->palette_size[1];
// U channel colors.
uint16_t color_cache[2 * PALETTE_MAX_SIZE];
const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
int idx = PALETTE_MAX_SIZE;
for (int i = 0; i < n_cache && idx < PALETTE_MAX_SIZE + n; ++i)
- if (aom_read_bit(r, ACCT_STR)) pmi->palette_colors[idx++] = color_cache[i];
+ if (aom_read_bit(r, ACCT_INFO("color_cache")))
+ pmi->palette_colors[idx++] = color_cache[i];
if (idx < PALETTE_MAX_SIZE + n) {
- pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
+ pmi->palette_colors[idx++] =
+ aom_read_literal(r, bit_depth, ACCT_INFO("palette_colors"));
if (idx < PALETTE_MAX_SIZE + n) {
const int min_bits = bit_depth - 3;
- int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
+ int bits = min_bits + aom_read_literal(r, 2, ACCT_INFO("bits"));
int range = (1 << bit_depth) - pmi->palette_colors[idx - 1];
for (; idx < PALETTE_MAX_SIZE + n; ++idx) {
assert(range >= 0);
- const int delta = aom_read_literal(r, bits, ACCT_STR);
+ const int delta = aom_read_literal(r, bits, ACCT_INFO("delta"));
pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
0, (1 << bit_depth) - 1);
range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
@@ -976,18 +1084,20 @@
const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
int idx = 0;
for (int i = 0; i < n_cache && idx < n; ++i)
- if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
+ if (aom_read_bit(r, ACCT_INFO("color_cache")))
+ cached_colors[idx++] = color_cache[i];
if (idx < n) {
const int n_cached_colors = idx;
idx += PALETTE_MAX_SIZE;
- pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
+ pmi->palette_colors[idx++] =
+ aom_read_literal(r, bit_depth, ACCT_INFO("palette_colors"));
if (idx < PALETTE_MAX_SIZE + n) {
const int min_bits = bit_depth - 3;
- int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
+ int bits = min_bits + aom_read_literal(r, 2, ACCT_INFO("bits"));
int range = (1 << bit_depth) - pmi->palette_colors[idx - 1];
for (; idx < PALETTE_MAX_SIZE + n; ++idx) {
assert(range >= 0);
- const int delta = aom_read_literal(r, bits, ACCT_STR);
+ const int delta = aom_read_literal(r, bits, ACCT_INFO("delta"));
pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
0, (1 << bit_depth) - 1);
range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
@@ -1000,17 +1110,17 @@
memcpy(pmi->palette_colors + PALETTE_MAX_SIZE, cached_colors,
n * sizeof(cached_colors[0]));
}
-#endif // CONFIG_INDEP_PALETTE_PARSING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
// V channel colors.
- if (aom_read_bit(r, ACCT_STR)) { // Delta encoding.
+ if (aom_read_bit(r, ACCT_INFO("use_delta"))) { // Delta encoding.
const int min_bits_v = bit_depth - 4;
const int max_val = 1 << bit_depth;
- int bits = min_bits_v + aom_read_literal(r, 2, ACCT_STR);
+ int bits = min_bits_v + aom_read_literal(r, 2, ACCT_INFO("bits"));
pmi->palette_colors[2 * PALETTE_MAX_SIZE] =
- aom_read_literal(r, bit_depth, ACCT_STR);
+ aom_read_literal(r, bit_depth, ACCT_INFO("palette_colors"));
for (int i = 1; i < n; ++i) {
- int delta = aom_read_literal(r, bits, ACCT_STR);
- if (delta && aom_read_bit(r, ACCT_STR)) delta = -delta;
+ int delta = aom_read_literal(r, bits, ACCT_INFO("delta"));
+ if (delta && aom_read_bit(r, ACCT_INFO("negate"))) delta = -delta;
int val = (int)pmi->palette_colors[2 * PALETTE_MAX_SIZE + i - 1] + delta;
if (val < 0) val += max_val;
if (val >= max_val) val -= max_val;
@@ -1019,7 +1129,7 @@
} else {
for (int i = 0; i < n; ++i) {
pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
- aom_read_literal(r, bit_depth, ACCT_STR);
+ aom_read_literal(r, bit_depth, ACCT_INFO("palette_colors"));
}
}
}
@@ -1036,11 +1146,11 @@
const int palette_mode_ctx = av1_get_palette_mode_ctx(xd);
const int modev = aom_read_symbol(
r, xd->tile_ctx->palette_y_mode_cdf[bsize_ctx][palette_mode_ctx], 2,
- ACCT_STR);
+ ACCT_INFO("modev", "luma"));
if (modev) {
pmi->palette_size[0] =
aom_read_symbol(r, xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
- PALETTE_SIZES, ACCT_STR) +
+ PALETTE_SIZES, ACCT_INFO("palette_size", "luma")) +
2;
read_palette_colors_y(xd, cm->seq_params.bit_depth, pmi, r);
}
@@ -1049,11 +1159,12 @@
mbmi->uv_mode == UV_DC_PRED && xd->is_chroma_ref) {
const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
const int modev = aom_read_symbol(
- r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR);
+ r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2,
+ ACCT_INFO("modev", "chroma"));
if (modev) {
pmi->palette_size[1] =
aom_read_symbol(r, xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
- PALETTE_SIZES, ACCT_STR) +
+ PALETTE_SIZES, ACCT_INFO("palette_size", "chroma")) +
2;
read_palette_colors_uv(xd, cm->seq_params.bit_depth, pmi, r);
}
@@ -1062,7 +1173,7 @@
#if !CONFIG_AIMC
static int read_angle_delta(aom_reader *r, aom_cdf_prob *cdf) {
- const int sym = aom_read_symbol(r, cdf, 2 * MAX_ANGLE_DELTA + 1, ACCT_STR);
+ const int sym = aom_read_symbol(r, cdf, 2 * MAX_ANGLE_DELTA + 1, ACCT_INFO());
return sym - MAX_ANGLE_DELTA;
}
#endif // !CONFIG_AIMC
@@ -1075,10 +1186,11 @@
if (av1_filter_intra_allowed(cm, mbmi) && xd->tree_type != CHROMA_PART) {
filter_intra_mode_info->use_filter_intra = aom_read_symbol(
r, xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type[PLANE_TYPE_Y]], 2,
- ACCT_STR);
+ ACCT_INFO("use_filter_intra"));
if (filter_intra_mode_info->use_filter_intra) {
- filter_intra_mode_info->filter_intra_mode = aom_read_symbol(
- r, xd->tile_ctx->filter_intra_mode_cdf, FILTER_INTRA_MODES, ACCT_STR);
+ filter_intra_mode_info->filter_intra_mode =
+ aom_read_symbol(r, xd->tile_ctx->filter_intra_mode_cdf,
+ FILTER_INTRA_MODES, ACCT_INFO("filter_intra_mode"));
}
} else {
filter_intra_mode_info->use_filter_intra = 0;
@@ -1086,12 +1198,22 @@
}
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row,
- int blk_col, TX_SIZE tx_size, aom_reader *r) {
+ int blk_col, TX_SIZE tx_size, aom_reader *r
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ const int plane, const int eob, const int dc_skip) {
+ if (plane != PLANE_TYPE_Y) return;
+#else
+) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
MB_MODE_INFO *mbmi = xd->mi[0];
TX_TYPE *tx_type =
&xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col];
*tx_type = DCT_DCT;
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (dc_skip == 1) return;
+#endif // CONFIG_ATC_DCTX_ALIGNED
// No need to read transform type if block is skipped.
if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART] ||
segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP))
@@ -1114,9 +1236,16 @@
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
if (inter_block) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int eob_tx_ctx = get_lp2tx_ctx(tx_size, get_txb_bwl(tx_size), eob);
+ *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol(
+ r, ec_ctx->inter_ext_tx_cdf[eset][eob_tx_ctx][square_tx_size],
+ av1_num_ext_tx_set[tx_set_type], ACCT_INFO("tx_type"))];
+#else
*tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol(
r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
- av1_num_ext_tx_set[tx_set_type], ACCT_STR)];
+ av1_num_ext_tx_set[tx_set_type], ACCT_INFO("tx_type"))];
+#endif // CONFIG_ATC_DCTX_ALIGNED
} else {
if (mbmi->fsc_mode[xd->tree_type == CHROMA_PART]) {
*tx_type = IDTX;
@@ -1127,7 +1256,7 @@
? fimode_to_intradir[mbmi->filter_intra_mode_info
.filter_intra_mode]
: mbmi->mode;
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
#if CONFIG_ATC_REDUCED_TXSET
const int size_info = av1_size_class[tx_size];
*tx_type = av1_tx_idx_to_type(
@@ -1138,21 +1267,21 @@
cm->features.reduced_tx_set_used
? av1_num_reduced_tx_set
: av1_num_ext_tx_set_intra[tx_set_type],
- ACCT_STR),
+ ACCT_INFO("tx_type")),
tx_set_type, intra_mode, size_info);
#else
const int size_info = av1_size_class[tx_size];
*tx_type = av1_tx_idx_to_type(
aom_read_symbol(
r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_mode],
- av1_num_ext_tx_set_intra[tx_set_type], ACCT_STR),
+ av1_num_ext_tx_set_intra[tx_set_type], ACCT_INFO("tx_type")),
tx_set_type, intra_mode, size_info);
#endif // CONFIG_ATC_REDUCED_TXSET
#else
*tx_type = av1_ext_tx_inv_intra[tx_set_type][aom_read_symbol(
r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_mode],
- av1_num_ext_tx_set_intra[tx_set_type], ACCT_STR)];
-#endif // CONFIG_ATC_NEWTXSETS
+ av1_num_ext_tx_set_intra[tx_set_type], ACCT_INFO("tx_type"))];
+#endif // CONFIG_ATC
}
}
}
@@ -1193,8 +1322,9 @@
get_above_and_left_cctx_type(cm, xd, tx_size, &above_cctx, &left_cctx);
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int cctx_ctx = get_cctx_context(xd, &above_cctx, &left_cctx);
- cctx_type = aom_read_symbol(
- r, ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx], CCTX_TYPES, ACCT_STR);
+ cctx_type =
+ aom_read_symbol(r, ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx],
+ CCTX_TYPES, ACCT_INFO("cctx_type"));
update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset, tx_size,
cctx_type);
}
@@ -1222,8 +1352,9 @@
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
if (!inter_block) {
if (block_signals_sec_tx_type(xd, tx_size, *tx_type, *eob)) {
- const uint8_t stx_flag = aom_read_symbol(
- r, ec_ctx->stx_cdf[square_tx_size], STX_TYPES, ACCT_STR);
+ const uint8_t stx_flag =
+ aom_read_symbol(r, ec_ctx->stx_cdf[square_tx_size], STX_TYPES,
+ ACCT_INFO("stx_flag"));
*tx_type |= (stx_flag << 4);
}
}
@@ -1232,7 +1363,7 @@
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
if (block_signals_sec_tx_type(xd, tx_size, *tx_type, *eob)) {
const uint8_t stx_flag = aom_read_symbol(
- r, ec_ctx->stx_cdf[square_tx_size], STX_TYPES, ACCT_STR);
+ r, ec_ctx->stx_cdf[square_tx_size], STX_TYPES, ACCT_INFO("stx_flag"));
*tx_type |= (stx_flag << 4);
}
}
@@ -1258,12 +1389,12 @@
const int_mv *ref_mv, int mi_row, int mi_col,
BLOCK_SIZE bsize, aom_reader *r) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
const MB_MODE_INFO *const mbmi = xd->mi[0];
if (mbmi->intrabc_mode == 1) {
mv->as_int = ref_mv->as_int;
} else {
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
#if CONFIG_FLEX_MVRES
read_mv(r, &mv->as_mv, ref_mv->as_mv,
#if CONFIG_ADAPTIVE_MVD
@@ -1278,9 +1409,9 @@
&ec_ctx->ndvc, MV_SUBPEL_NONE);
#endif
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
// DV should not have sub-pel.
assert((mv->as_mv.col & 7) == 0);
assert((mv->as_mv.row & 7) == 0);
@@ -1292,21 +1423,21 @@
return valid;
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
static void read_intrabc_drl_idx(int max_ref_bv_cnt, FRAME_CONTEXT *ec_ctx,
MB_MODE_INFO *mbmi, aom_reader *r) {
mbmi->intrabc_drl_idx = 0;
int bit_cnt = 0;
for (int idx = 0; idx < max_ref_bv_cnt - 1; ++idx) {
- const int intrabc_drl_idx =
- aom_read_symbol(r, ec_ctx->intrabc_drl_idx_cdf[bit_cnt], 2, ACCT_STR);
+ const int intrabc_drl_idx = aom_read_symbol(
+ r, ec_ctx->intrabc_drl_idx_cdf[bit_cnt], 2, ACCT_INFO());
mbmi->intrabc_drl_idx = idx + intrabc_drl_idx;
if (!intrabc_drl_idx) break;
++bit_cnt;
}
assert(mbmi->intrabc_drl_idx < max_ref_bv_cnt);
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
static void read_intrabc_info(AV1_COMMON *const cm, DecoderCodingBlock *dcb,
aom_reader *r) {
@@ -1314,16 +1445,18 @@
MB_MODE_INFO *const mbmi = xd->mi[0];
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
assert(xd->tree_type != CHROMA_PART);
+#if !CONFIG_SKIP_TXFM_OPT
#if CONFIG_NEW_CONTEXT_MODELING
mbmi->use_intrabc[0] = 0;
mbmi->use_intrabc[1] = 0;
const int intrabc_ctx = get_intrabc_ctx(xd);
mbmi->use_intrabc[xd->tree_type == CHROMA_PART] =
- aom_read_symbol(r, ec_ctx->intrabc_cdf[intrabc_ctx], 2, ACCT_STR);
+ aom_read_symbol(r, ec_ctx->intrabc_cdf[intrabc_ctx], 2, ACCT_INFO());
#else
mbmi->use_intrabc[xd->tree_type == CHROMA_PART] =
- aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR);
+ aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_INFO());
#endif // CONFIG_NEW_CONTEXT_MODELING
+#endif // !CONFIG_SKIP_TXFM_OPT
if (xd->tree_type == CHROMA_PART)
assert(mbmi->use_intrabc[PLANE_TYPE_UV] == 0);
if (mbmi->use_intrabc[xd->tree_type == CHROMA_PART]) {
@@ -1344,6 +1477,10 @@
set_most_probable_mv_precision(cm, mbmi, bsize);
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
#if CONFIG_BAWP
mbmi->bawp_flag = 0;
#endif
@@ -1354,7 +1491,7 @@
// TODO(kslu): Rework av1_find_mv_refs to avoid having this big array
// ref_mvs
int_mv ref_mvs[INTRA_FRAME + 1][MAX_MV_REF_CANDIDATES];
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
for (int i = 0; i < MAX_REF_BV_STACK_SIZE; ++i) {
xd->ref_mv_stack[INTRA_FRAME][i].this_mv.as_int = 0;
xd->ref_mv_stack[INTRA_FRAME][i].comp_mv.as_int = 0;
@@ -1362,8 +1499,11 @@
xd->ref_mv_stack[INTRA_FRAME][i].row_offset = OFFSET_NONSPATIAL;
xd->ref_mv_stack[INTRA_FRAME][i].col_offset = OFFSET_NONSPATIAL;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWP
+ xd->ref_mv_stack[INTRA_FRAME][i].cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
av1_find_mv_refs(cm, xd, mbmi, INTRA_FRAME, dcb->ref_mv_count,
xd->ref_mv_stack, xd->weight, ref_mvs, /*global_mvs=*/NULL
@@ -1378,9 +1518,9 @@
);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
mbmi->intrabc_mode =
- aom_read_symbol(r, ec_ctx->intrabc_mode_cdf, 2, ACCT_STR);
+ aom_read_symbol(r, ec_ctx->intrabc_mode_cdf, 2, ACCT_INFO());
read_intrabc_drl_idx(MAX_REF_BV_STACK_SIZE, ec_ctx, mbmi, r);
int_mv dv_ref =
xd->ref_mv_stack[INTRA_FRAME][mbmi->intrabc_drl_idx].this_mv;
@@ -1396,7 +1536,7 @@
av1_find_best_ref_mvs(0, ref_mvs[INTRA_FRAME], &nearestmv, &nearmv, 0);
#endif
int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
if (dv_ref.as_int == 0)
av1_find_ref_dv(&dv_ref, &xd->tile, cm->mib_size, xd->mi_row);
// Ref DV should not have sub-pel.
@@ -1467,14 +1607,17 @@
uint8_t mode_idx = 0;
const int context = get_y_mode_idx_ctx(xd);
int mode_set_index =
- aom_read_symbol(r, ec_ctx->y_mode_set_cdf, INTRA_MODE_SETS, ACCT_STR);
+ aom_read_symbol(r, ec_ctx->y_mode_set_cdf, INTRA_MODE_SETS,
+ ACCT_INFO("mode_set_index", "y_mode_set_cdf"));
if (mode_set_index == 0) {
- mode_idx = aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_0[context],
- FIRST_MODE_COUNT, ACCT_STR);
+ mode_idx =
+ aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_0[context], FIRST_MODE_COUNT,
+ ACCT_INFO("mode_idx", "y_mode_idx_cdf_0"));
} else {
- mode_idx = FIRST_MODE_COUNT + (mode_set_index - 1) * SECOND_MODE_COUNT +
- aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_1[context],
- SECOND_MODE_COUNT, ACCT_STR);
+ mode_idx =
+ FIRST_MODE_COUNT + (mode_set_index - 1) * SECOND_MODE_COUNT +
+ aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_1[context], SECOND_MODE_COUNT,
+ ACCT_INFO("mode_idx", "y_mode_idx_cdf_1"));
}
assert(mode_idx < LUMA_MODE_COUNT);
get_y_intra_mode_set(mbmi, xd);
@@ -1493,7 +1636,7 @@
const int context = av1_is_directional_mode(mbmi->mode) ? 1 : 0;
const int uv_mode_idx =
aom_read_symbol(r, ec_ctx->uv_mode_cdf[cfl_allowed][context],
- UV_INTRA_MODES - !cfl_allowed, ACCT_STR);
+ UV_INTRA_MODES - !cfl_allowed, ACCT_INFO("uv_mode_idx"));
assert(uv_mode_idx >= 0 && uv_mode_idx < UV_INTRA_MODES);
get_uv_intra_mode_set(mbmi);
mbmi->uv_mode = mbmi->uv_intra_mode_list[uv_mode_idx];
@@ -1520,8 +1663,30 @@
mbmi->skip_mode = 0;
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_SKIP_TXFM_OPT
+ if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+#if CONFIG_NEW_CONTEXT_MODELING
+ mbmi->use_intrabc[0] = 0;
+ mbmi->use_intrabc[1] = 0;
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] =
+ aom_read_symbol(r, ec_ctx->intrabc_cdf[intrabc_ctx], 2,
+ ACCT_INFO("use_intrabc", "chroma"));
+#else
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = aom_read_symbol(
+ r, ec_ctx->intrabc_cdf, 2, ACCT_INFO("use_intrabc", "chroma"));
+#endif // CONFIG_NEW_CONTEXT_MODELING
+ }
+ if (is_intrabc_block(mbmi, xd->tree_type)) {
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] =
+ read_skip_txfm(cm, xd, mbmi->segment_id, r);
+ } else {
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
+ }
+#else
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] =
read_skip_txfm(cm, xd, mbmi->segment_id, r);
+#endif // CONFIG_SKIP_TXFM_OPT
if (!seg->segid_preskip)
mbmi->segment_id = read_intra_segment_id(
@@ -1590,7 +1755,11 @@
mbmi->mrl_index =
(cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode))
+#if CONFIG_EXT_DIR
+ ? read_mrl_index(ec_ctx, r, xd->neighbors[0], xd->neighbors[1])
+#else
? read_mrl_index(ec_ctx, r)
+#endif // CONFIG_EXT_DIR
: 0;
}
@@ -1649,13 +1818,13 @@
static int read_mv_component_low_precision(aom_reader *r, nmv_component *mvcomp,
MvSubpelPrecision precision) {
int offset, mag;
- const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_STR);
+ const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_INFO("sign"));
const int num_mv_classes = MV_CLASSES - (precision <= MV_PRECISION_FOUR_PEL) -
(precision <= MV_PRECISION_8_PEL);
int mv_class = aom_read_symbol(
r, mvcomp->classes_cdf[av1_get_mv_class_context(precision)],
- num_mv_classes, ACCT_STR);
+ num_mv_classes, ACCT_INFO("mv_class"));
if (precision <= MV_PRECISION_FOUR_PEL && mv_class >= MV_CLASS_1)
mv_class += (precision == MV_PRECISION_FOUR_PEL ? 1 : 2);
@@ -1673,7 +1842,8 @@
const int n = (mv_class == MV_CLASS_0) ? 1 : mv_class;
offset = 0;
for (int i = start_lsb; i < n; ++i)
- offset |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_STR) << i;
+ offset |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_INFO("offset"))
+ << i;
const int base = mv_class ? (1 << mv_class) : 0;
mag = (offset + base); // int mv data
}
@@ -1705,19 +1875,21 @@
#endif
int mag, d, fr, hp;
- const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_STR);
+ const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_INFO("sign"));
const int mv_class =
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd
- ? aom_read_symbol(r, mvcomp->amvd_classes_cdf, MV_CLASSES, ACCT_STR)
+ ? aom_read_symbol(r, mvcomp->amvd_classes_cdf, MV_CLASSES,
+ ACCT_INFO("mv_class", "amvd_classes_cdf"))
:
#endif // CONFIG_ADAPTIVE_MVD
#if CONFIG_FLEX_MVRES
aom_read_symbol(
r, mvcomp->classes_cdf[av1_get_mv_class_context(precision)],
- MV_CLASSES, ACCT_STR);
+ MV_CLASSES, ACCT_INFO("mv_class", "classes_cdf"));
#else
- aom_read_symbol(r, mvcomp->classes_cdf, MV_CLASSES, ACCT_STR);
+ aom_read_symbol(r, mvcomp->classes_cdf, MV_CLASSES,
+ ACCT_INFO("mv_class", "classes_cdf"));
#endif
const int class0 = mv_class == MV_CLASS_0;
@@ -1729,13 +1901,15 @@
#endif // CONFIG_ADAPTIVE_MVD
// Integer part
if (class0) {
- d = aom_read_symbol(r, mvcomp->class0_cdf, CLASS0_SIZE, ACCT_STR);
+ d = aom_read_symbol(r, mvcomp->class0_cdf, CLASS0_SIZE,
+ ACCT_INFO("class0_cdf"));
mag = 0;
} else {
const int n = mv_class + CLASS0_BITS - 1; // number of bits
d = 0;
for (int i = 0; i < n; ++i)
- d |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_STR) << i;
+ d |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_INFO("bits_cdf"))
+ << i;
mag = CLASS0_SIZE << (mv_class + 2);
}
#if CONFIG_ADAPTIVE_MVD
@@ -1771,17 +1945,19 @@
#if CONFIG_FLEX_MVRES
fr = aom_read_symbol(
r, class0 ? mvcomp->class0_fp_cdf[d][0] : mvcomp->fp_cdf[0], 2,
- ACCT_STR)
+ ACCT_INFO("class0_fp_cdf"))
<< 1;
- fr += precision > MV_PRECISION_HALF_PEL
- ? aom_read_symbol(r,
- class0 ? mvcomp->class0_fp_cdf[d][1 + (fr >> 1)]
- : mvcomp->fp_cdf[1 + (fr >> 1)],
- 2, ACCT_STR)
- : 1;
+ fr +=
+ precision > MV_PRECISION_HALF_PEL
+ ? aom_read_symbol(r,
+ class0 ? mvcomp->class0_fp_cdf[d][1 + (fr >> 1)]
+ : mvcomp->fp_cdf[1 + (fr >> 1)],
+ 2, ACCT_INFO(class0 ? "class0_fp_cdf" : "fp_cdf"))
+ : 1;
#else
fr = aom_read_symbol(r, class0 ? mvcomp->class0_fp_cdf[d] : mvcomp->fp_cdf,
- MV_FP_SIZE, ACCT_STR);
+ MV_FP_SIZE,
+ ACCT_INFO(class0 ? "class0_fp_cdf" : "fp_cdf"));
#endif // CONFIG_FLEX_MVRES
#if CONFIG_FLEX_MVRES
@@ -1790,9 +1966,9 @@
#else
hp = usehp
#endif
- ? aom_read_symbol(r,
- class0 ? mvcomp->class0_hp_cdf : mvcomp->hp_cdf,
- 2, ACCT_STR)
+ ? aom_read_symbol(
+ r, class0 ? mvcomp->class0_hp_cdf : mvcomp->hp_cdf, 2,
+ ACCT_INFO(class0 ? "class0_hp_cdf" : "hp_cdf"))
: 1;
} else {
fr = 3;
@@ -1825,12 +2001,14 @@
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
const MV_JOINT_TYPE joint_type =
#if CONFIG_ADAPTIVE_MVD
- is_adaptive_mvd ? (MV_JOINT_TYPE)aom_read_symbol(r, ctx->amvd_joints_cdf,
- MV_JOINTS, ACCT_STR)
- :
+ is_adaptive_mvd
+ ? (MV_JOINT_TYPE)aom_read_symbol(
+ r, ctx->amvd_joints_cdf, MV_JOINTS,
+ ACCT_INFO("joint_type", "amvd_joints_cdf"))
+ :
#endif // CONFIG_ADAPTIVE_MVD
- (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joints_cdf,
- MV_JOINTS, ACCT_STR);
+ (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joints_cdf, MV_JOINTS,
+ ACCT_INFO("joint_type", "joints_cdf"));
if (mv_joint_vertical(joint_type))
diff.row = read_mv_component(r, &ctx->comps[0],
#if CONFIG_ADAPTIVE_MVD
@@ -1879,7 +2057,7 @@
if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) {
const int ctx = av1_get_reference_mode_context(cm, xd);
const REFERENCE_MODE mode = (REFERENCE_MODE)aom_read_symbol(
- r, xd->tile_ctx->comp_inter_cdf[ctx], 2, ACCT_STR);
+ r, xd->tile_ctx->comp_inter_cdf[ctx], 2, ACCT_INFO());
return mode; // SINGLE_REFERENCE or COMPOUND_REFERENCE
} else {
assert(cm->current_frame.reference_mode == SINGLE_REFERENCE);
@@ -1893,7 +2071,7 @@
const int n_refs = ref_frames_info->num_total_refs;
for (int i = 0; i < n_refs - 1; i++) {
const int bit = aom_read_symbol(
- r, av1_get_pred_cdf_single_ref(xd, i, n_refs), 2, ACCT_STR);
+ r, av1_get_pred_cdf_single_ref(xd, i, n_refs), 2, ACCT_INFO());
if (bit) {
ref_frame[0] = i;
return;
@@ -1924,7 +2102,7 @@
: aom_read_symbol(r,
av1_get_pred_cdf_compound_ref(
xd, i, n_bits, bit_type, n_refs),
- 2, ACCT_STR);
+ 2, ACCT_INFO());
if (bit) {
ref_frame[n_bits++] = i;
#if CONFIG_ALLOW_SAME_REF_COMPOUND
@@ -1968,7 +2146,8 @@
is_tip_allowed_bsize(bsize)) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int tip_ctx = get_tip_ctx(xd);
- if (aom_read_symbol(r, xd->tile_ctx->tip_cdf[tip_ctx], 2, ACCT_STR)) {
+ if (aom_read_symbol(r, xd->tile_ctx->tip_cdf[tip_ctx], 2,
+ ACCT_INFO("tip_cdf"))) {
ref_frame[0] = TIP_FRAME;
}
}
@@ -2015,7 +2194,8 @@
} else {
const int ctx = av1_get_pred_context_switchable_interp(xd, 0);
const InterpFilter filter = (InterpFilter)aom_read_symbol(
- r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS, ACCT_STR);
+ r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS,
+ ACCT_INFO("switchable_interp_cdf"));
mbmi->interp_fltr = filter;
}
}
@@ -2040,6 +2220,10 @@
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_AIMC
@@ -2074,7 +2258,11 @@
// Parsing reference line index
mbmi->mrl_index =
(cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode))
+#if CONFIG_EXT_DIR
+ ? read_mrl_index(ec_ctx, r, xd->neighbors[0], xd->neighbors[1])
+#else
? read_mrl_index(ec_ctx, r)
+#endif // CONFIG_EXT_DIR
: 0;
if (!cm->seq_params.monochrome && xd->is_chroma_ref) {
@@ -2153,6 +2341,9 @@
allow_hp = MV_SUBPEL_NONE;
}
#endif
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ (void)ref_warp_model;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#if CONFIG_JOINT_MVD
int first_ref_dist = 0;
int sec_ref_dist = 0;
@@ -2202,6 +2393,28 @@
}
#if CONFIG_WARPMV
case WARPMV: {
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->mv[0] = ref_mv[0];
+ if (mbmi->warpmv_with_mvd_flag) {
+ nmv_context *const nmvc = &ec_ctx->nmvc;
+ read_mv(r, &mv[0].as_mv,
+#if CONFIG_FLEX_MVRES
+ ref_mv[0].as_mv,
+#else
+ &ref_mv[0].as_mv,
+#endif
+#if CONFIG_ADAPTIVE_MVD
+ is_adaptive_mvd,
+#endif // CONFIG_ADAPTIVE_MVD
+ nmvc,
+#if CONFIG_FLEX_MVRES
+ precision);
+#else
+ allow_hp);
+#endif
+ }
+
+#else
assert(ref_warp_model);
mbmi->mv[0] = get_mv_from_wrl(xd, ref_warp_model,
@@ -2211,6 +2424,8 @@
1, 0,
#endif
bsize, xd->mi_col, xd->mi_row);
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
break;
}
#endif // CONFIG_WARPMV
@@ -2437,10 +2652,10 @@
static int read_is_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd,
int segment_id, aom_reader *r
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
,
const int skip_txfm
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
return 1;
@@ -2448,11 +2663,12 @@
const int ctx = av1_get_intra_inter_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const int is_inter =
-#if CONFIG_CONTEXT_DERIVATION
- aom_read_symbol(r, ec_ctx->intra_inter_cdf[skip_txfm][ctx], 2, ACCT_STR);
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
+ aom_read_symbol(r, ec_ctx->intra_inter_cdf[skip_txfm][ctx], 2,
+ ACCT_INFO());
#else
- aom_read_symbol(r, ec_ctx->intra_inter_cdf[ctx], 2, ACCT_STR);
-#endif // CONFIG_CONTEXT_DERIVATION
+ aom_read_symbol(r, ec_ctx->intra_inter_cdf[ctx], 2, ACCT_INFO());
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
return is_inter;
}
@@ -2489,6 +2705,22 @@
}
#endif // DEC_MISMATCH_DEBUG
+#if CONFIG_REFINEMV
+// This function read the refinemv_flag ( if require) from the bitstream
+static void read_refinemv_flag(AV1_COMMON *const cm, MACROBLOCKD *xd,
+ aom_reader *r, BLOCK_SIZE bsize) {
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+ mbmi->refinemv_flag = get_default_refinemv_flag(cm, mbmi);
+ int signal_refinemv = switchable_refinemv_flag(cm, mbmi);
+ if (signal_refinemv) {
+ const int refinemv_ctx = av1_get_refinemv_context(cm, xd, bsize);
+ mbmi->refinemv_flag =
+ aom_read_symbol(r, xd->tile_ctx->refinemv_flag_cdf[refinemv_ctx],
+ REFINEMV_NUM_MODES, ACCT_INFO("refinemv_flag"));
+ }
+}
+#endif // CONFIG_REFINEMV
+
#if CONFIG_FLEX_MVRES
MvSubpelPrecision av1_read_pb_mv_precision(AV1_COMMON *const cm,
MACROBLOCKD *const xd,
@@ -2505,8 +2737,9 @@
cm->features.most_probable_fr_mv_precision);
const int mpp_flag_context = av1_get_mpp_flag_context(cm, xd);
- const int mpp_flag = aom_read_symbol(
- r, xd->tile_ctx->pb_mv_mpp_flag_cdf[mpp_flag_context], 2, ACCT_STR);
+ const int mpp_flag =
+ aom_read_symbol(r, xd->tile_ctx->pb_mv_mpp_flag_cdf[mpp_flag_context], 2,
+ ACCT_INFO("mpp_flag"));
if (mpp_flag) return mbmi->most_probable_pb_mv_precision;
const PRECISION_SET *precision_def =
&av1_mv_precision_sets[mbmi->mb_precision_set];
@@ -2515,7 +2748,7 @@
r,
xd->tile_ctx->pb_mv_precision_cdf[down_ctx]
[max_precision - MV_PRECISION_HALF_PEL],
- nsymbs, ACCT_STR);
+ nsymbs, ACCT_INFO("down"));
return av1_get_precision_from_index(mbmi, down);
}
#endif // CONFIG_FLEX_MVRES
@@ -2561,6 +2794,10 @@
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
av1_collect_neighbors_ref_counts(xd);
read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame);
@@ -2573,6 +2810,7 @@
xd->valid_num_warp_candidates);
#endif // CONFIG_WARP_REF_LIST
+#if !CONFIG_SEP_COMP_DRL
av1_find_mv_refs(
cm, xd, mbmi, ref_frame, dcb->ref_mv_count, xd->ref_mv_stack, xd->weight,
ref_mvs, /*global_mvs=*/NULL
@@ -2586,32 +2824,42 @@
ref_frame < INTER_REFS_PER_FRAME ? MAX_WARP_REF_CANDIDATES : 0,
xd->valid_num_warp_candidates
#endif // CONFIG_WARP_REF_LIST
-
);
+#endif // !CONFIG_SEP_COMP_DRL
#if CONFIG_C076_INTER_MOD_CTX
av1_find_mode_ctx(cm, xd, inter_mode_ctx, ref_frame);
#endif // CONFIG_C076_INTER_MOD_CTX
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif // CONFIG_SEP_COMP_DRL
+
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
+#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
+ mbmi->jmvd_scale_mode = 0;
+#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
+
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
#endif // CONFIG_WARP_REF_LIST
#if CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
mbmi->motion_mode = SIMPLE_TRANSLATION;
WARP_CANDIDATE warp_param_stack[MAX_WARP_REF_CANDIDATES];
- WarpedMotionParams ref_warp_model;
+ WarpedMotionParams ref_warp_model = default_warp_params;
#endif // CONFIG_WARPMV
if (mbmi->skip_mode) {
assert(is_compound);
-#if CONFIG_SKIP_MODE_ENHANCEMENT && CONFIG_OPTFLOW_REFINEMENT
- mbmi->mode =
- (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV);
-#else
- mbmi->mode = NEAR_NEARMV;
-#endif // CONFIG_SKIP_MODE_ENHANCEMENT && CONFIG_OPTFLOW_REFINEMENT
#if CONFIG_SKIP_MODE_ENHANCEMENT
read_drl_idx(cm->features.max_drl_bits,
@@ -2619,12 +2867,52 @@
ec_ctx, dcb, mbmi, r);
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SEP_COMP_DRL
+ av1_find_mv_refs(
+ cm, xd, mbmi, ref_frame, dcb->ref_mv_count, xd->ref_mv_stack,
+ xd->weight, ref_mvs, /*global_mvs=*/NULL
+#if !CONFIG_C076_INTER_MOD_CTX
+ ,
+ inter_mode_ctx
+#endif // !CONFIG_C076_INTER_MOD_CTX
+#if CONFIG_WARP_REF_LIST
+ ,
+ xd->warp_param_stack,
+ ref_frame < SINGLE_REF_FRAMES ? MAX_WARP_REF_CANDIDATES : 0,
+ xd->valid_num_warp_candidates
+#endif // CONFIG_WARP_REF_LIST
+ );
+#endif // CONFIG_SEP_COMP_DRL
+
+#if CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_frame[0] =
+ xd->skip_mvp_candidate_list.ref_frame0[get_ref_mv_idx(mbmi, 0)];
+ mbmi->ref_frame[1] =
+ xd->skip_mvp_candidate_list.ref_frame1[get_ref_mv_idx(mbmi, 1)];
+#else
mbmi->ref_frame[0] =
xd->skip_mvp_candidate_list.ref_frame0[mbmi->ref_mv_idx];
mbmi->ref_frame[1] =
xd->skip_mvp_candidate_list.ref_frame1[mbmi->ref_mv_idx];
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+
+#if CONFIG_REFINEMV && !CONFIG_CWP
+ mbmi->refinemv_flag = get_default_refinemv_flag(cm, mbmi);
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_SKIP_MODE_ENHANCEMENT && CONFIG_OPTFLOW_REFINEMENT
+ mbmi->mode = (cm->features.opfl_refine_type
+#if CONFIG_CWP
+ && !cm->features.enable_cwp
+#endif // CONFIG_CWP
+ ? NEAR_NEARMV_OPTFLOW
+ : NEAR_NEARMV);
+#else
+ mbmi->mode = NEAR_NEARMV;
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT && CONFIG_OPTFLOW_REFINEMENT
+
} else {
if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) ||
segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_GLOBALMV)) {
@@ -2646,12 +2934,29 @@
#endif // CONFIG_WARPMV
);
+#if CONFIG_SEP_COMP_DRL
+ av1_find_mv_refs(
+ cm, xd, mbmi, ref_frame, dcb->ref_mv_count, xd->ref_mv_stack,
+ xd->weight, ref_mvs, /*global_mvs=*/NULL
+#if !CONFIG_C076_INTER_MOD_CTX
+ ,
+ inter_mode_ctx
+#endif // !CONFIG_C076_INTER_MOD_CTX
+#if CONFIG_WARP_REF_LIST
+ ,
+ xd->warp_param_stack,
+ ref_frame < SINGLE_REF_FRAMES ? MAX_WARP_REF_CANDIDATES : 0,
+ xd->valid_num_warp_candidates
+#endif // CONFIG_WARP_REF_LIST
+ );
+#endif // CONFIG_SEP_COMP_DRL
+
#if CONFIG_WARPMV
#if CONFIG_BAWP
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
- mbmi->bawp_flag =
- aom_read_symbol(r, xd->tile_ctx->bawp_cdf, 2, ACCT_STR);
+ mbmi->bawp_flag = aom_read_symbol(r, xd->tile_ctx->bawp_cdf, 2,
+ ACCT_INFO("bawp_flag"));
}
#endif
@@ -2671,12 +2976,15 @@
av1_count_overlappable_neighbors(cm, xd);
mbmi->motion_mode = read_motion_mode(cm, xd, mbmi, r);
int is_warpmv_warp_causal =
- (mbmi->motion_mode == WARPED_CAUSAL && mbmi->mode == WARPMV);
+ ((mbmi->motion_mode == WARPED_CAUSAL) && mbmi->mode == WARPMV);
if (mbmi->motion_mode == WARP_DELTA || is_warpmv_warp_causal) {
- mbmi->max_num_warp_candidates =
- (mbmi->mode == GLOBALMV || mbmi->mode == NEARMV)
- ? 1
- : MAX_WARP_REF_CANDIDATES;
+ mbmi->max_num_warp_candidates = (mbmi->mode == GLOBALMV ||
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->mode == AMVDNEWMV ||
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->mode == NEARMV)
+ ? 1
+ : MAX_WARP_REF_CANDIDATES;
if (is_warpmv_warp_causal) {
mbmi->max_num_warp_candidates = MAX_WARP_REF_CANDIDATES;
}
@@ -2691,6 +2999,14 @@
}
#endif // CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (allow_warpmv_with_mvd_coding(cm, mbmi)) {
+ read_warpmv_with_mvd_flag(xd->tile_ctx, mbmi, r);
+ } else {
+ mbmi->warpmv_with_mvd_flag = 0;
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
mbmi->jmvd_scale_mode = read_jmvd_scale_mode(xd, r, mbmi);
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
@@ -2729,23 +3045,68 @@
mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]);
}
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (mbmi->mode == WARPMV) {
+ ref_mv[0] = get_mv_from_wrl(xd, &ref_warp_model,
+ !mbmi->warpmv_with_mvd_flag
+ ? MV_PRECISION_ONE_EIGHTH_PEL
+ : mbmi->pb_mv_precision,
+ bsize, xd->mi_col, xd->mi_row);
+
+ } else {
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mbmi))
+ ref_mv[0] =
+ xd->ref_mv_stack[mbmi->ref_frame[0]][get_ref_mv_idx(mbmi, 0)].this_mv;
+ else
+ ref_mv[0] = xd->ref_mv_stack[ref_frame][get_ref_mv_idx(mbmi, 0)].this_mv;
+#else
ref_mv[0] = xd->ref_mv_stack[ref_frame][mbmi->ref_mv_idx].this_mv;
+#endif // CONFIG_SEP_COMP_DRL
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
if (is_compound && mbmi->mode != GLOBAL_GLOBALMV) {
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mbmi))
+ ref_mv[1] =
+ xd->ref_mv_stack[mbmi->ref_frame[1]][get_ref_mv_idx(mbmi, 1)].this_mv;
+ else
+ ref_mv[1] = xd->ref_mv_stack[ref_frame][get_ref_mv_idx(mbmi, 1)].comp_mv;
+#else
ref_mv[1] = xd->ref_mv_stack[ref_frame][mbmi->ref_mv_idx].comp_mv;
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) {
+#if CONFIG_SEP_COMP_DRL
+ ref_mv[0] =
+ xd->skip_mvp_candidate_list.ref_mv_stack[get_ref_mv_idx(mbmi, 0)]
+ .this_mv;
+ ref_mv[1] =
+ xd->skip_mvp_candidate_list.ref_mv_stack[get_ref_mv_idx(mbmi, 1)]
+ .comp_mv;
+#else
ref_mv[0] =
xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx].this_mv;
ref_mv[1] =
xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx].comp_mv;
+#endif // CONFIG_SEP_COMP_DRL
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
if (mbmi->skip_mode) {
#if CONFIG_SKIP_MODE_ENHANCEMENT && CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_CWP
+ assert(mbmi->mode ==
+ (cm->features.opfl_refine_type && !cm->features.enable_cwp
+ ? NEAR_NEARMV_OPTFLOW
+ : NEAR_NEARMV));
+#else // CONFIG_CWP
assert(mbmi->mode ==
(cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
+#endif // CONFIG_CWP
#else
assert(mbmi->mode == NEAR_NEARMV);
#endif // CONFIG_SKIP_MODE_ENHANCEMENT && CONFIG_OPTFLOW_REFINEMENT
@@ -2773,7 +3134,8 @@
#if CONFIG_BAWP && !CONFIG_WARPMV
if (cm->features.enable_bawp && av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col))
- mbmi->bawp_flag = aom_read_symbol(r, xd->tile_ctx->bawp_cdf, 2, ACCT_STR);
+ mbmi->bawp_flag =
+ aom_read_symbol(r, xd->tile_ctx->bawp_cdf, 2, ACCT_INFO("bawp_flag"));
#endif
#if CONFIG_EXTENDED_WARP_PREDICTION
@@ -2812,8 +3174,8 @@
if (cm->seq_params.enable_interintra_compound && !mbmi->skip_mode &&
is_interintra_allowed(mbmi)) {
const int bsize_group = size_group_lookup[bsize];
- const int interintra =
- aom_read_symbol(r, ec_ctx->interintra_cdf[bsize_group], 2, ACCT_STR);
+ const int interintra = aom_read_symbol(
+ r, ec_ctx->interintra_cdf[bsize_group], 2, ACCT_INFO("interintra"));
assert(mbmi->ref_frame[1] == NONE_FRAME);
if (interintra) {
const INTERINTRA_MODE interintra_mode =
@@ -2824,15 +3186,17 @@
mbmi->angle_delta[PLANE_TYPE_UV] = 0;
mbmi->filter_intra_mode_info.use_filter_intra = 0;
if (av1_is_wedge_used(bsize)) {
- mbmi->use_wedge_interintra = aom_read_symbol(
- r, ec_ctx->wedge_interintra_cdf[bsize], 2, ACCT_STR);
+ mbmi->use_wedge_interintra =
+ aom_read_symbol(r, ec_ctx->wedge_interintra_cdf[bsize], 2,
+ ACCT_INFO("use_wedge_interintra"));
if (mbmi->use_wedge_interintra) {
#if CONFIG_WEDGE_MOD_EXT
mbmi->interintra_wedge_index = read_wedge_mode(r, ec_ctx, bsize);
assert(mbmi->interintra_wedge_index != -1);
#else
mbmi->interintra_wedge_index = (int8_t)aom_read_symbol(
- r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR);
+ r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES,
+ ACCT_INFO("interintra_wedge_index"));
#endif
}
}
@@ -2859,6 +3223,12 @@
mbmi->motion_mode = read_motion_mode(cm, xd, mbmi, r);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_REFINEMV
+ if (!mbmi->skip_mode) {
+ read_refinemv_flag(cm, xd, r, bsize);
+ }
+#endif // CONFIG_REFINEMV
+
// init
mbmi->comp_group_idx = 0;
mbmi->interinter_comp.type = COMPOUND_AVERAGE;
@@ -2867,6 +3237,9 @@
#if CONFIG_OPTFLOW_REFINEMENT
mbmi->mode < NEAR_NEARMV_OPTFLOW &&
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ (!mbmi->refinemv_flag || !switchable_refinemv_flag(cm, mbmi)) &&
+#endif // CONFIG_REFINEMV
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
!is_joint_amvd_coding_mode(mbmi->mode) &&
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
@@ -2878,7 +3251,8 @@
if (masked_compound_used) {
const int ctx_comp_group_idx = get_comp_group_idx_context(cm, xd);
mbmi->comp_group_idx = (uint8_t)aom_read_symbol(
- r, ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2, ACCT_STR);
+ r, ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2,
+ ACCT_INFO("comp_group_idx"));
}
if (mbmi->comp_group_idx == 0) {
@@ -2892,9 +3266,9 @@
// compound_diffwtd, wedge
if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) {
mbmi->interinter_comp.type =
- COMPOUND_WEDGE + aom_read_symbol(r,
- ec_ctx->compound_type_cdf[bsize],
- MASKED_COMPOUND_TYPES, ACCT_STR);
+ COMPOUND_WEDGE +
+ aom_read_symbol(r, ec_ctx->compound_type_cdf[bsize],
+ MASKED_COMPOUND_TYPES, ACCT_INFO("comp_type"));
} else {
mbmi->interinter_comp.type = COMPOUND_DIFFWTD;
}
@@ -2905,17 +3279,41 @@
mbmi->interinter_comp.wedge_index = read_wedge_mode(r, ec_ctx, bsize);
assert(mbmi->interinter_comp.wedge_index != -1);
#else
- mbmi->interinter_comp.wedge_index = (int8_t)aom_read_symbol(
- r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR);
+ mbmi->interinter_comp.wedge_index =
+ (int8_t)aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize],
+ MAX_WEDGE_TYPES, ACCT_INFO("wedge_index"));
#endif // CONFIG_WEDGE_MOD_EXT
- mbmi->interinter_comp.wedge_sign = (int8_t)aom_read_bit(r, ACCT_STR);
+ mbmi->interinter_comp.wedge_sign =
+ (int8_t)aom_read_bit(r, ACCT_INFO("wedge_sign"));
} else {
assert(mbmi->interinter_comp.type == COMPOUND_DIFFWTD);
mbmi->interinter_comp.mask_type =
- aom_read_literal(r, MAX_DIFFWTD_MASK_BITS, ACCT_STR);
+ aom_read_literal(r, MAX_DIFFWTD_MASK_BITS, ACCT_INFO("mask_type"));
}
}
}
+#if CONFIG_CWP && CONFIG_SKIP_MODE_ENHANCEMENT
+ mbmi->cwp_idx = CWP_EQUAL;
+ if (cm->features.enable_cwp) {
+ if (is_cwp_allowed(mbmi) && !mbmi->skip_mode)
+ mbmi->cwp_idx = read_cwp_idx(xd, r, cm, mbmi);
+ if (is_cwp_allowed(mbmi) && mbmi->skip_mode)
+ mbmi->cwp_idx =
+#if CONFIG_SEP_COMP_DRL
+ xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx[0]].cwp_idx;
+#else
+ xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx].cwp_idx;
+#endif // CONFIG_SEP_COMP_DRL
+ }
+#if CONFIG_REFINEMV
+ if (mbmi->skip_mode) {
+ mbmi->refinemv_flag =
+ (mbmi->cwp_idx == CWP_EQUAL && is_refinemv_allowed_skip_mode(cm, mbmi))
+ ? 1
+ : 0;
+ }
+#endif // CONFIG_REFINEMV
+#endif // CONFIG_CWP && CONFIG_SKIP_MODE_ENHANCEMENT
read_mb_interp_filter(xd, features->interp_filter, cm, mbmi, r);
@@ -2946,7 +3344,12 @@
}
if (mbmi->motion_mode == WARP_EXTEND) {
+#if CONFIG_SEP_COMP_DRL
+ CANDIDATE_MV *neighbor =
+ &xd->ref_mv_stack[ref_frame][get_ref_mv_idx(mbmi, 0)];
+#else
CANDIDATE_MV *neighbor = &xd->ref_mv_stack[ref_frame][mbmi->ref_mv_idx];
+#endif
POSITION base_pos = { 0, 0 };
if (!get_extend_base_pos(cm, xd, mbmi, neighbor->row_offset,
neighbor->col_offset, &base_pos)) {
@@ -3006,14 +3409,14 @@
if (xd->tree_type != LUMA_PART) xd->cfl.store_y = store_cfl_required(cm, xd);
-#if CONFIG_REF_MV_BANK && !CONFIG_BVP_IMPROVEMENT
+#if CONFIG_REF_MV_BANK && !CONFIG_IBC_BV_IMPROVEMENT
#if CONFIG_IBC_SR_EXT
if (cm->seq_params.enable_refmvbank && !is_intrabc_block(mbmi, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank)
#endif // CONFIG_IBC_SR_EXT
av1_update_ref_mv_bank(cm, xd, mbmi);
-#endif // CONFIG_REF_MV_BANK && !CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_REF_MV_BANK && !CONFIG_IBC_BV_IMPROVEMENT
#if DEC_MISMATCH_DEBUG
dec_dump_logs(cm, mi, mi_row, mi_col, mode_ctx);
@@ -3045,10 +3448,70 @@
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
mbmi->segment_id = read_inter_segment_id(cm, xd, 1, r);
mbmi->skip_mode = read_skip_mode(cm, xd, mbmi->segment_id, r);
+ mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
+ mbmi->fsc_mode[PLANE_TYPE_UV] = 0;
+
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
+
+#if CONFIG_WARP_REF_LIST
+ mbmi->warp_ref_idx = 0;
+ mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+#endif // CONFIG_WARP_REF_LIST
+#if CONFIG_NEW_CONTEXT_MODELING
+ mbmi->use_intrabc[0] = 0;
+ mbmi->use_intrabc[1] = 0;
+#endif // CONFIG_NEW_CONTEXT_MODELING
+
+#if CONFIG_SKIP_TXFM_OPT
+ if (!mbmi->skip_mode) {
+ inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
+ }
+
+#if CONFIG_IBC_SR_EXT
+ if (!inter_block && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+#if CONFIG_NEW_CONTEXT_MODELING
+ mbmi->use_intrabc[0] = 0;
+ mbmi->use_intrabc[1] = 0;
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] =
+ aom_read_symbol(r, xd->tile_ctx->intrabc_cdf[intrabc_ctx], 2,
+ ACCT_INFO("use_intrabc", "chroma"));
+#else
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = aom_read_symbol(
+ r, ec_ctx->intrabc_cdf, 2, ACCT_INFO("use_intrabc", "chroma"));
+#endif // CONFIG_NEW_CONTEXT_MODELING
+ }
+#endif // CONFIG_IBC_SR_EXT
+
+ if (inter_block
+#if CONFIG_IBC_SR_EXT
+ || (!inter_block && is_intrabc_block(mbmi, xd->tree_type))
+#endif // CONFIG_IBC_SR_EXT
+ ) {
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
+ if (mbmi->skip_mode)
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
+ else
+#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] =
+ read_skip_txfm(cm, xd, mbmi->segment_id, r);
+ } else {
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
+ }
+#else
#if !CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode)
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
@@ -3056,17 +3519,8 @@
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] =
read_skip_txfm(cm, xd, mbmi->segment_id, r);
+#endif // CONFIG_SKIP_TXFM_OPT
- mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
- mbmi->fsc_mode[PLANE_TYPE_UV] = 0;
-#if CONFIG_WARP_REF_LIST
- mbmi->warp_ref_idx = 0;
- mbmi->max_num_warp_candidates = 0;
-#endif // CONFIG_WARP_REF_LIST
-#if CONFIG_NEW_CONTEXT_MODELING
- mbmi->use_intrabc[0] = 0;
- mbmi->use_intrabc[1] = 0;
-#endif // CONFIG_NEW_CONTEXT_MODELING
if (!cm->seg.segid_preskip)
mbmi->segment_id = read_inter_segment_id(cm, xd, 0, r);
@@ -3078,6 +3532,7 @@
read_delta_q_params(cm, xd, r);
+#if !CONFIG_SKIP_TXFM_OPT
if (!mbmi->skip_mode)
inter_block =
read_is_inter_block(cm, xd, mbmi->segment_id, r
@@ -3086,6 +3541,7 @@
mbmi->skip_txfm[xd->tree_type == CHROMA_PART]
#endif // CONFIG_CONTEXT_DERIVATION
);
+#endif // !CONFIG_SKIP_TXFM_OPT
mbmi->current_qindex = xd->current_base_qindex;
@@ -3100,6 +3556,17 @@
mbmi->ref_frame[1] = NONE_FRAME;
mbmi->palette_mode_info.palette_size[0] = 0;
mbmi->palette_mode_info.palette_size[1] = 0;
+#if CONFIG_NEW_CONTEXT_MODELING
+ mbmi->use_intrabc[0] = 0;
+ mbmi->use_intrabc[1] = 0;
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] =
+ aom_read_symbol(r, xd->tile_ctx->intrabc_cdf[intrabc_ctx], 2,
+ ACCT_INFO("use_intrabc", "chroma"));
+#else
+ mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = aom_read_symbol(
+ r, xd->tile_ctx->intrabc_cdf, 2, ACCT_INFO("use_intrabc", "chroma"));
+#endif // CONFIG_NEW_CONTEXT_MODELING
read_intrabc_info(cm, dcb, r);
if (is_intrabc_block(mbmi, xd->tree_type)) return;
}
@@ -3160,31 +3627,33 @@
MACROBLOCKD *const xd = &dcb->xd;
MB_MODE_INFO *const mi = xd->mi[0];
mi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
-
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
if (xd->tree_type == SHARED_PART)
mi->sb_type[PLANE_TYPE_UV] = mi->sb_type[PLANE_TYPE_Y];
if (frame_is_intra_only(cm)) {
read_intra_frame_mode_info(cm, dcb, r);
-#if CONFIG_BVP_IMPROVEMENT && CONFIG_REF_MV_BANK
+#if CONFIG_IBC_BV_IMPROVEMENT && CONFIG_REF_MV_BANK
if (cm->seq_params.enable_refmvbank) {
MB_MODE_INFO *const mbmi = xd->mi[0];
if (is_intrabc_block(mbmi, xd->tree_type))
av1_update_ref_mv_bank(cm, xd, mbmi);
}
-#endif // CONFIG_BVP_IMPROVEMENT && CONFIG_REF_MV_BANK
+#endif // CONFIG_IBC_BV_IMPROVEMENT && CONFIG_REF_MV_BANK
if (cm->seq_params.order_hint_info.enable_ref_frame_mvs)
intra_copy_frame_mvs(cm, xd->mi_row, xd->mi_col, x_inside_boundary,
y_inside_boundary);
} else {
read_inter_frame_mode_info(pbi, dcb, r);
-#if CONFIG_BVP_IMPROVEMENT && CONFIG_REF_MV_BANK
+#if CONFIG_IBC_BV_IMPROVEMENT && CONFIG_REF_MV_BANK
if (cm->seq_params.enable_refmvbank) {
MB_MODE_INFO *const mbmi = xd->mi[0];
if (is_inter_block(mbmi, xd->tree_type))
av1_update_ref_mv_bank(cm, xd, mbmi);
}
-#endif // CONFIG_BVP_IMPROVEMENT && CONFIG_REF_MV_BANK
+#endif // CONFIG_IBC_BV_IMPROVEMENT && CONFIG_REF_MV_BANK
#if CONFIG_WARP_REF_LIST
MB_MODE_INFO *const mbmi_tmp = xd->mi[0];
diff --git a/av1/decoder/decodemv.h b/av1/decoder/decodemv.h
index ac2e813..208f5c5 100644
--- a/av1/decoder/decodemv.h
+++ b/av1/decoder/decodemv.h
@@ -34,7 +34,12 @@
uint16_t *eob, aom_reader *r);
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row,
- int blk_col, TX_SIZE tx_size, aom_reader *r);
+ int blk_col, TX_SIZE tx_size, aom_reader *r
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ const int plane, const int eob, const int dc_skip
+#endif // CONFIG_ATC_DCTX_ALIGNED
+);
#if CONFIG_CROSS_CHROMA_TX
void av1_read_cctx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
diff --git a/av1/decoder/decoder.c b/av1/decoder/decoder.c
index 56b05f5..4bb23aa 100644
--- a/av1/decoder/decoder.c
+++ b/av1/decoder/decoder.c
@@ -486,8 +486,37 @@
update_subgop_stats(cm, &pbi->subgop_stats, cm->cur_frame->order_hint,
pbi->enable_subgop_stats);
}
-
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (cm->seq_params.order_hint_info.enable_order_hint &&
+ cm->seq_params.enable_frame_output_order && cm->show_frame &&
+ !cm->show_existing_frame) {
+ // Refresh the reference slots of output frames in the output queue.
+ if (pbi->num_output_frames > 0) {
+ decrease_ref_count(pbi->output_frames[0], pool);
+ }
+ // Add the currently decoded frame into the output queue.
+ pbi->output_frames[0] = cm->cur_frame;
+ pbi->num_output_frames = 1;
+ // Add the next frames (showable_frame == 1) into the output queue.
+ int successive_output = 1;
+ for (int k = 1; k <= REF_FRAMES && successive_output > 0; k++) {
+ unsigned int next_disp_order = cm->cur_frame->display_order_hint + k;
+ successive_output = 0;
+ for (int i = 0; i < REF_FRAMES; i++) {
+ if (cm->ref_frame_map[i]->display_order_hint == next_disp_order &&
+ cm->ref_frame_map[i]->showable_frame == 1) {
+ pbi->output_frames[k] = cm->ref_frame_map[i];
+ pbi->num_output_frames++;
+ successive_output++;
+ }
+ }
+ }
+ } else if ((!cm->seq_params.order_hint_info.enable_order_hint ||
+ !cm->seq_params.enable_frame_output_order) &&
+ (cm->show_existing_frame || cm->show_frame)) {
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (cm->show_existing_frame || cm->show_frame) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (pbi->output_all_layers) {
// Append this frame to the output queue
if (pbi->num_output_frames >= MAX_NUM_SPATIAL_LAYERS) {
@@ -645,7 +674,15 @@
// TODO(rachelbarker): What should this do?
int av1_get_frame_to_show(AV1Decoder *pbi, YV12_BUFFER_CONFIG *frame) {
if (pbi->num_output_frames == 0) return -1;
-
- *frame = pbi->output_frames[pbi->num_output_frames - 1]->buf;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ const size_t out_frame_idx =
+ (pbi->common.seq_params.order_hint_info.enable_order_hint &&
+ pbi->common.seq_params.enable_frame_output_order)
+ ? 0
+ : pbi->num_output_frames - 1;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ const size_t out_frame_idx = pbi->num_output_frames - 1;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ *frame = pbi->output_frames[out_frame_idx]->buf;
return 0;
}
diff --git a/av1/decoder/decoder.h b/av1/decoder/decoder.h
index b4f734b..11dc3f7 100644
--- a/av1/decoder/decoder.h
+++ b/av1/decoder/decoder.h
@@ -62,6 +62,13 @@
* with appropriate offset for the current superblock, for each plane.
*/
tran_low_t *dqcoeff_block[MAX_MB_PLANE];
+#if CONFIG_INSPECTION
+ // dqcoeff_block gets clobbered before the inspect callback happens, so keep a
+ // copy here.
+ tran_low_t *dqcoeff_block_copy[MAX_MB_PLANE];
+ tran_low_t *qcoeff_block[MAX_MB_PLANE];
+ tran_low_t *dequant_values[MAX_MB_PLANE];
+#endif
/*!
* cb_offset[p] is the offset into the dqcoeff_block[p] for the current coding
* block, for each plane 'p'.
@@ -76,6 +83,13 @@
* with appropriate offset for the current superblock, for each plane.
*/
eob_info *eob_data[MAX_MB_PLANE];
+#if CONFIG_ATC_DCTX_ALIGNED
+ /*!
+ * Pointer to 'bob_data' inside 'td->cb_buffer_base' or 'pbi->cb_buffer_base'
+ * with appropriate offset for the current superblock, for each plane.
+ */
+ eob_info *bob_data[MAX_MB_PLANE];
+#endif // CONFIG_ATC_DCTX_ALIGNED
/*!
* txb_offset[p] is the offset into the eob_data[p] for the current coding
* block, for each plane 'p'.
@@ -273,7 +287,11 @@
// Note: The saved buffers are released at the start of the next time the
// application calls aom_codec_decode().
int output_all_layers;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ RefCntBuffer *output_frames[REF_FRAMES]; // Use only for single layer
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
RefCntBuffer *output_frames[MAX_NUM_SPATIAL_LAYERS];
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
size_t num_output_frames; // How many frames are queued up so far?
// In order to properly support random-access decoding, we need
@@ -296,7 +314,10 @@
int sequence_header_ready;
int sequence_header_changed;
#if CONFIG_INSPECTION
+ // Inspection callback at the end of each frame.
aom_inspect_cb inspect_cb;
+ // Inspection callback at the end of each superblock.
+ aom_inspect_cb inspect_sb_cb;
void *inspect_ctx;
#endif
int operating_point;
@@ -408,16 +429,15 @@
}
}
-#define ACCT_STR __func__
static INLINE int av1_read_uniform(aom_reader *r, int n) {
const int l = get_unsigned_bits(n);
const int m = (1 << l) - n;
- const int v = aom_read_literal(r, l - 1, ACCT_STR);
+ const int v = aom_read_literal(r, l - 1, ACCT_INFO("v"));
assert(l != 0);
if (v < m)
return v;
else
- return (v << 1) - m + aom_read_literal(r, 1, ACCT_STR);
+ return (v << 1) - m + aom_read_literal(r, 1, ACCT_INFO());
}
typedef void (*palette_visitor_fn_t)(MACROBLOCKD *const xd, int plane,
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 91046a3..cb43098 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -20,24 +20,22 @@
#include "av1/common/reconintra.h"
#include "av1/decoder/decodemv.h"
-#define ACCT_STR __func__
-
static int read_golomb(MACROBLOCKD *xd, aom_reader *r) {
int x = 1;
int length = 0;
#if CONFIG_BYPASS_IMPROVEMENT
- length = aom_read_unary(r, 21, ACCT_STR);
+ length = aom_read_unary(r, 21, ACCT_INFO("length"));
if (length > 20) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Invalid length in read_golomb");
}
x = 1 << length;
- x += aom_read_literal(r, length, ACCT_STR);
+ x += aom_read_literal(r, length, ACCT_INFO());
#else
int i = 0;
while (!i) {
- i = aom_read_bit(r, ACCT_STR);
+ i = aom_read_bit(r, ACCT_INFO());
++length;
if (length > 20) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
@@ -47,7 +45,7 @@
}
for (i = 0; i < length - 1; ++i) {
x <<= 1;
- x += aom_read_bit(r, ACCT_STR);
+ x += aom_read_bit(r, ACCT_INFO());
}
#endif // CONFIG_BYPASS_IMPROVEMENT
@@ -73,42 +71,45 @@
static INLINE void read_coeffs_reverse_2d(
aom_reader *r,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
int start_si, int end_si, const int16_t *scan, int bwl, uint8_t *levels,
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
base_lf_cdf_arr base_lf_cdf, br_cdf_arr br_lf_cdf, int plane,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
base_cdf_arr base_cdf, br_cdf_arr br_cdf) {
for (int c = end_si; c >= start_si; --c) {
const int pos = scan[c];
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
int level = 0;
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, 0, plane);
if (limits) {
const int coeff_ctx = get_lower_levels_ctx_lf_2d(levels, pos, bwl);
- level +=
- aom_read_symbol(r, base_lf_cdf[coeff_ctx], LF_BASE_SYMBOLS, ACCT_STR);
+ level += aom_read_symbol(r, base_lf_cdf[coeff_ctx], LF_BASE_SYMBOLS,
+ ACCT_INFO("level", "base_lf_cdf"));
if (level > LF_NUM_BASE_LEVELS) {
const int br_ctx = get_br_lf_ctx_2d(levels, pos, bwl);
aom_cdf_prob *cdf = br_lf_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_lf_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
}
} else {
const int coeff_ctx = get_lower_levels_ctx_2d(levels, pos, bwl);
- level += aom_read_symbol(r, base_cdf[coeff_ctx], 4, ACCT_STR);
+ level += aom_read_symbol(r, base_cdf[coeff_ctx], 4,
+ ACCT_INFO("level", "base_cdf"));
if (level > NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx_2d(levels, pos, bwl);
aom_cdf_prob *cdf = br_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
@@ -117,62 +118,67 @@
#else
const int coeff_ctx = get_lower_levels_ctx_2d(levels, pos, bwl, tx_size);
const int nsymbs = 4;
- int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR);
+ int level =
+ aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_INFO("level"));
if (level > NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx_2d(levels, pos, bwl);
aom_cdf_prob *cdf = br_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
levels[get_padded_idx(pos, bwl)] = level;
}
}
static INLINE void read_coeffs_reverse(aom_reader *r,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
TX_CLASS tx_class, int start_si,
int end_si, const int16_t *scan, int bwl,
uint8_t *levels,
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
base_lf_cdf_arr base_lf_cdf,
br_cdf_arr br_lf_cdf, int plane,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
base_cdf_arr base_cdf,
br_cdf_arr br_cdf) {
for (int c = end_si; c >= start_si; --c) {
const int pos = scan[c];
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
int level = 0;
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
if (limits) {
const int coeff_ctx = get_lower_levels_lf_ctx(levels, pos, bwl, tx_class);
- level +=
- aom_read_symbol(r, base_lf_cdf[coeff_ctx], LF_BASE_SYMBOLS, ACCT_STR);
+ level += aom_read_symbol(r, base_lf_cdf[coeff_ctx], LF_BASE_SYMBOLS,
+ ACCT_INFO("level", "base_lf_cdf"));
if (level > LF_NUM_BASE_LEVELS) {
const int br_ctx = get_br_lf_ctx(levels, pos, bwl, tx_class);
aom_cdf_prob *cdf = br_lf_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_lf_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
}
} else {
const int coeff_ctx = get_lower_levels_ctx(levels, pos, bwl, tx_class);
- level += aom_read_symbol(r, base_cdf[coeff_ctx], 4, ACCT_STR);
+ level += aom_read_symbol(r, base_cdf[coeff_ctx], 4,
+ ACCT_INFO("level", "base_cdf"));
if (level > NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class);
aom_cdf_prob *cdf = br_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
@@ -182,17 +188,19 @@
const int coeff_ctx =
get_lower_levels_ctx(levels, pos, bwl, tx_size, tx_class);
const int nsymbs = 4;
- int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR);
+ int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs,
+ ACCT_INFO("level", "base_cdf"));
if (level > NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class);
aom_cdf_prob *cdf = br_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("br_cdf", "k"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
levels[get_padded_idx(pos, bwl)] = level;
}
}
@@ -206,12 +214,14 @@
const int pos = scan[c];
const int coeff_ctx = get_upper_levels_ctx_2d(levels, pos, bwl);
const int nsymbs = 4;
- int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR);
+ int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs,
+ ACCT_INFO("level", "base_cdf"));
if (level > NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx_skip(levels, pos, bwl);
aom_cdf_prob *cdf = br_cdf[br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
@@ -220,6 +230,98 @@
}
}
+#if CONFIG_ATC_DCTX_ALIGNED
+// Decode the end-of-block syntax.
+static INLINE void decode_eob(DecoderCodingBlock *dcb, aom_reader *const r,
+ const int plane, const TX_SIZE tx_size) {
+ MACROBLOCKD *const xd = &dcb->xd;
+ const PLANE_TYPE plane_type = get_plane_type(plane);
+ FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
+ const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
+ eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
+ uint16_t *const eob = &(eob_data->eob);
+ eob_info *bob_data = dcb->bob_data[plane] + dcb->txb_offset[plane];
+ uint16_t *const bob = &(bob_data->eob);
+
+ int eob_extra = 0;
+ int eob_pt = 1;
+ const int eob_multi_size = txsize_log2_minus4[tx_size];
+ switch (eob_multi_size) {
+ case 0:
+ eob_pt = aom_read_symbol(r, ec_ctx->eob_flag_cdf16[plane_type],
+ EOB_MAX_SYMS - 6,
+ ACCT_INFO("eob_pt", "eob_multi_size:0")) +
+ 1;
+ break;
+ case 1:
+ eob_pt = aom_read_symbol(r, ec_ctx->eob_flag_cdf32[plane_type],
+ EOB_MAX_SYMS - 5,
+ ACCT_INFO("eob_pt", "eob_multi_size:1")) +
+ 1;
+ break;
+ case 2:
+ eob_pt = aom_read_symbol(r, ec_ctx->eob_flag_cdf64[plane_type],
+ EOB_MAX_SYMS - 4,
+ ACCT_INFO("eob_pt", "eob_multi_size:2")) +
+ 1;
+ break;
+ case 3:
+ eob_pt = aom_read_symbol(r, ec_ctx->eob_flag_cdf128[plane_type],
+ EOB_MAX_SYMS - 3,
+ ACCT_INFO("eob_pt", "eob_multi_size:3")) +
+ 1;
+ break;
+ case 4:
+ eob_pt = aom_read_symbol(r, ec_ctx->eob_flag_cdf256[plane_type],
+ EOB_MAX_SYMS - 2,
+ ACCT_INFO("eob_pt", "eob_multi_size:4")) +
+ 1;
+ break;
+ case 5:
+ eob_pt = aom_read_symbol(r, ec_ctx->eob_flag_cdf512[plane_type],
+ EOB_MAX_SYMS - 1,
+ ACCT_INFO("eob_pt", "eob_multi_size:5")) +
+ 1;
+ break;
+ case 6:
+ default:
+ eob_pt =
+ aom_read_symbol(r, ec_ctx->eob_flag_cdf1024[plane_type], EOB_MAX_SYMS,
+ ACCT_INFO("eob_pt", "eob_multi_size:6")) +
+ 1;
+ break;
+ }
+ const int eob_offset_bits = av1_eob_offset_bits[eob_pt];
+ if (eob_offset_bits > 0) {
+ const int eob_ctx = eob_pt - 3;
+ int bit =
+ aom_read_symbol(r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx],
+ 2, ACCT_INFO("eob_extra_cdf"));
+ if (bit) {
+ eob_extra += (1 << (eob_offset_bits - 1));
+ }
+#if CONFIG_BYPASS_IMPROVEMENT
+ eob_extra +=
+ aom_read_literal(r, eob_offset_bits - 1, ACCT_INFO("eob_extra"));
+#else
+ for (int i = 1; i < eob_offset_bits; i++) {
+ bit = aom_read_bit(r, ACCT_INFO("eob_offset_bits"));
+ if (bit) {
+ eob_extra += (1 << (eob_offset_bits - 1 - i));
+ }
+ }
+#endif // CONFIG_BYPASS_IMPROVEMENT
+ }
+ *eob = rec_eob_pos(eob_pt, eob_extra);
+ *bob = *eob; // escape character
+#if CONFIG_CONTEXT_DERIVATION
+ if (plane == AOM_PLANE_U) {
+ xd->eob_u = *eob;
+ }
+#endif // CONFIG_CONTEXT_DERIVATION
+}
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
uint8_t av1_read_sig_txtype(const AV1_COMMON *const cm, DecoderCodingBlock *dcb,
aom_reader *const r, const int blk_row,
const int blk_col, const int plane,
@@ -229,6 +331,10 @@
FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
uint16_t *const eob = &(eob_data->eob);
uint16_t *const max_scan_line = &(eob_data->max_scan_line);
@@ -250,15 +356,16 @@
int all_zero;
if (plane == AOM_PLANE_Y || plane == AOM_PLANE_U) {
all_zero = aom_read_symbol(r, ec_ctx->txb_skip_cdf[txs_ctx][txb_skip_ctx],
- 2, ACCT_STR);
+ 2, ACCT_INFO("all_zero", "plane_y_or_u"));
} else {
txb_skip_ctx += (xd->eob_u_flag ? V_TXB_SKIP_CONTEXT_OFFSET : 0);
- all_zero =
- aom_read_symbol(r, ec_ctx->v_txb_skip_cdf[txb_skip_ctx], 2, ACCT_STR);
+ all_zero = aom_read_symbol(r, ec_ctx->v_txb_skip_cdf[txb_skip_ctx], 2,
+ ACCT_INFO("all_zero", "plane_v"));
}
#else
- const int all_zero = aom_read_symbol(
- r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx], 2, ACCT_STR);
+ const int all_zero =
+ aom_read_symbol(r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx],
+ 2, ACCT_INFO("all_zero"));
#endif // CONFIG_CONTEXT_DERIVATION
#if CONFIG_INSPECTION
@@ -276,7 +383,7 @@
}
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_CROSS_CHROMA_TX && !CONFIG_ATC_DCTX_ALIGNED
if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) {
if (!all_zero) {
av1_read_cctx_type(cm, xd, blk_row, blk_col, tx_size, r);
@@ -291,7 +398,7 @@
CCTX_NONE);
}
}
-#endif // CONFIG_CROSS_CHROMA_TX
+#endif // CONFIG_CROSS_CHROMA_TX && !CONFIG_ATC_DCTX_ALIGNED
if (all_zero) {
*max_scan_line = 0;
@@ -300,9 +407,33 @@
}
return 0;
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ decode_eob(dcb, r, plane, tx_size);
+ av1_read_tx_type(cm, xd, blk_row, blk_col, tx_size, r, plane, *eob,
+ is_inter ? 0 : *eob);
+
+#if CONFIG_CROSS_CHROMA_TX
+ if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) {
+ const int skip_cctx = is_inter ? 0 : (*eob == 1);
+ if (!all_zero && !skip_cctx) {
+ av1_read_cctx_type(cm, xd, blk_row, blk_col, tx_size, r);
+ } else {
+ int row_offset, col_offset;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ get_chroma_mi_offsets(xd, &row_offset, &col_offset);
+#else
+ get_chroma_mi_offsets(xd, tx_size, &row_offset, &col_offset);
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset, tx_size,
+ CCTX_NONE);
+ }
+ }
+#endif // CONFIG_CROSS_CHROMA_TX
+#else
if (plane == AOM_PLANE_Y) { // only y plane's tx_type is transmitted
av1_read_tx_type(cm, xd, blk_row, blk_col, tx_size, r);
}
+#endif // CONFIG_ATC_DCTX_ALIGNED
return 1;
}
@@ -324,6 +455,18 @@
const int shift = av1_get_tx_scale(tx_size);
const int bwl = get_txb_bwl(tx_size);
const int width = get_txb_wide(tx_size);
+ const int height = get_txb_high(tx_size);
+#if CONFIG_INSPECTION
+ tran_low_t *const tcoeffs_copy =
+ dcb->dqcoeff_block_copy[plane] + dcb->cb_offset[plane];
+ tran_low_t *const quant_coeffs =
+ dcb->qcoeff_block[plane] + dcb->cb_offset[plane];
+ tran_low_t *const dequant_values =
+ dcb->dequant_values[plane] + dcb->cb_offset[plane];
+ memset(tcoeffs_copy, 0, sizeof(tran_low_t) * width * height);
+ memset(quant_coeffs, 0, sizeof(tran_low_t) * width * height);
+ memset(dequant_values, 0, sizeof(tran_low_t) * width * height);
+#endif // CONFIG_INSPECTION
int cul_level = 0;
int dc_val = 0;
uint8_t levels_buf[TX_PAD_2D];
@@ -333,12 +476,21 @@
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
eob_data->max_scan_line = 0;
eob_data->eob = av1_get_max_eob(tx_size);
+#if CONFIG_ATC_DCTX_ALIGNED
+ eob_info *bob_data = dcb->bob_data[plane] + dcb->txb_offset[plane];
+ bob_data->max_scan_line = 0;
+#endif // CONFIG_ATC_DCTX_ALIGNED
const TX_TYPE tx_type =
av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size,
cm->features.reduced_tx_set_used);
const qm_val_t *iqmatrix =
av1_get_iqmatrix(&cm->quant_params, xd, plane, tx_size, tx_type);
+#if CONFIG_INSPECTION
+ for (int c = 0; c < width * height; c++) {
+ dequant_values[c] = get_dqv(dequant, c, iqmatrix);
+ }
+#endif // CONFIG_INSPECTION
const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type);
const int16_t *const scan = scan_order->scan;
@@ -347,8 +499,34 @@
memset(signs_buf, 0, sizeof(*signs_buf) * TX_PAD_2D);
base_cdf_arr base_cdf = ec_ctx->coeff_base_cdf_idtx;
br_cdf_arr br_cdf = ec_ctx->coeff_br_cdf_idtx;
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob = av1_get_max_eob(tx_size) - bob_data->eob;
+ {
+ const int pos = scan[bob];
+ const int coeff_ctx_bob = get_lower_levels_ctx_bob(bwl, height, bob);
+ const int nsymbs_bob = 3;
+ aom_cdf_prob *cdf_bob = ec_ctx->coeff_base_bob_cdf[coeff_ctx_bob];
+ int level = aom_read_symbol(r, cdf_bob, nsymbs_bob,
+ ACCT_INFO("level", "cdf_bob")) +
+ 1;
+ if (level > NUM_BASE_LEVELS) {
+ const int br_ctx = get_br_ctx_skip(levels, pos, bwl);
+ aom_cdf_prob *cdf = br_cdf[br_ctx];
+ for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
+ const int k =
+ aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_INFO("k", "br_cdf"));
+ level += k;
+ if (k < BR_CDF_SIZE - 1) break;
+ }
+ }
+ levels[get_padded_idx_left(pos, bwl)] = level;
+ }
+ read_coeffs_forward_2d(r, bob + 1, eob_data->eob - 1, scan, bwl, levels,
+ base_cdf, br_cdf);
+#else
read_coeffs_forward_2d(r, 0, eob_data->eob - 1, scan, bwl, levels, base_cdf,
br_cdf);
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
for (int c = eob_data->eob - 1; c >= 0; --c) {
@@ -358,8 +536,8 @@
if (level) {
eob_data->max_scan_line = AOMMAX(eob_data->max_scan_line, pos);
int idtx_sign_ctx = get_sign_ctx_skip(signs, levels, pos, bwl);
- sign =
- aom_read_symbol(r, ec_ctx->idtx_sign_cdf[idtx_sign_ctx], 2, ACCT_STR);
+ sign = aom_read_symbol(r, ec_ctx->idtx_sign_cdf[idtx_sign_ctx], 2,
+ ACCT_INFO("sign"));
signs[get_padded_idx(pos, bwl)] = sign > 0 ? -1 : 1;
if (level >= MAX_BASE_BR_RANGE) {
level += read_golomb(xd, r);
@@ -381,6 +559,10 @@
dq_coeff = -dq_coeff;
}
tcoeffs[pos] = clamp(dq_coeff, min_value, max_value);
+#if CONFIG_INSPECTION
+ tcoeffs_copy[pos] = tcoeffs[pos];
+ quant_coeffs[pos] = sign ? -level : level;
+#endif // CONFIG_INSPECTION
}
}
cul_level = AOMMIN(COEFF_CONTEXT_MASK, cul_level);
@@ -399,13 +581,14 @@
int q_index;
const int pos = scan[0];
int ctx_idx = get_base_ctx_ph(levels, pos, bwl, tx_class);
- q_index = aom_read_symbol(r, base_cdf_ph[ctx_idx], 4, ACCT_STR);
+ q_index = aom_read_symbol(r, base_cdf_ph[ctx_idx], 4, ACCT_INFO("q_index"));
if (q_index > NUM_BASE_LEVELS) {
ctx_idx = get_par_br_ctx(levels, pos, bwl, tx_class);
aom_cdf_prob *cdf_br = br_cdf_ph[ctx_idx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf_br, BR_CDF_SIZE, ACCT_STR);
+ const int k =
+ aom_read_symbol(r, cdf_br, BR_CDF_SIZE, ACCT_INFO("k", "cdf_br"));
q_index += k;
if (k < BR_CDF_SIZE - 1) break;
}
@@ -436,15 +619,32 @@
const int bwl = get_txb_bwl(tx_size);
const int width = get_txb_wide(tx_size);
const int height = get_txb_high(tx_size);
+#if CONFIG_INSPECTION
+ tran_low_t *const tcoeffs_copy =
+ dcb->dqcoeff_block_copy[plane] + dcb->cb_offset[plane];
+ tran_low_t *const quant_coeffs =
+ dcb->qcoeff_block[plane] + dcb->cb_offset[plane];
+ tran_low_t *const dequant_values =
+ dcb->dequant_values[plane] + dcb->cb_offset[plane];
+ memset(tcoeffs_copy, 0, sizeof(tran_low_t) * width * height);
+ memset(quant_coeffs, 0, sizeof(tran_low_t) * width * height);
+ memset(dequant_values, 0, sizeof(tran_low_t) * width * height);
+#endif // CONFIG_INSPECTION
int cul_level = 0;
int dc_val = 0;
uint8_t levels_buf[TX_PAD_2D];
uint8_t *const levels = set_levels(levels_buf, width);
+#if !CONFIG_ATC_DCTX_ALIGNED
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
uint16_t *const eob = &(eob_data->eob);
uint16_t *const max_scan_line = &(eob_data->max_scan_line);
*max_scan_line = 0;
*eob = 0;
+#else
+ eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
+ uint16_t *const eob = &(eob_data->eob);
+ uint16_t *const max_scan_line = &(eob_data->max_scan_line);
+#endif // !CONFIG_ATC_DCTX_ALIGNED
#if DEBUG_EXTQUANT
fprintf(cm->fDecCoeffLog,
@@ -459,8 +659,14 @@
const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
const qm_val_t *iqmatrix =
av1_get_iqmatrix(&cm->quant_params, xd, plane, tx_size, tx_type);
+#if CONFIG_INSPECTION
+ for (int c = 0; c < width * height; c++) {
+ dequant_values[c] = get_dqv(dequant, c, iqmatrix);
+ }
+#endif // CONFIG_INSPECTION
const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type);
const int16_t *const scan = scan_order->scan;
+#if !CONFIG_ATC_DCTX_ALIGNED
int eob_extra = 0;
int eob_pt = 1;
@@ -470,44 +676,44 @@
case 0:
eob_pt =
aom_read_symbol(r, ec_ctx->eob_flag_cdf16[plane_type][eob_multi_ctx],
- 5, ACCT_STR) +
+ 5, ACCT_INFO("eob_pt", "eob_multi_size:0")) +
1;
break;
case 1:
eob_pt =
aom_read_symbol(r, ec_ctx->eob_flag_cdf32[plane_type][eob_multi_ctx],
- 6, ACCT_STR) +
+ 6, ACCT_INFO("eob_pt", "eob_multi_size:1")) +
1;
break;
case 2:
eob_pt =
aom_read_symbol(r, ec_ctx->eob_flag_cdf64[plane_type][eob_multi_ctx],
- 7, ACCT_STR) +
+ 7, ACCT_INFO("eob_pt", "eob_multi_size:2")) +
1;
break;
case 3:
eob_pt =
aom_read_symbol(r, ec_ctx->eob_flag_cdf128[plane_type][eob_multi_ctx],
- 8, ACCT_STR) +
+ 8, ACCT_INFO("eob_pt", "eob_multi_size:3")) +
1;
break;
case 4:
eob_pt =
aom_read_symbol(r, ec_ctx->eob_flag_cdf256[plane_type][eob_multi_ctx],
- 9, ACCT_STR) +
+ 9, ACCT_INFO("eob_pt", "eob_multi_size:4")) +
1;
break;
case 5:
eob_pt =
aom_read_symbol(r, ec_ctx->eob_flag_cdf512[plane_type][eob_multi_ctx],
- 10, ACCT_STR) +
+ 10, ACCT_INFO("eob_pt", "eob_multi_size:5")) +
1;
break;
case 6:
default:
eob_pt = aom_read_symbol(
r, ec_ctx->eob_flag_cdf1024[plane_type][eob_multi_ctx], 11,
- ACCT_STR) +
+ ACCT_INFO("eob_pt", "eob_multi_size:6")) +
1;
break;
}
@@ -515,17 +721,19 @@
const int eob_offset_bits = av1_eob_offset_bits[eob_pt];
if (eob_offset_bits > 0) {
const int eob_ctx = eob_pt - 3;
- int bit = aom_read_symbol(
- r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2, ACCT_STR);
+ int bit =
+ aom_read_symbol(r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx],
+ 2, ACCT_INFO("eob_offset_bits"));
if (bit) {
eob_extra += (1 << (eob_offset_bits - 1));
}
#if CONFIG_BYPASS_IMPROVEMENT
- eob_extra += aom_read_literal(r, eob_offset_bits - 1, ACCT_STR);
+ eob_extra +=
+ aom_read_literal(r, eob_offset_bits - 1, ACCT_INFO("eob_extra"));
#else
for (int i = 1; i < eob_offset_bits; i++) {
- bit = aom_read_bit(r, ACCT_STR);
+ bit = aom_read_bit(r, ACCT_INFO("eob_offset_bits"));
if (bit) {
eob_extra += (1 << (eob_offset_bits - 1 - i));
}
@@ -539,10 +747,15 @@
xd->eob_u = *eob;
}
#endif // CONFIG_CONTEXT_DERIVATION
+#endif // !CONFIG_ATC_DCTX_ALIGNED
// read sec_tx_type here
// Only y plane's sec_tx_type is transmitted
- if ((plane == AOM_PLANE_Y) && (cm->seq_params.enable_ist)) {
+ if ((plane == AOM_PLANE_Y) && (cm->seq_params.enable_ist)
+#if CONFIG_ATC_DCTX_ALIGNED
+ && (*eob != 1)
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ ) {
av1_read_sec_tx_type(cm, xd, blk_row, blk_col, tx_size, eob, r);
}
//
@@ -560,7 +773,7 @@
const int c = *eob - 1;
const int pos = scan[c];
const int coeff_ctx = get_lower_levels_ctx_eob(bwl, height, c);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
int level = 0;
const int row = pos >> bwl;
const int col = pos - (row << bwl);
@@ -568,12 +781,15 @@
if (limits) {
aom_cdf_prob *cdf =
ec_ctx->coeff_base_lf_eob_cdf[txs_ctx][plane_type][coeff_ctx];
- level += aom_read_symbol(r, cdf, LF_BASE_SYMBOLS - 1, ACCT_STR) + 1;
+ level += aom_read_symbol(r, cdf, LF_BASE_SYMBOLS - 1,
+ ACCT_INFO("level", "coeff_base_lf_eob_cdf")) +
+ 1;
if (level > LF_NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx_lf_eob(pos, tx_class);
cdf = ec_ctx->coeff_br_lf_cdf[plane_type][br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE,
+ ACCT_INFO("k", "coeff_br_lf_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
@@ -581,12 +797,15 @@
} else {
aom_cdf_prob *cdf =
ec_ctx->coeff_base_eob_cdf[txs_ctx][plane_type][coeff_ctx];
- level += aom_read_symbol(r, cdf, 3, ACCT_STR) + 1;
+ level +=
+ aom_read_symbol(r, cdf, 3, ACCT_INFO("level", "coeff_base_eob_cdf")) +
+ 1;
if (level > NUM_BASE_LEVELS) {
const int br_ctx = 0; /* get_lf_ctx_eob */
cdf = ec_ctx->coeff_br_cdf[plane_type][br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE,
+ ACCT_INFO("k", "coeff_br_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
@@ -596,17 +815,20 @@
const int nsymbs = 3;
aom_cdf_prob *cdf =
ec_ctx->coeff_base_eob_cdf[txs_ctx][plane_type][coeff_ctx];
- int level = aom_read_symbol(r, cdf, nsymbs, ACCT_STR) + 1;
+ int level = aom_read_symbol(r, cdf, nsymbs,
+ ACCT_INFO("level", "coeff_base_eob_cdf")) +
+ 1;
if (level > NUM_BASE_LEVELS) {
const int br_ctx = get_br_ctx_eob(pos, bwl, tx_class);
cdf = ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][br_ctx];
for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
- const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
+ const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE,
+ ACCT_INFO("k", "coeff_br_cdf"));
level += k;
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
levels[get_padded_idx(pos, bwl)] = level;
}
#if CONFIG_PAR_HIDING
@@ -617,21 +839,21 @@
bool is_hidden = false;
#endif // CONFIG_PAR_HIDING
if (*eob > 1) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
base_lf_cdf_arr base_lf_cdf =
ec_ctx->coeff_base_lf_cdf[txs_ctx][plane_type];
br_cdf_arr br_lf_cdf = ec_ctx->coeff_br_lf_cdf[plane_type];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
base_cdf_arr base_cdf = ec_ctx->coeff_base_cdf[txs_ctx][plane_type];
br_cdf_arr br_cdf =
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
ec_ctx->coeff_br_cdf[plane_type];
#else
ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#if CONFIG_PAR_HIDING
if (tx_class == TX_CLASS_2D) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
read_coeffs_reverse_2d(r, 1, *eob - 2, scan, bwl, levels, base_lf_cdf,
br_lf_cdf, plane, base_cdf, br_cdf);
if (enable_parity_hiding) {
@@ -675,9 +897,9 @@
read_coeffs_reverse(r, tx_size, tx_class, 0, 0, scan, bwl, levels,
base_cdf, br_cdf);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
read_coeffs_reverse(r, tx_class, 1, *eob - 2, scan, bwl, levels,
base_lf_cdf, br_lf_cdf, plane, base_cdf, br_cdf);
if (enable_parity_hiding) {
@@ -721,11 +943,11 @@
read_coeffs_reverse(r, tx_size, tx_class, 0, 0, scan, bwl, levels,
base_cdf, br_cdf);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
#else
if (tx_class == TX_CLASS_2D) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
read_coeffs_reverse_2d(r, 1, *eob - 2, scan, bwl, levels, base_lf_cdf,
br_lf_cdf, plane, base_cdf, br_cdf);
read_coeffs_reverse(r, tx_class, 0, 0, scan, bwl, levels, base_lf_cdf,
@@ -735,15 +957,15 @@
base_cdf, br_cdf);
read_coeffs_reverse(r, tx_size, tx_class, 0, 0, scan, bwl, levels,
base_cdf, br_cdf);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
read_coeffs_reverse(r, tx_class, 0, *eob - 2, scan, bwl, levels,
base_lf_cdf, br_lf_cdf, plane, base_cdf, br_cdf);
#else
read_coeffs_reverse(r, tx_size, tx_class, 0, *eob - 2, scan, bwl, levels,
base_cdf, br_cdf);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
#endif // CONFIG_PAR_HIDING
}
@@ -764,35 +986,37 @@
#if CONFIG_CONTEXT_DERIVATION
if (plane == AOM_PLANE_Y || plane == AOM_PLANE_U) {
sign = aom_read_symbol(
- r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], 2, ACCT_STR);
+ r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], 2,
+ ACCT_INFO("sign", "dc_sign_cdf", "plane_y_or_u"));
} else {
int32_t tmp_sign = 0;
if (c < xd->eob_u) tmp_sign = xd->tmp_sign[0];
- sign = aom_read_symbol(
- r, ec_ctx->v_dc_sign_cdf[tmp_sign][dc_sign_ctx], 2, ACCT_STR);
+ sign =
+ aom_read_symbol(r, ec_ctx->v_dc_sign_cdf[tmp_sign][dc_sign_ctx],
+ 2, ACCT_INFO("sign", "v_dc_sign_cdf", "plane_v"));
}
if (plane == AOM_PLANE_U) xd->tmp_sign[0] = (sign ? 2 : 1);
#else
sign = aom_read_symbol(r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx],
- 2, ACCT_STR);
+ 2, ACCT_INFO("sign", "dc_sign_cdf"));
#endif // CONFIG_CONTEXT_DERIVATION
} else {
#if CONFIG_CONTEXT_DERIVATION
if (plane == AOM_PLANE_Y || plane == AOM_PLANE_U)
- sign = aom_read_bit(r, ACCT_STR);
+ sign = aom_read_bit(r, ACCT_INFO("sign", "plane_y_or_u"));
else {
int32_t tmp_sign = 0;
if (c < xd->eob_u) tmp_sign = xd->tmp_sign[pos];
- sign =
- aom_read_symbol(r, ec_ctx->v_ac_sign_cdf[tmp_sign], 2, ACCT_STR);
+ sign = aom_read_symbol(r, ec_ctx->v_ac_sign_cdf[tmp_sign], 2,
+ ACCT_INFO("sign", "v_ac_sign_cdf", "plane_v"));
}
if (plane == AOM_PLANE_U) xd->tmp_sign[pos] = (sign ? 2 : 1);
#else
- sign = aom_read_bit(r, ACCT_STR);
+ sign = aom_read_bit(r, ACCT_INFO("sign"));
#endif // CONFIG_CONTEXT_DERIVATION
}
#if CONFIG_PAR_HIDING
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (is_hidden && c == 0) {
if (level >= (MAX_BASE_BR_RANGE << 1)) {
level += (read_golomb(xd, r) << 1);
@@ -821,9 +1045,9 @@
level += read_golomb(xd, r);
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#else
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -840,7 +1064,7 @@
if (level >= MAX_BASE_BR_RANGE) {
level += read_golomb(xd, r);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#endif // CONFIG_PAR_HIDING
if (c == 0) dc_val = sign ? -level : level;
@@ -860,6 +1084,10 @@
dq_coeff = -dq_coeff;
}
tcoeffs[pos] = clamp(dq_coeff, min_value, max_value);
+#if CONFIG_INSPECTION
+ tcoeffs_copy[pos] = tcoeffs[pos];
+ quant_coeffs[pos] = sign ? -level : level;
+#endif // CONFIG_INSPECTION
}
}
#if DEBUG_EXTQUANT
diff --git a/av1/decoder/detokenize.c b/av1/decoder/detokenize.c
index 1fb2975..b71fd40 100644
--- a/av1/decoder/detokenize.c
+++ b/av1/decoder/detokenize.c
@@ -17,8 +17,6 @@
#include "av1/common/blockd.h"
#include "av1/decoder/detokenize.h"
-#define ACCT_STR __func__
-
#include "av1/common/common.h"
#include "av1/common/entropy.h"
#include "av1/common/idct.h"
@@ -33,13 +31,13 @@
int rows = param->rows;
int cols = param->cols;
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
IdentityRowCdf identity_row_cdf = param->identity_row_cdf;
int prev_identity_row_flag = 0;
for (int y = 0; y < rows; y++) {
const int ctx = y == 0 ? 2 : prev_identity_row_flag;
- int identity_row_flag =
- aom_read_symbol(r, identity_row_cdf[ctx], 2, ACCT_STR);
+ int identity_row_flag = aom_read_symbol(r, identity_row_cdf[ctx], 2,
+ ACCT_INFO("identity_row_flag"));
for (int x = 0; x < cols; x++) {
if (identity_row_flag && x > 0) {
color_map[y * plane_block_width + x] =
@@ -50,8 +48,9 @@
const int color_ctx = av1_get_palette_color_index_context(
color_map, plane_block_width, y, x, n, color_order, NULL,
identity_row_flag, prev_identity_row_flag);
- const int color_idx = aom_read_symbol(
- r, color_map_cdf[n - PALETTE_MIN_SIZE][color_ctx], n, ACCT_STR);
+ const int color_idx =
+ aom_read_symbol(r, color_map_cdf[n - PALETTE_MIN_SIZE][color_ctx],
+ n, ACCT_INFO("color_idx"));
assert(color_idx >= 0 && color_idx < n);
color_map[y * plane_block_width + x] = color_order[color_idx];
}
@@ -68,8 +67,9 @@
for (int j = AOMMIN(i, cols - 1); j >= AOMMAX(0, i - rows + 1); --j) {
const int color_ctx = av1_get_palette_color_index_context(
color_map, plane_block_width, (i - j), j, n, color_order, NULL);
- const int color_idx = aom_read_symbol(
- r, color_map_cdf[n - PALETTE_MIN_SIZE][color_ctx], n, ACCT_STR);
+ const int color_idx =
+ aom_read_symbol(r, color_map_cdf[n - PALETTE_MIN_SIZE][color_ctx], n,
+ ACCT_INFO("color_idx"));
assert(color_idx >= 0 && color_idx < n);
color_map[(i - j) * plane_block_width + j] = color_order[color_idx];
}
@@ -98,10 +98,10 @@
xd->plane[plane].color_index_map + xd->color_index_map_offset[plane];
params.map_cdf = plane ? xd->tile_ctx->palette_uv_color_index_cdf
: xd->tile_ctx->palette_y_color_index_cdf;
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
params.identity_row_cdf = plane ? xd->tile_ctx->identity_row_cdf_uv
: xd->tile_ctx->identity_row_cdf_y;
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
const MB_MODE_INFO *const mbmi = xd->mi[0];
params.n_colors = mbmi->palette_mode_info.palette_size[plane];
av1_get_block_dimensions(mbmi->sb_type[plane > 0], plane, xd,
diff --git a/av1/decoder/inspection.c b/av1/decoder/inspection.c
index 75e06cc..2cba1fb 100644
--- a/av1/decoder/inspection.c
+++ b/av1/decoder/inspection.c
@@ -11,6 +11,7 @@
*/
#include "av1/decoder/decoder.h"
#include "av1/decoder/inspection.h"
+#include "av1/common/blockd.h"
#include "av1/common/enums.h"
#include "av1/common/cdef.h"
@@ -19,6 +20,12 @@
fd->mi_rows = mi_rows;
fd->mi_grid = (insp_mi_data *)aom_malloc(sizeof(insp_mi_data) * fd->mi_rows *
fd->mi_cols);
+ fd->max_sb_rows =
+ (mi_rows + (1 << MIN_MIB_SIZE_LOG2) - 1) / (1 << MIN_MIB_SIZE_LOG2);
+ fd->max_sb_cols =
+ (mi_cols + (1 << MIN_MIB_SIZE_LOG2) - 1) / (1 << MIN_MIB_SIZE_LOG2);
+ fd->sb_grid = (insp_sb_data *)aom_calloc(sizeof(insp_sb_data),
+ fd->max_sb_rows * fd->max_sb_cols);
}
void ifd_init(insp_frame_data *fd, int frame_width, int frame_height) {
@@ -30,6 +37,70 @@
void ifd_clear(insp_frame_data *fd) {
aom_free(fd->mi_grid);
fd->mi_grid = NULL;
+ for (int i = 0; i < fd->max_sb_rows; i++) {
+ for (int j = 0; j < fd->max_sb_cols; j++) {
+ insp_sb_data *sb = &fd->sb_grid[i * fd->max_sb_cols + j];
+ // Note: NULL checking happens within av1_free_ptree_recursive
+ av1_free_ptree_recursive(sb->partition_tree_luma);
+ av1_free_ptree_recursive(sb->partition_tree_chroma);
+ }
+ }
+ aom_free(fd->sb_grid);
+ fd->sb_grid = NULL;
+}
+
+PARTITION_TREE *copy_partition_tree(PARTITION_TREE *orig,
+ PARTITION_TREE *parent) {
+ PARTITION_TREE *copy = av1_alloc_ptree_node(NULL, 0);
+ memcpy(copy, orig, sizeof(PARTITION_TREE));
+ copy->parent = parent;
+ for (size_t i = 0; i < sizeof(copy->sub_tree) / sizeof(copy->sub_tree[0]);
+ i++) {
+ if (copy->sub_tree[i] != NULL) {
+ copy->sub_tree[i] = copy_partition_tree(orig->sub_tree[i], copy);
+ }
+ }
+ return copy;
+}
+
+int ifd_inspect_superblock(insp_frame_data *fd, void *decoder) {
+ struct AV1Decoder *pbi = (struct AV1Decoder *)decoder;
+ AV1_COMMON *const cm = &pbi->common;
+ const CommonModeInfoParams *const mi_params = &cm->mi_params;
+ if (fd->mi_rows != mi_params->mi_rows || fd->mi_cols != mi_params->mi_cols) {
+ ifd_clear(fd);
+ ifd_init_mi_rc(fd, mi_params->mi_rows, mi_params->mi_cols);
+ }
+
+ int sb_size = cm->seq_params.sb_size;
+ int sb_width = mi_size_wide[sb_size];
+ int sb_height = mi_size_high[sb_size];
+
+ int sb_row = pbi->td.dcb.xd.sbi->mi_row / sb_height;
+ int sb_col = pbi->td.dcb.xd.sbi->mi_col / sb_width;
+
+ PARTITION_TREE *luma_tree = pbi->td.dcb.xd.sbi->ptree_root[0];
+ PARTITION_TREE *chroma_tree = pbi->td.dcb.xd.sbi->ptree_root[1];
+ insp_sb_data *sb = &fd->sb_grid[sb_row * fd->max_sb_cols + sb_col];
+ sb->partition_tree_luma = copy_partition_tree(luma_tree, NULL);
+ // Semi-decoupled partitioning is enabled only for intra-frames.
+ int use_sdp = (frame_is_intra_only(cm) && !cm->seq_params.monochrome &&
+ cm->seq_params.enable_sdp);
+ if (chroma_tree != NULL && use_sdp) {
+ sb->partition_tree_chroma = copy_partition_tree(chroma_tree, NULL);
+ } else {
+ // For consistency, use a copy of the luma tree when SDP is not enabled for
+ // the frame.
+ sb->partition_tree_chroma = copy_partition_tree(luma_tree, NULL);
+ }
+ sb->has_separate_chroma_partition_tree = use_sdp;
+
+ for (int i = 0; i < MAX_MB_PLANE; i++) {
+ memcpy(sb->dqcoeff[i], pbi->td.dcb.dqcoeff_block_copy[i], MAX_SB_SQUARE);
+ memcpy(sb->qcoeff[i], pbi->td.dcb.qcoeff_block[i], MAX_SB_SQUARE);
+ memcpy(sb->dequant_values[i], pbi->td.dcb.dequant_values[i], MAX_SB_SQUARE);
+ }
+ return 1;
}
/* TODO(negge) This function may be called by more than one thread when using
@@ -39,7 +110,9 @@
AV1_COMMON *const cm = &pbi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const CommonQuantParams *quant_params = &cm->quant_params;
-
+ fd->recon_frame_buffer = cm->cur_frame->buf;
+ fd->predicted_frame_buffer = cm->predicted_pixels;
+ fd->prefiltered_frame_buffer = cm->prefiltered_pixels;
if (fd->mi_rows != mi_params->mi_rows || fd->mi_cols != mi_params->mi_cols) {
ifd_clear(fd);
ifd_init_mi_rc(fd, mi_params->mi_rows, mi_params->mi_cols);
@@ -49,6 +122,7 @@
fd->show_frame = cm->show_frame;
fd->frame_type = cm->current_frame.frame_type;
fd->base_qindex = quant_params->base_qindex;
+ fd->superblock_size = cm->seq_params.sb_size;
// Set width and height of the first tile until generic support can be added
TileInfo tile_info;
av1_tile_set_row(&tile_info, cm, 0);
@@ -57,6 +131,11 @@
fd->tile_mi_rows = tile_info.mi_row_end - tile_info.mi_row_start;
fd->delta_q_present_flag = cm->delta_q_info.delta_q_present_flag;
fd->delta_q_res = cm->delta_q_info.delta_q_res;
+ fd->bit_depth = cm->seq_params.bit_depth;
+ fd->width = cm->width;
+ fd->height = cm->height;
+ fd->render_width = cm->render_width;
+ fd->render_height = cm->render_height;
#if CONFIG_ACCOUNTING
fd->accounting = &pbi->accounting;
#endif
@@ -101,14 +180,15 @@
// Block Size
mi->sb_type = mbmi->sb_type[0];
+ mi->sb_type_chroma = mbmi->sb_type[1];
// Skip Flag
+ // TODO(comc): Check handling of skip_txfm vs tx_skip.
mi->skip = mbmi->skip_txfm[0];
mi->filter[0] = mbmi->interp_fltr;
mi->filter[1] = mbmi->interp_fltr;
mi->dual_filter_type = mi->filter[0] * 3 + mi->filter[1];
// Transform
- // TODO(anyone): extract tx type info from mbmi->txk_type[].
const BLOCK_SIZE bsize = mbmi->sb_type[0];
const int c = i % mi_size_wide[bsize];
const int r = j % mi_size_high[bsize];
@@ -120,19 +200,19 @@
if (skip_not_transform && mi->skip) mi->tx_size = -1;
- if (mi->skip) {
- const int tx_type_row = j - j % tx_size_high_unit[mi->tx_size];
- const int tx_type_col = i - i % tx_size_wide_unit[mi->tx_size];
- const int tx_type_map_idx =
- tx_type_row * mi_params->mi_stride + tx_type_col;
- mi->tx_type = mi_params->tx_type_map[tx_type_map_idx];
- } else {
- mi->tx_type = 0;
- }
+ const int tx_type_row = j - j % tx_size_high_unit[mi->tx_size];
+ const int tx_type_col = i - i % tx_size_wide_unit[mi->tx_size];
+ const int tx_type_map_idx =
+ tx_type_row * mi_params->mi_stride + tx_type_col;
+ mi->tx_type = mi_params->tx_type_map[tx_type_map_idx];
+
+ bool skip = mbmi->tx_skip[av1_get_txk_type_index(bsize, r, c)];
+ mi->skip |= skip;
if (skip_not_transform &&
- (mi->skip || mbmi->tx_skip[av1_get_txk_type_index(bsize, r, c)]))
+ (mi->skip || mbmi->tx_skip[av1_get_txk_type_index(bsize, r, c)])) {
mi->tx_type = -1;
+ }
mi->cdef_level = cm->cdef_info.cdef_strengths[mbmi->cdef_strength] /
CDEF_SEC_STRENGTHS;
diff --git a/av1/decoder/inspection.h b/av1/decoder/inspection.h
index 19d4f5f..cb8175f 100644
--- a/av1/decoder/inspection.h
+++ b/av1/decoder/inspection.h
@@ -16,6 +16,7 @@
extern "C" {
#endif // __cplusplus
+#include "av1/common/blockd.h"
#include "av1/common/seg_common.h"
#if CONFIG_ACCOUNTING
#include "av1/decoder/accounting.h"
@@ -32,6 +33,12 @@
int16_t col;
};
+typedef struct insp_pixel_data insp_pixel_data;
+
+struct insp_pixel_data {
+ int16_t samples[MAX_SB_SIZE][MAX_SB_SIZE];
+};
+
typedef struct insp_mi_data insp_mi_data;
struct insp_mi_data {
@@ -40,6 +47,7 @@
int16_t mode;
int16_t uv_mode;
int16_t sb_type;
+ int16_t sb_type_chroma;
int16_t skip;
int16_t segment_id;
int16_t dual_filter_type;
@@ -58,6 +66,19 @@
int16_t uv_palette;
};
+typedef struct insp_sb_data insp_sb_data;
+
+struct insp_sb_data {
+ PARTITION_TREE *partition_tree_luma;
+ PARTITION_TREE *partition_tree_chroma;
+ bool has_separate_chroma_partition_tree;
+ int16_t prediction_samples[MAX_SB_SIZE][MAX_SB_SIZE];
+ int16_t recon_samples[MAX_SB_SIZE][MAX_SB_SIZE];
+ tran_low_t dqcoeff[MAX_MB_PLANE][MAX_SB_SQUARE];
+ tran_low_t qcoeff[MAX_MB_PLANE][MAX_SB_SQUARE];
+ tran_low_t dequant_values[MAX_MB_PLANE][MAX_SB_SQUARE];
+};
+
typedef struct insp_frame_data insp_frame_data;
struct insp_frame_data {
@@ -65,6 +86,9 @@
Accounting *accounting;
#endif
insp_mi_data *mi_grid;
+ insp_sb_data *sb_grid;
+ int max_sb_rows;
+ int max_sb_cols;
int16_t frame_number;
int show_frame;
int frame_type;
@@ -82,10 +106,21 @@
int delta_q_present_flag;
int delta_q_res;
int show_existing_frame;
+ int superblock_size;
+ // Points to the same underlying allocations as the decoder
+ YV12_BUFFER_CONFIG recon_frame_buffer;
+ YV12_BUFFER_CONFIG predicted_frame_buffer;
+ YV12_BUFFER_CONFIG prefiltered_frame_buffer;
+ int bit_depth;
+ int render_width;
+ int render_height;
+ int width;
+ int height;
};
void ifd_init(insp_frame_data *fd, int frame_width, int frame_height);
void ifd_clear(insp_frame_data *fd);
+int ifd_inspect_superblock(insp_frame_data *fd, void *decoder);
int ifd_inspect(insp_frame_data *fd, void *decoder, int skip_not_transform);
#ifdef __cplusplus
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 5a695bc..252b2ab 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -145,27 +145,61 @@
// 0 -> 0 10 -> 1 110 -> 2 111 -> 3
// Also use the number of reference MVs for a frame type to reduce the
// number of bits written if there are less than 4 valid DRL indices.
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mbmi)) {
+ if (mbmi->mode == NEAR_NEWMV)
+ max_drl_bits = AOMMIN(max_drl_bits, SEP_COMP_DRL_SIZE);
+ else
+ assert(mbmi->mode == NEAR_NEARMV);
+ }
+
+#if CONFIG_SKIP_MODE_ENHANCEMENT
+ if (mbmi->skip_mode)
+ assert(mbmi->ref_mv_idx[0] <
+ mbmi_ext_frame->skip_mvp_candidate_list.ref_mv_count);
+ else
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+ assert(mbmi->ref_mv_idx[0] < mbmi_ext_frame->ref_mv_count[0]);
+ if (has_second_drl(mbmi))
+ assert(mbmi->ref_mv_idx[1] < mbmi_ext_frame->ref_mv_count[1]);
+ assert(mbmi->ref_mv_idx[0] < max_drl_bits + 1);
+ if (has_second_drl(mbmi)) assert(mbmi->ref_mv_idx[1] < max_drl_bits + 1);
+ for (int ref = 0; ref < 1 + has_second_drl(mbmi); ref++) {
+ for (int idx = 0; idx < max_drl_bits; ++idx) {
+ aom_cdf_prob *drl_cdf =
+#if CONFIG_SKIP_MODE_ENHANCEMENT
+ mbmi->skip_mode ? ec_ctx->skip_drl_cdf[AOMMIN(idx, 2)]
+ : av1_get_drl_cdf(ec_ctx, mbmi_ext_frame->weight[ref],
+ mode_ctx, idx);
+#else
+ av1_get_drl_cdf(ec_ctx, mbmi_ext_frame->weight[ref], mode_ctx, idx);
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+ aom_write_symbol(w, mbmi->ref_mv_idx[ref] != idx, drl_cdf, 2);
+ if (mbmi->ref_mv_idx[ref] == idx) break;
+ }
+ }
+#else
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode)
assert(mbmi->ref_mv_idx <
mbmi_ext_frame->skip_mvp_candidate_list.ref_mv_count);
else
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
assert(mbmi->ref_mv_idx < mbmi_ext_frame->ref_mv_count);
-
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf =
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
mbmi->skip_mode
? ec_ctx->skip_drl_cdf[AOMMIN(idx, 2)]
: av1_get_drl_cdf(ec_ctx, mbmi_ext_frame->weight, mode_ctx, idx);
#else
av1_get_drl_cdf(ec_ctx, mbmi_ext_frame->weight, mode_ctx, idx);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
aom_write_symbol(w, mbmi->ref_mv_idx != idx, drl_cdf, 2);
if (mbmi->ref_mv_idx == idx) break;
}
+#endif // CONFIG_SEP_COMP_DRL
}
#if CONFIG_WARP_REF_LIST
static void write_warp_ref_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi,
@@ -184,6 +218,16 @@
if (mbmi->warp_ref_idx == bit_idx) break;
}
}
+#if CONFIG_CWG_D067_IMPROVED_WARP
+static void write_warpmv_with_mvd_flag(FRAME_CONTEXT *ec_ctx,
+ const MB_MODE_INFO *mbmi,
+ aom_writer *w) {
+ aom_write_symbol(
+ w, mbmi->warpmv_with_mvd_flag,
+ ec_ctx->warpmv_with_mvd_flag_cdf[mbmi->sb_type[PLANE_TYPE_Y]], 2);
+}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#endif // CONFIG_WARP_REF_LIST
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
@@ -208,6 +252,24 @@
}
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
+#if CONFIG_CWP
+// Write the index for the weighting factor of compound weighted prediction
+static AOM_INLINE void write_cwp_idx(MACROBLOCKD *xd, aom_writer *w,
+ const AV1_COMMON *const cm,
+ const MB_MODE_INFO *const mbmi) {
+ const int8_t final_idx = get_cwp_coding_idx(mbmi->cwp_idx, 1, cm, mbmi);
+
+ int bit_cnt = 0;
+ const int ctx = 0;
+ for (int idx = 0; idx < MAX_CWP_NUM - 1; ++idx) {
+ aom_write_symbol(w, final_idx != idx,
+ xd->tile_ctx->cwp_idx_cdf[ctx][bit_cnt], 2);
+ if (final_idx == idx) break;
+ ++bit_cnt;
+ }
+}
+#endif // CONFIG_CWP
+
static AOM_INLINE void write_inter_compound_mode(MACROBLOCKD *xd, aom_writer *w,
PREDICTION_MODE mode,
#if CONFIG_OPTFLOW_REFINEMENT
@@ -397,10 +459,10 @@
static AOM_INLINE void write_is_inter(const AV1_COMMON *cm,
const MACROBLOCKD *xd, int segment_id,
aom_writer *w, const int is_inter
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
,
const int skip_txfm
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
assert(is_inter);
@@ -408,11 +470,11 @@
}
const int ctx = av1_get_intra_inter_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
aom_write_symbol(w, is_inter, ec_ctx->intra_inter_cdf[skip_txfm][ctx], 2);
#else
aom_write_symbol(w, is_inter, ec_ctx->intra_inter_cdf[ctx], 2);
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
}
#if CONFIG_WEDGE_MOD_EXT
@@ -464,7 +526,11 @@
#if !CONFIG_WARPMV
write_warp_ref_idx(xd->tile_ctx, mbmi, w);
#endif // !CONFIG_WARPMV
- if (!allow_warp_parameter_signaling(mbmi)) {
+ if (!allow_warp_parameter_signaling(
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ cm,
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi)) {
return;
}
#endif // CONFIG_WARP_REF_LIST
@@ -501,7 +567,11 @@
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame, aom_writer *w) {
const BLOCK_SIZE bsize = mbmi->sb_type[PLANE_TYPE_Y];
const int allowed_motion_modes =
+#if CONFIG_SEP_COMP_DRL
+ motion_mode_allowed(cm, xd, mbmi_ext_frame->ref_mv_stack[0], mbmi);
+#else
motion_mode_allowed(cm, xd, mbmi_ext_frame->ref_mv_stack, mbmi);
+#endif // CONFIG_SEP_COMP_DRL
assert((allowed_motion_modes & (1 << mbmi->motion_mode)) != 0);
assert((cm->features.enabled_motion_modes & (1 << mbmi->motion_mode)) != 0);
@@ -662,7 +732,7 @@
}
}
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
static AOM_INLINE void pack_map_tokens(aom_writer *w, const TokenExtra **tp,
int n, int cols, int rows) {
const TokenExtra *p = *tp;
@@ -693,7 +763,7 @@
}
*tp = p;
}
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
static AOM_INLINE void av1_write_coeffs_txb_facade(
aom_writer *w, AV1_COMMON *cm, MACROBLOCK *const x, MACROBLOCKD *xd,
@@ -1016,7 +1086,12 @@
#if CONFIG_OPTFLOW_REFINEMENT
// Sharp filter is always used whenever optical flow refinement is applied.
int mb_interp_filter =
- (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
+ (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)
+
+#if CONFIG_REFINEMV
+ || mbmi->refinemv_flag
+#endif // CONFIG_REFINEMV
+ )
? MULTITAP_SHARP
: cm->features.interp_filter;
#else
@@ -1029,10 +1104,20 @@
}
if (cm->features.interp_filter == SWITCHABLE) {
#if CONFIG_OPTFLOW_REFINEMENT
- if (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)) {
+ if (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)
+#if CONFIG_REFINEMV
+ || mbmi->refinemv_flag
+#endif // CONFIG_REFINEMV
+ ) {
+#if CONFIG_REFINEMV
+ assert(IMPLIES(mbmi->mode >= NEAR_NEARMV_OPTFLOW ||
+ use_opfl_refine_all(cm, mbmi) || mbmi->refinemv_flag,
+ mbmi->interp_fltr == MULTITAP_SHARP));
+#else
assert(IMPLIES(
mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi),
mbmi->interp_fltr == MULTITAP_SHARP));
+#endif // CONFIG_REFINEMV
return;
}
#endif // CONFIG_OPTFLOW_REFINEMENT
@@ -1202,16 +1287,23 @@
}
void av1_write_tx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
- TX_TYPE tx_type, TX_SIZE tx_size, aom_writer *w) {
+ TX_TYPE tx_type, TX_SIZE tx_size, aom_writer *w
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ const int plane, const int eob, const int dc_skip) {
+ if (plane != PLANE_TYPE_Y || dc_skip) return;
+#else
+) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
MB_MODE_INFO *mbmi = xd->mi[0];
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
intra_dir =
fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode];
else
intra_dir = mbmi->mode;
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
const FeatureFlags *const features = &cm->features;
const int is_inter = is_inter_block(mbmi, xd->tree_type);
if (get_ext_tx_types(tx_size, is_inter, features->reduced_tx_set_used) > 1 &&
@@ -1228,7 +1320,7 @@
// eset == 0 should correspond to a set with only DCT_DCT and there
// is no need to send the tx_type
assert(eset > 0);
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
const int size_info = av1_size_class[tx_size];
if (!is_inter) {
const int mode_info = av1_md_class[intra_dir];
@@ -1240,25 +1332,33 @@
}
#else
assert(av1_ext_tx_used[tx_set_type][get_primary_tx_type(tx_type)]);
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
if (is_inter) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int eob_tx_ctx = get_lp2tx_ctx(tx_size, get_txb_bwl(tx_size), eob);
+ aom_write_symbol(
+ w, av1_ext_tx_ind[tx_set_type][tx_type],
+ ec_ctx->inter_ext_tx_cdf[eset][eob_tx_ctx][square_tx_size],
+ av1_num_ext_tx_set[tx_set_type]);
+#else
aom_write_symbol(w, av1_ext_tx_ind[tx_set_type][tx_type],
ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
av1_num_ext_tx_set[tx_set_type]);
+#endif // CONFIG_ATC_DCTX_ALIGNED
} else {
if (mbmi->fsc_mode[xd->tree_type == CHROMA_PART]) {
return;
}
-#if !CONFIG_ATC_NEWTXSETS
+#if !CONFIG_ATC
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
intra_dir =
fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode];
else
intra_dir = mbmi->mode;
-#endif // !CONFIG_ATC_NEWTXSETS
+#endif // !CONFIG_ATC
aom_write_symbol(
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
w,
av1_tx_type_to_idx(get_primary_tx_type(tx_type), tx_set_type,
intra_dir, size_info),
@@ -1276,7 +1376,7 @@
w, av1_ext_tx_ind_intra[tx_set_type][get_primary_tx_type(tx_type)],
ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_dir],
av1_num_ext_tx_set_intra[tx_set_type]);
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
}
}
}
@@ -1347,9 +1447,19 @@
INTRA_MODES);
}
#endif // !CONFIG_AIMC
-static AOM_INLINE void write_mrl_index(FRAME_CONTEXT *ec_ctx, uint8_t mrl_index,
- aom_writer *w) {
+static AOM_INLINE void write_mrl_index(FRAME_CONTEXT *ec_ctx,
+#if CONFIG_EXT_DIR
+ const MB_MODE_INFO *neighbor0,
+ const MB_MODE_INFO *neighbor1,
+#endif // CONFIG_EXT_DIR
+ uint8_t mrl_index, aom_writer *w) {
+#if CONFIG_EXT_DIR
+ int ctx = get_mrl_index_ctx(neighbor0, neighbor1);
+ aom_cdf_prob *mrl_cdf = ec_ctx->mrl_index_cdf[ctx];
+ aom_write_symbol(w, mrl_index, mrl_cdf, MRL_LINE_NUMBER);
+#else
aom_write_symbol(w, mrl_index, ec_ctx->mrl_index_cdf, MRL_LINE_NUMBER);
+#endif // CONFIG_EXT_DIR
}
static AOM_INLINE void write_fsc_mode(uint8_t fsc_mode, aom_writer *w,
@@ -1645,7 +1755,11 @@
#endif // CONFIG_AIMC
// Encoding reference line index
if (cm->seq_params.enable_mrls && av1_is_directional_mode(mode)) {
- write_mrl_index(ec_ctx, mbmi->mrl_index, w);
+ write_mrl_index(ec_ctx,
+#if CONFIG_EXT_DIR
+ xd->neighbors[0], xd->neighbors[1],
+#endif // CONFIG_EXT_DIR
+ mbmi->mrl_index, w);
}
}
@@ -1705,19 +1819,39 @@
static INLINE int_mv get_ref_mv_from_stack(
int ref_idx, const MV_REFERENCE_FRAME *ref_frame, int ref_mv_idx,
- const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame) {
+ const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame
+#if CONFIG_SEP_COMP_DRL
+ ,
+ const MB_MODE_INFO *mbmi
+#endif // CONFIG_SEP_COMP_DRL
+) {
const int8_t ref_frame_type = av1_ref_frame_type(ref_frame);
+#if CONFIG_SEP_COMP_DRL
+ const CANDIDATE_MV *curr_ref_mv_stack =
+ has_second_drl(mbmi) ? mbmi_ext_frame->ref_mv_stack[ref_idx]
+ : mbmi_ext_frame->ref_mv_stack[0];
+#else
const CANDIDATE_MV *curr_ref_mv_stack = mbmi_ext_frame->ref_mv_stack;
+#endif // CONFIG_SEP_COMP_DRL
if (is_inter_ref_frame(ref_frame[1])) {
assert(ref_idx == 0 || ref_idx == 1);
+#if CONFIG_SEP_COMP_DRL
+ return ref_idx && !has_second_drl(mbmi)
+ ? curr_ref_mv_stack[ref_mv_idx].comp_mv
+#else
return ref_idx ? curr_ref_mv_stack[ref_mv_idx].comp_mv
- : curr_ref_mv_stack[ref_mv_idx].this_mv;
+#endif // CONFIG_SEP_COMP_DRL
+ : curr_ref_mv_stack[ref_mv_idx].this_mv;
}
assert(ref_idx == 0);
#if CONFIG_TIP
+#if CONFIG_SEP_COMP_DRL
+ if (ref_mv_idx < mbmi_ext_frame->ref_mv_count[0]) {
+#else
if (ref_mv_idx < mbmi_ext_frame->ref_mv_count) {
+#endif // CONFIG_SEP_COMP_DRL
return curr_ref_mv_stack[ref_mv_idx].this_mv;
} else if (is_tip_ref_frame(ref_frame_type)) {
int_mv zero_mv;
@@ -1736,13 +1870,42 @@
static INLINE int_mv get_ref_mv(const MACROBLOCK *x, int ref_idx) {
const MACROBLOCKD *xd = &x->e_mbd;
const MB_MODE_INFO *mbmi = xd->mi[0];
+#if CONFIG_SEP_COMP_DRL
+ const int ref_mv_idx = get_ref_mv_idx(mbmi, ref_idx);
+#else
const int ref_mv_idx = mbmi->ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
assert(IMPLIES(have_nearmv_newmv_in_inter_mode(mbmi->mode),
has_second_ref(mbmi)));
return get_ref_mv_from_stack(ref_idx, mbmi->ref_frame, ref_mv_idx,
+#if CONFIG_SEP_COMP_DRL
+ x->mbmi_ext_frame, mbmi);
+#else
x->mbmi_ext_frame);
+#endif // CONFIG_SEP_COMP_DRL
}
+#if CONFIG_REFINEMV
+// This function write the refinemv_flag ( if require) to the bitstream
+static void write_refinemv_flag(const AV1_COMMON *const cm,
+ MACROBLOCKD *const xd, aom_writer *w,
+ BLOCK_SIZE bsize) {
+ const MB_MODE_INFO *const mbmi = xd->mi[0];
+ int signal_refinemv = switchable_refinemv_flag(cm, mbmi);
+
+ if (signal_refinemv) {
+ const int refinemv_ctx = av1_get_refinemv_context(cm, xd, bsize);
+ assert(mbmi->refinemv_flag < REFINEMV_NUM_MODES);
+ aom_write_symbol(w, mbmi->refinemv_flag,
+ xd->tile_ctx->refinemv_flag_cdf[refinemv_ctx],
+ REFINEMV_NUM_MODES);
+
+ } else {
+ assert(mbmi->refinemv_flag == get_default_refinemv_flag(cm, mbmi));
+ }
+}
+#endif // CONFIG_REFINEMV
+
#if CONFIG_FLEX_MVRES
static void write_pb_mv_precision(const AV1_COMMON *const cm,
MACROBLOCKD *const xd, aom_writer *w) {
@@ -1823,6 +1986,39 @@
write_skip_mode(cm, xd, segment_id, mbmi, w);
+#if CONFIG_SKIP_TXFM_OPT
+ if (!mbmi->skip_mode) {
+ write_is_inter(cm, xd, mbmi->segment_id, w, is_inter);
+
+#if CONFIG_IBC_SR_EXT
+ if (!is_inter && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+ const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
+ if (xd->tree_type == CHROMA_PART) assert(use_intrabc == 0);
+#if CONFIG_NEW_CONTEXT_MODELING
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf[intrabc_ctx], 2);
+#else
+ aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2);
+#endif // CONFIG_NEW_CONTEXT_MODELING
+ }
+#endif // CONFIG_IBC_SR_EXT
+ }
+
+ int skip = 0;
+ if (is_inter
+#if CONFIG_IBC_SR_EXT
+ || (!is_inter && is_intrabc_block(mbmi, xd->tree_type))
+#endif // CONFIG_IBC_SR_EXT
+ ) {
+#if CONFIG_SKIP_MODE_ENHANCEMENT
+ skip = write_skip(cm, xd, segment_id, mbmi, w);
+#else
+ assert(IMPLIES(mbmi->skip_mode,
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART]));
+ skip = mbmi->skip_mode ? 1 : write_skip(cm, xd, segment_id, mbmi, w);
+#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
+ }
+#else
#if CONFIG_SKIP_MODE_ENHANCEMENT
const int skip = write_skip(cm, xd, segment_id, mbmi, w);
#else
@@ -1831,6 +2027,7 @@
const int skip =
mbmi->skip_mode ? 1 : write_skip(cm, xd, segment_id, mbmi, w);
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
+#endif // CONFIG_SKIP_TXFM_OPT
write_inter_segment_id(cpi, w, seg, segp, skip, 0);
write_cdef(cm, xd, w, skip);
@@ -1841,13 +2038,31 @@
write_delta_q_params(cpi, skip, w);
+#if CONFIG_REFINEMV
+ assert(IMPLIES(mbmi->refinemv_flag,
+ mbmi->skip_mode ? is_refinemv_allowed_skip_mode(cm, mbmi)
+ : is_refinemv_allowed(cm, mbmi, bsize)));
+ if (mbmi->refinemv_flag && switchable_refinemv_flag(cm, mbmi)) {
+ assert(mbmi->interinter_comp.type == COMPOUND_AVERAGE);
+ assert(mbmi->comp_group_idx == 0);
+ assert(mbmi->bawp_flag == 0);
+ }
+#if CONFIG_CWP
+ assert(IMPLIES(mbmi->refinemv_flag, mbmi->cwp_idx == CWP_EQUAL));
+#endif // CONFIG_CWP
+#endif // CONFIG_REFINEMV
#if CONFIG_WARPMV
// Just for debugging purpose
if (mbmi->mode == WARPMV) {
assert(mbmi->skip_mode == 0);
assert(mbmi->motion_mode == WARP_DELTA ||
mbmi->motion_mode == WARPED_CAUSAL);
+#if CONFIG_SEP_COMP_DRL
+ assert(get_ref_mv_idx(mbmi, 0) == 0);
+ assert(get_ref_mv_idx(mbmi, 1) == 0);
+#else
assert(mbmi->ref_mv_idx == 0);
+#endif // CONFIG_SEP_COMP_DRL
assert(!is_tip_ref_frame(mbmi->ref_frame[0]));
assert(is_inter);
assert(!have_drl_index(mode));
@@ -1860,6 +2075,7 @@
}
#endif // CONFIG_WARPMV
+#if !CONFIG_SKIP_TXFM_OPT
if (!mbmi->skip_mode)
write_is_inter(cm, xd, mbmi->segment_id, w, is_inter
#if CONFIG_CONTEXT_DERIVATION
@@ -1867,6 +2083,7 @@
skip
#endif // CONFIG_CONTEXT_DERIVATION
);
+#endif // !CONFIG_SKIP_TXFM_OPT
#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) {
@@ -1881,6 +2098,13 @@
#if CONFIG_IBC_SR_EXT
if (!is_inter && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+#if CONFIG_NEW_CONTEXT_MODELING
+ const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf[intrabc_ctx], 2);
+#else
+ aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2);
+#endif // CONFIG_NEW_CONTEXT_MODELING
write_intrabc_info(xd, mbmi_ext_frame, w);
if (is_intrabc_block(mbmi, xd->tree_type)) return;
}
@@ -1941,11 +2165,19 @@
#endif
write_motion_mode(cm, xd, mbmi, mbmi_ext_frame, w);
int is_warpmv_warp_causal =
- (mbmi->motion_mode == WARPED_CAUSAL && mbmi->mode == WARPMV);
+ ((mbmi->motion_mode == WARPED_CAUSAL) && mbmi->mode == WARPMV);
if (mbmi->motion_mode == WARP_DELTA || is_warpmv_warp_causal)
write_warp_ref_idx(xd->tile_ctx, mbmi, w);
#endif // CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (allow_warpmv_with_mvd_coding(cm, mbmi)) {
+ write_warpmv_with_mvd_flag(xd->tile_ctx, mbmi, w);
+ } else {
+ assert(mbmi->warpmv_with_mvd_flag == 0);
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
write_jmvd_scale_mode(xd, w, mbmi);
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
@@ -1963,7 +2195,14 @@
#endif // IMPROVED_AMVD
mbmi_ext_frame->mode_context, ec_ctx, mbmi, mbmi_ext_frame, w);
else
+#if CONFIG_SEP_COMP_DRL
+ {
+ assert(get_ref_mv_idx(mbmi, 0) == 0);
+ assert(get_ref_mv_idx(mbmi, 1) == 0);
+ }
+#else
assert(mbmi->ref_mv_idx == 0);
+#endif // CONFIG_SEP_COMP_DRL
#if CONFIG_FLEX_MVRES
if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
write_pb_mv_precision(cm, xd, w);
@@ -1971,65 +2210,19 @@
#endif // CONFIG_FLEX_MVRES
}
- if (have_newmv_in_each_reference(mode)) {
- for (ref = 0; ref < 1 + is_compound; ++ref) {
- nmv_context *nmvc = &ec_ctx->nmvc;
- const int_mv ref_mv = get_ref_mv(x, ref);
-
- av1_encode_mv(cpi, w,
-#if CONFIG_FLEX_MVRES
- mbmi->mv[ref].as_mv, ref_mv.as_mv,
-#else
- &mbmi->mv[ref].as_mv, &ref_mv.as_mv,
-#endif
- nmvc,
-#if CONFIG_FLEX_MVRES
- pb_mv_precision);
-#else
- allow_hp);
-#endif
- }
- } else if (mode == NEAR_NEWMV
-#if CONFIG_OPTFLOW_REFINEMENT
- || mode == NEAR_NEWMV_OPTFLOW
-#endif // CONFIG_OPTFLOW_REFINEMENT
-#if CONFIG_JOINT_MVD
- || (is_joint_mvd_coding_mode(mode) && jmvd_base_ref_list == 1)
-#endif // CONFIG_JOINT_MVD
- ) {
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (mbmi->mode == WARPMV && mbmi->warpmv_with_mvd_flag) {
nmv_context *nmvc = &ec_ctx->nmvc;
- const int_mv ref_mv = get_ref_mv(x, 1);
-
- av1_encode_mv(cpi, w,
-#if CONFIG_FLEX_MVRES
- mbmi->mv[1].as_mv, ref_mv.as_mv,
-#else
- &mbmi->mv[1].as_mv, &ref_mv.as_mv,
-#endif
- nmvc,
-#if CONFIG_FLEX_MVRES
- pb_mv_precision);
-#else
- allow_hp);
-#endif
-
- } else if (mode == NEW_NEARMV
-#if CONFIG_OPTFLOW_REFINEMENT
- || mode == NEW_NEARMV_OPTFLOW
-#endif // CONFIG_OPTFLOW_REFINEMENT
-#if CONFIG_JOINT_MVD
- || (is_joint_mvd_coding_mode(mode) && jmvd_base_ref_list == 0)
-#endif // CONFIG_JOINT_MVD
- ) {
- nmv_context *nmvc = &ec_ctx->nmvc;
- const int_mv ref_mv = get_ref_mv(x, 0);
-
+ WarpedMotionParams ref_warp_model =
+ x->mbmi_ext_frame->warp_param_stack[mbmi->warp_ref_idx].wm_params;
+ const int_mv ref_mv =
+ get_mv_from_wrl(xd, &ref_warp_model, mbmi->pb_mv_precision, bsize,
+ xd->mi_col, xd->mi_row);
av1_encode_mv(cpi, w,
#if CONFIG_FLEX_MVRES
mbmi->mv[0].as_mv, ref_mv.as_mv,
-
#else
- &mbmi->mv[0].as_mv, &ref_mv.as_mv,
+ &mbmi->mv[ref].as_mv, &ref_mv.as_mv,
#endif
nmvc,
#if CONFIG_FLEX_MVRES
@@ -2038,6 +2231,81 @@
allow_hp);
#endif
}
+
+ else {
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+ if (have_newmv_in_each_reference(mode)) {
+ for (ref = 0; ref < 1 + is_compound; ++ref) {
+ nmv_context *nmvc = &ec_ctx->nmvc;
+ const int_mv ref_mv = get_ref_mv(x, ref);
+
+ av1_encode_mv(cpi, w,
+#if CONFIG_FLEX_MVRES
+ mbmi->mv[ref].as_mv, ref_mv.as_mv,
+#else
+ &mbmi->mv[ref].as_mv, &ref_mv.as_mv,
+#endif
+ nmvc,
+#if CONFIG_FLEX_MVRES
+ pb_mv_precision);
+#else
+ allow_hp);
+#endif
+ }
+ } else if (mode == NEAR_NEWMV
+#if CONFIG_OPTFLOW_REFINEMENT
+ || mode == NEAR_NEWMV_OPTFLOW
+#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_JOINT_MVD
+ || (is_joint_mvd_coding_mode(mode) && jmvd_base_ref_list == 1)
+#endif // CONFIG_JOINT_MVD
+ ) {
+ nmv_context *nmvc = &ec_ctx->nmvc;
+ const int_mv ref_mv = get_ref_mv(x, 1);
+
+ av1_encode_mv(cpi, w,
+#if CONFIG_FLEX_MVRES
+ mbmi->mv[1].as_mv, ref_mv.as_mv,
+#else
+ &mbmi->mv[1].as_mv, &ref_mv.as_mv,
+#endif
+ nmvc,
+#if CONFIG_FLEX_MVRES
+ pb_mv_precision);
+#else
+ allow_hp);
+#endif
+
+ } else if (mode == NEW_NEARMV
+#if CONFIG_OPTFLOW_REFINEMENT
+ || mode == NEW_NEARMV_OPTFLOW
+#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_JOINT_MVD
+ || (is_joint_mvd_coding_mode(mode) && jmvd_base_ref_list == 0)
+#endif // CONFIG_JOINT_MVD
+ ) {
+ nmv_context *nmvc = &ec_ctx->nmvc;
+ const int_mv ref_mv = get_ref_mv(x, 0);
+
+ av1_encode_mv(cpi, w,
+#if CONFIG_FLEX_MVRES
+ mbmi->mv[0].as_mv, ref_mv.as_mv,
+
+#else
+ &mbmi->mv[0].as_mv, &ref_mv.as_mv,
+#endif
+ nmvc,
+#if CONFIG_FLEX_MVRES
+ pb_mv_precision);
+#else
+ allow_hp);
+#endif
+ }
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#if CONFIG_BAWP && !CONFIG_WARPMV
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
@@ -2083,6 +2351,12 @@
if (mbmi->ref_frame[1] != INTRA_FRAME) write_motion_mode(cm, xd, mbmi, w);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_REFINEMV
+ if (!mbmi->skip_mode) {
+ write_refinemv_flag(cm, xd, w, bsize);
+ }
+#endif // CONFIG_REFINEMV
+
// First write idx to indicate current compound inter prediction mode
// group Group A (0): dist_wtd_comp, compound_average Group B (1):
// interintra, compound_diffwtd, wedge
@@ -2091,6 +2365,9 @@
#if CONFIG_OPTFLOW_REFINEMENT
&& mbmi->mode < NEAR_NEARMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ && (!mbmi->refinemv_flag || !switchable_refinemv_flag(cm, mbmi))
+#endif // CONFIG_REFINEMV
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
&& !is_joint_amvd_coding_mode(mbmi->mode)
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
@@ -2139,17 +2416,25 @@
}
}
}
+#if CONFIG_CWP
+ if (cm->features.enable_cwp && is_cwp_allowed(mbmi) && !mbmi->skip_mode)
+ write_cwp_idx(xd, w, cm, mbmi);
+#endif // CONFIG_CWP
write_mb_interp_filter(cm, xd, w);
}
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
static void write_intrabc_drl_idx(int max_ref_bv_num, FRAME_CONTEXT *ec_ctx,
const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
aom_writer *w) {
assert(!mbmi->skip_mode);
+#if CONFIG_SEP_COMP_DRL
+ assert(mbmi->intrabc_drl_idx < mbmi_ext_frame->ref_mv_count[0]);
+#else
assert(mbmi->intrabc_drl_idx < mbmi_ext_frame->ref_mv_count);
+#endif
assert(mbmi->intrabc_drl_idx < max_ref_bv_num);
(void)mbmi_ext_frame;
@@ -2161,7 +2446,7 @@
++bit_cnt;
}
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
static AOM_INLINE void write_intrabc_info(
MACROBLOCKD *xd, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
@@ -2170,12 +2455,14 @@
int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
if (xd->tree_type == CHROMA_PART) assert(use_intrabc == 0);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
+#if !CONFIG_SKIP_TXFM_OPT
#if CONFIG_NEW_CONTEXT_MODELING
const int intrabc_ctx = get_intrabc_ctx(xd);
aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf[intrabc_ctx], 2);
#else
aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2);
#endif // CONFIG_NEW_CONTEXT_MODELING
+#endif // !CONFIG_SKIP_TXFM_OPT
if (use_intrabc) {
assert(mbmi->mode == DC_PRED);
@@ -2185,9 +2472,13 @@
assert(mbmi->pb_mv_precision == MV_PRECISION_ONE_PEL);
#endif
+#if CONFIG_SEP_COMP_DRL
+ int_mv dv_ref = mbmi_ext_frame->ref_mv_stack[0][0].this_mv;
+#else
int_mv dv_ref = mbmi_ext_frame->ref_mv_stack[0].this_mv;
+#endif
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
aom_write_symbol(w, mbmi->intrabc_mode, ec_ctx->intrabc_mode_cdf, 2);
write_intrabc_drl_idx(MAX_REF_BV_STACK_SIZE, ec_ctx, mbmi, mbmi_ext_frame,
w);
@@ -2196,7 +2487,7 @@
av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc);
#else
av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
}
@@ -2212,8 +2503,25 @@
if (seg->segid_preskip && seg->update_map)
write_segment_id(cpi, mbmi, w, seg, segp, 0);
- const int skip = write_skip(cm, xd, mbmi->segment_id, mbmi, w);
+#if CONFIG_SKIP_TXFM_OPT
+ if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+ const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
+ if (xd->tree_type == CHROMA_PART) assert(use_intrabc == 0);
+#if CONFIG_NEW_CONTEXT_MODELING
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf[intrabc_ctx], 2);
+#else
+ aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2);
+#endif // CONFIG_NEW_CONTEXT_MODELING
+ }
+ int skip = 0;
+ if (is_intrabc_block(mbmi, xd->tree_type)) {
+ skip = write_skip(cm, xd, mbmi->segment_id, mbmi, w);
+ }
+#else
+ const int skip = write_skip(cm, xd, mbmi->segment_id, mbmi, w);
+#endif // CONFIG_SKIP_TXFM_OPT
if (!seg->segid_preskip && seg->update_map)
write_segment_id(cpi, mbmi, w, seg, segp, skip);
@@ -2550,11 +2858,11 @@
av1_get_block_dimensions(mbmi->sb_type[plane], plane, xd, NULL, NULL,
&rows, &cols);
assert(*tok < tok_end);
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
pack_map_tokens(w, tok, palette_size_plane, cols, rows);
#else
pack_map_tokens(w, tok, palette_size_plane, rows * cols);
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
}
}
@@ -2597,7 +2905,8 @@
write_tokens_b(cpi, w, tok, tok_end);
}
#if CONFIG_PC_WIENER
- else {
+ else if (!is_global_intrabc_allowed(cm) && !cm->features.coded_lossless) {
+ // Assert only when LR is enabled.
assert(1 == av1_get_txk_skip(cm, xd->mi_row, xd->mi_col, 0, 0, 0));
}
#endif // CONFIG_PC_WIENER
@@ -2614,36 +2923,28 @@
const PARTITION_TREE *ptree_luma,
#endif // CONFIG_EXT_RECUR_PARTITIONS
aom_writer *w) {
- if (!is_partition_point(bsize)) {
- return;
- }
-
const int plane = xd->tree_type == CHROMA_PART;
- if (bsize == BLOCK_8X8 && plane > 0) {
- return;
- }
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ if (!is_partition_point(bsize)) return;
+ if (bsize == BLOCK_8X8 && plane > 0) return;
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
const int ssx = cm->seq_params.subsampling_x;
const int ssy = cm->seq_params.subsampling_y;
- if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
- assert(p ==
- sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ssx, ssy));
- return;
- }
-
- PARTITION_TYPE implied_partition;
- const bool is_part_implied = is_partition_implied_at_boundary(
- &cm->mi_params, xd->tree_type, ssx, ssy, mi_row, mi_col, bsize,
- &ptree->chroma_ref_info, &implied_partition);
- if (is_part_implied) {
- assert(p == implied_partition);
+ const PARTITION_TYPE derived_partition =
+ av1_get_normative_forced_partition_type(
+ &cm->mi_params, xd->tree_type, ssx, ssy, mi_row, mi_col, bsize,
+ ptree_luma, &ptree->chroma_ref_info);
+ if (derived_partition != PARTITION_INVALID) {
+ assert(p == derived_partition);
return;
}
#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
const bool do_split = p != PARTITION_NONE;
aom_write_symbol(w, do_split, ec_ctx->do_split_cdf[plane][ctx], 2);
@@ -2658,20 +2959,42 @@
ec_ctx->do_square_split_cdf[plane][square_split_ctx], 2);
}
if (do_square_split) {
+ assert(p == PARTITION_SPLIT);
return;
}
RECT_PART_TYPE rect_type = get_rect_part_type(p);
if (rect_type_implied_by_bsize(bsize, xd->tree_type) == RECT_INVALID) {
- aom_write_symbol(w, rect_type, ec_ctx->rect_type_cdf[plane][ctx], 2);
+ aom_write_symbol(w, rect_type, ec_ctx->rect_type_cdf[plane][ctx],
+ NUM_RECT_PARTS);
}
- const bool disable_ext_part = !cm->seq_params.enable_ext_partitions;
const bool ext_partition_allowed =
- !disable_ext_part &&
+ cm->seq_params.enable_ext_partitions &&
is_ext_partition_allowed(bsize, rect_type, xd->tree_type);
if (ext_partition_allowed) {
const bool do_ext_partition = (p >= PARTITION_HORZ_3);
aom_write_symbol(w, do_ext_partition,
ec_ctx->do_ext_partition_cdf[plane][rect_type][ctx], 2);
+#if CONFIG_UNEVEN_4WAY
+ if (do_ext_partition) {
+ const bool uneven_4way_partition_allowed =
+ is_uneven_4way_partition_allowed(bsize, rect_type, xd->tree_type);
+ if (uneven_4way_partition_allowed) {
+ const bool do_uneven_4way_partition = (p >= PARTITION_HORZ_4A);
+ aom_write_symbol(
+ w, do_uneven_4way_partition,
+ ec_ctx->do_uneven_4way_partition_cdf[plane][rect_type][ctx], 2);
+ if (do_uneven_4way_partition) {
+ const UNEVEN_4WAY_PART_TYPE uneven_4way_type =
+ (p == PARTITION_HORZ_4A || p == PARTITION_VERT_4A) ? UNEVEN_4A
+ : UNEVEN_4B;
+ aom_write_symbol(
+ w, uneven_4way_type,
+ ec_ctx->uneven_4way_partition_type_cdf[plane][rect_type][ctx],
+ NUM_UNEVEN_4WAY_PARTS);
+ }
+ }
+ }
+#endif // CONFIG_UNEVEN_4WAY
}
#else // CONFIG_EXT_RECUR_PARTITIONS
const int hbs_w = mi_size_wide[bsize] / 2;
@@ -2728,13 +3051,18 @@
assert(bsize < BLOCK_SIZES_ALL);
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
-#if !CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ const int ebs_w = mi_size_wide[bsize] / 8;
+ const int ebs_h = mi_size_high[bsize] / 8;
+#endif // CONFIG_UNEVEN_4WAY
+#if !CONFIG_EXT_RECUR_PARTITIONS
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
-#endif // !CONFIG_H_PARTITION
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
assert(ptree);
const PARTITION_TYPE partition = ptree->partition;
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
+ if (subsize == BLOCK_INVALID) return;
if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
@@ -2743,7 +3071,12 @@
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
for (int plane = plane_start; plane < plane_end; ++plane) {
int rcol0, rcol1, rrow0, rrow1;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if ((cm->rst_info[plane].frame_restoration_type != RESTORE_NONE ||
+ cm->rst_info[plane].frame_cross_restoration_type != RESTORE_NONE) &&
+#else
if (cm->rst_info[plane].frame_restoration_type != RESTORE_NONE &&
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
&rcol0, &rcol1, &rrow0, &rrow1)) {
const int rstride = cm->rst_info[plane].horz_units_per_tile;
@@ -2762,9 +3095,12 @@
#if CONFIG_EXT_RECUR_PARTITIONS
write_partition(cm, xd, mi_row, mi_col, partition, bsize, ptree, ptree_luma,
w);
- if (!is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
+ const int track_ptree_luma =
+ is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize);
+ if (!track_ptree_luma) {
ptree_luma = NULL;
}
+ assert(IMPLIES(track_ptree_luma, ptree_luma));
#else
write_partition(cm, xd, mi_row, mi_col, partition, bsize, w);
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -2805,7 +3141,96 @@
#endif
break;
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+ get_partition_subtree_const(ptree_luma, 0), mi_row, mi_col,
+ subsize);
+ if (mi_row + ebs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+ get_partition_subtree_const(ptree_luma, 1), mi_row + ebs_h,
+ mi_col, bsize_med);
+ if (mi_row + 3 * ebs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+ get_partition_subtree_const(ptree_luma, 2),
+ mi_row + 3 * ebs_h, mi_col, bsize_big);
+ if (mi_row + 7 * ebs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[3],
+ get_partition_subtree_const(ptree_luma, 3),
+ mi_row + 7 * ebs_h, mi_col, subsize);
+ break;
+ }
+ case PARTITION_HORZ_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+ get_partition_subtree_const(ptree_luma, 0), mi_row, mi_col,
+ subsize);
+ if (mi_row + ebs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+ get_partition_subtree_const(ptree_luma, 1), mi_row + ebs_h,
+ mi_col, bsize_big);
+ if (mi_row + 5 * ebs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+ get_partition_subtree_const(ptree_luma, 2),
+ mi_row + 5 * ebs_h, mi_col, bsize_med);
+ if (mi_row + 7 * ebs_h >= mi_params->mi_rows) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[3],
+ get_partition_subtree_const(ptree_luma, 3),
+ mi_row + 7 * ebs_h, mi_col, subsize);
+ break;
+ }
+ case PARTITION_VERT_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+ get_partition_subtree_const(ptree_luma, 0), mi_row, mi_col,
+ subsize);
+ if (mi_col + ebs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+ get_partition_subtree_const(ptree_luma, 1), mi_row,
+ mi_col + ebs_w, bsize_med);
+ if (mi_col + 3 * ebs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+ get_partition_subtree_const(ptree_luma, 2), mi_row,
+ mi_col + 3 * ebs_w, bsize_big);
+ if (mi_col + 7 * ebs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[3],
+ get_partition_subtree_const(ptree_luma, 3), mi_row,
+ mi_col + 7 * ebs_w, subsize);
+ break;
+ }
+ case PARTITION_VERT_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
+ get_partition_subtree_const(ptree_luma, 0), mi_row, mi_col,
+ subsize);
+ if (mi_col + ebs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[1],
+ get_partition_subtree_const(ptree_luma, 1), mi_row,
+ mi_col + ebs_w, bsize_big);
+ if (mi_col + 5 * ebs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[2],
+ get_partition_subtree_const(ptree_luma, 2), mi_row,
+ mi_col + 5 * ebs_w, bsize_med);
+ if (mi_col + 7 * ebs_w >= mi_params->mi_cols) break;
+ write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[3],
+ get_partition_subtree_const(ptree_luma, 3), mi_row,
+ mi_col + 7 * ebs_w, subsize);
+ break;
+ }
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3:
case PARTITION_VERT_3:
for (int i = 0; i < 4; ++i) {
@@ -2829,36 +3254,6 @@
this_mi_col, this_bsize);
}
break;
-#else
- case PARTITION_HORZ_3:
- write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
- get_partition_subtree_const(ptree_luma, 0), 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],
- get_partition_subtree_const(ptree_luma, 1), mi_row,
- 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],
- get_partition_subtree_const(ptree_luma, 2), mi_row,
- 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],
- get_partition_subtree_const(ptree_luma, 0), 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],
- get_partition_subtree_const(ptree_luma, 1), 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],
- get_partition_subtree_const(ptree_luma, 2), mi_row,
- mi_col + 3 * qbs_w, subsize);
- break;
-#endif // CONFIG_H_PARTITION
case PARTITION_SPLIT:
write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0],
get_partition_subtree_const(ptree_luma, 0), mi_row, mi_col,
@@ -2873,7 +3268,7 @@
get_partition_subtree_const(ptree_luma, 3), mi_row + hbs_h,
mi_col + hbs_w, subsize);
break;
-#else
+#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
write_modes_sb(cpi, tile, w, tok, tok_end, ptree->sub_tree[0], mi_row,
mi_col, subsize);
@@ -3024,11 +3419,25 @@
if (!cm->seq_params.enable_restoration) return;
if (is_global_intrabc_allowed(cm)) return;
const int num_planes = av1_num_planes(cm);
+#if CONFIG_FLEXIBLE_RU_SIZE
+ int luma_none = 1, chroma_none = 1;
+#else
int all_none = 1, chroma_none = 1;
+#endif // CONFIG_FLEXIBLE_RU_SIZE
for (int p = 0; p < num_planes; ++p) {
RestorationInfo *rsi = &cm->rst_info[p];
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsi->frame_restoration_type != RESTORE_NONE ||
+ rsi->frame_cross_restoration_type != RESTORE_NONE) {
+ if (p == 0) assert(rsi->frame_cross_restoration_type == RESTORE_NONE);
+#else
if (rsi->frame_restoration_type != RESTORE_NONE) {
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+#if CONFIG_FLEXIBLE_RU_SIZE
+ luma_none &= p > 0;
+#else
all_none = 0;
+#endif // CONFIG_FLEXIBLE_RU_SIZE
chroma_none &= p == 0;
}
#if CONFIG_LR_FLEX_SYNTAX
@@ -3046,11 +3455,17 @@
aom_wb_write_bit(wb, 0);
} else {
aom_wb_write_bit(wb, 1);
+ int tools_count = cm->features.lr_tools_count[p];
for (int i = 1; i < RESTORE_SWITCHABLE_TYPES; ++i) {
if (!(plane_lr_tools_disable_mask & (1 << i))) {
- aom_wb_write_bit(wb, ((sw_lr_tools_disable_mask >> i) & 1));
+ const int disable_tool = (sw_lr_tools_disable_mask >> i) & 1;
+ aom_wb_write_bit(wb, disable_tool);
plane_lr_tools_disable_mask |=
(sw_lr_tools_disable_mask & (1 << i));
+ tools_count -= disable_tool;
+ // if tools_count becomes 2 break from the loop since we
+ // do not allow any other tool to be disabled.
+ if (tools_count == 2) break;
}
}
av1_set_lr_tools(plane_lr_tools_disable_mask, p, &cm->features);
@@ -3107,7 +3522,29 @@
? NUM_WIENERNS_CLASS_INIT_LUMA
: NUM_WIENERNS_CLASS_INIT_CHROMA));
#endif // CONFIG_WIENER_NONSEP
+
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (p > 0) {
+ aom_wb_write_bit(wb, rsi->frame_cross_restoration_type != RESTORE_NONE);
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
+#if CONFIG_FLEXIBLE_RU_SIZE
+ int size = cm->rst_info[0].max_restoration_unit_size;
+ if (!luma_none) {
+ aom_wb_write_bit(wb, cm->rst_info[0].restoration_unit_size == size >> 1);
+ if (cm->rst_info[0].restoration_unit_size != size >> 1)
+ aom_wb_write_bit(wb, cm->rst_info[0].restoration_unit_size == size);
+ }
+ if (!chroma_none) {
+ size = cm->rst_info[1].max_restoration_unit_size;
+ aom_wb_write_bit(wb, cm->rst_info[1].restoration_unit_size == size >> 1);
+ if (cm->rst_info[1].restoration_unit_size != size >> 1)
+ aom_wb_write_bit(wb, cm->rst_info[1].restoration_unit_size == size);
+ assert(cm->rst_info[2].restoration_unit_size ==
+ cm->rst_info[1].restoration_unit_size);
+ }
+#else
if (!all_none) {
#if CONFIG_BLOCK_256
assert(cm->sb_size == BLOCK_64X64 || cm->sb_size == BLOCK_128X128 ||
@@ -3161,6 +3598,7 @@
cm->rst_info[1].restoration_unit_size);
}
}
+#endif // CONFIG_FLEXIBLE_RU_SIZE
}
static AOM_INLINE void write_wiener_filter(MACROBLOCKD *xd, int wiener_win,
@@ -3313,8 +3751,9 @@
aom_write_literal(wb, match, 1);
if (match) break;
}
- assert(
- IMPLIES(!match, ref == bank->bank_size_for_class[wiener_class_id] - 1));
+ assert(IMPLIES(
+ !match,
+ ref == AOMMAX(0, bank->bank_size_for_class[wiener_class_id] - 1)));
return exact_match;
}
#endif // CONFIG_LR_MERGE_COEFFS
@@ -3323,7 +3762,12 @@
MACROBLOCKD *xd, int plane, const WienerNonsepInfo *wienerns_info,
WienerNonsepInfoBank *bank, aom_writer *wb) {
const WienernsFilterParameters *nsfilter_params =
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ get_wienerns_parameters(xd->current_base_qindex, plane != AOM_PLANE_Y,
+ wienerns_info->is_cross_filter);
+#else
get_wienerns_parameters(xd->current_base_qindex, plane != AOM_PLANE_Y);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
int skip_filter_write_for_class[WIENERNS_MAX_CLASSES] = { 0 };
int ref_for_class[WIENERNS_MAX_CLASSES] = { 0 };
#if CONFIG_LR_MERGE_COEFFS
@@ -3344,7 +3788,6 @@
for (int c_id = 0; c_id < num_classes; ++c_id) {
if (skip_filter_write_for_class[c_id]) continue;
const int ref = ref_for_class[c_id];
-
const WienerNonsepInfo *ref_wienerns_info =
av1_constref_from_wienerns_bank(bank, ref, c_id);
const int16_t *wienerns_info_nsfilter =
@@ -3437,13 +3880,25 @@
aom_writer *const w, int plane, FRAME_COUNTS *counts) {
const RestorationInfo *rsi = cm->rst_info + plane;
RestorationType frame_rtype = rsi->frame_restoration_type;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ RestorationType frame_cross_rtype = rsi->frame_cross_restoration_type;
+ RestorationType unit_cross_rtype = rui->cross_restoration_type;
+ assert(frame_rtype != RESTORE_NONE || frame_cross_rtype != RESTORE_NONE);
+#else
assert(frame_rtype != RESTORE_NONE);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
(void)counts;
assert(!cm->features.all_lossless);
const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN;
RestorationType unit_rtype = rui->restoration_type;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ WienerNonsepInfo *info = (WienerNonsepInfo *)&rui->wienerns_info;
+ info->is_cross_filter = 0;
+ info = (WienerNonsepInfo *)&rui->wienerns_cross_info;
+ info->is_cross_filter = 1;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#if CONFIG_LR_FLEX_SYNTAX
assert(((cm->features.lr_tools_disable_mask[plane] >> rui->restoration_type) &
1) == 0);
@@ -3533,6 +3988,19 @@
}
#endif // CONFIG_PC_WIENER
}
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (frame_cross_rtype == RESTORE_WIENER_NONSEP) {
+ aom_write_symbol(w, unit_cross_rtype != RESTORE_NONE,
+ xd->tile_ctx->wienerns_restore_cdf, 2);
+#if CONFIG_ENTROPY_STATS
+ ++counts->wienerns_restore[unit_cross_rtype != RESTORE_NONE];
+#endif // CONFIG_ENTROPY_STATS
+ if (unit_cross_rtype != RESTORE_NONE) {
+ write_wienerns_filter(xd, plane, &rui->wienerns_cross_info,
+ &xd->wienerns_cross_info[plane], w);
+ }
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
static AOM_INLINE void encode_loopfilter(AV1_COMMON *cm,
@@ -4378,7 +4846,7 @@
aom_wb_write_bit(wb, uv_neq_y);
if (uv_neq_y) {
for (int i = 1; i < RESTORE_SWITCHABLE_TYPES; ++i) {
- if (DEF_UV_LR_TOOLS_DISABLE_MASK | (1 << i)) continue;
+ if (DEF_UV_LR_TOOLS_DISABLE_MASK & (1 << i)) continue;
aom_wb_write_bit(wb, (seq_params->lr_tools_disable_mask[1] >> i) & 1);
}
}
@@ -4392,6 +4860,10 @@
aom_wb_write_bit(wb, seq_params->enable_refmvbank);
#endif // CONFIG_REF_MV_BANK
aom_wb_write_bit(wb, seq_params->explicit_ref_frame_map);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // 0 : show_existing_frame, 1: implicit derviation
+ aom_wb_write_bit(wb, seq_params->enable_frame_output_order);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
// A bit is sent here to indicate if the max number of references is 7. If
// this bit is 0, then two more bits are sent to indicate the exact number
// of references allowed (range: 3 to 6).
@@ -4416,6 +4888,12 @@
#if CONFIG_BAWP
aom_wb_write_bit(wb, seq_params->enable_bawp);
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ aom_wb_write_bit(wb, seq_params->enable_cwp);
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ aom_wb_write_bit(wb, seq_params->enable_imp_msk_bld);
+#endif // CONFIG_D071_IMP_MSK_BLD
aom_wb_write_bit(wb, seq_params->enable_fsc);
#if CONFIG_CCSO
aom_wb_write_bit(wb, seq_params->enable_ccso);
@@ -4426,6 +4904,9 @@
#if CONFIG_ORIP
aom_wb_write_bit(wb, seq_params->enable_orip);
#endif
+#if CONFIG_IDIF
+ aom_wb_write_bit(wb, seq_params->enable_idif);
+#endif // CONFIG_IDIF
#if CONFIG_OPTFLOW_REFINEMENT
if (seq_params->order_hint_info.enable_order_hint)
aom_wb_write_literal(wb, seq_params->enable_opfl_refine, 2);
@@ -4435,6 +4916,10 @@
aom_wb_write_bit(wb, seq_params->enable_adaptive_mvd);
#endif // CONFIG_ADAPTIVE_MVD
+#if CONFIG_REFINEMV
+ aom_wb_write_bit(wb, seq_params->enable_refinemv);
+#endif // CONFIG_REFINEMV
+
#if CONFIG_FLEX_MVRES
aom_wb_write_bit(wb, seq_params->enable_flex_mvres);
#endif // CONFIG_FLEX_MVRES
@@ -4449,22 +4934,41 @@
#if CONFIG_EXT_RECUR_PARTITIONS
aom_wb_write_bit(wb, seq_params->enable_ext_partitions);
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ if (seq_params->reduced_still_picture_hdr) {
+ assert(seq_params->enable_global_motion == 0);
+ } else {
+ aom_wb_write_bit(wb, seq_params->enable_global_motion);
+ }
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
static AOM_INLINE void write_global_motion_params(
const WarpedMotionParams *params, const WarpedMotionParams *ref_params,
#if !CONFIG_FLEX_MVRES
struct aom_write_bit_buffer *wb, int allow_hp) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ (void)allow_hp;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
#else
struct aom_write_bit_buffer *wb, MvSubpelPrecision precision) {
const int precision_loss = get_gm_precision_loss(precision);
-#endif
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ (void)precision_loss;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+#endif // !CONFIG_FLEX_MVRES
const TransformationType type = params->wmtype;
aom_wb_write_bit(wb, type != IDENTITY);
if (type != IDENTITY) {
aom_wb_write_bit(wb, type == ROTZOOM);
- if (type != ROTZOOM) aom_wb_write_bit(wb, type == TRANSLATION);
+ if (type != ROTZOOM) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ assert(type == AFFINE);
+#else
+ aom_wb_write_bit(wb, type == TRANSLATION);
+#endif // !CONFIG_IMPROVED_GLOBAL_MOTION
+ }
}
if (type >= ROTZOOM) {
@@ -4492,6 +4996,10 @@
}
if (type >= TRANSLATION) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ const int trans_prec_diff = GM_TRANS_PREC_DIFF;
+ const int trans_max = GM_TRANS_MAX;
+#else
#if CONFIG_FLEX_MVRES
const int trans_bits = (type == TRANSLATION)
? GM_ABS_TRANS_ONLY_BITS - precision_loss
@@ -4506,14 +5014,16 @@
const int trans_prec_diff = (type == TRANSLATION)
? GM_TRANS_ONLY_PREC_DIFF + !allow_hp
: GM_TRANS_PREC_DIFF;
-#endif
+#endif // CONFIG_FLEX_MVRES
+ const int trans_max = (1 << trans_bits);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
aom_wb_write_signed_primitive_refsubexpfin(
- wb, (1 << trans_bits) + 1, SUBEXPFIN_K,
+ wb, trans_max + 1, SUBEXPFIN_K,
(ref_params->wmmat[0] >> trans_prec_diff),
(params->wmmat[0] >> trans_prec_diff));
aom_wb_write_signed_primitive_refsubexpfin(
- wb, (1 << trans_bits) + 1, SUBEXPFIN_K,
+ wb, trans_max + 1, SUBEXPFIN_K,
(ref_params->wmmat[1] >> trans_prec_diff),
(params->wmmat[1] >> trans_prec_diff));
}
@@ -4522,11 +5032,88 @@
static AOM_INLINE void write_global_motion(AV1_COMP *cpi,
struct aom_write_bit_buffer *wb) {
AV1_COMMON *const cm = &cpi->common;
+ int num_total_refs = cm->ref_frames_info.num_total_refs;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ assert(cm->cur_frame->num_ref_frames == num_total_refs);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
int frame;
- for (frame = 0; frame < cm->ref_frames_info.num_total_refs; ++frame) {
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ if (!seq_params->enable_global_motion) {
+ return;
+ }
+
+ bool use_global_motion = false;
+ for (frame = 0; frame < num_total_refs; ++frame) {
+ if (cm->global_motion[frame].wmtype != IDENTITY) {
+ use_global_motion = true;
+ break;
+ }
+ }
+
+ aom_wb_write_bit(wb, use_global_motion);
+ if (!use_global_motion) {
+ return;
+ }
+
+ int our_ref = cpi->gm_info.base_model_our_ref;
+ int their_ref = cpi->gm_info.base_model_their_ref;
+ aom_wb_write_primitive_quniform(wb, num_total_refs + 1, our_ref);
+ if (our_ref >= num_total_refs) {
+ // Special case: Use IDENTITY model
+ // Nothing more to code
+ assert(their_ref == -1);
+ } else {
+ RefCntBuffer *buf = get_ref_frame_buf(cm, our_ref);
+ assert(buf);
+ int their_num_refs = buf->num_ref_frames;
+ if (their_num_refs == 0) {
+ // Special case: if an intra/key frame is used as a ref, use an
+ // IDENTITY model
+ // Nothing more to code
+ assert(their_ref == -1);
+ } else {
+ aom_wb_write_primitive_quniform(wb, their_num_refs, their_ref);
+ }
+ }
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
+ for (frame = 0; frame < num_total_refs; ++frame) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ int temporal_distance;
+ if (seq_params->order_hint_info.enable_order_hint) {
+ const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, frame);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = ref_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
+ const int ref_order_hint = ref_buf->order_hint;
+ const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ temporal_distance = get_relative_dist(&seq_params->order_hint_info,
+ cur_order_hint, ref_order_hint);
+ } else {
+ temporal_distance = 1;
+ }
+
+ if (temporal_distance == 0) {
+ // Don't code global motion for frames at the same temporal instant
+ assert(cm->global_motion[frame].wmtype == IDENTITY);
+ continue;
+ }
+
+ WarpedMotionParams ref_params_;
+ av1_scale_warp_model(&cm->base_global_motion_model,
+ cm->base_global_motion_distance, &ref_params_,
+ temporal_distance);
+ WarpedMotionParams *ref_params = &ref_params_;
+#else
const WarpedMotionParams *ref_params =
cm->prev_frame ? &cm->prev_frame->global_motion[frame]
: &default_warp_params;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
write_global_motion_params(&cm->global_motion[frame], ref_params, wb,
#if !CONFIG_FLEX_MVRES
cm->features.allow_high_precision_mv);
@@ -4610,11 +5197,7 @@
}
}
aom_wb_write_bit(wb, features->disable_cdf_update);
-#if DS_FRAME_LEVEL
- if (current_frame->frame_type == KEY_FRAME) {
- aom_wb_write_literal(wb, features->ds_filter_type, 2);
- }
-#endif // DS_FRAME_LEVEL
+
if (seq_params->force_screen_content_tools == 2) {
aom_wb_write_bit(wb, features->allow_screen_content_tools);
} else {
@@ -4734,11 +5317,11 @@
if (features->allow_global_intrabc) {
aom_wb_write_bit(wb, features->allow_local_intrabc);
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
aom_wb_write_primitive_quniform(
wb, MAX_MAX_DRL_BITS - MIN_MAX_DRL_BITS + 1,
features->max_drl_bits - MIN_MAX_DRL_BITS);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#endif // CONFIG_IBC_SR_EXT
} else {
@@ -4753,11 +5336,11 @@
if (features->allow_global_intrabc) {
aom_wb_write_bit(wb, features->allow_local_intrabc);
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
aom_wb_write_primitive_quniform(
wb, MAX_MAX_DRL_BITS - MIN_MAX_DRL_BITS + 1,
features->max_drl_bits - MIN_MAX_DRL_BITS);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#endif // CONFIG_IBC_SR_EXT
} else if (current_frame->frame_type == INTER_FRAME ||
@@ -4997,6 +5580,15 @@
aom_wb_write_bit(wb, features->enable_bawp);
#endif // CONFIG_BAWP
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (!frame_is_intra_only(cm) &&
+ (features->enabled_motion_modes & (1 << WARP_DELTA)) != 0) {
+ aom_wb_write_bit(wb, features->allow_warpmv_mode);
+ } else {
+ assert(IMPLIES(!frame_is_intra_only(cm), !features->allow_warpmv_mode));
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
aom_wb_write_bit(wb, features->reduced_tx_set_used);
if (!frame_is_intra_only(cm)) write_global_motion(cpi, wb);
@@ -5881,7 +6473,16 @@
}
const int write_frame_header =
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ (cpi->num_tg > 1 ||
+ (encode_show_existing_frame(cm) &&
+ (!cm->seq_params.order_hint_info.enable_order_hint ||
+ !cm->seq_params.enable_frame_output_order)) ||
+ (encode_show_existing_frame(cm) &&
+ cm->cur_frame->frame_type == KEY_FRAME)
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
(cpi->num_tg > 1 || encode_show_existing_frame(cm)
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
#if CONFIG_TIP
|| (cm->features.tip_frame_mode == TIP_FRAME_AS_OUTPUT)
#endif // CONFIG_TIP
@@ -5907,7 +6508,19 @@
data += fh_info.total_length;
}
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // When enable_frame_output_order == 1, the OBU packet of show_existing_frame
+ // is not signaled for non-error-resilient mode.
+ // For error-resilienet mode, still an OBU is signaled.
+ if ((cm->seq_params.order_hint_info.enable_order_hint &&
+ cm->seq_params.enable_frame_output_order && cm->show_existing_frame &&
+ !cm->features.error_resilient_mode) ||
+ ((!cm->seq_params.order_hint_info.enable_order_hint ||
+ !cm->seq_params.enable_frame_output_order) &&
+ encode_show_existing_frame(cm))
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (encode_show_existing_frame(cm)
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
#if CONFIG_TIP
|| (cm->features.tip_frame_mode == TIP_FRAME_AS_OUTPUT)
#endif // CONFIG_TIP
@@ -5916,7 +6529,7 @@
} else {
// Since length_field is determined adaptively after frame header
// encoding, saved_wb must be adjusted accordingly.
- saved_wb.bit_buffer += length_field;
+ if (saved_wb.bit_buffer) saved_wb.bit_buffer += length_field;
// Each tile group obu will be preceded by 4-byte size of the tile group
// obu
diff --git a/av1/encoder/bitstream.h b/av1/encoder/bitstream.h
index 7257870..7148835 100644
--- a/av1/encoder/bitstream.h
+++ b/av1/encoder/bitstream.h
@@ -49,7 +49,12 @@
aom_writer *w);
void av1_write_tx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
- TX_TYPE tx_type, TX_SIZE tx_size, aom_writer *w);
+ TX_TYPE tx_type, TX_SIZE tx_size, aom_writer *w
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ const int plane, const int eob, const int dc_skip
+#endif // CONFIG_ATC_DCTX_ALIGNED
+);
#if CONFIG_CROSS_CHROMA_TX
void av1_write_cctx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 3051f9d..ac9663e 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -113,6 +113,10 @@
tran_low_t *coeff;
//! Location of the end of qcoeff (end of block).
uint16_t *eobs;
+#if CONFIG_ATC_DCTX_ALIGNED
+ //! Location of the beginning of qcoeff (beginning of block).
+ uint16_t *bobs;
+#endif // CONFIG_ATC_DCTX_ALIGNED
//! Contexts used to code the transform coefficients.
uint8_t *txb_entropy_ctx;
//! A buffer containing the source frame.
@@ -154,7 +158,7 @@
//! Cost to skip txfm for the current AOM_PLANE_V txfm block.
int v_txb_skip_cost[V_TXB_SKIP_CONTEXTS][2];
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
//! Cost for encoding the base_eob level of a low-frequency coefficient
int base_lf_eob_cost[SIG_COEF_CONTEXTS_EOB][LF_BASE_SYMBOLS - 1];
//! Cost for encoding the base level of a low-frequency coefficient
@@ -162,7 +166,7 @@
//! Cost for encoding an increment to the low-frequency coefficient
int lps_lf_cost[LF_LEVEL_CONTEXTS]
[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#if CONFIG_PAR_HIDING
//! Cost for encoding the base level of a parity-hidden coefficient
int base_ph_cost[COEFF_BASE_PH_CONTEXTS][4];
@@ -202,13 +206,24 @@
//! Cost for encoding an increment to the coefficient for IDTX blocks
int lps_cost_skip[IDTX_LEVEL_CONTEXTS]
[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1];
+#if CONFIG_ATC_DCTX_ALIGNED
+ /*! \brief Cost for encoding the base_bob of a level for IDTX blocks.
+ *
+ * Decoder uses base_bob to derive the base_level as base_bob := base_bob+1.
+ */
+ int base_bob_cost[SIG_COEF_CONTEXTS_BOB][3];
+#endif // CONFIG_ATC_DCTX_ALIGNED
} LV_MAP_COEFF_COST;
/*! \brief Costs for encoding the eob.
*/
typedef struct {
//! eob_cost.
+#if CONFIG_ATC_DCTX_ALIGNED
+ int eob_cost[EOB_MAX_SYMS];
+#else
int eob_cost[2][11];
+#endif // CONFIG_ATC_DCTX_ALIGNED
} LV_MAP_EOB_COST;
/*! \brief Stores the transforms coefficients for the whole superblock.
@@ -218,6 +233,10 @@
tran_low_t tcoeff[MAX_MB_PLANE][MAX_SB_SQUARE];
//! Where the transformed coefficients end.
uint16_t eobs[MAX_MB_PLANE][MAX_SB_SQUARE / (TX_SIZE_W_MIN * TX_SIZE_H_MIN)];
+#if CONFIG_ATC_DCTX_ALIGNED
+ //! Where the transformed coefficients begin.
+ uint16_t bobs[MAX_MB_PLANE][MAX_SB_SQUARE / (TX_SIZE_W_MIN * TX_SIZE_H_MIN)];
+#endif // CONFIG_ATC_DCTX_ALIGNED
/*! \brief Transform block entropy contexts.
*
* Each element is used as a bit field.
@@ -241,7 +260,7 @@
//! Global mvs
int_mv global_mvs[INTER_REFS_PER_FRAME];
//! skip_mvp_candidate_list is the MVP list for skip mode.
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
SKIP_MODE_MVP_LIST skip_mvp_candidate_list;
#endif
@@ -265,14 +284,23 @@
* memory.
*/
typedef struct {
+#if CONFIG_SEP_COMP_DRL
+ //! \copydoc MB_MODE_INFO_EXT::ref_mv_stack
+ CANDIDATE_MV ref_mv_stack[2][USABLE_REF_MV_STACK_SIZE];
+ //! \copydoc MB_MODE_INFO_EXT::weight
+ uint16_t weight[2][USABLE_REF_MV_STACK_SIZE];
+ //! \copydoc MB_MODE_INFO_EXT::ref_mv_count
+ uint8_t ref_mv_count[2];
+#else
//! \copydoc MB_MODE_INFO_EXT::ref_mv_stack
CANDIDATE_MV ref_mv_stack[USABLE_REF_MV_STACK_SIZE];
//! \copydoc MB_MODE_INFO_EXT::weight
uint16_t weight[USABLE_REF_MV_STACK_SIZE];
//! \copydoc MB_MODE_INFO_EXT::ref_mv_count
uint8_t ref_mv_count;
+#endif // CONFIG_SEP_COMP_DRL
//! skip_mvp_candidate_list is the MVP list for skip mode.
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
SKIP_MODE_MVP_LIST skip_mvp_candidate_list;
#endif
// TODO(Ravi/Remya): Reduce the buffer size of global_mvs
@@ -339,6 +367,10 @@
int rate;
//! Location of the end of non-zero entries.
uint16_t eob;
+#if CONFIG_ATC_DCTX_ALIGNED
+ //! Location of the first of non-zero entries.
+ uint16_t bob;
+#endif // CONFIG_ATC_DCTX_ALIGNED
//! Transform type used on the current block.
TX_TYPE tx_type;
//! Unknown usage
@@ -390,11 +422,19 @@
//! Current interpolation filter.
InterpFilter interp_fltr;
//! Refmv index in the drl.
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx[2];
+#else
int ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
//! Whether the predictors are GLOBALMV.
int is_global[2];
//! Current parameters for interinter mode.
INTERINTER_COMPOUND_DATA interinter_comp;
+#if CONFIG_CWP
+ //! Index for compound weighted prediction parameters.
+ int cwp_idx;
+#endif // CONFIG_CWP
} COMP_RD_STATS;
/*! \brief Contains buffers used to speed up rdopt for obmc.
@@ -495,19 +535,37 @@
/*!\cond */
#if CONFIG_BLOCK_256
+
#define BLOCK_256_COUNT 1
#define BLOCK_128_COUNT 3
#define BLOCK_64_COUNT 7
+
+#if CONFIG_UNEVEN_4WAY
+#define BLOCK_32_COUNT 31
+#define BLOCK_16_COUNT 63
+#define BLOCK_8_COUNT 64
+#else
#define BLOCK_32_COUNT 15
#define BLOCK_16_COUNT 31
-#define BLOCK_8_COUNT 127
-#define BLOCK_4_COUNT 128
+#define BLOCK_8_COUNT 63
+#endif // CONFIG_UNEVEN_4WAY
+
+#define BLOCK_4_COUNT 64
+
#else
#define BLOCK_128_COUNT 1
#define BLOCK_64_COUNT 3
+
+#if CONFIG_UNEVEN_4WAY
+#define BLOCK_32_COUNT 15
+#define BLOCK_16_COUNT 31
+#define BLOCK_8_COUNT 32
+#else
#define BLOCK_32_COUNT 7
#define BLOCK_16_COUNT 15
#define BLOCK_8_COUNT 31
+#endif // CONFIG_UNEVEN_4WAY
+
#define BLOCK_4_COUNT 32
#endif // CONFIG_BLOCK_256
@@ -768,6 +826,15 @@
/*! Cost for sending do_ext_partition token. */
int do_ext_partition_cost[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
[PARTITION_CONTEXTS][2];
+#if CONFIG_UNEVEN_4WAY
+ /*! Cost for sending do_uneven_4way_partition token. */
+ int do_uneven_4way_partition_cost[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
+ [PARTITION_CONTEXTS][2];
+ /*! Cost for sending uneven_4way_partition_type token. */
+ int uneven_4way_partition_type_cost[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
+ [PARTITION_CONTEXTS]
+ [NUM_UNEVEN_4WAY_PARTS];
+#endif // CONFIG_UNEVEN_4WAY
//! Cost for coding the partition.
int partition_cost[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
[ALL_PARTITION_TYPES];
@@ -799,7 +866,11 @@
[2 * MAX_ANGLE_DELTA + 1];
//! mrl_index_cost
+#if CONFIG_EXT_DIR
+ int mrl_index_cost[MRL_INDEX_CONTEXTS][MRL_LINE_NUMBER];
+#else
int mrl_index_cost[MRL_LINE_NUMBER];
+#endif // CONFIG_EXT_DIR
//! Cost of signaling the forward skip coding mode
int fsc_cost[FSC_MODE_CONTEXTS][FSC_BSIZE_CONTEXTS][FSC_MODES];
#if CONFIG_IMPROVED_CFL
@@ -834,12 +905,12 @@
#else
int intrabc_cost[2];
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
//! intrabc_mode_cost
int intrabc_mode_cost[2];
//! intrabc_drl_idx_cost
int intrabc_drl_idx_cost[MAX_REF_BV_STACK_SIZE - 1][2];
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
//! palette_y_size_cost
int palette_y_size_cost[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
@@ -855,12 +926,12 @@
int palette_y_mode_cost[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
//! palette_uv_mode_cost
int palette_uv_mode_cost[PALETTE_UV_MODE_CONTEXTS][2];
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
//! palette_y_row_flag_cost
int palette_y_row_flag_cost[PALETTE_ROW_FLAG_CONTEXTS][2];
//! palette_uv_row_flag_cost
int palette_uv_row_flag_cost[PALETTE_ROW_FLAG_CONTEXTS][2];
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
/**@}*/
/*****************************************************************************
@@ -887,10 +958,10 @@
int pb_block_mv_precision_costs[MV_PREC_DOWN_CONTEXTS][FLEX_MV_COSTS_SIZE]
[NUM_MV_PRECISIONS];
#endif
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
//! skip_drl_mode_cost
int skip_drl_mode_cost[3][2];
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
/**@}*/
/*****************************************************************************
@@ -924,11 +995,11 @@
****************************************************************************/
/**@{*/
//! intra_inter_cost
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
int intra_inter_cost[INTRA_INTER_SKIP_TXFM_CONTEXTS][INTRA_INTER_CONTEXTS][2];
#else
int intra_inter_cost[INTRA_INTER_CONTEXTS][2];
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
//! inter_compound_mode_cost
#if CONFIG_OPTFLOW_REFINEMENT
/*! use_optflow_cost */
@@ -941,6 +1012,10 @@
int inter_compound_mode_cost[INTER_COMPOUND_MODE_CONTEXTS]
[INTER_COMPOUND_MODES];
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_CWP
+ //! cwp_idx_cost for compound weighted prediction
+ int cwp_idx_cost[MAX_CWP_CONTEXTS][MAX_CWP_NUM - 1][2];
+#endif // CONFIG_CWP
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
//! jmvd_scale_mode_cost for JOINT_NEWMV
int jmvd_scale_mode_cost[JOINT_NEWMV_SCALE_FACTOR_CNT];
@@ -997,11 +1072,20 @@
int warped_causal_warpmv_cost[BLOCK_SIZES_ALL][2];
#endif // CONFIG_WARPMV
+#if CONFIG_REFINEMV
+ //! refinemv_flag_cost
+ int refinemv_flag_cost[NUM_REFINEMV_CTX][REFINEMV_NUM_MODES];
+#endif // CONFIG_REFINEMV
+
//! warp_delta_param_cost
int warp_delta_param_cost[2][WARP_DELTA_NUM_SYMBOLS];
#if CONFIG_WARP_REF_LIST
//! warp_ref_idx_cost
int warp_ref_idx_cost[3][WARP_REF_CONTEXTS][2];
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ //! warpmv_with_mvd_flag_cost
+ int warpmv_with_mvd_flag_cost[BLOCK_SIZES_ALL][2];
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
//! warp_extend_cost
int warp_extend_cost[WARP_EXTEND_CTXS1][WARP_EXTEND_CTXS2][2];
@@ -1045,7 +1129,12 @@
int txfm_partition_cost[TXFM_PARTITION_CONTEXTS][2];
#endif // CONFIG_NEW_TX_PARTITION
//! inter_tx_type_costs
+#if CONFIG_ATC_DCTX_ALIGNED
+ int inter_tx_type_costs[EXT_TX_SETS_INTER][EOB_TX_CTXS][EXT_TX_SIZES]
+ [TX_TYPES];
+#else
int inter_tx_type_costs[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
+#endif // CONFIG_ATC_DCTX_ALIGNED
//! intra_tx_type_costs
int intra_tx_type_costs[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
[TX_TYPES];
@@ -1144,7 +1233,7 @@
int *amvd_nmv_cost[2];
#endif // CONFIG_ADAPTIVE_MVD
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
/*! Costs for coding the zero components of dv cost. */
int *dv_joint_cost;
@@ -1226,7 +1315,7 @@
} IntraBCMvCosts;
#endif
-#if CONFIG_BVCOST_UPDATE && !CONFIG_FLEX_MVRES
+#if CONFIG_IBC_BV_IMPROVEMENT && !CONFIG_FLEX_MVRES
/*! \brief Holds mv costs for intrabc.
*/
typedef struct {
@@ -1395,7 +1484,7 @@
//! multipliers for motion search.
#if CONFIG_FLEX_MVRES
IntraBCMvCosts dv_costs;
-#elif CONFIG_BVCOST_UPDATE
+#elif CONFIG_IBC_BV_IMPROVEMENT
IntraBCMVCosts dv_costs;
#endif
diff --git a/av1/encoder/compound_type.c b/av1/encoder/compound_type.c
index 9b7c1dc..5cf2f22 100644
--- a/av1/encoder/compound_type.c
+++ b/av1/encoder/compound_type.c
@@ -38,6 +38,10 @@
// Check if interp filter matches with previous case
if (st->interp_fltr != mi->interp_fltr) return 0;
+#if CONFIG_CWP
+ if (st->cwp_idx != mi->cwp_idx) return 0;
+#endif // CONFIG_CWP
+
const MACROBLOCKD *const xd = &x->e_mbd;
// Match MV and reference indices
for (int i = 0; i < 2; ++i) {
@@ -87,6 +91,10 @@
int32_t *comp_model_rate,
int64_t *comp_model_dist, int *comp_rs2,
int *match_index) {
+#if CONFIG_CWP
+ if (mbmi->cwp_idx != CWP_EQUAL) return 0;
+#endif // CONFIG_CWP
+
for (int j = 0; j < x->comp_rd_stats_idx; ++j) {
if (is_comp_rd_match(cpi, x, &x->comp_rd_stats[j], mbmi, comp_rate,
comp_dist, comp_model_rate, comp_model_dist,
@@ -904,19 +912,23 @@
COMPOUND_TYPE *valid_comp_types) {
int valid_type_count = 0;
int comp_type, valid_check;
-#if CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_OPTFLOW_REFINEMENT || CONFIG_REFINEMV
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *mbmi = xd->mi[0];
const PREDICTION_MODE this_mode = mbmi->mode;
// For implementation simplicity, set compound type to COMPOUND_AVERAGE for
// now to avoid compound type RD search. In practice, dist_wtd will always
// be applied instead.
- if (this_mode >= NEAR_NEARMV_OPTFLOW) {
+ if (this_mode >= NEAR_NEARMV_OPTFLOW
+#if CONFIG_REFINEMV
+ || (mbmi->refinemv_flag && switchable_refinemv_flag(&cpi->common, mbmi))
+#endif // CONFIG_REFINEMV
+ ) {
*try_average_and_distwtd_comp = 0;
valid_comp_types[0] = COMPOUND_AVERAGE;
return 1;
}
-#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // CONFIG_OPTFLOW_REFINEMENT || CONFIG_REFINEMV
int8_t enable_masked_type[MASKED_COMPOUND_TYPES] = { 0, 0 };
const int try_average_comp = (mode_search_mask & (1 << COMPOUND_AVERAGE));
@@ -976,6 +988,9 @@
COMPOUND_TYPE cur_type) {
mbmi->interinter_comp.type = cur_type;
mbmi->comp_group_idx = (cur_type >= COMPOUND_WEDGE);
+#if CONFIG_CWP
+ mbmi->cwp_idx = (cur_type == COMPOUND_AVERAGE) ? mbmi->cwp_idx : CWP_EQUAL;
+#endif // CONFIG_CWP
}
// When match is found, populate the compound type data
@@ -1010,6 +1025,9 @@
best_type_stats->comp_best_model_rd = comp_model_rd_cur;
best_type_stats->best_compound_data = mbmi->interinter_comp;
best_type_stats->best_compmode_interinter_cost = rs2;
+#if CONFIG_CWP
+ best_type_stats->cwp_idx = mbmi->cwp_idx;
+#endif // CONFIG_CWP
}
// Updates best_mv for masked compound types
@@ -1034,6 +1052,9 @@
MACROBLOCK *x, const MB_MODE_INFO *const mbmi, const int32_t *comp_rate,
const int64_t *comp_dist, const int32_t *comp_model_rate,
const int64_t *comp_model_dist, const int_mv *cur_mv, const int *comp_rs2) {
+#if CONFIG_CWP
+ if (mbmi->cwp_idx != CWP_EQUAL) return;
+#endif // CONFIG_CWP
const int offset = x->comp_rd_stats_idx;
if (offset < MAX_COMP_RD_STATS) {
COMP_RD_STATS *const rd_stats = x->comp_rd_stats + offset;
@@ -1046,7 +1067,15 @@
memcpy(rd_stats->ref_frames, mbmi->ref_frame, sizeof(rd_stats->ref_frames));
rd_stats->mode = mbmi->mode;
rd_stats->interp_fltr = mbmi->interp_fltr;
+#if CONFIG_SEP_COMP_DRL
+ rd_stats->ref_mv_idx[0] = mbmi->ref_mv_idx[0];
+ rd_stats->ref_mv_idx[1] = mbmi->ref_mv_idx[1];
+#else
rd_stats->ref_mv_idx = mbmi->ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
+#if CONFIG_CWP
+ rd_stats->cwp_idx = mbmi->cwp_idx;
+#endif // CONFIG_CWP
const MACROBLOCKD *const xd = &x->e_mbd;
for (int i = 0; i < 2; ++i) {
const WarpedMotionParams *const wm =
@@ -1324,6 +1353,10 @@
best_type_stats.best_compmode_interinter_cost = 0;
best_type_stats.comp_best_model_rd = INT64_MAX;
+#if CONFIG_CWP
+ best_type_stats.cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
+
int tmp_rate_mv;
const int num_pix = 1 << num_pels_log2_lookup[bsize];
const int mask_len = 2 * num_pix * sizeof(uint8_t);
@@ -1369,6 +1402,11 @@
av1_zero_array(masked_type_cost, COMPOUND_TYPES);
else
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ if (mbmi->refinemv_flag && switchable_refinemv_flag(cm, mbmi))
+ av1_zero_array(masked_type_cost, COMPOUND_TYPES);
+ else
+#endif // CONFIG_REFINEMV
// Populates masked_type_cost local array for the 4 compound types
calc_masked_type_cost(&x->mode_costs, bsize, comp_group_idx_ctx,
masked_compound_used, masked_type_cost);
@@ -1384,6 +1422,9 @@
#if CONFIG_OPTFLOW_REFINEMENT
this_mode < NEAR_NEARMV_OPTFLOW &&
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ (!mbmi->refinemv_flag || !switchable_refinemv_flag(cm, mbmi)) &&
+#endif // CONFIG_REFINEMV
cpi->sf.inter_sf.reuse_compound_type_decision) {
return populate_reuse_comp_type_data(x, mbmi, &best_type_stats, cur_mv,
comp_rate, comp_dist, comp_rs2,
@@ -1396,6 +1437,7 @@
// Loop over valid compound types
for (int i = 0; i < valid_type_count; i++) {
cur_type = valid_comp_types[i];
+
comp_model_rd_cur = INT64_MAX;
tmp_rate_mv = *rate_mv;
best_rd_cur = INT64_MAX;
@@ -1404,6 +1446,13 @@
if (cur_type < COMPOUND_WEDGE) {
update_mbmi_for_compound_type(mbmi, cur_type);
rs2 = masked_type_cost[cur_type];
+
+#if CONFIG_CWP
+ if (cm->features.enable_cwp && is_cwp_allowed(mbmi) && !mbmi->skip_mode) {
+ rs2 += av1_get_cwp_idx_cost(mbmi->cwp_idx, cm, x);
+ }
+#endif // CONFIG_CWP
+
const int64_t mode_rd = RDCOST(x->rdmult, rs2 + rd_stats->rate, 0);
if (mode_rd < ref_best_rd) {
// Reuse data if matching record is found
@@ -1506,6 +1555,11 @@
mbmi->interinter_comp = best_type_stats.best_compound_data;
memcpy(xd->seg_mask, buffers->tmp_best_mask_buf, mask_len);
}
+#if CONFIG_CWP
+ // update best cwp_idx
+ mbmi->cwp_idx = best_type_stats.cwp_idx;
+#endif // CONFIG_CWP
+
if (have_newmv_in_inter_mode(this_mode)) {
mbmi->mv[0].as_int = best_mv[0].as_int;
mbmi->mv[1].as_int = best_mv[1].as_int;
diff --git a/av1/encoder/compound_type.h b/av1/encoder/compound_type.h
index 7543aa0..eb66e4f 100644
--- a/av1/encoder/compound_type.h
+++ b/av1/encoder/compound_type.h
@@ -25,6 +25,10 @@
INTERINTER_COMPOUND_DATA best_compound_data;
int64_t comp_best_model_rd;
int best_compmode_interinter_cost;
+#if CONFIG_CWP
+ // Index for the weighting factor of compound weighted prediction
+ int8_t cwp_idx;
+#endif // CONFIG_CWP
} BEST_COMP_TYPE_STATS;
#define IGNORE_MODE -1
diff --git a/av1/encoder/context_tree.c b/av1/encoder/context_tree.c
index bce1223..a057bc7 100644
--- a/av1/encoder/context_tree.c
+++ b/av1/encoder/context_tree.c
@@ -31,6 +31,7 @@
dst_ctx->mbmi_ext_best = src_ctx->mbmi_ext_best;
dst_ctx->num_4x4_blk = src_ctx->num_4x4_blk;
+ dst_ctx->num_4x4_blk_chroma = src_ctx->num_4x4_blk_chroma;
dst_ctx->skippable = src_ctx->skippable;
memcpy(dst_ctx->blk_skip, src_ctx->blk_skip,
@@ -52,8 +53,11 @@
const int num_pix = src_ctx->num_4x4_blk * 16;
if (num_pix <= MAX_PALETTE_SQUARE) {
for (int i = 0; i < 2; ++i) {
+ const int num_blk =
+ (i == 0) ? src_ctx->num_4x4_blk : src_ctx->num_4x4_blk_chroma;
+ const int color_map_size = num_blk * 16;
memcpy(dst_ctx->color_index_map[i], src_ctx->color_index_map[i],
- sizeof(src_ctx->color_index_map[i][0]) * num_pix);
+ sizeof(src_ctx->color_index_map[i][0]) * color_map_size);
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -83,8 +87,9 @@
}
}
-PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, int mi_row, int mi_col,
- BLOCK_SIZE bsize, PC_TREE *parent,
+PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, TREE_TYPE tree_type,
+ 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) {
@@ -95,7 +100,8 @@
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,
+ set_chroma_ref_info(tree_type, 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);
@@ -105,6 +111,19 @@
const int num_pix = block_size_wide[bsize] * block_size_high[bsize];
const int num_blk = num_pix / 16;
+#if CONFIG_UNEVEN_4WAY
+ // Biggest chroma block covering multiple luma blocks is of size 8X16 / 16X8,
+ // when a 16X32 / 32X16 block uses a HORZ / VERTICAL 4A/4B partition.
+ const int num_pix_chroma = AOMMAX(num_pix, 16 * 8);
+#else
+ // Biggest chroma block covering multiple luma blocks is of size 8X8,
+ // when a 16X16 block uses a HORZ_3 / VERTICAL_3 partition.
+ // However, we don't explicitly need to allocate that minimum, because palette
+ // is only allowed for bsize >= BLOCK_8X8, and all these block sizes have at
+ // least 64 pixels.
+ const int num_pix_chroma = num_pix;
+#endif // CONFIG_UNEVEN_4WAY
+
AOM_CHECK_MEM_ERROR(&error, ctx->blk_skip,
aom_calloc(num_blk, sizeof(*ctx->blk_skip)));
AOM_CHECK_MEM_ERROR(&error, ctx->tx_type_map,
@@ -119,6 +138,7 @@
aom_calloc(num_blk, sizeof(*ctx->cctx_type_map)));
#endif // CONFIG_CROSS_CHROMA_TX
ctx->num_4x4_blk = num_blk;
+ ctx->num_4x4_blk_chroma = num_pix_chroma / 16;
for (int i = 0; i < num_planes; ++i) {
ctx->coeff[i] = shared_bufs->coeff_buf[i];
@@ -126,6 +146,10 @@
ctx->dqcoeff[i] = shared_bufs->dqcoeff_buf[i];
AOM_CHECK_MEM_ERROR(&error, ctx->eobs[i],
aom_memalign(32, num_blk * sizeof(*ctx->eobs[i])));
+#if CONFIG_ATC_DCTX_ALIGNED
+ AOM_CHECK_MEM_ERROR(&error, ctx->bobs[i],
+ aom_memalign(32, num_blk * sizeof(*ctx->bobs[i])));
+#endif // CONFIG_ATC_DCTX_ALIGNED
AOM_CHECK_MEM_ERROR(
&error, ctx->txb_entropy_ctx[i],
aom_memalign(32, num_blk * sizeof(*ctx->txb_entropy_ctx[i])));
@@ -133,9 +157,10 @@
if (num_pix <= MAX_PALETTE_SQUARE) {
for (int i = 0; i < 2; ++i) {
+ const int color_map_size = (i == 0) ? num_pix : num_pix_chroma;
AOM_CHECK_MEM_ERROR(
&error, ctx->color_index_map[i],
- aom_memalign(32, num_pix * sizeof(*ctx->color_index_map[i])));
+ aom_memalign(32, color_map_size * sizeof(*ctx->color_index_map[i])));
}
}
av1_invalid_rd_stats(&ctx->rd_stats);
@@ -162,6 +187,10 @@
ctx->dqcoeff[i] = NULL;
aom_free(ctx->eobs[i]);
ctx->eobs[i] = NULL;
+#if CONFIG_ATC_DCTX_ALIGNED
+ aom_free(ctx->bobs[i]);
+ ctx->bobs[i] = NULL;
+#endif // CONFIG_ATC_DCTX_ALIGNED
aom_free(ctx->txb_entropy_ctx[i]);
ctx->txb_entropy_ctx[i] = NULL;
}
@@ -174,8 +203,8 @@
aom_free(ctx);
}
-PC_TREE *av1_alloc_pc_tree_node(int mi_row, int mi_col, BLOCK_SIZE bsize,
- PC_TREE *parent,
+PC_TREE *av1_alloc_pc_tree_node(TREE_TYPE tree_type, 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) {
@@ -196,7 +225,8 @@
av1_invalid_rd_stats(&pc_tree->none_rd);
pc_tree->skippable = false;
#endif // CONFIG_EXT_RECUR_PARTITIONS
- set_chroma_ref_info(mi_row, mi_col, index, bsize, &pc_tree->chroma_ref_info,
+ set_chroma_ref_info(tree_type, 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);
@@ -207,19 +237,20 @@
pc_tree->vertical[i] = NULL;
}
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ for (int i = 0; i < 4; ++i) {
+ pc_tree->horizontal4a[i] = NULL;
+ pc_tree->horizontal4b[i] = NULL;
+ pc_tree->vertical4a[i] = NULL;
+ pc_tree->vertical4b[i] = NULL;
+ }
+#endif // CONFIG_UNEVEN_4WAY
for (int i = 0; i < 4; ++i) {
pc_tree->horizontal3[i] = NULL;
pc_tree->vertical3[i] = NULL;
}
#else
for (int i = 0; i < 3; ++i) {
- pc_tree->horizontal3[i] = NULL;
- pc_tree->vertical3[i] = NULL;
- }
-#endif // CONFIG_H_PARTITION
-#else
- for (int i = 0; i < 3; ++i) {
pc_tree->horizontala[i] = NULL;
pc_tree->horizontalb[i] = NULL;
pc_tree->verticala[i] = NULL;
@@ -272,11 +303,45 @@
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+
+#if CONFIG_UNEVEN_4WAY
+ if (!keep_best || (partition != PARTITION_HORZ_4A)) {
+ for (int i = 0; i < 4; ++i) {
+ if (pc_tree->horizontal4a[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal4a[i], num_planes, 0, 0);
+ pc_tree->horizontal4a[i] = NULL;
+ }
+ }
+ }
+
+ if (!keep_best || (partition != PARTITION_HORZ_4B)) {
+ for (int i = 0; i < 4; ++i) {
+ if (pc_tree->horizontal4b[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal4b[i], num_planes, 0, 0);
+ pc_tree->horizontal4b[i] = NULL;
+ }
+ }
+ }
+
+ if (!keep_best || (partition != PARTITION_VERT_4A)) {
+ for (int i = 0; i < 4; ++i) {
+ if (pc_tree->vertical4a[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->vertical4a[i], num_planes, 0, 0);
+ pc_tree->vertical4a[i] = NULL;
+ }
+ }
+ }
+
+ if (!keep_best || (partition != PARTITION_VERT_4B)) {
+ for (int i = 0; i < 4; ++i) {
+ if (pc_tree->vertical4b[i] != NULL) {
+ av1_free_pc_tree_recursive(pc_tree->vertical4b[i], num_planes, 0, 0);
+ pc_tree->vertical4b[i] = NULL;
+ }
+ }
+ }
+#endif // CONFIG_UNEVEN_4WAY
for (int i = 0; i < 4; ++i) {
-#else
- for (int i = 0; i < 3; ++i) {
-#endif // CONFIG_H_PARTITION
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);
@@ -323,13 +388,20 @@
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) {
+ TREE_TYPE tree_type, 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;
dst->none_rd = src->none_rd;
dst->skippable = src->skippable;
+#if CONFIG_MVP_IMPROVEMENT
+ dst->ref_mv_bank = src->ref_mv_bank;
+#endif // CONFIG_MVP_IMPROVEMENT
+#if WARP_CU_BANK
+ dst->warp_param_bank = src->warp_param_bank;
+#endif // WARP_CU_BANK
+
const BLOCK_SIZE bsize = dst->block_size;
const BLOCK_SIZE subsize = get_partition_subsize(bsize, src->partitioning);
const int mi_row = src->mi_row;
@@ -341,7 +413,7 @@
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,
+ dst->none = av1_alloc_pmc(cm, tree_type, mi_row, mi_col, bsize, dst,
PARTITION_NONE, 0, ss_x, ss_y, shared_bufs);
av1_copy_tree_context(dst->none, src->none);
}
@@ -358,10 +430,11 @@
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);
+ tree_type, 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);
+ ss_y, shared_bufs, tree_type,
+ num_planes);
}
}
}
@@ -376,12 +449,12 @@
}
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);
+ dst->horizontal[i] = av1_alloc_pc_tree_node(
+ tree_type, 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);
+ shared_bufs, tree_type, num_planes);
}
}
}
@@ -396,16 +469,135 @@
}
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);
+ dst->vertical[i] = av1_alloc_pc_tree_node(
+ tree_type, 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);
+ ss_x, ss_y, shared_bufs, tree_type,
+ num_planes);
}
}
}
break;
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ // PARTITION_HORZ_4A
+ case PARTITION_HORZ_4A:
+ if (is_partition_valid(bsize, PARTITION_HORZ_4A)) {
+ const int ebh = (mi_size_high[bsize] >> 3);
+ const int mi_rows[4] = { mi_row, mi_row + ebh, mi_row + ebh * 3,
+ mi_row + ebh * 7 };
+ const BLOCK_SIZE bsize_big =
+ get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ const BLOCK_SIZE subsizes[4] = { subsize, bsize_med, bsize_big,
+ subsize };
+ for (int i = 0; i < 4; ++i) {
+ if (dst->horizontal4a[i]) {
+ av1_free_pc_tree_recursive(dst->horizontal4a[i], num_planes, 0, 0);
+ dst->horizontal4a[i] = NULL;
+ }
+ if (src->horizontal4a[i]) {
+ dst->horizontal4a[i] = av1_alloc_pc_tree_node(
+ tree_type, mi_rows[i], mi_col, subsizes[i], dst,
+ PARTITION_HORZ_4A, i, i == 3, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->horizontal4a[i],
+ src->horizontal4a[i], ss_x, ss_y,
+ shared_bufs, tree_type, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_HORZ_4B
+ case PARTITION_HORZ_4B:
+ if (is_partition_valid(bsize, PARTITION_HORZ_4B)) {
+ const int ebh = (mi_size_high[bsize] >> 3);
+ const int mi_rows[4] = { mi_row, mi_row + ebh, mi_row + ebh * 5,
+ mi_row + ebh * 7 };
+ const BLOCK_SIZE bsize_big =
+ get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ const BLOCK_SIZE subsizes[4] = { subsize, bsize_big, bsize_med,
+ subsize };
+ for (int i = 0; i < 4; ++i) {
+ if (dst->horizontal4b[i]) {
+ av1_free_pc_tree_recursive(dst->horizontal4b[i], num_planes, 0, 0);
+ dst->horizontal4b[i] = NULL;
+ }
+ if (src->horizontal4b[i]) {
+ dst->horizontal4b[i] = av1_alloc_pc_tree_node(
+ tree_type, mi_rows[i], mi_col, subsizes[i], dst,
+ PARTITION_HORZ_4B, i, i == 3, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->horizontal4b[i],
+ src->horizontal4b[i], ss_x, ss_y,
+ shared_bufs, tree_type, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_VERT_4A
+ case PARTITION_VERT_4A:
+ if (is_partition_valid(bsize, PARTITION_VERT_4A)) {
+ const int ebw = (mi_size_wide[bsize] >> 3);
+ const int mi_cols[4] = { mi_col, mi_col + ebw, mi_col + ebw * 3,
+ mi_col + ebw * 7 };
+ const BLOCK_SIZE bsize_big =
+ get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ const BLOCK_SIZE subsizes[4] = { subsize, bsize_med, bsize_big,
+ subsize };
+ for (int i = 0; i < 4; ++i) {
+ if (dst->vertical4a[i]) {
+ av1_free_pc_tree_recursive(dst->vertical4a[i], num_planes, 0, 0);
+ dst->vertical4a[i] = NULL;
+ }
+ if (src->vertical4a[i]) {
+ dst->vertical4a[i] = av1_alloc_pc_tree_node(
+ tree_type, mi_row, mi_cols[i], subsizes[i], dst,
+ PARTITION_VERT_4A, i, i == 3, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->vertical4a[i],
+ src->vertical4a[i], ss_x, ss_y,
+ shared_bufs, tree_type, num_planes);
+ }
+ }
+ }
+ break;
+ // PARTITION_VERT_4B
+ case PARTITION_VERT_4B:
+ if (is_partition_valid(bsize, PARTITION_VERT_4B)) {
+ const int ebw = (mi_size_wide[bsize] >> 3);
+ const int mi_cols[4] = { mi_col, mi_col + ebw, mi_col + ebw * 5,
+ mi_col + ebw * 7 };
+ const BLOCK_SIZE bsize_big =
+ get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ const BLOCK_SIZE subsizes[4] = { subsize, bsize_big, bsize_med,
+ subsize };
+ for (int i = 0; i < 4; ++i) {
+ if (dst->vertical4b[i]) {
+ av1_free_pc_tree_recursive(dst->vertical4b[i], num_planes, 0, 0);
+ dst->vertical4b[i] = NULL;
+ }
+ if (src->vertical4b[i]) {
+ dst->vertical4b[i] = av1_alloc_pc_tree_node(
+ tree_type, mi_row, mi_cols[i], subsizes[i], dst,
+ PARTITION_VERT_4B, i, i == 3, ss_x, ss_y);
+ av1_copy_pc_tree_recursive(cm, dst->vertical4b[i],
+ src->vertical4b[i], ss_x, ss_y,
+ shared_bufs, tree_type, num_planes);
+ }
+ }
+ }
+ break;
+#endif // CONFIG_UNEVEN_4WAY
+
// PARTITION_HORZ_3
case PARTITION_HORZ_3:
if (is_partition_valid(bsize, PARTITION_HORZ_3)) {
@@ -423,11 +615,11 @@
}
if (src->horizontal3[i]) {
dst->horizontal3[i] = av1_alloc_pc_tree_node(
- mi_row + offset_mr, mi_col + offset_mc, this_subsize, dst,
- PARTITION_HORZ_3, i, i == 3, ss_x, ss_y);
+ tree_type, mi_row + offset_mr, mi_col + offset_mc, this_subsize,
+ dst, PARTITION_HORZ_3, i, i == 3, ss_x, ss_y);
av1_copy_pc_tree_recursive(cm, dst->horizontal3[i],
src->horizontal3[i], ss_x, ss_y,
- shared_bufs, num_planes);
+ shared_bufs, tree_type, num_planes);
}
}
}
@@ -449,65 +641,15 @@
}
if (src->vertical3[i]) {
dst->vertical3[i] = av1_alloc_pc_tree_node(
- mi_row + offset_mr, mi_col + offset_mc, this_subsize, dst,
- PARTITION_VERT_3, i, i == 3, ss_x, ss_y);
+ tree_type, mi_row + offset_mr, mi_col + offset_mc, this_subsize,
+ dst, PARTITION_VERT_3, i, i == 3, ss_x, ss_y);
av1_copy_pc_tree_recursive(cm, dst->vertical3[i], src->vertical3[i],
- ss_x, ss_y, shared_bufs, num_planes);
+ ss_x, ss_y, shared_bufs, tree_type,
+ num_planes);
}
}
}
break;
-#else
- // 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;
-#endif // CONFIG_H_PARTITION
default: assert(0 && "Not a valid partition."); break;
}
}
@@ -647,11 +789,20 @@
if (result) return result;
result = look_for_counterpart_helper(pc_tree->vertical[0], target);
if (result) return result;
+#if CONFIG_UNEVEN_4WAY
+ result = look_for_counterpart_helper(pc_tree->horizontal4a[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->horizontal4b[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->vertical4a[0], target);
+ if (result) return result;
+ result = look_for_counterpart_helper(pc_tree->vertical4b[0], target);
+ if (result) return result;
+#endif // CONFIG_UNEVEN_4WAY
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;
}
diff --git a/av1/encoder/context_tree.h b/av1/encoder/context_tree.h
index 280b3e9..d99cb98 100644
--- a/av1/encoder/context_tree.h
+++ b/av1/encoder/context_tree.h
@@ -46,6 +46,9 @@
tran_low_t *qcoeff[MAX_MB_PLANE];
tran_low_t *dqcoeff[MAX_MB_PLANE];
uint16_t *eobs[MAX_MB_PLANE];
+#if CONFIG_ATC_DCTX_ALIGNED
+ uint16_t *bobs[MAX_MB_PLANE];
+#endif // CONFIG_ATC_DCTX_ALIGNED
uint8_t *txb_entropy_ctx[MAX_MB_PLANE];
TX_TYPE *tx_type_map;
#if CONFIG_CROSS_CHROMA_TX
@@ -53,6 +56,7 @@
#endif // CONFIG_CROSS_CHROMA_TX
int num_4x4_blk;
+ int num_4x4_blk_chroma;
// For current partition, only if all Y, U, and V transform blocks'
// coefficients are quantized to 0, skippable is set to 1.
int skippable;
@@ -76,14 +80,15 @@
#if CONFIG_EXT_RECUR_PARTITIONS
struct PC_TREE *horizontal[2];
struct PC_TREE *vertical[2];
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ struct PC_TREE *horizontal4a[4];
+ struct PC_TREE *horizontal4b[4];
+ struct PC_TREE *vertical4a[4];
+ struct PC_TREE *vertical4b[4];
+#endif // CONFIG_UNEVEN_4WAY
struct PC_TREE *horizontal3[4];
struct PC_TREE *vertical3[4];
#else
- struct PC_TREE *horizontal3[3];
- struct PC_TREE *vertical3[3];
-#endif // CONFIG_H_PARTITION
-#else
PICK_MODE_CONTEXT *horizontal[2];
PICK_MODE_CONTEXT *vertical[2];
PICK_MODE_CONTEXT *horizontala[3];
@@ -104,9 +109,9 @@
#if CONFIG_EXT_RECUR_PARTITIONS
RD_STATS none_rd;
bool skippable;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
REF_MV_BANK ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
WARP_PARAM_BANK warp_param_bank;
#endif // WARP_CU_BANK
@@ -134,8 +139,8 @@
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(int mi_row, int mi_col, BLOCK_SIZE bsize,
- PC_TREE *parent,
+PC_TREE *av1_alloc_pc_tree_node(TREE_TYPE tree_type, 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);
@@ -145,11 +150,12 @@
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);
+ TREE_TYPE tree_type, int num_planes);
#endif // CONFIG_EXT_RECUR_PARTITIONS
-PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, int mi_row, int mi_col,
- BLOCK_SIZE bsize, PC_TREE *parent,
+PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, TREE_TYPE tree_type,
+ 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);
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index a931f84..06809d7 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -863,6 +863,12 @@
source_buffer->metadata);
}
}
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // when enable_frame_output_order == 1, show_existing mechanism is
+ // used for alt_ref in encoder side internally, but the OBU with
+ // show_existing_frame == 1 is not signaled in the bitstream.
+ if (cm->seq_params.enable_frame_output_order) show_existing_alt_ref = 1;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
set_show_existing_alt_ref(&cpi->gf_group, apply_filtering,
oxcf->algo_cfg.enable_overlay,
show_existing_alt_ref);
@@ -1105,6 +1111,9 @@
AOMMIN(cm->seq_params.num_same_ref_compound,
cm->ref_frames_info.num_total_refs);
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ cm->cur_frame->num_ref_frames = cm->ref_frames_info.num_total_refs;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
// ref_frame_flags is defined based on the external flag
// max-reference-frames.
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index e1dca4f..ecd0ee6 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -572,8 +572,9 @@
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row, mi_col,
1);
- 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);
+ PC_TREE *const pc_root =
+ av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, sb_size, NULL,
+ PARTITION_NONE, 0, 1, ss_x, ss_y);
#if CONFIG_EXT_RECUR_PARTITIONS
const PARTITION_TREE *template_tree =
multi_pass_params ? multi_pass_params->template_tree : NULL;
@@ -615,9 +616,9 @@
// First pass
SB_FIRST_PASS_STATS sb_fp_stats;
av1_backup_sb_state(&sb_fp_stats, cpi, td, tile_data, mi_row, mi_col);
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
REF_MV_BANK stored_mv_bank = td->mb.e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
WARP_PARAM_BANK stored_warp_bank = td->mb.e_mbd.warp_param_bank;
#endif // WARP_CU_BANK
@@ -632,9 +633,9 @@
av1_reset_simple_motion_tree_partition(sms_root, sb_size);
av1_restore_sb_state(&sb_fp_stats, cpi, td, tile_data, mi_row, mi_col);
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
td->mb.e_mbd.ref_mv_bank = stored_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
td->mb.e_mbd.warp_param_bank = stored_warp_bank;
#endif // WARP_CU_BANK
@@ -666,13 +667,14 @@
case PARTITION_NONE: num_subtrees = 0; break;
case PARTITION_HORZ:
case PARTITION_VERT: num_subtrees = 2; break;
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B:
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B: num_subtrees = 4; break;
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3:
case PARTITION_VERT_3: num_subtrees = 4; break;
-#else
- case PARTITION_HORZ_3:
- case PARTITION_VERT_3: num_subtrees = 3; break;
-#endif // CONFIG_H_PARTITION
case PARTITION_SPLIT: num_subtrees = 4; break;
default:
assert(0 && "Invalid partition type in set_min_none_to_invalid!");
@@ -797,8 +799,9 @@
cm, xd->tree_type, mi_row, mi_col, bsize,
xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)]);
#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);
+ PC_TREE *const pc_root =
+ av1_alloc_pc_tree_node(xd->tree_type, 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,
#if CONFIG_EXT_RECUR_PARTITIONS
@@ -825,8 +828,9 @@
: (loop_idx == 0 ? LUMA_PART : CHROMA_PART));
init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row,
mi_col, 1);
- 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);
+ PC_TREE *const pc_root =
+ av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, sb_size, NULL,
+ PARTITION_NONE, 0, 1, ss_x, ss_y);
#if CONFIG_EXT_RECUR_PARTITIONS
av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
av1_build_partition_tree_fixed_partitioning(
@@ -1139,7 +1143,7 @@
mi_row += cm->mib_size) {
#if CONFIG_REF_MV_BANK
av1_zero(td->mb.e_mbd.ref_mv_bank);
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
td->mb.e_mbd.ref_mv_bank_pt = &td->mb.e_mbd.ref_mv_bank;
#endif
#endif // CONFIG_REF_MV_BANK
@@ -1237,8 +1241,13 @@
get_ref_frame_buf(cm, skip_mode_info->ref_frame_idx_1);
assert(buf_0 != NULL && buf_1 != NULL);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ ref_order_hint[0] = buf_0->display_order_hint;
+ ref_order_hint[1] = buf_1->display_order_hint;
+#else
ref_order_hint[0] = buf_0->order_hint;
ref_order_hint[1] = buf_1->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
}
static int check_skip_mode_enabled(AV1_COMP *const cpi) {
@@ -1247,9 +1256,13 @@
av1_setup_skip_mode_allowed(cm);
if (!cm->current_frame.skip_mode_info.skip_mode_allowed) return 0;
- // Turn off skip mode if the temporal distances of the reference pair to the
- // current frame are different by more than 1 frame.
+ // Turn off skip mode if the temporal distances of the reference pair to the
+ // current frame are different by more than 1 frame.
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int cur_offset = (int)cm->current_frame.display_order_hint;
+#else
const int cur_offset = (int)cm->current_frame.order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
int ref_offset[2];
get_skip_mode_ref_offsets(cm, ref_offset);
const int cur_to_ref0 = get_relative_dist(&cm->seq_params.order_hint_info,
@@ -1291,6 +1304,19 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
int *src_stride) {
+
+#if CONFIG_REFINEMV
+ if (inter_pred_params->use_ref_padding) {
+ tip_common_calc_subpel_params_and_extend(
+ src_mv, inter_pred_params, xd, mi_x, mi_y, ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ mc_buf, pre, subpel_params, src_stride);
+ return;
+ }
+#endif // CONFIG_REFINEMV
+
// These are part of the function signature to use this function through a
// function pointer. See typedef of 'CalcSubpelParamsFunc'.
(void)xd;
@@ -1338,11 +1364,29 @@
subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
subpel_params->xs = sf->x_step_q4;
subpel_params->ys = sf->y_step_q4;
+
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ // Get reference block top left coordinate.
+ subpel_params->x0 = pos_x >> SCALE_SUBPEL_BITS;
+ subpel_params->y0 = pos_y >> SCALE_SUBPEL_BITS;
+ // Get reference block bottom right coordinate.
+ subpel_params->x1 = subpel_params->x0 + inter_pred_params->block_width;
+ subpel_params->y1 = subpel_params->y0 + inter_pred_params->block_height;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+
*pre = pre_buf->buf0 + (pos_y >> SCALE_SUBPEL_BITS) * pre_buf->stride +
(pos_x >> SCALE_SUBPEL_BITS);
} else {
int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
+
+#if CONFIG_REFINEMV
+ const int bw = inter_pred_params->original_pu_width;
+ const int bh = inter_pred_params->original_pu_height;
+
+#else
#if CONFIG_OPTFLOW_REFINEMENT
// Use original block size to clamp MV and to extend block boundary
const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
@@ -1353,6 +1397,8 @@
const int bw = inter_pred_params->block_width;
const int bh = inter_pred_params->block_height;
#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#endif // CONFIG_REFINEMV
const MV mv_q4 = tip_clamp_mv_to_umv_border_sb(
inter_pred_params, src_mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
@@ -1365,6 +1411,18 @@
subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;
pos_x += mv_q4.col;
pos_y += mv_q4.row;
+
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ // Get reference block top left coordinate.
+ subpel_params->x0 = pos_x >> SUBPEL_BITS;
+ subpel_params->y0 = pos_y >> SUBPEL_BITS;
+ // Get reference block bottom right coordinate.
+ subpel_params->x1 = subpel_params->x0 + inter_pred_params->block_width;
+ subpel_params->y1 = subpel_params->y0 + inter_pred_params->block_height;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+
*pre = pre_buf->buf0 + (pos_y >> SUBPEL_BITS) * pre_buf->stride +
(pos_x >> SUBPEL_BITS);
}
@@ -1479,6 +1537,19 @@
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ features->allow_warpmv_mode =
+ (features->enabled_motion_modes & (1 << WARP_DELTA)) != 0;
+ if (features->allow_warpmv_mode &&
+ cpi->sf.inter_sf.prune_warpmv_prob_thresh > 0) {
+ const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
+ if (frame_probs->warped_probs[update_type] <
+ cpi->sf.inter_sf.prune_warpmv_prob_thresh) {
+ features->allow_warpmv_mode = 0;
+ }
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
int hash_table_created = 0;
if (!is_stat_generation_stage(cpi) && av1_use_hash_me(cpi)) {
// TODO(any): move this outside of the recoding loop to avoid recalculating
@@ -1643,10 +1714,10 @@
start_timing(cpi, av1_setup_motion_field_time);
#endif
if (features->allow_ref_frame_mvs) av1_setup_motion_field(cm);
-#if CONFIG_SMVP_IMPROVEMENT
+#if CONFIG_MVP_IMPROVEMENT
else
av1_setup_ref_frame_sides(cm);
-#endif // CONFIG_SMVP_IMPROVEMENT
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_COLLECT_COMPONENT_TIMING
end_timing(cpi, av1_setup_motion_field_time);
#endif
@@ -1766,6 +1837,17 @@
(frame_probs->warped_probs[update_type] + new_prob) >> 1;
}
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (cpi->sf.inter_sf.prune_warpmv_prob_thresh > 0) {
+ const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
+ int sum = 0;
+ for (i = 0; i < 2; i++) sum += cpi->td.rd_counts.warped_used[i];
+ const int new_prob = sum ? 128 * cpi->td.rd_counts.warped_used[1] / sum : 0;
+ frame_probs->warped_probs[update_type] =
+ (frame_probs->warped_probs[update_type] + new_prob) >> 1;
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
if ((!is_stat_generation_stage(cpi) && av1_use_hash_me(cpi)) ||
hash_table_created) {
av1_hash_table_destroy(&intrabc_hash_info->intrabc_hash_table);
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index e7589aa..4258a28 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -196,13 +196,42 @@
// MB_MODE_INFO_EXT_FRAME to MB_MODE_INFO_EXT.
static INLINE void copy_mbmi_ext_frame_to_mbmi_ext(
MB_MODE_INFO_EXT *mbmi_ext,
- const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_best, uint8_t ref_frame_type) {
+ const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_best, uint8_t ref_frame_type
+#if CONFIG_SEP_COMP_DRL
+ ,
+ PREDICTION_MODE this_mode
+#endif // CONFIG_SEP_COMP_DRL
+) {
+#if CONFIG_SEP_COMP_DRL
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame_type);
+ if (has_second_drl_by_mode(this_mode, rf)) {
+ memcpy(mbmi_ext->ref_mv_stack[rf[0]], mbmi_ext_best->ref_mv_stack[0],
+ sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
+ memcpy(mbmi_ext->weight[rf[0]], mbmi_ext_best->weight[0],
+ sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
+ mbmi_ext->ref_mv_count[rf[0]] = mbmi_ext_best->ref_mv_count[0];
+ memcpy(mbmi_ext->ref_mv_stack[rf[1]], mbmi_ext_best->ref_mv_stack[1],
+ sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
+ memcpy(mbmi_ext->weight[rf[1]], mbmi_ext_best->weight[1],
+ sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
+ mbmi_ext->ref_mv_count[rf[1]] = mbmi_ext_best->ref_mv_count[1];
+ } else {
+ memcpy(mbmi_ext->ref_mv_stack[ref_frame_type],
+ mbmi_ext_best->ref_mv_stack[0],
+ sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
+ memcpy(mbmi_ext->weight[ref_frame_type], mbmi_ext_best->weight[0],
+ sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
+ mbmi_ext->ref_mv_count[ref_frame_type] = mbmi_ext_best->ref_mv_count[0];
+ }
+#else
memcpy(mbmi_ext->ref_mv_stack[ref_frame_type], mbmi_ext_best->ref_mv_stack,
sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
memcpy(mbmi_ext->weight[ref_frame_type], mbmi_ext_best->weight,
sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
- mbmi_ext->mode_context[ref_frame_type] = mbmi_ext_best->mode_context;
mbmi_ext->ref_mv_count[ref_frame_type] = mbmi_ext_best->ref_mv_count;
+#endif // CONFIG_SEP_COMP_DRL
+ mbmi_ext->mode_context[ref_frame_type] = mbmi_ext_best->mode_context;
memcpy(mbmi_ext->global_mvs, mbmi_ext_best->global_mvs,
sizeof(mbmi_ext->global_mvs));
@@ -240,12 +269,18 @@
assert(mi->sb_type[xd->tree_type == CHROMA_PART] == bsize);
*mi_addr = *mi;
+ mi_addr->chroma_ref_info = ctx->chroma_ref_info;
#if CONFIG_C071_SUBBLK_WARPMV
if (is_warp_mode(mi->motion_mode)) update_submi(xd, cm, ctx->submic, bsize);
#endif // CONFIG_C071_SUBBLK_WARPMV
if (xd->tree_type != CHROMA_PART)
copy_mbmi_ext_frame_to_mbmi_ext(x->mbmi_ext, &ctx->mbmi_ext_best,
- av1_ref_frame_type(ctx->mic.ref_frame));
+ av1_ref_frame_type(ctx->mic.ref_frame)
+#if CONFIG_SEP_COMP_DRL
+ ,
+ ctx->mic.mode
+#endif // CONFIG_SEP_COMP_DRL
+ );
memcpy(txfm_info->blk_skip, ctx->blk_skip,
sizeof(txfm_info->blk_skip[0]) * ctx->num_4x4_blk);
@@ -344,6 +379,9 @@
p[i].qcoeff = ctx->qcoeff[i];
p[i].dqcoeff = ctx->dqcoeff[i];
p[i].eobs = ctx->eobs[i];
+#if CONFIG_ATC_DCTX_ALIGNED
+ p[i].bobs = ctx->bobs[i];
+#endif // CONFIG_ATC_DCTX_ALIGNED
p[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i];
}
for (i = 0; i < 2; ++i) pd[i].color_index_map = ctx->color_index_map[i];
@@ -367,6 +405,12 @@
xd->mi[x_idx + y * mis]->cfl_alpha_signs = mi_addr->cfl_alpha_signs;
xd->mi[x_idx + y * mis]->cfl_alpha_idx = mi_addr->cfl_alpha_idx;
xd->mi[x_idx + y * mis]->partition = mi_addr->partition;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ xd->mi[x_idx + y * mis]->chroma_mi_row_start =
+ mi_addr->chroma_mi_row_start;
+ xd->mi[x_idx + y * mis]->chroma_mi_col_start =
+ mi_addr->chroma_mi_col_start;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
xd->mi[x_idx + y * mis]
->palette_mode_info.palette_size[PLANE_TYPE_UV] =
mi_addr->palette_mode_info.palette_size[PLANE_TYPE_UV];
@@ -386,12 +430,6 @@
if (dry_run) return;
if (mi_addr->ref_frame[0] != INTRA_FRAME) {
- if (is_inter_block(mi_addr, xd->tree_type)) {
- // TODO(sarahparker): global motion stats need to be handled per-tile
- // to be compatible with tile-based threading.
- update_global_motion_used(mi_addr->mode, bsize, mi_addr, rdc);
- }
-
if (cm->features.interp_filter == SWITCHABLE &&
!is_warp_mode(mi_addr->motion_mode) &&
!is_nontrans_global_motion(xd, xd->mi[0])) {
@@ -561,10 +599,18 @@
intraonly);
#endif // CONFIG_AIMC
if (cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode)) {
+#if CONFIG_EXT_DIR
+ int mrl_ctx = get_mrl_index_ctx(xd->neighbors[0], xd->neighbors[1]);
+ update_cdf(fc->mrl_index_cdf[mrl_ctx], mbmi->mrl_index, MRL_LINE_NUMBER);
+#if CONFIG_ENTROPY_STATS
+ ++counts->mrl_index[mrl_ctx][mbmi->mrl_index];
+#endif // CONFIG_ENTROPY_STATS
+#else
+ update_cdf(fc->mrl_index_cdf, mbmi->mrl_index, MRL_LINE_NUMBER);
#if CONFIG_ENTROPY_STATS
++counts->mrl_index[mbmi->mrl_index];
-#endif
- update_cdf(fc->mrl_index_cdf, mbmi->mrl_index, MRL_LINE_NUMBER);
+#endif // CONFIG_ENTROPY_STATS
+#endif // CONFIG_EXT_DIR
}
if (av1_filter_intra_allowed(cm, mbmi)) {
const int use_filter_intra_mode =
@@ -1193,21 +1239,31 @@
AVERAGE_CDF(ctx_left->v_dc_sign_cdf, ctx_tr->v_dc_sign_cdf, 2);
AVERAGE_CDF(ctx_left->v_ac_sign_cdf, ctx_tr->v_ac_sign_cdf, 2);
#endif // CONFIG_CONTEXT_DERIVATION
- AVERAGE_CDF(ctx_left->eob_flag_cdf16, ctx_tr->eob_flag_cdf16, 5);
- AVERAGE_CDF(ctx_left->eob_flag_cdf32, ctx_tr->eob_flag_cdf32, 6);
- AVERAGE_CDF(ctx_left->eob_flag_cdf64, ctx_tr->eob_flag_cdf64, 7);
- AVERAGE_CDF(ctx_left->eob_flag_cdf128, ctx_tr->eob_flag_cdf128, 8);
- AVERAGE_CDF(ctx_left->eob_flag_cdf256, ctx_tr->eob_flag_cdf256, 9);
- AVERAGE_CDF(ctx_left->eob_flag_cdf512, ctx_tr->eob_flag_cdf512, 10);
- AVERAGE_CDF(ctx_left->eob_flag_cdf1024, ctx_tr->eob_flag_cdf1024, 11);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf16, ctx_tr->eob_flag_cdf16,
+ EOB_MAX_SYMS - 6);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf32, ctx_tr->eob_flag_cdf32,
+ EOB_MAX_SYMS - 5);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf64, ctx_tr->eob_flag_cdf64,
+ EOB_MAX_SYMS - 4);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf128, ctx_tr->eob_flag_cdf128,
+ EOB_MAX_SYMS - 3);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf256, ctx_tr->eob_flag_cdf256,
+ EOB_MAX_SYMS - 2);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf512, ctx_tr->eob_flag_cdf512,
+ EOB_MAX_SYMS - 1);
+ AVERAGE_CDF(ctx_left->eob_flag_cdf1024, ctx_tr->eob_flag_cdf1024,
+ EOB_MAX_SYMS);
AVERAGE_CDF(ctx_left->coeff_base_eob_cdf, ctx_tr->coeff_base_eob_cdf, 3);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC_DCTX_ALIGNED
+ AVERAGE_CDF(ctx_left->coeff_base_bob_cdf, ctx_tr->coeff_base_bob_cdf, 3);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+#if CONFIG_ATC
AVERAGE_CDF(ctx_left->coeff_base_lf_cdf, ctx_tr->coeff_base_lf_cdf,
LF_BASE_SYMBOLS);
AVERAGE_CDF(ctx_left->coeff_base_lf_eob_cdf, ctx_tr->coeff_base_lf_eob_cdf,
LF_BASE_SYMBOLS - 1);
AVERAGE_CDF(ctx_left->coeff_br_lf_cdf, ctx_tr->coeff_br_lf_cdf, BR_CDF_SIZE);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
AVERAGE_CDF(ctx_left->coeff_base_cdf, ctx_tr->coeff_base_cdf, 4);
AVERAGE_CDF(ctx_left->idtx_sign_cdf, ctx_tr->idtx_sign_cdf, 2);
AVERAGE_CDF(ctx_left->coeff_base_cdf_idtx, ctx_tr->coeff_base_cdf_idtx, 4);
@@ -1221,12 +1277,17 @@
AVERAGE_CDF(ctx_left->inter_warp_mode_cdf, ctx_tr->inter_warp_mode_cdf, 2);
#endif // CONFIG_WARPMV
+#if CONFIG_REFINEMV
+ AVERAGE_CDF(ctx_left->refinemv_flag_cdf, ctx_tr->refinemv_flag_cdf,
+ REFINEMV_NUM_MODES);
+#endif // CONFIG_REFINEMV
+
AVERAGE_CDF(ctx_left->drl_cdf[0], ctx_tr->drl_cdf[0], 2);
AVERAGE_CDF(ctx_left->drl_cdf[1], ctx_tr->drl_cdf[1], 2);
AVERAGE_CDF(ctx_left->drl_cdf[2], ctx_tr->drl_cdf[2], 2);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
AVERAGE_CDF(ctx_left->skip_drl_cdf, ctx_tr->skip_drl_cdf, 2);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_OPTFLOW_REFINEMENT
AVERAGE_CDF(ctx_left->inter_compound_mode_cdf,
ctx_tr->inter_compound_mode_cdf, INTER_COMPOUND_REF_TYPES);
@@ -1234,6 +1295,9 @@
AVERAGE_CDF(ctx_left->inter_compound_mode_cdf,
ctx_tr->inter_compound_mode_cdf, INTER_COMPOUND_MODES);
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_CWP
+ AVERAGE_CDF(ctx_left->cwp_idx_cdf, ctx_tr->cwp_idx_cdf, 2);
+#endif // CONFIG_CWP
#if CONFIG_IMPROVED_JMVD
AVERAGE_CDF(ctx_left->jmvd_scale_mode_cdf, ctx_tr->jmvd_scale_mode_cdf,
JOINT_NEWMV_SCALE_FACTOR_CNT);
@@ -1273,6 +1337,10 @@
AVERAGE_CDF(ctx_left->warp_ref_idx_cdf[0], ctx_tr->warp_ref_idx_cdf[0], 2);
AVERAGE_CDF(ctx_left->warp_ref_idx_cdf[1], ctx_tr->warp_ref_idx_cdf[1], 2);
AVERAGE_CDF(ctx_left->warp_ref_idx_cdf[2], ctx_tr->warp_ref_idx_cdf[2], 2);
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ AVERAGE_CDF(ctx_left->warpmv_with_mvd_flag_cdf,
+ ctx_tr->warpmv_with_mvd_flag_cdf, 2);
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
AVERAGE_CDF(ctx_left->warp_extend_cdf, ctx_tr->warp_extend_cdf, 2);
#else
@@ -1316,19 +1384,19 @@
AVERAGE_CDF(ctx_left->comp_group_idx_cdf, ctx_tr->comp_group_idx_cdf, 2);
AVERAGE_CDF(ctx_left->skip_mode_cdfs, ctx_tr->skip_mode_cdfs, 2);
AVERAGE_CDF(ctx_left->skip_txfm_cdfs, ctx_tr->skip_txfm_cdfs, 2);
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
AVERAGE_CDF(ctx_left->intra_inter_cdf[0], ctx_tr->intra_inter_cdf[0], 2);
AVERAGE_CDF(ctx_left->intra_inter_cdf[1], ctx_tr->intra_inter_cdf[1], 2);
#else
AVERAGE_CDF(ctx_left->intra_inter_cdf, ctx_tr->intra_inter_cdf, 2);
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
avg_nmv(&ctx_left->nmvc, &ctx_tr->nmvc, wt_left, wt_tr);
avg_nmv(&ctx_left->ndvc, &ctx_tr->ndvc, wt_left, wt_tr);
AVERAGE_CDF(ctx_left->intrabc_cdf, ctx_tr->intrabc_cdf, 2);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
AVERAGE_CDF(ctx_left->intrabc_mode_cdf, ctx_tr->intrabc_mode_cdf, 2);
AVERAGE_CDF(ctx_left->intrabc_drl_idx_cdf, ctx_tr->intrabc_drl_idx_cdf, 2);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
AVERAGE_CDF(ctx_left->seg.tree_cdf, ctx_tr->seg.tree_cdf, MAX_SEGMENTS);
AVERAGE_CDF(ctx_left->seg.pred_cdf, ctx_tr->seg.pred_cdf, 2);
AVERAGE_CDF(ctx_left->seg.spatial_pred_seg_cdf,
@@ -1383,6 +1451,7 @@
AVG_CDF_STRIDE(ctx_left->uv_mode_cdf[0], ctx_tr->uv_mode_cdf[0],
UV_INTRA_MODES - 1, CDF_SIZE(UV_INTRA_MODES));
AVERAGE_CDF(ctx_left->uv_mode_cdf[1], ctx_tr->uv_mode_cdf[1], UV_INTRA_MODES);
+
#if CONFIG_EXT_RECUR_PARTITIONS
for (int plane_index = 0; plane_index < PARTITION_STRUCTURE_NUM;
plane_index++) {
@@ -1411,6 +1480,15 @@
for (RECT_PART_TYPE rect = 0; rect < NUM_RECT_PARTS; rect++) {
AVERAGE_CDF(ctx_left->do_ext_partition_cdf[plane_index][rect][i],
ctx_tr->do_ext_partition_cdf[plane_index][rect][i], 2);
+#if CONFIG_UNEVEN_4WAY
+ AVERAGE_CDF(
+ ctx_left->do_uneven_4way_partition_cdf[plane_index][rect][i],
+ ctx_tr->do_uneven_4way_partition_cdf[plane_index][rect][i], 2);
+ AVERAGE_CDF(
+ ctx_left->uneven_4way_partition_type_cdf[plane_index][rect][i],
+ ctx_tr->uneven_4way_partition_type_cdf[plane_index][rect][i],
+ NUM_UNEVEN_4WAY_PARTS);
+#endif // CONFIG_UNEVEN_4WAY
}
}
}
@@ -1466,10 +1544,10 @@
}
AVG_CDF_STRIDE(ctx_left->intra_ext_tx_cdf[1], ctx_tr->intra_ext_tx_cdf[1],
INTRA_TX_SET1, CDF_SIZE(TX_TYPES));
-#if !(CONFIG_ATC_NEWTXSETS && !CONFIG_ATC_REDUCED_TXSET)
+#if !(CONFIG_ATC && !CONFIG_ATC_REDUCED_TXSET)
AVG_CDF_STRIDE(ctx_left->intra_ext_tx_cdf[2], ctx_tr->intra_ext_tx_cdf[2],
INTRA_TX_SET2, CDF_SIZE(TX_TYPES));
-#endif // !(CONFIG_ATC_NEWTXSETS && !CONFIG_ATC_REDUCED_TXSET)
+#endif // !(CONFIG_ATC && !CONFIG_ATC_REDUCED_TXSET)
AVG_CDF_STRIDE(ctx_left->inter_ext_tx_cdf[1], ctx_tr->inter_ext_tx_cdf[1], 16,
CDF_SIZE(TX_TYPES));
AVG_CDF_STRIDE(ctx_left->inter_ext_tx_cdf[2], ctx_tr->inter_ext_tx_cdf[2], 12,
@@ -1590,9 +1668,9 @@
const int alloc_mi_idx = get_alloc_mi_idx(&cm->mi_params, mi_row, mi_col);
sb_fp_stats->current_qindex =
cm->mi_params.mi_alloc[alloc_mi_idx].current_qindex;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
sb_fp_stats->ref_mv_bank = td->mb.e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
sb_fp_stats->warp_param_bank = td->mb.e_mbd.warp_param_bank;
#endif // WARP_CU_BANK
@@ -1626,9 +1704,9 @@
const int alloc_mi_idx = get_alloc_mi_idx(&cm->mi_params, mi_row, mi_col);
cm->mi_params.mi_alloc[alloc_mi_idx].current_qindex =
sb_fp_stats->current_qindex;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
x->e_mbd.ref_mv_bank = sb_fp_stats->ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
x->e_mbd.warp_param_bank = sb_fp_stats->warp_param_bank;
#endif // WARP_CU_BANK
@@ -1693,7 +1771,7 @@
#else
cm->features.allow_high_precision_mv, &x->mv_costs);
#endif
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
if (cm->features.allow_intrabc) {
#if CONFIG_FLEX_MVRES
fill_dv_costs(&x->dv_costs, xd->tile_ctx, &x->mv_costs);
@@ -1701,7 +1779,7 @@
av1_fill_dv_costs(xd->tile_ctx, &x->dv_costs);
#endif
}
-#endif // CONFIG_BVCOST_UPDATE
+#endif // CONFIG_IBC_BV_IMPROVEMENT
break;
default: assert(0);
}
diff --git a/av1/encoder/encodeframe_utils.h b/av1/encoder/encodeframe_utils.h
index 4da6144..3da084f 100644
--- a/av1/encoder/encodeframe_utils.h
+++ b/av1/encoder/encodeframe_utils.h
@@ -40,6 +40,19 @@
TXFM_CONTEXT *p_tl;
TXFM_CONTEXT ta[MAX_MIB_SIZE];
TXFM_CONTEXT tl[MAX_MIB_SIZE];
+#if CONFIG_MVP_IMPROVEMENT
+ //! The current level bank, used to restore the level bank in MACROBLOCKD.
+ REF_MV_BANK curr_level_bank;
+ //! The best level bank from the rdopt process.
+ REF_MV_BANK best_level_bank;
+#endif // CONFIG_MVP_IMPROVEMENT
+#if WARP_CU_BANK
+ //! The current warp, level bank, used to restore the warp level bank in
+ //! MACROBLOCKD.
+ WARP_PARAM_BANK curr_level_warp_bank;
+ //! The best warp level bank from the rdopt process.
+ WARP_PARAM_BANK best_level_warp_bank;
+#endif // WARP_CU_BANK
} RD_SEARCH_MACROBLOCK_CONTEXT;
// This struct is used to store the statistics used by sb-level multi-pass
@@ -54,9 +67,9 @@
InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
int thresh_freq_fact[BLOCK_SIZES_ALL][MB_MODE_COUNT];
int current_qindex;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
REF_MV_BANK ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
WARP_PARAM_BANK warp_param_bank;
#endif // WARP_CU_BANK
@@ -99,10 +112,16 @@
int bsize_at_least_8x8;
#endif // !CONFIG_EXT_RECUR_PARTITIONS
- // Indicates edge blocks in frame.
+ // Indicates if at least half of the rows / cols of this block are within the
+ // frame.
int has_rows;
int has_cols;
+ // Indicates if at least 7/8th of the rows / cols of this block are within the
+ // frame. Used by HORZ/VERT_4A/4B partitions.
+ int has_7_8th_rows;
+ int has_7_8th_cols;
+
// Block size of current partition.
BLOCK_SIZE bsize;
@@ -130,14 +149,13 @@
// RD cost summed across all blocks of partition type.
RD_STATS sum_rdc;
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Array holding partition type cost.
int tmp_partition_cost[PARTITION_TYPES];
-#if CONFIG_EXT_RECUR_PARTITIONS
- int partition_cost_table[ALL_PARTITION_TYPES];
-#endif
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Pointer to partition cost buffer
- int *partition_cost;
+ const int *partition_cost;
// RD costs for different partition types.
int64_t none_rd;
@@ -164,7 +182,24 @@
#if !CONFIG_EXT_RECUR_PARTITIONS
int do_square_split;
#endif // !CONFIG_EXT_RECUR_PARTITIONS
- int prune_rect_part[NUM_RECT_PARTS];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ bool prune_partition_none;
+ bool ext_partition_allowed;
+ bool partition_3_allowed[NUM_RECT_PARTS];
+ bool prune_partition_3[NUM_RECT_PARTS];
+#if CONFIG_UNEVEN_4WAY
+ bool partition_4a_allowed[NUM_RECT_PARTS];
+ bool partition_4b_allowed[NUM_RECT_PARTS];
+ bool prune_partition_4a[NUM_RECT_PARTS];
+ bool prune_partition_4b[NUM_RECT_PARTS];
+#endif // CONFIG_UNEVEN_4WAY
+ PARTITION_TYPE forced_partition;
+ // Pointer to an array that traces out the current best partition boundary.
+ // Used by prune_part_h_with_partition_boundary and
+ // prune_part_4_with_partition_boundary.
+ bool *partition_boundaries;
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+ bool prune_rect_part[NUM_RECT_PARTS];
int is_block_splittable;
// Chroma subsampling in x and y directions.
@@ -178,19 +213,6 @@
bool found_best_partition;
} PartitionSearchState;
-static AOM_INLINE void update_global_motion_used(PREDICTION_MODE mode,
- BLOCK_SIZE bsize,
- const MB_MODE_INFO *mbmi,
- RD_COUNTS *rdc) {
- if (mode == GLOBALMV || mode == GLOBAL_GLOBALMV) {
- const int num_4x4s = mi_size_wide[bsize] * mi_size_high[bsize];
- int ref;
- for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
- rdc->global_motion_used[mbmi->ref_frame[ref]] += num_4x4s;
- }
- }
-}
-
#if CONFIG_WEDGE_MOD_EXT
static AOM_INLINE void update_wedge_mode_cdf(FRAME_CONTEXT *fc,
const BLOCK_SIZE bsize,
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index a78753b..33b8cc2 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -466,6 +466,32 @@
}
#endif // CONFIG_CROSS_CHROMA_TX
+#if CONFIG_ATC_DCTX_ALIGNED
+// Finds and sets the first position (BOB) index.
+// To make sure the BOB value is statistically similar to EOB
+// for arithmetic coding efficiency performs a simple rotation.
+void set_bob(MACROBLOCK *x, int plane, int block, TX_SIZE tx_size,
+ TX_TYPE tx_type) {
+ const struct macroblock_plane *const p = &x->plane[plane];
+ const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type);
+ const int block_offset = BLOCK_OFFSET(block);
+ tran_low_t *const qcoeff = p->qcoeff + block_offset;
+ uint16_t *const eob = &p->eobs[block];
+ uint16_t *const bob_ptr = &p->bobs[block];
+ int bob = 0;
+ for (int c = 0; c < *eob; ++c) {
+ const int pos = scan_order->scan[c];
+ const tran_low_t v = qcoeff[pos];
+ const tran_low_t level = abs(v);
+ if (level != 0) {
+ break;
+ }
+ bob++;
+ }
+ *bob_ptr = av1_get_max_eob(tx_size) - bob;
+}
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
void av1_quant(MACROBLOCK *x, int plane, int block, TxfmParam *txfm_param,
QUANT_PARAM *qparam) {
const struct macroblock_plane *const p = &x->plane[plane];
@@ -487,6 +513,10 @@
}
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ set_bob(x, plane, block, txfm_param->tx_size, txfm_param->tx_type);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
#if CONFIG_CONTEXT_DERIVATION
MACROBLOCKD *const xd = &x->e_mbd;
const int16_t *const scan = scan_order->scan;
@@ -687,10 +717,17 @@
}
#endif
#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int skip_cctx = is_inter ? 0 : (p->eobs[block] == 1);
+#endif // CONFIG_ATC_DCTX_ALIGNED
// Since eob can be updated here, make sure cctx_type is always CCTX_NONE
// when eob of U is 0.
if (is_cctx_allowed(cm, xd) && plane == AOM_PLANE_U &&
+#if CONFIG_ATC_DCTX_ALIGNED
+ (p->eobs[block] == 0 || skip_cctx)) {
+#else
p->eobs[block] == 0) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
// In dry run, cctx type will not be referenced by neighboring blocks, so
// there is no need to fill in the whole chroma region. In addition,
// ctx->cctx_type_map size in dry run may not be aligned with actual
@@ -709,6 +746,9 @@
&p->eobs[block]);
#endif // CONFIG_CROSS_CHROMA_TX && CCTX_C2_DROPPED
p->eobs[block] = 0;
+#if CONFIG_ATC_DCTX_ALIGNED
+ p->bobs[block] = 0;
+#endif // CONFIG_ATC_DCTX_ALIGNED
p->txb_entropy_ctx[block] = 0;
}
@@ -733,7 +773,13 @@
.buf[(blk_row * pd_c1->dst.stride + blk_col) << MI_SIZE_LOG2];
int eob_c1 = p_c1->eobs[block];
int eob_c2 = x->plane[AOM_PLANE_V].eobs[block];
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int is_inter = is_inter_block(mbmi, xd->tree_type);
+ const int skip_cctx = is_inter ? 0 : (p->eobs[block] == 1);
+ recon_with_cctx = (eob_c1 || eob_c2) && !skip_cctx;
+#else
recon_with_cctx = eob_c1 || eob_c2;
+#endif // CONFIG_ATC_DCTX_ALIGNED
max_chroma_eob = AOMMAX(eob_c1, eob_c2);
if (recon_with_cctx) {
av1_inv_cross_chroma_tx_block(dqcoeff_c1, dqcoeff, tx_size, cctx_type);
@@ -751,8 +797,14 @@
av1_inverse_transform_block(
xd, dqcoeff, plane, tx_type, tx_size, dst, pd->dst.stride,
#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_ATC_DCTX_ALIGNED
+ (plane == 0 || !is_cctx_allowed(cm, xd) || !recon_with_cctx)
+ ? p->eobs[block]
+ : max_chroma_eob,
+#else
(plane == 0 || !is_cctx_allowed(cm, xd)) ? p->eobs[block]
: max_chroma_eob,
+#endif // CONFIG_ATC_DCTX_ALIGNED
#else
p->eobs[block],
#endif
@@ -816,11 +868,20 @@
&pd_c1->dst
.buf[(blk_row * pd_c1->dst.stride + blk_col) << MI_SIZE_LOG2];
mismatch_record_block_tx(dst_c1, pd_c1->dst.stride,
- cm->current_frame.order_hint, AOM_PLANE_U,
- pixel_c, pixel_r, blk_w, blk_h);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ AOM_PLANE_U, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_CROSS_CHROMA_TX
- mismatch_record_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
+ mismatch_record_block_tx(dst, pd->dst.stride,
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
plane, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
@@ -1136,6 +1197,9 @@
tran_low_t *dqcoeff = p->dqcoeff + BLOCK_OFFSET(block);
PLANE_TYPE plane_type = get_plane_type(plane);
uint16_t *eob = &p->eobs[block];
+#if CONFIG_ATC_DCTX_ALIGNED
+ uint16_t *bob_code = &p->bobs[block];
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int dst_stride = pd->dst.stride;
uint16_t *dst =
&pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2];
@@ -1155,9 +1219,14 @@
mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, blk_col,
blk_row, pd->subsampling_x, pd->subsampling_y);
}
- mismatch_record_block_pre(
- pd->dst.buf, pd->dst.stride, cm->current_frame.order_hint, plane,
- pixel_c, pixel_r, tx_size_wide[tx_size], tx_size_high[tx_size]);
+ mismatch_record_block_pre(pd->dst.buf, pd->dst.stride,
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ plane, pixel_c, pixel_r, tx_size_wide[tx_size],
+ tx_size_high[tx_size]);
}
#endif // CONFIG_MISMATCH_DEBUG
@@ -1175,6 +1244,9 @@
if (plane == 0 && is_blk_skip(x->txfm_search_info.blk_skip, plane,
blk_row * bw + blk_col)) {
*eob = 0;
+#if CONFIG_ATC_DCTX_ALIGNED
+ *bob_code = 0;
+#endif // CONFIG_ATC_DCTX_ALIGNED
p->txb_entropy_ctx[block] = 0;
#if DEBUG_EXTQUANT
if (args->dry_run == OUTPUT_ENABLED) {
@@ -1260,6 +1332,43 @@
av1_dropout_qcoeff(x, plane, block, tx_size, tx_type,
cm->quant_params.base_qindex);
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ // make sure recon is correct at the encoder
+ if (*eob == 1 && tx_type != 0 && plane == 0) {
+ xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col] = DCT_DCT;
+ tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size,
+ cm->features.reduced_tx_set_used);
+ av1_setup_xform(cm, x, plane, tx_size, tx_type,
+#if CONFIG_CROSS_CHROMA_TX
+ CCTX_NONE,
+#endif // CONFIG_CROSS_CHROMA_TX
+ &txfm_param);
+ av1_setup_quant(tx_size, use_trellis, quant_idx,
+ cpi->oxcf.q_cfg.quant_b_adapt, &quant_param);
+ av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type,
+ &quant_param);
+ av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize,
+ &txfm_param, &quant_param);
+ if (quant_param.use_optimize_b && do_trellis) {
+ TXB_CTX txb_ctx;
+ get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx,
+ mbmi->fsc_mode[xd->tree_type == CHROMA_PART]);
+ av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type,
+#if CONFIG_CROSS_CHROMA_TX
+ CCTX_NONE,
+#endif // CONFIG_CROSS_CHROMA_TX
+ &txb_ctx, &dummy_rate_cost);
+ }
+ if (do_dropout && !fsc_mode
+#if CONFIG_PAR_HIDING
+ && !enable_parity_hiding
+#endif // CONFIG_PAR_HIDING
+ ) {
+ av1_dropout_qcoeff(x, plane, block, tx_size, tx_type,
+ cm->quant_params.base_qindex);
+ }
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
#if CONFIG_PAR_HIDING
if (!quant_param.use_optimize_b && enable_parity_hiding) {
parity_hiding_trellis_off(cpi, x, plane, block, tx_size, tx_type);
@@ -1312,7 +1421,12 @@
mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, blk_col,
blk_row, pd->subsampling_x, pd->subsampling_y);
}
- mismatch_record_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
+ mismatch_record_block_tx(dst, pd->dst.stride,
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
plane, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
@@ -1323,11 +1437,7 @@
if (plane == AOM_PLANE_Y && xd->cfl.store_y && xd->tree_type == SHARED_PART) {
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_tx(xd, blk_row, blk_col, tx_size,
-#if DS_FRAME_LEVEL
- cm->features.ds_filter_type);
-#else
cm->seq_params.enable_cfl_ds_filter);
-#endif // DS_FRAME_LEVEL
#else
cfl_store_tx(xd, blk_row, blk_col, tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
@@ -1402,13 +1512,21 @@
xd->mi[0]->chroma_ref_info.mi_row_chroma_base, blk_col,
blk_row, pd_c1->subsampling_x, pd_c1->subsampling_y);
mismatch_record_block_pre(pd_c1->dst.buf, pd_c1->dst.stride,
- cm->current_frame.order_hint, AOM_PLANE_U,
- pixel_c, pixel_r, tx_size_wide[tx_size],
- tx_size_high[tx_size]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ AOM_PLANE_U, pixel_c, pixel_r,
+ tx_size_wide[tx_size], tx_size_high[tx_size]);
mismatch_record_block_pre(pd_c2->dst.buf, pd_c2->dst.stride,
- cm->current_frame.order_hint, AOM_PLANE_V,
- pixel_c, pixel_r, tx_size_wide[tx_size],
- tx_size_high[tx_size]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ AOM_PLANE_V, pixel_c, pixel_r,
+ tx_size_wide[tx_size], tx_size_high[tx_size]);
}
#endif // CONFIG_MISMATCH_DEBUG
@@ -1447,6 +1565,14 @@
(INTRA_BLOCK_OPT_TYPE == DROPOUT_OPT ||
INTRA_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT));
for (int plane = AOM_PLANE_U; plane <= AOM_PLANE_V; plane++) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ int skip_cctx = !is_inter_block(xd->mi[0], xd->tree_type) && *eob_c1 == 1;
+ if (plane == AOM_PLANE_V && skip_cctx) {
+ update_cctx_array(xd, blk_row, blk_col, 0, 0,
+ args->dry_run ? TX_4X4 : tx_size, CCTX_NONE);
+ cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
// Since eob can be updated here, make sure cctx_type is always CCTX_NONE
// when eob of U is 0.
if (plane == AOM_PLANE_V && *eob_c1 == 0) {
@@ -1486,6 +1612,33 @@
av1_dropout_qcoeff(x, plane, block, tx_size, tx_type,
cm->quant_params.base_qindex);
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ skip_cctx = !is_inter_block(xd->mi[0], xd->tree_type) && *eob_c1 == 1;
+ if (plane == AOM_PLANE_V && skip_cctx) {
+ update_cctx_array(xd, blk_row, blk_col, 0, 0,
+ args->dry_run ? TX_4X4 : tx_size, CCTX_NONE);
+ cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
+ av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type,
+ &quant_param);
+ av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize,
+ &txfm_param, &quant_param);
+ if (quant_param.use_optimize_b && do_trellis) {
+ const ENTROPY_CONTEXT *a =
+ &args->ta[blk_col + (plane - AOM_PLANE_U) * MAX_MIB_SIZE];
+ const ENTROPY_CONTEXT *l =
+ &args->tl[blk_row + (plane - AOM_PLANE_U) * MAX_MIB_SIZE];
+ TXB_CTX txb_ctx;
+ get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx,
+ xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART]);
+ av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, cctx_type,
+ &txb_ctx, &dummy_rate_cost);
+ }
+ if (do_dropout) {
+ av1_dropout_qcoeff(x, plane, block, tx_size, tx_type,
+ cm->quant_params.base_qindex);
+ }
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
if (*eob_c1 || *eob_c2) {
@@ -1522,11 +1675,19 @@
xd->mi[0]->chroma_ref_info.mi_row_chroma_base, blk_col,
blk_row, pd_c1->subsampling_x, pd_c1->subsampling_y);
mismatch_record_block_tx(dst_c1, pd_c1->dst.stride,
- cm->current_frame.order_hint, AOM_PLANE_U, pixel_c,
- pixel_r, blk_w, blk_h);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ AOM_PLANE_U, pixel_c, pixel_r, blk_w, blk_h);
mismatch_record_block_tx(dst_c2, pd_c2->dst.stride,
- cm->current_frame.order_hint, AOM_PLANE_V, pixel_c,
- pixel_r, blk_w, blk_h);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ AOM_PLANE_V, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h
index 3d0a27c..f6be3e4 100644
--- a/av1/encoder/encodemb.h
+++ b/av1/encoder/encodemb.h
@@ -105,6 +105,12 @@
CctxType cctx_type);
#endif // CONFIG_CROSS_CHROMA_TX
+#if CONFIG_ATC_DCTX_ALIGNED
+// This function sets the first position index in a TU.
+void set_bob(MACROBLOCK *x, int plane, int block, TX_SIZE tx_size,
+ TX_TYPE tx_type);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
void av1_quant(MACROBLOCK *x, int plane, int block, TxfmParam *txfm_param,
QUANT_PARAM *qparam);
diff --git a/av1/encoder/encodemv.c b/av1/encoder/encodemv.c
index 369054d..6e7a524 100644
--- a/av1/encoder/encodemv.c
+++ b/av1/encoder/encodemv.c
@@ -875,15 +875,31 @@
int_mv av1_get_ref_mv_from_stack(
int ref_idx, const MV_REFERENCE_FRAME *ref_frame, int ref_mv_idx,
- const MB_MODE_INFO_EXT *mbmi_ext) {
+ const MB_MODE_INFO_EXT *mbmi_ext
+#if CONFIG_SEP_COMP_DRL
+ ,
+ const MB_MODE_INFO *mbmi
+#endif // CONFIG_SEP_COMP_DRL
+ ) {
const int8_t ref_frame_type = av1_ref_frame_type(ref_frame);
+#if CONFIG_SEP_COMP_DRL
const CANDIDATE_MV *curr_ref_mv_stack =
- mbmi_ext->ref_mv_stack[ref_frame_type];
+ has_second_drl(mbmi) ? mbmi_ext->ref_mv_stack[ref_frame[ref_idx]]
+ : mbmi_ext->ref_mv_stack[ref_frame_type];
+#else
+ const CANDIDATE_MV *curr_ref_mv_stack =
+ mbmi_ext->ref_mv_stack[ref_frame_type];
+#endif // CONFIG_SEP_COMP_DRL
if (is_inter_ref_frame(ref_frame[1])) {
assert(ref_idx == 0 || ref_idx == 1);
- return ref_idx ? curr_ref_mv_stack[ref_mv_idx].comp_mv
- : curr_ref_mv_stack[ref_mv_idx].this_mv;
+#if CONFIG_SEP_COMP_DRL
+ return ref_idx && !has_second_drl(mbmi)
+ ? curr_ref_mv_stack[ref_mv_idx].comp_mv
+#else
+ return ref_idx ? curr_ref_mv_stack[ref_mv_idx].comp_mv
+#endif // CONFIG_SEP_COMP_DRL
+ : curr_ref_mv_stack[ref_mv_idx].this_mv;
}
assert(ref_idx == 0);
@@ -910,8 +926,14 @@
if (have_nearmv_newmv_in_inter_mode(mbmi->mode)) {
assert(has_second_ref(mbmi));
}
- return av1_get_ref_mv_from_stack(ref_idx, mbmi->ref_frame,
- mbmi->ref_mv_idx, x->mbmi_ext);
+#if CONFIG_SEP_COMP_DRL
+ const int ref_mv_idx = get_ref_mv_idx(mbmi, ref_idx);
+ return av1_get_ref_mv_from_stack(ref_idx, mbmi->ref_frame, ref_mv_idx,
+ x->mbmi_ext, mbmi);
+#else
+ return av1_get_ref_mv_from_stack(ref_idx, mbmi->ref_frame, mbmi->ref_mv_idx,
+ x->mbmi_ext);
+#endif // CONFIG_SEP_COMP_DRL
}
/**
@@ -927,6 +949,9 @@
*/
#if CONFIG_FLEX_MVRES
int_mv av1_find_best_ref_mv_from_stack(const MB_MODE_INFO_EXT *mbmi_ext,
+#if CONFIG_SEP_COMP_DRL
+ const MB_MODE_INFO *mbmi,
+#endif // CONFIG_SEP_COMP_DRL
MV_REFERENCE_FRAME ref_frame,
MvSubpelPrecision precision) {
#else
@@ -941,7 +966,11 @@
int range =
AOMMIN(mbmi_ext->ref_mv_count[ref_frame], MAX_REF_MV_STACK_SIZE);
for (int i = 0; i < range; i++) {
- mv = av1_get_ref_mv_from_stack(0, ref_frames, i, mbmi_ext);
+#if CONFIG_SEP_COMP_DRL
+ mv = av1_get_ref_mv_from_stack(0, ref_frames, i, mbmi_ext, mbmi);
+#else
+ mv = av1_get_ref_mv_from_stack(0, ref_frames, i, mbmi_ext);
+#endif // CONFIG_SEP_COMP_DRL
if (mv.as_int != 0 && mv.as_int != INVALID_MV) {
found_ref_mv = true;
break;
@@ -969,7 +998,16 @@
int_mv mv;
const int ref_idx = 0;
MV_REFERENCE_FRAME ref_frames[2] = { ref_frame, NONE_FRAME };
- mv = av1_get_ref_mv_from_stack(ref_idx, ref_frames, 0, mbmi_ext);
+#if CONFIG_SEP_COMP_DRL
+ // this function is not called in this software.
+ MB_MODE_INFO mbmi;
+ mbmi.skip_mode = 0;
+ mbmi.mode = NEWMV;
+ mbmi.ref_frame[0] = ref_frame;
+ mv = av1_get_ref_mv_from_stack(ref_idx, ref_frames, 0, mbmi_ext, &mbmi);
+#else
+ mv = av1_get_ref_mv_from_stack(ref_idx, ref_frames, 0, mbmi_ext);
+#endif // CONFIG_SEP_COMP_DRL
#if CONFIG_FLEX_MVRES
lower_mv_precision(&mv.as_mv, precision);
#else
diff --git a/av1/encoder/encodemv.h b/av1/encoder/encodemv.h
index 39cdf7d..119107d 100644
--- a/av1/encoder/encodemv.h
+++ b/av1/encoder/encodemv.h
@@ -57,12 +57,20 @@
int_mv av1_get_ref_mv_from_stack(int ref_idx,
const MV_REFERENCE_FRAME *ref_frame,
int ref_mv_idx,
- const MB_MODE_INFO_EXT *mbmi_ext);
+ const MB_MODE_INFO_EXT *mbmi_ext
+#if CONFIG_SEP_COMP_DRL
+ ,
+ const MB_MODE_INFO *mbmi
+#endif // CONFIG_SEP_COMP_DRL
+);
#if CONFIG_FLEX_MVRES
int_mv av1_find_first_ref_mv_from_stack(const MB_MODE_INFO_EXT *mbmi_ext,
MV_REFERENCE_FRAME ref_frame,
MvSubpelPrecision precision);
int_mv av1_find_best_ref_mv_from_stack(const MB_MODE_INFO_EXT *mbmi_ext,
+#if CONFIG_SEP_COMP_DRL
+ const MB_MODE_INFO *mbmi,
+#endif // CONFIG_SEP_COMP_DRL
MV_REFERENCE_FRAME ref_frame,
MvSubpelPrecision precision);
#else
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 543f671..378e9d6 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -204,6 +204,9 @@
av1_init_me_luts();
av1_rc_init_minq_luts();
av1_init_wedge_masks();
+#if CONFIG_CWP
+ init_cwp_masks();
+#endif // CONFIG_CWP
}
static void update_reference_segmentation_map(AV1_COMP *cpi) {
@@ -371,6 +374,10 @@
? DEFAULT_EXPLICIT_ORDER_HINT_BITS - 1
: -1;
seq->explicit_ref_frame_map = oxcf->ref_frm_cfg.explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // Set 0 for multi-layer coding
+ seq->enable_frame_output_order = oxcf->ref_frm_cfg.enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
seq->max_reference_frames = oxcf->ref_frm_cfg.max_reference_frames;
#if CONFIG_ALLOW_SAME_REF_COMPOUND
seq->num_same_ref_compound = SAME_REF_COMPOUND_PRUNE;
@@ -414,6 +421,12 @@
#if CONFIG_BAWP
seq->enable_bawp = tool_cfg->enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ seq->enable_cwp = tool_cfg->enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ seq->enable_imp_msk_bld = tool_cfg->enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
#if CONFIG_EXTENDED_WARP_PREDICTION
seq->seq_enabled_motion_modes =
oxcf->motion_mode_cfg.seq_enabled_motion_modes;
@@ -434,6 +447,9 @@
#if CONFIG_ORIP
seq->enable_orip = oxcf->intra_mode_cfg.enable_orip;
#endif
+#if CONFIG_IDIF
+ seq->enable_idif = oxcf->intra_mode_cfg.enable_idif;
+#endif // CONFIG_IDIF
seq->enable_ist = oxcf->txfm_cfg.enable_ist;
#if CONFIG_CROSS_CHROMA_TX
seq->enable_cctx = oxcf->txfm_cfg.enable_cctx;
@@ -451,6 +467,9 @@
#if CONFIG_JOINT_MVD
seq->enable_joint_mvd = tool_cfg->enable_joint_mvd;
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ seq->enable_refinemv = tool_cfg->enable_refinemv;
+#endif // CONFIG_REFINEMV
set_bitstream_level_tier(seq, cm, frm_dim_cfg->width, frm_dim_cfg->height,
oxcf->input_cfg.init_framerate);
@@ -495,6 +514,13 @@
#if CONFIG_PAR_HIDING
seq->enable_parity_hiding = tool_cfg->enable_parity_hiding;
#endif // CONFIG_PAR_HIDING
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // TODO(rachelbarker): Check if cpi->sf.gm_sf.gm_search_type is set by this
+ // point, and set to 0 if cpi->sf.gm_sf.gm_search_type == GM_DISABLE_SEARCH
+ // if possible
+ seq->enable_global_motion =
+ tool_cfg->enable_global_motion && !seq->reduced_still_picture_hdr;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
static void init_config(struct AV1_COMP *cpi, AV1EncoderConfig *oxcf) {
@@ -575,7 +601,7 @@
// set sb size before allocations
const BLOCK_SIZE sb_size = av1_select_sb_size(cpi);
set_sb_size(cm, sb_size);
- cpi->td.sb_size = sb_size;
+ cpi->td.sb_size = cm->sb_size;
alloc_compressor_data(cpi);
av1_update_film_grain_parameters(cpi, oxcf);
@@ -1469,7 +1495,14 @@
PSNR_STATS psnr;
const uint32_t in_bit_depth = cpi->oxcf.input_cfg.input_bit_depth;
const uint32_t bit_depth = cpi->td.mb.e_mbd.bd;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // To match the PSNR results between encoder log and VMAF results,
+ // the same reference sources (unfiltered source) need to be used.
+ aom_calc_highbd_psnr(cpi->unfiltered_source, &cpi->common.cur_frame->buf,
+ &psnr,
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
aom_calc_highbd_psnr(cpi->source, &cpi->common.cur_frame->buf, &psnr,
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
bit_depth, in_bit_depth);
for (i = 0; i < 4; ++i) {
@@ -1622,9 +1655,13 @@
dst += CFL_BUF_LINE;
}
}
-
+#if CONFIG_CFL_IMPROVEMENTS
+static int64_t compute_sad(const uint16_t *src, uint16_t *src2, int width,
+ int height, int round_offset, int src2_stride) {
+#else
static int compute_sad(const uint16_t *src, uint16_t *src2, int width,
int height, int round_offset, int src2_stride) {
+#endif // CONFIG_CFL_IMPROVEMENTS
int sad = round_offset;
for (int j = 0; j < height; ++j) {
for (int i = 0; i < width; ++i) {
@@ -1633,7 +1670,11 @@
src += CFL_BUF_LINE;
src2 += src2_stride;
}
+#if CONFIG_CFL_IMPROVEMENTS
+ return sad;
+#else
return (sad / (height * width));
+#endif // CONFIG_CFL_IMPROVEMENTS
}
static void cfl_predict_hbd_pre_analysis(const int16_t *ac_buf_q3,
@@ -1688,11 +1729,7 @@
}
}
-#if DS_FRAME_LEVEL
-void av1_set_downsample_filter_options(AV1_COMP *cpi, FeatureFlags *features) {
-#else
void av1_set_downsample_filter_options(AV1_COMP *cpi) {
-#endif // DS_FRAME_LEVE
AV1_COMMON *cm = &cpi->common;
const uint16_t *src = cpi->unfiltered_source->y_buffer;
uint16_t *src_chroma_u = cpi->unfiltered_source->u_buffer;
@@ -1707,14 +1744,34 @@
const int subsampling_x = cpi->unfiltered_source->subsampling_x;
const int subsampling_y = cpi->unfiltered_source->subsampling_y;
+#if CONFIG_ADPTIVE_DS_422
+ if (subsampling_x == 0 && subsampling_y == 0) {
+ cm->seq_params.enable_cfl_ds_filter =
+ 0; // For 4:4:4 chroma format, downsampling filter is not used. There
+ // is a redundant that the filter index is still signalled for
+ // 4:4:4. Should we remove the index signalling for 4:4:4 with this
+ // MR?
+ return;
+ }
+#endif // CONFIG_ADPTIVE_DS_422
+
+#if CONFIG_CFL_IMPROVEMENTS
+ const int blk_w = 16;
+ const int blk_h = 16;
+#else
const int blk_w = 32;
const int blk_h = 32;
+#endif // CONFIG_CFL_IMPROVEMENTS
uint16_t recon_buf_q3[CFL_BUF_SQUARE];
uint16_t dc_buf_q3[CFL_BUF_SQUARE];
// Q3 AC contributions (reconstructed luma pixels - tx block avg)
int16_t ac_buf_q3[CFL_BUF_SQUARE];
+#if CONFIG_CFL_IMPROVEMENTS
+ int64_t cost[3] = { 0, 0, 0 };
+#else
int cost[3] = { 0, 0, 0 };
+#endif // CONFIG_CFL_IMPROVEMENTS
for (int filter_type = 0; filter_type < 3; ++filter_type) {
for (int comp = 0; comp < 2; comp++) {
for (int r = 2; r + blk_h <= height - 2; r += blk_h) {
@@ -1730,7 +1787,14 @@
}
int alpha = 0;
+#if CONFIG_ADPTIVE_DS_422
+ if (subsampling_x == 1 && subsampling_y == 0) {
+ cfl_adaptive_luma_subsampling_422_hbd_c(
+ this_src, stride, recon_buf_q3, blk_w, blk_h, filter_type);
+ } else if (filter_type == 1) {
+#else
if (filter_type == 1) {
+#endif // CONFIG_ADPTIVE_DS_422
cfl_luma_subsampling_420_hbd_121_c(this_src, stride, recon_buf_q3,
blk_w, blk_h);
} else if (filter_type == 2) {
@@ -1740,6 +1804,30 @@
cfl_luma_subsampling_420_hbd_c(this_src, stride, recon_buf_q3,
blk_w, blk_h);
}
+#if CONFIG_ADPTIVE_DS_422
+ cfl_derive_block_implicit_scaling_factor(
+ recon_buf_q3, this_src_chroma, blk_w >> subsampling_x,
+ blk_h >> subsampling_y, CFL_BUF_LINE, chroma_stride, &alpha);
+ subtract_average_c(
+ recon_buf_q3, ac_buf_q3, blk_w >> subsampling_x,
+ blk_h >> subsampling_y, 4,
+ (blk_w >> subsampling_x) * (blk_h >> subsampling_y));
+ cfl_predict_hbd_dc(this_src_chroma - chroma_stride, dc_buf_q3,
+ chroma_stride, blk_w >> subsampling_x,
+ blk_h >> subsampling_y);
+ cfl_predict_hbd_pre_analysis(ac_buf_q3, dc_buf_q3, CFL_BUF_LINE,
+ alpha, bd, blk_w >> subsampling_x,
+ blk_h >> subsampling_y);
+#if CONFIG_CFL_IMPROVEMENTS
+ int64_t filter_cost =
+ compute_sad(dc_buf_q3, this_src_chroma, blk_w >> 1, blk_h >> 1, 2,
+ chroma_stride);
+#else
+ int filter_cost =
+ compute_sad(dc_buf_q3, this_src_chroma, blk_w >> subsampling_x,
+ blk_h >> subsampling_y, 2, chroma_stride);
+#endif // CONFIG_CFL_IMPROVEMENTS
+#else
cfl_derive_block_implicit_scaling_factor(
recon_buf_q3, this_src_chroma, blk_w >> 1, blk_h >> 1,
CFL_BUF_LINE, chroma_stride, &alpha);
@@ -1749,23 +1837,29 @@
chroma_stride, blk_w >> 1, blk_h >> 1);
cfl_predict_hbd_pre_analysis(ac_buf_q3, dc_buf_q3, CFL_BUF_LINE,
alpha, bd, blk_w >> 1, blk_h >> 1);
+#if CONFIG_CFL_IMPROVEMENTS
+ int64_t filter_cost =
+ compute_sad(dc_buf_q3, this_src_chroma, blk_w >> 1, blk_h >> 1, 2,
+ chroma_stride);
+#else
int filter_cost = compute_sad(dc_buf_q3, this_src_chroma, blk_w >> 1,
blk_h >> 1, 2, chroma_stride);
+#endif // CONFIG_CFL_IMPROVEMENTS
+#endif // CONFIG_ADPTIVE_DS_422
cost[filter_type] = cost[filter_type] + filter_cost;
}
}
}
}
-
+#if CONFIG_CFL_IMPROVEMENTS
+ int64_t min_cost = INT64_MAX;
+#else
int min_cost = INT_MAX;
+#endif // CONFIG_CFL_IMPROVEMENTS
for (int i = 0; i < 3; ++i) {
if (cost[i] < min_cost) {
min_cost = cost[i];
-#if DS_FRAME_LEVEL
- features->ds_filter_type = i;
-#else
cm->seq_params.enable_cfl_ds_filter = i;
-#endif // DS_FRAME_LEVEL
}
}
}
@@ -1911,6 +2005,29 @@
}
}
+#define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0
+#if !CONFIG_FLEXIBLE_RU_SIZE
+static void set_restoration_unit_size(int width, int height, int sx, int sy,
+ RestorationInfo *rst) {
+ (void)width;
+ (void)height;
+ (void)sx;
+ (void)sy;
+#if COUPLED_CHROMA_FROM_LUMA_RESTORATION
+ int s = AOMMIN(sx, sy);
+#else
+ int s = 0;
+#endif // !COUPLED_CHROMA_FROM_LUMA_RESTORATION
+
+ if (width * height > 352 * 288)
+ rst[0].restoration_unit_size = RESTORATION_UNITSIZE_MAX;
+ else
+ rst[0].restoration_unit_size = (RESTORATION_UNITSIZE_MAX >> 1);
+ rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s;
+ rst[2].restoration_unit_size = rst[1].restoration_unit_size;
+}
+#endif // !CONFIG_FLEXIBLE_RU_SIZE
+
static void init_ref_frame_bufs(AV1_COMP *cpi) {
AV1_COMMON *const cm = &cpi->common;
int i;
@@ -2049,11 +2166,15 @@
const int frame_width = cm->superres_upscaled_width;
const int frame_height = cm->superres_upscaled_height;
- av1_set_restoration_unit_size(
- frame_width, frame_height, seq_params->subsampling_x,
- seq_params->subsampling_y, cm->rst_info, cm->sb_size);
+ set_restoration_unit_size(frame_width, frame_height,
+ seq_params->subsampling_x,
+ seq_params->subsampling_y, cm->rst_info);
for (int i = 0; i < num_planes; ++i)
cm->rst_info[i].frame_restoration_type = RESTORE_NONE;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ for (int i = 0; i < num_planes; ++i)
+ cm->rst_info[i].frame_cross_restoration_type = RESTORE_NONE;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
av1_alloc_restoration_buffers(cm);
if (!is_stat_generation_stage(cpi)) alloc_util_frame_buffers(cpi);
@@ -2094,6 +2215,30 @@
set_ref_ptrs(cm, xd, 0, 0);
}
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+static void save_pre_filter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
+ (void)cpi;
+ YV12_BUFFER_CONFIG *frame = &cm->cur_frame->buf;
+ YV12_BUFFER_CONFIG *pre_filter_frame = &cm->pre_rst_frame;
+
+ const SequenceHeader *const seq_params = &cm->seq_params;
+
+ const int frame_width = frame->crop_widths[0];
+ const int frame_height = frame->crop_heights[0];
+
+ if (aom_realloc_frame_buffer(
+ pre_filter_frame, frame_width, frame_height,
+ seq_params->subsampling_x, seq_params->subsampling_y,
+ AOM_RESTORATION_FRAME_BORDER, cm->features.byte_alignment, NULL, NULL,
+ NULL) < 0)
+ aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
+ "Failed to allocate restoration dst buffer");
+
+ const int num_planes = av1_num_planes(cm);
+ aom_yv12_copy_frame(frame, pre_filter_frame, num_planes);
+}
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
/*!\brief Select and apply cdef filters and switchable restoration filters
*
* \ingroup high_level_algo
@@ -2235,9 +2380,32 @@
if (use_restoration) {
av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 1);
av1_pick_filter_restoration(cpi->source, cpi);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ save_pre_filter_frame(cpi, cm);
+ if (num_workers > 1)
+ av1_loop_restoration_filter_frame_mt(
+ &cm->cur_frame->buf, cm, 0, mt_info->workers, num_workers,
+ &mt_info->lr_row_sync, &cpi->lr_ctxt);
+ else
+ av1_loop_restoration_filter_frame(&cm->cur_frame->buf, cm, 0,
+ &cpi->lr_ctxt);
+
+ // restore luma component of the frame
+ aom_yv12_copy_y(&cm->pre_rst_frame, &cm->cur_frame->buf);
+ av1_pick_cross_filter_restoration(cpi->source, cpi);
+ // restore chroma components of the frame
+ aom_yv12_copy_u(&cm->pre_rst_frame, &cm->cur_frame->buf);
+ aom_yv12_copy_v(&cm->pre_rst_frame, &cm->cur_frame->buf);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
- cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
+ cm->rst_info[2].frame_restoration_type != RESTORE_NONE
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ || cm->rst_info[0].frame_cross_restoration_type != RESTORE_NONE ||
+ cm->rst_info[1].frame_cross_restoration_type != RESTORE_NONE ||
+ cm->rst_info[2].frame_cross_restoration_type != RESTORE_NONE
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ) {
if (num_workers > 1)
av1_loop_restoration_filter_frame_mt(
&cm->cur_frame->buf, cm, 0, mt_info->workers, num_workers,
@@ -2250,6 +2418,11 @@
cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[0].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[1].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[2].frame_cross_restoration_type = RESTORE_NONE;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
#if CONFIG_COLLECT_COMPONENT_TIMING
end_timing(cpi, loop_restoration_time);
@@ -2724,13 +2897,6 @@
loop = 0;
}
- if (allow_recode && !cpi->sf.gm_sf.gm_disable_recode &&
- av1_recode_loop_test_global_motion(cm->global_motion,
- cpi->td.rd_counts.global_motion_used,
- gm_info->params_cost)) {
- loop = 1;
- }
-
if (loop) {
++loop_count;
@@ -2837,6 +3003,11 @@
cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[0].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[1].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[2].frame_cross_restoration_type = RESTORE_NONE;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
cm->global_motion[i] = default_warp_params;
@@ -2967,6 +3138,11 @@
cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[0].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[1].frame_cross_restoration_type = RESTORE_NONE;
+ cm->rst_info[2].frame_cross_restoration_type = RESTORE_NONE;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
}
#if CONFIG_TIP
@@ -3218,13 +3394,8 @@
}
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_ADAPTIVE_DS_FILTER
-#if DS_FRAME_LEVEL
- if (cm->current_frame.frame_type == KEY_FRAME) {
- av1_set_downsample_filter_options(cpi, features);
-#else
- if (cpi->common.current_frame.absolute_poc == 0) {
+ if (cpi->common.current_frame.frame_type == KEY_FRAME) {
av1_set_downsample_filter_options(cpi);
-#endif // DS_FRAME_LEVEL
}
#endif // CONFIG_ADAPTIVE_DS_FILTER
// frame type has been decided outside of this function call
@@ -3243,11 +3414,20 @@
features->allow_warped_motion = oxcf->motion_mode_cfg.allow_warped_motion &&
frame_might_allow_warped_motion(cm);
#endif // !CONFIG_EXTENDED_WARP_PREDICTION
-
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ features->allow_warpmv_mode = features->enabled_motion_modes;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
// temporal set of frame level enable_bawp flag.
#if CONFIG_BAWP
features->enable_bawp = seq_params->enable_bawp;
#endif
+#if CONFIG_CWP
+ features->enable_cwp = seq_params->enable_cwp;
+#endif // CONFIG_CWP
+
+#if CONFIG_D071_IMP_MSK_BLD
+ features->enable_imp_msk_bld = seq_params->enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
cpi->last_frame_type = current_frame->frame_type;
@@ -3715,7 +3895,11 @@
#endif
cpi->bytes += frame_bytes;
if (cm->show_frame) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ const YV12_BUFFER_CONFIG *orig = cpi->unfiltered_source;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
const YV12_BUFFER_CONFIG *orig = cpi->source;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
const YV12_BUFFER_CONFIG *recon = &cpi->common.cur_frame->buf;
double y, u, v, frame_all;
@@ -3814,10 +3998,18 @@
aom_usec_timer_mark(&cmptimer);
cpi->time_compress_data += aom_usec_timer_elapsed(&cmptimer);
#endif // CONFIG_INTERNAL_STATS
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (cpi->b_calculate_psnr && *size > 0) {
+ if ((cm->showable_frame && cm->seq_params.enable_frame_output_order) ||
+ (cm->show_existing_frame &&
+ !cm->seq_params.enable_frame_output_order) ||
+ (!is_stat_generation_stage(cpi) && cm->show_frame)) {
+#else
// Note *size = 0 indicates a dropeed frame for which psnr is not calculated
if (cpi->b_calculate_psnr && *size > 0) {
if (cm->show_existing_frame ||
(!is_stat_generation_stage(cpi) && cm->show_frame)) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
generate_psnr_packet(cpi);
}
}
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index a0a16b0..e365151 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -288,6 +288,12 @@
*/
bool enable_orip;
#endif
+#if CONFIG_IDIF
+ /*!
+ * Flag to indicate if IDIF should be enabled
+ */
+ bool enable_idif;
+#endif
/*!
* Flag to indicate if IBP should be enabled
*/
@@ -678,6 +684,10 @@
// Indicates if one-sided compound should be enabled.
bool enable_onesided_comp;
bool explicit_ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // Indicates if the implicit frame order derivation is enabled.
+ bool enable_frame_output_order;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
} RefFrameCfg;
typedef struct {
@@ -864,6 +874,10 @@
// Indicates if joint mvd coding should be enabled.
bool enable_joint_mvd;
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ // Indicates if refineMV mode should be enabled.
+ bool enable_refinemv;
+#endif // CONFIG_REFINEMV
#if CONFIG_TIP
// enable temporal interpolated prediction
int enable_tip;
@@ -872,6 +886,14 @@
// enable block adaptive weighted prediction
int enable_bawp;
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ // enable compound weighted prediction
+ int enable_cwp;
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ // enable implicit masked blending
+ bool enable_imp_msk_bld;
+#endif // CONFIG_D071_IMP_MSK_BLD
// When enabled, video mode should be used even for single frame input.
bool force_video_mode;
// Indicates if the error resiliency features should be enabled.
@@ -1220,7 +1242,11 @@
unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
#endif
unsigned int fsc_mode[FSC_MODE_CONTEXTS][FSC_BSIZE_CONTEXTS][FSC_MODES];
+#if CONFIG_EXT_DIR
+ unsigned int mrl_index[MRL_INDEX_CONTEXTS][MRL_LINE_NUMBER];
+#else
unsigned int mrl_index[MRL_LINE_NUMBER];
+#endif // CONFIG_EXT_DIR
#if CONFIG_IMPROVED_CFL
unsigned int cfl_index[CFL_TYPE_COUNT];
#endif
@@ -1243,6 +1269,13 @@
unsigned int rect_type[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][2];
unsigned int do_ext_partition[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
[PARTITION_CONTEXTS][2];
+#if CONFIG_UNEVEN_4WAY
+ unsigned int do_uneven_4way_partition[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
+ [PARTITION_CONTEXTS][2];
+ unsigned int uneven_4way_partition_type[PARTITION_STRUCTURE_NUM]
+ [NUM_RECT_PARTS][PARTITION_CONTEXTS]
+ [NUM_UNEVEN_4WAY_PARTS];
+#endif // CONFIG_UNEVEN_4WAY
#else
unsigned int partition[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
[EXT_PARTITION_TYPES];
@@ -1268,6 +1301,17 @@
unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
[2];
unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
+#if CONFIG_ATC_DCTX_ALIGNED
+ unsigned int coeff_base_bob_multi[TOKEN_CDF_Q_CTXS][SIG_COEF_CONTEXTS_BOB]
+ [NUM_BASE_LEVELS + 1];
+ unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS - 6];
+ unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS - 5];
+ unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS - 4];
+ unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS - 3];
+ unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS - 2];
+ unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS - 1];
+ unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][EOB_MAX_SYMS];
+#else
unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
@@ -1275,7 +1319,8 @@
unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
-#if CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC_DCTX_ALIGNED
+#if CONFIG_ATC
unsigned int coeff_lps_lf[PLANE_TYPES][BR_CDF_SIZE - 1][LF_LEVEL_CONTEXTS][2];
unsigned int coeff_base_lf_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[LF_SIG_COEF_CONTEXTS][LF_BASE_SYMBOLS];
@@ -1289,7 +1334,7 @@
#else
unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[LEVEL_CONTEXTS][BR_CDF_SIZE];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#if CONFIG_PAR_HIDING
unsigned int coeff_base_ph_multi[TOKEN_CDF_Q_CTXS][COEFF_BASE_PH_CONTEXTS]
[NUM_BASE_LEVELS + 2];
@@ -1304,9 +1349,9 @@
unsigned int inter_single_mode[INTER_SINGLE_MODE_CONTEXTS]
[INTER_SINGLE_MODES];
unsigned int drl_mode[3][DRL_MODE_CONTEXTS][2];
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
unsigned int skip_drl_mode[3][2];
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_OPTFLOW_REFINEMENT
unsigned int use_optflow[INTER_COMPOUND_MODE_CONTEXTS][2];
unsigned int inter_compound_mode[INTER_COMPOUND_MODE_CONTEXTS]
@@ -1338,12 +1383,15 @@
unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
unsigned int obmc[BLOCK_SIZES_ALL][2];
#endif // CONFIG_EXTENDED_WARP_PREDICTION
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
unsigned int intra_inter[INTRA_INTER_SKIP_TXFM_CONTEXTS][INTRA_INTER_CONTEXTS]
[2];
#else
unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
-#endif
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
+#if CONFIG_CWP
+ int8_t cwp_idx[MAX_CWP_NUM - 1][2];
+#endif // CONFIG_CWP
#if CONFIG_BAWP
unsigned int bawp[2];
#endif // CONFIG_BAWP
@@ -1360,7 +1408,7 @@
#else
unsigned int intrabc[2];
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
unsigned int intrabc_mode[2];
unsigned int intrabc_drl_idx[MAX_REF_BV_STACK_SIZE - 1][2];
#endif
@@ -1380,7 +1428,12 @@
unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
unsigned int delta_lf[DELTA_LF_PROBS][2];
+#if CONFIG_ATC_DCTX_ALIGNED
+ unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EOB_TX_CTXS][EXT_TX_SIZES]
+ [TX_TYPES];
+#else
unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
+#endif // CONFIG_ATC_DCTX_ALIGNED
unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
[TX_TYPES];
#if CONFIG_CROSS_CHROMA_TX
@@ -1625,8 +1678,6 @@
typedef struct RD_COUNTS {
int64_t comp_pred_diff[REFERENCE_MODES];
- // Stores number of 4x4 blocks using global motion per reference frame.
- int global_motion_used[INTER_REFS_PER_FRAME];
int compound_ref_used_flag;
int skip_mode_used_flag;
int tx_type_used[TX_SIZES_ALL][TX_TYPES];
@@ -1944,19 +1995,6 @@
*/
typedef struct {
/*!
- * Array to store the cost for signalling each global motion model.
- * gmtype_cost[i] stores the cost of signalling the ith Global Motion model.
- */
- int type_cost[TRANS_TYPES];
-
- /*!
- * Array to store the cost for signalling a particular global motion model for
- * each reference frame. gmparams_cost[i] stores the cost of signalling global
- * motion for the ith reference frame.
- */
- int params_cost[INTER_REFS_PER_FRAME];
-
- /*!
* Flag to indicate if global motion search needs to be rerun.
*/
bool search_done;
@@ -2007,6 +2045,25 @@
* the y co-ordinate of the ith corner point detected.
*/
int src_corners[2 * MAX_CORNERS];
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ /*!
+ * \brief Error ratio for each selected global motion model
+ *
+ * This is used to help decide which models will actually be used,
+ * because that decision has to be deferred until we actually select a
+ * base model to use
+ */
+ double erroradvantage[INTER_REFS_PER_FRAME];
+
+ /**
+ * \name Reference path for selected base model
+ */
+ /**@{*/
+ int base_model_our_ref; /*!< which of our ref frames to copy from */
+ int base_model_their_ref; /*!< which model to copy from that frame */
+ /**@}*/
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
} GlobalMotionInfo;
/*!
@@ -2743,7 +2800,7 @@
/*!
* Tables to calculate IntraBC MV cost.
*/
-#if !CONFIG_FLEX_MVRES && !CONFIG_BVCOST_UPDATE
+#if !CONFIG_FLEX_MVRES && !CONFIG_IBC_BV_IMPROVEMENT
IntraBCMVCosts dv_costs;
#endif
@@ -2896,6 +2953,14 @@
* Number of frames left to be encoded, is 0 if limit is not set.
*/
int frames_left;
+
+ /*!
+ * Indicates if a valid global motion model has been found in the different
+ * frame update types of a GF group.
+ * valid_gm_model_found[i] indicates if valid global motion model has been
+ * found in the frame update type with enum value equal to i
+ */
+ int valid_gm_model_found[FRAME_UPDATE_TYPES];
} AV1_COMP;
/*!
@@ -3077,11 +3142,7 @@
int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
-#if DS_FRAME_LEVEL
-void av1_set_downsample_filter_options(AV1_COMP *cpi, FeatureFlags *features);
-#else
void av1_set_downsample_filter_options(AV1_COMP *cpi);
-#endif // DS_FRAME_LEVEl
// Set screen content options.
// This function estimates whether to use screen content tools, by counting
@@ -3289,8 +3350,18 @@
// frame. An exception can be made for a forward keyframe since it has no
// previous dependencies.
static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
- return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
- cm->current_frame.frame_type == KEY_FRAME);
+ if (!cm->show_existing_frame) return 0;
+
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // When enable_frame_output_order == 1, show_existing_frame can be equal to 1
+ // only for a forward key frame
+ if (cm->seq_params.enable_frame_output_order)
+ return (!cm->features.error_resilient_mode &&
+ cm->current_frame.frame_type == KEY_FRAME);
+ else
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ return (!cm->features.error_resilient_mode ||
+ cm->current_frame.frame_type == KEY_FRAME);
}
// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
@@ -3358,6 +3429,16 @@
return AOMMIN(max_allowed_refs_for_given_speed, max_reference_frames);
}
+#if CONFIG_SEP_COMP_DRL
+/*!\brief Return whether the current coding block has two separate DRLs,
+ * the mdoe info is used as inputs */
+static INLINE int has_second_drl_by_mode(const PREDICTION_MODE mode,
+ const MV_REFERENCE_FRAME *ref_frame) {
+ return (mode == NEAR_NEARMV || mode == NEAR_NEWMV) &&
+ !is_tip_ref_frame(ref_frame[0]);
+}
+#endif // CONFIG_SEP_COMP_DRL
+
// Enforce the number of references for each arbitrary frame based on user
// options and speed.
static AOM_INLINE void enforce_max_ref_frames(AV1_COMP *cpi,
diff --git a/av1/encoder/encoder_alloc.h b/av1/encoder/encoder_alloc.h
index 8ae62cd..2b6e702 100644
--- a/av1/encoder/encoder_alloc.h
+++ b/av1/encoder/encoder_alloc.h
@@ -80,7 +80,7 @@
#endif // CONFIG_EXT_RECUR_PARTITIONS
cpi->td.firstpass_ctx =
- av1_alloc_pmc(cm, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
+ av1_alloc_pmc(cm, SHARED_PART, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
&cpi->td.shared_coeff_buf);
}
diff --git a/av1/encoder/encoder_utils.c b/av1/encoder/encoder_utils.c
index c6cdc29..9b6842d 100644
--- a/av1/encoder/encoder_utils.c
+++ b/av1/encoder/encoder_utils.c
@@ -740,9 +740,6 @@
return AOMMIN(cm->width, cm->height) > 480 ? BLOCK_128X128 : BLOCK_64X64;
}
#if CONFIG_BLOCK_256
- if (cm->features.allow_intrabc) {
- return BLOCK_128X128;
- }
return AOMMIN(oxcf->frm_dim_cfg.width, oxcf->frm_dim_cfg.height) >= 720
? BLOCK_256X256
: BLOCK_128X128;
@@ -779,9 +776,9 @@
const int frame_width = cm->superres_upscaled_width;
const int frame_height = cm->superres_upscaled_height;
- av1_set_restoration_unit_size(
- frame_width, frame_height, seq_params->subsampling_x,
- seq_params->subsampling_y, cm->rst_info, seq_params->sb_size);
+ set_restoration_unit_size(frame_width, frame_height,
+ seq_params->subsampling_x,
+ seq_params->subsampling_y, cm->rst_info);
if (old_restoration_unit_size != cm->rst_info[0].restoration_unit_size) {
for (int i = 0; i < num_planes; ++i)
@@ -1006,28 +1003,6 @@
cpi->sf.part_sf.fixed_partition_size = fixed_partition_block_size_orig;
}
-#define GM_RECODE_LOOP_NUM4X4_FACTOR 192
-int av1_recode_loop_test_global_motion(WarpedMotionParams *const global_motion,
- const int *const global_motion_used,
- int *const gm_params_cost) {
- int i;
- int recode = 0;
- for (i = 0; i < INTER_REFS_PER_FRAME; ++i) {
- if (global_motion[i].wmtype != IDENTITY &&
- global_motion_used[i] * GM_RECODE_LOOP_NUM4X4_FACTOR <
- gm_params_cost[i]) {
- global_motion[i] = default_warp_params;
- assert(global_motion[i].wmtype == IDENTITY);
- gm_params_cost[i] = 0;
- recode = 1;
- // TODO(sarahparker): The earlier condition for recoding here was:
- // "recode |= (rdc->global_motion_used[i] > 0);". Can we bring something
- // similar to that back to speed up global motion?
- }
- }
- return recode;
-}
-
static void fix_interp_filter(InterpFilter *const interp_filter,
const FRAME_COUNTS *const counts) {
if (*interp_filter == SWITCHABLE) {
diff --git a/av1/encoder/encoder_utils.h b/av1/encoder/encoder_utils.h
index 37f5cef..5399797 100644
--- a/av1/encoder/encoder_utils.h
+++ b/av1/encoder/encoder_utils.h
@@ -921,7 +921,11 @@
cpi->sf.inter_sf.prune_obmc_prob_thresh > 0) {
av1_copy(frame_probs->obmc_probs, default_obmc_probs);
}
- if (cpi->sf.inter_sf.prune_warped_prob_thresh > 0) {
+ if (cpi->sf.inter_sf.prune_warped_prob_thresh > 0
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || cpi->sf.inter_sf.prune_warpmv_prob_thresh > 0
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ ) {
av1_copy(frame_probs->warped_probs, default_warped_probs);
}
}
@@ -1071,10 +1075,6 @@
void av1_determine_sc_tools_with_encoding(AV1_COMP *cpi, const int q_orig);
-int av1_recode_loop_test_global_motion(WarpedMotionParams *const global_motion,
- const int *const global_motion_used,
- int *const gm_params_cost);
-
void av1_set_size_dependent_vars(AV1_COMP *cpi, int *q, int *bottom_index,
int *top_index);
@@ -1136,31 +1136,6 @@
}
av1_calculate_tile_rows(cm, mi_params->mi_rows, tiles);
}
-
-#define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0
-static AOM_INLINE void av1_set_restoration_unit_size(int width, int height,
- int sx, int sy,
- RestorationInfo *rst,
- BLOCK_SIZE sb_size) {
- (void)width;
- (void)height;
- (void)sx;
- (void)sy;
-#if COUPLED_CHROMA_FROM_LUMA_RESTORATION
- int s = AOMMIN(sx, sy);
-#else
- int s = 0;
-#endif // !COUPLED_CHROMA_FROM_LUMA_RESTORATION
-
- if (width * height > 352 * 288)
- rst[0].restoration_unit_size = RESTORATION_UNITSIZE_MAX;
- else
- rst[0].restoration_unit_size =
- AOMMAX((RESTORATION_UNITSIZE_MAX >> 1), block_size_wide[sb_size]);
- rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s;
- rst[2].restoration_unit_size = rst[1].restoration_unit_size;
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 1c36d25..f1f51e6 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -174,11 +174,16 @@
#if CONFIG_ENTROPY_STATS
void av1_update_eob_context(int cdf_idx, int eob, TX_SIZE tx_size,
- TX_CLASS tx_class, PLANE_TYPE plane,
- FRAME_CONTEXT *ec_ctx, FRAME_COUNTS *counts,
- uint8_t allow_update_cdf) {
+#if !CONFIG_ATC_DCTX_ALIGNED
+ TX_CLASS tx_class,
+#endif // !CONFIG_ATC_DCTX_ALIGNED
+ PLANE_TYPE plane, FRAME_CONTEXT *ec_ctx,
+ FRAME_COUNTS *counts, uint8_t allow_update_cdf) {
#else
-void av1_update_eob_context(int eob, TX_SIZE tx_size, TX_CLASS tx_class,
+void av1_update_eob_context(int eob, TX_SIZE tx_size,
+#if !CONFIG_ATC_DCTX_ALIGNED
+ TX_CLASS tx_class,
+#endif // !CONFIG_ATC_DCTX_ALIGNED
PLANE_TYPE plane, FRAME_CONTEXT *ec_ctx,
uint8_t allow_update_cdf) {
#endif
@@ -187,6 +192,67 @@
TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
const int eob_multi_size = txsize_log2_minus4[tx_size];
+#if CONFIG_ATC_DCTX_ALIGNED
+ switch (eob_multi_size) {
+ case 0:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi16[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf)
+ update_cdf(ec_ctx->eob_flag_cdf16[plane], eob_pt - 1, EOB_MAX_SYMS - 6);
+ break;
+ case 1:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi32[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf)
+ update_cdf(ec_ctx->eob_flag_cdf32[plane], eob_pt - 1, EOB_MAX_SYMS - 5);
+ break;
+ case 2:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi64[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf)
+ update_cdf(ec_ctx->eob_flag_cdf64[plane], eob_pt - 1, EOB_MAX_SYMS - 4);
+ break;
+ case 3:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi128[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf) {
+ update_cdf(ec_ctx->eob_flag_cdf128[plane], eob_pt - 1,
+ EOB_MAX_SYMS - 3);
+ }
+ break;
+ case 4:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi256[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf) {
+ update_cdf(ec_ctx->eob_flag_cdf256[plane], eob_pt - 1,
+ EOB_MAX_SYMS - 2);
+ }
+ break;
+ case 5:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi512[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf) {
+ update_cdf(ec_ctx->eob_flag_cdf512[plane], eob_pt - 1,
+ EOB_MAX_SYMS - 1);
+ }
+ break;
+ case 6:
+ default:
+#if CONFIG_ENTROPY_STATS
+ ++counts->eob_multi1024[cdf_idx][plane][eob_pt - 1];
+#endif
+ if (allow_update_cdf) {
+ update_cdf(ec_ctx->eob_flag_cdf1024[plane], eob_pt - 1, EOB_MAX_SYMS);
+ }
+ break;
+ }
+#else
const int eob_multi_ctx = (tx_class == TX_CLASS_2D) ? 0 : 1;
switch (eob_multi_size) {
@@ -249,6 +315,7 @@
}
break;
}
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (av1_eob_offset_bits[eob_pt] > 0) {
int eob_ctx = eob_pt - 3;
@@ -263,13 +330,21 @@
}
static int get_eob_cost(int eob, const LV_MAP_EOB_COST *txb_eob_costs,
- const LV_MAP_COEFF_COST *txb_costs, TX_CLASS tx_class) {
+ const LV_MAP_COEFF_COST *txb_costs
+#if !CONFIG_ATC_DCTX_ALIGNED
+ ,
+ TX_CLASS tx_class
+#endif // !CONFIG_ATC_DCTX_ALIGNED
+) {
int eob_extra;
const int eob_pt = get_eob_pos_token(eob, &eob_extra);
int eob_cost = 0;
+#if CONFIG_ATC_DCTX_ALIGNED
+ eob_cost = txb_eob_costs->eob_cost[eob_pt - 1];
+#else
const int eob_multi_ctx = (tx_class == TX_CLASS_2D) ? 0 : 1;
eob_cost = txb_eob_costs->eob_cost[eob_multi_ctx][eob_pt - 1];
-
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (av1_eob_offset_bits[eob_pt] > 0) {
const int eob_ctx = eob_pt - 3;
const int eob_shift = av1_eob_offset_bits[eob_pt] - 1;
@@ -301,7 +376,7 @@
return 0;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
// Golomb cost of coding bypass coded level values in the
// low-frequency region.
static INLINE int get_golomb_cost_lf(int abs_qc) {
@@ -342,7 +417,7 @@
}
return coeff_lps[base_range] + golomb_bits;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
static INLINE int get_br_cost_with_diff(tran_low_t level, const int *coeff_lps,
int *diff) {
@@ -374,23 +449,23 @@
const int coeff_idx, const int bwl,
const int height, const int scan_idx,
const int is_eob,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
const TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
const TX_CLASS tx_class
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
const int plane) {
#else
) {
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (is_eob) {
if (scan_idx == 0) return 0;
if (scan_idx <= (height << bwl) / 8) return 1;
if (scan_idx <= (height << bwl) / 4) return 2;
return 3;
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
int stats = 0;
const int row = coeff_idx >> bwl;
const int col = coeff_idx - (row << bwl);
@@ -407,11 +482,20 @@
const int stats =
get_nz_mag(levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
return get_nz_map_ctx_from_stats(stats, coeff_idx, bwl, tx_size, tx_class);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
static INLINE int get_nz_map_ctx_skip(const uint8_t *const levels,
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int height, const int scan_idx,
+ const int is_bob, const int coeff_idx,
+ const int bwl) {
+ if (is_bob) {
+ return get_lower_levels_ctx_bob(bwl, height, scan_idx);
+ }
+#else
const int coeff_idx, const int bwl) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int stats =
get_nz_mag_skip(levels + get_padded_idx_left(coeff_idx, bwl), bwl);
return get_nz_map_ctx_from_stats_skip(stats, coeff_idx, bwl);
@@ -492,39 +576,114 @@
const int16_t *const scan, const uint16_t eob,
const TX_SIZE tx_size, const TX_CLASS tx_class,
int8_t *const coeff_contexts
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
const int plane) {
#else
) {
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
const int bwl = get_txb_bwl(tx_size);
const int height = get_txb_high(tx_size);
for (int i = 0; i < eob; ++i) {
const int pos = scan[i];
coeff_contexts[pos] =
get_nz_map_ctx(levels, pos, bwl, height, i, i == eob - 1,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
tx_class
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
plane);
#else
);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
}
+#if CONFIG_ATC_DCTX_ALIGNED
+// Encodes the EOB syntax in the bitstream.
+static INLINE void code_eob(MACROBLOCK *const x, aom_writer *w, int plane,
+ TX_SIZE tx_size, const int eob) {
+ MACROBLOCKD *xd = &x->e_mbd;
+ FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
+ const PLANE_TYPE plane_type = get_plane_type(plane);
+ const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
+
+ int eob_extra;
+ const int eob_pt = get_eob_pos_token(eob, &eob_extra);
+ const int eob_multi_size = txsize_log2_minus4[tx_size];
+ switch (eob_multi_size) {
+ case 0:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf16[plane_type],
+ EOB_MAX_SYMS - 6);
+ break;
+ case 1:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf32[plane_type],
+ EOB_MAX_SYMS - 5);
+ break;
+ case 2:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf64[plane_type],
+ EOB_MAX_SYMS - 4);
+ break;
+ case 3:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf128[plane_type],
+ EOB_MAX_SYMS - 3);
+ break;
+ case 4:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf256[plane_type],
+ EOB_MAX_SYMS - 2);
+ break;
+ case 5:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf512[plane_type],
+ EOB_MAX_SYMS - 1);
+ break;
+ default:
+ aom_write_symbol(w, eob_pt - 1, ec_ctx->eob_flag_cdf1024[plane_type],
+ EOB_MAX_SYMS);
+ break;
+ }
+ const int eob_offset_bits = av1_eob_offset_bits[eob_pt];
+ if (eob_offset_bits > 0) {
+ const int eob_ctx = eob_pt - 3;
+ int eob_shift = eob_offset_bits - 1;
+ int bit = (eob_extra & (1 << eob_shift)) ? 1 : 0;
+ aom_write_symbol(w, bit,
+ ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2);
+#if CONFIG_BYPASS_IMPROVEMENT
+ // Zero out top bit; write (eob_offset_bits - 1) lsb bits.
+ eob_extra &= (1 << (eob_offset_bits - 1)) - 1;
+ aom_write_literal(w, eob_extra, eob_offset_bits - 1);
+#else
+ for (int i = 1; i < eob_offset_bits; i++) {
+ eob_shift = eob_offset_bits - 1 - i;
+ bit = (eob_extra & (1 << eob_shift)) ? 1 : 0;
+ aom_write_bit(w, bit);
+ }
+#endif
+ }
+}
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
void av1_get_nz_map_contexts_skip_c(const uint8_t *const levels,
const int16_t *const scan,
+#if CONFIG_ATC_DCTX_ALIGNED
+ const uint16_t bob,
+#endif // CONFIG_ATC_DCTX_ALIGNED
const uint16_t eob, const TX_SIZE tx_size,
int8_t *const coeff_contexts) {
const int bwl = get_txb_bwl(tx_size);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int height = get_txb_high(tx_size);
+ for (int i = bob; i < eob; ++i) {
+ const int pos = scan[i];
+ coeff_contexts[pos] =
+ get_nz_map_ctx_skip(levels, height, i, bob == i, pos, bwl);
+#else
for (int i = 0; i < eob; ++i) {
const int pos = scan[i];
coeff_contexts[pos] = get_nz_map_ctx_skip(levels, pos, bwl);
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
}
@@ -545,6 +704,10 @@
const uint16_t *eob_txb = cb_coef_buff->eobs[plane] + txb_offset;
const uint16_t eob = eob_txb[block];
+#if CONFIG_ATC_DCTX_ALIGNED
+ const uint16_t *bob_txb = cb_coef_buff->bobs[plane] + txb_offset;
+ const uint16_t bob_code = bob_txb[block];
+#endif // CONFIG_ATC_DCTX_ALIGNED
const uint8_t *entropy_ctx = cb_coef_buff->entropy_ctx[plane] + txb_offset;
#if CONFIG_CONTEXT_DERIVATION
@@ -563,6 +726,12 @@
const TX_TYPE tx_type =
av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size,
cm->features.reduced_tx_set_used);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
+ const int is_fsc = (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] &&
+ plane == PLANE_TYPE_Y) ||
+ use_inter_fsc(cm, plane, tx_type, is_inter);
+#endif // CONFIG_ATC_DCTX_ALIGNED
#if CONFIG_CROSS_CHROMA_TX && CCTX_C2_DROPPED
if (plane == AOM_PLANE_V && is_cctx_allowed(cm, xd)) {
@@ -585,17 +754,32 @@
aom_write_symbol(w, eob == 0, ec_ctx->txb_skip_cdf[txs_ctx][txb_skip_ctx], 2);
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_CROSS_CHROMA_TX && !CONFIG_ATC_DCTX_ALIGNED
if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) {
CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
if (eob > 0) av1_write_cctx_type(cm, xd, cctx_type, tx_size, w);
}
-#endif // CONFIG_CROSS_CHROMA_TX
+#endif // CONFIG_CROSS_CHROMA_TX && !CONFIG_ATC_DCTX_ALIGNED
if (eob == 0) return 0;
+#if CONFIG_ATC_DCTX_ALIGNED
+ int esc_eob = is_fsc ? bob_code : eob;
+ const int dc_skip = (eob == 1) && !is_inter;
+ code_eob(x, w, plane, tx_size, esc_eob);
+ av1_write_tx_type(cm, xd, tx_type, tx_size, w, plane, esc_eob, dc_skip);
+#if CONFIG_CROSS_CHROMA_TX
+ if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) {
+ const int skip_cctx = is_inter ? 0 : (eob == 1);
+ CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
+ if (eob > 0 && !skip_cctx)
+ av1_write_cctx_type(cm, xd, cctx_type, tx_size, w);
+ }
+#endif // CONFIG_CROSS_CHROMA_TX
+#else
if (plane == 0) { // Only y plane's tx_type is transmitted
av1_write_tx_type(cm, xd, tx_type, tx_size, w);
}
+#endif
return 1;
}
@@ -625,15 +809,39 @@
const int bwl = get_txb_bwl(tx_size);
DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int txb_offset =
+ x->mbmi_ext_frame->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
+ const uint16_t *bob_txb = cb_coef_buff->bobs[plane] + txb_offset;
+ const int bob_code = bob_txb[block];
+ int bob = av1_get_max_eob(tx_size) - bob_code;
+ av1_get_nz_map_contexts_skip_c(levels, scan, bob, eob, tx_size,
+ coeff_contexts);
+#else
av1_get_nz_map_contexts_skip(levels, scan, eob, tx_size, coeff_contexts);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+#if CONFIG_ATC_DCTX_ALIGNED
+ for (int c = bob; c < eob; ++c) {
+#else
for (int c = 0; c < eob; ++c) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int pos = scan[c];
const int coeff_ctx = coeff_contexts[pos];
const tran_low_t v = tcoeff[pos];
const tran_low_t level = abs(v);
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (c == bob) {
+ aom_write_symbol(w, AOMMIN(level, 3) - 1,
+ ec_ctx->coeff_base_bob_cdf[coeff_ctx], 3);
+ } else {
+ aom_write_symbol(w, AOMMIN(level, 3),
+ ec_ctx->coeff_base_cdf_idtx[coeff_ctx], 4);
+ }
+#else
aom_write_symbol(w, AOMMIN(level, 3),
ec_ctx->coeff_base_cdf_idtx[coeff_ctx], 4);
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (level > NUM_BASE_LEVELS) {
// level is above 1.
const int base_range = level - 1 - NUM_BASE_LEVELS;
@@ -705,8 +913,11 @@
const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_PC_WIENER
- assert((eob == 0) ==
- av1_get_txk_skip(cm, xd->mi_row, xd->mi_col, plane, blk_row, blk_col));
+ if (!is_global_intrabc_allowed(cm) && !cm->features.coded_lossless) {
+ // Assert only when LR is enabled.
+ assert((eob == 0) == av1_get_txk_skip(cm, xd->mi_row, xd->mi_col, plane,
+ blk_row, blk_col));
+ }
#endif // CONFIG_PC_WIENER
if (eob == 0) return;
@@ -719,7 +930,7 @@
fprintf(cm->fEncCoeffLog, "\nblk_row=%d,blk_col=%d,plane=%d,tx_size=%d",
blk_row, blk_col, plane, tx_size);
#endif
-
+#if !CONFIG_ATC_DCTX_ALIGNED
int eob_extra;
const int eob_pt = get_eob_pos_token(eob, &eob_extra);
const int eob_multi_size = txsize_log2_minus4[tx_size];
@@ -775,10 +986,17 @@
}
#endif
}
+#else
+ const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
+#endif // !CONFIG_ATC_DCTX_ALIGNED
// write sec_tx_type here
// Only y plane's sec_tx_type is transmitted
+#if CONFIG_ATC_DCTX_ALIGNED
+ if ((plane == AOM_PLANE_Y) && (cm->seq_params.enable_ist) && eob != 1) {
+#else
if ((plane == AOM_PLANE_Y) && (cm->seq_params.enable_ist)) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
av1_write_sec_tx_type(cm, xd, tx_type, tx_size, eob, w);
}
@@ -800,10 +1018,10 @@
const int16_t *const scan = scan_order->scan;
DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
av1_get_nz_map_contexts(levels, scan, eob, tx_size, tx_class, coeff_contexts
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
plane
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
const int bwl = get_txb_bwl(tx_size);
@@ -822,7 +1040,7 @@
const tran_low_t v = tcoeff[pos];
const tran_low_t level = abs(v);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (c == eob - 1) {
const int row = pos >> bwl;
const int col = pos - (row << bwl);
@@ -860,9 +1078,9 @@
aom_write_symbol(w, AOMMIN(level, 3),
ec_ctx->coeff_base_cdf[txs_ctx][plane_type][coeff_ctx],
4);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -903,7 +1121,7 @@
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
#if CONFIG_PAR_HIDING
@@ -929,7 +1147,7 @@
const tran_low_t v = tcoeff[pos];
const tran_low_t level = abs(v);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (c == eob - 1) {
const int row = pos >> bwl;
const int col = pos - (row << bwl);
@@ -967,9 +1185,9 @@
aom_write_symbol(w, AOMMIN(level, 3),
ec_ctx->coeff_base_cdf[txs_ctx][plane_type][coeff_ctx],
4);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -1010,7 +1228,7 @@
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
#endif // CONFIG_PAR_HIDING
@@ -1059,7 +1277,7 @@
#endif // CONFIG_CONTEXT_DERIVATION
}
#if CONFIG_PAR_HIDING
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (is_hidden && c == 0) {
int q_index = level >> 1;
if (q_index > COEFF_BASE_RANGE + NUM_BASE_LEVELS)
@@ -1086,9 +1304,9 @@
if (level > COEFF_BASE_RANGE + NUM_BASE_LEVELS)
write_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#else
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int pos = scan[c];
const int row = pos >> bwl;
const int col = pos - (row << bwl);
@@ -1103,7 +1321,7 @@
#else
if (level > COEFF_BASE_RANGE + NUM_BASE_LEVELS)
write_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#endif // CONFIG_PAR_HIDING
}
}
@@ -1202,8 +1420,17 @@
int get_cctx_type_cost(const AV1_COMMON *cm, const MACROBLOCK *x,
const MACROBLOCKD *xd, int plane, TX_SIZE tx_size,
int block, CctxType cctx_type) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int skip_cctx = is_inter_block(xd->mi[0], xd->tree_type)
+ ? 0
+ : (x->plane[plane].eobs[block] == 1);
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (plane == AOM_PLANE_U && x->plane[plane].eobs[block] &&
- is_cctx_allowed(cm, xd)) {
+ is_cctx_allowed(cm, xd)
+#if CONFIG_ATC_DCTX_ALIGNED
+ && !skip_cctx
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ ) {
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
int above_cctx, left_cctx;
#if CONFIG_EXT_RECUR_PARTITIONS
@@ -1222,7 +1449,12 @@
// TODO(angiebird): use this function whenever it's possible
static int get_tx_type_cost(const MACROBLOCK *x, const MACROBLOCKD *xd,
int plane, TX_SIZE tx_size, TX_TYPE tx_type,
- int reduced_tx_set_used, int eob) {
+ int reduced_tx_set_used, int eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ int bob_code, int is_fsc
+#endif // CONFIG_ATC_DCTX_ALIGNED
+) {
if (plane > 0) return 0;
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
@@ -1239,8 +1471,18 @@
get_ext_tx_set(tx_size, is_inter, reduced_tx_set_used);
if (is_inter) {
if (ext_tx_set > 0)
+#if CONFIG_ATC_DCTX_ALIGNED
+ {
+ const int esc_eob = is_fsc ? bob_code : eob;
+ const int eob_tx_ctx =
+ get_lp2tx_ctx(tx_size, get_txb_bwl(tx_size), esc_eob);
+ return x->mode_costs.inter_tx_type_costs[ext_tx_set][eob_tx_ctx]
+ [square_tx_size][tx_type];
+ }
+#else
return x->mode_costs
.inter_tx_type_costs[ext_tx_set][square_tx_size][tx_type];
+#endif // CONFIG_ATC_DCTX_ALIGNED
} else {
if (ext_tx_set > 0) {
PREDICTION_MODE intra_dir;
@@ -1250,6 +1492,20 @@
else
intra_dir = mbmi->mode;
TX_TYPE primary_tx_type = get_primary_tx_type(tx_type);
+#if CONFIG_ATC_DCTX_ALIGNED
+ int tx_type_cost = 0;
+ if (eob != 1) {
+ tx_type_cost =
+ x->mode_costs.intra_tx_type_costs[ext_tx_set][square_tx_size]
+ [intra_dir][primary_tx_type];
+ }
+ if (block_signals_sec_tx_type(xd, tx_size, tx_type, eob) &&
+ xd->enable_ist) {
+ tx_type_cost +=
+ x->mode_costs.stx_flag_cost[square_tx_size]
+ [get_secondary_tx_type(tx_type)];
+ }
+#else
int tx_type_cost =
x->mode_costs.intra_tx_type_costs[ext_tx_set][square_tx_size]
[intra_dir][primary_tx_type];
@@ -1259,6 +1515,7 @@
x->mode_costs.stx_flag_cost[square_tx_size]
[get_secondary_tx_type(tx_type)];
}
+#endif // CONFIG_ATC_DCTX_ALIGNED
return tx_type_cost;
}
}
@@ -1304,9 +1561,9 @@
}
static AOM_FORCE_INLINE int warehouse_efficients_txb_skip(
-#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
const AV1_COMMON *cm,
-#endif // CONFIG_CROSS_CHROMA_TX
+#endif // CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
const MACROBLOCK *x, const int plane, const int block,
const TX_SIZE tx_size, const TXB_CTX *const txb_ctx,
const struct macroblock_plane *p, const int eob,
@@ -1329,22 +1586,61 @@
int8_t signs_buf[TX_PAD_2D];
int8_t *const signs = set_signs(signs_buf, width);
av1_txb_init_levels_signs(qcoeff, width, height, levels_buf, signs_buf);
- cost += get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used,
- eob);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob_code = p->bobs[block];
+ const int bob = av1_get_max_eob(tx_size) - bob_code;
+ const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
+ const int is_fsc = (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] &&
+ plane == PLANE_TYPE_Y) ||
+ use_inter_fsc(cm, plane, tx_type, is_inter);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ cost +=
+ get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used, eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ bob_code, is_fsc
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ );
+
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int eob_multi_size = txsize_log2_minus4[tx_size];
+ const LV_MAP_EOB_COST *const eob_costs =
+ &x->coeff_costs.eob_costs[eob_multi_size][PLANE_TYPE_Y];
+ cost += get_eob_cost(bob_code, eob_costs, coeff_costs);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
#if CONFIG_CROSS_CHROMA_TX
cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, block, cctx_type);
#endif // CONFIG_CROSS_CHROMA_TX
DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
+#if CONFIG_ATC_DCTX_ALIGNED
+ av1_get_nz_map_contexts_skip_c(levels, scan, bob, eob, tx_size,
+ coeff_contexts);
+#else
av1_get_nz_map_contexts_skip(levels, scan, eob, tx_size, coeff_contexts);
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int(*lps_cost)[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1] =
coeff_costs->lps_cost_skip;
const int(*base_cost)[8] = coeff_costs->idtx_base_cost;
+
+#if CONFIG_ATC_DCTX_ALIGNED
+ for (int c = bob; c < eob; c++) {
+#else
for (int c = 0; c < eob; c++) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int pos = scan[c];
const int coeff_ctx = coeff_contexts[pos];
const tran_low_t v = qcoeff[pos];
const int level = abs(v);
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (c == bob) {
+ cost += coeff_costs->base_bob_cost[coeff_ctx][AOMMIN(level, 3) - 1];
+ } else {
+ cost += base_cost[coeff_ctx][AOMMIN(level, 3)];
+ }
+#else
cost += base_cost[coeff_ctx][AOMMIN(level, 3)];
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (v) {
if (level > NUM_BASE_LEVELS) {
const int ctx = get_br_ctx_skip(levels, pos, bwl);
@@ -1352,7 +1648,11 @@
}
}
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ for (int c = eob - 1; c >= bob; --c) {
+#else
for (int c = eob - 1; c >= 0; --c) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int pos = scan[c];
const tran_low_t v = qcoeff[pos];
const tran_low_t level = abs(v);
@@ -1366,9 +1666,9 @@
}
static AOM_FORCE_INLINE int warehouse_efficients_txb(
-#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
const AV1_COMMON *cm,
-#endif // CONFIG_CROSS_CHROMA_TX
+#endif // CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
const MACROBLOCK *x, const int plane, const int block,
const TX_SIZE tx_size, const TXB_CTX *const txb_ctx,
const struct macroblock_plane *p, const int eob,
@@ -1417,27 +1717,43 @@
av1_txb_init_levels(qcoeff, width, height, levels);
- cost += get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used,
- eob);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob_code = p->bobs[block];
+ const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
+ const int is_fsc = (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] &&
+ plane == PLANE_TYPE_Y) ||
+ use_inter_fsc(cm, plane, tx_type, is_inter);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
+ cost +=
+ get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used, eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ bob_code, is_fsc
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ );
#if CONFIG_CROSS_CHROMA_TX
cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, block, cctx_type);
#endif // CONFIG_CROSS_CHROMA_TX
-
+#if CONFIG_ATC_DCTX_ALIGNED
+ cost += get_eob_cost(eob, eob_costs, coeff_costs);
+#else
cost += get_eob_cost(eob, eob_costs, coeff_costs, tx_class);
+#endif // CONFIG_ATC_DCTX_ALIGNED
av1_get_nz_map_contexts(levels, scan, eob, tx_size, tx_class, coeff_contexts
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
plane
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
const int(*lps_cost)[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1] =
coeff_costs->lps_cost;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int(*lps_lf_cost)[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1] =
coeff_costs->lps_lf_cost;
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
int c = eob - 1;
{
const int pos = scan[c];
@@ -1445,7 +1761,7 @@
const int sign = AOMSIGN(v);
const int level = (v ^ sign) - sign;
const int coeff_ctx = coeff_contexts[pos];
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -1458,11 +1774,11 @@
}
#else
cost += coeff_costs->base_eob_cost[coeff_ctx][AOMMIN(level, 3) - 1];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (v) {
// sign bit cost
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
if (level > LF_NUM_BASE_LEVELS) {
const int ctx = get_br_ctx_lf_eob(pos, tx_class);
@@ -1479,7 +1795,7 @@
const int ctx = get_br_ctx_eob(pos, bwl, tx_class);
cost += get_br_cost(level, lps_cost[ctx]);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (c) {
#if CONFIG_CONTEXT_DERIVATION
if (plane == AOM_PLANE_V) {
@@ -1508,16 +1824,16 @@
}
}
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int(*base_lf_cost)[LF_BASE_SYMBOLS * 2] = coeff_costs->base_lf_cost;
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
const int(*base_cost)[8] = coeff_costs->base_cost;
for (c = eob - 2; c >= 1; --c) {
const int pos = scan[c];
const int coeff_ctx = coeff_contexts[pos];
const tran_low_t v = qcoeff[pos];
const int level = abs(v);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -1528,7 +1844,7 @@
}
#else
cost += base_cost[coeff_ctx][AOMMIN(level, 3)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (v) {
// sign bit cost
#if CONFIG_CONTEXT_DERIVATION
@@ -1542,7 +1858,7 @@
#else
cost += av1_cost_literal(1);
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
if (level > LF_NUM_BASE_LEVELS) {
const int ctx = get_br_lf_ctx(levels, pos, bwl, tx_class);
@@ -1559,7 +1875,7 @@
const int ctx = get_br_ctx(levels, pos, bwl, tx_class);
cost += get_br_cost(level, lps_cost[ctx]);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
}
// c == 0 after previous loop
@@ -1595,7 +1911,7 @@
const int coeff_ctx = coeff_contexts[pos];
const int sign = AOMSIGN(v);
const int level = (v ^ sign) - sign;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -1606,7 +1922,7 @@
}
#else
cost += base_cost[coeff_ctx][AOMMIN(level, 3)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (v) {
// sign bit cost
@@ -1622,7 +1938,7 @@
#else
cost += coeff_costs->dc_sign_cost[dc_sign_ctx][sign01];
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
if (level > LF_NUM_BASE_LEVELS) {
const int ctx = get_br_lf_ctx(levels, pos, bwl, tx_class);
@@ -1639,7 +1955,7 @@
const int ctx = get_br_ctx(levels, pos, bwl, tx_class);
cost += get_br_cost(level, lps_cost[ctx]);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
}
return cost;
@@ -1653,7 +1969,10 @@
#if CONFIG_CROSS_CHROMA_TX
const CctxType cctx_type,
#endif // CONFIG_CROSS_CHROMA_TX
- const TX_CLASS tx_class, int reduced_tx_set_used) {
+#if !CONFIG_ATC_DCTX_ALIGNED
+ const TX_CLASS tx_class,
+#endif // !CONFIG_ATC_DCTX_ALIGNED
+ int reduced_tx_set_used) {
#if CONFIG_CONTEXT_DERIVATION
int txb_skip_ctx = txb_ctx->txb_skip_ctx;
if (plane == AOM_PLANE_V) {
@@ -1678,8 +1997,21 @@
int cost = coeff_costs->txb_skip_cost[txb_skip_ctx][0];
#endif // CONFIG_CONTEXT_DERIVATION
- cost += get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used,
- eob);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob_code = x->plane[plane].bobs[block];
+ const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
+ const int is_fsc = (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] &&
+ plane == PLANE_TYPE_Y) ||
+ use_inter_fsc(cm, plane, tx_type, is_inter);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
+ cost +=
+ get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used, eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ bob_code, is_fsc
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ );
#if CONFIG_CROSS_CHROMA_TX
cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, block, cctx_type);
#endif // CONFIG_CROSS_CHROMA_TX
@@ -1691,7 +2023,11 @@
cost +=
av1_cost_coeffs_txb_skip_estimate(x, plane, block, tx_size, tx_type);
} else {
+#if CONFIG_ATC_DCTX_ALIGNED
+ cost += get_eob_cost(eob, eob_costs, coeff_costs);
+#else
cost += get_eob_cost(eob, eob_costs, coeff_costs, tx_class);
+#endif // CONFIG_ATC_DCTX_ALIGNED
cost += av1_cost_coeffs_txb_estimate(x, plane, block, tx_size, tx_type);
}
return cost;
@@ -1816,9 +2152,9 @@
get_primary_tx_type(tx_type) == IDTX && plane == PLANE_TYPE_Y) ||
use_inter_fsc(cm, plane, tx_type, is_inter_block(mbmi, xd->tree_type))) {
return warehouse_efficients_txb_skip(
-#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
cm,
-#endif // CONFIG_CROSS_CHROMA_TX
+#endif // CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
x, plane, block, tx_size, txb_ctx, p, eob, coeff_costs, xd, tx_type,
#if CONFIG_CROSS_CHROMA_TX
cctx_type,
@@ -1826,9 +2162,9 @@
reduced_tx_set_used);
} else {
return warehouse_efficients_txb(
-#if CONFIG_CROSS_CHROMA_TX
+#if CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
cm,
-#endif // CONFIG_CROSS_CHROMA_TX
+#endif // CONFIG_CROSS_CHROMA_TX || CONFIG_ATC_DCTX_ALIGNED
x, plane, block, tx_size, txb_ctx, p, eob, plane_type, coeff_costs, xd,
tx_type,
#if CONFIG_CROSS_CHROMA_TX
@@ -1892,7 +2228,9 @@
return skip_cost;
}
+#if !CONFIG_ATC_DCTX_ALIGNED
const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
+#endif // !CONFIG_ATC_DCTX_ALIGNED
return warehouse_efficients_txb_laplacian(cm, x, plane, block, tx_size,
txb_ctx, eob, plane_type,
@@ -1900,20 +2238,23 @@
#if CONFIG_CROSS_CHROMA_TX
cctx_type,
#endif // CONFIG_CROSS_CHROMA_TX
- tx_class, reduced_tx_set_used);
+#if !CONFIG_ATC_DCTX_ALIGNED
+ tx_class,
+#endif // !CONFIG_ATC_DCTX_ALIGNED
+ reduced_tx_set_used);
}
static AOM_FORCE_INLINE int get_two_coeff_cost_simple(
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
int plane,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
int ci, tran_low_t abs_qc, int coeff_ctx,
const LV_MAP_COEFF_COST *txb_costs, int bwl, TX_CLASS tx_class,
const uint8_t *levels, int *cost_low) {
// this simple version assumes the coeff's scan_idx is not DC (scan_idx != 0)
// and not the last (scan_idx != eob - 1)
assert(ci > 0);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int cost = 0;
@@ -1926,9 +2267,9 @@
}
#else
int cost = txb_costs->base_cost[coeff_ctx][AOMMIN(abs_qc, 3)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
int diff = 0;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
if (abs_qc <= (LF_BASE_SYMBOLS - 1)) {
if (abs_qc == 0) {
@@ -1968,10 +2309,10 @@
}
#else
if (abs_qc <= 3) diff = txb_costs->base_cost[coeff_ctx][abs_qc + 4];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (abs_qc) {
cost += av1_cost_literal(1);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
if (abs_qc > LF_NUM_BASE_LEVELS) {
const int br_ctx = get_br_lf_ctx(levels, ci, bwl, tx_class);
@@ -1997,7 +2338,7 @@
&brcost_diff);
diff += brcost_diff;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
*cost_low = cost - diff;
@@ -2012,13 +2353,13 @@
,
int32_t *tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
int plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
) {
int cost = 0;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2031,7 +2372,7 @@
}
#else
cost += txb_costs->base_eob_cost[coeff_ctx][AOMMIN(abs_qc, 3) - 1];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (abs_qc != 0) {
if (ci == 0) {
#if CONFIG_CONTEXT_DERIVATION
@@ -2052,7 +2393,7 @@
cost += av1_cost_literal(1);
#endif // CONFIG_CONTEXT_DERIVATION
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
if (abs_qc > LF_NUM_BASE_LEVELS) {
int br_ctx;
@@ -2071,7 +2412,7 @@
br_ctx = get_br_ctx_eob(ci, bwl, tx_class);
cost += get_br_cost(abs_qc, txb_costs->lps_cost[br_ctx]);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
return cost;
}
@@ -2086,14 +2427,14 @@
,
int32_t *tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
int plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
) {
int cost = 0;
if (is_last) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2106,9 +2447,9 @@
}
#else
cost += txb_costs->base_eob_cost[coeff_ctx][AOMMIN(abs_qc, 3) - 1];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2121,7 +2462,7 @@
}
#else
cost += txb_costs->base_cost[coeff_ctx][AOMMIN(abs_qc, 3)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
if (abs_qc != 0) {
if (ci == 0) {
@@ -2143,7 +2484,7 @@
cost += av1_cost_literal(1);
#endif // CONFIG_CONTEXT_DERIVATION
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2175,7 +2516,7 @@
br_ctx = get_br_ctx(levels, ci, bwl, tx_class);
cost += get_br_cost(abs_qc, txb_costs->lps_cost[br_ctx]);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
return cost;
}
@@ -2198,9 +2539,9 @@
static INLINE void update_coeff_general(
int *accu_rate, int64_t *accu_dist, int si, int eob,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
TX_CLASS tx_class, int bwl, int height, int64_t rdmult, int shift,
int dc_sign_ctx, const int32_t *dequant, const int16_t *scan,
const LV_MAP_COEFF_COST *txb_costs, const tran_low_t *tcoeff,
@@ -2210,10 +2551,10 @@
,
int32_t *tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
int plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
#if CONFIG_PAR_HIDING
,
coeff_info *coef_info, bool enable_parity_hiding
@@ -2225,17 +2566,17 @@
const int is_last = si == (eob - 1);
const int coeff_ctx =
get_lower_levels_ctx_general(is_last, si, bwl, height, levels, ci,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
tx_class
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
plane
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
if (qc == 0) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2246,7 +2587,7 @@
}
#else
*accu_rate += txb_costs->base_cost[coeff_ctx][0];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
const int sign = (qc < 0) ? 1 : 0;
const tran_low_t abs_qc = abs(qc);
@@ -2261,10 +2602,10 @@
,
tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
const int64_t rd = RDCOST(rdmult, rate, dist);
@@ -2275,7 +2616,7 @@
if (abs_qc == 1) {
abs_qc_low = qc_low = dqc_low = 0;
dist_low = dist0;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2286,7 +2627,7 @@
}
#else
rate_low = txb_costs->base_cost[coeff_ctx][0];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
get_qc_dqc_low(abs_qc, sign, dqv, shift, &qc_low, &dqc_low);
abs_qc_low = abs_qc - 1;
@@ -2298,10 +2639,10 @@
,
tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
}
@@ -2331,9 +2672,9 @@
static AOM_FORCE_INLINE void update_coeff_simple(
int *accu_rate, int si, int eob,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
TX_CLASS tx_class, int bwl, int64_t rdmult, int shift,
const int32_t *dequant, const int16_t *scan,
const LV_MAP_COEFF_COST *txb_costs, const tran_low_t *tcoeff,
@@ -2343,12 +2684,12 @@
,
coeff_info *coef_info, bool enable_parity_hiding
#endif // CONFIG_PAR_HIDING
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
int plane) {
#else
) {
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
const int dqv = get_dqv(dequant, scan[si], iqmatrix);
(void)eob;
// this simple version assumes the coeff's scan_idx is not DC (scan_idx != 0)
@@ -2357,7 +2698,7 @@
assert(si > 0);
const int ci = scan[si];
const tran_low_t qc = qcoeff[ci];
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
@@ -2371,9 +2712,9 @@
#else
const int coeff_ctx =
get_lower_levels_ctx(levels, ci, bwl, tx_size, tx_class);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (qc == 0) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
*accu_rate += txb_costs->base_lf_cost[coeff_ctx][0];
} else {
@@ -2381,16 +2722,16 @@
}
#else
*accu_rate += txb_costs->base_cost[coeff_ctx][0];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
const tran_low_t abs_qc = abs(qc);
const tran_low_t abs_tqc = abs(tcoeff[ci]);
const tran_low_t abs_dqc = abs(dqcoeff[ci]);
int rate_low = 0;
const int rate = get_two_coeff_cost_simple(
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
plane,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
ci, abs_qc, coeff_ctx, txb_costs, bwl, tx_class, levels, &rate_low);
if (abs_dqc < abs_tqc) {
*accu_rate += rate;
@@ -2440,9 +2781,9 @@
static AOM_FORCE_INLINE void update_coeff_eob(
int *accu_rate, int64_t *accu_dist, int *eob, int *nz_num, int *nz_ci,
int si,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TX_SIZE tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
TX_CLASS tx_class, int bwl, int height, int dc_sign_ctx, int64_t rdmult,
int shift, const int32_t *dequant, const int16_t *scan,
const LV_MAP_EOB_COST *txb_eob_costs, const LV_MAP_COEFF_COST *txb_costs,
@@ -2452,10 +2793,10 @@
,
int32_t *tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
int plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
#if CONFIG_PAR_HIDING
,
coeff_info *coef_info, bool enable_parity_hiding
@@ -2465,7 +2806,7 @@
assert(si != *eob - 1);
const int ci = scan[si];
const tran_low_t qc = qcoeff[ci];
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = ci >> bwl;
const int col = ci - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -2478,9 +2819,9 @@
#else
const int coeff_ctx =
get_lower_levels_ctx(levels, ci, bwl, tx_size, tx_class);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
if (qc == 0) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
*accu_rate += txb_costs->base_lf_cost[coeff_ctx][0];
} else {
@@ -2488,7 +2829,7 @@
}
#else
*accu_rate += txb_costs->base_cost[coeff_ctx][0];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
#if CONFIG_PAR_HIDING
int64_t rd_eob_low = INT64_MAX >> 1;
@@ -2508,10 +2849,10 @@
,
tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
int64_t rd = RDCOST(rdmult, *accu_rate + rate, *accu_dist + dist);
@@ -2523,7 +2864,7 @@
abs_qc_low = 0;
dqc_low = qc_low = 0;
dist_low = 0;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
if (limits) {
rate_low = txb_costs->base_lf_cost[coeff_ctx][0];
} else {
@@ -2531,7 +2872,7 @@
}
#else
rate_low = txb_costs->base_cost[coeff_ctx][0];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
rd_low = RDCOST(rdmult, *accu_rate + rate_low, *accu_dist);
} else {
get_qc_dqc_low(abs_qc, sign, dqv, shift, &qc_low, &dqc_low);
@@ -2544,10 +2885,10 @@
,
tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
rd_low = RDCOST(rdmult, *accu_rate + rate_low, *accu_dist + dist_low);
}
@@ -2559,7 +2900,11 @@
const int new_eob = si + 1;
const int coeff_ctx_new_eob = get_lower_levels_ctx_eob(bwl, height, si);
const int new_eob_cost =
+#if CONFIG_ATC_DCTX_ALIGNED
+ get_eob_cost(new_eob, txb_eob_costs, txb_costs);
+#else
get_eob_cost(new_eob, txb_eob_costs, txb_costs, tx_class);
+#endif // CONFIG_ATC_DCTX_ALIGNED
int rate_coeff_eob =
new_eob_cost + get_coeff_cost_eob(ci, abs_qc, sign, coeff_ctx_new_eob,
dc_sign_ctx, txb_costs, bwl, tx_class
@@ -2567,10 +2912,10 @@
,
tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
int64_t dist_new_eob = dist;
int64_t rd_new_eob = RDCOST(rdmult, rate_coeff_eob, dist_new_eob);
@@ -2587,10 +2932,10 @@
,
tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
const int64_t dist_new_eob_low = dist_low;
const int64_t rd_new_eob_low =
@@ -2682,14 +3027,14 @@
tran_low_t level, int bwl, int pos,
uint8_t *levels, int dc_sign_ctx,
TX_CLASS tx_class, int *rate
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
,
TX_SIZE tx_size
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
) {
tran_low_t abslevel = abs(level), q_index = abslevel >> 1;
int sign = level < 0;
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, 0);
@@ -2702,17 +3047,17 @@
#else
const int coeff_ctx =
get_lower_levels_ctx(levels, pos, bwl, tx_size, tx_class);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
*rate = get_coeff_cost_general(0, pos, abslevel, level < 0, coeff_ctx,
dc_sign_ctx, txb_costs, bwl, tx_class, levels
#if CONFIG_CONTEXT_DERIVATION
,
0
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
0
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
const int base_ctx_ph = get_base_ctx_ph(levels, pos, bwl, tx_class);
@@ -2898,10 +3243,10 @@
const qm_val_t *iqmatrix, int dc_sign_ctx, const TX_CLASS tx_class,
tran_low_t *qcoeff, tran_low_t *dqcoeff, const tran_low_t *tcoeff,
coeff_info *coef_info, int *accu_rate
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
,
TX_SIZE tx_size
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
) {
int nzsbb = 0, sum_abs1 = 0;
for (int scan_idx = eob - 1; scan_idx > 0; --scan_idx) {
@@ -2922,10 +3267,10 @@
const int ratesaving =
rate_save(txb_costs, txb_costs_ph, qcoeff[hidepos], bwl, hidepos, levels,
dc_sign_ctx, tx_class, &rate_cur
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
,
tx_size
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
if (!needtune && nzsbb >= PHTHRESH) {
@@ -3009,6 +3354,12 @@
const int height = get_txb_high(tx_size);
assert(width == (1 << bwl));
const int is_inter = is_inter_block(mbmi, xd->tree_type);
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob_code = p->bobs[block];
+ const int is_fsc = (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] &&
+ plane == PLANE_TYPE_Y) ||
+ use_inter_fsc(&cpi->common, plane, tx_type, is_inter);
+#endif // CONFIG_ATC_DCTX_ALIGNED
const LV_MAP_COEFF_COST *txb_costs =
&coeff_costs->coeff_costs[txs_ctx][plane_type];
const int eob_multi_size = txsize_log2_minus4[tx_size];
@@ -3068,7 +3419,11 @@
const int non_skip_cost = txb_costs->txb_skip_cost[txb_ctx->txb_skip_ctx][0];
const int skip_cost = txb_costs->txb_skip_cost[txb_ctx->txb_skip_ctx][1];
#endif // CONFIG_CONTEXT_DERIVATION
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int eob_cost = get_eob_cost(eob, txb_eob_costs, txb_costs);
+#else
const int eob_cost = get_eob_cost(eob, txb_eob_costs, txb_costs, tx_class);
+#endif // CONFIG_ATC_DCTX_ALIGNED
int accu_rate = eob_cost;
int64_t accu_dist = 0;
int si = eob - 1;
@@ -3081,9 +3436,9 @@
int nz_ci[3] = { ci, 0, 0 };
if (abs_qc >= 2) {
update_coeff_general(&accu_rate, &accu_dist, si, eob,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
tx_class, bwl, height, rdmult, shift,
txb_ctx->dc_sign_ctx, dequant, scan, txb_costs, tcoeff,
qcoeff, dqcoeff, levels, iqmatrix
@@ -3091,10 +3446,10 @@
,
xd->tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
#if CONFIG_PAR_HIDING
,
coef_info, enable_parity_hiding
@@ -3111,10 +3466,10 @@
,
xd->tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
);
const tran_low_t tqc = tcoeff[ci];
const tran_low_t dqc = dqcoeff[ci];
@@ -3126,9 +3481,9 @@
#if CONFIG_PAR_HIDING
for (; si >= 0 && nz_num <= max_nz_num; --si) {
update_coeff_eob(&accu_rate, &accu_dist, &eob, &nz_num, nz_ci, si,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
tx_size,
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
tx_class, bwl, height, txb_ctx->dc_sign_ctx, rdmult, shift,
dequant, scan, txb_eob_costs, txb_costs, tcoeff, qcoeff,
dqcoeff, levels, sharpness, iqmatrix
@@ -3136,16 +3491,16 @@
,
xd->tmp_sign
#endif
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
coef_info, enable_parity_hiding);
}
#else
#if CONFIG_CONTEXT_DERIVATION
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
#define UPDATE_COEFF_EOB_CASE(tx_class_literal) \
case tx_class_literal: \
for (; si >= 0 && nz_num <= max_nz_num; --si) { \
@@ -3167,7 +3522,7 @@
levels, sharpness, iqmatrix, xd->tmp_sign, plane); \
} \
break;
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#else
#define UPDATE_COEFF_EOB_CASE(tx_class_literal) \
case tx_class_literal: \
@@ -3197,20 +3552,20 @@
#if CONFIG_PAR_HIDING
for (; si >= 1; --si) {
update_coeff_simple(&accu_rate, si, eob,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
tx_class, bwl, rdmult, shift, dequant, scan, txb_costs,
tcoeff, qcoeff, dqcoeff, levels, iqmatrix, coef_info,
enable_parity_hiding
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
plane
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
}
#else
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
#define UPDATE_COEFF_SIMPLE_CASE(tx_class_literal) \
case tx_class_literal: \
for (; si >= 1; --si) { \
@@ -3242,7 +3597,7 @@
#undef UPDATE_COEFF_SIMPLE_CASE
default: assert(false);
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#endif // CONFIG_PAR_HIDING
// DC position
@@ -3250,9 +3605,9 @@
// no need to update accu_dist because it's not used after this point
int64_t dummy_dist = 0;
update_coeff_general(&accu_rate, &dummy_dist, si, eob,
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
tx_size,
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
tx_class, bwl, height, rdmult, shift,
txb_ctx->dc_sign_ctx, dequant, scan, txb_costs, tcoeff,
qcoeff, dqcoeff, levels, iqmatrix
@@ -3260,10 +3615,10 @@
,
xd->tmp_sign
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#if CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
,
plane
-#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC_COEFCODING
+#endif // CONFIG_CONTEXT_DERIVATION || CONFIG_ATC
#if CONFIG_PAR_HIDING
,
coef_info, enable_parity_hiding
@@ -3276,16 +3631,30 @@
parity_hide_tb(eob, scan, levels, bwl, rdmult, shift, txb_costs,
txb_costs_ph, dequant, iqmatrix, txb_ctx->dc_sign_ctx,
tx_class, qcoeff, dqcoeff, tcoeff, coef_info, &accu_rate
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
,
tx_size
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
}
aom_free(coef_info);
#endif // CONFIG_PAR_HIDING
+#if CONFIG_ATC_DCTX_ALIGNED
+ set_bob(x, plane, block, tx_size, tx_type);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (eob == 0) {
+ accu_rate += skip_cost;
+ } else {
+ const int tx_type_cost = get_tx_type_cost(x, xd, plane, tx_size, tx_type,
+ cm->features.reduced_tx_set_used,
+ eob, bob_code, is_fsc);
+ accu_rate += non_skip_cost + tx_type_cost;
+ }
+#else
const int tx_type_cost = get_tx_type_cost(
x, xd, plane, tx_size, tx_type, cm->features.reduced_tx_set_used, eob);
@@ -3293,6 +3662,7 @@
accu_rate += skip_cost;
else
accu_rate += non_skip_cost + tx_type_cost;
+#endif // CONFIG_ATC_DCTX_ALIGNED
p->eobs[block] = eob;
p->txb_entropy_ctx[block] =
@@ -3360,7 +3730,12 @@
MACROBLOCKD *xd, int blk_row, int blk_col,
int plane, TX_SIZE tx_size,
FRAME_COUNTS *counts, uint8_t allow_update_cdf,
- int eob) {
+ int eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ int bob_code, int is_fsc
+#endif // CONFIG_ATC_DCTX_ALIGNED
+) {
MB_MODE_INFO *mbmi = xd->mi[0];
int is_inter = is_inter_block(mbmi, xd->tree_type);
const int reduced_tx_set_used = cm->features.reduced_tx_set_used;
@@ -3397,19 +3772,39 @@
const TxSetType tx_set_type =
av1_get_ext_tx_set_type(tx_size, is_inter, reduced_tx_set_used);
if (is_inter) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int esc_eob = is_fsc ? bob_code : eob;
+ const int eob_tx_ctx =
+ get_lp2tx_ctx(tx_size, get_txb_bwl(tx_size), esc_eob);
+ if (allow_update_cdf) {
+ update_cdf(
+ fc->inter_ext_tx_cdf[eset][eob_tx_ctx][txsize_sqr_map[tx_size]],
+ av1_ext_tx_ind[tx_set_type][tx_type],
+ av1_num_ext_tx_set[tx_set_type]);
+ }
+#else
if (allow_update_cdf) {
update_cdf(fc->inter_ext_tx_cdf[eset][txsize_sqr_map[tx_size]],
av1_ext_tx_ind[tx_set_type][tx_type],
av1_num_ext_tx_set[tx_set_type]);
}
+#endif // CONFIG_ATC_DCTX_ALIGNED
#if CONFIG_ENTROPY_STATS
+#if CONFIG_ATC_DCTX_ALIGNED
+ ++counts->inter_ext_tx[eset][eob_tx_ctx][txsize_sqr_map[tx_size]]
+ [av1_ext_tx_ind[tx_set_type][tx_type]];
+#else
++counts->inter_ext_tx[eset][txsize_sqr_map[tx_size]]
[av1_ext_tx_ind[tx_set_type][tx_type]];
+#endif // CONFIG_ATC_DCTX_ALIGNED
#endif // CONFIG_ENTROPY_STATS
} else {
if (mbmi->fsc_mode[xd->tree_type == CHROMA_PART] && allow_update_cdf) {
return;
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (eob == 1 && allow_update_cdf) return;
+#endif // CONFIG_ATC_DCTX_ALIGNED
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
intra_dir = fimode_to_intradir[mbmi->filter_intra_mode_info
@@ -3418,7 +3813,7 @@
intra_dir = mbmi->mode;
#if CONFIG_ENTROPY_STATS
const TX_TYPE primary_tx_type = get_primary_tx_type(tx_type);
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
++counts->intra_ext_tx[eset][txsize_sqr_map[tx_size]][intra_dir]
[av1_tx_type_to_idx(primary_tx_type, tx_set_type,
intra_dir,
@@ -3427,7 +3822,7 @@
++counts->intra_ext_tx[eset][txsize_sqr_map[tx_size]][intra_dir]
[av1_ext_tx_ind_intra[tx_set_type]
[primary_tx_type]];
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
#endif // CONFIG_ENTROPY_STATS
if (allow_update_cdf) {
update_cdf(
@@ -3437,12 +3832,12 @@
#else
fc->intra_ext_tx_cdf[eset][txsize_sqr_map[tx_size]][intra_dir],
#endif // CONFIG_ATC_REDUCED_TXSET
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
av1_tx_type_to_idx(get_primary_tx_type(tx_type), tx_set_type,
intra_dir, av1_size_class[tx_size]),
#else
av1_ext_tx_ind_intra[tx_set_type][get_primary_tx_type(tx_type)],
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
#if CONFIG_ATC_REDUCED_TXSET
cm->features.reduced_tx_set_used
? av1_num_reduced_tx_set
@@ -3465,6 +3860,9 @@
!segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) &&
cm->seq_params.enable_ist &&
block_signals_sec_tx_type(xd, tx_size, tx_type, eob)) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (eob == 1 && allow_update_cdf) return;
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (allow_update_cdf)
update_cdf(fc->stx_cdf[txsize_sqr_map[tx_size]],
(int8_t)get_secondary_tx_type(tx_type), STX_TYPES);
@@ -3483,6 +3881,9 @@
struct macroblock_plane *p = &x->plane[plane];
struct macroblockd_plane *pd = &xd->plane[plane];
const int eob = p->eobs[block];
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob_code = p->bobs[block];
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int block_offset = BLOCK_OFFSET(block);
tran_low_t *qcoeff = p->qcoeff + block_offset;
const PLANE_TYPE plane_type = pd->plane_type;
@@ -3520,6 +3921,11 @@
uint8_t *const entropy_ctx = cb_coef_buff->entropy_ctx[plane] + txb_offset;
entropy_ctx[block] = txb_ctx.txb_skip_ctx;
eob_txb[block] = eob;
+#if CONFIG_ATC_DCTX_ALIGNED
+ uint16_t *bob_txb = cb_coef_buff->bobs[plane] + txb_offset;
+ bob_txb[block] = bob_code;
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
if (eob == 0) {
av1_set_entropy_contexts(xd, pd, plane, plane_bsize, tx_size, 0, blk_col,
blk_row);
@@ -3539,23 +3945,67 @@
int8_t *const signs = set_signs(signs_buf, width);
av1_txb_init_levels_signs(tcoeff, width, height, levels_buf, signs_buf);
update_tx_type_count(cpi, cm, xd, blk_row, blk_col, plane, tx_size,
- td->counts, allow_update_cdf, eob);
+ td->counts, allow_update_cdf, eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ bob_code, 1 /* is_fsc */
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ );
const int16_t *const scan = scan_order->scan;
// record tx type usage
td->rd_counts.tx_type_used[tx_size][get_primary_tx_type(tx_type)]++;
+#if CONFIG_ATC_DCTX_ALIGNED
+ int bob = av1_get_max_eob(tx_size) - bob_code;
+#if CONFIG_ENTROPY_STATS
+ av1_update_eob_context(cdf_idx, bob_code, tx_size, plane_type, ec_ctx,
+ td->counts, allow_update_cdf);
+#else
+ av1_update_eob_context(bob_code, tx_size, plane_type, ec_ctx,
+ allow_update_cdf);
+#endif
+#endif // CONFIG_ATC_DCTX_ALIGNED
DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
+#if CONFIG_ATC_DCTX_ALIGNED
+ av1_get_nz_map_contexts_skip_c(levels, scan, bob, eob, tx_size,
+ coeff_contexts);
+#else
av1_get_nz_map_contexts_skip(levels, scan, eob, tx_size, coeff_contexts);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+#if CONFIG_ATC_DCTX_ALIGNED
+ for (int c = bob; c < eob; ++c) {
+#else
for (int c = 0; c < eob; c++) {
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int pos = scan[c];
const int coeff_ctx = coeff_contexts[pos];
const tran_low_t v = qcoeff[pos];
const tran_low_t level = abs(v);
if (allow_update_cdf) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (c == bob) {
+ update_cdf(ec_ctx->coeff_base_bob_cdf[coeff_ctx],
+ AOMMIN(level, 3) - 1, 3);
+ } else {
+ update_cdf(ec_ctx->coeff_base_cdf_idtx[coeff_ctx], AOMMIN(level, 3),
+ 4);
+ }
+#else
update_cdf(ec_ctx->coeff_base_cdf_idtx[coeff_ctx], AOMMIN(level, 3), 4);
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
#if CONFIG_ENTROPY_STATS
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (c == bob) {
+ ++td->counts
+ ->coeff_base_bob_multi[cdf_idx][coeff_ctx][AOMMIN(level, 3) - 1];
+ } else {
+ ++td->counts
+ ->coeff_base_multi_skip[cdf_idx][coeff_ctx][AOMMIN(level, 3)];
+ }
+#else
++td->counts->coeff_base_multi_skip[cdf_idx][coeff_ctx][AOMMIN(level, 3)];
-#endif // CONFIG_ENTROPY_STATS
+#endif // CONFIG_ATC_DCTX_ALIGNED
+#endif
if (level > NUM_BASE_LEVELS) {
const int base_range = level - 1 - NUM_BASE_LEVELS;
const int br_ctx = get_br_ctx_skip(levels, pos, bwl);
@@ -3650,9 +4100,19 @@
struct macroblock_plane *p = &x->plane[plane];
struct macroblockd_plane *pd = &xd->plane[plane];
const int eob = p->eobs[block];
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int bob_code = p->bobs[block];
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int block_offset = BLOCK_OFFSET(block);
tran_low_t *qcoeff = p->qcoeff + block_offset;
const PLANE_TYPE plane_type = pd->plane_type;
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
+ if (eob == 1 && plane_type == 0 &&
+ !xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] && !is_inter) {
+ update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
const TX_TYPE tx_type =
av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size,
cm->features.reduced_tx_set_used);
@@ -3737,9 +4197,22 @@
uint8_t *const entropy_ctx = cb_coef_buff->entropy_ctx[plane] + txb_offset;
entropy_ctx[block] = txb_ctx.txb_skip_ctx;
eob_txb[block] = eob;
+#if CONFIG_ATC_DCTX_ALIGNED
+ uint16_t *bob_txb = cb_coef_buff->bobs[plane] + txb_offset;
+ bob_txb[block] = bob_code;
+#endif // CONFIG_ATC_DCTX_ALIGNED
#if CONFIG_CROSS_CHROMA_TX
- if (is_cctx_allowed(cm, xd) && plane == AOM_PLANE_U && eob > 0)
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int skip_cctx = is_inter ? 0 : (eob == 1);
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ if (is_cctx_allowed(cm, xd) && plane == AOM_PLANE_U &&
+#if CONFIG_ATC_DCTX_ALIGNED
+ !skip_cctx && eob > 0
+#else
+ eob > 0
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ )
update_cctx_type_count(cm, xd, blk_row, blk_col, tx_size, td->counts,
allow_update_cdf);
#endif // CONFIG_CROSS_CHROMA_TX
@@ -3759,7 +4232,12 @@
uint8_t *const levels = set_levels(levels_buf, width);
av1_txb_init_levels(tcoeff, width, height, levels);
update_tx_type_count(cpi, cm, xd, blk_row, blk_col, plane, tx_size,
- td->counts, allow_update_cdf, eob);
+ td->counts, allow_update_cdf, eob
+#if CONFIG_ATC_DCTX_ALIGNED
+ ,
+ bob_code, 0 /* is_fsc */
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ );
const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
const int16_t *const scan = scan_order->scan;
@@ -3768,19 +4246,25 @@
td->rd_counts.tx_type_used[tx_size][get_primary_tx_type(tx_type)]++;
#if CONFIG_ENTROPY_STATS
- av1_update_eob_context(cdf_idx, eob, tx_size, tx_class, plane_type, ec_ctx,
- td->counts, allow_update_cdf);
+ av1_update_eob_context(cdf_idx, eob, tx_size,
+#if !CONFIG_ATC_DCTX_ALIGNED
+ tx_class,
+#endif // !CONFIG_ATC_DCTX_ALIGNED
+ plane_type, ec_ctx, td->counts, allow_update_cdf);
#else
- av1_update_eob_context(eob, tx_size, tx_class, plane_type, ec_ctx,
- allow_update_cdf);
+ av1_update_eob_context(eob, tx_size,
+#if !CONFIG_ATC_DCTX_ALIGNED
+ tx_class,
+#endif // !CONFIG_ATC_DCTX_ALIGNED
+ plane_type, ec_ctx, allow_update_cdf);
#endif
DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
av1_get_nz_map_contexts(levels, scan, eob, tx_size, tx_class, coeff_contexts
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
,
plane
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
);
#if CONFIG_PAR_HIDING
bool enable_parity_hiding = cm->features.allow_parity_hiding &&
@@ -3799,7 +4283,7 @@
if (allow_update_cdf) {
if (c == eob - 1) {
assert(coeff_ctx < 4);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -3818,9 +4302,9 @@
update_cdf(
ec_ctx->coeff_base_eob_cdf[txsize_ctx][plane_type][coeff_ctx],
AOMMIN(level, 3) - 1, 3);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -3836,14 +4320,14 @@
#else
update_cdf(ec_ctx->coeff_base_cdf[txsize_ctx][plane_type][coeff_ctx],
AOMMIN(level, 3), 4);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
}
if (c == eob - 1) {
assert(coeff_ctx < 4);
assert(level > 0);
#if CONFIG_ENTROPY_STATS
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -3858,9 +4342,9 @@
#else
++td->counts->coeff_base_eob_multi[cdf_idx][txsize_ctx][plane_type]
[coeff_ctx][AOMMIN(level, 3) - 1];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -3875,10 +4359,10 @@
#else
++td->counts->coeff_base_multi[cdf_idx][txsize_ctx][plane_type]
[coeff_ctx][AOMMIN(level, 3)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#endif
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -3953,7 +4437,7 @@
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
#if CONFIG_PAR_HIDING
@@ -3986,7 +4470,7 @@
if (allow_update_cdf) {
if (c == eob - 1) {
assert(coeff_ctx < 4);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -4004,9 +4488,9 @@
update_cdf(
ec_ctx->coeff_base_eob_cdf[txsize_ctx][plane_type][coeff_ctx],
AOMMIN(level, 3) - 1, 3);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -4022,13 +4506,13 @@
#else
update_cdf(ec_ctx->coeff_base_cdf[txsize_ctx][plane_type][coeff_ctx],
AOMMIN(level, 3), 4);
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
}
if (c == eob - 1) {
assert(coeff_ctx < 4);
#if CONFIG_ENTROPY_STATS
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -4043,9 +4527,9 @@
#else
++td->counts->coeff_base_eob_multi[cdf_idx][txsize_ctx][plane_type]
[coeff_ctx][AOMMIN(level, 3) - 1];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -4060,10 +4544,10 @@
#else
++td->counts->coeff_base_multi[cdf_idx][txsize_ctx][plane_type]
[coeff_ctx][AOMMIN(level, 3)];
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
#endif
}
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
const int row = pos >> bwl;
const int col = pos - (row << bwl);
int limits = get_lf_limits(row, col, tx_class, plane);
@@ -4138,7 +4622,7 @@
if (k < BR_CDF_SIZE - 1) break;
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
}
#endif // CONFIG_PAR_HIDING
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 6c669ac..a1d0de8 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -27,10 +27,6 @@
for (int i = 0; i < REFERENCE_MODES; i++)
td->rd_counts.comp_pred_diff[i] += td_t->rd_counts.comp_pred_diff[i];
- for (int i = 0; i < INTER_REFS_PER_FRAME; i++)
- td->rd_counts.global_motion_used[i] +=
- td_t->rd_counts.global_motion_used[i];
-
td->rd_counts.compound_ref_used_flag |=
td_t->rd_counts.compound_ref_used_flag;
td->rd_counts.skip_mode_used_flag |= td_t->rd_counts.skip_mode_used_flag;
@@ -470,7 +466,7 @@
&td->mb.txfm_search_info.mb_rd_record.crc_calculator);
#if CONFIG_REF_MV_BANK
av1_zero(td->mb.e_mbd.ref_mv_bank);
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
td->mb.e_mbd.ref_mv_bank_pt = &td->mb.e_mbd.ref_mv_bank;
#endif
#endif // CONFIG_REF_MV_BANK}
@@ -679,7 +675,7 @@
if (i > 0) {
// Set up firstpass PICK_MODE_CONTEXT.
thread_data->td->firstpass_ctx = av1_alloc_pmc(
- cm, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
+ cm, SHARED_PART, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
&thread_data->td->shared_coeff_buf);
@@ -814,7 +810,7 @@
}
#if CONFIG_REF_MV_BANK
av1_zero(thread_data->td->mb.e_mbd.ref_mv_bank);
-#if !CONFIG_C043_MVP_IMPROVEMENTS
+#if !CONFIG_MVP_IMPROVEMENT
thread_data->td->mb.e_mbd.ref_mv_bank_pt =
&thread_data->td->mb.e_mbd.ref_mv_bank;
@@ -1431,7 +1427,7 @@
// source_alt_ref_frame w.r.t. ARF frames.
if (cpi->sf.gm_sf.prune_ref_frame_for_gm_search &&
gm_info->reference_frames[cur_dir][ref_frame_idx].distance != 0 &&
- cpi->common.global_motion[ref_buf_idx].wmtype != ROTZOOM)
+ cpi->common.global_motion[ref_buf_idx].wmtype <= TRANSLATION)
job_info->early_exit[cur_dir] = 1;
#if CONFIG_MULTITHREAD
diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c
index cf7332c..9d3f5dc 100644
--- a/av1/encoder/firstpass.c
+++ b/av1/encoder/firstpass.c
@@ -221,7 +221,7 @@
}
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = cm->features.fr_mv_precision;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -230,7 +230,7 @@
#if CONFIG_FLEX_MVRES
av1_make_default_fullpel_ms_params(
&ms_params, cpi, x, bsize, ref_mv, pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
first_pass_search_sites, fine_search_interval);
@@ -688,6 +688,9 @@
xd->mi[0]->tx_size = TX_4X4;
xd->mi[0]->ref_frame[0] = get_closest_pastcur_ref_index(cm);
xd->mi[0]->ref_frame[1] = NONE_FRAME;
+#if CONFIG_CWP
+ xd->mi[0]->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
av1_enc_build_inter_predictor(cm, xd, mb_row * mb_scale, mb_col * mb_scale,
NULL, bsize, AOM_PLANE_Y, AOM_PLANE_Y);
av1_encode_sby_pass1(cpi, x, bsize);
@@ -984,6 +987,9 @@
x->plane[i].coeff = ctx->coeff[i];
x->plane[i].qcoeff = ctx->qcoeff[i];
x->plane[i].eobs = ctx->eobs[i];
+#if CONFIG_ATC_DCTX_ALIGNED
+ x->plane[i].bobs = ctx->bobs[i];
+#endif // CONFIG_ATC_DCTX_ALIGNED
x->plane[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i];
x->plane[i].dqcoeff = ctx->dqcoeff[i];
}
@@ -1087,14 +1093,8 @@
cpi->is_screen_content_type = features->allow_screen_content_tools;
}
#if CONFIG_ADAPTIVE_DS_FILTER
-#if DS_FRAME_LEVEL
- if (cm->current_frame.frame_type == KEY_FRAME) {
- FeatureFlags *const features = &cm->features;
- av1_set_downsample_filter_options(cpi, features);
-#else
- if (cpi->common.current_frame.absolute_poc == 0) {
+ if (cpi->common.current_frame.frame_type == KEY_FRAME) {
av1_set_downsample_filter_options(cpi);
-#endif // DS_FRAME_LEVEL
}
#endif // CONFIG_ADAPTIVE_DS_FILTER
// First pass coding proceeds in raster scan order with unit size of 16x16.
diff --git a/av1/encoder/global_motion.c b/av1/encoder/global_motion.c
index 1f07c20..c3495e1 100644
--- a/av1/encoder/global_motion.c
+++ b/av1/encoder/global_motion.c
@@ -72,7 +72,9 @@
static void convert_to_params(const double *params, int32_t *model) {
int i;
+#if !CONFIG_IMPROVED_GLOBAL_MOTION
int alpha_present = 0;
+#endif // !CONFIG_IMPROVED_GLOBAL_MOTION
model[0] = (int32_t)floor(params[0] * (1 << GM_TRANS_PREC_BITS) + 0.5);
model[1] = (int32_t)floor(params[1] * (1 << GM_TRANS_PREC_BITS) + 0.5);
model[0] = (int32_t)clamp(model[0], GM_TRANS_MIN, GM_TRANS_MAX) *
@@ -85,22 +87,28 @@
model[i] = (int32_t)floor(params[i] * (1 << GM_ALPHA_PREC_BITS) + 0.5);
model[i] =
(int32_t)clamp(model[i] - diag_value, GM_ALPHA_MIN, GM_ALPHA_MAX);
+#if !CONFIG_IMPROVED_GLOBAL_MOTION
alpha_present |= (model[i] != 0);
+#endif // !CONFIG_IMPROVED_GLOBAL_MOTION
model[i] = (model[i] + diag_value) * GM_ALPHA_DECODE_FACTOR;
}
for (; i < 8; ++i) {
model[i] = (int32_t)floor(params[i] * (1 << GM_ROW3HOMO_PREC_BITS) + 0.5);
model[i] = (int32_t)clamp(model[i], GM_ROW3HOMO_MIN, GM_ROW3HOMO_MAX) *
GM_ROW3HOMO_DECODE_FACTOR;
+#if !CONFIG_IMPROVED_GLOBAL_MOTION
alpha_present |= (model[i] != 0);
+#endif // !CONFIG_IMPROVED_GLOBAL_MOTION
}
+#if !CONFIG_IMPROVED_GLOBAL_MOTION
if (!alpha_present) {
if (abs(model[0]) < MIN_TRANS_THRESH && abs(model[1]) < MIN_TRANS_THRESH) {
model[0] = 0;
model[1] = 0;
}
}
+#endif // !CONFIG_IMPROVED_GLOBAL_MOTION
}
void av1_convert_model_to_params(const double *params,
diff --git a/av1/encoder/global_motion_facade.c b/av1/encoder/global_motion_facade.c
index 7e28cab..8180bf4 100644
--- a/av1/encoder/global_motion_facade.c
+++ b/av1/encoder/global_motion_facade.c
@@ -30,11 +30,38 @@
const WarpedMotionParams *ref_gm,
MvSubpelPrecision precision) {
const int precision_loss = get_gm_precision_loss(precision);
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ (void)precision_loss;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
#else
const WarpedMotionParams *ref_gm, int allow_hp) {
-#endif
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ (void)allow_hp;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+#endif // CONFIG_FLEX_MVRES
int params_cost = 0;
- int trans_bits, trans_prec_diff;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ const int trans_bits = GM_ABS_TRANS_BITS;
+ const int trans_prec_diff = GM_TRANS_PREC_DIFF;
+ const int trans_max = (1 << trans_bits) - 1;
+#else
+ const int trans_bits = (gm->wmtype == TRANSLATION)
+#if CONFIG_FLEX_MVRES
+ ? GM_ABS_TRANS_ONLY_BITS - precision_loss
+#else
+ ? GM_ABS_TRANS_ONLY_BITS - !allow_hp
+#endif
+ : GM_ABS_TRANS_BITS;
+ const int trans_prec_diff = (gm->wmtype == TRANSLATION)
+#if CONFIG_FLEX_MVRES
+ ? GM_TRANS_ONLY_PREC_DIFF + precision_loss
+#else
+ ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp
+#endif
+ : GM_TRANS_PREC_DIFF;
+ const int trans_max = (1 << trans_bits);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
switch (gm->wmtype) {
case AFFINE:
case ROTZOOM:
@@ -57,29 +84,11 @@
(1 << GM_ALPHA_PREC_BITS),
(gm->wmmat[5] >> GM_ALPHA_PREC_DIFF) - (1 << GM_ALPHA_PREC_BITS));
}
- AOM_FALLTHROUGH_INTENDED;
- case TRANSLATION:
- trans_bits = (gm->wmtype == TRANSLATION)
-#if CONFIG_FLEX_MVRES
- ? GM_ABS_TRANS_ONLY_BITS - precision_loss
-#else
- ? GM_ABS_TRANS_ONLY_BITS - !allow_hp
-#endif
- : GM_ABS_TRANS_BITS;
- trans_prec_diff = (gm->wmtype == TRANSLATION)
-#if CONFIG_FLEX_MVRES
- ? GM_TRANS_ONLY_PREC_DIFF + precision_loss
-#else
- ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp
-#endif
- : GM_TRANS_PREC_DIFF;
params_cost += aom_count_signed_primitive_refsubexpfin(
- (1 << trans_bits) + 1, SUBEXPFIN_K,
- (ref_gm->wmmat[0] >> trans_prec_diff),
+ trans_max + 1, SUBEXPFIN_K, (ref_gm->wmmat[0] >> trans_prec_diff),
(gm->wmmat[0] >> trans_prec_diff));
params_cost += aom_count_signed_primitive_refsubexpfin(
- (1 << trans_bits) + 1, SUBEXPFIN_K,
- (ref_gm->wmmat[1] >> trans_prec_diff),
+ trans_max + 1, SUBEXPFIN_K, (ref_gm->wmmat[1] >> trans_prec_diff),
(gm->wmmat[1] >> trans_prec_diff));
AOM_FALLTHROUGH_INTENDED;
case IDENTITY: break;
@@ -95,16 +104,28 @@
// For the given reference frame, computes the global motion parameters for
// different motion models and finds the best.
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+static AOM_INLINE void compute_global_motion_for_ref_frame(
+ AV1_COMP *cpi, YV12_BUFFER_CONFIG *ref_buf[INTER_REFS_PER_FRAME], int frame,
+ int num_src_corners, int *src_corners, unsigned char *src_buffer,
+ MotionModel *params_by_motion, uint8_t *segment_map,
+ const int segment_map_w, const int segment_map_h) {
+#else
static AOM_INLINE void compute_global_motion_for_ref_frame(
AV1_COMP *cpi, YV12_BUFFER_CONFIG *ref_buf[INTER_REFS_PER_FRAME], int frame,
int num_src_corners, int *src_corners, unsigned char *src_buffer,
MotionModel *params_by_motion, uint8_t *segment_map,
const int segment_map_w, const int segment_map_h,
const WarpedMotionParams *ref_params) {
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
ThreadData *const td = &cpi->td;
MACROBLOCK *const x = &td->mb;
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ GlobalMotionInfo *const gm_info = &cpi->gm_info;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
int i;
int src_width = cpi->source->y_width;
int src_height = cpi->source->y_height;
@@ -125,16 +146,21 @@
// TODO(sarahparker, debargha): Explore do_adaptive_gm_estimation = 1
const int do_adaptive_gm_estimation = 0;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_frame_dist = get_relative_dist(
+ &cm->seq_params.order_hint_info, cm->current_frame.display_order_hint,
+ cm->cur_frame->ref_display_order_hint[frame]);
+#else
const int ref_frame_dist = get_relative_dist(
&cm->seq_params.order_hint_info, cm->current_frame.order_hint,
cm->cur_frame->ref_order_hints[frame]);
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const GlobalMotionEstimationType gm_estimation_type =
cm->seq_params.order_hint_info.enable_order_hint &&
abs(ref_frame_dist) <= 2 && do_adaptive_gm_estimation
? GLOBAL_MOTION_DISFLOW_BASED
: GLOBAL_MOTION_FEATURE_BASED;
for (model = ROTZOOM; model < GLOBAL_TRANS_TYPES_ENC; ++model) {
- int64_t best_warp_error = INT64_MAX;
// Initially set all params to identity.
for (i = 0; i < RANSAC_NUM_MOTIONS; ++i) {
memcpy(params_by_motion[i].params, kIdentityParams,
@@ -147,48 +173,82 @@
ref_buf[frame], cpi->common.seq_params.bit_depth,
gm_estimation_type, inliers_by_motion,
params_by_motion, RANSAC_NUM_MOTIONS);
- int64_t ref_frame_error = 0;
+
+ int64_t best_ref_frame_error = 0;
+ int64_t best_warp_error = INT64_MAX;
for (i = 0; i < RANSAC_NUM_MOTIONS; ++i) {
if (inliers_by_motion[i] == 0) continue;
params_this_motion = params_by_motion[i].params;
av1_convert_model_to_params(params_this_motion, &tmp_wm_params);
- if (tmp_wm_params.wmtype != IDENTITY) {
- av1_compute_feature_segmentation_map(
- segment_map, segment_map_w, segment_map_h,
- params_by_motion[i].inliers, params_by_motion[i].num_inliers);
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // If the found model can be represented as a simple translation,
+ // then reject it. This is because translational motion is cheaper
+ // to signal through the standard MV coding tools, rather than through
+ // global motion
+ if (tmp_wm_params.wmtype <= TRANSLATION) continue;
+#else
+ // For IDENTITY type models, we don't need to evaluate anything because
+ // all the following logic is effectively comparing the estimated model
+ // to an identity model.
+ if (tmp_wm_params.wmtype == IDENTITY) continue;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
- ref_frame_error = av1_segmented_frame_error(
- xd->bd, ref_buf[frame]->y_buffer, ref_buf[frame]->y_stride,
- cpi->source->y_buffer, src_width, src_height, src_stride,
- segment_map, segment_map_w);
+ av1_compute_feature_segmentation_map(
+ segment_map, segment_map_w, segment_map_h,
+ params_by_motion[i].inliers, params_by_motion[i].num_inliers);
- const int64_t erroradv_threshold =
- calc_erroradv_threshold(ref_frame_error);
+ const int64_t ref_frame_error = av1_segmented_frame_error(
+ xd->bd, ref_buf[frame]->y_buffer, ref_buf[frame]->y_stride,
+ cpi->source->y_buffer, src_width, src_height, src_stride, segment_map,
+ segment_map_w);
- const int64_t warp_error = av1_refine_integerized_param(
- &tmp_wm_params, tmp_wm_params.wmtype, xd->bd,
- ref_buf[frame]->y_buffer, ref_buf[frame]->y_width,
- ref_buf[frame]->y_height, ref_buf[frame]->y_stride,
- cpi->source->y_buffer, src_width, src_height, src_stride,
- GM_REFINEMENT_COUNT, best_warp_error, segment_map, segment_map_w,
- erroradv_threshold);
+ if (ref_frame_error == 0) continue;
- if (warp_error < best_warp_error) {
- best_warp_error = warp_error;
- // Save the wm_params modified by
- // av1_refine_integerized_param() rather than motion index to
- // avoid rerunning refine() below.
- memcpy(&(cm->global_motion[frame]), &tmp_wm_params,
- sizeof(WarpedMotionParams));
- }
+ const int64_t erroradv_threshold =
+ calc_erroradv_threshold(ref_frame_error);
+
+ const int64_t warp_error = av1_refine_integerized_param(
+ &tmp_wm_params, tmp_wm_params.wmtype, xd->bd,
+ ref_buf[frame]->y_buffer, ref_buf[frame]->y_width,
+ ref_buf[frame]->y_height, ref_buf[frame]->y_stride,
+ cpi->source->y_buffer, src_width, src_height, src_stride,
+ GM_REFINEMENT_COUNT, best_warp_error, segment_map, segment_map_w,
+ erroradv_threshold);
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // av1_refine_integerized_param() can change the wmtype to a simpler
+ // model type than its input. So we need to check again to see if
+ // we have a translational model
+ if (tmp_wm_params.wmtype <= TRANSLATION) continue;
+#else
+ // av1_refine_integerized_param() can return a simpler model type than
+ // its input, so re-check model type here
+ if (tmp_wm_params.wmtype == IDENTITY) continue;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // Apply initial quality filter, which depends only on the error metrics
+ // and not the model cost
+ if (warp_error >= ref_frame_error * erroradv_tr) continue;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
+ if (warp_error < best_warp_error) {
+ best_ref_frame_error = ref_frame_error;
+ best_warp_error = warp_error;
+ // Save the wm_params modified by
+ // av1_refine_integerized_param() rather than motion index to
+ // avoid rerunning refine() below.
+ memcpy(&(cm->global_motion[frame]), &tmp_wm_params,
+ sizeof(WarpedMotionParams));
}
}
if (cm->global_motion[frame].wmtype <= AFFINE)
if (!av1_get_shear_params(&cm->global_motion[frame]))
cm->global_motion[frame] = default_warp_params;
+#if !CONFIG_IMPROVED_GLOBAL_MOTION
if (cm->global_motion[frame].wmtype == TRANSLATION) {
cm->global_motion[frame].wmmat[0] =
#if CONFIG_FLEX_MVRES
@@ -207,15 +267,25 @@
cm->global_motion[frame].wmmat[1]) *
GM_TRANS_ONLY_DECODE_FACTOR;
}
+#endif // !CONFIG_IMPROVED_GLOBAL_MOTION
if (cm->global_motion[frame].wmtype == IDENTITY) continue;
- if (ref_frame_error == 0) continue;
+ // Once we get here, best_ref_frame_error must be > 0. This is because
+ // of the logic above, which skips over any models which have
+ // ref_frame_error == 0
+ assert(best_ref_frame_error > 0);
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ gm_info->erroradvantage[frame] =
+ (double)best_warp_error / best_ref_frame_error;
+
+ break;
+#else
// If the best error advantage found doesn't meet the threshold for
// this motion type, revert to IDENTITY.
if (!av1_is_enough_erroradvantage(
- (double)best_warp_error / ref_frame_error,
+ (double)best_warp_error / best_ref_frame_error,
gm_get_params_cost(&cm->global_motion[frame], ref_params,
#if CONFIG_FLEX_MVRES
cm->features.fr_mv_precision))) {
@@ -226,6 +296,7 @@
}
if (cm->global_motion[frame].wmtype != IDENTITY) break;
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
aom_clear_system_state();
@@ -237,8 +308,12 @@
int num_src_corners, int *src_corners, unsigned char *src_buffer,
MotionModel *params_by_motion, uint8_t *segment_map, int segment_map_w,
int segment_map_h) {
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ compute_global_motion_for_ref_frame(
+ cpi, ref_buf, frame, num_src_corners, src_corners, src_buffer,
+ params_by_motion, segment_map, segment_map_w, segment_map_h);
+#else
AV1_COMMON *const cm = &cpi->common;
- GlobalMotionInfo *const gm_info = &cpi->gm_info;
const WarpedMotionParams *ref_params =
cm->prev_frame ? &cm->prev_frame->global_motion[frame]
: &default_warp_params;
@@ -246,16 +321,7 @@
compute_global_motion_for_ref_frame(
cpi, ref_buf, frame, num_src_corners, src_corners, src_buffer,
params_by_motion, segment_map, segment_map_w, segment_map_h, ref_params);
-
- gm_info->params_cost[frame] =
- gm_get_params_cost(&cm->global_motion[frame], ref_params,
-#if !CONFIG_FLEX_MVRES
- cm->features.allow_high_precision_mv) +
-#else
- cm->features.fr_mv_precision) +
-#endif
- gm_info->type_cost[cm->global_motion[frame].wmtype] -
- gm_info->type_cost[IDENTITY];
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
}
// Loops over valid reference frames and computes global motion estimation.
@@ -282,7 +348,7 @@
// source_alt_ref_frame w.r.t. ARF frames.
if (cpi->sf.gm_sf.prune_ref_frame_for_gm_search &&
reference_frame[frame].distance != 0 &&
- cm->global_motion[ref_frame].wmtype != ROTZOOM)
+ cm->global_motion[ref_frame].wmtype <= TRANSLATION)
break;
}
}
@@ -299,37 +365,26 @@
return 0;
}
-// Function to decide if we can skip the global motion parameter computation
-// for a particular ref frame.
-static AOM_INLINE int skip_gm_frame(AV1_COMMON *const cm, int refrank) {
- const RefCntBuffer *const refbuf = get_ref_frame_buf(cm, refrank);
- if (refbuf == NULL) return 1;
- const int d0 = get_dir_rank(cm, refrank, NULL);
- for (int i = 0; i < refrank; ++i) {
- const int di = get_dir_rank(cm, i, NULL);
- if (di == d0 && cm->global_motion[i].wmtype != IDENTITY) {
- // Same direction higher ranked ref has a non-identity gm.
- // Allow search if distance is smaller in this case.
- return (abs(cm->ref_frames_info.ref_frame_distance[i]) >
- abs(cm->ref_frames_info.ref_frame_distance[refrank]));
- }
- }
- return 0;
-}
+static int disable_gm_search_based_on_stats(const AV1_COMP *const cpi) {
+ const GF_GROUP *gf_group = &cpi->gf_group;
+ int is_gm_present = 1;
-// Prunes reference frames for global motion estimation based on the speed
-// feature 'gm_search_type'.
-static int do_gm_search_logic(SPEED_FEATURES *const sf, int refrank) {
- switch (sf->gm_sf.gm_search_type) {
- case GM_FULL_SEARCH: return 1;
- case GM_REDUCED_REF_SEARCH_SKIP_LEV2:
- return refrank < INTER_REFS_PER_FRAME - 2;
- case GM_REDUCED_REF_SEARCH_SKIP_LEV3:
- return refrank < INTER_REFS_PER_FRAME - 4;
- case GM_DISABLE_SEARCH: return 0;
- default: assert(0);
+ // Check number of GM models only in GF groups with ARF frames. GM param
+ // estimation is always done in the case of GF groups with no ARF frames (flat
+ // gops)
+ if (gf_group->arf_index > -1) {
+ // valid_gm_model_found is initialized to INT32_MAX in the beginning of
+ // every GF group.
+ // Therefore, GM param estimation is always done for all frames until
+ // at least 1 frame each of ARF_UPDATE, INTNL_ARF_UPDATE and LF_UPDATE are
+ // encoded in a GF group For subsequent frames, GM param estimation is
+ // disabled, if no valid models have been found in all the three update
+ // types.
+ is_gm_present = (cpi->valid_gm_model_found[ARF_UPDATE] != 0) ||
+ (cpi->valid_gm_model_found[INTNL_ARF_UPDATE] != 0) ||
+ (cpi->valid_gm_model_found[LF_UPDATE] != 0);
}
- return 1;
+ return !is_gm_present;
}
// Populates valid reference frames in past/future directions in
@@ -344,6 +399,12 @@
const GF_GROUP *gf_group = &cpi->gf_group;
int ref_pruning_enabled = is_frame_eligible_for_ref_pruning(
gf_group, cpi->sf.inter_sf.selective_ref_frame, 1, gf_group->index);
+ int cur_frame_gm_disabled = 0;
+ int pyr_lvl = cm->cur_frame->pyramid_level;
+
+ if (cpi->sf.gm_sf.disable_gm_search_based_on_stats) {
+ cur_frame_gm_disabled = disable_gm_search_based_on_stats(cpi);
+ }
for (int frame = cm->ref_frames_info.num_total_refs - 1; frame >= 0;
--frame) {
@@ -358,7 +419,6 @@
// Skip global motion estimation for invalid ref frames
if (buf == NULL ||
(ref_disabled && cpi->sf.hl_sf.recode_loop != DISALLOW_RECODE)) {
- cpi->gm_info.params_cost[frame] = 0;
continue;
} else {
ref_buf[frame] = &buf->buf;
@@ -367,12 +427,12 @@
int prune_ref_frames =
ref_pruning_enabled &&
prune_ref_by_selective_ref_frame(cpi, NULL, ref_frame);
+ int ref_pyr_lvl = buf->pyramid_level;
if (ref_buf[frame]->y_crop_width == cpi->source->y_crop_width &&
ref_buf[frame]->y_crop_height == cpi->source->y_crop_height &&
- do_gm_search_logic(&cpi->sf, ref_frame[0]) &&
- !(cpi->sf.gm_sf.selective_ref_gm && skip_gm_frame(cm, ref_frame[0])) &&
- !prune_ref_frames) {
+ frame < cpi->sf.gm_sf.max_ref_frames && !prune_ref_frames &&
+ ref_pyr_lvl <= pyr_lvl && !cur_frame_gm_disabled) {
assert(ref_buf[frame] != NULL);
const int relative_frame_dist = av1_encoder_get_relative_dist(
buf->display_order_hint, cm->cur_frame->display_order_hint);
@@ -420,6 +480,173 @@
}
}
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+// Select which global motion model to use as a base
+static AOM_INLINE void pick_base_gm_params(AV1_COMP *cpi) {
+ AV1_COMMON *const cm = &cpi->common;
+ const SequenceHeader *const seq_params = &cm->seq_params;
+ GlobalMotionInfo *const gm_info = &cpi->gm_info;
+ int num_total_refs = cm->ref_frames_info.num_total_refs;
+
+ int best_our_ref;
+ int best_their_ref;
+ const WarpedMotionParams *best_base_model;
+ int best_temporal_distance;
+ int best_num_models;
+ int best_cost;
+
+ // Bitmask of which models we will actually use if we accept the current
+ // best base model
+ uint8_t best_enable_models;
+
+ // First, evaluate the identity model as a base
+ {
+ int this_num_models = 0;
+ int this_cost =
+ aom_count_primitive_quniform(num_total_refs + 1, num_total_refs)
+ << AV1_PROB_COST_SHIFT;
+ uint8_t this_enable_models = 0;
+
+ for (int frame = 0; frame < num_total_refs; frame++) {
+ const WarpedMotionParams *model = &cm->global_motion[frame];
+ if (model->wmtype == IDENTITY) continue;
+
+#if CONFIG_FLEX_MVRES
+ int model_cost = gm_get_params_cost(model, &default_warp_params,
+ cm->features.fr_mv_precision);
+#else
+ int model_cost = gm_get_params_cost(model, &default_warp_params,
+ cm->features.allow_high_precision_mv);
+#endif // CONFIG_FLEX_MVRES
+ bool use_model = av1_is_enough_erroradvantage(
+ gm_info->erroradvantage[frame], model_cost);
+
+ if (use_model) {
+ this_num_models += 1;
+ this_cost += model_cost;
+ this_enable_models |= (1 << frame);
+ }
+ }
+
+ // Set initial values
+ best_our_ref = cm->ref_frames_info.num_total_refs;
+ best_their_ref = -1;
+ best_base_model = &default_warp_params;
+ best_temporal_distance = 1;
+ best_num_models = this_num_models;
+ best_cost = this_cost;
+ best_enable_models = this_enable_models;
+ }
+
+ // Then try each available reference model in turn
+ for (int our_ref = 0; our_ref < num_total_refs; ++our_ref) {
+ const int ref_disabled = !(cm->ref_frame_flags & (1 << our_ref));
+ RefCntBuffer *buf = get_ref_frame_buf(cm, our_ref);
+ // Skip looking at invalid ref frames
+ if (buf == NULL ||
+ (ref_disabled && cpi->sf.hl_sf.recode_loop != DISALLOW_RECODE)) {
+ continue;
+ }
+
+ int their_num_refs = buf->num_ref_frames;
+ for (int their_ref = 0; their_ref < their_num_refs; ++their_ref) {
+ const WarpedMotionParams *base_model = &buf->global_motion[their_ref];
+ if (base_model->wmtype == IDENTITY) {
+ continue;
+ }
+
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int our_ref_order_hint = buf->display_order_hint;
+ const int their_ref_order_hint = buf->ref_display_order_hint[their_ref];
+#else
+ const int our_ref_order_hint = buf->order_hint;
+ const int their_ref_order_hint = buf->ref_order_hints[their_ref];
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ int base_temporal_distance =
+ get_relative_dist(&seq_params->order_hint_info, our_ref_order_hint,
+ their_ref_order_hint);
+
+ int this_num_models = 0;
+ int this_cost =
+ (aom_count_primitive_quniform(num_total_refs + 1, our_ref) +
+ aom_count_primitive_quniform(their_num_refs, their_ref))
+ << AV1_PROB_COST_SHIFT;
+ uint8_t this_enable_models = 0;
+
+ for (int frame = 0; frame < num_total_refs; frame++) {
+ const WarpedMotionParams *model = &cm->global_motion[frame];
+ if (model->wmtype == IDENTITY) continue;
+
+ int temporal_distance;
+ if (seq_params->order_hint_info.enable_order_hint) {
+ const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, frame);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int ref_order_hint = ref_buf->display_order_hint;
+ const int cur_order_hint = cm->cur_frame->display_order_hint;
+#else
+ const int ref_order_hint = ref_buf->order_hint;
+ const int cur_order_hint = cm->cur_frame->order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ temporal_distance = get_relative_dist(&seq_params->order_hint_info,
+ cur_order_hint, ref_order_hint);
+ } else {
+ temporal_distance = 1;
+ }
+
+ if (temporal_distance == 0) {
+ // Don't code global motion for frames at the same temporal instant
+ assert(model->wmtype == IDENTITY);
+ continue;
+ }
+
+ WarpedMotionParams ref_params;
+ av1_scale_warp_model(base_model, base_temporal_distance, &ref_params,
+ temporal_distance);
+
+#if CONFIG_FLEX_MVRES
+ int model_cost = gm_get_params_cost(model, &ref_params,
+ cm->features.fr_mv_precision);
+#else
+ int model_cost = gm_get_params_cost(
+ model, &ref_params, cm->features.allow_high_precision_mv);
+#endif // CONFIG_FLEX_MVRES
+ bool use_model = av1_is_enough_erroradvantage(
+ gm_info->erroradvantage[frame], model_cost);
+
+ if (use_model) {
+ this_num_models += 1;
+ this_cost += model_cost;
+ this_enable_models |= (1 << frame);
+ }
+ }
+
+ if (this_num_models > best_num_models ||
+ (this_num_models == best_num_models && this_cost < best_cost)) {
+ best_our_ref = our_ref;
+ best_their_ref = their_ref;
+ best_base_model = base_model;
+ best_temporal_distance = base_temporal_distance;
+ best_num_models = this_num_models;
+ best_cost = this_cost;
+ best_enable_models = this_enable_models;
+ }
+ }
+ }
+
+ gm_info->base_model_our_ref = best_our_ref;
+ gm_info->base_model_their_ref = best_their_ref;
+ cm->base_global_motion_model = *best_base_model;
+ cm->base_global_motion_distance = best_temporal_distance;
+
+ for (int frame = 0; frame < num_total_refs; frame++) {
+ if ((best_enable_models & (1 << frame)) == 0) {
+ // Disable this model
+ cm->global_motion[frame] = default_warp_params;
+ }
+ }
+}
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
// Initializes parameters used for computing global motion.
static AOM_INLINE void setup_global_motion_info_params(AV1_COMP *cpi) {
GlobalMotionInfo *const gm_info = &cpi->gm_info;
@@ -486,15 +713,45 @@
dealloc_global_motion_data(params_by_motion, segment_map);
}
+static AOM_INLINE void reset_gm_stats(AV1_COMP *cpi) {
+ for (int i = 0; i < FRAME_UPDATE_TYPES; i++) {
+ cpi->valid_gm_model_found[i] = INT32_MAX;
+ }
+}
+
+// Updates frame level stats related to global motion
+static AOM_INLINE void update_gm_stats(AV1_COMP *cpi) {
+ const GF_GROUP *gf_group = &cpi->gf_group;
+ FRAME_UPDATE_TYPE update_type = gf_group->update_type[gf_group->index];
+
+ int is_gm_present = 0;
+ for (int frame = 0; frame < INTER_REFS_PER_FRAME; frame++) {
+ if (cpi->common.global_motion[frame].wmtype != IDENTITY) {
+ is_gm_present = 1;
+ break;
+ }
+ }
+
+ if (cpi->valid_gm_model_found[update_type] == INT32_MAX) {
+ cpi->valid_gm_model_found[update_type] = is_gm_present;
+ } else {
+ cpi->valid_gm_model_found[update_type] |= is_gm_present;
+ }
+}
+
// Global motion estimation for the current frame is computed.This computation
// happens once per frame and the winner motion model parameters are stored in
// cm->cur_frame->global_motion.
void av1_compute_global_motion_facade(AV1_COMP *cpi) {
AV1_COMMON *const cm = &cpi->common;
+ const GF_GROUP *gf_group = &cpi->gf_group;
GlobalMotionInfo *const gm_info = &cpi->gm_info;
- av1_zero(cpi->td.rd_counts.global_motion_used);
- av1_zero(gm_info->params_cost);
+ // Reset `valid_gm_model_found` at the start of each GOP
+ if (cpi->oxcf.tool_cfg.enable_global_motion &&
+ cpi->sf.gm_sf.disable_gm_search_based_on_stats && gf_group->index == 0) {
+ reset_gm_stats(cpi);
+ }
if (cpi->common.current_frame.frame_type == INTER_FRAME && cpi->source &&
cpi->oxcf.tool_cfg.enable_global_motion && !gm_info->search_done) {
@@ -503,8 +760,22 @@
av1_global_motion_estimation_mt(cpi);
else
global_motion_estimation(cpi);
+
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ // Once we have determined the best motion model for each ref frame,
+ // choose the base parameters to minimize the total encoding cost
+ pick_base_gm_params(cpi);
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
+
+ // Check if the current frame has any valid global motion model across its
+ // reference frames
+ if (cpi->sf.gm_sf.disable_gm_search_based_on_stats) {
+ update_gm_stats(cpi);
+ }
+
gm_info->search_done = 1;
}
+
memcpy(cm->cur_frame->global_motion, cm->global_motion,
sizeof(cm->cur_frame->global_motion));
}
diff --git a/av1/encoder/interp_search.c b/av1/encoder/interp_search.c
index d3108aa..c355ffc 100644
--- a/av1/encoder/interp_search.c
+++ b/av1/encoder/interp_search.c
@@ -125,6 +125,9 @@
// to MULTITAP_SHARP, and thus is not switchable.
assert(x->e_mbd.mi[0]->mode < NEAR_NEARMV_OPTFLOW);
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ assert(!x->e_mbd.mi[0]->refinemv_flag);
+#endif // CONFIG_REFINEMV
const int inter_filter_cost =
x->mode_costs.switchable_interp_costs[ctx[0]][interp_fltr];
return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
@@ -188,7 +191,11 @@
mbmi->interp_fltr = filter_idx;
#if CONFIG_OPTFLOW_REFINEMENT
const int tmp_rs =
- (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
+ (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)
+#if CONFIG_REFINEMV
+ || mbmi->refinemv_flag
+#endif // CONFIG_REFINEMV
+ )
? 0
: get_switchable_rate(x, mbmi->interp_fltr, switchable_ctx);
#else
@@ -439,7 +446,11 @@
switchable_ctx[1] = av1_get_pred_context_switchable_interp(xd, 1);
#if CONFIG_OPTFLOW_REFINEMENT
*switchable_rate =
- (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
+ (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)
+#if CONFIG_REFINEMV
+ || mbmi->refinemv_flag
+#endif // CONFIG_REFINEMV
+ )
? 0
: get_switchable_rate(x, mbmi->interp_fltr, switchable_ctx);
#else
@@ -475,28 +486,54 @@
}
if (!need_search) {
#if CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ assert(mbmi->interp_fltr ==
+ ((mbmi->mode >= NEAR_NEARMV_OPTFLOW ||
+ use_opfl_refine_all(cm, mbmi) || mbmi->refinemv_flag)
+ ? MULTITAP_SHARP
+ : EIGHTTAP_REGULAR));
+#else
assert(mbmi->interp_fltr ==
((mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
? MULTITAP_SHARP
: EIGHTTAP_REGULAR));
+#endif // CONFIG_REFINEMV
#else
assert(mbmi->interp_fltr == EIGHTTAP_REGULAR);
#endif // CONFIG_OPTFLOW_REFINEMENT
return 0;
}
if (args->modelled_rd != NULL) {
+#if CONFIG_REFINEMV
+ int use_default_filter = mbmi->refinemv_flag
+#if CONFIG_OPTFLOW_REFINEMENT
+ || mbmi->mode >= NEAR_NEARMV_OPTFLOW ||
+ use_opfl_refine_all(cm, mbmi)
+#endif
+ ;
+ if (has_second_ref(mbmi) && !use_default_filter) {
+#else
#if CONFIG_OPTFLOW_REFINEMENT
if (has_second_ref(mbmi) && mbmi->mode < NEAR_NEARMV_OPTFLOW &&
!use_opfl_refine_all(cm, mbmi)) {
#else
if (has_second_ref(mbmi)) {
#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // CONFIG_REFINEMV
+#if !CONFIG_SEP_COMP_DRL
const int ref_mv_idx = mbmi->ref_mv_idx;
+#endif // !CONFIG_SEP_COMP_DRL
MV_REFERENCE_FRAME *refs = mbmi->ref_frame;
const int mode0 = compound_ref0_mode(mbmi->mode);
const int mode1 = compound_ref1_mode(mbmi->mode);
+#if CONFIG_SEP_COMP_DRL
+ const int64_t mrd =
+ AOMMIN(args->modelled_rd[mode0][get_ref_mv_idx(mbmi, 0)][refs[0]],
+ args->modelled_rd[mode1][get_ref_mv_idx(mbmi, 1)][refs[1]]);
+#else
const int64_t mrd = AOMMIN(args->modelled_rd[mode0][ref_mv_idx][refs[0]],
args->modelled_rd[mode1][ref_mv_idx][refs[1]]);
+#endif // CONFIG_SEP_COMP_DRL
if ((*rd >> 1) > mrd && ref_best_rd < INT64_MAX) {
return INT64_MAX;
diff --git a/av1/encoder/interp_search.h b/av1/encoder/interp_search.h
index 8dfbe2b..d5c0a77 100644
--- a/av1/encoder/interp_search.h
+++ b/av1/encoder/interp_search.h
@@ -153,6 +153,17 @@
* Index of the last set of saved stats in the interp_filter_stats array.
*/
int interp_filter_stats_idx;
+#if CONFIG_SKIP_ME_FOR_OPFL_MODES
+ /*!
+ * Saved MV information for opfl off case.
+ */
+ int_mv (*comp_newmv)[4][NUM_MV_PRECISIONS][2];
+ /*!
+ * Valid status of saved MV information for opfl off case.
+ */
+ int (*comp_newmv_valid)[4][NUM_MV_PRECISIONS];
+#endif // CONFIG_SKIP_ME_FOR_OPFL_MODES
+
} HandleInterModeArgs;
/*!\cond */
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c
index b2d10b5..d31870a 100644
--- a/av1/encoder/intra_mode_search.c
+++ b/av1/encoder/intra_mode_search.c
@@ -10,6 +10,7 @@
* aomedia.org/license/patent-license/.
*/
+#include "av1/common/av1_common_int.h"
#include "av1/common/reconintra.h"
#include "av1/encoder/intra_mode_search.h"
@@ -790,12 +791,19 @@
set_mv_precision(mbmi, mbmi->max_mv_precision);
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
#if CONFIG_EXTENDED_WARP_PREDICTION
mbmi->motion_mode = SIMPLE_TRANSLATION;
#endif
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
RD_STATS rd_stats_y;
av1_invalid_rd_stats(&rd_stats_y);
@@ -856,10 +864,15 @@
if (skippable) {
rate2 -= rd_stats_y.rate;
if (num_planes > 1) rate2 -= intra_search_state->rate_uv_tokenonly;
+#if !CONFIG_SKIP_TXFM_OPT
rate2 += mode_costs->skip_txfm_cost[av1_get_skip_txfm_context(xd)][1];
- } else {
+#endif // !CONFIG_SKIP_TXFM_OPT
+ }
+#if !CONFIG_SKIP_TXFM_OPT
+ else {
rate2 += mode_costs->skip_txfm_cost[av1_get_skip_txfm_context(xd)][0];
}
+#endif // !CONFIG_SKIP_TXFM_OPT
this_rd = RDCOST(x->rdmult, rate2, distortion2);
this_rd_cost->rate = rate2;
this_rd_cost->dist = distortion2;
@@ -948,6 +961,9 @@
#if CONFIG_FLEX_MVRES
set_mv_precision(mbmi, mbmi->max_mv_precision);
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
mbmi->motion_mode = SIMPLE_TRANSLATION;
RD_STATS rd_stats_y_fi;
@@ -1026,10 +1042,20 @@
assert(mbmi->ref_frame[0] == INTRA_FRAME);
const PREDICTION_MODE mode = mbmi->mode;
const ModeCosts *mode_costs = &x->mode_costs;
+
+#if CONFIG_EXT_DIR
+ int mrl_ctx = get_mrl_index_ctx(xd->neighbors[0], xd->neighbors[1]);
+ int mrl_idx_cost =
+ (av1_is_directional_mode(mbmi->mode) &&
+ cpi->common.seq_params.enable_mrls)
+ ? x->mode_costs.mrl_index_cost[mrl_ctx][mbmi->mrl_index]
+ : 0;
+#else
int mrl_idx_cost = (av1_is_directional_mode(mbmi->mode) &&
cpi->common.seq_params.enable_mrls)
? x->mode_costs.mrl_index_cost[mbmi->mrl_index]
: 0;
+#endif // CONFIG_EXT_DIR
#if CONFIG_AIMC
int mode_cost = 0;
const int context = get_y_mode_idx_ctx(xd);
@@ -1055,12 +1081,16 @@
const int intra_cost_penalty = av1_get_intra_cost_penalty(
cm->quant_params.base_qindex, cm->quant_params.y_dc_delta_q,
cm->seq_params.base_y_dc_delta_q, cm->seq_params.bit_depth);
+#if !CONFIG_SKIP_TXFM_OPT
const int skip_ctx = av1_get_skip_txfm_context(xd);
+#endif // !CONFIG_SKIP_TXFM_OPT
int known_rate = mode_cost;
if (mode != DC_PRED && mode != PAETH_PRED) known_rate += intra_cost_penalty;
+#if !CONFIG_SKIP_TXFM_OPT
known_rate += AOMMIN(mode_costs->skip_txfm_cost[skip_ctx][0],
mode_costs->skip_txfm_cost[skip_ctx][1]);
+#endif // !CONFIG_SKIP_TXFM_OPT
const int64_t known_rd = RDCOST(x->rdmult, known_rate, 0);
if (known_rd > best_rd) {
intra_search_state->skip_intra_modes = 1;
@@ -1140,10 +1170,14 @@
#if !CONFIG_AIMC
if (intra_search_state->rate_uv_intra == INT_MAX) {
#endif // !CONFIG_AIMC
- // If no good uv-predictor had been found, search for it.
- const int rate_y = rd_stats_y->skip_txfm
- ? mode_costs->skip_txfm_cost[skip_ctx][1]
- : rd_stats_y->rate;
+ // If no good uv-predictor had been found, search for it.
+#if CONFIG_SKIP_TXFM_OPT
+ const int rate_y = rd_stats_y->rate;
+#else
+ const int rate_y = rd_stats_y->skip_txfm
+ ? mode_costs->skip_txfm_cost[skip_ctx][1]
+ : rd_stats_y->rate;
+#endif // CONFIG_SKIP_TXFM_OPT
const int64_t rdy =
RDCOST(x->rdmult, rate_y + mode_cost_y, rd_stats_y->dist);
if (best_rd < (INT64_MAX / 2) && rdy > (best_rd + (best_rd >> 2))) {
@@ -1224,8 +1258,10 @@
// Intra block is always coded as non-skip
rd_stats->skip_txfm = 0;
rd_stats->dist = rd_stats_y->dist + rd_stats_uv->dist;
+#if !CONFIG_SKIP_TXFM_OPT
// Add in the cost of the no skip flag.
rd_stats->rate += mode_costs->skip_txfm_cost[skip_ctx][0];
+#endif // !CONFIG_SKIP_TXFM_OPT
// Calculate the final RD estimate for this mode.
const int64_t this_rd = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
// Keep record of best intra rd
@@ -1349,13 +1385,23 @@
continue;
if (!is_directional_mode && mrl_idx) continue;
+#if !CONFIG_EXT_DIR
if (best_mbmi->mrl_index == 0 && mbmi->mrl_index > 1 &&
av1_is_directional_mode(best_mbmi->mode) == 0) {
continue;
}
+#endif // CONFIG_EXT_DIR
+#if CONFIG_EXT_DIR
+ int mrl_ctx = get_mrl_index_ctx(xd->neighbors[0], xd->neighbors[1]);
+ int mrl_idx_cost =
+ (is_directional_mode && enable_mrls_flag)
+ ? x->mode_costs.mrl_index_cost[mrl_ctx][mbmi->mrl_index]
+ : 0;
+#else
int mrl_idx_cost = (is_directional_mode && enable_mrls_flag)
? x->mode_costs.mrl_index_cost[mbmi->mrl_index]
: 0;
+#endif // CONFIG_EXT_DIR
#if CONFIG_AIMC
mode_costs += mrl_idx_cost;
#endif // CONFIG_AIMC
@@ -1548,13 +1594,23 @@
continue;
if (!is_directional_mode && mrl_idx) continue;
+#if !CONFIG_EXT_DIR
if (best_mbmi.mrl_index == 0 && mbmi->mrl_index > 1 &&
av1_is_directional_mode(best_mbmi.mode) == 0) {
continue;
}
+#endif // CONFIG_EXT_DIR
+#if CONFIG_EXT_DIR
+ int mrl_ctx = get_mrl_index_ctx(xd->neighbors[0], xd->neighbors[1]);
+ int mrl_idx_cost =
+ (is_directional_mode && enable_mrls_flag)
+ ? x->mode_costs.mrl_index_cost[mrl_ctx][mbmi->mrl_index]
+ : 0;
+#else
int mrl_idx_cost = (is_directional_mode && enable_mrls_flag)
? x->mode_costs.mrl_index_cost[mbmi->mrl_index]
: 0;
+#endif // CONFIG_EXT_DIR
#if CONFIG_AIMC
mode_costs += mrl_idx_cost;
#endif // CONFIG_AIMC
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 572864a..5280a23 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -42,7 +42,7 @@
#if CONFIG_FLEX_MVRES
,
MvSubpelPrecision pb_mv_precision
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
,
const int is_ibc_cost
#endif
@@ -60,7 +60,7 @@
mv_cost_params->is_adaptive_mvd = is_adaptive_mvd;
#endif // CONFIG_ADAPTIVE_MVD
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
mv_cost_params->is_ibc_cost = is_ibc_cost;
#endif
@@ -119,7 +119,7 @@
const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv,
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost,
#endif
#endif
@@ -136,6 +136,10 @@
enable_adaptive_mvd_resolution(&cpi->common, mbmi);
#endif // CONFIG_ADAPTIVE_MVD
+#if CONFIG_CWP
+ ms_params->xd = xd;
+#endif // CONFIG_CWP
+
// High level params
ms_params->bsize = bsize;
ms_params->vfp = &cpi->fn_ptr[bsize];
@@ -143,12 +147,16 @@
init_ms_buffers(&ms_params->ms_buffers, x);
SEARCH_METHODS search_method = mv_sf->search_method;
+ const int min_dim = AOMMIN(block_size_wide[bsize], block_size_high[bsize]);
+ const int max_dim = AOMMAX(block_size_wide[bsize], block_size_high[bsize]);
if (mv_sf->use_bsize_dependent_search_method) {
- const int min_dim = AOMMIN(block_size_wide[bsize], block_size_high[bsize]);
if (min_dim >= 32) {
search_method = get_faster_search_method(search_method);
}
}
+ if (max_dim >= 256) {
+ search_method = get_faster_search_method(search_method);
+ }
#if CONFIG_FLEX_MVRES
// MV search of flex MV precision is supported only for NSTEP or DIAMOND
// search
@@ -209,7 +217,7 @@
#endif // CONFIG_ADAPTIVE_MVD
#if CONFIG_FLEX_MVRES
ref_mv, pb_mv_precision
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
,
is_ibc_cost
#endif
@@ -237,7 +245,7 @@
ms_params->allow_hp = cm->features.allow_high_precision_mv;
#endif
-#if CONFIG_BVCOST_UPDATE && CONFIG_FLEX_MVRES
+#if CONFIG_IBC_BV_IMPROVEMENT && CONFIG_FLEX_MVRES
const int is_ibc_cost = 0;
#endif
@@ -287,7 +295,7 @@
#if CONFIG_FLEX_MVRES
ref_mv, pb_mv_precision
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
,
is_ibc_cost
#endif
@@ -303,6 +311,10 @@
ms_params->var_params.subpel_search_type =
cpi->sf.mv_sf.use_accurate_subpel_search;
#endif
+ if (AOMMAX(block_size_wide[bsize], block_size_high[bsize]) >= 256) {
+ ms_params->var_params.subpel_search_type =
+ AOMMIN(ms_params->var_params.subpel_search_type, USE_2_TAPS);
+ }
ms_params->var_params.w = block_size_wide[bsize];
ms_params->var_params.h = block_size_high[bsize];
@@ -471,7 +483,7 @@
#if CONFIG_ADAPTIVE_MVD
const int is_adaptive_mvd,
#endif
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost,
#endif
const MvCosts *mv_costs, int weight, int round_bits) {
@@ -480,7 +492,7 @@
const int *mvjcost =
is_adaptive_mvd
? mv_costs->amvd_nmv_joint_cost
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
: (is_ibc_cost ? mv_costs->dv_joint_cost : mv_costs->nmv_joint_cost);
#else
: mv_costs->nmv_joint_cost;
@@ -488,7 +500,7 @@
const int *const *mvcost =
is_adaptive_mvd
? CONVERT_TO_CONST_MVCOST(mv_costs->amvd_nmv_cost)
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
: (is_ibc_cost ? CONVERT_TO_CONST_MVCOST(mv_costs->dv_nmv_cost)
: CONVERT_TO_CONST_MVCOST(
mv_costs->nmv_costs[pb_mv_precision]));
@@ -497,7 +509,7 @@
#endif
#else
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int *mvjcost =
(is_ibc_cost ? mv_costs->dv_joint_cost : mv_costs->nmv_joint_cost);
const int *const *mvcost =
@@ -556,7 +568,7 @@
const int is_adaptive_mvd
#endif
) {
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
// For ibc block this function should not be called
const int is_ibc_cost = 0;
#endif
@@ -565,7 +577,7 @@
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd,
#endif
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
mv_costs, weight, 7);
@@ -618,7 +630,7 @@
#if CONFIG_ADAPTIVE_MVD
mv_cost_params->is_adaptive_mvd,
#endif
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
mv_cost_params->is_ibc_cost,
#endif
mv_costs, mv_costs->errorperbit,
@@ -677,7 +689,7 @@
const MvCosts *mv_costs = mv_cost_params->mv_costs;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int *mvjcost =
mv_cost_params->is_ibc_cost
? mv_costs->dv_joint_cost
@@ -1062,7 +1074,7 @@
((col + range) <= mv_limits->col_max);
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
int av1_get_mv_err_cost(const MV *mv, const MV_COST_PARAMS *mv_cost_params) {
#if CONFIG_FLEX_MVRES
return mv_err_cost(*mv, mv_cost_params);
@@ -1073,7 +1085,7 @@
mv_cost_params->mv_cost_type);
#endif
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
static INLINE int get_mvpred_var_cost(
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV *this_mv) {
@@ -1170,6 +1182,17 @@
return bestsme;
}
+#if CONFIG_CWP
+// Set weighting factor for two reference frames
+static INLINE void set_cmp_weight(const MB_MODE_INFO *mi, int invert_mask,
+ DIST_WTD_COMP_PARAMS *jcp_param) {
+ int weight = get_cwp_idx(mi);
+ weight = invert_mask ? (1 << CWP_WEIGHT_BITS) - weight : weight;
+ jcp_param->fwd_offset = weight;
+ jcp_param->bck_offset = (1 << CWP_WEIGHT_BITS) - weight;
+}
+#endif // CONFIG_CWP
+
static INLINE int get_mvpred_compound_sad(
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
const struct buf_2d *const src, const uint16_t *const ref_address,
@@ -1187,6 +1210,16 @@
return vfp->msdf(src_buf, src_stride, ref_address, ref_stride, second_pred,
mask, mask_stride, invert_mask);
} else if (second_pred) {
+#if CONFIG_CWP
+ const MB_MODE_INFO *mi = ms_params->xd->mi[0];
+ if (get_cwp_idx(mi) != CWP_EQUAL) {
+ DIST_WTD_COMP_PARAMS jcp_param;
+ set_cmp_weight(mi, invert_mask, &jcp_param);
+
+ return vfp->jsdaf(src_buf, src_stride, ref_address, ref_stride,
+ second_pred, &jcp_param);
+ }
+#endif // CONFIG_CWP
return vfp->sdaf(src_buf, src_stride, ref_address, ref_stride, second_pred);
} else {
return ms_params->sdf(src_buf, src_stride, ref_address, ref_stride);
@@ -2804,7 +2837,28 @@
return var;
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_CWP
+// Get the cost for compound weighted prediction
+int av1_get_cwp_idx_cost(int8_t cwp_idx, const AV1_COMMON *const cm,
+ const MACROBLOCK *x) {
+ assert(cwp_idx >= CWP_MIN && cwp_idx <= CWP_MAX);
+ const MACROBLOCKD *xd = &x->e_mbd;
+ MB_MODE_INFO *mi = xd->mi[0];
+ int cost = 0;
+ int bit_cnt = 0;
+ const int ctx = 0;
+
+ const int8_t final_idx = get_cwp_coding_idx(cwp_idx, 1, cm, mi);
+ for (int idx = 0; idx < MAX_CWP_NUM - 1; ++idx) {
+ cost += x->mode_costs.cwp_idx_cost[ctx][bit_cnt][final_idx != idx];
+ if (final_idx == idx) return cost;
+ ++bit_cnt;
+ }
+ return cost;
+}
+#endif // CONFIG_CWP
+
+#if CONFIG_IBC_BV_IMPROVEMENT
int av1_get_ref_mvpred_var_cost(const AV1_COMP *cpi, const MACROBLOCKD *xd,
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params) {
const BLOCK_SIZE bsize = ms_params->bsize;
@@ -2946,7 +3000,7 @@
}
return INT_MAX;
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
int av1_intrabc_hash_search(const AV1_COMP *cpi, const MACROBLOCKD *xd,
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
@@ -2973,13 +3027,13 @@
uint32_t hash_value1, hash_value2;
int best_hash_cost = INT_MAX;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
int best_intrabc_mode = 0;
int best_intrabc_drl_idx = 0;
int_mv best_ref_bv;
best_ref_bv.as_mv = *ms_params->mv_cost_params.ref_mv;
MB_MODE_INFO *mbmi = xd->mi[0];
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
// for the hashMap
hash_table *ref_frame_hash = &intrabc_hash_info->intrabc_hash_table;
@@ -3014,7 +3068,7 @@
#endif
))
continue;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
int refCost = get_mvpred_var_cost(ms_params, &hash_mv);
int cur_intrabc_mode = 0;
int cur_intrabc_drl_idx = 0;
@@ -3035,24 +3089,24 @@
}
#else
const int refCost = get_mvpred_var_cost(ms_params, &hash_mv);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
if (refCost < best_hash_cost) {
best_hash_cost = refCost;
*best_mv = hash_mv;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
best_intrabc_mode = cur_intrabc_mode;
best_intrabc_drl_idx = cur_intrabc_drl_idx;
best_ref_bv = cur_ref_bv;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
}
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
mbmi->ref_bv = best_ref_bv;
mbmi->intrabc_drl_idx = best_intrabc_drl_idx;
mbmi->intrabc_mode = best_intrabc_mode;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
return best_hash_cost;
}
@@ -3429,9 +3483,22 @@
subpel_y_q3, ref, ref_stride, mask, mask_stride, invert_mask, xd->bd,
subpel_search_type);
} else {
- aom_highbd_comp_avg_upsampled_pred(
- xd, cm, mi_row, mi_col, this_mv, pred, second_pred, w, h, subpel_x_q3,
- subpel_y_q3, ref, ref_stride, xd->bd, subpel_search_type);
+#if CONFIG_CWP
+ if (get_cwp_idx(xd->mi[0]) != CWP_EQUAL) {
+ DIST_WTD_COMP_PARAMS jcp_param;
+ set_cmp_weight(xd->mi[0], invert_mask, &jcp_param);
+
+ aom_highbd_dist_wtd_comp_avg_upsampled_pred(
+ xd, cm, mi_row, mi_col, this_mv, pred, second_pred, w, h,
+ subpel_x_q3, subpel_y_q3, ref, ref_stride, xd->bd, &jcp_param,
+ subpel_search_type);
+ } else
+#endif // CONFIG_CWP
+
+ aom_highbd_comp_avg_upsampled_pred(xd, cm, mi_row, mi_col, this_mv,
+ pred, second_pred, w, h, subpel_x_q3,
+ subpel_y_q3, ref, ref_stride, xd->bd,
+ subpel_search_type);
}
} else {
aom_highbd_upsampled_pred(xd, cm, mi_row, mi_col, this_mv, pred, w, h,
@@ -3914,18 +3981,11 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
lower_mv_precision(&ref_mv, mbmi->pb_mv_precision);
// We are not signaling other_mv. So frame level precision should be okay.
-#if !CONFIG_C071_SUBBLK_WARPMV
- lower_mv_precision(other_mv, cm->features.fr_mv_precision);
-#endif // !CONFIG_C071_SUBBLK_WARPMV
#else
-#if !CONFIG_C071_SUBBLK_WARPMV
- lower_mv_precision(other_mv, allow_hp,
- cm->features.cur_frame_force_integer_mv);
-#endif // !CONFIG_C071_SUBBLK_WARPMV
#endif
- // How many steps to take. A round of 0 means fullpel search only, 1 means
- // half-pel, and so on.
+ // How many steps to take. A round of 0 means fullpel search only, 1 means
+ // half-pel, and so on.
#if CONFIG_FLEX_MVRES
const int round = (mbmi->pb_mv_precision >= MV_PRECISION_ONE_PEL)
? AOMMIN(FULL_PEL - forced_stop,
@@ -4163,10 +4223,7 @@
if (mbmi->pb_mv_precision < MV_PRECISION_HALF_PEL)
#endif
lower_mv_precision(&ref_mv, mbmi->pb_mv_precision);
- // We are not signaling other_mv. So frame level precision should be okay.
-#if !CONFIG_C071_SUBBLK_WARPMV
- lower_mv_precision(other_mv, cm->features.fr_mv_precision);
-#endif // CONFIG_C071_SUBBLK_WARPMV
+ // We are not signaling other_mv. So frame level precision should be okay.
unsigned int besterr = INT_MAX;
@@ -4392,23 +4449,10 @@
// perform prediction for second MV
const BLOCK_SIZE bsize = mbmi->sb_type[PLANE_TYPE_Y];
-#if CONFIG_FLEX_MVRES
#if BUGFIX_AMVD_AMVR
set_amvd_mv_precision(mbmi, mbmi->max_mv_precision);
-#if !CONFIG_C071_SUBBLK_WARPMV
- lower_mv_precision(other_mv, cm->features.fr_mv_precision);
-#endif // !CONFIG_C071_SUBBLK_WARPMV
#else
assert(mbmi->pb_mv_precision == mbmi->max_mv_precision);
-#if !CONFIG_C071_SUBBLK_WARPMV
- lower_mv_precision(other_mv, mbmi->pb_mv_precision);
-#endif // !CONFIG_C071_SUBBLK_WARPMV
-#endif
-#else
-#if !CONFIG_C071_SUBBLK_WARPMV
- lower_mv_precision(other_mv, allow_hp,
- cm->features.cur_frame_force_integer_mv);
-#endif // !CONFIG_C071_SUBBLK_WARPMV
#endif
// How many steps to take. A round of 0 means fullpel search only, 1 means
@@ -5581,7 +5625,15 @@
int mi_row = xd->mi_row;
int mi_col = xd->mi_col;
- bool can_refine_mv = (mbmi->mode == NEWMV);
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ assert(IMPLIES(mbmi->warpmv_with_mvd_flag, mbmi->mode == WARPMV));
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+ bool can_refine_mv = (mbmi->mode == NEWMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || (mbmi->mode == WARPMV && mbmi->warpmv_with_mvd_flag)
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ );
const SubpelMvLimits *mv_limits = &ms_params->mv_limits;
// get the base parameters
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index e6571b2..2e57f5e 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -92,7 +92,7 @@
#if CONFIG_ADAPTIVE_MVD
int is_adaptive_mvd;
#endif // CONFIG_ADAPTIVE_MVD
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
int is_ibc_cost;
#endif
#endif
@@ -217,10 +217,10 @@
int mi_row;
int mi_col;
#endif // CONFIG_IBC_SR_EXT
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
MACROBLOCK *x;
int ref_bv_cnt;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
MSBuffers ms_buffers;
@@ -261,7 +261,7 @@
const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv,
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost,
#endif
#endif
@@ -577,9 +577,6 @@
int row_max =
av1_lower_mv_limit(GET_MV_SUBPEL(mv_limits->row_max), sub_pel_prec_shift);
- const int mv_low = av1_lower_mv_limit(MV_LOW + 1, sub_pel_prec_shift);
- const int mv_upp = av1_lower_mv_limit(MV_UPP - 1, sub_pel_prec_shift);
-
int minc = AOMMAX(col_min, low_prec_ref_mv.col - max_mv);
int maxc = AOMMIN(col_max, low_prec_ref_mv.col + max_mv);
int minr = AOMMAX(row_min, low_prec_ref_mv.row - max_mv);
@@ -588,10 +585,10 @@
maxc = AOMMAX(minc, maxc);
maxr = AOMMAX(minr, maxr);
- subpel_limits->col_min = AOMMAX(mv_low + (1 << sub_pel_prec_shift), minc);
- subpel_limits->col_max = AOMMIN(mv_upp - (1 << sub_pel_prec_shift), maxc);
- subpel_limits->row_min = AOMMAX(mv_low + (1 << sub_pel_prec_shift), minr);
- subpel_limits->row_max = AOMMIN(mv_upp - (1 << sub_pel_prec_shift), maxr);
+ subpel_limits->col_min = AOMMAX(MV_LOW + (1 << sub_pel_prec_shift), minc);
+ subpel_limits->col_max = AOMMIN(MV_UPP - (1 << sub_pel_prec_shift), maxc);
+ subpel_limits->row_min = AOMMAX(MV_LOW + (1 << sub_pel_prec_shift), minr);
+ subpel_limits->row_max = AOMMIN(MV_UPP - (1 << sub_pel_prec_shift), maxr);
#else
const int max_mv = GET_MV_SUBPEL(MAX_FULL_PEL_VAL);
@@ -628,7 +625,13 @@
(mv.row >= mv_limits->row_min) && (mv.row <= mv_limits->row_max);
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_CWP
+// Returns the cost for signaling the index of compound weighted prediction
+int av1_get_cwp_idx_cost(int8_t cwp_idx, const AV1_COMMON *const cm,
+ const MACROBLOCK *x);
+#endif // CONFIG_CWP
+
+#if CONFIG_IBC_BV_IMPROVEMENT
// Returns the cost of using the current mv during the motion search
int av1_get_mv_err_cost(const MV *mv, const MV_COST_PARAMS *mv_cost_params);
@@ -654,7 +657,7 @@
int av1_get_ref_mvpred_var_cost(const struct AV1_COMP *cpi,
const MACROBLOCKD *xd,
const FULLPEL_MOTION_SEARCH_PARAMS *ms_params);
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
#ifdef __cplusplus
} // extern "C"
diff --git a/av1/encoder/motion_search_facade.c b/av1/encoder/motion_search_facade.c
index 9b72201..b6481a4 100644
--- a/av1/encoder/motion_search_facade.c
+++ b/av1/encoder/motion_search_facade.c
@@ -50,12 +50,23 @@
void av1_single_motion_search(const AV1_COMP *const cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, int ref_idx, int *rate_mv,
int search_range, inter_mode_info *mode_info,
- int_mv *best_mv) {
+ int_mv *best_mv
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ ,
+ const int_mv *warp_ref_mv
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+) {
MACROBLOCKD *xd = &x->e_mbd;
const AV1_COMMON *cm = &cpi->common;
const MotionVectorSearchParams *mv_search_params = &cpi->mv_search_params;
const int num_planes = av1_num_planes(cm);
MB_MODE_INFO *mbmi = xd->mi[0];
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ MOTION_MODE backup_motion_mode = mbmi->motion_mode;
+ // Make the motion mode transalational, so that transalation MS can be used.
+ if (mbmi->mode == WARPMV) mbmi->motion_mode = SIMPLE_TRANSLATION;
+#endif // CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+
struct buf_2d backup_yv12[MAX_MB_PLANE] = { { 0, 0, 0, 0, 0 } };
int bestsme = INT_MAX;
const int ref = mbmi->ref_frame[ref_idx];
@@ -97,7 +108,11 @@
}
#if CONFIG_FLEX_MVRES
- MV ref_mv_low_prec = av1_get_ref_mv(x, ref_idx).as_mv;
+ MV ref_mv_low_prec =
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ (mbmi->mode == WARPMV) ? warp_ref_mv->as_mv :
+#endif // CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ av1_get_ref_mv(x, ref_idx).as_mv;
#if CONFIG_C071_SUBBLK_WARPMV
MV sub_mv_offset = { 0, 0 };
get_phase_from_mv(ref_mv_low_prec, &sub_mv_offset, mbmi->pb_mv_precision);
@@ -229,7 +244,7 @@
mv_search_params->search_site_cfg[SS_CFG_SRC];
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -238,7 +253,7 @@
#if CONFIG_FLEX_MVRES
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
src_search_sites, fine_search_interval);
@@ -305,6 +320,9 @@
// for the other ref_mv.
if (cpi->sf.inter_sf.skip_repeated_full_newmv &&
mbmi->motion_mode == SIMPLE_TRANSLATION &&
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
best_mv->as_int != INVALID_MV) {
int_mv this_mv;
this_mv.as_mv = get_mv_from_fullmv(&best_mv->as_fullmv);
@@ -320,7 +338,11 @@
this_mv.as_mv.col += sub_mv_offset.col;
}
#endif // CONFIG_C071_SUBBLK_WARPMV
+#if CONFIG_SEP_COMP_DRL
+ const int ref_mv_idx = av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx);
+#else
const int ref_mv_idx = mbmi->ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
#if CONFIG_FLEX_MVRES
const int this_mv_rate = av1_mv_bit_cost(
&this_mv.as_mv, &ref_mv, pb_mv_precision, mv_costs, MV_COST_WEIGHT
@@ -477,6 +499,10 @@
assert(is_this_mv_precision_compliant(best_mv->as_mv, mbmi->pb_mv_precision));
#endif // !CONFIG_C071_SUBBLK_WARPMV
#endif
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ // Restore the motion mode
+ if (mbmi->mode == WARPMV) mbmi->motion_mode = backup_motion_mode;
+#endif // CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
}
#if CONFIG_FLEX_MVRES
@@ -531,13 +557,13 @@
lower_mv_precision(&ref_mv_low_prec, mbmi->pb_mv_precision);
const MV ref_mv = ref_mv_low_prec;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
@@ -579,7 +605,11 @@
this_mv.as_mv.col += sub_mv_offset.col;
}
#endif // CONFIG_C071_SUBBLK_WARPMV
+#if CONFIG_SEP_COMP_DRL
+ const int ref_mv_idx = av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx);
+#else
const int ref_mv_idx = mbmi->ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
const int this_mv_rate = av1_mv_bit_cost(
&this_mv.as_mv, &ref_mv, pb_mv_precision, mv_costs, MV_COST_WEIGHT
#if CONFIG_ADAPTIVE_MVD
@@ -763,7 +793,7 @@
// Do full-pixel compound motion search on the current reference frame.
if (id) xd->plane[plane].pre[0] = ref_yv12[id];
-#if CONFIG_FLEX_MVRES && CONFIG_BVCOST_UPDATE
+#if CONFIG_FLEX_MVRES && CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
@@ -773,7 +803,7 @@
&ref_mv[id].as_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
@@ -1020,7 +1050,7 @@
const MvCosts *mv_costs = &x->mv_costs;
#if CONFIG_FLEX_MVRES
MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -1178,7 +1208,7 @@
&ref_mv.as_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
@@ -1485,6 +1515,9 @@
mbmi->use_intrabc[1] = 0;
#endif // CONFIG_IBC_SR_EXT
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
#if CONFIG_FLEX_MVRES
set_default_max_mv_precision(mbmi, xd->sbi->sb_mv_precision);
set_mv_precision(mbmi, mbmi->max_mv_precision);
@@ -1500,6 +1533,10 @@
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
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);
@@ -1530,7 +1567,7 @@
const int fine_search_interval = use_fine_search_interval(cpi);
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -1539,7 +1576,7 @@
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
@@ -1677,7 +1714,7 @@
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -1686,7 +1723,7 @@
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
diff --git a/av1/encoder/motion_search_facade.h b/av1/encoder/motion_search_facade.h
index e116997..066c438 100644
--- a/av1/encoder/motion_search_facade.h
+++ b/av1/encoder/motion_search_facade.h
@@ -35,7 +35,13 @@
void av1_single_motion_search(const AV1_COMP *const cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, int ref_idx, int *rate_mv,
int search_range, inter_mode_info *mode_info,
- int_mv *best_mv);
+ int_mv *best_mv
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ ,
+ const int_mv *warp_ref_mv
+#endif // CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+);
+
#if CONFIG_FLEX_MVRES
void av1_single_motion_search_high_precision(const AV1_COMP *const cpi,
MACROBLOCK *x, BLOCK_SIZE bsize,
diff --git a/av1/encoder/mv_prec.c b/av1/encoder/mv_prec.c
index 2ed092d..2b0f175 100644
--- a/av1/encoder/mv_prec.c
+++ b/av1/encoder/mv_prec.c
@@ -28,23 +28,42 @@
static AOM_INLINE int_mv get_ref_mv_for_mv_stats(
const MB_MODE_INFO *mbmi, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
int ref_idx) {
+#if CONFIG_SEP_COMP_DRL
+ const int ref_mv_idx = get_ref_mv_idx(mbmi, ref_idx);
+#else
const int ref_mv_idx = mbmi->ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
assert(IMPLIES(have_nearmv_newmv_in_inter_mode(mbmi->mode),
has_second_ref(mbmi)));
const MV_REFERENCE_FRAME *ref_frames = mbmi->ref_frame;
const int8_t ref_frame_type = av1_ref_frame_type(ref_frames);
+#if CONFIG_SEP_COMP_DRL
+ const CANDIDATE_MV *curr_ref_mv_stack =
+ has_second_drl(mbmi) ? mbmi_ext_frame->ref_mv_stack[ref_idx]
+ : mbmi_ext_frame->ref_mv_stack[0];
+#else
const CANDIDATE_MV *curr_ref_mv_stack = mbmi_ext_frame->ref_mv_stack;
+#endif // CONFIG_SEP_COMP_DRL
if (is_inter_ref_frame(ref_frames[1])) {
assert(ref_idx == 0 || ref_idx == 1);
+#if CONFIG_SEP_COMP_DRL
+ return ref_idx && !has_second_drl(mbmi)
+ ? curr_ref_mv_stack[ref_mv_idx].comp_mv
+#else
return ref_idx ? curr_ref_mv_stack[ref_mv_idx].comp_mv
- : curr_ref_mv_stack[ref_mv_idx].this_mv;
+#endif // CONFIG_SEP_COMP_DRL
+ : curr_ref_mv_stack[ref_mv_idx].this_mv;
}
assert(ref_idx == 0);
#if CONFIG_TIP
+#if CONFIG_SEP_COMP_DRL
+ if (ref_mv_idx < mbmi_ext_frame->ref_mv_count[0]) {
+#else
if (ref_mv_idx < mbmi_ext_frame->ref_mv_count) {
+#endif // CONFIG_SEP_COMP_DRL
return curr_ref_mv_stack[ref_mv_idx].this_mv;
} else if (is_tip_ref_frame(ref_frame_type)) {
int_mv zero_mv;
@@ -629,10 +648,14 @@
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
-#if !CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ const int ebs_w = mi_size_wide[bsize] / 8;
+ const int ebs_h = mi_size_high[bsize] / 8;
+#endif // CONFIG_UNEVEN_4WAY
+#if !CONFIG_EXT_RECUR_PARTITIONS
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
-#endif // !CONFIG_H_PARTITION
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
case PARTITION_NONE:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
@@ -670,7 +693,68 @@
subsize, ptree->sub_tree[3]);
break;
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ 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 + ebs_h, mi_col, bsize_med,
+ ptree->sub_tree[1]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + 3 * ebs_h, mi_col, bsize_big,
+ ptree->sub_tree[2]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + 7 * ebs_h, mi_col, subsize,
+ ptree->sub_tree[3]);
+ break;
+ }
+ case PARTITION_HORZ_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ 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 + ebs_h, mi_col, bsize_big,
+ ptree->sub_tree[1]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + 5 * ebs_h, mi_col, bsize_med,
+ ptree->sub_tree[2]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row + 7 * ebs_h, mi_col, subsize,
+ ptree->sub_tree[3]);
+ break;
+ }
+ case PARTITION_VERT_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ 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 + ebs_w, bsize_med,
+ ptree->sub_tree[1]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + 3 * ebs_w, bsize_big,
+ ptree->sub_tree[2]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + 7 * ebs_w, subsize,
+ ptree->sub_tree[3]);
+ break;
+ }
+ case PARTITION_VERT_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ 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 + ebs_w, bsize_big,
+ ptree->sub_tree[1]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + 5 * ebs_w, bsize_med,
+ ptree->sub_tree[2]);
+ collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col + 7 * ebs_w, subsize,
+ ptree->sub_tree[3]);
+ break;
+ }
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3:
case PARTITION_VERT_3: {
for (int i = 0; i < 4; ++i) {
@@ -686,28 +770,6 @@
}
break;
}
-#else
- 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;
- }
-#endif // CONFIG_H_PARTITION
#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_A:
collect_mv_stats_b(mv_stats, cpi, mi_row, mi_col);
@@ -788,14 +850,22 @@
}
mv_stats->q = current_q;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ mv_stats->order = cpi->common.current_frame.display_order_hint;
+#else
mv_stats->order = cpi->common.current_frame.order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
mv_stats->valid = 1;
}
static AOM_INLINE int get_smart_mv_prec(AV1_COMP *cpi, const MV_STATS *mv_stats,
int current_q) {
const AV1_COMMON *cm = &cpi->common;
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ const int order_hint = cpi->common.current_frame.display_order_hint;
+#else
const int order_hint = cpi->common.current_frame.order_hint;
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
const int order_diff = order_hint - mv_stats->order;
aom_clear_system_state();
const float area = (float)(cm->width * cm->height);
diff --git a/av1/encoder/palette.c b/av1/encoder/palette.c
index efeda05..0d963ab 100644
--- a/av1/encoder/palette.c
+++ b/av1/encoder/palette.c
@@ -87,7 +87,7 @@
int n_in_cache = 0;
int in_cache_flags[PALETTE_MAX_SIZE];
memset(in_cache_flags, 0, sizeof(in_cache_flags));
-#if CONFIG_INDEP_PALETTE_PARSING
+#if CONFIG_PALETTE_IMPROVEMENTS
for (int i = 0; i < n_cache; ++i) {
int duplicate = 0;
for (int j = 0; j < i; j++) {
@@ -96,7 +96,7 @@
if (duplicate) continue;
#else
for (int i = 0; i < n_cache && n_in_cache < n_colors; ++i) {
-#endif // CONFIG_INDEP_PALETTE_PARSING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
for (int j = 0; j < n_colors; ++j) {
if (colors[j] == color_cache[i]) {
in_cache_flags[j] = 1;
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index f62672c..ca6a45a 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c
@@ -417,8 +417,13 @@
pd->subsampling_x, pd->subsampling_y);
}
mismatch_record_block_pre(pd->dst.buf, pd->dst.stride,
- cm->current_frame.order_hint, plane, pixel_c,
- pixel_r, pd->width, pd->height);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ plane, pixel_c, pixel_r, pd->width,
+ pd->height);
}
}
#else
@@ -491,15 +496,15 @@
if (intra_tx_size != max_txsize_rect_lookup[bsize])
++x->txfm_search_info.txb_split_count;
}
-#if CONFIG_REF_MV_BANK && !CONFIG_C043_MVP_IMPROVEMENTS
-#if CONFIG_IBC_SR_EXT && !CONFIG_BVP_IMPROVEMENT
+#if CONFIG_REF_MV_BANK && !CONFIG_MVP_IMPROVEMENT
+#if CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
if (cm->seq_params.enable_refmvbank && is_inter &&
!is_intrabc_block(mbmi, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank && is_inter)
-#endif // CONFIG_IBC_SR_EXT && !CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, mbmi);
-#endif // CONFIG_REF_MV_BANK && !CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_REF_MV_BANK && !CONFIG_MVP_IMPROVEMENT
#if CONFIG_WARP_REF_LIST && !WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, mbmi);
@@ -534,12 +539,7 @@
is_cfl_allowed(xd)) {
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_block(xd, mbmi->sb_type[xd->tree_type == CHROMA_PART],
- mbmi->tx_size,
-#if DS_FRAME_LEVEL
- cm->features.ds_filter_type);
-#else
- cm->seq_params.enable_cfl_ds_filter);
-#endif // DS_FRAME_LEVEL
+ mbmi->tx_size, cm->seq_params.enable_cfl_ds_filter);
#else
cfl_store_block(xd, mbmi->sb_type[xd->tree_type == CHROMA_PART],
mbmi->tx_size);
@@ -742,16 +742,16 @@
rd_cost->rate = ctx->rd_stats.rate;
rd_cost->dist = ctx->rd_stats.dist;
rd_cost->rdcost = ctx->rd_stats.rdcost;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
const int is_inter = is_inter_block(&ctx->mic, xd->tree_type);
-#if CONFIG_IBC_SR_EXT && !CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
if (cm->seq_params.enable_refmvbank && is_inter &&
!is_intrabc_block(&ctx->mic, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank && is_inter)
-#endif // CONFIG_IBC_SR_EXT && !CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, &ctx->mic);
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, &ctx->mic);
#endif // WARP_CU_BANK
@@ -796,6 +796,9 @@
p[i].qcoeff = ctx->qcoeff[i];
p[i].dqcoeff = ctx->dqcoeff[i];
p[i].eobs = ctx->eobs[i];
+#if CONFIG_ATC_DCTX_ALIGNED
+ p[i].bobs = ctx->bobs[i];
+#endif // CONFIG_ATC_DCTX_ALIGNED
p[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i];
}
@@ -827,7 +830,6 @@
start_timing(cpi, av1_rd_pick_intra_mode_sb_time);
#endif
av1_rd_pick_intra_mode_sb(cpi, x, rd_cost, bsize, ctx, best_rd.rdcost);
-
#if CONFIG_COLLECT_COMPONENT_TIMING
end_timing(cpi, av1_rd_pick_intra_mode_sb_time);
#endif
@@ -847,16 +849,16 @@
#endif
}
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
const int is_inter = is_inter_block(mbmi, xd->tree_type);
-#if CONFIG_IBC_SR_EXT && !CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
if (cm->seq_params.enable_refmvbank && is_inter &&
!is_intrabc_block(mbmi, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank && is_inter)
-#endif // CONFIG_IBC_SR_EXT && !CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, mbmi);
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, mbmi);
@@ -898,6 +900,34 @@
if (mbmi->mode == AMVDNEWMV) max_drl_bits = AOMMIN(max_drl_bits, 1);
#endif // IMPROVED_AMVD
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
+#if CONFIG_SEP_COMP_DRL
+ assert(mbmi->ref_mv_idx[0] < max_drl_bits + 1);
+ assert(mbmi->ref_mv_idx[1] < max_drl_bits + 1);
+ for (int ref = 0; ref < 1 + has_second_drl(mbmi); ++ref) {
+ for (int idx = 0; idx < max_drl_bits; ++idx) {
+ const uint16_t *weight = has_second_drl(mbmi)
+ ? mbmi_ext->weight[mbmi->ref_frame[ref]]
+ : mbmi_ext->weight[ref_frame_type];
+ aom_cdf_prob *drl_cdf = av1_get_drl_cdf(fc, weight, mode_ctx, idx);
+#if CONFIG_ENTROPY_STATS
+ int drl_ctx = av1_drl_ctx(mode_ctx);
+ switch (idx) {
+ case 0:
+ counts->drl_mode[0][drl_ctx][mbmi->ref_mv_idx[ref] != idx]++;
+ break;
+ case 1:
+ counts->drl_mode[1][drl_ctx][mbmi->ref_mv_idx[ref] != idx]++;
+ break;
+ default:
+ counts->drl_mode[2][drl_ctx][mbmi->ref_mv_idx[ref] != idx]++;
+ break;
+ }
+#endif // CONFIG_ENTROPY_STATS
+ update_cdf(drl_cdf, mbmi->ref_mv_idx[ref] != idx, 2);
+ if (mbmi->ref_mv_idx[ref] == idx) break;
+ }
+ }
+#else
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf =
@@ -913,9 +943,10 @@
update_cdf(drl_cdf, mbmi->ref_mv_idx != idx, 2);
if (mbmi->ref_mv_idx == idx) break;
}
+#endif // CONFIG_SEP_COMP_DRL
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
static void update_intrabc_drl_idx_stats(int max_ref_bv_num, FRAME_CONTEXT *fc,
FRAME_COUNTS *counts,
const MB_MODE_INFO *mbmi) {
@@ -934,7 +965,32 @@
++bit_cnt;
}
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
+
+#if CONFIG_CWP
+// Update the stats for compound weighted prediction
+static void update_cwp_idx_stats(FRAME_CONTEXT *fc, FRAME_COUNTS *counts,
+ const AV1_COMMON *const cm, MACROBLOCKD *xd) {
+#if !CONFIG_ENTROPY_STATS
+ (void)counts;
+#endif // !CONFIG_ENTROPY_STATS
+ const MB_MODE_INFO *mbmi = xd->mi[0];
+
+ assert(mbmi->cwp_idx >= CWP_MIN && mbmi->cwp_idx <= CWP_MAX);
+ int bit_cnt = 0;
+ const int ctx = 0;
+
+ int8_t final_idx = get_cwp_coding_idx(mbmi->cwp_idx, 1, cm, mbmi);
+ for (int idx = 0; idx < MAX_CWP_NUM - 1; ++idx) {
+#if CONFIG_ENTROPY_STATS
+ counts->cwp_idx[bit_cnt][final_idx != idx]++;
+#endif // CONFIG_ENTROPY_STATS
+ update_cdf(fc->cwp_idx_cdf[ctx][bit_cnt], final_idx != idx, 2);
+ if (final_idx == idx) break;
+ ++bit_cnt;
+ }
+}
+#endif // CONFIG_CWP
#if CONFIG_EXTENDED_WARP_PREDICTION
static void update_warp_delta_param_stats(int index, int value,
@@ -975,7 +1031,11 @@
if (mbmi->warp_ref_idx == bit_idx) break;
}
}
- if (allow_warp_parameter_signaling(mbmi)) {
+ if (allow_warp_parameter_signaling(
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ cm,
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi)) {
#endif // CONFIG_WARP_REF_LIST
const WarpedMotionParams *params = &mbmi->wm_params[0];
WarpedMotionParams base_params;
@@ -1017,7 +1077,7 @@
#endif // CONFIG_WARP_REF_LIST
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
static void update_skip_drl_index_stats(int max_drl_bits, FRAME_CONTEXT *fc,
FRAME_COUNTS *counts,
const MB_MODE_INFO *mbmi) {
@@ -1025,9 +1085,26 @@
(void)counts;
#endif // !CONFIG_ENTROPY_STATS
assert(have_drl_index(mbmi->mode));
+#if CONFIG_SEP_COMP_DRL
+ assert(get_ref_mv_idx(mbmi, 0) < max_drl_bits + 1);
+ assert(get_ref_mv_idx(mbmi, 1) < max_drl_bits + 1);
+#else
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
+#endif // CONFIG_SEP_COMP_DRL
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf = fc->skip_drl_cdf[AOMMIN(idx, 2)];
+#if CONFIG_SEP_COMP_DRL
+ update_cdf(drl_cdf, mbmi->ref_mv_idx[0] != idx, 2);
+#if CONFIG_ENTROPY_STATS
+ switch (idx) {
+ case 0: counts->skip_drl_mode[idx][mbmi->ref_mv_idx[0] != idx]++; break;
+ case 1: counts->skip_drl_mode[idx][mbmi->ref_mv_idx[0] != idx]++; break;
+ default: counts->skip_drl_mode[2][mbmi->ref_mv_idx[0] != idx]++; break;
+ }
+#endif // CONFIG_ENTROPY_STATS
+ if (mbmi->ref_mv_idx[0] == idx) break;
+#else
+ update_cdf(drl_cdf, mbmi->ref_mv_idx != idx, 2);
#if CONFIG_ENTROPY_STATS
switch (idx) {
case 0: counts->skip_drl_mode[idx][mbmi->ref_mv_idx != idx]++; break;
@@ -1035,11 +1112,11 @@
default: counts->skip_drl_mode[2][mbmi->ref_mv_idx != idx]++; break;
}
#endif // CONFIG_ENTROPY_STATS
- update_cdf(drl_cdf, mbmi->ref_mv_idx != idx, 2);
if (mbmi->ref_mv_idx == idx) break;
+#endif // CONFIG_SEP_COMP_DRL
}
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
static void update_stats(const AV1_COMMON *const cm, ThreadData *td) {
MACROBLOCK *x = &td->mb;
@@ -1049,6 +1126,7 @@
const CurrentFrame *const current_frame = &cm->current_frame;
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
FRAME_CONTEXT *fc = xd->tile_ctx;
+ const int inter_block = mbmi->ref_frame[0] != INTRA_FRAME;
const int seg_ref_active = 0;
if (current_frame->skip_mode_info.skip_mode_flag && !seg_ref_active &&
@@ -1059,6 +1137,50 @@
#endif
update_cdf(fc->skip_mode_cdfs[skip_mode_ctx], mbmi->skip_mode, 2);
}
+
+#if CONFIG_SKIP_TXFM_OPT
+ const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
+ if (!seg_ref_active) {
+ if (!mbmi->skip_mode && !frame_is_intra_only(cm)) {
+ const int intra_inter_ctx = av1_get_intra_inter_context(xd);
+#if CONFIG_ENTROPY_STATS
+ td->counts->intra_inter[intra_inter_ctx][inter_block]++;
+#endif // CONFIG_ENTROPY_STATS
+ update_cdf(fc->intra_inter_cdf[intra_inter_ctx], inter_block, 2);
+ }
+
+ if (!inter_block && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+#if CONFIG_NEW_CONTEXT_MODELING
+ const int intrabc_ctx = get_intrabc_ctx(xd);
+ update_cdf(fc->intrabc_cdf[intrabc_ctx], use_intrabc, 2);
+#if CONFIG_ENTROPY_STATS
+ ++td->counts->intrabc[intrabc_ctx][use_intrabc];
+#endif // CONFIG_ENTROPY_STATS
+#else
+ update_cdf(fc->intrabc_cdf, use_intrabc, 2);
+#if CONFIG_ENTROPY_STATS
+ ++td->counts->intrabc[use_intrabc];
+#endif // CONFIG_ENTROPY_STATS
+#endif // CONFIG_NEW_CONTEXT_MODELING
+ }
+
+ if (inter_block || (!inter_block && use_intrabc)) {
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
+ if (!mbmi->skip_mode) {
+#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
+ const int skip_ctx = av1_get_skip_txfm_context(xd);
+#if CONFIG_ENTROPY_STATS
+ td->counts->skip_txfm[skip_ctx]
+ [mbmi->skip_txfm[xd->tree_type == CHROMA_PART]]++;
+#endif
+ update_cdf(fc->skip_txfm_cdfs[skip_ctx],
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART], 2);
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
+ }
+#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
+ }
+ }
+#else
#if CONFIG_SKIP_MODE_ENHANCEMENT
if (!seg_ref_active) {
#else
@@ -1072,6 +1194,7 @@
update_cdf(fc->skip_txfm_cdfs[skip_ctx],
mbmi->skip_txfm[xd->tree_type == CHROMA_PART], 2);
}
+#endif // CONFIG_SKIP_TXFM_OPT
#if CONFIG_ENTROPY_STATS
// delta quant applies to both intra and inter
@@ -1121,6 +1244,7 @@
av1_sum_intra_stats(cm, td->counts, xd, mbmi);
}
if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+#if !CONFIG_SKIP_TXFM_OPT
const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
#if CONFIG_NEW_CONTEXT_MODELING
const int intrabc_ctx = get_intrabc_ctx(xd);
@@ -1134,7 +1258,8 @@
++td->counts->intrabc[use_intrabc];
#endif // CONFIG_ENTROPY_STATS
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVCOST_UPDATE
+#endif // !CONFIG_SKIP_TXFM_OPT
+#if CONFIG_IBC_BV_IMPROVEMENT
if (use_intrabc) {
const int_mv ref_mv = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv;
#if CONFIG_FLEX_MVRES
@@ -1153,8 +1278,8 @@
}
#endif
-#endif // CONFIG_BVCOST_UPDATE
-#if CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
if (use_intrabc) {
update_cdf(fc->intrabc_mode_cdf, mbmi->intrabc_mode, 2);
#if CONFIG_ENTROPY_STATS
@@ -1162,29 +1287,37 @@
#endif // CONFIG_ENTROPY_STATS
update_intrabc_drl_idx_stats(MAX_REF_BV_STACK_SIZE, fc, td->counts, mbmi);
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode && have_drl_index(mbmi->mode)) {
FRAME_COUNTS *const counts = td->counts;
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
update_skip_drl_index_stats(cm->features.max_drl_bits, fc, counts, mbmi);
#else
const int16_t mode_ctx_pristine =
av1_mode_context_pristine(mbmi_ext->mode_context, mbmi->ref_frame);
update_drl_index_stats(cm->features.max_drl_bits, mode_ctx_pristine, fc,
counts, mbmi, mbmi_ext);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_REFINEMV
+ if (mbmi->skip_mode && switchable_refinemv_flag(cm, mbmi)) {
+ const int refinemv_ctx = av1_get_refinemv_context(cm, xd, bsize);
+ update_cdf(fc->refinemv_flag_cdf[refinemv_ctx], mbmi->refinemv_flag,
+ REFINEMV_NUM_MODES);
+ }
+#endif // CONFIG_REFINEMV
+
if (frame_is_intra_only(cm) || mbmi->skip_mode) return;
FRAME_COUNTS *const counts = td->counts;
- const int inter_block = mbmi->ref_frame[0] != INTRA_FRAME;
if (!seg_ref_active) {
+#if !CONFIG_SKIP_TXFM_OPT
#if CONFIG_ENTROPY_STATS && !CONFIG_CONTEXT_DERIVATION
counts->intra_inter[av1_get_intra_inter_context(xd)][inter_block]++;
#endif // CONFIG_ENTROPY_STATS && !CONFIG_CONTEXT_DERIVATION
@@ -1200,6 +1333,7 @@
update_cdf(fc->intra_inter_cdf[av1_get_intra_inter_context(xd)],
inter_block, 2);
#endif // CONFIG_CONTEXT_DERIVATION
+#endif // !CONFIG_SKIP_TXFM_OPT
// If the segment reference feature is enabled we have only a single
// reference frame allowed for the segment so exclude it from
// the reference frame counts used to work out probabilities.
@@ -1492,10 +1626,33 @@
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (allow_warpmv_with_mvd_coding(cm, mbmi)) {
+ update_cdf(fc->warpmv_with_mvd_flag_cdf[mbmi->sb_type[PLANE_TYPE_Y]],
+ mbmi->warpmv_with_mvd_flag, 2);
+ } else {
+ assert(mbmi->warpmv_with_mvd_flag == 0);
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+#if CONFIG_REFINEMV
+ int is_refinemv_signaled = switchable_refinemv_flag(cm, mbmi);
+ if (!mbmi->skip_mode && is_refinemv_signaled) {
+ const int refinemv_ctx = av1_get_refinemv_context(cm, xd, bsize);
+ update_cdf(fc->refinemv_flag_cdf[refinemv_ctx], mbmi->refinemv_flag,
+ REFINEMV_NUM_MODES);
+ }
+ assert(IMPLIES(mbmi->refinemv_flag && is_refinemv_signaled,
+ mbmi->comp_group_idx == 0 &&
+ mbmi->interinter_comp.type == COMPOUND_AVERAGE));
+#endif // CONFIG_REFINEMV
if (has_second_ref(mbmi)
#if CONFIG_OPTFLOW_REFINEMENT
&& mbmi->mode < NEAR_NEARMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_REFINEMV
+ && (!mbmi->refinemv_flag || !is_refinemv_signaled)
+#endif // CONFIG_REFINEMV
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
&& !is_joint_amvd_coding_mode(mbmi->mode)
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
@@ -1546,12 +1703,21 @@
#endif // CONFIG_WEDGE_MOD_EXT
}
}
+
+#if CONFIG_CWP
+ if (cm->features.enable_cwp && is_cwp_allowed(mbmi) && !mbmi->skip_mode) {
+ update_cwp_idx_stats(fc, td->counts, cm, xd);
+ }
+#endif // CONFIG_CWP
}
}
if (inter_block && cm->features.interp_filter == SWITCHABLE &&
- !is_warp_mode(mbmi->motion_mode) &&
- !is_nontrans_global_motion(xd, mbmi)) {
+ !is_warp_mode(mbmi->motion_mode) && !is_nontrans_global_motion(xd, mbmi)
+#if CONFIG_REFINEMV
+ && !(mbmi->refinemv_flag || mbmi->mode >= NEAR_NEARMV_OPTFLOW)
+#endif // CONFIG_REFINEMV
+ ) {
update_filter_type_cdf(xd, mbmi);
}
if (inter_block &&
@@ -1625,11 +1791,44 @@
update_drl_index_stats(cm->features.max_drl_bits, mode_ctx_pristine, fc,
counts, mbmi, mbmi_ext);
}
- if (have_newmv_in_inter_mode(mbmi->mode) && xd->tree_type != CHROMA_PART) {
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (xd->tree_type != CHROMA_PART && mbmi->mode == WARPMV) {
+ if (mbmi->warpmv_with_mvd_flag) {
+ WarpedMotionParams ref_warp_model =
+ mbmi_ext
+ ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
+ [mbmi->warp_ref_idx]
+ .wm_params;
+ const int_mv ref_mv =
+ get_mv_from_wrl(xd, &ref_warp_model, mbmi->pb_mv_precision, bsize,
+ xd->mi_col, xd->mi_row);
+ assert(is_adaptive_mvd == 0);
+
#if CONFIG_FLEX_MVRES
- const int pb_mv_precision = mbmi->pb_mv_precision;
- assert(IMPLIES(cm->features.cur_frame_force_integer_mv,
- pb_mv_precision == MV_PRECISION_ONE_PEL));
+ av1_update_mv_stats(mbmi->mv[0].as_mv, ref_mv.as_mv, &fc->nmvc,
+#if CONFIG_ADAPTIVE_MVD
+ is_adaptive_mvd,
+#endif // CONFIG_ADAPTIVE_MVD
+ mbmi->pb_mv_precision);
+#else
+ av1_update_mv_stats(&mbmi->mv[0].as_mv, &ref_mv.as_mv, &fc->nmvc,
+#if CONFIG_ADAPTIVE_MVD
+ is_adaptive_mvd,
+#endif // CONFIG_ADAPTIVE_MVD
+ allow_hp);
+#endif
+ }
+
+ } else {
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+ if (have_newmv_in_inter_mode(mbmi->mode) &&
+ xd->tree_type != CHROMA_PART) {
+#if CONFIG_FLEX_MVRES
+ const int pb_mv_precision = mbmi->pb_mv_precision;
+ assert(IMPLIES(cm->features.cur_frame_force_integer_mv,
+ pb_mv_precision == MV_PRECISION_ONE_PEL));
#else
const int allow_hp = cm->features.cur_frame_force_integer_mv
? MV_SUBPEL_NONE
@@ -1637,41 +1836,42 @@
#endif
#if CONFIG_FLEX_MVRES
- if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
+ if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
#if CONFIG_ADAPTIVE_MVD
- assert(!is_adaptive_mvd);
+ assert(!is_adaptive_mvd);
#endif
- assert(mbmi->most_probable_pb_mv_precision <= mbmi->max_mv_precision);
- const int mpp_flag_context = av1_get_mpp_flag_context(cm, xd);
- const int mpp_flag =
- (mbmi->pb_mv_precision == mbmi->most_probable_pb_mv_precision);
- update_cdf(fc->pb_mv_mpp_flag_cdf[mpp_flag_context], mpp_flag, 2);
+ assert(mbmi->most_probable_pb_mv_precision <= mbmi->max_mv_precision);
+ const int mpp_flag_context = av1_get_mpp_flag_context(cm, xd);
+ const int mpp_flag =
+ (mbmi->pb_mv_precision == mbmi->most_probable_pb_mv_precision);
+ update_cdf(fc->pb_mv_mpp_flag_cdf[mpp_flag_context], mpp_flag, 2);
- if (!mpp_flag) {
- const PRECISION_SET *precision_def =
- &av1_mv_precision_sets[mbmi->mb_precision_set];
- int down = av1_get_pb_mv_precision_index(mbmi);
- int nsymbs = precision_def->num_precisions - 1;
+ if (!mpp_flag) {
+ const PRECISION_SET *precision_def =
+ &av1_mv_precision_sets[mbmi->mb_precision_set];
+ int down = av1_get_pb_mv_precision_index(mbmi);
+ int nsymbs = precision_def->num_precisions - 1;
- const int down_ctx = av1_get_pb_mv_precision_down_context(cm, xd);
+ const int down_ctx = av1_get_pb_mv_precision_down_context(cm, xd);
- update_cdf(fc->pb_mv_precision_cdf[down_ctx][mbmi->max_mv_precision -
- MV_PRECISION_HALF_PEL],
- down, nsymbs);
+ update_cdf(
+ fc->pb_mv_precision_cdf[down_ctx][mbmi->max_mv_precision -
+ MV_PRECISION_HALF_PEL],
+ down, nsymbs);
+ }
}
- }
#endif // CONFIG_FLEX_MVRES
- if (new_mv) {
- for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
- const int_mv ref_mv = av1_get_ref_mv(x, ref);
+ if (new_mv) {
+ for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
+ const int_mv ref_mv = av1_get_ref_mv(x, ref);
#if CONFIG_FLEX_MVRES
- av1_update_mv_stats(mbmi->mv[ref].as_mv, ref_mv.as_mv, &fc->nmvc,
+ av1_update_mv_stats(mbmi->mv[ref].as_mv, ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
- is_adaptive_mvd,
+ is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
- pb_mv_precision);
+ pb_mv_precision);
#else
av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
@@ -1679,23 +1879,23 @@
#endif // CONFIG_ADAPTIVE_MVD
allow_hp);
#endif
- }
- } else if (have_nearmv_newmv_in_inter_mode(mbmi->mode)) {
- const int ref =
+ }
+ } else if (have_nearmv_newmv_in_inter_mode(mbmi->mode)) {
+ const int ref =
#if CONFIG_OPTFLOW_REFINEMENT
- mbmi->mode == NEAR_NEWMV_OPTFLOW ||
+ mbmi->mode == NEAR_NEWMV_OPTFLOW ||
#endif // CONFIG_OPTFLOW_REFINEMENT
#if CONFIG_JOINT_MVD
- jmvd_base_ref_list ||
+ jmvd_base_ref_list ||
#endif // CONFIG_JOINT_MVD
- mbmi->mode == NEAR_NEWMV;
- const int_mv ref_mv = av1_get_ref_mv(x, ref);
+ mbmi->mode == NEAR_NEWMV;
+ const int_mv ref_mv = av1_get_ref_mv(x, ref);
#if CONFIG_FLEX_MVRES
- av1_update_mv_stats(mbmi->mv[ref].as_mv, ref_mv.as_mv, &fc->nmvc,
+ av1_update_mv_stats(mbmi->mv[ref].as_mv, ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
- is_adaptive_mvd,
+ is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
- pb_mv_precision);
+ pb_mv_precision);
#else
av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
@@ -1703,8 +1903,12 @@
#endif // CONFIG_ADAPTIVE_MVD
allow_hp);
#endif
+ }
}
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
}
}
@@ -1828,9 +2032,9 @@
assert(!frame_is_intra_only(cm));
rdc->skip_mode_used_flag = 1;
if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) {
-#if !CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
assert(has_second_ref(mbmi));
-#endif // !CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
rdc->compound_ref_used_flag = 1;
}
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
@@ -1859,7 +2063,11 @@
if ((!cpi->sf.inter_sf.disable_obmc &&
cpi->sf.inter_sf.prune_obmc_prob_thresh > 0) ||
#if CONFIG_EXTENDED_WARP_PREDICTION
- cpi->sf.inter_sf.prune_warped_prob_thresh > 0) {
+ cpi->sf.inter_sf.prune_warped_prob_thresh > 0
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || cpi->sf.inter_sf.prune_warpmv_prob_thresh > 0
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ ) {
#else
(cm->features.allow_warped_motion &&
cpi->sf.inter_sf.prune_warped_prob_thresh > 0)) {
@@ -1874,11 +2082,20 @@
if (allowed_motion_modes & (1 << OBMC_CAUSAL)) {
td->rd_counts.obmc_used[bsize][mbmi->motion_mode == OBMC_CAUSAL]++;
}
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ int is_warp_allowed = (allowed_motion_modes & (1 << WARPED_CAUSAL)) ||
+ (allowed_motion_modes & (1 << WARP_DELTA)) ||
+ (allowed_motion_modes & (1 << WARP_EXTEND));
+ if (is_warp_allowed) {
+ td->rd_counts.warped_used[mbmi->motion_mode >= WARPED_CAUSAL]++;
+ }
+#else
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
td->rd_counts.warped_used[mbmi->motion_mode == WARPED_CAUSAL]++;
}
- // TODO(rachelbarker): Add counts and pruning for WARP_DELTA and
- // WARP_EXTEND
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ // TODO(rachelbarker): Add counts and pruning for WARP_DELTA and
+ // WARP_EXTEND
}
#else
const MOTION_MODE motion_allowed = motion_mode_allowed(cm, xd, mbmi);
@@ -1901,7 +2118,7 @@
// frame level buffer (cpi->mbmi_ext_info.frame_base) will be used during
// bitstream preparation.
if (xd->tree_type != CHROMA_PART)
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
{
if (mbmi->skip_mode) {
const SkipModeInfo *const skip_mode_info =
@@ -1928,16 +2145,20 @@
// mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
av1_copy_usable_ref_mv_stack_and_weight(xd, x->mbmi_ext, ref_frame_type);
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+
av1_copy_mbmi_ext_to_mbmi_ext_frame(
x->mbmi_ext_frame, x->mbmi_ext,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SEP_COMP_DRL
+ mbmi,
+#endif // CONFIG_SEP_COMP_DRL
+#if CONFIG_SKIP_MODE_ENHANCEMENT
mbmi->skip_mode,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
av1_ref_frame_type(xd->mi[0]->ref_frame));
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
x->rdmult = origin_mult;
}
@@ -1949,44 +2170,27 @@
const CommonModeInfoParams *const mi_params,
#if CONFIG_EXT_RECUR_PARTITIONS
int disable_ext_part,
-#if !CONFIG_H_PARTITION
- PARTITION_TREE const *ptree,
-#endif // !CONFIG_H_PARTITION
PARTITION_TREE const *ptree_luma,
const CHROMA_REF_INFO *chroma_ref_info,
#endif // CONFIG_EXT_RECUR_PARTITIONS
PARTITION_TYPE partition, const int mi_row,
const int mi_col, BLOCK_SIZE bsize,
const int ctx, BLOCK_SIZE sb_size) {
- const int plane_index = xd->tree_type == CHROMA_PART;
+ const TREE_TYPE tree_type = xd->tree_type;
+ const int plane_index = tree_type == CHROMA_PART;
FRAME_CONTEXT *fc = xd->tile_ctx;
#if CONFIG_EXT_RECUR_PARTITIONS
- if (!is_partition_point(bsize)) {
- return;
- }
- if (xd->tree_type == CHROMA_PART && bsize == BLOCK_8X8) {
- return;
- }
+ const bool ss_x = xd->plane[1].subsampling_x;
+ const bool ss_y = xd->plane[1].subsampling_y;
- const int ss_x = xd->plane[1].subsampling_x;
- const int ss_y = xd->plane[1].subsampling_y;
- if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
- PARTITION_TYPE derived_partition_mode =
- sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ss_x, ss_y);
- assert(partition == derived_partition_mode &&
- "Chroma partition does not match the derived mode.");
- (void)derived_partition_mode;
- return;
- }
-
- PARTITION_TYPE implied_partition;
- const bool is_part_implied = is_partition_implied_at_boundary(
- mi_params, xd->tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
- chroma_ref_info, &implied_partition);
- if (is_part_implied) {
- assert(partition == implied_partition &&
- "Partition doesn't match the implied partition at boundary.");
+ const PARTITION_TYPE derived_partition =
+ av1_get_normative_forced_partition_type(mi_params, tree_type, ss_x, ss_y,
+ mi_row, mi_col, bsize, ptree_luma,
+ chroma_ref_info);
+ if (derived_partition != PARTITION_INVALID) {
+ assert(partition == derived_partition &&
+ "Partition does not match normatively derived partition.");
return;
}
@@ -2016,7 +2220,7 @@
}
RECT_PART_TYPE rect_type = get_rect_part_type(partition);
- if (rect_type_implied_by_bsize(bsize, xd->tree_type) == RECT_INVALID) {
+ if (rect_type_implied_by_bsize(bsize, tree_type) == RECT_INVALID) {
#if CONFIG_ENTROPY_STATS
counts->rect_type[plane_index][ctx][rect_type]++;
#endif // CONFIG_ENTROPY_STATS
@@ -2025,7 +2229,7 @@
const bool ext_partition_allowed =
!disable_ext_part &&
- is_ext_partition_allowed(bsize, rect_type, xd->tree_type);
+ is_ext_partition_allowed(bsize, rect_type, tree_type);
if (ext_partition_allowed) {
const bool do_ext_partition = (partition >= PARTITION_HORZ_3);
#if CONFIG_ENTROPY_STATS
@@ -2033,6 +2237,35 @@
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->do_ext_partition_cdf[plane_index][rect_type][ctx],
do_ext_partition, 2);
+#if CONFIG_UNEVEN_4WAY
+ if (do_ext_partition) {
+ const bool uneven_4way_partition_allowed =
+ is_uneven_4way_partition_allowed(bsize, rect_type, tree_type);
+ if (uneven_4way_partition_allowed) {
+ const bool do_uneven_4way_partition = (partition >= PARTITION_HORZ_4A);
+#if CONFIG_ENTROPY_STATS
+ counts->do_uneven_4way_partition[plane_index][rect_type][ctx]
+ [do_uneven_4way_partition]++;
+#endif // CONFIG_ENTROPY_STATS
+ update_cdf(
+ fc->do_uneven_4way_partition_cdf[plane_index][rect_type][ctx],
+ do_uneven_4way_partition, 2);
+ if (do_uneven_4way_partition) {
+ const UNEVEN_4WAY_PART_TYPE uneven_4way_type =
+ (partition == PARTITION_HORZ_4A || partition == PARTITION_VERT_4A)
+ ? UNEVEN_4A
+ : UNEVEN_4B;
+#if CONFIG_ENTROPY_STATS
+ counts->uneven_4way_partition_type[plane_index][rect_type][ctx]
+ [uneven_4way_type]++;
+#endif // CONFIG_ENTROPY_STATS
+ update_cdf(
+ fc->uneven_4way_partition_type_cdf[plane_index][rect_type][ctx],
+ uneven_4way_type, NUM_UNEVEN_4WAY_PARTS);
+ }
+ }
+ }
+#endif // CONFIG_UNEVEN_4WAY
}
#else // CONFIG_EXT_RECUR_PARTITIONS
const int hbs_w = mi_size_wide[bsize] / 2;
@@ -2042,8 +2275,7 @@
if (has_rows && has_cols) {
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) {
+ if (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) {
@@ -2147,10 +2379,14 @@
assert(bsize < BLOCK_SIZES_ALL);
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
-#if !CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ const int ebs_w = mi_size_wide[bsize] / 8;
+ const int ebs_h = mi_size_high[bsize] / 8;
+#endif // CONFIG_UNEVEN_4WAY
+#if !CONFIG_EXT_RECUR_PARTITIONS
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
-#endif // !CONFIG_H_PARTITION
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
const int is_partition_root = is_partition_point(bsize);
const int ctx = is_partition_root
? partition_plane_context(xd, mi_row, mi_col, bsize)
@@ -2159,9 +2395,10 @@
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
#if CONFIG_EXT_RECUR_PARTITIONS
const bool disable_ext_part = !cm->seq_params.enable_ext_partitions;
-#else
- const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
+ const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
if (subsize == BLOCK_INVALID) return;
@@ -2172,11 +2409,8 @@
#endif // CONFIG_ENTROPY_STATS
tile_data->allow_update_cdf, mi_params,
#if CONFIG_EXT_RECUR_PARTITIONS
- disable_ext_part,
-#if !CONFIG_H_PARTITION
- ptree,
-#endif // !CONFIG_H_PARTITION
- ptree_luma, &pc_tree->chroma_ref_info,
+ disable_ext_part, ptree_luma,
+ &pc_tree->chroma_ref_info,
#endif // CONFIG_EXT_RECUR_PARTITIONS
partition, mi_row, mi_col, bsize, ctx, cm->sb_size);
@@ -2198,12 +2432,18 @@
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,
+ xd->tree_type, 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) {
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B:
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B:
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_SPLIT:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
@@ -2221,9 +2461,7 @@
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);
-#if CONFIG_H_PARTITION
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
-#endif // CONFIG_H_PARTITION
break;
#endif // CONFIG_EXT_RECUR_PARTITIONS
default: break;
@@ -2290,7 +2528,96 @@
#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
#if CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->horizontal4a[0], sub_tree[0],
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+ if (mi_row + ebs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run,
+ bsize_med, pc_tree->horizontal4a[1], sub_tree[1],
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+ if (mi_row + 3 * ebs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + 3 * ebs_h, mi_col, dry_run,
+ bsize_big, pc_tree->horizontal4a[2], sub_tree[2],
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+ if (mi_row + 7 * ebs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run,
+ subsize, pc_tree->horizontal4a[3], sub_tree[3],
+ track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+ break;
+ }
+ case PARTITION_HORZ_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->horizontal4b[0], sub_tree[0],
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+ if (mi_row + ebs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run,
+ bsize_big, pc_tree->horizontal4b[1], sub_tree[1],
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+ if (mi_row + 5 * ebs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + 5 * ebs_h, mi_col, dry_run,
+ bsize_med, pc_tree->horizontal4b[2], sub_tree[2],
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+ if (mi_row + 7 * ebs_h >= cm->mi_params.mi_rows) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run,
+ subsize, pc_tree->horizontal4b[3], sub_tree[3],
+ track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+ break;
+ }
+ case PARTITION_VERT_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->vertical4a[0], sub_tree[0],
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+ if (mi_col + ebs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run,
+ bsize_med, pc_tree->vertical4a[1], sub_tree[1],
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+ if (mi_col + 3 * ebs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 3 * ebs_w, dry_run,
+ bsize_big, pc_tree->vertical4a[2], sub_tree[2],
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+ if (mi_col + 7 * ebs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run,
+ subsize, pc_tree->vertical4a[3], sub_tree[3],
+ track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+ break;
+ }
+ case PARTITION_VERT_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
+ pc_tree->vertical4b[0], sub_tree[0],
+ track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+ if (mi_col + ebs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run,
+ bsize_big, pc_tree->vertical4b[1], sub_tree[1],
+ track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+ if (mi_col + 5 * ebs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 5 * ebs_w, dry_run,
+ bsize_med, pc_tree->vertical4b[2], sub_tree[2],
+ track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+ if (mi_col + 7 * ebs_w >= cm->mi_params.mi_cols) break;
+ encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run,
+ subsize, pc_tree->vertical4b[3], sub_tree[3],
+ track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+ break;
+ }
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3:
case PARTITION_VERT_3: {
for (int i = 0; i < 4; ++i) {
@@ -2315,38 +2642,6 @@
}
break;
}
-#else
- 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],
- track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, 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],
- track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, 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],
- track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, 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],
- track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, 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],
- track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, 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],
- track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
- break;
- }
-#endif // CONFIG_H_PARTITION
case PARTITION_SPLIT:
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->split[0], sub_tree[0],
@@ -2443,7 +2738,7 @@
const int ss_y = cm->seq_params.subsampling_y;
PARTITION_TREE *parent = ptree->parent;
- set_chroma_ref_info(mi_row, mi_col, ptree->index, bsize,
+ set_chroma_ref_info(tree_type, mi_row, mi_col, ptree->index, bsize,
&ptree->chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
@@ -2592,13 +2887,14 @@
if (ptree) {
#ifndef NDEBUG
#if CONFIG_EXT_RECUR_PARTITIONS
- const bool ssx = cm->cur_frame->buf.subsampling_x;
- const bool ssy = cm->cur_frame->buf.subsampling_y;
- PARTITION_TYPE implied_partition;
- const bool is_part_implied = is_partition_implied_at_boundary(
- &cm->mi_params, tree_type, ssx, ssy, mi_row, mi_col, bsize,
- &ptree->chroma_ref_info, &implied_partition);
- assert(IMPLIES(is_part_implied, ptree->partition == implied_partition));
+ const bool ss_x = cm->cur_frame->buf.subsampling_x;
+ const bool ss_y = cm->cur_frame->buf.subsampling_y;
+ const PARTITION_TYPE derived_partition =
+ av1_get_normative_forced_partition_type(
+ &cm->mi_params, tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
+ /* ptree_luma= */ NULL, &ptree->chroma_ref_info);
+ assert(IMPLIES(derived_partition != PARTITION_INVALID,
+ ptree->partition == derived_partition));
#endif // CONFIG_EXT_RECUR_PARTITIONS
#endif // NDEBUG
return ptree->partition;
@@ -2681,8 +2977,8 @@
if (pc_tree->none == NULL) {
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);
+ av1_alloc_pmc(cm, xd->tree_type, 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;
@@ -2719,9 +3015,9 @@
for (int i = 0; i < SUB_PARTITIONS_SPLIT; ++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);
+ pc_tree->split[i] = av1_alloc_pc_tree_node(
+ xd->tree_type, 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) {
@@ -2731,11 +3027,12 @@
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[0] =
+ av1_alloc_pc_tree_node(xd->tree_type, 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_alloc_pc_tree_node(xd->tree_type, 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,
@@ -2744,8 +3041,8 @@
for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
if (pc_tree->horizontal[i] == NULL) {
pc_tree->horizontal[i] = av1_alloc_pmc(
- cm, mi_row + hbs * i, mi_col, subsize, pc_tree, PARTITION_HORZ, i,
- ss_x, ss_y, &td->shared_coeff_buf);
+ cm, xd->tree_type, 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,
@@ -2781,11 +3078,12 @@
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[0] =
+ av1_alloc_pc_tree_node(xd->tree_type, 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_alloc_pc_tree_node(xd->tree_type, 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,
@@ -2794,8 +3092,8 @@
for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
if (pc_tree->vertical[i] == NULL) {
pc_tree->vertical[i] = av1_alloc_pmc(
- cm, mi_row, mi_col + hbs * i, subsize, pc_tree, PARTITION_VERT, i,
- ss_x, ss_y, &td->shared_coeff_buf);
+ cm, xd->tree_type, 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,
@@ -2842,8 +3140,8 @@
(mi_col + x_idx >= mi_params->mi_cols))
continue;
pc_tree->split[i] = av1_alloc_pc_tree_node(
- mi_row + y_idx, mi_col + x_idx, subsize, pc_tree, PARTITION_SPLIT,
- i, i == 3, ss_x, ss_y);
+ xd->tree_type, mi_row + y_idx, mi_col + x_idx, subsize, pc_tree,
+ PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
av1_init_rd_stats(&tmp_rdc);
av1_rd_use_partition(
@@ -2860,6 +3158,12 @@
last_part_rdc.dist += tmp_rdc.dist;
}
break;
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ case PARTITION_HORZ_4B:
+ case PARTITION_VERT_4A:
+ case PARTITION_VERT_4B:
+#endif // CONFIG_UNEVEN_4WAY
case PARTITION_HORZ_3:
case PARTITION_VERT_3:
#else // CONFIG_EXT_RECUR_PARTITIONS
@@ -2950,6 +3254,44 @@
*dist = last_part_rdc.dist;
x->rdmult = orig_rdmult;
}
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+/*! \brief Contains level banks used for rdopt.*/
+typedef struct LevelBanksRDO {
+#if CONFIG_MVP_IMPROVEMENT
+ //! The current level bank, used to restore the level bank in MACROBLOCKD.
+ REF_MV_BANK curr_level_bank;
+ //! The best level bank from the rdopt process.
+ REF_MV_BANK best_level_bank;
+#endif // CONFIG_MVP_IMPROVEMENT
+#if WARP_CU_BANK
+ //! The current warp, level bank, used to restore the warp level bank in
+ //! MACROBLOCKD.
+ WARP_PARAM_BANK curr_level_warp_bank;
+ //! The best warp level bank from the rdopt process.
+ WARP_PARAM_BANK best_level_warp_bank;
+#endif // WARP_CU_BANK
+} LevelBanksRDO;
+
+static AOM_INLINE void update_best_level_banks(LevelBanksRDO *level_banks,
+ const MACROBLOCKD *xd) {
+#if CONFIG_MVP_IMPROVEMENT
+ level_banks->best_level_bank = xd->ref_mv_bank;
+#endif // CONFIG_MVP_IMPROVEMENT
+#if WARP_CU_BANK
+ level_banks->best_level_warp_bank = xd->warp_param_bank;
+#endif // WARP_CU_BANK
+}
+
+static AOM_INLINE void restore_level_banks(MACROBLOCKD *xd,
+ const LevelBanksRDO *level_banks) {
+#if CONFIG_MVP_IMPROVEMENT
+ xd->ref_mv_bank = level_banks->curr_level_bank;
+#endif // CONFIG_MVP_IMPROVEMENT
+#if WARP_CU_BANK
+ xd->warp_param_bank = level_banks->curr_level_warp_bank;
+#endif // WARP_CU_BANK
+}
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
#if !CONFIG_EXT_RECUR_PARTITIONS
// Try searching for an encoding for the given subblock. Returns zero if the
@@ -3012,15 +3354,10 @@
PARTITION_TYPE partition,
const BLOCK_SIZE ab_subsize[SUB_PARTITIONS_AB],
const int ab_mi_pos[SUB_PARTITIONS_AB][2]
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- REF_MV_BANK *best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- WARP_PARAM_BANK *best_level_warp_bank
-#endif // WARP_CU_BANK
-
+ LevelBanksRDO *level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const MACROBLOCK *const x = &td->mb;
const MACROBLOCKD *const xd = &x->e_mbd;
@@ -3045,22 +3382,46 @@
if (sum_rdc.rdcost >= best_rdc->rdcost) return false;
*best_rdc = sum_rdc;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
pc_tree->partitioning = partition;
return true;
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
+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, const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree,
+ const CHROMA_REF_INFO *chroma_ref_info) {
+ // Partition types forced by bitstream syntax.
+ const MACROBLOCKD *xd = &x->e_mbd;
+ const bool ss_x = cm->seq_params.subsampling_x;
+ const bool ss_y = cm->seq_params.subsampling_y;
+ const PARTITION_TYPE derived_partition =
+ av1_get_normative_forced_partition_type(&cm->mi_params, xd->tree_type,
+ ss_x, ss_y, mi_row, mi_col, bsize,
+ ptree_luma, chroma_ref_info);
+ if (derived_partition != PARTITION_INVALID) {
+ return derived_partition;
+ }
+
+ // Partition types forced by speed_features.
+ if (template_tree) {
+ return template_tree->partition;
+ }
+
+ if (should_reuse_mode(x, REUSE_PARTITION_MODE_FLAG)) {
+ return av1_get_prev_partition(x, mi_row, mi_col, bsize, cm->sb_size);
+ }
+ return PARTITION_INVALID;
+}
+
static AOM_INLINE void init_allowed_partitions(
PartitionSearchState *part_search_state, const PartitionCfg *part_cfg,
- const CHROMA_REF_INFO *chroma_ref_info,
- const CommonModeInfoParams *mi_params, TREE_TYPE tree_type) {
+ const CHROMA_REF_INFO *chroma_ref_info, TREE_TYPE tree_type) {
const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
const int mi_row = blk_params->mi_row;
const int mi_col = blk_params->mi_col;
@@ -3099,38 +3460,89 @@
is_bsize_geq(vert_subsize, blk_params->min_partition_size) &&
is_vert_size_valid;
- // Boundary Handling
- PARTITION_TYPE implied_partition;
- const bool is_part_implied = is_partition_implied_at_boundary(
- mi_params, tree_type, ss_x, ss_y, mi_row, mi_col, bsize, chroma_ref_info,
- &implied_partition);
- if (is_part_implied) {
- part_search_state->partition_none_allowed = false;
- if (implied_partition == PARTITION_HORZ) {
- part_search_state->partition_rect_allowed[VERT] = false;
- } else {
- assert(implied_partition == PARTITION_VERT);
- part_search_state->partition_rect_allowed[HORZ] = false;
- }
- }
+ const int ext_partition_allowed = part_search_state->ext_partition_allowed =
+ part_cfg->enable_ext_partitions &&
+ is_ext_partition_allowed_at_bsize(bsize, tree_type);
+
+ part_search_state->partition_3_allowed[HORZ] =
+ ext_partition_allowed &&
+ get_partition_subsize(bsize, PARTITION_HORZ_3) != BLOCK_INVALID &&
+ check_is_chroma_size_valid(tree_type, PARTITION_HORZ_3, bsize, mi_row,
+ mi_col, ss_x, ss_y, chroma_ref_info) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_3),
+ blk_params->min_partition_size);
+
+ part_search_state->partition_3_allowed[VERT] =
+ ext_partition_allowed &&
+ get_partition_subsize(bsize, PARTITION_VERT_3) != BLOCK_INVALID &&
+ check_is_chroma_size_valid(tree_type, PARTITION_VERT_3, bsize, mi_row,
+ mi_col, ss_x, ss_y, chroma_ref_info) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_3),
+ blk_params->min_partition_size);
+
+#if CONFIG_UNEVEN_4WAY
+ part_search_state->partition_4a_allowed[HORZ] =
+ ext_partition_allowed &&
+ get_partition_subsize(bsize, PARTITION_HORZ_4A) != BLOCK_INVALID &&
+ check_is_chroma_size_valid(tree_type, PARTITION_HORZ_4A, bsize, mi_row,
+ mi_col, ss_x, ss_y, chroma_ref_info) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_4A),
+ blk_params->min_partition_size) &&
+ IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_HORZ_4A, ss_x, ss_y),
+ blk_params->has_7_8th_rows);
+
+ part_search_state->partition_4b_allowed[HORZ] =
+ ext_partition_allowed &&
+ get_partition_subsize(bsize, PARTITION_HORZ_4B) != BLOCK_INVALID &&
+ check_is_chroma_size_valid(tree_type, PARTITION_HORZ_4B, bsize, mi_row,
+ mi_col, ss_x, ss_y, chroma_ref_info) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_4B),
+ blk_params->min_partition_size) &&
+ IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_HORZ_4B, ss_x, ss_y),
+ blk_params->has_7_8th_rows);
+
+ part_search_state->partition_4a_allowed[VERT] =
+ ext_partition_allowed &&
+ get_partition_subsize(bsize, PARTITION_VERT_4A) != BLOCK_INVALID &&
+ check_is_chroma_size_valid(tree_type, PARTITION_VERT_4A, bsize, mi_row,
+ mi_col, ss_x, ss_y, chroma_ref_info) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_4A),
+ blk_params->min_partition_size) &&
+ IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_VERT_4A, ss_x, ss_y),
+ blk_params->has_7_8th_cols);
+
+ part_search_state->partition_4b_allowed[VERT] =
+ ext_partition_allowed &&
+ get_partition_subsize(bsize, PARTITION_VERT_4B) != BLOCK_INVALID &&
+ check_is_chroma_size_valid(tree_type, PARTITION_VERT_4B, bsize, mi_row,
+ mi_col, ss_x, ss_y, chroma_ref_info) &&
+ is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_4B),
+ blk_params->min_partition_size) &&
+ IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_VERT_4B, ss_x, ss_y),
+ blk_params->has_7_8th_cols);
+#endif // CONFIG_UNEVEN_4WAY
// Reset the flag indicating whether a partition leading to a rdcost lower
// than the bound best_rdc has been found.
part_search_state->found_best_partition = false;
}
+
+static const int kZeroPartitionCosts[ALL_PARTITION_TYPES];
#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,
+ PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree, int max_recursion_depth,
#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;
+ const TREE_TYPE tree_type = xd->tree_type;
assert(bsize < BLOCK_SIZES_ALL);
@@ -3163,10 +3575,19 @@
#endif // !CONFIG_EXT_RECUR_PARTITIONS
blk_params->bsize = bsize;
+ // Chroma subsampling.
+ part_search_state->ss_x = x->e_mbd.plane[1].subsampling_x;
+ part_search_state->ss_y = x->e_mbd.plane[1].subsampling_y;
+
// Check if the partition corresponds to edge block.
blk_params->has_rows = (blk_params->mi_row_edge < mi_params->mi_rows);
blk_params->has_cols = (blk_params->mi_col_edge < mi_params->mi_cols);
+ const int ebw = mi_size_wide[bsize] / 8;
+ const int ebh = mi_size_high[bsize] / 8;
+ blk_params->has_7_8th_rows = (mi_row + 7 * ebh < mi_params->mi_rows);
+ blk_params->has_7_8th_cols = (mi_col + 7 * ebw < mi_params->mi_cols);
+
// Update intra partitioning related info.
part_search_state->intra_part_info = &x->part_search_info;
// Prepare for segmentation CNN-based partitioning for intra-frame.
@@ -3188,8 +3609,16 @@
// Partition cost buffer update
ModeCosts *mode_costs = &x->mode_costs;
part_search_state->partition_cost =
- mode_costs->partition_cost[xd->tree_type == CHROMA_PART]
+ mode_costs->partition_cost[tree_type == CHROMA_PART]
[part_search_state->pl_ctx_idx];
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (av1_get_normative_forced_partition_type(
+ mi_params, tree_type, part_search_state->ss_x,
+ part_search_state->ss_y, mi_row, mi_col, bsize, ptree_luma,
+ &pc_tree->chroma_ref_info) != PARTITION_INVALID) {
+ part_search_state->partition_cost = kZeroPartitionCosts;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Initialize HORZ and VERT win flags as true for all split partitions.
for (int i = 0; i < SUB_PARTITIONS_SPLIT; i++) {
@@ -3210,26 +3639,46 @@
// Initialize HORZ and VERT partitions to be not ready.
av1_zero(part_search_state->is_rect_ctx_is_ready);
- // Chroma subsampling.
- part_search_state->ss_x = x->e_mbd.plane[1].subsampling_x;
- part_search_state->ss_y = x->e_mbd.plane[1].subsampling_y;
-
// Initialize partition search flags to defaults.
part_search_state->terminate_partition_search = 0;
av1_zero(part_search_state->prune_rect_part);
#if CONFIG_EXT_RECUR_PARTITIONS
+ part_search_state->partition_boundaries = NULL;
+ part_search_state->prune_partition_none = false;
+ av1_zero(part_search_state->prune_partition_3);
+#if CONFIG_UNEVEN_4WAY
+ av1_zero(part_search_state->prune_partition_4a);
+ av1_zero(part_search_state->prune_partition_4b);
+#endif // CONFIG_UNEVEN_4WAY
+
+ part_search_state->forced_partition =
+ get_forced_partition_type(cm, x, mi_row, mi_col, bsize, ptree_luma,
+ template_tree, &pc_tree->chroma_ref_info);
+
init_allowed_partitions(part_search_state, &cpi->oxcf.part_cfg,
- &pc_tree->chroma_ref_info, &cm->mi_params,
- xd->tree_type);
+ &pc_tree->chroma_ref_info, tree_type);
+
+ if (max_recursion_depth == 0) {
+ part_search_state->prune_rect_part[HORZ] =
+ part_search_state->prune_rect_part[VERT] = true;
+ part_search_state->prune_partition_3[HORZ] =
+ part_search_state->prune_partition_3[VERT] = true;
+#if CONFIG_UNEVEN_4WAY
+ part_search_state->prune_partition_4a[HORZ] =
+ part_search_state->prune_partition_4a[VERT] = true;
+ part_search_state->prune_partition_4b[HORZ] =
+ part_search_state->prune_partition_4b[VERT] = true;
+#endif // CONFIG_UNEVEN_4WAY
+ }
#else
part_search_state->do_square_split =
blk_params->bsize_at_least_8x8 &&
- (xd->tree_type != CHROMA_PART || bsize > BLOCK_8X8);
+ (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);
+ (tree_type != CHROMA_PART || bsize > BLOCK_8X8);
const BLOCK_SIZE horz_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE vert_subsize = get_partition_subsize(bsize, PARTITION_VERT);
@@ -3242,7 +3691,7 @@
get_plane_block_size(vert_subsize, part_search_state->ss_x,
part_search_state->ss_y) != BLOCK_INVALID;
const bool no_sub_16_chroma_part =
- xd->tree_type != CHROMA_PART ||
+ tree_type != CHROMA_PART ||
(block_size_wide[bsize] > 8 && block_size_high[bsize] > 8);
// Initialize allowed partition types for the partition block.
@@ -3264,27 +3713,11 @@
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Override partition cost buffer for the edge blocks.
static void set_partition_cost_for_edge_blk(
AV1_COMMON const *cm, MACROBLOCKD *const xd,
-#if CONFIG_EXT_RECUR_PARTITIONS
- const CHROMA_REF_INFO *chroma_ref_info,
-#endif // CONFIG_EXT_RECUR_PARTITIONS
PartitionSearchState *part_search_state) {
-#if CONFIG_EXT_RECUR_PARTITIONS
- const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
- const bool is_part_implied = is_partition_implied_at_boundary(
- &cm->mi_params, xd->tree_type, part_search_state->ss_x,
- part_search_state->ss_y, blk_params->mi_row, blk_params->mi_col,
- blk_params->bsize, chroma_ref_info, NULL);
- if (is_part_implied) {
- 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;
- }
- (void)xd;
-#else // CONFIG_EXT_RECUR_PARTITIONS
PartitionBlkParams blk_params = part_search_state->part_blk_params;
assert(blk_params.bsize_at_least_8x8 && part_search_state->pl_ctx_idx >= 0);
const int plane = xd->tree_type == CHROMA_PART;
@@ -3313,10 +3746,8 @@
}
// Override the partition cost buffer.
part_search_state->partition_cost = part_search_state->tmp_partition_cost;
-#endif // CONFIG_EXT_RECUR_PARTITIONS
}
-#if !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(
@@ -3448,13 +3879,16 @@
}
}
}
+
+static AOM_INLINE bool is_part_pruned_by_forced_partition(
+ const PartitionSearchState *part_state, PARTITION_TYPE partition) {
+ const PARTITION_TYPE forced_partition = part_state->forced_partition;
+ return forced_partition != PARTITION_INVALID && forced_partition != partition;
+}
#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,
@@ -3479,35 +3913,30 @@
}
#if CONFIG_EXT_RECUR_PARTITIONS
-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, const PARTITION_TREE *template_tree,
- const PARTITION_TREE *ptree_luma, const CHROMA_REF_INFO *chroma_ref_info) {
- if (template_tree) {
- return template_tree->partition;
+static AOM_INLINE void prune_rect_with_none_rd(
+ PartitionSearchState *part_search_state, BLOCK_SIZE bsize, int q_index,
+ int rdmult, int64_t part_none_rd, const int *is_not_edge_block) {
+ for (RECT_PART_TYPE rect = 0; rect < NUM_RECT_PARTS; rect++) {
+ // Disable pruning on the boundary
+ if (!is_not_edge_block[rect]) {
+ continue;
+ }
+ const PARTITION_TYPE partition_type = rect_partition_type[rect];
+ float discount_factor = 1.1f;
+ const int q_thresh = 180;
+ if (q_index < q_thresh) {
+ discount_factor -= 0.025f;
+ }
+ if (AOMMAX(block_size_wide[bsize], block_size_high[bsize]) < 16) {
+ discount_factor -= 0.02f;
+ }
+ const int part_rate = part_search_state->partition_cost[partition_type];
+ const int64_t est_rd = (int64_t)(part_none_rd / discount_factor) +
+ RDCOST(rdmult, part_rate, 0);
+ if (est_rd > part_none_rd) {
+ part_search_state->prune_rect_part[rect] = true;
+ }
}
-
- const MACROBLOCKD *xd = &x->e_mbd;
- const int ss_x = cm->seq_params.subsampling_x;
- const int ss_y = cm->seq_params.subsampling_y;
- if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
- const PARTITION_TYPE derived_partition_mode =
- sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ss_x, ss_y);
- return derived_partition_mode;
- }
-
- PARTITION_TYPE implied_partition;
- const bool is_part_implied = is_partition_implied_at_boundary(
- &cm->mi_params, xd->tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
- chroma_ref_info, &implied_partition);
- if (is_part_implied) {
- return implied_partition;
- }
-
- if (should_reuse_mode(x, REUSE_PARTITION_MODE_FLAG)) {
- return av1_get_prev_partition(x, mi_row, mi_col, bsize, cm->sb_size);
- }
- return PARTITION_INVALID;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -3522,13 +3951,9 @@
const PARTITION_TREE *template_tree, int max_recursion_depth,
#endif // CONFIG_EXT_RECUR_PARTITIONS
RD_RECT_PART_WIN_INFO *rect_part_win_info,
-#if CONFIG_C043_MVP_IMPROVEMENTS
- REF_MV_BANK *best_level_bank, REF_MV_BANK *curr_level_bank,
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- WARP_PARAM_BANK *best_level_warp_bank,
- WARP_PARAM_BANK *curr_level_warp_bank,
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
int64_t part_none_rd) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
@@ -3543,9 +3968,6 @@
#if CONFIG_EXT_RECUR_PARTITIONS
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
- PARTITION_TYPE forced_partition = get_forced_partition_type(
- cm, x, blk_params.mi_row, blk_params.mi_col, blk_params.bsize,
- template_tree, ptree_luma, &pc_tree->chroma_ref_info);
#else // !CONFIG_EXT_RECUR_PARTITIONS
(void)part_none_rd;
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -3585,14 +4007,13 @@
(blk_params.mi_col + mi_size_wide[bsize] < mi_params->mi_cols);
const bool try_prune_with_ml =
cpi->sf.part_sf.prune_rect_with_ml && !frame_is_intra_only(cm) &&
- forced_partition == PARTITION_INVALID && is_whole_block_inside &&
- part_none_rd < INT64_MAX &&
+ part_search_state->forced_partition == PARTITION_INVALID &&
+ is_whole_block_inside && part_none_rd < INT64_MAX &&
(is_rect_part_allowed(cpi, part_search_state, active_edge_type, HORZ,
mi_pos_rect[HORZ][0][HORZ]) ||
is_rect_part_allowed(cpi, part_search_state, active_edge_type, VERT,
mi_pos_rect[VERT][0][VERT]));
- bool prune_horz = false, prune_vert = false;
if (try_prune_with_ml && bsize != BLOCK_4X8 && bsize != BLOCK_8X4 &&
is_partition_point(bsize)) {
float ml_features[19];
@@ -3601,7 +4022,15 @@
mi_pos_rect);
const bool is_hd = AOMMIN(cm->width, cm->height) >= 1080;
- av1_erp_prune_rect(bsize, is_hd, ml_features, &prune_horz, &prune_vert);
+ av1_erp_prune_rect(bsize, is_hd, ml_features,
+ &part_search_state->prune_rect_part[HORZ],
+ &part_search_state->prune_rect_part[VERT]);
+ }
+ if (cpi->sf.part_sf.prune_rect_with_none_rd &&
+ part_search_state->forced_partition == PARTITION_INVALID &&
+ !frame_is_intra_only(cm) && part_none_rd < INT64_MAX) {
+ prune_rect_with_none_rd(part_search_state, bsize, x->qindex, x->rdmult,
+ part_none_rd, is_not_edge_block);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -3615,16 +4044,6 @@
mi_pos_rect[i][0][i]))
continue;
-#if CONFIG_EXT_RECUR_PARTITIONS
- if (pc_tree->parent) {
- if ((pc_tree->parent->horizontal3[1] == pc_tree && i == HORZ) ||
- (pc_tree->parent->vertical3[1] == pc_tree && i == VERT)) {
- continue;
- }
- }
-
-#endif // CONFIG_EXT_RECUR_PARTITIONS
-
// Sub-partition idx.
const PARTITION_TYPE partition_type = rect_partition_type[i];
blk_params.subsize =
@@ -3639,38 +4058,12 @@
#endif // !CONFIG_EXT_RECUR_PARTITIONS
av1_init_rd_stats(sum_rdc);
#if CONFIG_EXT_RECUR_PARTITIONS
- if (!IS_FORCED_PARTITION_TYPE(partition_type)) {
+ if (is_part_pruned_by_forced_partition(part_search_state, partition_type)) {
continue;
}
- if (partition_type == PARTITION_HORZ && prune_horz) {
- continue;
- } else if (partition_type == PARTITION_VERT && prune_vert) {
- continue;
- }
-
- if (cpi->sf.part_sf.prune_rect_with_none_rd &&
- forced_partition == PARTITION_INVALID && !frame_is_intra_only(cm) &&
- part_none_rd < INT64_MAX && sum_rdc->rate < INT_MAX &&
- is_not_edge_block[i]) {
- float discount_factor = 1.1f;
- const int q_thresh = 180;
- const int q = x->qindex;
- if (q < q_thresh) {
- discount_factor -= 0.025f;
- }
- if (AOMMAX(block_size_wide[blk_params.bsize],
- block_size_high[blk_params.bsize]) < 16) {
- discount_factor -= 0.02f;
- }
- const int64_t est_rd = (int64_t)(part_none_rd / discount_factor) +
- RDCOST(x->rdmult, part_hv_rate, 0);
- if (est_rd > part_none_rd) {
- continue;
- }
- }
-
PC_TREE **sub_tree = (i == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
+ assert(sub_tree);
const int num_planes = av1_num_planes(cm);
for (int idx = 0; idx < SUB_PARTITIONS_RECT; idx++) {
@@ -3680,11 +4073,11 @@
}
}
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);
+ xd->tree_type, 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);
+ xd->tree_type, 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);
bool both_blocks_skippable = true;
@@ -3703,10 +4096,11 @@
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, 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);
+ cur_ctx[i][j][0] =
+ av1_alloc_pmc(cm, xd->tree_type, 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];
@@ -3766,12 +4160,10 @@
pc_tree->skippable = both_blocks_skippable;
#endif // CONFIG_EXT_RECUR_PARTITIONS
*best_rdc = *sum_rdc;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
pc_tree->partitioning = partition_type;
}
@@ -3780,12 +4172,9 @@
if (rect_part_win_info != NULL)
rect_part_win_info->rect_part_win[i] = false;
}
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = *curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = *curr_level_warp_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
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
@@ -3822,14 +4211,10 @@
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
const BLOCK_SIZE ab_subsize[SUB_PARTITIONS_AB],
const int ab_mi_pos[SUB_PARTITIONS_AB][2], const PARTITION_TYPE part_type
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- REF_MV_BANK *best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- WARP_PARAM_BANK *best_level_warp_bank
-#endif // WARP_CU_BANK
+ LevelBanksRDO *level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
@@ -3856,14 +4241,10 @@
part_search_state->found_best_partition |=
rd_test_partition3(cpi, td, tile_data, tp, pc_tree, best_rdc, dst_ctxs,
mi_row, mi_col, bsize, part_type, ab_subsize, ab_mi_pos
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- best_level_warp_bank
-#endif // WARP_CU_BANK
+ level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
#if CONFIG_COLLECT_PARTITION_STATS
@@ -3913,14 +4294,10 @@
PC_TREE *pc_tree, PartitionSearchState *part_search_state,
RD_STATS *best_rdc, RD_RECT_PART_WIN_INFO *rect_part_win_info,
int pb_source_variance, int ext_partition_allowed
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- REF_MV_BANK *best_level_bank, REF_MV_BANK *curr_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- WARP_PARAM_BANK *best_level_warp_bank, WARP_PARAM_BANK *curr_level_warp_bank
-#endif // WARP_CU_BANK
+ LevelBanksRDO *level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
@@ -4004,9 +4381,9 @@
// Set AB partition context.
if (cur_part_ctxs[ab_part_type][i] == NULL)
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,
+ cm, x->e_mbd.tree_type, 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;
@@ -4030,21 +4407,14 @@
rd_pick_ab_part(cpi, td, tile_data, tp, x, x_ctx, pc_tree,
cur_part_ctxs[ab_part_type], part_search_state, best_rdc,
ab_subsize[ab_part_type], ab_mi_pos[ab_part_type], part_type
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- best_level_warp_bank
-#endif // WARP_CU_BANK
+ level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = *curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = *curr_level_warp_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
}
@@ -4073,10 +4443,10 @@
RDCOST(x->rdmult, part_search_state->sum_rdc.rate, 0);
for (PART4_TYPES i = 0; i < SUB_PARTITIONS_PART4; ++i) {
if (cur_part_ctx[i] == NULL)
- 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);
+ cur_part_ctx[i] = av1_alloc_pmc(
+ cm, x->e_mbd.tree_type, 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);
}
}
@@ -4087,14 +4457,10 @@
PC_TREE *pc_tree, PICK_MODE_CONTEXT *cur_part_ctx[SUB_PARTITIONS_PART4],
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
const int inc_step[NUM_PART4_TYPES], PARTITION_TYPE partition_type
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- REF_MV_BANK *best_level_bank, REF_MV_BANK *curr_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- WARP_PARAM_BANK *best_level_warp_bank, WARP_PARAM_BANK *curr_level_warp_bank
-#endif // WARP_CU_BANK
+ LevelBanksRDO *level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
@@ -4136,12 +4502,9 @@
av1_rd_cost_update(x->rdmult, &part_search_state->sum_rdc);
if (part_search_state->sum_rdc.rdcost < best_rdc->rdcost) {
*best_rdc = part_search_state->sum_rdc;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
pc_tree->partitioning = partition_type;
}
@@ -4153,14 +4516,11 @@
partition_timer_on = 0;
}
#endif
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = *curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = *curr_level_warp_bank;
-#endif // WARP_CU_BANK
av1_restore_context(cm, x, x_ctx, blk_params.mi_row, blk_params.mi_col,
blk_params.bsize, av1_num_planes(cm));
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
// Prune 4-way partitions based on the number of horz/vert wins
@@ -4276,12 +4636,13 @@
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);
+#if !CONFIG_EXT_RECUR_PARTITIONS
if (part_search_state->partition_none_allowed == BLOCK_INVALID) {
part_search_state->partition_none_allowed = 0;
return;
}
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE for screen content.
if (cpi->is_screen_content_type)
@@ -4301,9 +4662,9 @@
// Set PARTITION_NONE context.
if (pc_tree->none == NULL)
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);
+ cm, x->e_mbd.tree_type, 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) {
@@ -4478,14 +4839,10 @@
RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
unsigned int *pb_source_variance, int64_t *none_rd, int64_t *part_none_rd
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- REF_MV_BANK *best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- WARP_PARAM_BANK *best_level_warp_bank
-#endif // WARP_CU_BANK
+ LevelBanksRDO *level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
@@ -4495,13 +4852,25 @@
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_NONE)) {
+ return;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE allowed flag.
set_part_none_allowed_flag(cpi,
#if CONFIG_EXT_RECUR_PARTITIONS
x->e_mbd.tree_type,
#endif // CONFIG_EXT_RECUR_PARTITIONS
part_search_state);
- if (!part_search_state->partition_none_allowed) return;
+ if (!part_search_state->partition_none_allowed) {
+ return;
+ }
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (part_search_state->prune_partition_none) {
+ return;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
int pt_cost = 0;
RD_STATS best_remain_rdcost;
@@ -4569,12 +4938,9 @@
*part_none_rd = this_rdc->rdcost;
if (this_rdc->rdcost < best_rdc->rdcost) {
*best_rdc = *this_rdc;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
#if !CONFIG_EXT_RECUR_PARTITIONS
if (blk_params.bsize_at_least_8x8) {
@@ -4592,6 +4958,9 @@
}
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
// PARTITION_SPLIT search.
@@ -4601,14 +4970,10 @@
SIMPLE_MOTION_DATA_TREE *sms_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
SB_MULTI_PASS_MODE multi_pass_mode, int64_t *part_split_rd
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- REF_MV_BANK *best_level_bank
+ LevelBanksRDO *level_banks
#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- WARP_PARAM_BANK *best_level_warp_bank
-#endif // WARP_CU_BANK
#if CONFIG_EXT_RECUR_PARTITIONS
,
const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
@@ -4632,6 +4997,13 @@
!is_square_split_eligible(bsize, cm->sb_size)) {
return;
}
+ if (part_search_state->forced_partition != PARTITION_INVALID &&
+ part_search_state->forced_partition != PARTITION_SPLIT) {
+ return;
+ }
+ if (max_recursion_depth < 0) {
+ return;
+ }
const int num_planes = av1_num_planes(cm);
PC_TREE **sub_tree = pc_tree->split;
@@ -4677,8 +5049,9 @@
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);
+ x->e_mbd.tree_type, 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);
}
#if !CONFIG_EXT_RECUR_PARTITIONS
int64_t *p_split_rd = &part_search_state->split_rd[idx];
@@ -4751,12 +5124,9 @@
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, sum_rdc.dist);
if (sum_rdc.rdcost < best_rdc->rdcost) {
*best_rdc = sum_rdc;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_SPLIT;
}
@@ -4774,6 +5144,9 @@
#endif // !CONFIG_EXT_RECUR_PARTITIONS
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
#if CONFIG_EXT_RECUR_PARTITIONS
@@ -4799,15 +5172,23 @@
/*!\brief Whether the current partition node uses horizontal type partitions. */
static AOM_INLINE bool node_uses_horz(const PC_TREE *pc_tree) {
assert(pc_tree);
- return pc_tree->partitioning == PARTITION_HORZ ||
- pc_tree->partitioning == PARTITION_HORZ_3;
+ return pc_tree->partitioning == PARTITION_HORZ
+#if CONFIG_UNEVEN_4WAY
+ || pc_tree->partitioning == PARTITION_HORZ_4A ||
+ pc_tree->partitioning == PARTITION_HORZ_4B
+#endif // CONFIG_UNEVEN_4WAY
+ || pc_tree->partitioning == PARTITION_HORZ_3;
}
/*!\brief Whether the current partition node uses vertical type partitions. */
static AOM_INLINE bool node_uses_vert(const PC_TREE *pc_tree) {
assert(pc_tree);
- return pc_tree->partitioning == PARTITION_VERT ||
- pc_tree->partitioning == PARTITION_VERT_3;
+ return pc_tree->partitioning == PARTITION_VERT
+#if CONFIG_UNEVEN_4WAY
+ || pc_tree->partitioning == PARTITION_VERT_4A ||
+ pc_tree->partitioning == PARTITION_VERT_4B
+#endif // CONFIG_UNEVEN_4WAY
+ || pc_tree->partitioning == PARTITION_VERT_3;
}
/*!\brief Try searching for an encoding for the given subblock.
@@ -4863,43 +5244,1054 @@
return 1;
}
+/*!\brief Trace out the partition boundaries using the structure in pc_tree.
+ *
+ * The results are stored in partition_boundaries. The array
+ * partition_boundaries has a stride of MAX_MIB_SIZE, and the units are in mi.
+ * The actual values stored is a bitmask, with 1 << HORZ means that there is a
+ * horizontal boundary, and 1 << VERT means that there is a vertical boundary.
+ * */
+static AOM_INLINE void trace_partition_boundary(bool *partition_boundaries,
+ const PC_TREE *pc_tree,
+ int mi_row, int mi_col,
+ BLOCK_SIZE bsize) {
+ mi_row &= MAX_MIB_MASK;
+ mi_col &= MAX_MIB_MASK;
+ const PARTITION_TYPE partition = pc_tree->partitioning;
+ assert(bsize < BLOCK_SIZES_ALL);
+ const int mi_width = mi_size_wide[bsize];
+ const int mi_height = mi_size_high[bsize];
+#if CONFIG_UNEVEN_4WAY
+ const int ebs_w = mi_size_wide[bsize] / 8;
+ const int ebs_h = mi_size_high[bsize] / 8;
+ const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
+#endif // CONFIG_UNEVEN_4WAY
+ switch (partition) {
+ case PARTITION_NONE:
+ for (int col = 0; col < mi_width; col++) {
+ partition_boundaries[(mi_row + mi_height - 1) * MAX_MIB_SIZE +
+ (mi_col + col)] |= (1 << HORZ);
+ }
+ for (int row = 0; row < mi_height; row++) {
+ partition_boundaries[(mi_row + row) * MAX_MIB_SIZE + mi_col + mi_width -
+ 1] |= (1 << VERT);
+ }
+ break;
+ case PARTITION_HORZ:
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal[0],
+ mi_row, mi_col,
+ get_partition_subsize(bsize, PARTITION_HORZ));
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal[1],
+ mi_row + mi_height / 2, mi_col,
+ get_partition_subsize(bsize, PARTITION_HORZ));
+ break;
+ case PARTITION_VERT:
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical[0],
+ mi_row, mi_col,
+ get_partition_subsize(bsize, PARTITION_VERT));
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical[1],
+ mi_row, mi_col + mi_width / 2,
+ get_partition_subsize(bsize, PARTITION_VERT));
+ break;
+ case PARTITION_HORZ_3:
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->horizontal3[0], mi_row, mi_col,
+ get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->horizontal3[1], mi_row + mi_height / 4,
+ mi_col, get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->horizontal3[2], mi_row + mi_height / 4,
+ mi_col + mi_width / 2,
+ get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->horizontal3[3],
+ mi_row + 3 * mi_height / 4, mi_col,
+ get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
+ break;
+ case PARTITION_VERT_3:
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->vertical3[0], mi_row, mi_col,
+ get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->vertical3[1], mi_row,
+ mi_col + mi_width / 4,
+ get_h_partition_subsize(bsize, 1, PARTITION_VERT_3));
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->vertical3[2], mi_row + mi_height / 2,
+ mi_col + mi_width / 4,
+ get_h_partition_subsize(bsize, 1, PARTITION_VERT_3));
+ trace_partition_boundary(
+ partition_boundaries, pc_tree->vertical3[3], mi_row,
+ mi_col + 3 * mi_width / 4,
+ get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
+ break;
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[0],
+ mi_row, mi_col, subsize);
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[1],
+ mi_row + ebs_h, mi_col, bsize_med);
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[2],
+ mi_row + 3 * ebs_h, mi_col, bsize_big);
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[3],
+ mi_row + 7 * ebs_h, mi_col, subsize);
+ break;
+ }
+ case PARTITION_HORZ_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_HORZ);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_HORZ));
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[0],
+ mi_row, mi_col, subsize);
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[1],
+ mi_row + ebs_h, mi_col, bsize_big);
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[2],
+ mi_row + 5 * ebs_h, mi_col, bsize_med);
+ trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[3],
+ mi_row + 7 * ebs_h, mi_col, subsize);
+ break;
+ }
+ case PARTITION_VERT_4A: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[0],
+ mi_row, mi_col, subsize);
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[1],
+ mi_row, mi_col + ebs_w, bsize_med);
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[2],
+ mi_row, mi_col + 3 * ebs_w, bsize_big);
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[3],
+ mi_row, mi_col + 7 * ebs_w, subsize);
+ break;
+ }
+ case PARTITION_VERT_4B: {
+ const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE bsize_med =
+ get_partition_subsize(bsize_big, PARTITION_VERT);
+ assert(subsize == get_partition_subsize(bsize_med, PARTITION_VERT));
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[0],
+ mi_row, mi_col, subsize);
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[1],
+ mi_row, mi_col + ebs_w, bsize_big);
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[2],
+ mi_row, mi_col + 5 * ebs_w, bsize_med);
+ trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[3],
+ mi_row, mi_col + 7 * ebs_w, subsize);
+ break;
+ }
+#endif // CONFIG_UNEVEN_4WAY
+ default: assert(0 && "Invalid partition type in trace_partition_boundary!");
+ }
+}
+
+/*!\brief Prunes h partitions using the current best partition boundaries.
+ *
+ * If the H-shaped partitions don't have any overlap with the current best
+ * partition boundaries, then they are pruned from the search.
+ * */
+static AOM_INLINE void prune_part_3_with_partition_boundary(
+ PartitionSearchState *part_search_state, BLOCK_SIZE bsize, int mi_row,
+ int mi_col, bool can_search_horz, bool can_search_vert) {
+ const int mi_width = mi_size_wide[bsize];
+ const int mi_height = mi_size_high[bsize];
+ const int masked_mi_row = mi_row & MAX_MIB_MASK;
+ const int masked_mi_col = mi_col & MAX_MIB_MASK;
+ const bool *partition_boundaries = part_search_state->partition_boundaries;
+ if (can_search_horz) {
+ bool keep_horz_3 = false;
+ for (int col = 0; col < mi_width; col++) {
+ if (partition_boundaries[(masked_mi_row + mi_height / 4 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + col] &
+ (1 << HORZ)) {
+ keep_horz_3 = true;
+ break;
+ }
+ }
+ if (!keep_horz_3) {
+ for (int col = 0; col < mi_width; col++) {
+ if (partition_boundaries[(masked_mi_row + 3 * mi_height / 4 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + col] &
+ (1 << HORZ)) {
+ keep_horz_3 = true;
+ break;
+ }
+ }
+ }
+ if (!keep_horz_3) {
+ for (int row = 0; row < mi_height / 2; row++) {
+ if (partition_boundaries[(masked_mi_row + mi_height / 4 + row) *
+ MAX_MIB_SIZE +
+ masked_mi_col + mi_width / 2 - 1] &
+ (1 << VERT)) {
+ keep_horz_3 = true;
+ break;
+ }
+ }
+ }
+ part_search_state->prune_partition_3[HORZ] |= !keep_horz_3;
+ }
+ if (can_search_vert) {
+ bool keep_vert_3 = false;
+ for (int row = 0; row < mi_height; row++) {
+ if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
+ masked_mi_col + mi_width / 4 - 1] &
+ (1 << VERT)) {
+ keep_vert_3 = true;
+ break;
+ }
+ }
+ if (!keep_vert_3) {
+ for (int row = 0; row < mi_height; row++) {
+ if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
+ masked_mi_col + 3 * mi_width / 4 - 1] &
+ (1 << VERT)) {
+ keep_vert_3 = true;
+ break;
+ }
+ }
+ }
+ if (!keep_vert_3) {
+ for (int col = 0; col < mi_width / 2; col++) {
+ if (partition_boundaries[(masked_mi_row + mi_height / 2 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + mi_width / 4 + col] &
+ (1 << HORZ)) {
+ keep_vert_3 = true;
+ break;
+ }
+ }
+ }
+ part_search_state->prune_partition_3[VERT] |= !keep_vert_3;
+ }
+}
+
+#if CONFIG_UNEVEN_4WAY
+/*!\brief Prunes 4-way partitions using the current best partition boundaries.
+ *
+ * If the 4-way partitions don't have any overlap with the current best
+ * partition boundaries, then they are pruned from the search.
+ */
+static AOM_INLINE void prune_part_4_with_partition_boundary(
+ PartitionSearchState *part_search_state, const bool *partition_boundaries,
+ BLOCK_SIZE bsize, int mi_row, int mi_col, bool can_search_horz_4a,
+ bool can_search_horz_4b, bool can_search_vert_4a, bool can_search_vert_4b) {
+ const int mi_width = mi_size_wide[bsize];
+ const int mi_height = mi_size_high[bsize];
+ const int masked_mi_row = mi_row & MAX_MIB_MASK;
+ const int masked_mi_col = mi_col & MAX_MIB_MASK;
+ bool keep_horz_4a = false, keep_horz_4b = false;
+ bool keep_vert_4a = false, keep_vert_4b = false;
+ if (can_search_horz_4a || can_search_horz_4b) {
+ for (int col = 0; col < mi_width; col++) {
+ if (partition_boundaries[(masked_mi_row + mi_height / 8 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + col] &
+ (1 << HORZ)) {
+ keep_horz_4a = true;
+ keep_horz_4b = true;
+ break;
+ }
+ if (partition_boundaries[(masked_mi_row + 7 * mi_height / 8 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + col] &
+ (1 << HORZ)) {
+ keep_horz_4a = true;
+ keep_horz_4b = true;
+ break;
+ }
+ }
+ if (can_search_horz_4a && !keep_horz_4a) {
+ for (int col = 0; col < mi_width; col++) {
+ if (partition_boundaries[(masked_mi_row + 3 * mi_height / 8 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + col] &
+ (1 << HORZ)) {
+ keep_horz_4a = true;
+ break;
+ }
+ }
+ }
+ if (can_search_horz_4b && !keep_horz_4b) {
+ for (int col = 0; col < mi_width; col++) {
+ if (partition_boundaries[(masked_mi_row + 5 * mi_height / 8 - 1) *
+ MAX_MIB_SIZE +
+ masked_mi_col + col] &
+ (1 << HORZ)) {
+ keep_horz_4b = true;
+ break;
+ }
+ }
+ }
+ part_search_state->prune_partition_4a[HORZ] |= !keep_horz_4a;
+ part_search_state->prune_partition_4b[HORZ] |= !keep_horz_4b;
+ }
+ if (can_search_vert_4a || can_search_vert_4b) {
+ for (int row = 0; row < mi_height; row++) {
+ if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
+ masked_mi_col + mi_width / 8 - 1] &
+ (1 << VERT)) {
+ keep_vert_4a = true;
+ keep_vert_4b = true;
+ break;
+ }
+ if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
+ masked_mi_col + 7 * mi_width / 8 - 1] &
+ (1 << VERT)) {
+ keep_vert_4a = true;
+ keep_vert_4b = true;
+ break;
+ }
+ }
+ if (can_search_vert_4a && !keep_vert_4a) {
+ for (int row = 0; row < mi_height; row++) {
+ if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
+ masked_mi_col + 3 * mi_width / 8 - 1] &
+ (1 << VERT)) {
+ keep_vert_4a = true;
+ break;
+ }
+ }
+ }
+ if (can_search_vert_4b && !keep_vert_4b) {
+ for (int row = 0; row < mi_height; row++) {
+ if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
+ masked_mi_col + 5 * mi_width / 8 - 1] &
+ (1 << VERT)) {
+ keep_vert_4b = true;
+ break;
+ }
+ }
+ }
+ part_search_state->prune_partition_4a[VERT] |= !keep_vert_4a;
+ part_search_state->prune_partition_4b[VERT] |= !keep_vert_4b;
+ }
+}
+
+#endif // CONFIG_UNEVEN_4WAY
+
+// Pruning logic for PARTITION_HORZ_3 and PARTITION_VERT_3.
+static AOM_INLINE void prune_ext_partitions_3way(
+ AV1_COMP *const cpi, PC_TREE *pc_tree,
+ PartitionSearchState *part_search_state, bool *partition_boundaries) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
+ const PARTITION_TYPE forced_partition = part_search_state->forced_partition;
+ if (part_search_state->forced_partition != PARTITION_INVALID) {
+ return;
+ }
+
+ // Prune horz 3 with speed features
+ if (part_search_state->partition_3_allowed[HORZ] &&
+ !frame_is_intra_only(cm) && forced_partition != PARTITION_HORZ_3) {
+ if (part_sf->prune_ext_part_with_part_none &&
+ pc_tree->partitioning == PARTITION_NONE) {
+ // Prune if the best partition does not split
+ part_search_state->prune_partition_3[HORZ] = 1;
+ }
+ if (part_sf->prune_ext_part_with_part_rect) {
+ // Prune if the best partition is rect but the subtrees did not further
+ // split in horz
+ if (pc_tree->partitioning == PARTITION_HORZ &&
+ !node_uses_horz(pc_tree->horizontal[0]) &&
+ !node_uses_horz(pc_tree->horizontal[1])) {
+ part_search_state->prune_partition_3[HORZ] = 1;
+ }
+ if (pc_tree->partitioning == PARTITION_VERT &&
+ !node_uses_horz(pc_tree->vertical[0]) &&
+ !node_uses_horz(pc_tree->vertical[1])) {
+ part_search_state->prune_partition_3[HORZ] = 1;
+ }
+ }
+ }
+
+ if (part_search_state->partition_3_allowed[VERT] &&
+ !frame_is_intra_only(cm) && forced_partition != PARTITION_VERT_3) {
+ if (part_sf->prune_ext_part_with_part_none &&
+ pc_tree->partitioning == PARTITION_NONE) {
+ // Prune if the best partition does not split
+ part_search_state->prune_partition_3[VERT] = 1;
+ }
+ if (part_sf->prune_ext_part_with_part_rect) {
+ // Prune if the best partition is rect but the subtrees did not further
+ // split in vert
+ if (pc_tree->partitioning == PARTITION_VERT &&
+ !node_uses_vert(pc_tree->vertical[0]) &&
+ !node_uses_vert(pc_tree->vertical[1])) {
+ part_search_state->prune_partition_3[VERT] = 1;
+ }
+ if (pc_tree->partitioning == PARTITION_HORZ &&
+ !node_uses_vert(pc_tree->horizontal[0]) &&
+ !node_uses_vert(pc_tree->horizontal[1])) {
+ part_search_state->prune_partition_3[VERT] = 1;
+ }
+ }
+ }
+
+ const bool can_search_horz = part_search_state->partition_3_allowed[HORZ] &&
+ !part_search_state->prune_partition_3[HORZ];
+ const bool can_search_vert = part_search_state->partition_3_allowed[VERT] &&
+ !part_search_state->prune_partition_3[VERT];
+ const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
+ const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col,
+ bsize = blk_params->bsize;
+ if (part_sf->prune_part_h_with_partition_boundary &&
+ (can_search_horz || can_search_vert) &&
+ part_search_state->found_best_partition) {
+ if (!part_search_state->partition_boundaries) {
+ part_search_state->partition_boundaries = partition_boundaries;
+ trace_partition_boundary(partition_boundaries, pc_tree, mi_row, mi_col,
+ bsize);
+ }
+ prune_part_3_with_partition_boundary(part_search_state, bsize, mi_row,
+ mi_col, can_search_horz,
+ can_search_vert);
+ }
+}
+
+#if CONFIG_UNEVEN_4WAY
+// Pruning logic for PARTITION_HORZ_4A/B and PARTITION_VERT_4A/B.
+static AOM_INLINE void prune_ext_partitions_4way(
+ AV1_COMP *const cpi, PC_TREE *pc_tree,
+ PartitionSearchState *part_search_state, bool *partition_boundaries) {
+ const AV1_COMMON *const cm = &cpi->common;
+ const PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
+ const PARTITION_TYPE forced_partition = part_search_state->forced_partition;
+ if (part_search_state->partition_4a_allowed[HORZ] &&
+ forced_partition != PARTITION_HORZ_4A) {
+ if (part_sf->prune_ext_part_with_part_none &&
+ pc_tree->partitioning == PARTITION_NONE) {
+ // Prune if the best partition does not split
+ part_search_state->prune_partition_4a[HORZ] = 1;
+ }
+ if (part_sf->prune_ext_part_with_part_rect &&
+ pc_tree->partitioning == PARTITION_HORZ &&
+ !node_uses_horz(pc_tree->horizontal[0]) &&
+ !node_uses_horz(pc_tree->horizontal[1])) {
+ // Prune if the best partition is horz but horz did not further split in
+ // horz
+ part_search_state->prune_partition_4a[HORZ] = 1;
+ }
+ if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_HORZ_3 &&
+ !node_uses_horz(pc_tree->horizontal3[0]) &&
+ !node_uses_horz(pc_tree->horizontal3[3])) {
+ // Prune is best partition is horizontal H, but first and last
+ // subpartitions did not further split in horizontal direction.
+ part_search_state->prune_partition_4a[HORZ] = 1;
+ }
+ if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_VERT &&
+ part_search_state->partition_rect_allowed[HORZ]) {
+ part_search_state->prune_partition_4a[HORZ] = 1;
+ }
+ }
+
+ // Prune HORZ 4B with speed features
+ if (part_search_state->partition_4b_allowed[HORZ] &&
+ forced_partition != PARTITION_HORZ_4B) {
+ if (part_sf->prune_ext_part_with_part_none &&
+ pc_tree->partitioning == PARTITION_NONE) {
+ // Prune if the best partition does not split
+ part_search_state->prune_partition_4b[HORZ] = 1;
+ }
+ if (part_sf->prune_ext_part_with_part_rect &&
+ pc_tree->partitioning == PARTITION_HORZ &&
+ !node_uses_horz(pc_tree->horizontal[0]) &&
+ !node_uses_horz(pc_tree->horizontal[1])) {
+ // Prune if the best partition is horz but horz did not further split in
+ // horz
+ part_search_state->prune_partition_4b[HORZ] = 1;
+ }
+ if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_HORZ_3 &&
+ !node_uses_horz(pc_tree->horizontal3[0]) &&
+ !node_uses_horz(pc_tree->horizontal3[3])) {
+ // Prune is best partition is horizontal H, but first and last
+ // subpartitions did not further split in horizontal direction.
+ part_search_state->prune_partition_4b[HORZ] = 1;
+ }
+ if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_VERT &&
+ part_search_state->partition_rect_allowed[HORZ]) {
+ part_search_state->prune_partition_4b[HORZ] = 1;
+ }
+ }
+
+ // Prune VERT_4A with speed features
+ if (part_search_state->partition_4a_allowed[VERT] &&
+ forced_partition != PARTITION_VERT_4A) {
+ if (part_sf->prune_ext_part_with_part_none &&
+ pc_tree->partitioning == PARTITION_NONE) {
+ // Prune if the best partition does not split
+ part_search_state->prune_partition_4a[VERT] = 1;
+ }
+ if (part_sf->prune_ext_part_with_part_rect &&
+ pc_tree->partitioning == PARTITION_VERT &&
+ !node_uses_vert(pc_tree->vertical[0]) &&
+ !node_uses_vert(pc_tree->vertical[1])) {
+ // Prune if the best partition is vert but vert did not further split in
+ // vert
+ part_search_state->prune_partition_4a[VERT] = 1;
+ }
+ if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_VERT_3 &&
+ !node_uses_vert(pc_tree->vertical3[0]) &&
+ !node_uses_vert(pc_tree->vertical3[3])) {
+ // Prune is best partition is vertical H, but first and last
+ // subpartitions did not further split in vertical direction.
+ part_search_state->prune_partition_4a[VERT] = 1;
+ }
+ if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_HORZ &&
+ part_search_state->partition_rect_allowed[VERT]) {
+ part_search_state->prune_partition_4a[VERT] = 1;
+ }
+ }
+
+ // Prune VERT_4B with speed features
+ if (part_search_state->partition_4b_allowed[VERT] &&
+ forced_partition != PARTITION_VERT_4B) {
+ if (part_sf->prune_ext_part_with_part_none &&
+ pc_tree->partitioning == PARTITION_NONE) {
+ // Prune if the best partition does not split
+ part_search_state->prune_partition_4b[VERT] = 1;
+ }
+ if (part_sf->prune_ext_part_with_part_rect &&
+ pc_tree->partitioning == PARTITION_VERT &&
+ !node_uses_vert(pc_tree->vertical[0]) &&
+ !node_uses_vert(pc_tree->vertical[1])) {
+ // Prune if the best partition is vert but vert did not further split in
+ // vert
+ part_search_state->prune_partition_4b[VERT] = 1;
+ }
+ if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_VERT_3 &&
+ !node_uses_vert(pc_tree->vertical3[0]) &&
+ !node_uses_vert(pc_tree->vertical3[3])) {
+ // Prune is best partition is vertical H, but first and last
+ // subpartitions did not further split in vertical direction.
+ part_search_state->prune_partition_4b[VERT] = 1;
+ }
+ if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
+ pc_tree->partitioning == PARTITION_HORZ &&
+ part_search_state->partition_rect_allowed[VERT]) {
+ part_search_state->prune_partition_4b[VERT] = 1;
+ }
+ }
+
+ const bool can_search_horz_4a =
+ part_search_state->partition_4a_allowed[HORZ] &&
+ !part_search_state->prune_partition_4a[HORZ];
+ const bool can_search_horz_4b =
+ part_search_state->partition_4b_allowed[HORZ] &&
+ !part_search_state->prune_partition_4b[HORZ];
+ const bool can_search_vert_4a =
+ part_search_state->partition_4a_allowed[VERT] &&
+ !part_search_state->prune_partition_4a[VERT];
+ const bool can_search_vert_4b =
+ part_search_state->partition_4b_allowed[VERT] &&
+ !part_search_state->prune_partition_4b[VERT];
+ const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
+ const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col,
+ bsize = blk_params->bsize;
+ if (part_sf->prune_part_4_with_partition_boundary &&
+ (can_search_horz_4a || can_search_vert_4a || can_search_horz_4b ||
+ can_search_vert_4b) &&
+ part_search_state->found_best_partition) {
+ if (!part_search_state->partition_boundaries ||
+ pc_tree->partitioning == PARTITION_HORZ_3 ||
+ pc_tree->partitioning == PARTITION_VERT_3) {
+ part_search_state->partition_boundaries = partition_boundaries;
+ trace_partition_boundary(partition_boundaries, pc_tree, mi_row, mi_col,
+ bsize);
+ }
+ prune_part_4_with_partition_boundary(
+ part_search_state, partition_boundaries, bsize, mi_row, mi_col,
+ can_search_horz_4a, can_search_horz_4b, can_search_vert_4a,
+ can_search_vert_4b);
+ }
+}
+
+static INLINE void search_partition_horz_4a(
+ PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+ PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
+ const PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &td->mb;
+ const int num_planes = av1_num_planes(cm);
+ 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 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;
+
+ if (is_part_pruned_by_forced_partition(part_search_state,
+ PARTITION_HORZ_4A) ||
+ !part_search_state->partition_4a_allowed[HORZ] ||
+ part_search_state->prune_partition_4a[HORZ]) {
+ return;
+ }
+
+ if (search_state->terminate_partition_search || !blk_params->has_rows ||
+ !is_partition_valid(bsize, PARTITION_HORZ_4A) ||
+ !(search_state->do_rectangular_split ||
+ av1_active_h_edge(cpi, mi_row, blk_params->mi_step_h))) {
+ return;
+ }
+
+ const int part_h4a_rate = search_state->partition_cost[PARTITION_HORZ_4A];
+ if (part_h4a_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_h4a_rate, 0) >= best_rdc->rdcost) {
+ return;
+ }
+ RD_STATS sum_rdc;
+ av1_init_rd_stats(&sum_rdc);
+ const int eighth_step = mi_size_high[bsize] / 8;
+
+ sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_4A];
+ sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
+
+ const BLOCK_SIZE sml_subsize =
+ get_partition_subsize(bsize, PARTITION_HORZ_4A);
+ const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE med_subsize =
+ get_partition_subsize(big_subsize, PARTITION_HORZ);
+ assert(sml_subsize == get_partition_subsize(med_subsize, PARTITION_HORZ));
+
+ const int cum_step_multipliers[4] = { 0, 1, 3, 7 };
+ const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, med_subsize, big_subsize,
+ sml_subsize };
+
+ for (int idx = 0; idx < 4; idx++) {
+ if (pc_tree->horizontal4a[idx]) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal4a[idx], num_planes, 0, 0);
+ pc_tree->horizontal4a[idx] = NULL;
+ }
+ const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[idx];
+ pc_tree->horizontal4a[idx] = av1_alloc_pc_tree_node(
+ xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
+ PARTITION_HORZ_4A, idx, idx == 3, ss_x, ss_y);
+ }
+
+ bool skippable = true;
+ for (int i = 0; i < 4; ++i) {
+ const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[i];
+
+ if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
+
+ SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal4a[i],
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree,
+ i),
+ this_mi_row,
+ mi_col,
+ subblock_sizes[i],
+ PARTITION_HORZ_4A };
+ if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
+ &sum_rdc, multi_pass_mode, &skippable,
+ max_recursion_depth)) {
+ av1_invalid_rd_stats(&sum_rdc);
+ break;
+ }
+ }
+
+ av1_rd_cost_update(x->rdmult, &sum_rdc);
+ if (sum_rdc.rdcost < best_rdc->rdcost) {
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ *best_rdc = sum_rdc;
+ search_state->found_best_partition = true;
+ pc_tree->partitioning = PARTITION_HORZ_4A;
+ pc_tree->skippable = skippable;
+ }
+
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+}
+
+static INLINE void search_partition_horz_4b(
+ PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+ PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
+ const PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &td->mb;
+ const int num_planes = av1_num_planes(cm);
+ 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 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;
+
+ if (is_part_pruned_by_forced_partition(part_search_state,
+ PARTITION_HORZ_4B) ||
+ !part_search_state->partition_4b_allowed[HORZ] ||
+ part_search_state->prune_partition_4b[HORZ]) {
+ return;
+ }
+
+ if (search_state->terminate_partition_search || !blk_params->has_rows ||
+ !is_partition_valid(bsize, PARTITION_HORZ_4B) ||
+ !(search_state->do_rectangular_split ||
+ av1_active_h_edge(cpi, mi_row, blk_params->mi_step_h))) {
+ return;
+ }
+
+ const int part_h4b_rate = search_state->partition_cost[PARTITION_HORZ_4B];
+ if (part_h4b_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_h4b_rate, 0) >= best_rdc->rdcost) {
+ return;
+ }
+ RD_STATS sum_rdc;
+ av1_init_rd_stats(&sum_rdc);
+ const int eighth_step = mi_size_high[bsize] / 8;
+
+ sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_4B];
+ sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
+
+ const BLOCK_SIZE sml_subsize =
+ get_partition_subsize(bsize, PARTITION_HORZ_4B);
+ const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
+ const BLOCK_SIZE med_subsize =
+ get_partition_subsize(big_subsize, PARTITION_HORZ);
+ assert(sml_subsize == get_partition_subsize(med_subsize, PARTITION_HORZ));
+
+ const int cum_step_multipliers[4] = { 0, 1, 5, 7 };
+ const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, big_subsize, med_subsize,
+ sml_subsize };
+
+ for (int idx = 0; idx < 4; idx++) {
+ if (pc_tree->horizontal4b[idx]) {
+ av1_free_pc_tree_recursive(pc_tree->horizontal4b[idx], num_planes, 0, 0);
+ pc_tree->horizontal4b[idx] = NULL;
+ }
+ const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[idx];
+ pc_tree->horizontal4b[idx] = av1_alloc_pc_tree_node(
+ xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
+ PARTITION_HORZ_4B, idx, idx == 3, ss_x, ss_y);
+ }
+
+ bool skippable = true;
+ for (int i = 0; i < 4; ++i) {
+ const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[i];
+
+ if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
+
+ SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal4b[i],
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree,
+ i),
+ this_mi_row,
+ mi_col,
+ subblock_sizes[i],
+ PARTITION_HORZ_4B };
+ if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
+ &sum_rdc, multi_pass_mode, &skippable,
+ max_recursion_depth)) {
+ av1_invalid_rd_stats(&sum_rdc);
+ break;
+ }
+ }
+
+ av1_rd_cost_update(x->rdmult, &sum_rdc);
+ if (sum_rdc.rdcost < best_rdc->rdcost) {
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ *best_rdc = sum_rdc;
+ search_state->found_best_partition = true;
+ pc_tree->partitioning = PARTITION_HORZ_4B;
+ pc_tree->skippable = skippable;
+ }
+
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+}
+
+static INLINE void search_partition_vert_4a(
+ PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+ PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
+ const PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &td->mb;
+ const int num_planes = av1_num_planes(cm);
+ 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 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;
+
+ if (is_part_pruned_by_forced_partition(part_search_state,
+ PARTITION_VERT_4A) ||
+ !part_search_state->partition_4a_allowed[VERT] ||
+ part_search_state->prune_partition_4a[VERT]) {
+ return;
+ }
+
+ if (search_state->terminate_partition_search || !blk_params->has_cols ||
+ !is_partition_valid(bsize, PARTITION_VERT_4A) ||
+ !(search_state->do_rectangular_split ||
+ av1_active_v_edge(cpi, mi_col, blk_params->mi_step_w))) {
+ return;
+ }
+
+ const int part_v4a_rate = search_state->partition_cost[PARTITION_VERT_4A];
+ if (part_v4a_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_v4a_rate, 0) >= best_rdc->rdcost) {
+ return;
+ }
+ RD_STATS sum_rdc;
+ av1_init_rd_stats(&sum_rdc);
+ const int eighth_step = mi_size_wide[bsize] / 8;
+
+ sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_4A];
+ sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
+
+ const BLOCK_SIZE sml_subsize =
+ get_partition_subsize(bsize, PARTITION_VERT_4A);
+ const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE med_subsize =
+ get_partition_subsize(big_subsize, PARTITION_VERT);
+ assert(sml_subsize == get_partition_subsize(med_subsize, PARTITION_VERT));
+
+ const int cum_step_multipliers[4] = { 0, 1, 3, 7 };
+ const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, med_subsize, big_subsize,
+ sml_subsize };
+
+ for (int idx = 0; idx < 4; idx++) {
+ if (pc_tree->vertical4a[idx]) {
+ av1_free_pc_tree_recursive(pc_tree->vertical4a[idx], num_planes, 0, 0);
+ pc_tree->vertical4a[idx] = NULL;
+ }
+ const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[idx];
+ pc_tree->vertical4a[idx] = av1_alloc_pc_tree_node(
+ xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
+ PARTITION_VERT_4A, idx, idx == 3, ss_x, ss_y);
+ }
+
+ bool skippable = true;
+ for (int i = 0; i < 4; ++i) {
+ const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[i];
+
+ if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
+
+ SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical4a[i],
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree,
+ i),
+ mi_row,
+ this_mi_col,
+ subblock_sizes[i],
+ PARTITION_VERT_4A };
+ if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
+ &sum_rdc, multi_pass_mode, &skippable,
+ max_recursion_depth)) {
+ av1_invalid_rd_stats(&sum_rdc);
+ break;
+ }
+ }
+
+ av1_rd_cost_update(x->rdmult, &sum_rdc);
+ if (sum_rdc.rdcost < best_rdc->rdcost) {
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ *best_rdc = sum_rdc;
+ search_state->found_best_partition = true;
+ pc_tree->partitioning = PARTITION_VERT_4A;
+ pc_tree->skippable = skippable;
+ }
+
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+}
+
+static INLINE void search_partition_vert_4b(
+ PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+ TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+ PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
+ const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
+ const PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
+ const AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &td->mb;
+ const int num_planes = av1_num_planes(cm);
+ 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 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;
+
+ if (is_part_pruned_by_forced_partition(part_search_state,
+ PARTITION_VERT_4B) ||
+ !part_search_state->partition_4b_allowed[VERT] ||
+ part_search_state->prune_partition_4b[VERT]) {
+ return;
+ }
+
+ if (search_state->terminate_partition_search || !blk_params->has_cols ||
+ !is_partition_valid(bsize, PARTITION_VERT_4B) ||
+ !(search_state->do_rectangular_split ||
+ av1_active_v_edge(cpi, mi_col, blk_params->mi_step_w))) {
+ return;
+ }
+
+ const int part_v4b_rate = search_state->partition_cost[PARTITION_VERT_4B];
+ if (part_v4b_rate == INT_MAX ||
+ RDCOST(x->rdmult, part_v4b_rate, 0) >= best_rdc->rdcost) {
+ return;
+ }
+ RD_STATS sum_rdc;
+ av1_init_rd_stats(&sum_rdc);
+ const int eighth_step = mi_size_wide[bsize] / 8;
+
+ sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_4B];
+ sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
+
+ const BLOCK_SIZE sml_subsize =
+ get_partition_subsize(bsize, PARTITION_VERT_4B);
+ const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_VERT);
+ const BLOCK_SIZE med_subsize =
+ get_partition_subsize(big_subsize, PARTITION_VERT);
+ assert(sml_subsize == get_partition_subsize(med_subsize, PARTITION_VERT));
+
+ const int cum_step_multipliers[4] = { 0, 1, 5, 7 };
+ const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, big_subsize, med_subsize,
+ sml_subsize };
+
+ for (int idx = 0; idx < 4; idx++) {
+ if (pc_tree->vertical4b[idx]) {
+ av1_free_pc_tree_recursive(pc_tree->vertical4b[idx], num_planes, 0, 0);
+ pc_tree->vertical4b[idx] = NULL;
+ }
+ const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[idx];
+ pc_tree->vertical4b[idx] = av1_alloc_pc_tree_node(
+ xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
+ PARTITION_VERT_4B, idx, idx == 3, ss_x, ss_y);
+ }
+
+ bool skippable = true;
+ for (int i = 0; i < 4; ++i) {
+ const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[i];
+
+ if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
+
+ SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical4b[i],
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree,
+ i),
+ mi_row,
+ this_mi_col,
+ subblock_sizes[i],
+ PARTITION_VERT_4B };
+ if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
+ &sum_rdc, multi_pass_mode, &skippable,
+ max_recursion_depth)) {
+ av1_invalid_rd_stats(&sum_rdc);
+ break;
+ }
+ }
+
+ av1_rd_cost_update(x->rdmult, &sum_rdc);
+ if (sum_rdc.rdcost < best_rdc->rdcost) {
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ *best_rdc = sum_rdc;
+ search_state->found_best_partition = true;
+ pc_tree->partitioning = PARTITION_VERT_4B;
+ pc_tree->skippable = skippable;
+ }
+
+ av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+}
+#endif // CONFIG_UNEVEN_4WAY
+
/*!\brief Performs rdopt on PARTITION_HORZ_3. */
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, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
-#if CONFIG_C043_MVP_IMPROVEMENTS
- REF_MV_BANK *best_level_bank,
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- WARP_PARAM_BANK *best_level_warp_bank,
-#endif // WARP_CU_BANK
+ const PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
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;
+ if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_HORZ_3) ||
+ !part_search_state->partition_3_allowed[HORZ] ||
+ part_search_state->prune_partition_3[HORZ]) {
+ return;
+ }
+
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;
}
-#if CONFIG_H_PARTITION
// TODO(yuec): set default partition modes for the edge directly by ruling out
// h partitions from the syntax if the 2nd middle block is not in the frame.
if (mi_col + (mi_size_wide[bsize] >> 1) >= cm->mi_params.mi_cols) return;
-#endif // CONFIG_H_PARTITION
const int part_h3_rate = search_state->partition_cost[PARTITION_HORZ_3];
if (part_h3_rate == INT_MAX ||
@@ -4913,7 +6305,6 @@
sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_3];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
-#if CONFIG_H_PARTITION
const BLOCK_SIZE sml_subsize =
get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3);
const BLOCK_SIZE big_subsize =
@@ -4930,59 +6321,26 @@
}
pc_tree->horizontal3[idx] = av1_alloc_pc_tree_node(
- mi_row + offset_mr[idx], mi_col + offset_mc[idx], subblock_sizes[idx],
- pc_tree, PARTITION_HORZ_3, idx, idx == 3, ss_x, ss_y);
+ xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
+ subblock_sizes[idx], pc_tree, PARTITION_HORZ_3, idx, idx == 3, ss_x,
+ ss_y);
}
-#else // CONFIG_H_PARTITION
- const BLOCK_SIZE sml_subsize = get_partition_subsize(bsize, PARTITION_HORZ_3);
- const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
- 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);
-#endif // CONFIG_H_PARTITION
bool skippable = true;
-#if CONFIG_H_PARTITION
for (int i = 0; i < 4; ++i) {
const int this_mi_row = mi_row + offset_mr[i];
const int this_mi_col = mi_col + offset_mc[i];
-#else // CONFIG_H_PARTITION
- int this_mi_row = mi_row;
- for (int i = 0; i < 3; ++i) {
- this_mi_row += quarter_step * step_multipliers[i];
-#endif // CONFIG_H_PARTITION
if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
- SUBBLOCK_RDO_DATA rdo_data = {
- pc_tree->horizontal3[i],
- get_partition_subtree_const(ptree_luma, i),
- get_partition_subtree_const(template_tree, i),
- this_mi_row,
-#if CONFIG_H_PARTITION
- this_mi_col,
-#else
- mi_col,
-#endif // CONFIG_H_PARTITION
- subblock_sizes[i],
- PARTITION_HORZ_3
- };
+ SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal3[i],
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree,
+ i),
+ this_mi_row,
+ this_mi_col,
+ subblock_sizes[i],
+ PARTITION_HORZ_3 };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
@@ -4993,12 +6351,9 @@
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_HORZ_3;
@@ -5006,6 +6361,9 @@
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
/*!\brief Performs rdopt on PARTITION_VERT_3. */
@@ -5014,37 +6372,37 @@
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
-#if CONFIG_C043_MVP_IMPROVEMENTS
- REF_MV_BANK *best_level_bank,
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- WARP_PARAM_BANK *best_level_warp_bank,
-#endif // WARP_CU_BANK
+ const PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ LevelBanksRDO *level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
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;
+ if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_VERT_3) ||
+ !part_search_state->partition_3_allowed[VERT] ||
+ part_search_state->prune_partition_3[VERT]) {
+ return;
+ }
+
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_col, blk_params->mi_step_w))) {
return;
}
-#if CONFIG_H_PARTITION
// TODO(yuec): set default partition modes for the edge directly by ruling out
// h partitions from the syntax if the 2nd middle block is not in the frame.
if (mi_row + (mi_size_high[bsize] >> 1) >= cm->mi_params.mi_rows) return;
-#endif // CONFIG_H_PARTITION
const int part_v3_rate = search_state->partition_cost[PARTITION_VERT_3];
if (part_v3_rate == INT_MAX ||
@@ -5059,7 +6417,6 @@
sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_3];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
-#if CONFIG_H_PARTITION
const BLOCK_SIZE sml_subsize =
get_h_partition_subsize(bsize, 0, PARTITION_VERT_3);
const BLOCK_SIZE big_subsize =
@@ -5076,59 +6433,26 @@
}
pc_tree->vertical3[idx] = av1_alloc_pc_tree_node(
- mi_row + offset_mr[idx], mi_col + offset_mc[idx], subblock_sizes[idx],
- pc_tree, PARTITION_VERT_3, idx, idx == 3, ss_x, ss_y);
+ xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
+ subblock_sizes[idx], pc_tree, PARTITION_VERT_3, idx, idx == 3, ss_x,
+ ss_y);
}
-#else
- const BLOCK_SIZE sml_subsize = get_partition_subsize(bsize, PARTITION_VERT_3);
- const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_VERT);
- 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);
-#endif // CONFIG_H_PARTITION
bool skippable = true;
-#if CONFIG_H_PARTITION
for (int i = 0; i < 4; ++i) {
const int this_mi_row = mi_row + offset_mr[i];
const int this_mi_col = mi_col + offset_mc[i];
-#else
- int this_mi_col = mi_col;
- for (int i = 0; i < 3; ++i) {
- this_mi_col += quarter_step * step_multipliers[i];
-#endif // CONFIG_H_PARTITION
if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
- SUBBLOCK_RDO_DATA rdo_data = {
- pc_tree->vertical3[i],
- get_partition_subtree_const(ptree_luma, i),
- get_partition_subtree_const(template_tree, i),
-#if CONFIG_H_PARTITION
- this_mi_row,
-#else // CONFIG_H_PARTITION
- mi_row,
-#endif // CONFIG_H_PARTITION
- this_mi_col,
- subblock_sizes[i],
- PARTITION_VERT_3
- };
+ SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical3[i],
+ get_partition_subtree_const(ptree_luma, i),
+ get_partition_subtree_const(template_tree,
+ i),
+ this_mi_row,
+ this_mi_col,
+ subblock_sizes[i],
+ PARTITION_VERT_3 };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
@@ -5139,19 +6463,20 @@
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
-#if CONFIG_C043_MVP_IMPROVEMENTS
- *best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- *best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ update_best_level_banks(level_banks, &x->e_mbd);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_VERT_3;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ restore_level_banks(&x->e_mbd, level_banks);
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
+
#endif // CONFIG_EXT_RECUR_PARTITIONS
static AOM_INLINE int get_partition_depth(const PC_TREE *pc_tree,
@@ -5194,12 +6519,144 @@
get_partition_depth(pc_tree->vertical3[idx], curr_depth + 1));
}
break;
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ for (int idx = 0; idx < 4; idx++) {
+ max_depth = AOMMAX(
+ max_depth,
+ get_partition_depth(pc_tree->horizontal4a[idx], curr_depth + 1));
+ }
+ break;
+ case PARTITION_HORZ_4B:
+ for (int idx = 0; idx < 4; idx++) {
+ max_depth = AOMMAX(
+ max_depth,
+ get_partition_depth(pc_tree->horizontal4b[idx], curr_depth + 1));
+ }
+ break;
+ case PARTITION_VERT_4A:
+ for (int idx = 0; idx < 4; idx++) {
+ max_depth = AOMMAX(
+ max_depth,
+ get_partition_depth(pc_tree->vertical4a[idx], curr_depth + 1));
+ }
+ break;
+ case PARTITION_VERT_4B:
+ for (int idx = 0; idx < 4; idx++) {
+ max_depth = AOMMAX(
+ max_depth,
+ get_partition_depth(pc_tree->vertical4b[idx], curr_depth + 1));
+ }
+ break;
+#endif // CONFIG_UNEVEN_4WAY
default: assert(0); break;
}
return max_depth;
}
#if CONFIG_EXT_RECUR_PARTITIONS
+static AOM_INLINE bool try_none_after_rect(
+ const MACROBLOCKD *xd, const CommonModeInfoParams *mi_params,
+ BLOCK_SIZE bsize, int mi_row, int mi_col) {
+ if (!is_partition_point(bsize)) {
+ return false;
+ }
+ const int tree_idx = av1_get_sdp_idx(xd->tree_type);
+ // This speed feature is not applicable if either the above or left block is
+ // unavailable.
+ if (tree_idx == 0 && !(xd->up_available && xd->left_available)) {
+ return false;
+ }
+ if (tree_idx == 1 &&
+ !(xd->chroma_up_available && xd->chroma_left_available)) {
+ return false;
+ }
+ // Scan for the maximum and minimum dimension of the above and left blocks.
+ const int mi_stride = xd->mi_stride;
+ int min_left_dim_log2 = INT_MAX, min_above_dim_log2 = INT_MAX;
+ int max_left_dim_log2 = 0, max_above_dim_log2 = 0;
+ const int mi_height =
+ AOMMIN(mi_size_high[bsize], mi_params->mi_rows - mi_row);
+ const int mi_width = AOMMIN(mi_size_wide[bsize], mi_params->mi_cols - mi_col);
+ for (int row = 0; row < mi_height;) {
+ const MB_MODE_INFO *mi = xd->mi[row * mi_stride - 1];
+ const BLOCK_SIZE left_bsize = mi->sb_type[tree_idx];
+
+ min_left_dim_log2 =
+ AOMMIN(min_left_dim_log2, mi_size_high_log2[left_bsize]);
+ max_left_dim_log2 =
+ AOMMAX(max_left_dim_log2, mi_size_high_log2[left_bsize]);
+ const int row_step =
+ tree_idx == 0
+ ? mi_size_high[left_bsize] - AOMMAX(mi_row - mi->mi_row_start, 0)
+ : mi_size_high[left_bsize] -
+ AOMMAX(mi_row - mi->chroma_mi_row_start, 0);
+ row += row_step;
+ assert(row_step > 0);
+ }
+ for (int col = 0; col < mi_width;) {
+ const MB_MODE_INFO *mi = xd->mi[-1 * mi_stride + col];
+ const BLOCK_SIZE above_bsize = mi->sb_type[tree_idx];
+
+ min_above_dim_log2 =
+ AOMMIN(min_above_dim_log2, mi_size_wide_log2[above_bsize]);
+ max_above_dim_log2 =
+ AOMMAX(max_above_dim_log2, mi_size_wide_log2[above_bsize]);
+ const int col_step =
+ tree_idx == 0
+ ? mi_size_wide[above_bsize] - AOMMAX(mi_col - mi->mi_col_start, 0)
+ : mi_size_wide[above_bsize] -
+ AOMMAX(mi_col - mi->chroma_mi_col_start, 0);
+ col += col_step;
+ assert(col_step > 0);
+ }
+ // Delay the search for partition none if the above width and left height
+ // are not bigger than the current block dimension AND at least one of the
+ // dimensions if smaller than the current block by a factor of 4.
+ if ((mi_size_high_log2[bsize] > max_left_dim_log2 + 1 &&
+ mi_size_wide_log2[bsize] >= min_above_dim_log2) ||
+ (mi_size_wide_log2[bsize] > max_above_dim_log2 + 1 &&
+ mi_size_high_log2[bsize] >= min_left_dim_log2)) {
+ return true;
+ }
+ return false;
+}
+
+/*!\brief Prune PARTITION_NONE search if rect partitions split deeper.
+ */
+static AOM_INLINE void prune_none_with_rect_results(
+ PartitionSearchState *part_search_state, const PC_TREE *pc_tree) {
+ if (!part_search_state->found_best_partition) {
+ return;
+ }
+
+ const PARTITION_TYPE cur_best_partition = pc_tree->partitioning;
+ PC_TREE *const *tree = NULL;
+ int num_sub_parts = 0;
+ if (cur_best_partition == PARTITION_SPLIT) {
+ tree = pc_tree->split;
+ num_sub_parts = SUB_PARTITIONS_SPLIT;
+ } else if (cur_best_partition == PARTITION_HORZ) {
+ tree = pc_tree->horizontal;
+ num_sub_parts = NUM_RECT_PARTS;
+ } else if (cur_best_partition == PARTITION_VERT) {
+ tree = pc_tree->vertical;
+ num_sub_parts = NUM_RECT_PARTS;
+ } else {
+ assert(0 &&
+ "Unexpected best partition type in prune_none_with_rect_results.");
+ }
+ // Give up on PARTITION_NONE if either of the subtrees decided to split
+ // further.
+ for (int idx = 0; idx < num_sub_parts; idx++) {
+ if (!tree[idx]) {
+ break;
+ }
+ part_search_state->prune_partition_none |=
+ tree[idx]->partitioning != PARTITION_NONE;
+ }
+}
+
/*!\brief AV1 block partition search (full search).
*
* \ingroup partition_search
@@ -5309,14 +6766,12 @@
// Initialization of state variables used in partition search.
init_partition_search_state_params(x, cpi, &part_search_state,
#if CONFIG_EXT_RECUR_PARTITIONS
- pc_tree,
+ pc_tree, ptree_luma, template_tree,
+ max_recursion_depth,
#endif // CONFIG_EXT_RECUR_PARTITIONS
mi_row, mi_col, bsize);
PartitionBlkParams blk_params = part_search_state.part_blk_params;
#if CONFIG_EXT_RECUR_PARTITIONS
- PARTITION_TYPE forced_partition =
- get_forced_partition_type(cm, x, mi_row, mi_col, bsize, template_tree,
- ptree_luma, &pc_tree->chroma_ref_info);
if (sms_tree != NULL)
#endif // CONFIG_EXT_RECUR_PARTITIONS
sms_tree->partitioning = PARTITION_NONE;
@@ -5334,11 +6789,12 @@
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);
+ &td->shared_coeff_buf, xd->tree_type,
+ num_planes);
*rd_cost = pc_tree->rd_cost;
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT
x->e_mbd.ref_mv_bank = counterpart_block->ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
x->e_mbd.warp_param_bank = counterpart_block->warp_param_bank;
#endif // WARP_CU_BANK
@@ -5377,14 +6833,12 @@
#endif
#endif
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Override partition costs at the edges of the frame in the same
// way as in read_partition (see decodeframe.c).
if (!(blk_params.has_rows && blk_params.has_cols))
- set_partition_cost_for_edge_blk(cm, xd,
-#if CONFIG_EXT_RECUR_PARTITIONS
- &pc_tree->chroma_ref_info,
-#endif // CONFIG_EXT_RECUR_PARTITIONS
- &part_search_state);
+ set_partition_cost_for_edge_blk(cm, xd, &part_search_state);
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Disable rectangular partitions for inner blocks when the current block is
// forced to only use square partitions.
@@ -5412,6 +6866,17 @@
av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize,
&pc_tree->chroma_ref_info);
+ bool search_none_after_rect = false;
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (part_search_state.forced_partition == PARTITION_INVALID) {
+ if (cpi->sf.part_sf.adaptive_partition_search_order) {
+ search_none_after_rect =
+ try_none_after_rect(xd, &cm->mi_params, bsize, mi_row, mi_col);
+ }
+ search_none_after_rect |= bsize == BLOCK_256X256;
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
+
// Save rdmult before it might be changed, so it can be restored later.
const int orig_rdmult = x->rdmult;
setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL);
@@ -5428,6 +6893,16 @@
xd->left_txfm_context =
xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
av1_save_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT
+ LevelBanksRDO level_banks = {
+ x->e_mbd.ref_mv_bank, /* curr_level_bank*/
+ x->e_mbd.ref_mv_bank, /* best_level_bank*/
+#if WARP_CU_BANK
+ x->e_mbd.warp_param_bank, /* curr_level_warp_bank*/
+ x->e_mbd.warp_param_bank, /* best_level_warp_bank*/
+#endif // WARP_CU_BANK
+ };
+#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_EXT_RECUR_PARTITIONS
{
SimpleMotionData *sms_data =
@@ -5439,11 +6914,11 @@
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
- if (forced_partition == PARTITION_INVALID &&
+ if (part_search_state.forced_partition == PARTITION_INVALID &&
is_bsize_gt(bsize, x->sb_enc.min_partition_size)) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
- int *prune_horz = &part_search_state.prune_rect_part[HORZ];
- int *prune_vert = &part_search_state.prune_rect_part[VERT];
+ bool *prune_horz = &part_search_state.prune_rect_part[HORZ];
+ bool *prune_vert = &part_search_state.prune_rect_part[VERT];
#if CONFIG_EXT_RECUR_PARTITIONS
int do_square_split = true;
int *sqr_split_ptr = &do_square_split;
@@ -5458,9 +6933,9 @@
partition_vert_allowed, &part_search_state.do_rectangular_split,
sqr_split_ptr, prune_horz, prune_vert, pc_tree);
#if CONFIG_EXT_RECUR_PARTITIONS
- forced_partition = get_forced_partition_type(
+ part_search_state.forced_partition = get_forced_partition_type(
cm, x, blk_params.mi_row, blk_params.mi_col, blk_params.bsize,
- template_tree, ptree_luma, &pc_tree->chroma_ref_info);
+ ptree_luma, template_tree, &pc_tree->chroma_ref_info);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -5476,34 +6951,7 @@
#endif
int luma_split_flag = 0;
-#if CONFIG_EXT_RECUR_PARTITIONS
- int horz_3_allowed_sdp = 1;
- int vert_3_allowed_sdp = 1;
- if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
- 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
- assert(IMPLIES(
- is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize),
- forced_partition == PARTITION_INVALID ||
- forced_partition == sdp_chroma_part_from_luma(
- bsize, ptree_luma->partition,
- cpi->common.seq_params.subsampling_x,
- cpi->common.seq_params.subsampling_x)));
- }
-#else // CONFIG_EXT_RECUR_PARTITIONS
+#if !CONFIG_EXT_RECUR_PARTITIONS
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int parent_block_width = block_size_wide[bsize];
if (xd->tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) {
@@ -5515,7 +6963,7 @@
part_search_state.partition_rect_allowed[HORZ] = 0;
part_search_state.partition_rect_allowed[VERT] = 0;
}
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Partition search
BEGIN_PARTITION_SEARCH:
@@ -5525,8 +6973,7 @@
if (x->must_find_valid_partition) {
#if CONFIG_EXT_RECUR_PARTITIONS
init_allowed_partitions(&part_search_state, &cpi->oxcf.part_cfg,
- &pc_tree->chroma_ref_info, &cm->mi_params,
- xd->tree_type);
+ &pc_tree->chroma_ref_info, xd->tree_type);
#else
reset_part_limitations(cpi, &part_search_state);
#endif // CONFIG_EXT_RECUR_PARTITIONS
@@ -5537,41 +6984,21 @@
// PARTITION_NONE search stage.
int64_t part_none_rd = INT64_MAX;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- REF_MV_BANK curr_level_bank = x->e_mbd.ref_mv_bank;
- REF_MV_BANK best_level_bank = x->e_mbd.ref_mv_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- WARP_PARAM_BANK curr_level_warp_bank = x->e_mbd.warp_param_bank;
- WARP_PARAM_BANK best_level_warp_bank = x->e_mbd.warp_param_bank;
-#endif // WARP_CU_BANK
-#if CONFIG_EXT_RECUR_PARTITIONS
- if (IS_FORCED_PARTITION_TYPE(PARTITION_NONE) &&
- (forced_partition == PARTITION_NONE || bsize != BLOCK_256X256)) {
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+ if (!search_none_after_rect) {
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_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- &best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- &best_level_warp_bank
-#endif // WARP_CU_BANK
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = curr_level_warp_bank;
-#endif // WARP_CU_BANK
-#if CONFIG_EXT_RECUR_PARTITIONS
}
+#if CONFIG_EXT_RECUR_PARTITIONS
if (cpi->sf.part_sf.end_part_search_after_consec_failures && x->is_whole_sb &&
- !frame_is_intra_only(cm) && forced_partition == PARTITION_INVALID &&
+ !frame_is_intra_only(cm) &&
+ part_search_state.forced_partition == PARTITION_INVALID &&
pc_tree->parent && pc_tree->parent->parent) {
if (pc_tree->none_rd.rate == INT_MAX &&
pc_tree->parent->none_rd.rate == INT_MAX &&
@@ -5585,33 +7012,20 @@
// PARTITION_SPLIT search stage.
int64_t part_split_rd = INT64_MAX;
- if (IS_FORCED_PARTITION_TYPE(PARTITION_SPLIT) && max_recursion_depth > 0 &&
- !frame_is_intra_only(cm)) {
- split_partition_search(cpi, td, tile_data, tp, x, pc_tree, sms_tree, &x_ctx,
- &part_search_state, &best_rdc, multi_pass_mode,
- &part_split_rd
-#if CONFIG_C043_MVP_IMPROVEMENTS
- ,
- &best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- &best_level_warp_bank
-#endif // WARP_CU_BANK
+ split_partition_search(cpi, td, tile_data, tp, x, pc_tree, sms_tree, &x_ctx,
+ &part_search_state, &best_rdc, multi_pass_mode,
+ &part_split_rd
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ ,
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
#if CONFIG_EXT_RECUR_PARTITIONS
- ,
- ptree_luma, template_tree, max_recursion_depth - 1
+ ,
+ ptree_luma, template_tree, max_recursion_depth - 1
#endif // CONFIG_EXT_RECUR_PARTITIONS
- );
- }
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = curr_level_warp_bank;
-#endif // WARP_CU_BANK
-#if !CONFIG_EXT_RECUR_PARTITIONS
+ );
+#if !CONFIG_EXT_RECUR_PARTITIONS
// Terminate partition search for child partition,
// when NONE and SPLIT partition rd_costs are INT64_MAX.
if (cpi->sf.part_sf.early_term_after_none_split &&
@@ -5626,15 +7040,18 @@
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
bool prune_none = false;
- if (forced_partition == PARTITION_INVALID && bsize == BLOCK_256X256) {
+ if (part_search_state.forced_partition == PARTITION_INVALID &&
+ bsize == BLOCK_256X256) {
+ assert(pc_tree->partitioning == PARTITION_SPLIT);
for (int idx = 0; idx < 4; idx++) {
const int depth = get_partition_depth(pc_tree->split[idx], 0);
prune_none |= depth > 0;
}
}
if (cpi->sf.part_sf.prune_rect_with_split_depth && !frame_is_intra_only(cm) &&
- forced_partition == PARTITION_INVALID && pc_tree->split[0] &&
- pc_tree->split[1] && pc_tree->split[2] && pc_tree->split[3]) {
+ part_search_state.forced_partition == PARTITION_INVALID &&
+ pc_tree->split[0] && pc_tree->split[1] && pc_tree->split[2] &&
+ pc_tree->split[3]) {
int min_depth = INT_MAX, max_depth = 0;
for (int idx = 0; idx < 4; idx++) {
const int depth = get_partition_depth(pc_tree->split[idx], 0);
@@ -5649,52 +7066,35 @@
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
- if (forced_partition == PARTITION_INVALID && bsize == BLOCK_256X256 &&
- !prune_none) {
+ bool none_searched = false;
+ if (part_search_state.forced_partition == PARTITION_INVALID &&
+ bsize == BLOCK_256X256 && !prune_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_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- &best_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- &best_level_warp_bank
-#endif // WARP_CU_BANK
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = curr_level_warp_bank;
-#endif // WARP_CU_BANK
#if CONFIG_EXT_RECUR_PARTITIONS
+ none_searched = true;
}
#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
- if (max_recursion_depth > 0) {
+ multi_pass_mode, ptree_luma, template_tree, max_recursion_depth - 1,
#endif // CONFIG_EXT_RECUR_PARTITIONS
- 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, ptree_luma, template_tree,
- max_recursion_depth - 1,
-#endif // CONFIG_EXT_RECUR_PARTITIONS
- rect_part_win_info,
-#if CONFIG_C043_MVP_IMPROVEMENTS
- &best_level_bank, &curr_level_bank,
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- &best_level_warp_bank, &curr_level_warp_bank,
-#endif // WARP_CU_BANK
- part_none_rd);
-#if CONFIG_EXT_RECUR_PARTITIONS
- }
-#endif // CONFIG_EXT_RECUR_PARTITIONS
+ rect_part_win_info,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ part_none_rd);
+
if (pb_source_variance == UINT_MAX) {
av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, NULL);
pb_source_variance = av1_high_get_sby_perpixel_variance(
@@ -5703,6 +7103,19 @@
assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
!part_search_state.do_rectangular_split));
+#if CONFIG_EXT_RECUR_PARTITIONS
+ if (search_none_after_rect && !none_searched) {
+ prune_none_with_rect_results(&part_search_state, pc_tree);
+ 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_MVP_IMPROVEMENT || WARP_CU_BANK
+ ,
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ );
+ }
+#endif // CONFIG_EXT_RECUR_PARTITIONS
#if !CONFIG_EXT_RECUR_PARTITIONS
const int ext_partition_allowed =
@@ -5714,14 +7127,10 @@
ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
&part_search_state, &best_rdc, rect_part_win_info,
pb_source_variance, ext_partition_allowed
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- &best_level_bank, &curr_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- &best_level_warp_bank, &curr_level_warp_bank
-#endif // WARP_CU_BANK
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
// 4-way partitions search stage.
@@ -5754,14 +7163,10 @@
rd_pick_4partition(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
pc_tree->horizontal4, &part_search_state, &best_rdc,
inc_step, PARTITION_HORZ_4
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- &best_level_bank, &curr_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- &best_level_warp_bank, &curr_level_warp_bank
-#endif // WARP_CU_BANK
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
@@ -5778,132 +7183,88 @@
rd_pick_4partition(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
pc_tree->vertical4, &part_search_state, &best_rdc,
inc_step, PARTITION_VERT_4
-#if CONFIG_C043_MVP_IMPROVEMENTS
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
- &best_level_bank, &curr_level_bank
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- ,
- &best_level_warp_bank, &curr_level_warp_bank
-#endif // WARP_CU_BANK
+ &level_banks
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
- const int ext_partition_allowed = !is_partition_implied_at_boundary(
- &cm->mi_params, xd->tree_type, part_search_state.ss_x,
- part_search_state.ss_y, mi_row, mi_col, bsize, &pc_tree->chroma_ref_info,
- NULL);
- const int partition_3_allowed = ext_partition_allowed &&
- max_recursion_depth > 0 &&
- cpi->oxcf.part_cfg.enable_ext_partitions;
- 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 PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
-
- int horz_3_allowed =
- partition_3_allowed && !is_wide_block && horz_3_allowed_sdp &&
- check_is_chroma_size_valid(xd->tree_type, PARTITION_HORZ_3, bsize, mi_row,
- mi_col, part_search_state.ss_x,
- part_search_state.ss_y,
- &pc_tree->chroma_ref_info) &&
- is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_3),
- blk_params.min_partition_size);
- // Prune horz 3 with speed features
- if (horz_3_allowed && !frame_is_intra_only(cm) &&
- forced_partition != PARTITION_HORZ_3) {
- if (part_sf->prune_part_3_with_part_none &&
- pc_tree->partitioning == PARTITION_NONE) {
- // Prune if the best partition does not split
- horz_3_allowed = 0;
- }
- if (part_sf->prune_part_3_with_part_rect &&
- pc_tree->partitioning == PARTITION_HORZ &&
- !node_uses_horz(pc_tree->horizontal[0]) &&
- !node_uses_horz(pc_tree->horizontal[1])) {
- // Prune if the best partition is horz but horz did not further split in
- // horz
- horz_3_allowed = 0;
- }
- }
-
- int vert_3_allowed =
- partition_3_allowed && !is_tall_block && vert_3_allowed_sdp &&
- check_is_chroma_size_valid(xd->tree_type, PARTITION_VERT_3, bsize, mi_row,
- mi_col, part_search_state.ss_x,
- part_search_state.ss_y,
- &pc_tree->chroma_ref_info) &&
- is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_3),
- blk_params.min_partition_size);
-
- if (vert_3_allowed && !frame_is_intra_only(cm) &&
- forced_partition != PARTITION_VERT_3) {
- if (part_sf->prune_part_3_with_part_none &&
- pc_tree->partitioning == PARTITION_NONE) {
- // Prune if the best partition does not split
- vert_3_allowed = 0;
- }
- if (part_sf->prune_part_3_with_part_rect &&
- pc_tree->partitioning == PARTITION_VERT &&
- !node_uses_vert(pc_tree->vertical[0]) &&
- !node_uses_vert(pc_tree->vertical[1])) {
- // Prune if the best partition is vert but vert did not further split in
- // vert
- vert_3_allowed = 0;
- }
- }
+ bool partition_boundaries[MAX_MIB_SQUARE] = { 0 };
+ prune_ext_partitions_3way(cpi, pc_tree, &part_search_state,
+ partition_boundaries);
const int ext_recur_depth =
AOMMIN(max_recursion_depth - 1, cpi->sf.part_sf.ext_recur_depth);
+ const bool track_ptree_luma =
+ is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize);
// 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,
- (ptree_luma && ptree_luma->partition == PARTITION_HORZ_3) ? ptree_luma
- : NULL,
-
- template_tree, &x_ctx,
-#if CONFIG_C043_MVP_IMPROVEMENTS
- &best_level_bank,
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- &best_level_warp_bank,
-#endif // WARP_CU_BANK
- multi_pass_mode, ext_recur_depth);
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = curr_level_warp_bank;
-#endif // WARP_CU_BANK
- }
+ search_partition_horz_3(&part_search_state, cpi, td, tile_data, tp, &best_rdc,
+ pc_tree, track_ptree_luma ? ptree_luma : NULL,
+ template_tree, &x_ctx, &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ multi_pass_mode, ext_recur_depth);
// 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,
- (ptree_luma && ptree_luma->partition == PARTITION_VERT_3) ? ptree_luma
- : NULL,
-
- template_tree, &x_ctx,
-#if CONFIG_C043_MVP_IMPROVEMENTS
- &best_level_bank,
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- &best_level_warp_bank,
-#endif // WARP_CU_BANK
- multi_pass_mode, ext_recur_depth);
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = curr_level_bank;
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
-#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = curr_level_warp_bank;
-#endif // WARP_CU_BANK
- }
+ search_partition_vert_3(&part_search_state, cpi, td, tile_data, tp, &best_rdc,
+ pc_tree, track_ptree_luma ? ptree_luma : NULL,
+ template_tree, &x_ctx, &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ multi_pass_mode, ext_recur_depth);
#endif // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_UNEVEN_4WAY
+ prune_ext_partitions_4way(cpi, pc_tree, &part_search_state,
+ partition_boundaries);
+
+ // PARTITION_HORZ_4A
+ search_partition_horz_4a(&part_search_state, cpi, td, tile_data, tp,
+ &best_rdc, pc_tree,
+ track_ptree_luma ? ptree_luma : NULL, template_tree,
+ &x_ctx, &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ multi_pass_mode, ext_recur_depth);
+
+ // PARTITION_HORZ_4B
+ search_partition_horz_4b(&part_search_state, cpi, td, tile_data, tp,
+ &best_rdc, pc_tree,
+ track_ptree_luma ? ptree_luma : NULL, template_tree,
+ &x_ctx, &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ multi_pass_mode, ext_recur_depth);
+
+ // PARTITION_VERT_4A
+ search_partition_vert_4a(&part_search_state, cpi, td, tile_data, tp,
+ &best_rdc, pc_tree,
+ track_ptree_luma ? ptree_luma : NULL, template_tree,
+ &x_ctx, &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ multi_pass_mode, ext_recur_depth);
+
+ // PARTITION_VERT_4B
+ search_partition_vert_4b(&part_search_state, cpi, td, tile_data, tp,
+ &best_rdc, pc_tree,
+ track_ptree_luma ? ptree_luma : NULL, template_tree,
+ &x_ctx, &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ &level_banks,
+#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+ multi_pass_mode, ext_recur_depth);
+#endif // CONFIG_UNEVEN_4WAY
+
if (bsize == cm->sb_size && !part_search_state.found_best_partition) {
if (x->must_find_valid_partition) {
aom_internal_error(
@@ -5924,23 +7285,27 @@
pc_tree->partitioning != template_tree->partition) {
assert(0);
printf("Mismatch with template at fr: %d, mi: (%d, %d), BLOCK_%dX%d\n",
- cm->current_frame.order_hint, mi_row, mi_col, block_size_wide[bsize],
- block_size_high[bsize]);
+#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ cm->current_frame.display_order_hint,
+#else
+ cm->current_frame.order_hint,
+#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
+ mi_row, mi_col, block_size_wide[bsize], block_size_high[bsize]);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS && !defined(NDEBUG)
// Store the final rd cost
*rd_cost = best_rdc;
-#if CONFIG_C043_MVP_IMPROVEMENTS
- x->e_mbd.ref_mv_bank = best_level_bank;
+#if CONFIG_MVP_IMPROVEMENT
+ x->e_mbd.ref_mv_bank = level_banks.best_level_bank;
#if CONFIG_EXT_RECUR_PARTITIONS
- pc_tree->ref_mv_bank = best_level_bank;
+ pc_tree->ref_mv_bank = level_banks.best_level_bank;
#endif // CONFIG_EXT_RECUR_PARTITIONS
-#endif // CONFIG_C043_MVP_IMPROVEMENTS
+#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
- x->e_mbd.warp_param_bank = best_level_warp_bank;
+ x->e_mbd.warp_param_bank = level_banks.best_level_warp_bank;
#if CONFIG_EXT_RECUR_PARTITIONS
- pc_tree->warp_param_bank = best_level_warp_bank;
+ pc_tree->warp_param_bank = level_banks.best_level_warp_bank;
#endif // CONFIG_EXT_RECUR_PARTITIONS
#endif // WARP_CU_BANK
pc_tree->rd_cost = best_rdc;
diff --git a/av1/encoder/partition_strategy.c b/av1/encoder/partition_strategy.c
index 89fb2d7..cc8ea99 100644
--- a/av1/encoder/partition_strategy.c
+++ b/av1/encoder/partition_strategy.c
@@ -253,6 +253,9 @@
int *partition_horz_allowed, int *partition_vert_allowed,
int *do_rectangular_split, int *do_square_split) {
aom_clear_system_state();
+ (void)partition_horz_allowed;
+ (void)partition_vert_allowed;
+ (void)do_rectangular_split;
const AV1_COMMON *const cm = &cpi->common;
const int bsize_idx = convert_bsize_to_idx(bsize);
@@ -511,7 +514,11 @@
void av1_simple_motion_search_prune_rect(
AV1_COMP *const cpi, MACROBLOCK *x, SIMPLE_MOTION_DATA_TREE *sms_tree,
int mi_row, int mi_col, BLOCK_SIZE bsize, int partition_horz_allowed,
- int partition_vert_allowed, int *prune_horz, int *prune_vert) {
+ int partition_vert_allowed, bool *prune_horz, bool *prune_vert) {
+ // TODO(urvang): Need to change for CONFIG_UNEVEN_4WAY.
+#if CONFIG_UNEVEN_4WAY
+ assert(0 && "Not implemented");
+#endif // CONFIG_UNEVEN_4WAY
aom_clear_system_state();
const AV1_COMMON *const cm = &cpi->common;
const int bsize_idx = convert_bsize_to_idx(bsize);
@@ -924,8 +931,8 @@
void av1_ml_prune_rect_partition(const AV1_COMP *const cpi,
const MACROBLOCK *const x, BLOCK_SIZE bsize,
int64_t best_rd, int64_t none_rd,
- int64_t *split_rd, int *const dst_prune_horz,
- int *const dst_prune_vert) {
+ int64_t *split_rd, bool *const dst_prune_horz,
+ bool *const dst_prune_vert) {
if (bsize < BLOCK_8X8 || best_rd >= 1000000000) return;
best_rd = AOMMAX(best_rd, 1);
const NN_CONFIG *nn_config = NULL;
@@ -1091,6 +1098,7 @@
}
}
+#if !CONFIG_EXT_RECUR_PARTITIONS
#define FEATURES 18
#define LABELS 4
// Use a ML model to predict if horz4 and vert4 should be considered.
@@ -1229,6 +1237,8 @@
#undef FEATURES
#undef LABELS
+#endif // !CONFIG_EXT_RECUR_PARTITIONS
+
#define FEATURES 4
int av1_ml_predict_breakout(const AV1_COMP *const cpi, BLOCK_SIZE bsize,
const MACROBLOCK *const x,
@@ -1300,7 +1310,7 @@
BLOCK_SIZE bsize, SIMPLE_MOTION_DATA_TREE *const sms_tree,
int *partition_none_allowed, int *partition_horz_allowed,
int *partition_vert_allowed, int *do_rectangular_split,
- int *do_square_split, int *prune_horz, int *prune_vert,
+ int *do_square_split, bool *prune_horz, bool *prune_vert,
const PC_TREE *pc_tree) {
const AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
@@ -1342,27 +1352,15 @@
do_square_split);
#if CONFIG_EXT_RECUR_PARTITIONS
if (!*partition_none_allowed) {
- if (!pc_tree->parent || pc_tree != pc_tree->parent->horizontal3[1]) {
- av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, bsize,
- cm->sb_size, PARTITION_HORZ);
- const int mi_step = block_size_high[bsize] / 2;
- BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_HORZ);
- av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, subsize,
- cm->sb_size, PARTITION_VERT);
- av1_cache_best_partition(x->sms_bufs, mi_row + mi_step, mi_col, subsize,
- cm->sb_size, PARTITION_VERT);
- } else if (pc_tree != pc_tree->parent->vertical[1]) {
- av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, bsize,
- cm->sb_size, PARTITION_VERT);
- const int mi_step = block_size_wide[bsize] / 2;
- BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_VERT);
- av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, subsize,
- cm->sb_size, PARTITION_HORZ);
- av1_cache_best_partition(x->sms_bufs, mi_row, mi_col + mi_step, subsize,
- cm->sb_size, PARTITION_HORZ);
- }
+ av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, bsize, cm->sb_size,
+ PARTITION_HORZ);
+ const int mi_step = block_size_high[bsize] / 2;
+ BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_HORZ);
+ av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, subsize,
+ cm->sb_size, PARTITION_VERT);
+ av1_cache_best_partition(x->sms_bufs, mi_row + mi_step, mi_col, subsize,
+ cm->sb_size, PARTITION_VERT);
}
-#else
(void)pc_tree;
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
@@ -1631,6 +1629,24 @@
}
// Gets the linear index corresponds to the current block.
+
+#if CONFIG_UNEVEN_4WAY
+static INLINE int get_sms_arr_1d_idx(int mi_bsize, int mi_in_sb) {
+ int idx = -1;
+ if (mi_bsize <= 2) {
+ idx = mi_in_sb;
+ } else if (mi_bsize <= 8) {
+ assert(mi_in_sb % (mi_bsize / 4) == 0);
+ idx = mi_in_sb / (mi_bsize / 4);
+ } 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;
+}
+#else
static INLINE int get_sms_arr_1d_idx(int mi_bsize, int mi_in_sb) {
int idx = -1;
if (mi_bsize == 1) {
@@ -1643,6 +1659,7 @@
return idx;
}
+#endif // CONFIG_UNEVEN_4WAY
#define MAKE_SMS_ARR_SWITCH_CASE(width, height) \
case BLOCK_##width##X##height: { \
@@ -1817,42 +1834,59 @@
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;
+ const int eighth_step_h = block_size_high[bsize] / 8;
+ const int eighth_step_w = block_size_wide[bsize] / 8;
static const int subblock_count[ALL_PARTITION_TYPES] = {
1, // PARTITION_NONE
2, // PARTITION_HORZ
2, // PARTITION_VERT
-#if CONFIG_H_PARTITION
4, // PARTITION_HORZ_3
4, // PARTITION_VERT_3
-#else
- 3, // PARTITION_HORZ_3
- 3, // PARTITION_VERT_3
-#endif // CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ 4, // PARTITION_HORZ_4A
+ 4, // PARTITION_HORZ_4B
+ 4, // PARTITION_VERT_4A
+ 4, // PARTITION_VERT_4B
+#endif // CONFIG_UNEVEN_4WAY
4, // PARTITION_SPLIT
};
// PARTITION x NUM_SUBBLOCKS x (ROW and COL)
static const int step_multiplier[ALL_PARTITION_TYPES][4][2] = {
{ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }, // PARTITION_NONE
- { { 0, 0 }, { 2, 0 }, { 0, 0 }, { 0, 0 } }, // PARTITION_HORZ
- { { 0, 0 }, { 0, 2 }, { 0, 0 }, { 0, 0 } }, // PARTITION_VERT
-#if CONFIG_H_PARTITION
- { { 0, 0 }, { 1, 0 }, { 1, 2 }, { 3, 0 } }, // PARTITION_HORZ_3
- { { 0, 0 }, { 0, 1 }, { 2, 1 }, { 0, 3 } }, // PARTITION_VERT_3
-#else
- { { 0, 0 }, { 1, 0 }, { 3, 0 }, { 0, 0 } }, // PARTITION_HORZ_3
- { { 0, 0 }, { 0, 1 }, { 0, 3 }, { 0, 0 } }, // PARTITION_VERT_3
-#endif // CONFIG_H_PARTITION
- { { 0, 0 }, { 0, 2 }, { 2, 0 }, { 2, 2 } }, // PARTITION_SPLIT
+ { { 0, 0 }, { 4, 0 }, { 0, 0 }, { 0, 0 } }, // PARTITION_HORZ
+ { { 0, 0 }, { 0, 4 }, { 0, 0 }, { 0, 0 } }, // PARTITION_VERT
+ { { 0, 0 }, { 2, 0 }, { 2, 4 }, { 6, 0 } }, // PARTITION_HORZ_3
+ { { 0, 0 }, { 0, 2 }, { 4, 2 }, { 0, 6 } }, // PARTITION_VERT_3
+#if CONFIG_UNEVEN_4WAY
+ { { 0, 0 }, { 1, 0 }, { 3, 0 }, { 7, 0 } }, // PARTITION_HORZ_4A
+ { { 0, 0 }, { 1, 0 }, { 5, 0 }, { 7, 0 } }, // PARTITION_HORZ_4B
+ { { 0, 0 }, { 0, 1 }, { 0, 3 }, { 0, 7 } }, // PARTITION_VERT_4A
+ { { 0, 0 }, { 0, 1 }, { 0, 5 }, { 0, 7 } }, // PARTITION_VERT_4B
+#endif // CONFIG_UNEVEN_4WAY
+ { { 0, 0 }, { 0, 4 }, { 4, 0 }, { 4, 4 } }, // PARTITION_SPLIT
};
+ // Sizes of subblocks.
const BLOCK_SIZE part_subsize = get_partition_subsize(bsize, partition);
if (part_subsize == BLOCK_INVALID) return;
BLOCK_SIZE subsizes[4] = { part_subsize, part_subsize, part_subsize,
part_subsize };
-#if CONFIG_H_PARTITION
+#if CONFIG_UNEVEN_4WAY
+ if (partition == PARTITION_HORZ_4A) {
+ subsizes[2] = get_partition_subsize(bsize, PARTITION_HORZ);
+ subsizes[1] = get_partition_subsize(subsizes[2], PARTITION_HORZ);
+ } else if (partition == PARTITION_HORZ_4B) {
+ subsizes[1] = get_partition_subsize(bsize, PARTITION_HORZ);
+ subsizes[2] = get_partition_subsize(subsizes[1], PARTITION_HORZ);
+ } else if (partition == PARTITION_VERT_4A) {
+ subsizes[2] = get_partition_subsize(bsize, PARTITION_VERT);
+ subsizes[1] = get_partition_subsize(subsizes[2], PARTITION_VERT);
+ } else if (partition == PARTITION_VERT_4B) {
+ subsizes[1] = get_partition_subsize(bsize, PARTITION_VERT);
+ subsizes[2] = get_partition_subsize(subsizes[1], PARTITION_VERT);
+ }
+#endif // CONFIG_UNEVEN_4WAY
if (partition == PARTITION_HORZ_3) {
subsizes[1] = get_h_partition_subsize(sb_size, 1, PARTITION_HORZ_3);
subsizes[2] = get_h_partition_subsize(sb_size, 2, PARTITION_HORZ_3);
@@ -1860,12 +1894,12 @@
subsizes[1] = get_h_partition_subsize(sb_size, 1, PARTITION_VERT_3);
subsizes[2] = get_h_partition_subsize(sb_size, 2, PARTITION_VERT_3);
}
-#endif // CONFIG_H_PARTITION
+
for (int idx = 0; idx < subblock_count[partition]; idx++) {
const int sub_row =
- mi_row + step_multiplier[partition][idx][0] * quarter_step_h / 4;
+ mi_row + step_multiplier[partition][idx][0] * eighth_step_h / 4;
const int sub_col =
- mi_col + step_multiplier[partition][idx][1] * quarter_step_w / 4;
+ mi_col + step_multiplier[partition][idx][1] * eighth_step_w / 4;
SimpleMotionData *subblock = av1_get_sms_data_entry(
sms_bufs, sub_row, sub_col, subsizes[idx], sb_size);
add_start_mv_to_block(subblock, start_mv);
@@ -1989,15 +2023,10 @@
// Whether we are in the middle of a PARTITION_3 subblock
const PC_TREE *parent = pc_tree->parent;
-#if CONFIG_H_PARTITION
ml_features[num_features++] = parent && (parent->horizontal3[1] == pc_tree ||
parent->horizontal3[2] == pc_tree);
ml_features[num_features++] = parent && (parent->vertical3[1] == pc_tree ||
parent->vertical3[2] == pc_tree);
-#else
- ml_features[num_features++] = parent && parent->horizontal3[1] == pc_tree;
- ml_features[num_features++] = parent && parent->vertical3[1] == pc_tree;
-#endif // CONFIG_H_PARTITION
assert(num_features == 19);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
diff --git a/av1/encoder/partition_strategy.h b/av1/encoder/partition_strategy.h
index 4c59fb9..63fc974 100644
--- a/av1/encoder/partition_strategy.h
+++ b/av1/encoder/partition_strategy.h
@@ -87,7 +87,7 @@
void av1_simple_motion_search_prune_rect(
AV1_COMP *const cpi, MACROBLOCK *x, SIMPLE_MOTION_DATA_TREE *sms_tree,
int mi_row, int mi_col, BLOCK_SIZE bsize, int partition_horz_allowed,
- int partition_vert_allowed, int *prune_horz, int *prune_vert);
+ int partition_vert_allowed, bool *prune_horz, bool *prune_vert);
// Early terminates PARTITION_NONE using simple_motion_search features and the
// rate, distortion, and rdcost of PARTITION_NONE. This is only called when:
@@ -130,8 +130,8 @@
void av1_ml_prune_rect_partition(const AV1_COMP *const cpi,
const MACROBLOCK *const x, BLOCK_SIZE bsize,
int64_t best_rd, int64_t none_rd,
- int64_t *split_rd, int *const dst_prune_horz,
- int *const dst_prune_vert);
+ int64_t *split_rd, bool *const dst_prune_horz,
+ bool *const dst_prune_vert);
// Use a ML model to predict if horz_a, horz_b, vert_a, and vert_b should be
// considered.
@@ -165,7 +165,7 @@
BLOCK_SIZE bsize, SIMPLE_MOTION_DATA_TREE *const sms_tree,
int *partition_none_allowed, int *partition_horz_allowed,
int *partition_vert_allowed, int *do_rectangular_split,
- int *do_square_split, int *prune_horz, int *prune_vert,
+ int *do_square_split, bool *prune_horz, bool *prune_vert,
const PC_TREE *pc_tree);
// Prune out partitions that lead to coding block sizes outside the min and max
diff --git a/av1/encoder/pickccso.c b/av1/encoder/pickccso.c
index 2653a09..1dd7be9 100644
--- a/av1/encoder/pickccso.c
+++ b/av1/encoder/pickccso.c
@@ -281,12 +281,13 @@
return ssd;
}
/* Compute SSE */
-void compute_distortion(const uint16_t *org, const int org_stride,
- const uint16_t *rec16, const int rec_stride,
- const int log2_filter_unit_size, const int height,
- const int width, uint64_t *distortion_buf,
- const int distortion_buf_stride,
- uint64_t *total_distortion) {
+static void compute_distortion(const uint16_t *org, const int org_stride,
+ const uint16_t *rec16, const int rec_stride,
+ const int log2_filter_unit_size,
+ const int height, const int width,
+ uint64_t *distortion_buf,
+ const int distortion_buf_stride,
+ uint64_t *total_distortion) {
for (int y = 0; y < height; y += (1 << log2_filter_unit_size)) {
for (int x = 0; x < width; x += (1 << log2_filter_unit_size)) {
const uint64_t ssd =
diff --git a/av1/encoder/pickccso.h b/av1/encoder/pickccso.h
index 725311d..d455980 100644
--- a/av1/encoder/pickccso.h
+++ b/av1/encoder/pickccso.h
@@ -46,13 +46,6 @@
const uint8_t shift_bits);
#endif
-void compute_distortion(const uint16_t *org, const int org_stride,
- const uint16_t *rec16, const int rec_stride,
- const int log2_filter_unit_size, const int height,
- const int width, uint64_t *distortion_buf,
- const int distortion_buf_stride,
- uint64_t *total_distortion);
-
void derive_ccso_filter(AV1_COMMON *cm, const int plane, MACROBLOCKD *xd,
const uint16_t *org_uv, const uint16_t *ext_rec_y,
const uint16_t *rec_uv, int rdmult);
diff --git a/av1/encoder/picklpf.c b/av1/encoder/picklpf.c
index 113bf17..452ab8d 100644
--- a/av1/encoder/picklpf.c
+++ b/av1/encoder/picklpf.c
@@ -321,6 +321,17 @@
cpi->td.mb.rdmult = cpi->rd.RDMULT;
+ double no_deblocking_cost[MAX_MB_PLANE] = { DBL_MAX, DBL_MAX, DBL_MAX };
+
+ for (int i = 0; i < num_planes; i++) {
+ const int chroma_lambda_mult = i ? CHROMA_LAMBDA_MULT : 1;
+ const int64_t no_deblocking_sse =
+ aom_get_sse_plane(cpi->source, &cm->cur_frame->buf, i);
+ no_deblocking_cost[i] = RDCOST_DBL_WITH_NATIVE_BD_DIST(
+ cpi->td.mb.rdmult * chroma_lambda_mult, 0, no_deblocking_sse,
+ cm->seq_params.bit_depth);
+ }
+
if (method == LPF_PICK_MINIMAL_LPF) {
lf->filter_level[0] = 0;
lf->filter_level[1] = 0;
@@ -416,7 +427,12 @@
last_frame_offsets[2] = lf->delta_q_luma[1] = lf->delta_side_luma[1];
#endif // DF_TWO_PARAM
- if (best_single_cost < best_dual_cost) {
+ if (no_deblocking_cost[0] < AOMMIN(best_single_cost, best_dual_cost)) {
+ lf->filter_level[0] = 0;
+ lf->filter_level[1] = 0;
+ lf->delta_q_luma[0] = lf->delta_side_luma[0] = lf->delta_q_luma[1] =
+ lf->delta_side_luma[1] = 0;
+ } else if (best_single_cost < best_dual_cost) {
lf->delta_q_luma[0] = last_frame_offsets[0] = best_single_offsets[0];
lf->delta_side_luma[0] = last_frame_offsets[1] = best_single_offsets[1];
lf->delta_q_luma[1] = last_frame_offsets[2] = best_single_offsets[2];
@@ -424,10 +440,12 @@
}
if (num_planes > 1) {
+ double best_cost_u = DBL_MAX;
+ double best_cost_v = DBL_MAX;
// Cb
last_frame_offsets[5] = lf->delta_side_u =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
- last_frame_offsets, NULL, 1, 1, dir);
+ last_frame_offsets, &best_cost_u, 1, 1, dir);
#if DF_TWO_PARAM
last_frame_offsets[4] = lf->delta_q_u =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
@@ -438,7 +456,7 @@
last_frame_offsets[5] = lf->delta_side_u =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
- last_frame_offsets, NULL, 1, 1, dir);
+ last_frame_offsets, &best_cost_u, 1, 1, dir);
#if DF_TWO_PARAM
last_frame_offsets[4] = lf->delta_q_u =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
@@ -446,10 +464,16 @@
#else
last_frame_offsets[4] = lf->delta_q_u = lf->delta_side_u;
#endif // DF_TWO_PARAM
+
+ if (no_deblocking_cost[1] < best_cost_u) {
+ lf->filter_level_u = 0;
+ lf->delta_q_u = lf->delta_side_u = 0;
+ }
+
// Cr
last_frame_offsets[7] = lf->delta_side_v =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
- last_frame_offsets, NULL, 2, 1, dir);
+ last_frame_offsets, &best_cost_v, 2, 1, dir);
#if DF_TWO_PARAM
last_frame_offsets[6] = lf->delta_q_v =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
@@ -459,7 +483,7 @@
#endif // DF_TWO_PARAM
last_frame_offsets[7] = lf->delta_side_v =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
- last_frame_offsets, NULL, 2, 1, dir);
+ last_frame_offsets, &best_cost_v, 2, 1, dir);
#if DF_TWO_PARAM
last_frame_offsets[6] = lf->delta_q_v =
search_filter_offsets(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE,
@@ -468,6 +492,11 @@
last_frame_offsets[6] = lf->delta_q_v = lf->delta_side_v;
#endif // DF_TWO_PARAM
+ if (no_deblocking_cost[2] < best_cost_v) {
+ lf->filter_level_v = 0;
+ lf->delta_q_v = lf->delta_side_v = 0;
+ }
+
// to switch off filters if offsets are zero
if (!df_quant_from_qindex(cm->quant_params.base_qindex +
cm->lf.delta_q_luma[0] * DF_DELTA_SCALE,
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c
index 2e7c780..5c49b56 100644
--- a/av1/encoder/pickrst.c
+++ b/av1/encoder/pickrst.c
@@ -180,6 +180,10 @@
Vector *unit_indices;
#endif // CONFIG_LR_MERGE_COEFFS
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ // To indicate whether it's encoder process for cross-component wiener filter
+ bool is_cross_filter_round;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
AV1PixelRect tile_rect;
} RestSearchCtxt;
@@ -224,12 +228,17 @@
#endif // CONFIG_LR_MERGE_COEFFS
static AOM_INLINE void reset_all_banks(RestSearchCtxt *rsc) {
- av1_reset_wiener_bank(&rsc->wiener_bank);
+ av1_reset_wiener_bank(&rsc->wiener_bank, rsc->plane != AOM_PLANE_Y);
av1_reset_sgrproj_bank(&rsc->sgrproj_bank);
#if CONFIG_WIENER_NONSEP
av1_reset_wienerns_bank(&rsc->wienerns_bank,
rsc->cm->quant_params.base_qindex,
- rsc->num_filter_classes, rsc->plane != AOM_PLANE_Y);
+ rsc->num_filter_classes, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
#endif // CONFIG_WIENER_NONSEP
}
@@ -302,13 +311,34 @@
// TODO(yunqing): For now, only use optimized LR filter in decoder. Can be
// also used in encoder.
const int optimized_lr = 0;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsc->is_cross_filter_round) {
+ // copy the pre-filtered data to dst buffer, this implementation could be
+ // improved
+ int unit_h = limits->v_end - limits->v_start;
+ int unit_w = limits->h_end - limits->h_start;
+ uint16_t *data_tl = fts->buffers[plane] +
+ limits->v_start * fts->strides[is_uv] + limits->h_start;
+ uint16_t *dst_tl = rsc->dst->buffers[plane] +
+ limits->v_start * rsc->dst->strides[is_uv] +
+ limits->h_start;
+ copy_tile(unit_w, unit_h, data_tl, fts->strides[is_uv], dst_tl,
+ rsc->dst->strides[is_uv]);
- av1_loop_restoration_filter_unit(
- limits, rui, &rsi->boundaries, &rlbs, tile_rect, rsc->tile_stripe0,
- is_uv && cm->seq_params.subsampling_x,
- is_uv && cm->seq_params.subsampling_y, bit_depth, fts->buffers[plane],
- fts->strides[is_uv], rsc->dst->buffers[plane], rsc->dst->strides[is_uv],
- cm->rst_tmpbuf, optimized_lr);
+ av1_wiener_ns_cross_filter_unit(
+ limits, rui, &rsi->boundaries, &rlbs, tile_rect, rsc->tile_stripe0,
+ is_uv && cm->seq_params.subsampling_x,
+ is_uv && cm->seq_params.subsampling_y, bit_depth, fts->buffers[plane],
+ fts->strides[is_uv], rsc->dst->buffers[plane], rsc->dst->strides[is_uv],
+ cm->rst_tmpbuf, optimized_lr);
+ } else
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ av1_loop_restoration_filter_unit(
+ limits, rui, &rsi->boundaries, &rlbs, tile_rect, rsc->tile_stripe0,
+ is_uv && cm->seq_params.subsampling_x,
+ is_uv && cm->seq_params.subsampling_y, bit_depth, fts->buffers[plane],
+ fts->strides[is_uv], rsc->dst->buffers[plane], rsc->dst->strides[is_uv],
+ cm->rst_tmpbuf, optimized_lr);
return sse_restoration_unit(limits, rsc->src, rsc->dst, plane);
}
@@ -637,7 +667,7 @@
// Iterate over the stripe in blocks of width pu_width
for (int j = 0; j < width; j += pu_width) {
const int w = AOMMIN(pu_width, width - j);
- const int ret = av1_selfguided_restoration(
+ const int ret = av1_selfguided_restoration_c(
dat_row + j, w, h, dat_stride, flt0_row + j, flt1_row + j, flt_stride,
sgr_params_idx, bit_depth);
(void)ret;
@@ -1685,6 +1715,9 @@
const AV1PixelRect *tile,
RestorationUnitInfo *rui) {
int64_t err = 0;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsc->is_cross_filter_round) rui->wienerns_cross_info = rui->wienerns_info;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#if CONFIG_LR_MERGE_COEFFS
if (limits != NULL) {
err = try_restoration_unit(rsc, limits, tile, rui);
@@ -1749,7 +1782,12 @@
#ifndef NDEBUG
{
const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
- rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y);
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
assert(check_wienerns_eq(&rui->wienerns_info, &last_unit_filters,
nsfilter_params->ncoeffs, ALL_WIENERNS_CLASSES));
}
@@ -2981,7 +3019,11 @@
}
copy_nsfilter_taps(&rui->wienerns_info, &best);
-
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsc->is_cross_filter_round) {
+ rui->wienerns_cross_info = rui->wienerns_info;
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#if CONFIG_LR_MERGE_COEFFS
(void)count_wienerns_bits_set(rsc->plane, &x->mode_costs, &rui->wienerns_info,
ref_wienerns_bank, nsfilter_params,
@@ -3114,6 +3156,9 @@
}
static int64_t compute_stats_for_wienerns_filter(
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ RestSearchCtxt *rsc,
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
const uint16_t *dgd_hbd, const uint16_t *src_hbd,
const RestorationTileLimits *limits, int dgd_stride, int src_stride,
const RestorationUnitInfo *rui, int bit_depth, double *A, double *b,
@@ -3137,9 +3182,14 @@
int is_uv = (rui->plane != AOM_PLANE_Y);
const int(*wienerns_config2)[3] =
is_uv ? nsfilter_params->nsfilter_config.config2 : NULL;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ const int end_pixel = is_uv && !rsc->is_cross_filter_round
+ ? nsfilter_params->nsfilter_config.num_pixels +
+#else
const int end_pixel = is_uv ? nsfilter_params->nsfilter_config.num_pixels +
- nsfilter_params->nsfilter_config.num_pixels2
- : nsfilter_params->nsfilter_config.num_pixels;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ nsfilter_params->nsfilter_config.num_pixels2
+ : nsfilter_params->nsfilter_config.num_pixels;
#else
const int end_pixel = nsfilter_params->nsfilter_config.num_pixels;
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
@@ -3157,8 +3207,14 @@
memset(buf, 0, sizeof(buf));
for (int k = 0; k < end_pixel; ++k) {
#if CONFIG_WIENER_NONSEP_CROSS_FILT
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ int cross =
+ rsc->is_cross_filter_round ||
+ (is_uv && k >= nsfilter_params->nsfilter_config.num_pixels);
+#else
const int cross =
(is_uv && k >= nsfilter_params->nsfilter_config.num_pixels);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#else
const int cross = 0;
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
@@ -3176,14 +3232,32 @@
bit_depth);
} else {
#if CONFIG_WIENER_NONSEP_CROSS_FILT
- const int k2 = k - nsfilter_params->nsfilter_config.num_pixels;
- const int pos = wienerns_config2[k2][WIENERNS_BUF_POS];
- const int r = wienerns_config2[k2][WIENERNS_ROW_ID];
- const int c = wienerns_config2[k2][WIENERNS_COL_ID];
- buf[pos] += clip_base(
- (int16_t)luma_hbd[(i + r) * rui->luma_stride + (j + c)] -
- (int16_t)luma_hbd[luma_id],
- bit_depth);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsc->is_cross_filter_round) {
+ const int pos = wienerns_config[k][WIENERNS_BUF_POS];
+ const int r = wienerns_config[k][WIENERNS_ROW_ID];
+ const int c = wienerns_config[k][WIENERNS_COL_ID];
+ int sign = k % 2 ? -1 : 1;
+ buf[pos] +=
+ clip_base(
+ (int16_t)luma_hbd[(i + r) * rui->luma_stride + (j + c)] -
+ (int16_t)luma_hbd[luma_id],
+ bit_depth) *
+ sign;
+ } else {
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ const int k2 = k - nsfilter_params->nsfilter_config.num_pixels;
+ const int pos = wienerns_config2[k2][WIENERNS_BUF_POS];
+ const int r = wienerns_config2[k2][WIENERNS_ROW_ID];
+ const int c = wienerns_config2[k2][WIENERNS_COL_ID];
+
+ buf[pos] += clip_base(
+ (int16_t)luma_hbd[(i + r) * rui->luma_stride + (j + c)] -
+ (int16_t)luma_hbd[luma_id],
+ bit_depth);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#else
assert(0 && "Incorrect CONFIG_WIENER_NONSEP configuration");
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
@@ -3507,12 +3581,20 @@
initialize_rui_for_nonsep_search(rsc, &rui);
rui.restoration_type = RESTORE_WIENER_NONSEP;
const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
- rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y);
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
assert(rsc->num_filter_classes == rsc->wienerns_bank.filter[0].num_classes);
// Calculate and save this RU's stats.
RstUnitStats unit_stats;
unit_stats.real_sse = compute_stats_for_wienerns_filter(
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ rsc,
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
rsc->dgd_buffer, rsc->src_buffer, limits, rsc->dgd_stride,
rsc->src_stride, &rui, rsc->cm->seq_params.bit_depth, unit_stats.A,
unit_stats.b, nsfilter_params, rsc->num_stat_classes);
@@ -3547,8 +3629,16 @@
RestorationUnitInfo rui;
initialize_rui_for_nonsep_search(rsc, &rui);
rui.restoration_type = RESTORE_WIENER_NONSEP;
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ rui.cross_restoration_type = RESTORE_WIENER_NONSEP;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
- rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y);
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
const RstUnitStats *unit_stats = (const RstUnitStats *)aom_vector_const_get(
rsc->wienerns_stats, rest_unit_idx_in_rutile);
@@ -3578,6 +3668,11 @@
const int num_classes = rsc->num_filter_classes;
assert(num_classes == rsc->wienerns_bank.filter[0].num_classes);
if (num_classes > 1) {
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (rsc->is_cross_filter_round) {
+ rui.wienerns_cross_info = rui.wienerns_info;
+ }
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
rui.wiener_class_id_restrict = -1;
calc_finer_tile_search_error(rsc, limits, &rsc->tile_rect, &rui);
}
@@ -3949,7 +4044,12 @@
const MACROBLOCK *const x = rsc->x;
#if CONFIG_WIENER_NONSEP
const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
- rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y);
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
#endif // CONFIG_WIENER_NONSEP
const int wiener_win =
(rsc->plane == AOM_PLANE_Y) ? WIENER_WIN : WIENER_WIN_CHROMA;
@@ -4083,7 +4183,12 @@
} else if (best_rtype == RESTORE_WIENER_NONSEP) {
#if CONFIG_LR_MERGE_COEFFS
const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
- rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y);
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
int equal_ref_for_class[WIENERNS_MAX_CLASSES] = { 0 };
for (int c_id = 0; c_id < rusi->wienerns_info.num_classes; ++c_id) {
const int is_equal = check_wienerns_bank_eq(
@@ -4207,7 +4312,12 @@
rui->wienerns_info = rusi->wienerns_info;
#if CONFIG_LR_MERGE_COEFFS
const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
- rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y);
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ ,
+ rsc->is_cross_filter_round
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ );
int equal_ref_for_class[WIENERNS_MAX_CLASSES] = { 0 };
count_wienerns_bits_set(rsc->plane, mode_costs, &rui->wienerns_info,
&rsc->wienerns_bank, nsfilter_params,
@@ -4352,15 +4462,24 @@
RestSearchCtxt *rsc = (RestSearchCtxt *)priv;
const RestUnitSearchInfo *rusi = &rsc->rusi[rest_unit_idx];
const RestorationInfo *rsi = &rsc->cm->rst_info[rsc->plane];
- copy_unit_info(rsi->frame_restoration_type, rusi,
- &rsi->unit_info[rest_unit_idx], rsc);
+
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ rsi->unit_info[rest_unit_idx].restoration_type = RESTORE_NONE;
+ rsi->unit_info[rest_unit_idx].cross_restoration_type = RESTORE_NONE;
+ if (rsi->frame_restoration_type != RESTORE_NONE)
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ copy_unit_info(rsi->frame_restoration_type, rusi,
+ &rsi->unit_info[rest_unit_idx], rsc);
}
static void finalize_frame_and_unit_info(RestorationType frame_rtype,
RestorationInfo *rsi,
RestSearchCtxt *rsc) {
rsi->frame_restoration_type = frame_rtype;
- if (frame_rtype != RESTORE_NONE) {
+#if !CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ if (frame_rtype != RESTORE_NONE)
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ {
process_by_rutile(rsc, copy_unit_info_visitor);
}
}
@@ -4370,6 +4489,31 @@
return rsi->units_per_tile;
}
+#if CONFIG_FLEXIBLE_RU_SIZE
+// Set the value of number of units, for a given unit size.
+void av1_reset_restoration_struct(AV1_COMMON *cm, RestorationInfo *rsi,
+ int is_uv) {
+ const AV1PixelRect tile_rect = av1_whole_frame_rect(cm, is_uv);
+ const int max_tile_w = tile_rect.right - tile_rect.left;
+ const int max_tile_h = tile_rect.bottom - tile_rect.top;
+
+ // To calculate hpertile and vpertile (horizontal and vertical units per
+ // tile), we basically want to divide the largest tile width or height by the
+ // size of a restoration unit. Rather than rounding up unconditionally as you
+ // might expect, we round to nearest, which models the way a right or bottom
+ // restoration unit can extend to up to 150% its normal width or height. The
+ // max with 1 is to deal with tiles that are smaller than half of a
+ // restoration unit.
+ const int unit_size = rsi->restoration_unit_size;
+ const int hpertile = av1_lr_count_units_in_tile(unit_size, max_tile_w);
+ const int vpertile = av1_lr_count_units_in_tile(unit_size, max_tile_h);
+
+ rsi->units_per_tile = hpertile * vpertile;
+ rsi->horz_units_per_tile = hpertile;
+ rsi->vert_units_per_tile = vpertile;
+}
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+
void av1_pick_filter_restoration(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
@@ -4425,11 +4569,20 @@
dgd->buffers[AOM_PLANE_Y], dgd->crop_heights[AOM_PLANE_Y],
dgd->crop_widths[AOM_PLANE_Y], dgd->strides[AOM_PLANE_Y], &luma,
dgd->crop_heights[1], dgd->crop_widths[1], WIENERNS_UV_BRD,
- rsc.luma_stride, cm->seq_params.bit_depth);
+ rsc.luma_stride, cm->seq_params.bit_depth
+#if WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ ,
+ cm->seq_params.enable_cfl_ds_filter == 1
+#endif
+ );
assert(luma_buf != NULL);
rsc.luma = luma;
#endif // CONFIG_WIENER_NONSEP_CROSS_FILT
#endif // CONFIG_WIENER_NONSEP
+
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ rsc.is_cross_filter_round = 0;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
for (int plane = plane_start; plane <= plane_end; ++plane) {
init_rsc(src, &cpi->common, x, &cpi->sf.lpf_sf, plane, rusi,
#if CONFIG_LR_MERGE_COEFFS
@@ -4437,21 +4590,49 @@
#endif // CONFIG_LR_MERGE_COEFFS
&cpi->trial_frame_rst, &rsc);
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+ cm->rst_info[plane].frame_restoration_type = RESTORE_NONE;
+ cm->rst_info[plane].frame_cross_restoration_type = RESTORE_NONE;
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+
const int plane_ntiles = ntiles[plane > 0];
const RestorationType num_rtypes =
(plane_ntiles > 1) ? RESTORE_TYPES : RESTORE_SWITCHABLE_TYPES;
+#if CONFIG_FLEXIBLE_RU_SIZE
+ double best_cost = DBL_MAX;
+#else
double best_cost = 0;
+#endif // CONFIG_FLEXIBLE_RU_SIZE
RestorationType best_rtype = RESTORE_NONE;
- if (!cpi->sf.lpf_sf.disable_loop_restoration_chroma || !plane) {
- av1_extend_frame(rsc.dgd_buffer, rsc.plane_width, rsc.plane_height,
- rsc.dgd_stride, RESTORATION_BORDER, RESTORATION_BORDER);
+#if CONFIG_FLEXIBLE_RU_SIZE
+ RestorationInfo *rsi = &cm->rst_info[plane];
+ const int max_unit_size = rsi->max_restoration_unit_size;
+ const int min_unit_size = rsi->min_restoration_unit_size;
- for (RestorationType r = 0; r < num_rtypes; ++r) {
+ int best_unit_size = min_unit_size;
+
+ for (int unit_size = min_unit_size; unit_size <= max_unit_size;
+ unit_size <<= 1) {
+ if (plane == 2 && unit_size != cm->rst_info[1].restoration_unit_size) {
+ continue;
+ }
+ aom_vector_clear(&wienerns_stats);
+
+ rsi->restoration_unit_size = unit_size;
+
+ av1_reset_restoration_struct(cm, rsi, plane > 0);
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ if (!cpi->sf.lpf_sf.disable_loop_restoration_chroma || !plane) {
+ av1_extend_frame(rsc.dgd_buffer, rsc.plane_width, rsc.plane_height,
+ rsc.dgd_stride, RESTORATION_BORDER,
+ RESTORATION_BORDER);
+
+ for (RestorationType r = 0; r < num_rtypes; ++r) {
#if CONFIG_LR_FLEX_SYNTAX
- if (cpi->common.features.lr_tools_disable_mask[plane > 0] & (1 << r))
- continue;
+ if (cpi->common.features.lr_tools_disable_mask[plane > 0] & (1 << r))
+ continue;
#else
const ToolCfg *const tool_cfg = &cpi->oxcf.tool_cfg;
switch (r) {
@@ -4476,36 +4657,57 @@
#endif // CONFIG_LR_FLEX_SYNTAX
#if CONFIG_PC_WIENER
- if (plane != AOM_PLANE_Y && r == RESTORE_PC_WIENER) continue;
+ if (plane != AOM_PLANE_Y && r == RESTORE_PC_WIENER) continue;
#endif // CONFIG_PC_WIENER
- gather_stats_rest_type(&rsc, r);
+ gather_stats_rest_type(&rsc, r);
#if CONFIG_WIENER_NONSEP
- if (r == RESTORE_WIENER_NONSEP) {
- rsc.num_filter_classes = rsc.plane == AOM_PLANE_Y
- ? NUM_WIENERNS_CLASS_INIT_LUMA
- : NUM_WIENERNS_CLASS_INIT_CHROMA;
- }
+ if (r == RESTORE_WIENER_NONSEP) {
+ rsc.num_filter_classes = rsc.plane == AOM_PLANE_Y
+ ? NUM_WIENERNS_CLASS_INIT_LUMA
+ : NUM_WIENERNS_CLASS_INIT_CHROMA;
+ }
#endif // CONFIG_WIENER_NONSEP
- double cost = search_rest_type(&rsc, r);
+ double cost = search_rest_type(&rsc, r);
+#if CONFIG_FLEXIBLE_RU_SIZE
+ if (cost < best_cost) {
+ best_cost = cost;
+ best_rtype = r;
+ best_unit_size = unit_size;
+ }
+#else
if (r == 0 || cost < best_cost) {
best_cost = cost;
best_rtype = r;
}
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ }
+ }
+#if CONFIG_FLEXIBLE_RU_SIZE
+ if (rsi->restoration_unit_size == min_unit_size ||
+ best_unit_size == rsi->restoration_unit_size) {
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ finalize_frame_and_unit_info(best_rtype, &cm->rst_info[plane], &rsc);
+#if CONFIG_FLEXIBLE_RU_SIZE
}
}
-
- finalize_frame_and_unit_info(best_rtype, &cm->rst_info[plane], &rsc);
-
+#endif // CONFIG_FLEXIBLE_RU_SIZE
#if CONFIG_LR_FLEX_SYNTAX
assert(IMPLIES(
cm->features.lr_tools_count[plane] < 2,
cm->rst_info[plane].frame_restoration_type != RESTORE_SWITCHABLE));
#endif // CONFIG_LR_FLEX_SYNTAX
+#if CONFIG_FLEXIBLE_RU_SIZE
+ rsi->restoration_unit_size = best_unit_size;
+ av1_reset_restoration_struct(cm, rsi, plane > 0);
+ int ru_num = rest_tiles_in_plane(cm, plane > 0);
+ adjust_frame_rtype(&cm->rst_info[plane], ru_num, &rsc, &cpi->oxcf.tool_cfg);
+#else
adjust_frame_rtype(&cm->rst_info[plane], plane_ntiles, &rsc,
&cpi->oxcf.tool_cfg);
+#endif // CONFIG_FLEXIBLE_RU_SIZE
}
#if CONFIG_WIENER_NONSEP_CROSS_FILT
@@ -4521,3 +4723,230 @@
aom_vector_destroy(&unit_indices);
#endif // CONFIG_LR_MERGE_COEFFS
}
+
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+static AOM_INLINE void copy_unit_cross_filter_info(
+ RestorationType frame_cross_rtype, const RestUnitSearchInfo *rusi,
+ RestorationUnitInfo *rui, RestSearchCtxt *rsc) {
+#if CONFIG_LR_MERGE_COEFFS
+ const ModeCosts *mode_costs = &rsc->x->mode_costs;
+#else
+ (void)rsc;
+#endif // CONFIG_LR_MERGE_COEFFS
+ assert(frame_cross_rtype > 0);
+ rui->cross_restoration_type = frame_cross_rtype == RESTORE_NONE
+ ? RESTORE_NONE
+ : rusi->best_rtype[frame_cross_rtype - 1];
+ if (rui->cross_restoration_type == RESTORE_WIENER_NONSEP) {
+ rui->wienerns_cross_info = rusi->wienerns_info;
+#if CONFIG_LR_MERGE_COEFFS
+ const WienernsFilterParameters *nsfilter_params = get_wienerns_parameters(
+ rsc->cm->quant_params.base_qindex, rsc->plane != AOM_PLANE_Y,
+ rsc->is_cross_filter_round);
+
+ int equal_ref_for_class[WIENERNS_MAX_CLASSES] = { 0 };
+ count_wienerns_bits_set(rsc->plane, mode_costs, &rui->wienerns_cross_info,
+ &rsc->wienerns_bank, nsfilter_params,
+ ALL_WIENERNS_CLASSES);
+ for (int c_id = 0; c_id < rui->wienerns_cross_info.num_classes; ++c_id) {
+ const int is_equal = check_wienerns_bank_eq(
+ &rsc->wienerns_bank, &rui->wienerns_cross_info,
+ nsfilter_params->ncoeffs, c_id, equal_ref_for_class);
+ if (is_equal == -1) {
+ av1_add_to_wienerns_bank(&rsc->wienerns_bank, &rui->wienerns_cross_info,
+ c_id);
+ }
+ }
+#endif // CONFIG_LR_MERGE_COEFFS
+ } else if (rui->cross_restoration_type == RESTORE_NONE) {
+ // do nothing
+ } else {
+ assert(0);
+ }
+}
+
+// copy cross-component filter data from rusi to rsi for one RU
+static void copy_unit_cross_filter_info_visitor(
+ const RestorationTileLimits *limits, const AV1PixelRect *tile_rect,
+ int rest_unit_idx, int rest_unit_idx_seq, void *priv, int32_t *tmpbuf,
+ RestorationLineBuffers *rlbs) {
+ (void)limits;
+ (void)tile_rect;
+ (void)rest_unit_idx_seq;
+ (void)tmpbuf;
+ (void)rlbs;
+
+ RestSearchCtxt *rsc = (RestSearchCtxt *)priv;
+ const RestUnitSearchInfo *rusi = &rsc->rusi[rest_unit_idx];
+ const RestorationInfo *rsi = &rsc->cm->rst_info[rsc->plane];
+
+ rsi->unit_info[rest_unit_idx].cross_restoration_type = RESTORE_NONE;
+ if (rsi->frame_cross_restoration_type != RESTORE_NONE)
+ copy_unit_cross_filter_info(rsi->frame_cross_restoration_type, rusi,
+ &rsi->unit_info[rest_unit_idx], rsc);
+ rsi->unit_info[rest_unit_idx].wienerns_cross_info.is_cross_filter = 0;
+}
+
+// copy cross-component filter data from rusi to rsi for one frame
+static void finalize_frame_and_unit_cross_filter_info(
+ RestorationType frame_cross_rtype, RestorationInfo *rsi,
+ RestSearchCtxt *rsc) {
+ rsi->frame_cross_restoration_type = frame_cross_rtype;
+ process_by_rutile(rsc, copy_unit_cross_filter_info_visitor);
+}
+
+// RD process to find the best mode of cross-component wiener filter
+// for each RU within the current frame
+void av1_pick_cross_filter_restoration(const YV12_BUFFER_CONFIG *src,
+ AV1_COMP *cpi) {
+ AV1_COMMON *const cm = &cpi->common;
+ MACROBLOCK *const x = &cpi->td.mb;
+ const int num_planes = av1_num_planes(cm);
+ assert(!cm->features.all_lossless);
+ if (num_planes <= 1) return;
+
+ av1_fill_lr_rates(&x->mode_costs, x->e_mbd.tile_ctx);
+
+ int ntiles = rest_tiles_in_plane(cm, 1);
+
+ RestUnitSearchInfo *rusi =
+ (RestUnitSearchInfo *)aom_memalign(16, sizeof(*rusi) * ntiles);
+
+ // If the restoration unit dimensions are not multiples of
+ // rsi->restoration_unit_size then some elements of the rusi array may be
+ // left uninitialised when we reach copy_unit_info(...). This is not a
+ // problem, as these elements are ignored later, but in order to quiet
+ // Valgrind's warnings we initialise the array below.
+ memset(rusi, 0, sizeof(*rusi) * ntiles);
+ x->rdmult = cpi->rd.RDMULT;
+
+#if CONFIG_LR_MERGE_COEFFS
+ Vector unit_stack;
+ aom_vector_setup(&unit_stack,
+ 1, // resizable capacity
+ sizeof(struct RstUnitSnapshot)); // element size
+ Vector unit_indices;
+ aom_vector_setup(&unit_indices,
+ 1, // resizable capacity
+ sizeof(int)); // element size
+#endif // CONFIG_LR_MERGE_COEFFS
+
+ RestSearchCtxt rsc;
+ const int plane_start = AOM_PLANE_U;
+ const int plane_end = AOM_PLANE_V;
+
+ Vector wienerns_stats;
+ aom_vector_setup(&wienerns_stats,
+ 1, // resizable capacity
+ sizeof(struct RstUnitStats)); // element size
+ rsc.wienerns_stats = &wienerns_stats;
+
+ uint16_t *luma = NULL;
+ uint16_t *luma_buf;
+ const YV12_BUFFER_CONFIG *dgd = &cpi->common.cur_frame->buf;
+ rsc.luma_stride = dgd->crop_widths[1] + 2 * WIENERNS_UV_BRD;
+ luma_buf = wienerns_copy_luma_highbd(
+ dgd->buffers[AOM_PLANE_Y], dgd->crop_heights[AOM_PLANE_Y],
+ dgd->crop_widths[AOM_PLANE_Y], dgd->strides[AOM_PLANE_Y], &luma,
+ dgd->crop_heights[1], dgd->crop_widths[1], WIENERNS_UV_BRD,
+ rsc.luma_stride, cm->seq_params.bit_depth
+#if WIENERNS_CROSS_FILT_LUMA_TYPE == 2
+ ,
+ cm->seq_params.enable_cfl_ds_filter == 1
+#endif
+ );
+ assert(luma_buf != NULL);
+ rsc.luma = luma;
+
+ rsc.is_cross_filter_round = 1;
+
+ for (int plane = plane_start; plane <= plane_end; ++plane) {
+ init_rsc(src, &cpi->common, x, &cpi->sf.lpf_sf, plane, rusi,
+#if CONFIG_LR_MERGE_COEFFS
+ &unit_stack, &unit_indices,
+#endif // CONFIG_LR_MERGE_COEFFS
+ &cpi->trial_frame_rst, &rsc);
+
+ const int plane_ntiles = ntiles;
+ const RestorationType num_rtypes =
+ (plane_ntiles > 1) ? RESTORE_TYPES : RESTORE_SWITCHABLE_TYPES;
+
+ double best_cost = DBL_MAX;
+ RestorationType best_cross_rtype = RESTORE_NONE;
+
+#if CONFIG_FLEXIBLE_RU_SIZE
+ RestorationInfo *rsi = &cm->rst_info[plane];
+ int min_unit_size = rsi->restoration_unit_size;
+ int max_unit_size = rsi->restoration_unit_size;
+ int best_unit_size =
+ min_unit_size; // the best unit_size has been determined at the RD of
+ // restoring filter, to be optimized.
+ for (int unit_size = min_unit_size; unit_size <= max_unit_size;
+ unit_size <<= 1) {
+ assert(rsi->restoration_unit_size == unit_size);
+ assert(cm->rst_info[1].restoration_unit_size ==
+ cm->rst_info[2].restoration_unit_size);
+
+ aom_vector_clear(&wienerns_stats);
+
+ av1_reset_restoration_struct(cm, rsi, plane > 0);
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ if (!cpi->sf.lpf_sf.disable_loop_restoration_chroma || !plane) {
+ av1_extend_frame(rsc.dgd_buffer, rsc.plane_width, rsc.plane_height,
+ rsc.dgd_stride, RESTORATION_BORDER,
+ RESTORATION_BORDER);
+
+ for (RestorationType r = 0; r < num_rtypes; ++r) {
+ //??????????? to be updated with tool on/off setting
+ if (r != RESTORE_NONE && r != RESTORE_WIENER_NONSEP) {
+ // to be updated with flexible tool on/off setting.
+ continue;
+ };
+
+ gather_stats_rest_type(&rsc, r);
+
+ // if (r == RESTORE_WIENER_NONSEP) {
+ rsc.num_filter_classes = rsc.plane == AOM_PLANE_Y
+ ? NUM_WIENERNS_CLASS_INIT_LUMA
+ : NUM_WIENERNS_CLASS_INIT_CHROMA;
+ // }
+
+ double cost = search_rest_type(&rsc, r);
+
+#if CONFIG_FLEXIBLE_RU_SIZE
+ if (cost < best_cost) {
+ best_cost = cost;
+ best_cross_rtype = r;
+ best_unit_size = unit_size;
+ }
+#else
+ if (r == 0 || cost < best_cost) {
+ best_cost = cost;
+ best_cross_rtype = r;
+ }
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ }
+ }
+#if CONFIG_FLEXIBLE_RU_SIZE
+ if (rsi->restoration_unit_size == min_unit_size ||
+ best_unit_size == rsi->restoration_unit_size) {
+ assert(rsi->restoration_unit_size == min_unit_size);
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ cm->rst_info[plane].frame_cross_restoration_type = best_cross_rtype;
+ finalize_frame_and_unit_cross_filter_info(best_cross_rtype,
+ &cm->rst_info[plane], &rsc);
+#if CONFIG_FLEXIBLE_RU_SIZE
+ }
+ }
+#endif // CONFIG_FLEXIBLE_RU_SIZE
+ }
+ free(luma_buf);
+ aom_free(rusi);
+ aom_vector_destroy(&wienerns_stats);
+
+#if CONFIG_LR_MERGE_COEFFS
+ aom_vector_destroy(&unit_stack);
+ aom_vector_destroy(&unit_indices);
+#endif // CONFIG_LR_MERGE_COEFFS
+}
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
diff --git a/av1/encoder/pickrst.h b/av1/encoder/pickrst.h
index 8fa2461..d536deb 100644
--- a/av1/encoder/pickrst.h
+++ b/av1/encoder/pickrst.h
@@ -191,7 +191,10 @@
*
*/
void av1_pick_filter_restoration(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi);
-
+#if CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
+void av1_pick_cross_filter_restoration(const YV12_BUFFER_CONFIG *sd,
+ AV1_COMP *cpi);
+#endif // CONFIG_HIGH_PASS_CROSS_WIENER_FILTER
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 4a70347..23eb416 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -64,12 +64,12 @@
static const int use_intra_ext_tx_for_txsize[EXT_TX_SETS_INTRA]
[EXT_TX_SIZES] = {
{ 1, 1, 1, 1 }, // unused
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
{ 1, 1, 1, 0 },
#else
{ 1, 1, 0, 0 },
{ 0, 0, 1, 0 },
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
};
static const int use_inter_ext_tx_for_txsize[EXT_TX_SETS_INTER]
@@ -85,12 +85,12 @@
{
// Intra
EXT_TX_SET_DCTONLY,
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
EXT_NEW_TX_SET,
#else
EXT_TX_SET_DTT4_IDTX_1DDCT,
EXT_TX_SET_DTT4_IDTX,
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
},
{
// Inter
@@ -133,6 +133,17 @@
av1_cost_tokens_from_cdf(
mode_costs->do_ext_partition_cost[plane_index][rect_type][i],
fc->do_ext_partition_cdf[plane_index][rect_type][i], NULL);
+#if CONFIG_UNEVEN_4WAY
+ av1_cost_tokens_from_cdf(
+ mode_costs
+ ->do_uneven_4way_partition_cost[plane_index][rect_type][i],
+ fc->do_uneven_4way_partition_cdf[plane_index][rect_type][i], NULL);
+ av1_cost_tokens_from_cdf(
+ mode_costs
+ ->uneven_4way_partition_type_cost[plane_index][rect_type][i],
+ fc->uneven_4way_partition_type_cdf[plane_index][rect_type][i],
+ NULL);
+#endif // CONFIG_UNEVEN_4WAY
}
}
}
@@ -164,15 +175,36 @@
mode_costs->partition_cost[plane_index][ctx][part] +=
mode_costs->rect_type_cost[plane_index][ctx][rect_type];
}
- const bool disable_ext_part = !cm->seq_params.enable_ext_partitions;
const bool ext_partition_allowed =
- !disable_ext_part &&
+ cm->seq_params.enable_ext_partitions &&
is_ext_partition_allowed(bsize, rect_type, tree_type);
if (ext_partition_allowed) {
const bool do_ext_partition = (part >= PARTITION_HORZ_3);
mode_costs->partition_cost[plane_index][ctx][part] +=
mode_costs->do_ext_partition_cost[plane_index][rect_type][ctx]
[do_ext_partition];
+#if CONFIG_UNEVEN_4WAY
+ if (do_ext_partition) {
+ const bool uneven_4way_partition_allowed =
+ is_uneven_4way_partition_allowed(bsize, rect_type, tree_type);
+ if (uneven_4way_partition_allowed) {
+ const bool do_uneven_4way_partition =
+ (part >= PARTITION_HORZ_4A);
+ mode_costs->partition_cost[plane_index][ctx][part] +=
+ mode_costs->do_uneven_4way_partition_cost
+ [plane_index][rect_type][ctx][do_uneven_4way_partition];
+ if (do_uneven_4way_partition) {
+ const UNEVEN_4WAY_PART_TYPE uneven_4way_type =
+ (part == PARTITION_HORZ_4A || part == PARTITION_VERT_4A)
+ ? UNEVEN_4A
+ : UNEVEN_4B;
+ mode_costs->partition_cost[plane_index][ctx][part] +=
+ mode_costs->uneven_4way_partition_type_cost
+ [plane_index][rect_type][ctx][uneven_4way_type];
+ }
+ }
+ }
+#endif // CONFIG_UNEVEN_4WAY
}
}
}
@@ -200,7 +232,14 @@
fc->skip_txfm_cdfs[i], NULL);
}
+#if CONFIG_EXT_DIR
+ for (i = 0; i < MRL_INDEX_CONTEXTS; ++i) {
+ av1_cost_tokens_from_cdf(mode_costs->mrl_index_cost[i],
+ fc->mrl_index_cdf[i], NULL);
+ }
+#else
av1_cost_tokens_from_cdf(mode_costs->mrl_index_cost, fc->mrl_index_cdf, NULL);
+#endif // CONFIG_EXT_DIR
for (i = 0; i < FSC_MODE_CONTEXTS; ++i) {
for (j = 0; j < FSC_BSIZE_CONTEXTS; ++j) {
@@ -278,7 +317,7 @@
}
}
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
for (i = 0; i < PALETTE_ROW_FLAG_CONTEXTS; ++i) {
av1_cost_tokens_from_cdf(mode_costs->palette_y_row_flag_cost[i],
fc->identity_row_cdf_y[i], NULL);
@@ -344,6 +383,24 @@
for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
int s;
+#if CONFIG_ATC_DCTX_ALIGNED
+ int k;
+ for (k = 0; k < EOB_TX_CTXS; ++k) {
+ for (s = 1; s < EXT_TX_SETS_INTER; ++s) {
+#if CONFIG_ATC_REDUCED_TXSET
+ if (cm->features.reduced_tx_set_used ||
+ use_inter_ext_tx_for_txsize[s][i]) {
+#else
+ if (use_inter_ext_tx_for_txsize[s][i]) {
+#endif // CONFIG_ATC_REDUCED_TXSET
+ av1_cost_tokens_from_cdf(
+ mode_costs->inter_tx_type_costs[s][k][i],
+ fc->inter_ext_tx_cdf[s][k][i],
+ av1_ext_tx_inv[av1_ext_tx_set_idx_to_type[1][s]]);
+ }
+ }
+ }
+#else
for (s = 1; s < EXT_TX_SETS_INTER; ++s) {
#if CONFIG_ATC_REDUCED_TXSET
if (cm->features.reduced_tx_set_used ||
@@ -356,17 +413,18 @@
av1_ext_tx_inv[av1_ext_tx_set_idx_to_type[1][s]]);
}
}
+#endif // CONFIG_ATC_DCTX_ALIGNED
for (s = 1; s < EXT_TX_SETS_INTRA; ++s) {
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
int tx_set_type = av1_ext_tx_set_idx_to_type[0][s];
#if CONFIG_ATC_REDUCED_TXSET
const int cdf_offset = cm->features.reduced_tx_set_used ? 1 : 0;
#endif // CONFIG_ATC_REDUCED_TXSET
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
if (use_intra_ext_tx_for_txsize[s][i]) {
for (j = 0; j < INTRA_MODES; ++j) {
av1_cost_tokens_from_cdf(
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
mode_costs->intra_tx_type_costs[s][i][j],
#if CONFIG_ATC_REDUCED_TXSET
fc->intra_ext_tx_cdf[s + cdf_offset][i][j],
@@ -380,7 +438,7 @@
mode_costs->intra_tx_type_costs[s][i][j],
fc->intra_ext_tx_cdf[s][i][j],
av1_ext_tx_inv_intra[av1_ext_tx_set_idx_to_type[0][s]]);
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
}
}
}
@@ -402,14 +460,14 @@
#else
av1_cost_tokens_from_cdf(mode_costs->intrabc_cost, fc->intrabc_cdf, NULL);
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
av1_cost_tokens_from_cdf(mode_costs->intrabc_mode_cost, fc->intrabc_mode_cdf,
NULL);
for (i = 0; i < MAX_REF_BV_STACK_SIZE - 1; ++i) {
av1_cost_tokens_from_cdf(mode_costs->intrabc_drl_idx_cost[i],
fc->intrabc_drl_idx_cdf[i], NULL);
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
for (i = 0; i < TX_SIZES; ++i) {
av1_cost_tokens_from_cdf(mode_costs->stx_flag_cost[i], fc->stx_cdf[i],
@@ -467,7 +525,7 @@
}
}
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
for (j = 0; j < INTRA_INTER_SKIP_TXFM_CONTEXTS; ++j) {
for (i = 0; i < INTRA_INTER_CONTEXTS; ++i) {
av1_cost_tokens_from_cdf(mode_costs->intra_inter_cost[j][i],
@@ -479,7 +537,7 @@
av1_cost_tokens_from_cdf(mode_costs->intra_inter_cost[i],
fc->intra_inter_cdf[i], NULL);
}
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
for (i = 0; i < INTER_SINGLE_MODE_CONTEXTS; ++i) {
av1_cost_tokens_from_cdf(mode_costs->inter_single_mode_cost[i],
@@ -502,12 +560,12 @@
fc->drl_cdf[2][i], NULL);
}
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
for (i = 0; i < 3; ++i) {
av1_cost_tokens_from_cdf(mode_costs->skip_drl_mode_cost[i],
fc->skip_drl_cdf[i], NULL);
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_OPTFLOW_REFINEMENT
for (i = 0; i < INTER_COMPOUND_MODE_CONTEXTS; ++i)
@@ -570,6 +628,14 @@
av1_cost_tokens_from_cdf(mode_costs->wedge_interintra_cost[i],
fc->wedge_interintra_cdf[i], NULL);
}
+
+#if CONFIG_REFINEMV
+ for (i = 0; i < NUM_REFINEMV_CTX; ++i) {
+ av1_cost_tokens_from_cdf(mode_costs->refinemv_flag_cost[i],
+ fc->refinemv_flag_cdf[i], NULL);
+ }
+#endif // CONFIG_REFINEMV
+
#if CONFIG_EXTENDED_WARP_PREDICTION
for (i = BLOCK_8X8; i < BLOCK_SIZES_ALL; i++) {
av1_cost_tokens_from_cdf(mode_costs->obmc_cost[i], fc->obmc_cdf[i], NULL);
@@ -584,6 +650,12 @@
fc->warped_causal_warpmv_cdf[i], NULL);
}
#endif // CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ for (i = BLOCK_8X8; i < BLOCK_SIZES_ALL; i++) {
+ av1_cost_tokens_from_cdf(mode_costs->warpmv_with_mvd_flag_cost[i],
+ fc->warpmv_with_mvd_flag_cdf[i], NULL);
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#if CONFIG_WARP_REF_LIST
for (i = 0; i < 3; i++) {
@@ -625,6 +697,14 @@
av1_cost_tokens_from_cdf(mode_costs->comp_group_idx_cost[i],
fc->comp_group_idx_cdf[i], NULL);
}
+#if CONFIG_CWP
+ for (j = 0; j < MAX_CWP_CONTEXTS; j++) {
+ for (i = 0; i < MAX_CWP_NUM - 1; ++i) {
+ av1_cost_tokens_from_cdf(mode_costs->cwp_idx_cost[j][i],
+ fc->cwp_idx_cdf[j][i], NULL);
+ }
+ }
+#endif // CONFIG_CWP
}
}
@@ -868,6 +948,20 @@
for (int plane = 0; plane < nplanes; ++plane) {
LV_MAP_EOB_COST *pcost = &coeff_costs->eob_costs[eob_multi_size][plane];
+#if CONFIG_ATC_DCTX_ALIGNED
+ aom_cdf_prob *pcdf;
+ switch (eob_multi_size) {
+ case 0: pcdf = fc->eob_flag_cdf16[plane]; break;
+ case 1: pcdf = fc->eob_flag_cdf32[plane]; break;
+ case 2: pcdf = fc->eob_flag_cdf64[plane]; break;
+ case 3: pcdf = fc->eob_flag_cdf128[plane]; break;
+ case 4: pcdf = fc->eob_flag_cdf256[plane]; break;
+ case 5: pcdf = fc->eob_flag_cdf512[plane]; break;
+ case 6: pcdf = fc->eob_flag_cdf1024[plane]; break;
+ default: assert(0 && "Invalid eob_multi_size");
+ }
+ av1_cost_tokens_from_cdf(pcost->eob_cost, pcdf, NULL);
+#else
for (int ctx = 0; ctx < 2; ++ctx) {
aom_cdf_prob *pcdf;
switch (eob_multi_size) {
@@ -882,6 +976,7 @@
}
av1_cost_tokens_from_cdf(pcost->eob_cost[ctx], pcdf, NULL);
}
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
}
for (int tx_size = 0; tx_size < TX_SIZES; ++tx_size) {
@@ -900,7 +995,7 @@
av1_cost_tokens_from_cdf(pcost->base_eob_cost[ctx],
fc->coeff_base_eob_cdf[tx_size][plane][ctx],
NULL);
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
for (int ctx = 0; ctx < SIG_COEF_CONTEXTS_EOB; ++ctx)
av1_cost_tokens_from_cdf(pcost->base_lf_eob_cost[ctx],
fc->coeff_base_lf_eob_cdf[tx_size][plane][ctx],
@@ -929,7 +1024,12 @@
pcost->base_cost[ctx][7] =
pcost->base_cost[ctx][3] - pcost->base_cost[ctx][2];
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
+#if CONFIG_ATC_DCTX_ALIGNED
+ for (int ctx = 0; ctx < SIG_COEF_CONTEXTS_BOB; ++ctx)
+ av1_cost_tokens_from_cdf(pcost->base_bob_cost[ctx],
+ fc->coeff_base_bob_cdf[ctx], NULL);
+#endif // CONFIG_ATC_DCTX_ALIGNED
for (int ctx = 0; ctx < EOB_COEF_CONTEXTS; ++ctx)
av1_cost_tokens_from_cdf(pcost->eob_extra_cost[ctx],
fc->eob_extra_cdf[tx_size][plane][ctx], NULL);
@@ -949,7 +1049,7 @@
}
#endif // CONFIG_CONTEXT_DERIVATION
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
for (int ctx = 0; ctx < LF_LEVEL_CONTEXTS; ++ctx) {
int br_lf_rate[BR_CDF_SIZE];
int prev_cost_lf = 0;
@@ -972,17 +1072,17 @@
pcost->lps_lf_cost[ctx][i] - pcost->lps_lf_cost[ctx][i - 1];
}
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
for (int ctx = 0; ctx < LEVEL_CONTEXTS; ++ctx) {
int br_rate[BR_CDF_SIZE];
int prev_cost = 0;
int i, j;
av1_cost_tokens_from_cdf(
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
br_rate, fc->coeff_br_cdf[plane][ctx],
#else
br_rate, fc->coeff_br_cdf[AOMMIN(tx_size, TX_32X32)][plane][ctx],
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
NULL);
// printf("br_rate: ");
// for(j = 0; j < BR_CDF_SIZE; j++)
@@ -1099,7 +1199,7 @@
#endif
);
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
// Copy the pointer of the dv cost to the mvcost
mv_costs->dv_joint_cost = &dv_costs->joint_mv[0];
mv_costs->dv_nmv_cost[0] = dv_costs->dv_costs[0];
@@ -1108,7 +1208,7 @@
(void)mv_costs;
#endif
}
-#elif CONFIG_BVCOST_UPDATE
+#elif CONFIG_IBC_BV_IMPROVEMENT
void av1_fill_dv_costs(const FRAME_CONTEXT *fc, IntraBCMVCosts *dv_costs) {
int *dvcost[2] = { &dv_costs->mv_component[0][MV_MAX],
&dv_costs->mv_component[1][MV_MAX] };
@@ -1223,14 +1323,14 @@
#endif
if (cm->features.allow_screen_content_tools &&
-#if !CONFIG_BVCOST_UPDATE
+#if !CONFIG_IBC_BV_IMPROVEMENT
frame_is_intra_only(cm) &&
-#endif // !CONFIG_BVCOST_UPDATE
+#endif // !CONFIG_IBC_BV_IMPROVEMENT
!is_stat_generation_stage(cpi)) {
#if CONFIG_FLEX_MVRES
fill_dv_costs(&x->dv_costs, cm->fc, mv_costs);
#else
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
IntraBCMVCosts *const dv_costs = &x->dv_costs;
#else
IntraBCMVCosts *const dv_costs = &cpi->dv_costs;
@@ -1244,16 +1344,6 @@
dvcost, &cm->fc->ndvc, MV_SUBPEL_NONE);
#endif
}
-
- if (!is_stat_generation_stage(cpi)) {
- for (int i = 0; i < TRANS_TYPES; ++i)
- // IDENTITY: 1 bit
- // TRANSLATION: 3 bits
- // ROTZOOM: 2 bits
- // AFFINE: 3 bits
- cpi->gm_info.type_cost[i] = (1 + (i > 0 ? (i == ROTZOOM ? 1 : 2) : 0))
- << AV1_PROB_COST_SHIFT;
- }
}
static void model_rd_norm(int xsq_q10, int *r_q10, int *d_q10) {
@@ -1635,10 +1725,19 @@
}
#endif // CONFIG_TIP
const MV_REFERENCE_FRAME ref_frames[2] = { ref_frame, NONE_FRAME };
+
+#if CONFIG_SEP_COMP_DRL
+ const MB_MODE_INFO *mbmi = x->e_mbd.mi[0];
+ const int_mv ref_mv =
+ av1_get_ref_mv_from_stack(0, ref_frames, 0, x->mbmi_ext, mbmi);
+ const int_mv ref_mv1 =
+ av1_get_ref_mv_from_stack(0, ref_frames, 1, x->mbmi_ext, mbmi);
+#else
const int_mv ref_mv =
av1_get_ref_mv_from_stack(0, ref_frames, 0, x->mbmi_ext);
const int_mv ref_mv1 =
av1_get_ref_mv_from_stack(0, ref_frames, 1, x->mbmi_ext);
+#endif // CONFIG_SEP_COMP_DRL
MV pred_mv[MAX_MV_REF_CANDIDATES + 1];
int num_mv_refs = 0;
pred_mv[num_mv_refs++] = ref_mv.as_mv;
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index 3620853..be21280 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -81,7 +81,7 @@
double r0;
} RD_OPT;
-#if !CONFIG_FLEX_MVRES && !CONFIG_BVCOST_UPDATE
+#if !CONFIG_FLEX_MVRES && !CONFIG_IBC_BV_IMPROVEMENT
typedef struct {
// Cost of transmitting the actual motion vector.
// mv_component[0][i] is the cost of motion vector with horizontal component
@@ -154,6 +154,9 @@
static INLINE void av1_merge_rd_stats(RD_STATS *rd_stats_dst,
const RD_STATS *rd_stats_src) {
assert(rd_stats_dst->rate != INT_MAX && rd_stats_src->rate != INT_MAX);
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (rd_stats_src->dist == INT64_MAX || rd_stats_src->rate == INT_MAX) return;
+#endif // CONFIG_ATC_DCTX_ALIGNED
rd_stats_dst->rate = (int)AOMMIN(
((int64_t)rd_stats_dst->rate + (int64_t)rd_stats_src->rate), INT_MAX);
if (!rd_stats_dst->zero_rate)
@@ -375,7 +378,7 @@
#if CONFIG_FLEX_MVRES
void fill_dv_costs(IntraBCMvCosts *dv_costs, const FRAME_CONTEXT *fc,
MvCosts *mv_costs);
-#elif CONFIG_BVCOST_UPDATE
+#elif CONFIG_IBC_BV_IMPROVEMENT
void av1_fill_dv_costs(const FRAME_CONTEXT *fc, IntraBCMVCosts *dv_costs);
#endif
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 88c474d..9c33f8b 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -584,7 +584,7 @@
REF_FRAMES * sizeof((*ref_costs_comp)[0]));
} else {
int intra_inter_ctx = av1_get_intra_inter_context(xd);
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
const int skip_txfm = xd->mi[0]->skip_txfm[xd->tree_type == CHROMA_PART];
ref_costs_single[INTRA_FRAME_INDEX] =
mode_costs->intra_inter_cost[skip_txfm][intra_inter_ctx][0];
@@ -594,7 +594,7 @@
ref_costs_single[INTRA_FRAME_INDEX] =
mode_costs->intra_inter_cost[intra_inter_ctx][0];
unsigned int base_cost = mode_costs->intra_inter_cost[intra_inter_ctx][1];
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
#if CONFIG_TIP
if (cm->features.tip_frame_mode) {
@@ -786,9 +786,12 @@
if (xd->tree_type != CHROMA_PART)
av1_copy_mbmi_ext_to_mbmi_ext_frame(
&ctx->mbmi_ext_best, x->mbmi_ext,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SEP_COMP_DRL
+ xd->mi[0],
+#endif // CONFIG_SEP_COMP_DRL
+#if CONFIG_SKIP_MODE_ENHANCEMENT
xd->mi[0]->skip_mode,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
av1_ref_frame_type(xd->mi[0]->ref_frame));
ctx->single_pred_diff = (int)comp_pred_diff[SINGLE_REFERENCE];
ctx->comp_pred_diff = (int)comp_pred_diff[COMPOUND_REFERENCE];
@@ -826,9 +829,9 @@
av1_setup_pred_block(xd, yv12_mb[ref_frame_idx], yv12, sf, sf, num_planes);
}
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) return;
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
// Gets an initial list of candidate vectors from neighbours and orders them
av1_find_mv_refs(
@@ -1006,7 +1009,10 @@
const PREDICTION_MODE this_mode = mbmi->mode;
const MV_REFERENCE_FRAME refs[2] = { COMPACT_INDEX0_NRS(mbmi->ref_frame[0]),
COMPACT_INDEX1_NRS(mbmi->ref_frame[1]) };
+
+#if !CONFIG_SEP_COMP_DRL
const int ref_mv_idx = mbmi->ref_mv_idx;
+#endif // !CONFIG_SEP_COMP_DRL
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
#endif
@@ -1017,7 +1023,12 @@
int valid_precision_mv0 = NUM_MV_PRECISIONS;
for (int prev_mv_precision = pb_mv_precision;
prev_mv_precision <= mbmi->max_mv_precision; prev_mv_precision++) {
+#if CONFIG_SEP_COMP_DRL
+ if (args->single_newmv_valid[prev_mv_precision][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]]) {
+#else
if (args->single_newmv_valid[prev_mv_precision][ref_mv_idx][refs[0]]) {
+#endif // CONFIG_SEP_COMP_DRL
valid_mv0_found = 1;
valid_precision_mv0 = prev_mv_precision;
break;
@@ -1028,7 +1039,12 @@
int valid_precision_mv1 = NUM_MV_PRECISIONS;
for (int prev_mv_precision = pb_mv_precision;
prev_mv_precision <= mbmi->max_mv_precision; prev_mv_precision++) {
+#if CONFIG_SEP_COMP_DRL
+ if (args->single_newmv_valid[prev_mv_precision][get_ref_mv_idx(mbmi, 1)]
+ [refs[1]]) {
+#else
if (args->single_newmv_valid[prev_mv_precision][ref_mv_idx][refs[1]]) {
+#endif // CONFIG_SEP_COMP_DRL
valid_mv1_found = 1;
valid_precision_mv1 = prev_mv_precision;
break;
@@ -1043,64 +1059,37 @@
#if CONFIG_OPTFLOW_REFINEMENT
if (this_mode == NEW_NEWMV || this_mode == NEW_NEWMV_OPTFLOW) {
+#if CONFIG_SKIP_ME_FOR_OPFL_MODES
+ if (this_mode == NEW_NEWMV_OPTFLOW &&
+ args->comp_newmv_valid[av1_ref_frame_type(mbmi->ref_frame)]
+#if CONFIG_SEP_COMP_DRL
+ [av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx)]
#else
- if (this_mode == NEW_NEWMV) {
-#endif // CONFIG_OPTFLOW_REFINEMENT
- if (valid_mv0) {
-#if CONFIG_FLEX_MVRES
+ [mbmi->ref_mv_idx]
+#endif
+ [pb_mv_precision]) {
cur_mv[0].as_int =
- args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
+ args->comp_newmv[av1_ref_frame_type(mbmi->ref_frame)]
+#if CONFIG_SEP_COMP_DRL
+ [av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx)]
#else
- cur_mv[0].as_int = args->single_newmv[ref_mv_idx][refs[0]].as_int;
+ [mbmi->ref_mv_idx]
#endif
-
-#if CONFIG_FLEX_MVRES
- lower_mv_precision(&cur_mv[0].as_mv, pb_mv_precision);
-#endif
- clamp_mv_in_range(x, &cur_mv[0], 0
-#if CONFIG_FLEX_MVRES
- ,
- pb_mv_precision
-#endif
-
- );
- }
- if (valid_mv1) {
-#if CONFIG_FLEX_MVRES
+ [pb_mv_precision][0]
+ .as_int;
cur_mv[1].as_int =
- args->single_newmv[valid_precision_mv1][ref_mv_idx][refs[1]].as_int;
+ args->comp_newmv[av1_ref_frame_type(mbmi->ref_frame)]
+#if CONFIG_SEP_COMP_DRL
+ [av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx)]
#else
- cur_mv[1].as_int = args->single_newmv[ref_mv_idx][refs[1]].as_int;
+ [mbmi->ref_mv_idx]
#endif
-#if CONFIG_FLEX_MVRES
- lower_mv_precision(&cur_mv[1].as_mv, pb_mv_precision);
-#endif
- clamp_mv_in_range(x, &cur_mv[1], 1
-#if CONFIG_FLEX_MVRES
- ,
- pb_mv_precision
-#endif
- );
- }
+ [pb_mv_precision][1]
+ .as_int;
- // aomenc1
- if (cpi->sf.inter_sf.comp_inter_joint_search_thresh <= bsize ||
- !valid_mv0 || !valid_mv1) {
- // uint8_t mask_value = 32;
- av1_joint_motion_search(cpi, x, bsize, cur_mv, NULL, 0, rate_mv);
- } else {
*rate_mv = 0;
for (int i = 0; i < 2; ++i) {
const int_mv ref_mv = av1_get_ref_mv(x, i);
-#if CONFIG_C071_SUBBLK_WARPMV
- update_mv_precision(ref_mv.as_mv,
-#if CONFIG_FLEX_MVRES
- pb_mv_precision,
-#else
- cm->features.allow_high_precision_mv,
-#endif
- &cur_mv[i].as_mv);
-#endif // CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
*rate_mv +=
av1_mv_bit_cost(&cur_mv[i].as_mv, &ref_mv.as_mv, pb_mv_precision,
@@ -1116,7 +1105,122 @@
x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
#endif
}
+ } else {
+#endif // CONFIG_SKIP_ME_FOR_OPFL_MODES
+#else
+ if (this_mode == NEW_NEWMV) {
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ if (valid_mv0) {
+#if CONFIG_FLEX_MVRES
+ cur_mv[0].as_int =
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv[valid_precision_mv0][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]]
+ .as_int;
+#else
+ args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
+#endif // CONFIG_SEP_COMP_DRL
+#else
+ cur_mv[0].as_int = args->single_newmv[ref_mv_idx][refs[0]].as_int;
+#endif
+
+#if CONFIG_FLEX_MVRES
+ lower_mv_precision(&cur_mv[0].as_mv, pb_mv_precision);
+#endif
+ clamp_mv_in_range(x, &cur_mv[0], 0
+#if CONFIG_FLEX_MVRES
+ ,
+ pb_mv_precision
+#endif
+
+ );
+ }
+ if (valid_mv1) {
+#if CONFIG_FLEX_MVRES
+ cur_mv[1].as_int =
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv[valid_precision_mv1][get_ref_mv_idx(mbmi, 1)]
+ [refs[1]]
+ .as_int;
+#else
+ args->single_newmv[valid_precision_mv1][ref_mv_idx][refs[1]].as_int;
+#endif // CONFIG_SEP_COMP_DRL
+#else
+ cur_mv[1].as_int = args->single_newmv[ref_mv_idx][refs[1]].as_int;
+#endif
+#if CONFIG_FLEX_MVRES
+ lower_mv_precision(&cur_mv[1].as_mv, pb_mv_precision);
+#endif
+ clamp_mv_in_range(x, &cur_mv[1], 1
+#if CONFIG_FLEX_MVRES
+ ,
+ pb_mv_precision
+#endif
+ );
+ }
+
+ // aomenc1
+ if (cpi->sf.inter_sf.comp_inter_joint_search_thresh <= bsize ||
+ !valid_mv0 || !valid_mv1) {
+ // uint8_t mask_value = 32;
+ av1_joint_motion_search(cpi, x, bsize, cur_mv, NULL, 0, rate_mv);
+ } else {
+ *rate_mv = 0;
+ for (int i = 0; i < 2; ++i) {
+ const int_mv ref_mv = av1_get_ref_mv(x, i);
+#if CONFIG_C071_SUBBLK_WARPMV
+ update_mv_precision(ref_mv.as_mv,
+#if CONFIG_FLEX_MVRES
+ pb_mv_precision,
+#else
+ cm->features.allow_high_precision_mv,
+#endif
+ &cur_mv[i].as_mv);
+#endif // CONFIG_C071_SUBBLK_WARPMV
+#if CONFIG_FLEX_MVRES
+ *rate_mv +=
+ av1_mv_bit_cost(&cur_mv[i].as_mv, &ref_mv.as_mv,
+ pb_mv_precision, &x->mv_costs, MV_COST_WEIGHT
+#if CONFIG_ADAPTIVE_MVD
+ ,
+ 0
+#endif
+ );
+#else
+ *rate_mv += av1_mv_bit_cost(
+ &cur_mv[i].as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
+ x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
+#endif
+ }
+ }
+#if CONFIG_SKIP_ME_FOR_OPFL_MODES
+ if (this_mode == NEW_NEWMV) {
+ args->comp_newmv_valid[av1_ref_frame_type(mbmi->ref_frame)]
+#if CONFIG_SEP_COMP_DRL
+ [av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx)]
+#else
+ [mbmi->ref_mv_idx]
+#endif
+ [pb_mv_precision] = 1;
+ args->comp_newmv[av1_ref_frame_type(mbmi->ref_frame)]
+#if CONFIG_SEP_COMP_DRL
+ [av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx)]
+#else
+ [mbmi->ref_mv_idx]
+#endif
+ [pb_mv_precision][0]
+ .as_int = cur_mv[0].as_int;
+ args->comp_newmv[av1_ref_frame_type(mbmi->ref_frame)]
+#if CONFIG_SEP_COMP_DRL
+ [av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx)]
+#else
+ [mbmi->ref_mv_idx]
+#endif
+ [pb_mv_precision][1]
+ .as_int = cur_mv[1].as_int;
+ }
}
+#endif // CONFIG_SKIP_ME_FOR_OPFL_MODES
#if CONFIG_OPTFLOW_REFINEMENT
} else if (this_mode == NEAR_NEWMV || this_mode == NEAR_NEWMV_OPTFLOW) {
#else
@@ -1125,7 +1229,13 @@
if (valid_mv1) {
#if CONFIG_FLEX_MVRES
cur_mv[1].as_int =
- args->single_newmv[valid_precision_mv1][ref_mv_idx][refs[1]].as_int;
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv[valid_precision_mv1][get_ref_mv_idx(mbmi, 1)]
+ [refs[1]]
+ .as_int;
+#else
+ args->single_newmv[valid_precision_mv1][ref_mv_idx][refs[1]].as_int;
+#endif // CONFIG_SEP_COMP_DRL
#else
cur_mv[1].as_int = args->single_newmv[ref_mv_idx][refs[1]].as_int;
#endif
@@ -1161,7 +1271,7 @@
#if CONFIG_FLEX_MVRES
pb_mv_precision,
#else
- cm->features.allow_high_precision_mv,
+ cm->features.allow_high_precision_mv,
#endif
&cur_mv[1].as_mv);
#endif // CONFIG_C071_SUBBLK_WARPMV
@@ -1201,8 +1311,8 @@
#if IMPROVED_AMVD
if (first_ref_dist != sec_ref_dist) return INT64_MAX;
#else
- if (first_ref_dist > 2 * sec_ref_dist) return INT64_MAX;
- if (sec_ref_dist > 2 * first_ref_dist) return INT64_MAX;
+ if (first_ref_dist > 2 * sec_ref_dist) return INT64_MAX;
+ if (sec_ref_dist > 2 * first_ref_dist) return INT64_MAX;
#endif // IMPROVED_AMVD
const int jmvd_base_ref_list = get_joint_mvd_base_ref_list(cm, mbmi);
@@ -1217,10 +1327,15 @@
#if CONFIG_FLEX_MVRES
args->single_newmv[jmvd_base_ref_list == 0 ? valid_precision_mv0
: valid_precision_mv1]
- [ref_mv_idx][refs[jmvd_base_ref_list]]
+#if CONFIG_SEP_COMP_DRL
+ [get_ref_mv_idx(mbmi, 1)]
+#else
+ [ref_mv_idx]
+#endif // CONFIG_SEP_COMP_DRL
+ [refs[jmvd_base_ref_list]]
.as_int;
#else
- args->single_newmv[ref_mv_idx][refs[jmvd_base_ref_list]].as_int;
+ args->single_newmv[ref_mv_idx][refs[jmvd_base_ref_list]].as_int;
#endif
#if CONFIG_FLEX_MVRES
@@ -1247,7 +1362,13 @@
if (valid_mv0) {
#if CONFIG_FLEX_MVRES
cur_mv[0].as_int =
- args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv[valid_precision_mv0][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]]
+ .as_int;
+#else
+ args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
+#endif // CONFIG_SEP_COMP_DRL
#else
cur_mv[0].as_int = args->single_newmv[ref_mv_idx][refs[0]].as_int;
#endif
@@ -1285,7 +1406,7 @@
#if CONFIG_FLEX_MVRES
pb_mv_precision,
#else
- cm->features.allow_high_precision_mv,
+ cm->features.allow_high_precision_mv,
#endif
&cur_mv[0].as_mv);
#endif // CONFIG_C071_SUBBLK_WARPMV
@@ -1338,7 +1459,13 @@
int valid_mv0_found = 0;
for (int prev_mv_precision = pb_mv_precision;
prev_mv_precision <= mbmi->max_mv_precision; prev_mv_precision++) {
- if (args->single_newmv_valid[prev_mv_precision][ref_mv_idx][refs[0]]) {
+#if CONFIG_SEP_COMP_DRL
+ assert(get_ref_mv_idx(mbmi, 1) == get_ref_mv_idx(mbmi, 0));
+ if (args->single_newmv_valid[prev_mv_precision][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]]) {
+#else
+ if (args->single_newmv_valid[prev_mv_precision][ref_mv_idx][refs[0]]) {
+#endif // CONFIG_SEP_COMP_DRL
valid_mv0_found = 1;
valid_precision_mv0 = prev_mv_precision;
break;
@@ -1353,7 +1480,13 @@
assert(valid_precision_mv0 > pb_mv_precision &&
valid_precision_mv0 < NUM_MV_PRECISIONS);
start_mv.as_int =
- args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv[valid_precision_mv0][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]]
+ .as_int;
+#else
+ args->single_newmv[valid_precision_mv0][ref_mv_idx][refs[0]].as_int;
+#endif // CONFIG_SEP_COMP_DRL
lower_mv_precision(&start_mv.as_mv, pb_mv_precision);
clamp_mv_in_range(x, &start_mv, 0, pb_mv_precision);
@@ -1363,15 +1496,27 @@
} else {
#endif
int search_range = INT_MAX;
- if (cpi->sf.mv_sf.reduce_search_range && mbmi->ref_mv_idx > 0) {
+#if CONFIG_SEP_COMP_DRL
+ if (cpi->sf.mv_sf.reduce_search_range && mbmi->ref_mv_idx[0] > 0) {
+#else
+ if (cpi->sf.mv_sf.reduce_search_range && mbmi->ref_mv_idx > 0) {
+#endif // CONFIG_SEP_COMP_DRL
const MV ref_mv = av1_get_ref_mv(x, ref_idx).as_mv;
int min_mv_diff = INT_MAX;
int best_match = -1;
MV best_mv1 = { 0 };
- for (int idx = 0; idx < mbmi->ref_mv_idx; ++idx) {
+#if CONFIG_SEP_COMP_DRL
+ assert(ref_idx == 0);
+ for (int idx = 0; idx < mbmi->ref_mv_idx[ref_idx]; ++idx) {
MV prev_ref_mv = av1_get_ref_mv_from_stack(ref_idx, mbmi->ref_frame,
- idx, x->mbmi_ext)
+ idx, x->mbmi_ext, mbmi)
.as_mv;
+#else
+ for (int idx = 0; idx < mbmi->ref_mv_idx; ++idx) {
+ MV prev_ref_mv = av1_get_ref_mv_from_stack(ref_idx, mbmi->ref_frame,
+ idx, x->mbmi_ext)
+ .as_mv;
+#endif // CONFIG_SEP_COMP_DRL
const int ref_mv_diff = AOMMAX(abs(ref_mv.row - prev_ref_mv.row),
abs(ref_mv.col - prev_ref_mv.col));
@@ -1411,7 +1556,13 @@
}
}
av1_single_motion_search(cpi, x, bsize, ref_idx, rate_mv, search_range,
- mode_info, &best_mv);
+ mode_info, &best_mv
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ ,
+ NULL
+#endif // CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+
+ );
#if CONFIG_FLEX_MVRES
}
@@ -1420,9 +1571,18 @@
if (best_mv.as_int == INVALID_MV) return INT64_MAX;
#if CONFIG_FLEX_MVRES
- args->single_newmv[pb_mv_precision][ref_mv_idx][refs[0]] = best_mv;
- args->single_newmv_rate[pb_mv_precision][ref_mv_idx][refs[0]] = *rate_mv;
- args->single_newmv_valid[pb_mv_precision][ref_mv_idx][refs[0]] = 1;
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv[pb_mv_precision][get_ref_mv_idx(mbmi, 0)][refs[0]] =
+ best_mv;
+ args->single_newmv_rate[pb_mv_precision][get_ref_mv_idx(mbmi, 0)][refs[0]] =
+ *rate_mv;
+ args->single_newmv_valid[pb_mv_precision][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]] = 1;
+#else
+ args->single_newmv[pb_mv_precision][ref_mv_idx][refs[0]] = best_mv;
+ args->single_newmv_rate[pb_mv_precision][ref_mv_idx][refs[0]] = *rate_mv;
+ args->single_newmv_valid[pb_mv_precision][ref_mv_idx][refs[0]] = 1;
+#endif // CONFIG_SEP_COMP_DRL
#else
args->single_newmv[ref_mv_idx][refs[0]] = best_mv;
args->single_newmv_rate[ref_mv_idx][refs[0]] = *rate_mv;
@@ -1451,7 +1611,11 @@
const ModeCosts *mode_costs) {
#if CONFIG_WARP_REF_LIST
(void)xd;
- if (!allow_warp_parameter_signaling(mbmi)) {
+ if (!allow_warp_parameter_signaling(
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ cm,
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi)) {
return 0;
}
#endif // CONFIG_WARP_REF_LIST
@@ -1650,7 +1814,11 @@
#if CONFIG_CROSS_CHROMA_TX
CctxType best_cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
#endif // CONFIG_CROSS_CHROMA_TX
- const int rate_mv0 = *rate_mv;
+ const int rate_mv0 =
+#if CONFIG_WARPMV
+ this_mode == WARPMV ? 0 :
+#endif
+ *rate_mv;
#if !CONFIG_EXTENDED_WARP_PREDICTION
const int interintra_allowed =
cm->seq_params.enable_interintra_compound && is_interintra_allowed(mbmi);
@@ -1670,6 +1838,9 @@
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
#if CONFIG_EXTENDED_WARP_PREDICTION
int allowed_motion_modes = motion_mode_allowed(
@@ -1700,6 +1871,13 @@
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ int_mv previous_mvs[MAX_WARP_REF_CANDIDATES];
+ for (int w_ref_idx = 0; w_ref_idx < MAX_WARP_REF_CANDIDATES; w_ref_idx++) {
+ previous_mvs[w_ref_idx].as_int = INVALID_MV;
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ int num_rd_check = 0;
const MB_MODE_INFO base_mbmi = *mbmi;
MB_MODE_INFO best_mbmi;
#if CONFIG_C071_SUBBLK_WARPMV
@@ -1763,10 +1941,14 @@
|| is_warpmv_warp_causal
#endif // CONFIG_WARPMV
) {
- max_warp_ref_idx =
- (base_mbmi.mode == GLOBALMV || base_mbmi.mode == NEARMV)
- ? 1
- : MAX_WARP_REF_CANDIDATES;
+ max_warp_ref_idx = (base_mbmi.mode == GLOBALMV || base_mbmi.mode == NEARMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || base_mbmi.mode == AMVDNEWMV
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+ )
+ ? 1
+ : MAX_WARP_REF_CANDIDATES;
#if CONFIG_WARPMV
if (is_warpmv_warp_causal) {
max_warp_ref_idx = MAX_WARP_REF_CANDIDATES;
@@ -1797,33 +1979,38 @@
if (is_warpmv_warp_causal && warp_ref_idx >= valid_num_candidates)
continue;
#endif // CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ for (int warpmv_with_mvd_flag = 0;
+ warpmv_with_mvd_flag < (1 + (base_mbmi.mode == WARPMV));
+ warpmv_with_mvd_flag++) {
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
- int tmp_rate2 = rate2_nocoeff;
- int tmp_rate_mv = rate_mv0;
+ int tmp_rate2 = rate2_nocoeff;
+ int tmp_rate_mv = rate_mv0;
- *mbmi = base_mbmi;
+ *mbmi = base_mbmi;
#if CONFIG_C071_SUBBLK_WARPMV
- update_submi(xd, cm, base_submi, bsize);
+ update_submi(xd, cm, base_submi, bsize);
#endif // CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_WARP_REF_LIST
- mbmi->warp_ref_idx = warp_ref_idx;
- mbmi->max_num_warp_candidates = (mode_index == WARP_DELTA
+ mbmi->warp_ref_idx = warp_ref_idx;
+ mbmi->max_num_warp_candidates = (mode_index == WARP_DELTA
#if CONFIG_WARPMV
- || is_warpmv_warp_causal
+ || is_warpmv_warp_causal
#endif // CONFIG_WARPMV
- )
- ? max_warp_ref_idx
- : 0;
- assert(valid_num_candidates <= mbmi->max_num_warp_candidates);
+ )
+ ? max_warp_ref_idx
+ : 0;
+ assert(valid_num_candidates <= mbmi->max_num_warp_candidates);
#endif // CONFIG_WARP_REF_LIST
#if CONFIG_EXTENDED_WARP_PREDICTION
- mbmi->motion_mode = (MOTION_MODE)mode_index;
- if (mbmi->motion_mode != INTERINTRA) {
- assert(mbmi->ref_frame[1] != INTRA_FRAME);
- }
+ mbmi->motion_mode = (MOTION_MODE)mode_index;
+ if (mbmi->motion_mode != INTERINTRA) {
+ assert(mbmi->ref_frame[1] != INTRA_FRAME);
+ }
#else
if (is_interintra_mode) {
// Only use SIMPLE_TRANSLATION for interintra
@@ -1834,312 +2021,279 @@
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (warpmv_with_mvd_flag && !allow_warpmv_with_mvd_coding(cm, mbmi))
+ continue;
+ mbmi->warpmv_with_mvd_flag = warpmv_with_mvd_flag;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
#if CONFIG_WARPMV
- // Only WARP_DELTA and WARPED_CAUSAL are supported for WARPMV mode
- assert(IMPLIES(mbmi->mode == WARPMV,
- mbmi->motion_mode == WARP_DELTA || is_warpmv_warp_causal));
+ // Only WARP_DELTA and WARPED_CAUSAL are supported for WARPMV mode
+ assert(IMPLIES(mbmi->mode == WARPMV, mbmi->motion_mode == WARP_DELTA ||
+ is_warpmv_warp_causal));
#endif // CONFIG_WARPMV
- // Do not search OBMC if the probability of selecting it is below a
- // predetermined threshold for this update_type and block size.
- const FRAME_UPDATE_TYPE update_type =
- get_frame_update_type(&cpi->gf_group);
- const int prune_obmc = cpi->frame_probs.obmc_probs[update_type][bsize] <
- cpi->sf.inter_sf.prune_obmc_prob_thresh;
+ // Do not search OBMC if the probability of selecting it is below a
+ // predetermined threshold for this update_type and block size.
+ const FRAME_UPDATE_TYPE update_type =
+ get_frame_update_type(&cpi->gf_group);
+ const int prune_obmc = cpi->frame_probs.obmc_probs[update_type][bsize] <
+ cpi->sf.inter_sf.prune_obmc_prob_thresh;
#if CONFIG_EXTENDED_WARP_PREDICTION
- bool enable_obmc =
- (cm->features.enabled_motion_modes & (1 << OBMC_CAUSAL)) != 0;
+ bool enable_obmc =
+ (cm->features.enabled_motion_modes & (1 << OBMC_CAUSAL)) != 0;
#else
bool enable_obmc = cpi->oxcf.motion_mode_cfg.enable_obmc;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
- if ((!enable_obmc || cpi->sf.inter_sf.disable_obmc || prune_obmc) &&
- mbmi->motion_mode == OBMC_CAUSAL)
- continue;
+ if ((!enable_obmc || cpi->sf.inter_sf.disable_obmc || prune_obmc) &&
+ mbmi->motion_mode == OBMC_CAUSAL)
+ continue;
- if (is_warp_mode(mbmi->motion_mode)) {
- mbmi->interp_fltr = av1_unswitchable_filter(interp_filter);
- }
+ if (is_warp_mode(mbmi->motion_mode)) {
+ mbmi->interp_fltr = av1_unswitchable_filter(interp_filter);
+ }
#if CONFIG_EXTENDED_WARP_PREDICTION
- if (mbmi->motion_mode == SIMPLE_TRANSLATION) {
+ if (mbmi->motion_mode == SIMPLE_TRANSLATION) {
#else
if (mbmi->motion_mode == SIMPLE_TRANSLATION && !is_interintra_mode) {
#endif // CONFIG_EXTENDED_WARP_PREDICTION
// SIMPLE_TRANSLATION mode: no need to recalculate.
// The prediction is calculated before motion_mode_rd() is called in
// handle_inter_mode()
- } else if (mbmi->motion_mode == OBMC_CAUSAL) {
- // OBMC_CAUSAL not allowed for compound prediction
- assert(!is_comp_pred);
- if (this_mode == NEWMV) {
- av1_single_motion_search(cpi, x, bsize, 0, &tmp_rate_mv, INT_MAX,
- NULL, &mbmi->mv[0]);
- tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
- }
- // Build the inter predictor by blending the predictor corresponding to
- // this MV, and the neighboring blocks using the OBMC model
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, orig_dst, bsize,
- 0, av1_num_planes(cm) - 1);
- av1_build_obmc_inter_prediction(
- cm, xd, args->above_pred_buf, args->above_pred_stride,
- args->left_pred_buf, args->left_pred_stride);
- } else if (mbmi->motion_mode == WARPED_CAUSAL) {
- int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
+ } else if (mbmi->motion_mode == OBMC_CAUSAL) {
+ // OBMC_CAUSAL not allowed for compound prediction
+ assert(!is_comp_pred);
+ if (this_mode == NEWMV) {
+ av1_single_motion_search(cpi, x, bsize, 0, &tmp_rate_mv, INT_MAX,
+ NULL, &mbmi->mv[0]
+#if CONFIG_CWG_D067_IMPROVED_WARP && CONFIG_WARPMV
+ ,
+ NULL
+#endif // CONFIG_CWG_D067_IMPROVED_WARP && CONFIG_WARPMV
+ );
+ tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
+ }
+ // Build the inter predictor by blending the predictor
+ // corresponding to this MV, and the neighboring blocks using the
+ // OBMC model
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, orig_dst, bsize,
+ 0, av1_num_planes(cm) - 1);
+ av1_build_obmc_inter_prediction(
+ cm, xd, args->above_pred_buf, args->above_pred_stride,
+ args->left_pred_buf, args->left_pred_stride);
+ } else if (mbmi->motion_mode == WARPED_CAUSAL) {
+ int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
#if CONFIG_EXTENDED_WARP_PREDICTION
- mbmi->wm_params[0].wmtype = DEFAULT_WMTYPE;
+ mbmi->wm_params[0].wmtype = DEFAULT_WMTYPE;
#else
mbmi->wm_params.wmtype = DEFAULT_WMTYPE;
#endif // CONFIG_EXTENDED_WARP_PREDICTION
#if CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ int_mv warp_ref_mv = mbmi->mv[0];
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
// Build the motion vector of the WARPMV mode
- if (mbmi->mode == WARPMV) {
- WarpedMotionParams ref_model =
- mbmi_ext
- ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
- [mbmi->warp_ref_idx]
- .wm_params;
- mbmi->mv[0] = get_mv_from_wrl(xd, &ref_model,
+ if (mbmi->mode == WARPMV) {
+ WarpedMotionParams ref_model =
+ mbmi_ext
+ ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
+ [mbmi->warp_ref_idx]
+ .wm_params;
+ mbmi->mv[0] = get_mv_from_wrl(
+ xd, &ref_model,
#if CONFIG_FLEX_MVRES
- MV_PRECISION_ONE_EIGHTH_PEL,
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag ? mbmi->pb_mv_precision :
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ MV_PRECISION_ONE_EIGHTH_PEL,
#else
- 1, 0,
+ 1, 0,
#endif
- bsize, xd->mi_col, xd->mi_row);
- if (!is_warp_candidate_inside_of_frame(cm, xd, mbmi->mv[0])) continue;
+ bsize, xd->mi_col, xd->mi_row);
+
+ if (!is_warp_candidate_inside_of_frame(cm, xd, mbmi->mv[0]))
+ continue;
#if CONFIG_FLEX_MVRES
- assert(mbmi->pb_mv_precision == mbmi->max_mv_precision);
+ assert(mbmi->pb_mv_precision == mbmi->max_mv_precision);
#endif
- }
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ warp_ref_mv.as_int = mbmi->mv[0].as_int;
+ // search MVD if mbmi->warpmv_with_mvd_flag is used.
+ if (mbmi->warpmv_with_mvd_flag) {
+ if (previous_mvs[mbmi->warp_ref_idx].as_int == INVALID_MV) {
+ int tmp_trans_ratemv = 0;
+ av1_single_motion_search(cpi, x, bsize, 0, &tmp_trans_ratemv,
+ 16, NULL, &mbmi->mv[0], &warp_ref_mv);
+ previous_mvs[mbmi->warp_ref_idx].as_int = mbmi->mv[0].as_int;
+ } else {
+ mbmi->mv[0].as_int = previous_mvs[mbmi->warp_ref_idx].as_int;
+ }
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ }
#endif // CONFIG_WARPMV
- memcpy(pts, pts0, total_samples * 2 * sizeof(*pts0));
- memcpy(pts_inref, pts_inref0, total_samples * 2 * sizeof(*pts_inref0));
- // Select the samples according to motion vector difference
- if (mbmi->num_proj_ref > 1) {
- mbmi->num_proj_ref = av1_selectSamples(
- &mbmi->mv[0].as_mv, pts, pts_inref, mbmi->num_proj_ref, bsize);
- }
+ memcpy(pts, pts0, total_samples * 2 * sizeof(*pts0));
+ memcpy(pts_inref, pts_inref0,
+ total_samples * 2 * sizeof(*pts_inref0));
+ // Select the samples according to motion vector difference
+ if (mbmi->num_proj_ref > 1) {
+ mbmi->num_proj_ref = av1_selectSamples(
+ &mbmi->mv[0].as_mv, pts, pts_inref, mbmi->num_proj_ref, bsize);
+ }
- // Compute the warped motion parameters with a least squares fit
- // using the collected samples
+ // Compute the warped motion parameters with a least squares fit
+ // using the collected samples
#if CONFIG_EXTENDED_WARP_PREDICTION
- if (!av1_find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize,
- mbmi->mv[0].as_mv, &mbmi->wm_params[0], mi_row,
- mi_col)) {
+ if (!av1_find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize,
+ mbmi->mv[0].as_mv, &mbmi->wm_params[0],
+ mi_row, mi_col)) {
#else
if (!av1_find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize,
mbmi->mv[0].as_mv, &mbmi->wm_params, mi_row,
mi_col)) {
#endif // CONFIG_EXTENDED_WARP_PREDICTION
- assert(!is_comp_pred);
- if (this_mode == NEWMV
+ assert(!is_comp_pred);
+ if ((this_mode == NEWMV
#if CONFIG_FLEX_MVRES
- && (mbmi->pb_mv_precision >= MV_PRECISION_ONE_PEL)
+ && (mbmi->pb_mv_precision >= MV_PRECISION_ONE_PEL))
#endif
- ) {
- // Refine MV for NEWMV mode
- const int_mv mv0 = mbmi->mv[0];
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || mbmi->warpmv_with_mvd_flag
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ ) {
+ // Refine MV for NEWMV mode
+ const int_mv mv0 =
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->mode == WARPMV ? warp_ref_mv :
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->mv[0];
+ const int_mv ref_mv =
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag ? warp_ref_mv :
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
- const int_mv ref_mv = av1_get_ref_mv(x, 0);
+ av1_get_ref_mv(x, 0);
#if CONFIG_FLEX_MVRES
- const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
+ const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
#endif
- SUBPEL_MOTION_SEARCH_PARAMS ms_params;
- av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize,
- &ref_mv.as_mv,
+ SUBPEL_MOTION_SEARCH_PARAMS ms_params;
+ av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize,
+ &ref_mv.as_mv,
#if CONFIG_FLEX_MVRES
- pb_mv_precision,
+ pb_mv_precision,
#endif
- NULL);
-
- // Refine MV in a small range.
- av1_refine_warped_mv(xd, cm, &ms_params, bsize, pts0, pts_inref0,
- total_samples,
- cpi->sf.mv_sf.warp_search_method,
- cpi->sf.mv_sf.warp_search_iters);
-
- if (mv0.as_int != mbmi->mv[0].as_int) {
- // Keep the refined MV and WM parameters.
+ NULL);
+ // Refine MV in a small range.
+ av1_refine_warped_mv(xd, cm, &ms_params, bsize, pts0, pts_inref0,
+ total_samples,
+ cpi->sf.mv_sf.warp_search_method,
+ cpi->sf.mv_sf.warp_search_iters);
+ if (mv0.as_int != mbmi->mv[0].as_int
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ || mbmi->warpmv_with_mvd_flag
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ ) {
+ // Keep the refined MV and WM parameters.
#if CONFIG_FLEX_MVRES
- tmp_rate_mv =
- av1_mv_bit_cost(&mbmi->mv[0].as_mv, &ref_mv.as_mv,
- pb_mv_precision, &x->mv_costs, MV_COST_WEIGHT
+ tmp_rate_mv = av1_mv_bit_cost(
+ &mbmi->mv[0].as_mv, &ref_mv.as_mv, pb_mv_precision,
+ &x->mv_costs, MV_COST_WEIGHT
#if CONFIG_ADAPTIVE_MVD
- ,
- ms_params.mv_cost_params.is_adaptive_mvd
+ ,
+ ms_params.mv_cost_params.is_adaptive_mvd
#endif
- );
+ );
#else
tmp_rate_mv = av1_mv_bit_cost(
&mbmi->mv[0].as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
#endif
- tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
+ tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ assert(
+ IMPLIES(mbmi->mode == WARPMV, mbmi->warpmv_with_mvd_flag));
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ }
}
- }
#if CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_EXTENDED_WARP_PREDICTION
- assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row,
- mi_col);
+ assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row,
+ mi_col);
#else
assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params, mi_row, mi_col);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
#endif // CONFIG_C071_SUBBLK_WARPMV
// Build the warped predictor
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
- } else {
- continue;
- }
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize,
+ 0, av1_num_planes(cm) - 1);
+ } else {
+ continue;
+ }
+
#if CONFIG_EXTENDED_WARP_PREDICTION
- } else if (mbmi->motion_mode == INTERINTRA) {
+ } else if (mbmi->motion_mode == INTERINTRA) {
#else
} else if (is_interintra_mode) {
#endif // CONFIG_EXTENDED_WARP_PREDICTION
- const int ret =
- av1_handle_inter_intra_mode(cpi, x, bsize, mbmi, args, ref_best_rd,
- &tmp_rate_mv, &tmp_rate2, orig_dst);
- if (ret < 0) continue;
+ const int ret = av1_handle_inter_intra_mode(cpi, x, bsize, mbmi, args,
+ ref_best_rd, &tmp_rate_mv,
+ &tmp_rate2, orig_dst);
+ if (ret < 0) continue;
#if CONFIG_EXTENDED_WARP_PREDICTION
- } else if (mbmi->motion_mode == WARP_DELTA) {
+ } else if (mbmi->motion_mode == WARP_DELTA) {
#if CONFIG_FLEX_MVRES
- if (mbmi->mode == NEWMV &&
- mbmi->pb_mv_precision < MV_PRECISION_ONE_PEL) {
- // Don't bother with warp modes for MV precisions >1px
- continue;
- }
-#endif
-#if CONFIG_WARPMV
- // Build the motion vector of the WARPMV mode
- if (mbmi->mode == WARPMV) {
- WarpedMotionParams ref_model =
- mbmi_ext
- ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
- [mbmi->warp_ref_idx]
- .wm_params;
- mbmi->mv[0] = get_mv_from_wrl(xd, &ref_model,
-#if CONFIG_FLEX_MVRES
- MV_PRECISION_ONE_EIGHTH_PEL,
-#else
- 1, 0,
-#endif
- bsize, xd->mi_col, xd->mi_row);
-#if CONFIG_FLEX_MVRES
- assert(mbmi->pb_mv_precision == mbmi->max_mv_precision);
-#endif
- if (!is_warp_candidate_inside_of_frame(cm, xd, mbmi->mv[0])) continue;
- }
-#endif // CONFIG_WARPMV
- int_mv mv0 = mbmi->mv[0];
- const int_mv ref_mv = av1_get_ref_mv(x, 0);
- SUBPEL_MOTION_SEARCH_PARAMS ms_params;
- av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize,
- &ref_mv.as_mv,
-#if CONFIG_FLEX_MVRES
- mbmi->pb_mv_precision,
-#endif
- NULL);
- int valid = 0;
-#if CONFIG_WARP_REF_LIST
- if (!allow_warp_parameter_signaling(mbmi)) {
- // Default parameters are not searched if the delta is not signalled
- if (mbmi_ext
- ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
- [mbmi->warp_ref_idx]
- .proj_type == PROJ_DEFAULT)
- continue;
- valid = av1_refine_mv_for_base_param_warp_model(
- cm, xd, mbmi, mbmi_ext, &ms_params,
- cpi->sf.mv_sf.warp_search_method,
- cpi->sf.mv_sf.warp_search_iters);
- } else {
-#endif // CONFIG_WARP_REF_LIST
-
- valid = av1_pick_warp_delta(
- cm, xd, mbmi, mbmi_ext, &ms_params, &x->mode_costs
-#if CONFIG_WARP_REF_LIST
- ,
- mbmi_ext->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
-#endif // CONFIG_WARP_REF_LIST
-
- );
-
-#if CONFIG_WARP_REF_LIST
- }
-#endif // CONFIG_WARP_REF_LIST
-
- if (!valid) {
- continue;
- }
-
- // If we changed the MV, update costs
- if (mv0.as_int != mbmi->mv[0].as_int) {
- // Keep the refined MV and WM parameters.
-#if CONFIG_FLEX_MVRES
- tmp_rate_mv = av1_mv_bit_cost(&mbmi->mv[0].as_mv, &ref_mv.as_mv,
- mbmi->pb_mv_precision, &x->mv_costs,
- MV_COST_WEIGHT
-#if CONFIG_ADAPTIVE_MVD
- ,
- ms_params.mv_cost_params.is_adaptive_mvd
-#endif
- );
-#else
- tmp_rate_mv = av1_mv_bit_cost(
- &mbmi->mv[0].as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
- x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
-#endif
-
- tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
-#if CONFIG_WARPMV
- assert(mbmi->mode == NEWMV);
-#endif // CONFIG_WARPMV
- }
-#if CONFIG_C071_SUBBLK_WARPMV
- assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row,
- mi_col);
-#endif // CONFIG_C071_SUBBLK_WARPMV
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
- } else if (mbmi->motion_mode == WARP_EXTEND) {
-#if CONFIG_FLEX_MVRES
- if (mbmi->mode == NEWMV &&
- mbmi->pb_mv_precision < MV_PRECISION_ONE_PEL) {
- // Don't bother with warp modes for MV precisions >1px
- continue;
- }
-#endif
-
- CANDIDATE_MV *neighbor =
- &mbmi_ext->ref_mv_stack[mbmi->ref_frame[0]][mbmi->ref_mv_idx];
- POSITION base_pos = { 0, 0 };
- if (!get_extend_base_pos(cm, xd, mbmi, neighbor->row_offset,
- neighbor->col_offset, &base_pos)) {
- continue;
- }
- const MB_MODE_INFO *neighbor_mi =
- xd->mi[base_pos.row * xd->mi_stride + base_pos.col];
-
- if (mbmi->mode == NEARMV) {
- assert(is_warp_mode(neighbor_mi->motion_mode));
- if (neighbor_mi->wm_params[0].invalid) {
- // Skip invalid models
+ if (mbmi->mode == NEWMV &&
+ mbmi->pb_mv_precision < MV_PRECISION_ONE_PEL) {
+ // Don't bother with warp modes for MV precisions >1px
continue;
}
- mbmi->wm_params[0] = neighbor_mi->wm_params[0];
- } else {
- assert(mbmi->mode == NEWMV);
+#endif
+#if CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ int_mv wrl_ref_mv = mbmi->mv[0];
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
- bool neighbor_is_above =
- xd->up_available && (base_pos.row == -1 && base_pos.col >= 0);
+ // Build the motion vector of the WARPMV mode
+ if (mbmi->mode == WARPMV) {
+ WarpedMotionParams ref_model =
+ mbmi_ext
+ ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
+ [mbmi->warp_ref_idx]
+ .wm_params;
+ mbmi->mv[0] = get_mv_from_wrl(
+ xd, &ref_model,
+#if CONFIG_FLEX_MVRES
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag ? mbmi->pb_mv_precision :
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
- WarpedMotionParams neighbor_params;
- av1_get_neighbor_warp_model(cm, xd, neighbor_mi, &neighbor_params);
-
- const int_mv ref_mv = av1_get_ref_mv(x, 0);
+ MV_PRECISION_ONE_EIGHTH_PEL,
+#else
+ 1, 0,
+#endif
+ bsize, xd->mi_col, xd->mi_row);
+#if CONFIG_FLEX_MVRES
+ assert(mbmi->pb_mv_precision == mbmi->max_mv_precision);
+#endif
+ if (!is_warp_candidate_inside_of_frame(cm, xd, mbmi->mv[0]))
+ continue;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ wrl_ref_mv = mbmi->mv[0];
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ }
+#endif // CONFIG_WARPMV
+ int_mv mv0 = mbmi->mv[0];
+ const int_mv ref_mv =
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ (mbmi->mode == WARPMV) ? wrl_ref_mv :
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ av1_get_ref_mv(x, 0);
SUBPEL_MOTION_SEARCH_PARAMS ms_params;
av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize,
&ref_mv.as_mv,
@@ -2147,97 +2301,62 @@
mbmi->pb_mv_precision,
#endif
NULL);
- const SubpelMvLimits *mv_limits = &ms_params.mv_limits;
-
- // Note: The warp filter is only able to accept small deviations from
- // the identity transform, up to 1/4 pel of shift per pixel.
- // Especially for small blocks, it is likely that the motion vector
- // estimated by the newmv search will be too distant from the
- // neighbor's motion vectors for the warp filter to be applied.
- // However, we don't want to give up the benefits of a good initial
- // MV in the cases where a suitable one has already been found.
- //
- // To get the best of both worlds, we run an initial test to see
- // if the motion vector found by newmv search gives a valid motion
- // model. If so, we use that as the starting point for refinement.
- // Otherwise, we use the MV which is predicted by the neighbor's
- // warp model
- // TODO(rachelbarker): Do we need this logic?
-
- // Backup initial motion vector and resulting warp params
- int_mv mv0 = mbmi->mv[0];
- WarpedMotionParams wm_params0;
- if (!av1_extend_warp_model(neighbor_is_above, bsize,
- &mbmi->mv[0].as_mv, mi_row, mi_col,
- &neighbor_params, &wm_params0)) {
- // NEWMV search produced a valid model
- mbmi->wm_params[0] = wm_params0;
+ int valid = 0;
+#if CONFIG_WARP_REF_LIST
+ if (!allow_warp_parameter_signaling(
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ cm,
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi)) {
+ // Default parameters are not searched if the delta is not
+ // signalled
+ if (mbmi_ext
+ ->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
+ [mbmi->warp_ref_idx]
+ .proj_type == PROJ_DEFAULT)
+ continue;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ // search MVD if mbmi->warpmv_with_mvd_flag is used.
+ if (mbmi->mode == WARPMV && mbmi->warpmv_with_mvd_flag) {
+ if (previous_mvs[mbmi->warp_ref_idx].as_int == INVALID_MV) {
+ int tmp_trans_ratemv = 0;
+ av1_single_motion_search(cpi, x, bsize, 0, &tmp_trans_ratemv,
+ 16, NULL, &mbmi->mv[0], &ref_mv);
+ previous_mvs[mbmi->warp_ref_idx].as_int = mbmi->mv[0].as_int;
+ } else {
+ mbmi->mv[0].as_int = previous_mvs[mbmi->warp_ref_idx].as_int;
+ }
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ valid = av1_refine_mv_for_base_param_warp_model(
+ cm, xd, mbmi, mbmi_ext, &ms_params,
+ cpi->sf.mv_sf.warp_search_method,
+ cpi->sf.mv_sf.warp_search_iters);
} else {
- // NEWMV search did not produce a valid model, so fall back to
- // starting with the motion vector predicted by the neighbor's
- // warp model (if any)
-#if CONFIG_FLEX_MVRES
- mbmi->mv[0] = get_warp_motion_vector(xd, &neighbor_params,
- mbmi->pb_mv_precision, bsize,
- mi_col, mi_row);
-#else
- mbmi->mv[0] = get_warp_motion_vector(
- xd, &neighbor_params, features->allow_high_precision_mv, bsize,
- mi_col, mi_row, features->cur_frame_force_integer_mv);
-#endif
-#if CONFIG_C071_SUBBLK_WARPMV
- if (
-#if CONFIG_FLEX_MVRES
- mbmi->pb_mv_precision >= MV_PRECISION_HALF_PEL
-#else
- !cm->features.allow_high_precision_mv
-#endif
- ) {
- FULLPEL_MV tmp_full_mv = get_fullmv_from_mv(&mbmi->mv[0].as_mv);
- MV tmp_sub_mv = get_mv_from_fullmv(&tmp_full_mv);
- MV sub_mv_offset = { 0, 0 };
- get_phase_from_mv(ref_mv.as_mv, &sub_mv_offset,
-#if CONFIG_FLEX_MVRES
- mbmi->pb_mv_precision
-#else
- cm->features.allow_high_precision_mv
-#endif
- );
- mbmi->mv[0].as_mv.col = tmp_sub_mv.col + sub_mv_offset.col;
- mbmi->mv[0].as_mv.row = tmp_sub_mv.row + sub_mv_offset.row;
- }
-#endif // CONFIG_C071_SUBBLK_WARPMV
- // Check that the prediction is in range
- if (!av1_is_subpelmv_in_range(mv_limits, mbmi->mv[0].as_mv)) {
- continue;
- }
+#endif // CONFIG_WARP_REF_LIST
- // Regenerate model with this new MV
- //
- // Note: This should be very close to the neighbor's warp model,
- // but may be slightly different due to rounding. So it may be
- // invalid even if the neighbor's warp model is valid.
- // Because an exact copy will already have been tried using the
- // NEARMV mode, we can just detect an invalid model and bail out.
- //
- // TODO(rachelbarker): Is it worth trying to search anyway in
- // this case, in order to try to find a valid model?
- if (av1_extend_warp_model(neighbor_is_above, bsize,
- &mbmi->mv[0].as_mv, mi_row, mi_col,
- &neighbor_params, &mbmi->wm_params[0])) {
- continue;
- }
+ valid = av1_pick_warp_delta(
+ cm, xd, mbmi, mbmi_ext, &ms_params, &x->mode_costs
+#if CONFIG_WARP_REF_LIST
+ ,
+ mbmi_ext->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
+#endif // CONFIG_WARP_REF_LIST
+ );
+
+#if CONFIG_WARP_REF_LIST
+ }
+#endif // CONFIG_WARP_REF_LIST
+
+ if (!valid) {
+ continue;
}
- // Refine motion vector. The final choice of MV and warp model are
- // stored directly into `mbmi`
- av1_refine_mv_for_warp_extend(cm, xd, &ms_params, neighbor_is_above,
- bsize, &neighbor_params,
- cpi->sf.mv_sf.warp_search_method,
- cpi->sf.mv_sf.warp_search_iters);
-
// If we changed the MV, update costs
- if (mv0.as_int != mbmi->mv[0].as_int) {
+ if (mv0.as_int != mbmi->mv[0].as_int
+#if CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ || mbmi->warpmv_with_mvd_flag
+#endif // CONFIG_WARPMV && CONFIG_CWG_D067_IMPROVED_WARP
+ ) {
// Keep the refined MV and WM parameters.
#if CONFIG_FLEX_MVRES
tmp_rate_mv = av1_mv_bit_cost(
@@ -2249,129 +2368,316 @@
#endif
);
#else
+ tmp_rate_mv = av1_mv_bit_cost(
+ &mbmi->mv[0].as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
+ x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
+#endif
+
+ tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
+#if CONFIG_WARPMV
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ assert(mbmi->mode == NEWMV || mbmi->warpmv_with_mvd_flag);
+#else
+ assert(mbmi->mode == NEWMV);
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ assert(IMPLIES(mbmi->mode == WARPMV, rate_mv0 == 0));
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
+#endif // CONFIG_WARPMV
+ }
+#if CONFIG_C071_SUBBLK_WARPMV
+ assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row,
+ mi_col);
+#endif // CONFIG_C071_SUBBLK_WARPMV
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
+ av1_num_planes(cm) - 1);
+ } else if (mbmi->motion_mode == WARP_EXTEND) {
+#if CONFIG_FLEX_MVRES
+ if (mbmi->mode == NEWMV &&
+ mbmi->pb_mv_precision < MV_PRECISION_ONE_PEL) {
+ // Don't bother with warp modes for MV precisions >1px
+ continue;
+ }
+#endif
+
+ CANDIDATE_MV *neighbor =
+#if CONFIG_SEP_COMP_DRL
+ &mbmi_ext
+ ->ref_mv_stack[mbmi->ref_frame[0]][get_ref_mv_idx(mbmi, 0)];
+#else
+ &mbmi_ext->ref_mv_stack[mbmi->ref_frame[0]][mbmi->ref_mv_idx];
+#endif
+ POSITION base_pos = { 0, 0 };
+ if (!get_extend_base_pos(cm, xd, mbmi, neighbor->row_offset,
+ neighbor->col_offset, &base_pos)) {
+ continue;
+ }
+ const MB_MODE_INFO *neighbor_mi =
+ xd->mi[base_pos.row * xd->mi_stride + base_pos.col];
+
+ if (mbmi->mode == NEARMV) {
+ assert(is_warp_mode(neighbor_mi->motion_mode));
+ if (neighbor_mi->wm_params[0].invalid) {
+ // Skip invalid models
+ continue;
+ }
+ mbmi->wm_params[0] = neighbor_mi->wm_params[0];
+ } else {
+ assert(mbmi->mode == NEWMV);
+
+ bool neighbor_is_above =
+ xd->up_available && (base_pos.row == -1 && base_pos.col >= 0);
+
+ WarpedMotionParams neighbor_params;
+ av1_get_neighbor_warp_model(cm, xd, neighbor_mi, &neighbor_params);
+
+ const int_mv ref_mv = av1_get_ref_mv(x, 0);
+ SUBPEL_MOTION_SEARCH_PARAMS ms_params;
+ av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize,
+ &ref_mv.as_mv,
+#if CONFIG_FLEX_MVRES
+ mbmi->pb_mv_precision,
+#endif
+ NULL);
+ const SubpelMvLimits *mv_limits = &ms_params.mv_limits;
+
+ // Note: The warp filter is only able to accept small deviations
+ // from the identity transform, up to 1/4 pel of shift per
+ // pixel. Especially for small blocks, it is likely that the
+ // motion vector estimated by the newmv search will be too
+ // distant from the neighbor's motion vectors for the warp
+ // filter to be applied. However, we don't want to give up the
+ // benefits of a good initial MV in the cases where a suitable
+ // one has already been found.
+ //
+ // To get the best of both worlds, we run an initial test to see
+ // if the motion vector found by newmv search gives a valid
+ // motion model. If so, we use that as the starting point for
+ // refinement. Otherwise, we use the MV which is predicted by
+ // the neighbor's warp model
+ // TODO(rachelbarker): Do we need this logic?
+
+ // Backup initial motion vector and resulting warp params
+ int_mv mv0 = mbmi->mv[0];
+ WarpedMotionParams wm_params0;
+ if (!av1_extend_warp_model(neighbor_is_above, bsize,
+ &mbmi->mv[0].as_mv, mi_row, mi_col,
+ &neighbor_params, &wm_params0)) {
+ // NEWMV search produced a valid model
+ mbmi->wm_params[0] = wm_params0;
+ } else {
+ // NEWMV search did not produce a valid model, so fall back to
+ // starting with the motion vector predicted by the neighbor's
+ // warp model (if any)
+#if CONFIG_FLEX_MVRES
+ mbmi->mv[0] = get_warp_motion_vector(xd, &neighbor_params,
+ mbmi->pb_mv_precision, bsize,
+ mi_col, mi_row);
+#else
+ mbmi->mv[0] = get_warp_motion_vector(
+ xd, &neighbor_params, features->allow_high_precision_mv, bsize,
+ mi_col, mi_row, features->cur_frame_force_integer_mv);
+#endif
+#if CONFIG_C071_SUBBLK_WARPMV
+ if (
+#if CONFIG_FLEX_MVRES
+ mbmi->pb_mv_precision >= MV_PRECISION_HALF_PEL
+#else
+ !cm->features.allow_high_precision_mv
+#endif
+ ) {
+ FULLPEL_MV tmp_full_mv = get_fullmv_from_mv(&mbmi->mv[0].as_mv);
+ MV tmp_sub_mv = get_mv_from_fullmv(&tmp_full_mv);
+ MV sub_mv_offset = { 0, 0 };
+ get_phase_from_mv(ref_mv.as_mv, &sub_mv_offset,
+#if CONFIG_FLEX_MVRES
+ mbmi->pb_mv_precision
+#else
+ cm->features.allow_high_precision_mv
+#endif
+ );
+ mbmi->mv[0].as_mv.col = tmp_sub_mv.col + sub_mv_offset.col;
+ mbmi->mv[0].as_mv.row = tmp_sub_mv.row + sub_mv_offset.row;
+ }
+#endif // CONFIG_C071_SUBBLK_WARPMV
+ // Check that the prediction is in range
+ if (!av1_is_subpelmv_in_range(mv_limits, mbmi->mv[0].as_mv)) {
+ continue;
+ }
+
+ // Regenerate model with this new MV
+ //
+ // Note: This should be very close to the neighbor's warp
+ // model, but may be slightly different due to rounding. So it
+ // may be invalid even if the neighbor's warp model is valid.
+ // Because an exact copy will already have been tried using
+ // the NEARMV mode, we can just detect an invalid model and
+ // bail out.
+ //
+ // TODO(rachelbarker): Is it worth trying to search anyway in
+ // this case, in order to try to find a valid model?
+ if (av1_extend_warp_model(
+ neighbor_is_above, bsize, &mbmi->mv[0].as_mv, mi_row,
+ mi_col, &neighbor_params, &mbmi->wm_params[0])) {
+ continue;
+ }
+ }
+
+ // Refine motion vector. The final choice of MV and warp model
+ // are stored directly into `mbmi`
+ av1_refine_mv_for_warp_extend(cm, xd, &ms_params, neighbor_is_above,
+ bsize, &neighbor_params,
+ cpi->sf.mv_sf.warp_search_method,
+ cpi->sf.mv_sf.warp_search_iters);
+
+ // If we changed the MV, update costs
+ if (mv0.as_int != mbmi->mv[0].as_int) {
+ // Keep the refined MV and WM parameters.
+#if CONFIG_FLEX_MVRES
+ tmp_rate_mv = av1_mv_bit_cost(
+ &mbmi->mv[0].as_mv, &ref_mv.as_mv, mbmi->pb_mv_precision,
+ &x->mv_costs, MV_COST_WEIGHT
+#if CONFIG_ADAPTIVE_MVD
+ ,
+ ms_params.mv_cost_params.is_adaptive_mvd
+#endif
+ );
+#else
tmp_rate_mv = av1_mv_bit_cost(
&mbmi->mv[0].as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
#endif
- tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
- } else {
- // Restore the old MV and WM parameters.
- mbmi->mv[0] = mv0;
- mbmi->wm_params[0] = wm_params0;
+ tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
+ } else {
+ // Restore the old MV and WM parameters.
+ mbmi->mv[0] = mv0;
+ mbmi->wm_params[0] = wm_params0;
+ }
}
- }
#if CONFIG_C071_SUBBLK_WARPMV
- assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row,
- mi_col);
+ assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row,
+ mi_col);
#endif // CONFIG_C071_SUBBLK_WARPMV
// Build the warped predictor
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
+ av1_num_planes(cm) - 1);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
- }
+ }
- // If we are searching newmv and the mv is the same as refmv, skip the
- // current mode
- if (!av1_check_newmv_joint_nonzero(cm, x)) continue;
+ // If we are searching newmv and the mv is the same as refmv, skip
+ // the current mode
+ if (!av1_check_newmv_joint_nonzero(cm, x)) continue;
- // Update rd_stats for the current motion mode
- txfm_info->skip_txfm = 0;
- rd_stats->dist = 0;
- rd_stats->sse = 0;
- rd_stats->skip_txfm = 1;
- rd_stats->rate = tmp_rate2;
- const ModeCosts *mode_costs = &x->mode_costs;
- if (!is_warp_mode(mbmi->motion_mode)) rd_stats->rate += switchable_rate;
+ // Update rd_stats for the current motion mode
+ txfm_info->skip_txfm = 0;
+ rd_stats->dist = 0;
+ rd_stats->sse = 0;
+ rd_stats->skip_txfm = 1;
+ rd_stats->rate = tmp_rate2;
+ const ModeCosts *mode_costs = &x->mode_costs;
+ if (!is_warp_mode(mbmi->motion_mode)) rd_stats->rate += switchable_rate;
#if CONFIG_BAWP
- if (cm->features.enable_bawp && av1_allow_bawp(mbmi, mi_row, mi_col))
- rd_stats->rate += mode_costs->bawp_flg_cost[mbmi->bawp_flag == 1];
+ if (cm->features.enable_bawp && av1_allow_bawp(mbmi, mi_row, mi_col))
+ rd_stats->rate += mode_costs->bawp_flg_cost[mbmi->bawp_flag == 1];
#endif
#if CONFIG_EXTENDED_WARP_PREDICTION
- MOTION_MODE motion_mode = mbmi->motion_mode;
+ MOTION_MODE motion_mode = mbmi->motion_mode;
#if CONFIG_WARPMV
- bool continue_motion_mode_signaling = (mbmi->mode != WARPMV);
+ bool continue_motion_mode_signaling = (mbmi->mode != WARPMV);
#else
bool continue_motion_mode_signaling = true;
#endif // CONFIG_WARPMV
- if (continue_motion_mode_signaling &&
- allowed_motion_modes & (1 << INTERINTRA)) {
- rd_stats->rate +=
- mode_costs->interintra_cost[size_group_lookup[bsize]]
- [motion_mode == INTERINTRA];
- if (motion_mode == INTERINTRA) {
- // Note(rachelbarker): Costs for other interintra-related signaling
- // are already accounted for by `av1_handle_inter_intra_mode`
- continue_motion_mode_signaling = false;
- }
- }
-
- if (continue_motion_mode_signaling &&
- allowed_motion_modes & (1 << OBMC_CAUSAL)) {
- rd_stats->rate +=
- mode_costs->obmc_cost[bsize][motion_mode == OBMC_CAUSAL];
- if (motion_mode == OBMC_CAUSAL) {
- continue_motion_mode_signaling = false;
- }
- }
-
- if (continue_motion_mode_signaling &&
- allowed_motion_modes & (1 << WARP_EXTEND)) {
- const int ctx1 = av1_get_warp_extend_ctx1(xd, mbmi);
- const int ctx2 = av1_get_warp_extend_ctx2(xd, mbmi);
- rd_stats->rate +=
- mode_costs
- ->warp_extend_cost[ctx1][ctx2][motion_mode == WARP_EXTEND];
- if (motion_mode == WARP_EXTEND) {
- continue_motion_mode_signaling = false;
- }
- }
-
- if (continue_motion_mode_signaling &&
- allowed_motion_modes & (1 << WARPED_CAUSAL)) {
- rd_stats->rate +=
- mode_costs->warped_causal_cost[bsize][motion_mode == WARPED_CAUSAL];
- if (motion_mode == WARPED_CAUSAL) {
- continue_motion_mode_signaling = false;
- }
- }
-
- if (continue_motion_mode_signaling &&
- allowed_motion_modes & (1 << WARP_DELTA)) {
- rd_stats->rate +=
- mode_costs->warp_delta_cost[bsize][motion_mode == WARP_DELTA];
- }
-
-#if CONFIG_WARPMV
- if (mbmi->mode == WARPMV) {
- if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
+ if (continue_motion_mode_signaling &&
+ allowed_motion_modes & (1 << INTERINTRA)) {
rd_stats->rate +=
- mode_costs->warped_causal_warpmv_cost[bsize][motion_mode ==
- WARPED_CAUSAL];
- } else {
- assert(motion_mode == WARP_DELTA);
+ mode_costs->interintra_cost[size_group_lookup[bsize]]
+ [motion_mode == INTERINTRA];
+ if (motion_mode == INTERINTRA) {
+ // Note(rachelbarker): Costs for other interintra-related
+ // signaling are already accounted for by
+ // `av1_handle_inter_intra_mode`
+ continue_motion_mode_signaling = false;
+ }
}
- }
+
+ if (continue_motion_mode_signaling &&
+ allowed_motion_modes & (1 << OBMC_CAUSAL)) {
+ rd_stats->rate +=
+ mode_costs->obmc_cost[bsize][motion_mode == OBMC_CAUSAL];
+ if (motion_mode == OBMC_CAUSAL) {
+ continue_motion_mode_signaling = false;
+ }
+ }
+
+ if (continue_motion_mode_signaling &&
+ allowed_motion_modes & (1 << WARP_EXTEND)) {
+ const int ctx1 = av1_get_warp_extend_ctx1(xd, mbmi);
+ const int ctx2 = av1_get_warp_extend_ctx2(xd, mbmi);
+ rd_stats->rate +=
+ mode_costs
+ ->warp_extend_cost[ctx1][ctx2][motion_mode == WARP_EXTEND];
+ if (motion_mode == WARP_EXTEND) {
+ continue_motion_mode_signaling = false;
+ }
+ }
+
+ if (continue_motion_mode_signaling &&
+ allowed_motion_modes & (1 << WARPED_CAUSAL)) {
+ rd_stats->rate +=
+ mode_costs
+ ->warped_causal_cost[bsize][motion_mode == WARPED_CAUSAL];
+ if (motion_mode == WARPED_CAUSAL) {
+ continue_motion_mode_signaling = false;
+ }
+ }
+
+ if (continue_motion_mode_signaling &&
+ allowed_motion_modes & (1 << WARP_DELTA)) {
+ rd_stats->rate +=
+ mode_costs->warp_delta_cost[bsize][motion_mode == WARP_DELTA];
+ }
+
+#if CONFIG_WARPMV
+ if (mbmi->mode == WARPMV) {
+ if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
+ rd_stats->rate +=
+ mode_costs->warped_causal_warpmv_cost[bsize][motion_mode !=
+ WARP_DELTA];
+
+ } else {
+ assert(motion_mode == WARP_DELTA);
+ }
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ if (allow_warpmv_with_mvd_coding(cm, mbmi)) {
+ rd_stats->rate +=
+ mode_costs
+ ->warpmv_with_mvd_flag_cost[bsize]
+ [mbmi->warpmv_with_mvd_flag];
+ }
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+ }
#endif // CONFIG_WARPMV
- if (motion_mode == WARP_DELTA
+ if (motion_mode == WARP_DELTA
#if CONFIG_WARPMV
- || (motion_mode == WARPED_CAUSAL && mbmi->mode == WARPMV)
+ || ((motion_mode == WARPED_CAUSAL) && mbmi->mode == WARPMV)
#endif // CONFIG_WARPMV
- ) {
+ ) {
#if CONFIG_WARP_REF_LIST
- rd_stats->rate += get_warp_ref_idx_cost(mbmi, x);
+ rd_stats->rate += get_warp_ref_idx_cost(mbmi, x);
#endif // CONFIG_WARP_REF_LIST
- rd_stats->rate +=
- av1_cost_warp_delta(cm, xd, mbmi, mbmi_ext, mode_costs);
- // The following line is commented out to remove a spurious
- // static analysis warning. Uncomment when adding a new motion mode
- // continue_motion_mode_signaling = false;
- }
+ rd_stats->rate +=
+ av1_cost_warp_delta(cm, xd, mbmi, mbmi_ext, mode_costs);
+ // The following line is commented out to remove a spurious
+ // static analysis warning. Uncomment when adding a new motion
+ // mode continue_motion_mode_signaling = false;
+ }
#else
if (interintra_allowed) {
rd_stats->rate +=
@@ -2390,45 +2696,57 @@
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
- if (!do_tx_search) {
- // Avoid doing a transform search here to speed up the overall mode
- // search. It will be done later in the mode search if the current
- // motion mode seems promising.
- int64_t curr_sse = -1;
- int64_t sse_y = -1;
- int est_residue_cost = 0;
- int64_t est_dist = 0;
- int64_t est_rd = 0;
- if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1) {
- curr_sse = get_sse(cpi, x, &sse_y);
- const int has_est_rd = get_est_rate_dist(
- tile_data, bsize, curr_sse, &est_residue_cost, &est_dist);
- (void)has_est_rd;
- assert(has_est_rd);
- } else if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 2) {
- model_rd_sb_fn[MODELRD_TYPE_MOTION_MODE_RD](
- cpi, bsize, x, xd, 0, num_planes - 1, &est_residue_cost,
- &est_dist, NULL, &curr_sse, NULL, NULL, NULL);
- sse_y = x->pred_sse[COMPACT_INDEX0_NRS(xd->mi[0]->ref_frame[0])];
- }
- est_rd = RDCOST(x->rdmult, rd_stats->rate + est_residue_cost, est_dist);
- if (est_rd * 0.80 > *best_est_rd) {
- mbmi->ref_frame[1] = ref_frame_1;
- continue;
- }
- const int mode_rate = rd_stats->rate;
- rd_stats->rate += est_residue_cost;
- rd_stats->dist = est_dist;
- rd_stats->rdcost = est_rd;
- if (rd_stats->rdcost < *best_est_rd) {
- *best_est_rd = rd_stats->rdcost;
- assert(sse_y >= 0);
- ref_skip_rd[1] = cpi->sf.inter_sf.txfm_rd_gate_level
- ? RDCOST(x->rdmult, mode_rate, (sse_y << 4))
- : INT64_MAX;
- }
- if (cm->current_frame.reference_mode == SINGLE_REFERENCE) {
- if (!is_comp_pred) {
+ if (!do_tx_search) {
+ // Avoid doing a transform search here to speed up the overall
+ // mode search. It will be done later in the mode search if the
+ // current motion mode seems promising.
+ int64_t curr_sse = -1;
+ int64_t sse_y = -1;
+ int est_residue_cost = 0;
+ int64_t est_dist = 0;
+ int64_t est_rd = 0;
+ if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1) {
+ curr_sse = get_sse(cpi, x, &sse_y);
+ const int has_est_rd = get_est_rate_dist(
+ tile_data, bsize, curr_sse, &est_residue_cost, &est_dist);
+ (void)has_est_rd;
+ assert(has_est_rd);
+ } else if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 2) {
+ model_rd_sb_fn[MODELRD_TYPE_MOTION_MODE_RD](
+ cpi, bsize, x, xd, 0, num_planes - 1, &est_residue_cost,
+ &est_dist, NULL, &curr_sse, NULL, NULL, NULL);
+ sse_y = x->pred_sse[COMPACT_INDEX0_NRS(xd->mi[0]->ref_frame[0])];
+ }
+ est_rd =
+ RDCOST(x->rdmult, rd_stats->rate + est_residue_cost, est_dist);
+ if (est_rd * 0.80 > *best_est_rd) {
+ mbmi->ref_frame[1] = ref_frame_1;
+ continue;
+ }
+ const int mode_rate = rd_stats->rate;
+ rd_stats->rate += est_residue_cost;
+ rd_stats->dist = est_dist;
+ rd_stats->rdcost = est_rd;
+ if (rd_stats->rdcost < *best_est_rd) {
+ *best_est_rd = rd_stats->rdcost;
+ assert(sse_y >= 0);
+ ref_skip_rd[1] = cpi->sf.inter_sf.txfm_rd_gate_level
+ ? RDCOST(x->rdmult, mode_rate, (sse_y << 4))
+ : INT64_MAX;
+ }
+ if (cm->current_frame.reference_mode == SINGLE_REFERENCE) {
+ if (!is_comp_pred) {
+ assert(curr_sse >= 0);
+ inter_modes_info_push(inter_modes_info, mode_rate, curr_sse,
+ rd_stats->rdcost, rd_stats, rd_stats_y,
+ rd_stats_uv, mbmi
+#if CONFIG_C071_SUBBLK_WARPMV
+ ,
+ xd, cm
+#endif // CONFIG_C071_SUBBLK_WARPMV
+ );
+ }
+ } else {
assert(curr_sse >= 0);
inter_modes_info_push(inter_modes_info, mode_rate, curr_sse,
rd_stats->rdcost, rd_stats, rd_stats_y,
@@ -2439,95 +2757,95 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
);
}
+ mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
} else {
- assert(curr_sse >= 0);
- inter_modes_info_push(inter_modes_info, mode_rate, curr_sse,
- rd_stats->rdcost, rd_stats, rd_stats_y,
- rd_stats_uv, mbmi
-#if CONFIG_C071_SUBBLK_WARPMV
- ,
- xd, cm
-#endif // CONFIG_C071_SUBBLK_WARPMV
- );
- }
- mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
- } else {
- // Perform full transform search
- int64_t skip_rd = INT64_MAX;
- int64_t skip_rdy = INT64_MAX;
- if (cpi->sf.inter_sf.txfm_rd_gate_level) {
- // Check if the mode is good enough based on skip RD
- int64_t sse_y = INT64_MAX;
- int64_t curr_sse = get_sse(cpi, x, &sse_y);
- skip_rd = RDCOST(x->rdmult, rd_stats->rate, curr_sse);
- skip_rdy = RDCOST(x->rdmult, rd_stats->rate, (sse_y << 4));
- int eval_txfm =
- check_txfm_eval(x, bsize, ref_skip_rd[0], skip_rd,
- cpi->sf.inter_sf.txfm_rd_gate_level, 0);
- if (!eval_txfm) continue;
- }
-
- // Do transform search
- if (!av1_txfm_search(cpi, x, bsize, rd_stats, rd_stats_y, rd_stats_uv,
- rd_stats->rate, ref_best_rd)) {
- if (rd_stats_y->rate == INT_MAX && mode_index == 0) {
- return INT64_MAX;
+ // Perform full transform search
+ int64_t skip_rd = INT64_MAX;
+ int64_t skip_rdy = INT64_MAX;
+ if (cpi->sf.inter_sf.txfm_rd_gate_level) {
+ // Check if the mode is good enough based on skip RD
+ int64_t sse_y = INT64_MAX;
+ int64_t curr_sse = get_sse(cpi, x, &sse_y);
+ skip_rd = RDCOST(x->rdmult, rd_stats->rate, curr_sse);
+ skip_rdy = RDCOST(x->rdmult, rd_stats->rate, (sse_y << 4));
+ int eval_txfm =
+ check_txfm_eval(x, bsize, ref_skip_rd[0], skip_rd,
+ cpi->sf.inter_sf.txfm_rd_gate_level, 0);
+ if (!eval_txfm) continue;
}
- continue;
+
+ // Do transform search
+ if (!av1_txfm_search(cpi, x, bsize, rd_stats, rd_stats_y, rd_stats_uv,
+ rd_stats->rate, ref_best_rd)) {
+ if (rd_stats_y->rate == INT_MAX && mode_index == 0) {
+ return INT64_MAX;
+ }
+ continue;
+ }
+ const int64_t curr_rd =
+ RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
+
+ if (curr_rd < ref_best_rd) {
+ ref_best_rd = curr_rd;
+ ref_skip_rd[0] = skip_rd;
+ ref_skip_rd[1] = skip_rdy;
+ }
+ if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1) {
+ const int skip_ctx = av1_get_skip_txfm_context(xd);
+ inter_mode_data_push(
+ tile_data, mbmi->sb_type[PLANE_TYPE_Y], rd_stats->sse,
+ rd_stats->dist,
+ rd_stats_y->rate + rd_stats_uv->rate +
+ mode_costs->skip_txfm_cost[skip_ctx]
+ [mbmi->skip_txfm[xd->tree_type ==
+ CHROMA_PART]]);
+ }
}
- const int64_t curr_rd =
+
+ if (this_mode == GLOBALMV || this_mode == GLOBAL_GLOBALMV) {
+ if (is_nontrans_global_motion(xd, xd->mi[0])) {
+ mbmi->interp_fltr = av1_unswitchable_filter(interp_filter);
+ }
+ }
+
+ const int64_t tmp_rd =
RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
- if (curr_rd < ref_best_rd) {
- ref_best_rd = curr_rd;
- ref_skip_rd[0] = skip_rd;
- ref_skip_rd[1] = skip_rdy;
+ if (num_rd_check == 0) {
+#if CONFIG_SEP_COMP_DRL
+ args->simple_rd[this_mode][get_ref_mv_idx(mbmi, 0)]
+#else
+ args->simple_rd[this_mode][mbmi->ref_mv_idx]
+#endif
+ [COMPACT_INDEX0_NRS(mbmi->ref_frame[0])] = tmp_rd;
}
- if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1) {
- const int skip_ctx = av1_get_skip_txfm_context(xd);
- inter_mode_data_push(
- tile_data, mbmi->sb_type[PLANE_TYPE_Y], rd_stats->sse,
- rd_stats->dist,
- rd_stats_y->rate + rd_stats_uv->rate +
- mode_costs->skip_txfm_cost[skip_ctx]
- [mbmi->skip_txfm[xd->tree_type ==
- CHROMA_PART]]);
- }
- }
- if (this_mode == GLOBALMV || this_mode == GLOBAL_GLOBALMV) {
- if (is_nontrans_global_motion(xd, xd->mi[0])) {
- mbmi->interp_fltr = av1_unswitchable_filter(interp_filter);
- }
- }
-
- const int64_t tmp_rd = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
- if (mode_index == 0) {
- args->simple_rd[this_mode][mbmi->ref_mv_idx]
- [COMPACT_INDEX0_NRS(mbmi->ref_frame[0])] = tmp_rd;
- }
- if (mode_index == 0 || tmp_rd < best_rd) {
- // Update best_rd data if this is the best motion mode so far
- best_mbmi = *mbmi;
+ if (num_rd_check == 0 || tmp_rd < best_rd) {
+ // Update best_rd data if this is the best motion mode so far
+ best_mbmi = *mbmi;
#if CONFIG_C071_SUBBLK_WARPMV
- if (is_warp_mode(mbmi->motion_mode)) {
- store_submi(xd, cm, best_submi, bsize);
- }
+ if (is_warp_mode(mbmi->motion_mode)) {
+ store_submi(xd, cm, best_submi, bsize);
+ }
#endif // CONFIG_C071_SUBBLK_WARPMV
- best_rd = tmp_rd;
- best_rd_stats = *rd_stats;
- best_rd_stats_y = *rd_stats_y;
- best_rate_mv = tmp_rate_mv;
- if (num_planes > 1) best_rd_stats_uv = *rd_stats_uv;
- memcpy(best_blk_skip, txfm_info->blk_skip,
- sizeof(txfm_info->blk_skip[0]) * xd->height * xd->width);
- av1_copy_array(best_tx_type_map, xd->tx_type_map,
- xd->height * xd->width);
+ best_rd = tmp_rd;
+ best_rd_stats = *rd_stats;
+ best_rd_stats_y = *rd_stats_y;
+ best_rate_mv = tmp_rate_mv;
+ if (num_planes > 1) best_rd_stats_uv = *rd_stats_uv;
+ memcpy(best_blk_skip, txfm_info->blk_skip,
+ sizeof(txfm_info->blk_skip[0]) * xd->height * xd->width);
+ av1_copy_array(best_tx_type_map, xd->tx_type_map,
+ xd->height * xd->width);
#if CONFIG_CROSS_CHROMA_TX
- av1_copy_array(best_cctx_type_map, xd->cctx_type_map,
- xd->height * xd->width);
+ av1_copy_array(best_cctx_type_map, xd->cctx_type_map,
+ xd->height * xd->width);
#endif // CONFIG_CROSS_CHROMA_TX
- best_xskip_txfm = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
+ best_xskip_txfm = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
+ }
+ num_rd_check++;
+#if CONFIG_CWG_D067_IMPROVED_WARP
}
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#if CONFIG_WARP_REF_LIST
}
#endif // CONFIG_WARP_REF_LIST
@@ -2605,8 +2923,17 @@
static INLINE int check_repeat_ref_mv(const MB_MODE_INFO_EXT *mbmi_ext,
int ref_idx,
const MV_REFERENCE_FRAME *ref_frame,
+#if CONFIG_SEP_COMP_DRL
+ PREDICTION_MODE this_mode,
+#endif
PREDICTION_MODE single_mode) {
+#if CONFIG_SEP_COMP_DRL
+ const int8_t ref_frame_type = has_second_drl_by_mode(this_mode, ref_frame)
+ ? ref_frame[ref_idx]
+ : av1_ref_frame_type(ref_frame);
+#else
const uint8_t ref_frame_type = av1_ref_frame_type(ref_frame);
+#endif
#if CONFIG_TIP
if (is_tip_ref_frame(ref_frame_type)) return 0;
#endif // CONFIG_TIP
@@ -2632,7 +2959,11 @@
for (int ref_mv_idx = 0; ref_mv_idx < stack_size; ref_mv_idx++) {
int_mv this_mv;
+#if CONFIG_SEP_COMP_DRL
+ if (ref_idx == 0 || has_second_drl_by_mode(this_mode, ref_frame))
+#else
if (ref_idx == 0)
+#endif
this_mv = mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv;
else
this_mv = mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv;
@@ -2654,7 +2985,12 @@
this_mv->as_int = INVALID_MV;
} else if (single_mode == GLOBALMV) {
if (skip_repeated_ref_mv &&
+#if CONFIG_SEP_COMP_DRL
+ check_repeat_ref_mv(mbmi_ext, ref_idx, ref_frame, this_mode,
+ single_mode))
+#else
check_repeat_ref_mv(mbmi_ext, ref_idx, ref_frame, single_mode))
+#endif
return 0;
*this_mv = mbmi_ext->global_mvs[ref_frame[ref_idx]];
}
@@ -2668,7 +3004,13 @@
else {
assert(single_mode == NEARMV);
const int ref_mv_offset = ref_mv_idx;
+#if CONFIG_SEP_COMP_DRL
+ const int8_t ref_frame_type = has_second_drl_by_mode(this_mode, ref_frame)
+ ? ref_frame[ref_idx]
+ : av1_ref_frame_type(ref_frame);
+#else
const int8_t ref_frame_type = av1_ref_frame_type(ref_frame);
+#endif
if (ref_frame_type > NONE_FRAME &&
ref_mv_offset < mbmi_ext->ref_mv_count[ref_frame_type]) {
assert(ref_mv_offset >= 0);
@@ -2677,11 +3019,21 @@
mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_offset].this_mv;
} else {
*this_mv =
- mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_offset].comp_mv;
+#if CONFIG_SEP_COMP_DRL
+ has_second_drl_by_mode(this_mode, ref_frame)
+ ? mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_offset].this_mv
+ :
+#endif
+ mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_offset].comp_mv;
}
} else {
if (skip_repeated_ref_mv &&
+#if CONFIG_SEP_COMP_DRL
+ check_repeat_ref_mv(mbmi_ext, ref_idx, ref_frame, this_mode,
+ single_mode))
+#else
check_repeat_ref_mv(mbmi_ext, ref_idx, ref_frame, single_mode))
+#endif
return 0;
#if CONFIG_TIP
if (is_tip_ref_frame(ref_frame_type)) {
@@ -2705,14 +3057,24 @@
const MB_MODE_INFO *mbmi = xd->mi[0];
const int is_comp_pred = has_second_ref(mbmi);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) {
int ret = 1;
+#if CONFIG_SEP_COMP_DRL
+ assert(get_ref_mv_idx(mbmi, 0) < xd->skip_mvp_candidate_list.ref_mv_count);
+ assert(get_ref_mv_idx(mbmi, 1) == get_ref_mv_idx(mbmi, 0));
+#else
assert(mbmi->ref_mv_idx < xd->skip_mvp_candidate_list.ref_mv_count);
+#endif
int_mv this_mv;
this_mv.as_int = INVALID_MV;
this_mv =
+#if CONFIG_SEP_COMP_DRL
+ xd->skip_mvp_candidate_list.ref_mv_stack[get_ref_mv_idx(mbmi, 0)]
+ .this_mv;
+#else
xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx].this_mv;
+#endif
cur_mv[0] = this_mv;
#if !CONFIG_C071_SUBBLK_WARPMV
@@ -2726,7 +3088,12 @@
ret &= clamp_and_check_mv(cur_mv, this_mv, cm, x);
this_mv =
+#if CONFIG_SEP_COMP_DRL
+ xd->skip_mvp_candidate_list.ref_mv_stack[get_ref_mv_idx(mbmi, 1)]
+ .comp_mv;
+#else
xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx].comp_mv;
+#endif
cur_mv[1] = this_mv;
#if !CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
@@ -2740,23 +3107,39 @@
return ret;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
int ret = 1;
for (int i = 0; i < is_comp_pred + 1; ++i) {
int_mv this_mv;
this_mv.as_int = INVALID_MV;
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx = get_ref_mv_idx(mbmi, i);
+ ret = get_this_mv(&this_mv, this_mode, i, ref_mv_idx,
+#else
ret = get_this_mv(&this_mv, this_mode, i, mbmi->ref_mv_idx,
+#endif
skip_repeated_ref_mv, mbmi->ref_frame, x->mbmi_ext);
if (!ret) return 0;
const PREDICTION_MODE single_mode = get_single_mode(this_mode, i);
if (single_mode == NEWMV) {
const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mbmi))
+ cur_mv[i] =
+ x->mbmi_ext->ref_mv_stack[mbmi->ref_frame[i]][ref_mv_idx].this_mv;
+ else
+ cur_mv[i] =
+ (i == 0)
+ ? x->mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv
+ : x->mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv;
+#else
cur_mv[i] =
(i == 0) ? x->mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx]
.this_mv
: x->mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx]
.comp_mv;
+#endif
} else {
ret &= clamp_and_check_mv(cur_mv + i, this_mv, cm, x);
}
@@ -2774,13 +3157,38 @@
#if IMPROVED_AMVD
if (mbmi->mode == AMVDNEWMV) max_drl_bits = AOMMIN(max_drl_bits, 1);
#endif // IMPROVED_AMVD
+#if CONFIG_SEP_COMP_DRL
+ assert(get_ref_mv_idx(mbmi, 0) < max_drl_bits + 1);
+ assert(get_ref_mv_idx(mbmi, 1) < max_drl_bits + 1);
+#else
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
+#endif
if (!have_drl_index(mbmi->mode)) {
return 0;
}
int16_t mode_ctx_pristine =
av1_mode_context_pristine(mbmi_ext->mode_context, mbmi->ref_frame);
int cost = 0;
+#if CONFIG_SEP_COMP_DRL
+ for (int ref_idx = 0; ref_idx < 1 + has_second_drl(mbmi); ref_idx++) {
+ for (int idx = 0; idx < max_drl_bits; ++idx) {
+ int drl_ctx = av1_drl_ctx(mode_ctx_pristine);
+ int ref_mv_idx = get_ref_mv_idx(mbmi, ref_idx);
+ switch (idx) {
+ case 0:
+ cost += x->mode_costs.drl_mode_cost[0][drl_ctx][ref_mv_idx != idx];
+ break;
+ case 1:
+ cost += x->mode_costs.drl_mode_cost[1][drl_ctx][ref_mv_idx != idx];
+ break;
+ default:
+ cost += x->mode_costs.drl_mode_cost[2][drl_ctx][ref_mv_idx != idx];
+ break;
+ }
+ if (ref_mv_idx == idx) break;
+ }
+ }
+#else
for (int idx = 0; idx < max_drl_bits; ++idx) {
int drl_ctx = av1_drl_ctx(mode_ctx_pristine);
switch (idx) {
@@ -2799,18 +3207,40 @@
}
if (mbmi->ref_mv_idx == idx) return cost;
}
+#endif
return cost;
}
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
static INLINE int get_skip_drl_cost(int max_drl_bits, const MB_MODE_INFO *mbmi,
const MACROBLOCK *x) {
+#if CONFIG_SEP_COMP_DRL
+ assert(get_ref_mv_idx(mbmi, 0) < max_drl_bits + 1);
+#else
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
+#endif
assert(mbmi->skip_mode);
if (!have_drl_index(mbmi->mode)) {
return 0;
}
int cost = 0;
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx = get_ref_mv_idx(mbmi, 0);
+ for (int idx = 0; idx < max_drl_bits; ++idx) {
+ switch (idx) {
+ case 0:
+ cost += x->mode_costs.skip_drl_mode_cost[0][ref_mv_idx != idx];
+ break;
+ case 1:
+ cost += x->mode_costs.skip_drl_mode_cost[1][ref_mv_idx != idx];
+ break;
+ default:
+ cost += x->mode_costs.skip_drl_mode_cost[2][ref_mv_idx != idx];
+ break;
+ }
+ if (ref_mv_idx == idx) return cost;
+ }
+#else
for (int idx = 0; idx < max_drl_bits; ++idx) {
switch (idx) {
case 0:
@@ -2825,9 +3255,10 @@
}
if (mbmi->ref_mv_idx == idx) return cost;
}
+#endif
return cost;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
static INLINE int is_single_newmv_valid(const HandleInterModeArgs *const args,
const MB_MODE_INFO *const mbmi,
@@ -2837,8 +3268,13 @@
const MV_REFERENCE_FRAME ref = mbmi->ref_frame[ref_idx];
if (single_mode == NEWMV &&
#if CONFIG_FLEX_MVRES
+#if CONFIG_SEP_COMP_DRL
+ args->single_newmv_valid[mbmi->pb_mv_precision]
+ [get_ref_mv_idx(mbmi, ref_idx)][ref] == 0) {
+#else
args->single_newmv_valid[mbmi->pb_mv_precision][mbmi->ref_mv_idx]
[ref] == 0) {
+#endif
#else
args->single_newmv_valid[mbmi->ref_mv_idx][ref] == 0) {
#endif
@@ -2850,7 +3286,12 @@
static int get_drl_refmv_count(int max_drl_bits, const MACROBLOCK *const x,
const MV_REFERENCE_FRAME *ref_frame,
- PREDICTION_MODE mode) {
+ PREDICTION_MODE mode
+#if CONFIG_SEP_COMP_DRL
+ ,
+ int ref_idx
+#endif
+) {
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
int has_drl = have_drl_index(mode);
if (!has_drl) {
@@ -2861,17 +3302,25 @@
#endif // CONFIG_WARPMV
return 1;
}
+#if CONFIG_SEP_COMP_DRL
+ MB_MODE_INFO *mbmi = x->e_mbd.mi[0];
+ if (has_second_drl(mbmi)) {
+ return AOMMIN(max_drl_bits + 1, mbmi_ext->ref_mv_count[ref_frame[ref_idx]]);
+ }
+#endif
+
const int8_t ref_frame_type = av1_ref_frame_type(ref_frame);
+
int ref_mv_count =
ref_frame_type > NONE_FRAME ? mbmi_ext->ref_mv_count[ref_frame_type] : 0;
#if IMPROVED_AMVD
if (mode == AMVDNEWMV) ref_mv_count = AOMMIN(ref_mv_count, 2);
#endif // IMPROVED_AMVD
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (x->e_mbd.mi[0]->skip_mode)
ref_mv_count = mbmi_ext->skip_mvp_candidate_list.ref_mv_count;
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
return AOMMIN(max_drl_bits + 1, ref_mv_count);
}
@@ -2882,7 +3331,11 @@
const AV1_COMP *const cpi,
const RefFrameDistanceInfo *const ref_frame_dist_info, MACROBLOCK *x,
const HandleInterModeArgs *const args, int64_t ref_best_rd,
+#if CONFIG_SEP_COMP_DRL
+ int *ref_mv_idx) {
+#else
int ref_mv_idx) {
+#endif
(void)ref_frame_dist_info;
const AV1_COMMON *const cm = &cpi->common;
const SPEED_FEATURES *const sf = &cpi->sf;
@@ -2891,7 +3344,12 @@
const MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
const int8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
const int is_comp_pred = has_second_ref(mbmi);
+#if CONFIG_SEP_COMP_DRL
+ if (sf->inter_sf.reduce_inter_modes &&
+ (ref_mv_idx[0] > 0 || ref_mv_idx[1] > 0)) {
+#else
if (sf->inter_sf.reduce_inter_modes && ref_mv_idx > 0) {
+#endif
// NOTE: This section changes the stats.
int ranks[2][2], dir[2] = { -1, -1 };
if (mbmi->ref_frame[0] != INTRA_FRAME)
@@ -2900,9 +3358,21 @@
dir[1] = get_dir_rank(cm, mbmi->ref_frame[1], ranks[1]);
if ((dir[0] != -1 && ranks[0][dir[0]] > 3) ||
(dir[1] != -1 && ranks[1][dir[1]] > 2)) {
+#if CONFIG_SEP_COMP_DRL //????????? to be updated
+ if (has_second_drl(mbmi)) {
+ if (mbmi_ext->weight[mbmi->ref_frame[0]][ref_mv_idx[0]] <
+ REF_CAT_LEVEL &&
+ mbmi_ext->weight[mbmi->ref_frame[1]][ref_mv_idx[1]] < REF_CAT_LEVEL)
+ return true;
+ } else {
+ if (mbmi_ext->weight[ref_frame_type][ref_mv_idx[0]] < REF_CAT_LEVEL)
+ return true;
+ }
+#else
if (mbmi_ext->weight[ref_frame_type][ref_mv_idx] < REF_CAT_LEVEL) {
return true;
}
+#endif
}
// TODO(any): Experiment with reduce_inter_modes for compound prediction
if (sf->inter_sf.reduce_inter_modes >= 2 && !is_comp_pred &&
@@ -2911,14 +3381,32 @@
mbmi->ref_frame[0] != cm->ref_frames_info.future_refs[0]) &&
(cm->ref_frames_info.num_past_refs == 0 ||
mbmi->ref_frame[0] != cm->ref_frames_info.past_refs[0])) {
+#if CONFIG_SEP_COMP_DRL //????????? to be updated
+ if (has_second_drl(mbmi)) {
+ if (mbmi_ext->weight[mbmi->ref_frame[0]][ref_mv_idx[0]] <
+ REF_CAT_LEVEL &&
+ mbmi_ext->weight[mbmi->ref_frame[1]][ref_mv_idx[1]] <
+ REF_CAT_LEVEL)
+ return true;
+ } else {
+ if (mbmi_ext->weight[ref_frame_type][ref_mv_idx[0]] < REF_CAT_LEVEL)
+ return true;
+ }
+#else
if (mbmi_ext->weight[ref_frame_type][ref_mv_idx] < REF_CAT_LEVEL) {
return true;
}
+#endif
}
}
}
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = ref_mv_idx[0];
+ mbmi->ref_mv_idx[1] = ref_mv_idx[1];
+#else
mbmi->ref_mv_idx = ref_mv_idx;
+#endif
if (is_comp_pred && (!is_single_newmv_valid(args, mbmi, mbmi->mode))) {
return true;
}
@@ -2936,7 +3424,11 @@
static int64_t simple_translation_pred_rd(AV1_COMP *const cpi, MACROBLOCK *x,
RD_STATS *rd_stats,
HandleInterModeArgs *args,
+#if CONFIG_SEP_COMP_DRL
+ int *ref_mv_idx,
+#else
int ref_mv_idx,
+#endif
inter_mode_info *mode_info,
int64_t ref_best_rd, BLOCK_SIZE bsize
#if CONFIG_FLEX_MVRES
@@ -2968,16 +3460,27 @@
mbmi->num_proj_ref = 0;
mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = ref_mv_idx[0];
+ mbmi->ref_mv_idx[1] = ref_mv_idx[1];
+ int ref_mv_idx_type = av1_ref_mv_idx_type(mbmi, ref_mv_idx);
+#else
mbmi->ref_mv_idx = ref_mv_idx;
+#endif
rd_stats->rate += args->ref_frame_cost + args->single_comp_cost;
#if CONFIG_FLEX_MVRES
rd_stats->rate += flex_mv_cost;
#endif
+
const int drl_cost =
get_drl_cost(cpi->common.features.max_drl_bits, mbmi, mbmi_ext, x);
rd_stats->rate += drl_cost;
+#if CONFIG_SEP_COMP_DRL
+ mode_info[ref_mv_idx_type].drl_cost = drl_cost;
+#else
mode_info[ref_mv_idx].drl_cost = drl_cost;
+#endif
int_mv cur_mv[2];
if (!build_cur_mv(cur_mv, mbmi->mode, cm, x, 0)) {
@@ -3018,6 +3521,9 @@
}
mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
mbmi->num_proj_ref = 0;
if (is_comp_pred) {
// Only compound_average
@@ -3032,6 +3538,7 @@
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
+
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, bsize,
AOM_PLANE_Y, AOM_PLANE_Y);
int est_rate;
@@ -3060,36 +3567,74 @@
if (is_pb_mv_precision_active(cm, mbmi, bsize) &&
(mbmi->pb_mv_precision < mbmi->max_mv_precision) &&
+#if CONFIG_SEP_COMP_DRL
+ (mbmi->ref_mv_idx[0] > 0 || mbmi->ref_mv_idx[1] > 0)) {
+#else
mbmi->ref_mv_idx > 0) {
+#endif
const int is_comp_pred = has_second_ref(mbmi);
const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
int_mv this_refmv[2];
this_refmv[0].as_int = 0;
this_refmv[1].as_int = 0;
for (int i = 0; i < is_comp_pred + 1; ++i) {
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mbmi))
+ this_refmv[i] =
+ mbmi_ext->ref_mv_stack[mbmi->ref_frame[i]][mbmi->ref_mv_idx[i]]
+ .this_mv;
+ else
+ this_refmv[i] =
+ (i == 0)
+ ? mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx[0]]
+ .this_mv
+ : mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx[0]]
+ .comp_mv;
+#else
this_refmv[i] =
(i == 0)
? mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].this_mv
: mbmi_ext->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx]
.comp_mv;
+#endif
#if CONFIG_C071_SUBBLK_WARPMV
if (mbmi->pb_mv_precision < MV_PRECISION_HALF_PEL)
#endif // CONFIG_C071_SUBBLK_WARPMV
lower_mv_precision(&this_refmv[i].as_mv, mbmi->pb_mv_precision);
}
+#if CONFIG_SEP_COMP_DRL
+ const uint8_t ref_mv_idx_type = av1_ref_mv_idx_type(mbmi, mbmi->ref_mv_idx);
+ for (int prev_ref_mv_idx = 0; prev_ref_mv_idx < ref_mv_idx_type;
+ prev_ref_mv_idx++) {
+#else
for (int prev_ref_mv_idx = 0; prev_ref_mv_idx < mbmi->ref_mv_idx;
prev_ref_mv_idx++) {
+#endif
int_mv prev_refmv[2];
prev_refmv[0].as_int = INVALID_MV;
prev_refmv[1].as_int = INVALID_MV;
for (int i = 0; i < is_comp_pred + 1; ++i) {
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(mbmi)) {
+ int temp_idx[2];
+ av1_set_ref_mv_idx(temp_idx, prev_ref_mv_idx);
+ prev_refmv[i] =
+ mbmi_ext->ref_mv_stack[mbmi->ref_frame[i]][temp_idx[i]].this_mv;
+ } else
+ prev_refmv[i] =
+ (i == 0) ? mbmi_ext->ref_mv_stack[ref_frame_type][prev_ref_mv_idx]
+ .this_mv
+ : mbmi_ext->ref_mv_stack[ref_frame_type][prev_ref_mv_idx]
+ .comp_mv;
+#else
prev_refmv[i] =
(i == 0) ? mbmi_ext->ref_mv_stack[ref_frame_type][prev_ref_mv_idx]
.this_mv
: mbmi_ext->ref_mv_stack[ref_frame_type][prev_ref_mv_idx]
.comp_mv;
+#endif
#if CONFIG_C071_SUBBLK_WARPMV
if (mbmi->pb_mv_precision < MV_PRECISION_HALF_PEL)
#endif // CONFIG_C071_SUBBLK_WARPMV
@@ -3115,7 +3660,12 @@
RD_STATS *rd_stats,
HandleInterModeArgs *const args,
int64_t ref_best_rd, inter_mode_info *mode_info,
- BLOCK_SIZE bsize, const int ref_set
+ BLOCK_SIZE bsize,
+#if CONFIG_SEP_COMP_DRL
+ const int *ref_set
+#else
+ const int ref_set
+#endif
#if CONFIG_FLEX_MVRES
,
const int flex_mv_cost
@@ -3133,22 +3683,36 @@
// Only search indices if they have some chance of being good.
int good_indices = 0;
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx[2];
+ for (ref_mv_idx[1] = 0; ref_mv_idx[1] < ref_set[1]; ++ref_mv_idx[1]) {
+ for (ref_mv_idx[0] = 0; ref_mv_idx[0] < ref_set[0]; ++ref_mv_idx[0]) {
+ int i = av1_ref_mv_idx_type(mbmi, ref_mv_idx);
+ if (ref_mv_idx_early_breakout(cpi, &cpi->ref_frame_dist_info, x, args,
+ ref_best_rd, ref_mv_idx)) {
+ continue;
+ }
+#else
for (int i = 0; i < ref_set; ++i) {
if (ref_mv_idx_early_breakout(cpi, &cpi->ref_frame_dist_info, x, args,
ref_best_rd, i)) {
continue;
}
- mask_set_bit(&good_indices, i);
+#endif
+ mask_set_bit(&good_indices, i);
+ }
+#if CONFIG_SEP_COMP_DRL
}
+#endif
// Always have at least one motion vector searched.
if (!good_indices) {
good_indices = 0x1;
}
- // Only prune in NEARMV mode, if the speed feature is set, and the block size
- // is large enough. If these conditions are not met, return all good indices
- // found so far.
+ // Only prune in NEARMV mode, if the speed feature is set, and the block
+ // size is large enough. If these conditions are not met, return all good
+ // indices found so far.
if (!cpi->sf.inter_sf.prune_mode_search_simple_translation)
return good_indices;
if (!have_nearmv_in_inter_mode(this_mode)) return good_indices;
@@ -3162,6 +3726,29 @@
}
// Calculate the RD cost for the motion vectors using simple translation.
+#if CONFIG_SEP_COMP_DRL
+ int64_t idx_rdcost[MAX_REF_MV_SEARCH * MAX_REF_MV_SEARCH];
+ for (int i = 0; i < MAX_REF_MV_SEARCH * MAX_REF_MV_SEARCH; i++)
+ idx_rdcost[i] = INT64_MAX;
+
+ for (ref_mv_idx[1] = 0; ref_mv_idx[1] < ref_set[1]; ++ref_mv_idx[1]) {
+ for (ref_mv_idx[0] = 0; ref_mv_idx[0] < ref_set[0]; ++ref_mv_idx[0]) {
+ int i = av1_ref_mv_idx_type(mbmi, ref_mv_idx);
+
+ // If this index is bad, ignore it.
+ if (!mask_check_bit(good_indices, i)) {
+ continue;
+ }
+ idx_rdcost[i] = simple_translation_pred_rd(
+ cpi, x, rd_stats, args, ref_mv_idx, mode_info, ref_best_rd, bsize
+#if CONFIG_FLEX_MVRES
+ ,
+ flex_mv_cost
+#endif
+ );
+ }
+ }
+#else
int64_t idx_rdcost[MAX_REF_MV_SEARCH];
for (int i = 0; i < MAX_REF_MV_SEARCH; i++) idx_rdcost[i] = INT64_MAX;
for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ++ref_mv_idx) {
@@ -3177,6 +3764,7 @@
#endif
);
}
+#endif
// Find the index with the best RD cost.
int best_idx = 0;
// Find the 2nd best motion vector and search motion vectors within a
@@ -3203,13 +3791,22 @@
// best RD, skip it. Note that the cutoff is derived experimentally.
const double ref_dth = 5;
int result = 0;
+#if CONFIG_SEP_COMP_DRL
+ for (ref_mv_idx[1] = 0; ref_mv_idx[1] < ref_set[1]; ++ref_mv_idx[1]) {
+ for (ref_mv_idx[0] = 0; ref_mv_idx[0] < ref_set[0]; ++ref_mv_idx[0]) {
+ int i = av1_ref_mv_idx_type(mbmi, ref_mv_idx);
+#else
for (int i = 0; i < ref_set; ++i) {
- if (mask_check_bit(good_indices, i) &&
- (1.0 * idx_rdcost[i]) < idx_rdcost[best_idx] * dth &&
- (1.0 * idx_rdcost[i]) < ref_best_rd * ref_dth) {
- mask_set_bit(&result, i);
+#endif
+ if (mask_check_bit(good_indices, i) &&
+ (1.0 * idx_rdcost[i]) < idx_rdcost[best_idx] * dth &&
+ (1.0 * idx_rdcost[i]) < ref_best_rd * ref_dth) {
+ mask_set_bit(&result, i);
+ }
}
+#if CONFIG_SEP_COMP_DRL
}
+#endif
return result;
}
@@ -3408,8 +4005,8 @@
// Thresholds used for pruning:
// Lower value indicates aggressive pruning and higher value indicates
// conservative pruning which is set based on ref_mv_idx and speed feature.
- // 'prune_index' 0, 1, 2 corresponds to ref_mv indices 0, 1 and 2. prune_index
- // 3 corresponds to GLOBALMV/GLOBAL_GLOBALMV
+ // 'prune_index' 0, 1, 2 corresponds to ref_mv indices 0, 1 and 2.
+ // prune_index 3 corresponds to GLOBALMV/GLOBAL_GLOBALMV
static const int tpl_inter_mode_prune_mul_factor[2][MAX_REF_MV_SEARCH + 1] = {
{ 3, 3, 3, 2, 2, 2, 2, 2 }, { 3, 2, 2, 2, 2, 2, 2, 2 }
};
@@ -3458,9 +4055,18 @@
RD_STATS *best_rd_stats_uv, inter_mode_info *mode_info,
HandleInterModeArgs *args, int drl_cost, const MV_REFERENCE_FRAME *refs,
int_mv *cur_mv, int64_t *best_rd, const BUFFER_SET orig_dst,
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx[2]) {
+#else
int ref_mv_idx) {
+#endif
// This feature only works for NEWMV when a previous mv has been searched
+#if CONFIG_SEP_COMP_DRL
+ if (this_mode != NEWMV || (ref_mv_idx[0] == 0 && ref_mv_idx[1] == 0))
+ return 0;
+#else
if (this_mode != NEWMV || ref_mv_idx == 0) return 0;
+#endif
MACROBLOCKD *xd = &x->e_mbd;
const AV1_COMMON *cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
@@ -3478,105 +4084,154 @@
int skip = 0;
int this_rate_mv = 0;
int i;
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx_type = av1_ref_mv_idx_type(mbmi, ref_mv_idx);
+ int temp_mv_idx[2];
+ for (temp_mv_idx[1] = 0; temp_mv_idx[1] <= ref_mv_idx[1]; ++temp_mv_idx[1]) {
+ for (temp_mv_idx[0] = 0; temp_mv_idx[0] <= ref_mv_idx[0];
+ ++temp_mv_idx[0]) {
+ if (temp_mv_idx[0] == ref_mv_idx[0] && temp_mv_idx[1] == ref_mv_idx[1])
+ continue;
+ i = av1_ref_mv_idx_type(mbmi, temp_mv_idx);
+#else
for (i = 0; i < ref_mv_idx; ++i) {
- // Check if the motion search result same as previous results
+#endif
+ // Check if the motion search result same as previous results
#if CONFIG_FLEX_MVRES
- if (cur_mv[0].as_int ==
- args->single_newmv[pb_mv_precision][i][refs[0]].as_int &&
- args->single_newmv_valid[pb_mv_precision][i][refs[0]]) {
+#if CONFIG_SEP_COMP_DRL
+ if (cur_mv[0].as_int ==
+ args->single_newmv[pb_mv_precision][temp_mv_idx[0]][refs[0]]
+ .as_int &&
+ args->single_newmv_valid[pb_mv_precision][temp_mv_idx[0]][refs[0]]) {
+#else
+ if (cur_mv[0].as_int ==
+ args->single_newmv[pb_mv_precision][i][refs[0]].as_int &&
+ args->single_newmv_valid[pb_mv_precision][i][refs[0]]) {
+#endif
#else
if (cur_mv[0].as_int == args->single_newmv[i][refs[0]].as_int &&
args->single_newmv_valid[i][refs[0]]) {
#endif
- // If the compared mode has no valid rd, it is unlikely this
- // mode will be the best mode
- if (mode_info[i].rd == INT64_MAX) {
- skip = 1;
- break;
- }
- // Compare the cost difference including drl cost and mv cost
- if (mode_info[i].mv.as_int != INVALID_MV) {
- const int compare_cost = mode_info[i].rate_mv + mode_info[i].drl_cost;
- const int_mv ref_mv = av1_get_ref_mv(x, 0);
+ // If the compared mode has no valid rd, it is unlikely this
+ // mode will be the best mode
+ if (mode_info[i].rd == INT64_MAX) {
+ skip = 1;
+ break;
+ }
+ // Compare the cost difference including drl cost and mv cost
+ if (mode_info[i].mv.as_int != INVALID_MV) {
+ const int compare_cost = mode_info[i].rate_mv + mode_info[i].drl_cost;
+ const int_mv ref_mv = av1_get_ref_mv(x, 0);
#if CONFIG_FLEX_MVRES
- // Check if this MV is within mv_limit
- SubpelMvLimits mv_limits;
- av1_set_subpel_mv_search_range(&mv_limits, &x->mv_limits, &ref_mv.as_mv,
- pb_mv_precision);
- if (!av1_is_subpelmv_in_range(&mv_limits, mode_info[i].mv.as_mv))
- continue;
+ // Check if this MV is within mv_limit
+ SubpelMvLimits mv_limits;
+ av1_set_subpel_mv_search_range(&mv_limits, &x->mv_limits,
+ &ref_mv.as_mv, pb_mv_precision);
+ if (!av1_is_subpelmv_in_range(&mv_limits, mode_info[i].mv.as_mv))
+ continue;
- this_rate_mv =
- av1_mv_bit_cost(&mode_info[i].mv.as_mv, &ref_mv.as_mv,
- pb_mv_precision, &x->mv_costs, MV_COST_WEIGHT
+ this_rate_mv =
+ av1_mv_bit_cost(&mode_info[i].mv.as_mv, &ref_mv.as_mv,
+ pb_mv_precision, &x->mv_costs, MV_COST_WEIGHT
#if CONFIG_ADAPTIVE_MVD
- ,
- is_adaptive_mvd
+ ,
+ is_adaptive_mvd
#endif
- );
+ );
#else
this_rate_mv = av1_mv_bit_cost(
&mode_info[i].mv.as_mv, &ref_mv.as_mv, x->mv_costs.nmv_joint_cost,
x->mv_costs.mv_cost_stack, MV_COST_WEIGHT);
#endif
- const int this_cost = this_rate_mv + drl_cost;
+ const int this_cost = this_rate_mv + drl_cost;
- if (compare_cost <= this_cost) {
- // Skip this mode if it is more expensive as the previous result
- // for this MV
- skip = 1;
- break;
- } else {
- // If the cost is less than current best result, make this
- // the best and update corresponding variables unless the
- // best_mv is the same as ref_mv. In this case we skip and
- // rely on NEAR(EST)MV instead
+ if (compare_cost <= this_cost) {
+ // Skip this mode if it is more expensive as the previous result
+ // for this MV
+ skip = 1;
+ break;
+ } else {
+ // If the cost is less than current best result, make this
+ // the best and update corresponding variables unless the
+ // best_mv is the same as ref_mv. In this case we skip and
+ // rely on NEAR(EST)MV instead
+#if CONFIG_SEP_COMP_DRL
+ if (av1_ref_mv_idx_type(best_mbmi, best_mbmi->ref_mv_idx) == i &&
+#else
if (best_mbmi->ref_mv_idx == i &&
- best_mbmi->mv[0].as_int != ref_mv.as_int
+#endif
+ best_mbmi->mv[0].as_int != ref_mv.as_int
#if CONFIG_FLEX_MVRES
- && best_mbmi->pb_mv_precision == pb_mv_precision
+ && best_mbmi->pb_mv_precision == pb_mv_precision
#endif
#if CONFIG_BAWP
- && best_mbmi->bawp_flag == bawp_flag
+ && best_mbmi->bawp_flag == bawp_flag
#endif
- ) {
- assert(*best_rd != INT64_MAX);
- assert(best_mbmi->mv[0].as_int == mode_info[i].mv.as_int);
+ ) {
+ assert(*best_rd != INT64_MAX);
+ assert(best_mbmi->mv[0].as_int == mode_info[i].mv.as_int);
+#if CONFIG_SEP_COMP_DRL
+ best_mbmi->ref_mv_idx[0] = ref_mv_idx[0];
+ best_mbmi->ref_mv_idx[1] = ref_mv_idx[1];
+#else
best_mbmi->ref_mv_idx = ref_mv_idx;
- motion_mode_cand->rate_mv = this_rate_mv;
- best_rd_stats->rate += this_cost - compare_cost;
- *best_rd =
- RDCOST(x->rdmult, best_rd_stats->rate, best_rd_stats->dist);
- // We also need to update mode_info here because we are setting
- // (ref_)best_rd here. So we will not be able to search the same
- // mode again with the current configuration.
+#endif
+ motion_mode_cand->rate_mv = this_rate_mv;
+ best_rd_stats->rate += this_cost - compare_cost;
+ *best_rd =
+ RDCOST(x->rdmult, best_rd_stats->rate, best_rd_stats->dist);
+ // We also need to update mode_info here because we are setting
+ // (ref_)best_rd here. So we will not be able to search the same
+ // mode again with the current configuration.
+#if CONFIG_SEP_COMP_DRL
+ mode_info[ref_mv_idx_type].mv.as_int = best_mbmi->mv[0].as_int;
+ mode_info[ref_mv_idx_type].rate_mv = this_rate_mv;
+ mode_info[ref_mv_idx_type].rd = *best_rd;
+#else
mode_info[ref_mv_idx].mv.as_int = best_mbmi->mv[0].as_int;
mode_info[ref_mv_idx].rate_mv = this_rate_mv;
mode_info[ref_mv_idx].rd = *best_rd;
- if (*best_rd < *ref_best_rd) *ref_best_rd = *best_rd;
- break;
+#endif
+ if (*best_rd < *ref_best_rd) *ref_best_rd = *best_rd;
+ break;
+ }
}
}
}
}
+#if CONFIG_SEP_COMP_DRL
}
+#endif
if (skip) {
// Collect mode stats for multiwinner mode processing
store_winner_mode_stats(
&cpi->common, x, best_mbmi, best_rd_stats, best_rd_stats_y,
best_rd_stats_uv, refs, best_mbmi->mode, NULL, bsize, *best_rd,
cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
+#if CONFIG_SEP_COMP_DRL
+ args->modelled_rd[this_mode][ref_mv_idx[0]][refs[0]] =
+ args->modelled_rd[this_mode][i][refs[0]];
+ args->simple_rd[this_mode][ref_mv_idx[0]][refs[0]] =
+ args->simple_rd[this_mode][i][refs[0]];
+ mode_info[ref_mv_idx_type].rd = mode_info[i].rd;
+ mode_info[ref_mv_idx_type].rate_mv = this_rate_mv;
+#else
args->modelled_rd[this_mode][ref_mv_idx][refs[0]] =
args->modelled_rd[this_mode][i][refs[0]];
args->simple_rd[this_mode][ref_mv_idx][refs[0]] =
args->simple_rd[this_mode][i][refs[0]];
mode_info[ref_mv_idx].rd = mode_info[i].rd;
mode_info[ref_mv_idx].rate_mv = this_rate_mv;
+#endif
#if CONFIG_FLEX_MVRES
int_mv temp_mv = mode_info[i].mv;
clamp_mv_in_range(x, &temp_mv, 0, pb_mv_precision);
+#if CONFIG_SEP_COMP_DRL
+ mode_info[ref_mv_idx_type].mv.as_int = temp_mv.as_int;
+#else
mode_info[ref_mv_idx].mv.as_int = temp_mv.as_int;
+#endif
#else
mode_info[ref_mv_idx].mv.as_int = mode_info[i].mv.as_int;
#endif
@@ -3589,7 +4244,8 @@
/*!\brief High level function to select parameters for compound mode.
*
* \ingroup inter_mode_search
- * The main search functionality is done in the call to av1_compound_type_rd().
+ * The main search functionality is done in the call to
+ av1_compound_type_rd().
*
* \param[in] cpi Top-level encoder structure.
* \param[in] x Pointer to struct holding all the data for
@@ -3611,27 +4267,38 @@
* search.
* \param[in,out] orig_dst A prediction buffer to hold a computed
* prediction. This will eventually hold the
- * final prediction, and the tmp_dst info will
+ * final prediction, and the tmp_dst info
+ will
* be copied here.
* \param[in] tmp_dst A temporary prediction buffer to hold a
* computed prediction.
- * \param[in,out] rate_mv The rate associated with the motion vectors.
- * This will be modified if a motion search is
+ * \param[in,out] rate_mv The rate associated with the motion
+ vectors.
+ * This will be modified if a motion search
+ is
* done in the motion mode search.
* \param[in,out] rd_stats Struct to keep track of the overall RD
* information.
- * \param[in,out] skip_rd An array of length 2 where skip_rd[0] is the
+ * \param[in,out] skip_rd An array of length 2 where skip_rd[0] is
+ the
* best total RD for a skip mode so far, and
- * skip_rd[1] is the best RD for a skip mode so
- * far in luma. This is used as a speed feature
- * to skip the transform search if the computed
+ * skip_rd[1] is the best RD for a skip mode
+ so
+ * far in luma. This is used as a speed
+ feature
+ * to skip the transform search if the
+ computed
* skip RD for the current mode is not better
* than the best skip_rd so far.
- * \param[in,out] skip_build_pred Indicates whether or not to build the inter
- * predictor. If this is 0, the inter predictor
- * has already been built and thus we can avoid
+ * \param[in,out] skip_build_pred Indicates whether or not to build the
+ inter
+ * predictor. If this is 0, the inter
+ predictor
+ * has already been built and thus we can
+ avoid
* repeating computation.
- * \return Returns 1 if this mode is worse than one already seen and 0 if it is
+ * \return Returns 1 if this mode is worse than one already seen and 0 if it
+ is
* a viable candidate.
*/
static int process_compound_inter_mode(
@@ -3643,11 +4310,22 @@
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *mbmi = xd->mi[0];
const AV1_COMMON *cm = &cpi->common;
- const int masked_compound_used = is_any_masked_compound_used(bsize) &&
- cm->seq_params.enable_masked_compound;
+ const int masked_compound_used =
+ is_any_masked_compound_used(bsize) &&
+ cm->seq_params.enable_masked_compound
+#if CONFIG_REFINEMV
+ && (!mbmi->refinemv_flag || !switchable_refinemv_flag(cm, mbmi))
+#endif // CONFIG_REFINEMV
+ ;
int mode_search_mask =
(1 << COMPOUND_AVERAGE) | (1 << COMPOUND_WEDGE) | (1 << COMPOUND_DIFFWTD);
+#if CONFIG_CWP
+ if (get_cwp_idx(mbmi) != CWP_EQUAL) {
+ mode_search_mask = (1 << COMPOUND_AVERAGE);
+ }
+#endif // CONFIG_CWP
+
const int num_planes = av1_num_planes(cm);
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
@@ -3697,7 +4375,11 @@
// Speed feature to prune out MVs that are similar to previous MVs if they
// don't achieve the best RD advantage.
static int prune_ref_mv_idx_search(const FeatureFlags *const features,
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx[2], int best_ref_mv_idx[2],
+#else
int ref_mv_idx, int best_ref_mv_idx,
+#endif
int_mv save_mv[MAX_REF_MV_SEARCH - 1][2],
MB_MODE_INFO *mbmi, int pruning_factor) {
(void)features;
@@ -3706,6 +4388,40 @@
const int thr = (1 + is_comp_pred) << (pruning_factor + 1);
// Skip the evaluation if an MV match is found.
+#if CONFIG_SEP_COMP_DRL
+ if (ref_mv_idx[0] > 0 || ref_mv_idx[1] > 0) {
+ int idx[2];
+ for (idx[1] = 0; idx[1] <= ref_mv_idx[1]; ++idx[1]) {
+ for (idx[0] = 0; idx[0] <= ref_mv_idx[0]; ++idx[0]) {
+ if (idx[1] == ref_mv_idx[1] && idx[0] == ref_mv_idx[0]) continue;
+
+ int idx_type = av1_ref_mv_idx_type(mbmi, idx);
+
+ if (save_mv[idx_type][0].as_int == INVALID_MV) continue;
+
+ int mv_diff = 0;
+ for (i = 0; i < 1 + is_comp_pred; ++i) {
+ mv_diff +=
+ abs(save_mv[idx_type][i].as_mv.row - mbmi->mv[i].as_mv.row) +
+ abs(save_mv[idx_type][i].as_mv.col - mbmi->mv[i].as_mv.col);
+ }
+
+ // If this mode is not the best one, and current MV is similar to
+ // previous stored MV, terminate this ref_mv_idx evaluation.
+ if ((best_ref_mv_idx[0] == -1 || best_ref_mv_idx[1] == -1) &&
+ mv_diff <= thr)
+ return 1;
+ }
+ }
+ }
+
+ if (ref_mv_idx[0] < features->max_drl_bits &&
+ ref_mv_idx[1] < features->max_drl_bits) {
+ for (i = 0; i < is_comp_pred + 1; ++i)
+ save_mv[av1_ref_mv_idx_type(mbmi, ref_mv_idx)][i].as_int =
+ mbmi->mv[i].as_int;
+ }
+#else
if (ref_mv_idx > 0) {
for (int idx = 0; idx < ref_mv_idx; ++idx) {
if (save_mv[idx][0].as_int == INVALID_MV) continue;
@@ -3726,16 +4442,120 @@
for (i = 0; i < is_comp_pred + 1; ++i)
save_mv[ref_mv_idx][i].as_int = mbmi->mv[i].as_int;
}
-
+#endif
return 0;
}
+#if CONFIG_CWP
+// Calculate SSE when using compound weighted prediction
+uint64_t av1_cwp_sse_from_residuals_c(const int16_t *r1, const int16_t *d,
+ const int8_t *m, int N) {
+ uint64_t csse = 0;
+ int i;
+
+ for (i = 0; i < N; i++) {
+ int32_t t = (1 << WEDGE_WEIGHT_BITS) * r1[i] + m[i] * d[i];
+ t = clamp(t, INT16_MIN, INT16_MAX);
+ csse += t * t;
+ }
+ return ROUND_POWER_OF_TWO(csse, 2 * WEDGE_WEIGHT_BITS);
+}
+
+// Select a subset of cwp weighting factors
+static void set_cwp_search_mask(const AV1_COMP *const cpi, MACROBLOCK *const x,
+ const BLOCK_SIZE bsize, uint16_t *const p0,
+ uint16_t *const p1, int16_t *residual1,
+ int16_t *diff10, int stride, int *mask) {
+ MACROBLOCKD *xd = &x->e_mbd;
+ const int bw = block_size_wide[bsize];
+ const int bh = block_size_high[bsize];
+ // get inter predictors to use for masked compound modes
+ av1_build_inter_predictor_single_buf_y(xd, bsize, 0, p0, stride);
+ av1_build_inter_predictor_single_buf_y(xd, bsize, 1, p1, stride);
+ const struct buf_2d *const src = &x->plane[0].src;
+
+ aom_highbd_subtract_block(bh, bw, residual1, bw, src->buf, src->stride, p1,
+ bw, xd->bd);
+ aom_highbd_subtract_block(bh, bw, diff10, bw, p1, bw, p0, bw, xd->bd);
+
+ MB_MODE_INFO *const mbmi = xd->mi[0];
+
+ const AV1_COMMON *const cm = &cpi->common;
+ const int same_side = is_ref_frame_same_side(cm, mbmi);
+
+ const int N = 1 << num_pels_log2_lookup[bsize];
+ int rate;
+ int64_t dist;
+ int cwp_index;
+ int64_t best_rd = INT64_MAX;
+ const int bd_round = (xd->bd - 8) * 2;
+
+ const int8_t *tmp_mask;
+ int rate_cwp_idx;
+
+ int idx_list[MAX_CWP_NUM];
+ int64_t cost_list[MAX_CWP_NUM];
+
+ for (int i = 0; i < MAX_CWP_NUM; i++) {
+ idx_list[i] = i;
+ cost_list[i] = INT64_MAX;
+ }
+
+ for (cwp_index = 0; cwp_index < MAX_CWP_NUM; cwp_index++) {
+ if (cwp_index == 0) continue;
+
+ tmp_mask = av1_get_cwp_mask(same_side, cwp_index);
+
+ // compute rd for mask
+ uint64_t sse = av1_cwp_sse_from_residuals_c(residual1, diff10, tmp_mask, N);
+ sse = ROUND_POWER_OF_TWO(sse, bd_round);
+
+ model_rd_sse_fn[MODELRD_TYPE_MASKED_COMPOUND](cpi, x, bsize, 0, sse, N,
+ &rate, &dist);
+ int8_t cur_cwp = cwp_weighting_factor[same_side][cwp_index];
+ rate_cwp_idx = av1_get_cwp_idx_cost(cur_cwp, cm, x);
+ const int64_t rd0 = RDCOST(x->rdmult, rate + rate_cwp_idx, dist);
+ if (rd0 < best_rd) {
+ best_rd = rd0;
+ }
+
+ cost_list[cwp_index] = rd0;
+ }
+
+ // sort cwp in ascending order
+ for (int i = 0; i < MAX_CWP_NUM - 1; i++) {
+ for (int j = 0; j < (MAX_CWP_NUM - 1) - i; j++) {
+ if (cost_list[j] > cost_list[j + 1]) {
+ int64_t tmp_cost = cost_list[j];
+ cost_list[j] = cost_list[j + 1];
+ cost_list[j + 1] = tmp_cost;
+
+ int tmp_idx = idx_list[j];
+ idx_list[j] = idx_list[j + 1];
+ idx_list[j + 1] = tmp_idx;
+ }
+ }
+ }
+
+ int th = 2;
+ for (int i = 0; i < MAX_CWP_NUM; i++) {
+ if (i < th) {
+ mask[idx_list[i]] = 1;
+ } else {
+ mask[idx_list[i]] = 0;
+ }
+ }
+
+ return;
+}
+#endif // CONFIG_CWP
+
/*!\brief AV1 inter mode RD computation
*
* \ingroup inter_mode_search
- * Do the RD search for a given inter mode and compute all information relevant
- * to the input mode. It will compute the best MV,
- * compound parameters (if the mode is a compound mode) and interpolation filter
+ * Do the RD search for a given inter mode and compute all information
+ * relevant to the input mode. It will compute the best MV, compound
+ * parameters (if the mode is a compound mode) and interpolation filter
* parameters.
*
* \param[in] cpi Top-level encoder structure.
@@ -3769,31 +4589,25 @@
* \param[in] do_tx_search Parameter to indicate whether or not to do
* a full transform search. This will compute
* an estimated RD for the modes without the
- * transform search and later perform the full
- * transform search on the best candidates.
- * \param[in,out] inter_modes_info InterModesInfo struct to hold inter mode
- * information to perform a full transform
- * search only on winning candidates searched
- * with an estimate for transform coding RD.
- * \param[in,out] motion_mode_cand A motion_mode_candidate struct to store
- * motion mode information used in a speed
- * feature to search motion modes other than
- * SIMPLE_TRANSLATION only on winning
- * candidates.
- * \param[in,out] skip_rd A length 2 array, where skip_rd[0] is the
- * best total RD for a skip mode so far, and
- * skip_rd[1] is the best RD for a skip mode so
- * far in luma. This is used as a speed feature
- * to skip the transform search if the computed
- * skip RD for the current mode is not better
- * than the best skip_rd so far.
- * \param[in] best_ref_mode Parameter to indicate the best mode so far.
- * This is used as a speed feature to skip the
+ * transform search and later perform the
+ * full transform search on the best candidates. \param[in,out]
+ * inter_modes_info InterModesInfo struct to hold inter mode information to
+ * perform a full transform search only on winning candidates searched with an
+ * estimate for transform coding RD. \param[in,out] motion_mode_cand A
+ * motion_mode_candidate struct to store motion mode information used in a
+ * speed feature to search motion modes other than SIMPLE_TRANSLATION only on
+ * winning candidates. \param[in,out] skip_rd A length 2 array,
+ * where skip_rd[0] is the best total RD for a skip mode so far, and
+ * skip_rd[1] is the best RD for a skip mode
+ * so far in luma. This is used as a speed feature to skip the transform
+ * search if the computed skip RD for the current mode is not better than the
+ * best skip_rd so far. \param[in] best_ref_mode Parameter to indicate
+ * the best mode so far. This is used as a speed feature to skip the
* additional scaling factors for joint mvd
* coding mode.
* \param[in] inter_cost_info_from_tpl A PruneInfoFromTpl struct used to
- * narrow down the search based on data
- * collected in the TPL model.
+ * narrow down the search based on
+ * data collected in the TPL model.
*
* \return The RD cost for the mode being searched.
*/
@@ -3861,12 +4675,21 @@
int64_t newmv_ret_val = INT64_MAX;
#if CONFIG_FLEX_MVRES
#if CONFIG_BAWP
+#if CONFIG_SEP_COMP_DRL
+ inter_mode_info mode_info[2][NUM_MV_PRECISIONS]
+ [MAX_REF_MV_SEARCH * MAX_REF_MV_SEARCH];
+#else
inter_mode_info mode_info[2][NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH];
+#endif
// initialize mode_info
for (int bawp = 0; bawp < 2; bawp++) {
for (int prec = 0; prec < NUM_MV_PRECISIONS; prec++) {
+#if CONFIG_SEP_COMP_DRL
+ for (int idx = 0; idx < MAX_REF_MV_SEARCH * MAX_REF_MV_SEARCH; idx++) {
+#else
for (int idx = 0; idx < MAX_REF_MV_SEARCH; idx++) {
+#endif
mode_info[bawp][prec][idx].full_search_mv.as_int = INVALID_MV;
mode_info[bawp][prec][idx].mv.as_int = INVALID_MV;
mode_info[bawp][prec][idx].rd = INT64_MAX;
@@ -3921,6 +4744,10 @@
#if CONFIG_BAWP
mbmi->bawp_flag = 0;
#endif
+
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
// Do not prune the mode based on inter cost from tpl if the current ref
// frame is the winner ref in neighbouring blocks.
int ref_match_found_in_above_nb = 0;
@@ -3935,20 +4762,50 @@
// First, perform a simple translation search for each of the indices. If
// an index performs well, it will be fully searched in the main loop
// of this function.
+#if CONFIG_SEP_COMP_DRL
+ int ref_set[2];
+ ref_set[0] = get_drl_refmv_count(cm->features.max_drl_bits, x,
+ mbmi->ref_frame, this_mode, 0);
+ ref_set[1] = 1;
+ if (has_second_drl(mbmi)) {
+ ref_set[1] = get_drl_refmv_count(cm->features.max_drl_bits, x,
+ mbmi->ref_frame, this_mode, 1);
+
+ if (mbmi->mode == NEAR_NEWMV) {
+ ref_set[0] = AOMMIN(ref_set[0], SEP_COMP_DRL_SIZE);
+ ref_set[1] = AOMMIN(ref_set[1], SEP_COMP_DRL_SIZE);
+ } else {
+ assert(mbmi->mode == NEAR_NEARMV);
+ }
+ }
+#else
const int ref_set = get_drl_refmv_count(cm->features.max_drl_bits, x,
mbmi->ref_frame, this_mode);
+#endif
#if CONFIG_WARPMV
+#if CONFIG_SEP_COMP_DRL
+ assert(IMPLIES(this_mode == WARPMV, ref_set[0] == 1));
+#else
assert(IMPLIES(this_mode == WARPMV, ref_set == 1));
+#endif
#endif // CONFIG_WARPMV
// Save MV results from first 2 ref_mv_idx.
#if CONFIG_FLEX_MVRES
+#if CONFIG_SEP_COMP_DRL
+ int_mv save_mv[NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH * MAX_REF_MV_SEARCH][2];
+#else
int_mv save_mv[NUM_MV_PRECISIONS][MAX_REF_MV_SEARCH - 1][2];
+#endif
#else
int_mv save_mv[MAX_REF_MV_SEARCH - 1][2];
#endif
+#if CONFIG_SEP_COMP_DRL
+ int best_ref_mv_idx[2] = { -1, -1 };
+#else
int best_ref_mv_idx = -1;
+#endif
const int16_t mode_ctx =
av1_mode_context_analyzer(mbmi_ext->mode_context, mbmi->ref_frame);
#if !CONFIG_FLEX_MVRES
@@ -3986,7 +4843,11 @@
#if CONFIG_FLEX_MVRES
for (int pb_mv_precision = mbmi->max_mv_precision;
pb_mv_precision >= MV_PRECISION_8_PEL; pb_mv_precision--) {
+#if CONFIG_SEP_COMP_DRL
+ for (i = 0; i < MAX_REF_MV_SEARCH * MAX_REF_MV_SEARCH - 1; ++i) {
+#else
for (i = 0; i < MAX_REF_MV_SEARCH - 1; ++i) {
+#endif
save_mv[pb_mv_precision][i][0].as_int = INVALID_MV;
save_mv[pb_mv_precision][i][1].as_int = INVALID_MV;
}
@@ -4029,7 +4890,6 @@
idx_mask[0][pb_mv_precision] = ref_mv_idx_to_search(
cpi, x, rd_stats, args, ref_best_rd, mode_info[0][pb_mv_precision],
bsize, ref_set, flex_mv_cost[pb_mv_precision]);
-
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
mbmi->bawp_flag = 1;
@@ -4079,6 +4939,10 @@
// 4.) Build the inter predictor
// 5.) Pick the motion mode
// 6.) Update stats if best so far
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag =
+ 0; // initialize to 0; later on the default value is assigned
+#endif // CONFIG_REFINEMV
#if CONFIG_IMPROVED_JMVD
const int jmvd_scaling_factor_num =
is_joint_mvd_coding_mode(mbmi->mode) ? JOINT_NEWMV_SCALE_FACTOR_CNT : 1;
@@ -4096,270 +4960,412 @@
continue;
}
#endif // CONFIG_IMPROVED_JMVD
- for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ++ref_mv_idx) {
-#if CONFIG_IMPROVED_JMVD
- // apply early termination method to jmvd scaling factors
- if (cpi->sf.inter_sf.early_terminate_jmvd_scale_factor) {
- if (scale_index > 0 && ref_mv_idx > 0 &&
- best_mbmi.jmvd_scale_mode == 0 && best_mbmi.ref_mv_idx < ref_mv_idx)
- continue;
- }
-#endif // CONFIG_IMPROVED_JMVD
-#if CONFIG_FLEX_MVRES
-
- // Initialize compound mode data
- mbmi->interinter_comp.type = COMPOUND_AVERAGE;
- mbmi->comp_group_idx = 0;
- if (mbmi->ref_frame[1] == INTRA_FRAME) mbmi->ref_frame[1] = NONE_FRAME;
-
- mbmi->num_proj_ref = 0;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->ref_mv_idx = ref_mv_idx;
- set_mv_precision(mbmi, mbmi->max_mv_precision);
- if (
-#if CONFIG_WARPMV
- mbmi->mode != WARPMV &&
-#endif // CONFIG_WARPMV
- prune_modes_based_on_tpl && !ref_match_found_in_above_nb &&
- !ref_match_found_in_left_nb && (ref_best_rd != INT64_MAX)) {
- // Skip mode if TPL model indicates it will not be beneficial.
- if (prune_modes_based_on_tpl_stats(
- &cm->features, inter_cost_info_from_tpl, refs, ref_mv_idx,
- this_mode, cpi->sf.inter_sf.prune_inter_modes_based_on_tpl))
- continue;
- }
- const int drl_cost =
- get_drl_cost(cm->features.max_drl_bits, mbmi, mbmi_ext, x);
-
-#if CONFIG_FLEX_MVRES
- MvSubpelPrecision best_precision_so_far = mbmi->max_mv_precision;
- int64_t best_precision_rd_so_far = INT64_MAX;
- set_precision_set(cm, xd, mbmi, bsize, ref_mv_idx);
- set_most_probable_mv_precision(cm, mbmi, bsize);
- const PRECISION_SET *precision_def =
- &av1_mv_precision_sets[mbmi->mb_precision_set];
- for (int precision_dx = precision_def->num_precisions - 1;
- precision_dx >= 0; precision_dx--) {
- MvSubpelPrecision pb_mv_precision =
- precision_def->precision[precision_dx];
- mbmi->pb_mv_precision = pb_mv_precision;
- if (!is_pb_mv_precision_active(cm, mbmi, bsize) &&
- (pb_mv_precision != mbmi->max_mv_precision)) {
- continue;
- }
- assert(pb_mv_precision <= mbmi->max_mv_precision);
+#if CONFIG_CWP
+ int best_cwp_idx = CWP_EQUAL;
+ int64_t best_cwp_cost = INT64_MAX;
+#endif // CONFIG_CWP
+#if CONFIG_SEP_COMP_DRL
+ int ref_mv_idx[2];
+ for (ref_mv_idx[1] = 0; ref_mv_idx[1] < ref_set[1]; ++ref_mv_idx[1]) {
+ for (ref_mv_idx[0] = 0; ref_mv_idx[0] < ref_set[0]; ++ref_mv_idx[0]) {
+#else
+ for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ++ref_mv_idx) {
+#endif // CONFIG_SEP_COMP_DRL
#if CONFIG_IMPROVED_JMVD
// apply early termination method to jmvd scaling factors
if (cpi->sf.inter_sf.early_terminate_jmvd_scale_factor) {
- if (scale_index > 0 && (!is_inter_compound_mode(best_ref_mode)) &&
- mbmi->pb_mv_precision <= MV_PRECISION_HALF_PEL &&
+#if CONFIG_SEP_COMP_DRL
+ if (scale_index > 0 && (ref_mv_idx[0] > 0 || ref_mv_idx[1] > 0) &&
best_mbmi.jmvd_scale_mode == 0 &&
- best_mbmi.pb_mv_precision > MV_PRECISION_HALF_PEL)
+ (best_mbmi.ref_mv_idx[0] < ref_mv_idx[0] ||
+ best_mbmi.ref_mv_idx[1] < ref_mv_idx[1]))
+#else
+ if (scale_index > 0 && ref_mv_idx > 0 &&
+ best_mbmi.jmvd_scale_mode == 0 &&
+ best_mbmi.ref_mv_idx < ref_mv_idx)
+#endif // CONFIG_SEP_COMP_DRL
continue;
}
#endif // CONFIG_IMPROVED_JMVD
-
- if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
- if (cpi->sf.flexmv_sf.terminate_early_4_pel_precision &&
- pb_mv_precision < MV_PRECISION_FOUR_PEL &&
- best_precision_so_far >= MV_PRECISION_QTR_PEL)
- continue;
- if (mbmi->ref_mv_idx) {
- if (cpi->sf.flexmv_sf.do_not_search_8_pel_precision &&
- mbmi->pb_mv_precision == MV_PRECISION_8_PEL)
- continue;
-
- if (cpi->sf.flexmv_sf.do_not_search_4_pel_precision &&
- mbmi->pb_mv_precision == MV_PRECISION_FOUR_PEL)
- continue;
- }
- }
-
-#endif
-#endif
-
-#if !CONFIG_FLEX_MVRES && !CONFIG_BAWP
- mode_info[ref_mv_idx].full_search_mv.as_int = INVALID_MV;
- mode_info[ref_mv_idx].mv.as_int = INVALID_MV;
- mode_info[ref_mv_idx].rd = INT64_MAX;
- if (
-#if CONFIG_WARPMV
- mbmi->mode != WARPMV &&
-#endif // CONFIG_WARPMV
-
- !mask_check_bit(idx_mask, ref_mv_idx)) {
- // MV did not perform well in simple translation search. Skip it.
- continue;
- }
-#endif // !CONFIG_FLEX_MVRES && !CONFIG_BAWP
-#if !CONFIG_FLEX_MVRES
- if (prune_modes_based_on_tpl && !ref_match_found_in_above_nb &&
- !ref_match_found_in_left_nb && (ref_best_rd != INT64_MAX)) {
- // Skip mode if TPL model indicates it will not be beneficial.
- if (prune_modes_based_on_tpl_stats(
- &cm->features, inter_cost_info_from_tpl, refs, ref_mv_idx,
- this_mode, cpi->sf.inter_sf.prune_inter_modes_based_on_tpl))
- continue;
- }
- av1_init_rd_stats(rd_stats);
- // Initialize compound mode data
- mbmi->interinter_comp.type = COMPOUND_AVERAGE;
- mbmi->comp_group_idx = 0;
- if (mbmi->ref_frame[1] == INTRA_FRAME) mbmi->ref_frame[1] = NONE_FRAME;
-
- mbmi->num_proj_ref = 0;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->ref_mv_idx = ref_mv_idx;
- // Compute cost for signalling this DRL index
- rd_stats->rate = base_rate;
- const int drl_cost =
- get_drl_cost(cm->features.max_drl_bits, mbmi, mbmi_ext, x);
-
- rd_stats->rate += drl_cost;
-#if CONFIG_BAWP
- mode_info[0][ref_mv_idx].drl_cost = drl_cost;
- mode_info[1][ref_mv_idx].drl_cost = drl_cost;
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+ const int same_side = is_ref_frame_same_side(cm, mbmi);
+ int cwp_loop_num = cm->features.enable_cwp ? MAX_CWP_NUM : 1;
+#if CONFIG_SEP_COMP_DRL
+ if (best_cwp_idx == CWP_EQUAL &&
+ (ref_mv_idx[0] > 0 || ref_mv_idx[1] > 0))
+ cwp_loop_num = 1;
#else
- mode_info[ref_mv_idx].drl_cost = drl_cost;
-#endif
-#endif //! CONFIG_FLEX_MVRES
+ if (best_cwp_idx == CWP_EQUAL && ref_mv_idx > 0) cwp_loop_num = 1;
+#endif // CONFIG_SEP_COMP_DRL
- int rs = 0;
- int compmode_interinter_cost = 0;
- int_mv cur_mv[2];
- // TODO(Cherma): Extend this speed feature to support compound mode
- int skip_repeated_ref_mv =
- is_comp_pred ? 0 : cpi->sf.inter_sf.skip_repeated_ref_mv;
- // Generate the current mv according to the prediction mode
- if (
-#if CONFIG_WARPMV
- mbmi->mode != WARPMV &&
-#endif // CONFIG_WARPMV
- !build_cur_mv(cur_mv, this_mode, cm, x, skip_repeated_ref_mv)) {
- continue;
- }
-#if CONFIG_WARPMV
- // For WARPMV mode we will build MV in the later stage
- // Currently initialize to 0
- if (mbmi->mode == WARPMV) {
- cur_mv[0].as_int = 0;
- cur_mv[1].as_int = 0;
- assert(ref_mv_idx == 0);
- }
-#endif // CONFIG_WARPMV
+ int cwp_search_mask[MAX_CWP_NUM] = { 0 };
+ av1_zero(cwp_search_mask);
+ // Loop all supported weighting factors for CWP
+ for (int cwp_search_idx = 0; cwp_search_idx < cwp_loop_num;
+ cwp_search_idx++) {
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[1] = ref_mv_idx[1];
+ mbmi->ref_mv_idx[0] = ref_mv_idx[0];
+#else
+ mbmi->ref_mv_idx = ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+ mbmi->comp_group_idx = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->cwp_idx = cwp_weighting_factor[same_side][cwp_search_idx];
+
+ if (mbmi->cwp_idx != CWP_EQUAL) {
+ if (!is_cwp_allowed(mbmi)) break;
+ if (cwp_search_mask[cwp_search_idx] == 0) {
+ continue;
+ }
+ }
+ if (mbmi->cwp_idx == -1) {
+ break;
+ }
+#endif // CONFIG_CWP
#if CONFIG_FLEX_MVRES
-#if !CONFIG_BAWP
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].full_search_mv.as_int =
- INVALID_MV;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int = INVALID_MV;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = INT64_MAX;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].drl_cost = drl_cost;
- if (
-#if CONFIG_WARPMV
- mbmi->mode != WARPMV &&
-#endif // CONFIG_WARPMV
- !mask_check_bit(idx_mask[mbmi->pb_mv_precision], ref_mv_idx)) {
- // MV did not perform well in simple translation search. Skip it.
- continue;
- }
-#endif
- if (
-#if CONFIG_WARPMV
- mbmi->mode != WARPMV &&
-#endif // CONFIG_WARPMV
- cpi->sf.flexmv_sf.skip_similar_ref_mv &&
- skip_similar_ref_mv(cpi, x, bsize)) {
- continue;
- }
+ // Initialize compound mode data
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+ mbmi->comp_group_idx = 0;
+ if (mbmi->ref_frame[1] == INTRA_FRAME)
+ mbmi->ref_frame[1] = NONE_FRAME;
-#if CONFIG_WARPMV
- assert(IMPLIES(mbmi->mode == WARPMV,
- mbmi->pb_mv_precision == mbmi->max_mv_precision));
-#endif // CONFIG_WARPMV
-#endif
-
-#if CONFIG_BAWP
- int_mv bawp_off_mv[2];
- int64_t bawp_off_newmv_ret_val = 0;
- for (i = 0; i < is_comp_pred + 1; ++i) {
- bawp_off_mv[i].as_int = cur_mv[i].as_int;
- }
- int bawp_eanbled = cm->features.enable_bawp &&
- av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col);
- for (int bawp_flag = 0; bawp_flag <= bawp_eanbled; bawp_flag++) {
- mbmi->bawp_flag = bawp_flag;
-
-#if CONFIG_FLEX_MVRES
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
- .full_search_mv.as_int = INVALID_MV;
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].mv.as_int =
- INVALID_MV;
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].rd =
- INT64_MAX;
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].drl_cost =
- drl_cost;
-
+ mbmi->num_proj_ref = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[1] = ref_mv_idx[1];
+ mbmi->ref_mv_idx[0] = ref_mv_idx[0];
+ int ref_mv_idx_type = av1_ref_mv_idx_type(mbmi, ref_mv_idx);
+#else
+ mbmi->ref_mv_idx = ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
+ set_mv_precision(mbmi, mbmi->max_mv_precision);
if (
#if CONFIG_WARPMV
mbmi->mode != WARPMV &&
#endif // CONFIG_WARPMV
- !mask_check_bit(idx_mask[bawp_flag][mbmi->pb_mv_precision],
- ref_mv_idx)) {
- // MV did not perform well in simple translation search. Skip it.
- continue;
- }
+ prune_modes_based_on_tpl && !ref_match_found_in_above_nb &&
+ !ref_match_found_in_left_nb && (ref_best_rd != INT64_MAX)) {
+ // Skip mode if TPL model indicates it will not be beneficial.
+ if (prune_modes_based_on_tpl_stats(
+#if CONFIG_SEP_COMP_DRL
+ &cm->features, inter_cost_info_from_tpl, refs,
+ ref_mv_idx[0],
#else
- mode_info[bawp_flag][ref_mv_idx].full_search_mv.as_int = INVALID_MV;
- mode_info[bawp_flag][ref_mv_idx].mv.as_int = INVALID_MV;
- mode_info[bawp_flag][ref_mv_idx].rd = INT64_MAX;
- mode_info[bawp_flag][ref_mv_idx].drl_cost = drl_cost;
+ &cm->features, inter_cost_info_from_tpl, refs, ref_mv_idx,
+#endif // CONFIG_SEP_COMP_DRL
+ this_mode, cpi->sf.inter_sf.prune_inter_modes_based_on_tpl))
+ continue;
+ }
+ const int drl_cost =
+ get_drl_cost(cm->features.max_drl_bits, mbmi, mbmi_ext, x);
- if (
-#if CONFIG_WARPMV
- mbmi->mode != WARPMV &&
-#endif // CONFIG_WARPMV
- !mask_check_bit(idx_mask[bawp_flag], ref_mv_idx)) {
- // MV did not perform well in simple translation search. Skip it.
- continue;
- }
-#endif // CONFIG_FLEX_MVRES
- if (mbmi->bawp_flag == 1) {
- for (i = 0; i < is_comp_pred + 1; ++i) {
- mbmi->mv[i].as_int = bawp_off_mv[i].as_int;
- cur_mv[i].as_int = bawp_off_mv[i].as_int;
+#if CONFIG_FLEX_MVRES
+ MvSubpelPrecision best_precision_so_far = mbmi->max_mv_precision;
+ int64_t best_precision_rd_so_far = INT64_MAX;
+ set_precision_set(cm, xd, mbmi, bsize, ref_mv_idx);
+ set_most_probable_mv_precision(cm, mbmi, bsize);
+ const PRECISION_SET *precision_def =
+ &av1_mv_precision_sets[mbmi->mb_precision_set];
+ for (int precision_dx = precision_def->num_precisions - 1;
+ precision_dx >= 0; precision_dx--) {
+ MvSubpelPrecision pb_mv_precision =
+ precision_def->precision[precision_dx];
+ mbmi->pb_mv_precision = pb_mv_precision;
+ if (!is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ (pb_mv_precision != mbmi->max_mv_precision)) {
+ continue;
+ }
+ assert(pb_mv_precision <= mbmi->max_mv_precision);
+#if CONFIG_IMPROVED_JMVD
+ // apply early termination method to jmvd scaling factors
+ if (cpi->sf.inter_sf.early_terminate_jmvd_scale_factor) {
+ if (scale_index > 0 && (!is_inter_compound_mode(best_ref_mode)) &&
+ mbmi->pb_mv_precision <= MV_PRECISION_HALF_PEL &&
+ best_mbmi.jmvd_scale_mode == 0 &&
+ best_mbmi.pb_mv_precision > MV_PRECISION_HALF_PEL)
+ continue;
+ }
+#endif // CONFIG_IMPROVED_JMVD
+
+ if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
+ if (cpi->sf.flexmv_sf.terminate_early_4_pel_precision &&
+ pb_mv_precision < MV_PRECISION_FOUR_PEL &&
+ best_precision_so_far >= MV_PRECISION_QTR_PEL)
+ continue;
+#if CONFIG_SEP_COMP_DRL
+ if (mbmi->ref_mv_idx[0] || mbmi->ref_mv_idx[1]) {
+#else
+ if (mbmi->ref_mv_idx) {
+#endif // CONFIG_SEP_COMP_DRL
+ if (cpi->sf.flexmv_sf.do_not_search_8_pel_precision &&
+ mbmi->pb_mv_precision == MV_PRECISION_8_PEL)
+ continue;
+
+ if (cpi->sf.flexmv_sf.do_not_search_4_pel_precision &&
+ mbmi->pb_mv_precision == MV_PRECISION_FOUR_PEL)
+ continue;
+ }
}
-#if CONFIG_FLEX_MVRES
- mode_info[1][mbmi->pb_mv_precision][ref_mv_idx]
- .full_search_mv.as_int =
- mode_info[0][mbmi->pb_mv_precision][ref_mv_idx]
- .full_search_mv.as_int;
- mode_info[1][mbmi->pb_mv_precision][ref_mv_idx].full_mv_rate =
- mode_info[0][mbmi->pb_mv_precision][ref_mv_idx].full_mv_rate;
+#endif
+#endif
+
+#if CONFIG_REFINEMV
+ // Get the default value of DMVR flag based on mode
+ mbmi->refinemv_flag = get_default_refinemv_flag(cm, mbmi);
+#endif // CONFIG_REFINEMV
+
+#if !CONFIG_FLEX_MVRES && !CONFIG_BAWP
+ mode_info[ref_mv_idx].full_search_mv.as_int = INVALID_MV;
+ mode_info[ref_mv_idx].mv.as_int = INVALID_MV;
+ mode_info[ref_mv_idx].rd = INT64_MAX;
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+
+ !mask_check_bit(idx_mask, ref_mv_idx)) {
+ // MV did not perform well in simple translation search. Skip it.
+ continue;
+ }
+#endif // !CONFIG_FLEX_MVRES && !CONFIG_BAWP
+#if !CONFIG_FLEX_MVRES
+ if (prune_modes_based_on_tpl && !ref_match_found_in_above_nb &&
+ !ref_match_found_in_left_nb && (ref_best_rd != INT64_MAX)) {
+ // Skip mode if TPL model indicates it will not be beneficial.
+ if (prune_modes_based_on_tpl_stats(
+ &cm->features, inter_cost_info_from_tpl, refs, ref_mv_idx,
+ this_mode,
+ cpi->sf.inter_sf.prune_inter_modes_based_on_tpl))
+ continue;
+ }
+ av1_init_rd_stats(rd_stats);
+ // Initialize compound mode data
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+ mbmi->comp_group_idx = 0;
+ if (mbmi->ref_frame[1] == INTRA_FRAME)
+ mbmi->ref_frame[1] = NONE_FRAME;
+
+ mbmi->num_proj_ref = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+ mbmi->ref_mv_idx = ref_mv_idx;
+ // Compute cost for signalling this DRL index
+ rd_stats->rate = base_rate;
+ const int drl_cost =
+ get_drl_cost(cm->features.max_drl_bits, mbmi, mbmi_ext, x);
+
+ rd_stats->rate += drl_cost;
+#if CONFIG_BAWP
+ mode_info[0][ref_mv_idx].drl_cost = drl_cost;
+ mode_info[1][ref_mv_idx].drl_cost = drl_cost;
#else
- mode_info[1][ref_mv_idx].full_search_mv.as_int =
- mode_info[0][ref_mv_idx].full_search_mv.as_int;
- mode_info[1][ref_mv_idx].full_mv_rate =
- mode_info[0][ref_mv_idx].full_mv_rate;
+ mode_info[ref_mv_idx].drl_cost = drl_cost;
+#endif
+#endif //! CONFIG_FLEX_MVRES
+
+ int rs = 0;
+ int compmode_interinter_cost = 0;
+ int_mv cur_mv[2];
+ // TODO(Cherma): Extend this speed feature to support compound mode
+ int skip_repeated_ref_mv =
+ is_comp_pred ? 0 : cpi->sf.inter_sf.skip_repeated_ref_mv;
+ // Generate the current mv according to the prediction mode
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+ !build_cur_mv(cur_mv, this_mode, cm, x, skip_repeated_ref_mv)) {
+ continue;
+ }
+#if CONFIG_WARPMV
+ // For WARPMV mode we will build MV in the later stage
+ // Currently initialize to 0
+ if (mbmi->mode == WARPMV) {
+ cur_mv[0].as_int = 0;
+ cur_mv[1].as_int = 0;
+
+#if CONFIG_SEP_COMP_DRL
+ assert(ref_mv_idx[0] == 0 && ref_mv_idx[1] == 0);
+#else
+ assert(ref_mv_idx == 0);
+#endif // CONFIG_SEP_COMP_DRL
+ }
+#endif // CONFIG_WARPMV
+
+#if CONFIG_FLEX_MVRES
+#if !CONFIG_BAWP
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].full_search_mv.as_int =
+ INVALID_MV;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int = INVALID_MV;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = INT64_MAX;
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].drl_cost = drl_cost;
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+ !mask_check_bit(idx_mask[mbmi->pb_mv_precision], ref_mv_idx)) {
+ // MV did not perform well in simple translation search. Skip it.
+ continue;
+ }
+#endif
+
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+ cpi->sf.flexmv_sf.skip_similar_ref_mv &&
+ skip_similar_ref_mv(cpi, x, bsize)) {
+ continue;
+ }
+
+#if CONFIG_WARPMV
+ assert(IMPLIES(mbmi->mode == WARPMV,
+ mbmi->pb_mv_precision == mbmi->max_mv_precision));
+#endif // CONFIG_WARPMV
+#endif
+
+#if CONFIG_BAWP
+ int_mv bawp_off_mv[2];
+ int64_t bawp_off_newmv_ret_val = 0;
+#if BAWP_BUGFIX
+ int bawp_off_rate_mv = 0;
+#endif
+ for (i = 0; i < is_comp_pred + 1; ++i) {
+ bawp_off_mv[i].as_int = cur_mv[i].as_int;
+ }
+ int bawp_eanbled = cm->features.enable_bawp &&
+#if CONFIG_REFINEMV
+ !mbmi->refinemv_flag &&
+#endif // CONFIG_REFINEMV
+ av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col);
+ for (int bawp_flag = 0; bawp_flag <= bawp_eanbled; bawp_flag++) {
+ mbmi->bawp_flag = bawp_flag;
+
+#if CONFIG_FLEX_MVRES
+#if CONFIG_SEP_COMP_DRL
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .full_search_mv.as_int = INVALID_MV;
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .mv.as_int = INVALID_MV;
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type].rd =
+ INT64_MAX;
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .drl_cost = drl_cost;
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+#if CONFIG_REFINEMV
+ !mbmi->refinemv_flag &&
+#endif // CONFIG_REFINEMV
+ !mask_check_bit(idx_mask[bawp_flag][mbmi->pb_mv_precision],
+ ref_mv_idx_type)) {
+ // MV did not perform well in simple translation search. Skip
+ // it.
+ continue;
+ }
+#else
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
+ .full_search_mv.as_int = INVALID_MV;
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
+ .mv.as_int = INVALID_MV;
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].rd =
+ INT64_MAX;
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].drl_cost =
+ drl_cost;
+
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+#if CONFIG_REFINEMV
+ !mbmi->refinemv_flag &&
+#endif // CONFIG_REFINEMV
+ !mask_check_bit(idx_mask[bawp_flag][mbmi->pb_mv_precision],
+ ref_mv_idx)) {
+ // MV did not perform well in simple translation search. Skip
+ // it.
+ continue;
+ }
+#endif // CONFIG_SEP_COMP_DRL
+#else
+ mode_info[bawp_flag][ref_mv_idx].full_search_mv.as_int = INVALID_MV;
+ mode_info[bawp_flag][ref_mv_idx].mv.as_int = INVALID_MV;
+ mode_info[bawp_flag][ref_mv_idx].rd = INT64_MAX;
+ mode_info[bawp_flag][ref_mv_idx].drl_cost = drl_cost;
+
+ if (
+#if CONFIG_WARPMV
+ mbmi->mode != WARPMV &&
+#endif // CONFIG_WARPMV
+#if CONFIG_REFINEMV
+ !mbmi->refinemv_flag &&
+#endif // CONFIG_REFINEMV
+ !mask_check_bit(idx_mask[bawp_flag], ref_mv_idx)) {
+ // MV did not perform well in simple translation search. Skip it.
+ continue;
+ }
#endif // CONFIG_FLEX_MVRES
- if (bawp_off_newmv_ret_val != 0) continue;
- } else {
+
+#if CONFIG_REFINEMV
+ assert(!(mbmi->bawp_flag && mbmi->refinemv_flag));
+#endif // CONFIG_REFINEMV
+
+ if (mbmi->bawp_flag == 1) {
+ for (i = 0; i < is_comp_pred + 1; ++i) {
+ mbmi->mv[i].as_int = bawp_off_mv[i].as_int;
+ cur_mv[i].as_int = bawp_off_mv[i].as_int;
+ }
+
+#if CONFIG_FLEX_MVRES
+#if CONFIG_SEP_COMP_DRL
+ mode_info[1][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .full_search_mv.as_int =
+ mode_info[0][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .full_search_mv.as_int;
+ mode_info[1][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .full_mv_rate =
+ mode_info[0][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .full_mv_rate;
+#else
+ mode_info[1][mbmi->pb_mv_precision][ref_mv_idx]
+ .full_search_mv.as_int =
+ mode_info[0][mbmi->pb_mv_precision][ref_mv_idx]
+ .full_search_mv.as_int;
+ mode_info[1][mbmi->pb_mv_precision][ref_mv_idx].full_mv_rate =
+ mode_info[0][mbmi->pb_mv_precision][ref_mv_idx]
+ .full_mv_rate;
+#endif // CONFIG_SEP_COMP_DRL
+#else
+ mode_info[1][ref_mv_idx].full_search_mv.as_int =
+ mode_info[0][ref_mv_idx].full_search_mv.as_int;
+ mode_info[1][ref_mv_idx].full_mv_rate =
+ mode_info[0][ref_mv_idx].full_mv_rate;
+#endif // CONFIG_FLEX_MVRES
+#if BAWP_BUGFIX
+ rate_mv = bawp_off_rate_mv;
#endif
- // The above call to build_cur_mv does not handle NEWMV modes. Build
- // the mv here if we have NEWMV for any predictors.
- if (have_newmv_in_inter_mode(this_mode)) {
+ if (bawp_off_newmv_ret_val != 0) continue;
+ } else {
+#endif // CONFIG_BAWP
+ // The above call to build_cur_mv does not handle NEWMV modes.
+ // Build the mv here if we have NEWMV for any predictors.
+ if (have_newmv_in_inter_mode(this_mode)) {
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, handle_newmv_time);
+ start_timing(cpi, handle_newmv_time);
#endif
- newmv_ret_val =
- handle_newmv(cpi, x, bsize, cur_mv, &rate_mv, args,
+ newmv_ret_val =
+ handle_newmv(cpi, x, bsize, cur_mv, &rate_mv, args,
#if CONFIG_FLEX_MVRES
#if CONFIG_BAWP
- mode_info[bawp_flag][mbmi->pb_mv_precision]);
+ mode_info[bawp_flag][mbmi->pb_mv_precision]);
#else
- mode_info[mbmi->pb_mv_precision]);
+ mode_info[mbmi->pb_mv_precision]);
#endif
#else
#if CONFIG_BAWP
@@ -4369,67 +5375,71 @@
#endif
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, handle_newmv_time);
+ end_timing(cpi, handle_newmv_time);
#endif
#if CONFIG_BAWP
- for (i = 0; i < is_comp_pred + 1; ++i) {
- bawp_off_mv[i].as_int = cur_mv[i].as_int;
+#if BAWP_BUGFIX
+ bawp_off_rate_mv = rate_mv;
+#endif
+ for (i = 0; i < is_comp_pred + 1; ++i) {
+ bawp_off_mv[i].as_int = cur_mv[i].as_int;
+ }
+ bawp_off_newmv_ret_val = newmv_ret_val;
+ if (newmv_ret_val != 0) continue;
+ }
}
- bawp_off_newmv_ret_val = newmv_ret_val;
- if (newmv_ret_val != 0) continue;
- }
- }
- if (have_newmv_in_inter_mode(this_mode)) {
+ if (have_newmv_in_inter_mode(this_mode)) {
#else
if (newmv_ret_val != 0) continue;
#endif
#if CONFIG_C071_SUBBLK_WARPMV && CONFIG_FLEX_MVRES
- int mv_outlim = 0;
- for (int ref = 0; ref < is_comp_pred + 1; ref++) {
- const PREDICTION_MODE single_mode =
- get_single_mode(this_mode, ref);
- if (single_mode == NEWMV) {
- SUBPEL_MOTION_SEARCH_PARAMS ms_params;
- MV ref_mv = av1_get_ref_mv(x, ref).as_mv;
- if (mbmi->pb_mv_precision < MV_PRECISION_HALF_PEL)
- lower_mv_precision(&ref_mv, mbmi->pb_mv_precision);
- av1_make_default_subpel_ms_params(
- &ms_params, cpi, x, bsize, &ref_mv, pb_mv_precision, NULL);
- if (!av1_is_subpelmv_in_range(&ms_params.mv_limits,
- cur_mv[ref].as_mv)) {
- mv_outlim = 1;
- break;
+ int mv_outlim = 0;
+ for (int ref = 0; ref < is_comp_pred + 1; ref++) {
+ const PREDICTION_MODE single_mode =
+ get_single_mode(this_mode, ref);
+ if (single_mode == NEWMV) {
+ SUBPEL_MOTION_SEARCH_PARAMS ms_params;
+ MV ref_mv = av1_get_ref_mv(x, ref).as_mv;
+ if (mbmi->pb_mv_precision < MV_PRECISION_HALF_PEL)
+ lower_mv_precision(&ref_mv, mbmi->pb_mv_precision);
+ av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize,
+ &ref_mv, pb_mv_precision,
+ NULL);
+ if (!av1_is_subpelmv_in_range(&ms_params.mv_limits,
+ cur_mv[ref].as_mv)) {
+ mv_outlim = 1;
+ break;
+ }
+ }
}
- }
- }
- if (mv_outlim) continue;
+ if (mv_outlim) continue;
#endif // CONFIG_C071_SUBBLK_WARPMV && CONFIG_FLEX_MVRES
- // skip NEWMV mode in drl if the motion search result is the same
- // as a previous result
+ // skip NEWMV mode in drl if the motion search result is the
+ // same as a previous result
#if CONFIG_FLEX_MVRES
- int skip_new_mv =
- cpi->sf.inter_sf.skip_repeated_newmv ||
- (mbmi->pb_mv_precision != mbmi->max_mv_precision &&
- cpi->sf.flexmv_sf.skip_repeated_newmv_low_prec);
- if (skip_new_mv &&
- skip_repeated_newmv(
- cpi, x, bsize, do_tx_search, this_mode,
- mbmi->pb_mv_precision,
+ int skip_new_mv =
+ cpi->sf.inter_sf.skip_repeated_newmv ||
+ (mbmi->pb_mv_precision != mbmi->max_mv_precision &&
+ cpi->sf.flexmv_sf.skip_repeated_newmv_low_prec);
+ if (skip_new_mv &&
+ skip_repeated_newmv(
+ cpi, x, bsize, do_tx_search, this_mode,
+ mbmi->pb_mv_precision,
#if CONFIG_BAWP
- mbmi->bawp_flag,
+ mbmi->bawp_flag,
#endif
- &best_mbmi, motion_mode_cand, &ref_best_rd, &best_rd_stats,
- &best_rd_stats_y,
+ &best_mbmi, motion_mode_cand, &ref_best_rd,
+ &best_rd_stats, &best_rd_stats_y,
#if CONFIG_BAWP
- &best_rd_stats_uv,
- mode_info[bawp_flag][mbmi->pb_mv_precision], args,
+ &best_rd_stats_uv,
+ mode_info[bawp_flag][mbmi->pb_mv_precision], args,
#else
- &best_rd_stats_uv, mode_info[mbmi->pb_mv_precision], args,
+ &best_rd_stats_uv, mode_info[mbmi->pb_mv_precision], args,
#endif
- drl_cost, refs, cur_mv, &best_rd, orig_dst, ref_mv_idx))
+ drl_cost, refs, cur_mv, &best_rd, orig_dst, ref_mv_idx))
#else
if (cpi->sf.inter_sf.skip_repeated_newmv &&
skip_repeated_newmv(
@@ -4446,52 +5456,99 @@
#endif
args, drl_cost, refs, cur_mv, &best_rd, orig_dst, ref_mv_idx))
#endif
- continue;
- }
+ continue;
+ }
+
+#if CONFIG_REFINEMV
+ const MB_MODE_INFO base_mbmi = *mbmi;
+ for (int refinemv_loop = 0; refinemv_loop < REFINEMV_NUM_MODES;
+ refinemv_loop++) {
+ *mbmi = base_mbmi;
+ int_mv tmp_cur_mv[2];
+ for (i = 0; i < 2; ++i) {
+ tmp_cur_mv[i].as_int = cur_mv[i].as_int;
+ }
+ int tmp_rate_mv = rate_mv;
+#endif // CONFIG_REFINEMV
#if CONFIG_FLEX_MVRES || CONFIG_BAWP
- av1_init_rd_stats(rd_stats);
- // Initialize compound mode data
- mbmi->interinter_comp.type = COMPOUND_AVERAGE;
- mbmi->comp_group_idx = 0;
- if (mbmi->ref_frame[1] == INTRA_FRAME)
- mbmi->ref_frame[1] = NONE_FRAME;
+ av1_init_rd_stats(rd_stats);
+ // Initialize compound mode data
+ mbmi->interinter_comp.type = COMPOUND_AVERAGE;
+ mbmi->comp_group_idx = 0;
+ if (mbmi->ref_frame[1] == INTRA_FRAME)
+ mbmi->ref_frame[1] = NONE_FRAME;
- mbmi->num_proj_ref = 0;
- mbmi->motion_mode = SIMPLE_TRANSLATION;
- mbmi->ref_mv_idx = ref_mv_idx;
+ mbmi->num_proj_ref = 0;
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = ref_mv_idx[0];
+ mbmi->ref_mv_idx[1] = ref_mv_idx[1];
+#else
+ mbmi->ref_mv_idx = ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
- // Compute cost for signalling this DRL index
- rd_stats->rate = base_rate;
+ // Compute cost for signalling this DRL index
+ rd_stats->rate = base_rate;
#if CONFIG_FLEX_MVRES
- rd_stats->rate += flex_mv_cost[mbmi->pb_mv_precision];
+ rd_stats->rate += flex_mv_cost[mbmi->pb_mv_precision];
#endif
- rd_stats->rate += drl_cost;
+ rd_stats->rate += drl_cost;
#endif
+#if CONFIG_REFINEMV
+ if (refinemv_loop && !switchable_refinemv_flag(cm, mbmi))
+ continue;
+ mbmi->refinemv_flag = switchable_refinemv_flag(cm, mbmi)
+ ? refinemv_loop
+ : get_default_refinemv_flag(cm, mbmi);
+ if (mbmi->refinemv_flag &&
+ !is_refinemv_allowed(cm, mbmi, bsize)) {
+ continue;
+ }
+#if CONFIG_CWP
+ if (mbmi->refinemv_flag && mbmi->cwp_idx != CWP_EQUAL) continue;
+#endif
+#endif // CONFIG_REFINEMV
+
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
- if (is_joint_mvd_coding_mode(mbmi->mode)) {
- int jmvd_scale_mode_cost =
+ if (is_joint_mvd_coding_mode(mbmi->mode)) {
+ int jmvd_scale_mode_cost =
#if CONFIG_ADAPTIVE_MVD
- is_joint_amvd_coding_mode(mbmi->mode)
- ? mode_costs
- ->jmvd_amvd_scale_mode_cost[mbmi->jmvd_scale_mode]
- :
+ is_joint_amvd_coding_mode(mbmi->mode)
+ ? mode_costs->jmvd_amvd_scale_mode_cost
+ [mbmi->jmvd_scale_mode]
+ :
#endif // CONFIG_ADAPTIVE_MVD
- mode_costs->jmvd_scale_mode_cost[mbmi->jmvd_scale_mode];
- rd_stats->rate += jmvd_scale_mode_cost;
- }
+ mode_costs
+ ->jmvd_scale_mode_cost[mbmi->jmvd_scale_mode];
+ rd_stats->rate += jmvd_scale_mode_cost;
+ }
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
- rd_stats->rate += rate_mv;
+#if CONFIG_REFINEMV
+ rd_stats->rate += tmp_rate_mv;
+ if (switchable_refinemv_flag(cm, mbmi)) {
+ rd_stats->rate +=
+ mode_costs->refinemv_flag_cost[av1_get_refinemv_context(
+ cm, xd, bsize)][mbmi->refinemv_flag];
+ }
+#else
+ rd_stats->rate += rate_mv;
+#endif // CONFIG_REFINEMV
- // Copy the motion vector for this mode into mbmi struct
- for (i = 0; i < is_comp_pred + 1; ++i) {
- mbmi->mv[i].as_int = cur_mv[i].as_int;
- }
+ // Copy the motion vector for this mode into mbmi struct
+ for (i = 0; i < is_comp_pred + 1; ++i) {
+#if CONFIG_REFINEMV
+ mbmi->mv[i].as_int = tmp_cur_mv[i].as_int;
+#else
+
+ mbmi->mv[i].as_int = cur_mv[i].as_int;
+#endif // CONFIG_REFINEMV
+ }
#if CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
- assert(check_mv_precision(cm, mbmi, x));
+ assert(check_mv_precision(cm, mbmi, x));
#endif
#else
#if CONFIG_FLEX_MVRES
@@ -4499,59 +5556,101 @@
#endif
#endif // CONFIG_C071_SUBBLK_WARPMV
- const int like_nearest = (mbmi->mode == NEARMV ||
+ const int like_nearest = (mbmi->mode == NEARMV ||
#if CONFIG_WARPMV
- mbmi->mode == WARPMV ||
+ mbmi->mode == WARPMV ||
#endif // CONFIG_WARPMV
#if CONFIG_OPTFLOW_REFINEMENT
- mbmi->mode == NEAR_NEARMV_OPTFLOW ||
+ mbmi->mode == NEAR_NEARMV_OPTFLOW ||
#endif // CONFIG_OPTFLOW_REFINEMENT
- mbmi->mode == NEAR_NEARMV) &&
- mbmi->ref_mv_idx == 0;
- if (RDCOST(x->rdmult, rd_stats->rate, 0) > ref_best_rd &&
- !like_nearest) {
- continue;
- }
+ mbmi->mode == NEAR_NEARMV) &&
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] == 0 &&
+ mbmi->ref_mv_idx[1] == 0;
+#else
+ mbmi->ref_mv_idx == 0;
+#endif // CONFIG_SEP_COMP_DRL
+ if (RDCOST(x->rdmult, rd_stats->rate, 0) > ref_best_rd &&
+ !like_nearest) {
+ continue;
+ }
- // Skip the rest of the search if prune_ref_mv_idx_search speed
- // feature is enabled, and the current MV is similar to a previous
- // one.
- if (cpi->sf.inter_sf.prune_ref_mv_idx_search && is_comp_pred &&
- prune_ref_mv_idx_search(&cm->features, ref_mv_idx,
- best_ref_mv_idx,
+ // Skip the rest of the search if prune_ref_mv_idx_search speed
+ // feature is enabled, and the current MV is similar to a
+ // previous one.
+ if (cpi->sf.inter_sf.prune_ref_mv_idx_search && is_comp_pred &&
+ prune_ref_mv_idx_search(
+ &cm->features, ref_mv_idx, best_ref_mv_idx,
#if CONFIG_FLEX_MVRES
- save_mv[mbmi->pb_mv_precision], mbmi,
+ save_mv[mbmi->pb_mv_precision], mbmi,
#else
- save_mv, mbmi,
+ save_mv, mbmi,
#endif
- cpi->sf.inter_sf.prune_ref_mv_idx_search))
- continue;
+ cpi->sf.inter_sf.prune_ref_mv_idx_search))
+ continue;
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, compound_type_rd_time);
+ start_timing(cpi, compound_type_rd_time);
#endif
- int skip_build_pred = 0;
- const int mi_row = xd->mi_row;
- const int mi_col = xd->mi_col;
+ int skip_build_pred = 0;
+ const int mi_row = xd->mi_row;
+ const int mi_col = xd->mi_col;
- // Handle a compound predictor, continue if it is determined this
- // cannot be the best compound mode
- if (is_comp_pred
+#if CONFIG_CWP
+ // set cwp_search_mask
+ if (is_cwp_allowed(mbmi) && mbmi->cwp_idx == CWP_EQUAL) {
+ set_cwp_search_mask(cpi, x, bsize, rd_buffers->pred0,
+ rd_buffers->pred1, rd_buffers->residual1,
+ rd_buffers->diff10,
+ block_size_wide[bsize], cwp_search_mask);
+ }
+#endif // CONFIG_CWP
+
+ // Handle a compound predictor, continue if it is determined
+ // this cannot be the best compound mode
+ if (is_comp_pred
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
- && !is_joint_amvd_coding_mode(mbmi->mode)
+ && !is_joint_amvd_coding_mode(mbmi->mode)
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
- ) {
- const int not_best_mode = process_compound_inter_mode(
- cpi, x, args, ref_best_rd, cur_mv, bsize,
- &compmode_interinter_cost, rd_buffers, &orig_dst, &tmp_dst,
- &rate_mv, rd_stats, skip_rd, &skip_build_pred);
- if (not_best_mode) continue;
- }
+#if CONFIG_REFINEMV
+ && (!mbmi->refinemv_flag ||
+ !switchable_refinemv_flag(cm, mbmi))
+#endif // CONFIG_REFINEMV
+ ) {
+ const int not_best_mode = process_compound_inter_mode(
+ cpi, x, args, ref_best_rd,
+#if CONFIG_REFINEMV
+ tmp_cur_mv,
+#else
+ cur_mv,
+#endif // CONFIG_REFINEMV
+ bsize, &compmode_interinter_cost, rd_buffers, &orig_dst,
+ &tmp_dst,
+#if CONFIG_REFINEMV
+ &tmp_rate_mv,
+#else
+
+ &rate_mv,
+#endif // CONFIG_REFINEMV
+
+ rd_stats, skip_rd, &skip_build_pred);
+ if (not_best_mode) continue;
+ }
+
+#if CONFIG_CWP
+ if (cm->features.enable_cwp && is_comp_pred &&
+ is_joint_amvd_coding_mode(mbmi->mode)) {
+ if (is_cwp_allowed(mbmi)) {
+ compmode_interinter_cost =
+ av1_get_cwp_idx_cost(mbmi->cwp_idx, cm, x);
+ }
+ }
+#endif // CONFIG_CWP
#if CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
- assert(check_mv_precision(cm, mbmi, x));
+ assert(check_mv_precision(cm, mbmi, x));
#endif
#else
#if CONFIG_FLEX_MVRES
@@ -4560,20 +5659,20 @@
#endif // CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, compound_type_rd_time);
+ end_timing(cpi, compound_type_rd_time);
#endif
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, interpolation_filter_search_time);
+ start_timing(cpi, interpolation_filter_search_time);
#endif
- // Determine the interpolation filter for this mode
- ret_val = av1_interpolation_filter_search(
- x, cpi, tile_data, bsize, &tmp_dst, &orig_dst, &rd, &rs,
- &skip_build_pred, args, ref_best_rd);
+ // Determine the interpolation filter for this mode
+ ret_val = av1_interpolation_filter_search(
+ x, cpi, tile_data, bsize, &tmp_dst, &orig_dst, &rd, &rs,
+ &skip_build_pred, args, ref_best_rd);
#if CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
- assert(check_mv_precision(cm, mbmi, x));
+ assert(check_mv_precision(cm, mbmi, x));
#endif
#else
#if CONFIG_FLEX_MVRES
@@ -4581,87 +5680,111 @@
#endif
#endif // CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, interpolation_filter_search_time);
+ end_timing(cpi, interpolation_filter_search_time);
#endif
- if (args->modelled_rd != NULL && !is_comp_pred) {
- args->modelled_rd[this_mode][ref_mv_idx][refs[0]] = rd;
- }
+ if (args->modelled_rd != NULL && !is_comp_pred) {
+#if CONFIG_SEP_COMP_DRL
+ args->modelled_rd[this_mode][ref_mv_idx_type][refs[0]] = rd;
+#else
+ args->modelled_rd[this_mode][ref_mv_idx][refs[0]] = rd;
+#endif // CONFIG_SEP_COMP_DRL
+ }
#if CONFIG_WARPMV
- if (mbmi->mode != WARPMV) {
+ if (mbmi->mode != WARPMV) {
#endif // CONFIG_WARPMV
- if (ret_val != 0) {
- restore_dst_buf(xd, orig_dst, num_planes);
- continue;
- } else if (cpi->sf.inter_sf
- .model_based_post_interp_filter_breakout &&
- ref_best_rd != INT64_MAX &&
- (rd >> 3) * 3 > ref_best_rd) {
- restore_dst_buf(xd, orig_dst, num_planes);
- continue;
- }
+ if (ret_val != 0) {
+ restore_dst_buf(xd, orig_dst, num_planes);
+ continue;
+ } else if (cpi->sf.inter_sf
+ .model_based_post_interp_filter_breakout &&
+ ref_best_rd != INT64_MAX &&
+ (rd >> 3) * 3 > ref_best_rd) {
+ restore_dst_buf(xd, orig_dst, num_planes);
+ continue;
+ }
#if CONFIG_WARPMV
- }
+ }
#endif // CONFIG_WARPMV
// Compute modelled RD if enabled
- if (args->modelled_rd != NULL) {
+ if (args->modelled_rd != NULL) {
#if CONFIG_OPTFLOW_REFINEMENT
- if (is_comp_pred && this_mode < NEAR_NEARMV_OPTFLOW) {
+ if (is_comp_pred && this_mode < NEAR_NEARMV_OPTFLOW) {
#else
if (is_comp_pred) {
#endif // CONFIG_OPTFLOW_REFINEMENT
- const int mode0 = compound_ref0_mode(this_mode);
- const int mode1 = compound_ref1_mode(this_mode);
- const int64_t mrd =
- AOMMIN(args->modelled_rd[mode0][ref_mv_idx][refs[0]],
- args->modelled_rd[mode1][ref_mv_idx][refs[1]]);
-
- if ((rd >> 3) * 6 > mrd && ref_best_rd < INT64_MAX) {
- restore_dst_buf(xd, orig_dst, num_planes);
- continue;
- }
- }
- }
- rd_stats->rate += compmode_interinter_cost;
- if (skip_build_pred != 1
+ const int mode0 = compound_ref0_mode(this_mode);
+ const int mode1 = compound_ref1_mode(this_mode);
+ const int64_t mrd =
+#if CONFIG_SEP_COMP_DRL
+ AOMMIN(args->modelled_rd[mode0][get_ref_mv_idx(mbmi, 0)]
+ [refs[0]],
+ args->modelled_rd[mode1][get_ref_mv_idx(mbmi, 1)]
+ [refs[1]]);
+#else
+ AOMMIN(args->modelled_rd[mode0][ref_mv_idx][refs[0]],
+ args->modelled_rd[mode1][ref_mv_idx][refs[1]]);
+#endif // CONFIG_SEP_COMP_DRL
+ if ((rd >> 3) * 6 > mrd && ref_best_rd < INT64_MAX) {
+ restore_dst_buf(xd, orig_dst, num_planes);
+ continue;
+ }
+ }
+ }
+ rd_stats->rate += compmode_interinter_cost;
+ if (skip_build_pred != 1
#if CONFIG_WARPMV
- && (mbmi->mode != WARPMV)
+ && (mbmi->mode != WARPMV)
#endif // CONFIG_WARPMV
- ) {
- // Build this inter predictor if it has not been previously built
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst,
- bsize, 0, av1_num_planes(cm) - 1);
- }
+ ) {
+ // Build this inter predictor if it has not been previously
+ // built
+ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col,
+ &orig_dst, bsize, 0,
+ av1_num_planes(cm) - 1);
+ }
#if CONFIG_WARPMV
- // So far we did not make prediction for WARPMV mode
- assert(IMPLIES(mbmi->mode == WARPMV, skip_build_pred != 1));
+ // So far we did not make prediction for WARPMV mode
+ assert(IMPLIES(mbmi->mode == WARPMV, skip_build_pred != 1));
#endif // CONFIG_WARPMV
#if CONFIG_COLLECT_COMPONENT_TIMING
- start_timing(cpi, motion_mode_rd_time);
+ start_timing(cpi, motion_mode_rd_time);
#endif
- int rate2_nocoeff = rd_stats->rate;
+ int rate2_nocoeff = rd_stats->rate;
#if CONFIG_WARPMV
- assert(IMPLIES(mbmi->mode == WARPMV,
- (rd_stats->rate == base_rate && rate_mv == 0)));
+#if CONFIG_REFINEMV
+ assert(
+ IMPLIES(mbmi->mode == WARPMV,
+ (rd_stats->rate == base_rate && tmp_rate_mv == 0)));
+#else
+ assert(IMPLIES(mbmi->mode == WARPMV,
+ (rd_stats->rate == base_rate && rate_mv == 0)));
+#endif
#endif // CONFIG_WARPMV
// Determine the motion mode. This will be one of SIMPLE_TRANSLATION,
// OBMC_CAUSAL or WARPED_CAUSAL or WARP_EXTEND or WARP_DELTA
- ret_val = motion_mode_rd(cpi, tile_data, x, bsize, rd_stats,
- rd_stats_y, rd_stats_uv, args, ref_best_rd,
- skip_rd, &rate_mv, &orig_dst, best_est_rd,
- do_tx_search, inter_modes_info, 0);
+ ret_val = motion_mode_rd(
+ cpi, tile_data, x, bsize, rd_stats, rd_stats_y, rd_stats_uv,
+ args, ref_best_rd, skip_rd,
+#if CONFIG_REFINEMV
+ &tmp_rate_mv,
+#else
+ &rate_mv,
+#endif // CONFIG_REFINEMV
+
+ &orig_dst, best_est_rd, do_tx_search, inter_modes_info, 0);
#if CONFIG_COLLECT_COMPONENT_TIMING
- end_timing(cpi, motion_mode_rd_time);
+ end_timing(cpi, motion_mode_rd_time);
#endif
- assert(IMPLIES(!av1_check_newmv_joint_nonzero(cm, x),
- ret_val == INT64_MAX));
+ assert(IMPLIES(!av1_check_newmv_joint_nonzero(cm, x),
+ ret_val == INT64_MAX));
#if CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
- assert(check_mv_precision(cm, mbmi, x));
+ assert(check_mv_precision(cm, mbmi, x));
#endif
#else
#if CONFIG_FLEX_MVRES
@@ -4669,85 +5792,152 @@
#endif
#endif // CONFIG_C071_SUBBLK_WARPMV
- if (ret_val != INT64_MAX) {
- int64_t tmp_rd = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
+ if (ret_val != INT64_MAX) {
+ int64_t tmp_rd =
+ RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
#if CONFIG_FLEX_MVRES
- if (is_pb_mv_precision_active(cm, mbmi, bsize) &&
- tmp_rd < best_precision_rd_so_far) {
- best_precision_so_far = mbmi->pb_mv_precision;
- best_precision_rd_so_far = tmp_rd;
- }
+ if (is_pb_mv_precision_active(cm, mbmi, bsize) &&
+ tmp_rd < best_precision_rd_so_far) {
+ best_precision_so_far = mbmi->pb_mv_precision;
+ best_precision_rd_so_far = tmp_rd;
+ }
#if CONFIG_BAWP
- if (tmp_rd <
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].rd) {
- // Only update mode_info if the new result is actually better.
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
- .mv.as_int = mbmi->mv[0].as_int;
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].rate_mv =
- rate_mv;
- mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].rd =
- tmp_rd;
- }
+#if CONFIG_SEP_COMP_DRL
+ if (tmp_rd < mode_info[bawp_flag][mbmi->pb_mv_precision]
+ [ref_mv_idx_type]
+ .rd) {
+ // Only update mode_info if the new result is actually
+ // better.
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .mv.as_int = mbmi->mv[0].as_int;
+#if CONFIG_REFINEMV
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .rate_mv = tmp_rate_mv;
#else
- if (tmp_rd < mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd) {
- // Only update mode_info if the new result is actually better.
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int =
- mbmi->mv[0].as_int;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rate_mv = rate_mv;
- mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = tmp_rd;
- }
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .rate_mv = rate_mv;
+#endif // CONFIG_REFINEMV
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx_type]
+ .rd = tmp_rd;
+ }
+#else
+ if (tmp_rd <
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
+ .rd) {
+ // Only update mode_info if the new result is actually
+ // better.
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
+ .mv.as_int = mbmi->mv[0].as_int;
+#if CONFIG_REFINEMV
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
+ .rate_mv = tmp_rate_mv;
+#else
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx]
+ .rate_mv = rate_mv;
+#endif // CONFIG_REFINEMV
+ mode_info[bawp_flag][mbmi->pb_mv_precision][ref_mv_idx].rd =
+ tmp_rd;
+ }
+#endif // CONFIG_SEP_COMP_DRL
+#else
+#if CONFIG_SEP_COMP_DRL
+ if (tmp_rd <
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx_type].rd) {
+ // Only update mode_info if the new result is actually better.
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx_type].mv.as_int =
+ mbmi->mv[0].as_int;
+#if CONFIG_REFINEMV
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx_type].rate_mv =
+ tmp_rate_mv;
+#else
+
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx_type].rate_mv =
+ rate_mv;
+#endif // CONFIG_REFINEMV
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx_type].rd = tmp_rd;
+ }
+#else
+ if (tmp_rd < mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd) {
+ // Only update mode_info if the new result is actually better.
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].mv.as_int =
+ mbmi->mv[0].as_int;
+#if CONFIG_REFINEMV
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rate_mv =
+ tmp_rate_mv;
+#else
+
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rate_mv =
+ rate_mv;
+#endif // CONFIG_REFINEMV
+ mode_info[mbmi->pb_mv_precision][ref_mv_idx].rd = tmp_rd;
+ }
+#endif // CONFIG_SEP_COMP_DRL
#endif
#else
#if CONFIG_BAWP
if (tmp_rd < mode_info[bawp_flag][ref_mv_idx].rd) {
// Only update mode_info if the new result is actually better.
mode_info[bawp_flag][ref_mv_idx].mv.as_int = mbmi->mv[0].as_int;
+#if CONFIG_REFINEMV
+ mode_info[bawp_flag][ref_mv_idx].rate_mv = tmp_rate_mv;
+#else
mode_info[bawp_flag][ref_mv_idx].rate_mv = rate_mv;
+#endif // CONFIG_REFINEMV
mode_info[bawp_flag][ref_mv_idx].rd = tmp_rd;
}
#else
if (tmp_rd < mode_info[ref_mv_idx].rd) {
// Only update mode_info if the new result is actually better.
mode_info[ref_mv_idx].mv.as_int = mbmi->mv[0].as_int;
+#if CONFIG_REFINEMV
+ mode_info[ref_mv_idx].rate_mv = tmp_rate_mv;
+#else
mode_info[ref_mv_idx].rate_mv = rate_mv;
+#endif // CONFIG_REFINEMV
mode_info[ref_mv_idx].rd = tmp_rd;
}
#endif // CONFIG_BAWP
#endif // CONFIG_FLEX_MVRES
- // Collect mode stats for multiwinner mode processing
- store_winner_mode_stats(
- &cpi->common, x, mbmi, rd_stats, rd_stats_y, rd_stats_uv, refs,
- mbmi->mode, NULL, bsize, tmp_rd,
- cpi->sf.winner_mode_sf.multi_winner_mode_type, do_tx_search);
- if (tmp_rd < best_rd) {
- // Update the best rd stats if we found the best mode so far
- best_rd_stats = *rd_stats;
- best_rd_stats_y = *rd_stats_y;
- best_rd_stats_uv = *rd_stats_uv;
- best_rd = tmp_rd;
- best_mbmi = *mbmi;
+ // Collect mode stats for multiwinner mode processing
+ store_winner_mode_stats(
+ &cpi->common, x, mbmi, rd_stats, rd_stats_y, rd_stats_uv,
+ refs, mbmi->mode, NULL, bsize, tmp_rd,
+ cpi->sf.winner_mode_sf.multi_winner_mode_type,
+ do_tx_search);
+ if (tmp_rd < best_rd) {
+ // Update the best rd stats if we found the best mode so far
+ best_rd_stats = *rd_stats;
+ best_rd_stats_y = *rd_stats_y;
+ best_rd_stats_uv = *rd_stats_uv;
+ best_rd = tmp_rd;
+ best_mbmi = *mbmi;
#if CONFIG_C071_SUBBLK_WARPMV
- if (is_warp_mode(mbmi->motion_mode)) {
- store_submi(xd, cm, best_submi, bsize);
- }
+ if (is_warp_mode(mbmi->motion_mode)) {
+ store_submi(xd, cm, best_submi, bsize);
+ }
#endif // CONFIG_C071_SUBBLK_WARPMV
- best_xskip_txfm = txfm_info->skip_txfm;
- memcpy(best_blk_skip, txfm_info->blk_skip,
- sizeof(best_blk_skip[0]) * xd->height * xd->width);
- av1_copy_array(best_tx_type_map, xd->tx_type_map,
- xd->height * xd->width);
+ best_xskip_txfm = txfm_info->skip_txfm;
+ memcpy(best_blk_skip, txfm_info->blk_skip,
+ sizeof(best_blk_skip[0]) * xd->height * xd->width);
+ av1_copy_array(best_tx_type_map, xd->tx_type_map,
+ xd->height * xd->width);
#if CONFIG_CROSS_CHROMA_TX
- av1_copy_array(best_cctx_type_map, xd->cctx_type_map,
- xd->height * xd->width);
+ av1_copy_array(best_cctx_type_map, xd->cctx_type_map,
+ xd->height * xd->width);
#endif // CONFIG_CROSS_CHROMA_TX
- motion_mode_cand->rate_mv = rate_mv;
- motion_mode_cand->rate2_nocoeff = rate2_nocoeff;
- }
+
+#if CONFIG_REFINEMV
+ motion_mode_cand->rate_mv = tmp_rate_mv;
+#else
+ motion_mode_cand->rate_mv = rate_mv;
+#endif // CONFIG_REFINEMV
+ motion_mode_cand->rate2_nocoeff = rate2_nocoeff;
+ }
#if CONFIG_C071_SUBBLK_WARPMV
#if CONFIG_FLEX_MVRES
- assert(check_mv_precision(cm, mbmi, x));
+ assert(check_mv_precision(cm, mbmi, x));
#endif
#else
#if CONFIG_FLEX_MVRES
@@ -4755,19 +5945,41 @@
#endif
#endif // CONFIG_C071_SUBBLK_WARPMV
- if (tmp_rd < ref_best_rd) {
- ref_best_rd = tmp_rd;
- best_ref_mv_idx = ref_mv_idx;
- }
- }
- restore_dst_buf(xd, orig_dst, num_planes);
+#if CONFIG_CWP
+ if (is_cwp_allowed(mbmi)) {
+ if (tmp_rd < best_cwp_cost) {
+ best_cwp_cost = tmp_rd;
+ best_cwp_idx = mbmi->cwp_idx;
+ }
+ }
+#endif // CONFIG_CWP
+ if (tmp_rd < ref_best_rd) {
+ ref_best_rd = tmp_rd;
+#if CONFIG_SEP_COMP_DRL
+ best_ref_mv_idx[0] = ref_mv_idx[0];
+ best_ref_mv_idx[1] = ref_mv_idx[1];
+#else
+ best_ref_mv_idx = ref_mv_idx;
+#endif // CONFIG_SEP_COMP_DRL
+ }
+ }
+ restore_dst_buf(xd, orig_dst, num_planes);
+#if CONFIG_REFINEMV
+ }
+#endif // CONFIG_REFINEMV
#if CONFIG_BAWP
- }
+ }
#endif
#if CONFIG_FLEX_MVRES
- }
+ }
#endif
+#if CONFIG_CWP
+ }
+#endif // CONFIG_CWP
+ }
+#if CONFIG_SEP_COMP_DRL
}
+#endif // CONFIG_SEP_COMP_DRL
#if CONFIG_IMPROVED_JMVD
}
#endif // CONFIG_IMPROVED_JMVD
@@ -4798,7 +6010,7 @@
return rd_stats->rdcost;
}
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
// Check if BV is valid
static INLINE int is_bv_valid(const FULLPEL_MV *full_mv, const AV1_COMMON *cm,
const MACROBLOCKD *xd, int mi_row, int mi_col,
@@ -4926,7 +6138,7 @@
}
return 0;
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
/*!\brief Search for the best intrabc predictor
*
@@ -4956,7 +6168,7 @@
set_mv_precision(mbmi, MV_PRECISION_ONE_PEL);
set_default_precision_set(cm, mbmi, bsize);
set_most_probable_mv_precision(cm, mbmi, bsize);
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 1;
#endif
#endif
@@ -4965,6 +6177,10 @@
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
const int w = block_size_wide[bsize];
@@ -4996,18 +6212,22 @@
av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame);
#if CONFIG_FLEX_MVRES
+#if CONFIG_SEP_COMP_DRL
+ int_mv dv_ref = av1_find_best_ref_mv_from_stack(mbmi_ext, mbmi, ref_frame,
+#else
int_mv dv_ref = av1_find_best_ref_mv_from_stack(mbmi_ext, ref_frame,
+#endif
mbmi->pb_mv_precision);
#else
int_mv dv_ref = av1_find_best_ref_mv_from_stack(
/*allow_hp=*/0, mbmi_ext, ref_frame, /*is_integer=*/0);
#endif
dv_ref.as_int = dv_ref.as_int == INVALID_MV ? 0 : dv_ref.as_int;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
if (mbmi_ext->ref_mv_count[INTRA_FRAME] == 0) {
dv_ref.as_int = 0;
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
if (dv_ref.as_int == 0) {
av1_find_ref_dv(&dv_ref, tile, cm->mib_size, mi_row);
}
@@ -5046,7 +6266,7 @@
#if CONFIG_FLEX_MVRES
av1_make_default_fullpel_ms_params(&fullms_params, cpi, x, bsize,
&dv_ref.as_mv, mbmi->pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
lookahead_search_sites,
@@ -5056,7 +6276,7 @@
&dv_ref.as_mv, lookahead_search_sites,
/*fine_search_interval=*/0);
#endif
-#if CONFIG_BVCOST_UPDATE && !CONFIG_FLEX_MVRES
+#if CONFIG_IBC_BV_IMPROVEMENT && !CONFIG_FLEX_MVRES
// The costs for block vector are stored in x->dv_costs. Assign the costs
// to mv_cost_params for motion search.
fullms_params.mv_cost_params.mvjcost = x->dv_costs.joint_mv;
@@ -5064,7 +6284,7 @@
(int *)&x->dv_costs.mv_component[0][MV_MAX];
fullms_params.mv_cost_params.mvcost[1] =
(int *)&x->dv_costs.mv_component[1][MV_MAX];
-#endif // CONFIG_BVCOST_UPDATE
+#endif // CONFIG_IBC_BV_IMPROVEMENT
fullms_params.is_intra_mode = 1;
#if CONFIG_IBC_SR_EXT
@@ -5074,17 +6294,20 @@
fullms_params.mi_col = mi_col;
fullms_params.mi_row = mi_row;
#endif // CONFIG_IBC_SR_EXT
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
fullms_params.x = x;
fullms_params.cm = cm;
fullms_params.ref_bv_cnt = mbmi_ext->ref_mv_count[INTRA_FRAME];
mbmi->intrabc_mode = 0;
mbmi->intrabc_drl_idx = 0;
mbmi->ref_bv.as_int = 0;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
mbmi->motion_mode = SIMPLE_TRANSLATION;
for (enum IntrabcMotionDirection dir = IBC_MOTION_ABOVE;
@@ -5166,7 +6389,7 @@
assert(fullms_params.mv_limits.row_min >= fullms_params.mv_limits.row_min);
assert(fullms_params.mv_limits.row_max <= fullms_params.mv_limits.row_max);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
FULLPEL_MOTION_SEARCH_PARAMS fullms_params_init = fullms_params;
int best_ref_bv_cost = INT_MAX;
int_mv best_bv;
@@ -5190,7 +6413,7 @@
mbmi->ref_bv = dv_ref;
int best_intrabc_drl_idx = mbmi->intrabc_drl_idx;
int best_intrabc_mode = mbmi->intrabc_mode;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
av1_set_mv_search_range(&fullms_params.mv_limits, &dv_ref.as_mv
@@ -5212,7 +6435,7 @@
int bestsme = av1_full_pixel_search(start_mv, &fullms_params, step_param,
NULL, &best_mv.as_fullmv, NULL);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
if (bestsme != INT_MAX && is_bv_valid(&best_mv.as_fullmv, cm, xd, mi_row,
mi_col, bsize, fullms_params)) {
int cur_ref_bv_cost = bestsme;
@@ -5244,12 +6467,12 @@
best_bv.as_mv = cur_bv.as_mv;
}
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
const int hashsme = av1_intrabc_hash_search(
cpi, xd, &fullms_params, intrabc_hash_info, &best_hash_mv.as_fullmv);
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
if (hashsme != INT_MAX &&
is_bv_valid(&best_hash_mv.as_fullmv, cm, xd, mi_row, mi_col, bsize,
fullms_params)) {
@@ -5299,7 +6522,7 @@
continue;
if (!av1_is_dv_valid(dv, cm, xd, mi_row, mi_col, bsize, cm->mib_size_log2))
continue;
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
// DV should not have sub-pel.
assert((dv.col & 7) == 0);
@@ -5322,10 +6545,16 @@
mbmi->mv[0].as_mv = dv;
mbmi->interp_fltr = BILINEAR;
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 0;
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
mbmi->motion_mode = SIMPLE_TRANSLATION;
@@ -5336,7 +6565,7 @@
#if CONFIG_FLEX_MVRES
const IntraBCMvCosts *const dv_costs = &x->dv_costs;
#else
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const IntraBCMVCosts *const dv_costs = &x->dv_costs;
#else
const IntraBCMVCosts *const dv_costs = &cpi->dv_costs;
@@ -5345,7 +6574,7 @@
(int *)&dv_costs->mv_component[1][MV_MAX] };
#endif
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
int rate_mv = 0;
if (!mbmi->intrabc_mode)
#if CONFIG_FLEX_MVRES
@@ -5383,7 +6612,7 @@
#else
const int rate_mode = x->mode_costs.intrabc_cost[1];
#endif // CONFIG_NEW_CONTEXT_MODELING
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
RD_STATS rd_stats_yuv, rd_stats_y, rd_stats_uv;
if (!av1_txfm_search(cpi, x, bsize, &rd_stats_yuv, &rd_stats_y,
@@ -5405,13 +6634,13 @@
}
}
*mbmi = best_mbmi;
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
if (mbmi->use_intrabc[xd->tree_type == CHROMA_PART]) {
mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv = mbmi->ref_bv;
} else {
mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv.as_int = 0;
}
-#endif // CONFIG_BVP_IMPROVEMENT
+#endif // CONFIG_IBC_BV_IMPROVEMENT
*rd_stats = best_rdstats;
memcpy(txfm_info->blk_skip, best_blk_skip,
@@ -5483,9 +6712,13 @@
}
// Intra block is always coded as non-skip
+#if CONFIG_SKIP_TXFM_OPT
+ rd_cost->rate = rate_y + rate_uv;
+#else
rd_cost->rate =
rate_y + rate_uv +
x->mode_costs.skip_txfm_cost[av1_get_skip_txfm_context(xd)][0];
+#endif // CONFIG_SKIP_TXFM_OPT
rd_cost->dist = dist_y + dist_uv;
rd_cost->rdcost = RDCOST(x->rdmult, rd_cost->rate, rd_cost->dist);
rd_cost->skip_txfm = 0;
@@ -5507,9 +6740,12 @@
if (xd->tree_type != CHROMA_PART)
av1_copy_mbmi_ext_to_mbmi_ext_frame(
&ctx->mbmi_ext_best, x->mbmi_ext,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SEP_COMP_DRL
+ xd->mi[0],
+#endif
+#if CONFIG_SKIP_MODE_ENHANCEMENT
mbmi->skip_mode,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
av1_ref_frame_type(xd->mi[0]->ref_frame));
av1_copy_array(ctx->tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
}
@@ -5551,8 +6787,12 @@
const MV_REFERENCE_FRAME second_ref_frame = skip_mode_info->ref_frame_idx_1;
#if CONFIG_OPTFLOW_REFINEMENT
- const PREDICTION_MODE this_mode =
- cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV;
+ const PREDICTION_MODE this_mode = cm->features.opfl_refine_type
+#if CONFIG_CWP
+ && !cm->features.enable_cwp
+#endif // CONFIG_CWP
+ ? NEAR_NEARMV_OPTFLOW
+ : NEAR_NEARMV;
#else
const PREDICTION_MODE this_mode = NEAR_NEARMV;
#endif // CONFIG_OPTFLOW_REFINEMENT
@@ -5564,19 +6804,34 @@
}
mbmi->mode = this_mode;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif
mbmi->uv_mode = UV_DC_PRED;
mbmi->ref_frame[0] = ref_frame;
mbmi->ref_frame[1] = second_ref_frame;
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
#if CONFIG_IBC_SR_EXT
mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;
#endif // CONFIG_IBC_SR_EXT
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
-#if !CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
if (x->mbmi_ext->ref_mv_count[ref_frame_type] == UINT8_MAX) {
if (x->mbmi_ext->ref_mv_count[ref_frame] == UINT8_MAX ||
@@ -5600,25 +6855,35 @@
// mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame_type);
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_OPTFLOW_REFINEMENT
+#if CONFIG_CWP
+ assert(this_mode == (cm->features.opfl_refine_type && !cm->features.enable_cwp
+ ? NEAR_NEARMV_OPTFLOW
+ : NEAR_NEARMV));
+ assert(mbmi->mode ==
+ (cm->features.opfl_refine_type && !cm->features.enable_cwp
+ ? NEAR_NEARMV_OPTFLOW
+ : NEAR_NEARMV));
+#else // CONFIG_CWP
assert(this_mode ==
(cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
assert(mbmi->mode ==
(cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV));
+#endif // CONFIG_CWP
#else
assert(this_mode == NEAR_NEARMV);
assert(mbmi->mode == NEAR_NEARMV);
#endif
- assert(mbmi->ref_mv_idx == 0);
-#if !CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if !CONFIG_SKIP_MODE_ENHANCEMENT
if (!build_cur_mv(mbmi->mv, this_mode, cm, x, 0)) {
assert(av1_check_newmv_joint_nonzero(cm, x));
return;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+
mbmi->fsc_mode[xd->tree_type == CHROMA_PART] = 0;
#if CONFIG_BAWP
mbmi->bawp_flag = 0;
@@ -5629,7 +6894,12 @@
mbmi->comp_group_idx = 0;
mbmi->interinter_comp.type = COMPOUND_AVERAGE;
mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif // CONFIG_SEP_COMP_DRL
mbmi->skip_mode = mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
#if CONFIG_FLEX_MVRES
@@ -5642,6 +6912,9 @@
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
set_default_interp_filters(mbmi,
@@ -5650,7 +6923,7 @@
#endif // CONFIG_OPTFLOW_REFINEMENT
cm->features.interp_filter);
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
@@ -5690,17 +6963,54 @@
// mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
av1_copy_usable_ref_mv_stack_and_weight(xd, mbmi_ext, ref_frame_type);
+#if CONFIG_REFINEMV
+ mbmi->mode = this_mode;
+#endif // CONFIG_REFINEMV
// loop of ref_mv_idx
+#if CONFIG_SEP_COMP_DRL
+ assert(!has_second_drl(mbmi));
+ int ref_set = get_drl_refmv_count(cm->features.max_drl_bits, x,
+ mbmi->ref_frame, this_mode, 0);
+#else
int ref_set = get_drl_refmv_count(cm->features.max_drl_bits, x,
mbmi->ref_frame, this_mode);
+#endif
for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ref_mv_idx++) {
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = ref_mv_idx;
+ mbmi->ref_frame[0] =
+ xd->skip_mvp_candidate_list.ref_frame0[mbmi->ref_mv_idx[0]];
+ mbmi->ref_frame[1] =
+ xd->skip_mvp_candidate_list.ref_frame1[mbmi->ref_mv_idx[0]];
+#else
mbmi->ref_mv_idx = ref_mv_idx;
mbmi->ref_frame[0] =
xd->skip_mvp_candidate_list.ref_frame0[mbmi->ref_mv_idx];
mbmi->ref_frame[1] =
xd->skip_mvp_candidate_list.ref_frame1[mbmi->ref_mv_idx];
+#endif
+
+#if CONFIG_CWP
+ // Infer the index of compound weighted prediction from DRL list
+ mbmi->cwp_idx =
+#if CONFIG_SEP_COMP_DRL
+ xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx[0]].cwp_idx;
+#else
+ xd->skip_mvp_candidate_list.ref_mv_stack[mbmi->ref_mv_idx].cwp_idx;
+#endif
+#endif // CONFIG_CWP
+
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = (
+#if CONFIG_CWP
+ mbmi->cwp_idx == CWP_EQUAL &&
+#endif
+ is_refinemv_allowed_skip_mode(cm, mbmi))
+ ? 1
+ : 0;
+#endif // CONFIG_REFINEMV
if (!build_cur_mv(mbmi->mv, this_mode, cm, x, 0)) {
assert(av1_check_newmv_joint_nonzero(cm, x));
@@ -5723,7 +7033,7 @@
orig_dst.plane[i] = xd->plane[i].dst.buf;
orig_dst.stride[i] = xd->plane[i].dst.stride;
}
-#else // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#else // CONFIG_SKIP_MODE_ENHANCEMENT
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
for (int i = 0; i < num_planes; i++) {
xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
@@ -5748,6 +7058,7 @@
av1_rd_cost_update(x->rdmult, best_rd_cost);
search_state->best_rd = best_rd_cost->rdcost;
}
+
// loop of ref_mv_idx
const int ref_set = get_drl_refmv_count(cm->features.max_drl_bits, x,
mbmi->ref_frame, this_mode);
@@ -5763,7 +7074,7 @@
assert(av1_check_newmv_joint_nonzero(cm, x));
continue;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, bsize, 0,
av1_num_planes(cm) - 1);
@@ -5776,12 +7087,14 @@
skip_mode_rd_stats.rate = mode_costs->skip_mode_cost[skip_mode_ctx][1];
// add ref_mv_idx rate
+ // MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
+ // add ref_mv_idx rate
const int drl_cost =
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
get_skip_drl_cost(cpi->common.features.max_drl_bits, mbmi, x);
#else
get_drl_cost(cpi->common.features.max_drl_bits, mbmi, mbmi_ext, x);
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
skip_mode_rd_stats.rate += drl_cost;
// Do transform search
@@ -5807,17 +7120,22 @@
search_state->best_mbmode.fsc_mode[xd->tree_type == CHROMA_PART] = 0;
-#if CONFIG_OPTFLOW_REFINEMENT
- search_state->best_mbmode.mode =
- (cm->features.opfl_refine_type ? NEAR_NEARMV_OPTFLOW : NEAR_NEARMV);
-#else
- search_state->best_mbmode.mode = NEAR_NEARMV;
-#endif // CONFIG_OPTFLOW_REFINEMENT
+ search_state->best_mbmode.mode = (cm->features.opfl_refine_type
+#if CONFIG_CWP
+ && !cm->features.enable_cwp
+#endif // CONFIG_CWP
+ ? NEAR_NEARMV_OPTFLOW
+ : NEAR_NEARMV);
search_state->best_mbmode.ref_frame[0] = mbmi->ref_frame[0];
search_state->best_mbmode.ref_frame[1] = mbmi->ref_frame[1];
search_state->best_mbmode.mv[0].as_int = mbmi->mv[0].as_int;
search_state->best_mbmode.mv[1].as_int = mbmi->mv[1].as_int;
+#if CONFIG_SEP_COMP_DRL
+ search_state->best_mbmode.ref_mv_idx[0] = mbmi->ref_mv_idx[0];
+ search_state->best_mbmode.ref_mv_idx[1] = mbmi->ref_mv_idx[1];
+#else
search_state->best_mbmode.ref_mv_idx = mbmi->ref_mv_idx;
+#endif
// Set up tx_size related variables for skip-specific loop filtering.
if (search_state->best_mbmode.skip_txfm[xd->tree_type == CHROMA_PART]) {
@@ -5837,6 +7155,10 @@
x->txfm_search_info.skip_txfm = 1;
search_state->best_mode_skippable = 1;
search_state->best_skip2 = 1;
+#if CONFIG_SKIP_TXFM_OPT
+ search_state->best_rate_y =
+ x->mode_costs.skip_txfm_cost[av1_get_skip_txfm_context(xd)][1];
+#endif // CONFIG_SKIP_TXFM_OPT
restore_dst_buf(xd, orig_dst, num_planes);
} else {
@@ -5873,6 +7195,9 @@
cm,
#endif // CONFIG_OPTFLOW_REFINEMENT
cm->features.interp_filter);
+#if CONFIG_REFINEMV
+ search_state->best_mbmode.refinemv_flag = mbmi->refinemv_flag;
+#endif // CONFIG_REFINEMV
// Update rd_cost
best_rd_cost->rate = skip_mode_rd_stats.rate;
@@ -5916,7 +7241,12 @@
}
mbmi->mode = this_mode;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif // CONFIG_SEP_COMP_DRL
mbmi->uv_mode = UV_DC_PRED;
mbmi->ref_frame[0] = ref_frame;
mbmi->ref_frame[1] = second_ref_frame;
@@ -5960,7 +7290,12 @@
mbmi->comp_group_idx = 0;
mbmi->interinter_comp.type = COMPOUND_AVERAGE;
mbmi->motion_mode = SIMPLE_TRANSLATION;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif // CONFIG_SEP_COMP_DRL
mbmi->skip_mode = mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
set_default_interp_filters(mbmi,
@@ -5972,6 +7307,10 @@
set_mv_precision(mbmi, mbmi->max_mv_precision);
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
for (int i = 0; i < num_planes; i++) {
xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
@@ -6011,7 +7350,12 @@
search_state->best_mbmode.ref_frame[1] = mbmi->ref_frame[1];
search_state->best_mbmode.mv[0].as_int = mbmi->mv[0].as_int;
search_state->best_mbmode.mv[1].as_int = mbmi->mv[1].as_int;
+#if CONFIG_SEP_COMP_DRL
+ search_state->best_mbmode.ref_mv_idx[0] = 0;
+ search_state->best_mbmode.ref_mv_idx[1] = 0;
+#else
search_state->best_mbmode.ref_mv_idx = 0;
+#endif
#if CONFIG_FLEX_MVRES
search_state->best_mbmode.pb_mv_precision = mbmi->max_mv_precision;
@@ -6179,6 +7523,11 @@
av1_pick_uniform_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize,
INT64_MAX);
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ // Occasionally TX search will be unable to find a best mode decision.
+ // This case needs to be skipped to avoid integer overflows.
+ if (rd_stats_y.rate == INT_MAX) continue;
+#endif // CONFIG_ATC_DCTX_ALIGNED
if (num_planes > 1) {
av1_txfm_uvrd(cpi, x, &rd_stats_uv, INT64_MAX);
@@ -6201,7 +7550,13 @@
rd_stats_uv.dist = rd_stats_uv.sse;
} else {
skip_blk = 0;
+#if CONFIG_SKIP_TXFM_OPT
+ rd_stats_y.rate += is_inter_block(mbmi, xd->tree_type)
+ ? mode_costs->skip_txfm_cost[skip_ctx][0]
+ : 0;
+#else
rd_stats_y.rate += mode_costs->skip_txfm_cost[skip_ctx][0];
+#endif // CONFIG_SKIP_TXFM_OPT
}
int this_rate = rd_stats.rate + rd_stats_y.rate + rd_stats_uv.rate -
winner_rate_y - winner_rate_uv;
@@ -6676,6 +8031,7 @@
av1_zero(search_state->single_newmv);
av1_zero(search_state->single_newmv_rate);
av1_zero(search_state->single_newmv_valid);
+
for (int i = 0; i < MB_MODE_COUNT; ++i) {
for (int j = 0; j < MAX_REF_MV_SEARCH; ++j) {
for (int ref_frame = 0; ref_frame < SINGLE_REF_FRAMES; ++ref_frame) {
@@ -6991,7 +8347,12 @@
) {
PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif
mbmi->mode = curr_mode;
mbmi->uv_mode = UV_DC_PRED;
mbmi->ref_frame[0] = ref_frames[0];
@@ -7000,8 +8361,14 @@
pmi->palette_size[1] = 0;
mbmi->filter_intra_mode_info.use_filter_intra = 0;
mbmi->mv[0].as_int = mbmi->mv[1].as_int = 0;
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
mbmi->motion_mode = SIMPLE_TRANSLATION;
mbmi->interintra_mode = (INTERINTRA_MODE)(II_DC_PRED - 1);
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
set_default_interp_filters(mbmi,
#if CONFIG_OPTFLOW_REFINEMENT
cm,
@@ -7020,10 +8387,16 @@
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
#if CONFIG_BAWP
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
+ mbmi->jmvd_scale_mode = 0;
+#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
}
#if CONFIG_C071_SUBBLK_WARPMV
@@ -7045,8 +8418,14 @@
const MV_REFERENCE_FRAME ref_frame = COMPACT_INDEX0_NRS(mbmi->ref_frame[0]);
const int dir = get_dir_rank(cm, mbmi->ref_frame[0], NULL);
const int mode_offset = INTER_OFFSET(this_mode);
+#if CONFIG_SEP_COMP_DRL
+ const int ref_set = get_drl_refmv_count(features->max_drl_bits, x,
+ mbmi->ref_frame, this_mode, 0);
+ assert(!has_second_drl(mbmi));
+#else
const int ref_set = get_drl_refmv_count(features->max_drl_bits, x,
mbmi->ref_frame, this_mode);
+#endif
// Simple rd
int64_t simple_rd = search_state->simple_rd[this_mode][0][ref_frame];
@@ -7233,13 +8612,19 @@
}
}
}
-
+#if !CONFIG_SEP_COMP_DRL
const int ref_set = get_drl_refmv_count(cpi->common.features.max_drl_bits, x,
refs, this_mode);
+#endif
for (i = 0; i < 2; ++i) {
if (!ref_searched[i] || (mode[i] != NEARMV)) {
continue;
}
+#if CONFIG_SEP_COMP_DRL
+ const int ref_set = get_drl_refmv_count(cpi->common.features.max_drl_bits,
+ x, refs, this_mode, i);
+#endif
+
const MV_REFERENCE_FRAME single_refs[2] = { refs[i], NONE_FRAME };
for (int ref_mv_idx = 0; ref_mv_idx < ref_set; ref_mv_idx++) {
int_mv single_mv;
@@ -7404,8 +8789,16 @@
if (txfm_search_done) {
search_state->best_rate_y =
new_best_rd_stats_y->rate +
+#if CONFIG_SKIP_TXFM_OPT
+ (mode_is_intra
+ ? 0
+ : (x->mode_costs
+ .skip_txfm_cost[skip_ctx][new_best_rd_stats->skip_txfm ||
+ skip_txfm]));
+#else
x->mode_costs.skip_txfm_cost[skip_ctx]
[new_best_rd_stats->skip_txfm || skip_txfm];
+#endif // CONFIG_SKIP_TXFM_OPT
search_state->best_rate_uv = new_best_rd_stats_uv->rate;
}
memcpy(ctx->blk_skip, txfm_info->blk_skip,
@@ -7565,14 +8958,14 @@
}
#endif // CONFIG_TIP
-#if CONFIG_WARPMV
- if (this_mode == WARPMV) return 0;
-#endif // CONFIG_WARPMV
-
// Check if this mode should be skipped because it is incompatible with the
// current frame
if (inter_mode_compatible_skip(cpi, x, bsize, this_mode, ref_frames))
return 1;
+
+#if CONFIG_WARPMV
+ if (this_mode == WARPMV) return 0;
+#endif
const int ret = inter_mode_search_order_independent_skip(
cpi, x, args->mode_skip_mask, args->search_state,
args->skip_ref_frame_mask, this_mode, ref_frames);
@@ -7888,22 +9281,34 @@
INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES, INTERINTRA_MODES
};
- HandleInterModeArgs args = { { NULL },
- { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE },
- { NULL },
- { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
- MAX_SB_SIZE >> 1 },
- NULL,
- NULL,
- NULL,
- search_state.modelled_rd,
- INT_MAX,
- INT_MAX,
- search_state.simple_rd,
- 0,
- interintra_modes,
- { { 0, { { 0 } }, { 0 }, 0, 0, 0 } },
- 0 };
+#if CONFIG_SKIP_ME_FOR_OPFL_MODES
+ int_mv comp_newmv[MODE_CTX_REF_FRAMES][4][NUM_MV_PRECISIONS][2];
+ int comp_newmv_valid[MODE_CTX_REF_FRAMES][4][NUM_MV_PRECISIONS];
+ av1_zero(comp_newmv_valid);
+#endif // CONFIG_SKIP_ME_FOR_OPFL_MODES
+
+ HandleInterModeArgs args = {
+ { NULL },
+ { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE },
+ { NULL },
+ { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1 },
+ NULL,
+ NULL,
+ NULL,
+ search_state.modelled_rd,
+ INT_MAX,
+ INT_MAX,
+ search_state.simple_rd,
+ 0,
+ interintra_modes,
+ { { 0, { { 0 } }, { 0 }, 0, 0, 0 } },
+ 0
+#if CONFIG_SKIP_ME_FOR_OPFL_MODES
+ ,
+ comp_newmv,
+ comp_newmv_valid
+#endif // CONFIG_SKIP_ME_FOR_OPFL_MODES
+ };
// Indicates the appropriate number of simple translation winner modes for
// exhaustive motion mode evaluation
@@ -8013,6 +9418,13 @@
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
+
+#if CONFIG_SEP_COMP_DRL
+ mbmi->mode = NEARMV;
+#endif
// init params, set frame modes, speed features
set_params_rd_pick_inter_mode(cpi, x, &args, bsize, &mode_skip_mask,
skip_ref_frame_mask, ref_costs_single,
@@ -8289,10 +9701,18 @@
mbmi->angle_delta[PLANE_TYPE_Y] = 0;
mbmi->angle_delta[PLANE_TYPE_UV] = 0;
mbmi->filter_intra_mode_info.use_filter_intra = 0;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
const int64_t ref_best_rd = search_state.best_rd;
RD_STATS rd_stats, rd_stats_y, rd_stats_uv;
@@ -8601,23 +10021,24 @@
set_mode_eval_params(cpi, x, DEFAULT_EVAL);
// Only try palette mode when the best mode so far is an intra 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;
+ 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) && rd_cost->rate < INT_MAX;
+ int search_palette_mode = try_palette;
#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;
+ search_palette_mode = 0;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
RD_STATS this_rd_cost;
int this_skippable = 0;
- if (try_palette) {
+ if (search_palette_mode) {
this_skippable = av1_search_palette_mode(
&search_state.intra_search_state, cpi, x, bsize, intra_ref_frame_cost,
ctx, &this_rd_cost, search_state.best_rd);
@@ -8670,6 +10091,9 @@
#if CONFIG_WARP_REF_LIST
mbmi->warp_ref_idx = 0;
mbmi->max_num_warp_candidates = 0;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ mbmi->warpmv_with_mvd_flag = 0;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
#endif // CONFIG_WARP_REF_LIST
rd_pick_intrabc_mode_sb(cpi, x, ctx, &this_rd_cost, bsize, INT64_MAX);
@@ -8697,13 +10121,23 @@
// Make sure that the ref_mv_idx is only nonzero when we're
// using a mode which can support ref_mv_idx
+#if CONFIG_SEP_COMP_DRL
+ if ((search_state.best_mbmode.ref_mv_idx[0] != 0 ||
+ search_state.best_mbmode.ref_mv_idx[1] != 0) &&
+#else
if (search_state.best_mbmode.ref_mv_idx != 0 &&
+#endif
!(have_newmv_in_each_reference(search_state.best_mbmode.mode) ||
#if CONFIG_JOINT_MVD
is_joint_mvd_coding_mode(search_state.best_mbmode.mode) ||
#endif // CONFIG_JOINT_MVD
have_nearmv_in_inter_mode(search_state.best_mbmode.mode))) {
+#if CONFIG_SEP_COMP_DRL
+ search_state.best_mbmode.ref_mv_idx[0] = 0;
+ search_state.best_mbmode.ref_mv_idx[1] = 0;
+#else
search_state.best_mbmode.ref_mv_idx = 0;
+#endif
}
if (search_state.best_mbmode.mode == MODE_INVALID ||
@@ -8883,7 +10317,15 @@
mbmi->tx_size = max_txsize_lookup[bsize];
x->txfm_search_info.skip_txfm = 1;
+#if CONFIG_SEP_COMP_DRL
+ mbmi->ref_mv_idx[0] = 0;
+ mbmi->ref_mv_idx[1] = 0;
+#else
mbmi->ref_mv_idx = 0;
+#endif // CONFIG_SEP_COMP_DRL
+#if CONFIG_CWP
+ mbmi->cwp_idx = CWP_EQUAL;
+#endif // CONFIG_CWP
mbmi->motion_mode = SIMPLE_TRANSLATION;
#if CONFIG_FLEX_MVRES
@@ -8896,6 +10338,9 @@
#if CONFIG_BAWP
mbmi->bawp_flag = 0;
#endif
+#if CONFIG_REFINEMV
+ mbmi->refinemv_flag = 0;
+#endif // CONFIG_REFINEMV
av1_count_overlappable_neighbors(cm, xd);
if (is_motion_variation_allowed_bsize(bsize, mi_row, mi_col) &&
@@ -9119,9 +10564,9 @@
AOMMIN(block_size_high[bsize], block_size_high[BLOCK_64X64]) >> 1;
struct calc_target_weighted_pred_ctxt ctxt = { obmc_buffer, above,
above_stride, overlap };
- foreach_overlappable_nb_above(cm, (MACROBLOCKD *)xd,
- max_neighbor_obmc[mi_size_wide_log2[bsize]],
- calc_target_weighted_pred_above, &ctxt);
+ foreach_overlappable_nb_above(
+ cm, (MACROBLOCKD *)xd, max_neighbor_obmc[mi_size_wide_log2[bsize]],
+ calc_target_weighted_pred_above, &ctxt, false);
}
for (int i = 0; i < bw * bh; ++i) {
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 17b043f..de2167f 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -177,17 +177,38 @@
static INLINE void av1_copy_usable_ref_mv_stack_and_weight(
const MACROBLOCKD *xd, MB_MODE_INFO_EXT *const mbmi_ext,
MV_REFERENCE_FRAME ref_frame) {
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (xd->mi[0]->skip_mode) {
memcpy(&(mbmi_ext->skip_mvp_candidate_list), &(xd->skip_mvp_candidate_list),
sizeof(xd->skip_mvp_candidate_list));
return;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_SEP_COMP_DRL
+ if (has_second_drl(xd->mi[0])) {
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame);
+ if (rf[1] < 0) rf[1] = 0;
+ memcpy(mbmi_ext->weight[rf[0]], xd->weight[rf[0]],
+ USABLE_REF_MV_STACK_SIZE * sizeof(xd->weight[0][0]));
+ memcpy(mbmi_ext->ref_mv_stack[rf[0]], xd->ref_mv_stack[rf[0]],
+ USABLE_REF_MV_STACK_SIZE * sizeof(xd->ref_mv_stack[0][0]));
+ memcpy(mbmi_ext->weight[rf[1]], xd->weight[rf[1]],
+ USABLE_REF_MV_STACK_SIZE * sizeof(xd->weight[0][0]));
+ memcpy(mbmi_ext->ref_mv_stack[rf[1]], xd->ref_mv_stack[rf[1]],
+ USABLE_REF_MV_STACK_SIZE * sizeof(xd->ref_mv_stack[0][0]));
+ } else {
+ memcpy(mbmi_ext->weight[ref_frame], xd->weight[ref_frame],
+ USABLE_REF_MV_STACK_SIZE * sizeof(xd->weight[0][0]));
+ memcpy(mbmi_ext->ref_mv_stack[ref_frame], xd->ref_mv_stack[ref_frame],
+ USABLE_REF_MV_STACK_SIZE * sizeof(xd->ref_mv_stack[0][0]));
+ }
+#else
memcpy(mbmi_ext->weight[ref_frame], xd->weight[ref_frame],
USABLE_REF_MV_STACK_SIZE * sizeof(xd->weight[0][0]));
memcpy(mbmi_ext->ref_mv_stack[ref_frame], xd->ref_mv_stack[ref_frame],
USABLE_REF_MV_STACK_SIZE * sizeof(xd->ref_mv_stack[0][0]));
+#endif // CONFIG_SEP_COMP_DRL
}
#define PRUNE_SINGLE_REFS 0
@@ -301,26 +322,52 @@
static INLINE void av1_copy_mbmi_ext_to_mbmi_ext_frame(
MB_MODE_INFO_EXT_FRAME *mbmi_ext_best,
const MB_MODE_INFO_EXT *const mbmi_ext,
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SEP_COMP_DRL
+ MB_MODE_INFO *mbmi,
+#endif // CONFIG_SEP_COMP_DRL
+#if CONFIG_SKIP_MODE_ENHANCEMENT
uint8_t skip_mode,
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
uint8_t ref_frame_type) {
-#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#if CONFIG_SKIP_MODE_ENHANCEMENT
if (skip_mode) {
memcpy(&(mbmi_ext_best->skip_mvp_candidate_list),
&(mbmi_ext->skip_mvp_candidate_list),
sizeof(mbmi_ext->skip_mvp_candidate_list));
return;
}
-#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
+#endif // CONFIG_SKIP_MODE_ENHANCEMENT
+#if CONFIG_SEP_COMP_DRL
+ MV_REFERENCE_FRAME rf[2];
+ av1_set_ref_frame(rf, ref_frame_type);
+ if (!has_second_drl(mbmi))
+ rf[0] = ref_frame_type; //????????????? need to know how encoder work,
+ // whether the mode has been set
+ memcpy(mbmi_ext_best->ref_mv_stack[0], mbmi_ext->ref_mv_stack[rf[0]],
+ sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
+ memcpy(mbmi_ext_best->weight[0], mbmi_ext->weight[rf[0]],
+ sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
+ mbmi_ext_best->ref_mv_count[0] = mbmi_ext->ref_mv_count[rf[0]];
+
+ if (has_second_drl(mbmi)) {
+ assert(rf[0] == mbmi->ref_frame[0]);
+ assert(rf[1] == mbmi->ref_frame[1]);
+ memcpy(mbmi_ext_best->ref_mv_stack[1], mbmi_ext->ref_mv_stack[rf[1]],
+ sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
+ memcpy(mbmi_ext_best->weight[1], mbmi_ext->weight[rf[1]],
+ sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
+ mbmi_ext_best->ref_mv_count[1] = mbmi_ext->ref_mv_count[rf[1]];
+ }
+#else
memcpy(mbmi_ext_best->ref_mv_stack, mbmi_ext->ref_mv_stack[ref_frame_type],
sizeof(mbmi_ext->ref_mv_stack[USABLE_REF_MV_STACK_SIZE]));
memcpy(mbmi_ext_best->weight, mbmi_ext->weight[ref_frame_type],
sizeof(mbmi_ext->weight[USABLE_REF_MV_STACK_SIZE]));
- mbmi_ext_best->mode_context = mbmi_ext->mode_context[ref_frame_type];
mbmi_ext_best->ref_mv_count = mbmi_ext->ref_mv_count[ref_frame_type];
+#endif // CONFIG_SEP_COMP_DRL
+ mbmi_ext_best->mode_context = mbmi_ext->mode_context[ref_frame_type];
memcpy(mbmi_ext_best->global_mvs, mbmi_ext->global_mvs,
sizeof(mbmi_ext->global_mvs));
diff --git a/av1/encoder/rdopt_utils.h b/av1/encoder/rdopt_utils.h
index de13e91..b3861c8 100644
--- a/av1/encoder/rdopt_utils.h
+++ b/av1/encoder/rdopt_utils.h
@@ -459,10 +459,19 @@
winner_mode_stats[mode_idx].rd_cost = *rd_cost;
if (txfm_search_done) {
+#if CONFIG_SKIP_TXFM_OPT
+ winner_mode_stats[mode_idx].rate_y =
+ rd_cost_y->rate +
+ (!is_intra_mode
+ ? x->mode_costs
+ .skip_txfm_cost[skip_ctx][rd_cost->skip_txfm || skip_txfm]
+ : 0);
+#else
winner_mode_stats[mode_idx].rate_y =
rd_cost_y->rate +
x->mode_costs
.skip_txfm_cost[skip_ctx][rd_cost->skip_txfm || skip_txfm];
+#endif // CONFIG_SKIP_TXFM_OPT
winner_mode_stats[mode_idx].rate_uv = rd_cost_uv->rate;
}
}
diff --git a/av1/encoder/reconinter_enc.c b/av1/encoder/reconinter_enc.c
index 32bb328..655fcec 100644
--- a/av1/encoder/reconinter_enc.c
+++ b/av1/encoder/reconinter_enc.c
@@ -38,6 +38,19 @@
uint16_t **mc_buf, uint16_t **pre,
SubpelParams *subpel_params,
int *src_stride) {
+
+#if CONFIG_REFINEMV
+ if (inter_pred_params->use_ref_padding) {
+ common_calc_subpel_params_and_extend(
+ src_mv, inter_pred_params, xd, mi_x, mi_y, ref,
+#if CONFIG_OPTFLOW_REFINEMENT
+ use_optflow_refinement,
+#endif // CONFIG_OPTFLOW_REFINEMENT
+ mc_buf, pre, subpel_params, src_stride);
+ return;
+ }
+#endif // CONFIG_REFINEMV
+
// These are part of the function signature to use this function through a
// function pointer. See typedef of 'CalcSubpelParamsFunc'.
(void)xd;
@@ -87,12 +100,47 @@
subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
subpel_params->xs = sf->x_step_q4;
subpel_params->ys = sf->y_step_q4;
+
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ // Get reference block top left coordinate.
+ subpel_params->x0 = pos_x >> SCALE_SUBPEL_BITS;
+ subpel_params->y0 = pos_y >> SCALE_SUBPEL_BITS;
+ // Get reference block bottom right coordinate.
+ subpel_params->x1 =
+ ((pos_x + (inter_pred_params->block_width - 1) * subpel_params->xs) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+ subpel_params->y1 = ((pos_y + (inter_pred_params->block_height - 1) *
+ subpel_params->ys) >>
+ SCALE_SUBPEL_BITS) +
+ 1;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
+
*pre = pre_buf->buf0 + (pos_y >> SCALE_SUBPEL_BITS) * pre_buf->stride +
(pos_x >> SCALE_SUBPEL_BITS);
#if CONFIG_OPTFLOW_REFINEMENT || 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;
+
+#if CONFIG_REFINEMV
+#if CONFIG_OPTFLOW_REFINEMENT
+ const int bw = inter_pred_params->original_pu_width;
+ const int bh = inter_pred_params->original_pu_height;
+ const MV mv_q4 = clamp_mv_to_umv_border_sb(
+ xd, src_mv, bw, bh, use_optflow_refinement,
+ inter_pred_params->subsampling_x, inter_pred_params->subsampling_y);
+#else
+ const int bw = inter_pred_params->original_pu_width;
+ const int bh = inter_pred_params->original_pu_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);
+#endif // CONFIG_OPTFLOW_REFINEMENT
+
+#else
#if CONFIG_OPTFLOW_REFINEMENT
const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
: inter_pred_params->block_width;
@@ -108,11 +156,25 @@
xd, src_mv, bw, bh, inter_pred_params->subsampling_x,
inter_pred_params->subsampling_y);
#endif // CONFIG_OPTFLOW_REFINEMENT
+#endif // CONFIG_REFINEMV
+
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;
+#if CONFIG_D071_IMP_MSK_BLD
+ if (inter_pred_params->border_data.enable_bacp) {
+ subpel_params->x0 = pos_x >> SUBPEL_BITS;
+ subpel_params->y0 = pos_y >> SUBPEL_BITS;
+
+ // Get reference block bottom right coordinate.
+ subpel_params->x1 =
+ (pos_x >> SUBPEL_BITS) + (inter_pred_params->block_width - 1) + 1;
+ subpel_params->y1 =
+ (pos_y >> SUBPEL_BITS) + (inter_pred_params->block_height - 1) + 1;
+ }
+#endif // CONFIG_D071_IMP_MSK_BLD
*pre = pre_buf->buf0 + (pos_y >> SUBPEL_BITS) * pre_buf->stride +
(pos_x >> SUBPEL_BITS);
}
@@ -128,18 +190,26 @@
0 /* mi_y */, 0 /* ref */, NULL /* mc_buf */, enc_calc_subpel_params);
}
-static void enc_build_inter_predictors(const AV1_COMMON *cm, MACROBLOCKD *xd,
- int plane, MB_MODE_INFO *mi,
+void enc_build_inter_predictors(const AV1_COMMON *cm, MACROBLOCKD *xd,
+ int plane, MB_MODE_INFO *mi,
#if CONFIG_BAWP
- const BUFFER_SET *ctx,
+ const BUFFER_SET *ctx,
#endif
- int bw, int bh, int mi_x, int mi_y) {
+#if CONFIG_REFINEMV
+ int build_for_refine_mv_only,
+#endif // CONFIG_REFINEMV
+ int bw, int bh, int mi_x, int mi_y) {
av1_build_inter_predictors(cm, xd, plane, mi,
#if CONFIG_BAWP
ctx,
#endif
+#if CONFIG_REFINEMV
+ build_for_refine_mv_only,
+#endif // CONFIG_REFINEMV
0 /* build_for_obmc */, bw, bh, mi_x, mi_y,
- NULL /* mc_buf */, enc_calc_subpel_params);
+ NULL /* mc_buf */,
+
+ enc_calc_subpel_params);
}
void av1_enc_build_inter_predictor_y(MACROBLOCKD *xd, int mi_row, int mi_col) {
@@ -168,17 +238,60 @@
int mi_row, int mi_col,
const BUFFER_SET *ctx, BLOCK_SIZE bsize,
int plane_from, int plane_to) {
+#if CONFIG_REFINEMV
+ MB_MODE_INFO *mbmi = xd->mi[0];
+
+ int is_refinemv_supported =
+ mbmi->refinemv_flag && !is_intrabc_block(mbmi, xd->tree_type);
+
+ int need_chroma_dmvr = xd->is_chroma_ref &&
+ (plane_from != 0 || plane_to != 0) &&
+ is_refinemv_supported;
+ assert(IMPLIES(need_chroma_dmvr, !is_interintra_pred(mbmi)));
+
+ if (need_chroma_dmvr && default_refinemv_modes(mbmi))
+ need_chroma_dmvr &= (mbmi->comp_group_idx == 0 &&
+ mbmi->interinter_comp.type == COMPOUND_AVERAGE);
+
+ if (need_chroma_dmvr) {
+ fill_subblock_refine_mv(xd->refinemv_subinfo, xd->plane[0].width,
+ xd->plane[0].height, mbmi->mv[0].as_mv,
+ mbmi->mv[1].as_mv);
+
+ // if luma build is not available, we need to get refinemv based on luma
+ // need to search DMVR here based on luma plane
+ if (plane_from != 0) {
+#if CONFIG_BAWP
+ enc_build_inter_predictors(cm, xd, 0, xd->mi[0], ctx, 1,
+ xd->plane[0].width, xd->plane[0].height,
+ mi_col * MI_SIZE, mi_row * MI_SIZE);
+#else
+ enc_build_inter_predictors(cm, xd, 0, xd->mi[0], 1, xd->plane[0].width,
+ xd->plane[0].height, mi_col * MI_SIZE,
+ mi_row * MI_SIZE);
+#endif
+ }
+ }
+#endif // CONFIG_REFINEMV
+
for (int plane = plane_from; plane <= plane_to; ++plane) {
if (plane && !xd->is_chroma_ref) break;
const int mi_x = mi_col * MI_SIZE;
const int mi_y = mi_row * MI_SIZE;
#if CONFIG_BAWP
enc_build_inter_predictors(cm, xd, plane, xd->mi[0], ctx,
+#if CONFIG_REFINEMV
+ 0,
+#endif // CONFIG_REFINEMV
xd->plane[plane].width, xd->plane[plane].height,
mi_x, mi_y);
#else
- enc_build_inter_predictors(cm, xd, plane, xd->mi[0], xd->plane[plane].width,
- xd->plane[plane].height, mi_x, mi_y);
+ enc_build_inter_predictors(cm, xd, plane, xd->mi[0],
+#if CONFIG_REFINEMV
+ 0,
+#endif // CONFIG_REFINEMV
+ xd->plane[plane].width, xd->plane[plane].height,
+ mi_x, mi_y);
#endif
if (is_interintra_pred(xd->mi[0])) {
@@ -285,7 +398,7 @@
BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y];
foreach_overlappable_nb_above(cm, xd,
max_neighbor_obmc[mi_size_wide_log2[bsize]],
- build_obmc_prediction, &ctxt);
+ build_obmc_prediction, &ctxt, false);
}
void av1_build_prediction_by_left_preds(const AV1_COMMON *cm, MACROBLOCKD *xd,
diff --git a/av1/encoder/reconinter_enc.h b/av1/encoder/reconinter_enc.h
index 2309f16..5f3de5f 100644
--- a/av1/encoder/reconinter_enc.h
+++ b/av1/encoder/reconinter_enc.h
@@ -34,6 +34,16 @@
void av1_enc_build_inter_predictor_y(MACROBLOCKD *xd, int mi_row, int mi_col);
+void enc_build_inter_predictors(const AV1_COMMON *cm, MACROBLOCKD *xd,
+ int plane, MB_MODE_INFO *mi,
+#if CONFIG_BAWP
+ const BUFFER_SET *ctx,
+#endif
+#if CONFIG_REFINEMV
+ int build_for_refine_mv_only,
+#endif // CONFIG_REFINEMV
+ int bw, int bh, int mi_x, int mi_y);
+
// Build one inter predictor. It is called for building predictor for single
// reference case, or just the 1st or 2nd reference in compound reference case.
// Can build both regular and masked predictors.
diff --git a/av1/encoder/segmentation.c b/av1/encoder/segmentation.c
index cabf66e..7da61f4 100644
--- a/av1/encoder/segmentation.c
+++ b/av1/encoder/segmentation.c
@@ -100,6 +100,9 @@
const int bw = mi_size_wide[bsize], bh = mi_size_high[bsize];
const int hbw = bw / 2, hbh = bh / 2;
const int qbw = bw / 4, qbh = bh / 4;
+#if CONFIG_UNEVEN_4WAY
+ const int ebw = bw / 8, ebh = bh / 8;
+#endif // CONFIG_UNEVEN_4WAY
#else
const int bs = mi_size_wide[bsize], hbs = bs / 2;
const int qbs = bs / 4;
@@ -142,21 +145,55 @@
case PARTITION_HORZ_3:
CSEGS_RECURSIVE(0, 0, ptree->sub_tree[tree_idx++]);
CSEGS_RECURSIVE(qbh, 0, ptree->sub_tree[tree_idx++]);
-#if CONFIG_H_PARTITION
CSEGS_RECURSIVE(qbh, hbw, ptree->sub_tree[tree_idx++]);
-#endif // CONFIG_H_PARTITION
if (mi_row + 3 * qbh < mi_params->mi_rows)
CSEGS_RECURSIVE(3 * qbh, 0, ptree->sub_tree[tree_idx++]);
break;
case PARTITION_VERT_3:
CSEGS_RECURSIVE(0, 0, ptree->sub_tree[tree_idx++]);
CSEGS_RECURSIVE(0, qbw, ptree->sub_tree[tree_idx++]);
-#if CONFIG_H_PARTITION
CSEGS_RECURSIVE(hbh, qbw, ptree->sub_tree[tree_idx++]);
-#endif // CONFIG_H_PARTITION
if (mi_col + 3 * qbw < mi_params->mi_cols)
CSEGS_RECURSIVE(0, 3 * qbw, ptree->sub_tree[tree_idx++]);
break;
+#if CONFIG_UNEVEN_4WAY
+ case PARTITION_HORZ_4A:
+ CSEGS_RECURSIVE(0, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_row + ebh < mi_params->mi_rows)
+ CSEGS_RECURSIVE(ebh, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_row + 3 * ebh < mi_params->mi_rows)
+ CSEGS_RECURSIVE(3 * ebh, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_row + 7 * ebh < mi_params->mi_rows)
+ CSEGS_RECURSIVE(7 * ebh, 0, ptree->sub_tree[tree_idx++]);
+ break;
+ case PARTITION_HORZ_4B:
+ CSEGS_RECURSIVE(0, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_row + ebh < mi_params->mi_rows)
+ CSEGS_RECURSIVE(ebh, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_row + 5 * ebh < mi_params->mi_rows)
+ CSEGS_RECURSIVE(5 * ebh, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_row + 7 * ebh < mi_params->mi_rows)
+ CSEGS_RECURSIVE(7 * ebh, 0, ptree->sub_tree[tree_idx++]);
+ break;
+ case PARTITION_VERT_4A:
+ CSEGS_RECURSIVE(0, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_col + ebw < mi_params->mi_cols)
+ CSEGS_RECURSIVE(0, ebw, ptree->sub_tree[tree_idx++]);
+ if (mi_col + 3 * ebw < mi_params->mi_cols)
+ CSEGS_RECURSIVE(0, 3 * ebw, ptree->sub_tree[tree_idx++]);
+ if (mi_col + 7 * ebw < mi_params->mi_cols)
+ CSEGS_RECURSIVE(0, 7 * ebw, ptree->sub_tree[tree_idx++]);
+ break;
+ case PARTITION_VERT_4B:
+ CSEGS_RECURSIVE(0, 0, ptree->sub_tree[tree_idx++]);
+ if (mi_col + ebw < mi_params->mi_cols)
+ CSEGS_RECURSIVE(0, ebw, ptree->sub_tree[tree_idx++]);
+ if (mi_col + 5 * ebw < mi_params->mi_cols)
+ CSEGS_RECURSIVE(0, 5 * ebw, ptree->sub_tree[tree_idx++]);
+ if (mi_col + 7 * ebw < mi_params->mi_cols)
+ CSEGS_RECURSIVE(0, 7 * ebw, ptree->sub_tree[tree_idx++]);
+ break;
+#endif // CONFIG_UNEVEN_4WAY
#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_NONE: CSEGS(bs, bs, 0, 0); break;
case PARTITION_HORZ:
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index 93c839a..fa88d44 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -123,16 +123,6 @@
{ 1, 1, 0 },
{ 1, 1, 1 } };
-// This table holds the maximum number of reference frames for global motion.
-// The table is indexed as per the speed feature 'gm_search_type'.
-// 0 : All reference frames are allowed.
-// 1 : All reference frames except L2 and L3 are allowed.
-// 2 : All reference frames except L2, L3 and ARF2 are allowed.
-// 3 : No reference frame is allowed.
-static int gm_available_reference_frames[GM_DISABLE_SEARCH + 1] = {
- INTER_REFS_PER_FRAME, INTER_REFS_PER_FRAME - 2, INTER_REFS_PER_FRAME - 3, 0
-};
-
// Intra only frames, golden frames (except alt ref overlays) and
// alt ref frames tend to be coded at a higher than ambient quality
static int frame_is_boosted(const AV1_COMP *cpi) {
@@ -353,8 +343,9 @@
#endif
// Speed 0 for all speed features that give neutral coding performance change.
- sf->gm_sf.gm_disable_recode = 1;
- sf->gm_sf.gm_search_type = GM_REDUCED_REF_SEARCH_SKIP_LEV2;
+ sf->gm_sf.max_ref_frames = boosted ? 4 : 2;
+ sf->gm_sf.prune_ref_frame_for_gm_search = boosted ? 0 : 1;
+ sf->gm_sf.disable_gm_search_based_on_stats = 1;
sf->part_sf.less_rectangular_check_level = 1;
#if CONFIG_EXT_RECUR_PARTITIONS
@@ -410,9 +401,6 @@
sf->hl_sf.superres_auto_search_type = SUPERRES_AUTO_DUAL;
if (speed >= 1) {
- sf->gm_sf.gm_search_type = GM_REDUCED_REF_SEARCH_SKIP_LEV3;
- 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
@@ -514,7 +502,7 @@
sf->hl_sf.high_precision_mv_usage = CURRENT_Q;
sf->hl_sf.recode_loop = ALLOW_RECODE_KFARFGF;
- sf->gm_sf.gm_search_type = GM_DISABLE_SEARCH;
+ sf->gm_sf.max_ref_frames = 0;
sf->part_sf.less_rectangular_check_level = 2;
sf->part_sf.simple_motion_search_prune_agg = 1;
@@ -715,10 +703,9 @@
}
static AOM_INLINE void init_gm_sf(GLOBAL_MOTION_SPEED_FEATURES *gm_sf) {
- gm_sf->selective_ref_gm = 1;
- gm_sf->gm_search_type = GM_FULL_SEARCH;
- gm_sf->gm_disable_recode = 0;
+ gm_sf->max_ref_frames = INTER_REFS_PER_FRAME;
gm_sf->prune_ref_frame_for_gm_search = 0;
+ gm_sf->disable_gm_search_based_on_stats = 0;
}
static AOM_INLINE void init_part_sf(PARTITION_SPEED_FEATURES *part_sf) {
@@ -759,13 +746,19 @@
part_sf->early_term_after_none_split = 0;
#if CONFIG_EXT_RECUR_PARTITIONS
part_sf->prune_rect_with_none_rd = 0;
- part_sf->prune_part_3_with_part_none = 0;
- part_sf->prune_part_3_with_part_rect = 0;
+ part_sf->prune_ext_part_with_part_none = 0;
+ part_sf->prune_ext_part_with_part_rect = 0;
+#if CONFIG_UNEVEN_4WAY
+ part_sf->prune_part_4_with_partition_boundary = 0;
+ part_sf->prune_part_4_horz_or_vert = 0;
+ part_sf->prune_part_4_with_part_3 = 0;
+#endif // CONFIG_UNEVEN_4WAY
part_sf->two_pass_partition_search = 0;
part_sf->prune_rect_with_ml = 0;
part_sf->end_part_search_after_consec_failures = 0;
part_sf->ext_recur_depth = INT_MAX;
part_sf->prune_rect_with_split_depth = 0;
+ part_sf->prune_part_h_with_partition_boundary = 0;
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
@@ -853,6 +846,10 @@
#if CONFIG_EXT_RECUR_PARTITIONS
inter_sf->reuse_erp_mode_flag = 0;
#endif // CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ inter_sf->prune_warpmv_prob_thresh = 32;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
}
static AOM_INLINE void init_interp_sf(INTERP_FILTER_SPEED_FEATURES *interp_sf) {
@@ -1053,17 +1050,22 @@
sf->part_sf.simple_motion_search_early_term_none = 1;
AOM_FALLTHROUGH_INTENDED;
case 5:
+ sf->part_sf.prune_part_h_with_partition_boundary = true;
+ sf->part_sf.adaptive_partition_search_order = true;
sf->tx_sf.use_largest_tx_size_for_small_bsize = true;
// TODO(chiyotsai@google.com): This speed feature causes large regression
// on b2 testset. Disable this for now until we figure out how to avoid
// the loss.
// sf->part_sf.end_part_search_after_consec_failures = 1;
AOM_FALLTHROUGH_INTENDED;
- case 4:
- sf->part_sf.prune_part_3_with_part_rect = 1;
+ case 4: sf->part_sf.prune_ext_part_with_part_rect = 1;
+#if CONFIG_UNEVEN_4WAY
+ sf->part_sf.prune_part_4_horz_or_vert = 1;
+ sf->part_sf.prune_part_4_with_part_3 = 1;
+#endif // CONFIG_UNEVEN_4WAY
AOM_FALLTHROUGH_INTENDED;
case 3:
- sf->part_sf.prune_part_3_with_part_none = 1;
+ sf->part_sf.prune_ext_part_with_part_none = 1;
AOM_FALLTHROUGH_INTENDED;
case 2:
sf->inter_sf.prune_ref_frame_for_rect_partitions =
@@ -1249,9 +1251,8 @@
// Disable the speed feature 'prune_ref_frame_for_gm_search' to achieve
// better parallelism when number of threads available are greater than or
// equal to maximum number of reference frames allowed for global motion.
- if (sf->gm_sf.gm_search_type != GM_DISABLE_SEARCH &&
- (cpi->oxcf.max_threads >=
- gm_available_reference_frames[sf->gm_sf.gm_search_type]))
+ if (sf->gm_sf.max_ref_frames > 0 &&
+ cpi->oxcf.max_threads >= sf->gm_sf.max_ref_frames)
sf->gm_sf.prune_ref_frame_for_gm_search = 0;
}
}
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index 61e21d1..e3a6391 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -33,13 +33,6 @@
} MESH_PATTERN;
enum {
- GM_FULL_SEARCH,
- GM_REDUCED_REF_SEARCH_SKIP_LEV2,
- GM_REDUCED_REF_SEARCH_SKIP_LEV3,
- GM_DISABLE_SEARCH
-} UENUM1BYTE(GM_SEARCH_TYPE);
-
-enum {
INTRA_ALL = (1 << DC_PRED) | (1 << V_PRED) | (1 << H_PRED) | (1 << D45_PRED) |
(1 << D135_PRED) | (1 << D113_PRED) | (1 << D157_PRED) |
(1 << D203_PRED) | (1 << D67_PRED) | (1 << SMOOTH_PRED) |
@@ -369,20 +362,16 @@
} TPL_SPEED_FEATURES;
typedef struct GLOBAL_MOTION_SPEED_FEATURES {
- // Do not compute the global motion parameters for a LAST2_FRAME or
- // LAST3_FRAME if the GOLDEN_FRAME is closer and it has a non identity
- // global model.
- int selective_ref_gm;
-
- GM_SEARCH_TYPE gm_search_type;
-
- // whether to disable the global motion recode loop
- int gm_disable_recode;
+ int max_ref_frames;
// During global motion estimation, prune remaining reference frames in a
// given direction(past/future), if the evaluated ref_frame in that direction
// yields gm_type as INVALID/TRANSLATION/IDENTITY
int prune_ref_frame_for_gm_search;
+
+ // Disable global motion estimation based on stats of previous frames in the
+ // GF group
+ int disable_gm_search_based_on_stats;
} GLOBAL_MOTION_SPEED_FEATURES;
typedef struct PARTITION_SPEED_FEATURES {
@@ -496,11 +485,23 @@
// Prunes PARTITION_3 if PARTITION_NONE is used instead of PARTITION_HORZ|VERT
int prune_rect_with_none_rd;
- // Prunes PARTITION_3 if PARTITION_NONE is used instead of PARTITION_HORZ|VERT
- int prune_part_3_with_part_none;
+ // Prunes extended partitions if PARTITION_NONE is used instead of
+ // PARTITION_HORZ|VERT.
+ int prune_ext_part_with_part_none;
- // Prunes PARTITION_3 partition 3 doesn't split in the same direction
- int prune_part_3_with_part_rect;
+ // Prunes extended partitions if rect sub-partitions don't further split in
+ // the same direction.
+ int prune_ext_part_with_part_rect;
+
+#if CONFIG_UNEVEN_4WAY
+ // Prunes PARTITION_HORZ_4A/4B if vertical is the best partition, and
+ // Prunes PARTITION_VERT_4A/4B if horizontal is the best partition.
+ int prune_part_4_horz_or_vert;
+
+ // Prunes PARTITION_HORZ_4A/4B based on PARTITION_HORZ_3 search result, and
+ // Prunes PARTITION_VERT_4A/4B based on PARTITION_VERT_3 search result.
+ int prune_part_4_with_part_3;
+#endif // CONFIG_UNEVEN_4WAY
int two_pass_partition_search;
@@ -516,6 +517,21 @@
// Prune rect partitions if PARTITION_SPLIT goes deep.
int prune_rect_with_split_depth;
+
+ // Search horizontal and vertical split before PARTITION_NONE if the neighbor
+ // blocks are much smaller than the current block size.
+ int adaptive_partition_search_order;
+
+ // Prune h partition types if their resulting boundary does not agree with
+ // the current best partition's boundary after searching NONE, HORZ, and VERT.
+ int prune_part_h_with_partition_boundary;
+
+#if CONFIG_UNEVEN_4WAY
+ // Prune r-way partition types if their resulting boundary does not agree with
+ // the current best partition's boundary after searching NONE, HORZ, VERT, and
+ // H-parts.
+ int prune_part_4_with_partition_boundary;
+#endif // CONFIG_UNEVEN_4WAY
#endif // CONFIG_EXT_RECUR_PARTITIONS
} PARTITION_SPEED_FEATURES;
@@ -725,6 +741,11 @@
// Prune warped motion search using previous frame stats.
int prune_warped_prob_thresh;
+#if CONFIG_CWG_D067_IMPROVED_WARP
+ // Prune warpmv with mvd search using previous frame stats.
+ int prune_warpmv_prob_thresh;
+#endif // CONFIG_CWG_D067_IMPROVED_WARP
+
// Enable/disable interintra wedge search.
int disable_wedge_interintra_search;
diff --git a/av1/encoder/subgop.c b/av1/encoder/subgop.c
index 025fb82..9240d6c 100644
--- a/av1/encoder/subgop.c
+++ b/av1/encoder/subgop.c
@@ -195,9 +195,15 @@
switch (code) {
case FRAME_TYPE_INO_VISIBLE:
case FRAME_TYPE_INO_REPEAT:
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ case FRAME_TYPE_OOO_UNFILTERED: return 1;
+ case FRAME_TYPE_INO_SHOWEXISTING:
+ case FRAME_TYPE_OOO_FILTERED: return 0;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
case FRAME_TYPE_INO_SHOWEXISTING: return 1;
case FRAME_TYPE_OOO_FILTERED:
case FRAME_TYPE_OOO_UNFILTERED: return 0;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
default: assert(0 && "Invalid frame type code"); return 0;
}
}
@@ -211,9 +217,24 @@
// Each disp frame index must be shown exactly once and in ascending order
int last_visible = 0;
for (int s = 0; s < config->num_steps; ++s) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (config->step[s].type_code == FRAME_TYPE_INO_VISIBLE ||
+ config->step[s].type_code == FRAME_TYPE_INO_REPEAT) {
+ int updated_last_visible = config->step[s].disp_frame_idx;
+ do {
+ last_visible = updated_last_visible;
+ for (int k = 0; k < s; ++k) {
+ if (is_visible(config->step[k].type_code) &&
+ config->step[k].disp_frame_idx == last_visible + 1) {
+ updated_last_visible = config->step[k].disp_frame_idx;
+ }
+ }
+ } while (last_visible != updated_last_visible);
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (is_visible(config->step[s].type_code)) {
if (config->step[s].disp_frame_idx != last_visible + 1) return 0;
last_visible = config->step[s].disp_frame_idx;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
}
if (last_visible != config->num_frames) return 0;
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index f00c3e2..0e7fdce 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -98,7 +98,7 @@
// Save input state.
#if CONFIG_FLEX_MVRES
const AV1_COMMON *cm = &cpi->common;
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -153,7 +153,7 @@
&baseline_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
@@ -226,7 +226,7 @@
subblock_size, &baseline_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
@@ -1111,9 +1111,19 @@
// Set showable frame.
if (filter_frame_lookahead_idx >= 0) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // When enable_frame_output_order == 1, it is intended to set showable_frame
+ // to one only for the coded frames to be outputted. When enable_overlay ==
+ // 1, showable_frame of the filtered frame is set to zero by default.
+ cpi->common.showable_frame =
+ (!cpi->oxcf.ref_frm_cfg.enable_frame_output_order &&
+ (num_frames_for_filtering == 1 || is_second_arf)) ||
+ cpi->oxcf.ref_frm_cfg.enable_frame_output_order ||
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
cpi->common.showable_frame = num_frames_for_filtering == 1 ||
is_second_arf ||
- (cpi->oxcf.algo_cfg.enable_overlay == 0);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ (cpi->oxcf.algo_cfg.enable_overlay == 0);
}
// Do filtering.
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 8f95c72..221054e 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -28,7 +28,7 @@
#include "av1/encoder/rdopt.h"
#include "av1/encoder/tokenize.h"
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
static int cost_and_tokenize_map(Av1ColorMapParam *param, TokenExtra **t,
int plane, int calc_rate, int allow_update_cdf,
FRAME_COUNTS *counts, MapCdf map_pb_cdf,
@@ -157,7 +157,7 @@
if (calc_rate) return this_rate;
return 0;
}
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
static void get_palette_params(const MACROBLOCK *const x, int plane,
BLOCK_SIZE bsize, Av1ColorMapParam *params) {
@@ -167,12 +167,12 @@
params->color_map = xd->plane[plane].color_index_map;
params->map_cdf = plane ? xd->tile_ctx->palette_uv_color_index_cdf
: xd->tile_ctx->palette_y_color_index_cdf;
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
params->identity_row_cdf = plane ? xd->tile_ctx->identity_row_cdf_uv
: xd->tile_ctx->identity_row_cdf_y;
params->identity_row_cost = plane ? &x->mode_costs.palette_uv_row_flag_cost
: &x->mode_costs.palette_y_row_flag_cost;
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
params->color_cost = plane ? &x->mode_costs.palette_uv_color_cost
: &x->mode_costs.palette_y_color_cost;
params->n_colors = pmi->palette_size[plane];
@@ -200,7 +200,7 @@
get_color_map_params(x, plane, bsize, tx_size, type, &color_map_params);
MapCdf map_pb_cdf = plane ? x->tile_pb_ctx->palette_uv_color_index_cdf
: x->tile_pb_ctx->palette_y_color_index_cdf;
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
IdentityRowCdf eq_row_pb_cdf = plane ? x->tile_pb_ctx->identity_row_cdf_uv
: x->tile_pb_ctx->identity_row_cdf_y;
return cost_and_tokenize_map(&color_map_params, NULL, plane, 1, 0, NULL,
@@ -208,7 +208,7 @@
#else
return cost_and_tokenize_map(&color_map_params, NULL, plane, 1, 0, NULL,
map_pb_cdf);
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
}
void av1_tokenize_color_map(const MACROBLOCK *const x, int plane,
@@ -218,7 +218,7 @@
assert(plane == 0 || plane == 1);
Av1ColorMapParam color_map_params;
get_color_map_params(x, plane, bsize, tx_size, type, &color_map_params);
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
MapCdf map_pb_cdf = plane ? x->tile_pb_ctx->palette_uv_color_index_cdf
: x->tile_pb_ctx->palette_y_color_index_cdf;
IdentityRowCdf eq_row_pb_cdf = plane ? x->tile_pb_ctx->identity_row_cdf_uv
@@ -234,7 +234,7 @@
: x->tile_pb_ctx->palette_y_color_index_cdf;
cost_and_tokenize_map(&color_map_params, t, plane, 0, allow_update_cdf,
counts, map_pb_cdf);
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
}
static void tokenize_vartx(ThreadData *td, TX_SIZE tx_size,
diff --git a/av1/encoder/tokenize.h b/av1/encoder/tokenize.h
index 675b1f1..b886ea6 100644
--- a/av1/encoder/tokenize.h
+++ b/av1/encoder/tokenize.h
@@ -24,10 +24,10 @@
typedef struct {
aom_cdf_prob *color_map_cdf;
uint8_t token;
-#if CONFIG_NEW_COLOR_MAP_CODING
+#if CONFIG_PALETTE_IMPROVEMENTS
aom_cdf_prob *identity_row_cdf;
uint8_t identity_row_flag;
-#endif // CONFIG_NEW_COLOR_MAP_CODING
+#endif // CONFIG_PALETTE_IMPROVEMENTS
} TokenExtra;
typedef struct {
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index f91ed5b..a09040c 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -156,7 +156,7 @@
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = cm->features.fr_mv_precision;
full_pel_lower_mv_precision(&start_mv, pb_mv_precision);
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
const int is_ibc_cost = 0;
#endif
#endif
@@ -165,7 +165,7 @@
av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, ¢er_mv,
#if CONFIG_FLEX_MVRES
pb_mv_precision,
-#if CONFIG_BVCOST_UPDATE
+#if CONFIG_IBC_BV_IMPROVEMENT
is_ibc_cost,
#endif
#endif
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c
index fe75770..0f8f819 100644
--- a/av1/encoder/tx_search.c
+++ b/av1/encoder/tx_search.c
@@ -1192,6 +1192,12 @@
best_tx_type != DCT_DCT) {
update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (plane == 0 && x->plane[plane].eobs[block] == 1 &&
+ best_tx_type != DCT_DCT && !is_inter) {
+ update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
}
@@ -1357,10 +1363,10 @@
static uint32_t get_intra_txb_hash(MACROBLOCK *x, int plane, int blk_row,
int blk_col, BLOCK_SIZE plane_bsize,
TX_SIZE tx_size
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
,
PREDICTION_MODE intra_dir
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
) {
int16_t tmp_data[64 * 64];
const int diff_stride = block_size_wide[plane_bsize];
@@ -1380,11 +1386,11 @@
}
CRC32C *crc = &x->txfm_search_info.mb_rd_record.crc_calculator;
const uint32_t hash = av1_get_crc32c_value(crc, hash_data, 2 * txb_w * txb_h);
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
return (hash << 9) + (tx_size << 4) + (intra_dir);
#else
return (hash << 5) + tx_size;
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
}
// pruning thresholds for prune_txk_type and prune_txk_type_separ
@@ -1404,7 +1410,7 @@
frame_is_intra_only(&cpi->common) &&
!is_inter_block(xd->mi[0], xd->tree_type) && plane == 0 &&
tx_size_wide[tx_size] == tx_size_high[tx_size]);
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
MB_MODE_INFO *mbmi = xd->mi[0];
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
@@ -1417,7 +1423,7 @@
#else
const uint32_t intra_hash =
get_intra_txb_hash(x, plane, blk_row, blk_col, plane_bsize, tx_size);
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
const int intra_hash_idx =
find_tx_size_rd_info(&txfm_info->txb_rd_record_intra, intra_hash);
*intra_txb_rd_info =
@@ -2087,14 +2093,14 @@
const AV1_COMMON *cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *mbmi = xd->mi[0];
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
intra_dir =
fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode];
else
intra_dir = mbmi->mode;
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
const TxfmSearchParams *txfm_params = &x->txfm_search_params;
const int is_inter = is_inter_block(mbmi, xd->tree_type);
const int fast_tx_search = ftxs_mode & FTXS_DCT_AND_1D_DCT_ONLY;
@@ -2120,12 +2126,12 @@
av1_get_tx_type(xd, get_plane_type(plane), blk_row, blk_col, tx_size,
cm->features.reduced_tx_set_used);
}
-#if !CONFIG_ATC_NEWTXSETS
+#if !CONFIG_ATC
PREDICTION_MODE intra_dir =
mbmi->filter_intra_mode_info.use_filter_intra
? fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode]
: mbmi->mode;
-#endif // !CONFIG_ATC_NEWTXSETS
+#endif // !CONFIG_ATC
uint16_t ext_tx_used_flag =
cpi->sf.tx_sf.tx_type_search.use_reduced_intra_txset &&
tx_set_type == EXT_TX_SET_DTT4_IDTX_1DDCT
@@ -2138,7 +2144,7 @@
txk_allowed = DCT_DCT;
}
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
if (!is_inter) {
uint16_t mdtx_mask =
av1_md_trfm_used_flag[av1_size_class[tx_size]]
@@ -2150,6 +2156,9 @@
(1 << DCT_DCT) | (1 << ADST_ADST); // DCT_DCT, ADST_ADST
}
#endif // CONFIG_ATC_REDUCED_TXSET
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (txsize_sqr_up_map[tx_size] == TX_32X32) ext_tx_used_flag |= (1 << IDTX);
+#endif // CONFIG_ATC_DCTX_ALIGNED
}
#if CONFIG_ATC_REDUCED_TXSET
else {
@@ -2158,7 +2167,7 @@
}
}
#endif // CONFIG_ATC_REDUCED_TXSET
-#endif // CONFIG_ATC_NEWTXSETS
+#endif // CONFIG_ATC
if (cpi->oxcf.txfm_cfg.enable_flip_idtx == 0)
ext_tx_used_flag &= DCT_ADST_TX_MASK;
@@ -2207,6 +2216,7 @@
if (plane) {
const CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
assert(cctx_type == CCTX_NONE);
+ (void)cctx_type;
}
#endif // CONFIG_DEBUG && CONFIG_CROSS_CHROMA_TX
@@ -2242,7 +2252,12 @@
}
if (mbmi->fsc_mode[xd->tree_type == CHROMA_PART] &&
- txsize_sqr_up_map[tx_size] < TX_32X32 && plane == PLANE_TYPE_Y) {
+#if CONFIG_ATC_DCTX_ALIGNED
+ txsize_sqr_up_map[tx_size] <= TX_32X32
+#else
+ txsize_sqr_up_map[tx_size] < TX_32X32
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ && plane == PLANE_TYPE_Y) {
txk_allowed = IDTX;
allowed_tx_mask = (1 << txk_allowed);
}
@@ -2381,6 +2396,9 @@
best_rd_stats->skip_txfm = 1;
x->plane[plane].eobs[block] = 0;
+#if CONFIG_ATC_DCTX_ALIGNED
+ x->plane[plane].bobs[block] = 0;
+#endif // CONFIG_ATC_DCTX_ALIGNED
*block_sse = ROUND_POWER_OF_TWO((*block_sse), (xd->bd - 8) * 2);
@@ -2485,6 +2503,9 @@
best_rd_stats->sse = intra_txb_rd_info->sse;
best_rd_stats->skip_txfm = intra_txb_rd_info->eob == 0;
x->plane[plane].eobs[block] = intra_txb_rd_info->eob;
+#if CONFIG_ATC_DCTX_ALIGNED
+ x->plane[plane].bobs[block] = intra_txb_rd_info->bob;
+#endif // CONFIG_ATC_DCTX_ALIGNED
x->plane[plane].txb_entropy_ctx[block] =
intra_txb_rd_info->txb_entropy_ctx;
best_eob = intra_txb_rd_info->eob;
@@ -2597,6 +2618,9 @@
av1_setup_quant(tx_size, !skip_trellis,
skip_trellis ? xform_quant_b : AV1_XFORM_QUANT_FP,
cpi->oxcf.q_cfg.quant_b_adapt, &quant_param);
+#if CONFIG_ATC_DCTX_ALIGNED
+ int eob_found = 0;
+#endif // CONFIG_ATC_DCTX_ALIGNED
// Iterate through all transform type candidates.
for (int idx = 0; idx < TX_TYPES; ++idx) {
@@ -2622,8 +2646,13 @@
bool skip_idx = false;
xd->enable_ist = cm->seq_params.enable_ist &&
!cpi->sf.tx_sf.tx_type_search.skip_stx_search &&
- !mbmi->fsc_mode[xd->tree_type == CHROMA_PART];
+ !mbmi->fsc_mode[xd->tree_type == CHROMA_PART] &&
+ !xd->lossless[mbmi->segment_id];
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int max_stx = xd->enable_ist && !(eob_found) ? 4 : 1;
+#else
const int max_stx = xd->enable_ist ? 4 : 1;
+#endif // CONFIG_ATC_DCTX_ALIGNED
for (int stx = 0; stx < max_stx; ++stx) {
TX_TYPE tx_type = (TX_TYPE)txk_map[idx];
if (!(allowed_tx_mask & (1 << tx_type))) continue;
@@ -2635,6 +2664,9 @@
((tx_type != DCT_DCT && tx_type != ADST_ADST) || plane != 0 ||
is_inter_block(mbmi, xd->tree_type) || dc_only_blk ||
intra_mode >= PAETH_PRED || filter || !is_depth0 ||
+#if CONFIG_ATC_DCTX_ALIGNED
+ (eob_found) ||
+#endif // CONFIG_ATC_DCTX_ALIGNED
mbmi->fsc_mode[xd->tree_type == CHROMA_PART] ||
xd->lossless[mbmi->segment_id]);
if (skip_stx && stx) continue;
@@ -2675,6 +2707,17 @@
if (*eob != 0) *eob = av1_get_max_eob(txfm_param.tx_size);
}
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ // pre-skip DC only case to make things faster
+ uint16_t *const eob = &p->eobs[block];
+ if (*eob == 1 && plane == PLANE_TYPE_Y && !is_inter) {
+ if (tx_type == DCT_DCT) eob_found = 1;
+ if (tx_type != DCT_DCT || (stx && get_primary_tx_type(tx_type))) {
+ update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
+ continue;
+ }
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
// Calculate rate cost of quantized coefficients.
if (quant_param.use_optimize_b) {
av1_optimize_b(cpi, x, plane, block, tx_size, tx_type,
@@ -2699,6 +2742,19 @@
txb_ctx, cm->features.reduced_tx_set_used);
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (*eob == 1 && plane == PLANE_TYPE_Y && !is_inter) {
+ // post quant-skip DC only case
+ if (tx_type == DCT_DCT) eob_found = 1;
+ if (tx_type != DCT_DCT || (stx && get_primary_tx_type(tx_type))) {
+ if (plane == 0)
+ update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
+ continue;
+ }
+ if (get_secondary_tx_type(tx_type) > 0) continue;
+ if (txfm_param.sec_tx_type > 0) continue;
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
// If rd cost based on coeff rate alone is already more than best_rd,
// terminate early.
if (RDCOST(x->rdmult, rate_cost, 0) > best_rd) continue;
@@ -2831,6 +2887,14 @@
if (skip_idx) break;
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (((best_eob == 1 && best_tx_type != DCT_DCT && plane == 0) ||
+ best_rd == INT64_MAX) &&
+ !is_inter) {
+ best_tx_type = DCT_DCT;
+ if (plane == 0) update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
best_rd_stats->skip_txfm = best_eob == 0;
if (plane == 0) update_txk_array(xd, blk_row, blk_col, tx_size, best_tx_type);
x->plane[plane].txb_entropy_ctx[block] = best_txb_ctx;
@@ -2851,6 +2915,13 @@
best_rd_stats->sse = block_sse;
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (plane == 0 && x->plane[plane].eobs[block] == 1 &&
+ best_tx_type != DCT_DCT && !is_inter) {
+ av1_invalid_rd_stats(best_rd_stats);
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
if (intra_txb_rd_info != NULL) {
intra_txb_rd_info->valid = 1;
intra_txb_rd_info->entropy_context = cur_joint_ctx;
@@ -2878,6 +2949,12 @@
// can use them for prediction.
recon_intra(cpi, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
txb_ctx, skip_trellis, best_tx_type, 0, &rate_cost, best_eob);
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (plane == 0 && x->plane[plane].eobs[block] == 1 &&
+ best_tx_type != DCT_DCT && !is_inter) {
+ av1_invalid_rd_stats(best_rd_stats);
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
p->dqcoeff = orig_dqcoeff;
#endif // CONFIG_CROSS_CHROMA_TX
}
@@ -2894,6 +2971,9 @@
MB_MODE_INFO *mbmi = xd->mi[0];
struct macroblock_plane *const p_c1 = &x->plane[AOM_PLANE_U];
struct macroblock_plane *const p_c2 = &x->plane[AOM_PLANE_V];
+#if CONFIG_ATC_DCTX_ALIGNED
+ const int is_inter = is_inter_block(mbmi, xd->tree_type);
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int max_eob = av1_get_max_eob(tx_size);
int64_t best_rd = RDCOST(x->rdmult, best_rd_stats->rate, best_rd_stats->dist);
@@ -3020,6 +3100,11 @@
if (eobs_ptr_c1[block] == 0 || sse_dqcoeff_c2 > sse_dqcoeff_c1) {
continue;
}
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (eobs_ptr_c1[block] == 1 && !is_inter && cctx_type != CCTX_NONE) {
+ continue;
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
// If rd cost based on coeff rate alone is already more than best_rd,
// terminate early.
@@ -3061,7 +3146,16 @@
assert(best_rd != INT64_MAX);
best_rd_stats->skip_txfm = (best_eob_c1 == 0 && best_eob_c2 == 0);
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (best_eob_c1 == 1 && !is_inter && best_cctx_type != CCTX_NONE) {
+ best_cctx_type = CCTX_NONE;
+ update_cctx_array(xd, blk_row, blk_col, 0, 0, TX_4X4, CCTX_NONE);
+ } else {
+ update_cctx_array(xd, blk_row, blk_col, 0, 0, TX_4X4, best_cctx_type);
+ }
+#else
update_cctx_array(xd, blk_row, blk_col, 0, 0, TX_4X4, best_cctx_type);
+#endif // CONFIG_ATC_DCTX_ALIGNED
p_c1->txb_entropy_ctx[block] = best_txb_ctx_c1;
p_c2->txb_entropy_ctx[block] = best_txb_ctx_c2;
p_c1->eobs[block] = best_eob_c1;
@@ -3144,6 +3238,11 @@
#endif // CONFIG_CROSS_CHROMA_TX
txb_ctx, ftxs_mode, skip_trellis, ref_rdcost, &this_rd_stats);
+#if CONFIG_ATC_DCTX_ALIGNED
+ if (this_rd_stats.dist == INT64_MAX || this_rd_stats.rate == INT_MAX) {
+ return;
+ }
+#endif // CONFIG_ATC_DCTX_ALIGNED
av1_merge_rd_stats(rd_stats, &this_rd_stats);
#if !CONFIG_NEW_TX_PARTITION
@@ -3201,6 +3300,9 @@
rd_stats->rate = zero_blk_rate;
rd_stats->dist = rd_stats->sse;
p->eobs[block] = 0;
+#if CONFIG_ATC_DCTX_ALIGNED
+ p->bobs[block] = 0;
+#endif // CONFIG_ATC_DCTX_ALIGNED
update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT);
}
rd_stats->skip_txfm = pick_skip_txfm;
@@ -3648,7 +3750,13 @@
const int64_t skip_txfm_rd = is_inter_block(mbmi, xd->tree_type)
? RDCOST(x->rdmult, skip_txfm_rate, 0)
: INT64_MAX;
+#if CONFIG_SKIP_TXFM_OPT
+ const int64_t no_skip_txfm_rd = is_inter_block(mbmi, xd->tree_type)
+ ? RDCOST(x->rdmult, no_skip_txfm_rate, 0)
+ : 0;
+#else
const int64_t no_skip_txfm_rd = RDCOST(x->rdmult, no_skip_txfm_rate, 0);
+#endif // CONFIG_SKIP_TXFM_OPT
const int skip_trellis = 0;
av1_txfm_rd_in_plane(x, cpi, rd_stats, ref_best_rd,
AOMMIN(no_skip_txfm_rd, skip_txfm_rd), AOM_PLANE_Y, bs,
@@ -3873,7 +3981,11 @@
&txb_ctx, args->ftxs_mode, args->skip_trellis,
args->best_rd - args->current_rd, &this_rd_stats);
- if (this_rd_stats.dist == INT64_MAX) {
+ if (this_rd_stats.dist == INT64_MAX
+#if CONFIG_ATC_DCTX_ALIGNED
+ || this_rd_stats.rate == INT_MAX
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ ) {
args->exit_early = 1;
args->incomplete_exit = 1;
return;
@@ -3883,11 +3995,7 @@
assert(!is_inter || plane_bsize < BLOCK_8X8);
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_tx(xd, blk_row, blk_col, tx_size,
-#if DS_FRAME_LEVEL
- cm->features.ds_filter_type);
-#else
cm->seq_params.enable_cfl_ds_filter);
-#endif // DS_FRAME_LEVEL
#else
cfl_store_tx(xd, blk_row, blk_col, tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
@@ -3963,8 +4071,13 @@
const int skip_txfm_rate = mode_costs->skip_txfm_cost[skip_ctx][1];
const int64_t skip_txfm_rd =
is_inter ? RDCOST(x->rdmult, skip_txfm_rate, 0) : INT64_MAX;
+#if CONFIG_SKIP_TXFM_OPT
+ const int64_t no_this_rd =
+ is_inter ? RDCOST(x->rdmult, no_skip_txfm_rate + tx_size_rate, 0) : 0;
+#else
const int64_t no_this_rd =
RDCOST(x->rdmult, no_skip_txfm_rate + tx_size_rate, 0);
+#endif // CONFIG_SKIP_TXFM_OPT
mbmi->tx_size = tx_size;
av1_txfm_rd_in_plane(x, cpi, rd_stats, ref_best_rd,
@@ -4221,7 +4334,11 @@
#endif // CONFIG_CROSS_CHROMA_TX
txb_ctx, args->ftxs_mode, args->skip_trellis,
args->best_rd - args->current_rd, this_rd_stats);
- if (this_rd_stats->dist == INT64_MAX) {
+ if (this_rd_stats->dist == INT64_MAX
+#if CONFIG_ATC_DCTX_ALIGNED
+ || this_rd_stats->rate == INT_MAX
+#endif // CONFIG_ATC_DCTX_ALIGNED
+ ) {
args->exit_early = 1;
args->incomplete_exit = 1;
}
diff --git a/av1/encoder/x86/encodetxb_sse2.c b/av1/encoder/x86/encodetxb_sse2.c
index 93f4032..35c664b 100644
--- a/av1/encoder/x86/encodetxb_sse2.c
+++ b/av1/encoder/x86/encodetxb_sse2.c
@@ -544,11 +544,17 @@
// Note: levels[] must be in the range [0, 127], inclusive.
void av1_get_nz_map_contexts_skip_sse2(const uint8_t *const levels,
const int16_t *const scan,
+#if CONFIG_ATC_DCTX_ALIGNED
+ const uint16_t bob,
+#endif // CONFIG_ATC_DCTX_ALIGNED
const uint16_t eob,
const TX_SIZE tx_size,
int8_t *const coeff_contexts) {
(void)scan;
(void)eob;
+#if CONFIG_ATC_DCTX_ALIGNED
+ (void)bob;
+#endif // CONFIG_ATC_DCTX_ALIGNED
const int width = get_txb_wide(tx_size);
const int height = get_txb_high(tx_size);
// coeff_contexts must be 16 byte aligned.
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index 4fc3b51..4ad1bf5 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -137,25 +137,22 @@
"Use zero offset for non-normative bit upshift")
# AV2 experiment flags.
-set_aom_config_var(
- CONFIG_ATC_COEFCODING 1
- "AV2 enable adaptive transform coefficient coding improvement.")
-set_aom_config_var(CONFIG_ATC_NEWTXSETS 1
- "AV2 enable adaptive transform coding and new TX sets.")
+set_aom_config_var(CONFIG_ATC 1 "AV2 enable adaptive transform coding.")
set_aom_config_var(CONFIG_ATC_REDUCED_TXSET 1
"AV2 enable reduced transform set.")
+set_aom_config_var(
+ CONFIG_ATC_DCTX_ALIGNED 1
+ "AV2 TX signaling restriction for DC blocks with EOB alignment.")
set_aom_config_var(CONFIG_BYPASS_IMPROVEMENT 1
"AV2 enable entropy bypass improvement.")
-set_aom_config_var(CONFIG_C043_MVP_IMPROVEMENTS 1
- "AV2 enable MVP list improvements.")
-set_aom_config_var(CONFIG_C063_TMVP_IMPROVEMENT 1
- "AV2 experiment flag for improved TMVP derivation.")
-set_aom_config_var(CONFIG_EXT_RECUR_PARTITIONS 1 NUMBER
- "AV2 Fully recursive partitions experiment flag")
-set_aom_config_var(CONFIG_H_PARTITION 1 NUMBER
- "AV2 H partition mode experiment flag")
+set_aom_config_var(CONFIG_EXT_DIR 1 "AV2 extended intra prediction angles.")
+set_aom_config_var(
+ CONFIG_EXT_RECUR_PARTITIONS 1 NUMBER
+ "AV2 Fully recursive partitions including H partitions experiment flag")
set_aom_config_var(CONFIG_BLOCK_256 1 NUMBER "AV2 BLOCK_256 experiment flag")
set_aom_config_var(CONFIG_ERP_TFLITE 0 NUMBER "Build ERP with TFLite")
+set_aom_config_var(CONFIG_UNEVEN_4WAY 1 NUMBER
+ "AV2 uneven 4-way partition experiment flag")
set_aom_config_var(CONFIG_COMPOUND_WARP_SAMPLES 1 NUMBER
"AV2 compound warped motion samples experiment flag")
set_aom_config_var(CONFIG_NEW_TX_PARTITION 1
@@ -163,12 +160,14 @@
set_aom_config_var(
CONFIG_ORIP 1
"AV2 experiment flag to enable offset based refinement of intra prediction.")
+set_aom_config_var(
+ CONFIG_IDIF 1
+ "AV2 experiment flag to enable Intra Directional Interpolation Filter.")
set_aom_config_var(CONFIG_ORIP_DC_DISABLED 0
"AV2 experiment flag to disable ORIP for DC mode.")
set_aom_config_var(CONFIG_ORIP_NONDC_DISABLED 0
"AV2 experiment flag to disable ORIP for non-DC modes.")
-set_aom_config_var(CONFIG_SMVP_IMPROVEMENT 1 "Enable SMVP improvement")
-set_aom_config_var(CONFIG_TMVP_IMPROVEMENT 1 "Enable TMVP improvement")
+set_aom_config_var(CONFIG_MVP_IMPROVEMENT 1 "Enable MVP improvement")
set_aom_config_var(CONFIG_REF_MV_BANK 1 "AV2 ref mv bank experiment flag")
set_aom_config_var(
CONFIG_CCSO 1 "AV2 experiment flag to enable cross component sample offset.")
@@ -178,8 +177,6 @@
CONFIG_IBP_DC 1
"AV2 experiment flag to enable intra bi-prediction for DC mode.")
set_aom_config_var(CONFIG_AIMC 1 "AV2 adaptive intra mode coding flag.")
-set_aom_config_var(CONFIG_COMPLEXITY_SCALABLE_MVP 1
- "Enable complexity scalable mvp")
set_aom_config_var(
CONFIG_CONTEXT_DERIVATION 1
"AV2 experiment flag to enable modified context derivation : CWG-B065.")
@@ -199,31 +196,40 @@
set_aom_config_var(CONFIG_PC_WIENER 1 NUMBER
"AV2 pixel-classified Wiener filter experiment flag")
# End: CWG-C016
+set_aom_config_var(CONFIG_HIGH_PASS_CROSS_WIENER_FILTER 1
+ "AV2 high pass cross non-sep wiener filter experiment flag")
+set_aom_config_var(
+ CONFIG_FLEXIBLE_RU_SIZE 1
+ "AV2 experiment flag to choose RU size between 128x128, 256x256 and 512x512")
# Source of throughput analysis : CWG-B065
set_aom_config_var(CONFIG_THROUGHPUT_ANALYSIS 0
"AV2 experiment flag to measure throughput.")
set_aom_config_var(CONFIG_IBC_SR_EXT 1 "Enables IntraBC search range extension")
-set_aom_config_var(CONFIG_BVP_IMPROVEMENT 1 "Enables BVP improvements")
-set_aom_config_var(CONFIG_BVCOST_UPDATE 1 "Enables sb-level update for bv cost")
+set_aom_config_var(CONFIG_IBC_BV_IMPROVEMENT 1
+ "Enables BV improvements for IBC")
set_aom_config_var(CONFIG_CCSO_EXT 1
"AV2 experiment flag to enable extended CCSO.")
+set_aom_config_var(CONFIG_CFL_IMPROVEMENTS 1
+ "AV2 Cfl improvements from CWG-D029.")
+set_aom_config_var(CONFIG_ADPTIVE_DS_422 1
+ "AV2 adaptive downsampling in CfL for 422 from CWG-D028.")
set_aom_config_var(CONFIG_ADAPTIVE_MVD 1 "Enable adaptive MVD resolution")
set_aom_config_var(CONFIG_JOINT_MVD 1 "Enable joint MVD coding")
set_aom_config_var(CONFIG_IMPROVED_JMVD 1
"Enable joint MVD coding with multiple scaling factors")
-set_aom_config_var(CONFIG_INDEP_PALETTE_PARSING 1
- "AV2 experiment flag for palette parsing independency.")
-set_aom_config_var(CONFIG_NEW_COLOR_MAP_CODING 1
- "AV2 experiment flag to enable improved palette coding.")
+set_aom_config_var(
+ CONFIG_PALETTE_IMPROVEMENTS
+ 1
+ "AV2 experiment flag for palette parsing independency and improved palette color map coding."
+)
set_aom_config_var(CONFIG_SKIP_MODE_SSE_BUG_FIX 1
"AV2 experiment flag to fix the SSE calc bug for skip mode.")
set_aom_config_var(CONFIG_SKIP_MODE_ENHANCEMENT 1
- "AV2 experiment flag to enable skip mode enhancement: C019.")
-set_aom_config_var(
- CONFIG_SKIP_MODE_DRL_WITH_REF_IDX 1
- "AV2 experiment flag to enable DRL with ref_MV_idx for skip mode.")
+ "AV2 experiment flag to enable skip mode enhancement.")
set_aom_config_var(CONFIG_TIP 1 "Enable temporal interpolated prediction (TIP)")
+set_aom_config_var(CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT 0
+ "Enable frame output order derivation from order hint")
set_aom_config_var(CONFIG_OPTFLOW_ON_TIP 1
"Enable optical flow refinement on top of TIP")
set_aom_config_var(CONFIG_FLEX_MVRES 1
@@ -236,6 +242,28 @@
"Enable parity hiding for coefficients coding. (PH)")
set_aom_config_var(CONFIG_BAWP 1 "Enable block adaptive weighted prediction")
set_aom_config_var(CONFIG_WARPMV 1 "Enable warpmv modes")
+set_aom_config_var(CONFIG_IMPROVED_ANGULAR_INTRA 1
+ "Improved angular intra prediction mode")
+set_aom_config_var(CONFIG_D071_IMP_MSK_BLD 1
+ "Enable single reference mode for frame boundary")
+
+set_aom_config_var(CONFIG_SKIP_TXFM_OPT 1
+ "Enable to optimize the signaling of skip_txfm")
+set_aom_config_var(CONFIG_CWP 1 "Enables compound weighted prediction.")
+set_aom_config_var(CONFIG_REFINEMV 1 "Enable refinemv modes")
+
+set_aom_config_var(CONFIG_EXPLICIT_TEMPORAL_DIST_CALC 1
+ "Enable to explicit temporal distance calculation")
+
+set_aom_config_var(CONFIG_IMPROVED_GLOBAL_MOTION 1
+ "New global motion syntax for AV2")
+set_aom_config_var(CONFIG_SEP_COMP_DRL 1
+ "Use separate drl list for compound modes")
+set_aom_config_var(CONFIG_SKIP_ME_FOR_OPFL_MODES 1
+ "Reuse the mvs of compound mode from non-opfl path")
+
+set_aom_config_var(CONFIG_CWG_D067_IMPROVED_WARP 1
+ "Improvement of warp motions")
# This is an encode-only change.
set_aom_config_var(CONFIG_MV_SEARCH_RANGE 1
@@ -244,6 +272,9 @@
"AV2 experiment flag to fix CDEF syntax.")
set_aom_config_var(CONFIG_IMPROVED_CFL 1
"Enable improved CfL mode from CWG-C044")
+set_aom_config_var(CONFIG_BLEND_MODE 1
+ "Enable improved intra blend mode from CWG-D046")
+
set_aom_config_var(
CONFIG_PEF 1 "AV2 experiment flag to enable prediction enhancement filter")
@@ -264,6 +295,10 @@
set_aom_config_var(CONFIG_CROSS_CHROMA_TX 1
"AV2 cross chroma component transform experiment flag.")
set_aom_config_var(CONFIG_WEDGE_MOD_EXT 1 "AV2 wedge modes extensions.")
+
+set_aom_config_var(CONFIG_MF_IMPROVEMENT 1
+ "Enable to improve temporal motion projection")
+
#
# Variables in this section control optional features of the build system.
#
diff --git a/build/cmake/aom_experiment_deps.cmake b/build/cmake/aom_experiment_deps.cmake
index 760ed4b..e9460f2 100644
--- a/build/cmake/aom_experiment_deps.cmake
+++ b/build/cmake/aom_experiment_deps.cmake
@@ -37,11 +37,10 @@
change_config_and_warn(CONFIG_CCSO_EXT 0 !CONFIG_CCSO)
endif()
- # CONFIG_ATC_REDUCED_TXSET depends on CONFIG_ATC_NEWTXSETS. If
- # CONFIG_ATC_NEWTXSETS is off, then CONFIG_ATC_REDUCED_TXSET needs to be
- # disabled.
- if(NOT CONFIG_ATC_NEWTXSETS AND CONFIG_ATC_REDUCED_TXSET)
- change_config_and_warn(CONFIG_ATC_REDUCED_TXSET 0 !CONFIG_ATC_NEWTXSETS)
+ # CONFIG_ATC_REDUCED_TXSET depends on CONFIG_ATC. If CONFIG_ATC is off, then
+ # CONFIG_ATC_REDUCED_TXSET needs to be disabled.
+ if(NOT CONFIG_ATC AND CONFIG_ATC_REDUCED_TXSET)
+ change_config_and_warn(CONFIG_ATC_REDUCED_TXSET 0 !CONFIG_ATC)
endif()
# CONFIG_OPTFLOW_ON_TIP is dependent on CONFIG_OPTFLOW_REFINEMENT and
@@ -71,6 +70,17 @@
change_config_and_warn(CONFIG_WARPMV 0 !CONFIG_WARP_REF_LIST)
endif()
+ # CONFIG_CWG_D067_IMPROVED_WARP depends on CONFIG_WARP_REF_LIST
+ if(NOT CONFIG_WARP_REF_LIST AND CONFIG_CWG_D067_IMPROVED_WARP)
+ change_config_and_warn(CONFIG_CWG_D067_IMPROVED_WARP 0
+ !CONFIG_WARP_REF_LIST)
+ endif()
+
+ # CONFIG_CWG_D067_IMPROVED_WARP depends on CONFIG_WARPMV
+ if(NOT CONFIG_WARPMV AND CONFIG_CWG_D067_IMPROVED_WARP)
+ change_config_and_warn(CONFIG_CWG_D067_IMPROVED_WARP 0 !CONFIG_WARPMV)
+ endif()
+
# Begin: CWG-C016.
if(CONFIG_WIENER_NONSEP_CROSS_FILT)
change_config_and_warn(CONFIG_WIENER_NONSEP 1
@@ -78,11 +88,11 @@
endif()
# End: CWG-C016.
- # CONFIG_H_PARTITION is dependent on CONFIG_EXT_RECUR_PARTITIONS. If
- # CONFIG_EXT_RECUR_PARTITIONS is off, CONFIG_H_PARTITION needs to be turned
+ # CONFIG_UNEVEN_4WAY is dependent on CONFIG_EXT_RECUR_PARTITIONS. If
+ # CONFIG_EXT_RECUR_PARTITIONS is off, CONFIG_UNEVEN_4WAY needs to be turned
# off.
- if(NOT CONFIG_EXT_RECUR_PARTITIONS AND CONFIG_H_PARTITION)
- change_config_and_warn(CONFIG_H_PARTITION 0 !CONFIG_EXT_RECUR_PARTITIONS)
+ if(NOT CONFIG_EXT_RECUR_PARTITIONS AND CONFIG_UNEVEN_4WAY)
+ change_config_and_warn(CONFIG_UNEVEN_4WAY 0 !CONFIG_EXT_RECUR_PARTITIONS)
endif()
endmacro()
diff --git a/common/args.c b/common/args.c
index ffec73b..82a7e2a 100644
--- a/common/args.c
+++ b/common/args.c
@@ -96,10 +96,19 @@
#if CONFIG_BAWP
GET_PARAMS(enable_bawp);
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ GET_PARAMS(enable_cwp);
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ GET_PARAMS(enable_imp_msk_bld);
+#endif // CONFIG_D071_IMP_MSK_BLD
GET_PARAMS(enable_fsc);
#if CONFIG_ORIP
GET_PARAMS(enable_orip);
#endif
+#if CONFIG_IDIF
+ GET_PARAMS(enable_idif);
+#endif // CONFIG_IDIF
GET_PARAMS(enable_ist);
#if CONFIG_CROSS_CHROMA_TX
GET_PARAMS(enable_cctx);
@@ -117,6 +126,9 @@
#if CONFIG_JOINT_MVD
GET_PARAMS(enable_joint_mvd);
#endif // CONFIG_JOINT_MVD
+#if CONFIG_REFINEMV
+ GET_PARAMS(enable_refinemv);
+#endif // CONFIG_REFINEMV
GET_PARAMS(enable_flip_idtx);
GET_PARAMS(enable_deblocking);
GET_PARAMS(enable_cdef);
diff --git a/common/av1_config.c b/common/av1_config.c
index e8a9215..3d00147 100644
--- a/common/av1_config.c
+++ b/common/av1_config.c
@@ -9,6 +9,7 @@
* source code in the PATENTS file, you can obtain it at
* aomedia.org/license/patent-license/.
*/
+#include <stdbool.h>
#include <stdio.h>
#include <string.h>
@@ -234,7 +235,10 @@
}
// Parse Sequence Header OBU for coding tools beyond AV1
-int parse_sequence_header_beyond_av1(struct aom_read_bit_buffer *reader) {
+int parse_sequence_header_beyond_av1(struct aom_read_bit_buffer *reader,
+ bool reduced_still_picture_header) {
+ (void)reduced_still_picture_header;
+
int result = 0;
#if CONFIG_REF_MV_BANK
AV1C_READ_BIT_OR_RETURN_ERROR(enable_refmvbank);
@@ -244,6 +248,10 @@
AV1C_READ_BITS_OR_RETURN_ERROR(max_reference_frames, 2);
}
AV1C_READ_BIT_OR_RETURN_ERROR(explicit_ref_frame_map);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // 0: show_existing_frame, 1: implicit derivation
+ AV1C_READ_BIT_OR_RETURN_ERROR(enable_frame_output_order);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
AV1C_READ_BIT_OR_RETURN_ERROR(enable_sdp);
AV1C_READ_BIT_OR_RETURN_ERROR(enable_ist);
#if CONFIG_CROSS_CHROMA_TX
@@ -259,6 +267,12 @@
#if CONFIG_BAWP
AV1C_READ_BIT_OR_RETURN_ERROR(enable_bawp);
#endif // CONFIG_BAWP
+#if CONFIG_CWP
+ AV1C_READ_BIT_OR_RETURN_ERROR(enable_cwp);
+#endif // CONFIG_CWP
+#if CONFIG_D071_IMP_MSK_BLD
+ AV1C_READ_BIT_OR_RETURN_ERROR(enable_imp_msk_bld);
+#endif // CONFIG_D071_IMP_MSK_BLD
AV1C_READ_BIT_OR_RETURN_ERROR(enable_fsc);
#if CONFIG_CCSO
AV1C_READ_BIT_OR_RETURN_ERROR(enable_ccso);
@@ -269,10 +283,16 @@
#if CONFIG_ORIP
AV1C_READ_BIT_OR_RETURN_ERROR(enable_orip);
#endif
+#if CONFIG_IDIF
+ AV1C_READ_BIT_OR_RETURN_ERROR(enable_idif);
+#endif // CONFIG_IDIF
AV1C_READ_BIT_OR_RETURN_ERROR(enable_ibp);
#if CONFIG_ADAPTIVE_MVD
AV1C_READ_BIT_OR_RETURN_ERROR(enable_adaptive_mvd);
#endif // CONFIG_ADAPTIVE_MVD
+#if CONFIG_REFINEMV
+ AV1C_READ_BIT_OR_RETURN_ERROR(enable_refinemv);
+#endif // CONFIG_REFINEMV
#if CONFIG_FLEX_MVRES
AV1C_READ_BIT_OR_RETURN_ERROR(enable_flex_mvres);
#endif // CONFIG_FLEX_MVRES
@@ -282,6 +302,11 @@
#if CONFIG_PAR_HIDING
AV1C_READ_BIT_OR_RETURN_ERROR(enable_parity_hiding);
#endif // CONFIG_PAR_HIDING
+#if CONFIG_IMPROVED_GLOBAL_MOTION
+ if (!reduced_still_picture_header) {
+ AV1C_READ_BIT_OR_RETURN_ERROR(enable_global_motion);
+ }
+#endif // CONFIG_IMPROVED_GLOBAL_MOTION
return 0;
}
@@ -447,7 +472,7 @@
AV1C_READ_BIT_OR_RETURN_ERROR(film_grain_params_present);
// Sequence header for coding tools beyond AV1
- parse_sequence_header_beyond_av1(reader);
+ parse_sequence_header_beyond_av1(reader, reduced_still_picture_header);
return 0;
}
diff --git a/common/y4minput.c b/common/y4minput.c
index d24bf56..aec02e5 100644
--- a/common/y4minput.c
+++ b/common/y4minput.c
@@ -24,12 +24,13 @@
// Reads 'size' bytes from 'file' into 'buf' with some fault tolerance.
// Returns true on success.
static int file_read(void *buf, size_t size, FILE *file) {
- const int kMaxRetries = 5;
- int retry_count = 0;
- int file_error;
+ const int kMaxTries = 5;
+ int try_count = 0;
+ int file_error = 0;
size_t len = 0;
- do {
+ while (!feof(file) && len < size && try_count < kMaxTries) {
const size_t n = fread((uint8_t *)buf + len, 1, size - len, file);
+ ++try_count;
len += n;
file_error = ferror(file);
if (file_error) {
@@ -42,13 +43,13 @@
return 0;
}
}
- } while (!feof(file) && len < size && ++retry_count < kMaxRetries);
+ }
if (!feof(file) && len != size) {
fprintf(stderr,
"Error reading file: %u of %u bytes read,"
- " error: %d, retries: %d, %d: %s\n",
- (uint32_t)len, (uint32_t)size, file_error, retry_count, errno,
+ " error: %d, tries: %d, %d: %s\n",
+ (uint32_t)len, (uint32_t)size, file_error, try_count, errno,
strerror(errno));
}
return len == size;
@@ -1142,9 +1143,15 @@
y4m_ctx->dst_buf = (unsigned char *)malloc(y4m_ctx->dst_buf_sz);
else
y4m_ctx->dst_buf = (unsigned char *)malloc(2 * y4m_ctx->dst_buf_sz);
+ if (!y4m_ctx->dst_buf) return -1;
- if (y4m_ctx->aux_buf_sz > 0)
+ if (y4m_ctx->aux_buf_sz > 0) {
y4m_ctx->aux_buf = (unsigned char *)malloc(y4m_ctx->aux_buf_sz);
+ if (!y4m_ctx->aux_buf) {
+ free(y4m_ctx->dst_buf);
+ return -1;
+ }
+ }
return 0;
}
diff --git a/examples/inspect.c b/examples/inspect.c
index 4e98dca..1cc05e8 100644
--- a/examples/inspect.c
+++ b/examples/inspect.c
@@ -601,13 +601,39 @@
}
const int num_syms = accounting->syms.num_syms;
const int num_strs = accounting->syms.dictionary.num_strs;
- buf += put_str(buf, " \"symbolsMap\": [");
+ buf += put_str(buf, " \"symbolsFileMap\": [");
for (i = 0; i < num_strs; i++) {
- buf += snprintf(buf, MAX_BUFFER, "\"%s\"",
- accounting->syms.dictionary.strs[i]);
+ buf += snprintf(buf, MAX_BUFFER, "\"%s:%d\"",
+ accounting->syms.dictionary.acct_infos[i].c_file,
+ accounting->syms.dictionary.acct_infos[i].c_line);
if (i < num_strs - 1) *(buf++) = ',';
}
buf += put_str(buf, "],\n");
+
+ buf += put_str(buf, " \"symbolsMap\": [");
+ for (i = 0; i < num_strs; i++) {
+ buf += snprintf(buf, MAX_BUFFER, "\"%s\"",
+ accounting->syms.dictionary.acct_infos[i].c_func);
+ if (i < num_strs - 1) *(buf++) = ',';
+ }
+ buf += put_str(buf, "],\n");
+
+ buf += put_str(buf, " \"symbolsTagsMap\": [");
+ for (i = 0; i < num_strs; i++) {
+ buf += put_str(buf, "[");
+ for (int j = 0; j < AOM_ACCOUNTING_MAX_TAGS; j++) {
+ if (accounting->syms.dictionary.acct_infos[i].tags[j] == NULL) break;
+ if (j > 0) {
+ *(buf++) = ',';
+ }
+ buf += snprintf(buf, MAX_BUFFER, "\"%s\"",
+ accounting->syms.dictionary.acct_infos[i].tags[j]);
+ }
+ buf += put_str(buf, "]");
+ if (i < num_strs - 1) *(buf++) = ',';
+ }
+ buf += put_str(buf, "],\n");
+
buf += put_str(buf, " \"symbols\": [\n ");
AccountingSymbolContext context;
context.x = -2;
@@ -618,11 +644,12 @@
if (memcmp(&context, &sym->context, sizeof(AccountingSymbolContext)) != 0) {
buf += put_num(buf, '[', sym->context.x, 0);
buf += put_num(buf, ',', sym->context.y, ']');
- } else {
- buf += put_num(buf, '[', sym->id, 0);
- buf += put_num(buf, ',', sym->bits, 0);
- buf += put_num(buf, ',', sym->samples, ']');
+ *(buf++) = ',';
}
+ buf += put_num(buf, '[', sym->id, 0);
+ buf += put_num(buf, ',', sym->bits, 0);
+ buf += put_num(buf, ',', sym->value, 0);
+ buf += put_num(buf, ',', sym->coding_mode, ']');
context = sym->context;
if (i < num_syms - 1) *(buf++) = ',';
}
@@ -748,6 +775,8 @@
frame_data.delta_q_present_flag);
buf += snprintf(buf, MAX_BUFFER, " \"deltaQRes\": %d,\n",
frame_data.delta_q_res);
+ buf += snprintf(buf, MAX_BUFFER, " \"superblockSize\": %d,\n",
+ frame_data.superblock_size);
buf += put_str(buf, " \"config\": {");
buf += put_map(buf, config_map);
buf += put_str(buf, "},\n");
@@ -764,6 +793,7 @@
void ifd_init_cb() {
aom_inspect_init ii;
ii.inspect_cb = inspect;
+ ii.inspect_sb_cb = NULL;
ii.inspect_ctx = NULL;
aom_codec_control(&codec, AV1_SET_INSPECTION_CALLBACK, &ii);
}
diff --git a/test/accounting_test.cc b/test/accounting_test.cc
index 8d8d964..1e640fa 100644
--- a/test/accounting_test.cc
+++ b/test/accounting_test.cc
@@ -42,11 +42,9 @@
aom_accounting_init(&accounting);
br.accounting = &accounting;
for (int i = 0; i < kSymbols; i++) {
- aom_read(&br, 32, "A");
+ aom_read(&br, 32, ACCT_INFO("A"));
}
- // Consecutive symbols that are the same are coalesced.
- GTEST_ASSERT_EQ(accounting.syms.num_syms, 1);
- GTEST_ASSERT_EQ(accounting.syms.syms[0].samples, (unsigned int)kSymbols);
+ GTEST_ASSERT_EQ(accounting.syms.num_syms, kSymbols);
aom_accounting_reset(&accounting);
GTEST_ASSERT_EQ(accounting.syms.num_syms, 0);
@@ -55,9 +53,9 @@
aom_reader_init(&br, bw_buffer, bw.pos);
br.accounting = &accounting;
for (int i = 0; i < kSymbols; i++) {
- aom_read(&br, 32, "A");
- aom_read(&br, 32, "B");
- aom_read(&br, 32, "B");
+ aom_read(&br, 32, ACCT_INFO("A"));
+ aom_read(&br, 32, ACCT_INFO("B"));
+ aom_read(&br, 32, ACCT_INFO("B"));
}
GTEST_ASSERT_EQ(accounting.syms.num_syms, kSymbols * 2);
uint32_t tell_frac = aom_reader_tell_frac(&br);
@@ -66,11 +64,15 @@
}
GTEST_ASSERT_EQ(tell_frac, 0U);
- GTEST_ASSERT_EQ(aom_accounting_dictionary_lookup(&accounting, "A"),
- aom_accounting_dictionary_lookup(&accounting, "A"));
+ AccountingSymbolInfo a1 = ACCT_INFO("A");
+ AccountingSymbolInfo a2 = ACCT_INFO("A");
+ GTEST_ASSERT_EQ(aom_accounting_dictionary_lookup(&accounting, &a1),
+ aom_accounting_dictionary_lookup(&accounting, &a2));
// Check for collisions. The current aom_accounting_hash function returns
// the same hash code for AB and BA.
- GTEST_ASSERT_NE(aom_accounting_dictionary_lookup(&accounting, "AB"),
- aom_accounting_dictionary_lookup(&accounting, "BA"));
+ AccountingSymbolInfo ab = ACCT_INFO("AB");
+ AccountingSymbolInfo ba = ACCT_INFO("BA");
+ GTEST_ASSERT_NE(aom_accounting_dictionary_lookup(&accounting, &ab),
+ aom_accounting_dictionary_lookup(&accounting, &ba));
}
diff --git a/test/altref_test.cc b/test/altref_test.cc
index cf7ccd3..f5dfb4a 100644
--- a/test/altref_test.cc
+++ b/test/altref_test.cc
@@ -185,7 +185,11 @@
virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
(void)pkt;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ frame_num_ += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
++frame_num_;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
const gfIntervalParam gf_interval_param_;
diff --git a/test/av1_encoder_parms_get_to_decoder.cc b/test/av1_encoder_parms_get_to_decoder.cc
index 29043b1..47b4448 100644
--- a/test/av1_encoder_parms_get_to_decoder.cc
+++ b/test/av1_encoder_parms_get_to_decoder.cc
@@ -24,8 +24,6 @@
namespace {
-const int kMaxPsnr = 100;
-
struct ParamPassingTestVideo {
const char *name;
uint32_t width;
@@ -99,6 +97,7 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
+ encoder->Control(AOME_SET_CPUUSED, 5);
encoder->Control(AV1E_SET_COLOR_PRIMARIES, encode_parms.color_primaries);
encoder->Control(AV1E_SET_TRANSFER_CHARACTERISTICS,
encode_parms.transfer_characteristics);
@@ -130,7 +129,9 @@
virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
if (encode_parms.lossless) {
- EXPECT_EQ(kMaxPsnr, pkt->data.psnr.psnr[0]);
+ const double lossless_psnr =
+ get_lossless_psnr(test_video_.width, test_video_.height, 8, false);
+ EXPECT_EQ(lossless_psnr, pkt->data.psnr.psnr[0]);
}
}
diff --git a/test/binary_codes_test.cc b/test/binary_codes_test.cc
index 68cb79c..1f99f20 100644
--- a/test/binary_codes_test.cc
+++ b/test/binary_codes_test.cc
@@ -25,8 +25,6 @@
#include "aom_dsp/binary_codes_reader.h"
#include "aom_dsp/binary_codes_writer.h"
-#define ACCT_STR __func__
-
using libaom_test::ACMRandom;
namespace {
@@ -73,7 +71,7 @@
assert(k == enc_values[n][k][r][v][1]);
const uint16_t ref = enc_values[n][k][r][v][2];
const uint16_t value =
- aom_read_primitive_refsubexpfin(&br, range, k, ref, ACCT_STR);
+ aom_read_primitive_refsubexpfin(&br, range, k, ref, ACCT_INFO());
GTEST_ASSERT_EQ(value, enc_values[n][k][r][v][3]);
}
}
diff --git a/test/boolcoder_test.cc b/test/boolcoder_test.cc
index 9c9eac8..983afd9 100644
--- a/test/boolcoder_test.cc
+++ b/test/boolcoder_test.cc
@@ -78,7 +78,7 @@
} else if (bit_method == 3) {
bit = bit_rnd(2);
}
- GTEST_ASSERT_EQ(aom_read(&br, probas[i], NULL), bit)
+ GTEST_ASSERT_EQ(aom_read(&br, probas[i], {}), bit)
<< "pos: " << i << " / " << kBitsToTest
<< " bit_method: " << bit_method << " method: " << method;
}
@@ -105,25 +105,26 @@
aom_reader br;
aom_reader_init(&br, bw_buffer, bw.pos);
uint32_t last_tell = aom_reader_tell(&br);
- uint32_t last_tell_frac = aom_reader_tell_frac(&br);
+ uint64_t last_tell_frac = aom_reader_tell_frac(&br);
double frac_diff_total = 0;
GTEST_ASSERT_GE(aom_reader_tell(&br), 0u);
GTEST_ASSERT_LE(aom_reader_tell(&br), 1u);
ASSERT_FALSE(aom_reader_has_overflowed(&br));
for (int i = 0; i < kSymbols; i++) {
- aom_read(&br, p, NULL);
+ aom_read(&br, p, {});
uint32_t tell = aom_reader_tell(&br);
- uint32_t tell_frac = aom_reader_tell_frac(&br);
+ uint64_t tell_frac = aom_reader_tell_frac(&br);
GTEST_ASSERT_GE(tell, last_tell)
<< "tell: " << tell << ", last_tell: " << last_tell;
GTEST_ASSERT_GE(tell_frac, last_tell_frac)
<< "tell_frac: " << tell_frac
<< ", last_tell_frac: " << last_tell_frac;
// Frac tell should round up to tell.
- GTEST_ASSERT_EQ(tell, (tell_frac + 7) >> 3);
+ GTEST_ASSERT_EQ(tell, (tell_frac + (1 << OD_BITRES) - 1) >> OD_BITRES);
last_tell = tell;
frac_diff_total +=
- fabs(((tell_frac - last_tell_frac) / 8.0) + log2(probability));
+ fabs(((tell_frac - last_tell_frac) / (double)(1 << OD_BITRES)) +
+ log2(probability));
last_tell_frac = tell_frac;
}
const uint32_t expected = (uint32_t)(-kSymbols * log2(probability));
@@ -152,7 +153,7 @@
aom_reader_init(&br, bw_buffer, bw.pos);
ASSERT_FALSE(aom_reader_has_overflowed(&br));
for (int i = 0; i < kSymbols; i++) {
- GTEST_ASSERT_EQ(aom_read(&br, p, NULL), 1);
+ GTEST_ASSERT_EQ(aom_read(&br, p, {}), 1);
ASSERT_FALSE(aom_reader_has_overflowed(&br));
}
// In the worst case, the encoder uses just a tiny fraction of the last
@@ -171,11 +172,11 @@
// additional bits; therefore the number of reads should be increased;
// 174 * 8 will be enough to consume more than this number of bits.
for (int i = 0; i < 174 * 8; i++) {
- aom_read(&br, p, NULL);
+ aom_read(&br, p, {});
}
#else
for (int i = 0; i < 174; i++) {
- aom_read(&br, p, NULL);
+ aom_read(&br, p, {});
}
#endif
ASSERT_TRUE(aom_reader_has_overflowed(&br));
diff --git a/test/cpu_speed_test.cc b/test/cpu_speed_test.cc
index bddd8ab..e9984ad 100644
--- a/test/cpu_speed_test.cc
+++ b/test/cpu_speed_test.cc
@@ -19,15 +19,13 @@
namespace {
-const int kMaxPSNR = 100;
-
class CpuSpeedTest
: public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode, int>,
public ::libaom_test::EncoderTest {
protected:
CpuSpeedTest()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
- set_cpu_used_(GET_PARAM(2)), min_psnr_(kMaxPSNR),
+ set_cpu_used_(GET_PARAM(2)), min_psnr_(DBL_MAX),
tune_content_(AOM_CONTENT_DEFAULT) {}
virtual ~CpuSpeedTest() {}
@@ -38,7 +36,7 @@
cfg_.rc_end_usage = AOM_VBR;
}
- virtual void BeginPassHook(unsigned int /*pass*/) { min_psnr_ = kMaxPSNR; }
+ virtual void BeginPassHook(unsigned int /*pass*/) { min_psnr_ = DBL_MAX; }
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
@@ -75,14 +73,19 @@
cfg_.rc_target_bitrate = 400;
cfg_.rc_max_quantizer = 0;
cfg_.rc_min_quantizer = 0;
+ const unsigned int width = 208;
+ const unsigned int height = 144;
+ const unsigned int bit_depth = 8;
- ::libaom_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0,
- 10);
+ ::libaom_test::I420VideoSource video("hantro_odd.yuv", width, height, 30, 1,
+ 0, 10);
init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
- EXPECT_GE(min_psnr_, kMaxPSNR);
+ const double lossless_psnr =
+ get_lossless_psnr(width, height, bit_depth, false);
+ EXPECT_EQ(min_psnr_, lossless_psnr);
}
void CpuSpeedTest::TestScreencastQ0() {
@@ -91,11 +94,17 @@
cfg_.rc_target_bitrate = 400;
cfg_.rc_max_quantizer = 0;
cfg_.rc_min_quantizer = 0;
+ const unsigned int width = 640;
+ const unsigned int height = 480;
+ const unsigned int bit_depth = 8;
init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
- EXPECT_GE(min_psnr_, kMaxPSNR);
+
+ const double lossless_psnr =
+ get_lossless_psnr(width, height, bit_depth, false);
+ EXPECT_EQ(min_psnr_, lossless_psnr);
}
void CpuSpeedTest::TestTuneScreen() {
diff --git a/test/decode_perf_test.cc b/test/decode_perf_test.cc
index 5e5380e..4a85357 100644
--- a/test/decode_perf_test.cc
+++ b/test/decode_perf_test.cc
@@ -148,7 +148,11 @@
}
virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ out_frames_ += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
++out_frames_;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
// Write initial file header if first frame.
if (pkt->data.frame.pts == 0)
diff --git a/test/ec_test.cc b/test/ec_test.cc
index d89c991..6b30c66 100644
--- a/test/ec_test.cc
+++ b/test/ec_test.cc
@@ -44,7 +44,7 @@
#if CONFIG_BYPASS_IMPROVEMENT
unsigned *mode;
#endif // CONFIG_BYPASS_IMPROVEMENT
- unsigned *tell;
+ unsigned long *tell;
unsigned *enc_method;
int j;
sz = rand() / ((RAND_MAX >> (rand() % 9U)) + 1U);
@@ -54,7 +54,7 @@
#if CONFIG_BYPASS_IMPROVEMENT
mode = (unsigned *)malloc(sz * sizeof(*mode));
#endif // CONFIG_BYPASS_IMPROVEMENT
- tell = (unsigned *)malloc((sz + 1) * sizeof(*tell));
+ tell = (unsigned long *)malloc((sz + 1) * sizeof(*tell));
enc_method = (unsigned *)malloc(sz * sizeof(*enc_method));
od_ec_enc_reset(&enc);
tell[0] = od_ec_enc_tell_frac(&enc);
@@ -139,7 +139,7 @@
EXPECT_EQ(od_ec_dec_tell_frac(&dec), tell[0])
<< "od_ec_dec_tell() mismatch between encoder and decoder "
"at symbol 0: "
- << (unsigned)od_ec_dec_tell_frac(&dec) << " instead of " << tell[0]
+ << (unsigned long)od_ec_dec_tell_frac(&dec) << " instead of " << tell[0]
<< " (Random seed: " << seed << ").\n";
for (j = 0; j < sz; j++) {
int dec_method;
@@ -208,7 +208,7 @@
EXPECT_EQ(od_ec_dec_tell_frac(&dec), tell[j + 1])
<< "od_ec_dec_tell() mismatch between encoder and "
"decoder at symbol "
- << j + 1 << ": " << (unsigned)od_ec_dec_tell_frac(&dec)
+ << j + 1 << ": " << (unsigned long)od_ec_dec_tell_frac(&dec)
<< " instead of " << tell[j + 1] << " (Random seed: " << seed
<< ").\n";
}
diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc
index 2d191cd..74045a4 100644
--- a/test/encode_test_driver.cc
+++ b/test/encode_test_driver.cc
@@ -202,6 +202,10 @@
number_spatial_layers_ = GetNumSpatialLayers();
bool again;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ unsigned int rec_frame_cnt = 0;
+ unsigned int failed_frame_cnt = 0;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
for (again = true; again; video->Next()) {
again = (video->img() != NULL);
@@ -236,6 +240,9 @@
if (!HandleDecodeResult(res_dec, decoder.get())) break;
has_dxdata = true;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ rec_frame_cnt += pkt->data.frame.frame_count;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
ASSERT_GE(pkt->data.frame.pts, last_pts_);
if (sl == number_spatial_layers_) last_pts_ = pkt->data.frame.pts;
@@ -260,7 +267,22 @@
}
}
if (img_dec) DecompressedFrameHook(*img_dec, video->pts());
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ failed_frame_cnt = 0;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ // Continue the encoding process, when an empty packet is received
+ // by skipping OBU with show_existing_frame == 1) and
+ // no longer input frames are remained due to lag_in frames.
+ // However the consecutive(10) packets are empty/failed, stop the
+ // encoding.
+ else if (rec_frame_cnt < video->limit() && !again &&
+ failed_frame_cnt < 10) {
+ again = true;
+ failed_frame_cnt++;
+ }
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (!Continue()) break;
} // Loop over spatial layers
}
diff --git a/test/encodetxb_test.cc b/test/encodetxb_test.cc
index 58f1711..84ebbad 100644
--- a/test/encodetxb_test.cc
+++ b/test/encodetxb_test.cc
@@ -61,7 +61,7 @@
libaom_test::ClearSystemState();
}
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
void GetNzMapContextsRun() {
const int kNumTests = 10;
int result = 0;
@@ -149,7 +149,7 @@
(elapsed_time_ref * 1.0) / (elapsed_time * 1.0));
}
}
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
private:
void InitDataWithEob(const int16_t *const scan, const int bwl,
@@ -193,7 +193,7 @@
};
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EncodeTxbTest);
-#if !CONFIG_ATC_COEFCODING
+#if !CONFIG_ATC
TEST_P(EncodeTxbTest, GetNzMapContexts) { GetNzMapContextsRun(); }
TEST_P(EncodeTxbTest, DISABLED_SpeedTestGetNzMapContexts) {
@@ -209,7 +209,7 @@
INSTANTIATE_TEST_SUITE_P(NEON, EncodeTxbTest,
::testing::Values(av1_get_nz_map_contexts_neon));
#endif
-#endif // !CONFIG_ATC_COEFCODING
+#endif // !CONFIG_ATC
typedef void (*av1_txb_init_levels_func)(const tran_low_t *const coeff,
const int width, const int height,
diff --git a/test/error_resilience_test.cc b/test/error_resilience_test.cc
index cd9ca58..dc63465 100644
--- a/test/error_resilience_test.cc
+++ b/test/error_resilience_test.cc
@@ -82,6 +82,9 @@
if (video->frame() == 0) {
encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
encoder->Control(AOME_SET_ENABLEAUTOALTREF, enable_altref_);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ encoder->Control(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, 0);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
frame_flags_ &= ~(AOM_EFLAG_NO_REF_FRAME_MVS | AOM_EFLAG_ERROR_RESILIENT |
AOM_EFLAG_NO_UPD_ALL | AOM_EFLAG_SET_S_FRAME |
@@ -502,6 +505,9 @@
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
encoder->Control(AOME_SET_CPUUSED, 5);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ encoder->Control(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, 0);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (rc_end_usage_ == AOM_Q) {
encoder->Control(AOME_SET_QP, 210);
}
diff --git a/test/fwd_kf_test.cc b/test/fwd_kf_test.cc
index db429da..6c0050b 100644
--- a/test/fwd_kf_test.cc
+++ b/test/fwd_kf_test.cc
@@ -26,7 +26,7 @@
} FwdKfTestParam;
const FwdKfTestParam kTestParams[] = {
- { 4, 31.1 }, { 6, 31.1 }, { 8, 32.6 },
+ { 4, 31.1 }, { 6, 31.1 }, { 8, 32.3 },
{ 12, 31.7 }, { 16, 32.3 }, { 18, 32.1 }
};
@@ -183,7 +183,7 @@
is_fwd_kf_present_ = 0;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
cfg_.g_timebase.den, cfg_.g_timebase.num,
- 0, 150);
+ 0, 60);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_EQ(is_fwd_kf_present_, 1);
}
diff --git a/test/gf_pyr_height_test.cc b/test/gf_pyr_height_test.cc
index 7b8c8e3..8cfd996 100644
--- a/test/gf_pyr_height_test.cc
+++ b/test/gf_pyr_height_test.cc
@@ -68,19 +68,19 @@
}
// Params: encoding mode, rate control mode and GFPyrHeightTestParam object.
-class GFPyrHeightTest
+class GFPyrHeightTestLarge
: public ::libaom_test::CodecTestWith3Params<
libaom_test::TestMode, aom_rc_mode, GFPyrHeightTestParam>,
public ::libaom_test::EncoderTest {
protected:
- GFPyrHeightTest()
+ GFPyrHeightTestLarge()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
rc_mode_(GET_PARAM(2)) {
gf_min_pyr_height_ = GET_PARAM(3).gf_min_pyr_height;
gf_max_pyr_height_ = GET_PARAM(3).gf_max_pyr_height;
psnr_threshold_ = GET_PARAM(3).psnr_thresh;
}
- virtual ~GFPyrHeightTest() {}
+ virtual ~GFPyrHeightTestLarge() {}
virtual void SetUp() {
InitializeConfig();
@@ -139,7 +139,7 @@
double psnr_;
};
-TEST_P(GFPyrHeightTest, EncodeAndVerifyPSNR) {
+TEST_P(GFPyrHeightTestLarge, EncodeAndVerifyPSNR) {
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
cfg_.g_timebase.den, cfg_.g_timebase.num,
0, 32);
@@ -149,7 +149,7 @@
<< "GF Max Pyramid Height = " << gf_max_pyr_height_;
}
-AV1_INSTANTIATE_TEST_SUITE(GFPyrHeightTest, GOODQUALITY_TEST_MODES,
+AV1_INSTANTIATE_TEST_SUITE(GFPyrHeightTestLarge, GOODQUALITY_TEST_MODES,
::testing::Values(AOM_Q, AOM_VBR),
::testing::ValuesIn(kTestParams));
} // namespace
diff --git a/test/horz_superres_test.cc b/test/horz_superres_test.cc
index c7f1e54..be61740 100644
--- a/test/horz_superres_test.cc
+++ b/test/horz_superres_test.cc
@@ -54,9 +54,9 @@
const TestVideoParam kTestVideoVectors[] = {
{ "park_joy_90p_8_420.y4m", AOM_IMG_FMT_I420, AOM_BITS_8, 0, 5, 0, 25.0,
- 44.7 },
+ 43.0 },
{ "park_joy_90p_10_444.y4m", AOM_IMG_FMT_I44416, AOM_BITS_10, 1, 5, 0, 28.0,
- 47.7 },
+ 47.5 },
{ "screendata.y4m", AOM_IMG_FMT_I420, AOM_BITS_8, 0, 4, 1, 16.0, 56.0 },
// Image coding (single frame).
{ "niklas_1280_720_30.y4m", AOM_IMG_FMT_I420, AOM_BITS_8, 0, 1, 0, 25.0,
diff --git a/test/kf_test.cc b/test/kf_test.cc
index 4e290e3..4a2910c 100644
--- a/test/kf_test.cc
+++ b/test/kf_test.cc
@@ -73,6 +73,20 @@
}
}
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+ if (kf_dist_ != -1) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ kf_dist_ += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ (void)pkt;
+ ++kf_dist_;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (kf_dist_ > (int)kf_dist_param_.max_kf_dist) {
+ is_kf_interval_violated_ = true;
+ }
+ }
+ }
+
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
libaom_test::Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
@@ -81,12 +95,6 @@
int frame_flags = 0;
AOM_CODEC_CONTROL_TYPECHECKED(ctx_dec, AOMD_GET_FRAME_FLAGS,
&frame_flags);
- if (kf_dist_ != -1) {
- kf_dist_++;
- if (kf_dist_ > (int)kf_dist_param_.max_kf_dist) {
- is_kf_interval_violated_ = true;
- }
- }
if ((frame_flags & AOM_FRAME_IS_KEY) ==
static_cast<aom_codec_frame_flags_t>(AOM_FRAME_IS_KEY)) {
if (kf_dist_ != -1 && kf_dist_ < (int)kf_dist_param_.min_kf_dist) {
@@ -172,7 +180,9 @@
is_kf_placement_violated_ = true;
}
}
+#if !CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
++frame_num_;
+#endif // !CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
return AOM_CODEC_OK == res_dec;
}
diff --git a/test/level_test.cc b/test/level_test.cc
index 7c053d1..b5e0869 100644
--- a/test/level_test.cc
+++ b/test/level_test.cc
@@ -26,21 +26,21 @@
const int kLevelKeepStats = 24;
// Speed settings tested
static const int kCpuUsedVectors[] = {
- 1,
2,
3,
4,
+ 5,
};
-class LevelTest
+class LevelTestLarge
: public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode, int>,
public ::libaom_test::EncoderTest {
protected:
- LevelTest()
+ LevelTestLarge()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
cpu_used_(GET_PARAM(2)), target_level_(31) {}
- virtual ~LevelTest() {}
+ virtual ~LevelTestLarge() {}
virtual void SetUp() {
InitializeConfig();
@@ -70,7 +70,7 @@
int level_[32];
};
-TEST_P(LevelTest, TestTargetLevelApi) {
+TEST_P(LevelTestLarge, TestTargetLevelApi) {
static aom_codec_iface_t *codec = &aom_codec_av1_cx_algo;
aom_codec_ctx_t enc;
aom_codec_enc_cfg_t cfg;
@@ -96,7 +96,7 @@
EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
}
-TEST_P(LevelTest, TestTargetLevel19) {
+TEST_P(LevelTestLarge, TestTargetLevel19) {
std::unique_ptr<libaom_test::VideoSource> video;
video.reset(new libaom_test::Y4mVideoSource("park_joy_90p_8_420.y4m", 0, 10));
ASSERT_TRUE(video.get() != NULL);
@@ -105,9 +105,9 @@
ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
}
-TEST_P(LevelTest, TestLevelMonitoringLowBitrate) {
+TEST_P(LevelTestLarge, TestLevelMonitoringLowBitrate) {
// To save run time, we only test speed 4.
- if (cpu_used_ == 4) {
+ if (cpu_used_ == 5) {
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 40);
target_level_ = kLevelKeepStats;
@@ -118,22 +118,23 @@
}
}
-TEST_P(LevelTest, TestLevelMonitoringHighBitrate) {
+TEST_P(LevelTestLarge, TestLevelMonitoringHighBitrate) {
// To save run time, we only test speed 4.
- if (cpu_used_ == 4) {
+ if (cpu_used_ == 5) {
+ const int num_frames = 17;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- 30, 1, 0, 40);
+ 30, 1, 0, num_frames);
target_level_ = kLevelKeepStats;
cfg_.rc_target_bitrate = 4000;
- cfg_.g_limit = 40;
+ cfg_.g_limit = num_frames;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_EQ(level_[0], 4);
}
}
-TEST_P(LevelTest, TestTargetLevel0) {
+TEST_P(LevelTestLarge, TestTargetLevel0) {
// To save run time, we only test speed 4.
- if (cpu_used_ == 4) {
+ if (cpu_used_ == 5) {
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 50);
const int target_level = 0;
@@ -144,7 +145,7 @@
}
}
-AV1_INSTANTIATE_TEST_SUITE(LevelTest,
+AV1_INSTANTIATE_TEST_SUITE(LevelTestLarge,
::testing::Values(::libaom_test::kOnePassGood),
::testing::ValuesIn(kCpuUsedVectors));
} // namespace
diff --git a/test/lossless_test.cc b/test/lossless_test.cc
index a5cf3d7..69f3ff4 100644
--- a/test/lossless_test.cc
+++ b/test/lossless_test.cc
@@ -22,15 +22,13 @@
namespace {
-const int kMaxPsnr = 100;
-
class LosslessTestLarge
: public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode,
aom_rc_mode>,
public ::libaom_test::EncoderTest {
protected:
LosslessTestLarge()
- : EncoderTest(GET_PARAM(0)), psnr_(kMaxPsnr), nframes_(0),
+ : EncoderTest(GET_PARAM(0)), psnr_(DBL_MAX), nframes_(0),
encoding_mode_(GET_PARAM(1)), rc_end_usage_(GET_PARAM(2)) {}
virtual ~LosslessTestLarge() {}
@@ -53,7 +51,7 @@
}
virtual void BeginPassHook(unsigned int /*pass*/) {
- psnr_ = kMaxPsnr;
+ psnr_ = DBL_MAX;
nframes_ = 0;
}
@@ -95,11 +93,17 @@
init_flags_ = AOM_CODEC_USE_PSNR;
// intentionally changed the dimension for better testing coverage
- libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- timebase.den, timebase.num, 0, 5);
+ const unsigned int width = 352;
+ const unsigned int height = 288;
+ const unsigned int bit_depth = 8;
+ libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", width,
+ height, timebase.den, timebase.num, 0, 5);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
- const double psnr_lossless = GetMinPsnr();
- EXPECT_GE(psnr_lossless, kMaxPsnr);
+
+ const double min_psnr = GetMinPsnr();
+ const double lossless_psnr =
+ get_lossless_psnr(width, height, bit_depth, false);
+ EXPECT_EQ(min_psnr, lossless_psnr);
}
TEST_P(LosslessTestLarge, TestLossLessEncoding444) {
@@ -115,8 +119,10 @@
init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
- const double psnr_lossless = GetMinPsnr();
- EXPECT_GE(psnr_lossless, kMaxPsnr);
+
+ const double min_psnr = GetMinPsnr();
+ const double lossless_psnr = get_lossless_psnr(352, 288, 8, true);
+ EXPECT_EQ(min_psnr, lossless_psnr);
}
TEST_P(LosslessTestLarge, TestLossLessEncodingCtrl) {
@@ -131,11 +137,17 @@
init_flags_ = AOM_CODEC_USE_PSNR;
- libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- timebase.den, timebase.num, 0, 5);
+ const unsigned int width = 352;
+ const unsigned int height = 288;
+ const unsigned int bit_depth = 8;
+ libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", width,
+ height, timebase.den, timebase.num, 0, 5);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
- const double psnr_lossless = GetMinPsnr();
- EXPECT_GE(psnr_lossless, kMaxPsnr);
+
+ const double min_psnr = GetMinPsnr();
+ const double lossless_psnr =
+ get_lossless_psnr(width, height, bit_depth, false);
+ EXPECT_EQ(min_psnr, lossless_psnr);
}
AV1_INSTANTIATE_TEST_SUITE(LosslessTestLarge, GOODQUALITY_TEST_MODES,
diff --git a/test/resize_test.cc b/test/resize_test.cc
index f4fc0ee..46a17a1 100644
--- a/test/resize_test.cc
+++ b/test/resize_test.cc
@@ -279,8 +279,11 @@
#if WRITE_COMPRESSED_STREAM
virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ out_frames_ += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
++out_frames_;
-
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
// Write initial file header if first frame.
if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
@@ -372,6 +375,9 @@
if (video->frame() == 0) {
encoder->Control(AOME_SET_CPUUSED, cpu_used_);
encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ encoder->Control(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, 0);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
}
diff --git a/test/sad_test.cc b/test/sad_test.cc
index 340e1e8..fd21490 100644
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -1495,8 +1495,10 @@
make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 8),
make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 8),
make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 8),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 8),
make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 8),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 8),
make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 8),
make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 8),
@@ -1508,8 +1510,10 @@
make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 10),
make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 10),
make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 10),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 10),
make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 10),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 10),
make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 10),
make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 10),
@@ -1521,8 +1525,10 @@
make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 12),
make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 12),
make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 12),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 12),
make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 12),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 12),
make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 12),
make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 12),
@@ -1543,11 +1549,13 @@
make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 12),
make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 12),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 8),
- make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 8),
make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 10),
- make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 10),
make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 12),
+#endif // !CONFIG_UNEVEN_4WAY
+ make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 10),
make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 12),
};
INSTANTIATE_TEST_SUITE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
@@ -1559,8 +1567,10 @@
make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 8),
make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 8),
make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 8),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 8),
make_tuple(16, 8, &aom_highbd_sad_skip_16x8_sse2, 8),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 8),
make_tuple(8, 8, &aom_highbd_sad_skip_8x8_sse2, 8),
make_tuple(4, 8, &aom_highbd_sad_skip_4x8_sse2, 8),
@@ -1576,8 +1586,10 @@
make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 10),
make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 10),
make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 10),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 10),
make_tuple(16, 8, &aom_highbd_sad_skip_16x8_sse2, 10),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 10),
make_tuple(8, 8, &aom_highbd_sad_skip_8x8_sse2, 10),
make_tuple(4, 8, &aom_highbd_sad_skip_4x8_sse2, 10),
@@ -1593,8 +1605,10 @@
make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 12),
make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 12),
make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 12),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 12),
make_tuple(16, 8, &aom_highbd_sad_skip_16x8_sse2, 12),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 12),
make_tuple(8, 8, &aom_highbd_sad_skip_8x8_sse2, 12),
make_tuple(4, 8, &aom_highbd_sad_skip_4x8_sse2, 12),
@@ -1614,8 +1628,10 @@
make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 8),
make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 8),
make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 8),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 8),
make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 8),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 8),
make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 8),
make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 8),
@@ -1627,8 +1643,10 @@
make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 10),
make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 10),
make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 10),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 10),
make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 10),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 10),
make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 10),
make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 10),
@@ -1640,8 +1658,10 @@
make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 12),
make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 12),
make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 12),
+#if !CONFIG_UNEVEN_4WAY
make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 12),
make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 12),
+#endif // !CONFIG_UNEVEN_4WAY
make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 12),
make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 12),
make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 12),
diff --git a/test/scan_test.cc b/test/scan_test.cc
index cf3c317..e356c50 100644
--- a/test/scan_test.cc
+++ b/test/scan_test.cc
@@ -110,7 +110,7 @@
SCAN_MODE scan_mode;
TX_CLASS tx_class = tx_type_to_class[(TX_TYPE)tx_type];
if (tx_class == TX_CLASS_2D) {
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
scan_mode = SCAN_MODE_COL_DIAG;
#else
if (rows == cols) {
@@ -120,7 +120,7 @@
} else {
scan_mode = SCAN_MODE_COL_DIAG;
}
-#endif // CONFIG_ATC_COEFCODING
+#endif // CONFIG_ATC
} else if (tx_class == TX_CLASS_VERT) {
scan_mode = SCAN_MODE_ROW_1D;
} else {
diff --git a/test/sef_test.cc b/test/sef_test.cc
new file mode 100644
index 0000000..e1bfa72
--- /dev/null
+++ b/test/sef_test.cc
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2023, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the
+ * Alliance for Open Media Patent License 1.0 was not distributed with this
+ * source code in the PATENTS file, you can obtain it at
+ * aomedia.org/license/patent-license/.
+ */
+
+#include <ostream>
+
+#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
+#include "test/codec_factory.h"
+#include "test/encode_test_driver.h"
+#include "test/i420_video_source.h"
+#include "test/util.h"
+
+namespace {
+
+static const struct SEFTestParam {
+ int enable_frame_output_order_derivation;
+ double psnr_thresh;
+} sefTestParams[] = {
+ // enable_frame_output_order_derivation = 0
+ { 0, 30.0 },
+ // enable_frame_output_order_derivation = 1
+ { 1, 30.0 },
+};
+
+// Compiler may decide to add some padding to the struct above for alignment,
+// which the gtest may try to print (on error for example). This would cause
+// valgrind to complain that the padding is uninitialized. To avoid that, we
+// provide our own function to print the struct.
+// This also makes '--gtest_list_tests' output more understandable.
+std::ostream &operator<<(std::ostream &os, const SEFTestParam &p) {
+ os << "SEFTestParam { "
+ << "frame_output_order_derivation = "
+ << p.enable_frame_output_order_derivation << ", "
+ << "psnr_thresh = " << p.psnr_thresh << " }";
+ return os;
+}
+
+// Params: encoding mode, rate control mode and SEFTestParam object.
+class SEFTest
+ : public ::libaom_test::CodecTestWith3Params<libaom_test::TestMode,
+ aom_rc_mode, SEFTestParam>,
+ public ::libaom_test::EncoderTest {
+ protected:
+ SEFTest()
+ : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
+ rc_mode_(GET_PARAM(2)) {
+ enable_frame_output_order_derivation_ =
+ GET_PARAM(3).enable_frame_output_order_derivation;
+ psnr_threshold_ = GET_PARAM(3).psnr_thresh;
+ }
+ virtual ~SEFTest() {}
+
+ virtual void SetUp() {
+ InitializeConfig();
+ SetMode(encoding_mode_);
+ const aom_rational timebase = { 1, 30 };
+ cfg_.g_timebase = timebase;
+ cpu_used_ = 4;
+ cfg_.rc_end_usage = rc_mode_;
+ cfg_.g_lag_in_frames = 19;
+ cfg_.g_threads = 0;
+ init_flags_ = AOM_CODEC_USE_PSNR;
+ }
+
+ virtual void BeginPassHook(unsigned int) {
+ psnr_ = 0.0;
+ nframes_ = 0;
+ }
+
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
+ psnr_ += pkt->data.psnr.psnr[0];
+ nframes_++;
+ }
+
+ virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
+ ::libaom_test::Encoder *encoder) {
+ if (video->frame() == 0) {
+ encoder->Control(AOME_SET_CPUUSED, cpu_used_);
+ if (rc_mode_ == AOM_Q) {
+ encoder->Control(AOME_SET_QP, 210);
+ }
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ encoder->Control(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION,
+ enable_frame_output_order_derivation_);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ }
+ }
+
+ double GetAveragePsnr() const {
+ if (nframes_) return psnr_ / nframes_;
+ return 0.0;
+ }
+
+ double GetPsnrThreshold() { return psnr_threshold_; }
+
+ ::libaom_test::TestMode encoding_mode_;
+ aom_rc_mode rc_mode_;
+ int enable_frame_output_order_derivation_;
+ double psnr_threshold_;
+ int cpu_used_;
+ int nframes_;
+ double psnr_;
+};
+
+TEST_P(SEFTest, TestShowExistingFrame) {
+ libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
+ cfg_.g_timebase.den, cfg_.g_timebase.num,
+ 0, 32);
+ ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
+ EXPECT_GT(GetAveragePsnr(), GetPsnrThreshold())
+ << "Frame output order derivation = "
+ << enable_frame_output_order_derivation_ << ", ";
+}
+
+AV1_INSTANTIATE_TEST_SUITE(SEFTest, GOODQUALITY_TEST_MODES,
+ ::testing::Values(AOM_Q),
+ ::testing::ValuesIn(sefTestParams));
+} // namespace
diff --git a/test/subgop_test.cc b/test/subgop_test.cc
index c77b5c0..be62bd3 100644
--- a/test/subgop_test.cc
+++ b/test/subgop_test.cc
@@ -62,6 +62,9 @@
// low delay config without references
extern "C" const char subgop_config_str_ld[];
+const int kCpuUsed = 5;
+const unsigned int kFrames = 70;
+
typedef enum {
DEFAULT,
ENHANCE,
@@ -88,7 +91,6 @@
int max_gf_interval;
int frame_w;
int frame_h;
- int cpu_used;
int lag_in_frames;
int use_fixed_qp_offsets;
} SubgopTestParams;
@@ -104,69 +106,69 @@
static const SubgopTestParams SubGopTestVectors[] = {
// Default subgop config
{ subgop_config_str_preset_map[DEFAULT].preset_tag,
- "hantro_collage_w352h288.yuv", 0, 16, 352, 288, 5, 35, 0 },
+ "hantro_collage_w352h288.yuv", 0, 16, 352, 288, 35, 0 },
{ subgop_config_str_preset_map[DEFAULT].preset_tag, "desktop1.320_180.yuv", 0,
- 16, 320, 180, 5, 35, 0 },
+ 16, 320, 180, 35, 0 },
{ subgop_config_str_preset_map[DEFAULT].preset_tag,
- "pixel_capture_w320h240.yuv", 16, 16, 320, 240, 5, 35, 1 },
+ "pixel_capture_w320h240.yuv", 16, 16, 320, 240, 35, 1 },
{ subgop_config_str_preset_map[DEFAULT].preset_tag,
- "hantro_collage_w352h288.yuv", 0, 32, 352, 288, 5, 35, 0 },
+ "hantro_collage_w352h288.yuv", 0, 32, 352, 288, 35, 0 },
{ subgop_config_str_preset_map[DEFAULT].preset_tag,
- "pixel_capture_w320h240.yuv", 32, 32, 320, 240, 5, 35, 1 },
+ "pixel_capture_w320h240.yuv", 32, 32, 320, 240, 35, 1 },
// Enhanced subgop config
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "niklas_640_480_30.yuv",
- 0, 15, 640, 480, 5, 35, 0 },
+ 0, 15, 640, 480, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "paris_352_288_30.y4m", 0,
- 6, 352, 288, 5, 35, 0 },
+ 6, 352, 288, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "hantro_collage_w352h288.yuv", 0, 16, 352, 288, 5, 35, 0 },
+ "hantro_collage_w352h288.yuv", 0, 16, 352, 288, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "pixel_capture_w320h240.yuv", 0, 12, 320, 240, 5, 35, 0 },
+ "pixel_capture_w320h240.yuv", 0, 12, 320, 240, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "niklas_1280_720_30.y4m",
- 0, 11, 1280, 720, 5, 35, 0 },
+ 0, 11, 1280, 720, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "screendata.y4m", 0, 16,
- 640, 480, 5, 35, 0 },
+ 640, 480, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "pixel_capture_w320h240.yuv", 0, 14, 320, 240, 5, 35, 0 },
+ "pixel_capture_w320h240.yuv", 0, 14, 320, 240, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "desktop1.320_180.yuv", 0,
- 10, 320, 180, 5, 35, 0 },
+ 10, 320, 180, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "paris_352_288_30.y4m", 0,
- 13, 352, 288, 5, 35, 0 },
+ 13, 352, 288, 35, 0 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "pixel_capture_w320h240.yuv", 0, 8, 320, 240, 5, 35, 0 },
+ "pixel_capture_w320h240.yuv", 0, 8, 320, 240, 35, 0 },
// Asymmetric subgop config
{ subgop_config_str_preset_map[ASYMMETRIC].preset_tag,
- "pixel_capture_w320h240.yuv", 0, 16, 320, 240, 5, 35, 0 },
+ "pixel_capture_w320h240.yuv", 0, 16, 320, 240, 35, 0 },
{ subgop_config_str_preset_map[ASYMMETRIC].preset_tag, "desktop1.320_180.yuv",
- 0, 16, 320, 180, 5, 35, 0 },
+ 0, 16, 320, 180, 35, 0 },
// Temporal scalable subgop config
{ subgop_config_str_preset_map[TEMPORAL_SCALABLE].preset_tag,
- "pixel_capture_w320h240.yuv", 0, 16, 320, 240, 5, 35, 0 },
+ "pixel_capture_w320h240.yuv", 0, 16, 320, 240, 35, 0 },
{ subgop_config_str_preset_map[TEMPORAL_SCALABLE].preset_tag,
- "hantro_collage_w352h288.yuv", 0, 16, 352, 288, 5, 35, 0 },
+ "hantro_collage_w352h288.yuv", 0, 16, 352, 288, 35, 0 },
// Low delay subgop config
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag, "paris_352_288_30.y4m",
- 0, 16, 352, 288, 5, 0, 0 },
+ 0, 16, 352, 288, 0, 0 },
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag, "desktop1.320_180.yuv",
- 16, 16, 320, 180, 5, 0, 1 },
+ 16, 16, 320, 180, 0, 1 },
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag, "paris_352_288_30.y4m",
- 0, 32, 352, 288, 5, 0, 0 },
+ 0, 32, 352, 288, 0, 0 },
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag, "desktop1.320_180.yuv",
- 32, 32, 320, 180, 5, 0, 1 },
+ 32, 32, 320, 180, 0, 1 },
// Non-default subgop config
{ subgop_config_str_nondef[0], "pixel_capture_w320h240.yuv", 0, 4, 320, 240,
- 5, 35, 0 },
- { subgop_config_str_nondef[0], "desktop1.320_180.yuv", 0, 5, 320, 180, 5, 35,
+ 35, 0 },
+ { subgop_config_str_nondef[0], "desktop1.320_180.yuv", 0, 5, 320, 180, 35,
0 },
{ subgop_config_str_nondef[0], "pixel_capture_w320h240.yuv", 0, 7, 320, 240,
- 5, 35, 0 },
+ 35, 0 },
{ subgop_config_str_nondef[0], "hantro_collage_w352h288.yuv", 0, 9, 352, 288,
- 5, 35, 0 },
+ 35, 0 },
};
std::ostream &operator<<(std::ostream &os, const SubgopTestParams &test_arg) {
@@ -175,8 +177,7 @@
<< " min_gf_interval:" << test_arg.min_gf_interval
<< " max_gf_interval:" << test_arg.max_gf_interval
<< " frame_width:" << test_arg.frame_w
- << " frame_height:" << test_arg.frame_h
- << " cpu_used:" << test_arg.cpu_used
+ << " frame_height:" << test_arg.frame_h << " cpu_used:" << kCpuUsed
<< " lag_in_frames:" << test_arg.lag_in_frames
<< " use_fixed_qp_offsets:" << test_arg.use_fixed_qp_offsets
<< " }";
@@ -229,7 +230,7 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(AOME_SET_CPUUSED, subgop_test_params_.cpu_used);
+ encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
if (rc_end_usage_ == AOM_Q) {
encoder->Control(AOME_SET_QP, 210);
}
@@ -262,7 +263,6 @@
ResetSubgop();
is_first_frame_in_subgop_key_ = 0;
frames_from_key_ = 0;
- frame_num_ = 0;
enable_subgop_stats_ = 1;
memset(&subgop_last_step_, 0, sizeof(subgop_last_step_));
}
@@ -420,12 +420,18 @@
// Validates frametype(along with temporal filtering), frame coding order
bool ValidateSubgopFrametype() {
for (int idx = 0; idx < subgop_cfg_ref_->num_steps; idx++) {
- EXPECT_EQ(subgop_cfg_ref_->step[idx].disp_frame_idx,
- subgop_cfg_test_.step[idx].disp_frame_idx)
- << "Error:display_index doesn't match";
- EXPECT_EQ(subgop_cfg_ref_->step[idx].type_code,
- subgop_cfg_test_.step[idx].type_code)
- << "Error:frame type doesn't match";
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (subgop_cfg_ref_->step[idx].type_code != FRAME_TYPE_INO_SHOWEXISTING) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ EXPECT_EQ(subgop_cfg_ref_->step[idx].disp_frame_idx,
+ subgop_cfg_test_.step[idx].disp_frame_idx)
+ << "Error:display_index doesn't match";
+ EXPECT_EQ(subgop_cfg_ref_->step[idx].type_code,
+ subgop_cfg_test_.step[idx].type_code)
+ << "Error:frame type doesn't match";
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ }
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
return 1;
}
@@ -438,12 +444,18 @@
max_pyramid_level = subgop_cfg_ref_->step[idx].pyr_level;
}
for (int idx = 0; idx < subgop_cfg_ref_->num_steps; idx++) {
- int8_t ref_pyramid_level =
- (subgop_cfg_ref_->step[idx].pyr_level == max_pyramid_level)
- ? MAX_ARF_LAYERS
- : subgop_cfg_ref_->step[idx].pyr_level;
- EXPECT_EQ(subgop_cfg_test_.step[idx].pyr_level, ref_pyramid_level)
- << "Error:pyramid level doesn't match";
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (subgop_cfg_ref_->step[idx].type_code != FRAME_TYPE_INO_SHOWEXISTING) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ int8_t ref_pyramid_level =
+ (subgop_cfg_ref_->step[idx].pyr_level == max_pyramid_level)
+ ? MAX_ARF_LAYERS
+ : subgop_cfg_ref_->step[idx].pyr_level;
+ EXPECT_EQ(subgop_cfg_test_.step[idx].pyr_level, ref_pyramid_level)
+ << "Error:pyramid level doesn't match";
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ }
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
}
@@ -454,13 +466,19 @@
int pyramid_level;
for (int idx = 0; idx < subgop_cfg_ref_->num_steps; idx++) {
pyramid_level = subgop_cfg_test_.step[idx].pyr_level;
- if (level_qindex[pyramid_level] < 0) {
- level_qindex[pyramid_level] = subgop_data_.step[idx].qindex;
- } else if (!subgop_data_.step[idx].show_existing_frame &&
- !subgop_data_.step[idx].is_filtered) {
- EXPECT_EQ(level_qindex[pyramid_level], subgop_data_.step[idx].qindex)
- << "Error:qindex in a pyramid level doesn't match";
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (subgop_cfg_ref_->step[idx].type_code != FRAME_TYPE_INO_SHOWEXISTING) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (level_qindex[pyramid_level] < 0) {
+ level_qindex[pyramid_level] = subgop_data_.step[idx].qindex;
+ } else if (!subgop_data_.step[idx].show_existing_frame &&
+ !subgop_data_.step[idx].is_filtered) {
+ EXPECT_EQ(level_qindex[pyramid_level], subgop_data_.step[idx].qindex)
+ << "Error:qindex in a pyramid level doesn't match";
+ }
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
for (pyramid_level = 1; pyramid_level <= MAX_ARF_LAYERS; pyramid_level++) {
if (level_qindex[pyramid_level] >= 0) {
@@ -486,13 +504,22 @@
int refresh_frame_flags = curr_step_data->refresh_frame_flags;
// Validates user-defined refresh_flag with decoder
if (subgop_cfg_ref_->step[idx].refresh != -1 &&
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ subgop_cfg_ref_->step[idx].type_code != FRAME_TYPE_INO_SHOWEXISTING) {
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
!curr_step_data->show_existing_frame) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
EXPECT_EQ(subgop_cfg_ref_->step[idx].refresh,
(int8_t)refresh_frame_flags)
<< "Error: refresh flag mismatch";
}
// Validates reference picture management w.r.t refresh_flags
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (refresh_frame_flags &&
+ subgop_cfg_ref_->step[idx].type_code != FRAME_TYPE_INO_SHOWEXISTING) {
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (refresh_frame_flags && !curr_step_data->show_existing_frame) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
for (int mask = refresh_frame_flags; mask; mask >>= 1) {
if (mask & 1)
EXPECT_EQ(curr_step_data->disp_frame_idx,
@@ -521,7 +548,11 @@
unsigned int *ref_frame_map =
(idx > 0) ? subgop_data_.step[idx - 1].ref_frame_map
: subgop_last_step_.ref_frame_map;
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (subgop_cfg_ref_->step[idx].type_code != FRAME_TYPE_INO_SHOWEXISTING) {
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (!subgop_data_.step[idx].show_existing_frame) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
EXPECT_EQ(subgop_cfg_ref_->step[idx].num_references,
subgop_cfg_test_.step[idx].num_references)
<< "Error:Reference frames count doesn't match";
@@ -530,7 +561,13 @@
// config.
for (int ref = 0; ref < subgop_cfg_test_.step[idx].num_references;
ref++) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ if (subgop_cfg_ref_->step[idx].type_code !=
+ FRAME_TYPE_INO_SHOWEXISTING &&
+ subgop_data_.step[idx].is_valid_ref_frame[ref]) {
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
if (subgop_data_.step[idx].is_valid_ref_frame[ref]) {
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
EXPECT_EQ(subgop_cfg_ref_->step[idx].references[ref],
subgop_cfg_test_.step[idx].references[ref])
<< "Error:Reference frame level doesn't match";
@@ -574,12 +611,21 @@
}
}
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ frame_num_in_subgop_ += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ (void)pkt;
+ ++frame_num_in_subgop_;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ }
+
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
libaom_test::Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
if (AOM_CODEC_OK != res_dec) return 0;
aom_codec_ctx_t *ctx_dec = decoder->GetDecoder();
- frame_num_in_subgop_++;
+
int is_last_frame_in_subgop = (frame_num_in_subgop_ == subgop_info_.size);
if (subgop_info_.is_user_specified ||
@@ -614,7 +660,6 @@
}
ResetSubgop();
}
- frame_num_++;
return AOM_CODEC_OK == res_dec;
}
@@ -642,59 +687,62 @@
libaom_test::I420VideoSource video(
subgop_test_params_.input_file, subgop_test_params_.frame_w,
subgop_test_params_.frame_h, cfg_.g_timebase.den, cfg_.g_timebase.num,
- 0, 200);
+ 0, kFrames);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} else {
- ::libaom_test::Y4mVideoSource video(subgop_test_params_.input_file, 0, 200);
+ ::libaom_test::Y4mVideoSource video(subgop_test_params_.input_file, 0,
+ kFrames);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
}
AV1_INSTANTIATE_TEST_SUITE(SubGopTestLarge,
::testing::ValuesIn(SubGopTestVectors),
- ::testing::Values(AOM_Q, AOM_VBR, AOM_CQ, AOM_CBR));
+ ::testing::Values(AOM_Q, AOM_VBR
+ // Disabled to reduce combinations.
+ //, AOM_CQ, AOM_CBR
+ ));
typedef struct {
const char *subgop_str;
const char *input_file;
int frame_w;
int frame_h;
- int cpu_used;
int lag_in_frames;
} SubgopPsnrTestParams;
static const SubgopPsnrTestParams SubGopPsnrTestVectors[] = {
{ subgop_config_str_preset_map[DEFAULT].preset_tag,
- "hantro_collage_w352h288.yuv", 352, 288, 3, 35 },
+ "hantro_collage_w352h288.yuv", 352, 288, 35 },
{ subgop_config_str_preset_map[DEFAULT].preset_tag, "desktop1.320_180.yuv",
- 320, 180, 5, 35 },
+ 320, 180, 35 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "hantro_collage_w352h288.yuv", 352, 288, 3, 35 },
+ "hantro_collage_w352h288.yuv", 352, 288, 35 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "pixel_capture_w320h240.yuv", 320, 240, 5, 35 },
+ "pixel_capture_w320h240.yuv", 320, 240, 35 },
// TODO(any): Enable after fix
/* { subgop_config_str_preset_map[ENHANCE].preset_tag, "paris_352_288_30.y4m",
- 352, 288, 3, 35 },
+ 352, 288, 35 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "screendata.y4m", 640,
- 480, 5, 35 },
+ 480, 35 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "paris_352_288_30.y4m",
- 352, 288, 5, 35 }, */
+ 352, 288, 35 }, */
{ subgop_config_str_preset_map[ASYMMETRIC].preset_tag,
- "pixel_capture_w320h240.yuv", 320, 240, 5, 35 },
+ "pixel_capture_w320h240.yuv", 320, 240, 35 },
// TODO(any): Enable after fix
/* { subgop_config_str_preset_map[ASYMMETRIC].preset_tag,
- "desktop1.320_180.yuv", 320, 180, 3, 35 }, */
+ "desktop1.320_180.yuv", 320, 180, 35 }, */
{ subgop_config_str_preset_map[TEMPORAL_SCALABLE].preset_tag,
- "hantro_collage_w352h288.yuv", 352, 288, 5, 35 },
+ "hantro_collage_w352h288.yuv", 352, 288, 35 },
// TODO(any): Enable after fix
/* { subgop_config_str_preset_map[LOW_DELAY].preset_tag,
- "paris_352_288_30.y4m", 352, 288, 5, 0 },
+ "paris_352_288_30.y4m", 352, 288, 0 },
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag,
- "desktop1.320_180.yuv", 320, 180, 3, 0 }, */
+ "desktop1.320_180.yuv", 320, 180, 0 }, */
};
std::ostream &operator<<(std::ostream &os,
@@ -702,8 +750,7 @@
return os << "SubgopPsnrTestParams { sub_gop_config:" << test_arg.subgop_str
<< " source_file:" << test_arg.input_file
<< " frame_width:" << test_arg.frame_w
- << " frame_height:" << test_arg.frame_h
- << " cpu_used:" << test_arg.cpu_used
+ << " frame_height:" << test_arg.frame_h << " cpu_used:" << kCpuUsed
<< " lag_in_frames:" << test_arg.lag_in_frames << " }";
}
@@ -748,7 +795,10 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(AOME_SET_CPUUSED, test_params_.cpu_used);
+ encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
+ if (rc_end_usage_ == AOM_Q) {
+ encoder->Control(AOME_SET_QP, 210);
+ }
if (enable_subgop_)
encoder->Control(AV1E_SET_SUBGOP_CONFIG_STR, test_params_.subgop_str);
}
@@ -764,8 +814,7 @@
TEST_P(SubGopPSNRCheckTestLarge, SubGopPSNRCheck) {
std::unique_ptr<libaom_test::VideoSource> video;
- const unsigned int kFrames = 100;
- const double psnr_diff_thresh = 0.3;
+ const double psnr_diff_thresh = 0.5;
if (is_extension_y4m(test_params_.input_file)) {
video.reset(
new libaom_test::Y4mVideoSource(test_params_.input_file, 0, kFrames));
@@ -800,7 +849,6 @@
const char *input_file;
int frame_w;
int frame_h;
- int cpu_used;
int lag_in_frames;
int max_gf_interval;
} SubGopSwitchTestParams;
@@ -810,30 +858,29 @@
return os << "SubGopSwitchTestParams { sub_gop_config:" << test_arg.subgop_str
<< " source_file:" << test_arg.input_file
<< " frame_width:" << test_arg.frame_w
- << " frame_height:" << test_arg.frame_h
- << " cpu_used:" << test_arg.cpu_used
+ << " frame_height:" << test_arg.frame_h << " cpu_used:" << kCpuUsed
<< " lag_in_frames:" << test_arg.lag_in_frames
<< " max_gf_interval:" << test_arg.max_gf_interval << " }";
}
static const SubGopSwitchTestParams SubgopSwitchTestVectors[] = {
{ subgop_config_str_preset_map[DEFAULT].preset_tag, "niklas_640_480_30.yuv",
- 640, 480, 5, 35, 16 },
+ 640, 480, 35, 16 },
/* TODO(sarahparker/debargha): Enable after adding default 32 subgop config.
{ subgop_config_str_preset_map[DEFAULT].preset_tag, "niklas_640_480_30.yuv",
- 640, 480, 5, 35, 32 },*/
+ 640, 480, 35, 32 },*/
{ subgop_config_str_preset_map[ENHANCE].preset_tag, "desktop1.320_180.yuv",
- 320, 180, 3, 35, 16 },
+ 320, 180, 35, 16 },
{ subgop_config_str_preset_map[ENHANCE].preset_tag,
- "hantro_collage_w352h288.yuv", 352, 288, 5, 35, 16 },
+ "hantro_collage_w352h288.yuv", 352, 288, 35, 16 },
{ subgop_config_str_preset_map[ASYMMETRIC].preset_tag,
- "pixel_capture_w320h240.yuv", 320, 240, 3, 35, 16 },
+ "pixel_capture_w320h240.yuv", 320, 240, 35, 16 },
{ subgop_config_str_preset_map[TEMPORAL_SCALABLE].preset_tag,
- "paris_352_288_30.y4m", 352, 288, 3, 35, 16 },
+ "paris_352_288_30.y4m", 352, 288, 35, 16 },
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag, "screendata.y4m", 640,
- 480, 5, 0, 16 },
+ 480, 0, 16 },
{ subgop_config_str_preset_map[LOW_DELAY].preset_tag, "screendata.y4m", 640,
- 480, 5, 0, 32 },
+ 480, 0, 32 },
};
using libaom_test::ACMRandom;
@@ -897,18 +944,26 @@
// Set max gf interval
if (subgop_str) encoder->Control(AV1E_SET_MAX_GF_INTERVAL, max_gf_interval);
+ // Keep min gf interval same as max gf interval in most cases, to ensure
+ // that user-provided subgop config is used.
+ int min_gf_interval = max_gf_interval;
+ // In case of no subgop config / enhanced subgop config, test arbitrary gf
+ // intervals by setting a lower min gf interval.
+ if (!subgop_str || !strcmp(subgop_str, "enh")) min_gf_interval = 6;
+
+ // Set min gf interval
+ encoder->Control(AV1E_SET_MIN_GF_INTERVAL, min_gf_interval);
+
last_subgop_str_ = subgop_str;
}
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(AOME_SET_CPUUSED, test_params_.cpu_used);
+ encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
if (rc_end_usage_ == AOM_Q) {
encoder->Control(AOME_SET_QP, 210);
}
- // Set min gf interval
- encoder->Control(AV1E_SET_MIN_GF_INTERVAL, 6);
set_subgop_config(encoder);
}
@@ -943,13 +998,20 @@
return 1;
}
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ frame_num_in_subgop_ += pkt->data.frame.frame_count;
+#else // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ (void)pkt;
+ ++frame_num_in_subgop_;
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ }
+
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
libaom_test::Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
if (AOM_CODEC_OK != res_dec) return 0;
- frame_num_in_subgop_++;
-
return AOM_CODEC_OK == res_dec;
}
SubGopSwitchTestParams test_params_;
@@ -966,8 +1028,6 @@
TEST_P(SubGopSwitchingTestLarge, SubGopSwitching) {
std::unique_ptr<libaom_test::VideoSource> video;
- const unsigned int kFrames = 175;
-
if (is_extension_y4m(test_params_.input_file)) {
video.reset(
new libaom_test::Y4mVideoSource(test_params_.input_file, 0, kFrames));
diff --git a/test/test.cmake b/test/test.cmake
index a402306..7642949 100644
--- a/test/test.cmake
+++ b/test/test.cmake
@@ -132,6 +132,7 @@
"${AOM_ROOT}/test/segment_binarization_sync.cc"
"${AOM_ROOT}/test/still_picture_test.cc"
"${AOM_ROOT}/test/subgop_test.cc"
+ "${AOM_ROOT}/test/sef_test.cc"
"${AOM_ROOT}/test/superframe_test.cc"
"${AOM_ROOT}/test/tile_config_test.cc"
"${AOM_ROOT}/test/tile_independence_test.cc"
diff --git a/test/tile_config_test.cc b/test/tile_config_test.cc
index 2bed6cb..8588c53 100644
--- a/test/tile_config_test.cc
+++ b/test/tile_config_test.cc
@@ -324,6 +324,9 @@
tile_group_config_params_.num_tile_cols);
encoder->Control(AV1E_SET_TILE_ROWS,
tile_group_config_params_.num_tile_rows);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ encoder->Control(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, 0);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
}
}
diff --git a/test/tile_independence_test.cc b/test/tile_independence_test.cc
index aca8c8d..9a6689d 100644
--- a/test/tile_independence_test.cc
+++ b/test/tile_independence_test.cc
@@ -62,6 +62,9 @@
if (video->frame() == 0) {
encoder->Control(AV1E_SET_TILE_COLUMNS, n_tile_cols_);
encoder->Control(AV1E_SET_TILE_ROWS, n_tile_rows_);
+#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
+ encoder->Control(AV1E_SET_FRAME_OUTPUT_ORDER_DERIVATION, 0);
+#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
SetCpuUsed(encoder);
} else if (video->frame() == 3) {
encoder->Control(AV1E_SET_NUM_TG, n_tile_groups_);
diff --git a/test/util.h b/test/util.h
index e311207..e0ffe04 100644
--- a/test/util.h
+++ b/test/util.h
@@ -22,27 +22,49 @@
// Macros
#define GET_PARAM(k) std::get<k>(GetParam())
+// Same as 'aom_sse_to_psnr'.
+inline double sse_to_psnr(double samples, double peak, double sse) {
+ static const double kMinSSE = 0.5;
+ const bool zero_sse = (sse < kMinSSE);
+ if (zero_sse) sse = kMinSSE;
+ assert(sse > 0.0);
+ double psnr = 10.0 * log10(samples * peak * peak / sse);
+ if (zero_sse) psnr = ceil(psnr);
+ return psnr;
+}
+
inline double compute_psnr(const aom_image_t *img1, const aom_image_t *img2) {
assert((img1->fmt == img2->fmt) && (img1->d_w == img2->d_w) &&
(img1->d_h == img2->d_h));
const unsigned int width_y = img1->d_w;
const unsigned int height_y = img1->d_h;
- unsigned int i, j;
- int64_t sqrerr = 0;
- for (i = 0; i < height_y; ++i)
- for (j = 0; j < width_y; ++j) {
- int64_t d = img1->planes[AOM_PLANE_Y][i * img1->stride[AOM_PLANE_Y] + j] -
- img2->planes[AOM_PLANE_Y][i * img2->stride[AOM_PLANE_Y] + j];
- sqrerr += d * d;
+ double sse = 0;
+ for (unsigned int i = 0; i < height_y; ++i) {
+ for (unsigned int j = 0; j < width_y; ++j) {
+ const double d =
+ img1->planes[AOM_PLANE_Y][i * img1->stride[AOM_PLANE_Y] + j] -
+ img2->planes[AOM_PLANE_Y][i * img2->stride[AOM_PLANE_Y] + j];
+ sse += d * d;
}
- double mse = static_cast<double>(sqrerr) / (width_y * height_y);
- double psnr = 100.0;
- if (mse > 0.0) {
- psnr = 10 * log10(255.0 * 255.0 / mse);
}
- return psnr;
+ return sse_to_psnr(width_y * height_y, 255.0, sse);
+}
+
+// Returns the expected total PSNR for the zero distortion case, based on frame
+// dimensions.
+// If `is_yuv444` is true: assumes YUV4:4:4 format, otherwise assumes YUV4:2:0.
+inline double get_lossless_psnr(unsigned int width, unsigned int height,
+ unsigned int bit_depth, bool is_yuv444) {
+#if CONFIG_AV2CTC_PSNR_PEAK
+ const double peak = (double)(255 << (bit_depth - 8));
+#else
+ const double peak = (double)((1 << in_bit_depth) - 1);
+#endif // CONFIG_AV2CTC_PSNR_PEAK
+ const double y_samples = width * height;
+ const double uv_samples = is_yuv444 ? 2 * y_samples : 2 * y_samples / 4;
+ return sse_to_psnr(y_samples + uv_samples, peak, 0);
}
static INLINE double get_time_mark(aom_usec_timer *t) {
diff --git a/test/variance_test.cc b/test/variance_test.cc
index df15fcd..4e1942a 100644
--- a/test/variance_test.cc
+++ b/test/variance_test.cc
@@ -1436,9 +1436,11 @@
const SubpelVarianceParams kArrayHBDSubpelVariance_avx2[] = {
#if CONFIG_BLOCK_256X256
// SubpelVarianceParams(8, 8, &aom_highbd_12_sub_pixel_variance256x256_avx2,
-// 12), SubpelVarianceParams(8, 7,
-// &aom_highbd_12_sub_pixel_variance256x128_avx2, 12), SubpelVarianceParams(7,
-// 8, &aom_highbd_12_sub_pixel_variance128x256_avx2, 12),
+// 12),
+// SubpelVarianceParams(8, 7, &aom_highbd_12_sub_pixel_variance256x128_avx2,
+// 12),
+// SubpelVarianceParams(7, 8, &aom_highbd_12_sub_pixel_variance128x256_avx2,
+// 12),
#endif // CONFIG_BLOCK_256X256
// SubpelVarianceParams(7, 7, &aom_highbd_12_sub_pixel_variance128x128_avx2,
// 12),
@@ -1528,8 +1530,10 @@
SubpelVarianceParams(5, 5, &aom_highbd_12_sub_pixel_variance32x32_sse2, 12),
SubpelVarianceParams(5, 4, &aom_highbd_12_sub_pixel_variance32x16_sse2, 12),
SubpelVarianceParams(4, 5, &aom_highbd_12_sub_pixel_variance16x32_sse2, 12),
+#if !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(4, 4, &aom_highbd_12_sub_pixel_variance16x16_sse2, 12),
SubpelVarianceParams(4, 3, &aom_highbd_12_sub_pixel_variance16x8_sse2, 12),
+#endif // !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(3, 4, &aom_highbd_12_sub_pixel_variance8x16_sse2, 12),
SubpelVarianceParams(3, 3, &aom_highbd_12_sub_pixel_variance8x8_sse2, 12),
SubpelVarianceParams(3, 2, &aom_highbd_12_sub_pixel_variance8x4_sse2, 12),
@@ -1542,8 +1546,10 @@
SubpelVarianceParams(5, 5, &aom_highbd_10_sub_pixel_variance32x32_sse2, 10),
SubpelVarianceParams(5, 4, &aom_highbd_10_sub_pixel_variance32x16_sse2, 10),
SubpelVarianceParams(4, 5, &aom_highbd_10_sub_pixel_variance16x32_sse2, 10),
+#if !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(4, 4, &aom_highbd_10_sub_pixel_variance16x16_sse2, 10),
SubpelVarianceParams(4, 3, &aom_highbd_10_sub_pixel_variance16x8_sse2, 10),
+#endif // !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(3, 4, &aom_highbd_10_sub_pixel_variance8x16_sse2, 10),
SubpelVarianceParams(3, 3, &aom_highbd_10_sub_pixel_variance8x8_sse2, 10),
SubpelVarianceParams(3, 2, &aom_highbd_10_sub_pixel_variance8x4_sse2, 10),
@@ -1556,8 +1562,10 @@
SubpelVarianceParams(5, 5, &aom_highbd_8_sub_pixel_variance32x32_sse2, 8),
SubpelVarianceParams(5, 4, &aom_highbd_8_sub_pixel_variance32x16_sse2, 8),
SubpelVarianceParams(4, 5, &aom_highbd_8_sub_pixel_variance16x32_sse2, 8),
+#if !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(4, 4, &aom_highbd_8_sub_pixel_variance16x16_sse2, 8),
SubpelVarianceParams(4, 3, &aom_highbd_8_sub_pixel_variance16x8_sse2, 8),
+#endif // !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(3, 4, &aom_highbd_8_sub_pixel_variance8x16_sse2, 8),
SubpelVarianceParams(3, 3, &aom_highbd_8_sub_pixel_variance8x8_sse2, 8),
SubpelVarianceParams(3, 2, &aom_highbd_8_sub_pixel_variance8x4_sse2, 8),
@@ -1566,19 +1574,25 @@
SubpelVarianceParams(4, 6, &aom_highbd_12_sub_pixel_variance16x64_sse2, 12),
SubpelVarianceParams(5, 3, &aom_highbd_12_sub_pixel_variance32x8_sse2, 12),
SubpelVarianceParams(3, 5, &aom_highbd_12_sub_pixel_variance8x32_sse2, 12),
+#if !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(4, 2, &aom_highbd_12_sub_pixel_variance16x4_sse2, 12),
+#endif // !CONFIG_UNEVEN_4WAY
// SubpelVarianceParams(2, 4, &aom_highbd_12_sub_pixel_variance4x16_sse2, 12),
SubpelVarianceParams(6, 4, &aom_highbd_10_sub_pixel_variance64x16_sse2, 10),
SubpelVarianceParams(4, 6, &aom_highbd_10_sub_pixel_variance16x64_sse2, 10),
SubpelVarianceParams(5, 3, &aom_highbd_10_sub_pixel_variance32x8_sse2, 10),
SubpelVarianceParams(3, 5, &aom_highbd_10_sub_pixel_variance8x32_sse2, 10),
+#if !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(4, 2, &aom_highbd_10_sub_pixel_variance16x4_sse2, 10),
+#endif // !CONFIG_UNEVEN_4WAY
// SubpelVarianceParams(2, 4, &aom_highbd_10_sub_pixel_variance4x16_sse2, 10),
SubpelVarianceParams(6, 4, &aom_highbd_8_sub_pixel_variance64x16_sse2, 8),
SubpelVarianceParams(4, 6, &aom_highbd_8_sub_pixel_variance16x64_sse2, 8),
SubpelVarianceParams(5, 3, &aom_highbd_8_sub_pixel_variance32x8_sse2, 8),
SubpelVarianceParams(3, 5, &aom_highbd_8_sub_pixel_variance8x32_sse2, 8),
+#if !CONFIG_UNEVEN_4WAY
SubpelVarianceParams(4, 2, &aom_highbd_8_sub_pixel_variance16x4_sse2, 8),
+#endif // !CONFIG_UNEVEN_4WAY
// SubpelVarianceParams(2, 4, &aom_highbd_8_sub_pixel_variance4x16_sse2, 8),
};
INSTANTIATE_TEST_SUITE_P(SSE2, AvxHBDSubpelVarianceTest,
@@ -1597,10 +1611,12 @@
12),
SubpelAvgVarianceParams(4, 5, &aom_highbd_12_sub_pixel_avg_variance16x32_sse2,
12),
+#if !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(4, 4, &aom_highbd_12_sub_pixel_avg_variance16x16_sse2,
12),
SubpelAvgVarianceParams(4, 3, &aom_highbd_12_sub_pixel_avg_variance16x8_sse2,
12),
+#endif // !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(3, 4, &aom_highbd_12_sub_pixel_avg_variance8x16_sse2,
12),
SubpelAvgVarianceParams(3, 3, &aom_highbd_12_sub_pixel_avg_variance8x8_sse2,
@@ -1619,10 +1635,12 @@
10),
SubpelAvgVarianceParams(4, 5, &aom_highbd_10_sub_pixel_avg_variance16x32_sse2,
10),
+#if !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(4, 4, &aom_highbd_10_sub_pixel_avg_variance16x16_sse2,
10),
SubpelAvgVarianceParams(4, 3, &aom_highbd_10_sub_pixel_avg_variance16x8_sse2,
10),
+#endif // !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(3, 4, &aom_highbd_10_sub_pixel_avg_variance8x16_sse2,
10),
SubpelAvgVarianceParams(3, 3, &aom_highbd_10_sub_pixel_avg_variance8x8_sse2,
@@ -1641,10 +1659,12 @@
8),
SubpelAvgVarianceParams(4, 5, &aom_highbd_8_sub_pixel_avg_variance16x32_sse2,
8),
+#if !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(4, 4, &aom_highbd_8_sub_pixel_avg_variance16x16_sse2,
8),
SubpelAvgVarianceParams(4, 3, &aom_highbd_8_sub_pixel_avg_variance16x8_sse2,
8),
+#endif // !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(3, 4, &aom_highbd_8_sub_pixel_avg_variance8x16_sse2,
8),
SubpelAvgVarianceParams(3, 3, &aom_highbd_8_sub_pixel_avg_variance8x8_sse2,
@@ -1660,8 +1680,10 @@
12),
SubpelAvgVarianceParams(3, 5, &aom_highbd_12_sub_pixel_avg_variance8x32_sse2,
12),
+#if !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(4, 2, &aom_highbd_12_sub_pixel_avg_variance16x4_sse2,
12),
+#endif // !CONFIG_UNEVEN_4WAY
// SubpelAvgVarianceParams(2, 4,
// &aom_highbd_12_sub_pixel_avg_variance4x16_sse2, 12),
SubpelAvgVarianceParams(6, 4, &aom_highbd_10_sub_pixel_avg_variance64x16_sse2,
@@ -1672,8 +1694,10 @@
10),
SubpelAvgVarianceParams(3, 5, &aom_highbd_10_sub_pixel_avg_variance8x32_sse2,
10),
+#if !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(4, 2, &aom_highbd_10_sub_pixel_avg_variance16x4_sse2,
10),
+#endif // !CONFIG_UNEVEN_4WAY
// SubpelAvgVarianceParams(2, 4,
// &aom_highbd_10_sub_pixel_avg_variance4x16_sse2, 10),
SubpelAvgVarianceParams(6, 4, &aom_highbd_8_sub_pixel_avg_variance64x16_sse2,
@@ -1684,8 +1708,10 @@
8),
SubpelAvgVarianceParams(3, 5, &aom_highbd_8_sub_pixel_avg_variance8x32_sse2,
8),
+#if !CONFIG_UNEVEN_4WAY
SubpelAvgVarianceParams(4, 2, &aom_highbd_8_sub_pixel_avg_variance16x4_sse2,
8),
+#endif // !CONFIG_UNEVEN_4WAY
// SubpelAvgVarianceParams(2, 4,
// &aom_highbd_8_sub_pixel_avg_variance4x16_sse2, 8),
};
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index 11b187c..c71fb75 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -420,6 +420,15 @@
"default_uv_mode_cdf[CFL_ALLOWED_TYPES][INTRA_MODES]"
"[CDF_SIZE(UV_INTRA_MODES)]");
+#if CONFIG_EXT_DIR
+ /* MRL index */
+ cts_each_dim[0] = MRL_INDEX_CONTEXTS;
+ cts_each_dim[1] = MRL_LINE_NUMBER;
+ optimize_cdf_table(&fc.mrl_index[0][0], probsfile, 2, cts_each_dim,
+ "static const aom_cdf_prob default_mrl_index_cdf"
+ "[MRL_INDEX_CONTEXTS][CDF_SIZE(MRL_LINE_NUMBER)]");
+#endif // CONFIG_EXT_DIR
+
#if CONFIG_CROSS_CHROMA_TX
/* cctx type */
cts_each_dim[0] = EXT_TX_SIZES;
@@ -461,6 +470,26 @@
"static aom_cdf_prob default_do_ext_partition_cdf"
"[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS][PARTITION_"
"CONTEXTS][CDF_SIZE(2)]");
+#if CONFIG_UNEVEN_4WAY
+ cts_each_dim[0] = PARTITION_STRUCTURE_NUM;
+ cts_each_dim[1] = NUM_RECT_PARTS;
+ cts_each_dim[2] = PARTITION_CONTEXTS;
+ cts_each_dim[3] = 2;
+ optimize_cdf_table(&fc.do_uneven_4way_partition[0][0][0][0], probsfile, 4,
+ cts_each_dim,
+ "static aom_cdf_prob default_do_uneven_4way_partition_cdf"
+ "[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS][PARTITION_"
+ "CONTEXTS][CDF_SIZE(2)]");
+ cts_each_dim[0] = PARTITION_STRUCTURE_NUM;
+ cts_each_dim[1] = NUM_RECT_PARTS;
+ cts_each_dim[2] = PARTITION_CONTEXTS;
+ cts_each_dim[3] = NUM_UNEVEN_4WAY_PARTS;
+ optimize_cdf_table(
+ &fc.uneven_4way_partition_type[0][0][0][0], probsfile, 4, cts_each_dim,
+ "static aom_cdf_prob default_uneven_4way_partition_type_cdf"
+ "[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS][PARTITION_"
+ "CONTEXTS][CDF_SIZE(NUM_UNEVEN_4WAY_PARTS)]");
+#endif // CONFIG_UNEVEN_4WAY
#else
/* block partition */
cts_each_dim[0] = PARTITION_STRUCTURE_NUM;
@@ -481,7 +510,7 @@
cts_each_dim[1] = EXT_TX_SIZES;
cts_each_dim[2] = INTRA_MODES;
cts_each_dim[3] = TX_TYPES;
-#if CONFIG_ATC_NEWTXSETS
+#if CONFIG_ATC
int intra_ext_tx_types_each_ctx[EXT_TX_SETS_INTRA] = { 0, INTRA_TX_SET1 };
optimize_cdf_table_var_modes_4d(
&fc.intra_ext_tx[0][0][0][0], probsfile, 4, cts_each_dim,
@@ -498,6 +527,19 @@
"[EXT_TX_SIZES][INTRA_MODES][CDF_SIZE(TX_TYPES)]");
#endif
+#if CONFIG_ATC_DCTX_ALIGNED
+ cts_each_dim[0] = EXT_TX_SETS_INTER;
+ cts_each_dim[1] = EOB_TX_CTXS;
+ cts_each_dim[2] = EXT_TX_SIZES;
+ cts_each_dim[3] = TX_TYPES;
+ int inter_ext_tx_types_each_ctx[EXT_TX_SETS_INTER] = { 0, 16, 12, 2 };
+ optimize_cdf_table_var_modes_4d(
+ &fc.inter_ext_tx[0][0][0][0], probsfile, 4, cts_each_dim,
+ inter_ext_tx_types_each_ctx,
+ "static const aom_cdf_prob "
+ "default_inter_ext_tx_cdf[EXT_TX_SETS_INTER][EOB_TX_CTXS]"
+ "[EXT_TX_SIZES][CDF_SIZE(TX_TYPES)]");
+#else
cts_each_dim[0] = EXT_TX_SETS_INTER;
cts_each_dim[1] = EXT_TX_SIZES;
cts_each_dim[2] = TX_TYPES;
@@ -507,6 +549,7 @@
inter_ext_tx_types_each_ctx,
"static const aom_cdf_prob default_inter_ext_tx_cdf[EXT_TX_SETS_INTER]"
"[EXT_TX_SIZES][CDF_SIZE(TX_TYPES)]");
+#endif // CONFIG_ATC_DCTX_ALIGNED
/* Chroma from Luma */
#if CONFIG_IMPROVED_CFL
@@ -699,7 +742,7 @@
"default_bawp_cdf[CDF_SIZE(2)]");
#endif
/* Intra/inter flag */
-#if CONFIG_CONTEXT_DERIVATION
+#if CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
cts_each_dim[0] = INTRA_INTER_SKIP_TXFM_CONTEXTS;
cts_each_dim[1] = INTRA_INTER_CONTEXTS;
cts_each_dim[2] = 2;
@@ -714,7 +757,7 @@
&fc.intra_inter[0][0], probsfile, 2, cts_each_dim,
"static const aom_cdf_prob\n"
"default_intra_inter_cdf[INTRA_INTER_CONTEXTS][CDF_SIZE(2)]");
-#endif // CONFIG_CONTEXT_DERIVATION
+#endif // CONFIG_CONTEXT_DERIVATION && !CONFIG_SKIP_TXFM_OPT
/* Single/comp ref flag */
cts_each_dim[0] = COMP_INTER_CONTEXTS;
cts_each_dim[1] = 2;
@@ -877,7 +920,7 @@
"static const aom_cdf_prob default_intrabc_cdf[CDF_SIZE(2)]");
#endif // CONFIG_NEW_CONTEXT_MODELING
-#if CONFIG_BVP_IMPROVEMENT
+#if CONFIG_IBC_BV_IMPROVEMENT
/* intrabc mode flag*/
cts_each_dim[0] = 2;
optimize_cdf_table(&fc.intrabc_mode[0], probsfile, 1, cts_each_dim,
@@ -962,6 +1005,17 @@
"av1_default_idtx_sign_cdfs[TOKEN_CDF_Q_CTXS]"
"[IDTX_SIGN_CONTEXTS][CDF_SIZE(2)]");
+#if CONFIG_ATC_DCTX_ALIGNED
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = SIG_COEF_CONTEXTS_BOB;
+ cts_each_dim[2] = NUM_BASE_LEVELS + 1;
+ optimize_cdf_table(
+ &fc.coeff_base_bob_multi[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_coeff_base_bob_multi_cdfs"
+ "[TOKEN_CDF_Q_CTXS][SIG_COEF_CONTEXTS_BOB]"
+ "[CDF_SIZE(NUM_BASE_LEVELS + 1)]");
+#endif // CONFIG_ATC_DCTX_ALIGNED
+
#if CONFIG_CONTEXT_DERIVATION
cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
cts_each_dim[1] = V_TXB_SKIP_CONTEXTS;
@@ -983,6 +1037,62 @@
"[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS]"
"[CDF_SIZE(2)]");
+#if CONFIG_ATC_DCTX_ALIGNED
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS - 6;
+ optimize_cdf_table(
+ &fc.eob_multi16[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi16_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 6)]");
+
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS - 5;
+ optimize_cdf_table(
+ &fc.eob_multi32[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi32_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 5)]");
+
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS - 4;
+ optimize_cdf_table(
+ &fc.eob_multi64[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi64_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 4)]");
+
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS - 3;
+ optimize_cdf_table(
+ &fc.eob_multi128[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi128_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 3)]");
+
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS - 2;
+ optimize_cdf_table(
+ &fc.eob_multi256[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi256_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 2)]");
+
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS - 1;
+ optimize_cdf_table(
+ &fc.eob_multi512[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi512_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS - 1)]");
+
+ cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
+ cts_each_dim[1] = PLANE_TYPES;
+ cts_each_dim[2] = EOB_MAX_SYMS;
+ optimize_cdf_table(&fc.eob_multi1024[0][0][0], probsfile, 3, cts_each_dim,
+ "static const aom_cdf_prob av1_default_eob_multi1024_cdfs"
+ "[TOKEN_CDF_Q_CTXS][PLANE_TYPES][CDF_SIZE(EOB_MAX_SYMS)]");
+#else
cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
cts_each_dim[1] = PLANE_TYPES;
cts_each_dim[2] = 2;
@@ -1038,8 +1148,9 @@
optimize_cdf_table(&fc.eob_multi1024[0][0][0][0], probsfile, 4, cts_each_dim,
"static const aom_cdf_prob av1_default_eob_multi1024_cdfs"
"[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][CDF_SIZE(11)]");
+#endif // CONFIG_ATC_DCTX_ALIGNED
-#if CONFIG_ATC_COEFCODING
+#if CONFIG_ATC
cts_each_dim[0] = TOKEN_CDF_Q_CTXS;
cts_each_dim[1] = TX_SIZES;
cts_each_dim[2] = PLANE_TYPES;
diff --git a/tools/convexhull_framework/bin/AOM_CWG_AS_CTC_v9.7.1.xlsm b/tools/convexhull_framework/bin/AOM_CWG_AS_CTC_v9.7.1.xlsm
new file mode 100644
index 0000000..ce27081
--- /dev/null
+++ b/tools/convexhull_framework/bin/AOM_CWG_AS_CTC_v9.7.1.xlsm
Binary files differ
diff --git a/tools/convexhull_framework/bin/AOM_CWG_Regular_CTCv4_v7.3.2.xlsm b/tools/convexhull_framework/bin/AOM_CWG_Regular_CTCv4_v7.3.2.xlsm
new file mode 100644
index 0000000..6311b9b
--- /dev/null
+++ b/tools/convexhull_framework/bin/AOM_CWG_Regular_CTCv4_v7.3.2.xlsm
Binary files differ
diff --git a/tools/convexhull_framework/src/AV2CTCProgress.py b/tools/convexhull_framework/src/AV2CTCProgress.py
index 97ef091..f422cb5 100644
--- a/tools/convexhull_framework/src/AV2CTCProgress.py
+++ b/tools/convexhull_framework/src/AV2CTCProgress.py
@@ -22,6 +22,7 @@
import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
from CalcBDRate import BD_RATE
+from itertools import cycle
qtys = ["psnr_y", "psnr_u", "psnr_v", "overall_psnr", "ssim_y", "ms_ssim_y",
"vmaf", "vmaf_neg", "psnr_hvs","ciede2k", "apsnr_y", "apsnr_u",
@@ -50,51 +51,19 @@
csv_files = {
"v1.0.0":
{
- "AI": "D:\\AV2-CTC\\AV2-CTC-v1.0.0-Final\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
- "LD": "D:\\AV2-CTC\\AV2-CTC-v1.0.0-Final\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
- "RA": "D:\\AV2-CTC\\AV2-CTC-v1.0.0-Final\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
- "Still": "D:\\AV2-CTC\\AV2-CTC-v1.0.0-Final\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
- "AS": "D:\\AV2-CTC\\AV2-CTC-v1.0.0-Final\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
+ "AI": "F:\\Av2-CTC-v4-ToolOffTest\\v1.0-alt\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
+ "LD": "F:\\Av2-CTC-v4-ToolOffTest\\v1.0-alt\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
+ "RA": "F:\\Av2-CTC-v4-ToolOffTest\\v1.0-alt\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
+ "Still": "F:\\Av2-CTC-v4-ToolOffTest\\v1.0-alt\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
+ "AS": "F:\\Av2-CTC-v4-ToolOffTest\\v1.0-alt\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
},
- "v1.0.1":
+ "v4.0.0":
{
- "AI": "D:\\AV2-CTC\\AV2-CTC-v1.0.1\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
- "LD": "D:\\AV2-CTC\\AV2-CTC-v1.0.1\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
- "RA": "D:\\AV2-CTC\\AV2-CTC-v1.0.1\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
- "Still": "D:\\AV2-CTC\\AV2-CTC-v1.0.1\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
- "AS": "D:\\AV2-CTC\\AV2-CTC-v1.0.1\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
- },
- "B034":
- {
- "AI": "D:\\AV2-CTC\\AV2-CTC-B034\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
- "LD": "D:\\AV2-CTC\\AV2-CTC-B034\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
- "RA": "D:\\AV2-CTC\\AV2-CTC-B034\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
- "Still": "D:\\AV2-CTC\\AV2-CTC-B034\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
- "AS": "D:\\AV2-CTC\\AV2-CTC-B034\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
- },
- "ext-quant":
- {
- "AI": "D:\\AV2-CTC\\AV2-CTC-ExtQuant\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
- "LD": "D:\\AV2-CTC\\AV2-CTC-ExtQuant\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
- "RA": "D:\\AV2-CTC\\AV2-CTC-ExtQuant\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
- "Still": "D:\\AV2-CTC\\AV2-CTC-ExtQuant\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
- "AS": "D:\\AV2-CTC\\AV2-CTC-ExtQuant\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
- },
- "sdp-off":
- {
- "AI": "D:\\AV2-CTC\\AV2-CTC-SDP-OFF\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
- "LD": "D:\\AV2-CTC\\AV2-CTC-SDP-OFF\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
- "RA": "D:\\AV2-CTC\\AV2-CTC-SDP-OFF\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
- "Still": "D:\\AV2-CTC\\AV2-CTC-SDP-OFF\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
- "AS": "D:\\AV2-CTC\\AV2-CTC-SDP-OFF\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
- },
- "sdp-on":
- {
- "AI": "D:\\AV2-CTC\\AV2-CTC-SDP-ON\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
- "LD": "D:\\AV2-CTC\\AV2-CTC-SDP-ON\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
- "RA": "D:\\AV2-CTC\\AV2-CTC-SDP-ON\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
- "Still": "D:\\AV2-CTC\\AV2-CTC-SDP-ON\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
- "AS": "D:\\AV2-CTC\\AV2-CTC-SDP-ON\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
+ "AI": "F:\\Av2-CTC-v4-ToolOffTest\\v4.0\\analysis\\rdresult\\RDResults_aom_av2_AI_Preset_0.csv",
+ "LD": "F:\\Av2-CTC-v4-ToolOffTest\\v4.0\\analysis\\rdresult\\RDResults_aom_av2_LD_Preset_0.csv",
+ "RA": "F:\\Av2-CTC-v4-ToolOffTest\\v4.0\\analysis\\rdresult\\RDResults_aom_av2_RA_Preset_0.csv",
+ "Still": "F:\\Av2-CTC-v4-ToolOffTest\\v4.0\\analysis\\rdresult\\RDResults_aom_av2_STILL_Preset_0.csv",
+ "AS": "F:\\Av2-CTC-v4-ToolOffTest\\v4.0\\analysis\\rdresult\\RDResults_aom_av2_AS_Preset_0.csv",
},
}
@@ -108,15 +77,7 @@
formats = {
"v1.0.0": ['r', '-', 'o'],
- "v1.0.1": ['g', '-', '*'],
- "B034": ['k', '-', '^'],
- "ext-quant": ['r', '-', '*'],
- "sdp-off": ['b', '-', '+'],
- "sdp-on": ['r', '-', '<'],
- "HM_CloseGOP": ['r', '-', 'o'],
- "HM_OpenGOP": ['b', '-', '+'],
- "AV1_CloseGOP": ['g', '-', '>'],
- "AV1_OpenGOP": ['k', '-', '*'],
+ "v4.0.0": ['g', '-', '*'],
}
AS_formats = {
@@ -130,6 +91,8 @@
anchor = "v1.0.0"
rd_curve_pdf = "rdcurve.pdf"
+colors = cycle('bgrycmk')
+markers = cycle('o*^+<x')
def WriteSheet(csv_file, sht, start_row):
csv = open(csv_file, 'rt')
@@ -179,7 +142,7 @@
wb.save(xls_file)
-def DrawRDCurve(records, anchor, pdf):
+def DrawIndividualRDCurve(records, anchor, pdf):
with PdfPages(pdf) as export_pdf:
for cfg in records[anchor].keys():
videos = records[anchor][cfg].keys()
@@ -212,7 +175,7 @@
Int_RDPoints[tag] += int_rdpnts
plot_rd_curve(br[res], apsnr[res], "overall_apsnr", res, "bitrate(Kbps)",
AS_formats[res][0], AS_formats[res][1], AS_formats[res][2])
- plt.legend()
+ plt.legend(loc='lower right')
plt.grid(True)
export_pdf.savefig()
plt.close()
@@ -224,9 +187,9 @@
lower, upper = convex_hull(Int_RDPoints[tag])
br = [h[0] for h in upper]
apsnr = [h[1] for h in upper]
- plot_rd_curve(br, apsnr, "overall_apsnr", tag, "bitrate(Kbps)",
+ plot_rd_curve(br, apsnr, "overall_apsnr(dB)", tag, "bitrate(kbps)",
formats[tag][0], formats[tag][1], formats[tag][2])
- plt.legend()
+ plt.legend(loc='lower right')
plt.grid(True)
export_pdf.savefig()
plt.close()
@@ -238,13 +201,102 @@
record = records[tag][cfg][video]
br = [record[key].bitrate for key in record.keys()]
apsnr = [record[key].overall_apsnr for key in record.keys()]
- plot_rd_curve(br, apsnr, "overall_apsnr", tag, "bitrate(Kbps)",
+ plot_rd_curve(br, apsnr, "overall_apsnr(dB)", tag, "bitrate(kbps)",
formats[tag][0], formats[tag][1], formats[tag][2])
- plt.legend()
+ plt.legend(loc='lower right')
plt.grid(True)
export_pdf.savefig()
plt.close()
+
+def DrawCombinedRDCurve(records):
+ pdf = "combined_rdcurve.pdf"
+ with PdfPages(pdf) as export_pdf:
+ for tag in csv_files.keys():
+ for cfg in csv_files[tag].keys():
+ videos = records[tag][cfg].keys()
+ plt.figure(figsize=(30, 30))
+ plt.suptitle("%s : %s" % (tag, cfg))
+
+ for video in videos:
+ short_name = video.split('_')[0]
+ if cfg == "AS":
+ Int_RDPoints = []
+ record = records[tag][cfg][video]
+ br = {};
+ apsnr = {}
+ for key in record.keys():
+ res = re.split('_', key)[0]
+ if res not in br.keys():
+ br[res] = []
+ apsnr[res] = []
+ br[res].append(record[key].bitrate)
+ apsnr[res].append(record[key].overall_apsnr)
+
+ for res in br.keys():
+ rdpnts = [(brt, qty) for brt, qty in zip(br[res], apsnr[res])]
+ if UsePCHIPInterpolation:
+ int_rdpnts = Interpolate_PCHIP(rdpnts, QPs['AS'][:], InterpolatePieces, True)
+ else:
+ int_rdpnts = Interpolate_Bilinear(rdpnts, QPs['AS'][:], InterpolatePieces, True)
+ Int_RDPoints += int_rdpnts
+
+ # draw convex hull
+ lower, upper = convex_hull(Int_RDPoints)
+ br = [h[0] for h in upper]
+ apsnr = [h[1] for h in upper]
+ plot_rd_curve(br, apsnr, "overall_apsnr(dB)", short_name, "bitrate(kbps)",
+ next(colors), '-', next(markers))
+ else:
+ record = records[tag][cfg][video]
+ br = [record[key].bitrate for key in record.keys()]
+ apsnr = [record[key].overall_apsnr for key in record.keys()]
+ plot_rd_curve(br, apsnr, "overall_apsnr(dB)", short_name, "bitrate(kbps)",
+ next(colors), '-', next(markers))
+
+ plt.legend(loc='lower right')
+ plt.grid(True)
+ export_pdf.savefig()
+ plt.close()
+
+def DrawCombinedRuntime(records):
+ pdf = "combined_runtime.pdf"
+ with PdfPages(pdf) as export_pdf:
+ for tag in csv_files.keys():
+ for cfg in csv_files[tag].keys():
+ videos = records[tag][cfg].keys()
+ plt.figure(figsize=(30, 30))
+ plt.suptitle("%s : %s" % (tag, cfg))
+
+ for video in videos:
+ short_name = video.split('_')[0]
+ if cfg == "AS":
+ record = records[tag][cfg][video]
+ br = {};
+ enc_time = {}
+ for key in record.keys():
+ res = re.split('_', key)[0]
+ if res not in br.keys():
+ br[res] = []
+ enc_time[res] = []
+ br[res].append(record[key].bitrate)
+ enc_time[res].append(record[key].enc_time)
+
+ for res in br.keys():
+ plot_rd_curve(br[res], enc_time[res], "enc_time(s)", short_name+'_'+res, "bitrate(kbps)",
+ next(colors), '-', next(markers))
+ else:
+ record = records[tag][cfg][video]
+ br = [record[key].bitrate for key in record.keys()]
+ enc_time = [record[key].enc_time for key in record.keys()]
+ plot_rd_curve(br, enc_time, "enc_time(s)", short_name, "bitrate(kbps)",
+ next(colors), '-', next(markers))
+
+ plt.legend(loc='lower right')
+ plt.grid(True)
+ export_pdf.savefig()
+ plt.close()
+
def GetQty(record, qty):
qtys = []
for key in record.keys():
@@ -399,11 +451,13 @@
records[tag][test_cfg] = ParseCSVFile(csv_files[tag][test_cfg])
FillXlsFile()
- DrawRDCurve(records, anchor, rd_curve_pdf)
+ DrawCombinedRDCurve(records)
+ DrawCombinedRuntime(records)
+ DrawIndividualRDCurve(records, anchor, rd_curve_pdf)
#Calculate BDRate and collect total time
for test_cfg in csv_files[anchor].keys():
(bdrate, seq_time, seq_instr) = CalcFullBDRate(test_cfg)
#Write output summary xls file
- filename = "Summary-HEVC-AV1-%s"%test_cfg
+ filename = "Summary-AV1-vs-AV2_v4.0_%s"%test_cfg
WriteSummaryXlsFile(bdrate, seq_time, seq_instr, filename)
diff --git a/tools/convexhull_framework/src/AV2CTCTest.py b/tools/convexhull_framework/src/AV2CTCTest.py
index f8fcc50..42ad0f7 100644
--- a/tools/convexhull_framework/src/AV2CTCTest.py
+++ b/tools/convexhull_framework/src/AV2CTCTest.py
@@ -119,13 +119,10 @@
csv_file, perframe_csvfile = GetRDResultCsvFile(EncodeMethod, CodecName, EncodePreset, test_cfg)
csv = open(csv_file, 'wt')
- # "TestCfg,EncodeMethod,CodecName,EncodePreset,Class,OrigRes,Name,FPS,Bit Depth,CodedRes,QP,Bitrate(kbps)")
+ # "TestCfg,EncodeMethod,CodecName,EncodePreset,Class,OrigRes,Name,FPS,BitDepth,CodedRes,QP,Bitrate(kbps)")
csv.write("TestCfg,EncodeMethod,CodecName,EncodePreset,Class,Name,OrigRes,FPS,"\
- "Bit Depth,CodecRes,QP,")
- if (test_cfg == "STILL"):
- csv.write("FileSize(bytes)")
- else:
- csv.write("Bitrate(kbps)")
+ "BitDepth,CodedRes,QP,")
+ csv.write("Bitrate(kbps)")
for qty in QualityList:
csv.write(',' + qty)
csv.write(",EncT[s],DecT[s]")
@@ -138,7 +135,7 @@
perframe_csv = open(perframe_csvfile, 'wt')
perframe_csv.write("TestCfg,EncodeMethod,CodecName,EncodePreset,Class,Name,Res,FPS," \
- "Bit Depth,QP,POC,FrameType,Level,qindex,FrameSize")
+ "BitDepth,QP,POC,FrameType,Level,qindex,FrameSize")
for qty in QualityList:
if (qty != "Overall_PSNR" and qty != "Overall_APSNR" and not qty.startswith("APSNR")):
perframe_csv.write(',' + qty)
diff --git a/tools/convexhull_framework/src/AV2CTCVideo.py b/tools/convexhull_framework/src/AV2CTCVideo.py
index 400dfdf..36cb305 100644
--- a/tools/convexhull_framework/src/AV2CTCVideo.py
+++ b/tools/convexhull_framework/src/AV2CTCVideo.py
@@ -255,7 +255,7 @@
"/A1_4k_720p/NocturneDance_1280x720p_10bit_60fps.y4m",
"/A1_4k_540p/NocturneDance_960x540p_10bit_60fps.y4m",
"/A1_4k_360p/NocturneDance_640x360p_10bit_60fps.y4m"],
-"PierSeaSide_3840x2160_2997fps_10bit_420" :["/A1_4k_1440p/PierSeaSide_2560x1440_2997fps_10bit_420_v2.y4m",
+"PierSeaSide_3840x2160_2997fps_10bit_420_v2" :["/A1_4k_1440p/PierSeaSide_2560x1440_2997fps_10bit_420_v2.y4m",
"/A1_4k_1080p/PierSeaSide_1920x1080_2997fps_10bit_420_v2.y4m",
"/A1_4k_720p/PierSeaSide_1280x720_2997fps_10bit_420_v2.y4m",
"/A1_4k_540p/PierSeaSide_960x540_2997fps_10bit_420_v2.y4m",
diff --git a/tools/convexhull_framework/src/Config.py b/tools/convexhull_framework/src/Config.py
index 47b6ba0..5482c2c 100644
--- a/tools/convexhull_framework/src/Config.py
+++ b/tools/convexhull_framework/src/Config.py
@@ -46,8 +46,8 @@
APSNR_V_WEIGHT = 1.0
if CTC_VERSION == '4.0':
- CTC_RegularXLSTemplate = os.path.join(BinPath, 'AOM_CWG_Regular_CTCv4_v7.3.xlsm')
- CTC_ASXLSTemplate = os.path.join(BinPath, 'AOM_CWG_AS_CTC_v9.8.xlsm')
+ CTC_RegularXLSTemplate = os.path.join(BinPath, 'AOM_CWG_Regular_CTCv4_v7.3.2.xlsm')
+ CTC_ASXLSTemplate = os.path.join(BinPath, 'AOM_CWG_AS_CTC_v9.7.1.xlsm')
elif CTC_VERSION == '3.0':
CTC_RegularXLSTemplate = os.path.join(BinPath, 'AOM_CWG_Regular_CTC_v7.2.xlsm')
CTC_ASXLSTemplate = os.path.join(BinPath, 'AOM_CWG_AS_CTC_v9.7.xlsm')
diff --git a/tools/convexhull_framework/src/ConvexHullTest.py b/tools/convexhull_framework/src/ConvexHullTest.py
index 72bcf94..abbc931 100755
--- a/tools/convexhull_framework/src/ConvexHullTest.py
+++ b/tools/convexhull_framework/src/ConvexHullTest.py
@@ -284,7 +284,7 @@
quality, perframe_vmaf_log = GatherQualityMetrics(reconyuv, Path_QualityLog)
qualities.append(quality)
- #"TestCfg,EncodeMethod,CodecName,EncodePreset,Class,OrigRes,Name,FPS,Bit Depth,CodedRes,QP,Bitrate(kbps)")
+ #"TestCfg,EncodeMethod,CodecName,EncodePreset,Class,OrigRes,Name,FPS,BitDepth,CodedRes,QP,Bitrate(kbps)")
csv.write("%s,%s,%s,%s,%s,%s,%s,%.4f,%d,%s,%d,%f"%
("AS", EncodeMethod, CodecName, EncodePreset, clip.file_class,contentname,
str(clip.width)+"x"+str(clip.height), clip.fps,clip.bit_depth,
@@ -460,7 +460,7 @@
csv_file, perframe_csvfile = GetRDResultCsvFile(EncodeMethod, CodecName, EncodePreset, "AS")
csv = open(csv_file, "wt")
csv.write("TestCfg,EncodeMethod,CodecName,EncodePreset,Class,Name,OrigRes,FPS," \
- "Bit Depth,CodedRes,QP,Bitrate(kbps)")
+ "BitDepth,CodedRes,QP,Bitrate(kbps)")
for qty in QualityList:
csv.write(',' + qty)
csv.write(",EncT[s],DecT[s]")
@@ -473,7 +473,7 @@
perframe_csv = open(perframe_csvfile, 'wt')
perframe_csv.write("TestCfg,EncodeMethod,CodecName,EncodePreset,Class,Name,Res,FPS," \
- "Bit Depth,QP,POC,FrameType,Level,qindex,FrameSize")
+ "BitDepth,QP,POC,FrameType,Level,qindex,FrameSize")
for qty in QualityList:
if not qty.startswith("APSNR"):
perframe_csv.write(',' + qty)
diff --git a/tools/convexhull_framework/src/Utils.py b/tools/convexhull_framework/src/Utils.py
index 7d19e34..418ff0f 100755
--- a/tools/convexhull_framework/src/Utils.py
+++ b/tools/convexhull_framework/src/Utils.py
@@ -13,6 +13,7 @@
import os
import re
import sys
+from csv import DictReader
import subprocess
import time
import logging
@@ -81,6 +82,7 @@
apsnr_u = 0.0
apsnr_v = 0.0
overall_apsnr = 0.0
+ cambi = 0.0
enc_time = 0.0
dec_time = 0.0
enc_instr = 0.0
@@ -91,7 +93,7 @@
def __init__(self, test_cfg, encode_mode , codec_name, encode_preset, file_class, file_name,
orig_res, fps, bit_depth, coded_res, qp, bitrate, psnr_y, psnr_u, psnr_v,
ssim_y, ms_ssim_y, vmaf_y, vmaf_y_neg, psnr_hvs, ciede2k, apsnr_y, apsnr_u,
- apsnr_v, enc_time, dec_time, enc_instr, dec_instr, enc_cycle, dec_cycle):
+ apsnr_v, cambi, enc_time, dec_time, enc_instr, dec_instr, enc_cycle, dec_cycle):
self.test_cfg = test_cfg
self.encode_mode = encode_mode
@@ -124,6 +126,7 @@
APSNR_U_WEIGHT/pow(10, (self.apsnr_u / 10)) +
APSNR_V_WEIGHT/pow(10, (self.apsnr_v / 10))) /
(APSNR_Y_WEIGHT + APSNR_U_WEIGHT + APSNR_V_WEIGHT)))
+ self.cambi = float(cambi)
self.enc_time = float(enc_time)
self.dec_time = float(dec_time)
self.enc_instr = float(enc_instr)
@@ -133,20 +136,22 @@
def ParseCSVFile(csv_file):
records = {}
- csv = open(csv_file, 'rt')
- for line in csv:
- if not line.startswith('TestCfg'):
- words = re.split(',', line.strip())
- record = Record(words[0], words[1], words[2], words[3], words[4], words[5], words[6], words[7], words[8],
- words[9], words[10], words[11], words[12], words[13], words[14], words[15], words[16],
- words[17],words[18], words[19], words[20], words[21], words[22], words[23], words[24],
- words[25], words[26],words[27], words[28],words[29])
- key = record.coded_res + "_" + record.qp
- if record.file_name not in records.keys():
- records[record.file_name] = {}
- records[record.file_name][key] = record
+ with open(csv_file, 'r') as f:
+ list_of_data = list(DictReader(f))
+ for data in list_of_data:
+ key = data['CodedRes'] + "_" + data['QP']
+ name = data['Name']
+ record = Record(data['TestCfg'], data['EncodeMethod'], data['CodecName'], data['EncodePreset'],
+ data['Class'], data['Name'], data['OrigRes'], data['FPS'], data['BitDepth'],
+ data['CodedRes'], data['QP'], data['Bitrate(kbps)'], data['PSNR_Y'], data['PSNR_U'],
+ data['PSNR_V'], data['SSIM_Y(dB)'], data['MS-SSIM_Y(dB)'], data['VMAF_Y'],
+ data['VMAF_Y-NEG'], data['PSNR-HVS'], data['CIEDE2000'], data['APSNR_Y'],
+ data['APSNR_U'], data['APSNR_V'], data['CAMBI'], data['EncT[s]'], data['DecT[s]'],
+ data['EncInstr'], data['DecInstr'], data['EncCycles'], data['DecCycles'])
- csv.close()
+ if name not in records.keys():
+ records[name] = {}
+ records[name][key] = record
return records
def Cleanfolder(folder):
