Merge v3.0.0 Bug: aomedia:2828 Change-Id: I7f2a43066206ee62b68bd5b4919cc4dfc3b30b84
diff --git a/CMakeLists.txt b/CMakeLists.txt index e382c17..39369c7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt
@@ -100,6 +100,7 @@ "${AOM_ROOT}/third_party/libyuv/include/libyuv/row.h" "${AOM_ROOT}/third_party/libyuv/include/libyuv/scale.h" "${AOM_ROOT}/third_party/libyuv/include/libyuv/scale_row.h" + "${AOM_ROOT}/third_party/libyuv/source/convert_argb.cc" "${AOM_ROOT}/third_party/libyuv/source/cpu_id.cc" "${AOM_ROOT}/third_party/libyuv/source/planar_functions.cc" "${AOM_ROOT}/third_party/libyuv/source/row_any.cc" @@ -393,6 +394,14 @@ list(APPEND AOM_APP_TARGETS ${AOM_DECODER_EXAMPLE_TARGETS}) endif() +if(CONFIG_LIBYUV OR CONFIG_TUNE_BUTTERAUGLI) + add_library(yuv OBJECT ${AOM_LIBYUV_SOURCES}) + if(NOT MSVC) + target_compile_options(yuv PRIVATE -Wno-unused-parameter) + endif() + include_directories("${AOM_ROOT}/third_party/libyuv/include") +endif() + if(CONFIG_AV1_ENCODER) if(ENABLE_EXAMPLES) add_executable(aomenc "${AOM_ROOT}/apps/aomenc.c" @@ -449,42 +458,79 @@ list(APPEND AOM_APP_TARGETS ${AOM_ENCODER_EXAMPLE_TARGETS} ${AOM_ENCODER_TOOL_TARGETS}) - if(CONFIG_USE_VMAF_RC AND NOT CONFIG_TUNE_VMAF) - message(FATAL_ERROR "Turn on CONFIG_TUNE_VMAF to use CONFIG_USE_VMAF_RC.") + if(CONFIG_TUNE_BUTTERAUGLI) + find_package(PkgConfig) + # Use find_library() with STATIC_LINK_JXL for static build since + # pkg_check_modules() with LIBJXL_STATIC is not working. + if(STATIC_LINK_JXL OR NOT PKG_CONFIG_FOUND) + find_library(LIBJXL_LIBRARIES libjxl.a) + find_library(LIBHWY_LIBRARIES libhwy.a) + find_library(LIBSKCMS_LIBRARIES libskcms.a) + find_library(LIBBROTLICOMMON_LIBRARIES libbrotlicommon-static.a) + find_library(LIBBROTLIENC_LIBRARIES libbrotlienc-static.a) + find_library(LIBBROTLIDEC_LIBRARIES libbrotlidec-static.a) + find_path(LIBJXL_INCLUDE_DIRS butteraugli.h PATH_SUFFIXES jxl) + if(LIBJXL_LIBRARIES + AND LIBHWY_LIBRARIES + AND LIBSKCMS_LIBRARIES + AND LIBBROTLICOMMON_LIBRARIES + AND LIBBROTLIENC_LIBRARIES + AND LIBBROTLIDEC_LIBRARIES + AND LIBJXL_INCLUDE_DIRS) + message(STATUS "Found JXL library: ${LIBJXL_LIBRARIES} " + "${LIBHWY_LIBRARIES} ${LIBSKCMS_LIBRARIES} " + "${LIBBROTLICOMMON_LIBRARIES} ${LIBBROTLIENC_LIBRARIES}" + "${LIBBROTLIDEC_LIBRARIES}") + message(STATUS "Found JXL include: ${LIBJXL_INCLUDE_DIRS}") + else() + message(FATAL_ERROR "JXL library not found.") + endif() + target_link_libraries(aom + PRIVATE ${LIBJXL_LIBRARIES} ${LIBHWY_LIBRARIES} + ${LIBSKCMS_LIBRARIES} + ${LIBBROTLIENC_LIBRARIES} + ${LIBBROTLIDEC_LIBRARIES} + ${LIBBROTLICOMMON_LIBRARIES}) + target_include_directories(aom PRIVATE ${LIBJXL_INCLUDE_DIRS}) + else() + pkg_check_modules(LIBJXL REQUIRED libjxl) + target_link_libraries(aom PRIVATE ${LIBJXL_LDFLAGS} ${LIBJXL_LIBRARIES}) + target_include_directories(aom PRIVATE ${LIBJXL_INCLUDE_DIRS}) + if(LIBJXL_CFLAGS) + append_compiler_flag("${LIBJXL_CFLAGS}") + endif() + pkg_check_modules(LIBHWY REQUIRED libhwy) + target_link_libraries(aom PRIVATE ${LIBHWY_LDFLAGS} ${LIBHWY_LIBRARIES}) + target_include_directories(aom PRIVATE ${LIBLIBHWY_INCLUDE_DIRS}) + if(LIBHWY_CFLAGS) + append_compiler_flag("${LIBHWY_CFLAGS}") + endif() + endif() + + set_target_properties(aom PROPERTIES LINKER_LANGUAGE CXX) + if(BUILD_SHARED_LIBS) + set_target_properties(aom_static PROPERTIES LINKER_LANGUAGE CXX) + endif() + + list(APPEND AOM_LIB_TARGETS yuv) + target_sources(aom PRIVATE $<TARGET_OBJECTS:yuv>) + if(BUILD_SHARED_LIBS) + target_sources(aom_static PRIVATE $<TARGET_OBJECTS:yuv>) + endif() endif() if(CONFIG_TUNE_VMAF) find_package(PkgConfig) - if(CONFIG_USE_VMAF_RC) - if(PKG_CONFIG_FOUND) - pkg_check_modules(VMAF_RC REQUIRED libvmaf_rc) - target_link_libraries(aom - PRIVATE ${VMAF_RC_LDFLAGS} ${VMAF_RC_LIBRARIES}) - target_include_directories(aom PRIVATE ${VMAF_RC_INCLUDE_DIRS}) - if(VMAF_RC_CFLAGS) - append_compiler_flag("${VMAF_RC_CFLAGS}") - endif() - else() - message(FATAL_ERROR "CONFIG_USE_VMAF_RC error: pkg-config not found.") - endif() - else() - if(PKG_CONFIG_FOUND) - pkg_check_modules(VMAF REQUIRED libvmaf) - else() - find_library(VMAF_LIBRARIES vmaf) - find_path(VMAF_INCLUDE_DIRS libvmaf.h PATH_SUFFIXES libvmaf) - if(VMAF_LIBRARIES AND VMAF_INCLUDE_DIRS) - message(STATUS "Found VMAF library: ${VMAF_LIBRARIES}") - message(STATUS "Found VMAF include: ${VMAF_INCLUDE_DIRS}") - else() - message(FATAL_ERROR "VMAF library not found.") - endif() - endif() - target_link_libraries(aom PRIVATE ${VMAF_LDFLAGS} ${VMAF_LIBRARIES}) + if(PKG_CONFIG_FOUND) + pkg_check_modules(VMAF REQUIRED libvmaf) + target_link_libraries(aom + PRIVATE ${VMAF_LDFLAGS} ${VMAF_LIBRARIES} -static) target_include_directories(aom PRIVATE ${VMAF_INCLUDE_DIRS}) if(VMAF_CFLAGS) append_compiler_flag("${VMAF_CFLAGS}") endif() + else() + message(FATAL_ERROR "CONFIG_TUNE_VMAF error: pkg-config not found.") endif() set_target_properties(aom PROPERTIES LINKER_LANGUAGE CXX) if(BUILD_SHARED_LIBS) @@ -571,12 +617,6 @@ if(ENABLE_EXAMPLES OR ENABLE_TESTS OR ENABLE_TOOLS) if(CONFIG_LIBYUV) - add_library(yuv OBJECT ${AOM_LIBYUV_SOURCES}) - if(NOT MSVC) - target_compile_options(yuv PRIVATE -Wno-unused-parameter) - endif() - include_directories("${AOM_ROOT}/third_party/libyuv/include") - # Add to existing targets. foreach(aom_app ${AOM_APP_TARGETS}) target_sources(${aom_app} PRIVATE $<TARGET_OBJECTS:yuv>)
diff --git a/README.md b/README.md index a458f52..c4e7e6c 100644 --- a/README.md +++ b/README.md
@@ -326,7 +326,7 @@ ~~~ Please note that the default VMAF model -("/usr/local/share/model/vmaf_v0.6.1.pkl") +("/usr/local/share/model/vmaf_v0.6.1.json") will be used unless you set the following flag when running the encoder: ~~~
diff --git a/aom/aom_encoder.h b/aom/aom_encoder.h index e6aa95f..beac764 100644 --- a/aom/aom_encoder.h +++ b/aom/aom_encoder.h
@@ -293,6 +293,10 @@ * */ unsigned int disable_smooth_intra; + /*!\brief disable D45 to D203 intra modes + * + */ + unsigned int disable_diagonal_intra; /*!\brief disable filter intra * */ @@ -942,8 +946,8 @@ * \param[in] iface Pointer to the algorithm interface to use. * \param[out] cfg Configuration buffer to populate. * \param[in] usage Algorithm specific usage value. For AV1, must be - * set to AOM_USAGE_GOOD_QUALITY (0) or - * AOM_USAGE_REALTIME (1). + * set to AOM_USAGE_GOOD_QUALITY (0), + * AOM_USAGE_REALTIME (1), or AOM_USAGE_ALL_INTRA (2). * * \retval #AOM_CODEC_OK * The configuration was populated. @@ -1002,6 +1006,8 @@ #define AOM_USAGE_GOOD_QUALITY (0) /*!\brief usage parameter analogous to AV1 REALTIME mode. */ #define AOM_USAGE_REALTIME (1) +/*!\brief usage parameter analogous to AV1 all intra mode. */ +#define AOM_USAGE_ALL_INTRA (2) /*!\brief Encode a frame *
diff --git a/aom/aomcx.h b/aom/aomcx.h index 93ebad6..b4eeeb1 100644 --- a/aom/aomcx.h +++ b/aom/aomcx.h
@@ -265,6 +265,8 @@ /*!\brief Codec control function to set visual tuning, aom_tune_metric (int) * parameter + * + * The default is AOM_TUNE_PSNR. */ AOME_SET_TUNING = AOME_SET_ARNR_STRENGTH + 2, // 24 @@ -1315,6 +1317,16 @@ */ AV1E_SET_ENABLE_DNL_DENOISING = 140, + /*!\brief Codec control function to turn on / off D45 to D203 intra mode + * usage, int parameter + * + * This will enable or disable usage of D45 to D203 intra modes. + * + * - 0 = disable + * - 1 = enable (default) + */ + AV1E_SET_ENABLE_DIAGONAL_INTRA = 141, + // Any new encoder control IDs should be added above. // Maximum allowed encoder control ID is 229. // No encoder control ID should be added below. @@ -1412,6 +1424,7 @@ AOM_TUNE_VMAF_WITHOUT_PREPROCESSING = 5, AOM_TUNE_VMAF_MAX_GAIN = 6, AOM_TUNE_VMAF_NEG_MAX_GAIN = 7, + AOM_TUNE_BUTTERAUGLI = 8, } aom_tune_metric; #define AOM_MAX_LAYERS 32 /**< Max number of layers */ @@ -1670,6 +1683,9 @@ AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_CFL_INTRA, int) #define AOM_CTRL_AV1E_SET_ENABLE_CFL_INTRA +AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_DIAGONAL_INTRA, int) +#define AOM_CTRL_AV1E_SET_ENABLE_DIAGONAL_INTRA + AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_SUPERRES, int) #define AOM_CTRL_AV1E_SET_ENABLE_SUPERRES
diff --git a/aom_dsp/aom_dsp.cmake b/aom_dsp/aom_dsp.cmake index fa58f85..cf7072d 100644 --- a/aom_dsp/aom_dsp.cmake +++ b/aom_dsp/aom_dsp.cmake
@@ -319,6 +319,11 @@ list(APPEND AOM_DSP_ENCODER_SOURCES "${AOM_ROOT}/aom_dsp/vmaf.c" "${AOM_ROOT}/aom_dsp/vmaf.h") endif() + + if(CONFIG_TUNE_BUTTERAUGLI) + list(APPEND AOM_DSP_ENCODER_SOURCES "${AOM_ROOT}/aom_dsp/butteraugli.c" + "${AOM_ROOT}/aom_dsp/butteraugli.h") + endif() endif() # Creates aom_dsp build targets. Must not be called until after libaom target
diff --git a/aom_dsp/aom_dsp_rtcd_defs.pl b/aom_dsp/aom_dsp_rtcd_defs.pl index 3a31ad6..96375df 100755 --- a/aom_dsp/aom_dsp_rtcd_defs.pl +++ b/aom_dsp/aom_dsp_rtcd_defs.pl
@@ -1098,6 +1098,8 @@ # # hamadard transform and satd for implmenting temporal dependency model # + add_proto qw/void aom_hadamard_4x4/, "const int16_t *src_diff, ptrdiff_t src_stride, tran_low_t *coeff"; + add_proto qw/void aom_hadamard_8x8/, "const int16_t *src_diff, ptrdiff_t src_stride, tran_low_t *coeff"; specialize qw/aom_hadamard_8x8 sse2 neon/;
diff --git a/aom_dsp/avg.c b/aom_dsp/avg.c index 7386296..b88d48c 100644 --- a/aom_dsp/avg.c +++ b/aom_dsp/avg.c
@@ -88,6 +88,44 @@ } #endif // CONFIG_AV1_HIGHBITDEPTH +static void hadamard_col4(const int16_t *src_diff, ptrdiff_t src_stride, + int16_t *coeff) { + int16_t b0 = (src_diff[0 * src_stride] + src_diff[1 * src_stride]) >> 1; + int16_t b1 = (src_diff[0 * src_stride] - src_diff[1 * src_stride]) >> 1; + int16_t b2 = (src_diff[2 * src_stride] + src_diff[3 * src_stride]) >> 1; + int16_t b3 = (src_diff[2 * src_stride] - src_diff[3 * src_stride]) >> 1; + + coeff[0] = b0 + b2; + coeff[1] = b1 + b3; + coeff[2] = b0 - b2; + coeff[3] = b1 - b3; +} + +void aom_hadamard_4x4_c(const int16_t *src_diff, ptrdiff_t src_stride, + tran_low_t *coeff) { + int idx; + int16_t buffer[16]; + int16_t buffer2[16]; + int16_t *tmp_buf = &buffer[0]; + for (idx = 0; idx < 4; ++idx) { + hadamard_col4(src_diff, src_stride, tmp_buf); // src_diff: 9 bit + // dynamic range [-255, 255] + tmp_buf += 4; + ++src_diff; + } + + tmp_buf = &buffer[0]; + for (idx = 0; idx < 4; ++idx) { + hadamard_col4(tmp_buf, 4, buffer2 + 4 * idx); // tmp_buf: 12 bit + // dynamic range [-2040, 2040] + // buffer2: 15 bit + // dynamic range [-16320, 16320] + ++tmp_buf; + } + + for (idx = 0; idx < 16; ++idx) coeff[idx] = (tran_low_t)buffer2[idx]; +} + // src_diff: first pass, 9 bit, dynamic range [-255, 255] // second pass, 12 bit, dynamic range [-2040, 2040] static void hadamard_col8(const int16_t *src_diff, ptrdiff_t src_stride,
diff --git a/aom_dsp/butteraugli.c b/aom_dsp/butteraugli.c new file mode 100644 index 0000000..dff9fed --- /dev/null +++ b/aom_dsp/butteraugli.c
@@ -0,0 +1,99 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. + */ + +#include <assert.h> +#include <jxl/butteraugli.h> + +#include "aom_dsp/butteraugli.h" +#include "aom_mem/aom_mem.h" +#include "third_party/libyuv/include/libyuv/convert_argb.h" + +int aom_calc_butteraugli(const YV12_BUFFER_CONFIG *source, + const YV12_BUFFER_CONFIG *distorted, int bit_depth, + float *dist_map) { + (void)bit_depth; + assert(bit_depth == 8); + const int width = source->y_crop_width; + const int height = source->y_crop_height; + const int ss_x = source->subsampling_x; + const int ss_y = source->subsampling_y; + + const size_t stride_argb = width * 4; + const size_t buffer_size = height * stride_argb; + uint8_t *src_argb = (uint8_t *)aom_malloc(buffer_size); + uint8_t *distorted_argb = (uint8_t *)aom_malloc(buffer_size); + if (!src_argb || !distorted_argb) { + aom_free(src_argb); + aom_free(distorted_argb); + return 0; + } + + if (ss_x == 1 && ss_y == 1) { + I420ToARGBMatrix(source->y_buffer, source->y_stride, source->u_buffer, + source->uv_stride, source->v_buffer, source->uv_stride, + src_argb, stride_argb, &kYuvH709Constants, width, height); + I420ToARGBMatrix(distorted->y_buffer, distorted->y_stride, + distorted->u_buffer, distorted->uv_stride, + distorted->v_buffer, distorted->uv_stride, distorted_argb, + stride_argb, &kYuvH709Constants, width, height); + } else if (ss_x == 1 && ss_y == 0) { + I422ToARGBMatrix(source->y_buffer, source->y_stride, source->u_buffer, + source->uv_stride, source->v_buffer, source->uv_stride, + src_argb, stride_argb, &kYuvH709Constants, width, height); + I422ToARGBMatrix(distorted->y_buffer, distorted->y_stride, + distorted->u_buffer, distorted->uv_stride, + distorted->v_buffer, distorted->uv_stride, distorted_argb, + stride_argb, &kYuvH709Constants, width, height); + } else if (ss_x == 0 && ss_y == 0) { + I444ToARGBMatrix(source->y_buffer, source->y_stride, source->u_buffer, + source->uv_stride, source->v_buffer, source->uv_stride, + src_argb, stride_argb, &kYuvH709Constants, width, height); + I444ToARGBMatrix(distorted->y_buffer, distorted->y_stride, + distorted->u_buffer, distorted->uv_stride, + distorted->v_buffer, distorted->uv_stride, distorted_argb, + stride_argb, &kYuvH709Constants, width, height); + } else { + aom_free(src_argb); + aom_free(distorted_argb); + return 0; + } + + JxlPixelFormat pixel_format = { 4, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0 }; + JxlButteraugliApi *api = JxlButteraugliApiCreate(NULL); + JxlButteraugliApiSetHFAsymmetry(api, 0.8f); + + JxlButteraugliResult *result = JxlButteraugliCompute( + api, width, height, &pixel_format, src_argb, buffer_size, &pixel_format, + distorted_argb, buffer_size); + + const float *distmap = NULL; + uint32_t row_stride; + JxlButteraugliResultGetDistmap(result, &distmap, &row_stride); + if (distmap == NULL) { + JxlButteraugliApiDestroy(api); + JxlButteraugliResultDestroy(result); + aom_free(src_argb); + aom_free(distorted_argb); + return 0; + } + + for (int j = 0; j < height; ++j) { + for (int i = 0; i < width; ++i) { + dist_map[j * width + i] = distmap[j * row_stride + i]; + } + } + + JxlButteraugliApiDestroy(api); + JxlButteraugliResultDestroy(result); + aom_free(src_argb); + aom_free(distorted_argb); + return 1; +}
diff --git a/aom_dsp/butteraugli.h b/aom_dsp/butteraugli.h new file mode 100644 index 0000000..06402aa --- /dev/null +++ b/aom_dsp/butteraugli.h
@@ -0,0 +1,21 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. + */ + +#ifndef AOM_AOM_DSP_BUTTERAUGLI_H_ +#define AOM_AOM_DSP_BUTTERAUGLI_H_ + +#include "aom_scale/yv12config.h" + +int aom_calc_butteraugli(const YV12_BUFFER_CONFIG *source, + const YV12_BUFFER_CONFIG *distorted, int bit_depth, + float *dist_map); + +#endif // AOM_AOM_DSP_BUTTERAUGLI_H_
diff --git a/aom_dsp/vmaf.c b/aom_dsp/vmaf.c index 4165343..219e278 100644 --- a/aom_dsp/vmaf.c +++ b/aom_dsp/vmaf.c
@@ -12,9 +12,6 @@ #include "aom_dsp/vmaf.h" #include <assert.h> -#if !CONFIG_USE_VMAF_RC -#include <libvmaf.h> -#endif #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -24,10 +21,7 @@ #include <unistd.h> #endif -#if CONFIG_USE_VMAF_RC -#include <libvmaf/libvmaf.rc.h> -#endif - +#include <libvmaf/libvmaf.h> #include "aom_dsp/blend.h" #include "aom_ports/system_state.h" @@ -36,162 +30,18 @@ exit(EXIT_FAILURE); } -#if !CONFIG_USE_VMAF_RC -typedef struct FrameData { - const YV12_BUFFER_CONFIG *source; - const YV12_BUFFER_CONFIG *distorted; - int frame_set; - int bit_depth; -} FrameData; - -// A callback function used to pass data to VMAF. -// Returns 0 after reading a frame. -// Returns 2 when there is no more frame to read. -static int read_frame(float *ref_data, float *main_data, float *temp_data, - int stride, void *user_data) { - FrameData *frames = (FrameData *)user_data; - - if (!frames->frame_set) { - const int width = frames->source->y_width; - const int height = frames->source->y_height; - assert(width == frames->distorted->y_width); - assert(height == frames->distorted->y_height); - - if (frames->source->flags & YV12_FLAG_HIGHBITDEPTH) { - const float scale_factor = 1.0f / (float)(1 << (frames->bit_depth - 8)); - uint16_t *ref_ptr = CONVERT_TO_SHORTPTR(frames->source->y_buffer); - uint16_t *main_ptr = CONVERT_TO_SHORTPTR(frames->distorted->y_buffer); - - for (int row = 0; row < height; ++row) { - for (int col = 0; col < width; ++col) { - ref_data[col] = scale_factor * (float)ref_ptr[col]; - } - ref_ptr += frames->source->y_stride; - ref_data += stride / sizeof(*ref_data); - } - - for (int row = 0; row < height; ++row) { - for (int col = 0; col < width; ++col) { - main_data[col] = scale_factor * (float)main_ptr[col]; - } - main_ptr += frames->distorted->y_stride; - main_data += stride / sizeof(*main_data); - } - } else { - uint8_t *ref_ptr = frames->source->y_buffer; - uint8_t *main_ptr = frames->distorted->y_buffer; - - for (int row = 0; row < height; ++row) { - for (int col = 0; col < width; ++col) { - ref_data[col] = (float)ref_ptr[col]; - } - ref_ptr += frames->source->y_stride; - ref_data += stride / sizeof(*ref_data); - } - - for (int row = 0; row < height; ++row) { - for (int col = 0; col < width; ++col) { - main_data[col] = (float)main_ptr[col]; - } - main_ptr += frames->distorted->y_stride; - main_data += stride / sizeof(*main_data); - } - } - frames->frame_set = 1; - return 0; - } - - (void)temp_data; - return 2; -} - -void aom_calc_vmaf(const char *model_path, const YV12_BUFFER_CONFIG *source, - const YV12_BUFFER_CONFIG *distorted, const int bit_depth, - double *const vmaf) { - aom_clear_system_state(); - const int width = source->y_width; - const int height = source->y_height; - FrameData frames = { source, distorted, 0, bit_depth }; - char *fmt = bit_depth == 10 ? "yuv420p10le" : "yuv420p"; - double vmaf_score; - const int ret = - compute_vmaf(&vmaf_score, fmt, width, height, read_frame, - /*user_data=*/&frames, (char *)model_path, - /*log_path=*/NULL, /*log_fmt=*/NULL, /*disable_clip=*/1, - /*disable_avx=*/0, /*enable_transform=*/0, - /*phone_model=*/0, /*do_psnr=*/0, /*do_ssim=*/0, - /*do_ms_ssim=*/0, /*pool_method=*/NULL, /*n_thread=*/0, - /*n_subsample=*/1, /*enable_conf_interval=*/0); - if (ret) vmaf_fatal_error("Failed to compute VMAF scores."); - - aom_clear_system_state(); - *vmaf = vmaf_score; -} - -void aom_calc_vmaf_multi_frame(void *user_data, const char *model_path, - int (*rd_frm)(float *ref_data, float *main_data, - float *temp_data, int stride_byte, - void *user_data), - int frame_width, int frame_height, int bit_depth, - double *vmaf) { - aom_clear_system_state(); - - char *fmt = bit_depth == 10 ? "yuv420p10le" : "yuv420p"; - int log_path_length = snprintf(NULL, 0, "vmaf_scores_%d.xml", getpid()) + 1; - char *log_path = malloc(log_path_length); - snprintf(log_path, log_path_length, "vmaf_scores_%d.xml", getpid()); - double vmaf_score; - const int ret = - compute_vmaf(&vmaf_score, fmt, frame_width, frame_height, rd_frm, - /*user_data=*/user_data, (char *)model_path, - /*log_path=*/log_path, /*log_fmt=*/NULL, /*disable_clip=*/0, - /*disable_avx=*/0, /*enable_transform=*/0, - /*phone_model=*/0, /*do_psnr=*/0, /*do_ssim=*/0, - /*do_ms_ssim=*/0, /*pool_method=*/NULL, /*n_thread=*/0, - /*n_subsample=*/1, /*enable_conf_interval=*/0); - FILE *vmaf_log = fopen(log_path, "r"); - free(log_path); - log_path = NULL; - if (vmaf_log == NULL || ret) { - vmaf_fatal_error("Failed to compute VMAF scores."); - } - - int frame_index = 0; - char buf[512]; - while (fgets(buf, 511, vmaf_log) != NULL) { - if (memcmp(buf, "\t\t<frame ", 9) == 0) { - char *p = strstr(buf, "vmaf="); - if (p != NULL && p[5] == '"') { - char *p2 = strstr(&p[6], "\""); - *p2 = '\0'; - const double score = atof(&p[6]); - if (score < 0.0 || score > 100.0) { - vmaf_fatal_error("Failed to compute VMAF scores."); - } - vmaf[frame_index++] = score; - } - } - } - fclose(vmaf_log); - - aom_clear_system_state(); -} -#endif - -#if CONFIG_USE_VMAF_RC -void aom_init_vmaf_model_rc(VmafModel **vmaf_model, const char *model_path) { +void aom_init_vmaf_model(VmafModel **vmaf_model, const char *model_path) { if (*vmaf_model != NULL) return; VmafModelConfig model_cfg; model_cfg.flags = VMAF_MODEL_FLAG_DISABLE_CLIP; model_cfg.name = "vmaf"; - model_cfg.path = (char *)model_path; - if (vmaf_model_load_from_path(vmaf_model, &model_cfg)) { + if (vmaf_model_load_from_path(vmaf_model, &model_cfg, model_path)) { vmaf_fatal_error("Failed to load VMAF model."); } } -void aom_close_vmaf_model_rc(VmafModel *vmaf_model) { +void aom_close_vmaf_model(VmafModel *vmaf_model) { vmaf_model_destroy(vmaf_model); } @@ -221,8 +71,9 @@ } } -void aom_init_vmaf_context_rc(VmafContext **vmaf_context, VmafModel *vmaf_model, - bool cal_vmaf_neg) { +void aom_init_vmaf_context(VmafContext **vmaf_context, VmafModel *vmaf_model, + bool cal_vmaf_neg) { + // TODO(sdeng): make them CLI arguments. VmafConfiguration cfg; cfg.log_level = VMAF_LOG_LEVEL_NONE; cfg.n_threads = 0; @@ -233,41 +84,82 @@ vmaf_fatal_error("Failed to init VMAF context."); } - if (vmaf_use_features_from_model(*vmaf_context, vmaf_model)) { - vmaf_fatal_error("Failed to load feature extractors from VMAF model."); - } - if (cal_vmaf_neg) { VmafFeatureDictionary *vif_feature = NULL; - vmaf_feature_dictionary_set(&vif_feature, "vif_enhn_gain_limit", "1.0"); - if (vmaf_use_feature(*vmaf_context, "float_vif", vif_feature)) { + if (vmaf_feature_dictionary_set(&vif_feature, "vif_enhn_gain_limit", + "1.0")) { + vmaf_fatal_error("Failed to set vif_enhn_gain_limit."); + } + if (vmaf_model_feature_overload(vmaf_model, "float_vif", vif_feature)) { vmaf_fatal_error("Failed to use feature float_vif."); } VmafFeatureDictionary *adm_feature = NULL; - vmaf_feature_dictionary_set(&adm_feature, "adm_enhn_gain_limit", "1.0"); - if (vmaf_use_feature(*vmaf_context, "float_adm", adm_feature)) { + if (vmaf_feature_dictionary_set(&adm_feature, "adm_enhn_gain_limit", + "1.0")) { + vmaf_fatal_error("Failed to set adm_enhn_gain_limit."); + } + if (vmaf_model_feature_overload(vmaf_model, "adm", adm_feature)) { vmaf_fatal_error("Failed to use feature float_adm."); } } VmafFeatureDictionary *motion_force_zero = NULL; - vmaf_feature_dictionary_set(&motion_force_zero, "motion_force_zero", "true"); - if (vmaf_use_feature(*vmaf_context, "float_motion", motion_force_zero)) { + if (vmaf_feature_dictionary_set(&motion_force_zero, "motion_force_zero", + "1")) { + vmaf_fatal_error("Failed to set motion_force_zero."); + } + if (vmaf_model_feature_overload(vmaf_model, "float_motion", + motion_force_zero)) { vmaf_fatal_error("Failed to use feature float_motion."); } + + if (vmaf_use_features_from_model(*vmaf_context, vmaf_model)) { + vmaf_fatal_error("Failed to load feature extractors from VMAF model."); + } } -void aom_close_vmaf_context_rc(VmafContext *vmaf_context) { +void aom_close_vmaf_context(VmafContext *vmaf_context) { if (vmaf_close(vmaf_context)) { vmaf_fatal_error("Failed to close VMAF context."); } } -void aom_calc_vmaf_at_index_rc(VmafContext *vmaf_context, VmafModel *vmaf_model, - const YV12_BUFFER_CONFIG *source, - const YV12_BUFFER_CONFIG *distorted, - int bit_depth, int frame_index, double *vmaf) { +void aom_calc_vmaf(VmafModel *vmaf_model, const YV12_BUFFER_CONFIG *source, + const YV12_BUFFER_CONFIG *distorted, int bit_depth, + bool cal_vmaf_neg, double *vmaf) { + VmafContext *vmaf_context; + aom_init_vmaf_context(&vmaf_context, vmaf_model, cal_vmaf_neg); + const int frame_index = 0; + VmafPicture ref, dist; + if (vmaf_picture_alloc(&ref, VMAF_PIX_FMT_YUV420P, bit_depth, source->y_width, + source->y_height) || + vmaf_picture_alloc(&dist, VMAF_PIX_FMT_YUV420P, bit_depth, + source->y_width, source->y_height)) { + vmaf_fatal_error("Failed to alloc VMAF pictures."); + } + copy_picture(bit_depth, source, &ref); + copy_picture(bit_depth, distorted, &dist); + if (vmaf_read_pictures(vmaf_context, &ref, &dist, + /*picture index=*/frame_index)) { + vmaf_fatal_error("Failed to read VMAF pictures."); + } + + if (vmaf_read_pictures(vmaf_context, NULL, NULL, 0)) { + vmaf_fatal_error("Failed to flush context."); + } + + vmaf_picture_unref(&ref); + vmaf_picture_unref(&dist); + + vmaf_score_at_index(vmaf_context, vmaf_model, vmaf, frame_index); + aom_close_vmaf_context(vmaf_context); +} + +void aom_read_vmaf_image(VmafContext *vmaf_context, + const YV12_BUFFER_CONFIG *source, + const YV12_BUFFER_CONFIG *distorted, int bit_depth, + int frame_index) { VmafPicture ref, dist; if (vmaf_picture_alloc(&ref, VMAF_PIX_FMT_YUV420P, bit_depth, source->y_width, source->y_height) || @@ -284,8 +176,19 @@ vmaf_picture_unref(&ref); vmaf_picture_unref(&dist); - - vmaf_score_at_index(vmaf_context, vmaf_model, vmaf, frame_index); } -#endif // CONFIG_USE_VMAF_RC +double aom_calc_vmaf_at_index(VmafContext *vmaf_context, VmafModel *vmaf_model, + int frame_index) { + double vmaf; + if (vmaf_score_at_index(vmaf_context, vmaf_model, &vmaf, frame_index)) { + vmaf_fatal_error("Failed to calc VMAF scores."); + } + return vmaf; +} + +void aom_flush_vmaf_context(VmafContext *vmaf_context) { + if (vmaf_read_pictures(vmaf_context, NULL, NULL, 0)) { + vmaf_fatal_error("Failed to flush context."); + } +}
diff --git a/aom_dsp/vmaf.h b/aom_dsp/vmaf.h index d9da223..3ba8c8d 100644 --- a/aom_dsp/vmaf.h +++ b/aom_dsp/vmaf.h
@@ -15,33 +15,28 @@ #include <stdbool.h> #include "aom_scale/yv12config.h" -#if CONFIG_USE_VMAF_RC typedef struct VmafContext VmafContext; typedef struct VmafModel VmafModel; -#endif -#if CONFIG_USE_VMAF_RC -void aom_init_vmaf_context_rc(VmafContext **vmaf_context, VmafModel *vmaf_model, - bool cal_vmaf_neg); -void aom_close_vmaf_context_rc(VmafContext *vmaf_context); +void aom_init_vmaf_context(VmafContext **vmaf_context, VmafModel *vmaf_model, + bool cal_vmaf_neg); +void aom_close_vmaf_context(VmafContext *vmaf_context); -void aom_init_vmaf_model_rc(VmafModel **vmaf_model, const char *model_path); -void aom_close_vmaf_model_rc(VmafModel *vmaf_model); +void aom_init_vmaf_model(VmafModel **vmaf_model, const char *model_path); +void aom_close_vmaf_model(VmafModel *vmaf_model); -void aom_calc_vmaf_at_index_rc(VmafContext *vmaf_context, VmafModel *vmaf_model, - const YV12_BUFFER_CONFIG *source, - const YV12_BUFFER_CONFIG *distorted, - int bit_depth, int frame_index, double *vmaf); -#else -void aom_calc_vmaf(const char *model_path, const YV12_BUFFER_CONFIG *source, +void aom_calc_vmaf(VmafModel *vmaf_model, const YV12_BUFFER_CONFIG *source, const YV12_BUFFER_CONFIG *distorted, int bit_depth, - double *vmaf); + bool cal_vmaf_neg, double *vmaf); -void aom_calc_vmaf_multi_frame( - void *user_data, const char *model_path, - int (*read_frame)(float *ref_data, float *main_data, float *temp_data, - int stride_byte, void *user_data), - int frame_width, int frame_height, int bit_depth, double *vmaf); -#endif // CONFIG_USE_VMAF_RC +void aom_read_vmaf_image(VmafContext *vmaf_context, + const YV12_BUFFER_CONFIG *source, + const YV12_BUFFER_CONFIG *distorted, int bit_depth, + int frame_index); + +double aom_calc_vmaf_at_index(VmafContext *vmaf_context, VmafModel *vmaf_model, + int frame_index); + +void aom_flush_vmaf_context(VmafContext *vmaf_context); #endif // AOM_AOM_DSP_VMAF_H_
diff --git a/aom_dsp/x86/subtract_sse2.asm b/aom_dsp/x86/subtract_sse2.asm index 1a75a23..af38022 100644 --- a/aom_dsp/x86/subtract_sse2.asm +++ b/aom_dsp/x86/subtract_sse2.asm
@@ -143,4 +143,5 @@ lea predq, [predq+pred_str*2] sub rowsd, 2 jg .loop_4 + emms RET
diff --git a/aom_ports/system_state.h b/aom_ports/system_state.h index 6640839..46797e3 100644 --- a/aom_ports/system_state.h +++ b/aom_ports/system_state.h
@@ -16,7 +16,7 @@ #if ARCH_X86 || ARCH_X86_64 void aom_reset_mmx_state(void); -#define aom_clear_system_state() aom_reset_mmx_state() +#define aom_clear_system_state() #else #define aom_clear_system_state() #endif // ARCH_X86 || ARCH_X86_64
diff --git a/aom_scale/generic/yv12config.c b/aom_scale/generic/yv12config.c index 9b9242c..6ddc82f 100644 --- a/aom_scale/generic/yv12config.c +++ b/aom_scale/generic/yv12config.c
@@ -50,7 +50,8 @@ void *cb_priv, const int y_stride, const uint64_t yplane_size, const uint64_t uvplane_size, const int aligned_width, const int aligned_height, const int uv_width, const int uv_height, - const int uv_stride, const int uv_border_w, const int uv_border_h) { + const int uv_stride, const int uv_border_w, const int uv_border_h, + int alloc_y_buffer_8bit) { if (ybf) { const int aom_byte_align = (byte_alignment == 0) ? 1 : byte_alignment; const uint64_t frame_size = @@ -153,7 +154,7 @@ ybf->use_external_reference_buffers = 0; - if (use_highbitdepth) { + if (use_highbitdepth && alloc_y_buffer_8bit) { if (ybf->y_buffer_8bit) aom_free(ybf->y_buffer_8bit); ybf->y_buffer_8bit = (uint8_t *)aom_memalign(32, (size_t)yplane_size); if (!ybf->y_buffer_8bit) return AOM_CODEC_MEM_ERROR; @@ -198,7 +199,8 @@ int ss_x, int ss_y, int use_highbitdepth, int border, int byte_alignment, aom_codec_frame_buffer_t *fb, - aom_get_frame_buffer_cb_fn_t cb, void *cb_priv) { + aom_get_frame_buffer_cb_fn_t cb, void *cb_priv, + int alloc_y_buffer_8bit) { #if CONFIG_SIZE_LIMIT if (width > DECODE_WIDTH_LIMIT || height > DECODE_HEIGHT_LIMIT) return AOM_CODEC_MEM_ERROR; @@ -224,7 +226,7 @@ ybf, width, height, ss_x, ss_y, use_highbitdepth, border, byte_alignment, fb, cb, cb_priv, y_stride, yplane_size, uvplane_size, aligned_width, aligned_height, uv_width, uv_height, uv_stride, - uv_border_w, uv_border_h); + uv_border_w, uv_border_h, alloc_y_buffer_8bit); } return AOM_CODEC_MEM_ERROR; } @@ -236,7 +238,7 @@ aom_free_frame_buffer(ybf); return aom_realloc_frame_buffer(ybf, width, height, ss_x, ss_y, use_highbitdepth, border, byte_alignment, - NULL, NULL, NULL); + NULL, NULL, NULL, 0); } return AOM_CODEC_MEM_ERROR; }
diff --git a/aom_scale/yv12config.h b/aom_scale/yv12config.h index ea92c92..376cb74 100644 --- a/aom_scale/yv12config.h +++ b/aom_scale/yv12config.h
@@ -135,7 +135,8 @@ int ss_x, int ss_y, int use_highbitdepth, int border, int byte_alignment, aom_codec_frame_buffer_t *fb, - aom_get_frame_buffer_cb_fn_t cb, void *cb_priv); + aom_get_frame_buffer_cb_fn_t cb, void *cb_priv, + int alloc_y_buffer_8bit); int aom_free_frame_buffer(YV12_BUFFER_CONFIG *ybf);
diff --git a/apps/aomenc.c b/apps/aomenc.c index 4792512..11035bf 100644 --- a/apps/aomenc.c +++ b/apps/aomenc.c
@@ -168,6 +168,7 @@ AV1E_SET_ENABLE_SMOOTH_INTRA, AV1E_SET_ENABLE_PAETH_INTRA, AV1E_SET_ENABLE_CFL_INTRA, + AV1E_SET_ENABLE_DIAGONAL_INTRA, AV1E_SET_FORCE_VIDEO_MODE, AV1E_SET_ENABLE_OBMC, AV1E_SET_ENABLE_OVERLAY, @@ -240,6 +241,7 @@ &g_av1_codec_arg_defs.skip, &g_av1_codec_arg_defs.good_dl, &g_av1_codec_arg_defs.rt_dl, + &g_av1_codec_arg_defs.ai_dl, &g_av1_codec_arg_defs.quietarg, &g_av1_codec_arg_defs.verbosearg, &g_av1_codec_arg_defs.psnrarg, @@ -313,7 +315,9 @@ &g_av1_codec_arg_defs.sframe_mode, NULL }; -const arg_def_t *av1_args[] = { +// TODO(bohanli): Currently all options are supported by the key & value API. +// Consider removing the control ID usages? +const arg_def_t *av1_ctrl_args[] = { &g_av1_codec_arg_defs.cpu_used_av1, &g_av1_codec_arg_defs.auto_altref, &g_av1_codec_arg_defs.sharpness, @@ -359,6 +363,7 @@ &g_av1_codec_arg_defs.enable_smooth_intra, &g_av1_codec_arg_defs.enable_paeth_intra, &g_av1_codec_arg_defs.enable_cfl_intra, + &g_av1_codec_arg_defs.enable_diagonal_intra, &g_av1_codec_arg_defs.force_video_mode, &g_av1_codec_arg_defs.enable_obmc, &g_av1_codec_arg_defs.enable_overlay, @@ -417,13 +422,17 @@ #if CONFIG_TUNE_VMAF &g_av1_codec_arg_defs.vmaf_model_path, #endif - NULL + NULL, +}; + +const arg_def_t *av1_key_val_args[] = { + NULL, }; static const arg_def_t *no_args[] = { NULL }; static void show_help(FILE *fout, int shorthelp) { - fprintf(fout, "Usage: %s <options> -o dst_filename src_filename \n", + fprintf(fout, "Usage: %s <options> -o dst_filename src_filename\n", exec_name); if (shorthelp) { @@ -441,7 +450,8 @@ arg_show_usage(fout, kf_args); #if CONFIG_AV1_ENCODER fprintf(fout, "\nAV1 Specific Options:\n"); - arg_show_usage(fout, av1_args); + arg_show_usage(fout, av1_ctrl_args); + arg_show_usage(fout, av1_key_val_args); #endif fprintf(fout, "\nStream timebase (--timebase):\n" @@ -467,6 +477,7 @@ #if CONFIG_AV1_ENCODER #define ARG_CTRL_CNT_MAX NELEMENTS(av1_arg_ctrl_map) +#define ARG_KEY_VAL_CNT_MAX NELEMENTS(av1_key_val_args) #endif #if !CONFIG_WEBM_IO @@ -484,6 +495,8 @@ stereo_format_t stereo_fmt; int arg_ctrls[ARG_CTRL_CNT_MAX][2]; int arg_ctrl_cnt; + const char *arg_key_vals[ARG_KEY_VAL_CNT_MAX][2]; + int arg_key_val_cnt; int write_webm; const char *film_grain_filename; int write_ivf; @@ -597,6 +610,8 @@ global->usage = AOM_USAGE_GOOD_QUALITY; // Good quality usage } else if (arg_match(&arg, &g_av1_codec_arg_defs.rt_dl, argi)) { global->usage = AOM_USAGE_REALTIME; // Real-time usage + } else if (arg_match(&arg, &g_av1_codec_arg_defs.ai_dl, argi)) { + global->usage = AOM_USAGE_ALL_INTRA; // All intra usage } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_yv12, argi)) { global->color_type = YV12; } else if (arg_match(&arg, &g_av1_codec_arg_defs.use_i420, argi)) { @@ -668,6 +683,11 @@ warn("Enforcing one-pass encoding in realtime mode\n"); global->passes = 1; } + + if (global->usage == AOM_USAGE_ALL_INTRA && global->passes > 1) { + warn("Enforcing one-pass encoding in all intra mode\n"); + global->passes = 1; + } } static void open_input_file(struct AvxInputContext *input, @@ -791,7 +811,7 @@ // so we simply append it. if (key == AV1E_SET_TARGET_SEQ_LEVEL_IDX) { j = config->arg_ctrl_cnt; - assert(j < (int)ARG_CTRL_CNT_MAX); + assert(j < ARG_CTRL_CNT_MAX); config->arg_ctrls[j][0] = key; config->arg_ctrls[j][1] = arg_parse_enum_or_int(arg); ++config->arg_ctrl_cnt; @@ -805,7 +825,7 @@ if (config->arg_ctrls[j][0] == key) break; /* Update/insert */ - assert(j < (int)ARG_CTRL_CNT_MAX); + assert(j < ARG_CTRL_CNT_MAX); config->arg_ctrls[j][0] = key; config->arg_ctrls[j][1] = arg_parse_enum_or_int(arg); @@ -813,14 +833,53 @@ warn("auto-alt-ref > 1 is deprecated... setting auto-alt-ref=1\n"); config->arg_ctrls[j][1] = 1; } + if (j == config->arg_ctrl_cnt) config->arg_ctrl_cnt++; } +static void set_config_arg_key_vals(struct stream_config *config, + const char *name, const struct arg *arg) { + int j; + const char *val = arg->val; + // For target level, the settings should accumulate rather than overwrite, + // so we simply append it. + if (strcmp(name, "target-seq-level-idx") == 0) { + j = config->arg_key_val_cnt; + assert(j < ARG_KEY_VAL_CNT_MAX); + config->arg_key_vals[j][0] = name; + config->arg_key_vals[j][1] = val; + ++config->arg_key_val_cnt; + return; + } + + /* Point either to the next free element or the first instance of this + * control. + */ + for (j = 0; j < config->arg_ctrl_cnt; j++) + if (strcmp(name, config->arg_key_vals[j][0]) == 0) break; + + /* Update/insert */ + assert(j < ARG_KEY_VAL_CNT_MAX); + config->arg_key_vals[j][0] = name; + config->arg_key_vals[j][1] = val; + + if (strcmp(name, g_av1_codec_arg_defs.auto_altref.long_name) == 0) { + int auto_altref = arg_parse_int(arg); + if (auto_altref > 1) { + warn("auto-alt-ref > 1 is deprecated... setting auto-alt-ref=1\n"); + config->arg_key_vals[j][1] = "1"; + } + } + + if (j == config->arg_key_val_cnt) config->arg_key_val_cnt++; +} + static int parse_stream_params(struct AvxEncoderConfig *global, struct stream_state *stream, char **argv) { char **argi, **argj; struct arg arg; static const arg_def_t **ctrl_args = no_args; + static const arg_def_t **key_val_args = no_args; static const int *ctrl_args_map = NULL; struct stream_config *config = &stream->config; int eos_mark_found = 0; @@ -832,8 +891,9 @@ } else if (strcmp(get_short_name_by_aom_encoder(global->codec), "av1") == 0) { // TODO(jingning): Reuse AV1 specific encoder configuration parameters. // Consider to expand this set for AV1 encoder control. - ctrl_args = av1_args; + ctrl_args = av1_ctrl_args; ctrl_args_map = av1_arg_ctrl_map; + key_val_args = av1_key_val_args; #endif } @@ -1031,13 +1091,24 @@ } } else { int i, match = 0; - for (i = 0; ctrl_args[i]; i++) { - if (arg_match(&arg, ctrl_args[i], argi)) { - match = 1; - if (ctrl_args_map) { + // check if the control ID API supports this arg + if (ctrl_args_map) { + for (i = 0; ctrl_args[i]; i++) { + if (arg_match(&arg, ctrl_args[i], argi)) { + match = 1; set_config_arg_ctrls(config, ctrl_args_map[i], &arg); + break; } - break; + } + } + if (!match) { + // check if the key & value API supports this arg + for (i = 0; key_val_args[i]; i++) { + if (arg_match(&arg, key_val_args[i], argi)) { + match = 1; + set_config_arg_key_vals(config, key_val_args[i]->long_name, &arg); + break; + } } } if (!match) argj++; @@ -1049,6 +1120,19 @@ warn("non-zero lag-in-frames option ignored in realtime mode.\n"); config->cfg.g_lag_in_frames = 0; } + + if (global->usage == AOM_USAGE_ALL_INTRA) { + if (config->cfg.g_lag_in_frames != 0) { + warn("non-zero lag-in-frames option ignored in all intra mode.\n"); + config->cfg.g_lag_in_frames = 0; + } + if (config->cfg.kf_max_dist != 0) { + warn( + "non-zero max key frame distance option ignored in all intra " + "mode.\n"); + config->cfg.kf_max_dist = 0; + } + } return eos_mark_found; } @@ -1217,6 +1301,7 @@ SHOW_PARAMS(disable_intrabc); SHOW_PARAMS(disable_cfl); SHOW_PARAMS(disable_smooth_intra); + SHOW_PARAMS(disable_diagonal_intra); SHOW_PARAMS(disable_filter_intra); SHOW_PARAMS(disable_dual_filter); SHOW_PARAMS(disable_intra_angle_delta); @@ -1337,6 +1422,15 @@ ctx_exit_on_error(&stream->encoder, "Failed to control codec"); } + for (i = 0; i < stream->config.arg_key_val_cnt; i++) { + const char *name = stream->config.arg_key_vals[i][0]; + const char *val = stream->config.arg_key_vals[i][1]; + if (aom_codec_set_option(&stream->encoder, name, val)) + fprintf(stderr, "Error: Tried to set option %s = %s\n", name, val); + + ctx_exit_on_error(&stream->encoder, "Failed to set codec option"); + } + #if CONFIG_TUNE_VMAF if (stream->config.vmaf_model_path) { AOM_CODEC_CONTROL_TYPECHECKED(&stream->encoder, AV1E_SET_VMAF_MODEL_PATH,
diff --git a/av1/arg_defs.c b/av1/arg_defs.c index b20f568..e79f9b2 100644 --- a/av1/arg_defs.c +++ b/av1/arg_defs.c
@@ -46,6 +46,7 @@ { "vmaf_without_preprocessing", AOM_TUNE_VMAF_WITHOUT_PREPROCESSING }, { "vmaf", AOM_TUNE_VMAF_MAX_GAIN }, { "vmaf_neg", AOM_TUNE_VMAF_NEG_MAX_GAIN }, + { "butteraugli", AOM_TUNE_BUTTERAUGLI }, { NULL, 0 } }; @@ -139,7 +140,7 @@ .debugmode = ARG_DEF("D", "debug", 0, "Debug mode (makes output deterministic)"), .outputfile = ARG_DEF("o", "output", 1, "Output filename"), - .use_yv12 = ARG_DEF(NULL, "yv12", 0, "Input file is YV12 "), + .use_yv12 = ARG_DEF(NULL, "yv12", 0, "Input file is YV12"), .use_i420 = ARG_DEF(NULL, "i420", 0, "Input file is I420 (default)"), .use_i422 = ARG_DEF(NULL, "i422", 0, "Input file is I422"), .use_i444 = ARG_DEF(NULL, "i444", 0, "Input file is I444"), @@ -151,6 +152,7 @@ .skip = ARG_DEF(NULL, "skip", 1, "Skip the first n input frames"), .good_dl = ARG_DEF(NULL, "good", 0, "Use Good Quality Deadline"), .rt_dl = ARG_DEF(NULL, "rt", 0, "Use Realtime Quality Deadline"), + .ai_dl = ARG_DEF(NULL, "allintra", 0, "Use all intra mode"), .quietarg = ARG_DEF("q", "quiet", 0, "Do not print encode progress"), .verbosearg = ARG_DEF("v", "verbose", 0, "Show encoder parameters"), .psnrarg = ARG_DEF( @@ -188,7 +190,8 @@ .input_chroma_subsampling_y = ARG_DEF(NULL, "input-chroma-subsampling-y", 1, "chroma subsampling y value."), - .usage = ARG_DEF("u", "usage", 1, "Usage profile number to use"), + .usage = ARG_DEF("u", "usage", 1, + "Usage profile number to use (0: good, 1: rt, 2: allintra)"), .threads = ARG_DEF("t", "threads", 1, "Max number of threads to use"), .profile = ARG_DEF(NULL, "profile", 1, "Bitstream profile number to use"), .width = ARG_DEF("w", "width", 1, "Frame width"), @@ -402,6 +405,10 @@ .enable_cfl_intra = ARG_DEF(NULL, "enable-cfl-intra", 1, "Enable chroma from luma intra prediction mode " "(0: false, 1: true (default))"), + .enable_diagonal_intra = + ARG_DEF(NULL, "enable-diagonal-intra", 1, + "Enable diagonal (D45 to D203) intra prediction modes " + "(0: false, 1: true (default))"), .force_video_mode = ARG_DEF(NULL, "force-video-mode", 1, "Force video mode (0: false, 1: true (default))"), .enable_obmc = ARG_DEF(NULL, "enable-obmc", 1,
diff --git a/av1/arg_defs.h b/av1/arg_defs.h index 26c9277..f86e915 100644 --- a/av1/arg_defs.h +++ b/av1/arg_defs.h
@@ -44,6 +44,7 @@ arg_def_t skip; arg_def_t good_dl; arg_def_t rt_dl; + arg_def_t ai_dl; arg_def_t quietarg; arg_def_t verbosearg; arg_def_t psnrarg; @@ -153,6 +154,7 @@ arg_def_t enable_smooth_intra; arg_def_t enable_paeth_intra; arg_def_t enable_cfl_intra; + arg_def_t enable_diagonal_intra; arg_def_t force_video_mode; arg_def_t enable_obmc; arg_def_t enable_overlay;
diff --git a/av1/av1.cmake b/av1/av1.cmake index b48c614..3eb4a1f 100644 --- a/av1/av1.cmake +++ b/av1/av1.cmake
@@ -269,8 +269,17 @@ "${AOM_ROOT}/av1/encoder/tune_vmaf.h") endif() +if(CONFIG_TUNE_BUTTERAUGLI) + list(APPEND AOM_AV1_ENCODER_SOURCES + "${AOM_ROOT}/av1/encoder/tune_butteraugli.c" + "${AOM_ROOT}/av1/encoder/tune_butteraugli.h") +endif() + if(CONFIG_OPTICAL_FLOW_API) - list(APPEND AOM_AV1_ENCODER_SOURCES "${AOM_ROOT}/av1/encoder/optical_flow.c" + list(APPEND AOM_AV1_ENCODER_SOURCES + "${AOM_ROOT}/av1/encoder/sparse_linear_solver.c" + "${AOM_ROOT}/av1/encoder/sparse_linear_solver.h" + "${AOM_ROOT}/av1/encoder/optical_flow.c" "${AOM_ROOT}/av1/encoder/optical_flow.h") endif()
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c index e03a8d5e..a2acc61 100644 --- a/av1/av1_cx_iface.c +++ b/av1/av1_cx_iface.c
@@ -31,8 +31,6 @@ #include "common/args_helper.h" -#define MAG_SIZE (4) - struct av1_extracfg { int cpu_used; unsigned int enable_auto_alt_ref; @@ -127,6 +125,7 @@ int enable_smooth_intra; // enable smooth intra modes for sequence int enable_paeth_intra; // enable Paeth intra mode for sequence int enable_cfl_intra; // enable CFL uv intra mode for sequence + int enable_diagonal_intra; // enable D45 to D203 intra modes for sequence int enable_superres; int enable_overlay; // enable overlay for filtered arf frames int enable_palette; @@ -178,25 +177,25 @@ 0, // gf_min_pyr_height 5, // gf_max_pyr_height AOM_TUNE_PSNR, // tuning - "/usr/local/share/model/vmaf_v0.6.1.pkl", // VMAF model path - 10, // cq_level - 0, // rc_max_intra_bitrate_pct - 0, // rc_max_inter_bitrate_pct - 0, // gf_cbr_boost_pct - 0, // lossless - 1, // enable_cdef - 1, // enable_restoration - 0, // force_video_mode - 1, // enable_obmc - 3, // disable_trellis_quant - 0, // enable_qm - DEFAULT_QM_Y, // qm_y - DEFAULT_QM_U, // qm_u - DEFAULT_QM_V, // qm_v - DEFAULT_QM_FIRST, // qm_min - DEFAULT_QM_LAST, // qm_max - 1, // max number of tile groups - 0, // mtu_size + "/usr/local/share/model/vmaf_v0.6.1.json", // VMAF model path + 10, // cq_level + 0, // rc_max_intra_bitrate_pct + 0, // rc_max_inter_bitrate_pct + 0, // gf_cbr_boost_pct + 0, // lossless + 1, // enable_cdef + 1, // enable_restoration + 0, // force_video_mode + 1, // enable_obmc + 3, // disable_trellis_quant + 0, // enable_qm + DEFAULT_QM_Y, // qm_y + DEFAULT_QM_U, // qm_u + DEFAULT_QM_V, // qm_v + DEFAULT_QM_FIRST, // qm_min + DEFAULT_QM_LAST, // qm_max + 1, // max number of tile groups + 0, // mtu_size AOM_TIMING_UNSPECIFIED, // No picture timing signaling in bitstream 0, // frame_parallel_decoding_mode 1, // enable dual filter @@ -251,11 +250,12 @@ 1, // enable smooth intra modes usage for sequence 1, // enable Paeth intra mode usage for sequence 1, // enable CFL uv intra mode usage for sequence - 1, // superres - 1, // enable overlay - 1, // enable palette - !CONFIG_SHARP_SETTINGS, // enable intrabc - 1, // enable angle delta + 1, // enable D45 to D203 intra mode usage for sequence + 1, // superres + 1, // enable overlay + 1, // enable palette + !CONFIG_SHARP_SETTINGS, // enable intrabc + 1, // enable angle delta #if CONFIG_DENOISE 0, // noise_level 32, // noise_block_size @@ -295,13 +295,10 @@ aom_codec_pts_t pts_offset; unsigned char pts_offset_initialized; AV1EncoderConfig oxcf; - AV1_COMP *cpi; + AV1_PRIMARY *ppi; unsigned char *cx_data; size_t cx_data_sz; - unsigned char *pending_cx_data; size_t pending_cx_data_sz; - int pending_frame_count; - size_t pending_frame_sizes[8]; aom_image_t preview_img; aom_enc_frame_flags_t next_frame_flags; aom_codec_pkt_list_decl(256) pkt_list; @@ -311,7 +308,6 @@ // lookahead instance variables BufferPool *buffer_pool_lap; - AV1_COMP *cpi_lap; FIRSTPASS_STATS *frame_stats_buffer; // Number of stats buffers required for look ahead int num_lap_buffers; @@ -384,7 +380,11 @@ RANGE_CHECK_HI(extra_cfg, deltaq_mode, DELTA_Q_MODE_COUNT - 1); RANGE_CHECK_HI(extra_cfg, deltalf_mode, 1); RANGE_CHECK_HI(extra_cfg, frame_periodic_boost, 1); - RANGE_CHECK_HI(cfg, g_usage, 1); +#if CONFIG_REALTIME_ONLY + RANGE_CHECK(cfg, g_usage, AOM_USAGE_REALTIME, AOM_USAGE_REALTIME); +#else + RANGE_CHECK_HI(cfg, g_usage, AOM_USAGE_ALL_INTRA); +#endif RANGE_CHECK_HI(cfg, g_threads, MAX_NUM_THREADS); RANGE_CHECK(cfg, rc_end_usage, AOM_VBR, AOM_Q); RANGE_CHECK_HI(cfg, rc_undershoot_pct, 100); @@ -398,6 +398,10 @@ } else { RANGE_CHECK_HI(cfg, g_lag_in_frames, MAX_LAG_BUFFERS); } + if (cfg->g_usage == AOM_USAGE_ALL_INTRA) { + RANGE_CHECK_HI(cfg, g_lag_in_frames, 0); + RANGE_CHECK_HI(cfg, kf_max_dist, 0); + } RANGE_CHECK_HI(extra_cfg, min_gf_interval, MAX_LAG_BUFFERS - 1); RANGE_CHECK_HI(extra_cfg, max_gf_interval, MAX_LAG_BUFFERS - 1); if (extra_cfg->max_gf_interval > 0) { @@ -523,6 +527,14 @@ "VBR corpus complexity is supported only in the case of single pass " "VBR mode."); +#if !CONFIG_TUNE_BUTTERAUGLI + if (extra_cfg->tuning == AOM_TUNE_BUTTERAUGLI) { + ERROR( + "This error may be related to the wrong configuration options: try to " + "set -DCONFIG_TUNE_BUTTERAUGLI=1 at the time CMake is run."); + } +#endif + #if !CONFIG_TUNE_VMAF if (extra_cfg->tuning >= AOM_TUNE_VMAF_WITH_PREPROCESSING && extra_cfg->tuning <= AOM_TUNE_VMAF_NEG_MAX_GAIN) { @@ -532,20 +544,7 @@ } #endif -#if !CONFIG_USE_VMAF_RC - if (extra_cfg->tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN) { - ERROR( - "This error may be related to the wrong configuration options: try to " - "set -DCONFIG_TUNE_VMAF=1 and -DCONFIG_USE_VMAF_RC=1 at the time CMake" - " is run."); - } -#endif - -#if CONFIG_TUNE_VMAF - RANGE_CHECK(extra_cfg, tuning, AOM_TUNE_PSNR, AOM_TUNE_VMAF_NEG_MAX_GAIN); -#else - RANGE_CHECK(extra_cfg, tuning, AOM_TUNE_PSNR, AOM_TUNE_SSIM); -#endif + RANGE_CHECK(extra_cfg, tuning, AOM_TUNE_PSNR, AOM_TUNE_BUTTERAUGLI); RANGE_CHECK(extra_cfg, timing_info_type, AOM_TIMING_UNSPECIFIED, AOM_TIMING_DEC_MODEL); @@ -613,6 +612,19 @@ if (img->d_w != ctx->cfg.g_w || img->d_h != ctx->cfg.g_h) ERROR("Image size must match encoder init configuration size"); +#if CONFIG_TUNE_BUTTERAUGLI + if (ctx->extra_cfg.tuning == AOM_TUNE_BUTTERAUGLI) { + if (img->bit_depth > 8) { + ERROR("Only 8 bit depth images supported in tune=butteraugli mode."); + } + if ((img->cp != 0 && img->cp != AOM_CICP_CP_BT_709) || + (img->tc != 0 && img->tc != AOM_CICP_TC_BT_709) || + (img->mc != 0 && img->mc != AOM_CICP_MC_BT_709)) { + ERROR("Only BT.709 images supported in tune=butteraugli mode."); + } + } +#endif + return AOM_CODEC_OK; } @@ -672,6 +684,7 @@ extra_cfg->enable_smooth_intra = (cfg->disable_smooth_intra == 0); extra_cfg->enable_paeth_intra = (cfg->disable_paeth_intra == 0); extra_cfg->enable_cfl_intra = (cfg->disable_cfl == 0); + extra_cfg->enable_diagonal_intra = (cfg->disable_diagonal_intra == 0); extra_cfg->enable_obmc = (cfg->disable_obmc == 0); extra_cfg->enable_palette = (cfg->disable_palette == 0); extra_cfg->enable_intrabc = (cfg->disable_intrabc == 0); @@ -746,7 +759,12 @@ const int is_vbr = cfg->rc_end_usage == AOM_VBR; oxcf->profile = cfg->g_profile; oxcf->max_threads = (int)cfg->g_threads; - oxcf->mode = (cfg->g_usage == AOM_USAGE_REALTIME) ? REALTIME : GOOD; + + switch (cfg->g_usage) { + case AOM_USAGE_REALTIME: oxcf->mode = REALTIME; break; + case AOM_USAGE_ALL_INTRA: oxcf->mode = ALLINTRA; break; + default: oxcf->mode = GOOD; break; + } // Set frame-dimension related configuration. frm_dim_cfg->width = cfg->g_w; @@ -893,6 +911,8 @@ oxcf->cost_upd_freq.coeff = (COST_UPDATE_TYPE)extra_cfg->coeff_cost_upd_freq; oxcf->cost_upd_freq.mode = (COST_UPDATE_TYPE)extra_cfg->mode_cost_upd_freq; oxcf->cost_upd_freq.mv = (COST_UPDATE_TYPE)extra_cfg->mv_cost_upd_freq; + // TODO(chiyotsai@google.com): Add command line support in a separate cl. + oxcf->cost_upd_freq.dv = COST_UPD_SB; // Set frame resize mode configuration. resize_cfg->resize_mode = (RESIZE_MODE)cfg->rc_resize_mode; @@ -928,6 +948,10 @@ kf_cfg->sframe_mode = cfg->sframe_mode; kf_cfg->enable_sframe = extra_cfg->s_frame_mode; kf_cfg->enable_keyframe_filtering = extra_cfg->enable_keyframe_filtering; + // Disable key frame filtering in all intra mode. + if (cfg->kf_max_dist == 0) { + kf_cfg->enable_keyframe_filtering = 0; + } kf_cfg->enable_intrabc = extra_cfg->enable_intrabc; oxcf->speed = extra_cfg->cpu_used; @@ -1036,6 +1060,7 @@ intra_mode_cfg->enable_smooth_intra = extra_cfg->enable_smooth_intra; intra_mode_cfg->enable_paeth_intra = extra_cfg->enable_paeth_intra; intra_mode_cfg->enable_cfl_intra = extra_cfg->enable_cfl_intra; + intra_mode_cfg->enable_diagonal_intra = extra_cfg->enable_diagonal_intra; // Set transform size/type configuration. txfm_cfg->enable_tx64 = extra_cfg->enable_tx64; @@ -1118,7 +1143,8 @@ static aom_codec_err_t encoder_set_config(aom_codec_alg_priv_t *ctx, const aom_codec_enc_cfg_t *cfg) { - InitialDimensions *const initial_dimensions = &ctx->cpi->initial_dimensions; + InitialDimensions *const initial_dimensions = + &ctx->ppi->cpi->initial_dimensions; aom_codec_err_t res; int force_key = 0; @@ -1150,10 +1176,10 @@ ctx->cfg = *cfg; set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg); // On profile change, request a key frame - force_key |= ctx->cpi->common.seq_params.profile != ctx->oxcf.profile; - av1_change_config(ctx->cpi, &ctx->oxcf); - if (ctx->cpi_lap != NULL) { - av1_change_config(ctx->cpi_lap, &ctx->oxcf); + force_key |= ctx->ppi->cpi->common.seq_params.profile != ctx->oxcf.profile; + av1_change_config(ctx->ppi->cpi, &ctx->oxcf); + if (ctx->ppi->cpi_lap != NULL) { + av1_change_config(ctx->ppi->cpi_lap, &ctx->oxcf); } } @@ -1163,14 +1189,14 @@ } static aom_fixed_buf_t *encoder_get_global_headers(aom_codec_alg_priv_t *ctx) { - return av1_get_global_headers(ctx->cpi); + return av1_get_global_headers(ctx->ppi->cpi); } static aom_codec_err_t ctrl_get_quantizer(aom_codec_alg_priv_t *ctx, va_list args) { int *const arg = va_arg(args, int *); if (arg == NULL) return AOM_CODEC_INVALID_PARAM; - *arg = av1_get_quantizer(ctx->cpi); + *arg = av1_get_quantizer(ctx->ppi->cpi); return AOM_CODEC_OK; } @@ -1178,7 +1204,7 @@ va_list args) { int *const arg = va_arg(args, int *); if (arg == NULL) return AOM_CODEC_INVALID_PARAM; - *arg = av1_qindex_to_quantizer(av1_get_quantizer(ctx->cpi)); + *arg = av1_qindex_to_quantizer(av1_get_quantizer(ctx->ppi->cpi)); return AOM_CODEC_OK; } @@ -1186,7 +1212,7 @@ va_list args) { int *const arg = va_arg(args, int *); if (arg == NULL) return AOM_CODEC_INVALID_PARAM; - *arg = ctx->cpi->rc.baseline_gf_interval; + *arg = ctx->ppi->cpi->rc.baseline_gf_interval; return AOM_CODEC_OK; } @@ -1196,9 +1222,9 @@ if (res == AOM_CODEC_OK) { ctx->extra_cfg = *extra_cfg; set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg); - av1_change_config(ctx->cpi, &ctx->oxcf); - if (ctx->cpi_lap != NULL) { - av1_change_config(ctx->cpi_lap, &ctx->oxcf); + av1_change_config(ctx->ppi->cpi, &ctx->oxcf); + if (ctx->ppi->cpi_lap != NULL) { + av1_change_config(ctx->ppi->cpi_lap, &ctx->oxcf); } } return res; @@ -1640,6 +1666,13 @@ return update_extra_cfg(ctx, &extra_cfg); } +static aom_codec_err_t ctrl_set_enable_diagonal_intra(aom_codec_alg_priv_t *ctx, + va_list args) { + struct av1_extracfg extra_cfg = ctx->extra_cfg; + extra_cfg.enable_diagonal_intra = CAST(AV1E_SET_ENABLE_DIAGONAL_INTRA, args); + return update_extra_cfg(ctx, &extra_cfg); +} + static aom_codec_err_t ctrl_set_enable_paeth_intra(aom_codec_alg_priv_t *ctx, va_list args) { struct av1_extracfg extra_cfg = ctx->extra_cfg; @@ -1977,8 +2010,8 @@ #endif static aom_codec_err_t create_context_and_bufferpool( - AV1_COMP **p_cpi, BufferPool **p_buffer_pool, AV1EncoderConfig *oxcf, - struct aom_codec_pkt_list *pkt_list_head, FIRSTPASS_STATS *frame_stats_buf, + AV1_PRIMARY *ppi, AV1_COMP **p_cpi, BufferPool **p_buffer_pool, + AV1EncoderConfig *oxcf, FIRSTPASS_STATS *frame_stats_buf, COMPRESSOR_STAGE stage, int num_lap_buffers, int lap_lag_in_frames, STATS_BUFFER_CTX *stats_buf_context) { aom_codec_err_t res = AOM_CODEC_OK; @@ -1991,13 +2024,10 @@ return AOM_CODEC_MEM_ERROR; } #endif - *p_cpi = av1_create_compressor(oxcf, *p_buffer_pool, frame_stats_buf, stage, - num_lap_buffers, lap_lag_in_frames, + *p_cpi = av1_create_compressor(ppi, oxcf, *p_buffer_pool, frame_stats_buf, + stage, num_lap_buffers, lap_lag_in_frames, stats_buf_context); - if (*p_cpi == NULL) - res = AOM_CODEC_MEM_ERROR; - else - (*p_cpi)->output_pkt_list = pkt_list_head; + if (*p_cpi == NULL) res = AOM_CODEC_MEM_ERROR; return res; } @@ -2012,11 +2042,10 @@ ctx->priv = (aom_codec_priv_t *)priv; ctx->priv->init_flags = ctx->init_flags; - if (ctx->config.enc) { - // Update the reference to the config structure to an internal copy. - priv->cfg = *ctx->config.enc; - ctx->config.enc = &priv->cfg; - } + // Update the reference to the config structure to an internal copy. + assert(ctx->config.enc); + priv->cfg = *ctx->config.enc; + ctx->config.enc = &priv->cfg; priv->extra_cfg = default_extra_cfg; aom_once(av1_initialize_enc); @@ -2036,11 +2065,10 @@ if (priv->oxcf.rc_cfg.mode != AOM_CBR && priv->oxcf.pass == 0 && priv->oxcf.mode == GOOD) { // Enable look ahead - enabled for AOM_Q, AOM_CQ, AOM_VBR - *num_lap_buffers = priv->cfg.g_lag_in_frames; *num_lap_buffers = - clamp(*num_lap_buffers, 0, - AOMMIN(MAX_LAP_BUFFERS, priv->oxcf.kf_cfg.key_freq_max + - SCENE_CUT_KEY_TEST_INTERVAL)); + AOMMIN((int)priv->cfg.g_lag_in_frames, + AOMMIN(MAX_LAP_BUFFERS, priv->oxcf.kf_cfg.key_freq_max + + SCENE_CUT_KEY_TEST_INTERVAL)); if ((int)priv->cfg.g_lag_in_frames - (*num_lap_buffers) >= LAP_LAG_IN_FRAMES) { lap_lag_in_frames = LAP_LAG_IN_FRAMES; @@ -2049,6 +2077,9 @@ priv->oxcf.use_highbitdepth = (ctx->init_flags & AOM_CODEC_USE_HIGHBITDEPTH) ? 1 : 0; + priv->ppi = av1_create_primary_compressor(&priv->pkt_list.head); + if (!priv->ppi) return AOM_CODEC_MEM_ERROR; + #if !CONFIG_REALTIME_ONLY res = create_stats_buffer(&priv->frame_stats_buffer, &priv->stats_buf_context, *num_lap_buffers); @@ -2056,14 +2087,14 @@ #endif res = create_context_and_bufferpool( - &priv->cpi, &priv->buffer_pool, &priv->oxcf, &priv->pkt_list.head, + priv->ppi, &priv->ppi->cpi, &priv->buffer_pool, &priv->oxcf, priv->frame_stats_buffer, ENCODE_STAGE, *num_lap_buffers, -1, &priv->stats_buf_context); // Create another compressor if look ahead is enabled if (res == AOM_CODEC_OK && *num_lap_buffers) { res = create_context_and_bufferpool( - &priv->cpi_lap, &priv->buffer_pool_lap, &priv->oxcf, NULL, + priv->ppi, &priv->ppi->cpi_lap, &priv->buffer_pool_lap, &priv->oxcf, priv->frame_stats_buffer, LAP_STAGE, *num_lap_buffers, clamp(lap_lag_in_frames, 0, MAX_LAG_BUFFERS), &priv->stats_buf_context); @@ -2092,15 +2123,17 @@ static aom_codec_err_t encoder_destroy(aom_codec_alg_priv_t *ctx) { free(ctx->cx_data); - destroy_context_and_bufferpool(ctx->cpi, ctx->buffer_pool); - if (ctx->cpi_lap) { - // As both cpi and cpi_lap have the same lookahead_ctx, it is already freed - // when destroy is called on cpi. Thus, setting lookahead_ctx to null here, - // so that it doesn't attempt to free it again. - ctx->cpi_lap->lookahead = NULL; - destroy_context_and_bufferpool(ctx->cpi_lap, ctx->buffer_pool_lap); + + if (ctx->ppi) { + AV1_PRIMARY *ppi = ctx->ppi; + destroy_context_and_bufferpool(ppi->cpi, ctx->buffer_pool); + if (ppi->cpi_lap) { + destroy_context_and_bufferpool(ppi->cpi_lap, ctx->buffer_pool_lap); + } + av1_remove_primary_compressor(ppi); } destroy_stats_buffer(&ctx->stats_buf_context, ctx->frame_stats_buffer); + aom_free(ctx); return AOM_CODEC_OK; } @@ -2134,12 +2167,12 @@ aom_enc_frame_flags_t enc_flags) { const size_t kMinCompressedSize = 8192; volatile aom_codec_err_t res = AOM_CODEC_OK; - AV1_COMP *const cpi = ctx->cpi; + AV1_PRIMARY *const ppi = ctx->ppi; + AV1_COMP *const cpi = ppi->cpi; const aom_rational64_t *const timestamp_ratio = &ctx->timestamp_ratio; volatile aom_codec_pts_t ptsvol = pts; // LAP context - AV1_COMP *cpi_lap = ctx->cpi_lap; - + AV1_COMP *cpi_lap = ppi->cpi_lap; if (cpi == NULL) return AOM_CODEC_INVALID_PARAM; if (cpi->lap_enabled && cpi_lap == NULL && cpi->oxcf.pass == 0) @@ -2148,23 +2181,36 @@ if (img != NULL) { res = validate_img(ctx, img); if (res == AOM_CODEC_OK) { - size_t data_sz = ALIGN_POWER_OF_TWO(ctx->cfg.g_w, 5) * - ALIGN_POWER_OF_TWO(ctx->cfg.g_h, 5) * get_image_bps(img); + const size_t uncompressed_frame_sz = ALIGN_POWER_OF_TWO(ctx->cfg.g_w, 5) * + ALIGN_POWER_OF_TWO(ctx->cfg.g_h, 5) * + get_image_bps(img) / 8; + + // Due to the presence of no-show frames, the ctx->cx_data buffer holds + // compressed data corresponding to multiple frames. As no-show frames are + // not possible for all intra frame encoding with no forward key frames, + // the buffer is allocated with a smaller size in this case. + // + // For pseudo random input, the compressed frame size is seen to exceed + // the uncompressed frame size, but is less than 2 times the uncompressed + // frame size. Hence the size of the buffer is chosen as 2 times the + // uncompressed frame size. + int multiplier = 8; + if (cpi->oxcf.kf_cfg.key_freq_max == 0 && + !cpi->oxcf.kf_cfg.fwd_kf_enabled) + multiplier = 2; + size_t data_sz = uncompressed_frame_sz * multiplier; if (data_sz < kMinCompressedSize) data_sz = kMinCompressedSize; if (ctx->cx_data == NULL || ctx->cx_data_sz < data_sz) { ctx->cx_data_sz = data_sz; free(ctx->cx_data); ctx->cx_data = (unsigned char *)malloc(ctx->cx_data_sz); if (ctx->cx_data == NULL) { + ctx->cx_data_sz = 0; return AOM_CODEC_MEM_ERROR; } } } } - if (ctx->oxcf.mode != GOOD && ctx->oxcf.mode != REALTIME) { - ctx->oxcf.mode = GOOD; - av1_change_config(ctx->cpi, &ctx->oxcf); - } aom_codec_pkt_list_init(&ctx->pkt_list); @@ -2198,9 +2244,9 @@ av1_apply_encoding_flags(cpi_lap, flags); } -#if CONFIG_USE_VMAF_RC - aom_init_vmaf_model_rc(&cpi->vmaf_info.vmaf_model, - cpi->oxcf.tune_cfg.vmaf_model_path); +#if CONFIG_TUNE_VMAF + aom_init_vmaf_model(&cpi->vmaf_info.vmaf_model, + cpi->oxcf.tune_cfg.vmaf_model_path); #endif // Handle fixed keyframe intervals @@ -2241,24 +2287,24 @@ int subsampling_x = sd.subsampling_x; int subsampling_y = sd.subsampling_y; - if (!cpi->lookahead) { + if (!ppi->lookahead) { int lag_in_frames = cpi_lap != NULL ? cpi_lap->oxcf.gf_cfg.lag_in_frames : cpi->oxcf.gf_cfg.lag_in_frames; - cpi->lookahead = av1_lookahead_init( + ppi->lookahead = av1_lookahead_init( cpi->oxcf.frm_dim_cfg.width, cpi->oxcf.frm_dim_cfg.height, subsampling_x, subsampling_y, use_highbitdepth, lag_in_frames, cpi->oxcf.border_in_pixels, cpi->common.features.byte_alignment, - ctx->num_lap_buffers); + ctx->num_lap_buffers, (cpi->oxcf.kf_cfg.key_freq_max == 0), + cpi->oxcf.tool_cfg.enable_global_motion); } - if (!cpi->lookahead) + if (!ppi->lookahead) aom_internal_error(&cpi->common.error, AOM_CODEC_MEM_ERROR, "Failed to allocate lag buffers"); av1_check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y); if (cpi_lap != NULL) { - cpi_lap->lookahead = cpi->lookahead; av1_check_initial_width(cpi_lap, use_highbitdepth, subsampling_x, subsampling_y); } @@ -2275,12 +2321,8 @@ unsigned char *cx_data = ctx->cx_data; size_t cx_data_sz = ctx->cx_data_sz; - assert(!(cx_data == NULL && cx_data_sz != 0)); - /* Any pending invisible frames? */ - if (ctx->pending_cx_data) { - memmove(cx_data, ctx->pending_cx_data, ctx->pending_cx_data_sz); - ctx->pending_cx_data = cx_data; + if (ctx->pending_cx_data_sz) { cx_data += ctx->pending_cx_data_sz; cx_data_sz -= ctx->pending_cx_data_sz; @@ -2296,7 +2338,6 @@ size_t frame_size = 0; unsigned int lib_flags = 0; int is_frame_visible = 0; - int index_size = 0; int has_no_show_keyframe = 0; int num_workers = 0; @@ -2331,7 +2372,7 @@ if (status != AOM_CODEC_OK) { aom_internal_error(&cpi_lap->common.error, AOM_CODEC_ERROR, NULL); } - cpi_lap->seq_params_locked = 1; + cpi_lap->ppi->seq_params_locked = 1; } lib_flags = 0; frame_size = 0; @@ -2341,8 +2382,7 @@ // visible frame. int64_t dst_time_stamp; int64_t dst_end_time_stamp; - while (cx_data_sz - index_size >= ctx->cx_data_sz / 2 && - !is_frame_visible) { + while (cx_data_sz >= ctx->cx_data_sz / 2 && !is_frame_visible) { const int status = av1_get_compressed_data( cpi, &lib_flags, &frame_size, cx_data, &dst_time_stamp, &dst_end_time_stamp, !img, timestamp_ratio); @@ -2351,73 +2391,60 @@ aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); } - cpi->seq_params_locked = 1; - if (frame_size) { - if (ctx->pending_cx_data == 0) ctx->pending_cx_data = cx_data; + cpi->ppi->seq_params_locked = 1; + if (!frame_size) continue; + assert(cx_data != NULL && cx_data_sz != 0); + const int write_temporal_delimiter = + !cpi->common.spatial_layer_id && !ctx->pending_cx_data_sz; - const int write_temporal_delimiter = - !cpi->common.spatial_layer_id && !ctx->pending_frame_count; + if (write_temporal_delimiter) { + uint32_t obu_header_size = 1; + const uint32_t obu_payload_size = 0; + const size_t length_field_size = + aom_uleb_size_in_bytes(obu_payload_size); - if (write_temporal_delimiter) { - uint32_t obu_header_size = 1; - const uint32_t obu_payload_size = 0; - const size_t length_field_size = - aom_uleb_size_in_bytes(obu_payload_size); + const size_t move_offset = obu_header_size + length_field_size; + memmove(ctx->cx_data + move_offset, ctx->cx_data, frame_size); + obu_header_size = av1_write_obu_header( + &cpi->level_params, OBU_TEMPORAL_DELIMITER, 0, ctx->cx_data); - if (ctx->pending_cx_data) { - const size_t move_offset = length_field_size + 1; - memmove(ctx->pending_cx_data + move_offset, ctx->pending_cx_data, - frame_size); - } - const uint32_t obu_header_offset = 0; - obu_header_size = av1_write_obu_header( - &cpi->level_params, OBU_TEMPORAL_DELIMITER, 0, - (uint8_t *)(ctx->pending_cx_data + obu_header_offset)); - - // OBUs are preceded/succeeded by an unsigned leb128 coded integer. - if (av1_write_uleb_obu_size(obu_header_size, obu_payload_size, - ctx->pending_cx_data) != AOM_CODEC_OK) { - aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); - } - - frame_size += obu_header_size + obu_payload_size + length_field_size; + // OBUs are preceded/succeeded by an unsigned leb128 coded integer. + if (av1_write_uleb_obu_size(obu_header_size, obu_payload_size, + ctx->cx_data) != AOM_CODEC_OK) { + aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); } - if (ctx->oxcf.save_as_annexb) { - size_t curr_frame_size = frame_size; - if (av1_convert_sect5obus_to_annexb(cx_data, &curr_frame_size) != - AOM_CODEC_OK) { - aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); - } - frame_size = curr_frame_size; - - // B_PRIME (add frame size) - const size_t length_field_size = aom_uleb_size_in_bytes(frame_size); - if (ctx->pending_cx_data) { - const size_t move_offset = length_field_size; - memmove(cx_data + move_offset, cx_data, frame_size); - } - if (av1_write_uleb_obu_size(0, (uint32_t)frame_size, cx_data) != - AOM_CODEC_OK) { - aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); - } - frame_size += length_field_size; - } - - ctx->pending_frame_sizes[ctx->pending_frame_count++] = frame_size; - ctx->pending_cx_data_sz += frame_size; - - cx_data += frame_size; - cx_data_sz -= frame_size; - - index_size = MAG_SIZE * (ctx->pending_frame_count - 1) + 2; - - is_frame_visible = cpi->common.show_frame; - - has_no_show_keyframe |= - (!is_frame_visible && - cpi->common.current_frame.frame_type == KEY_FRAME); + frame_size += obu_header_size + obu_payload_size + length_field_size; } + + if (ctx->oxcf.save_as_annexb) { + size_t curr_frame_size = frame_size; + if (av1_convert_sect5obus_to_annexb(cx_data, &curr_frame_size) != + AOM_CODEC_OK) { + aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); + } + frame_size = curr_frame_size; + + // B_PRIME (add frame size) + const size_t length_field_size = aom_uleb_size_in_bytes(frame_size); + memmove(cx_data + length_field_size, cx_data, frame_size); + if (av1_write_uleb_obu_size(0, (uint32_t)frame_size, cx_data) != + AOM_CODEC_OK) { + aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); + } + frame_size += length_field_size; + } + + ctx->pending_cx_data_sz += frame_size; + + cx_data += frame_size; + cx_data_sz -= frame_size; + + is_frame_visible = cpi->common.show_frame; + + has_no_show_keyframe |= + (!is_frame_visible && + cpi->common.current_frame.frame_type == KEY_FRAME); } if (is_frame_visible) { // Add the frame packet to the list of returned packets. @@ -2429,13 +2456,9 @@ // B_PRIME (add TU size) size_t tu_size = ctx->pending_cx_data_sz; const size_t length_field_size = aom_uleb_size_in_bytes(tu_size); - if (ctx->pending_cx_data) { - const size_t move_offset = length_field_size; - memmove(ctx->pending_cx_data + move_offset, ctx->pending_cx_data, - tu_size); - } - if (av1_write_uleb_obu_size(0, (uint32_t)tu_size, - ctx->pending_cx_data) != AOM_CODEC_OK) { + memmove(ctx->cx_data + length_field_size, ctx->cx_data, tu_size); + if (av1_write_uleb_obu_size(0, (uint32_t)tu_size, ctx->cx_data) != + AOM_CODEC_OK) { aom_internal_error(&cpi->common.error, AOM_CODEC_ERROR, NULL); } ctx->pending_cx_data_sz += length_field_size; @@ -2443,7 +2466,7 @@ pkt.kind = AOM_CODEC_CX_FRAME_PKT; - pkt.data.frame.buf = ctx->pending_cx_data; + pkt.data.frame.buf = ctx->cx_data; pkt.data.frame.sz = ctx->pending_cx_data_sz; pkt.data.frame.partition_id = -1; pkt.data.frame.vis_frame_size = frame_size; @@ -2462,9 +2485,7 @@ aom_codec_pkt_list_add(&ctx->pkt_list.head, &pkt); - ctx->pending_cx_data = NULL; ctx->pending_cx_data_sz = 0; - ctx->pending_frame_count = 0; } } @@ -2485,7 +2506,7 @@ YV12_BUFFER_CONFIG sd; image2yuvconfig(&frame->img, &sd); - av1_set_reference_enc(ctx->cpi, frame->idx, &sd); + av1_set_reference_enc(ctx->ppi->cpi, frame->idx, &sd); return AOM_CODEC_OK; } else { return AOM_CODEC_INVALID_PARAM; @@ -2500,7 +2521,7 @@ YV12_BUFFER_CONFIG sd; image2yuvconfig(&frame->img, &sd); - av1_copy_reference_enc(ctx->cpi, frame->idx, &sd); + av1_copy_reference_enc(ctx->ppi->cpi, frame->idx, &sd); return AOM_CODEC_OK; } else { return AOM_CODEC_INVALID_PARAM; @@ -2512,7 +2533,7 @@ av1_ref_frame_t *const frame = va_arg(args, av1_ref_frame_t *); if (frame != NULL) { - YV12_BUFFER_CONFIG *fb = get_ref_frame(&ctx->cpi->common, frame->idx); + YV12_BUFFER_CONFIG *fb = get_ref_frame(&ctx->ppi->cpi->common, frame->idx); if (fb == NULL) return AOM_CODEC_ERROR; yuvconfig2image(&frame->img, fb, NULL); @@ -2529,7 +2550,7 @@ if (new_img != NULL) { YV12_BUFFER_CONFIG new_frame; - if (av1_get_last_show_frame(ctx->cpi, &new_frame) == 0) { + if (av1_get_last_show_frame(ctx->ppi->cpi, &new_frame) == 0) { yuvconfig2image(new_img, &new_frame, NULL); return AOM_CODEC_OK; } else { @@ -2547,10 +2568,10 @@ if (new_img != NULL) { YV12_BUFFER_CONFIG new_frame; - if (av1_get_last_show_frame(ctx->cpi, &new_frame) == 0) { + if (av1_get_last_show_frame(ctx->ppi->cpi, &new_frame) == 0) { YV12_BUFFER_CONFIG sd; image2yuvconfig(new_img, &sd); - return av1_copy_new_frame_enc(&ctx->cpi->common, &new_frame, &sd); + return av1_copy_new_frame_enc(&ctx->ppi->cpi->common, &new_frame, &sd); } else { return AOM_CODEC_ERROR; } @@ -2562,7 +2583,7 @@ static aom_image_t *encoder_get_preview(aom_codec_alg_priv_t *ctx) { YV12_BUFFER_CONFIG sd; - if (av1_get_preview_raw_frame(ctx->cpi, &sd) == 0) { + if (av1_get_preview_raw_frame(ctx->ppi->cpi, &sd) == 0) { yuvconfig2image(&ctx->preview_img, &sd, NULL); return &ctx->preview_img; } else { @@ -2574,7 +2595,8 @@ va_list args) { const int reference_flag = va_arg(args, int); - av1_use_as_reference(&ctx->cpi->ext_flags.ref_frame_flags, reference_flag); + av1_use_as_reference(&ctx->ppi->cpi->ext_flags.ref_frame_flags, + reference_flag); return AOM_CODEC_OK; } @@ -2592,7 +2614,7 @@ aom_active_map_t *const map = va_arg(args, aom_active_map_t *); if (map) { - if (!av1_set_active_map(ctx->cpi, map->active_map, (int)map->rows, + if (!av1_set_active_map(ctx->ppi->cpi, map->active_map, (int)map->rows, (int)map->cols)) return AOM_CODEC_OK; else @@ -2607,7 +2629,7 @@ aom_active_map_t *const map = va_arg(args, aom_active_map_t *); if (map) { - if (!av1_get_active_map(ctx->cpi, map->active_map, (int)map->rows, + if (!av1_get_active_map(ctx->ppi->cpi, map->active_map, (int)map->rows, (int)map->cols)) return AOM_CODEC_OK; else @@ -2623,7 +2645,7 @@ if (mode) { const int res = av1_set_internal_size( - &ctx->cpi->oxcf, &ctx->cpi->resize_pending_params, + &ctx->ppi->cpi->oxcf, &ctx->ppi->cpi->resize_pending_params, (AOM_SCALING)mode->h_scaling_mode, (AOM_SCALING)mode->v_scaling_mode); return (res == 0) ? AOM_CODEC_OK : AOM_CODEC_INVALID_PARAM; } else { @@ -2636,7 +2658,7 @@ const int spatial_layer_id = va_arg(args, int); if (spatial_layer_id >= MAX_NUM_SPATIAL_LAYERS) return AOM_CODEC_INVALID_PARAM; - ctx->cpi->common.spatial_layer_id = spatial_layer_id; + ctx->ppi->cpi->common.spatial_layer_id = spatial_layer_id; return AOM_CODEC_OK; } @@ -2645,23 +2667,23 @@ const int number_spatial_layers = va_arg(args, int); if (number_spatial_layers > MAX_NUM_SPATIAL_LAYERS) return AOM_CODEC_INVALID_PARAM; - ctx->cpi->common.number_spatial_layers = number_spatial_layers; + ctx->ppi->cpi->common.number_spatial_layers = number_spatial_layers; return AOM_CODEC_OK; } static aom_codec_err_t ctrl_set_layer_id(aom_codec_alg_priv_t *ctx, va_list args) { aom_svc_layer_id_t *const data = va_arg(args, aom_svc_layer_id_t *); - ctx->cpi->common.spatial_layer_id = data->spatial_layer_id; - ctx->cpi->common.temporal_layer_id = data->temporal_layer_id; - ctx->cpi->svc.spatial_layer_id = data->spatial_layer_id; - ctx->cpi->svc.temporal_layer_id = data->temporal_layer_id; + ctx->ppi->cpi->common.spatial_layer_id = data->spatial_layer_id; + ctx->ppi->cpi->common.temporal_layer_id = data->temporal_layer_id; + ctx->ppi->cpi->svc.spatial_layer_id = data->spatial_layer_id; + ctx->ppi->cpi->svc.temporal_layer_id = data->temporal_layer_id; return AOM_CODEC_OK; } static aom_codec_err_t ctrl_set_svc_params(aom_codec_alg_priv_t *ctx, va_list args) { - AV1_COMP *const cpi = ctx->cpi; + AV1_COMP *const cpi = ctx->ppi->cpi; AV1_COMMON *const cm = &cpi->common; aom_svc_params_t *const params = va_arg(args, aom_svc_params_t *); cm->number_spatial_layers = params->number_spatial_layers; @@ -2684,7 +2706,7 @@ } } if (cm->current_frame.frame_number == 0) { - if (!cpi->seq_params_locked) { + if (!cpi->ppi->seq_params_locked) { SequenceHeader *const seq_params = &cm->seq_params; seq_params->operating_points_cnt_minus_1 = cm->number_spatial_layers * cm->number_temporal_layers - 1; @@ -2700,7 +2722,7 @@ static aom_codec_err_t ctrl_set_svc_ref_frame_config(aom_codec_alg_priv_t *ctx, va_list args) { - AV1_COMP *const cpi = ctx->cpi; + AV1_COMP *const cpi = ctx->ppi->cpi; aom_svc_ref_frame_config_t *const data = va_arg(args, aom_svc_ref_frame_config_t *); cpi->svc.external_ref_frame_config = 1; @@ -2802,17 +2824,18 @@ // Used to mock the argv with just one string "--{name}={value}" char *argv[2] = { NULL, "" }; size_t len = strlen(name) + strlen(value) + 4; - char *err_string = ctx->cpi->common.error.detail; + char *err_string = ctx->ppi->cpi->common.error.detail; #if __STDC_VERSION__ >= 201112L // We use the keyword _Static_assert because clang-cl does not allow the // convenience macro static_assert to be used in function scope. See // https://bugs.llvm.org/show_bug.cgi?id=48904. - _Static_assert(sizeof(ctx->cpi->common.error.detail) >= ARG_ERR_MSG_MAX_LEN, - "The size of the err_msg buffer for arg_match_helper must be " - "at least ARG_ERR_MSG_MAX_LEN"); + _Static_assert( + sizeof(ctx->ppi->cpi->common.error.detail) >= ARG_ERR_MSG_MAX_LEN, + "The size of the err_msg buffer for arg_match_helper must be " + "at least ARG_ERR_MSG_MAX_LEN"); #else - assert(sizeof(ctx->cpi->common.error.detail) >= ARG_ERR_MSG_MAX_LEN); + assert(sizeof(ctx->ppi->cpi->common.error.detail) >= ARG_ERR_MSG_MAX_LEN); #endif argv[0] = aom_malloc(len * sizeof(argv[1][0])); @@ -3079,6 +3102,9 @@ } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_cfl_intra, argv, err_string)) { extra_cfg.enable_cfl_intra = arg_parse_int_helper(&arg, err_string); + } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_diagonal_intra, + argv, err_string)) { + extra_cfg.enable_diagonal_intra = arg_parse_int_helper(&arg, err_string); } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.enable_overlay, argv, err_string)) { extra_cfg.enable_overlay = arg_parse_int_helper(&arg, err_string); @@ -3182,7 +3208,7 @@ static aom_codec_err_t ctrl_get_seq_level_idx(aom_codec_alg_priv_t *ctx, va_list args) { int *const arg = va_arg(args, int *); - const AV1_COMP *const cpi = ctx->cpi; + const AV1_COMP *const cpi = ctx->ppi->cpi; if (arg == NULL) return AOM_CODEC_INVALID_PARAM; return av1_get_seq_level_idx(&cpi->common.seq_params, &cpi->level_params, arg); @@ -3265,6 +3291,7 @@ { AV1E_SET_ENABLE_SMOOTH_INTRA, ctrl_set_enable_smooth_intra }, { AV1E_SET_ENABLE_PAETH_INTRA, ctrl_set_enable_paeth_intra }, { AV1E_SET_ENABLE_CFL_INTRA, ctrl_set_enable_cfl_intra }, + { AV1E_SET_ENABLE_DIAGONAL_INTRA, ctrl_set_enable_diagonal_intra }, { AV1E_SET_ENABLE_SUPERRES, ctrl_set_enable_superres }, { AV1E_SET_ENABLE_OVERLAY, ctrl_set_enable_overlay }, { AV1E_SET_ENABLE_PALETTE, ctrl_set_enable_palette }, @@ -3330,6 +3357,7 @@ }; static const aom_codec_enc_cfg_t encoder_usage_cfg[] = { +#if !CONFIG_REALTIME_ONLY { // NOLINT AOM_USAGE_GOOD_QUALITY, // g_usage - non-realtime usage @@ -3398,8 +3426,9 @@ 0, // use_fixed_qp_offsets { -1, -1, -1, -1, -1 }, // fixed_qp_offsets { 0, 128, 128, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // cfg + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // cfg }, +#endif // !CONFIG_REALTIME_ONLY { // NOLINT AOM_USAGE_REALTIME, // g_usage - real-time usage @@ -3420,7 +3449,7 @@ AOM_RC_ONE_PASS, // g_pass - 1, // g_lag_in_frames + 0, // g_lag_in_frames 0, // rc_dropframe_thresh RESIZE_NONE, // rc_resize_mode @@ -3468,8 +3497,80 @@ 0, // use_fixed_qp_offsets { -1, -1, -1, -1, -1 }, // fixed_qp_offsets { 0, 128, 128, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // cfg + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // cfg }, +#if !CONFIG_REALTIME_ONLY + { + // NOLINT + AOM_USAGE_ALL_INTRA, // g_usage - all intra usage + 0, // g_threads + 0, // g_profile + + 320, // g_w + 240, // g_h + 0, // g_limit + 0, // g_forced_max_frame_width + 0, // g_forced_max_frame_height + AOM_BITS_8, // g_bit_depth + 8, // g_input_bit_depth + + { 1, 30 }, // g_timebase + + 0, // g_error_resilient + + AOM_RC_ONE_PASS, // g_pass + + 0, // g_lag_in_frames + + 0, // rc_dropframe_thresh + RESIZE_NONE, // rc_resize_mode + SCALE_NUMERATOR, // rc_resize_denominator + SCALE_NUMERATOR, // rc_resize_kf_denominator + + AOM_SUPERRES_NONE, // rc_superres_mode + SCALE_NUMERATOR, // rc_superres_denominator + SCALE_NUMERATOR, // rc_superres_kf_denominator + 63, // rc_superres_qthresh + 32, // rc_superres_kf_qthresh + + AOM_Q, // rc_end_usage + { NULL, 0 }, // rc_twopass_stats_in + { NULL, 0 }, // rc_firstpass_mb_stats_in + 256, // rc_target_bandwidth + 0, // rc_min_quantizer + 63, // rc_max_quantizer + 25, // rc_undershoot_pct + 25, // rc_overshoot_pct + + 6000, // rc_max_buffer_size + 4000, // rc_buffer_initial_size + 5000, // rc_buffer_optimal_size + + 50, // rc_two_pass_vbrbias + 0, // rc_two_pass_vbrmin_section + 2000, // rc_two_pass_vbrmax_section + + // keyframing settings (kf) + 0, // fwd_kf_enabled + AOM_KF_DISABLED, // kf_mode + 0, // kf_min_dist + 0, // kf_max_dist + 0, // sframe_dist + 1, // sframe_mode + 0, // large_scale_tile + 0, // monochrome + 0, // full_still_picture_hdr + 0, // save_as_annexb + 0, // tile_width_count + 0, // tile_height_count + { 0 }, // tile_widths + { 0 }, // tile_heights + 0, // use_fixed_qp_offsets + { -1, -1, -1, -1, -1 }, // fixed_qp_offsets + { 0, 128, 128, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // cfg + }, +#endif // !CONFIG_REALTIME_ONLY }; // This data structure and function are exported in aom/aomcx.h @@ -3494,7 +3595,7 @@ }, { // NOLINT - 2, // 2 cfg + 3, // 3 cfg encoder_usage_cfg, // aom_codec_enc_cfg_t encoder_encode, // aom_codec_encode_fn_t encoder_get_cxdata, // aom_codec_get_cx_data_fn_t
diff --git a/av1/common/arm/reconintra_neon.c b/av1/common/arm/reconintra_neon.c index ec6d0d7..43c470f 100644 --- a/av1/common/arm/reconintra_neon.c +++ b/av1/common/arm/reconintra_neon.c
@@ -14,7 +14,6 @@ #include "aom/aom_integer.h" #include "aom_dsp/arm/sum_neon.h" -#include "common/tools_common.h" DECLARE_ALIGNED(16, const int8_t, av1_filter_intra_taps_neon[FILTER_INTRA_MODES][8][8]) = {
diff --git a/av1/common/blockd.h b/av1/common/blockd.h index 0eb212c..8bb7daa 100644 --- a/av1/common/blockd.h +++ b/av1/common/blockd.h
@@ -893,7 +893,7 @@ /*! * Mask for this block used for compound prediction. */ - DECLARE_ALIGNED(16, uint8_t, seg_mask[2 * MAX_SB_SQUARE]); + uint8_t *seg_mask; /*! * CFL (chroma from luma) related parameters. @@ -1020,6 +1020,28 @@ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, }; +// The bitmask corresponds to the transform types as defined in +// enums.h TX_TYPE enumeration type. Setting the bit 0 means to disable +// the use of the corresponding transform type in that table. +// The av1_derived_intra_tx_used_flag table is used when +// use_reduced_intra_txset is set to 2, where one only searches +// the transform types derived from residual statistics. +static const uint16_t av1_derived_intra_tx_used_flag[INTRA_MODES] = { + 0x0209, // DC_PRED: 0000 0010 0000 1001 + 0x0403, // V_PRED: 0000 0100 0000 0011 + 0x0805, // H_PRED: 0000 1000 0000 0101 + 0x020F, // D45_PRED: 0000 0010 0000 1111 + 0x0009, // D135_PRED: 0000 0000 0000 1001 + 0x0009, // D113_PRED: 0000 0000 0000 1001 + 0x0009, // D157_PRED: 0000 0000 0000 1001 + 0x0805, // D203_PRED: 0000 1000 0000 0101 + 0x0403, // D67_PRED: 0000 0100 0000 0011 + 0x0205, // SMOOTH_PRED: 0000 0010 0000 1001 + 0x0403, // SMOOTH_V_PRED: 0000 0100 0000 0011 + 0x0805, // SMOOTH_H_PRED: 0000 1000 0000 0101 + 0x0209, // PAETH_PRED: 0000 0010 0000 1001 +}; + static const uint16_t av1_reduced_intra_tx_used_flag[INTRA_MODES] = { 0x080F, // DC_PRED: 0000 1000 0000 1111 0x040F, // V_PRED: 0000 0100 0000 1111 @@ -1507,10 +1529,12 @@ } /* clang-format off */ +// Pointer to a three-dimensional array whose first dimension is PALETTE_SIZES. typedef aom_cdf_prob (*MapCdf)[PALETTE_COLOR_INDEX_CONTEXTS] [CDF_SIZE(PALETTE_COLORS)]; -typedef const int (*ColorCost)[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS] - [PALETTE_COLORS]; +// Pointer to a const three-dimensional array whose first dimension is +// PALETTE_SIZES. +typedef const int (*ColorCost)[PALETTE_COLOR_INDEX_CONTEXTS][PALETTE_COLORS]; /* clang-format on */ typedef struct {
diff --git a/av1/common/cdef.c b/av1/common/cdef.c index bc8eecc..d9b5a10 100644 --- a/av1/common/cdef.c +++ b/av1/common/cdef.c
@@ -21,6 +21,35 @@ #include "av1/common/cdef_block.h" #include "av1/common/reconinter.h" +enum { TOP, LEFT, BOTTOM, RIGHT, BOUNDARIES } UENUM1BYTE(BOUNDARY); + +/*!\brief Parameters related to CDEF Block */ +typedef struct { + uint16_t *src; + uint8_t *dst; + uint16_t *colbuf[MAX_MB_PLANE]; + cdef_list dlist[MI_SIZE_64X64 * MI_SIZE_64X64]; + + int xdec; + int ydec; + int mi_wide_l2; + int mi_high_l2; + int frame_boundary[BOUNDARIES]; + + int damping; + int coeff_shift; + int level; + int sec_strength; + int cdef_count; + int is_zero_level; + int dir[CDEF_NBLOCKS][CDEF_NBLOCKS]; + int var[CDEF_NBLOCKS][CDEF_NBLOCKS]; + + int dst_stride; + int coffset; + int roffset; +} CdefBlockInfo; + static int is_8x8_block_skip(MB_MODE_INFO **grid, int mi_row, int mi_col, int mi_stride) { MB_MODE_INFO **mbmi = grid + mi_row * mi_stride + mi_col; @@ -118,271 +147,343 @@ } } -void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, - MACROBLOCKD *xd) { - const CdefInfo *const cdef_info = &cm->cdef_info; +// Prepares intermediate input buffer for CDEF. +// Inputs: +// cm: Pointer to common structure. +// fb_info: Pointer to the CDEF block-level parameter structure. +// linebuf: Top feedback buffer for CDEF. +// cdef_left: Left block is filtered or not. +// fbc, fbr: col and row index of a block. +// plane: plane index Y/CB/CR. +// prev_row_cdef: Top blocks are filtered or not. +// Returns: +// Nothing will be returned. +static void cdef_prepare_fb(AV1_COMMON *cm, CdefBlockInfo *fb_info, + uint16_t **linebuf, const int *cdef_left, int fbc, + int fbr, uint8_t plane, + unsigned char *prev_row_cdef) { const CommonModeInfoParams *const mi_params = &cm->mi_params; - const int num_planes = av1_num_planes(cm); - DECLARE_ALIGNED(16, uint16_t, src[CDEF_INBUF_SIZE]); - uint16_t *linebuf[3]; - uint16_t *colbuf[3]; - cdef_list dlist[MI_SIZE_64X64 * MI_SIZE_64X64]; - unsigned char *row_cdef, *prev_row_cdef, *curr_row_cdef; - int cdef_count; - int dir[CDEF_NBLOCKS][CDEF_NBLOCKS] = { { 0 } }; - int var[CDEF_NBLOCKS][CDEF_NBLOCKS] = { { 0 } }; - int mi_wide_l2[3]; - int mi_high_l2[3]; - int xdec[3]; - int ydec[3]; - int coeff_shift = AOMMAX(cm->seq_params.bit_depth - 8, 0); + uint16_t *src = fb_info->src; + const int stride = (mi_params->mi_cols << MI_SIZE_LOG2) + 2 * CDEF_HBORDER; const int nvfb = (mi_params->mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; const int nhfb = (mi_params->mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; + int cstart = 0; + if (!*cdef_left) cstart = -CDEF_HBORDER; + int rend, cend; + int nhb = AOMMIN(MI_SIZE_64X64, mi_params->mi_cols - MI_SIZE_64X64 * fbc); + int nvb = AOMMIN(MI_SIZE_64X64, mi_params->mi_rows - MI_SIZE_64X64 * fbr); + int hsize = nhb << fb_info->mi_wide_l2; + int vsize = nvb << fb_info->mi_high_l2; + + if (fbc == nhfb - 1) + cend = hsize; + else + cend = hsize + CDEF_HBORDER; + + if (fbr == nvfb - 1) + rend = vsize; + else + rend = vsize + CDEF_VBORDER; + + if (fbc == nhfb - 1) { + /* On the last superblock column, fill in the right border with + CDEF_VERY_LARGE to avoid filtering with the outside. */ + fill_rect(&src[cend + CDEF_HBORDER], CDEF_BSTRIDE, rend + CDEF_VBORDER, + hsize + CDEF_HBORDER - cend, CDEF_VERY_LARGE); + } + if (fbr == nvfb - 1) { + /* On the last superblock row, fill in the bottom border with + CDEF_VERY_LARGE to avoid filtering with the outside. */ + fill_rect(&src[(rend + CDEF_VBORDER) * CDEF_BSTRIDE], CDEF_BSTRIDE, + CDEF_VBORDER, hsize + 2 * CDEF_HBORDER, CDEF_VERY_LARGE); + } + /* Copy in the pixels we need from the current superblock for + deringing.*/ + copy_sb8_16(cm, &src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER + cstart], + CDEF_BSTRIDE, fb_info->dst, fb_info->roffset, + fb_info->coffset + cstart, fb_info->dst_stride, rend, + cend - cstart); + if (!prev_row_cdef[fbc]) { + copy_sb8_16(cm, &src[CDEF_HBORDER], CDEF_BSTRIDE, fb_info->dst, + fb_info->roffset - CDEF_VBORDER, fb_info->coffset, + fb_info->dst_stride, CDEF_VBORDER, hsize); + } else if (fbr > 0) { + copy_rect(&src[CDEF_HBORDER], CDEF_BSTRIDE, + &linebuf[plane][fb_info->coffset], stride, CDEF_VBORDER, hsize); + } else { + fill_rect(&src[CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, hsize, + CDEF_VERY_LARGE); + } + if (!prev_row_cdef[fbc - 1]) { + copy_sb8_16(cm, src, CDEF_BSTRIDE, fb_info->dst, + fb_info->roffset - CDEF_VBORDER, + fb_info->coffset - CDEF_HBORDER, fb_info->dst_stride, + CDEF_VBORDER, CDEF_HBORDER); + } else if (fbr > 0 && fbc > 0) { + copy_rect(src, CDEF_BSTRIDE, + &linebuf[plane][fb_info->coffset - CDEF_HBORDER], stride, + CDEF_VBORDER, CDEF_HBORDER); + } else { + fill_rect(src, CDEF_BSTRIDE, CDEF_VBORDER, CDEF_HBORDER, CDEF_VERY_LARGE); + } + if (!prev_row_cdef[fbc + 1]) { + copy_sb8_16(cm, &src[CDEF_HBORDER + hsize], CDEF_BSTRIDE, fb_info->dst, + fb_info->roffset - CDEF_VBORDER, fb_info->coffset + hsize, + fb_info->dst_stride, CDEF_VBORDER, CDEF_HBORDER); + } else if (fbr > 0 && fbc < nhfb - 1) { + copy_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, + &linebuf[plane][fb_info->coffset + hsize], stride, CDEF_VBORDER, + CDEF_HBORDER); + } else { + fill_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, + CDEF_HBORDER, CDEF_VERY_LARGE); + } + if (*cdef_left) { + /* If we deringed the superblock on the left then we need to copy in + saved pixels. */ + copy_rect(src, CDEF_BSTRIDE, fb_info->colbuf[plane], CDEF_HBORDER, + rend + CDEF_VBORDER, CDEF_HBORDER); + } + /* Saving pixels in case we need to dering the superblock on the + right. */ + copy_rect(fb_info->colbuf[plane], CDEF_HBORDER, src + hsize, CDEF_BSTRIDE, + rend + CDEF_VBORDER, CDEF_HBORDER); + copy_sb8_16(cm, &linebuf[plane][fb_info->coffset], stride, fb_info->dst, + (MI_SIZE_64X64 << fb_info->mi_high_l2) * (fbr + 1) - CDEF_VBORDER, + fb_info->coffset, fb_info->dst_stride, CDEF_VBORDER, hsize); + + if (fb_info->frame_boundary[TOP]) { + fill_rect(src, CDEF_BSTRIDE, CDEF_VBORDER, hsize + 2 * CDEF_HBORDER, + CDEF_VERY_LARGE); + } + if (fb_info->frame_boundary[LEFT]) { + fill_rect(src, CDEF_BSTRIDE, vsize + 2 * CDEF_VBORDER, CDEF_HBORDER, + CDEF_VERY_LARGE); + } + if (fb_info->frame_boundary[BOTTOM]) { + fill_rect(&src[(vsize + CDEF_VBORDER) * CDEF_BSTRIDE], CDEF_BSTRIDE, + CDEF_VBORDER, hsize + 2 * CDEF_HBORDER, CDEF_VERY_LARGE); + } + if (fb_info->frame_boundary[RIGHT]) { + fill_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, + vsize + 2 * CDEF_VBORDER, CDEF_HBORDER, CDEF_VERY_LARGE); + } +} + +static INLINE void cdef_filter_fb(CdefBlockInfo *fb_info, uint8_t plane, + uint8_t use_highbitdepth) { + int offset = fb_info->dst_stride * fb_info->roffset + fb_info->coffset; + if (use_highbitdepth) { + av1_cdef_filter_fb( + NULL, CONVERT_TO_SHORTPTR(fb_info->dst + offset), fb_info->dst_stride, + &fb_info->src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], + fb_info->xdec, fb_info->ydec, fb_info->dir, NULL, fb_info->var, plane, + fb_info->dlist, fb_info->cdef_count, fb_info->level, + fb_info->sec_strength, fb_info->damping, fb_info->coeff_shift); + } else { + av1_cdef_filter_fb( + fb_info->dst + offset, NULL, fb_info->dst_stride, + &fb_info->src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], + fb_info->xdec, fb_info->ydec, fb_info->dir, NULL, fb_info->var, plane, + fb_info->dlist, fb_info->cdef_count, fb_info->level, + fb_info->sec_strength, fb_info->damping, fb_info->coeff_shift); + } +} + +// Initializes block-level parameters for CDEF. +static INLINE void cdef_init_fb_col(MACROBLOCKD *xd, + const CdefInfo *const cdef_info, + CdefBlockInfo *fb_info, + const int mbmi_cdef_strength, int fbc, + int fbr, uint8_t plane) { + if (plane == AOM_PLANE_Y) { + fb_info->level = + cdef_info->cdef_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; + fb_info->sec_strength = + cdef_info->cdef_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; + fb_info->sec_strength += fb_info->sec_strength == 3; + int uv_level = + cdef_info->cdef_uv_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; + int uv_sec_strength = + cdef_info->cdef_uv_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; + uv_sec_strength += uv_sec_strength == 3; + fb_info->is_zero_level = (fb_info->level == 0) && + (fb_info->sec_strength == 0) && (uv_level == 0) && + (uv_sec_strength == 0); + } else { + fb_info->level = + cdef_info->cdef_uv_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; + fb_info->sec_strength = + cdef_info->cdef_uv_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; + fb_info->sec_strength += fb_info->sec_strength == 3; + } + fb_info->dst = xd->plane[plane].dst.buf; + fb_info->dst_stride = xd->plane[plane].dst.stride; + + fb_info->xdec = xd->plane[plane].subsampling_x; + fb_info->ydec = xd->plane[plane].subsampling_y; + fb_info->mi_wide_l2 = MI_SIZE_LOG2 - xd->plane[plane].subsampling_x; + fb_info->mi_high_l2 = MI_SIZE_LOG2 - xd->plane[plane].subsampling_y; + fb_info->roffset = MI_SIZE_64X64 * fbr << fb_info->mi_high_l2; + fb_info->coffset = MI_SIZE_64X64 * fbc << fb_info->mi_wide_l2; +} + +static bool cdef_fb_col(AV1_COMMON *cm, MACROBLOCKD *xd, CdefBlockInfo *fb_info, + int fbc, int fbr, int *cdef_left, uint16_t **linebuf, + unsigned char *prev_row_cdef) { + const CommonModeInfoParams *const mi_params = &cm->mi_params; + const int mbmi_cdef_strength = + mi_params + ->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + + MI_SIZE_64X64 * fbc] + ->cdef_strength; + const int num_planes = av1_num_planes(cm); + + if (mi_params->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + + MI_SIZE_64X64 * fbc] == NULL || + mbmi_cdef_strength == -1) { + *cdef_left = 0; + return 0; + } + for (uint8_t plane = 0; plane < num_planes; plane++) { + cdef_init_fb_col(xd, &cm->cdef_info, fb_info, mbmi_cdef_strength, fbc, fbr, + plane); + if (fb_info->is_zero_level || + (fb_info->cdef_count = av1_cdef_compute_sb_list( + mi_params, fbr * MI_SIZE_64X64, fbc * MI_SIZE_64X64, + fb_info->dlist, BLOCK_64X64)) == 0) { + *cdef_left = 0; + return 0; + } + cdef_prepare_fb(cm, fb_info, linebuf, cdef_left, fbc, fbr, plane, + prev_row_cdef); + cdef_filter_fb(fb_info, plane, cm->seq_params.use_highbitdepth); + } + *cdef_left = 1; + return 1; +} + +static INLINE void cdef_init_fb_row(CdefBlockInfo *fb_info, int mi_rows, + int fbr) { + const int nvfb = (mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; + + // for the current filter block, it's top left corner mi structure (mi_tl) + // is first accessed to check whether the top and left boundaries are + // frame boundaries. Then bottom-left and top-right mi structures are + // accessed to check whether the bottom and right boundaries + // (respectively) are frame boundaries. + // + // Note that we can't just check the bottom-right mi structure - eg. if + // we're at the right-hand edge of the frame but not the bottom, then + // the bottom-right mi is NULL but the bottom-left is not. + fb_info->frame_boundary[TOP] = (MI_SIZE_64X64 * fbr == 0) ? 1 : 0; + if (fbr != nvfb - 1) + fb_info->frame_boundary[BOTTOM] = + (MI_SIZE_64X64 * (fbr + 1) == mi_rows) ? 1 : 0; + else + fb_info->frame_boundary[BOTTOM] = 1; +} + +static void cdef_fb_row(AV1_COMMON *cm, MACROBLOCKD *xd, CdefBlockInfo *fb_info, + uint16_t **linebuf, int fbr, + unsigned char *curr_row_cdef, + unsigned char *prev_row_cdef) { + int cdef_left = 1; + const int nhfb = (cm->mi_params.mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; + + cdef_init_fb_row(fb_info, cm->mi_params.mi_rows, fbr); + for (int fbc = 0; fbc < nhfb; fbc++) { + fb_info->frame_boundary[LEFT] = (MI_SIZE_64X64 * fbc == 0) ? 1 : 0; + if (fbc != nhfb - 1) + fb_info->frame_boundary[RIGHT] = + (MI_SIZE_64X64 * (fbc + 1) == cm->mi_params.mi_cols) ? 1 : 0; + else + fb_info->frame_boundary[RIGHT] = 1; + curr_row_cdef[fbc] = cdef_fb_col(cm, xd, fb_info, fbc, fbr, &cdef_left, + linebuf, prev_row_cdef); + } +} + +// Initialize the frame-level CDEF parameters. +// Inputs: +// frame: Pointer to input frame buffer. +// cm: Pointer to common structure. +// xd: Pointer to common current coding block structure. +// fb_info: Pointer to the CDEF block-level parameter structure. +// src: Intermediate input buffer for CDEF. +// colbuf: Left feedback buffer for CDEF. +// linebuf: Top feedback buffer for CDEF. +// Returns: +// Nothing will be returned. +static void cdef_prepare_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, + MACROBLOCKD *xd, CdefBlockInfo *fb_info, + uint16_t *src, uint16_t **colbuf, + uint16_t **linebuf) { + const int num_planes = av1_num_planes(cm); + const int stride = (cm->mi_params.mi_cols << MI_SIZE_LOG2) + 2 * CDEF_HBORDER; av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0, num_planes); + + for (uint8_t plane = 0; plane < num_planes; plane++) { + linebuf[plane] = aom_malloc(sizeof(*linebuf) * CDEF_VBORDER * stride); + const int mi_high_l2 = MI_SIZE_LOG2 - xd->plane[plane].subsampling_y; + const int block_height = (MI_SIZE_64X64 << mi_high_l2) + 2 * CDEF_VBORDER; + colbuf[plane] = aom_malloc( + sizeof(*colbuf) * + ((CDEF_BLOCKSIZE << (MI_SIZE_LOG2 - xd->plane[plane].subsampling_y)) + + 2 * CDEF_VBORDER) * + CDEF_HBORDER); + fill_rect(colbuf[plane], CDEF_HBORDER, block_height, CDEF_HBORDER, + CDEF_VERY_LARGE); + fb_info->colbuf[plane] = colbuf[plane]; + } + + fb_info->src = src; + fb_info->damping = cm->cdef_info.cdef_damping; + fb_info->coeff_shift = AOMMAX(cm->seq_params.bit_depth - 8, 0); + memset(fb_info->dir, 0, sizeof(fb_info->dir)); + memset(fb_info->var, 0, sizeof(fb_info->var)); +} + +static void cdef_free(unsigned char *row_cdef, uint16_t **colbuf, + uint16_t **linebuf, const int num_planes) { + aom_free(row_cdef); + for (uint8_t plane = 0; plane < num_planes; plane++) { + aom_free(colbuf[plane]); + aom_free(linebuf[plane]); + } +} + +// Perform CDEF on input frame. +// Inputs: +// frame: Pointer to input frame buffer. +// cm: Pointer to common structure. +// xd: Pointer to common current coding block structure. +// Returns: +// Nothing will be returned. +void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, + MACROBLOCKD *xd) { + DECLARE_ALIGNED(16, uint16_t, src[CDEF_INBUF_SIZE]); + uint16_t *colbuf[MAX_MB_PLANE] = { NULL }; + uint16_t *linebuf[MAX_MB_PLANE] = { NULL }; + CdefBlockInfo fb_info; + unsigned char *row_cdef, *prev_row_cdef, *curr_row_cdef; + const int num_planes = av1_num_planes(cm); + const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; + const int nhfb = (cm->mi_params.mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; + row_cdef = aom_malloc(sizeof(*row_cdef) * (nhfb + 2) * 2); memset(row_cdef, 1, sizeof(*row_cdef) * (nhfb + 2) * 2); prev_row_cdef = row_cdef + 1; curr_row_cdef = prev_row_cdef + nhfb + 2; - for (int pli = 0; pli < num_planes; pli++) { - xdec[pli] = xd->plane[pli].subsampling_x; - ydec[pli] = xd->plane[pli].subsampling_y; - mi_wide_l2[pli] = MI_SIZE_LOG2 - xd->plane[pli].subsampling_x; - mi_high_l2[pli] = MI_SIZE_LOG2 - xd->plane[pli].subsampling_y; - } - const int stride = (mi_params->mi_cols << MI_SIZE_LOG2) + 2 * CDEF_HBORDER; - for (int pli = 0; pli < num_planes; pli++) { - linebuf[pli] = aom_malloc(sizeof(*linebuf) * CDEF_VBORDER * stride); - colbuf[pli] = - aom_malloc(sizeof(*colbuf) * - ((CDEF_BLOCKSIZE << mi_high_l2[pli]) + 2 * CDEF_VBORDER) * - CDEF_HBORDER); - } + cdef_prepare_frame(frame, cm, xd, &fb_info, src, colbuf, linebuf); + for (int fbr = 0; fbr < nvfb; fbr++) { - for (int pli = 0; pli < num_planes; pli++) { - const int block_height = - (MI_SIZE_64X64 << mi_high_l2[pli]) + 2 * CDEF_VBORDER; - fill_rect(colbuf[pli], CDEF_HBORDER, block_height, CDEF_HBORDER, - CDEF_VERY_LARGE); - } - int cdef_left = 1; - for (int fbc = 0; fbc < nhfb; fbc++) { - int level, sec_strength; - int uv_level, uv_sec_strength; - int nhb, nvb; - int cstart = 0; - curr_row_cdef[fbc] = 0; - if (mi_params->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + - MI_SIZE_64X64 * fbc] == NULL || - mi_params - ->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + - MI_SIZE_64X64 * fbc] - ->cdef_strength == -1) { - cdef_left = 0; - continue; - } - if (!cdef_left) cstart = -CDEF_HBORDER; - nhb = AOMMIN(MI_SIZE_64X64, mi_params->mi_cols - MI_SIZE_64X64 * fbc); - nvb = AOMMIN(MI_SIZE_64X64, mi_params->mi_rows - MI_SIZE_64X64 * fbr); - int frame_top, frame_left, frame_bottom, frame_right; - - int mi_row = MI_SIZE_64X64 * fbr; - int mi_col = MI_SIZE_64X64 * fbc; - // for the current filter block, it's top left corner mi structure (mi_tl) - // is first accessed to check whether the top and left boundaries are - // frame boundaries. Then bottom-left and top-right mi structures are - // accessed to check whether the bottom and right boundaries - // (respectively) are frame boundaries. - // - // Note that we can't just check the bottom-right mi structure - eg. if - // we're at the right-hand edge of the frame but not the bottom, then - // the bottom-right mi is NULL but the bottom-left is not. - frame_top = (mi_row == 0) ? 1 : 0; - frame_left = (mi_col == 0) ? 1 : 0; - - if (fbr != nvfb - 1) - frame_bottom = (mi_row + MI_SIZE_64X64 == mi_params->mi_rows) ? 1 : 0; - else - frame_bottom = 1; - - if (fbc != nhfb - 1) - frame_right = (mi_col + MI_SIZE_64X64 == mi_params->mi_cols) ? 1 : 0; - else - frame_right = 1; - - const int mbmi_cdef_strength = - mi_params - ->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + - MI_SIZE_64X64 * fbc] - ->cdef_strength; - level = - cdef_info->cdef_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; - sec_strength = - cdef_info->cdef_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; - sec_strength += sec_strength == 3; - uv_level = - cdef_info->cdef_uv_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; - uv_sec_strength = - cdef_info->cdef_uv_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; - uv_sec_strength += uv_sec_strength == 3; - if ((level == 0 && sec_strength == 0 && uv_level == 0 && - uv_sec_strength == 0) || - (cdef_count = av1_cdef_compute_sb_list(mi_params, fbr * MI_SIZE_64X64, - fbc * MI_SIZE_64X64, dlist, - BLOCK_64X64)) == 0) { - cdef_left = 0; - continue; - } - - curr_row_cdef[fbc] = 1; - for (int pli = 0; pli < num_planes; pli++) { - int coffset; - int rend, cend; - int damping = cdef_info->cdef_damping; - int hsize = nhb << mi_wide_l2[pli]; - int vsize = nvb << mi_high_l2[pli]; - - if (pli) { - level = uv_level; - sec_strength = uv_sec_strength; - } - - if (fbc == nhfb - 1) - cend = hsize; - else - cend = hsize + CDEF_HBORDER; - - if (fbr == nvfb - 1) - rend = vsize; - else - rend = vsize + CDEF_VBORDER; - - coffset = fbc * MI_SIZE_64X64 << mi_wide_l2[pli]; - if (fbc == nhfb - 1) { - /* On the last superblock column, fill in the right border with - CDEF_VERY_LARGE to avoid filtering with the outside. */ - fill_rect(&src[cend + CDEF_HBORDER], CDEF_BSTRIDE, - rend + CDEF_VBORDER, hsize + CDEF_HBORDER - cend, - CDEF_VERY_LARGE); - } - if (fbr == nvfb - 1) { - /* On the last superblock row, fill in the bottom border with - CDEF_VERY_LARGE to avoid filtering with the outside. */ - fill_rect(&src[(rend + CDEF_VBORDER) * CDEF_BSTRIDE], CDEF_BSTRIDE, - CDEF_VBORDER, hsize + 2 * CDEF_HBORDER, CDEF_VERY_LARGE); - } - /* Copy in the pixels we need from the current superblock for - deringing.*/ - copy_sb8_16(cm, - &src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER + cstart], - CDEF_BSTRIDE, xd->plane[pli].dst.buf, - (MI_SIZE_64X64 << mi_high_l2[pli]) * fbr, coffset + cstart, - xd->plane[pli].dst.stride, rend, cend - cstart); - if (!prev_row_cdef[fbc]) { - copy_sb8_16(cm, &src[CDEF_HBORDER], CDEF_BSTRIDE, - xd->plane[pli].dst.buf, - (MI_SIZE_64X64 << mi_high_l2[pli]) * fbr - CDEF_VBORDER, - coffset, xd->plane[pli].dst.stride, CDEF_VBORDER, hsize); - } else if (fbr > 0) { - copy_rect(&src[CDEF_HBORDER], CDEF_BSTRIDE, &linebuf[pli][coffset], - stride, CDEF_VBORDER, hsize); - } else { - fill_rect(&src[CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, hsize, - CDEF_VERY_LARGE); - } - if (!prev_row_cdef[fbc - 1]) { - copy_sb8_16(cm, src, CDEF_BSTRIDE, xd->plane[pli].dst.buf, - (MI_SIZE_64X64 << mi_high_l2[pli]) * fbr - CDEF_VBORDER, - coffset - CDEF_HBORDER, xd->plane[pli].dst.stride, - CDEF_VBORDER, CDEF_HBORDER); - } else if (fbr > 0 && fbc > 0) { - copy_rect(src, CDEF_BSTRIDE, &linebuf[pli][coffset - CDEF_HBORDER], - stride, CDEF_VBORDER, CDEF_HBORDER); - } else { - fill_rect(src, CDEF_BSTRIDE, CDEF_VBORDER, CDEF_HBORDER, - CDEF_VERY_LARGE); - } - if (!prev_row_cdef[fbc + 1]) { - copy_sb8_16(cm, &src[CDEF_HBORDER + (nhb << mi_wide_l2[pli])], - CDEF_BSTRIDE, xd->plane[pli].dst.buf, - (MI_SIZE_64X64 << mi_high_l2[pli]) * fbr - CDEF_VBORDER, - coffset + hsize, xd->plane[pli].dst.stride, CDEF_VBORDER, - CDEF_HBORDER); - } else if (fbr > 0 && fbc < nhfb - 1) { - copy_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, - &linebuf[pli][coffset + hsize], stride, CDEF_VBORDER, - CDEF_HBORDER); - } else { - fill_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, - CDEF_HBORDER, CDEF_VERY_LARGE); - } - if (cdef_left) { - /* If we deringed the superblock on the left then we need to copy in - saved pixels. */ - copy_rect(src, CDEF_BSTRIDE, colbuf[pli], CDEF_HBORDER, - rend + CDEF_VBORDER, CDEF_HBORDER); - } - /* Saving pixels in case we need to dering the superblock on the - right. */ - copy_rect(colbuf[pli], CDEF_HBORDER, src + hsize, CDEF_BSTRIDE, - rend + CDEF_VBORDER, CDEF_HBORDER); - copy_sb8_16( - cm, &linebuf[pli][coffset], stride, xd->plane[pli].dst.buf, - (MI_SIZE_64X64 << mi_high_l2[pli]) * (fbr + 1) - CDEF_VBORDER, - coffset, xd->plane[pli].dst.stride, CDEF_VBORDER, hsize); - - if (frame_top) { - fill_rect(src, CDEF_BSTRIDE, CDEF_VBORDER, hsize + 2 * CDEF_HBORDER, - CDEF_VERY_LARGE); - } - if (frame_left) { - fill_rect(src, CDEF_BSTRIDE, vsize + 2 * CDEF_VBORDER, CDEF_HBORDER, - CDEF_VERY_LARGE); - } - if (frame_bottom) { - fill_rect(&src[(vsize + CDEF_VBORDER) * CDEF_BSTRIDE], CDEF_BSTRIDE, - CDEF_VBORDER, hsize + 2 * CDEF_HBORDER, CDEF_VERY_LARGE); - } - if (frame_right) { - fill_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, - vsize + 2 * CDEF_VBORDER, CDEF_HBORDER, CDEF_VERY_LARGE); - } - - if (cm->seq_params.use_highbitdepth) { - av1_cdef_filter_fb( - NULL, - &CONVERT_TO_SHORTPTR( - xd->plane[pli] - .dst.buf)[xd->plane[pli].dst.stride * - (MI_SIZE_64X64 * fbr << mi_high_l2[pli]) + - (fbc * MI_SIZE_64X64 << mi_wide_l2[pli])], - xd->plane[pli].dst.stride, - &src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], xdec[pli], - ydec[pli], dir, NULL, var, pli, dlist, cdef_count, level, - sec_strength, damping, coeff_shift); - } else { - av1_cdef_filter_fb( - &xd->plane[pli] - .dst.buf[xd->plane[pli].dst.stride * - (MI_SIZE_64X64 * fbr << mi_high_l2[pli]) + - (fbc * MI_SIZE_64X64 << mi_wide_l2[pli])], - NULL, xd->plane[pli].dst.stride, - &src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], xdec[pli], - ydec[pli], dir, NULL, var, pli, dlist, cdef_count, level, - sec_strength, damping, coeff_shift); - } - } - cdef_left = 1; - } - { - unsigned char *tmp = prev_row_cdef; - prev_row_cdef = curr_row_cdef; - curr_row_cdef = tmp; - } + unsigned char *tmp; + cdef_fb_row(cm, xd, &fb_info, linebuf, fbr, curr_row_cdef, prev_row_cdef); + tmp = prev_row_cdef; + prev_row_cdef = curr_row_cdef; + curr_row_cdef = tmp; } - aom_free(row_cdef); - for (int pli = 0; pli < num_planes; pli++) { - aom_free(linebuf[pli]); - aom_free(colbuf[pli]); - } + cdef_free(row_cdef, colbuf, linebuf, num_planes); }
diff --git a/av1/common/cdef_block.h b/av1/common/cdef_block.h index 6b0ae0a..574df2d 100644 --- a/av1/common/cdef_block.h +++ b/av1/common/cdef_block.h
@@ -19,8 +19,8 @@ #define CDEF_NBLOCKS ((1 << MAX_SB_SIZE_LOG2) / 8) #define CDEF_SB_SHIFT (MAX_SB_SIZE_LOG2 - CDEF_BLOCKSIZE_LOG2) -/* We need to buffer three vertical lines. */ -#define CDEF_VBORDER (3) +/* We need to buffer two vertical lines. */ +#define CDEF_VBORDER (2) /* We only need to buffer three horizontal pixels too, but let's align to 16 bytes (8 x 16 bits) to make vectorization easier. */ #define CDEF_HBORDER (8)
diff --git a/av1/common/quant_common.h b/av1/common/quant_common.h index 9c30204..8f36eb1 100644 --- a/av1/common/quant_common.h +++ b/av1/common/quant_common.h
@@ -36,6 +36,7 @@ #define DEFAULT_QM_V 12 #define DEFAULT_QM_FIRST 5 #define DEFAULT_QM_LAST 9 +#define LOSSLESS_Q_STEP 4 // this should equal to dc/ac_qlookup_QTX[0] struct AV1Common; struct CommonQuantParams;
diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h index 333802f..907db5d 100644 --- a/av1/common/reconintra.h +++ b/av1/common/reconintra.h
@@ -49,6 +49,10 @@ return mode >= V_PRED && mode <= D67_PRED; } +static INLINE int av1_is_diagonal_mode(PREDICTION_MODE mode) { + return mode >= D45_PRED && mode <= D67_PRED; +} + static INLINE int av1_use_angle_delta(BLOCK_SIZE bsize) { return bsize >= BLOCK_8X8; }
diff --git a/av1/common/resize.c b/av1/common/resize.c index 725b94f..0cfb5a2 100644 --- a/av1/common/resize.c +++ b/av1/common/resize.c
@@ -1476,7 +1476,7 @@ frame_to_show, cm->superres_upscaled_width, cm->superres_upscaled_height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, - AOM_BORDER_IN_PIXELS, byte_alignment, fb, cb, cb_priv)) { + AOM_BORDER_IN_PIXELS, byte_alignment, fb, cb, cb_priv, 0)) { unlock_buffer_pool(pool); aom_internal_error( &cm->error, AOM_CODEC_MEM_ERROR,
diff --git a/av1/common/restoration.c b/av1/common/restoration.c index a0f37ad..41d0e22 100644 --- a/av1/common/restoration.c +++ b/av1/common/restoration.c
@@ -1117,7 +1117,7 @@ if (aom_realloc_frame_buffer( lr_ctxt->dst, frame_width, frame_height, seq_params->subsampling_x, seq_params->subsampling_y, highbd, AOM_RESTORATION_FRAME_BORDER, - cm->features.byte_alignment, NULL, NULL, NULL) < 0) + cm->features.byte_alignment, NULL, NULL, NULL, 0) < 0) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate restoration dst buffer");
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c index f7eb103..58629e0 100644 --- a/av1/decoder/decodeframe.c +++ b/av1/decoder/decodeframe.c
@@ -304,16 +304,18 @@ const int bsw = tx_size_wide_unit[sub_txs]; const int bsh = tx_size_high_unit[sub_txs]; const int sub_step = bsw * bsh; + const int row_end = + AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); + const int col_end = + AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); assert(bsw > 0 && bsh > 0); - for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { - for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { - const int offsetr = blk_row + row; + for (int row = 0; row < row_end; row += bsh) { + const int offsetr = blk_row + row; + for (int col = 0; col < col_end; col += bsw) { const int offsetc = blk_col + col; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; - decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, offsetr, offsetc, block, sub_txs, eob_total); block += sub_step; @@ -1975,7 +1977,8 @@ &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, AOM_DEC_BORDER_IN_PIXELS, cm->features.byte_alignment, - &cm->cur_frame->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { + &cm->cur_frame->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv, + 0)) { unlock_buffer_pool(pool); aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate frame buffer"); @@ -2800,6 +2803,10 @@ if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) { decoder_alloc_tile_data(pbi, n_tiles); } + if (pbi->dcb.xd.seg_mask == NULL) + CHECK_MEM_ERROR(cm, pbi->dcb.xd.seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * sizeof(*pbi->dcb.xd.seg_mask))); #if CONFIG_ACCOUNTING if (pbi->acct_enabled) { aom_accounting_reset(&pbi->accounting); @@ -3356,6 +3363,8 @@ aom_free(thread_data->tmp_conv_dst); thread_data->tmp_conv_dst = NULL; + aom_free(thread_data->seg_mask); + thread_data->seg_mask = NULL; for (int i = 0; i < 2; ++i) { aom_free(thread_data->tmp_obmc_bufs[i]); thread_data->tmp_obmc_bufs[i] = NULL; @@ -3388,6 +3397,10 @@ CHECK_MEM_ERROR(cm, thread_data->tmp_conv_dst, aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE * sizeof(*thread_data->tmp_conv_dst))); + CHECK_MEM_ERROR(cm, thread_data->seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * sizeof(*thread_data->seg_mask))); + for (int i = 0; i < 2; ++i) { CHECK_MEM_ERROR( cm, thread_data->tmp_obmc_bufs[i], @@ -3410,6 +3423,8 @@ thread_data->td->dcb.mc_buf[0] = thread_data->td->mc_buf[0]; thread_data->td->dcb.mc_buf[1] = thread_data->td->mc_buf[1]; thread_data->td->dcb.xd.tmp_conv_dst = thread_data->td->tmp_conv_dst; + if (worker_idx) + thread_data->td->dcb.xd.seg_mask = thread_data->td->seg_mask; for (int j = 0; j < 2; ++j) { thread_data->td->dcb.xd.tmp_obmc_bufs[j] = thread_data->td->tmp_obmc_bufs[j]; @@ -3589,6 +3604,10 @@ if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) { decoder_alloc_tile_data(pbi, n_tiles); } + if (pbi->dcb.xd.seg_mask == NULL) + CHECK_MEM_ERROR(cm, pbi->dcb.xd.seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * sizeof(*pbi->dcb.xd.seg_mask))); for (int row = 0; row < tile_rows; row++) { for (int col = 0; col < tile_cols; col++) { @@ -3775,6 +3794,10 @@ } decoder_alloc_tile_data(pbi, n_tiles); } + if (pbi->dcb.xd.seg_mask == NULL) + CHECK_MEM_ERROR(cm, pbi->dcb.xd.seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * sizeof(*pbi->dcb.xd.seg_mask))); for (int row = 0; row < tile_rows; row++) { for (int col = 0; col < tile_cols; col++) { @@ -4756,7 +4779,7 @@ seq_params->max_frame_height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS, features->byte_alignment, - &buf->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { + &buf->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv, 0)) { decrease_ref_count(buf, pool); unlock_buffer_pool(pool); aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
diff --git a/av1/decoder/decoder.c b/av1/decoder/decoder.c index 1680734..48d0e56 100644 --- a/av1/decoder/decoder.c +++ b/av1/decoder/decoder.c
@@ -194,6 +194,7 @@ } aom_free(pbi->thread_data); } + aom_free(pbi->dcb.xd.seg_mask); for (i = 0; i < pbi->num_workers; ++i) { AVxWorker *const worker = &pbi->tile_workers[i];
diff --git a/av1/decoder/decoder.h b/av1/decoder/decoder.h index b20e9c1..61147f9 100644 --- a/av1/decoder/decoder.h +++ b/av1/decoder/decoder.h
@@ -112,6 +112,8 @@ // Motion compensation buffer used to get a prediction buffer with extended // borders. One buffer for each of the two possible references. uint8_t *mc_buf[2]; + // Mask for this block used for compound prediction. + uint8_t *seg_mask; // Allocated size of 'mc_buf'. int32_t mc_buf_size; // If true, the pointers in 'mc_buf' were converted from highbd pointers.
diff --git a/av1/encoder/aq_cyclicrefresh.c b/av1/encoder/aq_cyclicrefresh.c index 3308ffe..c7abe43 100644 --- a/av1/encoder/aq_cyclicrefresh.c +++ b/av1/encoder/aq_cyclicrefresh.c
@@ -16,6 +16,7 @@ #include "av1/encoder/aq_cyclicrefresh.h" #include "av1/encoder/ratectrl.h" #include "av1/encoder/segmentation.h" +#include "av1/encoder/tokenize.h" #include "aom_dsp/aom_dsp_common.h" #include "aom_ports/system_state.h" @@ -146,11 +147,13 @@ return bits_per_mb; } -void av1_cyclic_refresh_update_segment(const AV1_COMP *cpi, - MB_MODE_INFO *const mbmi, int mi_row, - int mi_col, BLOCK_SIZE bsize, - int64_t rate, int64_t dist, int skip) { +void av1_cyclic_refresh_update_segment(const AV1_COMP *cpi, MACROBLOCK *const x, + int mi_row, int mi_col, BLOCK_SIZE bsize, + int64_t rate, int64_t dist, int skip, + RUN_TYPE dry_run) { const AV1_COMMON *const cm = &cpi->common; + MACROBLOCKD *const xd = &x->e_mbd; + MB_MODE_INFO *const mbmi = xd->mi[0]; CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; const int bw = mi_size_wide[bsize]; const int bh = mi_size_high[bsize]; @@ -189,12 +192,37 @@ // Update entries in the cyclic refresh map with new_map_value, and // copy mbmi->segment_id into global segmentation map. // 8x8 is smallest coding block size for non-key frames. - for (int y = 0; y < ymis; y += 2) - for (int x = 0; x < xmis; x += 2) { - int map_offset = block_index + y * cm->mi_params.mi_cols + x; + const int sh = bw << 1; + for (int mi_y = 0; mi_y < ymis; mi_y += 2) { + for (int mi_x = 0; mi_x < xmis; mi_x += 2) { + int map_offset = block_index + mi_y * cm->mi_params.mi_cols + mi_x; cr->map[map_offset] = new_map_value; cpi->enc_seg.map[map_offset] = mbmi->segment_id; } + // Accumulate cyclic refresh update counters. + if (!dry_run && !frame_is_intra_only(cm)) { + if (cyclic_refresh_segment_id(mbmi->segment_id) == CR_SEGMENT_ID_BOOST1) + x->actual_num_seg1_blocks += sh; + else if (cyclic_refresh_segment_id(mbmi->segment_id) == + CR_SEGMENT_ID_BOOST2) + x->actual_num_seg2_blocks += sh; + } + } +} + +// Initializes counters used for cyclic refresh. +void av1_init_cyclic_refresh_counters(MACROBLOCK *const x) { + x->actual_num_seg1_blocks = 0; + x->actual_num_seg2_blocks = 0; + x->cnt_zeromv = 0; +} + +// Accumulate cyclic refresh counters. +void av1_accumulate_cyclic_refresh_counters( + CYCLIC_REFRESH *const cyclic_refresh, const MACROBLOCK *const x) { + cyclic_refresh->actual_num_seg1_blocks += x->actual_num_seg1_blocks; + cyclic_refresh->actual_num_seg2_blocks += x->actual_num_seg2_blocks; + cyclic_refresh->cnt_zeromv += x->cnt_zeromv; } void av1_cyclic_refresh_postencode(AV1_COMP *const cpi) { @@ -203,41 +231,15 @@ CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; RATE_CONTROL *const rc = &cpi->rc; SVC *const svc = &cpi->svc; - unsigned char *const seg_map = cpi->enc_seg.map; - int cnt_zeromv = 0; - cr->actual_num_seg1_blocks = 0; - cr->actual_num_seg2_blocks = 0; - // 8X8 blocks are smallest partition used on delta frames. - for (int mi_row = 0; mi_row < mi_params->mi_rows; mi_row += 2) { - MB_MODE_INFO **mi = mi_params->mi_grid_base + mi_row * mi_params->mi_stride; - int sh = 2; - for (int mi_col = 0; mi_col < mi_params->mi_cols; mi_col += sh) { - sh = mi_size_wide[mi[0]->bsize]; - MV mv = mi[0]->mv[0].as_mv; - if (cm->seg.enabled) { - int map_index = mi_row * mi_params->mi_cols + mi_col; - if (cyclic_refresh_segment_id(seg_map[map_index]) == - CR_SEGMENT_ID_BOOST1) - cr->actual_num_seg1_blocks += sh << 1; - else if (cyclic_refresh_segment_id(seg_map[map_index]) == - CR_SEGMENT_ID_BOOST2) - cr->actual_num_seg2_blocks += sh << 1; - } - // Accumulate low_content_frame. - if (is_inter_block(mi[0]) && mi[0]->ref_frame[0] == LAST_FRAME && - abs(mv.row) < 8 && abs(mv.col) < 8) - cnt_zeromv += sh << 1; - if (mi_col + sh < mi_params->mi_cols) { - mi += sh; - } - } - } - cnt_zeromv = 100 * cnt_zeromv / (mi_params->mi_rows * mi_params->mi_cols); + const int avg_cnt_zeromv = + 100 * cr->cnt_zeromv / (mi_params->mi_rows * mi_params->mi_cols); + if (!cpi->use_svc || (cpi->use_svc && !cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame && cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)) { - rc->avg_frame_low_motion = (3 * rc->avg_frame_low_motion + cnt_zeromv) / 4; + rc->avg_frame_low_motion = + (3 * rc->avg_frame_low_motion + avg_cnt_zeromv) / 4; // For SVC: set avg_frame_low_motion (only computed on top spatial layer) // to all lower spatial layers. if (cpi->use_svc &&
diff --git a/av1/encoder/aq_cyclicrefresh.h b/av1/encoder/aq_cyclicrefresh.h index 23d1f16..97bd6f2 100644 --- a/av1/encoder/aq_cyclicrefresh.h +++ b/av1/encoder/aq_cyclicrefresh.h
@@ -13,6 +13,8 @@ #define AOM_AV1_ENCODER_AQ_CYCLICREFRESH_H_ #include "av1/common/blockd.h" +#include "av1/encoder/block.h" +#include "av1/encoder/tokenize.h" #ifdef __cplusplus extern "C" { @@ -70,6 +72,10 @@ */ int rdmult; /*! + * Count of zero motion vectors + */ + int cnt_zeromv; + /*! * Cyclic refresh map. */ int8_t *map; @@ -166,21 +172,59 @@ * \callergraph * * \param[in] cpi Top level encoder structure - * \param[in] mbmi MB_MODE_INFO pointer for mi block + * \param[in] x Pointer to MACROBLOCK structure * \param[in] mi_row Row coordinate of the block in a step size of MI_SIZE * \param[in] mi_col Col coordinate of the block in a step size of MI_SIZE * \param[in] bsize Block size * \param[in] rate Projected block rate from pickmode * \param[in] dist Projected block dist from pickmode - * \param[in] skip Skip flag set from picmode + * \param[in] skip Skip flag set from picmode + * \param[in] dry_run A code indicating whether it is part of the final + * pass for reconstructing the superblock * * \return Update the \c mbmi->segment_id, the \c cpi->cyclic_refresh and * the \c cm->cpi->enc_seg.map. */ void av1_cyclic_refresh_update_segment(const struct AV1_COMP *cpi, - MB_MODE_INFO *const mbmi, int mi_row, + MACROBLOCK *const x, int mi_row, int mi_col, BLOCK_SIZE bsize, - int64_t rate, int64_t dist, int skip); + int64_t rate, int64_t dist, int skip, + RUN_TYPE dry_run); + +/*!\brief Initialize counters used for cyclic refresh. + * + * Initializes cyclic refresh counters cnt_zeromv, actual_num_seg1_blocks and + * actual_num_seg2_blocks. + * + * \ingroup cyclic_refresh + * \callgraph + * \callergraph + * + * \param[in] x Pointer to MACROBLOCK structure + * + * \return Update the \c x->cnt_zeromv, the \c x->actual_num_seg1_blocks and + * the \c x->actual_num_seg1_blocks. + */ +void av1_init_cyclic_refresh_counters(MACROBLOCK *const x); + +/*!\brief Accumulate cyclic refresh counters. + * + * Accumulates cyclic refresh counters cnt_zeromv, actual_num_seg1_blocks and + * actual_num_seg2_blocks from MACROBLOCK strcture to CYCLIC_REFRESH strcture. + * + * \ingroup cyclic_refresh + * \callgraph + * \callergraph + * + * \param[in] cyclic_refresh Pointer to CYCLIC_REFRESH structure + * \param[in] x Pointer to MACROBLOCK structure + * + * \return Update the \c cyclic_refresh->cnt_zeromv, the \c + * cyclic_refresh->actual_num_seg1_blocks and the \c + * cyclic_refresh->actual_num_seg1_blocks. + */ +void av1_accumulate_cyclic_refresh_counters( + CYCLIC_REFRESH *const cyclic_refresh, const MACROBLOCK *const x); /*!\brief Update stats after encoding frame. *
diff --git a/av1/encoder/arm/neon/picksrt_neon.c b/av1/encoder/arm/neon/picksrt_neon.c index 34595e8..d69c441 100644 --- a/av1/encoder/arm/neon/picksrt_neon.c +++ b/av1/encoder/arm/neon/picksrt_neon.c
@@ -16,7 +16,6 @@ #include "aom_mem/aom_mem.h" #include "aom_ports/mem.h" #include "av1/common/restoration.h" -#include "common/tools_common.h" #include "config/aom_config.h" #include "config/aom_dsp_rtcd.h"
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c index ad41af2..ccdad53 100644 --- a/av1/encoder/bitstream.c +++ b/av1/encoder/bitstream.c
@@ -185,12 +185,13 @@ } assert(bsw > 0 && bsh > 0); - for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) + for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { + const int offsetr = blk_row + row; for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { - int offsetr = blk_row + row; - int offsetc = blk_col + col; + const int offsetc = blk_col + col; write_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, offsetr, offsetc, w); } + } } } @@ -349,7 +350,8 @@ ++p; --num; for (int i = 0; i < num; ++i) { - assert((p->color_ctx >= 0) && (p->color_ctx < CDF_SIZE(PALETTE_COLORS))); + assert((p->color_ctx >= 0) && + (p->color_ctx < PALETTE_COLOR_INDEX_CONTEXTS)); aom_cdf_prob *color_map_cdf = map_pb_cdf[palette_size_idx][p->color_ctx]; aom_write_symbol(w, p->token, color_map_cdf, n); ++p; @@ -387,14 +389,17 @@ const int bsw = tx_size_wide_unit[sub_txs]; const int bsh = tx_size_high_unit[sub_txs]; const int step = bsh * bsw; + const int row_end = + AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); + const int col_end = + AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); assert(bsw > 0 && bsh > 0); - for (int r = 0; r < tx_size_high_unit[tx_size]; r += bsh) { - for (int c = 0; c < tx_size_wide_unit[tx_size]; c += bsw) { - const int offsetr = blk_row + r; + for (int r = 0; r < row_end; r += bsh) { + const int offsetr = blk_row + r; + for (int c = 0; c < col_end; c += bsw) { const int offsetc = blk_col + c; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; pack_txb_tokens(w, cm, x, tp, tok_end, xd, mbmi, plane, plane_bsize, bit_depth, block, offsetr, offsetc, sub_txs, token_stats); @@ -3463,191 +3468,231 @@ extern void av1_print_uncompressed_frame_header(const uint8_t *data, int size, const char *filename); -static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, - struct aom_write_bit_buffer *saved_wb, - uint8_t obu_extension_header, - const FrameHeaderInfo *fh_info, - int *const largest_tile_id) { +typedef struct { + uint32_t tg_hdr_size; + uint32_t frame_header_size; +} LargeTileFrameOBU; + +// Initialize OBU header for large scale tile case. +static uint32_t init_large_scale_tile_obu_header( + AV1_COMP *const cpi, uint8_t **data, struct aom_write_bit_buffer *saved_wb, + LargeTileFrameOBU *lst_obu) { + AV1LevelParams *const level_params = &cpi->level_params; + CurrentFrame *const current_frame = &cpi->common.current_frame; + // For large_scale_tile case, we always have only one tile group, so it can + // be written as an OBU_FRAME. + const OBU_TYPE obu_type = OBU_FRAME; + lst_obu->tg_hdr_size = av1_write_obu_header(level_params, obu_type, 0, *data); + *data += lst_obu->tg_hdr_size; + + const uint32_t frame_header_size = + write_frame_header_obu(cpi, saved_wb, *data, 0); + *data += frame_header_size; + lst_obu->frame_header_size = frame_header_size; + // (yunqing) This test ensures the correctness of large scale tile coding. + if (cpi->oxcf.tile_cfg.enable_ext_tile_debug) { + char fn[20] = "./fh"; + fn[4] = current_frame->frame_number / 100 + '0'; + fn[5] = (current_frame->frame_number % 100) / 10 + '0'; + fn[6] = (current_frame->frame_number % 10) + '0'; + fn[7] = '\0'; + av1_print_uncompressed_frame_header(*data - frame_header_size, + frame_header_size, fn); + } + return frame_header_size; +} + +// Write total buffer size and related information into the OBU header for large +// scale tile case. +static void write_large_scale_tile_obu_size( + const CommonTileParams *const tiles, uint8_t *const dst, uint8_t *data, + struct aom_write_bit_buffer *saved_wb, LargeTileFrameOBU *const lst_obu, + int have_tiles, uint32_t *total_size, int max_tile_size, + int max_tile_col_size) { + int tile_size_bytes = 0; + int tile_col_size_bytes = 0; + if (have_tiles) { + *total_size = remux_tiles( + tiles, data, *total_size - lst_obu->frame_header_size, max_tile_size, + max_tile_col_size, &tile_size_bytes, &tile_col_size_bytes); + *total_size += lst_obu->frame_header_size; + } + + // In EXT_TILE case, only use 1 tile group. Follow the obu syntax, write + // current tile group size before tile data(include tile column header). + // Tile group size doesn't include the bytes storing tg size. + *total_size += lst_obu->tg_hdr_size; + const uint32_t obu_payload_size = *total_size - lst_obu->tg_hdr_size; + const size_t length_field_size = + obu_memmove(lst_obu->tg_hdr_size, obu_payload_size, dst); + if (av1_write_uleb_obu_size(lst_obu->tg_hdr_size, obu_payload_size, dst) != + AOM_CODEC_OK) + assert(0); + + *total_size += (uint32_t)length_field_size; + saved_wb->bit_buffer += length_field_size; + + // Now fill in the gaps in the uncompressed header. + if (have_tiles) { + assert(tile_col_size_bytes >= 1 && tile_col_size_bytes <= 4); + aom_wb_overwrite_literal(saved_wb, tile_col_size_bytes - 1, 2); + + assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); + aom_wb_overwrite_literal(saved_wb, tile_size_bytes - 1, 2); + } +} + +// Store information on each large scale tile in the OBU header. +static void write_large_scale_tile_obu( + AV1_COMP *const cpi, uint8_t *const dst, LargeTileFrameOBU *const lst_obu, + int *const largest_tile_id, uint32_t *total_size, const int have_tiles, + unsigned int *const max_tile_size, unsigned int *const max_tile_col_size) { AV1_COMMON *const cm = &cpi->common; const CommonTileParams *const tiles = &cm->tiles; - AV1LevelParams *const level_params = &cpi->level_params; - aom_writer mode_bc; - int tile_row, tile_col; - // Store the location and size of each tile's data in the bitstream: + TileBufferEnc tile_buffers[MAX_TILE_ROWS][MAX_TILE_COLS]; - uint32_t total_size = 0; const int tile_cols = tiles->cols; const int tile_rows = tiles->rows; unsigned int tile_size = 0; + + for (int tile_col = 0; tile_col < tile_cols; tile_col++) { + TileInfo tile_info; + const int is_last_col = (tile_col == tile_cols - 1); + const uint32_t col_offset = *total_size; + + av1_tile_set_col(&tile_info, cm, tile_col); + + // The last column does not have a column header + if (!is_last_col) *total_size += 4; + + for (int tile_row = 0; tile_row < tile_rows; tile_row++) { + TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; + const int data_offset = have_tiles ? 4 : 0; + const int tile_idx = tile_row * tile_cols + tile_col; + TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; + av1_tile_set_row(&tile_info, cm, tile_row); + aom_writer mode_bc; + + buf->data = dst + *total_size + lst_obu->tg_hdr_size; + + // Is CONFIG_EXT_TILE = 1, every tile in the row has a header, + // even for the last one, unless no tiling is used at all. + *total_size += data_offset; + cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; + mode_bc.allow_update_cdf = !tiles->large_scale; + mode_bc.allow_update_cdf = + mode_bc.allow_update_cdf && !cm->features.disable_cdf_update; + aom_start_encode(&mode_bc, buf->data + data_offset); + write_modes(cpi, &tile_info, &mode_bc, tile_row, tile_col); + aom_stop_encode(&mode_bc); + tile_size = mode_bc.pos; + buf->size = tile_size; + + // Record the maximum tile size we see, so we can compact headers later. + if (tile_size > *max_tile_size) { + *max_tile_size = tile_size; + *largest_tile_id = tile_cols * tile_row + tile_col; + } + + if (have_tiles) { + // tile header: size of this tile, or copy offset + uint32_t tile_header = tile_size - AV1_MIN_TILE_SIZE_BYTES; + const int tile_copy_mode = + ((AOMMAX(tiles->width, tiles->height) << MI_SIZE_LOG2) <= 256) ? 1 + : 0; + + // If tile_copy_mode = 1, check if this tile is a copy tile. + // Very low chances to have copy tiles on the key frames, so don't + // search on key frames to reduce unnecessary search. + if (cm->current_frame.frame_type != KEY_FRAME && tile_copy_mode) { + const int identical_tile_offset = + find_identical_tile(tile_row, tile_col, tile_buffers); + + // Indicate a copy-tile by setting the most significant bit. + // The row-offset to copy from is stored in the highest byte. + // remux_tiles will move these around later + if (identical_tile_offset > 0) { + tile_size = 0; + tile_header = identical_tile_offset | 0x80; + tile_header <<= 24; + } + } + + mem_put_le32(buf->data, tile_header); + } + + *total_size += tile_size; + } + if (!is_last_col) { + uint32_t col_size = *total_size - col_offset - 4; + mem_put_le32(dst + col_offset + lst_obu->tg_hdr_size, col_size); + + // Record the maximum tile column size we see. + *max_tile_col_size = AOMMAX(*max_tile_col_size, col_size); + } + } +} + +// Packs information in the obu header for large scale tiles. +static INLINE uint32_t pack_large_scale_tiles_in_tg_obus( + AV1_COMP *const cpi, uint8_t *const dst, + struct aom_write_bit_buffer *saved_wb, int *const largest_tile_id) { + AV1_COMMON *const cm = &cpi->common; + const CommonTileParams *const tiles = &cm->tiles; + uint32_t total_size = 0; unsigned int max_tile_size = 0; unsigned int max_tile_col_size = 0; - const int n_log2_tiles = tiles->log2_rows + tiles->log2_cols; + const int have_tiles = tiles->cols * tiles->rows > 1; + uint8_t *data = dst; + + LargeTileFrameOBU lst_obu; + + total_size += + init_large_scale_tile_obu_header(cpi, &data, saved_wb, &lst_obu); + + write_large_scale_tile_obu(cpi, dst, &lst_obu, largest_tile_id, &total_size, + have_tiles, &max_tile_size, &max_tile_col_size); + + write_large_scale_tile_obu_size(tiles, dst, data, saved_wb, &lst_obu, + have_tiles, &total_size, max_tile_size, + max_tile_col_size); + + return total_size; +} + +// Store information related to each default tile in the OBU header. +static void write_tile_obu( + AV1_COMP *const cpi, uint8_t *const dst, uint32_t *total_size, + struct aom_write_bit_buffer *saved_wb, uint8_t obu_extension_header, + const FrameHeaderInfo *fh_info, int *const largest_tile_id, + unsigned int *max_tile_size, uint32_t *const obu_header_size, + uint8_t **tile_data_start) { + AV1_COMMON *const cm = &cpi->common; + const CommonTileParams *const tiles = &cm->tiles; + AV1LevelParams *const level_params = &cpi->level_params; + TileBufferEnc tile_buffers[MAX_TILE_ROWS][MAX_TILE_COLS]; + const int tile_cols = tiles->cols; + const int tile_rows = tiles->rows; + unsigned int tile_size = 0; // Fixed size tile groups for the moment const int num_tg_hdrs = cpi->num_tg; - const int tg_size = - (tiles->large_scale) - ? 1 - : (tile_rows * tile_cols + num_tg_hdrs - 1) / num_tg_hdrs; + const int tg_size = (tile_rows * tile_cols + num_tg_hdrs - 1) / num_tg_hdrs; int tile_count = 0; int curr_tg_data_size = 0; uint8_t *data = dst; int new_tg = 1; - const int have_tiles = tile_cols * tile_rows > 1; int first_tg = 1; - *largest_tile_id = 0; - - if (tiles->large_scale) { - // For large_scale_tile case, we always have only one tile group, so it can - // be written as an OBU_FRAME. - const OBU_TYPE obu_type = OBU_FRAME; - const uint32_t tg_hdr_size = - av1_write_obu_header(level_params, obu_type, 0, data); - data += tg_hdr_size; - - const uint32_t frame_header_size = - write_frame_header_obu(cpi, saved_wb, data, 0); - data += frame_header_size; - total_size += frame_header_size; - - // (yunqing) This test ensures the correctness of large scale tile coding. - if (cpi->oxcf.tile_cfg.enable_ext_tile_debug) { - char fn[20] = "./fh"; - fn[4] = cm->current_frame.frame_number / 100 + '0'; - fn[5] = (cm->current_frame.frame_number % 100) / 10 + '0'; - fn[6] = (cm->current_frame.frame_number % 10) + '0'; - fn[7] = '\0'; - av1_print_uncompressed_frame_header(data - frame_header_size, - frame_header_size, fn); - } - - int tile_size_bytes = 0; - int tile_col_size_bytes = 0; - - for (tile_col = 0; tile_col < tile_cols; tile_col++) { - TileInfo tile_info; - const int is_last_col = (tile_col == tile_cols - 1); - const uint32_t col_offset = total_size; - - av1_tile_set_col(&tile_info, cm, tile_col); - - // The last column does not have a column header - if (!is_last_col) total_size += 4; - - for (tile_row = 0; tile_row < tile_rows; tile_row++) { - TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; - const int data_offset = have_tiles ? 4 : 0; - const int tile_idx = tile_row * tile_cols + tile_col; - TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; - av1_tile_set_row(&tile_info, cm, tile_row); - - buf->data = dst + total_size + tg_hdr_size; - - // Is CONFIG_EXT_TILE = 1, every tile in the row has a header, - // even for the last one, unless no tiling is used at all. - total_size += data_offset; - cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; - mode_bc.allow_update_cdf = !tiles->large_scale; - mode_bc.allow_update_cdf = - mode_bc.allow_update_cdf && !cm->features.disable_cdf_update; - aom_start_encode(&mode_bc, buf->data + data_offset); - write_modes(cpi, &tile_info, &mode_bc, tile_row, tile_col); - aom_stop_encode(&mode_bc); - tile_size = mode_bc.pos; - buf->size = tile_size; - - // Record the maximum tile size we see, so we can compact headers later. - if (tile_size > max_tile_size) { - max_tile_size = tile_size; - *largest_tile_id = tile_cols * tile_row + tile_col; - } - - if (have_tiles) { - // tile header: size of this tile, or copy offset - uint32_t tile_header = tile_size - AV1_MIN_TILE_SIZE_BYTES; - const int tile_copy_mode = - ((AOMMAX(tiles->width, tiles->height) << MI_SIZE_LOG2) <= 256) - ? 1 - : 0; - - // If tile_copy_mode = 1, check if this tile is a copy tile. - // Very low chances to have copy tiles on the key frames, so don't - // search on key frames to reduce unnecessary search. - if (cm->current_frame.frame_type != KEY_FRAME && tile_copy_mode) { - const int identical_tile_offset = - find_identical_tile(tile_row, tile_col, tile_buffers); - - // Indicate a copy-tile by setting the most significant bit. - // The row-offset to copy from is stored in the highest byte. - // remux_tiles will move these around later - if (identical_tile_offset > 0) { - tile_size = 0; - tile_header = identical_tile_offset | 0x80; - tile_header <<= 24; - } - } - - mem_put_le32(buf->data, tile_header); - } - - total_size += tile_size; - } - - if (!is_last_col) { - uint32_t col_size = total_size - col_offset - 4; - mem_put_le32(dst + col_offset + tg_hdr_size, col_size); - - // Record the maximum tile column size we see. - max_tile_col_size = AOMMAX(max_tile_col_size, col_size); - } - } - - if (have_tiles) { - total_size = remux_tiles(tiles, data, total_size - frame_header_size, - max_tile_size, max_tile_col_size, - &tile_size_bytes, &tile_col_size_bytes); - total_size += frame_header_size; - } - - // In EXT_TILE case, only use 1 tile group. Follow the obu syntax, write - // current tile group size before tile data(include tile column header). - // Tile group size doesn't include the bytes storing tg size. - total_size += tg_hdr_size; - const uint32_t obu_payload_size = total_size - tg_hdr_size; - const size_t length_field_size = - obu_memmove(tg_hdr_size, obu_payload_size, dst); - if (av1_write_uleb_obu_size(tg_hdr_size, obu_payload_size, dst) != - AOM_CODEC_OK) { - assert(0); - } - total_size += (uint32_t)length_field_size; - saved_wb->bit_buffer += length_field_size; - - // Now fill in the gaps in the uncompressed header. - if (have_tiles) { - assert(tile_col_size_bytes >= 1 && tile_col_size_bytes <= 4); - aom_wb_overwrite_literal(saved_wb, tile_col_size_bytes - 1, 2); - - assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); - aom_wb_overwrite_literal(saved_wb, tile_size_bytes - 1, 2); - } - return total_size; - } - - uint32_t obu_header_size = 0; - uint8_t *tile_data_start = dst + total_size; - for (tile_row = 0; tile_row < tile_rows; tile_row++) { - TileInfo tile_info; - av1_tile_set_row(&tile_info, cm, tile_row); - - for (tile_col = 0; tile_col < tile_cols; tile_col++) { + for (int tile_row = 0; tile_row < tile_rows; tile_row++) { + for (int tile_col = 0; tile_col < tile_cols; tile_col++) { + aom_writer mode_bc; const int tile_idx = tile_row * tile_cols + tile_col; TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; int is_last_tile_in_tg = 0; if (new_tg) { - data = dst + total_size; + data = dst + *total_size; // A new tile group begins at this tile. Write the obu header and // tile group header @@ -3655,23 +3700,24 @@ (num_tg_hdrs == 1) ? OBU_FRAME : OBU_TILE_GROUP; curr_tg_data_size = av1_write_obu_header(level_params, obu_type, obu_extension_header, data); - obu_header_size = curr_tg_data_size; + *obu_header_size = curr_tg_data_size; - if (num_tg_hdrs == 1) { + if (num_tg_hdrs == 1) curr_tg_data_size += write_frame_header_obu( cpi, saved_wb, data + curr_tg_data_size, 0); - } curr_tg_data_size += write_tile_group_header( data + curr_tg_data_size, tile_idx, AOMMIN(tile_idx + tg_size - 1, tile_cols * tile_rows - 1), - n_log2_tiles, cpi->num_tg > 1); - total_size += curr_tg_data_size; - tile_data_start += curr_tg_data_size; + (tiles->log2_rows + tiles->log2_cols), cpi->num_tg > 1); + *total_size += curr_tg_data_size; + *tile_data_start += curr_tg_data_size; new_tg = 0; tile_count = 0; } tile_count++; + TileInfo tile_info; av1_tile_set_col(&tile_info, cm, tile_col); + av1_tile_set_row(&tile_info, cm, tile_row); if (tile_count == tg_size || tile_idx == (tile_cols * tile_rows - 1)) { is_last_tile_in_tg = 1; @@ -3680,10 +3726,10 @@ is_last_tile_in_tg = 0; } - buf->data = dst + total_size; + buf->data = dst + *total_size; // The last tile of the tile group does not have a header. - if (!is_last_tile_in_tg) total_size += 4; + if (!is_last_tile_in_tg) *total_size += 4; cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; mode_bc.allow_update_cdf = 1; @@ -3692,7 +3738,7 @@ const int num_planes = av1_num_planes(cm); av1_reset_loop_restoration(&cpi->td.mb.e_mbd, num_planes); - aom_start_encode(&mode_bc, dst + total_size); + aom_start_encode(&mode_bc, dst + *total_size); write_modes(cpi, &tile_info, &mode_bc, tile_row, tile_col); aom_stop_encode(&mode_bc); tile_size = mode_bc.pos; @@ -3700,9 +3746,9 @@ curr_tg_data_size += (tile_size + (is_last_tile_in_tg ? 0 : 4)); buf->size = tile_size; - if (tile_size > max_tile_size) { + if (tile_size > *max_tile_size) { *largest_tile_id = tile_cols * tile_row + tile_col; - max_tile_size = tile_size; + *max_tile_size = tile_size; } if (!is_last_tile_in_tg) { @@ -3710,16 +3756,16 @@ mem_put_le32(buf->data, tile_size - AV1_MIN_TILE_SIZE_BYTES); } else { // write current tile group size - const uint32_t obu_payload_size = curr_tg_data_size - obu_header_size; + const uint32_t obu_payload_size = curr_tg_data_size - *obu_header_size; const size_t length_field_size = - obu_memmove(obu_header_size, obu_payload_size, data); - if (av1_write_uleb_obu_size(obu_header_size, obu_payload_size, data) != + obu_memmove(*obu_header_size, obu_payload_size, data); + if (av1_write_uleb_obu_size(*obu_header_size, obu_payload_size, data) != AOM_CODEC_OK) { assert(0); } curr_tg_data_size += (int)length_field_size; - total_size += (uint32_t)length_field_size; - tile_data_start += length_field_size; + *total_size += (uint32_t)length_field_size; + *tile_data_start += length_field_size; if (num_tg_hdrs == 1) { // if this tg is combined with the frame header then update saved // frame header base offset accroding to length field size @@ -3747,65 +3793,112 @@ data += fh_info->total_length; curr_tg_data_size += (int)(fh_info->total_length); - total_size += (uint32_t)(fh_info->total_length); + *total_size += (uint32_t)(fh_info->total_length); } first_tg = 0; } - total_size += tile_size; + *total_size += tile_size; } } +} - if (have_tiles) { - // Fill in context_update_tile_id indicating the tile to use for the - // cdf update. The encoder currently sets it to the largest tile - // (but is up to the encoder) - aom_wb_overwrite_literal(saved_wb, *largest_tile_id, - tiles->log2_cols + tiles->log2_rows); - // If more than one tile group. tile_size_bytes takes the default value 4 - // and does not need to be set. For a single tile group it is set in the - // section below. - if (num_tg_hdrs == 1) { - int tile_size_bytes = 4, unused; - const uint32_t tile_data_offset = (uint32_t)(tile_data_start - dst); - const uint32_t tile_data_size = total_size - tile_data_offset; +// Write total buffer size and related information into the OBU header for +// default tile case. +static void write_tile_obu_size(AV1_COMP *const cpi, uint8_t *const dst, + struct aom_write_bit_buffer *saved_wb, + int largest_tile_id, uint32_t *const total_size, + unsigned int max_tile_size, + uint32_t obu_header_size, + uint8_t *tile_data_start) { + const CommonTileParams *const tiles = &cpi->common.tiles; - total_size = - remux_tiles(tiles, tile_data_start, tile_data_size, max_tile_size, - max_tile_col_size, &tile_size_bytes, &unused); - total_size += tile_data_offset; - assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); + // Fill in context_update_tile_id indicating the tile to use for the + // cdf update. The encoder currently sets it to the largest tile + // (but is up to the encoder) + aom_wb_overwrite_literal(saved_wb, largest_tile_id, + (tiles->log2_cols + tiles->log2_rows)); + // If more than one tile group. tile_size_bytes takes the default value 4 + // and does not need to be set. For a single tile group it is set in the + // section below. + if (cpi->num_tg != 1) return; + int tile_size_bytes = 4, unused; + const uint32_t tile_data_offset = (uint32_t)(tile_data_start - dst); + const uint32_t tile_data_size = *total_size - tile_data_offset; - aom_wb_overwrite_literal(saved_wb, tile_size_bytes - 1, 2); + *total_size = remux_tiles(tiles, tile_data_start, tile_data_size, + max_tile_size, 0, &tile_size_bytes, &unused); + *total_size += tile_data_offset; + assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); - // Update the OBU length if remux_tiles() reduced the size. - uint64_t payload_size; - size_t length_field_size; - int res = - aom_uleb_decode(dst + obu_header_size, total_size - obu_header_size, - &payload_size, &length_field_size); - assert(res == 0); - (void)res; + aom_wb_overwrite_literal(saved_wb, tile_size_bytes - 1, 2); - const uint64_t new_payload_size = - total_size - obu_header_size - length_field_size; - if (new_payload_size != payload_size) { - size_t new_length_field_size; - res = aom_uleb_encode(new_payload_size, length_field_size, - dst + obu_header_size, &new_length_field_size); - assert(res == 0); - if (new_length_field_size < length_field_size) { - const size_t src_offset = obu_header_size + length_field_size; - const size_t dst_offset = obu_header_size + new_length_field_size; - memmove(dst + dst_offset, dst + src_offset, (size_t)payload_size); - total_size -= (int)(length_field_size - new_length_field_size); - } - } + // Update the OBU length if remux_tiles() reduced the size. + uint64_t payload_size; + size_t length_field_size; + int res = + aom_uleb_decode(dst + obu_header_size, *total_size - obu_header_size, + &payload_size, &length_field_size); + assert(res == 0); + (void)res; + + const uint64_t new_payload_size = + *total_size - obu_header_size - length_field_size; + if (new_payload_size != payload_size) { + size_t new_length_field_size; + res = aom_uleb_encode(new_payload_size, length_field_size, + dst + obu_header_size, &new_length_field_size); + assert(res == 0); + if (new_length_field_size < length_field_size) { + const size_t src_offset = obu_header_size + length_field_size; + const size_t dst_offset = obu_header_size + new_length_field_size; + memmove(dst + dst_offset, dst + src_offset, (size_t)payload_size); + *total_size -= (int)(length_field_size - new_length_field_size); } } +} + +static INLINE uint32_t pack_tiles_in_tg_obus( + AV1_COMP *const cpi, uint8_t *const dst, + struct aom_write_bit_buffer *saved_wb, uint8_t obu_extension_header, + const FrameHeaderInfo *fh_info, int *const largest_tile_id) { + const CommonTileParams *const tiles = &cpi->common.tiles; + uint32_t total_size = 0; + unsigned int max_tile_size = 0; + uint32_t obu_header_size = 0; + uint8_t *tile_data_start = dst; + + write_tile_obu(cpi, dst, &total_size, saved_wb, obu_extension_header, fh_info, + largest_tile_id, &max_tile_size, &obu_header_size, + &tile_data_start); + + const int tile_cols = tiles->cols; + const int tile_rows = tiles->rows; + const int have_tiles = tile_cols * tile_rows > 1; + + if (have_tiles) + write_tile_obu_size(cpi, dst, saved_wb, *largest_tile_id, &total_size, + max_tile_size, obu_header_size, tile_data_start); return total_size; } +static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, + struct aom_write_bit_buffer *saved_wb, + uint8_t obu_extension_header, + const FrameHeaderInfo *fh_info, + int *const largest_tile_id) { + AV1_COMMON *const cm = &cpi->common; + const CommonTileParams *const tiles = &cm->tiles; + *largest_tile_id = 0; + + if (tiles->large_scale) + return pack_large_scale_tiles_in_tg_obus(cpi, dst, saved_wb, + largest_tile_id); + + return pack_tiles_in_tg_obus(cpi, dst, saved_wb, obu_extension_header, + fh_info, largest_tile_id); +} + static size_t av1_write_metadata_obu(const aom_metadata_t *metadata, uint8_t *const dst) { size_t coded_metadata_size = 0;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h index f72d11a..91df25d 100644 --- a/av1/encoder/block.h +++ b/av1/encoder/block.h
@@ -102,7 +102,7 @@ */ typedef struct macroblock_plane { //! Stores source - pred so the txfm can be computed later - DECLARE_ALIGNED(32, int16_t, src_diff[MAX_SB_SQUARE]); + int16_t *src_diff; //! Dequantized coefficients tran_low_t *dqcoeff; //! Quantized coefficients @@ -238,7 +238,7 @@ TX_SIZE inter_tx_size[INTER_TX_SIZE_BUF_LEN]; //! Map showing which txfm block skips the txfm process. uint8_t blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE]; - //! Map showing the txfm types for each blcok. + //! Map showing the txfm types for each block. uint8_t tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE]; //! Rd_stats for the whole partition block. RD_STATS rd_stats; @@ -487,8 +487,8 @@ * - MB_RD_RECORD: records a whole *partition block*'s inter-mode txfm result. * Since this operates on the partition block level, this can give us a * whole txfm partition tree. - * - TXB_RD_RECORD: records a txfm search result within a transform blcok - * itself. This operates on txb level only and onlyt appplies to square + * - TXB_RD_RECORD: records a txfm search result within a transform block + * itself. This operates on txb level only and only applies to square * txfms. */ typedef struct { @@ -548,8 +548,8 @@ * - MB_RD_RECORD: records a whole *partition block*'s inter-mode txfm result. * Since this operates on the partition block level, this can give us a * whole txfm partition tree. - * - TXB_RD_RECORD: records a txfm search result within a transform blcok - * itself. This operates on txb level only and onlyt appplies to square + * - TXB_RD_RECORD: records a txfm search result within a transform block + * itself. This operates on txb level only and only applies to square * txfms. */ TxbRdRecords *txb_rd_records; @@ -778,6 +778,23 @@ /**@}*/ } MvCosts; +/*! \brief Holds mv costs for intrabc. + */ +typedef struct { + /*! Costs for coding the joint mv. */ + int joint_mv[MV_JOINTS]; + + /*! \brief Cost of transmitting the actual motion vector. + * dv_costs_alloc[0][i] is the cost of motion vector with horizontal + * component (mv_row) equal to i - MV_MAX. dv_costs_alloc[1][i] is the cost of + * motion vector with vertical component (mv_col) equal to i - MV_MAX. + */ + int dv_costs_alloc[2][MV_VALS]; + + /*! Points to the middle of \ref dv_costs_alloc. */ + int *dv_costs[2]; +} IntraBCMVCosts; + /*! \brief Holds the costs needed to encode the coefficients */ typedef struct { @@ -897,7 +914,7 @@ * * Points to a buffer that is used to hold temporary prediction results. This * is used in two ways: - * - This is a temporary buffer used to pingpong the prediction in + * - This is a temporary buffer used to ping-pong the prediction in * handle_inter_mode. * - xd->tmp_obmc_bufs also points to this buffer, and is used in ombc * prediction. @@ -945,6 +962,11 @@ //! multipliers for motion search. MvCosts *mv_costs; + /*! The rate needed to encode a new motion vector to the bitstream in intrabc + * mode. + */ + IntraBCMVCosts *dv_costs; + //! The rate needed to signal the txfm coefficients to the bitstream. CoeffCosts coeff_costs; /**@}*/ @@ -969,6 +991,22 @@ * set 0 and all txfms are skipped. */ int seg_skip_block; + + /*! \brief Number of segment 1 blocks + * Actual number of (4x4) blocks that were applied delta-q, + * for segment 1. + */ + int actual_num_seg1_blocks; + + /*!\brief Number of segment 2 blocks + * Actual number of (4x4) blocks that were applied delta-q, + * for segment 2. + */ + int actual_num_seg2_blocks; + + /*!\brief Number of zero motion vectors + */ + int cnt_zeromv; /**@}*/ /***************************************************************************** @@ -1076,8 +1114,7 @@ * In the second pass, we retry the winner modes with more thorough txfm * options. */ - WinnerModeStats winner_mode_stats[AOMMAX(MAX_WINNER_MODE_COUNT_INTRA, - MAX_WINNER_MODE_COUNT_INTER)]; + WinnerModeStats *winner_mode_stats; //! Tracks how many winner modes there are. int winner_mode_count; @@ -1131,10 +1168,11 @@ */ IntraBCHashInfo intrabc_hash_info; - /*! \brief Whether to reuse the mode stored in intermode_cache. */ - int use_intermode_cache; - /*! \brief The mode to reuse during \ref av1_rd_pick_inter_mode. */ - const MB_MODE_INFO *intermode_cache; + /*! \brief Whether to reuse the mode stored in mb_mode_cache. */ + int use_mb_mode_cache; + /*! \brief The mode to reuse during \ref av1_rd_pick_intra_mode_sb and + * \ref av1_rd_pick_inter_mode. */ + const MB_MODE_INFO *mb_mode_cache; /**@}*/ /*****************************************************************************
diff --git a/av1/encoder/compound_type.c b/av1/encoder/compound_type.c index f7ad1d0..69062e3 100644 --- a/av1/encoder/compound_type.c +++ b/av1/encoder/compound_type.c
@@ -1002,6 +1002,29 @@ comp_rs2[cur_type] = rs2; } +static INLINE int save_mask_search_results(const PREDICTION_MODE this_mode, + const int reuse_level) { + if (reuse_level || (this_mode == NEW_NEWMV)) + return 1; + else + return 0; +} + +static INLINE int prune_mode_by_skip_rd(const AV1_COMP *const cpi, + MACROBLOCK *x, MACROBLOCKD *xd, + const BLOCK_SIZE bsize, + int64_t ref_skip_rd, int mode_rate) { + int eval_txfm = 1; + // Check if the mode is good enough based on skip rd + if (cpi->sf.inter_sf.txfm_rd_gate_level) { + int64_t sse_y = compute_sse_plane(x, xd, PLANE_TYPE_Y, bsize); + int64_t skip_rd = RDCOST(x->rdmult, mode_rate, (sse_y << 4)); + eval_txfm = check_txfm_eval(x, bsize, ref_skip_rd, skip_rd, + cpi->sf.inter_sf.txfm_rd_gate_level, 1); + } + return eval_txfm; +} + static int64_t masked_compound_type_rd( const AV1_COMP *const cpi, MACROBLOCK *x, const int_mv *const cur_mv, const BLOCK_SIZE bsize, const PREDICTION_MODE this_mode, int *rs2, @@ -1280,14 +1303,8 @@ RD_STATS est_rd_stats; const int64_t tmp_rd_thresh = AOMMIN(*rd, rd_thresh) - mode_rd; int64_t est_rd = INT64_MAX; - int eval_txfm = 1; - // Check if the mode is good enough based on skip rd - if (cpi->sf.inter_sf.txfm_rd_gate_level) { - int64_t sse_y = compute_sse_plane(x, xd, PLANE_TYPE_Y, bsize); - int64_t skip_rd = RDCOST(x->rdmult, rs2 + *rate_mv, (sse_y << 4)); - eval_txfm = check_txfm_eval(x, bsize, ref_skip_rd, skip_rd, - cpi->sf.inter_sf.txfm_rd_gate_level, 1); - } + int eval_txfm = prune_mode_by_skip_rd(cpi, x, xd, bsize, ref_skip_rd, + rs2 + *rate_mv); // Evaluate further if skip rd is low enough if (eval_txfm) { est_rd = estimate_yrd_for_sb(cpi, bsize, x, tmp_rd_thresh, @@ -1325,7 +1342,8 @@ &inter_pred_params.conv_params.bck_offset, &inter_pred_params.conv_params.use_dist_wtd_comp_avg, 1); int mask_value = inter_pred_params.conv_params.fwd_offset * 4; - memset(xd->seg_mask, mask_value, sizeof(xd->seg_mask)); + memset(xd->seg_mask, mask_value, + sizeof(xd->seg_mask[0]) * 2 * MAX_SB_SQUARE); tmp_rate_mv = av1_interinter_compound_motion_search(cpi, x, cur_mv, bsize, this_mode); } @@ -1333,11 +1351,15 @@ AOM_PLANE_Y, AOM_PLANE_Y); if (cur_type == COMPOUND_AVERAGE) *is_luma_interp_done = 1; - RD_STATS est_rd_stats; - estimate_yrd_for_sb(cpi, bsize, x, INT64_MAX, &est_rd_stats); + int eval_txfm = prune_mode_by_skip_rd(cpi, x, xd, bsize, ref_skip_rd, + rs2 + *rate_mv); + if (eval_txfm) { + RD_STATS est_rd_stats; + estimate_yrd_for_sb(cpi, bsize, x, INT64_MAX, &est_rd_stats); - best_rd_cur = RDCOST(x->rdmult, rs2 + tmp_rate_mv + est_rd_stats.rate, - est_rd_stats.dist); + best_rd_cur = RDCOST(x->rdmult, rs2 + tmp_rate_mv + est_rd_stats.rate, + est_rd_stats.dist); + } } // use spare buffer for following compound type try @@ -1382,8 +1404,13 @@ } RD_STATS est_rd_stats; - int64_t this_rd_cur = estimate_yrd_for_sb( - cpi, bsize, x, AOMMIN(best_rd_cur, ref_best_rd), &est_rd_stats); + int64_t this_rd_cur = INT64_MAX; + int eval_txfm = prune_mode_by_skip_rd(cpi, x, xd, bsize, ref_skip_rd, + rs2 + *rate_mv); + if (eval_txfm) { + this_rd_cur = estimate_yrd_for_sb( + cpi, bsize, x, AOMMIN(best_rd_cur, ref_best_rd), &est_rd_stats); + } if (this_rd_cur < INT64_MAX) { this_rd_cur = RDCOST(x->rdmult, rs2 + tmp_rate_mv + est_rd_stats.rate, @@ -1402,7 +1429,8 @@ } if (need_mask_search) { - if (this_mode == NEW_NEWMV) { + if (save_mask_search_results( + this_mode, cpi->sf.inter_sf.reuse_mask_search_results)) { args->wedge_index = best_mask_index; args->wedge_sign = best_wedge_sign; } @@ -1426,11 +1454,15 @@ best_rs2 += get_interinter_compound_mask_rate(&x->mode_costs, mbmi); av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, orig_dst, bsize, AOM_PLANE_Y, AOM_PLANE_Y); - RD_STATS est_rd_stats; - estimate_yrd_for_sb(cpi, bsize, x, INT64_MAX, &est_rd_stats); - best_rd_cur = - RDCOST(x->rdmult, best_rs2 + tmp_rate_mv + est_rd_stats.rate, - est_rd_stats.dist); + int eval_txfm = prune_mode_by_skip_rd(cpi, x, xd, bsize, ref_skip_rd, + best_rs2 + *rate_mv); + if (eval_txfm) { + RD_STATS est_rd_stats; + estimate_yrd_for_sb(cpi, bsize, x, INT64_MAX, &est_rd_stats); + best_rd_cur = + RDCOST(x->rdmult, best_rs2 + tmp_rate_mv + est_rd_stats.rate, + est_rd_stats.dist); + } } mbmi->interinter_comp.wedge_index = best_mask_index; @@ -1454,15 +1486,21 @@ if (have_newmv_in_inter_mode(this_mode)) { // hard coded number for diff wtd int mask_value = mask_index == 0 ? 38 : 26; - memset(xd->seg_mask, mask_value, sizeof(xd->seg_mask)); + memset(xd->seg_mask, mask_value, + sizeof(xd->seg_mask[0]) * 2 * MAX_SB_SQUARE); tmp_rate_mv = av1_interinter_compound_motion_search(cpi, x, cur_mv, bsize, this_mode); } av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, orig_dst, bsize, AOM_PLANE_Y, AOM_PLANE_Y); RD_STATS est_rd_stats; - int64_t this_rd_cur = - estimate_yrd_for_sb(cpi, bsize, x, ref_best_rd, &est_rd_stats); + int64_t this_rd_cur = INT64_MAX; + int eval_txfm = prune_mode_by_skip_rd(cpi, x, xd, bsize, ref_skip_rd, + rs2 + *rate_mv); + if (eval_txfm) { + this_rd_cur = + estimate_yrd_for_sb(cpi, bsize, x, ref_best_rd, &est_rd_stats); + } if (this_rd_cur < INT64_MAX) { this_rd_cur = RDCOST(x->rdmult, rs2 + tmp_rate_mv + est_rd_stats.rate, est_rd_stats.dist); @@ -1477,14 +1515,17 @@ } if (need_mask_search) { - if (this_mode == NEW_NEWMV) args->diffwtd_index = best_mask_index; + if (save_mask_search_results( + this_mode, cpi->sf.inter_sf.reuse_mask_search_results)) + args->diffwtd_index = best_mask_index; } else { mbmi->interinter_comp.mask_type = args->diffwtd_index; rs2 = masked_type_cost[cur_type]; rs2 += get_interinter_compound_mask_rate(&x->mode_costs, mbmi); int mask_value = mbmi->interinter_comp.mask_type == 0 ? 38 : 26; - memset(xd->seg_mask, mask_value, sizeof(xd->seg_mask)); + memset(xd->seg_mask, mask_value, + sizeof(xd->seg_mask[0]) * 2 * MAX_SB_SQUARE); if (have_newmv_in_inter_mode(this_mode)) { tmp_rate_mv = av1_interinter_compound_motion_search(cpi, x, cur_mv, @@ -1496,8 +1537,13 @@ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, orig_dst, bsize, AOM_PLANE_Y, AOM_PLANE_Y); RD_STATS est_rd_stats; - int64_t this_rd_cur = - estimate_yrd_for_sb(cpi, bsize, x, ref_best_rd, &est_rd_stats); + int64_t this_rd_cur = INT64_MAX; + int eval_txfm = prune_mode_by_skip_rd(cpi, x, xd, bsize, ref_skip_rd, + rs2 + *rate_mv); + if (eval_txfm) { + this_rd_cur = + estimate_yrd_for_sb(cpi, bsize, x, ref_best_rd, &est_rd_stats); + } if (this_rd_cur < INT64_MAX) { best_rd_cur = RDCOST(x->rdmult, rs2 + tmp_rate_mv + est_rd_stats.rate, est_rd_stats.dist);
diff --git a/av1/encoder/dwt.c b/av1/encoder/dwt.c index 04088b2..b5ed4a3 100644 --- a/av1/encoder/dwt.c +++ b/av1/encoder/dwt.c
@@ -70,14 +70,14 @@ } static void dyadic_analyze_53_uint8_input(int levels, int width, int height, - uint8_t *x, int pitch_x, + const uint8_t *x, int pitch_x, tran_low_t *c, int pitch_c, int dwt_scale_bits, int hbd) { int lv, i, j, nh, nw, hh = height, hw = width; tran_low_t buffer[2 * DWT_MAX_LENGTH]; if (hbd) { - uint16_t *x16 = CONVERT_TO_SHORTPTR(x); + const uint16_t *x16 = CONVERT_TO_SHORTPTR(x); for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { c[i * pitch_c + j] = x16[i * pitch_x + j] << dwt_scale_bits; @@ -109,12 +109,12 @@ } } -void av1_fdwt8x8_uint8_input_c(uint8_t *input, tran_low_t *output, int stride, - int hbd) { +void av1_fdwt8x8_uint8_input_c(const uint8_t *input, tran_low_t *output, + int stride, int hbd) { dyadic_analyze_53_uint8_input(4, 8, 8, input, stride, output, 8, 2, hbd); } -int av1_haar_ac_sad(tran_low_t *output, int bw, int bh, int stride) { +int av1_haar_ac_sad(const tran_low_t *output, int bw, int bh, int stride) { int acsad = 0; for (int r = 0; r < bh; ++r) @@ -147,7 +147,7 @@ return sse - (uint32_t)(((int64_t)sum * sum) / (bw * bh)); } -int av1_haar_ac_sad_8x8_uint8_input(uint8_t *input, int stride, int hbd) { +int av1_haar_ac_sad_8x8_uint8_input(const uint8_t *input, int stride, int hbd) { tran_low_t output[64]; av1_fdwt8x8_uint8_input_c(input, output, stride, hbd);
diff --git a/av1/encoder/dwt.h b/av1/encoder/dwt.h index 37306c6..1bd32ed 100644 --- a/av1/encoder/dwt.h +++ b/av1/encoder/dwt.h
@@ -17,9 +17,8 @@ #define DWT_MAX_LENGTH 64 -void av1_fdwt8x8(tran_low_t *input, tran_low_t *output, int stride); -void av1_fdwt8x8_uint8_input_c(uint8_t *input, tran_low_t *output, int stride, - int hbd); -int av1_haar_ac_sad_8x8_uint8_input(uint8_t *input, int stride, int hbd); +void av1_fdwt8x8_uint8_input_c(const uint8_t *input, tran_low_t *output, + int stride, int hbd); +int av1_haar_ac_sad_8x8_uint8_input(const uint8_t *input, int stride, int hbd); #endif // AOM_AV1_ENCODER_DWT_H_
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c index b622c6e..da7ec44 100644 --- a/av1/encoder/encode_strategy.c +++ b/av1/encoder/encode_strategy.c
@@ -380,7 +380,7 @@ // TODO(Aasaipriya): Forced key frames need to be fixed when rc_mode != AOM_Q if (src_index && - (is_forced_keyframe_pending(cpi->lookahead, src_index, + (is_forced_keyframe_pending(cpi->ppi->lookahead, src_index, cpi->compressor_stage) != -1) && cpi->oxcf.rc_cfg.mode != AOM_Q) { src_index = 0; @@ -396,11 +396,11 @@ // then do not pop. if (*pop_lookahead && cpi->oxcf.kf_cfg.enable_keyframe_filtering > 1 && gf_group->update_type[gf_group->index] == ARF_UPDATE && - !is_stat_generation_stage(cpi) && cpi->lookahead) { - if (cpi->lookahead->read_ctxs[cpi->compressor_stage].sz && + !is_stat_generation_stage(cpi) && cpi->ppi->lookahead) { + if (cpi->ppi->lookahead->read_ctxs[cpi->compressor_stage].sz && (*flush || - cpi->lookahead->read_ctxs[cpi->compressor_stage].sz == - cpi->lookahead->read_ctxs[cpi->compressor_stage].pop_sz)) { + cpi->ppi->lookahead->read_ctxs[cpi->compressor_stage].sz == + cpi->ppi->lookahead->read_ctxs[cpi->compressor_stage].pop_sz)) { *pop_lookahead = 0; } } @@ -410,14 +410,14 @@ // Get last frame source. if (cm->current_frame.frame_number > 0) { *last_source = - av1_lookahead_peek(cpi->lookahead, -1, cpi->compressor_stage); + av1_lookahead_peek(cpi->ppi->lookahead, -1, cpi->compressor_stage); } // Read in the source frame. - source = av1_lookahead_peek(cpi->lookahead, 0, cpi->compressor_stage); + source = av1_lookahead_peek(cpi->ppi->lookahead, 0, cpi->compressor_stage); } else { // no show frames are arf frames - source = - av1_lookahead_peek(cpi->lookahead, src_index, cpi->compressor_stage); + source = av1_lookahead_peek(cpi->ppi->lookahead, src_index, + cpi->compressor_stage); // When src_index == rc->frames_to_key, it indicates a fwd_kf if (src_index == cpi->rc.frames_to_key && src_index != 0) { cpi->no_show_fwd_kf = 1; @@ -437,7 +437,7 @@ if (cpi->common.current_frame.frame_number == 0) return 0; const struct lookahead_entry *lookahead_src = - av1_lookahead_peek(cpi->lookahead, 0, cpi->compressor_stage); + av1_lookahead_peek(cpi->ppi->lookahead, 0, cpi->compressor_stage); if (lookahead_src == NULL) return 1; const int is_error_resilient = @@ -1102,14 +1102,15 @@ // Check if we need to stuff more src frames if (flush == 0) { int srcbuf_size = - av1_lookahead_depth(cpi->lookahead, cpi->compressor_stage); - int pop_size = av1_lookahead_pop_sz(cpi->lookahead, cpi->compressor_stage); + av1_lookahead_depth(cpi->ppi->lookahead, cpi->compressor_stage); + int pop_size = + av1_lookahead_pop_sz(cpi->ppi->lookahead, cpi->compressor_stage); // Continue buffering look ahead buffer. if (srcbuf_size < pop_size) return -1; } - if (!av1_lookahead_peek(cpi->lookahead, 0, cpi->compressor_stage)) { + if (!av1_lookahead_peek(cpi->ppi->lookahead, 0, cpi->compressor_stage)) { #if !CONFIG_REALTIME_ONLY if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) { av1_end_first_pass(cpi); /* get last stats packet */ @@ -1170,7 +1171,7 @@ struct lookahead_entry *last_source = NULL; int pop_lookahead = 0; if (frame_params.show_existing_frame) { - source = av1_lookahead_peek(cpi->lookahead, 0, cpi->compressor_stage); + source = av1_lookahead_peek(cpi->ppi->lookahead, 0, cpi->compressor_stage); pop_lookahead = 1; frame_params.show_frame = 1; } else { @@ -1261,8 +1262,13 @@ av1_cyclic_refresh_update_parameters(cpi); } else if (is_stat_generation_stage(cpi)) { cpi->td.mb.e_mbd.lossless[0] = is_lossless_requested(&oxcf->rc_cfg); - const int kf_requested = (cm->current_frame.frame_number == 0 || - (*frame_flags & FRAMEFLAGS_KEY)); + // Current frame is coded as a key-frame for any of the following cases: + // 1) First frame of a video + // 2) For all-intra frame encoding + // 3) When a key-frame is forced + const int kf_requested = + (cm->current_frame.frame_number == 0 || + oxcf->kf_cfg.key_freq_max == 0 || (*frame_flags & FRAMEFLAGS_KEY)); if (kf_requested && frame_update_type != OVERLAY_UPDATE && frame_update_type != INTNL_OVERLAY_UPDATE) { frame_params.frame_type = KEY_FRAME; @@ -1398,7 +1404,7 @@ } #endif if (pop_lookahead == 1) { - av1_lookahead_pop(cpi->lookahead, flush, cpi->compressor_stage); + av1_lookahead_pop(cpi->ppi->lookahead, flush, cpi->compressor_stage); } if (!is_stat_generation_stage(cpi)) {
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c index 821a6cc..6a68b86 100644 --- a/av1/encoder/encodeframe.c +++ b/av1/encoder/encodeframe.c
@@ -708,10 +708,17 @@ cpi->oxcf.unit_test_cfg.sb_multipass_unit_test ? 2 : 1; if (num_passes == 1) { +#if CONFIG_PARTITION_SEARCH_ORDER + av1_reset_part_sf(&cpi->sf.part_sf); + RD_STATS this_rdc; + av1_rd_partition_search(cpi, td, tile_data, tp, sms_root, mi_row, mi_col, + sb_size, &this_rdc); +#else PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size, &dummy_rdc, dummy_rdc, pc_root, sms_root, NULL, SB_SINGLE_PASS, NULL); +#endif // CONFIG_PARTITION_SEARCH_ORDER } else { // First pass SB_FIRST_PASS_STATS sb_fp_stats; @@ -750,6 +757,13 @@ } } +static AOM_INLINE int is_rtc_mode(const CostUpdateFreq *cost_upd_freq, + int use_non_rd_mode) { + return (use_non_rd_mode && cost_upd_freq->coeff >= 2 && + cost_upd_freq->mode >= 2 && cost_upd_freq->mv >= 2 && + cost_upd_freq->dv >= 2); +} + /*!\brief Encode a superblock row by breaking it into superblocks * * \ingroup partition_search @@ -775,6 +789,9 @@ const int mib_size_log2 = cm->seq_params.mib_size_log2; const int sb_row = (mi_row - tile_info->mi_row_start) >> mib_size_log2; const int use_nonrd_mode = cpi->sf.rt_sf.use_nonrd_pick_mode; + const CostUpdateFreq *const cost_upd_freq = &cpi->oxcf.cost_upd_freq; + const int rtc_mode = is_rtc_mode(cost_upd_freq, use_nonrd_mode); + const int update_cdf = tile_data->allow_update_cdf && row_mt_enabled; #if CONFIG_COLLECT_COMPONENT_TIMING start_timing(cpi, encode_sb_row_time); @@ -797,28 +814,26 @@ // Code each SB in the row for (int mi_col = tile_info->mi_col_start, sb_col_in_tile = 0; mi_col < tile_info->mi_col_end; mi_col += mib_size, sb_col_in_tile++) { - (*(enc_row_mt->sync_read_ptr))(row_mt_sync, sb_row, sb_col_in_tile); + // In non-rd mode and when frequency of cost updates is off/tile, wait for + // the top superblock to finish encoding. Otherwise, wait for the top-right + // superblock to finish encoding. + (*(enc_row_mt->sync_read_ptr))(row_mt_sync, sb_row, + sb_col_in_tile - rtc_mode); - if (tile_data->allow_update_cdf && row_mt_enabled && - (tile_info->mi_row_start != mi_row)) { + if (update_cdf && (tile_info->mi_row_start != mi_row)) { if ((tile_info->mi_col_start == mi_col)) { // restore frame context at the 1st column sb memcpy(xd->tile_ctx, x->row_ctx, sizeof(*xd->tile_ctx)); } else { - if (!cpi->sf.rt_sf.use_nonrd_pick_mode || - cpi->oxcf.cost_upd_freq.coeff < 2 || - cpi->oxcf.cost_upd_freq.mode < 2 || - cpi->oxcf.cost_upd_freq.mv < 2) { - // update context - int wt_left = AVG_CDF_WEIGHT_LEFT; - int wt_tr = AVG_CDF_WEIGHT_TOP_RIGHT; - if (tile_info->mi_col_end > (mi_col + mib_size)) - av1_avg_cdf_symbols(xd->tile_ctx, x->row_ctx + sb_col_in_tile, - wt_left, wt_tr); - else - av1_avg_cdf_symbols(xd->tile_ctx, x->row_ctx + sb_col_in_tile - 1, - wt_left, wt_tr); - } + // update context + int wt_left = AVG_CDF_WEIGHT_LEFT; + int wt_tr = AVG_CDF_WEIGHT_TOP_RIGHT; + if (tile_info->mi_col_end > (mi_col + mib_size)) + av1_avg_cdf_symbols(xd->tile_ctx, x->row_ctx + sb_col_in_tile, + wt_left, wt_tr); + else + av1_avg_cdf_symbols(xd->tile_ctx, x->row_ctx + sb_col_in_tile - 1, + wt_left, wt_tr); } } @@ -856,8 +871,7 @@ } // Update the top-right context in row_mt coding - if (tile_data->allow_update_cdf && row_mt_enabled && - (tile_info->mi_row_end > (mi_row + mib_size))) { + if (update_cdf && (tile_info->mi_row_end > (mi_row + mib_size))) { if (sb_cols_in_tile == 1) memcpy(x->row_ctx, xd->tile_ctx, sizeof(*xd->tile_ctx)); else if (sb_col_in_tile >= 1) @@ -910,6 +924,9 @@ TokenList *tplist = token_info->tplist[0][0]; unsigned int tile_tok = 0; int tplist_count = 0; + const int use_nonrd_mode = cpi->sf.rt_sf.use_nonrd_pick_mode; + const CostUpdateFreq *const cost_upd_freq = &cpi->oxcf.cost_upd_freq; + const int rtc_mode = is_rtc_mode(cost_upd_freq, use_nonrd_mode); for (tile_row = 0; tile_row < tile_rows; ++tile_row) { for (tile_col = 0; tile_col < tile_cols; ++tile_col) { @@ -930,8 +947,9 @@ tplist_count = av1_get_sb_rows_in_tile(cm, tile_data->tile_info); } tile_data->allow_update_cdf = !cm->tiles.large_scale; - tile_data->allow_update_cdf = - tile_data->allow_update_cdf && !cm->features.disable_cdf_update; + tile_data->allow_update_cdf = tile_data->allow_update_cdf && + !cm->features.disable_cdf_update && + !rtc_mode; tile_data->tctx = *cm->fc; } } @@ -959,6 +977,7 @@ get_start_tok(cpi, tile_row, tile_col, mi_row, &tok, cm->seq_params.mib_size_log2 + MI_SIZE_LOG2, num_planes); + assert(tplist != NULL); tplist[sb_row_in_tile].start = tok; encode_sb_row(cpi, td, this_tile, mi_row, &tok); @@ -1019,6 +1038,7 @@ const int tile_rows = cm->tiles.rows; int tile_col, tile_row; + MACROBLOCK *const mb = &cpi->td.mb; assert(IMPLIES(cpi->tile_data == NULL, cpi->allocated_tiles < tile_cols * tile_rows)); if (cpi->allocated_tiles < tile_cols * tile_rows) av1_alloc_tile_data(cpi); @@ -1028,6 +1048,24 @@ cpi->td.mb.txfm_search_info.txb_rd_records = (TxbRdRecords *)aom_malloc(sizeof(TxbRdRecords)); } + const int num_planes = av1_num_planes(&cpi->common); + for (int plane = 0; plane < num_planes; plane++) { + const int subsampling_xy = + plane ? cm->seq_params.subsampling_x + cm->seq_params.subsampling_y : 0; + const int sb_size = MAX_SB_SQUARE >> subsampling_xy; + CHECK_MEM_ERROR(cm, mb->plane[plane].src_diff, + (int16_t *)aom_memalign( + 32, sizeof(*mb->plane[plane].src_diff) * sb_size)); + } + CHECK_MEM_ERROR(cm, mb->e_mbd.seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * sizeof(mb->e_mbd.seg_mask[0]))); + const int winner_mode_count = frame_is_intra_only(cm) + ? MAX_WINNER_MODE_COUNT_INTRA + : MAX_WINNER_MODE_COUNT_INTER; + CHECK_MEM_ERROR(cm, mb->winner_mode_stats, + (WinnerModeStats *)aom_malloc( + winner_mode_count * sizeof(mb->winner_mode_stats[0]))); for (tile_row = 0; tile_row < tile_rows; ++tile_row) { for (tile_col = 0; tile_col < tile_cols; ++tile_col) { @@ -1037,7 +1075,15 @@ cpi->td.deltaq_used = 0; cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; cpi->td.mb.tile_pb_ctx = &this_tile->tctx; + // Reset cyclic refresh counters. + av1_init_cyclic_refresh_counters(&cpi->td.mb); + av1_encode_tile(cpi, &cpi->td, tile_row, tile_col); + // Accumulate cyclic refresh params. + if (cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ && + !frame_is_intra_only(&cpi->common)) + av1_accumulate_cyclic_refresh_counters(cpi->cyclic_refresh, + &cpi->td.mb); cpi->intrabc_used |= cpi->td.intrabc_used; cpi->deltaq_used |= cpi->td.deltaq_used; } @@ -1047,6 +1093,16 @@ aom_free(cpi->td.mb.txfm_search_info.txb_rd_records); cpi->td.mb.txfm_search_info.txb_rd_records = NULL; } + for (int plane = 0; plane < num_planes; plane++) { + if (cpi->td.mb.plane[plane].src_diff) { + aom_free(cpi->td.mb.plane[plane].src_diff); + cpi->td.mb.plane[plane].src_diff = NULL; + } + } + aom_free(cpi->td.mb.e_mbd.seg_mask); + cpi->td.mb.e_mbd.seg_mask = NULL; + aom_free(cpi->td.mb.winner_mode_stats); + cpi->td.mb.winner_mode_stats = NULL; } // Set the relative distance of a reference frame w.r.t. current frame @@ -1377,6 +1433,10 @@ // base_qindex cm->delta_q_info.delta_q_present_flag &= quant_params->base_qindex > 0; cm->delta_q_info.delta_lf_present_flag &= quant_params->base_qindex > 0; + } else { + cpi->cyclic_refresh->actual_num_seg1_blocks = 0; + cpi->cyclic_refresh->actual_num_seg2_blocks = 0; + cpi->cyclic_refresh->cnt_zeromv = 0; } av1_frame_init_quantizer(cpi);
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c index 6251233..232db44 100644 --- a/av1/encoder/encodeframe_utils.c +++ b/av1/encoder/encodeframe_utils.c
@@ -256,14 +256,26 @@ // Else for cyclic refresh mode update the segment map, set the segment id // and then update the quantizer. if (cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ) { - av1_cyclic_refresh_update_segment(cpi, mi_addr, mi_row, mi_col, bsize, + av1_cyclic_refresh_update_segment(cpi, x, mi_row, mi_col, bsize, ctx->rd_stats.rate, ctx->rd_stats.dist, - txfm_info->skip_txfm); + txfm_info->skip_txfm, dry_run); } if (mi_addr->uv_mode == UV_CFL_PRED && !is_cfl_allowed(xd)) mi_addr->uv_mode = UV_DC_PRED; } + // Count zero motion vector. + if (!dry_run && cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ && + !frame_is_intra_only(cm)) { + const MV mv = mi->mv[0].as_mv; + if (is_inter_block(mi) && mi->ref_frame[0] == LAST_FRAME && + abs(mv.row) < 8 && abs(mv.col) < 8) { + const int ymis = AOMMIN(cm->mi_params.mi_rows - mi_row, bh); + // Accumulate low_content_frame. + for (int mi_y = 0; mi_y < ymis; mi_y += 2) x->cnt_zeromv += bw << 1; + } + } + for (i = 0; i < num_planes; ++i) { p[i].coeff = ctx->coeff[i]; p[i].qcoeff = ctx->qcoeff[i]; @@ -1282,30 +1294,32 @@ #endif // CONFIG_INTERNAL_STATS } -// Checks for skip status of mv cost update. -static int skip_mv_cost_update(AV1_COMP *cpi, const TileInfo *const tile_info, - const int mi_row, const int mi_col) { - // mv_cost_upd_level=0: update happens at each sb, - // so return skip status as 0. - // mv_cost_upd_level=1: update happens once for each sb row, - // so return skip status as 1 for - // mi_col != tile_info->mi_col_start. - // mv_cost_upd_level=2: update happens once for a set of rows, - // so return skip status as 1 appropriately. - if (!cpi->sf.inter_sf.mv_cost_upd_level) return 0; +/*! Checks whether to skip updating the entropy cost based on tile info. + * + * This function contains codes common to both \ref skip_mv_cost_update and + * \ref skip_dv_cost_update. + */ +static int skip_cost_update(const SequenceHeader *seq_params, + const TileInfo *const tile_info, const int mi_row, + const int mi_col, + INTERNAL_COST_UPDATE_TYPE upd_level) { + if (upd_level == INTERNAL_COST_UPD_SB) return 0; + if (upd_level == INTERNAL_COST_UPD_OFF) return 1; + + // upd_level is at most as frequent as each sb_row in a tile. if (mi_col != tile_info->mi_col_start) return 1; - if (cpi->sf.inter_sf.mv_cost_upd_level == 2) { - AV1_COMMON *const cm = &cpi->common; - const int mib_size_log2 = cm->seq_params.mib_size_log2; + + if (upd_level == INTERNAL_COST_UPD_SBROW_SET) { + const int mib_size_log2 = seq_params->mib_size_log2; const int sb_row = (mi_row - tile_info->mi_row_start) >> mib_size_log2; - const int sb_size = cm->seq_params.mib_size * MI_SIZE; + const int sb_size = seq_params->mib_size * MI_SIZE; const int tile_height = (tile_info->mi_row_end - tile_info->mi_row_start) * MI_SIZE; - // When mv_cost_upd_level = 2, the cost update happens once for 2, 4 sb - // rows for sb size 128, sb size 64 respectively. However, as the update - // will not be equally spaced in smaller resolutions making it equally - // spaced by calculating (mv_num_rows_cost_update) the number of rows - // after which the cost update should happen. + // When upd_level = INTERNAL_COST_UPD_SBROW_SET, the cost update happens + // once for 2, 4 sb rows for sb size 128, sb size 64 respectively. However, + // as the update will not be equally spaced in smaller resolutions making + // it equally spaced by calculating (mv_num_rows_cost_update) the number of + // rows after which the cost update should happen. const int sb_size_update_freq_map[2] = { 2, 4 }; const int update_freq_sb_rows = sb_size_update_freq_map[sb_size != MAX_SB_SIZE]; @@ -1322,6 +1336,32 @@ return 0; } +// Checks for skip status of mv cost update. +static int skip_mv_cost_update(AV1_COMP *cpi, const TileInfo *const tile_info, + const int mi_row, const int mi_col) { + const AV1_COMMON *cm = &cpi->common; + // For intra frames, mv cdfs are not updated during the encode. Hence, the mv + // cost calculation is skipped in this case. + if (frame_is_intra_only(cm)) return 1; + + return skip_cost_update(&cm->seq_params, tile_info, mi_row, mi_col, + cpi->sf.inter_sf.mv_cost_upd_level); +} + +// Checks for skip status of dv cost update. +static int skip_dv_cost_update(AV1_COMP *cpi, const TileInfo *const tile_info, + const int mi_row, const int mi_col) { + const AV1_COMMON *cm = &cpi->common; + // Intrabc is only applicable to intra frames. So skip if intrabc is not + // allowed. + if (!av1_allow_intrabc(cm) || is_stat_generation_stage(cpi)) { + return 1; + } + + return skip_cost_update(&cm->seq_params, tile_info, mi_row, mi_col, + cpi->sf.intra_sf.dv_cost_upd_level); +} + // Update the rate costs of some symbols according to the frequency directed // by speed features void av1_set_cost_upd_freq(AV1_COMP *cpi, ThreadData *td, @@ -1367,9 +1407,25 @@ case COST_UPD_SB: // SB level // Checks for skip status of mv cost update. if (skip_mv_cost_update(cpi, tile_info, mi_row, mi_col)) break; - av1_fill_mv_costs(xd->tile_ctx, cm->features.cur_frame_force_integer_mv, + av1_fill_mv_costs(&xd->tile_ctx->nmvc, + cm->features.cur_frame_force_integer_mv, cm->features.allow_high_precision_mv, x->mv_costs); break; default: assert(0); } + + switch (cpi->oxcf.cost_upd_freq.dv) { + case COST_UPD_OFF: + case COST_UPD_TILE: // Tile level + break; + case COST_UPD_SBROW: // SB row level in tile + if (mi_col != tile_info->mi_col_start) break; + AOM_FALLTHROUGH_INTENDED; + case COST_UPD_SB: // SB level + // Checks for skip status of dv cost update. + if (skip_dv_cost_update(cpi, tile_info, mi_row, mi_col)) break; + av1_fill_dv_costs(&xd->tile_ctx->ndvc, x->dv_costs); + break; + default: assert(0); + } }
diff --git a/av1/encoder/encodeframe_utils.h b/av1/encoder/encodeframe_utils.h index a08b89e..7bdfad5 100644 --- a/av1/encoder/encodeframe_utils.h +++ b/av1/encoder/encodeframe_utils.h
@@ -344,8 +344,11 @@ unsigned int num_refs_to_disable = 0; if (cpi->sf.inter_sf.selective_ref_frame >= 3) { num_refs_to_disable++; - if (cpi->sf.inter_sf.selective_ref_frame >= 5 && - *ref_frame_flags & av1_ref_frame_flag_list[LAST2_FRAME]) { + if (cpi->sf.inter_sf.selective_ref_frame >= 6) { + // Disable LAST2_FRAME and ALTREF2_FRAME + num_refs_to_disable += 2; + } else if (cpi->sf.inter_sf.selective_ref_frame == 5 && + *ref_frame_flags & av1_ref_frame_flag_list[LAST2_FRAME]) { const int last2_frame_dist = av1_encoder_get_relative_dist( ref_display_order_hint[LAST2_FRAME - LAST_FRAME], cur_frame_display_index);
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c index c9ee220..91b5974 100644 --- a/av1/encoder/encodemb.c +++ b/av1/encoder/encodemb.c
@@ -513,15 +513,17 @@ const int bsw = tx_size_wide_unit[sub_txs]; const int bsh = tx_size_high_unit[sub_txs]; const int step = bsh * bsw; + const int row_end = + AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); + const int col_end = + AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); assert(bsw > 0 && bsh > 0); - for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { - for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { - const int offsetr = blk_row + row; + for (int row = 0; row < row_end; row += bsh) { + const int offsetr = blk_row + row; + for (int col = 0; col < col_end; col += bsw) { const int offsetc = blk_col + col; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; - encode_block_inter(plane, block, offsetr, offsetc, plane_bsize, sub_txs, arg, dry_run); block += step;
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c index 8f8733e..c37ed29 100644 --- a/av1/encoder/encoder.c +++ b/av1/encoder/encoder.c
@@ -308,7 +308,7 @@ if (!is_stat_generation_stage(cpi)) alloc_context_buffers_ext(cm, &cpi->mbmi_ext_info); - if (!cpi->seq_params_locked) + if (!cpi->ppi->seq_params_locked) set_sb_size(&cm->seq_params, av1_select_sb_size(cpi)); set_tile_info(cm, &cpi->oxcf.tile_cfg); @@ -754,7 +754,7 @@ int sb_size = seq_params->sb_size; // Superblock size should not be updated after the first key frame. - if (!cpi->seq_params_locked) { + if (!cpi->ppi->seq_params_locked) { set_sb_size(&cm->seq_params, av1_select_sb_size(cpi)); for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) seq_params->tier[i] = (oxcf->tier_mask >> i) & 1; @@ -790,7 +790,7 @@ // Init sequence level coding tools // This should not be called after the first key frame. - if (!cpi->seq_params_locked) { + if (!cpi->ppi->seq_params_locked) { seq_params->operating_points_cnt_minus_1 = (cm->number_spatial_layers > 1 || cm->number_temporal_layers > 1) ? cm->number_spatial_layers * cm->number_temporal_layers - 1 @@ -834,7 +834,19 @@ } } -AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf, BufferPool *const pool, +AV1_PRIMARY *av1_create_primary_compressor( + struct aom_codec_pkt_list *pkt_list_head) { + AV1_PRIMARY *volatile const ppi = aom_memalign(32, sizeof(AV1_PRIMARY)); + if (!ppi) return NULL; + av1_zero(*ppi); + + ppi->seq_params_locked = 0; + ppi->output_pkt_list = pkt_list_head; + return ppi; +} + +AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi, AV1EncoderConfig *oxcf, + BufferPool *const pool, FIRSTPASS_STATS *frame_stats_buf, COMPRESSOR_STAGE stage, int num_lap_buffers, int lap_lag_in_frames, @@ -846,6 +858,8 @@ av1_zero(*cpi); + cpi->ppi = ppi; + // The jmp_buf is valid only for the duration of the function that calls // setjmp(). Therefore, this function must reset the 'setjmp' field to 0 // before it returns. @@ -908,7 +922,6 @@ cm->current_frame.frame_number = 0; cm->current_frame_id = -1; - cpi->seq_params_locked = 0; cpi->partition_search_skippable_frame = 0; cpi->tile_data = NULL; cpi->last_show_frame_buf = NULL; @@ -1066,16 +1079,33 @@ cpi->vmaf_info.last_frame_vmaf[i] = -1.0; } cpi->vmaf_info.original_qindex = -1; - -#if CONFIG_USE_VMAF_RC cpi->vmaf_info.vmaf_model = NULL; -#endif } #endif - if (!is_stat_generation_stage(cpi)) { - setup_tpl_buffers(cm, &cpi->tpl_data, cpi->oxcf.gf_cfg.lag_in_frames); +#if CONFIG_TUNE_BUTTERAUGLI + { + const int w = mi_size_wide[butteraugli_rdo_bsize]; + const int h = mi_size_high[butteraugli_rdo_bsize]; + const int num_cols = (mi_params->mi_cols + w - 1) / w; + const int num_rows = (mi_params->mi_rows + h - 1) / h; + CHECK_MEM_ERROR( + cm, cpi->butteraugli_info.rdmult_scaling_factors, + aom_malloc(num_rows * num_cols * + sizeof(*cpi->butteraugli_info.rdmult_scaling_factors))); + memset(&cpi->butteraugli_info.source, 0, + sizeof(cpi->butteraugli_info.source)); + memset(&cpi->butteraugli_info.resized_source, 0, + sizeof(cpi->butteraugli_info.resized_source)); + cpi->butteraugli_info.recon_set = false; } +#endif + +#if !CONFIG_REALTIME_ONLY + if (!is_stat_generation_stage(cpi)) { + av1_setup_tpl_buffers(cm, &cpi->tpl_data, cpi->oxcf.gf_cfg.lag_in_frames); + } +#endif #if CONFIG_COLLECT_PARTITION_STATS av1_zero(cpi->partition_stats); @@ -1390,6 +1420,12 @@ } } +void av1_remove_primary_compressor(AV1_PRIMARY *ppi) { + if (!ppi) return; + av1_lookahead_destroy(ppi->lookahead); + aom_free(ppi); +} + void av1_remove_compressor(AV1_COMP *cpi) { if (!cpi) return; @@ -1630,7 +1666,7 @@ #endif pkt.kind = AOM_CODEC_PSNR_PKT; - aom_codec_pkt_list_add(cpi->output_pkt_list, &pkt); + aom_codec_pkt_list_add(cpi->ppi->output_pkt_list, &pkt); } int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags) { @@ -1848,7 +1884,7 @@ cpi->oxcf.frm_dim_cfg.height != cm->height) || av1_superres_scaled(cm)) ? y_stride - : cpi->lookahead->buf->img.y_stride; + : cpi->ppi->lookahead->buf->img.y_stride; int fpf_y_stride = cm->cur_frame != NULL ? cm->cur_frame->buf.y_stride : cpi->scaled_source.y_stride; @@ -2050,7 +2086,7 @@ &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels, cm->features.byte_alignment, NULL, NULL, - NULL)) + NULL, cpi->oxcf.tool_cfg.enable_global_motion)) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate frame buffer"); @@ -2467,12 +2503,17 @@ if (!cpi->sf.hl_sf.disable_extra_sc_testing) av1_determine_sc_tools_with_encoding(cpi, q); -#if CONFIG_USE_VMAF_RC +#if CONFIG_TUNE_VMAF if (oxcf->tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN) { av1_vmaf_neg_preprocessing(cpi, cpi->unscaled_source); } #endif +#if CONFIG_TUNE_BUTTERAUGLI + cpi->butteraugli_info.recon_set = false; + int original_q = 0; +#endif + // Loop variables int loop = 0; int loop_count = 0; @@ -2497,6 +2538,20 @@ av1_scale_if_required(cm, cpi->unscaled_source, &cpi->scaled_source, EIGHTTAP_REGULAR, 0, false, false); +#if CONFIG_TUNE_BUTTERAUGLI + if (oxcf->tune_cfg.tuning == AOM_TUNE_BUTTERAUGLI) { + if (loop_count == 0) { + original_q = q; + // TODO(sdeng): different q here does not make big difference. Use a + // faster pass instead. + q = 96; + av1_setup_butteraugli_source(cpi); + } else { + q = original_q; + } + } +#endif + if (cpi->unscaled_last_source != NULL) { cpi->last_source = av1_scale_if_required( cm, cpi->unscaled_last_source, &cpi->scaled_last_source, @@ -2509,6 +2564,7 @@ } av1_scale_references(cpi, EIGHTTAP_REGULAR, 0, 0); } + #if CONFIG_TUNE_VMAF if (oxcf->tune_cfg.tuning >= AOM_TUNE_VMAF_WITH_PREPROCESSING && oxcf->tune_cfg.tuning <= AOM_TUNE_VMAF_NEG_MAX_GAIN) { @@ -2516,6 +2572,7 @@ q = av1_get_vmaf_base_qindex(cpi, q); } #endif + av1_set_quantizer(cm, q_cfg->qm_minlevel, q_cfg->qm_maxlevel, q, q_cfg->enable_chroma_deltaq); av1_set_speed_features_qindex_dependent(cpi, oxcf->speed); @@ -2627,6 +2684,13 @@ &low_cr_seen, loop_count); } +#if CONFIG_TUNE_BUTTERAUGLI + if (loop_count == 0 && oxcf->tune_cfg.tuning == AOM_TUNE_BUTTERAUGLI) { + loop = 1; + av1_restore_butteraugli_source(cpi); + } +#endif + if (loop) { ++loop_count; @@ -3045,7 +3109,7 @@ cm->ref_frame_id[i] = display_frame_id; } - cpi->seq_params_locked = 1; + cpi->ppi->seq_params_locked = 1; #if DUMP_RECON_FRAMES == 1 // NOTE(zoeliu): For debug - Output the filtered reconstructed video. @@ -3132,8 +3196,9 @@ } } - if (oxcf->tune_cfg.tuning == AOM_TUNE_SSIM) + if (oxcf->tune_cfg.tuning == AOM_TUNE_SSIM) { av1_set_mb_ssim_rdmult_scaling(cpi); + } #if CONFIG_TUNE_VMAF if (oxcf->tune_cfg.tuning == AOM_TUNE_VMAF_WITHOUT_PREPROCESSING || @@ -3192,7 +3257,7 @@ // compression loss). // TODO(huisu@google.com): design schemes for various trade-offs between // compression quality and decoding speed. - if (oxcf->mode == GOOD) { + if (oxcf->mode == GOOD || oxcf->mode == ALLINTRA) { features->disable_cdf_update = (frame_is_intra_only(cm) || !cm->show_frame) ? 0 : 1; } else { @@ -3224,7 +3289,7 @@ cpi->superres_mode = orig_superres_mode; // restore } - cpi->seq_params_locked = 1; + cpi->ppi->seq_params_locked = 1; // Update reference frame ids for reference frames this frame will overwrite if (seq_params->frame_id_numbers_present_flag) { @@ -3445,7 +3510,7 @@ res = -1; #endif // CONFIG_DENOISE - if (av1_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, + if (av1_lookahead_push(cpi->ppi->lookahead, sd, time_stamp, end_time, use_highbitdepth, frame_flags)) res = -1; #if CONFIG_INTERNAL_STATS @@ -3503,6 +3568,10 @@ 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 (cpi->use_svc && + cpi->svc.spatial_layer_id < cpi->svc.number_spatial_layers - 1) + return; + #if CONFIG_INTER_STATS_ONLY if (cm->current_frame.frame_type == KEY_FRAME) return; // skip key frame #endif
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h index 2bc1626..b3135dc 100644 --- a/av1/encoder/encoder.h +++ b/av1/encoder/encoder.h
@@ -63,6 +63,9 @@ #if CONFIG_AV1_TEMPORAL_DENOISING #include "av1/encoder/av1_temporal_denoiser.h" #endif +#if CONFIG_TUNE_BUTTERAUGLI +#include "av1/encoder/tune_butteraugli.h" +#endif #include "aom/internal/aom_codec_internal.h" #include "aom_util/aom_thread.h" @@ -100,7 +103,9 @@ GOOD, // Realtime Fast Encoding. Will force some restrictions on bitrate // constraints. - REALTIME + REALTIME, + // All intra mode. All the frames are coded as intra frames. + ALLINTRA } UENUM1BYTE(MODE); enum { @@ -154,13 +159,6 @@ /*!\cond */ typedef enum { - COST_UPD_SB, - COST_UPD_SBROW, - COST_UPD_TILE, - COST_UPD_OFF, -} COST_UPDATE_TYPE; - -typedef enum { MOD_FP, // First pass MOD_TF, // Temporal filtering MOD_TPL, // TPL @@ -174,6 +172,16 @@ /*!\endcond */ +/*!\enum COST_UPDATE_TYPE + * \brief This enum controls how often the entropy costs should be updated. + */ +typedef enum { + COST_UPD_SB, /*!< Update every sb. */ + COST_UPD_SBROW, /*!< Update every sb rows inside a tile. */ + COST_UPD_TILE, /*!< Update every tile. */ + COST_UPD_OFF, /*!< Turn off cost updates. */ +} COST_UPDATE_TYPE; + /*! * \brief Encoder config related to resize. */ @@ -248,6 +256,10 @@ */ bool enable_cfl_intra; /*! + * Flag to indicate if D45 to D203 intra prediction modes should be enabled. + */ + bool enable_diagonal_intra; + /*! * Flag to indicate if delta angles for directional intra prediction should be * enabled. */ @@ -614,6 +626,8 @@ COST_UPDATE_TYPE mode; // Indicates the update frequency for mv costs. COST_UPDATE_TYPE mv; + // Indicates the update frequency for dv costs. + COST_UPDATE_TYPE dv; } CostUpdateFreq; typedef struct { @@ -1294,6 +1308,7 @@ int32_t num_64x64_blocks; PICK_MODE_CONTEXT *firstpass_ctx; TemporalFilterData tf_data; + TplTxfmStats tpl_txfm_stats; } ThreadData; struct EncWorkerData; @@ -2037,10 +2052,53 @@ } CoeffBufferPool; /*! + * \brief Top level primary encoder structure + */ +typedef struct AV1_PRIMARY { + /*! + * Encode stage top level structure + */ + struct AV1_COMP *cpi; + + /*! + * Lookahead processing stage top level structure + */ + struct AV1_COMP *cpi_lap; + + /*! + * Look-ahead context. + */ + struct lookahead_ctx *lookahead; + + /*! + * Sequence parameters have been transmitted already and locked + * or not. Once locked av1_change_config cannot change the seq + * parameters. + */ + int seq_params_locked; + + /*! + * Pointer to internal utility functions that manipulate aom_codec_* data + * structures. + */ + struct aom_codec_pkt_list *output_pkt_list; + + /*! + * When set, indicates that internal ARFs are enabled. + */ + int internal_altref_allowed; +} AV1_PRIMARY; + +/*! * \brief Top level encoder structure. */ typedef struct AV1_COMP { /*! + * Pointer to top level primary encoder structure + */ + AV1_PRIMARY *ppi; + + /*! * Quantization and dequantization parameters for internal quantizer setup * in the encoder. */ @@ -2085,11 +2143,6 @@ AV1EncoderConfig oxcf; /*! - * Look-ahead context. - */ - struct lookahead_ctx *lookahead; - - /*! * When set, this flag indicates that the current frame is a forward keyframe. */ int no_show_fwd_kf; @@ -2109,7 +2162,10 @@ /*! * Pointer to the frame buffer holding the last raw source frame. - * NULL for first frame and alt_ref frames. + * last_source is NULL for the following cases: + * 1) First frame + * 2) Alt-ref frames + * 3) All frames for all-intra frame encoding. */ YV12_BUFFER_CONFIG *last_source; @@ -2243,12 +2299,6 @@ double framerate; /*! - * Pointer to internal utility functions that manipulate aom_codec_* data - * structures. - */ - struct aom_codec_pkt_list *output_pkt_list; - - /*! * Bitmask indicating which reference buffers may be referenced by this frame. */ int ref_frame_flags; @@ -2426,13 +2476,6 @@ TokenInfo token_info; /*! - * Sequence parameters have been transmitted already and locked - * or not. Once locked av1_change_config cannot change the seq - * parameters. - */ - int seq_params_locked; - - /*! * VARIANCE_AQ segment map refresh. */ int vaq_refresh; @@ -2460,21 +2503,11 @@ int existing_fb_idx_to_show; /*! - * When set, indicates that internal ARFs are enabled. - */ - int internal_altref_allowed; - - /*! * A flag to indicate if intrabc is ever used in current frame. */ int intrabc_used; /*! - * Tables to calculate IntraBC MV cost. - */ - IntraBCMVCosts dv_costs; - - /*! * Mark which ref frames can be skipped for encoding current frame during RDO. */ int prune_ref_frame_mask; @@ -2581,6 +2614,13 @@ TuneVMAFInfo vmaf_info; #endif +#if CONFIG_TUNE_BUTTERAUGLI + /*! + * Parameters for Butteraugli tuning. + */ + TuneButteraugliInfo butteraugli_info; +#endif + /*! * Indicates whether to use SVC. */ @@ -2655,6 +2695,12 @@ * Block size of first pass encoding */ BLOCK_SIZE fp_block_size; + + /*! + * The counter of encoded super block, used to differentiate block names. + * This number starts from 0 and increases whenever a super block is encoded. + */ + int sb_counter; } AV1_COMP; /*! @@ -2732,15 +2778,21 @@ // Must not be called more than once. void av1_initialize_enc(void); -struct AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf, +struct AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi, AV1EncoderConfig *oxcf, BufferPool *const pool, FIRSTPASS_STATS *frame_stats_buf, COMPRESSOR_STAGE stage, int num_lap_buffers, int lap_lag_in_frames, STATS_BUFFER_CTX *stats_buf_context); + +struct AV1_PRIMARY *av1_create_primary_compressor( + struct aom_codec_pkt_list *pkt_list_head); + void av1_remove_compressor(AV1_COMP *cpi); +void av1_remove_primary_compressor(AV1_PRIMARY *ppi); + void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf); void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth, @@ -2925,17 +2977,6 @@ return buf != NULL ? &buf->buf : NULL; } -static INLINE int enc_is_ref_frame_buf(const AV1_COMMON *const cm, - const RefCntBuffer *const frame_buf) { - MV_REFERENCE_FRAME ref_frame; - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); - if (buf == NULL) continue; - if (frame_buf == buf) break; - } - return (ref_frame <= ALTREF_FRAME); -} - static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) { assert(buf != NULL); ensure_mv_buffer(buf, cm);
diff --git a/av1/encoder/encoder_alloc.h b/av1/encoder/encoder_alloc.h index 15f4ac9..ef24a31 100644 --- a/av1/encoder/encoder_alloc.h +++ b/av1/encoder/encoder_alloc.h
@@ -78,6 +78,13 @@ CHECK_MEM_ERROR(cm, cpi->td.mb.mv_costs, (MvCosts *)aom_calloc(1, sizeof(MvCosts))); + if (cpi->td.mb.dv_costs) { + aom_free(cpi->td.mb.dv_costs); + cpi->td.mb.dv_costs = NULL; + } + CHECK_MEM_ERROR(cm, cpi->td.mb.dv_costs, + (IntraBCMVCosts *)aom_malloc(sizeof(*cpi->td.mb.dv_costs))); + av1_setup_shared_coeff_buffer(&cpi->common, &cpi->td.shared_coeff_buf); av1_setup_sms_tree(cpi, &cpi->td); cpi->td.firstpass_ctx = @@ -105,64 +112,6 @@ aom_calloc(mi_params->mi_rows * mi_params->mi_cols, 1)); } -static AOM_INLINE void set_tpl_stats_block_size(uint8_t *block_mis_log2, - uint8_t *tpl_bsize_1d) { - // tpl stats bsize: 2 means 16x16 - *block_mis_log2 = 2; - // Block size used in tpl motion estimation - *tpl_bsize_1d = 16; - // MIN_TPL_BSIZE_1D = 16; - assert(*tpl_bsize_1d >= 16); -} - -static AOM_INLINE void setup_tpl_buffers(AV1_COMMON *const cm, - TplParams *const tpl_data, - int lag_in_frames) { - CommonModeInfoParams *const mi_params = &cm->mi_params; - set_tpl_stats_block_size(&tpl_data->tpl_stats_block_mis_log2, - &tpl_data->tpl_bsize_1d); - const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2; - tpl_data->border_in_pixels = - ALIGN_POWER_OF_TWO(tpl_data->tpl_bsize_1d + 2 * AOM_INTERP_EXTEND, 5); - - for (int frame = 0; frame < MAX_LENGTH_TPL_FRAME_STATS; ++frame) { - const int mi_cols = - ALIGN_POWER_OF_TWO(mi_params->mi_cols, MAX_MIB_SIZE_LOG2); - const int mi_rows = - ALIGN_POWER_OF_TWO(mi_params->mi_rows, MAX_MIB_SIZE_LOG2); - - tpl_data->tpl_stats_buffer[frame].is_valid = 0; - tpl_data->tpl_stats_buffer[frame].width = mi_cols >> block_mis_log2; - tpl_data->tpl_stats_buffer[frame].height = mi_rows >> block_mis_log2; - tpl_data->tpl_stats_buffer[frame].stride = - tpl_data->tpl_stats_buffer[frame].width; - tpl_data->tpl_stats_buffer[frame].mi_rows = mi_params->mi_rows; - tpl_data->tpl_stats_buffer[frame].mi_cols = mi_params->mi_cols; - } - tpl_data->tpl_frame = &tpl_data->tpl_stats_buffer[REF_FRAMES + 1]; - - // If lag_in_frames <= 1, TPL module is not invoked. Hence tpl recon and - // stats buffers are not allocated. - if (lag_in_frames <= 1) return; - - // TODO(aomedia:2873): Explore the allocation of tpl buffers based on - // lag_in_frames. - for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) { - CHECK_MEM_ERROR( - cm, tpl_data->tpl_stats_pool[frame], - aom_calloc(tpl_data->tpl_stats_buffer[frame].width * - tpl_data->tpl_stats_buffer[frame].height, - sizeof(*tpl_data->tpl_stats_buffer[frame].tpl_stats_ptr))); - if (aom_alloc_frame_buffer( - &tpl_data->tpl_rec_pool[frame], cm->width, cm->height, - cm->seq_params.subsampling_x, cm->seq_params.subsampling_y, - cm->seq_params.use_highbitdepth, tpl_data->border_in_pixels, - cm->features.byte_alignment)) - aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, - "Failed to allocate frame buffer"); - } -} - static AOM_INLINE void alloc_obmc_buffers(OBMCBuffer *obmc_buffer, AV1_COMMON *cm) { CHECK_MEM_ERROR( @@ -253,10 +202,14 @@ #if CONFIG_TUNE_VMAF aom_free(cpi->vmaf_info.rdmult_scaling_factors); cpi->vmaf_info.rdmult_scaling_factors = NULL; - -#if CONFIG_USE_VMAF_RC - aom_close_vmaf_model_rc(cpi->vmaf_info.vmaf_model); + aom_close_vmaf_model(cpi->vmaf_info.vmaf_model); #endif + +#if CONFIG_TUNE_BUTTERAUGLI + aom_free(cpi->butteraugli_info.rdmult_scaling_factors); + cpi->butteraugli_info.rdmult_scaling_factors = NULL; + aom_free_frame_buffer(&cpi->butteraugli_info.source); + aom_free_frame_buffer(&cpi->butteraugli_info.resized_source); #endif release_obmc_buffers(&cpi->td.mb.obmc_buffer); @@ -266,6 +219,11 @@ cpi->td.mb.mv_costs = NULL; } + if (cpi->td.mb.dv_costs) { + aom_free(cpi->td.mb.dv_costs); + cpi->td.mb.dv_costs = NULL; + } + aom_free(cpi->td.mb.inter_modes_info); cpi->td.mb.inter_modes_info = NULL; @@ -298,7 +256,6 @@ aom_free_frame_buffer(&cpi->scaled_source); aom_free_frame_buffer(&cpi->scaled_last_source); aom_free_frame_buffer(&cpi->alt_ref_buffer); - av1_lookahead_destroy(cpi->lookahead); free_token_info(token_info); @@ -367,7 +324,7 @@ oxcf->frm_dim_cfg.height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels, cm->features.byte_alignment, NULL, NULL, - NULL)) + NULL, cpi->oxcf.tool_cfg.enable_global_motion)) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate altref buffer"); } @@ -379,7 +336,7 @@ if (aom_realloc_frame_buffer( &cpi->last_frame_uf, cm->width, cm->height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, - cpi->oxcf.border_in_pixels, byte_alignment, NULL, NULL, NULL)) + cpi->oxcf.border_in_pixels, byte_alignment, NULL, NULL, NULL, 0)) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate last frame buffer"); @@ -393,7 +350,7 @@ &cpi->trial_frame_rst, cm->superres_upscaled_width, cm->superres_upscaled_height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, - AOM_RESTORATION_FRAME_BORDER, byte_alignment, NULL, NULL, NULL)) + AOM_RESTORATION_FRAME_BORDER, byte_alignment, NULL, NULL, NULL, 0)) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate trial restored frame buffer"); } @@ -401,17 +358,27 @@ if (aom_realloc_frame_buffer( &cpi->scaled_source, cm->width, cm->height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, - cpi->oxcf.border_in_pixels, byte_alignment, NULL, NULL, NULL)) + cpi->oxcf.border_in_pixels, byte_alignment, NULL, NULL, NULL, + cpi->oxcf.tool_cfg.enable_global_motion)) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate scaled source buffer"); - if (aom_realloc_frame_buffer( - &cpi->scaled_last_source, cm->width, cm->height, - seq_params->subsampling_x, seq_params->subsampling_y, - seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels, - byte_alignment, NULL, NULL, NULL)) - aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, - "Failed to allocate scaled last source buffer"); + // The frame buffer cpi->scaled_last_source is used to hold the previous + // source frame information. As the previous source frame buffer allocation in + // the lookahead queue is avoided for all-intra frame encoding, + // cpi->unscaled_last_source will be NULL in such cases. As + // cpi->unscaled_last_source is NULL, cpi->scaled_last_source will not be used + // for all-intra frame encoding. Hence, the buffer is allocated conditionally. + if (cpi->oxcf.kf_cfg.key_freq_max > 0) { + if (aom_realloc_frame_buffer( + &cpi->scaled_last_source, cm->width, cm->height, + seq_params->subsampling_x, seq_params->subsampling_y, + seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels, + byte_alignment, NULL, NULL, NULL, + cpi->oxcf.tool_cfg.enable_global_motion)) + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate scaled last source buffer"); + } } static AOM_INLINE YV12_BUFFER_CONFIG *realloc_and_scale_source( @@ -428,7 +395,8 @@ &cpi->scaled_source, scaled_width, scaled_height, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y, cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS, - cm->features.byte_alignment, NULL, NULL, NULL)) + cm->features.byte_alignment, NULL, NULL, NULL, + cpi->oxcf.tool_cfg.enable_global_motion)) aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to reallocate scaled source buffer"); assert(cpi->scaled_source.y_crop_width == scaled_width);
diff --git a/av1/encoder/encoder_utils.c b/av1/encoder/encoder_utils.c index 3ed9e7f..c3d0cf8 100644 --- a/av1/encoder/encoder_utils.c +++ b/av1/encoder/encoder_utils.c
@@ -665,7 +665,7 @@ &new_fb->buf, cm->width, cm->height, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y, cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS, - cm->features.byte_alignment, NULL, NULL, NULL)) { + cm->features.byte_alignment, NULL, NULL, NULL, 0)) { if (force_scaling) { // Release the reference acquired in the get_free_fb() call above. --new_fb->ref_count; @@ -753,7 +753,7 @@ if ((cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) || frame_is_sframe(cm)) { - if (!cpi->seq_params_locked) { + if (!cpi->ppi->seq_params_locked) { set_sb_size(&cm->seq_params, av1_select_sb_size(cpi)); } } else {
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c index c906d6b..7b0b281 100644 --- a/av1/encoder/encodetxb.c +++ b/av1/encoder/encodetxb.c
@@ -486,7 +486,11 @@ const TX_TYPE default_type = get_default_tx_type( PLANE_TYPE_Y, xd, tx_size, cpi->use_screen_content_tools); (void)default_type; - assert(tx_type == default_type); + // TODO(kyslov): We don't always respect use_intra_default_tx_only flag in + // NonRD case. Specifically we ignore it in hybrid inta mode search and + // when picking up intra mode in nonRD inter mode search. We need to fix + // it in these two places. Meanwhile relieving the assert. + assert(tx_type == default_type || cpi->sf.rt_sf.use_nonrd_pick_mode); } }
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c index 0a9325c..d5816bf 100644 --- a/av1/encoder/ethread.c +++ b/av1/encoder/ethread.c
@@ -625,10 +625,6 @@ alloc_compound_type_rd_buffers(cm, &thread_data->td->comp_rd_buffer); - CHECK_MEM_ERROR( - cm, thread_data->td->tmp_conv_dst, - aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE * - sizeof(*thread_data->td->tmp_conv_dst))); for (int j = 0; j < 2; ++j) { CHECK_MEM_ERROR( cm, thread_data->td->tmp_pred_bufs[j], @@ -680,6 +676,10 @@ // Set up shared coeff buffers. av1_setup_shared_coeff_buffer(cm, &thread_data->td->shared_coeff_buf); + CHECK_MEM_ERROR( + cm, thread_data->td->tmp_conv_dst, + aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE * + sizeof(*thread_data->td->tmp_conv_dst))); } ++mt_info->num_workers; } @@ -775,14 +775,34 @@ EncWorkerData *const thread_data = (EncWorkerData *)worker->data1; cpi->intrabc_used |= thread_data->td->intrabc_used; cpi->deltaq_used |= thread_data->td->deltaq_used; + // Accumulate cyclic refresh params. + if (cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ && + !frame_is_intra_only(&cpi->common)) + av1_accumulate_cyclic_refresh_counters(cpi->cyclic_refresh, + &thread_data->td->mb); if (thread_data->td->mb.txfm_search_info.txb_rd_records) { aom_free(thread_data->td->mb.txfm_search_info.txb_rd_records); thread_data->td->mb.txfm_search_info.txb_rd_records = NULL; } - if (thread_data->td != &cpi->td && - cpi->oxcf.cost_upd_freq.mv < COST_UPD_OFF) { - aom_free(thread_data->td->mb.mv_costs); + if (thread_data->td != &cpi->td) { + if (cpi->oxcf.cost_upd_freq.mv < COST_UPD_OFF) { + aom_free(thread_data->td->mb.mv_costs); + } + if (cpi->oxcf.cost_upd_freq.dv < COST_UPD_OFF) { + aom_free(thread_data->td->mb.dv_costs); + } } + const int num_planes = av1_num_planes(&cpi->common); + for (int plane = 0; plane < num_planes; plane++) { + if (thread_data->td->mb.plane[plane].src_diff) { + aom_free(thread_data->td->mb.plane[plane].src_diff); + thread_data->td->mb.plane[plane].src_diff = NULL; + } + } + aom_free(thread_data->td->mb.e_mbd.seg_mask); + thread_data->td->mb.e_mbd.seg_mask = NULL; + aom_free(thread_data->td->mb.winner_mode_stats); + thread_data->td->mb.winner_mode_stats = NULL; // Accumulate counters. if (i > 0) { @@ -841,7 +861,39 @@ memcpy(thread_data->td->mb.mv_costs, cpi->td.mb.mv_costs, sizeof(MvCosts)); } + if (cpi->oxcf.cost_upd_freq.dv < COST_UPD_OFF) { + CHECK_MEM_ERROR(cm, thread_data->td->mb.dv_costs, + (IntraBCMVCosts *)aom_malloc(sizeof(IntraBCMVCosts))); + memcpy(thread_data->td->mb.dv_costs, cpi->td.mb.dv_costs, + sizeof(IntraBCMVCosts)); + } } + const int num_planes = av1_num_planes(&cpi->common); + for (int plane = 0; plane < num_planes; plane++) { + const int subsampling_xy = + plane ? cm->seq_params.subsampling_x + cm->seq_params.subsampling_y + : 0; + const int sb_size = MAX_SB_SQUARE >> subsampling_xy; + CHECK_MEM_ERROR( + cm, thread_data->td->mb.plane[plane].src_diff, + (int16_t *)aom_memalign( + 32, + sizeof(*thread_data->td->mb.plane[plane].src_diff) * sb_size)); + } + CHECK_MEM_ERROR(cm, thread_data->td->mb.e_mbd.seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * + sizeof(thread_data->td->mb.e_mbd.seg_mask[0]))); + const int winner_mode_count = frame_is_intra_only(cm) + ? MAX_WINNER_MODE_COUNT_INTRA + : MAX_WINNER_MODE_COUNT_INTER; + CHECK_MEM_ERROR(cm, thread_data->td->mb.winner_mode_stats, + (WinnerModeStats *)aom_malloc( + winner_mode_count * + sizeof(thread_data->td->mb.winner_mode_stats[0]))); + // Reset cyclic refresh counters. + av1_init_cyclic_refresh_counters(&thread_data->td->mb); + if (!cpi->sf.rt_sf.use_nonrd_pick_mode) { CHECK_MEM_ERROR(cm, thread_data->td->mb.txfm_search_info.txb_rd_records, (TxbRdRecords *)aom_malloc(sizeof(TxbRdRecords))); @@ -896,7 +948,37 @@ memcpy(thread_data->td->mb.mv_costs, cpi->td.mb.mv_costs, sizeof(MvCosts)); } + if (cpi->oxcf.cost_upd_freq.dv < COST_UPD_OFF) { + CHECK_MEM_ERROR(cm, thread_data->td->mb.dv_costs, + (IntraBCMVCosts *)aom_malloc(sizeof(IntraBCMVCosts))); + memcpy(thread_data->td->mb.dv_costs, cpi->td.mb.dv_costs, + sizeof(IntraBCMVCosts)); + } } + + const int num_planes = av1_num_planes(&cpi->common); + for (int plane = 0; plane < num_planes; plane++) { + const int subsampling_xy = + plane ? cm->seq_params.subsampling_x + cm->seq_params.subsampling_y + : 0; + const int sb_size = MAX_SB_SQUARE >> subsampling_xy; + CHECK_MEM_ERROR( + cm, thread_data->td->mb.plane[plane].src_diff, + (int16_t *)aom_memalign( + 32, + sizeof(*thread_data->td->mb.plane[plane].src_diff) * sb_size)); + } + CHECK_MEM_ERROR(cm, thread_data->td->mb.e_mbd.seg_mask, + (uint8_t *)aom_memalign( + 16, 2 * MAX_SB_SQUARE * + sizeof(thread_data->td->mb.e_mbd.seg_mask[0]))); + const int winner_mode_count = frame_is_intra_only(cm) + ? MAX_WINNER_MODE_COUNT_INTRA + : MAX_WINNER_MODE_COUNT_INTER; + CHECK_MEM_ERROR(cm, thread_data->td->mb.winner_mode_stats, + (WinnerModeStats *)aom_malloc( + winner_mode_count * + sizeof(thread_data->td->mb.winner_mode_stats[0]))); if (!cpi->sf.rt_sf.use_nonrd_pick_mode) { CHECK_MEM_ERROR(cm, thread_data->td->mb.txfm_search_info.txb_rd_records, (TxbRdRecords *)aom_malloc(sizeof(TxbRdRecords))); @@ -1183,13 +1265,28 @@ sync_enc_workers(&cpi->mt_info, cm, num_workers); for (int i = num_workers - 1; i >= 0; i--) { EncWorkerData *const thread_data = &cpi->mt_info.tile_thr_data[i]; - if (thread_data->td != &cpi->td && - cpi->oxcf.cost_upd_freq.mv < COST_UPD_OFF) { - aom_free(thread_data->td->mb.mv_costs); + if (thread_data->td != &cpi->td) { + if (cpi->oxcf.cost_upd_freq.mv < COST_UPD_OFF) { + aom_free(thread_data->td->mb.mv_costs); + } + if (cpi->oxcf.cost_upd_freq.dv < COST_UPD_OFF) { + aom_free(thread_data->td->mb.dv_costs); + } } if (thread_data->td->mb.txfm_search_info.txb_rd_records) { aom_free(thread_data->td->mb.txfm_search_info.txb_rd_records); } + const int num_planes = av1_num_planes(&cpi->common); + for (int plane = 0; plane < num_planes; plane++) { + if (thread_data->td->mb.plane[plane].src_diff) { + aom_free(thread_data->td->mb.plane[plane].src_diff); + thread_data->td->mb.plane[plane].src_diff = NULL; + } + } + aom_free(thread_data->td->mb.e_mbd.seg_mask); + thread_data->td->mb.e_mbd.seg_mask = NULL; + aom_free(thread_data->td->mb.winner_mode_stats); + thread_data->td->mb.winner_mode_stats = NULL; } } @@ -1269,11 +1366,15 @@ AV1_COMMON *cm = &cpi->common; MACROBLOCK *x = &thread_data->td->mb; MACROBLOCKD *xd = &x->e_mbd; + TplTxfmStats *tpl_txfm_stats = &thread_data->td->tpl_txfm_stats; CommonModeInfoParams *mi_params = &cm->mi_params; BLOCK_SIZE bsize = convert_length_to_bsize(cpi->tpl_data.tpl_bsize_1d); TX_SIZE tx_size = max_txsize_lookup[bsize]; int mi_height = mi_size_high[bsize]; int num_active_workers = cpi->tpl_data.tpl_mt_sync.num_threads_working; + + memset(tpl_txfm_stats, 0, sizeof(*tpl_txfm_stats)); + for (int mi_row = thread_data->start * mi_height; mi_row < mi_params->mi_rows; mi_row += num_active_workers * mi_height) { // Motion estimation row boundary @@ -1282,7 +1383,7 @@ xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_row * MI_SIZE); xd->mb_to_bottom_edge = GET_MV_SUBPEL((mi_params->mi_rows - mi_height - mi_row) * MI_SIZE); - av1_mc_flow_dispenser_row(cpi, x, mi_row, bsize, tx_size); + av1_mc_flow_dispenser_row(cpi, tpl_txfm_stats, x, mi_row, bsize, tx_size); } return 1; } @@ -1362,6 +1463,28 @@ // OBMC buffers are used only to init MS params and remain unused when // called from tpl, hence set the buffers to defaults. av1_init_obmc_buffer(&thread_data->td->mb.obmc_buffer); + thread_data->td->mb.tmp_conv_dst = thread_data->td->tmp_conv_dst; + thread_data->td->mb.e_mbd.tmp_conv_dst = thread_data->td->mb.tmp_conv_dst; + } + } +} + +// Accumulate transform stats after tpl. +static void tpl_accumulate_txfm_stats(AV1_COMP *cpi, int num_workers) { + double *total_abs_coeff_sum = cpi->td.tpl_txfm_stats.abs_coeff_sum; + int *txfm_block_count = &cpi->td.tpl_txfm_stats.txfm_block_count; + TplParams *tpl_data = &cpi->tpl_data; + int coeff_num = tpl_data->tpl_frame[tpl_data->frame_idx].coeff_num; + for (int i = num_workers - 1; i >= 0; i--) { + AVxWorker *const worker = &cpi->mt_info.workers[i]; + EncWorkerData *const thread_data = (EncWorkerData *)worker->data1; + ThreadData *td = thread_data->td; + if (td != &cpi->td) { + TplTxfmStats *tpl_txfm_stats = &td->tpl_txfm_stats; + *txfm_block_count += tpl_txfm_stats->txfm_block_count; + for (int j = 0; j < coeff_num; j++) { + total_abs_coeff_sum[j] += tpl_txfm_stats->abs_coeff_sum[j]; + } } } } @@ -1390,6 +1513,7 @@ prepare_tpl_workers(cpi, tpl_worker_hook, num_workers); launch_workers(&cpi->mt_info, num_workers); sync_enc_workers(&cpi->mt_info, cm, num_workers); + tpl_accumulate_txfm_stats(cpi, num_workers); } // Deallocate memory for temporal filter multi-thread synchronization.
diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c index e483b57..08fc498 100644 --- a/av1/encoder/firstpass.c +++ b/av1/encoder/firstpass.c
@@ -177,8 +177,9 @@ } void av1_end_first_pass(AV1_COMP *cpi) { - if (cpi->twopass.stats_buf_ctx->total_stats) - output_stats(cpi->twopass.stats_buf_ctx->total_stats, cpi->output_pkt_list); + if (cpi->twopass.stats_buf_ctx->total_stats && !cpi->lap_enabled) + output_stats(cpi->twopass.stats_buf_ctx->total_stats, + cpi->ppi->output_pkt_list); } static aom_variance_fn_t get_block_variance_fn(BLOCK_SIZE bsize) { @@ -482,9 +483,11 @@ const int hbd = is_cur_buf_hbd(xd); const int stride = x->plane[0].src.stride; - uint8_t *buf = x->plane[0].src.buf; - for (int r8 = 0; r8 < 2; ++r8) { - for (int c8 = 0; c8 < 2; ++c8) { + const int num_8x8_rows = block_size_high[fp_block_size] / 8; + const int num_8x8_cols = block_size_wide[fp_block_size] / 8; + const uint8_t *buf = x->plane[0].src.buf; + for (int r8 = 0; r8 < num_8x8_rows; ++r8) { + for (int c8 = 0; c8 < num_8x8_cols; ++c8) { stats->frame_avg_wavelet_energy += av1_haar_ac_sad_8x8_uint8_input( buf + c8 * 8 + r8 * 8 * stride, stride, hbd); } @@ -635,7 +638,7 @@ raw_motion_err_list[raw_motion_err_counts] = raw_motion_error; // TODO(pengchong): Replace the hard-coded threshold - if (raw_motion_error > LOW_MOTION_ERROR_THRESH) { + if (raw_motion_error > LOW_MOTION_ERROR_THRESH || cpi->oxcf.speed <= 2) { // Test last reference frame using the previous best mv as the // starting point (best reference) for the search. first_pass_motion_search(cpi, x, best_ref_mv, &mv, &motion_error); @@ -850,7 +853,8 @@ // We will store the stats inside the persistent twopass struct (and NOT the // local variable 'fps'), and then cpi->output_pkt_list will point to it. *this_frame_stats = fps; - output_stats(this_frame_stats, cpi->output_pkt_list); + if (!cpi->lap_enabled) + output_stats(this_frame_stats, cpi->ppi->output_pkt_list); if (cpi->twopass.stats_buf_ctx->total_stats != NULL) { av1_accumulate_stats(cpi->twopass.stats_buf_ctx->total_stats, &fps); } @@ -980,6 +984,16 @@ AV1_COMMON *const cm = &cpi->common; const int tile_cols = cm->tiles.cols; const int tile_rows = cm->tiles.rows; + const int num_planes = av1_num_planes(&cpi->common); + for (int plane = 0; plane < num_planes; plane++) { + const int subsampling_xy = + plane ? cm->seq_params.subsampling_x + cm->seq_params.subsampling_y : 0; + const int sb_size = MAX_SB_SQUARE >> subsampling_xy; + CHECK_MEM_ERROR( + cm, cpi->td.mb.plane[plane].src_diff, + (int16_t *)aom_memalign( + 32, sizeof(*cpi->td.mb.plane[plane].src_diff) * sb_size)); + } for (int tile_row = 0; tile_row < tile_rows; ++tile_row) { for (int tile_col = 0; tile_col < tile_cols; ++tile_col) { TileDataEnc *const tile_data = @@ -987,6 +1001,12 @@ first_pass_tile(cpi, &cpi->td, tile_data, fp_block_size); } } + for (int plane = 0; plane < num_planes; plane++) { + if (cpi->td.mb.plane[plane].src_diff) { + aom_free(cpi->td.mb.plane[plane].src_diff); + cpi->td.mb.plane[plane].src_diff = NULL; + } + } } void av1_first_pass_row(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data, @@ -1024,7 +1044,7 @@ (current_frame->frame_number % FIRST_PASS_ALT_REF_DISTANCE); if (alt_ref_offset < FIRST_PASS_ALT_REF_DISTANCE) { const struct lookahead_entry *const alt_ref_frame_buffer = - av1_lookahead_peek(cpi->lookahead, alt_ref_offset, + av1_lookahead_peek(cpi->ppi->lookahead, alt_ref_offset, cpi->compressor_stage); if (alt_ref_frame_buffer != NULL) { alt_ref_frame = &alt_ref_frame_buffer->img;
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c index b9f311e..8b310a7 100644 --- a/av1/encoder/intra_mode_search.c +++ b/av1/encoder/intra_mode_search.c
@@ -31,6 +31,33 @@ UV_D135_PRED, UV_D203_PRED, UV_D157_PRED, UV_D67_PRED, UV_D113_PRED, UV_D45_PRED, }; + +// The bitmask corresponds to the chroma intra modes as defined in enums.h +// UV_PREDICTION_MODE enumeration type. Setting a bit to 0 in the mask means to +// disable the evaluation of corresponding chroma intra mode. The table +// av1_derived_chroma_intra_mode_used_flag is used when speed feature +// prune_chroma_modes_using_luma_winner is enabled. The evaluated chroma +// intra modes are union of the following: +// 1) UV_DC_PRED +// 2) UV_SMOOTH_PRED +// 3) UV_CFL_PRED +// 4) mode that corresponds to luma intra mode winner (Eg : UV_V_PRED if luma +// intra mode winner is V_PRED). +static const uint16_t av1_derived_chroma_intra_mode_used_flag[INTRA_MODES] = { + 0x2201, // DC_PRED: 0010 0010 0000 0001 + 0x2203, // V_PRED: 0010 0010 0000 0011 + 0x2205, // H_PRED: 0010 0010 0000 0101 + 0x2209, // D45_PRED: 0010 0010 0000 1001 + 0x2211, // D135_PRED: 0010 0010 0001 0001 + 0x2221, // D113_PRED: 0010 0010 0010 0001 + 0x2241, // D157_PRED: 0010 0010 0100 0001 + 0x2281, // D203_PRED: 0010 0010 1000 0001 + 0x2301, // D67_PRED: 0010 0011 0000 0001 + 0x2201, // SMOOTH_PRED: 0010 0010 0000 0001 + 0x2601, // SMOOTH_V_PRED: 0010 0110 0000 0001 + 0x2a01, // SMOOTH_H_PRED: 0010 1010 0000 0001 + 0x3201 // PAETH_PRED: 0011 0010 0000 0001 +}; /*!\endcond */ /*!\brief Calculate the rdcost of a given luma intra angle @@ -57,7 +84,7 @@ assert(!is_inter_block(mbmi)); mbmi->angle_delta[PLANE_TYPE_Y] = angle_delta; if (!skip_model_rd) { - if (model_intra_yrd_and_prune(cpi, x, bsize, mode_cost, best_model_rd)) { + if (model_intra_yrd_and_prune(cpi, x, bsize, best_model_rd)) { return INT64_MAX; } } @@ -113,12 +140,24 @@ mbmi->mode = DC_PRED; mbmi->palette_mode_info.palette_size[0] = 0; + // Skip the evaluation of filter-intra if cached MB_MODE_INFO does not have + // filter-intra as winner. + if (x->use_mb_mode_cache && + !x->mb_mode_cache->filter_intra_mode_info.use_filter_intra) + return 0; + for (mode = 0; mode < FILTER_INTRA_MODES; ++mode) { int64_t this_rd; RD_STATS tokenonly_rd_stats; mbmi->filter_intra_mode_info.filter_intra_mode = mode; - if (model_intra_yrd_and_prune(cpi, x, bsize, mode_cost, best_model_rd)) { + // Skip the evaluation of modes that do not match with the winner mode in + // x->mb_mode_cache. + if (x->use_mb_mode_cache && + mode != x->mb_mode_cache->filter_intra_mode_info.filter_intra_mode) + continue; + + if (model_intra_yrd_and_prune(cpi, x, bsize, best_model_rd)) { continue; } av1_pick_uniform_tx_size_type_yrd(cpi, x, &tokenonly_rd_stats, bsize, @@ -482,7 +521,12 @@ int this_rate; RD_STATS tokenonly_rd_stats; UV_PREDICTION_MODE mode = uv_rd_search_mode_order[mode_idx]; + const int is_diagonal_mode = av1_is_diagonal_mode(get_uv_mode(mode)); const int is_directional_mode = av1_is_directional_mode(get_uv_mode(mode)); + + if (is_diagonal_mode && !cpi->oxcf.intra_mode_cfg.enable_diagonal_intra) + continue; + if (!(cpi->sf.intra_sf.intra_uv_mode_mask[txsize_sqr_up_map[max_tx_size]] & (1 << mode))) continue; @@ -492,6 +536,11 @@ if (!intra_mode_cfg->enable_paeth_intra && mode == UV_PAETH_PRED) continue; + assert(mbmi->mode < INTRA_MODES); + if (cpi->sf.intra_sf.prune_chroma_modes_using_luma_winner && + !(av1_derived_chroma_intra_mode_used_flag[mbmi->mode] & (1 << mode))) + continue; + mbmi->uv_mode = mode; // Init variables for cfl and angle delta @@ -1053,7 +1102,8 @@ mbmi->angle_delta[PLANE_TYPE_Y] = 0; if (cpi->sf.intra_sf.intra_pruning_with_hog) { // Less aggressive thresholds are used here than those used in inter frame - // encoding. + // encoding in av1_handle_intra_y_mode() because we want key frames/intra + // frames to have higher quality. const float thresh[4] = { -1.2f, -1.2f, -0.6f, 0.4f }; const int is_chroma = 0; prune_intra_mode_with_hog( @@ -1067,29 +1117,46 @@ set_mode_eval_params(cpi, x, MODE_EVAL); MB_MODE_INFO best_mbmi = *mbmi; - av1_zero(x->winner_mode_stats); + av1_zero_array(x->winner_mode_stats, MAX_WINNER_MODE_COUNT_INTRA); x->winner_mode_count = 0; // Searches the intra-modes except for intrabc, palette, and filter_intra. for (int mode_idx = INTRA_MODE_START; mode_idx < INTRA_MODE_END; ++mode_idx) { RD_STATS this_rd_stats; int this_rate, this_rate_tokenonly, s; + int is_diagonal_mode; int64_t this_distortion, this_rd; mbmi->mode = intra_rd_search_mode_order[mode_idx]; + + is_diagonal_mode = av1_is_diagonal_mode(mbmi->mode); + if (is_diagonal_mode && !cpi->oxcf.intra_mode_cfg.enable_diagonal_intra) + continue; + + // The smooth prediction mode appears to be more frequently picked + // than horizontal / vertical smooth prediction modes. Hence treat + // them differently in speed features. if ((!cpi->oxcf.intra_mode_cfg.enable_smooth_intra || cpi->sf.intra_sf.disable_smooth_intra) && - (mbmi->mode == SMOOTH_PRED || mbmi->mode == SMOOTH_H_PRED || - mbmi->mode == SMOOTH_V_PRED)) + (mbmi->mode == SMOOTH_H_PRED || mbmi->mode == SMOOTH_V_PRED)) + continue; + if (!cpi->oxcf.intra_mode_cfg.enable_smooth_intra && + mbmi->mode == SMOOTH_PRED) + continue; + + // The functionality of filter intra modes and smooth prediction + // overlap. Retain the smooth prediction if filter intra modes are + // disabled. + if (cpi->sf.intra_sf.disable_smooth_intra && + !cpi->sf.intra_sf.disable_filter_intra && mbmi->mode == SMOOTH_PRED) continue; if (!cpi->oxcf.intra_mode_cfg.enable_paeth_intra && mbmi->mode == PAETH_PRED) continue; mbmi->angle_delta[PLANE_TYPE_Y] = 0; - if (model_intra_yrd_and_prune(cpi, x, bsize, bmode_costs[mbmi->mode], - &best_model_rd)) { - continue; - } + // Skip the evaluation of modes that do not match with the winner mode in + // x->mb_mode_cache. + if (x->use_mb_mode_cache && mbmi->mode != x->mb_mode_cache->mode) continue; is_directional_mode = av1_is_directional_mode(mbmi->mode); if (is_directional_mode && directional_mode_skip_mask[mbmi->mode]) continue; @@ -1101,6 +1168,10 @@ bmode_costs[mbmi->mode], best_rd, &best_model_rd, 1); } else { + if (model_intra_yrd_and_prune(cpi, x, bsize, &best_model_rd)) { + continue; + } + // Builds the actual prediction. The prediction from // model_intra_yrd_and_prune was just an estimation that did not take into // account the effect of txfm pipeline, so we need to redo it for real @@ -1154,7 +1225,8 @@ } // Searches filter_intra - if (beat_best_rd && av1_filter_intra_allowed_bsize(&cpi->common, bsize)) { + if (beat_best_rd && av1_filter_intra_allowed_bsize(&cpi->common, bsize) && + !cpi->sf.intra_sf.disable_filter_intra) { if (rd_pick_filter_intra_sby(cpi, x, rate, rate_tokenonly, distortion, skippable, bsize, bmode_costs[DC_PRED], &best_rd, &best_model_rd, ctx)) {
diff --git a/av1/encoder/intra_mode_search_utils.h b/av1/encoder/intra_mode_search_utils.h index 18ab41b..3e6ecfb 100644 --- a/av1/encoder/intra_mode_search_utils.h +++ b/av1/encoder/intra_mode_search_utils.h
@@ -24,6 +24,7 @@ #include "av1/encoder/encoder.h" #include "av1/encoder/model_rd.h" #include "av1/encoder/palette.h" +#include "av1/encoder/hybrid_fwd_txfm.h" #ifdef __cplusplus extern "C" { @@ -382,56 +383,69 @@ return total_rate; } +/*!\brief Apply Hadamard or DCT transform + * + * \callergraph + */ +static void av1_quick_txfm(int use_hadamard, TX_SIZE tx_size, int is_hbd, + int bd, const int16_t *src_diff, int src_stride, + tran_low_t *coeff) { + if (use_hadamard) { + switch (tx_size) { + case TX_4X4: aom_hadamard_4x4(src_diff, src_stride, coeff); break; + case TX_8X8: aom_hadamard_8x8(src_diff, src_stride, coeff); break; + case TX_16X16: aom_hadamard_16x16(src_diff, src_stride, coeff); break; + case TX_32X32: aom_hadamard_32x32(src_diff, src_stride, coeff); break; + default: assert(0); + } + } else { + assert(IMPLIES(is_hbd == 0, bd == 8)); + TxfmParam txfm_param; + txfm_param.tx_type = DCT_DCT; + txfm_param.tx_size = tx_size; + txfm_param.lossless = 0; + txfm_param.bd = bd; + txfm_param.is_hbd = is_hbd; + av1_fwd_txfm(src_diff, coeff, src_stride, &txfm_param); + } +} + /*!\cond */ -// Makes a quick luma prediction and estimate the rdcost with a model without +// Makes a quick intra prediction and estimate the rdcost with a model without // going through the whole txfm/quantize/itxfm process. -static int64_t intra_model_yrd(const AV1_COMP *const cpi, MACROBLOCK *const x, - BLOCK_SIZE bsize, int mode_cost) { - const AV1_COMMON *cm = &cpi->common; +static int64_t intra_model_rd(const AV1_COMMON *cm, MACROBLOCK *const x, + int plane, BLOCK_SIZE plane_bsize, + TX_SIZE tx_size, int use_hadamard) { MACROBLOCKD *const xd = &x->e_mbd; - MB_MODE_INFO *const mbmi = xd->mi[0]; - assert(!is_inter_block(mbmi)); - RD_STATS this_rd_stats; int row, col; - int64_t temp_sse, this_rd; - const ModeCosts *mode_costs = &x->mode_costs; - const TxfmSearchParams *txfm_params = &x->txfm_search_params; - TX_SIZE tx_size = - tx_size_from_tx_mode(bsize, txfm_params->tx_mode_search_type); + assert(!is_inter_block(xd->mi[0])); const int stepr = tx_size_high_unit[tx_size]; const int stepc = tx_size_wide_unit[tx_size]; - const int max_blocks_wide = max_block_wide(xd, bsize, 0); - const int max_blocks_high = max_block_high(xd, bsize, 0); - mbmi->tx_size = tx_size; + const int txbw = tx_size_wide[tx_size]; + const int txbh = tx_size_high[tx_size]; + const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); + const int max_blocks_high = max_block_high(xd, plane_bsize, plane); + int64_t satd_cost = 0; + struct macroblock_plane *p = &x->plane[plane]; + struct macroblockd_plane *pd = &xd->plane[plane]; // Prediction. for (row = 0; row < max_blocks_high; row += stepr) { for (col = 0; col < max_blocks_wide; col += stepc) { - av1_predict_intra_block_facade(cm, xd, 0, col, row, tx_size); + av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size); + // Here we use p->src_diff and p->coeff as temporary buffers for + // prediction residue and transform coefficients. The buffers are only + // used in this for loop, therefore we don't need to properly add offset + // to the buffers. + av1_subtract_block( + xd, txbh, txbw, p->src_diff, block_size_wide[plane_bsize], + p->src.buf + (((row * p->src.stride) + col) << 2), p->src.stride, + pd->dst.buf + (((row * pd->dst.stride) + col) << 2), pd->dst.stride); + av1_quick_txfm(use_hadamard, tx_size, is_cur_buf_hbd(xd), xd->bd, + p->src_diff, block_size_wide[plane_bsize], p->coeff); + satd_cost += aom_satd(p->coeff, tx_size_2d[tx_size]); } } - // RD estimation. - model_rd_sb_fn[cpi->sf.rt_sf.use_simple_rd_model ? MODELRD_LEGACY - : MODELRD_TYPE_INTRA]( - cpi, bsize, x, xd, 0, 0, &this_rd_stats.rate, &this_rd_stats.dist, - &this_rd_stats.skip_txfm, &temp_sse, NULL, NULL, NULL); - if (av1_is_directional_mode(mbmi->mode) && av1_use_angle_delta(bsize)) { - mode_cost += mode_costs->angle_delta_cost[mbmi->mode - V_PRED] - [MAX_ANGLE_DELTA + - mbmi->angle_delta[PLANE_TYPE_Y]]; - } - if (mbmi->mode == DC_PRED && - av1_filter_intra_allowed_bsize(cm, mbmi->bsize)) { - if (mbmi->filter_intra_mode_info.use_filter_intra) { - const int mode = mbmi->filter_intra_mode_info.filter_intra_mode; - mode_cost += mode_costs->filter_intra_cost[mbmi->bsize][1] + - mode_costs->filter_intra_mode_cost[mode]; - } else { - mode_cost += mode_costs->filter_intra_cost[mbmi->bsize][0]; - } - } - this_rd = - RDCOST(x->rdmult, this_rd_stats.rate + mode_cost, this_rd_stats.dist); - return this_rd; + return satd_cost; } /*!\endcond */ @@ -441,17 +455,20 @@ * \callergraph * This function first makes a quick luma prediction and estimates the rdcost * with a model without going through the txfm, then try to prune the current - * mode if the new estimate y_rd > 1.5 * best_model_rd. + * mode if the new estimate y_rd > 1.25 * best_model_rd. * * \return Returns 1 if the given mode is prune; 0 otherwise. */ static AOM_INLINE int model_intra_yrd_and_prune(const AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize, - int mode_info_cost, int64_t *best_model_rd) { - const int64_t this_model_rd = intra_model_yrd(cpi, x, bsize, mode_info_cost); + const TX_SIZE tx_size = AOMMIN(TX_32X32, max_txsize_lookup[bsize]); + const int plane = 0; + const AV1_COMMON *cm = &cpi->common; + const int64_t this_model_rd = + intra_model_rd(cm, x, plane, bsize, tx_size, /*use_hadamard=*/1); if (*best_model_rd != INT64_MAX && - this_model_rd > *best_model_rd + (*best_model_rd >> 1)) { + this_model_rd > *best_model_rd + (*best_model_rd >> 2)) { return 1; } else if (this_model_rd < *best_model_rd) { *best_model_rd = this_model_rd;
diff --git a/av1/encoder/lookahead.c b/av1/encoder/lookahead.c index 78e2e08..e6d7213 100644 --- a/av1/encoder/lookahead.c +++ b/av1/encoder/lookahead.c
@@ -45,24 +45,32 @@ struct lookahead_ctx *av1_lookahead_init( unsigned int width, unsigned int height, unsigned int subsampling_x, unsigned int subsampling_y, int use_highbitdepth, unsigned int depth, - const int border_in_pixels, int byte_alignment, int num_lap_buffers) { - struct lookahead_ctx *ctx = NULL; + const int border_in_pixels, int byte_alignment, int num_lap_buffers, + bool is_all_intra, int enable_global_motion) { int lag_in_frames = AOMMAX(1, depth); + // For all-intra frame encoding, previous source frames are not required. + // Hence max_pre_frames is set to 0 in this case. As previous source frames + // are accessed using a negative index to av1_lookahead_peek(), setting + // max_pre_frames to 0 will cause av1_lookahead_peek() to return NULL for a + // negative index. + const uint8_t max_pre_frames = is_all_intra ? 0 : MAX_PRE_FRAMES; + // Add the lags to depth and clamp depth += num_lap_buffers; depth = clamp(depth, 1, MAX_TOTAL_BUFFERS); // Allocate memory to keep previous source frames available. - depth += MAX_PRE_FRAMES; + depth += max_pre_frames; // Allocate the lookahead structures - ctx = calloc(1, sizeof(*ctx)); + struct lookahead_ctx *ctx = calloc(1, sizeof(*ctx)); if (ctx) { unsigned int i; ctx->max_sz = depth; ctx->push_frame_count = 0; - ctx->read_ctxs[ENCODE_STAGE].pop_sz = ctx->max_sz - MAX_PRE_FRAMES; + ctx->max_pre_frames = max_pre_frames; + ctx->read_ctxs[ENCODE_STAGE].pop_sz = ctx->max_sz - ctx->max_pre_frames; ctx->read_ctxs[ENCODE_STAGE].valid = 1; if (num_lap_buffers) { ctx->read_ctxs[LAP_STAGE].pop_sz = lag_in_frames; @@ -71,11 +79,10 @@ ctx->buf = calloc(depth, sizeof(*ctx->buf)); if (!ctx->buf) goto fail; for (i = 0; i < depth; i++) { - aom_free_frame_buffer(&ctx->buf[i].img); - if (aom_realloc_frame_buffer(&ctx->buf[i].img, width, height, - subsampling_x, subsampling_y, - use_highbitdepth, border_in_pixels, - byte_alignment, NULL, NULL, NULL)) + if (aom_realloc_frame_buffer( + &ctx->buf[i].img, width, height, subsampling_x, subsampling_y, + use_highbitdepth, border_in_pixels, byte_alignment, NULL, NULL, + NULL, enable_global_motion)) goto fail; } } @@ -88,7 +95,6 @@ int av1_lookahead_push(struct lookahead_ctx *ctx, const YV12_BUFFER_CONFIG *src, int64_t ts_start, int64_t ts_end, int use_highbitdepth, aom_enc_frame_flags_t flags) { - struct lookahead_entry *buf; int width = src->y_crop_width; int height = src->y_crop_height; int uv_width = src->uv_crop_width; @@ -98,13 +104,13 @@ int larger_dimensions, new_dimensions; assert(ctx->read_ctxs[ENCODE_STAGE].valid == 1); - if (ctx->read_ctxs[ENCODE_STAGE].sz + 1 + MAX_PRE_FRAMES > ctx->max_sz) + if (ctx->read_ctxs[ENCODE_STAGE].sz + 1 + ctx->max_pre_frames > ctx->max_sz) return 1; ctx->read_ctxs[ENCODE_STAGE].sz++; if (ctx->read_ctxs[LAP_STAGE].valid) { ctx->read_ctxs[LAP_STAGE].sz++; } - buf = pop(ctx, &ctx->write_idx); + struct lookahead_entry *buf = pop(ctx, &ctx->write_idx); new_dimensions = width != buf->img.y_crop_width || height != buf->img.y_crop_height || @@ -162,12 +168,11 @@ struct lookahead_entry *av1_lookahead_peek(struct lookahead_ctx *ctx, int index, COMPRESSOR_STAGE stage) { struct lookahead_entry *buf = NULL; - struct read_ctx *read_ctx = NULL; if (ctx == NULL) { return buf; } - read_ctx = &ctx->read_ctxs[stage]; + struct read_ctx *read_ctx = &ctx->read_ctxs[stage]; assert(read_ctx->valid == 1); if (index >= 0) { // Forward peek @@ -178,7 +183,7 @@ } } else if (index < 0) { // Backward peek - if (-index <= MAX_PRE_FRAMES) { + if (-index <= ctx->max_pre_frames) { index += (int)(read_ctx->read_idx); if (index < 0) index += (int)(ctx->max_sz); buf = ctx->buf + index; @@ -190,19 +195,17 @@ unsigned int av1_lookahead_depth(struct lookahead_ctx *ctx, COMPRESSOR_STAGE stage) { - struct read_ctx *read_ctx = NULL; assert(ctx != NULL); - read_ctx = &ctx->read_ctxs[stage]; + struct read_ctx *read_ctx = &ctx->read_ctxs[stage]; assert(read_ctx->valid == 1); return read_ctx->sz; } int av1_lookahead_pop_sz(struct lookahead_ctx *ctx, COMPRESSOR_STAGE stage) { - struct read_ctx *read_ctx = NULL; assert(ctx != NULL); - read_ctx = &ctx->read_ctxs[stage]; + struct read_ctx *read_ctx = &ctx->read_ctxs[stage]; assert(read_ctx->valid == 1); return read_ctx->pop_sz; }
diff --git a/av1/encoder/lookahead.h b/av1/encoder/lookahead.h index 635857f..af79eb4 100644 --- a/av1/encoder/lookahead.h +++ b/av1/encoder/lookahead.h
@@ -15,6 +15,8 @@ #ifndef AOM_AV1_ENCODER_LOOKAHEAD_H_ #define AOM_AV1_ENCODER_LOOKAHEAD_H_ +#include <stdbool.h> + #include "aom_scale/yv12config.h" #include "aom/aom_integer.h" @@ -53,7 +55,9 @@ int write_idx; /* Write index */ struct read_ctx read_ctxs[MAX_STAGES]; /* Read context */ struct lookahead_entry *buf; /* Buffer list */ - int push_frame_count; /* Number of frames has been pushed in the queue*/ + int push_frame_count; /* Number of frames that have been pushed in the queue*/ + uint8_t + max_pre_frames; /* Maximum number of past frames allowed in the queue */ }; /*!\endcond */ @@ -65,7 +69,8 @@ struct lookahead_ctx *av1_lookahead_init( unsigned int width, unsigned int height, unsigned int subsampling_x, unsigned int subsampling_y, int use_highbitdepth, unsigned int depth, - const int border_in_pixels, int byte_alignment, int num_lap_buffers); + const int border_in_pixels, int byte_alignment, int num_lap_buffers, + bool is_all_intra, int enable_global_motion); /**\brief Destroys the lookahead stage */ @@ -76,9 +81,6 @@ * This function will copy the source image into a new framebuffer with * the expected stride/border. * - * If active_map is non-NULL and there is only one frame in the queue, then copy - * only active macroblocks. - * * \param[in] ctx Pointer to the lookahead context * \param[in] src Pointer to the image to enqueue * \param[in] ts_start Timestamp for the start of this frame
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c index f80fc48..5083084 100644 --- a/av1/encoder/mcomp.c +++ b/av1/encoder/mcomp.c
@@ -138,6 +138,17 @@ x->errorperbit, x->sadperbit); } +void av1_set_ms_to_intra_mode(FULLPEL_MOTION_SEARCH_PARAMS *ms_params, + const IntraBCMVCosts *dv_costs) { + ms_params->is_intra_mode = 1; + + MV_COST_PARAMS *mv_cost_params = &ms_params->mv_cost_params; + + mv_cost_params->mvjcost = dv_costs->joint_mv; + mv_cost_params->mvcost[0] = dv_costs->dv_costs[0]; + mv_cost_params->mvcost[1] = dv_costs->dv_costs[1]; +} + void av1_make_default_subpel_ms_params(SUBPEL_MOTION_SEARCH_PARAMS *ms_params, const struct AV1_COMP *cpi, const MACROBLOCK *x, BLOCK_SIZE bsize, @@ -242,7 +253,7 @@ // nearest 2 ** 7. // This is NOT used during motion compensation. int av1_mv_bit_cost(const MV *mv, const MV *ref_mv, const int *mvjcost, - int *mvcost[2], int weight) { + int *const mvcost[2], int weight) { const MV diff = { mv->row - ref_mv->row, mv->col - ref_mv->col }; return ROUND_POWER_OF_TWO( mv_cost(&diff, mvjcost, CONVERT_TO_CONST_MVCOST(mvcost)) * weight, 7);
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h index 94baed6..b2539f5 100644 --- a/av1/encoder/mcomp.h +++ b/av1/encoder/mcomp.h
@@ -14,6 +14,7 @@ #include "av1/common/mv.h" #include "av1/encoder/block.h" +#include "av1/encoder/rd.h" #include "aom_dsp/variance.h" @@ -83,7 +84,7 @@ } MV_COST_PARAMS; int av1_mv_bit_cost(const MV *mv, const MV *ref_mv, const int *mvjcost, - int *mvcost[2], int weight); + int *const mvcost[2], int weight); int av1_get_mvpred_sse(const MV_COST_PARAMS *mv_cost_params, const FULLPEL_MV best_mv, @@ -211,6 +212,10 @@ const search_site_config search_sites[NUM_SEARCH_METHODS], int fine_search_interval); +/*! Sets the \ref FULLPEL_MOTION_SEARCH_PARAMS to intra mode. */ +void av1_set_ms_to_intra_mode(FULLPEL_MOTION_SEARCH_PARAMS *ms_params, + const IntraBCMVCosts *dv_costs); + // Sets up configs for fullpixel DIAMOND / CLAMPED_DIAMOND search method. void av1_init_dsmotion_compensation(search_site_config *cfg, int stride, int level);
diff --git a/av1/encoder/motion_search_facade.c b/av1/encoder/motion_search_facade.c index bad8e65..96b77b7 100644 --- a/av1/encoder/motion_search_facade.c +++ b/av1/encoder/motion_search_facade.c
@@ -303,8 +303,9 @@ case SIMPLE_TRANSLATION: if (cpi->sf.mv_sf.use_accurate_subpel_search) { const int try_second = second_best_mv.as_int != INVALID_MV && - second_best_mv.as_int != best_mv->as_int; - mv_search_params->find_fractional_mv_step( + second_best_mv.as_int != best_mv->as_int && + (cpi->sf.mv_sf.disable_second_mv <= 1); + const int best_mv_var = mv_search_params->find_fractional_mv_step( xd, cm, &ms_params, subpel_start_mv, &best_mv->as_mv, &dis, &x->pred_sse[ref], fractional_ms_list); @@ -314,42 +315,55 @@ { p[0].dst.buf, p[1].dst.buf, p[2].dst.buf }, { p[0].dst.stride, p[1].dst.stride, p[2].dst.stride }, }; - mbmi->mv[0].as_mv = best_mv->as_mv; - av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, - bsize, 0, 0); - av1_subtract_plane(x, bsize, 0); - RD_STATS this_rd_stats; - av1_init_rd_stats(&this_rd_stats); - av1_estimate_txfm_yrd(cpi, x, &this_rd_stats, INT64_MAX, bsize, - max_txsize_rect_lookup[bsize]); - int this_mv_rate = av1_mv_bit_cost( - &best_mv->as_mv, &ref_mv, mv_costs->nmv_joint_cost, - mv_costs->mv_cost_stack, MV_COST_WEIGHT); - int64_t rd = RDCOST(x->rdmult, this_mv_rate + this_rd_stats.rate, - this_rd_stats.dist); + int64_t rd = INT64_MAX; + if (!cpi->sf.mv_sf.disable_second_mv) { + // Calculate actual rd cost. + mbmi->mv[0].as_mv = best_mv->as_mv; + av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, + bsize, 0, 0); + av1_subtract_plane(x, bsize, 0); + RD_STATS this_rd_stats; + av1_init_rd_stats(&this_rd_stats); + av1_estimate_txfm_yrd(cpi, x, &this_rd_stats, INT64_MAX, bsize, + max_txsize_rect_lookup[bsize]); + int this_mv_rate = av1_mv_bit_cost( + &best_mv->as_mv, &ref_mv, mv_costs->nmv_joint_cost, + mv_costs->mv_cost_stack, MV_COST_WEIGHT); + rd = RDCOST(x->rdmult, this_mv_rate + this_rd_stats.rate, + this_rd_stats.dist); + } MV this_best_mv; subpel_start_mv = get_mv_from_fullmv(&second_best_mv.as_fullmv); if (av1_is_subpelmv_in_range(&ms_params.mv_limits, subpel_start_mv)) { - mv_search_params->find_fractional_mv_step( + const int this_var = mv_search_params->find_fractional_mv_step( xd, cm, &ms_params, subpel_start_mv, &this_best_mv, &dis, &x->pred_sse[ref], fractional_ms_list); - mbmi->mv[0].as_mv = this_best_mv; - av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, - bsize, 0, 0); - av1_subtract_plane(x, bsize, 0); - RD_STATS tmp_rd_stats; - av1_init_rd_stats(&tmp_rd_stats); - av1_estimate_txfm_yrd(cpi, x, &tmp_rd_stats, INT64_MAX, bsize, - max_txsize_rect_lookup[bsize]); - int tmp_mv_rate = av1_mv_bit_cost( - &this_best_mv, &ref_mv, mv_costs->nmv_joint_cost, - mv_costs->mv_cost_stack, MV_COST_WEIGHT); - int64_t tmp_rd = - RDCOST(x->rdmult, tmp_rd_stats.rate + tmp_mv_rate, - tmp_rd_stats.dist); - if (tmp_rd < rd) best_mv->as_mv = this_best_mv; + + if (!cpi->sf.mv_sf.disable_second_mv) { + // If cpi->sf.mv_sf.disable_second_mv is 0, use actual rd cost + // to choose the better MV. + mbmi->mv[0].as_mv = this_best_mv; + av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, + bsize, 0, 0); + av1_subtract_plane(x, bsize, 0); + RD_STATS tmp_rd_stats; + av1_init_rd_stats(&tmp_rd_stats); + av1_estimate_txfm_yrd(cpi, x, &tmp_rd_stats, INT64_MAX, bsize, + max_txsize_rect_lookup[bsize]); + int tmp_mv_rate = av1_mv_bit_cost( + &this_best_mv, &ref_mv, mv_costs->nmv_joint_cost, + mv_costs->mv_cost_stack, MV_COST_WEIGHT); + int64_t tmp_rd = + RDCOST(x->rdmult, tmp_rd_stats.rate + tmp_mv_rate, + tmp_rd_stats.dist); + if (tmp_rd < rd) best_mv->as_mv = this_best_mv; + } else { + // If cpi->sf.mv_sf.disable_second_mv = 1, use var to decide the + // best MV. + if (this_var < best_mv_var) best_mv->as_mv = this_best_mv; + } } } } else { @@ -757,7 +771,7 @@ mask_stride, rate_mv, which); } else if (which == 2) { av1_joint_motion_search(cpi, x, bsize, tmp_mv, mask, mask_stride, rate_mv, - 1); + !cpi->sf.mv_sf.disable_second_mv); } }
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c index 702987c..bc7ee02 100644 --- a/av1/encoder/nonrd_pickmode.c +++ b/av1/encoder/nonrd_pickmode.c
@@ -518,7 +518,7 @@ TX_SIZE tx_size; const TxfmSearchParams *txfm_params = &x->txfm_search_params; if (txfm_params->tx_mode_search_type == TX_MODE_SELECT) { - if (sse > (var << 2)) + if (sse > (var << 1)) tx_size = AOMMIN(max_txsize_lookup[bsize], tx_mode_to_biggest_tx_size[txfm_params->tx_mode_search_type]); @@ -1666,6 +1666,7 @@ AOMMIN(max_txsize_lookup[bsize], tx_mode_to_biggest_tx_size[txfm_params->tx_mode_search_type]); int *bmode_costs; + PREDICTION_MODE best_mode = DC_PRED; const MB_MODE_INFO *above_mi = xd->above_mbmi; const MB_MODE_INFO *left_mi = xd->left_mbmi; const PREDICTION_MODE A = av1_above_block_mode(above_mi); @@ -1687,22 +1688,27 @@ args.skippable = 1; args.rdc = &this_rdc; mi->tx_size = intra_tx_size; + mi->mode = this_mode; av1_foreach_transformed_block_in_plane(xd, bsize, 0, estimate_block_intra, &args); + const int skip_ctx = av1_get_skip_txfm_context(xd); if (args.skippable) { - this_rdc.rate = av1_cost_symbol(av1_get_skip_txfm_cdf(xd)[1]); + this_rdc.rate = x->mode_costs.skip_txfm_cost[skip_ctx][1]; } else { - this_rdc.rate += av1_cost_symbol(av1_get_skip_txfm_cdf(xd)[0]); + this_rdc.rate += x->mode_costs.skip_txfm_cost[skip_ctx][0]; } this_rdc.rate += bmode_costs[this_mode]; this_rdc.rdcost = RDCOST(x->rdmult, this_rdc.rate, this_rdc.dist); if (this_rdc.rdcost < best_rdc.rdcost) { best_rdc = this_rdc; - mi->mode = this_mode; + best_mode = this_mode; } } + mi->mode = best_mode; + // Keep DC for UV since mode test is based on Y channel only. + mi->uv_mode = DC_PRED; *rd_cost = best_rdc; #if CONFIG_INTERNAL_STATS
diff --git a/av1/encoder/optical_flow.c b/av1/encoder/optical_flow.c index eed1def..82ae9c5 100644 --- a/av1/encoder/optical_flow.c +++ b/av1/encoder/optical_flow.c
@@ -16,11 +16,22 @@ #include "av1/encoder/encoder.h" #include "av1/encoder/mathutils.h" #include "av1/encoder/optical_flow.h" +#include "av1/encoder/sparse_linear_solver.h" #include "av1/encoder/reconinter_enc.h" #include "aom_mem/aom_mem.h" #if CONFIG_OPTICAL_FLOW_API +void av1_init_opfl_params(OPFL_PARAMS *opfl_params) { + opfl_params->pyramid_levels = OPFL_PYRAMID_LEVELS; + opfl_params->warping_steps = OPFL_WARPING_STEPS; + opfl_params->lk_params = NULL; +} + +void av1_init_lk_params(LK_PARAMS *lk_params) { + lk_params->window_size = OPFL_WINDOW_SIZE; +} + // Helper function to determine whether a frame is encoded with high bit-depth. static INLINE int is_frame_high_bitdepth(const YV12_BUFFER_CONFIG *frame) { return (frame->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0; @@ -31,20 +42,16 @@ return (opfl_params->flags & OPFL_FLAG_SPARSE) ? 1 : 0; } -typedef struct LOCALMV { - double row; - double col; -} LOCALMV; - -void gradients_over_window(const YV12_BUFFER_CONFIG *frame, - const YV12_BUFFER_CONFIG *ref_frame, - const double x_coord, const double y_coord, - const int window_size, const int bit_depth, - double *ix, double *iy, double *it, LOCALMV *mv); +static void gradients_over_window(const YV12_BUFFER_CONFIG *frame, + const YV12_BUFFER_CONFIG *ref_frame, + const double x_coord, const double y_coord, + const int window_size, const int bit_depth, + double *ix, double *iy, double *it, + LOCALMV *mv); // coefficients for bilinear interpolation on unit square -int pixel_interp(const double x, const double y, const double b00, - const double b01, const double b10, const double b11) { +static int pixel_interp(const double x, const double y, const double b00, + const double b01, const double b10, const double b11) { const int xint = (int)x; const int yint = (int)y; const double xdec = x - xint; @@ -57,10 +64,12 @@ int interp = (int)round(a * b00 + b * b01 + c * b10 + d * b11); return interp; } + // bilinear interpolation to find subpixel values -int get_subpixels(const YV12_BUFFER_CONFIG *frame, int *pred, const int w, - const int h, LOCALMV mv, const double x_coord, - const double y_coord) { +static AOM_INLINE int get_subpixels(const YV12_BUFFER_CONFIG *frame, int *pred, + const int w, const int h, LOCALMV mv, + const double x_coord, + const double y_coord) { double left = x_coord + mv.row; double top = y_coord + mv.col; const int fromedge = 2; @@ -92,10 +101,11 @@ } return 0; } + // Scharr filter to compute spatial gradient -void spatial_gradient(const YV12_BUFFER_CONFIG *frame, const int x_coord, - const int y_coord, const int direction, - double *derivative) { +static void spatial_gradient(const YV12_BUFFER_CONFIG *frame, const int x_coord, + const int y_coord, const int direction, + double *derivative) { double *filter; // Scharr filters double gx[9] = { -3, 0, 3, -10, 0, 10, -3, 0, 3 }; @@ -117,12 +127,13 @@ // normalization scaling factor for scharr *derivative = d / 32.0; } + // Determine the spatial gradient at subpixel locations // For example, when reducing images for pyramidal LK, // corners found in original image may be at subpixel locations. -void gradient_interp(double *fullpel_deriv, const double x_coord, - const double y_coord, const int w, const int h, - double *derivative) { +static void gradient_interp(double *fullpel_deriv, const double x_coord, + const double y_coord, const int w, const int h, + double *derivative) { const int xint = (int)x_coord; const int yint = (int)y_coord; double interp; @@ -138,17 +149,15 @@ *derivative = interp; } -void temporal_gradient(const YV12_BUFFER_CONFIG *frame, - const YV12_BUFFER_CONFIG *frame2, const double x_coord, - const double y_coord, const int bit_depth, - double *derivative, LOCALMV *mv) { - // TODO(any): this is a roundabout way of enforcing build_one_inter_pred - // to use the 8-tap filter (instead of lower). it would be more - // efficient to apply the filter only at 1 pixel instead of 25 pixels. - const int w = 5; - const int h = 5; - uint8_t pred1[25]; - uint8_t pred2[25]; +static void temporal_gradient(const YV12_BUFFER_CONFIG *frame, + const YV12_BUFFER_CONFIG *frame2, + const double x_coord, const double y_coord, + const int bit_depth, double *derivative, + LOCALMV *mv) { + const int w = 2; + const int h = 2; + uint8_t pred1[4]; + uint8_t pred2[4]; const int y = (int)y_coord; const int x = (int)x_coord; @@ -170,6 +179,10 @@ av1_init_inter_params(&inter_pred_params, w, h, y, x, subsampling_x, subsampling_y, bit_depth, is_high_bitdepth, is_intrabc, &scale, &ref_buf2, interp_filters); + inter_pred_params.interp_filter_params[0] = + &av1_interp_filter_params_list[interp_filters.as_filters.x_filter]; + inter_pred_params.interp_filter_params[1] = + &av1_interp_filter_params_list[interp_filters.as_filters.y_filter]; inter_pred_params.conv_params = get_conv_params(0, plane, bit_depth); MV newmv = { .row = (int16_t)round((mv->row + xdec) * 8), .col = (int16_t)round((mv->col + ydec) * 8) }; @@ -179,6 +192,10 @@ av1_init_inter_params(&inter_pred_params, w, h, y, x, subsampling_x, subsampling_y, bit_depth, is_high_bitdepth, is_intrabc, &scale, &ref_buf1, interp_filters); + inter_pred_params.interp_filter_params[0] = + &av1_interp_filter_params_list[interp_filters.as_filters.x_filter]; + inter_pred_params.interp_filter_params[1] = + &av1_interp_filter_params_list[interp_filters.as_filters.y_filter]; inter_pred_params.conv_params = get_conv_params(0, plane, bit_depth); MV zeroMV = { .row = (int16_t)round(xdec * 8), .col = (int16_t)round(ydec * 8) }; @@ -186,15 +203,17 @@ *derivative = pred2[0] - pred1[0]; } + // Numerical differentiate over window_size x window_size surrounding (x,y) // location. Alters ix, iy, it to contain numerical partial derivatives -void gradients_over_window(const YV12_BUFFER_CONFIG *frame, - const YV12_BUFFER_CONFIG *ref_frame, - const double x_coord, const double y_coord, - const int window_size, const int bit_depth, - double *ix, double *iy, double *it, LOCALMV *mv) { - const double left = x_coord - window_size / 2; - const double top = y_coord - window_size / 2; +static void gradients_over_window(const YV12_BUFFER_CONFIG *frame, + const YV12_BUFFER_CONFIG *ref_frame, + const double x_coord, const double y_coord, + const int window_size, const int bit_depth, + double *ix, double *iy, double *it, + LOCALMV *mv) { + const double left = x_coord - window_size / 2.0; + const double top = y_coord - window_size / 2.0; // gradient operators need pixel before and after (start at 1) const double x_start = AOMMAX(1, left); const double y_start = AOMMAX(1, top); @@ -204,8 +223,8 @@ double deriv_y; double deriv_t; - const double x_end = AOMMIN(x_coord + window_size / 2, frame_width - 2); - const double y_end = AOMMIN(y_coord + window_size / 2, frame_height - 2); + const double x_end = AOMMIN(x_coord + window_size / 2.0, frame_width - 2); + const double y_end = AOMMIN(y_coord + window_size / 2.0, frame_height - 2); const int xs = (int)AOMMAX(1, x_start - 1); const int ys = (int)AOMMAX(1, y_start - 1); const int xe = (int)AOMMIN(x_end + 2, frame_width - 2); @@ -251,7 +270,7 @@ // To compute eigenvalues of 2x2 matrix: Solve for lambda where // Determinant(matrix - lambda*identity) == 0 -void eigenvalues_2x2(const double *matrix, double *eig) { +static void eigenvalues_2x2(const double *matrix, double *eig) { const double a = 1; const double b = -1 * matrix[0] - matrix[3]; const double c = -1 * matrix[1] * matrix[2] + matrix[0] * matrix[3]; @@ -266,11 +285,12 @@ eig[1] = tmp; } } + // Shi-Tomasi corner detection criteria -double corner_score(const YV12_BUFFER_CONFIG *frame_to_filter, - const YV12_BUFFER_CONFIG *ref_frame, const int x, - const int y, double *i_x, double *i_y, double *i_t, - const int n, const int bit_depth) { +static double corner_score(const YV12_BUFFER_CONFIG *frame_to_filter, + const YV12_BUFFER_CONFIG *ref_frame, const int x, + const int y, double *i_x, double *i_y, double *i_t, + const int n, const int bit_depth) { double eig[2]; LOCALMV mv = { .row = 0, .col = 0 }; // TODO(any): technically, ref_frame and i_t are not used by corner score @@ -286,11 +306,13 @@ eigenvalues_2x2(M, eig); return fabs(eig[0]); } + // Finds corners in frame_to_filter // For less strict requirements (i.e. more corners), decrease threshold -int detect_corners(const YV12_BUFFER_CONFIG *frame_to_filter, - const YV12_BUFFER_CONFIG *ref_frame, const int maxcorners, - int *ref_corners, const int bit_depth) { +static int detect_corners(const YV12_BUFFER_CONFIG *frame_to_filter, + const YV12_BUFFER_CONFIG *ref_frame, + const int maxcorners, int *ref_corners, + const int bit_depth) { const int frame_height = frame_to_filter->y_crop_height; const int frame_width = frame_to_filter->y_crop_width; // TODO(any): currently if maxcorners is decreased, then it only means @@ -343,10 +365,11 @@ } return countcorners; } + // weights is an nxn matrix. weights is filled with a gaussian function, // with independent variable: distance from the center point. -void gaussian(const double sigma, const int n, const int normalize, - double *weights) { +static void gaussian(const double sigma, const int n, const int normalize, + double *weights) { double total_weight = 0; for (int j = 0; j < n; j++) { for (int i = 0; i < n; i++) { @@ -362,17 +385,19 @@ } } } -double convolve(const double *filter, const int *img, const int size) { + +static double convolve(const double *filter, const int *img, const int size) { double result = 0; for (int i = 0; i < size; i++) { result += filter[i] * img[i]; } return result; } + // Applies a Gaussian low-pass smoothing filter to produce // a corresponding lower resolution image with halved dimensions -void reduce(uint8_t *img, int height, int width, int stride, - uint8_t *reduced_img) { +static void reduce(uint8_t *img, int height, int width, int stride, + uint8_t *reduced_img) { const int new_width = width / 2; const int window_size = 5; const double gaussian_filter[25] = { @@ -399,13 +424,16 @@ } } reduced_img[(y / 2) * new_width + (x / 2)] = (uint8_t)convolve( - gaussian_filter, img_section, (int)pow(window_size, 2)); + gaussian_filter, img_section, window_size * window_size); } } } -int cmpfunc(const void *a, const void *b) { return (*(int *)a - *(int *)b); } -void filter_mvs(const MV_FILTER_TYPE mv_filter, const int frame_height, - const int frame_width, LOCALMV *localmvs, MV *mvs) { + +static int cmpfunc(const void *a, const void *b) { + return (*(int *)a - *(int *)b); +} +static void filter_mvs(const MV_FILTER_TYPE mv_filter, const int frame_height, + const int frame_width, LOCALMV *localmvs, MV *mvs) { const int n = 5; // window size // for smoothing filter const double gaussian_filter[25] = { @@ -421,56 +449,51 @@ for (int y = 0; y < frame_height; y++) { for (int x = 0; x < frame_width; x++) { int center_idx = y * frame_width + x; - if (fabs(localmvs[center_idx].row) > 0 || - fabs(localmvs[center_idx].col) > 0) { - int i = 0; - double filtered_row = 0; - double filtered_col = 0; - for (int yy = y - n / 2; yy <= y + n / 2; yy++) { - for (int xx = x - n / 2; xx <= x + n / 2; xx++) { - int yvalue = yy + y; - int xvalue = xx + x; - // copied pixels outside the boundary - if (yvalue < 0) yvalue = 0; - if (xvalue < 0) xvalue = 0; - if (yvalue >= frame_height) yvalue = frame_height - 1; - if (xvalue >= frame_width) xvalue = frame_width - 1; - int index = yvalue * frame_width + xvalue; - if (mv_filter == MV_FILTER_SMOOTH) { - filtered_row += mvs[index].row * gaussian_filter[i]; - filtered_col += mvs[index].col * gaussian_filter[i]; - } else if (mv_filter == MV_FILTER_MEDIAN) { - mvrows[i] = mvs[index].row; - mvcols[i] = mvs[index].col; - } - i++; + int i = 0; + double filtered_row = 0; + double filtered_col = 0; + for (int yy = y - n / 2; yy <= y + n / 2; yy++) { + for (int xx = x - n / 2; xx <= x + n / 2; xx++) { + int yvalue = yy; + int xvalue = xx; + // copied pixels outside the boundary + if (yvalue < 0) yvalue = 0; + if (xvalue < 0) xvalue = 0; + if (yvalue >= frame_height) yvalue = frame_height - 1; + if (xvalue >= frame_width) xvalue = frame_width - 1; + int index = yvalue * frame_width + xvalue; + if (mv_filter == MV_FILTER_SMOOTH) { + filtered_row += mvs[index].row * gaussian_filter[i]; + filtered_col += mvs[index].col * gaussian_filter[i]; + } else if (mv_filter == MV_FILTER_MEDIAN) { + mvrows[i] = mvs[index].row; + mvcols[i] = mvs[index].col; } + i++; } - - MV mv = mvs[center_idx]; - if (mv_filter == MV_FILTER_SMOOTH) { - mv.row = (int16_t)filtered_row; - mv.col = (int16_t)filtered_col; - } else if (mv_filter == MV_FILTER_MEDIAN) { - qsort(mvrows, 25, sizeof(mv.row), cmpfunc); - qsort(mvcols, 25, sizeof(mv.col), cmpfunc); - mv.row = mvrows[25 / 2]; - mv.col = mvcols[25 / 2]; - } - LOCALMV localmv = { .row = ((double)mv.row) / 8, - .col = ((double)mv.row) / 8 }; - localmvs[y * frame_width + x] = localmv; - // if mvs array is immediately updated here, then the result may - // propagate to other pixels. } + + MV mv = mvs[center_idx]; + if (mv_filter == MV_FILTER_SMOOTH) { + mv.row = (int16_t)filtered_row; + mv.col = (int16_t)filtered_col; + } else if (mv_filter == MV_FILTER_MEDIAN) { + qsort(mvrows, 25, sizeof(mv.row), cmpfunc); + qsort(mvcols, 25, sizeof(mv.col), cmpfunc); + mv.row = mvrows[25 / 2]; + mv.col = mvcols[25 / 2]; + } + LOCALMV localmv = { .row = ((double)mv.row) / 8, + .col = ((double)mv.row) / 8 }; + localmvs[y * frame_width + x] = localmv; + // if mvs array is immediately updated here, then the result may + // propagate to other pixels. } } for (int i = 0; i < frame_height * frame_width; i++) { - if (fabs(localmvs[i].row) > 0 || fabs(localmvs[i].col) > 0) { - MV mv = { .row = (int16_t)round(8 * localmvs[i].row), - .col = (int16_t)round(8 * localmvs[i].col) }; - mvs[i] = mv; - } + MV mv = { .row = (int16_t)round(8 * localmvs[i].row), + .col = (int16_t)round(8 * localmvs[i].col) }; + mvs[i] = mv; } } } @@ -478,20 +501,20 @@ // Computes optical flow at a single pyramid level, // using Lucas-Kanade algorithm. // Modifies mvs array. -void lucas_kanade(const YV12_BUFFER_CONFIG *frame_to_filter, - const YV12_BUFFER_CONFIG *ref_frame, const int level, - const LK_PARAMS *lk_params, const int num_ref_corners, - int *ref_corners, const int highres_frame_width, - const int bit_depth, LOCALMV *mvs) { +static void lucas_kanade(const YV12_BUFFER_CONFIG *from_frame, + const YV12_BUFFER_CONFIG *to_frame, const int level, + const LK_PARAMS *lk_params, const int num_ref_corners, + int *ref_corners, const int mv_stride, + const int bit_depth, LOCALMV *mvs) { assert(lk_params->window_size > 0 && lk_params->window_size % 2 == 0); const int n = lk_params->window_size; // algorithm is sensitive to window size - double *i_x = (double *)aom_malloc(n * n * sizeof(double)); - double *i_y = (double *)aom_malloc(n * n * sizeof(double)); - double *i_t = (double *)aom_malloc(n * n * sizeof(double)); + double *i_x = (double *)aom_malloc(n * n * sizeof(*i_x)); + double *i_y = (double *)aom_malloc(n * n * sizeof(*i_y)); + double *i_t = (double *)aom_malloc(n * n * sizeof(*i_t)); const int expand_multiplier = (int)pow(2, level); double sigma = 0.2 * n; - double *weights = (double *)aom_malloc(n * n * sizeof(double)); + double *weights = (double *)aom_malloc(n * n * sizeof(*weights)); // normalizing doesn't really affect anything since it's applied // to every component of M and b gaussian(sigma, n, 0, weights); @@ -500,7 +523,7 @@ const double y_coord = 1.0 * ref_corners[i * 2 + 1] / expand_multiplier; int highres_x = ref_corners[i * 2]; int highres_y = ref_corners[i * 2 + 1]; - int mv_idx = highres_y * (highres_frame_width) + highres_x; + int mv_idx = highres_y * (mv_stride) + highres_x; LOCALMV mv_old = mvs[mv_idx]; mv_old.row = mv_old.row / expand_multiplier; mv_old.col = mv_old.col / expand_multiplier; @@ -511,8 +534,8 @@ i_y[j] = 0; i_t[j] = 0; } - gradients_over_window(frame_to_filter, ref_frame, x_coord, y_coord, n, - bit_depth, i_x, i_y, i_t, &mv_old); + gradients_over_window(from_frame, to_frame, x_coord, y_coord, n, bit_depth, + i_x, i_y, i_t, &mv_old); double Mres1[1] = { 0 }, Mres2[1] = { 0 }, Mres3[1] = { 0 }; double bres1[1] = { 0 }, bres2[1] = { 0 }; for (int j = 0; j < n * n; j++) { @@ -547,11 +570,404 @@ aom_free(i_y); } +// Warp the src_frame to warper_frame according to mvs. +// mvs point to src_frame +static void warp_back_frame(YV12_BUFFER_CONFIG *warped_frame, + const YV12_BUFFER_CONFIG *src_frame, + const LOCALMV *mvs, int mv_stride) { + int w, h; + const int fw = src_frame->y_crop_width; + const int fh = src_frame->y_crop_height; + const int src_fs = src_frame->y_stride, warped_fs = warped_frame->y_stride; + const uint8_t *src_buf = src_frame->y_buffer; + uint8_t *warped_buf = warped_frame->y_buffer; + double temp; + for (h = 0; h < fh; h++) { + for (w = 0; w < fw; w++) { + double cord_x = (double)w + mvs[h * mv_stride + w].col; + double cord_y = (double)h + mvs[h * mv_stride + w].row; + cord_x = fclamp(cord_x, 0, (double)(fw - 1)); + cord_y = fclamp(cord_y, 0, (double)(fh - 1)); + const int floorx = (int)floor(cord_x); + const int floory = (int)floor(cord_y); + const double fracx = cord_x - (double)floorx; + const double fracy = cord_y - (double)floory; + + temp = 0; + for (int hh = 0; hh < 2; hh++) { + const double weighth = hh ? (fracy) : (1 - fracy); + for (int ww = 0; ww < 2; ww++) { + const double weightw = ww ? (fracx) : (1 - fracx); + int y = floory + hh; + int x = floorx + ww; + y = clamp(y, 0, fh - 1); + x = clamp(x, 0, fw - 1); + temp += (double)src_buf[y * src_fs + x] * weightw * weighth; + } + } + warped_buf[h * warped_fs + w] = (uint8_t)round(temp); + } + } +} + +// Same as warp_back_frame, but using a better interpolation filter. +static void warp_back_frame_intp(YV12_BUFFER_CONFIG *warped_frame, + const YV12_BUFFER_CONFIG *src_frame, + const LOCALMV *mvs, int mv_stride) { + int w, h; + const int fw = src_frame->y_crop_width; + const int fh = src_frame->y_crop_height; + const int warped_fs = warped_frame->y_stride; + uint8_t *warped_buf = warped_frame->y_buffer; + const int blk = 2; + uint8_t temp_blk[4]; + + const int is_intrabc = 0; // Is intra-copied? + const int is_high_bitdepth = is_frame_high_bitdepth(src_frame); + const int subsampling_x = 0, subsampling_y = 0; // for y-buffer + const int_interpfilters interp_filters = + av1_broadcast_interp_filter(MULTITAP_SHARP2); + const int plane = 0; // y-plane + const struct buf_2d ref_buf2 = { NULL, src_frame->y_buffer, + src_frame->y_crop_width, + src_frame->y_crop_height, + src_frame->y_stride }; + const int bit_depth = src_frame->bit_depth; + struct scale_factors scale; + av1_setup_scale_factors_for_frame( + &scale, src_frame->y_crop_width, src_frame->y_crop_height, + src_frame->y_crop_width, src_frame->y_crop_height); + + for (h = 0; h < fh; h++) { + for (w = 0; w < fw; w++) { + InterPredParams inter_pred_params; + av1_init_inter_params(&inter_pred_params, blk, blk, h, w, subsampling_x, + subsampling_y, bit_depth, is_high_bitdepth, + is_intrabc, &scale, &ref_buf2, interp_filters); + inter_pred_params.interp_filter_params[0] = + &av1_interp_filter_params_list[interp_filters.as_filters.x_filter]; + inter_pred_params.interp_filter_params[1] = + &av1_interp_filter_params_list[interp_filters.as_filters.y_filter]; + inter_pred_params.conv_params = get_conv_params(0, plane, bit_depth); + MV newmv = { .row = (int16_t)round((mvs[h * mv_stride + w].row) * 8), + .col = (int16_t)round((mvs[h * mv_stride + w].col) * 8) }; + av1_enc_build_one_inter_predictor(temp_blk, blk, &newmv, + &inter_pred_params); + warped_buf[h * warped_fs + w] = temp_blk[0]; + } + } +} + +#define DERIVATIVE_FILTER_LENGTH 7 +double filter[DERIVATIVE_FILTER_LENGTH] = { -1.0 / 60, 9.0 / 60, -45.0 / 60, 0, + 45.0 / 60, -9.0 / 60, 1.0 / 60 }; + +// Get gradient of the whole frame +static void get_frame_gradients(const YV12_BUFFER_CONFIG *from_frame, + const YV12_BUFFER_CONFIG *to_frame, double *ix, + double *iy, double *it, int grad_stride) { + int w, h, k, idx; + const int fw = from_frame->y_crop_width; + const int fh = from_frame->y_crop_height; + const int from_fs = from_frame->y_stride, to_fs = to_frame->y_stride; + const uint8_t *from_buf = from_frame->y_buffer; + const uint8_t *to_buf = to_frame->y_buffer; + + const int lh = DERIVATIVE_FILTER_LENGTH; + const int hleft = (lh - 1) / 2; + + for (h = 0; h < fh; h++) { + for (w = 0; w < fw; w++) { + // x + ix[h * grad_stride + w] = 0; + for (k = 0; k < lh; k++) { + // if we want to make this block dependent, need to extend the + // boundaries using other initializations. + idx = w + k - hleft; + idx = clamp(idx, 0, fw - 1); + ix[h * grad_stride + w] += filter[k] * 0.5 * + ((double)from_buf[h * from_fs + idx] + + (double)to_buf[h * to_fs + idx]); + } + // y + iy[h * grad_stride + w] = 0; + for (k = 0; k < lh; k++) { + // if we want to make this block dependent, need to extend the + // boundaries using other initializations. + idx = h + k - hleft; + idx = clamp(idx, 0, fh - 1); + iy[h * grad_stride + w] += filter[k] * 0.5 * + ((double)from_buf[idx * from_fs + w] + + (double)to_buf[idx * to_fs + w]); + } + // t + it[h * grad_stride + w] = + (double)to_buf[h * to_fs + w] - (double)from_buf[h * from_fs + w]; + } + } +} + +// Solve for linear equations given by the H-S method +static void solve_horn_schunck(const double *ix, const double *iy, + const double *it, int grad_stride, int width, + int height, const LOCALMV *init_mvs, + int init_mv_stride, LOCALMV *mvs, + int mv_stride) { + // TODO(bohanli): May just need to allocate the buffers once per optical flow + // calculation + int *row_pos = aom_calloc(width * height * 28, sizeof(*row_pos)); + int *col_pos = aom_calloc(width * height * 28, sizeof(*col_pos)); + double *values = aom_calloc(width * height * 28, sizeof(*values)); + double *mv_vec = aom_calloc(width * height * 2, sizeof(*mv_vec)); + double *mv_init_vec = aom_calloc(width * height * 2, sizeof(*mv_init_vec)); + double *temp_b = aom_calloc(width * height * 2, sizeof(*temp_b)); + double *b = aom_calloc(width * height * 2, sizeof(*b)); + + // the location idx for neighboring pixels, k < 4 are the 4 direct neighbors + const int check_locs_y[12] = { 0, 0, -1, 1, -1, -1, 1, 1, 0, 0, -2, 2 }; + const int check_locs_x[12] = { -1, 1, 0, 0, -1, 1, -1, 1, -2, 2, 0, 0 }; + + int h, w, checkh, checkw, k; + const int offset = height * width; + SPARSE_MTX A; + int c = 0; + const double lambda = 100; + + for (w = 0; w < width; w++) { + for (h = 0; h < height; h++) { + mv_init_vec[w * height + h] = init_mvs[h * init_mv_stride + w].col; + mv_init_vec[w * height + h + offset] = + init_mvs[h * init_mv_stride + w].row; + } + } + + // get matrix A + for (w = 0; w < width; w++) { + for (h = 0; h < height; h++) { + int center_num_direct = 4; + const int center_idx = w * height + h; + if (w == 0 || w == width - 1) center_num_direct--; + if (h == 0 || h == height - 1) center_num_direct--; + // diagonal entry for this row from the center pixel + double cor_w = center_num_direct * center_num_direct + center_num_direct; + row_pos[c] = center_idx; + col_pos[c] = center_idx; + values[c] = lambda * cor_w; + c++; + row_pos[c] = center_idx + offset; + col_pos[c] = center_idx + offset; + values[c] = lambda * cor_w; + c++; + // other entries from direct neighbors + for (k = 0; k < 4; k++) { + checkh = h + check_locs_y[k]; + checkw = w + check_locs_x[k]; + if (checkh < 0 || checkh >= height || checkw < 0 || checkw >= width) { + continue; + } + int this_idx = checkw * height + checkh; + int this_num_direct = 4; + if (checkw == 0 || checkw == width - 1) this_num_direct--; + if (checkh == 0 || checkh == height - 1) this_num_direct--; + cor_w = -center_num_direct - this_num_direct; + row_pos[c] = center_idx; + col_pos[c] = this_idx; + values[c] = lambda * cor_w; + c++; + row_pos[c] = center_idx + offset; + col_pos[c] = this_idx + offset; + values[c] = lambda * cor_w; + c++; + } + // entries from neighbors on the diagonal corners + for (k = 4; k < 8; k++) { + checkh = h + check_locs_y[k]; + checkw = w + check_locs_x[k]; + if (checkh < 0 || checkh >= height || checkw < 0 || checkw >= width) { + continue; + } + int this_idx = checkw * height + checkh; + cor_w = 2; + row_pos[c] = center_idx; + col_pos[c] = this_idx; + values[c] = lambda * cor_w; + c++; + row_pos[c] = center_idx + offset; + col_pos[c] = this_idx + offset; + values[c] = lambda * cor_w; + c++; + } + // entries from neighbors with dist of 2 + for (k = 8; k < 12; k++) { + checkh = h + check_locs_y[k]; + checkw = w + check_locs_x[k]; + if (checkh < 0 || checkh >= height || checkw < 0 || checkw >= width) { + continue; + } + int this_idx = checkw * height + checkh; + cor_w = 1; + row_pos[c] = center_idx; + col_pos[c] = this_idx; + values[c] = lambda * cor_w; + c++; + row_pos[c] = center_idx + offset; + col_pos[c] = this_idx + offset; + values[c] = lambda * cor_w; + c++; + } + } + } + av1_init_sparse_mtx(row_pos, col_pos, values, c, 2 * width * height, + 2 * width * height, &A); + // substract init mv part from b + av1_mtx_vect_multi_left(&A, mv_init_vec, temp_b, 2 * width * height); + for (int i = 0; i < 2 * width * height; i++) { + b[i] = -temp_b[i]; + } + av1_free_sparse_mtx_elems(&A); + + // add cross terms to A and modify b with ExEt / EyEt + for (w = 0; w < width; w++) { + for (h = 0; h < height; h++) { + int curidx = w * height + h; + // modify b + b[curidx] += -ix[h * grad_stride + w] * it[h * grad_stride + w]; + b[curidx + offset] += -iy[h * grad_stride + w] * it[h * grad_stride + w]; + // add cross terms to A + row_pos[c] = curidx; + col_pos[c] = curidx + offset; + values[c] = ix[h * grad_stride + w] * iy[h * grad_stride + w]; + c++; + row_pos[c] = curidx + offset; + col_pos[c] = curidx; + values[c] = ix[h * grad_stride + w] * iy[h * grad_stride + w]; + c++; + } + } + // Add diagonal terms to A + for (int i = 0; i < c; i++) { + if (row_pos[i] == col_pos[i]) { + if (row_pos[i] < offset) { + w = row_pos[i] / height; + h = row_pos[i] % height; + values[i] += pow(ix[h * grad_stride + w], 2); + } else { + w = (row_pos[i] - offset) / height; + h = (row_pos[i] - offset) % height; + values[i] += pow(iy[h * grad_stride + w], 2); + } + } + } + + av1_init_sparse_mtx(row_pos, col_pos, values, c, 2 * width * height, + 2 * width * height, &A); + + // solve for the mvs + av1_conjugate_gradient_sparse(&A, b, 2 * width * height, mv_vec); + // copy mvs + for (w = 0; w < width; w++) { + for (h = 0; h < height; h++) { + mvs[h * mv_stride + w].col = mv_vec[w * height + h]; + mvs[h * mv_stride + w].row = mv_vec[w * height + h + offset]; + } + } + aom_free(row_pos); + aom_free(col_pos); + aom_free(values); + aom_free(mv_vec); + aom_free(mv_init_vec); + aom_free(b); + aom_free(temp_b); + av1_free_sparse_mtx_elems(&A); +} + +// Calculate optical flow from from_frame to to_frame using the H-S method. +void horn_schunck(const YV12_BUFFER_CONFIG *from_frame, + const YV12_BUFFER_CONFIG *to_frame, const int level, + const int mv_stride, const int mv_height, const int mv_width, + const OPFL_PARAMS *opfl_params, LOCALMV *mvs) { + // mvs are always on level 0, here we define two new mv arrays that is of size + // of this level. + const int fw = from_frame->y_crop_width; + const int fh = from_frame->y_crop_height; + const int factor = (int)pow(2, level); + int w, h, k, init_mv_stride; + LOCALMV *init_mvs; + if (level == 0) { + init_mvs = mvs; + init_mv_stride = mv_stride; + } else { + init_mvs = aom_calloc(fw * fh, sizeof(*mvs)); + init_mv_stride = fw; + for (h = 0; h < fh; h++) { + for (w = 0; w < fw; w++) { + init_mvs[h * init_mv_stride + w].row = + mvs[h * factor * mv_stride + w * factor].row / (double)factor; + init_mvs[h * init_mv_stride + w].col = + mvs[h * factor * mv_stride + w * factor].col / (double)factor; + } + } + } + LOCALMV *refine_mvs = aom_calloc(fw * fh, sizeof(*mvs)); + // temp frame for warping + YV12_BUFFER_CONFIG temp_frame; + temp_frame.y_buffer = + (uint8_t *)aom_calloc(fh * fw, sizeof(*temp_frame.y_buffer)); + temp_frame.y_crop_height = fh; + temp_frame.y_crop_width = fw; + temp_frame.y_stride = fw; + // gradient buffers + double *ix = aom_calloc(fw * fh, sizeof(*ix)); + double *iy = aom_calloc(fw * fh, sizeof(*iy)); + double *it = aom_calloc(fw * fh, sizeof(*it)); + // For each warping step + for (k = 0; k < opfl_params->warping_steps; k++) { + // warp from_frame with init_mv + if (level == 0) { + warp_back_frame_intp(&temp_frame, to_frame, init_mvs, init_mv_stride); + } else { + warp_back_frame(&temp_frame, to_frame, init_mvs, init_mv_stride); + } + // calculate frame gradients + get_frame_gradients(from_frame, &temp_frame, ix, iy, it, fw); + // form linear equations and solve mvs + solve_horn_schunck(ix, iy, it, fw, fw, fh, init_mvs, init_mv_stride, + refine_mvs, fw); + // update init_mvs + for (h = 0; h < fh; h++) { + for (w = 0; w < fw; w++) { + init_mvs[h * init_mv_stride + w].col += refine_mvs[h * fw + w].col; + init_mvs[h * init_mv_stride + w].row += refine_mvs[h * fw + w].row; + } + } + } + // copy back the mvs if needed + if (level != 0) { + for (h = 0; h < mv_height; h++) { + for (w = 0; w < mv_width; w++) { + mvs[h * mv_stride + w].row = + init_mvs[h / factor * init_mv_stride + w / factor].row * + (double)factor; + mvs[h * mv_stride + w].col = + init_mvs[h / factor * init_mv_stride + w / factor].col * + (double)factor; + } + } + } + if (level != 0) aom_free(init_mvs); + aom_free(refine_mvs); + aom_free(temp_frame.y_buffer); + aom_free(ix); + aom_free(iy); + aom_free(it); +} + // Apply optical flow iteratively at each pyramid level -void pyramid_optical_flow(const YV12_BUFFER_CONFIG *from_frame, - const YV12_BUFFER_CONFIG *to_frame, - const int bit_depth, const OPFL_PARAMS *opfl_params, - const OPTFLOW_METHOD method, LOCALMV *mvs) { +static void pyramid_optical_flow(const YV12_BUFFER_CONFIG *from_frame, + const YV12_BUFFER_CONFIG *to_frame, + const int bit_depth, + const OPFL_PARAMS *opfl_params, + const OPTFLOW_METHOD method, LOCALMV *mvs) { assert(opfl_params->pyramid_levels > 0 && opfl_params->pyramid_levels <= MAX_PYRAMID_LEVELS); int levels = opfl_params->pyramid_levels; @@ -565,17 +981,16 @@ uint8_t *images2[MAX_PYRAMID_LEVELS]; images1[0] = from_frame->y_buffer; images2[0] = to_frame->y_buffer; - YV12_BUFFER_CONFIG *buffers1 = - aom_malloc(levels * sizeof(YV12_BUFFER_CONFIG)); - YV12_BUFFER_CONFIG *buffers2 = - aom_malloc(levels * sizeof(YV12_BUFFER_CONFIG)); + YV12_BUFFER_CONFIG *buffers1 = aom_malloc(levels * sizeof(*buffers1)); + YV12_BUFFER_CONFIG *buffers2 = aom_malloc(levels * sizeof(*buffers2)); buffers1[0] = *from_frame; buffers2[0] = *to_frame; int fw = frame_width; int fh = frame_height; for (int i = 1; i < levels; i++) { - images1[i] = (uint8_t *)aom_calloc(fh / 2 * fw / 2, sizeof(uint8_t)); - images2[i] = (uint8_t *)aom_calloc(fh / 2 * fw / 2, sizeof(uint8_t)); + // TODO(bohanli): may need to extend buffers for better interpolation SIMD + images1[i] = (uint8_t *)aom_calloc(fh / 2 * fw / 2, sizeof(*images1[i])); + images2[i] = (uint8_t *)aom_calloc(fh / 2 * fw / 2, sizeof(*images2[i])); int stride; if (i == 1) stride = from_frame->y_stride; @@ -597,10 +1012,11 @@ buffers2[i] = b; } // Compute corners for specific frame - int maxcorners = from_frame->y_crop_width * from_frame->y_crop_height; - int *ref_corners = aom_malloc(maxcorners * 2 * sizeof(int)); + int *ref_corners = NULL; int num_ref_corners = 0; if (is_sparse(opfl_params)) { + int maxcorners = from_frame->y_crop_width * from_frame->y_crop_height; + ref_corners = aom_malloc(maxcorners * 2 * sizeof(*ref_corners)); num_ref_corners = detect_corners(from_frame, to_frame, maxcorners, ref_corners, bit_depth); } @@ -611,6 +1027,11 @@ lucas_kanade(&buffers1[i], &buffers2[i], i, opfl_params->lk_params, num_ref_corners, ref_corners, buffers1[0].y_crop_width, bit_depth, mvs); + } else if (method == HORN_SCHUNCK) { + assert(!is_sparse(opfl_params)); + horn_schunck(&buffers1[i], &buffers2[i], i, buffers1[0].y_crop_width, + buffers1[0].y_crop_height, buffers1[0].y_crop_width, + opfl_params, mvs); } } for (int i = 1; i < levels; i++) { @@ -618,6 +1039,8 @@ aom_free(images2[i]); } aom_free(ref_corners); + aom_free(buffers1); + aom_free(buffers2); } // Computes optical flow by applying algorithm at // multiple pyramid levels of images (lower-resolution, smoothed images) @@ -630,16 +1053,16 @@ // bit_depth: // opfl_params: contains algorithm-specific parameters. // mv_filter: MV_FILTER_NONE, MV_FILTER_SMOOTH, or MV_FILTER_MEDIAN. -// method: LUCAS_KANADE, +// method: LUCAS_KANADE, HORN_SCHUNCK // mvs: pointer to MVs. Contains initialization, and modified // based on optical flow. Must have // dimensions = from_frame->y_crop_width * from_frame->y_crop_height -void optical_flow(const YV12_BUFFER_CONFIG *from_frame, - const YV12_BUFFER_CONFIG *to_frame, const int from_frame_idx, - const int to_frame_idx, const int bit_depth, - const OPFL_PARAMS *opfl_params, - const MV_FILTER_TYPE mv_filter, const OPTFLOW_METHOD method, - MV *mvs) { +void av1_optical_flow(const YV12_BUFFER_CONFIG *from_frame, + const YV12_BUFFER_CONFIG *to_frame, + const int from_frame_idx, const int to_frame_idx, + const int bit_depth, const OPFL_PARAMS *opfl_params, + const MV_FILTER_TYPE mv_filter, + const OPTFLOW_METHOD method, MV *mvs) { const int frame_height = from_frame->y_crop_height; const int frame_width = from_frame->y_crop_width; // TODO(any): deal with the case where frames are not of the same dimensions @@ -657,7 +1080,11 @@ } // Initialize double mvs based on input parameter mvs array - LOCALMV *localmvs = aom_malloc(frame_height * frame_width * sizeof(LOCALMV)); + LOCALMV *localmvs = + aom_malloc(frame_height * frame_width * sizeof(*localmvs)); + + filter_mvs(MV_FILTER_SMOOTH, frame_height, frame_width, localmvs, mvs); + for (int i = 0; i < frame_width * frame_height; i++) { MV mv = mvs[i]; LOCALMV localmv = { .row = ((double)mv.row) / 8, @@ -672,18 +1099,13 @@ for (int j = 0; j < frame_height; j++) { for (int i = 0; i < frame_width; i++) { int idx = j * frame_width + i; - int new_x = (int)(localmvs[idx].row + i); - int new_y = (int)(localmvs[idx].col + j); - if ((fabs(localmvs[idx].row) >= 0.125 || - fabs(localmvs[idx].col) >= 0.125)) { - // if mv points outside of frame (lost feature), keep old mv. - if (new_x < frame_width && new_x >= 0 && new_y < frame_height && - new_y >= 0) { - MV mv = { .row = (int16_t)round(8 * localmvs[idx].row), - .col = (int16_t)round(8 * localmvs[idx].col) }; - mvs[idx] = mv; - } + if (j + localmvs[idx].row < 0 || j + localmvs[idx].row >= frame_height || + i + localmvs[idx].col < 0 || i + localmvs[idx].col >= frame_width) { + continue; } + MV mv = { .row = (int16_t)round(8 * localmvs[idx].row), + .col = (int16_t)round(8 * localmvs[idx].col) }; + mvs[idx] = mv; } }
diff --git a/av1/encoder/optical_flow.h b/av1/encoder/optical_flow.h index 9b7cd62..2fbe474 100644 --- a/av1/encoder/optical_flow.h +++ b/av1/encoder/optical_flow.h
@@ -12,6 +12,8 @@ #ifndef AOM_AV1_ENCODER_OPTICAL_FLOW_H_ #define AOM_AV1_ENCODER_OPTICAL_FLOW_H_ +#include "aom_scale/yv12config.h" +#include "av1/common/mv.h" #include "config/aom_config.h" #ifdef __cplusplus @@ -20,7 +22,7 @@ #if CONFIG_OPTICAL_FLOW_API -typedef enum { LUCAS_KANADE } OPTFLOW_METHOD; +typedef enum { LUCAS_KANADE, HORN_SCHUNCK } OPTFLOW_METHOD; typedef enum { MV_FILTER_NONE, @@ -28,10 +30,16 @@ MV_FILTER_MEDIAN } MV_FILTER_TYPE; +typedef struct LOCALMV { + double row; + double col; +} LOCALMV; + #define MAX_PYRAMID_LEVELS 5 // default options for optical flow #define OPFL_WINDOW_SIZE 15 #define OPFL_PYRAMID_LEVELS 3 // total levels +#define OPFL_WARPING_STEPS 3 // parameters specific to Lucas-Kanade typedef struct lk_params { @@ -42,27 +50,23 @@ // optical flow algorithms typedef struct opfl_params { int pyramid_levels; + int warping_steps; LK_PARAMS *lk_params; int flags; } OPFL_PARAMS; #define OPFL_FLAG_SPARSE 1 -void init_opfl_params(OPFL_PARAMS *opfl_params) { - opfl_params->pyramid_levels = OPFL_PYRAMID_LEVELS; - opfl_params->lk_params = NULL; -} +void av1_init_opfl_params(OPFL_PARAMS *opfl_params); -void init_lk_params(LK_PARAMS *lk_params) { - lk_params->window_size = OPFL_WINDOW_SIZE; -} +void av1_init_lk_params(LK_PARAMS *lk_params); -void optical_flow(const YV12_BUFFER_CONFIG *from_frame, - const YV12_BUFFER_CONFIG *to_frame, const int from_frame_idx, - const int to_frame_idx, const int bit_depth, - const OPFL_PARAMS *opfl_params, - const MV_FILTER_TYPE mv_filter, const OPTFLOW_METHOD method, - MV *mvs); +void av1_optical_flow(const YV12_BUFFER_CONFIG *from_frame, + const YV12_BUFFER_CONFIG *to_frame, + const int from_frame_idx, const int to_frame_idx, + const int bit_depth, const OPFL_PARAMS *opfl_params, + const MV_FILTER_TYPE mv_filter, + const OPTFLOW_METHOD method, MV *mvs); #endif #ifdef __cplusplus
diff --git a/av1/encoder/palette.c b/av1/encoder/palette.c index f821bdc..fd579b7 100644 --- a/av1/encoder/palette.c +++ b/av1/encoder/palette.c
@@ -251,10 +251,7 @@ 1); extend_palette_color_map(color_map, cols, rows, block_width, block_height); - const int palette_mode_cost = - intra_mode_info_cost_y(cpi, x, mbmi, bsize, dc_mode_cost); - if (model_intra_yrd_and_prune(cpi, x, bsize, palette_mode_cost, - best_model_rd)) { + if (model_intra_yrd_and_prune(cpi, x, bsize, best_model_rd)) { return; } @@ -262,6 +259,8 @@ av1_pick_uniform_tx_size_type_yrd(cpi, x, &tokenonly_rd_stats, bsize, *best_rd); if (tokenonly_rd_stats.rate == INT_MAX) return; + const int palette_mode_cost = + intra_mode_info_cost_y(cpi, x, mbmi, bsize, dc_mode_cost); int this_rate = tokenonly_rd_stats.rate + palette_mode_cost; int64_t this_rd = RDCOST(x->rdmult, this_rate, tokenonly_rd_stats.dist); if (!xd->lossless[mbmi->segment_id] && block_signals_txsize(mbmi->bsize)) {
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c index b50bbd5..c3f88ae 100644 --- a/av1/encoder/partition_search.c +++ b/av1/encoder/partition_search.c
@@ -34,6 +34,44 @@ #include "av1/encoder/tune_vmaf.h" #endif +void av1_reset_part_sf(PARTITION_SPEED_FEATURES *part_sf) { + part_sf->partition_search_type = SEARCH_PARTITION; + part_sf->less_rectangular_check_level = 0; + part_sf->use_square_partition_only_threshold = BLOCK_128X128; + part_sf->auto_max_partition_based_on_simple_motion = NOT_IN_USE; + part_sf->default_max_partition_size = BLOCK_LARGEST; + part_sf->default_min_partition_size = BLOCK_4X4; + part_sf->adjust_var_based_rd_partitioning = 0; + part_sf->allow_partition_search_skip = 0; + part_sf->max_intra_bsize = BLOCK_LARGEST; + // This setting only takes effect when partition_search_type is set + // to FIXED_PARTITION. + part_sf->fixed_partition_size = BLOCK_16X16; + // Recode loop tolerance %. + part_sf->partition_search_breakout_dist_thr = 0; + part_sf->partition_search_breakout_rate_thr = 0; + part_sf->prune_ext_partition_types_search_level = 0; + part_sf->prune_part4_search = 0; + part_sf->ml_prune_partition = 0; + part_sf->ml_early_term_after_part_split_level = 0; + for (int i = 0; i < PARTITION_BLOCK_SIZES; ++i) { + part_sf->ml_partition_search_breakout_thresh[i] = + -1; // -1 means not enabled. + } + part_sf->simple_motion_search_prune_agg = 0; + part_sf->simple_motion_search_split = 0; + part_sf->simple_motion_search_prune_rect = 0; + part_sf->simple_motion_search_early_term_none = 0; + part_sf->simple_motion_search_reduce_search_steps = 0; + part_sf->intra_cnn_split = 0; + part_sf->ext_partition_eval_thresh = BLOCK_8X8; + part_sf->prune_ext_part_using_split_info = 0; + part_sf->prune_rectangular_split_based_on_qidx = 0; + part_sf->early_term_after_none_split = 0; + part_sf->ml_predict_breakout_level = 0; + part_sf->prune_sub_8x8_partition_level = 0; +} + static void update_txfm_count(MACROBLOCK *x, MACROBLOCKD *xd, FRAME_COUNTS *counts, TX_SIZE tx_size, int depth, int blk_row, int blk_col, @@ -151,11 +189,14 @@ const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; const int bsw = tx_size_wide_unit[sub_txs]; const int bsh = tx_size_high_unit[sub_txs]; - for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { - for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { - const int offsetr = blk_row + row; + const int row_end = + AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); + const int col_end = + AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); + for (int row = 0; row < row_end; row += bsh) { + const int offsetr = blk_row + row; + for (int col = 0; col < col_end; col += bsw) { const int offsetc = blk_col + col; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; set_txfm_context(xd, sub_txs, offsetr, offsetc); } } @@ -185,28 +226,30 @@ static void update_zeromv_cnt(const AV1_COMP *const cpi, const MB_MODE_INFO *const mi, int mi_row, int mi_col, BLOCK_SIZE bsize) { + if (mi->ref_frame[0] != LAST_FRAME || !is_inter_block(mi) || + mi->segment_id > CR_SEGMENT_ID_BOOST2) { + return; + } const AV1_COMMON *const cm = &cpi->common; - MV mv = mi->mv[0].as_mv; + const MV mv = mi->mv[0].as_mv; const int bw = mi_size_wide[bsize] >> 1; const int bh = mi_size_high[bsize] >> 1; const int xmis = AOMMIN((cm->mi_params.mi_cols - mi_col) >> 1, bw); const int ymis = AOMMIN((cm->mi_params.mi_rows - mi_row) >> 1, bh); const int block_index = (mi_row >> 1) * (cm->mi_params.mi_cols >> 1) + (mi_col >> 1); - for (int y = 0; y < ymis; y++) + for (int y = 0; y < ymis; y++) { for (int x = 0; x < xmis; x++) { // consec_zero_mv is in the scale of 8x8 blocks const int map_offset = block_index + y * (cm->mi_params.mi_cols >> 1) + x; - if (mi->ref_frame[0] == LAST_FRAME && is_inter_block(mi) && - mi->segment_id <= CR_SEGMENT_ID_BOOST2) { - if (abs(mv.row) < 10 && abs(mv.col) < 10) { - if (cpi->consec_zero_mv[map_offset] < 255) - cpi->consec_zero_mv[map_offset]++; - } else { - cpi->consec_zero_mv[map_offset] = 0; - } + if (abs(mv.row) < 10 && abs(mv.col) < 10) { + if (cpi->consec_zero_mv[map_offset] < 255) + cpi->consec_zero_mv[map_offset]++; + } else { + cpi->consec_zero_mv[map_offset] = 0; } } + } } static void encode_superblock(const AV1_COMP *const cpi, TileDataEnc *tile_data, @@ -443,6 +486,11 @@ av1_set_vmaf_rdmult(cpi, x, bsize, mi_row, mi_col, &x->rdmult); } #endif +#if CONFIG_TUNE_BUTTERAUGLI + if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_BUTTERAUGLI) { + av1_set_butteraugli_rdmult(cpi, x, bsize, mi_row, mi_col, &x->rdmult); + } +#endif } void av1_set_offsets_without_segment_id(const AV1_COMP *const cpi, @@ -516,9 +564,9 @@ * \ingroup intra_mode_search * \callgraph * \callergraph - * This is top level function for mode srarch for intra frames in non-RD - * optimized case. Depending on speed feature, rate control mode and block - * size it calls either non-RD or RD optimized intra mode search + * This is top level function for mode search for intra frames in non-RD + * optimized case. Depending on speed feature and block size it calls + * either non-RD or RD optimized intra mode search. * * \param[in] cpi Top-level encoder structure * \param[in] x Pointer to structure holding all the data for @@ -539,10 +587,7 @@ RD_STATS *rd_cost, BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { - // TODO(jianj): Investigate the failure of ScalabilityTest in AOM_Q mode, - // which sets base_qindex to 0 on keyframe. - if (cpi->oxcf.rc_cfg.mode != AOM_CBR || - !cpi->sf.rt_sf.hybrid_intra_pickmode || bsize < BLOCK_16X16) + if (cpi->sf.rt_sf.hybrid_intra_pickmode && bsize < BLOCK_16X16) av1_rd_pick_intra_mode_sb(cpi, x, rd_cost, bsize, ctx, INT64_MAX); else av1_nonrd_pick_intra_mode(cpi, x, rd_cost, bsize, ctx); @@ -794,10 +839,16 @@ } if (av1_allow_intrabc(cm)) { - update_cdf(fc->intrabc_cdf, is_intrabc_block(mbmi), 2); + const int is_intrabc = is_intrabc_block(mbmi); + update_cdf(fc->intrabc_cdf, is_intrabc, 2); #if CONFIG_ENTROPY_STATS - ++td->counts->intrabc[is_intrabc_block(mbmi)]; + ++td->counts->intrabc[is_intrabc]; #endif // CONFIG_ENTROPY_STATS + if (is_intrabc) { + const int_mv dv_ref = x->mbmi_ext_frame->ref_mv_stack[0].this_mv; + av1_update_mv_stats(&mbmi->mv[0].as_mv, &dv_ref.as_mv, &fc->ndvc, + MV_SUBPEL_NONE); + } } if (frame_is_intra_only(cm) || mbmi->skip_mode) return; @@ -1813,6 +1864,30 @@ av1_ref_frame_type(xd->mi[0]->ref_frame)); x->rdmult = origin_mult; } + +static AOM_INLINE void wait_for_top_right_sb( + AV1EncRowMultiThreadInfo *enc_row_mt, AV1EncRowMultiThreadSync *row_mt_sync, + TileInfo *tile_info, BLOCK_SIZE sb_size, int sb_mi_size_log2, + BLOCK_SIZE bsize, int mi_row, int mi_col) { + const int sb_size_in_mi = mi_size_wide[sb_size]; + const int bw_in_mi = mi_size_wide[bsize]; + const int blk_row_in_sb = mi_row & (sb_size_in_mi - 1); + const int blk_col_in_sb = mi_col & (sb_size_in_mi - 1); + const int top_right_block_in_sb = + (blk_row_in_sb == 0) && (blk_col_in_sb + bw_in_mi >= sb_size_in_mi); + + // Don't wait if the block is the not the top-right block in the superblock. + if (!top_right_block_in_sb) return; + + // Wait for the top-right superblock to finish encoding. + const int sb_row_in_tile = + (mi_row - tile_info->mi_row_start) >> sb_mi_size_log2; + const int sb_col_in_tile = + (mi_col - tile_info->mi_col_start) >> sb_mi_size_log2; + + (*(enc_row_mt->sync_read_ptr))(row_mt_sync, sb_row_in_tile, sb_col_in_tile); +} + /*!\brief Top level function to pick block mode for non-RD optimized case * * \ingroup partition_search @@ -1859,6 +1934,11 @@ const AQ_MODE aq_mode = cpi->oxcf.q_cfg.aq_mode; TxfmSearchInfo *txfm_info = &x->txfm_search_info; int i; + + wait_for_top_right_sb(&cpi->mt_info.enc_row_mt, &tile_data->row_mt_sync, + &tile_data->tile_info, cm->seq_params.sb_size, + cm->seq_params.mib_size_log2, bsize, mi_row, mi_col); + #if CONFIG_COLLECT_COMPONENT_TIMING start_timing(cpi, rd_pick_sb_modes_time); #endif @@ -2268,15 +2348,15 @@ // Loop over sub-partitions in AB partition type. for (int i = 0; i < SUB_PARTITIONS_AB; i++) { if (mode_cache && mode_cache[i]) { - x->use_intermode_cache = 1; - x->intermode_cache = mode_cache[i]; + x->use_mb_mode_cache = 1; + x->mb_mode_cache = mode_cache[i]; } const int mode_search_success = rd_try_subblock(cpi, td, tile_data, tp, i == SUB_PARTITIONS_AB - 1, ab_mi_pos[i][0], ab_mi_pos[i][1], ab_subsize[i], *best_rdc, &sum_rdc, partition, ctxs[i]); - x->use_intermode_cache = 0; - x->intermode_cache = NULL; + x->use_mb_mode_cache = 0; + x->mb_mode_cache = NULL; if (!mode_search_success) { return false; } @@ -2596,7 +2676,8 @@ TokenExtra **tp, MACROBLOCK *x, PC_TREE *pc_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx, PartitionSearchState *part_search_state, RD_STATS *best_rdc, - RD_RECT_PART_WIN_INFO *rect_part_win_info) { + RD_RECT_PART_WIN_INFO *rect_part_win_info, const RECT_PART_TYPE start_type, + const RECT_PART_TYPE end_type) { const AV1_COMMON *const cm = &cpi->common; PartitionBlkParams blk_params = part_search_state->part_blk_params; RD_STATS *sum_rdc = &part_search_state->sum_rdc; @@ -2630,7 +2711,7 @@ }; // Loop over rectangular partition types. - for (RECT_PART_TYPE i = HORZ; i < NUM_RECT_PARTS; i++) { + for (RECT_PART_TYPE i = start_type; i <= end_type; i++) { assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions, !part_search_state->partition_rect_allowed[i])); @@ -2846,7 +2927,8 @@ TokenExtra **tp, MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx, 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) { + int pb_source_variance, int ext_partition_allowed, + const AB_PART_TYPE start_type, const AB_PART_TYPE end_type) { 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; @@ -2913,7 +2995,7 @@ }; // Loop over AB partition types. - for (AB_PART_TYPE ab_part_type = 0; ab_part_type < NUM_AB_PARTS; + for (AB_PART_TYPE ab_part_type = start_type; ab_part_type <= end_type; ab_part_type++) { const PARTITION_TYPE part_type = ab_part_type + PARTITION_HORZ_A; @@ -2949,7 +3031,7 @@ // Even if the contexts don't match, we can still speed up by reusing the // previous prediction mode. const MB_MODE_INFO *mode_cache[3] = { NULL, NULL, NULL }; - if (cpi->sf.inter_sf.reuse_best_prediction_for_part_ab) { + if (cpi->sf.part_sf.reuse_best_prediction_for_part_ab) { set_mode_cache_for_partition_ab(mode_cache, pc_tree, ab_part_type); } @@ -3324,6 +3406,7 @@ int pt_cost = 0; RD_STATS best_remain_rdcost; + av1_invalid_rd_stats(&best_remain_rdcost); // Set PARTITION_NONE context and cost. set_none_partition_params(cpi, td, x, pc_tree, part_search_state, @@ -3520,6 +3603,363 @@ av1_restore_context(x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm)); } +static void write_partition_tree(AV1_COMP *const cpi, + const PC_TREE *const pc_tree, + const BLOCK_SIZE bsize, const int mi_row, + const int mi_col) { + (void)mi_row; + (void)mi_col; + char filename[128]; + snprintf(filename, sizeof(filename), "partition_tree_sb%d_c%d", + cpi->sb_counter, 0); + ++cpi->sb_counter; + FILE *pfile = fopen(filename, "w"); + fprintf(pfile, "%d", bsize); + + // Write partition type with BFS order. + const PC_TREE *tree_node_queue[1024] = { NULL }; + int q_idx = 0; + int depth = 0; + int last_idx = 1; + int num_nodes = 1; + + // First traversal to get number of leaf nodes and depth. + tree_node_queue[q_idx] = pc_tree; + while (num_nodes > 0) { + const PC_TREE *node = tree_node_queue[q_idx]; + if (node->partitioning == PARTITION_SPLIT) { + for (int i = 0; i < 4; ++i) { + tree_node_queue[last_idx] = node->split[i]; + ++last_idx; + } + ++depth; + num_nodes += 4; + } + --num_nodes; + ++q_idx; + } + const int num_leafs = last_idx; + fprintf(pfile, ",%d,%d", num_leafs, /*num_configs=*/1); + + // Write partitions for each node. + q_idx = 0; + depth = 0; + last_idx = 1; + num_nodes = 1; + tree_node_queue[q_idx] = pc_tree; + while (num_nodes > 0) { + const PC_TREE *node = tree_node_queue[q_idx]; + fprintf(pfile, ",%d", node->partitioning); + if (node->partitioning == PARTITION_SPLIT) { + for (int i = 0; i < 4; ++i) { + tree_node_queue[last_idx] = node->split[i]; + ++last_idx; + } + ++depth; + num_nodes += 4; + } + --num_nodes; + ++q_idx; + } + fprintf(pfile, "\n"); + + fclose(pfile); +} + +static void verify_write_partition_tree(const AV1_COMP *const cpi, + const PC_TREE *const pc_tree, + const BLOCK_SIZE bsize, + const int config_id, const int mi_row, + const int mi_col) { + (void)mi_row; + (void)mi_col; + char filename[128]; + snprintf(filename, sizeof(filename), "verify_partition_tree_sb%d_c%d", + cpi->sb_counter - 1, config_id); + FILE *pfile = fopen(filename, "w"); + fprintf(pfile, "%d", bsize); + + // Write partition type with BFS order. + const PC_TREE *tree_node_queue[1024] = { NULL }; + int q_idx = 0; + int depth = 0; + int last_idx = 1; + int num_nodes = 1; + + // First traversal to get number of leaf nodes and depth. + tree_node_queue[q_idx] = pc_tree; + while (num_nodes > 0) { + const PC_TREE *node = tree_node_queue[q_idx]; + if (node != NULL && node->partitioning == PARTITION_SPLIT) { + for (int i = 0; i < 4; ++i) { + tree_node_queue[last_idx] = node->split[i]; + ++last_idx; + } + ++depth; + num_nodes += 4; + } + --num_nodes; + ++q_idx; + } + const int num_leafs = last_idx; + fprintf(pfile, ",%d,%d", num_leafs, /*num_configs=*/1); + + // Write partitions for each node. + q_idx = 0; + depth = 0; + last_idx = 1; + num_nodes = 1; + tree_node_queue[q_idx] = pc_tree; + while (num_nodes > 0) { + const PC_TREE *node = tree_node_queue[q_idx]; + if (node != NULL) { // suppress warning + fprintf(pfile, ",%d", node->partitioning); + if (node->partitioning == PARTITION_SPLIT) { + for (int i = 0; i < 4; ++i) { + tree_node_queue[last_idx] = node->split[i]; + ++last_idx; + } + ++depth; + num_nodes += 4; + } + } + --num_nodes; + ++q_idx; + } + fprintf(pfile, "\n"); + + fclose(pfile); +} + +static int read_partition_tree(AV1_COMP *const cpi, PC_TREE *const pc_tree, + const int config_id) { + char filename[128]; + snprintf(filename, sizeof(filename), "partition_tree_sb%d_c%d", + cpi->sb_counter, config_id); + FILE *pfile = fopen(filename, "r"); + if (pfile == NULL) { + printf("Can't find the file: %s\n", filename); + exit(0); + } + + int read_bsize; + int num_nodes; + int num_configs; + fscanf(pfile, "%d,%d,%d", &read_bsize, &num_nodes, &num_configs); + assert(read_bsize == cpi->common.seq_params.sb_size); + BLOCK_SIZE bsize = (BLOCK_SIZE)read_bsize; + + PC_TREE *tree_node_queue[1024] = { NULL }; + int last_idx = 1; + int q_idx = 0; + tree_node_queue[q_idx] = pc_tree; + while (num_nodes > 0) { + int partitioning; + fscanf(pfile, ",%d", &partitioning); + assert(partitioning >= PARTITION_NONE && + partitioning < EXT_PARTITION_TYPES); + PC_TREE *node = tree_node_queue[q_idx]; + if (node != NULL) node->partitioning = partitioning; + if (partitioning == PARTITION_SPLIT) { + const BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_SPLIT); + for (int i = 0; i < 4; ++i) { + if (node != NULL) { // Suppress warning + node->split[i] = av1_alloc_pc_tree_node(subsize); + node->split[i]->index = i; + tree_node_queue[last_idx] = node->split[i]; + ++last_idx; + } + } + bsize = subsize; + } + --num_nodes; + ++q_idx; + } + fclose(pfile); + + return num_configs; +} + +static int64_t rd_search_for_fixed_partition( + AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data, + TokenExtra **tp, SIMPLE_MOTION_DATA_TREE *sms_tree, int mi_row, int mi_col, + const BLOCK_SIZE bsize, PC_TREE *pc_tree) { + const PARTITION_TYPE partition = pc_tree->partitioning; + const AV1_COMMON *const cm = &cpi->common; + const int num_planes = av1_num_planes(cm); + MACROBLOCK *const x = &td->mb; + MACROBLOCKD *const xd = &x->e_mbd; + TileInfo *const tile_info = &tile_data->tile_info; + int64_t rdcost = INT64_MAX; + RD_STATS this_rdc; + RD_STATS best_rdc; + av1_invalid_rd_stats(&this_rdc); + av1_invalid_rd_stats(&best_rdc); + PartitionSearchState part_search_state; + init_partition_search_state_params(x, cpi, &part_search_state, mi_row, mi_col, + bsize); + + av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize); + + // 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); + (void)orig_rdmult; + + // Set the context. + RD_SEARCH_MACROBLOCK_CONTEXT x_ctx; + xd->above_txfm_context = + cm->above_contexts.txfm[tile_info->tile_row] + mi_col; + 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); + + assert(bsize < BLOCK_SIZES_ALL); + unsigned int pb_source_variance = UINT_MAX; + int64_t part_none_rd = INT64_MAX; + int64_t none_rd = INT64_MAX; + int inc_step[NUM_PART4_TYPES] = { 0 }; + if (partition == PARTITION_HORZ_4) inc_step[HORZ4] = mi_size_high[bsize] / 4; + if (partition == PARTITION_VERT_4) inc_step[VERT4] = mi_size_wide[bsize] / 4; + + switch (partition) { + case PARTITION_NONE: + 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); + break; + case PARTITION_HORZ: + rectangular_partition_search(cpi, td, tile_data, tp, x, pc_tree, &x_ctx, + &part_search_state, &best_rdc, NULL, HORZ, + HORZ); + break; + case PARTITION_VERT: + rectangular_partition_search(cpi, td, tile_data, tp, x, pc_tree, &x_ctx, + &part_search_state, &best_rdc, NULL, VERT, + VERT); + break; + case PARTITION_HORZ_A: + ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree, + &part_search_state, &best_rdc, NULL, + pb_source_variance, 1, HORZ_A, HORZ_A); + break; + case PARTITION_HORZ_B: + ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree, + &part_search_state, &best_rdc, NULL, + pb_source_variance, 1, HORZ_B, HORZ_B); + break; + case PARTITION_VERT_A: + ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree, + &part_search_state, &best_rdc, NULL, + pb_source_variance, 1, VERT_A, VERT_A); + break; + case PARTITION_VERT_B: + ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree, + &part_search_state, &best_rdc, NULL, + pb_source_variance, 1, VERT_B, VERT_B); + break; + case PARTITION_HORZ_4: + 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); + break; + case PARTITION_VERT_4: + 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); + break; + case PARTITION_SPLIT: + rdcost = 0; + for (int idx = 0; idx < SUB_PARTITIONS_SPLIT; ++idx) { + const BLOCK_SIZE subsize = + get_partition_subsize(bsize, PARTITION_SPLIT); + assert(subsize < BLOCK_SIZES_ALL); + const int next_mi_row = + idx < 2 ? mi_row : mi_row + mi_size_high[subsize]; + const int next_mi_col = + idx % 2 == 0 ? mi_col : mi_col + mi_size_wide[subsize]; + if (next_mi_row >= cm->mi_params.mi_rows || + next_mi_col >= cm->mi_params.mi_cols) { + continue; + } + rdcost += rd_search_for_fixed_partition( + cpi, td, tile_data, tp, sms_tree->split[idx], next_mi_row, + next_mi_col, subsize, pc_tree->split[idx]); + } + break; + default: assert(0 && "invalid partition type."); exit(0); + } + // Note: it is necessary to restore context information. + av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); + + if (bsize != cm->seq_params.sb_size) { + encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize, + pc_tree, NULL); + } + x->rdmult = orig_rdmult; + + if (rdcost == INT64_MAX) { + rdcost = RDCOST(x->rdmult, best_rdc.rate, best_rdc.dist); + } + return rdcost; +} + +bool av1_rd_partition_search(AV1_COMP *const cpi, ThreadData *td, + TileDataEnc *tile_data, TokenExtra **tp, + SIMPLE_MOTION_DATA_TREE *sms_root, int mi_row, + int mi_col, const BLOCK_SIZE bsize, + RD_STATS *best_rd_cost) { + AV1_COMMON *const cm = &cpi->common; + MACROBLOCK *const x = &td->mb; + int best_idx = 0; + int64_t min_rdcost = INT64_MAX; + int num_configs; + int64_t *rdcost = NULL; + int i = 0; + do { + PC_TREE *const pc_tree = av1_alloc_pc_tree_node(bsize); + num_configs = read_partition_tree(cpi, pc_tree, i); + if (i == 0) { + rdcost = aom_calloc(num_configs, sizeof(int64_t)); + } + if (num_configs <= 0) { + av1_free_pc_tree_recursive(pc_tree, av1_num_planes(cm), 0, 0); + if (rdcost != NULL) aom_free(rdcost); + exit(0); + return false; + } + verify_write_partition_tree(cpi, pc_tree, bsize, i, mi_row, mi_col); + // Encode the block with the given partition tree. Get rdcost and encoding + // time. + rdcost[i] = rd_search_for_fixed_partition(cpi, td, tile_data, tp, sms_root, + mi_row, mi_col, bsize, pc_tree); + + if (rdcost[i] < min_rdcost) { + min_rdcost = rdcost[i]; + best_idx = i; + } + av1_free_pc_tree_recursive(pc_tree, av1_num_planes(cm), 0, 0); + ++i; + } while (i < num_configs); + + best_rd_cost->rdcost = min_rdcost; + + // Encode with the partition configuration with the smallest rdcost. + PC_TREE *const pc_tree = av1_alloc_pc_tree_node(bsize); + read_partition_tree(cpi, pc_tree, best_idx); + rd_search_for_fixed_partition(cpi, td, tile_data, tp, sms_root, mi_row, + mi_col, bsize, pc_tree); + set_cb_offsets(x->cb_offset, 0, 0); + encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, OUTPUT_ENABLED, bsize, + pc_tree, NULL); + + av1_free_pc_tree_recursive(pc_tree, av1_num_planes(cm), 0, 0); + aom_free(rdcost); + ++cpi->sb_counter; + + return true; +} + /*!\brief AV1 block partition search (full search). * * \ingroup partition_search @@ -3722,7 +4162,7 @@ // Rectangular partitions search stage. rectangular_partition_search(cpi, td, tile_data, tp, x, pc_tree, &x_ctx, &part_search_state, &best_rdc, - rect_part_win_info); + rect_part_win_info, HORZ, VERT); #if CONFIG_COLLECT_COMPONENT_TIMING end_timing(cpi, rectangular_partition_search_time); #endif @@ -3751,7 +4191,8 @@ // AB partitions search stage. 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); + pb_source_variance, ext_partition_allowed, HORZ_A, + VERT_B); #if CONFIG_COLLECT_COMPONENT_TIMING end_timing(cpi, ab_partitions_search_time); #endif @@ -3853,6 +4294,9 @@ const int emit_output = multi_pass_mode != SB_DRY_PASS; const RUN_TYPE run_type = emit_output ? OUTPUT_ENABLED : DRY_RUN_NORMAL; + // Write partition tree to file. Not used by default. + if (0) write_partition_tree(cpi, pc_tree, bsize, mi_row, mi_col); + set_cb_offsets(x->cb_offset, 0, 0); encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, run_type, bsize, pc_tree, NULL);
diff --git a/av1/encoder/partition_search.h b/av1/encoder/partition_search.h index 136548e..2d686dc 100644 --- a/av1/encoder/partition_search.h +++ b/av1/encoder/partition_search.h
@@ -39,6 +39,13 @@ RD_STATS *rd_cost, int do_recon, int64_t best_rd, PC_TREE *pc_tree); #endif +void av1_reset_part_sf(PARTITION_SPEED_FEATURES *part_sf); + +bool av1_rd_partition_search(AV1_COMP *const cpi, ThreadData *td, + TileDataEnc *tile_data, TokenExtra **tp, + SIMPLE_MOTION_DATA_TREE *sms_root, int mi_row, + int mi_col, BLOCK_SIZE bsize, + RD_STATS *best_rd_cost); bool av1_rd_pick_partition(AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data, TokenExtra **tp, int mi_row, int mi_col, BLOCK_SIZE bsize, RD_STATS *rd_cost,
diff --git a/av1/encoder/partition_strategy.c b/av1/encoder/partition_strategy.c index 87b6084..0f0da7e 100644 --- a/av1/encoder/partition_strategy.c +++ b/av1/encoder/partition_strategy.c
@@ -304,6 +304,17 @@ score < no_split_thresh) { *do_square_split = 0; } + + // If the score is very low, prune rectangular split since it is unlikely to + // occur. + if (cpi->sf.part_sf.simple_motion_search_rect_split) { + const float scale = res_idx >= 2 ? 3.0f : 2.0f; + const float rect_split_thresh = + scale * av1_simple_motion_search_no_split_thresh + [cpi->sf.part_sf.simple_motion_search_rect_split][res_idx] + [bsize_idx]; + if (score < rect_split_thresh) *do_rectangular_split = 0; + } } // Given a list of ref frames in refs, performs simple_motion_search on each of @@ -627,6 +638,7 @@ MACROBLOCKD *xd = &x->e_mbd; const BLOCK_SIZE sb_size = cm->seq_params.sb_size; + // Currently this only allows 128X128 SB size. May extend it to 64X64 SB size. assert(sb_size == BLOCK_128X128); int f_idx = 0; @@ -690,14 +702,18 @@ if (log_sse > max_log_sse) max_log_sse = log_sse; } aom_clear_system_state(); - const float avg_mv_row = sum_mv_row / 64.0f; - const float var_mv_row = sum_mv_row_sq / 64.0f - avg_mv_row * avg_mv_row; + const int blks = mb_rows * mb_cols; + const float avg_mv_row = sum_mv_row / (float)blks; + const float var_mv_row = + sum_mv_row_sq / (float)blks - avg_mv_row * avg_mv_row; - const float avg_mv_col = sum_mv_col / 64.0f; - const float var_mv_col = sum_mv_col_sq / 64.0f - avg_mv_col * avg_mv_col; + const float avg_mv_col = sum_mv_col / (float)blks; + const float var_mv_col = + sum_mv_col_sq / (float)blks - avg_mv_col * avg_mv_col; - const float avg_log_sse = sum_log_sse / 64.0f; - const float var_log_sse = sum_log_sse_sq / 64.0f - avg_log_sse * avg_log_sse; + const float avg_log_sse = sum_log_sse / (float)blks; + const float var_log_sse = + sum_log_sse_sq / (float)blks - avg_log_sse * avg_log_sse; features[f_idx++] = avg_log_sse; features[f_idx++] = avg_mv_col; @@ -716,11 +732,20 @@ assert(f_idx == FEATURE_SIZE_MAX_MIN_PART_PRED); } +// Convert result index to block size. +// result idx block size +// 0 BLOCK_16X16 +// 1 BLOCK_32X32 +// 2 BLOCK_64X64 +// 3 BLOCK_128X128 +static BLOCK_SIZE get_block_size(int idx) { + return (BLOCK_SIZE)((idx + 2) * 3); +} + BLOCK_SIZE av1_predict_max_partition(const AV1_COMP *const cpi, const MACROBLOCK *const x, const float *features) { - float scores[MAX_NUM_CLASSES_MAX_MIN_PART_PRED] = { 0.0f }, - probs[MAX_NUM_CLASSES_MAX_MIN_PART_PRED] = { 0.0f }; + float scores[MAX_NUM_CLASSES_MAX_MIN_PART_PRED] = { 0.0f }; const NN_CONFIG *nn_config = &av1_max_part_pred_nn_config; assert(cpi->sf.part_sf.auto_max_partition_based_on_simple_motion != @@ -728,21 +753,26 @@ aom_clear_system_state(); av1_nn_predict(features, nn_config, 1, scores); - av1_nn_softmax(scores, probs, MAX_NUM_CLASSES_MAX_MIN_PART_PRED); int result = MAX_NUM_CLASSES_MAX_MIN_PART_PRED - 1; if (cpi->sf.part_sf.auto_max_partition_based_on_simple_motion == DIRECT_PRED) { result = 0; - float max_prob = probs[0]; + float max_score = scores[0]; for (int i = 1; i < MAX_NUM_CLASSES_MAX_MIN_PART_PRED; ++i) { - if (probs[i] > max_prob) { - max_prob = probs[i]; + if (scores[i] > max_score) { + max_score = scores[i]; result = i; } } - } else if (cpi->sf.part_sf.auto_max_partition_based_on_simple_motion == - RELAXED_PRED) { + return get_block_size(result); + } + + float probs[MAX_NUM_CLASSES_MAX_MIN_PART_PRED] = { 0.0f }; + av1_nn_softmax(scores, probs, MAX_NUM_CLASSES_MAX_MIN_PART_PRED); + + if (cpi->sf.part_sf.auto_max_partition_based_on_simple_motion == + RELAXED_PRED) { for (result = MAX_NUM_CLASSES_MAX_MIN_PART_PRED - 1; result >= 0; --result) { if (result < MAX_NUM_CLASSES_MAX_MIN_PART_PRED - 1) { @@ -773,7 +803,7 @@ } } - return (BLOCK_SIZE)((result + 2) * 3); + return get_block_size(result); } // Get the minimum partition block width and height(in log scale) under a
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c index 5267f57..4fa6b53 100644 --- a/av1/encoder/pass2_strategy.c +++ b/av1/encoder/pass2_strategy.c
@@ -1222,12 +1222,14 @@ } // Estimate the noise variance of each frame from the first pass stats -static void estimate_region_noise(const FIRSTPASS_STATS *stats, - const int *is_flash, REGIONS *region) { +// TODO(bohanli): maybe handling of flashes should be done when using the stats, +// instead of generating them. +static void estimate_noise(const FIRSTPASS_STATS *stats, const int *is_flash, + int start, int last, double *noise_arr) { double C1, C2, C3, noise; int count = 0; - region->avg_noise_var = -1; - for (int i = region->start + 2; i <= region->last; i++) { + for (int i = AOMMAX(start, 2); i <= last; i++) { + noise_arr[i] = 0.0; if (is_flash[i] || is_flash[i - 1] || is_flash[i - 2]) continue; C1 = stats[i - 1].intra_error * @@ -1243,24 +1245,90 @@ noise = stats[i - 1].intra_error - C1 * C2 / C3; noise = AOMMAX(noise, 0.01); - region->avg_noise_var = (region->avg_noise_var == -1) - ? noise - : AOMMIN(noise, region->avg_noise_var); + noise_arr[i] = noise; count++; } - if (count == 0) { - region->avg_noise_var = 0; + + // Copy noise from the neighbor if the noise value is not trustworthy + for (int i = AOMMAX(start, 2); i <= last; i++) { + if (is_flash[i] || is_flash[i - 1] || is_flash[i - 2]) continue; + if (noise_arr[i] < 1) { + int found = 0; + for (int c = i + 1; c <= last; c++) { + if (is_flash[c] || is_flash[c - 1] || is_flash[c - 2] || + noise_arr[c] < 1) + continue; + found = 1; + noise_arr[i] = noise_arr[c]; + break; + } + if (found) continue; + for (int c = i - 1; c >= start + 2; c--) { + if (is_flash[c] || is_flash[c - 1] || is_flash[c - 2] || + noise_arr[c] < 1) + continue; + found = 1; + noise_arr[i] = noise_arr[c]; + break; + } + if (found) continue; + noise_arr[i] = 0; + } + } + + // copy the noise if this is a flash + for (int i = AOMMAX(start, 2); i <= last; i++) { + if (is_flash[i] || is_flash[i - 1] || is_flash[i - 2]) { + int found = 0; + for (int c = i + 1; c <= last; c++) { + if (is_flash[c] || is_flash[c - 1] || is_flash[c - 2]) continue; + found = 1; + noise_arr[i] = noise_arr[c]; + break; + } + if (found) continue; + for (int c = i - 1; c >= start + 2; c--) { + if (is_flash[c] || is_flash[c - 1] || is_flash[c - 2]) continue; + found = 1; + noise_arr[i] = noise_arr[c]; + break; + } + if (found) continue; + noise_arr[i] = 0; + } + } + + // if we are at the first 2 frames, copy the noise + for (int i = start; i < AOMMAX(start, 2); i++) { + noise_arr[i] = noise_arr[2]; } } -// Analyze the corrrelation coefficient of each frame with its previous frame in -// a region. Also get the average of stats inside a region. -// Before calling this function, the region's noise variance is needed. -static void analyze_region(const FIRSTPASS_STATS *stats, int region_idx, - REGIONS *regions, double *coeff) { - double cor_coeff; +// Estimate correlation coefficient of each frame with its previous frame. +static void estimate_coeff(const FIRSTPASS_STATS *stats, int start, int last, + double *noise, double *coeff) { + for (int i = start; i <= last; i++) { + const double C = + sqrt(AOMMAX(stats[i - 1].intra_error * + (stats[i].intra_error - stats[i].coded_error), + 0.001)); + const double cor_coeff = + C / AOMMAX(stats[i - 1].intra_error - noise[i], 0.001); - int i, k = region_idx; + coeff[i] = + cor_coeff * sqrt(AOMMAX(stats[i - 1].intra_error - noise[i], 0.001) / + AOMMAX(stats[i].intra_error - noise[i], 0.001)); + // clip correlation coefficient. + coeff[i] = AOMMIN(AOMMAX(coeff[i], 0), 1); + } +} + +// Get the average of stats inside a region. +// Before calling this function, the region's noise variance and correlation +// coefficients are needed. +static void analyze_region(const FIRSTPASS_STATS *stats, int k, + REGIONS *regions, double *coeff, double *noise) { + int i; regions[k].avg_cor_coeff = 0; regions[k].avg_sr_fr_ratio = 0; regions[k].avg_intra_err = 0; @@ -1269,12 +1337,6 @@ int check_first_sr = (k != 0); for (i = regions[k].start; i <= regions[k].last; i++) { - double C = sqrt(AOMMAX(stats[i - 1].intra_error * - (stats[i].intra_error - stats[i].coded_error), - 0.001)); - cor_coeff = - C / AOMMAX(stats[i - 1].intra_error - regions[k].avg_noise_var, 0.001); - if (i > regions[k].start || check_first_sr) { double num_frames = (double)(regions[k].last - regions[k].start + check_first_sr); @@ -1290,77 +1352,18 @@ regions[k].avg_coded_err += stats[i].coded_error / (double)(regions[k].last - regions[k].start + 1); - coeff[i] = - cor_coeff * - sqrt( - AOMMAX(stats[i - 1].intra_error - regions[k].avg_noise_var, 0.001) / - AOMMAX(stats[i].intra_error - regions[k].avg_noise_var, 0.001)); - // clip correlation coefficient. - coeff[i] = AOMMIN(AOMMAX(coeff[i], 0), 1); - regions[k].avg_cor_coeff += coeff[i] / (double)(regions[k].last - regions[k].start + 1); + regions[k].avg_noise_var += + noise[i] / (double)(regions[k].last - regions[k].start + 1); } } -// Calculate the regions stats of every region. Uses the stable regions to -// estimate noise variance of other regions. Then call analyze_region for each. -static void get_region_stats(const FIRSTPASS_STATS *stats, const int *is_flash, - REGIONS *regions, double *coeff, int num_regions) { - int k, count_stable = 0; - // Analyze stable regions. - for (k = 0; k < num_regions; k++) { - if (regions[k].type == STABLE_REGION) { - estimate_region_noise(stats, is_flash, regions + k); - analyze_region(stats, k, regions, coeff); - count_stable++; - } - } - - if (count_stable == 0) { - // no stable region, just use the lowest noise variance estimated. - double lowest_noise = -1; - for (k = 0; k < num_regions; k++) { - if (regions[k].type == SCENECUT_REGION) continue; - estimate_region_noise(stats, is_flash, regions + k); - if (regions[k].avg_noise_var < 0.01) continue; - if (lowest_noise < 0 || lowest_noise > regions[k].avg_noise_var) { - lowest_noise = regions[k].avg_noise_var; - } - } - lowest_noise = AOMMAX(lowest_noise, 0); - for (k = 0; k < num_regions; k++) { - regions[k].avg_noise_var = lowest_noise; - analyze_region(stats, k, regions, coeff); - } - return; - } - - // Analyze other regions - for (k = 0; k < num_regions; k++) { - if (regions[k].type != STABLE_REGION) { - // use the average of the nearest previous and next stable regions - int count = 0; - regions[k].avg_noise_var = 0; - for (int r = k - 1; r >= 0; r--) { - if (regions[r].type == STABLE_REGION) { - count++; - regions[k].avg_noise_var += regions[r].avg_noise_var; - break; - } - } - for (int r = k + 1; r < num_regions; r++) { - if (regions[r].type == STABLE_REGION) { - count++; - regions[k].avg_noise_var += regions[r].avg_noise_var; - break; - } - } - if (count) { - regions[k].avg_noise_var /= (double)count; - } - analyze_region(stats, k, regions, coeff); - } +// Calculate the regions stats of every region. +static void get_region_stats(const FIRSTPASS_STATS *stats, REGIONS *regions, + double *coeff, double *noise, int num_regions) { + for (int k = 0; k < num_regions; k++) { + analyze_region(stats, k, regions, coeff, noise); } } @@ -1452,15 +1455,14 @@ } static void adjust_unstable_region_bounds(const FIRSTPASS_STATS *stats, - const int *is_flash, - const double *grad, REGIONS *regions, - double *coeff, int *num_regions) { + REGIONS *regions, double *coeff, + double *noise, int *num_regions) { int i, j, k; // Remove regions that are too short. Likely noise. remove_short_regions(regions, num_regions, STABLE_REGION, HALF_WIN); remove_short_regions(regions, num_regions, HIGH_VAR_REGION, HALF_WIN); - get_region_stats(stats, is_flash, regions, coeff, *num_regions); + get_region_stats(stats, regions, coeff, noise, *num_regions); // Adjust region boundaries. The thresholds are empirically obtained, but // overall the performance is not very sensitive to small changes to them. @@ -1470,34 +1472,24 @@ // Adjust previous boundary. // First find the average intra/coded error in the previous // neighborhood. - double avg_intra_err = 0, avg_coded_err = 0, avg_coeff = 0; - int starti = AOMMAX(regions[k - 1].last - WINDOW_SIZE + 1, - regions[k - 1].start + 1); - int lasti = regions[k - 1].last; + double avg_intra_err = 0; + const int starti = AOMMAX(regions[k - 1].last - WINDOW_SIZE + 1, + regions[k - 1].start + 1); + const int lasti = regions[k - 1].last; int counti = 0; for (i = starti; i <= lasti; i++) { avg_intra_err += stats[i].intra_error; - avg_coded_err += stats[i].coded_error; - avg_coeff += coeff[i]; counti++; } if (counti > 0) { avg_intra_err = AOMMAX(avg_intra_err / (double)counti, 0.001); - avg_coded_err /= AOMMAX(avg_coded_err / (double)counti, 0.001); - avg_coeff /= AOMMIN(avg_intra_err / (double)counti, 0.99999); int count_coded = 0, count_grad = 0; for (j = lasti + 1; j <= regions[k].last; j++) { - int intra_close = + const int intra_close = fabs(stats[j].intra_error - avg_intra_err) / avg_intra_err < 0.1; - int coded_close = - fabs(stats[j].coded_error - avg_coded_err) / avg_coded_err < 0.15; - int grad_small = fabs(grad[j]) / avg_coded_err < 0.05; - int coded_small = stats[j].coded_error / avg_intra_err < 0.03; - int coeff_close = - (1 - coeff[j]) / (1 - avg_coeff) < 1.5 || coeff[j] > 0.995; - if (!coeff_close || (!coded_close && !coded_small)) count_coded--; - if (!grad_small && !coded_small) count_grad--; - + const int coded_small = stats[j].coded_error / avg_intra_err < 0.1; + const int coeff_close = coeff[j] > 0.995; + if (!coeff_close || !coded_small) count_coded--; if (intra_close && count_coded >= 0 && count_grad >= 0) { // this frame probably belongs to the previous stable region regions[k - 1].last = j; @@ -1511,35 +1503,26 @@ if (k < *num_regions - 1) { // Adjust next boundary. // First find the average intra/coded error in the next neighborhood. - double avg_intra_err = 0, avg_coded_err = 0, avg_coeff = 0; - int starti = regions[k + 1].start; - int lasti = AOMMIN(regions[k + 1].last - 1, - regions[k + 1].start + WINDOW_SIZE - 1); + double avg_intra_err = 0; + const int starti = regions[k + 1].start; + const int lasti = AOMMIN(regions[k + 1].last - 1, + regions[k + 1].start + WINDOW_SIZE - 1); int counti = 0; for (i = starti; i <= lasti; i++) { avg_intra_err += stats[i].intra_error; - avg_coded_err += stats[i + 1].coded_error; - avg_coeff += coeff[i]; counti++; } if (counti > 0) { avg_intra_err = AOMMAX(avg_intra_err / (double)counti, 0.001); - avg_coded_err /= AOMMAX(avg_coded_err / (double)counti, 0.001); - avg_coeff /= AOMMIN(avg_intra_err / (double)counti, 0.99999); // At the boundary, coded error is large, but still the frame is stable int count_coded = 1, count_grad = 1; for (j = starti - 1; j >= regions[k].start; j--) { - int intra_close = + const int intra_close = fabs(stats[j].intra_error - avg_intra_err) / avg_intra_err < 0.1; - int coded_close = - fabs(stats[j + 1].coded_error - avg_coded_err) / avg_coded_err < - 0.15; - int grad_small = fabs(grad[j + 1]) / avg_coded_err < 0.05; - int coded_small = stats[j + 1].coded_error / avg_intra_err < 0.03; - int coeff_close = - (1 - coeff[j + 1]) / (1 - avg_coeff) < 1.5 || coeff[j] > 0.995; - if (!coeff_close || (!coded_close && !coded_small)) count_coded--; - if (!grad_small && !coded_small) count_grad--; + const int coded_small = + stats[j + 1].coded_error / avg_intra_err < 0.1; + const int coeff_close = coeff[j] > 0.995; + if (!coeff_close || !coded_small) count_coded--; if (intra_close && count_coded >= 0 && count_grad >= 0) { // this frame probably belongs to the next stable region regions[k + 1].start = j; @@ -1554,7 +1537,7 @@ cleanup_regions(regions, num_regions); remove_short_regions(regions, num_regions, HIGH_VAR_REGION, HALF_WIN); - get_region_stats(stats, is_flash, regions, coeff, *num_regions); + get_region_stats(stats, regions, coeff, noise, *num_regions); // If a stable regions has higher error than neighboring high var regions, // or if the stable region has a lower average correlation, @@ -1562,25 +1545,31 @@ k = 0; while (k < *num_regions && (*num_regions) > 1) { if (regions[k].type == STABLE_REGION && + (regions[k].last - regions[k].start + 1) < 2 * WINDOW_SIZE && ((k > 0 && // previous regions - (regions[k].avg_coded_err > regions[k - 1].avg_coded_err || - regions[k].avg_cor_coeff < regions[k - 1].avg_cor_coeff)) && + (regions[k].avg_coded_err > regions[k - 1].avg_coded_err * 1.01 || + regions[k].avg_cor_coeff < regions[k - 1].avg_cor_coeff * 0.999)) && (k < *num_regions - 1 && // next region - (regions[k].avg_coded_err > regions[k + 1].avg_coded_err || - regions[k].avg_cor_coeff < regions[k + 1].avg_cor_coeff)))) { + (regions[k].avg_coded_err > regions[k + 1].avg_coded_err * 1.01 || + regions[k].avg_cor_coeff < regions[k + 1].avg_cor_coeff * 0.999)))) { // merge current region with the previous and next regions remove_region(2, regions, num_regions, &k); - analyze_region(stats, k - 1, regions, coeff); + analyze_region(stats, k - 1, regions, coeff, noise); } else if (regions[k].type == HIGH_VAR_REGION && + (regions[k].last - regions[k].start + 1) < 2 * WINDOW_SIZE && ((k > 0 && // previous regions - (regions[k].avg_coded_err < regions[k - 1].avg_coded_err || - regions[k].avg_cor_coeff > regions[k - 1].avg_cor_coeff)) && + (regions[k].avg_coded_err < + regions[k - 1].avg_coded_err * 0.99 || + regions[k].avg_cor_coeff > + regions[k - 1].avg_cor_coeff * 1.001)) && (k < *num_regions - 1 && // next region - (regions[k].avg_coded_err < regions[k + 1].avg_coded_err || - regions[k].avg_cor_coeff > regions[k + 1].avg_cor_coeff)))) { + (regions[k].avg_coded_err < + regions[k + 1].avg_coded_err * 0.99 || + regions[k].avg_cor_coeff > + regions[k + 1].avg_cor_coeff * 1.001)))) { // merge current region with the previous and next regions remove_region(2, regions, num_regions, &k); - analyze_region(stats, k - 1, regions, coeff); + analyze_region(stats, k - 1, regions, coeff, noise); } else { k++; } @@ -1593,7 +1582,8 @@ // Identify blending regions. static void find_blending_regions(const FIRSTPASS_STATS *stats, const int *is_flash, REGIONS *regions, - int *num_regions, double *coeff) { + int *num_regions, double *coeff, + double *noise) { int i, k = 0; // Blending regions will have large content change, therefore will have a // large consistent change in intra error. @@ -1634,14 +1624,14 @@ // If the blending region has very low correlation, mark it as high variance // since we probably cannot benefit from it anyways. - get_region_stats(stats, is_flash, regions, coeff, *num_regions); + get_region_stats(stats, regions, coeff, noise, *num_regions); for (k = 0; k < *num_regions; k++) { if (regions[k].type != BLENDING_REGION) continue; if (regions[k].last == regions[k].start || regions[k].avg_cor_coeff < 0.6 || count_stable == 0) regions[k].type = HIGH_VAR_REGION; } - get_region_stats(stats, is_flash, regions, coeff, *num_regions); + get_region_stats(stats, regions, coeff, noise, *num_regions); // It is possible for blending to result in a "dip" in intra error (first // decrease then increase). Therefore we need to find the dip and combine the @@ -1670,7 +1660,7 @@ if (regions[k].avg_sr_fr_ratio > ratio_thres) { regions[k].type = BLENDING_REGION; remove_region(2, regions, num_regions, &k); - analyze_region(stats, k - 1, regions, coeff); + analyze_region(stats, k - 1, regions, coeff, noise); continue; } } @@ -1728,7 +1718,7 @@ if (to_merge) { remove_region(0, regions, num_regions, &k); - analyze_region(stats, k - 1, regions, coeff); + analyze_region(stats, k - 1, regions, coeff, noise); continue; } else { // These are possibly two separate blending regions. Mark the boundary @@ -1736,9 +1726,9 @@ int prev_k = k - 1; insert_region(regions[prev_k].last, regions[prev_k].last, HIGH_VAR_REGION, regions, num_regions, &prev_k); - analyze_region(stats, prev_k, regions, coeff); + analyze_region(stats, prev_k, regions, coeff, noise); k = prev_k + 1; - analyze_region(stats, k, regions, coeff); + analyze_region(stats, k, regions, coeff, noise); } } k++; @@ -1794,11 +1784,13 @@ // pointing to. static void identify_regions(const FIRSTPASS_STATS *const stats_start, int total_frames, int offset, REGIONS *regions, - int *total_regions, double *cor_coeff) { + int *total_regions, double *cor_coeff, + double *noise_var) { int k; if (total_frames <= 1) return; double *coeff = cor_coeff + offset; + double *noise = noise_var + offset; // store the initial decisions REGIONS temp_regions[MAX_FIRSTPASS_ANALYSIS_FRAMES]; @@ -1809,7 +1801,7 @@ double filt_coded_err[MAX_FIRSTPASS_ANALYSIS_FRAMES] = { 0 }; double grad_coded[MAX_FIRSTPASS_ANALYSIS_FRAMES] = { 0 }; - int cur_region = 0, this_start = 0, this_last; + int cur_region = 0, this_start = 0, this_last = total_frames - 1; // find possible flash frames mark_flashes(stats_start, 0, total_frames - 1, is_flash); @@ -1817,10 +1809,14 @@ // first get the obvious scenecuts int next_scenecut = -1; + estimate_noise(stats_start, is_flash, this_start, this_last, noise); + estimate_coeff(stats_start, this_start, this_last, noise, coeff); + do { next_scenecut = find_next_scenecut(stats_start, this_start, total_frames - 1, is_flash); this_last = (next_scenecut >= 0) ? (next_scenecut - 1) : total_frames - 1; + // low-pass filter the needed stats smooth_filter_stats(stats_start, is_flash, this_start, this_last, filt_intra_err, filt_coded_err); @@ -1829,14 +1825,15 @@ // find tentative stable regions and unstable regions int num_regions = find_stable_regions(stats_start, grad_coded, is_flash, this_start, this_last, temp_regions); - adjust_unstable_region_bounds(stats_start, is_flash, grad_coded, - temp_regions, coeff, &num_regions); - get_region_stats(stats_start, is_flash, temp_regions, coeff, num_regions); + adjust_unstable_region_bounds(stats_start, temp_regions, coeff, noise, + &num_regions); + + get_region_stats(stats_start, temp_regions, coeff, noise, num_regions); // Try to identify blending regions in the unstable regions find_blending_regions(stats_start, is_flash, temp_regions, &num_regions, - coeff); + coeff, noise); cleanup_blendings(temp_regions, &num_regions); // The flash points should all be considered high variance points @@ -1859,6 +1856,11 @@ // copy the regions in the scenecut group for (k = 0; k < num_regions; k++) { + if (temp_regions[k].last < temp_regions[k].start && + k == num_regions - 1) { + num_regions--; + break; + } regions[k + cur_region] = temp_regions[k]; } cur_region += num_regions; @@ -1875,17 +1877,20 @@ } while (next_scenecut >= 0); *total_regions = cur_region; - get_region_stats(stats_start, is_flash, regions, coeff, *total_regions); + get_region_stats(stats_start, regions, coeff, noise, *total_regions); for (k = 0; k < *total_regions; k++) { // If scenecuts are very minor, mark them as high variance. - if (regions[k].type != SCENECUT_REGION || regions[k].avg_cor_coeff < 0.8) { + if (regions[k].type != SCENECUT_REGION || + regions[k].avg_cor_coeff * + (1 - noise[regions[k].start] / regions[k].avg_intra_err) < + 0.8) { continue; } regions[k].type = HIGH_VAR_REGION; } cleanup_regions(regions, total_regions); - get_region_stats(stats_start, is_flash, regions, coeff, *total_regions); + get_region_stats(stats_start, regions, coeff, noise, *total_regions); for (k = 0; k < *total_regions; k++) { regions[k].start += offset; @@ -2022,7 +2027,11 @@ // If we have a scenecut, then stop at it. // TODO(bohanli): add logic here to stop before the scenecut and for // the next gop start from the scenecut with GF - int is_minor_sc = (regions[scenecut_idx].avg_cor_coeff > 0.6); + int is_minor_sc = + (regions[scenecut_idx].avg_cor_coeff * + (1 - rc->noise_var[regions[scenecut_idx].start] / + regions[scenecut_idx].avg_intra_err) > + 0.6); cur_last = regions[scenecut_idx].last - offset - !is_minor_sc; } else { int is_last_analysed = (k_last == num_regions - 1) && @@ -2033,45 +2042,85 @@ // if we are very close to the end, then do not shrink since it may // introduce intervals that are too short if (!(is_last_analysed && not_enough_regions)) { - int found = 0; - // first try to end at a stable area - for (int j = cur_last; j >= cur_start + min_shrink_int; j--) { - if (regions[find_regions_index(regions, num_regions, j + offset)] - .type == STABLE_REGION) { - cur_last = j; - found = 1; - break; + const double arf_length_factor = 0.1; + double best_score = 0; + int best_j = -1; + const int first_frame = regions[0].start - offset; + const int last_frame = regions[num_regions - 1].last - offset; + // score of how much the arf helps the whole GOP + double base_score = 0.0; + // Accumulate base_score in + for (int j = cur_start + 1; j < cur_start + min_shrink_int; j++) { + base_score = (base_score + 1.0) * rc->cor_coeff[j + offset]; + } + int met_blending = 0; // Whether we have met blending areas before + int last_blending = 0; // Whether the previous frame if blending + for (int j = cur_start + min_shrink_int; j <= cur_last; j++) { + base_score = (base_score + 1.0) * rc->cor_coeff[j + offset]; + int this_reg = + find_regions_index(regions, num_regions, j + offset); + // A GOP should include at most 1 blending region. + if (regions[this_reg].type == BLENDING_REGION) { + last_blending = 1; + if (met_blending) { + break; + } else { + base_score = 0; + continue; + } + } else { + if (last_blending) met_blending = 1; + last_blending = 0; + } + + // Add the factor of how good the neighborhood is for this + // candidate arf. + double this_score = arf_length_factor * base_score; + double temp_accu_coeff = 1.0; + // following frames + int count_f = 0; + for (int n = j + 1; n <= j + 3 && n <= last_frame; n++) { + temp_accu_coeff *= rc->cor_coeff[n + offset]; + this_score += + temp_accu_coeff * (1 - rc->noise_var[n + offset] / + regions[this_reg].avg_intra_err); + count_f++; + } + // preceding frames + temp_accu_coeff = 1.0; + for (int n = j; n > j - 3 * 2 + count_f && n >= first_frame; + n--) { + temp_accu_coeff *= rc->cor_coeff[n + offset]; + this_score += + temp_accu_coeff * (1 - rc->noise_var[n + offset] / + regions[this_reg].avg_intra_err); + } + + if (this_score > best_score) { + best_score = this_score; + best_j = j; } } - if (!found) { - // Could not find stable point, - // try to find an OK point (high correlation, not blending) - for (int j = cur_last; j >= cur_start + min_shrink_int; j--) { - REGIONS *cur_region = - regions + - find_regions_index(regions, num_regions, j + offset); - double avg_coeff = cur_region->avg_cor_coeff; - if (rc->cor_coeff[j + offset] > avg_coeff && - cur_region->type != BLENDING_REGION) { - cur_last = j; - found = 1; - break; + + // For blending areas, move one more frame in case we missed the + // first blending frame. + int best_reg = + find_regions_index(regions, num_regions, best_j + offset); + if (best_reg < num_regions - 1 && best_reg > 0) { + if (regions[best_reg - 1].type == BLENDING_REGION && + regions[best_reg + 1].type == BLENDING_REGION) { + if (best_j + offset == regions[best_reg].start && + best_j + offset < regions[best_reg].last) { + best_j += 1; + } else if (best_j + offset == regions[best_reg].last && + best_j + offset > regions[best_reg].start) { + best_j -= 1; } } } - if (!found) { - // Could not find a better point, - // try not to cut in blending areas - for (int j = cur_last; j >= cur_start + min_shrink_int; j--) { - REGIONS *cur_region = - regions + - find_regions_index(regions, num_regions, j + offset); - if (cur_region->type != BLENDING_REGION) { - cur_last = j; - break; - } - } - } + + if (cur_last - best_j < 2) best_j = cur_last; + if (best_j > 0 && best_score > 0.1) cur_last = best_j; // if cannot find anything, just cut at the original place. } } @@ -2108,9 +2157,9 @@ static void correct_frames_to_key(AV1_COMP *cpi) { int lookahead_size = - (int)av1_lookahead_depth(cpi->lookahead, cpi->compressor_stage); + (int)av1_lookahead_depth(cpi->ppi->lookahead, cpi->compressor_stage); if (lookahead_size < - av1_lookahead_pop_sz(cpi->lookahead, cpi->compressor_stage)) { + av1_lookahead_pop_sz(cpi->ppi->lookahead, cpi->compressor_stage)) { assert(IMPLIES(cpi->oxcf.pass != 0 && cpi->frames_left > 0, lookahead_size == cpi->frames_left)); cpi->rc.frames_to_key = AOMMIN(cpi->rc.frames_to_key, lookahead_size); @@ -2290,7 +2339,7 @@ int64_t gf_group_bits; const int is_intra_only = rc->frames_since_key == 0; - cpi->internal_altref_allowed = (gf_cfg->gf_max_pyr_height > 1); + cpi->ppi->internal_altref_allowed = (gf_cfg->gf_max_pyr_height > 1); // Reset the GF group data structures unless this is a key // frame in which case it will already have been done. @@ -2408,7 +2457,7 @@ gf_stats.zero_motion_accumulator > MIN_ZERO_MOTION && gf_stats.avg_sr_coded_error / num_mbs < MAX_SR_CODED_ERROR && gf_stats.avg_raw_err_stdev < MAX_RAW_ERR_VAR) { - cpi->internal_altref_allowed = 0; + cpi->ppi->internal_altref_allowed = 0; } int use_alt_ref; @@ -2444,7 +2493,7 @@ // work well for certain other cases. const int allow_gf_length_reduction = ((rc_cfg->mode == AOM_Q && rc_cfg->cq_level <= 128) || - !cpi->internal_altref_allowed) && + !cpi->ppi->internal_altref_allowed) && !is_lossless_requested(rc_cfg); if (allow_gf_length_reduction && use_alt_ref) { @@ -2789,7 +2838,7 @@ static int detect_app_forced_key(AV1_COMP *cpi) { if (cpi->oxcf.kf_cfg.fwd_kf_enabled) cpi->rc.next_is_fwd_key = 1; int num_frames_to_app_forced_key = is_forced_keyframe_pending( - cpi->lookahead, cpi->lookahead->max_sz, cpi->compressor_stage); + cpi->ppi->lookahead, cpi->ppi->lookahead->max_sz, cpi->compressor_stage); if (num_frames_to_app_forced_key != -1) cpi->rc.next_is_fwd_key = 0; return num_frames_to_app_forced_key; } @@ -3602,7 +3651,7 @@ rc->frames_till_regions_update = rest_frames; identify_regions(stats_start, rest_frames - offset, offset, rc->regions, - &rc->num_regions, rc->cor_coeff); + &rc->num_regions, rc->cor_coeff, rc->noise_var); } int cur_region_idx =
diff --git a/av1/encoder/ratectrl.h b/av1/encoder/ratectrl.h index 3f1756f..9c96c8d 100644 --- a/av1/encoder/ratectrl.h +++ b/av1/encoder/ratectrl.h
@@ -207,6 +207,7 @@ int num_regions; REGIONS regions[MAX_FIRSTPASS_ANALYSIS_FRAMES]; double cor_coeff[MAX_FIRSTPASS_ANALYSIS_FRAMES]; + double noise_var[MAX_FIRSTPASS_ANALYSIS_FRAMES]; int regions_offset; // offset of regions from the last keyframe int frames_till_regions_update;
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c index c47bb70..aedb10e 100644 --- a/av1/encoder/rd.c +++ b/av1/encoder/rd.c
@@ -559,7 +559,7 @@ } } -void av1_fill_mv_costs(const FRAME_CONTEXT *fc, int integer_mv, int usehp, +void av1_fill_mv_costs(const nmv_context *nmvc, int integer_mv, int usehp, MvCosts *mv_costs) { mv_costs->nmv_cost[0] = &mv_costs->nmv_cost_alloc[0][MV_MAX]; mv_costs->nmv_cost[1] = &mv_costs->nmv_cost_alloc[1][MV_MAX]; @@ -568,15 +568,22 @@ if (integer_mv) { mv_costs->mv_cost_stack = (int **)&mv_costs->nmv_cost; av1_build_nmv_cost_table(mv_costs->nmv_joint_cost, mv_costs->mv_cost_stack, - &fc->nmvc, MV_SUBPEL_NONE); + nmvc, MV_SUBPEL_NONE); } else { mv_costs->mv_cost_stack = usehp ? mv_costs->nmv_cost_hp : mv_costs->nmv_cost; av1_build_nmv_cost_table(mv_costs->nmv_joint_cost, mv_costs->mv_cost_stack, - &fc->nmvc, usehp); + nmvc, usehp); } } +void av1_fill_dv_costs(const nmv_context *ndvc, IntraBCMVCosts *dv_costs) { + dv_costs->dv_costs[0] = &dv_costs->dv_costs_alloc[0][MV_MAX]; + dv_costs->dv_costs[1] = &dv_costs->dv_costs_alloc[1][MV_MAX]; + av1_build_nmv_cost_table(dv_costs->joint_mv, dv_costs->dv_costs, ndvc, + MV_SUBPEL_NONE); +} + void av1_initialize_rd_consts(AV1_COMP *cpi) { AV1_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->td.mb; @@ -599,7 +606,7 @@ if ((!use_nonrd_pick_mode && cost_upd_freq.mv != COST_UPD_OFF) || cost_upd_freq.mv == COST_UPD_TILE || fill_costs) - av1_fill_mv_costs(cm->fc, cm->features.cur_frame_force_integer_mv, + av1_fill_mv_costs(&cm->fc->nmvc, cm->features.cur_frame_force_integer_mv, cm->features.allow_high_precision_mv, mv_costs); if ((!use_nonrd_pick_mode && cost_upd_freq.coeff != COST_UPD_OFF) || @@ -610,14 +617,9 @@ cost_upd_freq.mode == COST_UPD_TILE || fill_costs) av1_fill_mode_rates(cm, &x->mode_costs, cm->fc); - if (!use_nonrd_pick_mode && frame_is_intra_only(cm) && - cm->features.allow_screen_content_tools && + if (!use_nonrd_pick_mode && av1_allow_intrabc(cm) && !is_stat_generation_stage(cpi)) { - IntraBCMVCosts *const dv_costs = &cpi->dv_costs; - int *dvcost[2] = { &dv_costs->mv_component[0][MV_MAX], - &dv_costs->mv_component[1][MV_MAX] }; - av1_build_nmv_cost_table(dv_costs->joint_mv, dvcost, &cm->fc->ndvc, - MV_SUBPEL_NONE); + av1_fill_dv_costs(&cm->fc->ndvc, x->dv_costs); } }
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h index 409e8ea..8af31b2 100644 --- a/av1/encoder/rd.h +++ b/av1/encoder/rd.h
@@ -81,20 +81,6 @@ double r0; } RD_OPT; -typedef struct { - // Cost of transmitting the actual motion vector. - // mv_component[0][i] is the cost of motion vector with horizontal component - // (mv_row) equal to i - MV_MAX. - // mv_component[1][i] is the cost of motion vector with vertical component - // (mv_col) equal to i - MV_MAX. - int mv_component[2][MV_VALS]; - - // joint_mv[i] is the cost of transmitting joint mv(MV_JOINT_TYPE) of - // type i. - // TODO(huisu@google.com): we can update dv_joint_cost per SB. - int joint_mv[MV_JOINTS]; -} IntraBCMVCosts; - static INLINE void av1_init_rd_stats(RD_STATS *rd_stats) { #if CONFIG_RD_DEBUG int plane; @@ -372,9 +358,11 @@ void av1_fill_coeff_costs(CoeffCosts *coeff_costs, FRAME_CONTEXT *fc, const int num_planes); -void av1_fill_mv_costs(const FRAME_CONTEXT *fc, int integer_mv, int usehp, +void av1_fill_mv_costs(const nmv_context *nmvc, int integer_mv, int usehp, MvCosts *mv_costs); +void av1_fill_dv_costs(const nmv_context *ndvc, IntraBCMVCosts *dv_costs); + int av1_get_adaptive_rdmult(const struct AV1_COMP *cpi, double beta); int av1_get_deltaq_offset(const struct AV1_COMP *cpi, int qindex, double beta);
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c index fc1e9ce..8cea21b 100644 --- a/av1/encoder/rdopt.c +++ b/av1/encoder/rdopt.c
@@ -485,7 +485,14 @@ static int compare_rd_idx_pair(const void *a, const void *b) { if (((RdIdxPair *)a)->rd == ((RdIdxPair *)b)->rd) { - return 0; + // To avoid inconsistency in qsort() ordering when two elements are equal, + // using idx as tie breaker. Refer aomedia:2928 + if (((RdIdxPair *)a)->idx == ((RdIdxPair *)b)->idx) + return 0; + else if (((RdIdxPair *)a)->idx > ((RdIdxPair *)b)->idx) + return 1; + else + return -1; } else if (((const RdIdxPair *)a)->rd > ((const RdIdxPair *)b)->rd) { return 1; } else { @@ -2925,7 +2932,7 @@ const int sb_col = mi_col >> cm->seq_params.mib_size_log2; MB_MODE_INFO_EXT *const mbmi_ext = &x->mbmi_ext; - MV_REFERENCE_FRAME ref_frame = INTRA_FRAME; + const MV_REFERENCE_FRAME ref_frame = INTRA_FRAME; av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count, xd->ref_mv_stack, xd->weight, NULL, mbmi_ext->global_mvs, mbmi_ext->mode_context); @@ -2976,7 +2983,8 @@ av1_make_default_fullpel_ms_params(&fullms_params, cpi, x, bsize, &dv_ref.as_mv, lookahead_search_sites, /*fine_search_interval=*/0); - fullms_params.is_intra_mode = 1; + const IntraBCMVCosts *const dv_costs = x->dv_costs; + av1_set_ms_to_intra_mode(&fullms_params, dv_costs); for (enum IntrabcMotionDirection dir = IBC_MOTION_ABOVE; dir < IBC_MOTION_DIRECTIONS; ++dir) { @@ -3057,13 +3065,10 @@ av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0, av1_num_planes(cm) - 1); - const IntraBCMVCosts *const dv_costs = &cpi->dv_costs; - int *dvcost[2] = { (int *)&dv_costs->mv_component[0][MV_MAX], - (int *)&dv_costs->mv_component[1][MV_MAX] }; // TODO(aconverse@google.com): The full motion field defining discount // in MV_COST_WEIGHT is too large. Explore other values. const int rate_mv = av1_mv_bit_cost(&dv, &dv_ref.as_mv, dv_costs->joint_mv, - dvcost, MV_COST_WEIGHT_SUB); + dv_costs->dv_costs, MV_COST_WEIGHT_SUB); const int rate_mode = x->mode_costs.intrabc_cost[1]; RD_STATS rd_stats_yuv, rd_stats_y, rd_stats_uv; if (!av1_txfm_search(cpi, x, bsize, &rd_stats_yuv, &rd_stats_y, @@ -3179,7 +3184,6 @@ const int num_planes = av1_num_planes(cm); MACROBLOCKD *const xd = &x->e_mbd; MB_MODE_INFO *const mbmi = xd->mi[0]; - const TxfmSearchParams *txfm_params = &x->txfm_search_params; x->compound_idx = 1; // COMPOUND_AVERAGE RD_STATS skip_mode_rd_stats; @@ -3240,6 +3244,8 @@ mbmi->motion_mode = SIMPLE_TRANSLATION; mbmi->ref_mv_idx = 0; mbmi->skip_mode = mbmi->skip_txfm = 1; + mbmi->palette_mode_info.palette_size[0] = 0; + mbmi->palette_mode_info.palette_size[1] = 0; set_default_interp_filters(mbmi, cm->features.interp_filter); @@ -3276,45 +3282,12 @@ assert(mode_index != THR_INVALID); search_state->best_mbmode.skip_mode = 1; search_state->best_mbmode = *mbmi; - - search_state->best_mbmode.skip_mode = search_state->best_mbmode.skip_txfm = - 1; - search_state->best_mbmode.mode = NEAREST_NEARESTMV; - 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; - search_state->best_mbmode.ref_mv_idx = 0; - - // Set up tx_size related variables for skip-specific loop filtering. - search_state->best_mbmode.tx_size = - block_signals_txsize(bsize) - ? tx_size_from_tx_mode(bsize, txfm_params->tx_mode_search_type) - : max_txsize_rect_lookup[bsize]; memset(search_state->best_mbmode.inter_tx_size, search_state->best_mbmode.tx_size, sizeof(search_state->best_mbmode.inter_tx_size)); set_txfm_ctxs(search_state->best_mbmode.tx_size, xd->width, xd->height, search_state->best_mbmode.skip_txfm && is_inter_block(mbmi), xd); - - // Set up color-related variables for skip mode. - search_state->best_mbmode.uv_mode = UV_DC_PRED; - search_state->best_mbmode.palette_mode_info.palette_size[0] = 0; - search_state->best_mbmode.palette_mode_info.palette_size[1] = 0; - - search_state->best_mbmode.comp_group_idx = 0; - search_state->best_mbmode.compound_idx = x->compound_idx; - search_state->best_mbmode.interinter_comp.type = COMPOUND_AVERAGE; - search_state->best_mbmode.motion_mode = SIMPLE_TRANSLATION; - - search_state->best_mbmode.interintra_mode = - (INTERINTRA_MODE)(II_DC_PRED - 1); - search_state->best_mbmode.filter_intra_mode_info.use_filter_intra = 0; - - set_default_interp_filters(&search_state->best_mbmode, - cm->features.interp_filter); - search_state->best_mode_index = mode_index; // Update rd_cost @@ -3791,7 +3764,7 @@ // compound ref. if (skip_ref_frame_mask & (1 << ref_frame) && !is_ref_frame_used_by_compound_ref(ref_frame, skip_ref_frame_mask) && - !is_ref_frame_used_in_cache(ref_frame, x->intermode_cache)) { + !is_ref_frame_used_in_cache(ref_frame, x->mb_mode_cache)) { continue; } assert(get_ref_frame_yv12_buf(cm, ref_frame) != NULL); @@ -3817,7 +3790,7 @@ } if (skip_ref_frame_mask & (1 << ref_frame) && - !is_ref_frame_used_in_cache(ref_frame, x->intermode_cache)) { + !is_ref_frame_used_in_cache(ref_frame, x->mb_mode_cache)) { continue; } // Ref mv list population is not required, when compound references are @@ -4053,8 +4026,8 @@ } // Reuse the prediction mode in cache - if (x->use_intermode_cache) { - const MB_MODE_INFO *cached_mi = x->intermode_cache; + if (x->use_mb_mode_cache) { + const MB_MODE_INFO *cached_mi = x->mb_mode_cache; const PREDICTION_MODE cached_mode = cached_mi->mode; const MV_REFERENCE_FRAME *cached_frame = cached_mi->ref_frame; const int cached_mode_is_single = cached_frame[1] <= INTRA_FRAME; @@ -4149,12 +4122,12 @@ } // If we are reusing the prediction from cache, and the current frame is // required by the cache, then we cannot prune it. - if (is_ref_frame_used_in_cache(ref_type, x->intermode_cache)) { + if (is_ref_frame_used_in_cache(ref_type, x->mb_mode_cache)) { skip_ref = 0; // If the cache only needs the current reference type for compound // prediction, then we can skip motion mode search. skip_motion_mode = (ref_type <= ALTREF_FRAME && - x->intermode_cache->ref_frame[1] > INTRA_FRAME); + x->mb_mode_cache->ref_frame[1] > INTRA_FRAME); } if (skip_ref) return 1; } @@ -5326,10 +5299,11 @@ get_block_level_tpl_stats(cpi, bsize, mi_row, mi_col, valid_refs, &inter_cost_info_from_tpl); } -#endif + const int do_pruning = (AOMMIN(cm->width, cm->height) > 480 && cpi->speed <= 1) ? 0 : 1; - if (do_pruning && sf->intra_sf.skip_intra_in_interframe) { + if (do_pruning && sf->intra_sf.skip_intra_in_interframe && + cpi->oxcf.algo_cfg.enable_tpl_model) { // Only consider full SB. const BLOCK_SIZE sb_size = cm->seq_params.sb_size; const int tpl_bsize_1d = cpi->tpl_data.tpl_bsize_1d; @@ -5359,9 +5333,10 @@ } } } +#endif // !CONFIG_REALTIME_ONLY // Initialize best mode stats for winner mode processing - av1_zero(x->winner_mode_stats); + av1_zero_array(x->winner_mode_stats, MAX_WINNER_MODE_COUNT_INTER); x->winner_mode_count = 0; store_winner_mode_stats(&cpi->common, x, mbmi, NULL, NULL, NULL, THR_INVALID, NULL, bsize, best_rd_so_far,
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h index df080b0..362da7b 100644 --- a/av1/encoder/rdopt.h +++ b/av1/encoder/rdopt.h
@@ -272,8 +272,16 @@ int ref_frame_list[2] = { LAST3_FRAME, LAST2_FRAME }; if (x != NULL) { - if (x->tpl_keep_ref_frame[LAST3_FRAME]) ref_frame_list[0] = NONE_FRAME; - if (x->tpl_keep_ref_frame[LAST2_FRAME]) ref_frame_list[1] = NONE_FRAME; + // Disable pruning if either tpl suggests that we keep the frame or + // the pred_mv gives us the best sad + if (x->tpl_keep_ref_frame[LAST3_FRAME] || + x->pred_mv_sad[LAST3_FRAME] == x->best_pred_mv_sad) { + ref_frame_list[0] = NONE_FRAME; + } + if (x->tpl_keep_ref_frame[LAST2_FRAME] || + x->pred_mv_sad[LAST2_FRAME] == x->best_pred_mv_sad) { + ref_frame_list[1] = NONE_FRAME; + } } if (prune_ref(ref_frame, ref_display_order_hint, @@ -286,8 +294,16 @@ int ref_frame_list[2] = { ALTREF2_FRAME, BWDREF_FRAME }; if (x != NULL) { - if (x->tpl_keep_ref_frame[ALTREF2_FRAME]) ref_frame_list[0] = NONE_FRAME; - if (x->tpl_keep_ref_frame[BWDREF_FRAME]) ref_frame_list[1] = NONE_FRAME; + // Disable pruning if either tpl suggests that we keep the frame or + // the pred_mv gives us the best sad + if (x->tpl_keep_ref_frame[ALTREF2_FRAME] || + x->pred_mv_sad[ALTREF2_FRAME] == x->best_pred_mv_sad) { + ref_frame_list[0] = NONE_FRAME; + } + if (x->tpl_keep_ref_frame[BWDREF_FRAME] || + x->pred_mv_sad[BWDREF_FRAME] == x->best_pred_mv_sad) { + ref_frame_list[1] = NONE_FRAME; + } } if (prune_ref(ref_frame, ref_display_order_hint,
diff --git a/av1/encoder/rdopt_utils.h b/av1/encoder/rdopt_utils.h index a130ffe..ddd180f 100644 --- a/av1/encoder/rdopt_utils.h +++ b/av1/encoder/rdopt_utils.h
@@ -334,14 +334,14 @@ // Derive aggressiveness factor for gating the transform search // Lower value indicates more aggressiveness. Be more conservative (high // value) for (i) low quantizers (ii) regions where prediction is poor - const int scale[6] = { INT_MAX, 4, 3, 3, 2, 2 }; + const int scale[5] = { INT_MAX, 4, 3, 2, 2 }; const int qslope = 2 * (!is_luma_only); - const int level_to_qindex_map[6] = { 0, 0, 0, 0, 80, 100 }; - int aggr_factor = 1; + const int level_to_qindex_map[5] = { 0, 0, 0, 80, 100 }; + int aggr_factor = 4; const int pred_qindex_thresh = level_to_qindex_map[level]; - if (!is_luma_only && level <= 3) { - aggr_factor = AOMMAX( - 1, ((MAXQ - x->qindex) * qslope + QINDEX_RANGE / 2) >> QINDEX_BITS); + if (!is_luma_only && level <= 2) { + aggr_factor = 4 * AOMMAX(1, ROUND_POWER_OF_TWO((MAXQ - x->qindex) * qslope, + QINDEX_BITS)); } if ((best_skip_rd > (x->source_variance << (num_pels_log2_lookup[bsize] + RDDIV_BITS))) && @@ -350,18 +350,18 @@ // For level setting 1, be more conservative for non-luma-only case even when // prediction is good. else if ((level <= 1) && !is_luma_only) - aggr_factor *= 2; + aggr_factor = (aggr_factor >> 2) * 6; // Be more conservative for luma only cases (called from compound type rd) // since best_skip_rd is computed after and skip_rd is computed (with 8-bit // prediction signals blended for WEDGE/DIFFWTD rather than 16-bit) before // interpolation filter search - const int luma_mul[6] = { INT_MAX, 32, 29, 20, 17, 17 }; + const int luma_mul[5] = { INT_MAX, 32, 29, 17, 17 }; int mul_factor = is_luma_only ? luma_mul[level] : 16; int64_t rd_thresh = (best_skip_rd == INT64_MAX) ? best_skip_rd - : (int64_t)(best_skip_rd * aggr_factor * mul_factor >> 4); + : (int64_t)(best_skip_rd * aggr_factor * mul_factor >> 6); if (skip_rd > rd_thresh) eval_txfm = 0; return eval_txfm; }
diff --git a/av1/encoder/sparse_linear_solver.c b/av1/encoder/sparse_linear_solver.c new file mode 100644 index 0000000..1c556c2 --- /dev/null +++ b/av1/encoder/sparse_linear_solver.c
@@ -0,0 +1,411 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. + */ +#include <float.h> +#include "av1/common/av1_common_int.h" +#include "av1/encoder/sparse_linear_solver.h" +#include "config/aom_config.h" +#include "aom_mem/aom_mem.h" +#include "av1/common/alloccommon.h" + +#if CONFIG_OPTICAL_FLOW_API + +/* + * Input: + * rows: array of row positions + * cols: array of column positions + * values: array of element values + * num_elem: total number of elements in the matrix + * num_rows: number of rows in the matrix + * num_cols: number of columns in the matrix + * + * Output: + * sm: pointer to the sparse matrix to be initialized + */ +void av1_init_sparse_mtx(const int *rows, const int *cols, const double *values, + int num_elem, int num_rows, int num_cols, + SPARSE_MTX *sm) { + sm->n_elem = num_elem; + sm->n_rows = num_rows; + sm->n_cols = num_cols; + if (num_elem == 0) { + sm->row_pos = NULL; + sm->col_pos = NULL; + sm->value = NULL; + return; + } + sm->row_pos = aom_calloc(num_elem, sizeof(*sm->row_pos)); + sm->col_pos = aom_calloc(num_elem, sizeof(*sm->col_pos)); + sm->value = aom_calloc(num_elem, sizeof(*sm->value)); + + memcpy(sm->row_pos, rows, num_elem * sizeof(*sm->row_pos)); + memcpy(sm->col_pos, cols, num_elem * sizeof(*sm->col_pos)); + memcpy(sm->value, values, num_elem * sizeof(*sm->value)); +} + +/* + * Combines two sparse matrices (allocating new space). + * + * Input: + * sm1, sm2: matrices to be combined + * row_offset1, row_offset2: row offset of each matrix in the new matrix + * col_offset1, col_offset2: column offset of each matrix in the new matrix + * new_n_rows, new_n_cols: number of rows and columns in the new matrix + * + * Output: + * sm: the combined matrix + */ +void av1_init_combine_sparse_mtx(const SPARSE_MTX *sm1, const SPARSE_MTX *sm2, + SPARSE_MTX *sm, int row_offset1, + int col_offset1, int row_offset2, + int col_offset2, int new_n_rows, + int new_n_cols) { + sm->n_elem = sm1->n_elem + sm2->n_elem; + sm->n_cols = new_n_cols; + sm->n_rows = new_n_rows; + + if (sm->n_elem == 0) { + sm->row_pos = NULL; + sm->col_pos = NULL; + sm->value = NULL; + return; + } + sm->row_pos = aom_calloc(sm->n_elem, sizeof(*sm->row_pos)); + sm->col_pos = aom_calloc(sm->n_elem, sizeof(*sm->col_pos)); + sm->value = aom_calloc(sm->n_elem, sizeof(*sm->value)); + + for (int i = 0; i < sm1->n_elem; i++) { + sm->row_pos[i] = sm1->row_pos[i] + row_offset1; + sm->col_pos[i] = sm1->col_pos[i] + col_offset1; + } + memcpy(sm->value, sm1->value, sm1->n_elem * sizeof(*sm1->value)); + int n_elem1 = sm1->n_elem; + for (int i = 0; i < sm2->n_elem; i++) { + sm->row_pos[n_elem1 + i] = sm2->row_pos[i] + row_offset2; + sm->col_pos[n_elem1 + i] = sm2->col_pos[i] + col_offset2; + } + memcpy(sm->value + n_elem1, sm2->value, sm2->n_elem * sizeof(*sm2->value)); +} + +void av1_free_sparse_mtx_elems(SPARSE_MTX *sm) { + sm->n_cols = 0; + sm->n_rows = 0; + if (sm->n_elem != 0) { + aom_free(sm->row_pos); + aom_free(sm->col_pos); + aom_free(sm->value); + } + sm->n_elem = 0; +} + +/* + * Calculate matrix and vector multiplication: A*b + * + * Input: + * sm: matrix A + * srcv: the vector b to be multiplied to + * dstl: the length of vectors + * + * Output: + * dstv: pointer to the resulting vector + */ +void av1_mtx_vect_multi_right(const SPARSE_MTX *sm, const double *srcv, + double *dstv, int dstl) { + memset(dstv, 0, sizeof(*dstv) * dstl); + for (int i = 0; i < sm->n_elem; i++) { + dstv[sm->row_pos[i]] += srcv[sm->col_pos[i]] * sm->value[i]; + } +} +/* + * Calculate matrix and vector multiplication: b*A + * + * Input: + * sm: matrix A + * srcv: the vector b to be multiplied to + * dstl: the length of vectors + * + * Output: + * dstv: pointer to the resulting vector + */ +void av1_mtx_vect_multi_left(const SPARSE_MTX *sm, const double *srcv, + double *dstv, int dstl) { + memset(dstv, 0, sizeof(*dstv) * dstl); + for (int i = 0; i < sm->n_elem; i++) { + dstv[sm->col_pos[i]] += srcv[sm->row_pos[i]] * sm->value[i]; + } +} + +/* + * Calculate inner product of two vectors + * + * Input: + * src1, scr2: the vectors to be multiplied + * src1l: length of the vectors + * + * Output: + * the inner product + */ +double av1_vect_vect_multi(const double *src1, int src1l, const double *src2) { + double result = 0; + for (int i = 0; i < src1l; i++) { + result += src1[i] * src2[i]; + } + return result; +} + +/* + * Multiply each element in the matrix sm with a constant c + */ +void av1_constant_multiply_sparse_matrix(SPARSE_MTX *sm, double c) { + for (int i = 0; i < sm->n_elem; i++) { + sm->value[i] *= c; + } +} + +/* + * Solve for Ax = b + * no requirement on A + * + * Input: + * A: the sparse matrix + * b: the vector b + * bl: length of b + * + * Output: + * x: pointer to the solution vector + */ +void av1_bi_conjugate_gradient_sparse(const SPARSE_MTX *A, const double *b, + int bl, double *x) { + double *r, *r_hat, *p, *p_hat, *Ap, *p_hatA, *x_hat; + double alpha, beta, rtr, r_norm_2; + double denormtemp; + + // initialize + r = aom_calloc(bl, sizeof(*r)); + r_hat = aom_calloc(bl, sizeof(*r_hat)); + p = aom_calloc(bl, sizeof(*p)); + p_hat = aom_calloc(bl, sizeof(*p_hat)); + Ap = aom_calloc(bl, sizeof(*Ap)); + p_hatA = aom_calloc(bl, sizeof(*p_hatA)); + x_hat = aom_calloc(bl, sizeof(*x_hat)); + + int i; + for (i = 0; i < bl; i++) { + r[i] = b[i]; + r_hat[i] = b[i]; + p[i] = r[i]; + p_hat[i] = r_hat[i]; + x[i] = 0; + x_hat[i] = 0; + } + r_norm_2 = av1_vect_vect_multi(r_hat, bl, r); + for (int k = 0; k < MAX_CG_SP_ITER; k++) { + rtr = r_norm_2; + av1_mtx_vect_multi_right(A, p, Ap, bl); + av1_mtx_vect_multi_left(A, p_hat, p_hatA, bl); + + denormtemp = av1_vect_vect_multi(p_hat, bl, Ap); + if (denormtemp < 1e-10) break; + alpha = rtr / denormtemp; + r_norm_2 = 0; + for (i = 0; i < bl; i++) { + x[i] += alpha * p[i]; + x_hat[i] += alpha * p_hat[i]; + r[i] -= alpha * Ap[i]; + r_hat[i] -= alpha * p_hatA[i]; + r_norm_2 += r_hat[i] * r[i]; + } + if (sqrt(r_norm_2) < 1e-2) { + break; + } + if (rtr < 1e-10) break; + beta = r_norm_2 / rtr; + for (i = 0; i < bl; i++) { + p[i] = r[i] + beta * p[i]; + p_hat[i] = r_hat[i] + beta * p_hat[i]; + } + } + // free + aom_free(r); + aom_free(r_hat); + aom_free(p); + aom_free(p_hat); + aom_free(Ap); + aom_free(p_hatA); + aom_free(x_hat); +} + +/* + * Solve for Ax = b when A is symmetric and positive definite + * + * Input: + * A: the sparse matrix + * b: the vector b + * bl: length of b + * + * Output: + * x: pointer to the solution vector + */ +void av1_conjugate_gradient_sparse(const SPARSE_MTX *A, const double *b, int bl, + double *x) { + double *r, *p, *Ap; + double alpha, beta, rtr, r_norm_2; + double denormtemp; + + // initialize + r = aom_calloc(bl, sizeof(*r)); + p = aom_calloc(bl, sizeof(*p)); + Ap = aom_calloc(bl, sizeof(*Ap)); + + int i; + for (i = 0; i < bl; i++) { + r[i] = b[i]; + p[i] = r[i]; + x[i] = 0; + } + r_norm_2 = av1_vect_vect_multi(r, bl, r); + int k; + for (k = 0; k < MAX_CG_SP_ITER; k++) { + rtr = r_norm_2; + av1_mtx_vect_multi_right(A, p, Ap, bl); + denormtemp = av1_vect_vect_multi(p, bl, Ap); + if (denormtemp < 1e-10) break; + alpha = rtr / denormtemp; + r_norm_2 = 0; + for (i = 0; i < bl; i++) { + x[i] += alpha * p[i]; + r[i] -= alpha * Ap[i]; + r_norm_2 += r[i] * r[i]; + } + if (r_norm_2 < 1e-8 * bl) break; + if (rtr < 1e-10) break; + beta = r_norm_2 / rtr; + for (i = 0; i < bl; i++) { + p[i] = r[i] + beta * p[i]; + } + } + // free + aom_free(r); + aom_free(p); + aom_free(Ap); +} + +/* + * Solve for Ax = b using Jacobi method + * + * Input: + * A: the sparse matrix + * b: the vector b + * bl: length of b + * + * Output: + * x: pointer to the solution vector + */ +void av1_jacobi_sparse(const SPARSE_MTX *A, const double *b, int bl, + double *x) { + double *diags, *Rx, *x_last, *x_cur, *tempx; + double resi2; + diags = aom_calloc(bl, sizeof((*diags))); + Rx = aom_calloc(bl, sizeof(*Rx)); + x_last = aom_calloc(bl, sizeof(*x_last)); + x_cur = aom_calloc(bl, sizeof(*x_cur)); + int i; + memset(x_last, 0, sizeof(*x_last) * bl); + // get the diagonals of A + memset(diags, 0, sizeof(*diags) * bl); + for (int c = 0; c < A->n_elem; c++) { + if (A->row_pos[c] != A->col_pos[c]) continue; + diags[A->row_pos[c]] = A->value[c]; + } + int k; + for (k = 0; k < MAX_CG_SP_ITER; k++) { + // R = A - diag(diags) + // get R*x_last + memset(Rx, 0, sizeof(*Rx) * bl); + for (int c = 0; c < A->n_elem; c++) { + if (A->row_pos[c] == A->col_pos[c]) continue; + Rx[A->row_pos[c]] += x_last[A->col_pos[c]] * A->value[c]; + } + resi2 = 0; + for (i = 0; i < bl; i++) { + x_cur[i] = (b[i] - Rx[i]) / diags[i]; + resi2 += (x_last[i] - x_cur[i]) * (x_last[i] - x_cur[i]); + } + if (resi2 <= 1e-10 * bl) break; + // swap last & cur buffer ptrs + tempx = x_last; + x_last = x_cur; + x_cur = tempx; + } + printf("\n numiter: %d\n", k); + for (i = 0; i < bl; i++) { + x[i] = x_cur[i]; + } + aom_free(diags); + aom_free(Rx); + aom_free(x_last); + aom_free(x_cur); +} + +/* + * Solve for Ax = b using Steepest descent method + * + * Input: + * A: the sparse matrix + * b: the vector b + * bl: length of b + * + * Output: + * x: pointer to the solution vector + */ +void av1_steepest_descent_sparse(const SPARSE_MTX *A, const double *b, int bl, + double *x) { + double *d, *Ad, *Ax; + double resi2, resi2_last, dAd, diff, temp; + d = aom_calloc(bl, sizeof(*d)); + Ax = aom_calloc(bl, sizeof(*Ax)); + Ad = aom_calloc(bl, sizeof(*Ad)); + int i; + // initialize with 0s + resi2 = 0; + for (i = 0; i < bl; i++) { + x[i] = 0; + d[i] = b[i]; + resi2 += d[i] * d[i] / bl; + } + int k; + for (k = 0; k < MAX_CG_SP_ITER; k++) { + // get A*x_last + av1_mtx_vect_multi_right(A, d, Ad, bl); + dAd = resi2 * bl / av1_vect_vect_multi(d, bl, Ad); + diff = 0; + for (i = 0; i < bl; i++) { + temp = dAd * d[i]; + x[i] = x[i] + temp; + diff += temp * temp; + } + av1_mtx_vect_multi_right(A, x, Ax, bl); + resi2_last = resi2; + resi2 = 0; + for (i = 0; i < bl; i++) { + d[i] = b[i] - Ax[i]; + resi2 += d[i] * d[i] / bl; + } + if (resi2 <= 1e-8) break; + if (resi2_last - resi2 < 1e-8) { + break; + } + } + aom_free(d); + aom_free(Ax); + aom_free(Ad); +} + +#endif // CONFIG_OPFL
diff --git a/av1/encoder/sparse_linear_solver.h b/av1/encoder/sparse_linear_solver.h new file mode 100644 index 0000000..3cacb51 --- /dev/null +++ b/av1/encoder/sparse_linear_solver.h
@@ -0,0 +1,67 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. + */ + +#ifndef AV1_COMMON_SPARSE_LINEAR_SOLVER_H_ +#define AV1_COMMON_SPARSE_LINEAR_SOLVER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "config/aom_config.h" + +#if CONFIG_OPTICAL_FLOW_API + +// Number of iterations for solving linear equations. +#define MAX_CG_SP_ITER 100 + +typedef struct { + int n_elem; // number of non-zero elements + int n_rows; + int n_cols; + // using arrays to represent non-zero elements. + int *col_pos; + int *row_pos; // starts with 0 + double *value; +} SPARSE_MTX; + +void av1_init_sparse_mtx(const int *rows, const int *cols, const double *values, + int num_elem, int num_rows, int num_cols, + SPARSE_MTX *sm); +void av1_init_combine_sparse_mtx(const SPARSE_MTX *sm1, const SPARSE_MTX *sm2, + SPARSE_MTX *sm, int row_offset1, + int col_offset1, int row_offset2, + int col_offset2, int new_n_rows, + int new_n_cols); +void av1_free_sparse_mtx_elems(SPARSE_MTX *sm); + +void av1_mtx_vect_multi_right(const SPARSE_MTX *sm, const double *srcv, + double *dstv, int dstl); +void av1_mtx_vect_multi_left(const SPARSE_MTX *sm, const double *srcv, + double *dstv, int dstl); +double av1_vect_vect_multi(const double *src1, int src1l, const double *src2); +void av1_constant_multiply_sparse_matrix(SPARSE_MTX *sm, double c); + +void av1_conjugate_gradient_sparse(const SPARSE_MTX *A, const double *b, int bl, + double *x); +void av1_bi_conjugate_gradient_sparse(const SPARSE_MTX *A, const double *b, + int bl, double *x); +void av1_jacobi_sparse(const SPARSE_MTX *A, const double *b, int bl, double *x); +void av1_steepest_descent_sparse(const SPARSE_MTX *A, const double *b, int bl, + double *x); + +#endif // CONFIG_OPTICAL_FLOW_API + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif /* AV1_COMMON_SPARSE_LINEAR_SOLVER_H_ */
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c index 7aae582..4b87012 100644 --- a/av1/encoder/speed_features.c +++ b/av1/encoder/speed_features.c
@@ -150,6 +150,335 @@ return frame_is_kf_gf_arf(cpi); } +static void set_allintra_speed_feature_framesize_dependent( + const AV1_COMP *const cpi, SPEED_FEATURES *const sf, int speed) { + const AV1_COMMON *const cm = &cpi->common; + const int is_480p_or_larger = AOMMIN(cm->width, cm->height) >= 480; + const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720; + const int is_1080p_or_larger = AOMMIN(cm->width, cm->height) >= 1080; + const int is_4k_or_larger = AOMMIN(cm->width, cm->height) >= 2160; + const bool use_hbd = cpi->oxcf.use_highbitdepth; + + if (is_480p_or_larger) { + sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128; + if (is_720p_or_larger) + sf->part_sf.auto_max_partition_based_on_simple_motion = ADAPT_PRED; + else + sf->part_sf.auto_max_partition_based_on_simple_motion = RELAXED_PRED; + } else { + sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64; + sf->part_sf.auto_max_partition_based_on_simple_motion = DIRECT_PRED; + if (use_hbd) sf->tx_sf.prune_tx_size_level = 1; + } + + if (is_4k_or_larger) { + sf->part_sf.default_min_partition_size = BLOCK_8X8; + } + + // TODO(huisu@google.com): train models for 720P and above. + if (!is_720p_or_larger) { + sf->part_sf.ml_partition_search_breakout_thresh[0] = 200; // BLOCK_8X8 + sf->part_sf.ml_partition_search_breakout_thresh[1] = 250; // BLOCK_16X16 + sf->part_sf.ml_partition_search_breakout_thresh[2] = 300; // BLOCK_32X32 + sf->part_sf.ml_partition_search_breakout_thresh[3] = 500; // BLOCK_64X64 + sf->part_sf.ml_partition_search_breakout_thresh[4] = -1; // BLOCK_128X128 + sf->part_sf.ml_early_term_after_part_split_level = 1; + } + + if (is_720p_or_larger) { + // TODO(chiyotsai@google.com): make this speed feature adaptive based on + // current block's vertical texture instead of hardcoded with resolution + sf->mv_sf.use_downsampled_sad = 1; + } + + if (speed >= 1) { + if (is_720p_or_larger) { + sf->part_sf.use_square_partition_only_threshold = BLOCK_128X128; + } else if (is_480p_or_larger) { + sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64; + } else { + sf->part_sf.use_square_partition_only_threshold = BLOCK_32X32; + } + + if (!is_720p_or_larger) { + sf->part_sf.ml_partition_search_breakout_thresh[0] = 200; // BLOCK_8X8 + sf->part_sf.ml_partition_search_breakout_thresh[1] = 250; // BLOCK_16X16 + sf->part_sf.ml_partition_search_breakout_thresh[2] = 300; // BLOCK_32X32 + sf->part_sf.ml_partition_search_breakout_thresh[3] = 300; // BLOCK_64X64 + sf->part_sf.ml_partition_search_breakout_thresh[4] = -1; // BLOCK_128X128 + } + sf->part_sf.ml_early_term_after_part_split_level = 2; + } + + if (speed >= 2) { + if (is_720p_or_larger) { + sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64; + } else if (is_480p_or_larger) { + sf->part_sf.use_square_partition_only_threshold = BLOCK_32X32; + } else { + sf->part_sf.use_square_partition_only_threshold = BLOCK_32X32; + } + + if (is_720p_or_larger) { + sf->part_sf.partition_search_breakout_dist_thr = (1 << 24); + sf->part_sf.partition_search_breakout_rate_thr = 120; + } else { + sf->part_sf.partition_search_breakout_dist_thr = (1 << 22); + sf->part_sf.partition_search_breakout_rate_thr = 100; + } + + if (is_480p_or_larger) { + sf->tx_sf.tx_type_search.prune_tx_type_using_stats = 1; + if (use_hbd) sf->tx_sf.prune_tx_size_level = 2; + } else { + if (use_hbd) sf->tx_sf.prune_tx_size_level = 3; + } + } + + if (speed >= 3) { + sf->part_sf.ml_early_term_after_part_split_level = 0; + + if (is_720p_or_larger) { + sf->part_sf.partition_search_breakout_dist_thr = (1 << 25); + sf->part_sf.partition_search_breakout_rate_thr = 200; + } else { + sf->part_sf.max_intra_bsize = BLOCK_32X32; + sf->part_sf.partition_search_breakout_dist_thr = (1 << 23); + sf->part_sf.partition_search_breakout_rate_thr = 120; + } + if (use_hbd) sf->tx_sf.prune_tx_size_level = 3; + } + + if (speed >= 4) { + if (is_720p_or_larger) { + sf->part_sf.partition_search_breakout_dist_thr = (1 << 26); + } else { + sf->part_sf.partition_search_breakout_dist_thr = (1 << 24); + } + + if (is_480p_or_larger) { + sf->tx_sf.tx_type_search.prune_tx_type_using_stats = 2; + } + } + + if (speed >= 6) { + if (is_720p_or_larger) { + sf->part_sf.auto_max_partition_based_on_simple_motion = NOT_IN_USE; + } else if (is_480p_or_larger) { + sf->part_sf.auto_max_partition_based_on_simple_motion = DIRECT_PRED; + } + + if (is_1080p_or_larger) { + sf->part_sf.default_min_partition_size = BLOCK_8X8; + } + + sf->part_sf.use_square_partition_only_threshold = BLOCK_16X16; + } +} + +static void set_allintra_speed_features_framesize_independent( + const AV1_COMP *const cpi, SPEED_FEATURES *const sf, int speed) { + const AV1_COMMON *const cm = &cpi->common; + const int allow_screen_content_tools = + cm->features.allow_screen_content_tools; + const int use_hbd = cpi->oxcf.use_highbitdepth; + + sf->part_sf.less_rectangular_check_level = 1; + sf->part_sf.ml_prune_partition = 1; + sf->part_sf.prune_ext_partition_types_search_level = 1; + sf->part_sf.prune_part4_search = 2; + sf->part_sf.simple_motion_search_prune_rect = 1; + sf->part_sf.ml_predict_breakout_level = use_hbd ? 1 : 3; + + sf->intra_sf.intra_pruning_with_hog = 1; + sf->intra_sf.dv_cost_upd_level = INTERNAL_COST_UPD_OFF; + + sf->tx_sf.adaptive_txb_search_level = 1; + sf->tx_sf.intra_tx_size_search_init_depth_sqr = 1; + sf->tx_sf.model_based_prune_tx_search_level = 1; + sf->tx_sf.tx_type_search.use_reduced_intra_txset = 1; + + sf->rt_sf.use_nonrd_pick_mode = 0; + sf->rt_sf.use_real_time_ref_set = 0; + + if (cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION || + cpi->use_screen_content_tools) { + sf->mv_sf.exhaustive_searches_thresh = (1 << 20); + } else { + sf->mv_sf.exhaustive_searches_thresh = (1 << 25); + } + + sf->rd_sf.perform_coeff_opt = 1; + sf->hl_sf.superres_auto_search_type = SUPERRES_AUTO_DUAL; + + if (speed >= 1) { + sf->part_sf.intra_cnn_split = 1; + sf->part_sf.simple_motion_search_early_term_none = 1; + // TODO(Venkat): Clean-up frame type dependency for + // simple_motion_search_split in partition search function and set the + // speed feature accordingly + sf->part_sf.simple_motion_search_split = allow_screen_content_tools ? 1 : 2; + sf->part_sf.ml_predict_breakout_level = use_hbd ? 2 : 3; + sf->part_sf.reuse_best_prediction_for_part_ab = 1; + + sf->mv_sf.exhaustive_searches_thresh <<= 1; + + sf->intra_sf.prune_palette_search_level = 1; + + sf->tx_sf.adaptive_txb_search_level = 2; + sf->tx_sf.inter_tx_size_search_init_depth_rect = 1; + sf->tx_sf.inter_tx_size_search_init_depth_sqr = 1; + sf->tx_sf.intra_tx_size_search_init_depth_rect = 1; + sf->tx_sf.model_based_prune_tx_search_level = 0; + sf->tx_sf.tx_type_search.ml_tx_split_thresh = 4000; + sf->tx_sf.tx_type_search.prune_2d_txfm_mode = TX_TYPE_PRUNE_2; + sf->tx_sf.tx_type_search.skip_tx_search = 1; + + sf->rd_sf.perform_coeff_opt = 2; + sf->rd_sf.tx_domain_dist_level = 1; + sf->rd_sf.tx_domain_dist_thres_level = 1; + + sf->lpf_sf.cdef_pick_method = CDEF_FAST_SEARCH_LVL1; + sf->lpf_sf.dual_sgr_penalty_level = 1; + sf->lpf_sf.enable_sgr_ep_pruning = 1; + } + + if (speed >= 2) { + sf->part_sf.allow_partition_search_skip = 1; + + sf->mv_sf.auto_mv_step_size = 1; + + sf->intra_sf.disable_smooth_intra = 1; + sf->intra_sf.intra_pruning_with_hog = 2; + + sf->rd_sf.perform_coeff_opt = 3; + + sf->lpf_sf.prune_wiener_based_on_src_var = 1; + sf->lpf_sf.prune_sgr_based_on_wiener = 1; + } + + if (speed >= 3) { + sf->hl_sf.high_precision_mv_usage = CURRENT_Q; + sf->hl_sf.recode_loop = ALLOW_RECODE_KFARFGF; + + sf->part_sf.less_rectangular_check_level = 2; + sf->part_sf.simple_motion_search_prune_agg = 1; + sf->part_sf.prune_ext_part_using_split_info = 1; + + sf->mv_sf.full_pixel_search_level = 1; + sf->mv_sf.search_method = DIAMOND; + + // TODO(chiyotsai@google.com): the thresholds chosen for intra hog are + // inherited directly from luma hog with some minor tweaking. Eventually we + // should run this with a bayesian optimizer to find the Pareto frontier. + sf->intra_sf.chroma_intra_pruning_with_hog = 2; + sf->intra_sf.intra_pruning_with_hog = 3; + sf->intra_sf.prune_palette_search_level = 2; + + sf->tx_sf.adaptive_txb_search_level = 2; + sf->tx_sf.tx_type_search.use_skip_flag_prediction = 2; + + // TODO(any): evaluate if these lpf features can be moved to speed 2. + // For screen content, "prune_sgr_based_on_wiener = 2" cause large quality + // loss. + sf->lpf_sf.prune_sgr_based_on_wiener = allow_screen_content_tools ? 1 : 2; + sf->lpf_sf.disable_loop_restoration_chroma = 0; + sf->lpf_sf.reduce_wiener_window_size = 1; + sf->lpf_sf.prune_wiener_based_on_src_var = 2; + } + + if (speed >= 4) { + sf->mv_sf.subpel_search_method = SUBPEL_TREE_PRUNED_MORE; + + sf->part_sf.simple_motion_search_prune_agg = 2; + sf->part_sf.simple_motion_search_reduce_search_steps = 4; + sf->part_sf.prune_ext_part_using_split_info = 2; + sf->part_sf.early_term_after_none_split = 1; + sf->part_sf.ml_predict_breakout_level = 3; + + sf->intra_sf.intra_uv_mode_mask[TX_16X16] = UV_INTRA_DC_H_V_CFL; + sf->intra_sf.intra_uv_mode_mask[TX_32X32] = UV_INTRA_DC_H_V_CFL; + sf->intra_sf.intra_uv_mode_mask[TX_64X64] = UV_INTRA_DC_H_V_CFL; + sf->intra_sf.intra_y_mode_mask[TX_16X16] = INTRA_DC_H_V; + sf->intra_sf.intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V; + sf->intra_sf.intra_y_mode_mask[TX_64X64] = INTRA_DC_H_V; + sf->intra_sf.prune_chroma_modes_using_luma_winner = 1; + + sf->mv_sf.simple_motion_subpel_force_stop = HALF_PEL; + + sf->tpl_sf.prune_starting_mv = 2; + sf->tpl_sf.subpel_force_stop = HALF_PEL; + sf->tpl_sf.search_method = FAST_BIGDIA; + + sf->tx_sf.tx_type_search.winner_mode_tx_type_pruning = 1; + sf->tx_sf.tx_type_search.fast_intra_tx_type_search = 1; + sf->tx_sf.tx_type_search.prune_2d_txfm_mode = TX_TYPE_PRUNE_3; + sf->tx_sf.tx_type_search.prune_tx_type_est_rd = 1; + + sf->rd_sf.perform_coeff_opt = 5; + sf->rd_sf.tx_domain_dist_thres_level = 2; + + sf->lpf_sf.lpf_pick = LPF_PICK_FROM_FULL_IMAGE_NON_DUAL; + sf->lpf_sf.cdef_pick_method = CDEF_FAST_SEARCH_LVL3; + + sf->mv_sf.reduce_search_range = 1; + + sf->winner_mode_sf.enable_winner_mode_for_coeff_opt = 1; + sf->winner_mode_sf.enable_winner_mode_for_use_tx_domain_dist = 1; + sf->winner_mode_sf.multi_winner_mode_type = MULTI_WINNER_MODE_DEFAULT; + sf->winner_mode_sf.enable_winner_mode_for_tx_size_srch = 1; + } + + if (speed >= 5) { + sf->part_sf.simple_motion_search_prune_agg = 3; + sf->part_sf.ext_partition_eval_thresh = + allow_screen_content_tools ? BLOCK_8X8 : BLOCK_16X16; + + sf->intra_sf.chroma_intra_pruning_with_hog = 3; + + sf->lpf_sf.use_coarse_filter_level_search = 0; + sf->lpf_sf.disable_lr_filter = 1; + + sf->mv_sf.prune_mesh_search = 1; + + sf->winner_mode_sf.multi_winner_mode_type = MULTI_WINNER_MODE_FAST; + } + + if (speed >= 6) { + sf->intra_sf.disable_filter_intra = 1; + sf->intra_sf.chroma_intra_pruning_with_hog = 4; + sf->intra_sf.intra_pruning_with_hog = 4; + + sf->part_sf.prune_rectangular_split_based_on_qidx = + allow_screen_content_tools ? 0 : 1; + sf->part_sf.prune_sub_8x8_partition_level = + allow_screen_content_tools ? 0 : 1; + sf->part_sf.prune_part4_search = 3; + // TODO(jingning): This might not be a good trade off if the + // target image quality is very low. + sf->part_sf.default_max_partition_size = BLOCK_32X32; + + sf->mv_sf.use_bsize_dependent_search_method = 1; + + sf->tx_sf.tx_type_search.winner_mode_tx_type_pruning = 2; + sf->tx_sf.tx_type_search.prune_tx_type_est_rd = 0; + // Use largest txfm block size for square coding blocks. + sf->tx_sf.intra_tx_size_search_init_depth_sqr = 2; + sf->tx_sf.tx_type_search.use_reduced_intra_txset = 2; + + sf->rd_sf.perform_coeff_opt = 6; + sf->lpf_sf.cdef_pick_method = CDEF_FAST_SEARCH_LVL4; + + sf->winner_mode_sf.multi_winner_mode_type = MULTI_WINNER_MODE_OFF; + } + + // Intra txb hash is currently not compatible with multi-winner mode as the + // hashes got reset during multi-winner mode processing. + assert(IMPLIES( + sf->winner_mode_sf.multi_winner_mode_type != MULTI_WINNER_MODE_OFF, + !sf->tx_sf.use_intra_txb_hash)); +} + static void set_good_speed_feature_framesize_dependent( const AV1_COMP *const cpi, SPEED_FEATURES *const sf, int speed) { const AV1_COMMON *const cm = &cpi->common; @@ -239,6 +568,10 @@ } else { if (use_hbd) sf->tx_sf.prune_tx_size_level = 3; } + + if (!is_720p_or_larger) sf->mv_sf.disable_second_mv = 1; + + if (!is_720p_or_larger) sf->hl_sf.recode_tolerance = 50; } if (speed >= 3) { @@ -267,6 +600,11 @@ } sf->inter_sf.prune_obmc_prob_thresh = INT_MAX; + + if (is_720p_or_larger) + sf->hl_sf.recode_tolerance = 32; + else + sf->hl_sf.recode_tolerance = 55; } if (speed >= 5) { @@ -275,6 +613,7 @@ } else if (is_480p_or_larger) { sf->inter_sf.prune_warped_prob_thresh = 8; } + if (is_720p_or_larger) sf->hl_sf.recode_tolerance = 40; } if (speed >= 6) { @@ -293,13 +632,10 @@ } if (!is_720p_or_larger) { - sf->inter_sf.mv_cost_upd_level = 2; + sf->inter_sf.mv_cost_upd_level = INTERNAL_COST_UPD_SBROW_SET; } - // TODO(yunqing): use BLOCK_32X32 for >= 4k. - if (is_4k_or_larger) { - sf->part_sf.use_square_partition_only_threshold = BLOCK_64X64; - } else if (is_720p_or_larger) { + if (is_720p_or_larger) { sf->part_sf.use_square_partition_only_threshold = BLOCK_32X32; } else { sf->part_sf.use_square_partition_only_threshold = BLOCK_16X16; @@ -313,56 +649,6 @@ } } -static void set_rt_speed_feature_framesize_dependent(const AV1_COMP *const cpi, - SPEED_FEATURES *const sf, - int speed) { - const AV1_COMMON *const cm = &cpi->common; - const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720; - const int is_480p_or_larger = AOMMIN(cm->width, cm->height) >= 480; - const int is_360p_or_larger = AOMMIN(cm->width, cm->height) >= 360; - - (void)is_720p_or_larger; // Not used so far - - if (!is_360p_or_larger) { - if (speed >= 6) sf->rt_sf.force_tx_search_off = 1; - if (speed >= 8) { - sf->rt_sf.use_modeled_non_rd_cost = 0; - sf->rt_sf.use_nonrd_filter_search = 0; - } - if (speed >= 9) { - sf->rt_sf.use_modeled_non_rd_cost = 1; - sf->rt_sf.nonrd_agressive_skip = 1; -// TODO(kyslov) Re-enable when AV1 models are trained -#if 0 -#if CONFIG_RT_ML_PARTITIONING - if (!frame_is_intra_only(cm)) { - sf->part_sf.partition_search_type = ML_BASED_PARTITION; - sf->rt_sf.reuse_inter_pred_nonrd = 0; - } -#endif -#endif - } - } else { - if (speed == 8 && !cpi->use_svc) { - sf->rt_sf.short_circuit_low_temp_var = 0; - sf->rt_sf.use_nonrd_altref_frame = 1; - } - } - if (!is_480p_or_larger) { - if (speed == 7) { - sf->rt_sf.nonrd_check_partition_merge_mode = 2; - } - if (speed >= 8) { - sf->mv_sf.subpel_search_method = SUBPEL_TREE; - sf->rt_sf.estimate_motion_for_var_based_partition = 1; - } - if (speed >= 9) { - sf->mv_sf.subpel_search_method = SUBPEL_TREE_PRUNED; - sf->rt_sf.estimate_motion_for_var_based_partition = 0; - } - } -} - static void set_good_speed_features_framesize_independent( const AV1_COMP *const cpi, SPEED_FEATURES *const sf, int speed) { const AV1_COMMON *const cm = &cpi->common; @@ -480,9 +766,14 @@ } if (speed >= 2) { + sf->hl_sf.recode_loop = ALLOW_RECODE_KFARFGF; + sf->part_sf.allow_partition_search_skip = 1; + sf->part_sf.reuse_best_prediction_for_part_ab = + !frame_is_intra_only(&cpi->common); sf->mv_sf.auto_mv_step_size = 1; + sf->mv_sf.simple_motion_subpel_force_stop = QUARTER_PEL; sf->mv_sf.subpel_iters_per_step = 1; // TODO(chiyotsai@google.com): We can get 10% speed up if we move @@ -498,11 +789,12 @@ sf->inter_sf.prune_compound_using_neighbors = 1; sf->inter_sf.prune_comp_using_best_single_mode_ref = 2; sf->inter_sf.prune_comp_type_by_comp_avg = 2; - sf->inter_sf.reuse_best_prediction_for_part_ab = 1; sf->inter_sf.selective_ref_frame = 3; sf->inter_sf.use_dist_wtd_comp_flag = DIST_WTD_COMP_DISABLED; // Enable fast search only for COMPOUND_DIFFWTD type. sf->inter_sf.enable_fast_compound_mode_search = 1; + sf->inter_sf.reuse_mask_search_results = 1; + sf->inter_sf.txfm_rd_gate_level = boosted ? 0 : 1; // TODO(Sachin): Enable/Enhance this speed feature for speed 2 & 3 sf->interp_sf.adaptive_interp_filter_search = 1; @@ -512,6 +804,9 @@ !frame_is_intra_only(&cpi->common) || (cpi->rc.frames_to_key > 1); sf->intra_sf.intra_pruning_with_hog = 2; + sf->tpl_sf.prune_starting_mv = 1; + sf->tpl_sf.search_method = DIAMOND; + sf->rd_sf.perform_coeff_opt = is_boosted_arf2_bwd_type ? 3 : 4; sf->lpf_sf.prune_wiener_based_on_src_var = 1; @@ -526,24 +821,21 @@ if (speed >= 3) { 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->part_sf.less_rectangular_check_level = 2; sf->part_sf.simple_motion_search_prune_agg = 1; sf->part_sf.prune_ext_part_using_split_info = 1; + sf->part_sf.simple_motion_search_rect_split = 1; - // adaptive_motion_search breaks encoder multi-thread tests. - // The values in x->pred_mv[] differ for single and multi-thread cases. - // See aomedia:1778. - // sf->mv_sf.adaptive_motion_search = 1; sf->mv_sf.full_pixel_search_level = 1; - sf->mv_sf.simple_motion_subpel_force_stop = QUARTER_PEL; sf->mv_sf.subpel_search_method = SUBPEL_TREE_PRUNED; sf->mv_sf.search_method = DIAMOND; + sf->mv_sf.disable_second_mv = 2; - sf->inter_sf.mv_cost_upd_level = 1; + sf->inter_sf.mv_cost_upd_level = INTERNAL_COST_UPD_SBROW; + sf->inter_sf.disable_onesided_comp = 1; // TODO(yunqing): evaluate this speed feature for speed 1 & 2, and combine // it with cpi->sf.disable_wedge_search_var_thresh. sf->inter_sf.disable_interintra_wedge_var_thresh = UINT_MAX; @@ -559,6 +851,8 @@ sf->inter_sf.txfm_rd_gate_level = boosted ? 0 : (is_boosted_arf2_bwd_type ? 1 : 2); + sf->interp_sf.adaptive_interp_filter_search = 2; + // TODO(chiyotsai@google.com): the thresholds chosen for intra hog are // inherited directly from luma hog with some minor tweaking. Eventually we // should run this with a bayesian optimizer to find the Pareto frontier. @@ -568,10 +862,8 @@ sf->tpl_sf.skip_alike_starting_mv = 2; sf->tpl_sf.prune_intra_modes = 1; - sf->tpl_sf.prune_starting_mv = 1; sf->tpl_sf.reduce_first_step_size = 6; sf->tpl_sf.subpel_force_stop = QUARTER_PEL; - sf->tpl_sf.search_method = DIAMOND; sf->tx_sf.adaptive_txb_search_level = boosted ? 2 : 3; sf->tx_sf.tx_type_search.use_skip_flag_prediction = 2; @@ -609,17 +901,15 @@ sf->part_sf.ml_predict_breakout_level = 3; sf->inter_sf.alt_ref_search_fp = 1; - sf->inter_sf.txfm_rd_gate_level = boosted ? 0 : 4; + sf->inter_sf.txfm_rd_gate_level = boosted ? 0 : 3; sf->inter_sf.prune_inter_modes_based_on_tpl = boosted ? 0 : 2; sf->inter_sf.prune_compound_using_neighbors = 2; sf->inter_sf.prune_obmc_prob_thresh = INT_MAX; - sf->inter_sf.disable_onesided_comp = 1; sf->interp_sf.cb_pred_filter_search = 1; sf->interp_sf.skip_sharp_interp_filter_search = 1; sf->interp_sf.use_interp_filter = 2; - sf->interp_sf.adaptive_interp_filter_search = 2; sf->intra_sf.intra_uv_mode_mask[TX_16X16] = UV_INTRA_DC_H_V_CFL; sf->intra_sf.intra_uv_mode_mask[TX_32X32] = UV_INTRA_DC_H_V_CFL; @@ -667,7 +957,7 @@ sf->inter_sf.disable_interinter_wedge_var_thresh = UINT_MAX; sf->inter_sf.prune_inter_modes_if_skippable = 1; - sf->inter_sf.txfm_rd_gate_level = boosted ? 0 : 5; + sf->inter_sf.txfm_rd_gate_level = boosted ? 0 : 4; // Enable fast search for all valid compound modes. sf->inter_sf.enable_fast_compound_mode_search = 2; @@ -685,6 +975,8 @@ sf->mv_sf.prune_mesh_search = 1; sf->tpl_sf.prune_starting_mv = 3; + sf->tpl_sf.use_y_only_rate_distortion = 1; + sf->tpl_sf.subpel_force_stop = FULL_PEL; sf->winner_mode_sf.dc_blk_pred_level = 1; } @@ -696,6 +988,7 @@ sf->inter_sf.prune_inter_modes_based_on_tpl = boosted ? 0 : 3; sf->inter_sf.prune_nearmv_using_neighbors = 1; + sf->inter_sf.selective_ref_frame = 6; sf->intra_sf.chroma_intra_pruning_with_hog = 4; sf->intra_sf.intra_pruning_with_hog = 4; @@ -711,7 +1004,6 @@ sf->mv_sf.use_bsize_dependent_search_method = 1; sf->tpl_sf.disable_gop_length_decision = 1; - sf->tpl_sf.subpel_force_stop = FULL_PEL; sf->tpl_sf.disable_filtered_key_tpl = 1; sf->tx_sf.tx_type_search.winner_mode_tx_type_pruning = 2; @@ -733,6 +1025,56 @@ !sf->tx_sf.use_intra_txb_hash)); } +static void set_rt_speed_feature_framesize_dependent(const AV1_COMP *const cpi, + SPEED_FEATURES *const sf, + int speed) { + const AV1_COMMON *const cm = &cpi->common; + const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720; + const int is_480p_or_larger = AOMMIN(cm->width, cm->height) >= 480; + const int is_360p_or_larger = AOMMIN(cm->width, cm->height) >= 360; + + (void)is_720p_or_larger; // Not used so far + + if (!is_360p_or_larger) { + if (speed >= 6) sf->rt_sf.force_tx_search_off = 1; + if (speed >= 8) { + sf->rt_sf.use_modeled_non_rd_cost = 0; + sf->rt_sf.use_nonrd_filter_search = 0; + } + if (speed >= 9) { + sf->rt_sf.use_modeled_non_rd_cost = 1; + sf->rt_sf.nonrd_agressive_skip = 1; +// TODO(kyslov) Re-enable when AV1 models are trained +#if 0 +#if CONFIG_RT_ML_PARTITIONING + if (!frame_is_intra_only(cm)) { + sf->part_sf.partition_search_type = ML_BASED_PARTITION; + sf->rt_sf.reuse_inter_pred_nonrd = 0; + } +#endif +#endif + } + } else { + if (speed == 8 && !cpi->use_svc) { + sf->rt_sf.short_circuit_low_temp_var = 0; + sf->rt_sf.use_nonrd_altref_frame = 1; + } + } + if (!is_480p_or_larger) { + if (speed == 7) { + sf->rt_sf.nonrd_check_partition_merge_mode = 2; + } + if (speed >= 8) { + sf->mv_sf.subpel_search_method = SUBPEL_TREE; + sf->rt_sf.estimate_motion_for_var_based_partition = 1; + } + if (speed >= 9) { + sf->mv_sf.subpel_search_method = SUBPEL_TREE_PRUNED; + sf->rt_sf.estimate_motion_for_var_based_partition = 0; + } + } +} + // TODO(kyslov): now this is very similar to // set_good_speed_features_framesize_independent // except it sets non-rd flag on speed8. This function will likely @@ -764,6 +1106,7 @@ sf->interp_sf.use_fast_interpolation_filter_search = 1; + sf->intra_sf.dv_cost_upd_level = INTERNAL_COST_UPD_OFF; sf->intra_sf.intra_pruning_with_hog = 1; sf->mv_sf.full_pixel_search_level = 1; @@ -771,7 +1114,7 @@ sf->rt_sf.check_intra_pred_nonrd = 1; sf->rt_sf.estimate_motion_for_var_based_partition = 1; - sf->rt_sf.hybrid_intra_pickmode = 0; + sf->rt_sf.hybrid_intra_pickmode = 1; sf->rt_sf.nonrd_prune_ref_frame_search = 0; sf->rt_sf.reuse_inter_pred_nonrd = 0; sf->rt_sf.use_comp_ref_nonrd = 1; @@ -863,7 +1206,7 @@ // sf->mv_sf.adaptive_motion_search = 1; sf->inter_sf.adaptive_rd_thresh = 2; - sf->inter_sf.mv_cost_upd_level = 1; + sf->inter_sf.mv_cost_upd_level = INTERNAL_COST_UPD_SBROW; // TODO(yunqing): evaluate this speed feature for speed 1 & 2, and combine // it with cpi->sf.disable_wedge_search_var_thresh. sf->inter_sf.disable_interintra_wedge_var_thresh = UINT_MAX; @@ -949,7 +1292,11 @@ cpi->oxcf.rc_cfg.mode == AOM_CBR) sf->rt_sf.overshoot_detection_cbr = FAST_DETECTION_MAXQ; // Enable noise estimation only for high resolutions for now. - if (cm->width * cm->height > 640 * 480) + // + // Since use_temporal_noise_estimate has no effect for all-intra frame + // encoding, it is disabled for this case. + if (cpi->oxcf.kf_cfg.key_freq_max != 0 && + cm->width * cm->height > 640 * 480) sf->rt_sf.use_temporal_noise_estimate = 1; } @@ -986,7 +1333,6 @@ sf->rt_sf.use_nonrd_pick_mode = 1; sf->rt_sf.nonrd_check_partition_merge_mode = 1; sf->rt_sf.nonrd_check_partition_split = 0; - sf->rt_sf.hybrid_intra_pickmode = 1; sf->rt_sf.skip_intra_pred_if_tx_skip = 1; // For SVC: use better mv search on base temporal layer, and only // on base spatial layer if highest resolution is above 640x360. @@ -1020,6 +1366,8 @@ } if (speed >= 8) { + sf->tx_sf.intra_tx_size_search_init_depth_sqr = 2; + sf->intra_sf.intra_pruning_with_hog = 1; sf->rt_sf.estimate_motion_for_var_based_partition = 1; sf->rt_sf.short_circuit_low_temp_var = 1; #if !CONFIG_AV1_TEMPORAL_DENOISING @@ -1065,6 +1413,7 @@ tpl_sf->disable_filtered_key_tpl = 0; tpl_sf->prune_ref_frames_in_tpl = 0; tpl_sf->allow_compound_pred = 1; + tpl_sf->use_y_only_rate_distortion = 0; } static AOM_INLINE void init_gm_sf(GLOBAL_MOTION_SPEED_FEATURES *gm_sf) { @@ -1108,6 +1457,8 @@ part_sf->early_term_after_none_split = 0; part_sf->ml_predict_breakout_level = 0; part_sf->prune_sub_8x8_partition_level = 0; + part_sf->simple_motion_search_rect_split = 0; + part_sf->reuse_best_prediction_for_part_ab = 0; } static AOM_INLINE void init_mv_sf(MV_SPEED_FEATURES *mv_sf) { @@ -1127,6 +1478,7 @@ mv_sf->use_fullpel_costlist = 0; mv_sf->use_downsampled_sad = 0; mv_sf->disable_extensive_joint_motion_search = 0; + mv_sf->disable_second_mv = 0; } static AOM_INLINE void init_inter_sf(INTER_MODE_SPEED_FEATURES *inter_sf) { @@ -1140,7 +1492,7 @@ inter_sf->fast_wedge_sign_estimate = 0; inter_sf->use_dist_wtd_comp_flag = DIST_WTD_COMP_ENABLED; inter_sf->reuse_inter_intra_mode = 0; - inter_sf->mv_cost_upd_level = 0; + inter_sf->mv_cost_upd_level = INTERNAL_COST_UPD_SB; inter_sf->prune_inter_modes_based_on_tpl = 0; inter_sf->prune_nearmv_using_neighbors = 0; inter_sf->prune_comp_search_by_single_result = 0; @@ -1167,8 +1519,8 @@ inter_sf->txfm_rd_gate_level = 0; inter_sf->prune_inter_modes_if_skippable = 0; inter_sf->disable_masked_comp = 0; - inter_sf->reuse_best_prediction_for_part_ab = 0; inter_sf->enable_fast_compound_mode_search = 0; + inter_sf->reuse_mask_search_results = 0; } static AOM_INLINE void init_interp_sf(INTERP_FILTER_SPEED_FEATURES *interp_sf) { @@ -1181,9 +1533,10 @@ } static AOM_INLINE void init_intra_sf(INTRA_MODE_SPEED_FEATURES *intra_sf) { - intra_sf->chroma_intra_pruning_with_hog = 0; + intra_sf->dv_cost_upd_level = INTERNAL_COST_UPD_SB; intra_sf->skip_intra_in_interframe = 1; intra_sf->intra_pruning_with_hog = 0; + intra_sf->chroma_intra_pruning_with_hog = 0; intra_sf->prune_palette_search_level = 0; for (int i = 0; i < TX_SIZES; i++) { @@ -1191,6 +1544,8 @@ intra_sf->intra_uv_mode_mask[i] = UV_INTRA_ALL; } intra_sf->disable_smooth_intra = 0; + intra_sf->disable_filter_intra = 0; + intra_sf->prune_chroma_modes_using_luma_winner = 0; } static AOM_INLINE void init_tx_sf(TX_SPEED_FEATURES *tx_sf) { @@ -1288,13 +1643,19 @@ SPEED_FEATURES *const sf = &cpi->sf; const AV1EncoderConfig *const oxcf = &cpi->oxcf; - if (oxcf->mode == GOOD) { - set_good_speed_feature_framesize_dependent(cpi, sf, speed); - } else if (oxcf->mode == REALTIME) { - set_rt_speed_feature_framesize_dependent(cpi, sf, speed); + switch (oxcf->mode) { + case GOOD: + set_good_speed_feature_framesize_dependent(cpi, sf, speed); + break; + case ALLINTRA: + set_allintra_speed_feature_framesize_dependent(cpi, sf, speed); + break; + case REALTIME: + set_rt_speed_feature_framesize_dependent(cpi, sf, speed); + break; } - if (!cpi->seq_params_locked) { + if (!cpi->ppi->seq_params_locked) { cpi->common.seq_params.enable_masked_compound &= !sf->inter_sf.disable_masked_comp; } @@ -1306,9 +1667,9 @@ cpi->mv_search_params.find_fractional_mv_step = av1_return_min_sub_pixel_mv; if ((cpi->oxcf.row_mt == 1) && (cpi->oxcf.max_threads > 1)) { - if (sf->inter_sf.mv_cost_upd_level > 1) { + if (sf->inter_sf.mv_cost_upd_level < INTERNAL_COST_UPD_SBROW) { // Set mv_cost_upd_level to use row level update. - sf->inter_sf.mv_cost_upd_level = 1; + sf->inter_sf.mv_cost_upd_level = INTERNAL_COST_UPD_SBROW; } } } @@ -1333,12 +1694,19 @@ init_lpf_sf(&sf->lpf_sf); init_rt_sf(&sf->rt_sf); - if (oxcf->mode == GOOD) - set_good_speed_features_framesize_independent(cpi, sf, speed); - else if (oxcf->mode == REALTIME) - set_rt_speed_features_framesize_independent(cpi, sf, speed); + switch (oxcf->mode) { + case GOOD: + set_good_speed_features_framesize_independent(cpi, sf, speed); + break; + case ALLINTRA: + set_allintra_speed_features_framesize_independent(cpi, sf, speed); + break; + case REALTIME: + set_rt_speed_features_framesize_independent(cpi, sf, speed); + break; + } - if (!cpi->seq_params_locked) { + if (!cpi->ppi->seq_params_locked) { cpi->common.seq_params.enable_dual_filter &= !sf->interp_sf.disable_dual_filter; cpi->common.seq_params.enable_restoration &= !sf->lpf_sf.disable_lr_filter; @@ -1347,13 +1715,6 @@ (sf->inter_sf.disable_interintra_wedge_var_thresh != UINT_MAX); } - // TODO(any) Currently use_intra_txb_hash is enabled in speed 1,2 for - // intra-only encoding (key_freq_max == 0). Experiment with this speed feature - // by enabling for image encoding in speed 1 and 2. - if (cpi->oxcf.kf_cfg.key_freq_max == 0 && speed >= 1 && speed <= 2) { - sf->tx_sf.use_intra_txb_hash = 1; - } - // sf->part_sf.partition_search_breakout_dist_thr is set assuming max 64x64 // blocks. Normalise this if the blocks are bigger. if (MAX_SB_SIZE_LOG2 > 6) { @@ -1470,7 +1831,9 @@ const int is_arf2_bwd_type = cpi->gf_group.update_type[cpi->gf_group.index] == INTNL_ARF_UPDATE; - if (cpi->oxcf.mode == GOOD && speed == 0) { + if (cpi->oxcf.mode == REALTIME) return; + + if (speed == 0) { // qindex_thresh for resolution < 720p const int qindex_thresh = boosted ? 70 : (is_arf2_bwd_type ? 110 : 140); if (!is_720p_or_larger && cm->quant_params.base_qindex <= qindex_thresh) { @@ -1508,7 +1871,7 @@ } } - if (cpi->oxcf.mode == GOOD && speed >= 3) { + if (speed >= 3) { // Disable extended partitions for lower quantizers const int qindex_thresh = cm->features.allow_screen_content_tools ? 50 : 100; @@ -1517,7 +1880,7 @@ } } - if (cpi->oxcf.mode == GOOD && speed >= 4) { + if (speed >= 4) { // Disable extended partitions for lower quantizers const int qindex_thresh = boosted ? 80 : 120; if (cm->quant_params.base_qindex <= qindex_thresh && @@ -1526,7 +1889,7 @@ } } - if (cpi->oxcf.mode == GOOD && speed >= 5) { + if (speed >= 5) { const int qindex_thresh = boosted ? 100 : 160; if (cm->quant_params.base_qindex <= qindex_thresh && !frame_is_intra_only(&cpi->common)) { @@ -1534,7 +1897,7 @@ } } - if (cpi->oxcf.mode == GOOD && (speed <= 2)) { + if (speed <= 2) { if (!is_stat_generation_stage(cpi)) { // Use faster full-pel motion search for high quantizers. // Also use reduced total search range for low resolutions at high
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h index 6a4ea3c..1a4d75b 100644 --- a/av1/encoder/speed_features.h +++ b/av1/encoder/speed_features.h
@@ -226,7 +226,8 @@ int fast_intra_tx_type_search; int fast_inter_tx_type_search; - // prune two least frequently chosen transforms for each intra mode + // Prune less likely chosen transforms for each intra mode. The speed + // feature ranges from 0 to 2, for different speed / compression trade offs. int use_reduced_intra_txset; // Use a skip flag prediction model to detect blocks with skip = 1 early @@ -286,8 +287,23 @@ SUPERRES_AUTO_DUAL, // Tries no superres and q-based superres ratios SUPERRES_AUTO_SOLO, // Only apply the q-based superres ratio } UENUM1BYTE(SUPERRES_AUTO_SEARCH_TYPE); - /*!\endcond */ + +/*!\enum INTERNAL_COST_UPDATE_TYPE + * \brief This enum decides internally how often to update the entropy costs + * + * INTERNAL_COST_UPD_TYPE is similar to \ref COST_UPDATE_TYPE but has slightly + * more flexibility in update frequency. This enum is separate from \ref + * COST_UPDATE_TYPE because although \ref COST_UPDATE_TYPE is not exposed, its + * values are public so it cannot be modified without breaking public API. + */ +typedef enum { + INTERNAL_COST_UPD_OFF, /*!< Turn off cost updates. */ + INTERNAL_COST_UPD_SBROW_SET, /*!< Update every row_set of height 256 pixs. */ + INTERNAL_COST_UPD_SBROW, /*!< Update every sb rows inside a tile. */ + INTERNAL_COST_UPD_SB, /*!< Update every sb. */ +} INTERNAL_COST_UPDATE_TYPE; + /*! * \brief Sequence/frame level speed vs quality features */ @@ -374,6 +390,9 @@ // Support compound predictions. int allow_compound_pred; + + // Calculate rate and distortion based on Y plane only. + int use_y_only_rate_distortion; } TPL_SPEED_FEATURES; typedef struct GLOBAL_MOTION_SPEED_FEATURES { @@ -503,6 +522,14 @@ // 1 : pruning based on neighbour block information // 2 : prune always int prune_sub_8x8_partition_level; + + // Prune rectangular split based on simple motion search split/no_split score. + // 0: disable pruning, 1: enable pruning + int simple_motion_search_rect_split; + + // Reuse the best prediction modes found in PARTITION_SPLIT and PARTITION_RECT + // when encoding PARTITION_AB. + int reuse_best_prediction_for_part_ab; } PARTITION_SPEED_FEATURES; typedef struct MV_SPEED_FEATURES { @@ -572,7 +599,10 @@ int disable_extensive_joint_motion_search; // Enable second best mv check in joint mv search. - int enable_second_mv; + // 0: allow second MV (use rd cost as the metric) + // 1: use var as the metric + // 2: disable second MV + int disable_second_mv; } MV_SPEED_FEATURES; typedef struct INTER_MODE_SPEED_FEATURES { @@ -598,7 +628,7 @@ int prune_inter_modes_if_skippable; // Drop less likely to be picked reference frames in the RD search. - // Has six levels for now: 0, 1, 2, 3, 4 and 5, where higher levels prune + // Has seven levels for now: 0, 1, 2, 3, 4, 5 and 6 where higher levels prune // more aggressively than lower ones. (0 means no pruning). int selective_ref_frame; @@ -711,12 +741,9 @@ // Decide when and how to use joint_comp. DIST_WTD_COMP_FLAG use_dist_wtd_comp_flag; - // To skip cost update for mv. - // mv_cost_upd_level indicates the aggressiveness of skipping. - // 0: update happens at each sb level. - // 1: update happens once for each sb row. - // 2: update happens once for a set of rows. - int mv_cost_upd_level; + // Clip the frequency of updating the mv cost. + INTERNAL_COST_UPDATE_TYPE mv_cost_upd_level; + // Prune inter modes based on tpl stats // 0 : no pruning // 1 - 3 indicate increasing aggressiveness in order. @@ -739,12 +766,11 @@ // Enable/disable masked compound. int disable_masked_comp; - // Reuse the best prediction modes found in PARTITION_SPLIT and PARTITION_RECT - // when encoding PARTITION_AB. - int reuse_best_prediction_for_part_ab; - // Enable/disable the fast compound mode search. int enable_fast_compound_mode_search; + + // Reuse masked compound type search results + int reuse_mask_search_results; } INTER_MODE_SPEED_FEATURES; typedef struct INTERP_FILTER_SPEED_FEATURES { @@ -781,15 +807,22 @@ // Prune intra mode candidates based on source block histogram of gradient. // Applies to luma plane only. + // Feasible values are 0..4. The feature is disabled for 0. An increasing + // value indicates more aggressive pruning threshold. int intra_pruning_with_hog; // Prune intra mode candidates based on source block histogram of gradient. // Applies to chroma plane only. + // Feasible values are 0..4. The feature is disabled for 0. An increasing + // value indicates more aggressive pruning threshold. int chroma_intra_pruning_with_hog; // Enable/disable smooth intra modes. int disable_smooth_intra; + // Enable/disable filter intra modes. + int disable_filter_intra; + // prune palette search // 0: No pruning // 1: Perform coarse search to prune the palette colors. For winner colors, @@ -798,6 +831,15 @@ // colors to remaining colors) and terminate the search if current number of // palette colors is not the winner. int prune_palette_search_level; + + // Prune chroma intra modes based on luma intra mode winner. + // 0: No pruning + // 1: Prune chroma intra modes other than UV_DC_PRED, UV_SMOOTH_PRED, + // UV_CFL_PRED and the mode that corresponds to luma intra mode winner. + int prune_chroma_modes_using_luma_winner; + + // Clip the frequency of updating the mv cost for intrabc. + INTERNAL_COST_UPDATE_TYPE dv_cost_upd_level; } INTRA_MODE_SPEED_FEATURES; typedef struct TX_SPEED_FEATURES { @@ -1018,8 +1060,9 @@ // If set forces interpolation filter to EIGHTTAP_REGULAR int skip_interp_filter_search; - // Use hybrid (rd for bsize < 16x16, otherwise nonrd) intra search for intra - // only frames. + // For nonrd mode: use hybrid (rd for bsize < 16x16, otherwise nonrd) + // intra mode search for intra only frames. If set to 0 then nonrd pick + // intra is used for all blocks. int hybrid_intra_pickmode; // Compute variance/sse on source difference, prior to encoding superblock.
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c index 1226e61..676e110 100644 --- a/av1/encoder/temporal_filter.c +++ b/av1/encoder/temporal_filter.c
@@ -937,7 +937,7 @@ int num_before = 0; // Number of filtering frames before the to-filter frame. int num_after = 0; // Number of filtering frames after the to-filer frame. const int lookahead_depth = - av1_lookahead_depth(cpi->lookahead, cpi->compressor_stage); + av1_lookahead_depth(cpi->ppi->lookahead, cpi->compressor_stage); int arf_src_offset = cpi->gf_group.arf_src_offset[cpi->gf_group.index]; const FRAME_TYPE frame_type = cpi->gf_group.frame_type[cpi->gf_group.index]; @@ -957,7 +957,7 @@ // Estimate noises for each plane. const struct lookahead_entry *to_filter_buf = av1_lookahead_peek( - cpi->lookahead, filter_frame_lookahead_idx, cpi->compressor_stage); + cpi->ppi->lookahead, filter_frame_lookahead_idx, cpi->compressor_stage); assert(to_filter_buf != NULL); const YV12_BUFFER_CONFIG *to_filter_frame = &to_filter_buf->img; const int num_planes = av1_num_planes(&cpi->common); @@ -1042,7 +1042,7 @@ for (int frame = 0; frame < num_frames; ++frame) { const int lookahead_idx = frame - num_before + filter_frame_lookahead_idx; struct lookahead_entry *buf = av1_lookahead_peek( - cpi->lookahead, lookahead_idx, cpi->compressor_stage); + cpi->ppi->lookahead, lookahead_idx, cpi->compressor_stage); assert(buf != NULL); frames[frame] = &buf->img; }
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c index 43ac270..7e16b29 100644 --- a/av1/encoder/tokenize.c +++ b/av1/encoder/tokenize.c
@@ -51,7 +51,7 @@ color_map, plane_block_width, i, j, &color_new_idx); assert(color_new_idx >= 0 && color_new_idx < n); if (calc_rate) { - this_rate += (*color_cost)[palette_size_idx][color_ctx][color_new_idx]; + this_rate += color_cost[palette_size_idx][color_ctx][color_new_idx]; } else { (*t)->token = color_new_idx; (*t)->color_ctx = color_ctx; @@ -82,8 +82,8 @@ 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; - params->color_cost = plane ? &x->mode_costs.palette_uv_color_cost - : &x->mode_costs.palette_y_color_cost; + 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]; av1_get_block_dimensions(bsize, plane, xd, ¶ms->plane_width, NULL, ¶ms->rows, ¶ms->cols); @@ -155,16 +155,18 @@ const int bsw = tx_size_wide_unit[sub_txs]; const int bsh = tx_size_high_unit[sub_txs]; const int step = bsw * bsh; + const int row_end = + AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); + const int col_end = + AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); assert(bsw > 0 && bsh > 0); - for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { - for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { - const int offsetr = blk_row + row; + for (int row = 0; row < row_end; row += bsh) { + const int offsetr = blk_row + row; + for (int col = 0; col < col_end; col += bsw) { const int offsetc = blk_col + col; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; - tokenize_vartx(td, sub_txs, plane_bsize, offsetr, offsetc, block, plane, arg); block += step;
diff --git a/av1/encoder/tokenize.h b/av1/encoder/tokenize.h index d5e1dfd..51eb28c 100644 --- a/av1/encoder/tokenize.h +++ b/av1/encoder/tokenize.h
@@ -20,9 +20,29 @@ extern "C" { #endif +// The token and color_ctx members of the TokenExtra structure are used +// to store the indices of color and color context of each pixel in +// case of palette mode. +// 1) token can take values in the range of [0, 7] as maximum number of possible +// colors is 8 (PALETTE_COLORS). Hence token requires 3 bits (unsigned). +// 2) The reserved field (1-bit) is positioned such that color_ctx occupies the +// most significant bits and token occupies the least significant bits of the +// byte. Thus accesses to token and color_ctx are optimal. If TokenExtra is +// defined as: +// typedef struct { +// int8_t color_ctx : 4; +// uint8_t token : 3; +// } TokenExtra; +// then read of color_ctx requires an extra left shift to facilitate sign +// extension and write of token requires an extra masking. +// 3) color_ctx can take 5 (PALETTE_COLOR_INDEX_CONTEXTS) valid values, i.e., +// from 0 to 4. As per the current implementation it can take values in the +// range of [-1, 4]. Here -1 corresponds to invalid color index context and is +// used for default initialization. Hence color_ctx requires 4 bits (signed). typedef struct { - int8_t color_ctx; - uint8_t token; + uint8_t token : 3; + uint8_t reserved : 1; + int8_t color_ctx : 4; } TokenExtra; typedef struct {
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c index 24e27ee..22f6d98 100644 --- a/av1/encoder/tpl_model.c +++ b/av1/encoder/tpl_model.c
@@ -35,6 +35,41 @@ #include "av1/encoder/reconinter_enc.h" #include "av1/encoder/tpl_model.h" +static AOM_INLINE void tpl_stats_record_txfm_block(TplTxfmStats *tpl_txfm_stats, + const tran_low_t *coeff, + int coeff_num) { + aom_clear_system_state(); + // For transform larger than 16x16, the scale of coeff need to be adjusted. + // It's not LOSSLESS_Q_STEP. + assert(coeff_num <= 256); + for (int i = 0; i < coeff_num; ++i) { + tpl_txfm_stats->abs_coeff_sum[i] += abs(coeff[i]) / (double)LOSSLESS_Q_STEP; + } + ++tpl_txfm_stats->txfm_block_count; +} + +static AOM_INLINE void tpl_stats_update_abs_coeff_mean( + TplParams *tpl_data, TplTxfmStats *tpl_txfm_stats) { + aom_clear_system_state(); + TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_data->frame_idx]; + tpl_frame->txfm_block_count = tpl_txfm_stats->txfm_block_count; + for (int i = 0; i < tpl_frame->coeff_num; ++i) { + tpl_frame->abs_coeff_sum[i] = tpl_txfm_stats->abs_coeff_sum[i]; + tpl_frame->abs_coeff_mean[i] = + tpl_frame->abs_coeff_sum[i] / tpl_txfm_stats->txfm_block_count; + } +} + +void av1_tpl_stats_init_txfm_stats(TplDepFrame *tpl_frame, int tpl_bsize_1d) { + aom_clear_system_state(); + tpl_frame->txfm_block_count = 0; + tpl_frame->coeff_num = tpl_bsize_1d * tpl_bsize_1d; + memset(tpl_frame->abs_coeff_sum, 0, sizeof(tpl_frame->abs_coeff_sum)); + assert(sizeof(tpl_frame->abs_coeff_mean) / + sizeof(tpl_frame->abs_coeff_mean[0]) == + tpl_frame->coeff_num); +} + static AOM_INLINE void get_quantize_error(const MACROBLOCK *x, int plane, const tran_low_t *coeff, tran_low_t *qcoeff, @@ -74,6 +109,63 @@ *sse = AOMMAX(*sse, 1); } +static AOM_INLINE void set_tpl_stats_block_size(uint8_t *block_mis_log2, + uint8_t *tpl_bsize_1d) { + // tpl stats bsize: 2 means 16x16 + *block_mis_log2 = 2; + // Block size used in tpl motion estimation + *tpl_bsize_1d = 16; + // MIN_TPL_BSIZE_1D = 16; + assert(*tpl_bsize_1d >= 16); +} + +void av1_setup_tpl_buffers(AV1_COMMON *const cm, TplParams *const tpl_data, + int lag_in_frames) { + CommonModeInfoParams *const mi_params = &cm->mi_params; + set_tpl_stats_block_size(&tpl_data->tpl_stats_block_mis_log2, + &tpl_data->tpl_bsize_1d); + const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2; + tpl_data->border_in_pixels = + ALIGN_POWER_OF_TWO(tpl_data->tpl_bsize_1d + 2 * AOM_INTERP_EXTEND, 5); + + for (int frame = 0; frame < MAX_LENGTH_TPL_FRAME_STATS; ++frame) { + const int mi_cols = + ALIGN_POWER_OF_TWO(mi_params->mi_cols, MAX_MIB_SIZE_LOG2); + const int mi_rows = + ALIGN_POWER_OF_TWO(mi_params->mi_rows, MAX_MIB_SIZE_LOG2); + TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame]; + tpl_frame->is_valid = 0; + tpl_frame->width = mi_cols >> block_mis_log2; + tpl_frame->height = mi_rows >> block_mis_log2; + tpl_frame->stride = tpl_data->tpl_stats_buffer[frame].width; + tpl_frame->mi_rows = mi_params->mi_rows; + tpl_frame->mi_cols = mi_params->mi_cols; + av1_tpl_stats_init_txfm_stats(tpl_frame, tpl_data->tpl_bsize_1d); + } + tpl_data->tpl_frame = &tpl_data->tpl_stats_buffer[REF_FRAMES + 1]; + + // If lag_in_frames <= 1, TPL module is not invoked. Hence tpl recon and + // stats buffers are not allocated. + if (lag_in_frames <= 1) return; + + // TODO(aomedia:2873): Explore the allocation of tpl buffers based on + // lag_in_frames. + for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) { + CHECK_MEM_ERROR( + cm, tpl_data->tpl_stats_pool[frame], + aom_calloc(tpl_data->tpl_stats_buffer[frame].width * + tpl_data->tpl_stats_buffer[frame].height, + sizeof(*tpl_data->tpl_stats_buffer[frame].tpl_stats_ptr))); + if (aom_alloc_frame_buffer( + &tpl_data->tpl_rec_pool[frame], cm->width, cm->height, + cm->seq_params.subsampling_x, cm->seq_params.subsampling_y, + cm->seq_params.use_highbitdepth, tpl_data->border_in_pixels, + cm->features.byte_alignment)) + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate frame buffer"); + } +} + static AOM_INLINE void tpl_fwd_txfm(const int16_t *src_diff, int bw, tran_low_t *coeff, TX_SIZE tx_size, int bit_depth, int is_hbd) { @@ -229,12 +321,13 @@ tran_low_t *qcoeff, tran_low_t *dqcoeff, AV1_COMMON *cm, MACROBLOCK *x, const YV12_BUFFER_CONFIG *ref_frame_ptr[2], uint8_t *rec_buffer_pool[3], const int rec_stride_pool[3], TX_SIZE tx_size, PREDICTION_MODE best_mode, - int mi_row, int mi_col) { + int mi_row, int mi_col, int use_y_only_rate_distortion) { *rate_cost = 0; *recon_error = 1; MACROBLOCKD *xd = &x->e_mbd; int is_compound = (best_mode == NEW_NEWMV); + int num_planes = use_y_only_rate_distortion ? 1 : MAX_MB_PLANE; uint8_t *src_buffer_pool[MAX_MB_PLANE] = { xd->cur_buf->y_buffer, @@ -250,7 +343,7 @@ const int_interpfilters kernel = av1_broadcast_interp_filter(EIGHTTAP_REGULAR); - for (int plane = 0; plane < MAX_MB_PLANE; ++plane) { + for (int plane = 0; plane < num_planes; ++plane) { struct macroblockd_plane *pd = &xd->plane[plane]; BLOCK_SIZE bsize_plane = ss_size_lookup[txsize_to_bsize[tx_size]][pd->subsampling_x] @@ -317,9 +410,10 @@ } } -static AOM_INLINE void mode_estimation(AV1_COMP *cpi, MACROBLOCK *x, int mi_row, - int mi_col, BLOCK_SIZE bsize, - TX_SIZE tx_size, +static AOM_INLINE void mode_estimation(AV1_COMP *cpi, + TplTxfmStats *tpl_txfm_stats, + MACROBLOCK *x, int mi_row, int mi_col, + BLOCK_SIZE bsize, TX_SIZE tx_size, TplDepStats *tpl_stats) { AV1_COMMON *cm = &cpi->common; const GF_GROUP *gf_group = &cpi->gf_group; @@ -348,6 +442,7 @@ mi_row * MI_SIZE * tpl_frame->rec_picture->y_stride + mi_col * MI_SIZE; uint8_t *dst_buffer = tpl_frame->rec_picture->y_buffer + dst_mb_offset; int dst_buffer_stride = tpl_frame->rec_picture->y_stride; + int use_y_only_rate_distortion = cpi->sf.tpl_sf.use_y_only_rate_distortion; uint8_t *rec_buffer_pool[3] = { tpl_frame->rec_picture->y_buffer, @@ -619,7 +714,8 @@ int_mv tmp_mv[2] = { single_mv[rf_idx0], single_mv[rf_idx1] }; int rate_mv; - av1_joint_motion_search(cpi, x, bsize, tmp_mv, NULL, 0, &rate_mv, 1); + av1_joint_motion_search(cpi, x, bsize, tmp_mv, NULL, 0, &rate_mv, + !cpi->sf.mv_sf.disable_second_mv); for (int ref = 0; ref < 2; ++ref) { struct buf_2d ref_buf = { NULL, ref_frame_ptr[ref]->y_buffer, @@ -668,7 +764,8 @@ int rate_cost = 1; get_rate_distortion(&rate_cost, &recon_error, src_diff, coeff, qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool, - rec_stride_pool, tx_size, best_mode, mi_row, mi_col); + rec_stride_pool, tx_size, best_mode, mi_row, mi_col, + use_y_only_rate_distortion); tpl_stats->srcrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2; } @@ -693,7 +790,10 @@ : NULL; get_rate_distortion(&rate_cost, &recon_error, src_diff, coeff, qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool, - rec_stride_pool, tx_size, best_mode, mi_row, mi_col); + rec_stride_pool, tx_size, best_mode, mi_row, mi_col, + use_y_only_rate_distortion); + + tpl_stats_record_txfm_block(tpl_txfm_stats, coeff, tpl_frame->coeff_num); tpl_stats->recrf_dist = recon_error << (TPL_DEP_COST_SCALE_LOG2); tpl_stats->recrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2; @@ -711,7 +811,8 @@ tpl_data->src_ref_frame[comp_ref_frames[best_cmp_rf_idx][1]]; get_rate_distortion(&rate_cost, &recon_error, src_diff, coeff, qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool, - rec_stride_pool, tx_size, best_mode, mi_row, mi_col); + rec_stride_pool, tx_size, best_mode, mi_row, mi_col, + use_y_only_rate_distortion); tpl_stats->cmp_recrf_dist[0] = recon_error << TPL_DEP_COST_SCALE_LOG2; tpl_stats->cmp_recrf_rate[0] = rate_cost << TPL_DEP_COST_SCALE_LOG2; @@ -731,7 +832,8 @@ ref_frame_ptr[1] = tpl_data->ref_frame[comp_ref_frames[best_cmp_rf_idx][1]]; get_rate_distortion(&rate_cost, &recon_error, src_diff, coeff, qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool, - rec_stride_pool, tx_size, best_mode, mi_row, mi_col); + rec_stride_pool, tx_size, best_mode, mi_row, mi_col, + use_y_only_rate_distortion); tpl_stats->cmp_recrf_dist[1] = recon_error << TPL_DEP_COST_SCALE_LOG2; tpl_stats->cmp_recrf_rate[1] = rate_cost << TPL_DEP_COST_SCALE_LOG2; @@ -809,8 +911,8 @@ break; default: assert(0); } - - return width * height; + int overlap_area = width * height; + return overlap_area; } int av1_tpl_ptr_pos(int mi_row, int mi_col, int stride, uint8_t right_shift) { @@ -849,6 +951,7 @@ static AOM_INLINE void tpl_model_update_b(TplParams *const tpl_data, int mi_row, int mi_col, const BLOCK_SIZE bsize, int frame_idx, int ref) { + aom_clear_system_state(); TplDepFrame *tpl_frame_ptr = &tpl_data->tpl_frame[frame_idx]; TplDepStats *tpl_ptr = tpl_frame_ptr->tpl_stats_ptr; TplDepFrame *tpl_frame = tpl_data->tpl_frame; @@ -907,101 +1010,45 @@ grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize); int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height; int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width; - const int step = 1 << block_mis_log2; - - for (int idy = 0; idy < mi_height; idy += step) { - for (int idx = 0; idx < mi_width; idx += step) { - TplDepStats *des_stats = &ref_stats_ptr[av1_tpl_ptr_pos( - ref_mi_row + idy, ref_mi_col + idx, ref_tpl_frame->stride, - block_mis_log2)]; - des_stats->mc_dep_dist += - ((cur_dep_dist + mc_dep_dist) * overlap_area) / pix_num; - des_stats->mc_dep_rate += - ((delta_rate + mc_dep_rate) * overlap_area) / pix_num; - - assert(overlap_area >= 0); - } - } + assert((1 << block_mis_log2) == mi_height); + assert((1 << block_mis_log2) == mi_width); + TplDepStats *des_stats = &ref_stats_ptr[av1_tpl_ptr_pos( + ref_mi_row, ref_mi_col, ref_tpl_frame->stride, block_mis_log2)]; + des_stats->mc_dep_dist += + ((cur_dep_dist + mc_dep_dist) * overlap_area) / pix_num; + des_stats->mc_dep_rate += + ((delta_rate + mc_dep_rate) * overlap_area) / pix_num; } } } static AOM_INLINE void tpl_model_update(TplParams *const tpl_data, int mi_row, - int mi_col, const BLOCK_SIZE bsize, - int frame_idx) { - const int mi_height = mi_size_high[bsize]; - const int mi_width = mi_size_wide[bsize]; - const int step = 1 << tpl_data->tpl_stats_block_mis_log2; + int mi_col, int frame_idx) { const BLOCK_SIZE tpl_stats_block_size = convert_length_to_bsize(MI_SIZE << tpl_data->tpl_stats_block_mis_log2); - - for (int idy = 0; idy < mi_height; idy += step) { - for (int idx = 0; idx < mi_width; idx += step) { - tpl_model_update_b(tpl_data, mi_row + idy, mi_col + idx, - tpl_stats_block_size, frame_idx, 0); - tpl_model_update_b(tpl_data, mi_row + idy, mi_col + idx, - tpl_stats_block_size, frame_idx, 1); - } - } + tpl_model_update_b(tpl_data, mi_row, mi_col, tpl_stats_block_size, frame_idx, + 0); + tpl_model_update_b(tpl_data, mi_row, mi_col, tpl_stats_block_size, frame_idx, + 1); } static AOM_INLINE void tpl_model_store(TplDepStats *tpl_stats_ptr, int mi_row, - int mi_col, BLOCK_SIZE bsize, int stride, + int mi_col, int stride, const TplDepStats *src_stats, uint8_t block_mis_log2) { - const int mi_height = mi_size_high[bsize]; - const int mi_width = mi_size_wide[bsize]; - const int step = 1 << block_mis_log2; - const int div = (mi_height >> block_mis_log2) * (mi_width >> block_mis_log2); - - int64_t intra_cost = src_stats->intra_cost / div; - int64_t inter_cost = src_stats->inter_cost / div; - int64_t srcrf_dist = src_stats->srcrf_dist / div; - int64_t recrf_dist = src_stats->recrf_dist / div; - int64_t srcrf_rate = src_stats->srcrf_rate / div; - int64_t recrf_rate = src_stats->recrf_rate / div; - int64_t cmp_recrf_dist[2] = { - src_stats->cmp_recrf_dist[0] / div, - src_stats->cmp_recrf_dist[1] / div, - }; - int64_t cmp_recrf_rate[2] = { - src_stats->cmp_recrf_rate[0] / div, - src_stats->cmp_recrf_rate[1] / div, - }; - - intra_cost = AOMMAX(1, intra_cost); - inter_cost = AOMMAX(1, inter_cost); - srcrf_dist = AOMMAX(1, srcrf_dist); - recrf_dist = AOMMAX(1, recrf_dist); - srcrf_rate = AOMMAX(1, srcrf_rate); - recrf_rate = AOMMAX(1, recrf_rate); - cmp_recrf_dist[0] = AOMMAX(1, cmp_recrf_dist[0]); - cmp_recrf_dist[1] = AOMMAX(1, cmp_recrf_dist[1]); - cmp_recrf_rate[0] = AOMMAX(1, cmp_recrf_rate[0]); - cmp_recrf_rate[1] = AOMMAX(1, cmp_recrf_rate[1]); - - for (int idy = 0; idy < mi_height; idy += step) { - TplDepStats *tpl_ptr = &tpl_stats_ptr[av1_tpl_ptr_pos( - mi_row + idy, mi_col, stride, block_mis_log2)]; - for (int idx = 0; idx < mi_width; idx += step) { - tpl_ptr->intra_cost = intra_cost; - tpl_ptr->inter_cost = inter_cost; - tpl_ptr->srcrf_dist = srcrf_dist; - tpl_ptr->recrf_dist = recrf_dist; - tpl_ptr->srcrf_rate = srcrf_rate; - tpl_ptr->recrf_rate = recrf_rate; - tpl_ptr->cmp_recrf_dist[0] = cmp_recrf_dist[0]; - tpl_ptr->cmp_recrf_dist[1] = cmp_recrf_dist[1]; - tpl_ptr->cmp_recrf_rate[0] = cmp_recrf_rate[0]; - tpl_ptr->cmp_recrf_rate[1] = cmp_recrf_rate[1]; - memcpy(tpl_ptr->mv, src_stats->mv, sizeof(tpl_ptr->mv)); - memcpy(tpl_ptr->pred_error, src_stats->pred_error, - sizeof(tpl_ptr->pred_error)); - tpl_ptr->ref_frame_index[0] = src_stats->ref_frame_index[0]; - tpl_ptr->ref_frame_index[1] = src_stats->ref_frame_index[1]; - ++tpl_ptr; - } - } + int index = av1_tpl_ptr_pos(mi_row, mi_col, stride, block_mis_log2); + TplDepStats *tpl_ptr = &tpl_stats_ptr[index]; + *tpl_ptr = *src_stats; + tpl_ptr->intra_cost = AOMMAX(1, tpl_ptr->intra_cost); + tpl_ptr->inter_cost = AOMMAX(1, tpl_ptr->inter_cost); + tpl_ptr->srcrf_dist = AOMMAX(1, tpl_ptr->srcrf_dist); + tpl_ptr->recrf_dist = AOMMAX(1, tpl_ptr->recrf_dist); + tpl_ptr->srcrf_rate = AOMMAX(1, tpl_ptr->srcrf_rate); + tpl_ptr->recrf_rate = AOMMAX(1, tpl_ptr->recrf_rate); + tpl_ptr->cmp_recrf_dist[0] = AOMMAX(1, tpl_ptr->cmp_recrf_dist[0]); + tpl_ptr->cmp_recrf_dist[1] = AOMMAX(1, tpl_ptr->cmp_recrf_dist[1]); + tpl_ptr->cmp_recrf_rate[0] = AOMMAX(1, tpl_ptr->cmp_recrf_rate[0]); + tpl_ptr->cmp_recrf_rate[1] = AOMMAX(1, tpl_ptr->cmp_recrf_rate[1]); } // Reset the ref and source frame pointers of tpl_data. @@ -1036,6 +1083,7 @@ ThreadData *td = &cpi->td; MACROBLOCK *x = &td->mb; MACROBLOCKD *xd = &x->e_mbd; + TplTxfmStats *tpl_txfm_stats = &td->tpl_txfm_stats; tpl_data->frame_idx = frame_idx; tpl_reset_src_ref_frames(tpl_data); av1_tile_init(&xd->tile, cm, 0, 0); @@ -1113,12 +1161,15 @@ tpl_frame->base_rdmult = av1_compute_rd_mult_based_on_qindex(cpi, pframe_qindex) / 6; + + memset(tpl_txfm_stats, 0, sizeof(*tpl_txfm_stats)); } // This function stores the motion estimation dependencies of all the blocks in // a row -void av1_mc_flow_dispenser_row(AV1_COMP *cpi, MACROBLOCK *x, int mi_row, - BLOCK_SIZE bsize, TX_SIZE tx_size) { +void av1_mc_flow_dispenser_row(AV1_COMP *cpi, TplTxfmStats *tpl_txfm_stats, + MACROBLOCK *x, int mi_row, BLOCK_SIZE bsize, + TX_SIZE tx_size) { AV1_COMMON *const cm = &cpi->common; MultiThreadInfo *const mt_info = &cpi->mt_info; AV1TplRowMultiThreadInfo *const tpl_row_mt = &mt_info->tpl_row_mt; @@ -1131,6 +1182,8 @@ const int tplb_cols_in_tile = ROUND_POWER_OF_TWO(mi_params->mi_cols, mi_size_wide_log2[bsize]); const int tplb_row = ROUND_POWER_OF_TWO(mi_row, mi_size_high_log2[bsize]); + assert(mi_size_high[bsize] == (1 << tpl_data->tpl_stats_block_mis_log2)); + assert(mi_size_wide[bsize] == (1 << tpl_data->tpl_stats_block_mis_log2)); for (int mi_col = 0, tplb_col_in_tile = 0; mi_col < mi_params->mi_cols; mi_col += mi_width, tplb_col_in_tile++) { @@ -1144,12 +1197,12 @@ xd->mb_to_left_edge = -GET_MV_SUBPEL(mi_col * MI_SIZE); xd->mb_to_right_edge = GET_MV_SUBPEL(mi_params->mi_cols - mi_width - mi_col); - mode_estimation(cpi, x, mi_row, mi_col, bsize, tx_size, &tpl_stats); + mode_estimation(cpi, tpl_txfm_stats, x, mi_row, mi_col, bsize, tx_size, + &tpl_stats); // Motion flow dependency dispenser. - tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize, - tpl_frame->stride, &tpl_stats, - tpl_data->tpl_stats_block_mis_log2); + tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, tpl_frame->stride, + &tpl_stats, tpl_data->tpl_stats_block_mis_log2); (*tpl_row_mt->sync_write_ptr)(&tpl_data->tpl_mt_sync, tplb_row, tplb_col_in_tile, tplb_cols_in_tile); } @@ -1171,7 +1224,8 @@ xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_row * MI_SIZE); xd->mb_to_bottom_edge = GET_MV_SUBPEL((mi_params->mi_rows - mi_height - mi_row) * MI_SIZE); - av1_mc_flow_dispenser_row(cpi, x, mi_row, bsize, tx_size); + av1_mc_flow_dispenser_row(cpi, &td->tpl_txfm_stats, x, mi_row, bsize, + tx_size); } } @@ -1182,11 +1236,13 @@ const BLOCK_SIZE bsize = convert_length_to_bsize(tpl_data->tpl_bsize_1d); const int mi_height = mi_size_high[bsize]; const int mi_width = mi_size_wide[bsize]; + assert(mi_height == (1 << tpl_data->tpl_stats_block_mis_log2)); + assert(mi_width == (1 << tpl_data->tpl_stats_block_mis_log2)); for (int mi_row = 0; mi_row < cm->mi_params.mi_rows; mi_row += mi_height) { for (int mi_col = 0; mi_col < cm->mi_params.mi_cols; mi_col += mi_width) { if (frame_idx) { - tpl_model_update(tpl_data, mi_row, mi_col, bsize, frame_idx); + tpl_model_update(tpl_data, mi_row, mi_col, frame_idx); } } } @@ -1250,11 +1306,11 @@ struct lookahead_entry *buf; if (gf_index == cur_frame_idx) { - buf = av1_lookahead_peek(cpi->lookahead, lookahead_index, + buf = av1_lookahead_peek(cpi->ppi->lookahead, lookahead_index, cpi->compressor_stage); tpl_frame->gf_picture = gop_eval ? &buf->img : frame_input->source; } else { - buf = av1_lookahead_peek(cpi->lookahead, lookahead_index, + buf = av1_lookahead_peek(cpi->ppi->lookahead, lookahead_index, cpi->compressor_stage); if (buf == NULL) break; tpl_frame->gf_picture = &buf->img; @@ -1322,7 +1378,7 @@ int lookahead_index = frame_display_index - anc_frame_offset; struct lookahead_entry *buf = av1_lookahead_peek( - cpi->lookahead, lookahead_index, cpi->compressor_stage); + cpi->ppi->lookahead, lookahead_index, cpi->compressor_stage); if (buf == NULL) break; @@ -1373,7 +1429,10 @@ } void av1_init_tpl_stats(TplParams *const tpl_data) { - for (int frame_idx = 0; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) { + int frame_idx; + set_tpl_stats_block_size(&tpl_data->tpl_stats_block_mis_log2, + &tpl_data->tpl_bsize_1d); + for (frame_idx = 0; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) { TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame_idx]; if (tpl_data->tpl_stats_pool[frame_idx] == NULL) continue; memset(tpl_data->tpl_stats_pool[frame_idx], 0, @@ -1381,6 +1440,10 @@ sizeof(*tpl_frame->tpl_stats_ptr)); tpl_frame->is_valid = 0; } + for (frame_idx = 0; frame_idx < MAX_LENGTH_TPL_FRAME_STATS; ++frame_idx) { + TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame_idx]; + av1_tpl_stats_init_txfm_stats(tpl_frame, tpl_data->tpl_bsize_1d); + } } int av1_tpl_setup_stats(AV1_COMP *cpi, int gop_eval, @@ -1439,7 +1502,7 @@ if (frame_params->frame_type == KEY_FRAME) { av1_init_mv_probs(cm); } - av1_fill_mv_costs(cm->fc, cm->features.cur_frame_force_integer_mv, + av1_fill_mv_costs(&cm->fc->nmvc, cm->features.cur_frame_force_integer_mv, cm->features.allow_high_precision_mv, cpi->td.mb.mv_costs); // Backward propagation from tpl_group_frames to 1. @@ -1450,13 +1513,14 @@ continue; init_mc_flow_dispenser(cpi, frame_idx, pframe_qindex); - if (mt_info->num_workers > 1 && !cpi->sf.tpl_sf.allow_compound_pred) { + if (mt_info->num_workers > 1) { tpl_row_mt->sync_read_ptr = av1_tpl_row_mt_sync_read; tpl_row_mt->sync_write_ptr = av1_tpl_row_mt_sync_write; av1_mc_flow_dispenser_mt(cpi); } else { mc_flow_dispenser(cpi); } + tpl_stats_update_abs_coeff_mean(tpl_data, &cpi->td.tpl_txfm_stats); aom_extend_frame_borders(tpl_data->tpl_frame[frame_idx].rec_picture, av1_num_planes(cm)); @@ -1477,6 +1541,13 @@ cm->current_frame.frame_type = frame_params->frame_type; cm->show_frame = frame_params->show_frame; +#if CONFIG_COLLECT_COMPONENT_TIMING + // Record the time if the function returns. + if (cpi->common.tiles.large_scale || gf_group->max_layer_depth_allowed == 0 || + !gop_eval) + end_timing(cpi, av1_tpl_setup_stats_time); +#endif + if (cpi->common.tiles.large_scale) return 0; if (gf_group->max_layer_depth_allowed == 0) return 1; if (!gop_eval) return 0;
diff --git a/av1/encoder/tpl_model.h b/av1/encoder/tpl_model.h index b4bb377..49f1605 100644 --- a/av1/encoder/tpl_model.h +++ b/av1/encoder/tpl_model.h
@@ -82,6 +82,11 @@ #define MAX_TPL_EXTEND (MAX_LAG_BUFFERS - MAX_GF_INTERVAL) #define TPL_DEP_COST_SCALE_LOG2 4 +typedef struct TplTxfmStats { + double abs_coeff_sum[256]; // Assume we are using 16x16 transform block + int txfm_block_count; +} TplTxfmStats; + typedef struct TplDepStats { int64_t intra_cost; int64_t inter_cost; @@ -111,6 +116,10 @@ int mi_cols; int base_rdmult; uint32_t frame_display_index; + double abs_coeff_sum[256]; // Assume we are using 16x16 transform block + double abs_coeff_mean[256]; + int coeff_num; // number of coefficients in a transform block + int txfm_block_count; } TplDepFrame; /*!\endcond */ @@ -194,6 +203,17 @@ int skip_tpl_setup_stats; } TplParams; +/*!\brief Allocate buffers used by tpl model + * + * \param[in] Top-level encode/decode structure + * \param[in] lag_in_frames number of lookahead frames + * + * \param[out] tpl_data tpl data structure + */ + +void av1_setup_tpl_buffers(AV1_COMMON *const cm, TplParams *const tpl_data, + int lag_in_frames); + /*!\brief Implements temporal dependency modelling for a GOP (GF/ARF * group) and selects between 16 and 32 frame GOP structure. * @@ -221,8 +241,9 @@ void av1_tpl_rdmult_setup_sb(struct AV1_COMP *cpi, MACROBLOCK *const x, BLOCK_SIZE sb_size, int mi_row, int mi_col); -void av1_mc_flow_dispenser_row(struct AV1_COMP *cpi, MACROBLOCK *x, int mi_row, - BLOCK_SIZE bsize, TX_SIZE tx_size); +void av1_mc_flow_dispenser_row(struct AV1_COMP *cpi, + TplTxfmStats *tpl_txfm_stats, MACROBLOCK *x, + int mi_row, BLOCK_SIZE bsize, TX_SIZE tx_size); /*!\brief Compute the entropy of an exponential probability distribution * function (pdf) subjected to uniform quantization. @@ -273,6 +294,17 @@ double av1_laplace_estimate_frame_rate(int q_index, int block_count, const double *abs_coeff_mean, int coeff_num); + +/*!\brief Init data structure storing transform stats + * + *\ingroup tpl_modelling + * + * \param[in] tpl_frame pointer of tpl frame data structure + * \param[in] coeff_num number of coefficients per transform block + * + */ +void av1_tpl_stats_init_txfm_stats(TplDepFrame *tpl_frame, int coeff_num); + /*!\endcond */ #ifdef __cplusplus } // extern "C"
diff --git a/av1/encoder/tune_butteraugli.c b/av1/encoder/tune_butteraugli.c new file mode 100644 index 0000000..620468d --- /dev/null +++ b/av1/encoder/tune_butteraugli.c
@@ -0,0 +1,254 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. + */ + +#include <math.h> + +#include "av1/encoder/tune_butteraugli.h" + +#include "aom_dsp/butteraugli.h" +#include "aom_ports/system_state.h" +#include "av1/encoder/rdopt.h" +#include "av1/encoder/extend.h" + +static const int resize_factor = 2; + +void set_mb_butteraugli_rdmult_scaling(AV1_COMP *cpi, + const YV12_BUFFER_CONFIG *source, + const YV12_BUFFER_CONFIG *recon) { + AV1_COMMON *const cm = &cpi->common; + const CommonModeInfoParams *const mi_params = &cm->mi_params; + const int bit_depth = cpi->td.mb.e_mbd.bd; + const int width = source->y_crop_width; + const int height = source->y_crop_height; + const int ss_x = source->subsampling_x; + const int ss_y = source->subsampling_y; + + float *diffmap; + CHECK_MEM_ERROR(cm, diffmap, aom_malloc(width * height * sizeof(*diffmap))); + if (!aom_calc_butteraugli(source, recon, bit_depth, diffmap)) { + aom_internal_error(&cm->error, AOM_CODEC_ERROR, + "Failed to calculate Butteraugli distances."); + } + + const int num_mi_w = mi_size_wide[butteraugli_rdo_bsize] / resize_factor; + const int num_mi_h = mi_size_high[butteraugli_rdo_bsize] / resize_factor; + const int num_cols = + (mi_params->mi_cols / resize_factor + num_mi_w - 1) / num_mi_w; + const int num_rows = + (mi_params->mi_rows / resize_factor + num_mi_h - 1) / num_mi_h; + const int block_w = num_mi_w << 2; + const int block_h = num_mi_h << 2; + double log_sum = 0.0; + double blk_count = 0.0; + + // Loop through each block. + for (int row = 0; row < num_rows; ++row) { + for (int col = 0; col < num_cols; ++col) { + const int index = row * num_cols + col; + const int y_start = row * block_h; + const int x_start = col * block_w; + float dbutteraugli = 0.0f; + float dmse = 0.0f; + float px_count = 0.0f; + + // Loop through each pixel. + for (int y = y_start; y < y_start + block_h && y < height; y++) { + for (int x = x_start; x < x_start + block_w && x < width; x++) { + dbutteraugli += powf(diffmap[y * width + x], 12.0f); + float px_diff = source->y_buffer[y * source->y_stride + x] - + recon->y_buffer[y * recon->y_stride + x]; + dmse += px_diff * px_diff; + px_count += 1.0f; + } + } + const int y_end = AOMMIN((y_start >> ss_y) + (block_h >> ss_y), + (height + ss_y) >> ss_y); + for (int y = y_start >> ss_y; y < y_end; y++) { + const int x_end = AOMMIN((x_start >> ss_x) + (block_w >> ss_x), + (width + ss_x) >> ss_x); + for (int x = x_start >> ss_x; x < x_end; x++) { + const int src_px_index = y * source->uv_stride + x; + const int recon_px_index = y * recon->uv_stride + x; + const float px_diff_u = (float)(source->u_buffer[src_px_index] - + recon->u_buffer[recon_px_index]); + const float px_diff_v = (float)(source->v_buffer[src_px_index] - + recon->v_buffer[recon_px_index]); + dmse += px_diff_u * px_diff_u + px_diff_v * px_diff_v; + px_count += 2.0f; + } + } + + dbutteraugli = powf(dbutteraugli, 1.0f / 12.0f); + dmse = dmse / px_count; + // 'K' is used to balance the rate-distortion distribution between PSNR + // and Butteraugli. + const double K = 0.4; + const float eps = 0.01f; + double weight; + if (dbutteraugli < eps || dmse < eps) { + weight = -1.0; + } else { + blk_count += 1.0; + weight = dmse / dbutteraugli; + weight = AOMMIN(weight, 5.0); + weight += K; + log_sum += log(weight); + } + cpi->butteraugli_info.rdmult_scaling_factors[index] = weight; + } + } + // Geometric average of the weights. + log_sum = exp(log_sum / blk_count); + + for (int row = 0; row < num_rows; ++row) { + for (int col = 0; col < num_cols; ++col) { + const int index = row * num_cols + col; + double *weight = &cpi->butteraugli_info.rdmult_scaling_factors[index]; + if (*weight <= 0.0) { + *weight = 1.0; + } else { + *weight /= log_sum; + } + *weight = AOMMIN(*weight, 2.5); + *weight = AOMMAX(*weight, 0.4); + } + } + + aom_free(diffmap); +} + +void av1_set_butteraugli_rdmult(const AV1_COMP *cpi, MACROBLOCK *x, + BLOCK_SIZE bsize, int mi_row, int mi_col, + int *rdmult) { + assert(cpi->oxcf.tune_cfg.tuning == AOM_TUNE_BUTTERAUGLI); + if (!cpi->butteraugli_info.recon_set) { + return; + } + const AV1_COMMON *const cm = &cpi->common; + + const int num_mi_w = mi_size_wide[butteraugli_rdo_bsize]; + const int num_mi_h = mi_size_high[butteraugli_rdo_bsize]; + const int num_cols = (cm->mi_params.mi_cols + num_mi_w - 1) / num_mi_w; + const int num_rows = (cm->mi_params.mi_rows + num_mi_h - 1) / num_mi_h; + const int num_bcols = (mi_size_wide[bsize] + num_mi_w - 1) / num_mi_w; + const int num_brows = (mi_size_high[bsize] + num_mi_h - 1) / num_mi_h; + double num_of_mi = 0.0; + double geom_mean_of_scale = 0.0; + + aom_clear_system_state(); + for (int row = mi_row / num_mi_w; + row < num_rows && row < mi_row / num_mi_w + num_brows; ++row) { + for (int col = mi_col / num_mi_h; + col < num_cols && col < mi_col / num_mi_h + num_bcols; ++col) { + const int index = row * num_cols + col; + geom_mean_of_scale += + log(cpi->butteraugli_info.rdmult_scaling_factors[index]); + num_of_mi += 1.0; + } + } + geom_mean_of_scale = exp(geom_mean_of_scale / num_of_mi); + + *rdmult = (int)((double)(*rdmult) * geom_mean_of_scale + 0.5); + *rdmult = AOMMAX(*rdmult, 0); + av1_set_error_per_bit(&x->errorperbit, *rdmult); + aom_clear_system_state(); +} + +static void copy_plane(const uint8_t *src, int src_stride, uint8_t *dst, + int dst_stride, int w, int h) { + for (int row = 0; row < h; row++) { + memcpy(dst, src, w); + src += src_stride; + dst += dst_stride; + } +} + +static void copy_img(const YV12_BUFFER_CONFIG *src, YV12_BUFFER_CONFIG *dst, + int width, int height) { + copy_plane(src->y_buffer, src->y_stride, dst->y_buffer, dst->y_stride, width, + height); + const int width_uv = (width + src->subsampling_x) >> src->subsampling_x; + const int height_uv = (height + src->subsampling_y) >> src->subsampling_y; + copy_plane(src->u_buffer, src->uv_stride, dst->u_buffer, dst->uv_stride, + width_uv, height_uv); + copy_plane(src->v_buffer, src->uv_stride, dst->v_buffer, dst->uv_stride, + width_uv, height_uv); +} + +static void zero_plane(uint8_t *dst, int dst_stride, int h) { + for (int row = 0; row < h; row++) { + memset(dst, 0, dst_stride); + dst += dst_stride; + } +} + +static void zero_img(YV12_BUFFER_CONFIG *dst) { + zero_plane(dst->y_buffer, dst->y_stride, dst->y_height); + zero_plane(dst->u_buffer, dst->uv_stride, dst->uv_height); + zero_plane(dst->v_buffer, dst->uv_stride, dst->uv_height); +} + +void av1_setup_butteraugli_source(AV1_COMP *cpi) { + aom_clear_system_state(); + YV12_BUFFER_CONFIG *const dst = &cpi->butteraugli_info.source; + AV1_COMMON *const cm = &cpi->common; + const int width = cpi->source->y_crop_width; + const int height = cpi->source->y_crop_height; + const int bit_depth = cpi->td.mb.e_mbd.bd; + const int ss_x = cpi->source->subsampling_x; + const int ss_y = cpi->source->subsampling_y; + if (dst->buffer_alloc_sz == 0) { + aom_alloc_frame_buffer( + dst, width, height, ss_x, ss_y, cm->seq_params.use_highbitdepth, + cpi->oxcf.border_in_pixels, cm->features.byte_alignment); + } + av1_copy_and_extend_frame(cpi->source, dst); + + YV12_BUFFER_CONFIG *const resized_dst = &cpi->butteraugli_info.resized_source; + if (resized_dst->buffer_alloc_sz == 0) { + aom_alloc_frame_buffer( + resized_dst, width / resize_factor, height / resize_factor, ss_x, ss_y, + cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels, + cm->features.byte_alignment); + } + av1_resize_and_extend_frame_nonnormative(cpi->source, resized_dst, bit_depth, + av1_num_planes(cm)); + + zero_img(cpi->source); + copy_img(resized_dst, cpi->source, width / resize_factor, + height / resize_factor); + aom_clear_system_state(); +} + +void av1_restore_butteraugli_source(AV1_COMP *cpi) { + aom_clear_system_state(); + av1_copy_and_extend_frame(&cpi->butteraugli_info.source, cpi->source); + AV1_COMMON *const cm = &cpi->common; + const int width = cpi->source->y_crop_width; + const int height = cpi->source->y_crop_height; + const int ss_x = cpi->source->subsampling_x; + const int ss_y = cpi->source->subsampling_y; + + YV12_BUFFER_CONFIG resized_recon; + memset(&resized_recon, 0, sizeof(resized_recon)); + aom_alloc_frame_buffer( + &resized_recon, width / resize_factor, height / resize_factor, ss_x, ss_y, + cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels, + cm->features.byte_alignment); + copy_img(&cpi->common.cur_frame->buf, &resized_recon, width / resize_factor, + height / resize_factor); + + set_mb_butteraugli_rdmult_scaling(cpi, &cpi->butteraugli_info.resized_source, + &resized_recon); + cpi->butteraugli_info.recon_set = true; + aom_free_frame_buffer(&resized_recon); + aom_clear_system_state(); +}
diff --git a/av1/encoder/tune_butteraugli.h b/av1/encoder/tune_butteraugli.h new file mode 100644 index 0000000..a4af31c --- /dev/null +++ b/av1/encoder/tune_butteraugli.h
@@ -0,0 +1,43 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. + */ + +#ifndef AOM_AV1_ENCODER_TUNE_BUTTERAUGLI_H_ +#define AOM_AV1_ENCODER_TUNE_BUTTERAUGLI_H_ + +#include "aom_scale/yv12config.h" +#include "av1/common/enums.h" +#include "av1/encoder/ratectrl.h" +#include "av1/encoder/block.h" + +typedef struct { + // Stores the scaling factors for rdmult when tuning for Butteraugli. + // rdmult_scaling_factors[row * num_cols + col] stores the scaling factors for + // 4x4 block at (row, col). + double *rdmult_scaling_factors; + YV12_BUFFER_CONFIG source, resized_source; + bool recon_set; +} TuneButteraugliInfo; + +typedef struct AV1_COMP AV1_COMP; +static const BLOCK_SIZE butteraugli_rdo_bsize = BLOCK_16X16; + +void av1_set_butteraugli_rdmult(const AV1_COMP *cpi, MACROBLOCK *x, + BLOCK_SIZE bsize, int mi_row, int mi_col, + int *rdmult); + +void av1_setup_butteraugli_recon(AV1_COMP *cpi, + const YV12_BUFFER_CONFIG *recon); + +void av1_setup_butteraugli_source(AV1_COMP *cpi); + +void av1_restore_butteraugli_source(AV1_COMP *cpi); + +#endif // AOM_AV1_ENCODER_TUNE_BUTTERAUGLI_H_
diff --git a/av1/encoder/tune_vmaf.c b/av1/encoder/tune_vmaf.c index a1afa21..36af861 100644 --- a/av1/encoder/tune_vmaf.c +++ b/av1/encoder/tune_vmaf.c
@@ -15,9 +15,7 @@ #include "aom_ports/system_state.h" #include "av1/encoder/extend.h" #include "av1/encoder/rdopt.h" -#if CONFIG_USE_VMAF_RC #include "config/aom_scale_rtcd.h" -#endif static const double kBaselineVmaf = 97.42773; @@ -294,38 +292,27 @@ } static AOM_INLINE double cal_approx_vmaf(const AV1_COMP *const cpi, -#if CONFIG_USE_VMAF_RC - VmafContext *vmaf_context, - int *vmaf_cal_index, -#endif double source_variance, YV12_BUFFER_CONFIG *const source, YV12_BUFFER_CONFIG *const sharpened) { const int bit_depth = cpi->td.mb.e_mbd.bd; + const bool cal_vmaf_neg = + cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN; double new_vmaf; -#if CONFIG_USE_VMAF_RC - aom_calc_vmaf_at_index_rc(vmaf_context, cpi->vmaf_info.vmaf_model, source, - sharpened, bit_depth, *vmaf_cal_index, &new_vmaf); - (*vmaf_cal_index)++; -#else - aom_calc_vmaf(cpi->oxcf.tune_cfg.vmaf_model_path, source, sharpened, - bit_depth, &new_vmaf); -#endif + aom_calc_vmaf(cpi->vmaf_info.vmaf_model, source, sharpened, bit_depth, + cal_vmaf_neg, &new_vmaf); const double sharpened_var = frame_average_variance(cpi, sharpened); return source_variance / sharpened_var * (new_vmaf - kBaselineVmaf); } static double find_best_frame_unsharp_amount_loop( - const AV1_COMP *const cpi, -#if CONFIG_USE_VMAF_RC - VmafContext *vmaf_context, int *vmaf_cal_index, -#endif - YV12_BUFFER_CONFIG *const source, YV12_BUFFER_CONFIG *const blurred, - YV12_BUFFER_CONFIG *const sharpened, double best_vmaf, - const double baseline_variance, const double unsharp_amount_start, - const double step_size, const int max_loop_count, const double max_amount) { + const AV1_COMP *const cpi, YV12_BUFFER_CONFIG *const source, + YV12_BUFFER_CONFIG *const blurred, YV12_BUFFER_CONFIG *const sharpened, + double best_vmaf, const double baseline_variance, + const double unsharp_amount_start, const double step_size, + const int max_loop_count, const double max_amount) { const double min_amount = 0.0; int loop_count = 0; double approx_vmaf = best_vmaf; @@ -335,11 +322,7 @@ unsharp_amount += step_size; if (unsharp_amount > max_amount || unsharp_amount < min_amount) break; unsharp(cpi, source, blurred, sharpened, unsharp_amount); - approx_vmaf = cal_approx_vmaf(cpi, -#if CONFIG_USE_VMAF_RC - vmaf_context, vmaf_cal_index, -#endif - baseline_variance, source, sharpened); + approx_vmaf = cal_approx_vmaf(cpi, baseline_variance, source, sharpened); loop_count++; } while (approx_vmaf > best_vmaf && loop_count < max_loop_count); @@ -358,13 +341,6 @@ const AV1_COMMON *const cm = &cpi->common; const int width = source->y_width; const int height = source->y_height; -#if CONFIG_USE_VMAF_RC - VmafContext *vmaf_context; - aom_init_vmaf_context_rc( - &vmaf_context, cpi->vmaf_info.vmaf_model, - cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN); - int vmaf_cal_index = 0; -#endif YV12_BUFFER_CONFIG sharpened; memset(&sharpened, 0, sizeof(sharpened)); aom_alloc_frame_buffer( @@ -375,56 +351,32 @@ double unsharp_amount; if (unsharp_amount_start <= step_size) { unsharp_amount = find_best_frame_unsharp_amount_loop( - cpi, -#if CONFIG_USE_VMAF_RC - vmaf_context, &vmaf_cal_index, -#endif - source, blurred, &sharpened, 0.0, baseline_variance, 0.0, step_size, - max_loop_count, max_filter_amount); + cpi, source, blurred, &sharpened, 0.0, baseline_variance, 0.0, + step_size, max_loop_count, max_filter_amount); } else { double a0 = unsharp_amount_start - step_size, a1 = unsharp_amount_start; double v0, v1; unsharp(cpi, source, blurred, &sharpened, a0); - v0 = cal_approx_vmaf(cpi, -#if CONFIG_USE_VMAF_RC - vmaf_context, &vmaf_cal_index, -#endif - baseline_variance, source, &sharpened); + v0 = cal_approx_vmaf(cpi, baseline_variance, source, &sharpened); unsharp(cpi, source, blurred, &sharpened, a1); - v1 = cal_approx_vmaf(cpi, -#if CONFIG_USE_VMAF_RC - vmaf_context, &vmaf_cal_index, -#endif - baseline_variance, source, &sharpened); + v1 = cal_approx_vmaf(cpi, baseline_variance, source, &sharpened); if (fabs(v0 - v1) < 0.01) { unsharp_amount = a0; } else if (v0 > v1) { unsharp_amount = find_best_frame_unsharp_amount_loop( - cpi, -#if CONFIG_USE_VMAF_RC - vmaf_context, &vmaf_cal_index, -#endif - source, blurred, &sharpened, v0, baseline_variance, a0, -step_size, - max_loop_count, max_filter_amount); + cpi, source, blurred, &sharpened, v0, baseline_variance, a0, + -step_size, max_loop_count, max_filter_amount); } else { unsharp_amount = find_best_frame_unsharp_amount_loop( - cpi, -#if CONFIG_USE_VMAF_RC - vmaf_context, &vmaf_cal_index, -#endif - source, blurred, &sharpened, v1, baseline_variance, a1, step_size, - max_loop_count, max_filter_amount); + cpi, source, blurred, &sharpened, v1, baseline_variance, a1, + step_size, max_loop_count, max_filter_amount); } } aom_free_frame_buffer(&sharpened); -#if CONFIG_USE_VMAF_RC - aom_close_vmaf_context_rc(vmaf_context); -#endif return unsharp_amount; } -#if CONFIG_USE_VMAF_RC void av1_vmaf_neg_preprocessing(AV1_COMP *const cpi, YV12_BUFFER_CONFIG *const source) { aom_clear_system_state(); @@ -452,7 +404,6 @@ aom_free_frame_buffer(&blurred); aom_clear_system_state(); } -#endif void av1_vmaf_frame_preprocessing(AV1_COMP *const cpi, YV12_BUFFER_CONFIG *const source) { @@ -654,93 +605,6 @@ aom_clear_system_state(); } -#if !CONFIG_USE_VMAF_RC -typedef struct FrameData { - const YV12_BUFFER_CONFIG *source, *blurred; - int block_w, block_h, num_rows, num_cols, row, col, bit_depth; -} FrameData; - -// A callback function used to pass data to VMAF. -// Returns 0 after reading a frame. -// Returns 2 when there is no more frame to read. -static int update_frame(float *ref_data, float *main_data, float *temp_data, - int stride, void *user_data) { - FrameData *frames = (FrameData *)user_data; - const int width = frames->source->y_width; - const int height = frames->source->y_height; - const int row = frames->row; - const int col = frames->col; - const int num_rows = frames->num_rows; - const int num_cols = frames->num_cols; - const int block_w = frames->block_w; - const int block_h = frames->block_h; - const YV12_BUFFER_CONFIG *source = frames->source; - const YV12_BUFFER_CONFIG *blurred = frames->blurred; - const int bit_depth = frames->bit_depth; - const float scale_factor = 1.0f / (float)(1 << (bit_depth - 8)); - (void)temp_data; - stride /= (int)sizeof(*ref_data); - - for (int i = 0; i < height; ++i) { - float *ref, *main; - ref = ref_data + i * stride; - main = main_data + i * stride; - if (source->flags & YV12_FLAG_HIGHBITDEPTH) { - uint16_t *src; - src = CONVERT_TO_SHORTPTR(source->y_buffer) + i * source->y_stride; - for (int j = 0; j < width; ++j) { - ref[j] = main[j] = scale_factor * (float)src[j]; - } - } else { - uint8_t *src; - src = source->y_buffer + i * source->y_stride; - for (int j = 0; j < width; ++j) { - ref[j] = main[j] = (float)src[j]; - } - } - } - if (row < num_rows && col < num_cols) { - // Set current block - const int row_offset = row * block_h; - const int col_offset = col * block_w; - const int block_width = AOMMIN(width - col_offset, block_w); - const int block_height = AOMMIN(height - row_offset, block_h); - - float *main_buf = main_data + col_offset + row_offset * stride; - if (source->flags & YV12_FLAG_HIGHBITDEPTH) { - uint16_t *blurred_buf = CONVERT_TO_SHORTPTR(blurred->y_buffer) + - row_offset * blurred->y_stride + col_offset; - for (int i = 0; i < block_height; ++i) { - for (int j = 0; j < block_width; ++j) { - main_buf[j] = scale_factor * (float)blurred_buf[j]; - } - main_buf += stride; - blurred_buf += blurred->y_stride; - } - } else { - uint8_t *blurred_buf = - blurred->y_buffer + row_offset * blurred->y_stride + col_offset; - for (int i = 0; i < block_height; ++i) { - for (int j = 0; j < block_width; ++j) { - main_buf[j] = (float)blurred_buf[j]; - } - main_buf += stride; - blurred_buf += blurred->y_stride; - } - } - - frames->col++; - if (frames->col >= num_cols) { - frames->col = 0; - frames->row++; - } - return 0; - } else { - return 2; - } -} -#endif - void av1_set_mb_vmaf_rdmult_scaling(AV1_COMP *cpi) { AV1_COMMON *cm = &cpi->common; const int y_width = cpi->source->y_width; @@ -776,7 +640,6 @@ cm->features.byte_alignment); gaussian_blur(bit_depth, &resized_source, &blurred); -#if CONFIG_USE_VMAF_RC YV12_BUFFER_CONFIG recon; memset(&recon, 0, sizeof(recon)); aom_alloc_frame_buffer(&recon, resized_y_width, resized_y_height, 1, 1, @@ -786,26 +649,11 @@ aom_yv12_copy_frame(&resized_source, &recon, 1); VmafContext *vmaf_context; - aom_init_vmaf_context_rc( - &vmaf_context, cpi->vmaf_info.vmaf_model, - cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN); -#else - double *scores = aom_malloc(sizeof(*scores) * (num_rows * num_cols)); - memset(scores, 0, sizeof(*scores) * (num_rows * num_cols)); - FrameData frame_data; - frame_data.source = &resized_source; - frame_data.blurred = &blurred; - frame_data.block_w = resized_block_w; - frame_data.block_h = resized_block_h; - frame_data.num_rows = num_rows; - frame_data.num_cols = num_cols; - frame_data.row = 0; - frame_data.col = 0; - frame_data.bit_depth = bit_depth; - aom_calc_vmaf_multi_frame(&frame_data, cpi->oxcf.tune_cfg.vmaf_model_path, - update_frame, resized_y_width, resized_y_height, - bit_depth, scores); -#endif + const bool cal_vmaf_neg = + cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN; + aom_init_vmaf_context(&vmaf_context, cpi->vmaf_info.vmaf_model, cal_vmaf_neg); + unsigned int *sses = aom_malloc(sizeof(*sses) * (num_rows * num_cols)); + memset(sses, 0, sizeof(*sses) * (num_rows * num_cols)); // Loop through each 'block_size' block. for (int row = 0; row < num_rows; ++row) { @@ -820,11 +668,10 @@ uint8_t *const blurred_buf = blurred.y_buffer + row_offset_y * blurred.y_stride + col_offset_y; - unsigned int sse; cpi->fn_ptr[resized_block_size].vf(orig_buf, resized_source.y_stride, - blurred_buf, blurred.y_stride, &sse); + blurred_buf, blurred.y_stride, + &sses[index]); -#if CONFIG_USE_VMAF_RC uint8_t *const recon_buf = recon.y_buffer + row_offset_y * recon.y_stride + col_offset_y; // Set recon buf @@ -839,10 +686,8 @@ resized_block_w, resized_block_h, 0.0); } - double vmaf; - aom_calc_vmaf_at_index_rc(vmaf_context, cpi->vmaf_info.vmaf_model, - &resized_source, &recon, bit_depth, index, - &vmaf); + aom_read_vmaf_image(vmaf_context, &resized_source, &recon, bit_depth, + index); // Restore recon buf if (cpi->common.seq_params.use_highbitdepth) { @@ -856,13 +701,18 @@ resized_source.y_stride, recon_buf, recon.y_stride, resized_block_w, resized_block_h, 0.0); } -#else - const double vmaf = scores[index]; -#endif + } + } + aom_flush_vmaf_context(vmaf_context); + for (int row = 0; row < num_rows; ++row) { + for (int col = 0; col < num_cols; ++col) { + const int index = row * num_cols + col; + const double vmaf = aom_calc_vmaf_at_index( + vmaf_context, cpi->vmaf_info.vmaf_model, index); const double dvmaf = kBaselineVmaf - vmaf; const double mse = - (double)sse / (double)(resized_y_width * resized_y_height); + (double)sses[index] / (double)(resized_y_width * resized_y_height); double weight; const double eps = 0.01 / (num_rows * num_cols); if (dvmaf < eps || mse < eps) { @@ -879,11 +729,8 @@ aom_free_frame_buffer(&resized_source); aom_free_frame_buffer(&blurred); -#if CONFIG_USE_VMAF_RC - aom_close_vmaf_context_rc(vmaf_context); -#else - aom_free(scores); -#endif + aom_close_vmaf_context(vmaf_context); + aom_free(sses); aom_clear_system_state(); } @@ -1029,10 +876,10 @@ const GF_GROUP *gf_group = &cpi->gf_group; const int src_index = cm->show_frame != 0 ? 0 : gf_group->arf_src_offset[gf_group->index]; - struct lookahead_entry *last_entry = - av1_lookahead_peek(cpi->lookahead, src_index - 1, cpi->compressor_stage); - struct lookahead_entry *next_entry = - av1_lookahead_peek(cpi->lookahead, src_index + 1, cpi->compressor_stage); + struct lookahead_entry *last_entry = av1_lookahead_peek( + cpi->ppi->lookahead, src_index - 1, cpi->compressor_stage); + struct lookahead_entry *next_entry = av1_lookahead_peek( + cpi->ppi->lookahead, src_index + 1, cpi->compressor_stage); *next = &next_entry->img; *last = cm->show_frame ? cpi->last_source : &last_entry->img; } @@ -1066,8 +913,8 @@ YV12_BUFFER_CONFIG *cur_buf = cpi->source; if (cm->show_frame == 0) { const int src_index = gf_group->arf_src_offset[gf_group->index]; - struct lookahead_entry *cur_entry = - av1_lookahead_peek(cpi->lookahead, src_index, cpi->compressor_stage); + struct lookahead_entry *cur_entry = av1_lookahead_peek( + cpi->ppi->lookahead, src_index, cpi->compressor_stage); cur_buf = &cur_entry->img; } assert(cur_buf); @@ -1094,23 +941,23 @@ return qindex; } -#if CONFIG_USE_VMAF_RC static AOM_INLINE double cal_approx_score( - AV1_COMP *const cpi, VmafContext *vmaf_context, int vmaf_cal_index, - double src_variance, double new_variance, double src_score, - YV12_BUFFER_CONFIG *const src, YV12_BUFFER_CONFIG *const recon_sharpened) { + AV1_COMP *const cpi, double src_variance, double new_variance, + double src_score, YV12_BUFFER_CONFIG *const src, + YV12_BUFFER_CONFIG *const recon_sharpened) { double score; const uint32_t bit_depth = cpi->td.mb.e_mbd.bd; - aom_calc_vmaf_at_index_rc(vmaf_context, cpi->vmaf_info.vmaf_model, src, - recon_sharpened, bit_depth, vmaf_cal_index, &score); + const bool cal_vmaf_neg = + cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN; + aom_calc_vmaf(cpi->vmaf_info.vmaf_model, src, recon_sharpened, bit_depth, + cal_vmaf_neg, &score); return src_variance / new_variance * (score - src_score); } static double find_best_frame_unsharp_amount_loop_neg( - AV1_COMP *const cpi, VmafContext *vmaf_context, double src_variance, - double base_score, YV12_BUFFER_CONFIG *const src, - YV12_BUFFER_CONFIG *const recon, YV12_BUFFER_CONFIG *const ref, - YV12_BUFFER_CONFIG *const src_blurred, + AV1_COMP *const cpi, double src_variance, double base_score, + YV12_BUFFER_CONFIG *const src, YV12_BUFFER_CONFIG *const recon, + YV12_BUFFER_CONFIG *const ref, YV12_BUFFER_CONFIG *const src_blurred, YV12_BUFFER_CONFIG *const recon_blurred, YV12_BUFFER_CONFIG *const src_sharpened, YV12_BUFFER_CONFIG *const recon_sharpened, FULLPEL_MV *mvs, @@ -1120,7 +967,6 @@ int loop_count = 0; double approx_score = best_score; double unsharp_amount = unsharp_amount_start; - int vmaf_cal_index = 3; do { best_score = approx_score; @@ -1130,9 +976,8 @@ unsharp(cpi, src, src_blurred, src_sharpened, unsharp_amount); const double new_variance = residual_frame_average_variance(cpi, src_sharpened, ref, mvs); - approx_score = - cal_approx_score(cpi, vmaf_context, vmaf_cal_index++, src_variance, - new_variance, base_score, src, recon_sharpened); + approx_score = cal_approx_score(cpi, src_variance, new_variance, base_score, + src, recon_sharpened); loop_count++; } while (approx_score > best_score && loop_count < max_loop_count); @@ -1143,11 +988,11 @@ } static double find_best_frame_unsharp_amount_neg( - AV1_COMP *const cpi, VmafContext *vmaf_context, - YV12_BUFFER_CONFIG *const src, YV12_BUFFER_CONFIG *const recon, - YV12_BUFFER_CONFIG *const ref, double base_score, - const double unsharp_amount_start, const double step_size, - const int max_loop_count, const double max_filter_amount) { + AV1_COMP *const cpi, YV12_BUFFER_CONFIG *const src, + YV12_BUFFER_CONFIG *const recon, YV12_BUFFER_CONFIG *const ref, + double base_score, const double unsharp_amount_start, + const double step_size, const int max_loop_count, + const double max_filter_amount) { FULLPEL_MV *mvs = NULL; const double src_variance = residual_frame_average_variance(cpi, src, ref, mvs); @@ -1181,32 +1026,28 @@ unsharp(cpi, src, &src_blurred, &src_sharpened, unsharp_amount_start); const double variance_start = residual_frame_average_variance(cpi, &src_sharpened, ref, mvs); - const double score_start = - cal_approx_score(cpi, vmaf_context, 1, src_variance, variance_start, - base_score, src, &recon_sharpened); + const double score_start = cal_approx_score( + cpi, src_variance, variance_start, base_score, src, &recon_sharpened); const double unsharp_amount_next = unsharp_amount_start + step_size; unsharp(cpi, recon, &recon_blurred, &recon_sharpened, unsharp_amount_next); unsharp(cpi, src, &src_blurred, &src_sharpened, unsharp_amount_next); const double variance_next = residual_frame_average_variance(cpi, &src_sharpened, ref, mvs); - const double score_next = - cal_approx_score(cpi, vmaf_context, 2, src_variance, variance_next, - base_score, src, &recon_sharpened); + const double score_next = cal_approx_score(cpi, src_variance, variance_next, + base_score, src, &recon_sharpened); double unsharp_amount; if (score_next > score_start) { unsharp_amount = find_best_frame_unsharp_amount_loop_neg( - cpi, vmaf_context, src_variance, base_score, src, recon, ref, - &src_blurred, &recon_blurred, &src_sharpened, &recon_sharpened, mvs, - score_next, unsharp_amount_next, step_size, max_loop_count, - max_filter_amount); + cpi, src_variance, base_score, src, recon, ref, &src_blurred, + &recon_blurred, &src_sharpened, &recon_sharpened, mvs, score_next, + unsharp_amount_next, step_size, max_loop_count, max_filter_amount); } else { unsharp_amount = find_best_frame_unsharp_amount_loop_neg( - cpi, vmaf_context, src_variance, base_score, src, recon, ref, - &src_blurred, &recon_blurred, &src_sharpened, &recon_sharpened, mvs, - score_start, unsharp_amount_start, -step_size, max_loop_count, - max_filter_amount); + cpi, src_variance, base_score, src, recon, ref, &src_blurred, + &recon_blurred, &src_sharpened, &recon_sharpened, mvs, score_start, + unsharp_amount_start, -step_size, max_loop_count, max_filter_amount); } aom_free_frame_buffer(&recon_sharpened); @@ -1216,7 +1057,6 @@ aom_free(mvs); return unsharp_amount; } -#endif // CONFIG_USE_VMAF_RC void av1_update_vmaf_curve(AV1_COMP *cpi) { YV12_BUFFER_CONFIG *source = cpi->source; @@ -1225,19 +1065,12 @@ const GF_GROUP *const gf_group = &cpi->gf_group; const int layer_depth = AOMMIN(gf_group->layer_depth[gf_group->index], MAX_ARF_LAYERS - 1); -#if CONFIG_USE_VMAF_RC double base_score; - VmafContext *vmaf_context; - aom_init_vmaf_context_rc( - &vmaf_context, cpi->vmaf_info.vmaf_model, - cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN); - aom_calc_vmaf_at_index_rc(vmaf_context, cpi->vmaf_info.vmaf_model, source, - recon, bit_depth, 0, &base_score); + const bool cal_vmaf_neg = + cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN; + aom_calc_vmaf(cpi->vmaf_info.vmaf_model, source, recon, bit_depth, + cal_vmaf_neg, &base_score); cpi->vmaf_info.last_frame_vmaf[layer_depth] = base_score; -#else - aom_calc_vmaf(cpi->oxcf.tune_cfg.vmaf_model_path, source, recon, bit_depth, - &cpi->vmaf_info.last_frame_vmaf[layer_depth]); -#endif // CONFIG_USE_VMAF_RC if (cpi->common.seq_params.use_highbitdepth) { assert(source->flags & YV12_FLAG_HIGHBITDEPTH); assert(recon->flags & YV12_FLAG_HIGHBITDEPTH); @@ -1248,7 +1081,6 @@ (double)aom_get_y_sse(source, recon); } -#if CONFIG_USE_VMAF_RC if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN) { YV12_BUFFER_CONFIG *last, *next; get_neighbor_frames(cpi, &last, &next); @@ -1256,10 +1088,8 @@ get_layer_value(cpi->vmaf_info.last_frame_unsharp_amount, layer_depth); const int max_loop_count = 5; cpi->vmaf_info.last_frame_unsharp_amount[layer_depth] = - find_best_frame_unsharp_amount_neg( - cpi, vmaf_context, source, recon, last, base_score, - best_unsharp_amount_start, 0.025, max_loop_count, 1.01); + find_best_frame_unsharp_amount_neg(cpi, source, recon, last, base_score, + best_unsharp_amount_start, 0.025, + max_loop_count, 1.01); } - aom_close_vmaf_context_rc(vmaf_context); -#endif // CONFIG_USE_VMAF_RC }
diff --git a/av1/encoder/tune_vmaf.h b/av1/encoder/tune_vmaf.h index 01c3068..4625fb9 100644 --- a/av1/encoder/tune_vmaf.h +++ b/av1/encoder/tune_vmaf.h
@@ -36,10 +36,8 @@ // Stores the origial qindex before scaling. int original_qindex; -#if CONFIG_USE_VMAF_RC // VMAF model used in VMAF caculations. VmafModel *vmaf_model; -#endif } TuneVMAFInfo; typedef struct AV1_COMP AV1_COMP; @@ -48,9 +46,7 @@ void av1_vmaf_frame_preprocessing(AV1_COMP *cpi, YV12_BUFFER_CONFIG *source); -#ifdef CONFIG_USE_VMAF_RC void av1_vmaf_neg_preprocessing(AV1_COMP *cpi, YV12_BUFFER_CONFIG *source); -#endif void av1_set_mb_vmaf_rdmult_scaling(AV1_COMP *cpi);
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c index e7b4d5b..68b4416 100644 --- a/av1/encoder/tx_search.c +++ b/av1/encoder/tx_search.c
@@ -1995,10 +1995,14 @@ ? fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode] : mbmi->mode; uint16_t ext_tx_used_flag = - cpi->sf.tx_sf.tx_type_search.use_reduced_intra_txset && + cpi->sf.tx_sf.tx_type_search.use_reduced_intra_txset != 0 && tx_set_type == EXT_TX_SET_DTT4_IDTX_1DDCT ? av1_reduced_intra_tx_used_flag[intra_dir] : av1_ext_tx_used_flag[tx_set_type]; + + if (cpi->sf.tx_sf.tx_type_search.use_reduced_intra_txset == 2) + ext_tx_used_flag &= av1_derived_intra_tx_used_flag[intra_dir]; + if (xd->lossless[mbmi->segment_id] || txsize_sqr_up_map[tx_size] > TX_32X32 || ext_tx_used_flag == 0x0001 || (is_inter && cpi->oxcf.txfm_cfg.use_inter_dct_only) || @@ -2716,11 +2720,12 @@ x->mode_costs.txfm_partition_cost[txfm_partition_ctx][1]; for (int r = 0, blk_idx = 0; r < txb_height; r += sub_txb_height) { + const int offsetr = blk_row + r; + if (offsetr >= max_blocks_high) break; for (int c = 0; c < txb_width; c += sub_txb_width, ++blk_idx) { assert(blk_idx < 4); - const int offsetr = blk_row + r; const int offsetc = blk_col + c; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; + if (offsetc >= max_blocks_wide) continue; RD_STATS this_rd_stats; int this_cost_valid = 1; @@ -3448,15 +3453,18 @@ const int txb_width = tx_size_wide_unit[sub_txs]; const int txb_height = tx_size_high_unit[sub_txs]; const int step = txb_height * txb_width; + const int row_end = + AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); + const int col_end = + AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); RD_STATS pn_rd_stats; int64_t this_rd = 0; assert(txb_width > 0 && txb_height > 0); - for (int row = 0; row < tx_size_high_unit[tx_size]; row += txb_height) { - for (int col = 0; col < tx_size_wide_unit[tx_size]; col += txb_width) { - const int offsetr = blk_row + row; + for (int row = 0; row < row_end; row += txb_height) { + const int offsetr = blk_row + row; + for (int col = 0; col < col_end; col += txb_width) { const int offsetc = blk_col + col; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; av1_init_rd_stats(&pn_rd_stats); tx_block_yrd(cpi, x, offsetr, offsetc, block, sub_txs, plane_bsize,
diff --git a/av1/encoder/txb_rdopt.h b/av1/encoder/txb_rdopt.h index 5209647..e86caaa 100644 --- a/av1/encoder/txb_rdopt.h +++ b/av1/encoder/txb_rdopt.h
@@ -9,8 +9,8 @@ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ -#ifndef AOM_AV1_ENCODER_OPTIMIZE_TXB_H_ -#define AOM_AV1_ENCODER_OPTIMIZE_TXB_H_ +#ifndef AOM_AV1_ENCODER_TXB_RDOPT_H_ +#define AOM_AV1_ENCODER_TXB_RDOPT_H_ #include "av1/common/blockd.h" #include "av1/common/txb_common.h" @@ -157,4 +157,4 @@ } #endif -#endif // AOM_AV1_ENCODER_OPTIMIZE_TXB_H_ +#endif // AOM_AV1_ENCODER_TXB_RDOPT_H_
diff --git a/av1/encoder/txb_rdopt_utils.h b/av1/encoder/txb_rdopt_utils.h index 8cce290..9943026 100644 --- a/av1/encoder/txb_rdopt_utils.h +++ b/av1/encoder/txb_rdopt_utils.h
@@ -9,6 +9,9 @@ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ +#ifndef AOM_AV1_ENCODER_TXB_RDOPT_UTILS_H_ +#define AOM_AV1_ENCODER_TXB_RDOPT_UTILS_H_ + #include "av1/encoder/encodetxb.h" static const int golomb_bits_cost[32] = { @@ -219,3 +222,4 @@ *eob = eob_out; } +#endif // AOM_AV1_ENCODER_TXB_RDOPT_UTILS_H_
diff --git a/av1/encoder/var_based_part.c b/av1/encoder/var_based_part.c index 025e125..a42be45 100644 --- a/av1/encoder/var_based_part.c +++ b/av1/encoder/var_based_part.c
@@ -344,7 +344,7 @@ int segment_id) { AV1_COMMON *const cm = &cpi->common; const int is_key_frame = frame_is_intra_only(cm); - const int threshold_multiplier = is_key_frame ? 40 : 1; + const int threshold_multiplier = is_key_frame ? 120 : 1; int64_t threshold_base = (int64_t)(threshold_multiplier * cpi->enc_quant_dequant_params.dequants.y_dequant_QTX[q][1]); @@ -353,8 +353,13 @@ if (is_key_frame) { thresholds[0] = threshold_base; thresholds[1] = threshold_base; - thresholds[2] = threshold_base >> 2; - thresholds[3] = threshold_base >> 2; + if (cm->width * cm->height < 1280 * 720) { + thresholds[2] = threshold_base / 3; + thresholds[3] = threshold_base >> 1; + } else { + thresholds[2] = threshold_base >> 2; + thresholds[3] = threshold_base >> 2; + } thresholds[4] = threshold_base << 2; } else { // Increase partition thresholds for noisy content. Apply it only for @@ -1021,7 +1026,8 @@ (max_var_32x32[m] - min_var_32x32[m]) > 3 * (thresholds[1] >> 3) && max_var_32x32[m] > thresholds[1] >> 1 && (noise_level >= kMedium || cpi->use_svc || - cpi->sf.rt_sf.force_large_partition_blocks)) { + cpi->sf.rt_sf.force_large_partition_blocks || + !cpi->sf.rt_sf.use_nonrd_pick_mode)) { force_split[1 + m] = 1; force_split[0] = 1; }
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake index f1b1e57..89516e5 100644 --- a/build/cmake/aom_config_defaults.cmake +++ b/build/cmake/aom_config_defaults.cmake
@@ -115,7 +115,9 @@ set_aom_config_var(DECODE_HEIGHT_LIMIT 0 "Set limit for decode height.") set_aom_config_var(DECODE_WIDTH_LIMIT 0 "Set limit for decode width.") set_aom_config_var(CONFIG_TUNE_VMAF 0 "Enable encoding tuning for VMAF.") -set_aom_config_var(CONFIG_USE_VMAF_RC 0 "Use libvmaf_rc tune for VMAF_NEG.") +set_aom_config_var(CONFIG_TUNE_BUTTERAUGLI 0 + "Enable encoding tuning for Butteraugli.") +set_aom_config_var(STATIC_LINK_JXL 0 "Statically link the JPEG-XL library.") # AV1 experiment flags. set_aom_config_var(CONFIG_SPEED_STATS 0 "AV1 experiment flag.") @@ -140,6 +142,8 @@ "AV1 experiment flag for optical flow API.") set_aom_config_var(CONFIG_RT_ML_PARTITIONING 0 "Build with ML-based partitioning for Real Time.") +set_aom_config_var(CONFIG_PARTITION_SEARCH_ORDER 0 + "AV1 experiment with alternative partition search order.") # # Variables in this section control optional features of the build system.
diff --git a/build/cmake/aom_install.cmake b/build/cmake/aom_install.cmake index cd40fe4..e22fc8a 100644 --- a/build/cmake/aom_install.cmake +++ b/build/cmake/aom_install.cmake
@@ -10,8 +10,7 @@ # list(APPEND AOM_INSTALL_INCS "${AOM_ROOT}/aom/aom.h" "${AOM_ROOT}/aom/aom_codec.h" "${AOM_ROOT}/aom/aom_frame_buffer.h" - "${AOM_ROOT}/aom/aom_image.h" "${AOM_ROOT}/aom/aom_integer.h" - "${AOM_ROOT}/aom/aom.h") + "${AOM_ROOT}/aom/aom_image.h" "${AOM_ROOT}/aom/aom_integer.h") if(CONFIG_AV1_DECODER) list(APPEND AOM_INSTALL_INCS "${AOM_ROOT}/aom/aom_decoder.h"
diff --git a/common/args.c b/common/args.c index ed62294..64d6e03 100644 --- a/common/args.c +++ b/common/args.c
@@ -92,6 +92,7 @@ GET_PARAMS(disable_intrabc); GET_PARAMS(disable_cfl); GET_PARAMS(disable_smooth_intra); + GET_PARAMS(disable_diagonal_intra); GET_PARAMS(disable_filter_intra); GET_PARAMS(disable_dual_filter); GET_PARAMS(disable_intra_angle_delta);
diff --git a/doc/dev_guide/av1_encoder.dox b/doc/dev_guide/av1_encoder.dox index d266394..9079d5c 100644 --- a/doc/dev_guide/av1_encoder.dox +++ b/doc/dev_guide/av1_encoder.dox
@@ -1482,7 +1482,7 @@ only pops if either the "flush" variable is set, or the buffer is at maximum capacity. - The buffer is stored in the \ref AV1_COMP::lookahead field. + The buffer is stored in the \ref AV1_PRIMARY::lookahead field. It is initialized in the first call to \ref aom_codec_encode(), in the \ref av1_receive_raw_frame() sub-routine. The buffer size is defined by the g_lag_in_frames parameter set in the
diff --git a/examples/svc_encoder_rtc.c b/examples/svc_encoder_rtc.c index dae92cb..24541f9 100644 --- a/examples/svc_encoder_rtc.c +++ b/examples/svc_encoder_rtc.c
@@ -24,6 +24,7 @@ #include "common/args.h" #include "common/tools_common.h" #include "common/video_writer.h" +#include "examples/encoder_util.h" #include "aom_ports/aom_timer.h" #define OPTION_BUFFER_SIZE 1024 @@ -35,6 +36,7 @@ int speed; int aq_mode; int layering_mode; + int output_obu; } AppInput; typedef enum { @@ -82,6 +84,9 @@ ARG_DEF(NULL, "drop-frame", 1, "Temporal resampling threshold (buf %)"); static const arg_def_t error_resilient_arg = ARG_DEF(NULL, "error-resilient", 1, "Error resilient flag"); +static const arg_def_t output_obu_arg = + ARG_DEF(NULL, "output-obu", 1, + "Write OBUs when set to 1. Otherwise write IVF files."); #if CONFIG_AV1_HIGHBITDEPTH static const struct arg_enum_list bitdepth_enum[] = { @@ -93,16 +98,16 @@ #endif // CONFIG_AV1_HIGHBITDEPTH static const arg_def_t *svc_args[] = { - &frames_arg, &outputfile, &width_arg, - &height_arg, &timebase_arg, &bitrate_arg, - &spatial_layers_arg, &kf_dist_arg, &scale_factors_arg, - &min_q_arg, &max_q_arg, &temporal_layers_arg, - &layering_mode_arg, &threads_arg, &aqmode_arg, + &frames_arg, &outputfile, &width_arg, + &height_arg, &timebase_arg, &bitrate_arg, + &spatial_layers_arg, &kf_dist_arg, &scale_factors_arg, + &min_q_arg, &max_q_arg, &temporal_layers_arg, + &layering_mode_arg, &threads_arg, &aqmode_arg, #if CONFIG_AV1_HIGHBITDEPTH &bitdepth_arg, #endif - &speed_arg, &bitrates_arg, &dropframe_thresh_arg, - &error_resilient_arg, NULL + &speed_arg, &bitrates_arg, &dropframe_thresh_arg, + &error_resilient_arg, &output_obu_arg, NULL }; #define zero(Dest) memset(&(Dest), 0, sizeof(Dest)); @@ -254,6 +259,7 @@ svc_params->number_spatial_layers = 1; svc_params->number_temporal_layers = 1; app_input->layering_mode = 0; + app_input->output_obu = 0; enc_cfg->g_threads = 1; enc_cfg->rc_end_usage = AOM_CBR; @@ -326,6 +332,11 @@ if (enc_cfg->g_error_resilient != 0 && enc_cfg->g_error_resilient != 1) die("Invalid value for error resilient (0, 1): %d.", enc_cfg->g_error_resilient); + } else if (arg_match(&arg, &output_obu_arg, argi)) { + app_input->output_obu = arg_parse_uint(&arg); + if (app_input->output_obu != 0 && app_input->output_obu != 1) + die("Invalid value for obu output flag (0, 1): %d.", + app_input->output_obu); } else { ++argj; } @@ -380,10 +391,10 @@ enc_cfg->rc_target_bitrate, enc_cfg->kf_max_dist); } -static unsigned int mode_to_num_temporal_layers[10] = { 1, 2, 3, 3, 2, - 1, 1, 3, 3, 3 }; -static unsigned int mode_to_num_spatial_layers[10] = { 1, 1, 1, 1, 1, - 2, 3, 3, 3, 3 }; +static unsigned int mode_to_num_temporal_layers[11] = { 1, 2, 3, 3, 2, 1, + 1, 3, 3, 3, 3 }; +static unsigned int mode_to_num_spatial_layers[11] = { 1, 1, 1, 1, 1, 2, + 3, 2, 3, 3, 3 }; // For rate control encoding stats. struct RateControlMetrics { @@ -552,7 +563,7 @@ int is_key_frame, int ksvc_mode) { int i; int enable_longterm_temporal_ref = 1; - int shift = (layering_mode == 7) ? 2 : 0; + int shift = (layering_mode == 8) ? 2 : 0; *use_svc_control = 1; layer_id->spatial_layer_id = spatial_layer_id; int lag_index = 0; @@ -565,8 +576,8 @@ for (i = 0; i < REF_FRAMES; i++) ref_frame_config->refresh[i] = 0; if (ksvc_mode) { - // Same pattern as case 8. - layering_mode = 8; + // Same pattern as case 9. + layering_mode = 9; if (!is_key_frame) // No inter-layer prediction on inter-frames. ref_frame_config->reference[SVC_LAST_FRAME] = 1; @@ -756,13 +767,99 @@ } break; case 7: + // 2 spatial and 3 temporal layer. + ref_frame_config->reference[SVC_LAST_FRAME] = 1; + if (superframe_cnt % 4 == 0) { + // Base temporal layer + layer_id->temporal_layer_id = 0; + if (layer_id->spatial_layer_id == 0) { + // Reference LAST, update LAST + // Set all buffer_idx to 0 + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 0; + ref_frame_config->refresh[0] = 1; + } else if (layer_id->spatial_layer_id == 1) { + // Reference LAST and GOLDEN. + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 0; + ref_frame_config->ref_idx[SVC_LAST_FRAME] = 1; + ref_frame_config->refresh[1] = 1; + } + } else if ((superframe_cnt - 1) % 4 == 0) { + // First top temporal enhancement layer. + layer_id->temporal_layer_id = 2; + if (layer_id->spatial_layer_id == 0) { + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 0; + ref_frame_config->ref_idx[SVC_GOLDEN_FRAME] = 3; + ref_frame_config->refresh[3] = 1; + } else if (layer_id->spatial_layer_id == 1) { + // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 1, + // GOLDEN (and all other refs) to slot 3. + // Set LAST2 to slot 4 and Update slot 4. + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 3; + ref_frame_config->ref_idx[SVC_LAST_FRAME] = 1; + ref_frame_config->ref_idx[SVC_LAST2_FRAME] = 4; + ref_frame_config->refresh[4] = 1; + } + } else if ((superframe_cnt - 2) % 4 == 0) { + // Middle temporal enhancement layer. + layer_id->temporal_layer_id = 1; + if (layer_id->spatial_layer_id == 0) { + // Reference LAST. + // Set all buffer_idx to 0. + // Set GOLDEN to slot 5 and update slot 5. + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 0; + ref_frame_config->ref_idx[SVC_GOLDEN_FRAME] = 5 - shift; + ref_frame_config->refresh[5 - shift] = 1; + } else if (layer_id->spatial_layer_id == 1) { + // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 1, + // GOLDEN (and all other refs) to slot 5. + // Set LAST3 to slot 6 and update slot 6. + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 5 - shift; + ref_frame_config->ref_idx[SVC_LAST_FRAME] = 1; + ref_frame_config->ref_idx[SVC_LAST3_FRAME] = 6 - shift; + ref_frame_config->refresh[6 - shift] = 1; + } + } else if ((superframe_cnt - 3) % 4 == 0) { + // Second top temporal enhancement layer. + layer_id->temporal_layer_id = 2; + if (layer_id->spatial_layer_id == 0) { + // Set LAST to slot 5 and reference LAST. + // Set GOLDEN to slot 3 and update slot 3. + // Set all other buffer_idx to 0. + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 0; + ref_frame_config->ref_idx[SVC_LAST_FRAME] = 5 - shift; + ref_frame_config->ref_idx[SVC_GOLDEN_FRAME] = 3; + ref_frame_config->refresh[3] = 1; + } else if (layer_id->spatial_layer_id == 1) { + // Reference LAST and GOLDEN. Set buffer_idx for LAST to slot 6, + // GOLDEN to slot 3. Set LAST2 to slot 4 and update slot 4. + for (i = 0; i < INTER_REFS_PER_FRAME; i++) + ref_frame_config->ref_idx[i] = 0; + ref_frame_config->ref_idx[SVC_LAST_FRAME] = 6 - shift; + ref_frame_config->ref_idx[SVC_GOLDEN_FRAME] = 3; + ref_frame_config->ref_idx[SVC_LAST2_FRAME] = 4; + ref_frame_config->refresh[4] = 1; + } + } + if (layer_id->spatial_layer_id > 0 && !ksvc_mode) { + // Reference GOLDEN. + ref_frame_config->reference[SVC_GOLDEN_FRAME] = 1; + } + break; + case 8: // 3 spatial and 3 temporal layer. - // Same as case 8 but overalap in the buffer slot updates. + // Same as case 9 but overalap in the buffer slot updates. // (shift = 2). The slots 3 and 4 updated by first TL2 are // reused for update in TL1 superframe. // Note for this case, frame order hint must be disabled for // lower resolutios (operating points > 0) to be decoedable. - case 8: + case 9: // 3 spatial and 3 temporal layer. // No overlap in buffer updates between TL2 and TL1. // TL2 updates slot 3 and 4, TL1 updates 5, 6, 7. @@ -886,12 +983,12 @@ if (layer_id->spatial_layer_id > 0 && !ksvc_mode) // Reference GOLDEN. ref_frame_config->reference[SVC_GOLDEN_FRAME] = 1; - // For 3 spatial layer case 7 (where there is free buffer slot): + // For 3 spatial layer case 8 (where there is free buffer slot): // allow for top spatial layer to use additional temporal reference. // Additional reference is only updated on base temporal layer, every // 10 TL0 frames here. if (enable_longterm_temporal_ref && layer_id->spatial_layer_id == 2 && - layering_mode == 7) { + layering_mode == 8) { ref_frame_config->ref_idx[SVC_ALTREF_FRAME] = REF_FRAMES - 1; ref_frame_config->reference[SVC_ALTREF_FRAME] = 1; if (base_count % 10 == 0 && layer_id->temporal_layer_id == 0) @@ -902,10 +999,70 @@ } } +#if CONFIG_AV1_DECODER +static void test_decode(aom_codec_ctx_t *encoder, aom_codec_ctx_t *decoder, + const int frames_out, int *mismatch_seen) { + aom_image_t enc_img, dec_img; + + if (*mismatch_seen) return; + + /* Get the internal reference frame */ + AOM_CODEC_CONTROL_TYPECHECKED(encoder, AV1_GET_NEW_FRAME_IMAGE, &enc_img); + AOM_CODEC_CONTROL_TYPECHECKED(decoder, AV1_GET_NEW_FRAME_IMAGE, &dec_img); + +#if CONFIG_AV1_HIGHBITDEPTH + if ((enc_img.fmt & AOM_IMG_FMT_HIGHBITDEPTH) != + (dec_img.fmt & AOM_IMG_FMT_HIGHBITDEPTH)) { + if (enc_img.fmt & AOM_IMG_FMT_HIGHBITDEPTH) { + aom_image_t enc_hbd_img; + aom_img_alloc(&enc_hbd_img, enc_img.fmt - AOM_IMG_FMT_HIGHBITDEPTH, + enc_img.d_w, enc_img.d_h, 16); + aom_img_truncate_16_to_8(&enc_hbd_img, &enc_img); + enc_img = enc_hbd_img; + } + if (dec_img.fmt & AOM_IMG_FMT_HIGHBITDEPTH) { + aom_image_t dec_hbd_img; + aom_img_alloc(&dec_hbd_img, dec_img.fmt - AOM_IMG_FMT_HIGHBITDEPTH, + dec_img.d_w, dec_img.d_h, 16); + aom_img_truncate_16_to_8(&dec_hbd_img, &dec_img); + dec_img = dec_hbd_img; + } + } +#endif + + if (!aom_compare_img(&enc_img, &dec_img)) { + int y[4], u[4], v[4]; +#if CONFIG_AV1_HIGHBITDEPTH + if (enc_img.fmt & AOM_IMG_FMT_HIGHBITDEPTH) { + aom_find_mismatch_high(&enc_img, &dec_img, y, u, v); + } else { + aom_find_mismatch(&enc_img, &dec_img, y, u, v); + } +#else + aom_find_mismatch(&enc_img, &dec_img, y, u, v); +#endif + decoder->err = 1; + printf( + "Encode/decode mismatch on frame %d at" + " Y[%d, %d] {%d/%d}," + " U[%d, %d] {%d/%d}," + " V[%d, %d] {%d/%d}", + frames_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0], v[1], + v[2], v[3]); + *mismatch_seen = frames_out; + } + + aom_img_free(&enc_img); + aom_img_free(&dec_img); +} +#endif // CONFIG_AV1_DECODER + int main(int argc, const char **argv) { AppInput app_input; AvxVideoWriter *outfile[AOM_MAX_LAYERS] = { NULL }; + FILE *obu_files[AOM_MAX_LAYERS] = { NULL }; AvxVideoWriter *total_layer_file = NULL; + FILE *total_layer_obu_file = NULL; aom_codec_enc_cfg_t cfg; int frame_cnt = 0; aom_image_t raw; @@ -919,6 +1076,17 @@ aom_svc_params_t svc_params; aom_svc_ref_frame_config_t ref_frame_config; +#if CONFIG_INTERNAL_STATS + FILE *stats_file = fopen("opsnr.stt", "a"); + if (stats_file == NULL) { + die("Cannot open opsnr.stt\n"); + } +#endif +#if CONFIG_AV1_DECODER + int mismatch_seen = 0; + aom_codec_ctx_t decoder; +#endif + struct RateControlMetrics rc; int64_t cx_time = 0; int64_t cx_time_sl[3]; // max number of spatial layers. @@ -1011,21 +1179,17 @@ svc_params.framerate_factor[2] = 1; } + if (app_input.input_ctx.file_type == FILE_TYPE_Y4M) { + // Override these settings with the info from Y4M file. + cfg.g_w = app_input.input_ctx.width; + cfg.g_h = app_input.input_ctx.height; + // g_timebase is the reciprocal of frame rate. + cfg.g_timebase.num = app_input.input_ctx.framerate.denominator; + cfg.g_timebase.den = app_input.input_ctx.framerate.numerator; + } framerate = cfg.g_timebase.den / cfg.g_timebase.num; set_rate_control_metrics(&rc, framerate, ss_number_layers, ts_number_layers); - if (app_input.input_ctx.file_type == FILE_TYPE_Y4M) { - if (app_input.input_ctx.width != cfg.g_w || - app_input.input_ctx.height != cfg.g_h) { - die("Incorrect width or height: %d x %d", cfg.g_w, cfg.g_h); - } - if (app_input.input_ctx.framerate.numerator != cfg.g_timebase.den || - app_input.input_ctx.framerate.denominator != cfg.g_timebase.num) { - die("Incorrect framerate: numerator %d denominator %d", - cfg.g_timebase.num, cfg.g_timebase.den); - } - } - AvxVideoInfo info; info.codec_fourcc = get_fourcc_by_aom_encoder(encoder); info.frame_width = cfg.g_w; @@ -1037,23 +1201,39 @@ for (unsigned tl = 0; tl < ts_number_layers; ++tl) { i = sl * ts_number_layers + tl; char file_name[PATH_MAX]; - snprintf(file_name, sizeof(file_name), "%s_%u.av1", app_input.output_filename, i); - outfile[i] = aom_video_writer_open(file_name, kContainerIVF, &info); - if (!outfile[i]) die("Failed to open %s for writing", file_name); + if (app_input.output_obu) { + obu_files[i] = fopen(file_name, "wb"); + if (!obu_files[i]) die("Failed to open %s for writing", file_name); + } else { + outfile[i] = aom_video_writer_open(file_name, kContainerIVF, &info); + if (!outfile[i]) die("Failed to open %s for writing", file_name); + } } } - total_layer_file = - aom_video_writer_open(app_input.output_filename, kContainerIVF, &info); - if (!total_layer_file) - die("Failed to open %s for writing", app_input.output_filename); + if (app_input.output_obu) { + total_layer_obu_file = fopen(app_input.output_filename, "wb"); + if (!total_layer_obu_file) + die("Failed to open %s for writing", app_input.output_filename); + } else { + total_layer_file = + aom_video_writer_open(app_input.output_filename, kContainerIVF, &info); + if (!total_layer_file) + die("Failed to open %s for writing", app_input.output_filename); + } // Initialize codec. aom_codec_ctx_t codec; if (aom_codec_enc_init(&codec, encoder, &cfg, 0)) die("Failed to initialize encoder"); +#if CONFIG_AV1_DECODER + if (aom_codec_dec_init(&decoder, get_aom_decoder_by_index(0), NULL, 0)) { + die("Failed to initialize decoder"); + } +#endif + aom_codec_control(&codec, AOME_SET_CPUUSED, app_input.speed); aom_codec_control(&codec, AV1E_SET_AQ_MODE, app_input.aq_mode ? 3 : 0); aom_codec_control(&codec, AV1E_SET_GF_CBR_BOOST_PCT, 0); @@ -1116,7 +1296,7 @@ // buffer index. set_layer_pattern(app_input.layering_mode, frame_cnt, &layer_id, &ref_frame_config, &use_svc_control, slx, is_key_frame, - (app_input.layering_mode == 9)); + (app_input.layering_mode == 10)); aom_codec_control(&codec, AV1E_SET_SVC_LAYER_ID, &layer_id); if (use_svc_control) aom_codec_control(&codec, AV1E_SET_SVC_REF_FRAME_CONFIG, @@ -1163,15 +1343,26 @@ for (unsigned tl = layer_id.temporal_layer_id; tl < ts_number_layers; ++tl) { unsigned int j = sl * ts_number_layers + tl; - aom_video_writer_write_frame(outfile[j], pkt->data.frame.buf, - pkt->data.frame.sz, pts); + if (app_input.output_obu) { + fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, + obu_files[j]); + } else { + aom_video_writer_write_frame(outfile[j], pkt->data.frame.buf, + pkt->data.frame.sz, pts); + } if (sl == (unsigned int)layer_id.spatial_layer_id) rc.layer_encoding_bitrate[j] += 8.0 * pkt->data.frame.sz; } } // Write everything into the top layer. - aom_video_writer_write_frame(total_layer_file, pkt->data.frame.buf, - pkt->data.frame.sz, pts); + if (app_input.output_obu) { + fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, + total_layer_obu_file); + } else { + aom_video_writer_write_frame(total_layer_file, + pkt->data.frame.buf, + pkt->data.frame.sz, pts); + } // Keep count of rate control stats per layer (for non-key). if (!(pkt->data.frame.flags & AOM_FRAME_IS_KEY)) { unsigned int j = layer_id.spatial_layer_id * ts_number_layers + @@ -1213,14 +1404,31 @@ sum_bitrate2 = 0.0; } } + +#if CONFIG_AV1_DECODER + if (aom_codec_decode(&decoder, pkt->data.frame.buf, + (unsigned int)pkt->data.frame.sz, NULL)) + die_codec(&decoder, "Failed to decode frame."); +#endif + break; default: break; } } +#if CONFIG_AV1_DECODER + // Don't look for mismatch on top spatial and top temporal layers as they + // are non reference frames. + if ((ss_number_layers > 1 || ts_number_layers > 1) && + !(layer_id.temporal_layer_id > 0 && + layer_id.temporal_layer_id == (int)ts_number_layers - 1)) { + test_decode(&codec, &decoder, frame_cnt, &mismatch_seen); + } +#endif } // loop over spatial layers ++frame_cnt; pts += frame_duration; } + close_input_file(&(app_input.input_ctx)); printout_rate_control_summary(&rc, frame_cnt, ss_number_layers, ts_number_layers); @@ -1239,6 +1447,15 @@ if (aom_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec"); +#if CONFIG_INTERNAL_STATS + if (mismatch_seen) { + fprintf(stats_file, "First mismatch occurred in frame %d\n", mismatch_seen); + } else { + fprintf(stats_file, "No mismatch detected in recon buffers\n"); + } + fclose(stats_file); +#endif + // Try to rewrite the output file headers with the actual frame count. for (i = 0; i < ss_number_layers * ts_number_layers; ++i) aom_video_writer_close(outfile[i]);
diff --git a/test/active_map_test.cc b/test/active_map_test.cc index 4b0ae7a..4e30f55 100644 --- a/test/active_map_test.cc +++ b/test/active_map_test.cc
@@ -30,8 +30,7 @@ virtual ~ActiveMapTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); cpu_used_ = GET_PARAM(2); }
diff --git a/test/altref_test.cc b/test/altref_test.cc index a09f7dd..1334b4a 100644 --- a/test/altref_test.cc +++ b/test/altref_test.cc
@@ -61,8 +61,7 @@ virtual ~AltRefFramePresenceTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(altref_test_params_.encoding_mode); + InitializeConfig(altref_test_params_.encoding_mode); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_; @@ -155,8 +154,7 @@ virtual ~GoldenFrameIntervalTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(gf_interval_param_.encoding_mode); + InitializeConfig(gf_interval_param_.encoding_mode); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_;
diff --git a/test/aq_segment_test.cc b/test/aq_segment_test.cc index e2715a1..4e52b55 100644 --- a/test/aq_segment_test.cc +++ b/test/aq_segment_test.cc
@@ -28,8 +28,7 @@ virtual ~AqSegmentTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); set_cpu_used_ = GET_PARAM(2); aq_mode_ = 0; }
diff --git a/test/arf_freq_test.cc b/test/arf_freq_test.cc index 0780cd7..0bf47e6 100644 --- a/test/arf_freq_test.cc +++ b/test/arf_freq_test.cc
@@ -87,14 +87,10 @@ virtual ~ArfFreqTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(test_encode_param_.mode); + InitializeConfig(test_encode_param_.mode); if (test_encode_param_.mode != ::libaom_test::kRealTime) { cfg_.g_lag_in_frames = 25; - cfg_.rc_end_usage = AOM_VBR; } else { - cfg_.g_lag_in_frames = 0; - cfg_.rc_end_usage = AOM_CBR; cfg_.rc_buf_sz = 1000; cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 600;
diff --git a/test/av1_encoder_parms_get_to_decoder.cc b/test/av1_encoder_parms_get_to_decoder.cc index 717584d..7bdb264 100644 --- a/test/av1_encoder_parms_get_to_decoder.cc +++ b/test/av1_encoder_parms_get_to_decoder.cc
@@ -88,8 +88,7 @@ virtual ~AVxEncoderParmsGetToDecoder() {} virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kTwoPassGood); + InitializeConfig(::libaom_test::kTwoPassGood); cfg_.g_lag_in_frames = 25; test_video_ = kAV1ParamPassingTestVector; cfg_.rc_target_bitrate = test_video_.bitrate;
diff --git a/test/av1_ext_tile_test.cc b/test/av1_ext_tile_test.cc index ad45667..c4f9cdc 100644 --- a/test/av1_ext_tile_test.cc +++ b/test/av1_ext_tile_test.cc
@@ -64,8 +64,7 @@ } virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); cfg_.g_lag_in_frames = 0; cfg_.rc_end_usage = AOM_VBR;
diff --git a/test/block_test.cc b/test/block_test.cc index 510a756..9cf5b02 100644 --- a/test/block_test.cc +++ b/test/block_test.cc
@@ -143,8 +143,7 @@ virtual ~SuperBlockSizeTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_;
diff --git a/test/borders_test.cc b/test/borders_test.cc index 841f0d9..bf9cc8b 100644 --- a/test/borders_test.cc +++ b/test/borders_test.cc
@@ -26,10 +26,7 @@ BordersTestLarge() : EncoderTest(GET_PARAM(0)) {} virtual ~BordersTestLarge() {} - virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); - } + virtual void SetUp() { InitializeConfig(GET_PARAM(1)); } virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video, ::libaom_test::Encoder *encoder) {
diff --git a/test/cpu_speed_test.cc b/test/cpu_speed_test.cc index 9ef3a5c..5396bec 100644 --- a/test/cpu_speed_test.cc +++ b/test/cpu_speed_test.cc
@@ -31,14 +31,9 @@ virtual ~CpuSpeedTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); if (encoding_mode_ != ::libaom_test::kRealTime) { cfg_.g_lag_in_frames = 25; - cfg_.rc_end_usage = AOM_VBR; - } else { - cfg_.g_lag_in_frames = 0; - cfg_.rc_end_usage = AOM_CBR; } }
diff --git a/test/datarate_test.cc b/test/datarate_test.cc index d0b513d..2ff074f 100644 --- a/test/datarate_test.cc +++ b/test/datarate_test.cc
@@ -38,8 +38,7 @@ virtual ~DatarateTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); ResetModel(); } @@ -252,8 +251,7 @@ virtual ~DatarateTestFrameDropLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); ResetModel(); } @@ -370,8 +368,7 @@ virtual ~DatarateTestSpeedChangeRealtime() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); ResetModel(); }
diff --git a/test/datarate_test.h b/test/datarate_test.h index 05df64d..0396034 100644 --- a/test/datarate_test.h +++ b/test/datarate_test.h
@@ -30,11 +30,6 @@ protected: virtual ~DatarateTest() {} - virtual void SetUp() { - InitializeConfig(); - ResetModel(); - } - virtual void ResetModel() { last_pts_ = 0; bits_in_buffer_model_ = cfg_.rc_target_bitrate * cfg_.rc_buf_initial_sz;
diff --git a/test/decode_multithreaded_test.cc b/test/decode_multithreaded_test.cc index 5224dcc..5a13f75 100644 --- a/test/decode_multithreaded_test.cc +++ b/test/decode_multithreaded_test.cc
@@ -69,10 +69,7 @@ delete multi_thread_dec_[i]; } - virtual void SetUp() { - InitializeConfig(); - SetMode(libaom_test::kTwoPassGood); - } + virtual void SetUp() { InitializeConfig(libaom_test::kTwoPassGood); } virtual void PreEncodeFrameHook(libaom_test::VideoSource *video, libaom_test::Encoder *encoder) {
diff --git a/test/encode_api_test.cc b/test/encode_api_test.cc index 4b79f25..eb91846 100644 --- a/test/encode_api_test.cc +++ b/test/encode_api_test.cc
@@ -44,7 +44,7 @@ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(NULL, iface, NULL, 0)); EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, NULL, 0)); EXPECT_EQ(AOM_CODEC_INVALID_PARAM, - aom_codec_enc_config_default(iface, &cfg, 2)); + aom_codec_enc_config_default(iface, &cfg, 3)); EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, 0)); EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0)); EXPECT_EQ(NULL, aom_codec_get_global_headers(NULL)); @@ -70,4 +70,28 @@ EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc)); } +TEST(EncodeAPI, AllIntraMode) { + aom_codec_iface_t *iface = aom_codec_av1_cx(); + aom_codec_ctx_t enc; + aom_codec_enc_cfg_t cfg; + EXPECT_EQ(AOM_CODEC_OK, + aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA)); + EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0)); + EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc)); + + // Set g_lag_in_frames to a nonzero value. This should cause + // aom_codec_enc_init() to fail. + EXPECT_EQ(AOM_CODEC_OK, + aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA)); + cfg.g_lag_in_frames = 1; + EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0)); + + // Set kf_max_dist to a nonzero value. This should cause aom_codec_enc_init() + // to fail. + EXPECT_EQ(AOM_CODEC_OK, + aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA)); + cfg.kf_max_dist = 1; + EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0)); +} + } // namespace
diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc index c95a86d..058e08e 100644 --- a/test/encode_test_driver.cc +++ b/test/encode_test_driver.cc
@@ -83,27 +83,20 @@ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError(); } -void EncoderTest::InitializeConfig() { - const aom_codec_err_t res = codec_->DefaultEncoderConfig(&cfg_, 0); - ASSERT_EQ(AOM_CODEC_OK, res); -} - -void EncoderTest::SetMode(TestMode mode) { +void EncoderTest::InitializeConfig(TestMode mode) { + int usage = AOM_USAGE_GOOD_QUALITY; switch (mode) { case kOnePassGood: case kTwoPassGood: break; - case kRealTime: { - cfg_.g_lag_in_frames = 0; - cfg_.g_usage = AOM_USAGE_REALTIME; - break; - } + case kRealTime: usage = AOM_USAGE_REALTIME; break; + case kAllIntra: usage = AOM_USAGE_ALL_INTRA; break; default: ASSERT_TRUE(false) << "Unexpected mode " << mode; } mode_ = mode; - if (mode == kTwoPassGood) - passes_ = 2; - else - passes_ = 1; + passes_ = (mode == kTwoPassGood) ? 2 : 1; + + const aom_codec_err_t res = codec_->DefaultEncoderConfig(&cfg_, usage); + ASSERT_EQ(AOM_CODEC_OK, res); } static bool compare_plane(const uint8_t *const buf1, int stride1,
diff --git a/test/encode_test_driver.h b/test/encode_test_driver.h index 9744b11..5da3ac5 100644 --- a/test/encode_test_driver.h +++ b/test/encode_test_driver.h
@@ -28,7 +28,7 @@ class CodecFactory; class VideoSource; -enum TestMode { kRealTime, kOnePassGood, kTwoPassGood }; +enum TestMode { kRealTime, kOnePassGood, kTwoPassGood, kAllIntra }; #define ALL_TEST_MODES \ ::testing::Values(::libaom_test::kRealTime, ::libaom_test::kOnePassGood, \ ::libaom_test::kTwoPassGood) @@ -186,11 +186,9 @@ virtual ~EncoderTest() {} - // Initialize the cfg_ member with the default configuration. - void InitializeConfig(); - - // Map the TestMode enum to the passes_ variables. - void SetMode(TestMode mode); + // Initialize the cfg_ member with the default configuration for the + // TestMode enum and maps the TestMode enum to the passes_ variable. + void InitializeConfig(TestMode mode); // Set encoder flag. void set_init_flags(aom_codec_flags_t flag) { init_flags_ = flag; }
diff --git a/test/end_to_end_test.cc b/test/end_to_end_test.cc index 82a4a8c..4c224a8 100644 --- a/test/end_to_end_test.cc +++ b/test/end_to_end_test.cc
@@ -106,14 +106,10 @@ virtual ~EndToEndTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); if (encoding_mode_ != ::libaom_test::kRealTime) { cfg_.g_lag_in_frames = 5; - cfg_.rc_end_usage = AOM_VBR; } else { - cfg_.g_lag_in_frames = 0; - cfg_.rc_end_usage = AOM_CBR; cfg_.rc_buf_sz = 1000; cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 600;
diff --git a/test/error_resilience_test.cc b/test/error_resilience_test.cc index a30de4f..3999c91 100644 --- a/test/error_resilience_test.cc +++ b/test/error_resilience_test.cc
@@ -58,10 +58,7 @@ init_flags_ = AOM_CODEC_USE_PSNR; } - virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); - } + virtual void SetUp() { InitializeConfig(encoding_mode_); } virtual void BeginPassHook(unsigned int /*pass*/) { psnr_ = 0.0; @@ -361,6 +358,10 @@ // if we lose (i.e., drop before decoding) a set of droppable // frames (i.e., frames that don't update any reference buffers). TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) { + if (GET_PARAM(1) == ::libaom_test::kOnePassGood && GET_PARAM(2) == 1) { + fprintf(stderr, "Skipping test case #1 because of bug aomedia:3002\n"); + return; + } SetupEncoder(500, 10); libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, cfg_.g_timebase.den, cfg_.g_timebase.num, @@ -478,8 +479,7 @@ virtual ~SFramePresenceTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_;
diff --git a/test/ethread_test.cc b/test/ethread_test.cc index 9c7e5d1..5bf8762 100644 --- a/test/ethread_test.cc +++ b/test/ethread_test.cc
@@ -40,8 +40,7 @@ virtual ~AVxFirstPassEncoderThreadTest() { free(firstpass_stats_.buf); } virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); cfg_.g_lag_in_frames = 35; cfg_.rc_end_usage = AOM_VBR; @@ -226,17 +225,13 @@ virtual ~AVxEncoderThreadTest() { delete decoder_; } virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); if (encoding_mode_ != ::libaom_test::kRealTime) { cfg_.g_lag_in_frames = 6; - cfg_.rc_end_usage = AOM_VBR; cfg_.rc_2pass_vbr_minsection_pct = 5; cfg_.rc_2pass_vbr_maxsection_pct = 2000; } else { - cfg_.g_lag_in_frames = 0; - cfg_.rc_end_usage = AOM_CBR; cfg_.g_error_resilient = 1; } cfg_.rc_max_quantizer = 56;
diff --git a/test/frame_size_tests.cc b/test/frame_size_tests.cc index 1546012..38b6a63 100644 --- a/test/frame_size_tests.cc +++ b/test/frame_size_tests.cc
@@ -12,6 +12,7 @@ #include "third_party/googletest/src/googletest/include/gtest/gtest.h" #include "test/codec_factory.h" #include "test/video_source.h" +#include "test/util.h" namespace { @@ -22,10 +23,7 @@ : EncoderTest(&::libaom_test::kAV1), expected_res_(AOM_CODEC_OK) {} virtual ~AV1FrameSizeTests() {} - virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kRealTime); - } + virtual void SetUp() { InitializeConfig(::libaom_test::kRealTime); } virtual bool HandleDecodeResult(const aom_codec_err_t res_dec, libaom_test::Decoder *decoder) { @@ -74,5 +72,62 @@ expected_res_ = AOM_CODEC_OK; ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); } -#undef ONE_BY_ONE_VIDEO_NAME + +typedef struct { + unsigned int width; + unsigned int height; +} FrameSizeParam; + +const FrameSizeParam FrameSizeTestParams[] = { { 96, 96 }, { 176, 144 } }; + +// This unit test is used to validate the allocated size of compressed data +// (ctx->cx_data) buffer, by feeding pseudo random input to the encoder in +// lossless encoding mode. +// +// If compressed data buffer is not large enough, the av1_get_compressed_data() +// call in av1/av1_cx_iface.c will overflow the buffer. +class AV1LosslessFrameSizeTests + : public ::libaom_test::CodecTestWith2Params<FrameSizeParam, + ::libaom_test::TestMode>, + public ::libaom_test::EncoderTest { + protected: + AV1LosslessFrameSizeTests() + : EncoderTest(GET_PARAM(0)), frame_size_param_(GET_PARAM(1)), + encoding_mode_(GET_PARAM(2)) {} + virtual ~AV1LosslessFrameSizeTests() {} + + virtual void SetUp() { InitializeConfig(encoding_mode_); } + + virtual bool HandleDecodeResult(const aom_codec_err_t res_dec, + libaom_test::Decoder *decoder) { + EXPECT_EQ(expected_res_, res_dec) << decoder->DecodeError(); + return !::testing::Test::HasFailure(); + } + + virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video, + ::libaom_test::Encoder *encoder) { + if (video->frame() == 0) { + encoder->Control(AOME_SET_CPUUSED, 6); + encoder->Control(AV1E_SET_LOSSLESS, 1); + } + } + + const FrameSizeParam frame_size_param_; + const ::libaom_test::TestMode encoding_mode_; + int expected_res_; +}; + +TEST_P(AV1LosslessFrameSizeTests, LosslessEncode) { + ::libaom_test::RandomVideoSource video; + + video.SetSize(frame_size_param_.width, frame_size_param_.height); + video.set_limit(10); + expected_res_ = AOM_CODEC_OK; + ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); +} + +AV1_INSTANTIATE_TEST_SUITE(AV1LosslessFrameSizeTests, + ::testing::ValuesIn(FrameSizeTestParams), + testing::Values(::libaom_test::kAllIntra)); + } // namespace
diff --git a/test/fwd_kf_test.cc b/test/fwd_kf_test.cc index 8b0fb69..4bfb225 100644 --- a/test/fwd_kf_test.cc +++ b/test/fwd_kf_test.cc
@@ -45,8 +45,7 @@ virtual ~ForwardKeyTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cpu_used_ = 2; @@ -142,8 +141,7 @@ virtual ~ForwardKeyPresenceTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = end_usage_check_;
diff --git a/test/gf_pyr_height_test.cc b/test/gf_pyr_height_test.cc index aac9cb6..a2d1a8f 100644 --- a/test/gf_pyr_height_test.cc +++ b/test/gf_pyr_height_test.cc
@@ -82,8 +82,7 @@ virtual ~GFPyrHeightTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cpu_used_ = 4;
diff --git a/test/horz_superres_test.cc b/test/horz_superres_test.cc index b8a268e..9733344 100644 --- a/test/horz_superres_test.cc +++ b/test/horz_superres_test.cc
@@ -52,7 +52,7 @@ } const TestVideoParam kTestVideoVectors[] = { - { "park_joy_90p_8_420.y4m", AOM_IMG_FMT_I420, AOM_BITS_8, 0, 5, 0, 25.7, + { "park_joy_90p_8_420.y4m", AOM_IMG_FMT_I420, AOM_BITS_8, 0, 5, 0, 25.5, 45.0 }, #if CONFIG_AV1_HIGHBITDEPTH { "park_joy_90p_10_444.y4m", AOM_IMG_FMT_I44416, AOM_BITS_10, 1, 5, 0, 27.0, @@ -103,8 +103,7 @@ virtual ~HorzSuperresEndToEndTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kTwoPassGood); + InitializeConfig(::libaom_test::kTwoPassGood); cfg_.g_lag_in_frames = 5; cfg_.rc_end_usage = AOM_Q; cfg_.rc_target_bitrate = kBitrate; @@ -207,8 +206,7 @@ virtual ~HorzSuperresFixedEndToEndTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kTwoPassGood); + InitializeConfig(::libaom_test::kTwoPassGood); cfg_.g_lag_in_frames = 5; cfg_.rc_end_usage = AOM_VBR; cfg_.rc_target_bitrate = kBitrate; @@ -318,8 +316,7 @@ virtual ~HorzSuperresQThreshEndToEndTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kTwoPassGood); + InitializeConfig(::libaom_test::kTwoPassGood); cfg_.g_lag_in_frames = 5; cfg_.rc_end_usage = AOM_VBR; cfg_.rc_target_bitrate = kBitrate;
diff --git a/test/kf_test.cc b/test/kf_test.cc index 0b36881..cc2cc89 100644 --- a/test/kf_test.cc +++ b/test/kf_test.cc
@@ -48,8 +48,7 @@ virtual ~KeyFrameIntervalTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = end_usage_check_; @@ -126,8 +125,7 @@ virtual ~ForcedKeyTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); cfg_.rc_end_usage = rc_end_usage_; cfg_.g_threads = 0; cfg_.kf_max_dist = 30;
diff --git a/test/level_test.cc b/test/level_test.cc index 82ada98..f512c5a 100644 --- a/test/level_test.cc +++ b/test/level_test.cc
@@ -42,14 +42,10 @@ virtual ~LevelTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); if (encoding_mode_ != ::libaom_test::kRealTime) { cfg_.g_lag_in_frames = 5; - cfg_.rc_end_usage = AOM_VBR; } else { - cfg_.g_lag_in_frames = 0; - cfg_.rc_end_usage = AOM_CBR; cfg_.rc_buf_sz = 1000; cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 600;
diff --git a/test/lossless_test.cc b/test/lossless_test.cc index b56b43a..92ab299 100644 --- a/test/lossless_test.cc +++ b/test/lossless_test.cc
@@ -35,8 +35,7 @@ virtual ~LosslessTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); cfg_.rc_end_usage = rc_end_usage_; }
diff --git a/test/metadata_test.cc b/test/metadata_test.cc index c102b7a..fd3d5c4 100644 --- a/test/metadata_test.cc +++ b/test/metadata_test.cc
@@ -60,10 +60,7 @@ virtual ~MetadataEncodeTest() {} - virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); - } + virtual void SetUp() { InitializeConfig(GET_PARAM(1)); } virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video) { aom_image_t *current_frame = video->img();
diff --git a/test/monochrome_test.cc b/test/monochrome_test.cc index 4688961..6395c22 100644 --- a/test/monochrome_test.cc +++ b/test/monochrome_test.cc
@@ -28,10 +28,7 @@ virtual ~MonochromeTest() {} - virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); - } + virtual void SetUp() { InitializeConfig(GET_PARAM(1)); } virtual void DecompressedFrameHook(const aom_image_t &img, aom_codec_pts_t pts) {
diff --git a/test/motion_vector_test.cc b/test/motion_vector_test.cc index 7516a36..f1f3ae03 100644 --- a/test/motion_vector_test.cc +++ b/test/motion_vector_test.cc
@@ -46,14 +46,10 @@ virtual ~MotionVectorTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); if (encoding_mode_ != ::libaom_test::kRealTime) { cfg_.g_lag_in_frames = 3; - cfg_.rc_end_usage = AOM_VBR; } else { - cfg_.g_lag_in_frames = 0; - cfg_.rc_end_usage = AOM_CBR; cfg_.rc_buf_sz = 1000; cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 600;
diff --git a/test/quant_test.cc b/test/quant_test.cc index 2ef3a76..9fca953 100644 --- a/test/quant_test.cc +++ b/test/quant_test.cc
@@ -28,8 +28,7 @@ virtual ~QMTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); set_cpu_used_ = GET_PARAM(2); } @@ -112,8 +111,7 @@ virtual ~QuantizerBoundsCheckTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_;
diff --git a/test/resize_test.cc b/test/resize_test.cc index adc9bb5..cb09a9a 100644 --- a/test/resize_test.cc +++ b/test/resize_test.cc
@@ -201,10 +201,7 @@ virtual ~ResizeTest() {} - virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); - } + virtual void SetUp() { InitializeConfig(GET_PARAM(1)); } virtual void DecompressedFrameHook(const aom_image_t &img, aom_codec_pts_t pts) { @@ -409,8 +406,7 @@ } virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); set_cpu_used_ = GET_PARAM(2); } @@ -804,8 +800,7 @@ virtual ~ResizeModeTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = AOM_VBR;
diff --git a/test/rt_end_to_end_test.cc b/test/rt_end_to_end_test.cc index fade1e8..e8a1a40 100644 --- a/test/rt_end_to_end_test.cc +++ b/test/rt_end_to_end_test.cc
@@ -47,7 +47,7 @@ { { 5, { { 0, 34.4 }, { 3, 34.4 } } }, { 6, { { 0, 34.2 }, { 3, 34.2 } } }, { 7, { { 0, 33.6 }, { 3, 33.6 } } }, - { 8, { { 0, 33.5 }, { 3, 33.5 } } }, + { 8, { { 0, 33.48 }, { 3, 33.48 } } }, { 9, { { 0, 33.4 }, { 3, 33.4 } } } } } }; typedef struct { @@ -86,14 +86,14 @@ virtual ~RTEndToEndTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kRealTime); + InitializeConfig(::libaom_test::kRealTime); - cfg_.rc_end_usage = AOM_CBR; cfg_.g_threads = threads_; cfg_.rc_buf_sz = 1000; cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_optimal_sz = 600; + cfg_.kf_max_dist = 9999; + cfg_.kf_min_dist = 9999; } virtual void BeginPassHook(unsigned int) { @@ -111,6 +111,10 @@ if (video->frame() == 0) { encoder->Control(AV1E_SET_ENABLE_RESTORATION, 0); encoder->Control(AV1E_SET_ENABLE_OBMC, 0); + encoder->Control(AV1E_SET_ENABLE_GLOBAL_MOTION, 0); + encoder->Control(AV1E_SET_ENABLE_WARPED_MOTION, 0); + encoder->Control(AV1E_SET_DELTAQ_MODE, 0); + encoder->Control(AV1E_SET_ENABLE_TPL_MODEL, 0); encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1); encoder->Control(AV1E_SET_TILE_COLUMNS, tile_columns_); encoder->Control(AOME_SET_CPUUSED, cpu_used_); @@ -118,6 +122,9 @@ encoder->Control(AV1E_SET_AQ_MODE, aq_mode_); encoder->Control(AV1E_SET_ROW_MT, 1); encoder->Control(AV1E_SET_ENABLE_CDEF, 1); + encoder->Control(AV1E_SET_COEFF_COST_UPD_FREQ, 2); + encoder->Control(AV1E_SET_MODE_COST_UPD_FREQ, 2); + encoder->Control(AV1E_SET_MV_COST_UPD_FREQ, 2); } }
diff --git a/test/sb_multipass_test.cc b/test/sb_multipass_test.cc index d2f56db..8ddc002 100644 --- a/test/sb_multipass_test.cc +++ b/test/sb_multipass_test.cc
@@ -45,8 +45,7 @@ virtual ~AV1SBMultipassTest() { delete decoder_; } virtual void SetUp() { - InitializeConfig(); - SetMode(::libaom_test::kTwoPassGood); + InitializeConfig(::libaom_test::kTwoPassGood); cfg_.g_lag_in_frames = 5; cfg_.rc_end_usage = AOM_VBR;
diff --git a/test/scalability_test.cc b/test/scalability_test.cc index d38d8ab..24dbef5 100644 --- a/test/scalability_test.cc +++ b/test/scalability_test.cc
@@ -29,8 +29,7 @@ virtual ~ScalabilityTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); num_spatial_layers_ = 2; }
diff --git a/test/screen_content_test.cc b/test/screen_content_test.cc index ecf2ef5..cd343a9 100644 --- a/test/screen_content_test.cc +++ b/test/screen_content_test.cc
@@ -32,8 +32,7 @@ virtual ~ScreenContentToolsTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_;
diff --git a/test/still_picture_test.cc b/test/still_picture_test.cc index 9800480..e2eef94 100644 --- a/test/still_picture_test.cc +++ b/test/still_picture_test.cc
@@ -30,8 +30,7 @@ virtual ~StillPicturePresenceTest() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = AOM_Q;
diff --git a/test/superframe_test.cc b/test/superframe_test.cc deleted file mode 100644 index b164286..0000000 --- a/test/superframe_test.cc +++ /dev/null
@@ -1,111 +0,0 @@ -/* - * Copyright (c) 2016, Alliance for Open Media. All rights reserved - * - * This source code is subject to the terms of the BSD 2 Clause License and - * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License - * was not distributed with this source code in the LICENSE file, you can - * obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent. - */ - -#include <climits> -#include <tuple> -#include <vector> -#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 { - -const int kTestMode = 0; -const int kTileCols = 1; -const int kTileRows = 2; - -typedef std::tuple<libaom_test::TestMode, int, int> SuperframeTestParam; - -class SuperframeTest - : public ::libaom_test::CodecTestWithParam<SuperframeTestParam>, - public ::libaom_test::EncoderTest { - protected: - SuperframeTest() : EncoderTest(GET_PARAM(0)), last_sf_pts_(0) {} - virtual ~SuperframeTest() {} - - virtual void SetUp() { - InitializeConfig(); - const SuperframeTestParam input = GET_PARAM(1); - const libaom_test::TestMode mode = std::get<kTestMode>(input); - SetMode(mode); - sf_count_ = 0; - sf_count_max_ = INT_MAX; - n_tile_cols_ = std::get<kTileCols>(input); - n_tile_rows_ = std::get<kTileRows>(input); - } - - virtual void PreEncodeFrameHook(libaom_test::VideoSource *video, - libaom_test::Encoder *encoder) { - if (video->frame() == 0) { - encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1); - encoder->Control(AOME_SET_CPUUSED, 2); - encoder->Control(AV1E_SET_TILE_COLUMNS, n_tile_cols_); - encoder->Control(AV1E_SET_TILE_ROWS, n_tile_rows_); - } - } - - virtual const aom_codec_cx_pkt_t *MutateEncoderOutputHook( - const aom_codec_cx_pkt_t *pkt) { - if (pkt->kind != AOM_CODEC_CX_FRAME_PKT) return pkt; - - const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf); - const uint8_t marker = buffer[0]; - const int frames = (marker & 0x7) + 1; - const int mag = ((marker >> 3) & 3) + 1; - const unsigned int index_sz = 2 + mag * (frames - 1); - if ((marker & 0xe0) == 0xc0 && pkt->data.frame.sz >= index_sz && - buffer[index_sz - 1] == marker) { - // frame is a superframe. strip off the index. - modified_buf_.resize(pkt->data.frame.sz - index_sz); - memcpy(&modified_buf_[0], (uint8_t *)pkt->data.frame.buf + index_sz, - pkt->data.frame.sz - index_sz); - modified_pkt_ = *pkt; - modified_pkt_.data.frame.buf = &modified_buf_[0]; - modified_pkt_.data.frame.sz -= index_sz; - - sf_count_++; - last_sf_pts_ = pkt->data.frame.pts; - return &modified_pkt_; - } - - // Make sure we do a few frames after the last SF - abort_ |= - sf_count_ > sf_count_max_ && pkt->data.frame.pts - last_sf_pts_ >= 5; - return pkt; - } - - int sf_count_; - int sf_count_max_; - aom_codec_cx_pkt_t modified_pkt_; - std::vector<uint8_t> modified_buf_; - aom_codec_pts_t last_sf_pts_; - - private: - int n_tile_cols_; - int n_tile_rows_; -}; -GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SuperframeTest); - -TEST_P(SuperframeTest, TestSuperframeIndexIsOptional) { - sf_count_max_ = 0; // early exit on successful test. - cfg_.g_lag_in_frames = 25; - cfg_.large_scale_tile = 1; - ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, - 30, 1, 0, 40); - ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); - // NOTE: The use of BWDREF_FRAME will enable the coding of more non-show - // frames besides ALTREF_FRAME. - EXPECT_GE(sf_count_, 1); -} - -} // namespace
diff --git a/test/svc_datarate_test.cc b/test/svc_datarate_test.cc index a64a999..8d7376a 100644 --- a/test/svc_datarate_test.cc +++ b/test/svc_datarate_test.cc
@@ -46,8 +46,7 @@ protected: virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); + InitializeConfig(GET_PARAM(1)); ResetModel(); } @@ -485,7 +484,7 @@ 1, 0, 400); cfg_.g_w = 640; cfg_.g_h = 480; - const int bitrate_array[2] = { 80, 100 }; + const int bitrate_array[2] = { 80, 90 }; cfg_.rc_target_bitrate = bitrate_array[GET_PARAM(4)]; ResetModel(); number_temporal_layers_ = 3;
diff --git a/test/test.cmake b/test/test.cmake index 17ae636..be485f3 100644 --- a/test/test.cmake +++ b/test/test.cmake
@@ -143,7 +143,6 @@ "${AOM_ROOT}/test/screen_content_test.cc" "${AOM_ROOT}/test/segment_binarization_sync.cc" "${AOM_ROOT}/test/still_picture_test.cc" - "${AOM_ROOT}/test/superframe_test.cc" "${AOM_ROOT}/test/tile_config_test.cc" "${AOM_ROOT}/test/tile_independence_test.cc" "${AOM_ROOT}/test/temporal_filter_test.cc")
diff --git a/test/tile_config_test.cc b/test/tile_config_test.cc index 8c92c14..0098903 100644 --- a/test/tile_config_test.cc +++ b/test/tile_config_test.cc
@@ -77,8 +77,7 @@ virtual ~UniformTileConfigTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = end_usage_check_; @@ -144,8 +143,7 @@ virtual ~NonUniformTileConfigTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = rc_end_usage_; @@ -301,8 +299,7 @@ virtual ~TileGroupTestLarge() {} virtual void SetUp() { - InitializeConfig(); - SetMode(encoding_mode_); + InitializeConfig(encoding_mode_); const aom_rational timebase = { 1, 30 }; cfg_.g_timebase = timebase; cfg_.rc_end_usage = AOM_Q;
diff --git a/test/tile_independence_test.cc b/test/tile_independence_test.cc index 5f167be..888c3ab 100644 --- a/test/tile_independence_test.cc +++ b/test/tile_independence_test.cc
@@ -52,10 +52,7 @@ delete inv_dec_; } - virtual void SetUp() { - InitializeConfig(); - SetMode(libaom_test::kTwoPassGood); - } + virtual void SetUp() { InitializeConfig(libaom_test::kTwoPassGood); } virtual void PreEncodeFrameHook(libaom_test::VideoSource *video, libaom_test::Encoder *encoder) {
diff --git a/test/time_stamp_test.cc b/test/time_stamp_test.cc index 3e2fa97..205e5ba 100644 --- a/test/time_stamp_test.cc +++ b/test/time_stamp_test.cc
@@ -74,10 +74,7 @@ TimestampTest() : EncoderTest(GET_PARAM(0)) {} virtual ~TimestampTest() {} - virtual void SetUp() { - InitializeConfig(); - SetMode(GET_PARAM(1)); - } + virtual void SetUp() { InitializeConfig(GET_PARAM(1)); } }; // Tests encoding in millisecond timebase.
diff --git a/tools/auto_refactor/auto_refactor.py b/tools/auto_refactor/auto_refactor.py index 0e9c289..1555207 100644 --- a/tools/auto_refactor/auto_refactor.py +++ b/tools/auto_refactor/auto_refactor.py
@@ -448,7 +448,9 @@ self.children = {} self.assign = False + self.last_assign_coord = None self.refer = False + self.last_refer_coord = None self.decl_status = None @@ -485,17 +487,19 @@ return self return concrete_node - def set_assign(self, assign): + def set_assign(self, assign, coord=None): concrete_node = self.get_concrete_node() concrete_node.assign = assign + concrete_node.last_assign_coord = coord def get_assign(self): concrete_node = self.get_concrete_node() return concrete_node.assign - def set_refer(self, refer): + def set_refer(self, refer, coord=None): concrete_node = self.get_concrete_node() concrete_node.refer = refer + concrete_node.last_refer_coord = coord def get_refer(self): concrete_node = self.get_concrete_node() @@ -561,16 +565,47 @@ else: return str(self.name) + ' -> ' + ' '.join(self.link_id_chain) - def show(self, id_chain=None): + def collect_assign_refer_status(self, + id_chain=None, + assign_ls=None, + refer_ls=None): if id_chain == None: id_chain = [] + if assign_ls == None: + assign_ls = [] + if refer_ls == None: + refer_ls = [] id_chain.append(self.name) - if self.assign or self.refer: - print(' '.join(id_chain[1:]), 'a:', int(self.assign), 'r:', - int(self.refer)) + if self.assign: + info_str = ' '.join([ + ' '.join(id_chain[1:]), 'a:', + str(int(self.assign)), 'r:', + str(int(self.refer)), + str(self.last_assign_coord) + ]) + assign_ls.append(info_str) + if self.refer: + info_str = ' '.join([ + ' '.join(id_chain[1:]), 'a:', + str(int(self.assign)), 'r:', + str(int(self.refer)), + str(self.last_refer_coord) + ]) + refer_ls.append(info_str) for c in self.children: - self.children[c].show(id_chain) + self.children[c].collect_assign_refer_status(id_chain, assign_ls, + refer_ls) id_chain.pop() + return assign_ls, refer_ls + + def show(self): + assign_ls, refer_ls = self.collect_assign_refer_status() + print('---- assign ----') + for item in assign_ls: + print(item) + print('---- refer ----') + for item in refer_ls: + print(item) class FuncInOutVisitor(c_ast.NodeVisitor): @@ -652,16 +687,16 @@ if decl_status.struct_item is None: init_descendant = self.id_tree_stack.add_id_node(init_id_chain) if init_descendant != None: - init_descendant.set_refer(True) + init_descendant.set_refer(True, node.coord) else: self.unknown.append(node) - descendant.set_assign(True) + descendant.set_assign(True, node.coord) else: self.id_tree_stack.add_link_node(descendant, init_id_chain) else: self.unknown.append(node) else: - descendant.set_assign(True) + descendant.set_assign(True, node.coord) self.generic_visit(node) def is_lvalue(self, node): @@ -702,43 +737,43 @@ return decl_status = descendant.get_decl_status() if decl_status == None: - descendant.set_assign(True) - descendant.set_refer(True) + descendant.set_assign(True, node.coord) + descendant.set_refer(True, node.coord) self.unknown.append(node) return if self.parent_node.__class__.__name__ == 'Assignment': if node is self.parent_node.lvalue: if decl_status.struct_item != None: if len(id_chain) > 1: - descendant.set_assign(True) + descendant.set_assign(True, node.coord) elif len(id_chain) == 1: if lead_char == '*': - descendant.set_assign(True) + descendant.set_assign(True, node.coord) else: right_id_chain = self.process_lvalue(self.parent_node.rvalue) if right_id_chain != None: self.id_tree_stack.add_link_node(descendant, right_id_chain) else: #TODO(angiebird): 1.Find a better way to deal with this case. - descendant.set_assign(True) + descendant.set_assign(True, node.coord) else: debug_print(getframeinfo(currentframe())) else: - descendant.set_assign(True) + descendant.set_assign(True, node.coord) elif node is self.parent_node.rvalue: if decl_status.struct_item is None: - descendant.set_refer(True) + descendant.set_refer(True, node.coord) if lead_char == '&': - descendant.set_assign(True) + descendant.set_assign(True, node.coord) else: left_id_chain = self.process_lvalue(self.parent_node.lvalue) left_lead_char = get_lvalue_lead(self.parent_node.lvalue) if left_id_chain != None: if len(left_id_chain) > 1: - descendant.set_refer(True) + descendant.set_refer(True, node.coord) elif len(left_id_chain) == 1: if left_lead_char == '*': - descendant.set_refer(True) + descendant.set_refer(True, node.coord) else: #TODO(angiebird): Check whether the other node is linked to this node. pass @@ -754,10 +789,10 @@ # TODO(angiebird): Consider +=, *=, -=, /= etc if self.parent_node.op == '--' or self.parent_node.op == '++' or\ self.parent_node.op == 'p--' or self.parent_node.op == 'p++': - descendant.set_assign(True) - descendant.set_refer(True) + descendant.set_assign(True, node.coord) + descendant.set_refer(True, node.coord) else: - descendant.set_refer(True) + descendant.set_refer(True, node.coord) elif self.parent_node.__class__.__name__ == 'Decl': #The logic is at visit_Decl pass @@ -765,7 +800,7 @@ #The logic is at visit_FuncCall pass else: - descendant.set_refer(True) + descendant.set_refer(True, node.coord) def visit_ID(self, node): # If the parent is a FuncCall, this ID is a function name. @@ -822,10 +857,10 @@ if decl_status != None: if decl_status.struct_item == None: if decl_status.is_ptr_decl == True: - descendant.set_assign(True) - descendant.set_refer(True) + descendant.set_assign(True, param_node.coord) + descendant.set_refer(True, param_node.coord) else: - descendant.set_refer(True) + descendant.set_refer(True, param_node.coord) else: call_param_map[decl_node.name] = descendant else:
diff --git a/tools/obu_parser.cc b/tools/obu_parser.cc index 7d71386..5716b46 100644 --- a/tools/obu_parser.cc +++ b/tools/obu_parser.cc
@@ -112,7 +112,7 @@ printf( " temporal_id: %d\n" " spatial_id: %d\n", - header->temporal_layer_id, header->temporal_layer_id); + header->temporal_layer_id, header->spatial_layer_id); } }