From 68569dee1416593955c1570d638b3d9250b33012 Mon Sep 17 00:00:00 2001 From: trav90 Date: Mon, 15 Oct 2018 21:45:30 -0500 Subject: Import aom library This is the reference implementation for the Alliance for Open Media's av1 video code. The commit used was 4d668d7feb1f8abd809d1bca0418570a7f142a36. --- third_party/aom/av1/encoder/picklpf.c | 211 ++++++++++++++++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 third_party/aom/av1/encoder/picklpf.c (limited to 'third_party/aom/av1/encoder/picklpf.c') diff --git a/third_party/aom/av1/encoder/picklpf.c b/third_party/aom/av1/encoder/picklpf.c new file mode 100644 index 000000000..fc0ea485d --- /dev/null +++ b/third_party/aom/av1/encoder/picklpf.c @@ -0,0 +1,211 @@ +/* + * 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 +#include + +#include "./aom_scale_rtcd.h" + +#include "aom_dsp/psnr.h" +#include "aom_dsp/aom_dsp_common.h" +#include "aom_mem/aom_mem.h" +#include "aom_ports/mem.h" + +#include "av1/common/av1_loopfilter.h" +#include "av1/common/onyxc_int.h" +#include "av1/common/quant_common.h" + +#include "av1/encoder/av1_quantize.h" +#include "av1/encoder/encoder.h" +#include "av1/encoder/picklpf.h" + +int av1_get_max_filter_level(const AV1_COMP *cpi) { + if (cpi->oxcf.pass == 2) { + return cpi->twopass.section_intra_rating > 8 ? MAX_LOOP_FILTER * 3 / 4 + : MAX_LOOP_FILTER; + } else { + return MAX_LOOP_FILTER; + } +} + +static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, + AV1_COMP *const cpi, int filt_level, + int partial_frame) { + AV1_COMMON *const cm = &cpi->common; + int64_t filt_err; + +#if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4 + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1, + partial_frame); +#else + if (cpi->num_workers > 1) + av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane, + filt_level, 1, partial_frame, cpi->workers, + cpi->num_workers, &cpi->lf_row_sync); + else + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, + 1, partial_frame); +#endif + +#if CONFIG_HIGHBITDEPTH + if (cm->use_highbitdepth) { + filt_err = aom_highbd_get_y_sse(sd, cm->frame_to_show); + } else { + filt_err = aom_get_y_sse(sd, cm->frame_to_show); + } +#else + filt_err = aom_get_y_sse(sd, cm->frame_to_show); +#endif // CONFIG_HIGHBITDEPTH + + // Re-instate the unfiltered frame + aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); + + return filt_err; +} + +int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, + int partial_frame, double *best_cost_ret) { + const AV1_COMMON *const cm = &cpi->common; + const struct loopfilter *const lf = &cm->lf; + const int min_filter_level = 0; + const int max_filter_level = av1_get_max_filter_level(cpi); + int filt_direction = 0; + int64_t best_err; + int filt_best; + MACROBLOCK *x = &cpi->td.mb; + + // Start the search at the previous frame filter level unless it is now out of + // range. + int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level); + int filter_step = filt_mid < 16 ? 4 : filt_mid / 4; + // Sum squared error at each filter level + int64_t ss_err[MAX_LOOP_FILTER + 1]; + + // Set each entry to -1 + memset(ss_err, 0xFF, sizeof(ss_err)); + + // Make a copy of the unfiltered / processed recon buffer + aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); + + best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame); + filt_best = filt_mid; + ss_err[filt_mid] = best_err; + + while (filter_step > 0) { + const int filt_high = AOMMIN(filt_mid + filter_step, max_filter_level); + const int filt_low = AOMMAX(filt_mid - filter_step, min_filter_level); + + // Bias against raising loop filter in favor of lowering it. + int64_t bias = (best_err >> (15 - (filt_mid / 8))) * filter_step; + + if ((cpi->oxcf.pass == 2) && (cpi->twopass.section_intra_rating < 20)) + bias = (bias * cpi->twopass.section_intra_rating) / 20; + + // yx, bias less for large block size + if (cm->tx_mode != ONLY_4X4) bias >>= 1; + + if (filt_direction <= 0 && filt_low != filt_mid) { + // Get Low filter error score + if (ss_err[filt_low] < 0) { + ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame); + } + // If value is close to the best so far then bias towards a lower loop + // filter value. + if (ss_err[filt_low] < (best_err + bias)) { + // Was it actually better than the previous best? + if (ss_err[filt_low] < best_err) { + best_err = ss_err[filt_low]; + } + filt_best = filt_low; + } + } + + // Now look at filt_high + if (filt_direction >= 0 && filt_high != filt_mid) { + if (ss_err[filt_high] < 0) { + ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame); + } + // If value is significantly better than previous best, bias added against + // raising filter value + if (ss_err[filt_high] < (best_err - bias)) { + best_err = ss_err[filt_high]; + filt_best = filt_high; + } + } + + // Half the step distance if the best filter value was the same as last time + if (filt_best == filt_mid) { + filter_step /= 2; + filt_direction = 0; + } else { + filt_direction = (filt_best < filt_mid) ? -1 : 1; + filt_mid = filt_best; + } + } + + // Update best error + best_err = ss_err[filt_best]; + + if (best_cost_ret) + *best_cost_ret = RDCOST_DBL(x->rdmult, x->rddiv, 0, best_err); + return filt_best; +} + +void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, + LPF_PICK_METHOD method) { + AV1_COMMON *const cm = &cpi->common; + struct loopfilter *const lf = &cm->lf; + + lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 : cpi->oxcf.sharpness; + + if (method == LPF_PICK_MINIMAL_LPF && lf->filter_level) { + lf->filter_level = 0; + } else if (method >= LPF_PICK_FROM_Q) { + const int min_filter_level = 0; + const int max_filter_level = av1_get_max_filter_level(cpi); + const int q = av1_ac_quant(cm->base_qindex, 0, cm->bit_depth); +// These values were determined by linear fitting the result of the +// searched level, filt_guess = q * 0.316206 + 3.87252 +#if CONFIG_HIGHBITDEPTH + int filt_guess; + switch (cm->bit_depth) { + case AOM_BITS_8: + filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18); + break; + case AOM_BITS_10: + filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 4060632, 20); + break; + case AOM_BITS_12: + filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 16242526, 22); + break; + default: + assert(0 && + "bit_depth should be AOM_BITS_8, AOM_BITS_10 " + "or AOM_BITS_12"); + return; + } +#else + int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18); +#endif // CONFIG_HIGHBITDEPTH + if (cm->frame_type == KEY_FRAME) filt_guess -= 4; + lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level); + } else { + lf->filter_level = av1_search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL); + } + +#if CONFIG_EXT_TILE + // TODO(any): 0 loopfilter level is only necessary if individual tile + // decoding is required. We need to communicate this requirement to this + // code and force loop filter level 0 only if required. + if (cm->tile_encoding_mode) lf->filter_level = 0; +#endif // CONFIG_EXT_TILE +} -- cgit v1.2.3 From 7369c7d7a5eed32963d8af37658286617919f91c Mon Sep 17 00:00:00 2001 From: trav90 Date: Thu, 18 Oct 2018 06:04:57 -0500 Subject: Update aom to commit id f5bdeac22930ff4c6b219be49c843db35970b918 --- third_party/aom/av1/encoder/picklpf.c | 111 ++++++++++++++++++++++++++++++---- 1 file changed, 98 insertions(+), 13 deletions(-) (limited to 'third_party/aom/av1/encoder/picklpf.c') diff --git a/third_party/aom/av1/encoder/picklpf.c b/third_party/aom/av1/encoder/picklpf.c index fc0ea485d..26fd55ef0 100644 --- a/third_party/aom/av1/encoder/picklpf.c +++ b/third_party/aom/av1/encoder/picklpf.c @@ -38,13 +38,23 @@ int av1_get_max_filter_level(const AV1_COMP *cpi) { static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, AV1_COMP *const cpi, int filt_level, - int partial_frame) { + int partial_frame +#if CONFIG_UV_LVL + , + int plane +#endif + ) { AV1_COMMON *const cm = &cpi->common; int64_t filt_err; #if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4 +#if CONFIG_UV_LVL + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, + plane, partial_frame); +#else av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1, partial_frame); +#endif // CONFIG_UV_LVL #else if (cpi->num_workers > 1) av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane, @@ -55,6 +65,40 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, 1, partial_frame); #endif +#if CONFIG_UV_LVL +#if CONFIG_HIGHBITDEPTH + if (cm->use_highbitdepth) { + if (plane == 0) + filt_err = aom_highbd_get_y_sse(sd, cm->frame_to_show); + else if (plane == 1) + filt_err = aom_highbd_get_u_sse(sd, cm->frame_to_show); + else + filt_err = aom_highbd_get_v_sse(sd, cm->frame_to_show); + } else { + if (plane == 0) + filt_err = aom_get_y_sse(sd, cm->frame_to_show); + else if (plane == 1) + filt_err = aom_get_u_sse(sd, cm->frame_to_show); + else + filt_err = aom_get_v_sse(sd, cm->frame_to_show); + } +#else + if (plane == 0) + filt_err = aom_get_y_sse(sd, cm->frame_to_show); + else if (plane == 1) + filt_err = aom_get_u_sse(sd, cm->frame_to_show); + else + filt_err = aom_get_v_sse(sd, cm->frame_to_show); +#endif // CONFIG_HIGHBITDEPTH + + // Re-instate the unfiltered frame + if (plane == 0) + aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); + else if (plane == 1) + aom_yv12_copy_u(&cpi->last_frame_uf, cm->frame_to_show); + else + aom_yv12_copy_v(&cpi->last_frame_uf, cm->frame_to_show); +#else #if CONFIG_HIGHBITDEPTH if (cm->use_highbitdepth) { filt_err = aom_highbd_get_y_sse(sd, cm->frame_to_show); @@ -67,12 +111,18 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, // Re-instate the unfiltered frame aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); +#endif // CONFIG_UV_LVL return filt_err; } int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, - int partial_frame, double *best_cost_ret) { + int partial_frame, double *best_cost_ret +#if CONFIG_UV_LVL + , + int plane +#endif + ) { const AV1_COMMON *const cm = &cpi->common; const struct loopfilter *const lf = &cm->lf; const int min_filter_level = 0; @@ -82,9 +132,20 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, int filt_best; MACROBLOCK *x = &cpi->td.mb; - // Start the search at the previous frame filter level unless it is now out of - // range. +// Start the search at the previous frame filter level unless it is now out of +// range. +#if CONFIG_UV_LVL + int lvl; + switch (plane) { + case 0: lvl = lf->filter_level; break; + case 1: lvl = lf->filter_level_u; break; + case 2: lvl = lf->filter_level_v; break; + default: lvl = lf->filter_level; break; + } + int filt_mid = clamp(lvl, min_filter_level, max_filter_level); +#else int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level); +#endif // CONFIG_UV_LVL int filter_step = filt_mid < 16 ? 4 : filt_mid / 4; // Sum squared error at each filter level int64_t ss_err[MAX_LOOP_FILTER + 1]; @@ -92,10 +153,23 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Set each entry to -1 memset(ss_err, 0xFF, sizeof(ss_err)); +#if CONFIG_UV_LVL + if (plane == 0) + aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); + else if (plane == 1) + aom_yv12_copy_u(cm->frame_to_show, &cpi->last_frame_uf); + else if (plane == 2) + aom_yv12_copy_v(cm->frame_to_show, &cpi->last_frame_uf); +#else // Make a copy of the unfiltered / processed recon buffer aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); +#endif // CONFIG_UV_LVL +#if CONFIG_UV_LVL + best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame, plane); +#else best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame); +#endif // CONFIG_UV_LVL filt_best = filt_mid; ss_err[filt_mid] = best_err; @@ -115,7 +189,12 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, if (filt_direction <= 0 && filt_low != filt_mid) { // Get Low filter error score if (ss_err[filt_low] < 0) { +#if CONFIG_UV_LVL + ss_err[filt_low] = + try_filter_frame(sd, cpi, filt_low, partial_frame, plane); +#else ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame); +#endif // CONFIG_UV_LVL } // If value is close to the best so far then bias towards a lower loop // filter value. @@ -131,7 +210,12 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Now look at filt_high if (filt_direction >= 0 && filt_high != filt_mid) { if (ss_err[filt_high] < 0) { +#if CONFIG_UV_LVL + ss_err[filt_high] = + try_filter_frame(sd, cpi, filt_high, partial_frame, plane); +#else ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame); +#endif // CONFIG_UV_LVL } // If value is significantly better than previous best, bias added against // raising filter value @@ -154,8 +238,7 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Update best error best_err = ss_err[filt_best]; - if (best_cost_ret) - *best_cost_ret = RDCOST_DBL(x->rdmult, x->rddiv, 0, best_err); + if (best_cost_ret) *best_cost_ret = RDCOST_DBL(x->rdmult, 0, best_err); return filt_best; } @@ -198,14 +281,16 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, if (cm->frame_type == KEY_FRAME) filt_guess -= 4; lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level); } else { +#if CONFIG_UV_LVL + lf->filter_level = av1_search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0); + lf->filter_level_u = av1_search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 1); + lf->filter_level_v = av1_search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 2); +#else lf->filter_level = av1_search_filter_level( sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL); +#endif // CONFIG_UV_LVL } - -#if CONFIG_EXT_TILE - // TODO(any): 0 loopfilter level is only necessary if individual tile - // decoding is required. We need to communicate this requirement to this - // code and force loop filter level 0 only if required. - if (cm->tile_encoding_mode) lf->filter_level = 0; -#endif // CONFIG_EXT_TILE } -- cgit v1.2.3 From ec910d81405c736a4490383a250299a7837c2e64 Mon Sep 17 00:00:00 2001 From: trav90 Date: Thu, 18 Oct 2018 21:53:44 -0500 Subject: Update aom to commit id e87fb2378f01103d5d6e477a4ef6892dc714e614 --- third_party/aom/av1/encoder/picklpf.c | 386 ++++++++++++++++++++++++++-------- 1 file changed, 301 insertions(+), 85 deletions(-) (limited to 'third_party/aom/av1/encoder/picklpf.c') diff --git a/third_party/aom/av1/encoder/picklpf.c b/third_party/aom/av1/encoder/picklpf.c index 26fd55ef0..d8b6f9074 100644 --- a/third_party/aom/av1/encoder/picklpf.c +++ b/third_party/aom/av1/encoder/picklpf.c @@ -14,8 +14,8 @@ #include "./aom_scale_rtcd.h" -#include "aom_dsp/psnr.h" #include "aom_dsp/aom_dsp_common.h" +#include "aom_dsp/psnr.h" #include "aom_mem/aom_mem.h" #include "aom_ports/mem.h" @@ -27,6 +27,85 @@ #include "av1/encoder/encoder.h" #include "av1/encoder/picklpf.h" +#if CONFIG_LPF_SB +#if CONFIG_HIGHBITDEPTH +static int compute_sb_y_sse_highbd(const YV12_BUFFER_CONFIG *src, + const YV12_BUFFER_CONFIG *frame, + AV1_COMMON *const cm, int mi_row, + int mi_col) { + int sse = 0; + const int mi_row_start = AOMMAX(0, mi_row - FILT_BOUNDARY_MI_OFFSET); + const int mi_col_start = AOMMAX(0, mi_col - FILT_BOUNDARY_MI_OFFSET); + const int mi_row_range = mi_row - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; + const int mi_col_range = mi_col - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; + const int mi_row_end = AOMMIN(mi_row_range, cm->mi_rows); + const int mi_col_end = AOMMIN(mi_col_range, cm->mi_cols); + + const int row = mi_row_start * MI_SIZE; + const int col = mi_col_start * MI_SIZE; + const uint16_t *src_y = + CONVERT_TO_SHORTPTR(src->y_buffer) + row * src->y_stride + col; + const uint16_t *frame_y = + CONVERT_TO_SHORTPTR(frame->y_buffer) + row * frame->y_stride + col; + const int row_end = (mi_row_end - mi_row_start) * MI_SIZE; + const int col_end = (mi_col_end - mi_col_start) * MI_SIZE; + + int x, y; + for (y = 0; y < row_end; ++y) { + for (x = 0; x < col_end; ++x) { + const int diff = src_y[x] - frame_y[x]; + sse += diff * diff; + } + src_y += src->y_stride; + frame_y += frame->y_stride; + } + return sse; +} +#endif + +static int compute_sb_y_sse(const YV12_BUFFER_CONFIG *src, + const YV12_BUFFER_CONFIG *frame, + AV1_COMMON *const cm, int mi_row, int mi_col) { + int sse = 0; + const int mi_row_start = AOMMAX(0, mi_row - FILT_BOUNDARY_MI_OFFSET); + const int mi_col_start = AOMMAX(0, mi_col - FILT_BOUNDARY_MI_OFFSET); + const int mi_row_range = mi_row - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; + const int mi_col_range = mi_col - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; + const int mi_row_end = AOMMIN(mi_row_range, cm->mi_rows); + const int mi_col_end = AOMMIN(mi_col_range, cm->mi_cols); + + const int row = mi_row_start * MI_SIZE; + const int col = mi_col_start * MI_SIZE; + const uint8_t *src_y = src->y_buffer + row * src->y_stride + col; + const uint8_t *frame_y = frame->y_buffer + row * frame->y_stride + col; + const int row_end = (mi_row_end - mi_row_start) * MI_SIZE; + const int col_end = (mi_col_end - mi_col_start) * MI_SIZE; + + int x, y; + for (y = 0; y < row_end; ++y) { + for (x = 0; x < col_end; ++x) { + const int diff = src_y[x] - frame_y[x]; + sse += diff * diff; + } + src_y += src->y_stride; + frame_y += frame->y_stride; + } + return sse; +} +#endif // CONFIG_LPF_SB + +#if !CONFIG_LPF_SB +static void yv12_copy_plane(const YV12_BUFFER_CONFIG *src_bc, + YV12_BUFFER_CONFIG *dst_bc, int plane) { + switch (plane) { + case 0: aom_yv12_copy_y(src_bc, dst_bc); break; + case 1: aom_yv12_copy_u(src_bc, dst_bc); break; + case 2: aom_yv12_copy_v(src_bc, dst_bc); break; + default: assert(plane >= 0 && plane <= 2); break; + } +} +#endif // CONFIG_LPF_SB + int av1_get_max_filter_level(const AV1_COMP *cpi) { if (cpi->oxcf.pass == 2) { return cpi->twopass.section_intra_rating > 8 ? MAX_LOOP_FILTER * 3 / 4 @@ -36,25 +115,156 @@ int av1_get_max_filter_level(const AV1_COMP *cpi) { } } +#if CONFIG_LPF_SB +// TODO(chengchen): reduce memory usage by copy superblock instead of frame +static int try_filter_superblock(const YV12_BUFFER_CONFIG *sd, + AV1_COMP *const cpi, int filt_level, + int partial_frame, int mi_row, int mi_col) { + AV1_COMMON *const cm = &cpi->common; + int filt_err; + +#if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4 + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1, + partial_frame, mi_row, mi_col); +#else + if (cpi->num_workers > 1) + av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane, + filt_level, 1, partial_frame, cpi->workers, + cpi->num_workers, &cpi->lf_row_sync); + else + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, + 1, partial_frame); +#endif + +#if CONFIG_HIGHBITDEPTH + if (cm->use_highbitdepth) { + filt_err = + compute_sb_y_sse_highbd(sd, cm->frame_to_show, cm, mi_row, mi_col); + } else { + filt_err = compute_sb_y_sse(sd, cm->frame_to_show, cm, mi_row, mi_col); + } +#else + filt_err = compute_sb_y_sse(sd, cm->frame_to_show, cm, mi_row, mi_col); +#endif // CONFIG_HIGHBITDEPTH + + // TODO(chengchen): Copy the superblock only + // Re-instate the unfiltered frame + aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); + + return filt_err; +} + +static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, + int partial_frame, double *best_cost_ret, + int mi_row, int mi_col, int last_lvl) { + assert(partial_frame == 1); + assert(last_lvl >= 0); + + const AV1_COMMON *const cm = &cpi->common; + MACROBLOCK *x = &cpi->td.mb; + + int min_filter_level = AOMMAX(0, last_lvl - MAX_LPF_OFFSET); + int max_filter_level = + AOMMIN(av1_get_max_filter_level(cpi), last_lvl + MAX_LPF_OFFSET); + + // search a larger range for the start superblock + if (mi_row == 0 && mi_col == 0) { + min_filter_level = 0; + max_filter_level = av1_get_max_filter_level(cpi); + } + + // TODO(chengchen): Copy for superblock only + // Make a copy of the unfiltered / processed recon buffer + aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); + + int estimate_err = + try_filter_superblock(sd, cpi, last_lvl, partial_frame, mi_row, mi_col); + + int best_err = estimate_err; + int filt_best = last_lvl; + + int i; + for (i = min_filter_level; i <= max_filter_level; i += LPF_STEP) { + if (i == last_lvl) continue; + + int filt_err = + try_filter_superblock(sd, cpi, i, partial_frame, mi_row, mi_col); + + if (filt_err < best_err) { + best_err = filt_err; + filt_best = i; + } + } + + // If previous sb filter level has similar filtering performance as current + // best filter level, use previous level such that we can only send one bit + // to indicate current filter level is the same as the previous. + int threshold = 400; + + // ratio = the filtering area / a superblock size + int ratio = 1; + if (mi_row + MAX_MIB_SIZE > cm->mi_rows) { + ratio *= (cm->mi_rows - mi_row); + } else { + if (mi_row == 0) { + ratio *= (MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET); + } else { + ratio *= MAX_MIB_SIZE; + } + } + if (mi_col + MAX_MIB_SIZE > cm->mi_cols) { + ratio *= (cm->mi_cols - mi_col); + } else { + if (mi_col == 0) { + ratio *= (MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET); + } else { + ratio *= MAX_MIB_SIZE; + } + } + threshold = threshold * ratio / (MAX_MIB_SIZE * MAX_MIB_SIZE); + + const int diff = abs(estimate_err - best_err); + + const int percent_thresh = (int)((double)estimate_err * 0.01); + threshold = AOMMAX(threshold, percent_thresh); + if (diff < threshold) { + best_err = estimate_err; + filt_best = last_lvl; + } + + // Compute rdcost to determine whether to reuse previous filter lvl + if (filt_best != last_lvl) { + } + + if (best_cost_ret) *best_cost_ret = RDCOST_DBL(x->rdmult, 0, best_err); + return filt_best; +} + +#else // CONFIG_LPF_SB static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, AV1_COMP *const cpi, int filt_level, int partial_frame -#if CONFIG_UV_LVL +#if CONFIG_LOOPFILTER_LEVEL , - int plane + int plane, int dir #endif ) { AV1_COMMON *const cm = &cpi->common; int64_t filt_err; #if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4 -#if CONFIG_UV_LVL - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, - plane, partial_frame); +#if CONFIG_LOOPFILTER_LEVEL + assert(plane >= 0 && plane <= 2); + int filter_level[2] = { filt_level, filt_level }; + if (plane == 0 && dir == 0) filter_level[1] = cm->lf.filter_level[1]; + if (plane == 0 && dir == 1) filter_level[0] = cm->lf.filter_level[0]; + + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, + filter_level[0], filter_level[1], plane, partial_frame); #else av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1, partial_frame); -#endif // CONFIG_UV_LVL +#endif // CONFIG_LOOPFILTER_LEVEL #else if (cpi->num_workers > 1) av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane, @@ -65,64 +275,33 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, 1, partial_frame); #endif -#if CONFIG_UV_LVL + int highbd = 0; #if CONFIG_HIGHBITDEPTH - if (cm->use_highbitdepth) { - if (plane == 0) - filt_err = aom_highbd_get_y_sse(sd, cm->frame_to_show); - else if (plane == 1) - filt_err = aom_highbd_get_u_sse(sd, cm->frame_to_show); - else - filt_err = aom_highbd_get_v_sse(sd, cm->frame_to_show); - } else { - if (plane == 0) - filt_err = aom_get_y_sse(sd, cm->frame_to_show); - else if (plane == 1) - filt_err = aom_get_u_sse(sd, cm->frame_to_show); - else - filt_err = aom_get_v_sse(sd, cm->frame_to_show); - } -#else - if (plane == 0) - filt_err = aom_get_y_sse(sd, cm->frame_to_show); - else if (plane == 1) - filt_err = aom_get_u_sse(sd, cm->frame_to_show); - else - filt_err = aom_get_v_sse(sd, cm->frame_to_show); + highbd = cm->use_highbitdepth; #endif // CONFIG_HIGHBITDEPTH +#if CONFIG_LOOPFILTER_LEVEL + filt_err = aom_get_sse_plane(sd, cm->frame_to_show, plane, highbd); + // Re-instate the unfiltered frame - if (plane == 0) - aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); - else if (plane == 1) - aom_yv12_copy_u(&cpi->last_frame_uf, cm->frame_to_show); - else - aom_yv12_copy_v(&cpi->last_frame_uf, cm->frame_to_show); -#else -#if CONFIG_HIGHBITDEPTH - if (cm->use_highbitdepth) { - filt_err = aom_highbd_get_y_sse(sd, cm->frame_to_show); - } else { - filt_err = aom_get_y_sse(sd, cm->frame_to_show); - } + yv12_copy_plane(&cpi->last_frame_uf, cm->frame_to_show, plane); #else - filt_err = aom_get_y_sse(sd, cm->frame_to_show); -#endif // CONFIG_HIGHBITDEPTH + filt_err = aom_get_sse_plane(sd, cm->frame_to_show, 0, highbd); // Re-instate the unfiltered frame - aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); -#endif // CONFIG_UV_LVL + yv12_copy_plane(&cpi->last_frame_uf, cm->frame_to_show, 0); +#endif // CONFIG_LOOPFILTER_LEVEL return filt_err; } -int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, - int partial_frame, double *best_cost_ret -#if CONFIG_UV_LVL - , - int plane +static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, + int partial_frame, double *best_cost_ret +#if CONFIG_LOOPFILTER_LEVEL + , + int plane, int dir #endif - ) { + ) { const AV1_COMMON *const cm = &cpi->common; const struct loopfilter *const lf = &cm->lf; const int min_filter_level = 0; @@ -134,18 +313,18 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Start the search at the previous frame filter level unless it is now out of // range. -#if CONFIG_UV_LVL +#if CONFIG_LOOPFILTER_LEVEL int lvl; switch (plane) { - case 0: lvl = lf->filter_level; break; + case 0: lvl = (dir == 1) ? lf->filter_level[1] : lf->filter_level[0]; break; case 1: lvl = lf->filter_level_u; break; case 2: lvl = lf->filter_level_v; break; - default: lvl = lf->filter_level; break; + default: assert(plane >= 0 && plane <= 2); return 0; } int filt_mid = clamp(lvl, min_filter_level, max_filter_level); #else int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level); -#endif // CONFIG_UV_LVL +#endif // CONFIG_LOOPFILTER_LEVEL int filter_step = filt_mid < 16 ? 4 : filt_mid / 4; // Sum squared error at each filter level int64_t ss_err[MAX_LOOP_FILTER + 1]; @@ -153,23 +332,18 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Set each entry to -1 memset(ss_err, 0xFF, sizeof(ss_err)); -#if CONFIG_UV_LVL - if (plane == 0) - aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); - else if (plane == 1) - aom_yv12_copy_u(cm->frame_to_show, &cpi->last_frame_uf); - else if (plane == 2) - aom_yv12_copy_v(cm->frame_to_show, &cpi->last_frame_uf); +#if CONFIG_LOOPFILTER_LEVEL + yv12_copy_plane(cm->frame_to_show, &cpi->last_frame_uf, plane); #else // Make a copy of the unfiltered / processed recon buffer aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); -#endif // CONFIG_UV_LVL +#endif // CONFIG_LOOPFILTER_LEVEL -#if CONFIG_UV_LVL - best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame, plane); +#if CONFIG_LOOPFILTER_LEVEL + best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame, plane, dir); #else best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame); -#endif // CONFIG_UV_LVL +#endif // CONFIG_LOOPFILTER_LEVEL filt_best = filt_mid; ss_err[filt_mid] = best_err; @@ -189,12 +363,12 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, if (filt_direction <= 0 && filt_low != filt_mid) { // Get Low filter error score if (ss_err[filt_low] < 0) { -#if CONFIG_UV_LVL +#if CONFIG_LOOPFILTER_LEVEL ss_err[filt_low] = - try_filter_frame(sd, cpi, filt_low, partial_frame, plane); + try_filter_frame(sd, cpi, filt_low, partial_frame, plane, dir); #else ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame); -#endif // CONFIG_UV_LVL +#endif // CONFIG_LOOPFILTER_LEVEL } // If value is close to the best so far then bias towards a lower loop // filter value. @@ -210,12 +384,12 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Now look at filt_high if (filt_direction >= 0 && filt_high != filt_mid) { if (ss_err[filt_high] < 0) { -#if CONFIG_UV_LVL +#if CONFIG_LOOPFILTER_LEVEL ss_err[filt_high] = - try_filter_frame(sd, cpi, filt_high, partial_frame, plane); + try_filter_frame(sd, cpi, filt_high, partial_frame, plane, dir); #else ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame); -#endif // CONFIG_UV_LVL +#endif // CONFIG_LOOPFILTER_LEVEL } // If value is significantly better than previous best, bias added against // raising filter value @@ -241,6 +415,7 @@ int av1_search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, if (best_cost_ret) *best_cost_ret = RDCOST_DBL(x->rdmult, 0, best_err); return filt_best; } +#endif // CONFIG_LPF_SB void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, LPF_PICK_METHOD method) { @@ -249,8 +424,13 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 : cpi->oxcf.sharpness; - if (method == LPF_PICK_MINIMAL_LPF && lf->filter_level) { + if (method == LPF_PICK_MINIMAL_LPF) { +#if CONFIG_LOOPFILTER_LEVEL + lf->filter_level[0] = 0; + lf->filter_level[1] = 0; +#else lf->filter_level = 0; +#endif } else if (method >= LPF_PICK_FROM_Q) { const int min_filter_level = 0; const int max_filter_level = av1_get_max_filter_level(cpi); @@ -279,18 +459,54 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18); #endif // CONFIG_HIGHBITDEPTH if (cm->frame_type == KEY_FRAME) filt_guess -= 4; +#if CONFIG_LOOPFILTER_LEVEL + lf->filter_level[0] = clamp(filt_guess, min_filter_level, max_filter_level); + lf->filter_level[1] = clamp(filt_guess, min_filter_level, max_filter_level); +#else lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level); +#endif } else { -#if CONFIG_UV_LVL - lf->filter_level = av1_search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0); - lf->filter_level_u = av1_search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 1); - lf->filter_level_v = av1_search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 2); +#if CONFIG_LPF_SB + int mi_row, mi_col; + // TODO(chengchen): init last_lvl using previous frame's info? + int last_lvl = 0; + // TODO(chengchen): if the frame size makes the last superblock very small, + // consider merge it to the previous superblock to save bits. + // Example, if frame size 1080x720, then in the last row of superblock, + // there're (FILT_BOUNDAR_OFFSET + 16) pixels. + for (mi_row = 0; mi_row < cm->mi_rows; mi_row += MAX_MIB_SIZE) { + for (mi_col = 0; mi_col < cm->mi_cols; mi_col += MAX_MIB_SIZE) { + int lvl = + search_filter_level(sd, cpi, 1, NULL, mi_row, mi_col, last_lvl); + + av1_loop_filter_sb_level_init(cm, mi_row, mi_col, lvl); + + // For the superblock at row start, its previous filter level should be + // the one above it, not the one at the end of last row + if (mi_col + MAX_MIB_SIZE >= cm->mi_cols) { + last_lvl = cm->mi_grid_visible[mi_row * cm->mi_stride]->mbmi.filt_lvl; + } else { + last_lvl = lvl; + } + } + } +#else // CONFIG_LPF_SB +#if CONFIG_LOOPFILTER_LEVEL + lf->filter_level[0] = lf->filter_level[1] = search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 2); + lf->filter_level[0] = search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 0); + lf->filter_level[1] = search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 1); + + lf->filter_level_u = search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 1, 0); + lf->filter_level_v = search_filter_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 2, 0); #else - lf->filter_level = av1_search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL); -#endif // CONFIG_UV_LVL + lf->filter_level = + search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL); +#endif // CONFIG_LOOPFILTER_LEVEL +#endif // CONFIG_LPF_SB } } -- cgit v1.2.3 From bbcc64772580c8a979288791afa02d30bc476d2e Mon Sep 17 00:00:00 2001 From: trav90 Date: Fri, 19 Oct 2018 21:52:15 -0500 Subject: Update aom to v1.0.0 Update aom to commit id d14c5bb4f336ef1842046089849dee4a301fbbf0. --- third_party/aom/av1/encoder/picklpf.c | 388 ++++++---------------------------- 1 file changed, 70 insertions(+), 318 deletions(-) (limited to 'third_party/aom/av1/encoder/picklpf.c') diff --git a/third_party/aom/av1/encoder/picklpf.c b/third_party/aom/av1/encoder/picklpf.c index d8b6f9074..5f802a707 100644 --- a/third_party/aom/av1/encoder/picklpf.c +++ b/third_party/aom/av1/encoder/picklpf.c @@ -12,7 +12,7 @@ #include #include -#include "./aom_scale_rtcd.h" +#include "config/aom_scale_rtcd.h" #include "aom_dsp/aom_dsp_common.h" #include "aom_dsp/psnr.h" @@ -27,74 +27,6 @@ #include "av1/encoder/encoder.h" #include "av1/encoder/picklpf.h" -#if CONFIG_LPF_SB -#if CONFIG_HIGHBITDEPTH -static int compute_sb_y_sse_highbd(const YV12_BUFFER_CONFIG *src, - const YV12_BUFFER_CONFIG *frame, - AV1_COMMON *const cm, int mi_row, - int mi_col) { - int sse = 0; - const int mi_row_start = AOMMAX(0, mi_row - FILT_BOUNDARY_MI_OFFSET); - const int mi_col_start = AOMMAX(0, mi_col - FILT_BOUNDARY_MI_OFFSET); - const int mi_row_range = mi_row - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; - const int mi_col_range = mi_col - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; - const int mi_row_end = AOMMIN(mi_row_range, cm->mi_rows); - const int mi_col_end = AOMMIN(mi_col_range, cm->mi_cols); - - const int row = mi_row_start * MI_SIZE; - const int col = mi_col_start * MI_SIZE; - const uint16_t *src_y = - CONVERT_TO_SHORTPTR(src->y_buffer) + row * src->y_stride + col; - const uint16_t *frame_y = - CONVERT_TO_SHORTPTR(frame->y_buffer) + row * frame->y_stride + col; - const int row_end = (mi_row_end - mi_row_start) * MI_SIZE; - const int col_end = (mi_col_end - mi_col_start) * MI_SIZE; - - int x, y; - for (y = 0; y < row_end; ++y) { - for (x = 0; x < col_end; ++x) { - const int diff = src_y[x] - frame_y[x]; - sse += diff * diff; - } - src_y += src->y_stride; - frame_y += frame->y_stride; - } - return sse; -} -#endif - -static int compute_sb_y_sse(const YV12_BUFFER_CONFIG *src, - const YV12_BUFFER_CONFIG *frame, - AV1_COMMON *const cm, int mi_row, int mi_col) { - int sse = 0; - const int mi_row_start = AOMMAX(0, mi_row - FILT_BOUNDARY_MI_OFFSET); - const int mi_col_start = AOMMAX(0, mi_col - FILT_BOUNDARY_MI_OFFSET); - const int mi_row_range = mi_row - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; - const int mi_col_range = mi_col - FILT_BOUNDARY_MI_OFFSET + MAX_MIB_SIZE; - const int mi_row_end = AOMMIN(mi_row_range, cm->mi_rows); - const int mi_col_end = AOMMIN(mi_col_range, cm->mi_cols); - - const int row = mi_row_start * MI_SIZE; - const int col = mi_col_start * MI_SIZE; - const uint8_t *src_y = src->y_buffer + row * src->y_stride + col; - const uint8_t *frame_y = frame->y_buffer + row * frame->y_stride + col; - const int row_end = (mi_row_end - mi_row_start) * MI_SIZE; - const int col_end = (mi_col_end - mi_col_start) * MI_SIZE; - - int x, y; - for (y = 0; y < row_end; ++y) { - for (x = 0; x < col_end; ++x) { - const int diff = src_y[x] - frame_y[x]; - sse += diff * diff; - } - src_y += src->y_stride; - frame_y += frame->y_stride; - } - return sse; -} -#endif // CONFIG_LPF_SB - -#if !CONFIG_LPF_SB static void yv12_copy_plane(const YV12_BUFFER_CONFIG *src_bc, YV12_BUFFER_CONFIG *dst_bc, int plane) { switch (plane) { @@ -104,7 +36,6 @@ static void yv12_copy_plane(const YV12_BUFFER_CONFIG *src_bc, default: assert(plane >= 0 && plane <= 2); break; } } -#endif // CONFIG_LPF_SB int av1_get_max_filter_level(const AV1_COMP *cpi) { if (cpi->oxcf.pass == 2) { @@ -115,195 +46,58 @@ int av1_get_max_filter_level(const AV1_COMP *cpi) { } } -#if CONFIG_LPF_SB -// TODO(chengchen): reduce memory usage by copy superblock instead of frame -static int try_filter_superblock(const YV12_BUFFER_CONFIG *sd, - AV1_COMP *const cpi, int filt_level, - int partial_frame, int mi_row, int mi_col) { - AV1_COMMON *const cm = &cpi->common; - int filt_err; - -#if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4 - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1, - partial_frame, mi_row, mi_col); -#else - if (cpi->num_workers > 1) - av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane, - filt_level, 1, partial_frame, cpi->workers, - cpi->num_workers, &cpi->lf_row_sync); - else - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, - 1, partial_frame); -#endif - -#if CONFIG_HIGHBITDEPTH - if (cm->use_highbitdepth) { - filt_err = - compute_sb_y_sse_highbd(sd, cm->frame_to_show, cm, mi_row, mi_col); - } else { - filt_err = compute_sb_y_sse(sd, cm->frame_to_show, cm, mi_row, mi_col); - } -#else - filt_err = compute_sb_y_sse(sd, cm->frame_to_show, cm, mi_row, mi_col); -#endif // CONFIG_HIGHBITDEPTH - - // TODO(chengchen): Copy the superblock only - // Re-instate the unfiltered frame - aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); - - return filt_err; -} - -static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, - int partial_frame, double *best_cost_ret, - int mi_row, int mi_col, int last_lvl) { - assert(partial_frame == 1); - assert(last_lvl >= 0); - - const AV1_COMMON *const cm = &cpi->common; - MACROBLOCK *x = &cpi->td.mb; - - int min_filter_level = AOMMAX(0, last_lvl - MAX_LPF_OFFSET); - int max_filter_level = - AOMMIN(av1_get_max_filter_level(cpi), last_lvl + MAX_LPF_OFFSET); - - // search a larger range for the start superblock - if (mi_row == 0 && mi_col == 0) { - min_filter_level = 0; - max_filter_level = av1_get_max_filter_level(cpi); - } - - // TODO(chengchen): Copy for superblock only - // Make a copy of the unfiltered / processed recon buffer - aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); - - int estimate_err = - try_filter_superblock(sd, cpi, last_lvl, partial_frame, mi_row, mi_col); - - int best_err = estimate_err; - int filt_best = last_lvl; - - int i; - for (i = min_filter_level; i <= max_filter_level; i += LPF_STEP) { - if (i == last_lvl) continue; - - int filt_err = - try_filter_superblock(sd, cpi, i, partial_frame, mi_row, mi_col); - - if (filt_err < best_err) { - best_err = filt_err; - filt_best = i; - } - } - - // If previous sb filter level has similar filtering performance as current - // best filter level, use previous level such that we can only send one bit - // to indicate current filter level is the same as the previous. - int threshold = 400; - - // ratio = the filtering area / a superblock size - int ratio = 1; - if (mi_row + MAX_MIB_SIZE > cm->mi_rows) { - ratio *= (cm->mi_rows - mi_row); - } else { - if (mi_row == 0) { - ratio *= (MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET); - } else { - ratio *= MAX_MIB_SIZE; - } - } - if (mi_col + MAX_MIB_SIZE > cm->mi_cols) { - ratio *= (cm->mi_cols - mi_col); - } else { - if (mi_col == 0) { - ratio *= (MAX_MIB_SIZE - FILT_BOUNDARY_MI_OFFSET); - } else { - ratio *= MAX_MIB_SIZE; - } - } - threshold = threshold * ratio / (MAX_MIB_SIZE * MAX_MIB_SIZE); - - const int diff = abs(estimate_err - best_err); - - const int percent_thresh = (int)((double)estimate_err * 0.01); - threshold = AOMMAX(threshold, percent_thresh); - if (diff < threshold) { - best_err = estimate_err; - filt_best = last_lvl; - } - - // Compute rdcost to determine whether to reuse previous filter lvl - if (filt_best != last_lvl) { - } - - if (best_cost_ret) *best_cost_ret = RDCOST_DBL(x->rdmult, 0, best_err); - return filt_best; -} - -#else // CONFIG_LPF_SB static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, AV1_COMP *const cpi, int filt_level, - int partial_frame -#if CONFIG_LOOPFILTER_LEVEL - , - int plane, int dir -#endif - ) { + int partial_frame, int plane, int dir) { AV1_COMMON *const cm = &cpi->common; int64_t filt_err; -#if CONFIG_VAR_TX || CONFIG_EXT_PARTITION || CONFIG_CB4X4 -#if CONFIG_LOOPFILTER_LEVEL assert(plane >= 0 && plane <= 2); int filter_level[2] = { filt_level, filt_level }; if (plane == 0 && dir == 0) filter_level[1] = cm->lf.filter_level[1]; if (plane == 0 && dir == 1) filter_level[0] = cm->lf.filter_level[0]; - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, - filter_level[0], filter_level[1], plane, partial_frame); -#else - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, 1, - partial_frame); -#endif // CONFIG_LOOPFILTER_LEVEL + // set base filters for use of get_filter_level when in DELTA_Q_LF mode + switch (plane) { + case 0: + cm->lf.filter_level[0] = filter_level[0]; + cm->lf.filter_level[1] = filter_level[1]; + break; + case 1: cm->lf.filter_level_u = filter_level[0]; break; + case 2: cm->lf.filter_level_v = filter_level[0]; break; + } + + // TODO(any): please enable multi-thread and remove the flag when loop + // filter mask is compatible with multi-thread. +#if LOOP_FILTER_BITMASK + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, plane, + plane + 1, partial_frame); #else if (cpi->num_workers > 1) - av1_loop_filter_frame_mt(cm->frame_to_show, cm, cpi->td.mb.e_mbd.plane, - filt_level, 1, partial_frame, cpi->workers, + av1_loop_filter_frame_mt(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, plane, + plane + 1, partial_frame, cpi->workers, cpi->num_workers, &cpi->lf_row_sync); else - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filt_level, - 1, partial_frame); + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, plane, + plane + 1, partial_frame); #endif int highbd = 0; -#if CONFIG_HIGHBITDEPTH highbd = cm->use_highbitdepth; -#endif // CONFIG_HIGHBITDEPTH -#if CONFIG_LOOPFILTER_LEVEL filt_err = aom_get_sse_plane(sd, cm->frame_to_show, plane, highbd); // Re-instate the unfiltered frame yv12_copy_plane(&cpi->last_frame_uf, cm->frame_to_show, plane); -#else - filt_err = aom_get_sse_plane(sd, cm->frame_to_show, 0, highbd); - - // Re-instate the unfiltered frame - yv12_copy_plane(&cpi->last_frame_uf, cm->frame_to_show, 0); -#endif // CONFIG_LOOPFILTER_LEVEL return filt_err; } static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, - int partial_frame, double *best_cost_ret -#if CONFIG_LOOPFILTER_LEVEL - , - int plane, int dir -#endif - ) { + int partial_frame, + const int *last_frame_filter_level, + double *best_cost_ret, int plane, int dir) { const AV1_COMMON *const cm = &cpi->common; - const struct loopfilter *const lf = &cm->lf; const int min_filter_level = 0; const int max_filter_level = av1_get_max_filter_level(cpi); int filt_direction = 0; @@ -311,39 +105,24 @@ static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, int filt_best; MACROBLOCK *x = &cpi->td.mb; -// Start the search at the previous frame filter level unless it is now out of -// range. -#if CONFIG_LOOPFILTER_LEVEL + // Start the search at the previous frame filter level unless it is now out of + // range. int lvl; switch (plane) { - case 0: lvl = (dir == 1) ? lf->filter_level[1] : lf->filter_level[0]; break; - case 1: lvl = lf->filter_level_u; break; - case 2: lvl = lf->filter_level_v; break; + case 0: lvl = last_frame_filter_level[dir]; break; + case 1: lvl = last_frame_filter_level[2]; break; + case 2: lvl = last_frame_filter_level[3]; break; default: assert(plane >= 0 && plane <= 2); return 0; } int filt_mid = clamp(lvl, min_filter_level, max_filter_level); -#else - int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level); -#endif // CONFIG_LOOPFILTER_LEVEL int filter_step = filt_mid < 16 ? 4 : filt_mid / 4; // Sum squared error at each filter level int64_t ss_err[MAX_LOOP_FILTER + 1]; // Set each entry to -1 memset(ss_err, 0xFF, sizeof(ss_err)); - -#if CONFIG_LOOPFILTER_LEVEL yv12_copy_plane(cm->frame_to_show, &cpi->last_frame_uf, plane); -#else - // Make a copy of the unfiltered / processed recon buffer - aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); -#endif // CONFIG_LOOPFILTER_LEVEL - -#if CONFIG_LOOPFILTER_LEVEL best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame, plane, dir); -#else - best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame); -#endif // CONFIG_LOOPFILTER_LEVEL filt_best = filt_mid; ss_err[filt_mid] = best_err; @@ -363,12 +142,8 @@ static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, if (filt_direction <= 0 && filt_low != filt_mid) { // Get Low filter error score if (ss_err[filt_low] < 0) { -#if CONFIG_LOOPFILTER_LEVEL ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame, plane, dir); -#else - ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame); -#endif // CONFIG_LOOPFILTER_LEVEL } // If value is close to the best so far then bias towards a lower loop // filter value. @@ -384,12 +159,8 @@ static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // Now look at filt_high if (filt_direction >= 0 && filt_high != filt_mid) { if (ss_err[filt_high] < 0) { -#if CONFIG_LOOPFILTER_LEVEL ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame, plane, dir); -#else - ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame); -#endif // CONFIG_LOOPFILTER_LEVEL } // If value is significantly better than previous best, bias added against // raising filter value @@ -415,33 +186,36 @@ static int search_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, if (best_cost_ret) *best_cost_ret = RDCOST_DBL(x->rdmult, 0, best_err); return filt_best; } -#endif // CONFIG_LPF_SB void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, LPF_PICK_METHOD method) { AV1_COMMON *const cm = &cpi->common; + const int num_planes = av1_num_planes(cm); struct loopfilter *const lf = &cm->lf; + (void)sd; - lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 : cpi->oxcf.sharpness; + lf->sharpness_level = 0; if (method == LPF_PICK_MINIMAL_LPF) { -#if CONFIG_LOOPFILTER_LEVEL lf->filter_level[0] = 0; lf->filter_level[1] = 0; -#else - lf->filter_level = 0; -#endif } else if (method >= LPF_PICK_FROM_Q) { const int min_filter_level = 0; const int max_filter_level = av1_get_max_filter_level(cpi); - const int q = av1_ac_quant(cm->base_qindex, 0, cm->bit_depth); -// These values were determined by linear fitting the result of the -// searched level, filt_guess = q * 0.316206 + 3.87252 -#if CONFIG_HIGHBITDEPTH + const int q = av1_ac_quant_Q3(cm->base_qindex, 0, cm->bit_depth); + // These values were determined by linear fitting the result of the + // searched level for 8 bit depth: + // Keyframes: filt_guess = q * 0.06699 - 1.60817 + // Other frames: filt_guess = q * 0.02295 + 2.48225 + // + // And high bit depth separately: + // filt_guess = q * 0.316206 + 3.87252 int filt_guess; switch (cm->bit_depth) { case AOM_BITS_8: - filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18); + filt_guess = (cm->frame_type == KEY_FRAME) + ? ROUND_POWER_OF_TWO(q * 17563 - 421574, 18) + : ROUND_POWER_OF_TWO(q * 6017 + 650707, 18); break; case AOM_BITS_10: filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 4060632, 20); @@ -455,58 +229,36 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, "or AOM_BITS_12"); return; } -#else - int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18); -#endif // CONFIG_HIGHBITDEPTH - if (cm->frame_type == KEY_FRAME) filt_guess -= 4; -#if CONFIG_LOOPFILTER_LEVEL + if (cm->bit_depth != AOM_BITS_8 && cm->frame_type == KEY_FRAME) + filt_guess -= 4; + // TODO(chengchen): retrain the model for Y, U, V filter levels lf->filter_level[0] = clamp(filt_guess, min_filter_level, max_filter_level); lf->filter_level[1] = clamp(filt_guess, min_filter_level, max_filter_level); -#else - lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level); -#endif + lf->filter_level_u = clamp(filt_guess, min_filter_level, max_filter_level); + lf->filter_level_v = clamp(filt_guess, min_filter_level, max_filter_level); } else { -#if CONFIG_LPF_SB - int mi_row, mi_col; - // TODO(chengchen): init last_lvl using previous frame's info? - int last_lvl = 0; - // TODO(chengchen): if the frame size makes the last superblock very small, - // consider merge it to the previous superblock to save bits. - // Example, if frame size 1080x720, then in the last row of superblock, - // there're (FILT_BOUNDAR_OFFSET + 16) pixels. - for (mi_row = 0; mi_row < cm->mi_rows; mi_row += MAX_MIB_SIZE) { - for (mi_col = 0; mi_col < cm->mi_cols; mi_col += MAX_MIB_SIZE) { - int lvl = - search_filter_level(sd, cpi, 1, NULL, mi_row, mi_col, last_lvl); - - av1_loop_filter_sb_level_init(cm, mi_row, mi_col, lvl); - - // For the superblock at row start, its previous filter level should be - // the one above it, not the one at the end of last row - if (mi_col + MAX_MIB_SIZE >= cm->mi_cols) { - last_lvl = cm->mi_grid_visible[mi_row * cm->mi_stride]->mbmi.filt_lvl; - } else { - last_lvl = lvl; - } - } + const int last_frame_filter_level[4] = { lf->filter_level[0], + lf->filter_level[1], + lf->filter_level_u, + lf->filter_level_v }; + + lf->filter_level[0] = lf->filter_level[1] = + search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, + last_frame_filter_level, NULL, 0, 2); + lf->filter_level[0] = + search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, + last_frame_filter_level, NULL, 0, 0); + lf->filter_level[1] = + search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, + last_frame_filter_level, NULL, 0, 1); + + if (num_planes > 1) { + lf->filter_level_u = + search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, + last_frame_filter_level, NULL, 1, 0); + lf->filter_level_v = + search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, + last_frame_filter_level, NULL, 2, 0); } -#else // CONFIG_LPF_SB -#if CONFIG_LOOPFILTER_LEVEL - lf->filter_level[0] = lf->filter_level[1] = search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 2); - lf->filter_level[0] = search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 0); - lf->filter_level[1] = search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 0, 1); - - lf->filter_level_u = search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 1, 0); - lf->filter_level_v = search_filter_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL, 2, 0); -#else - lf->filter_level = - search_filter_level(sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, NULL); -#endif // CONFIG_LOOPFILTER_LEVEL -#endif // CONFIG_LPF_SB } } -- cgit v1.2.3 From b8df135c97a854c2ff9b4394b016649c601177fa Mon Sep 17 00:00:00 2001 From: trav90 Date: Fri, 19 Oct 2018 23:00:02 -0500 Subject: Update libaom to rev b25610052a1398032320008d69b51d2da94f5928 --- third_party/aom/av1/encoder/picklpf.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) (limited to 'third_party/aom/av1/encoder/picklpf.c') diff --git a/third_party/aom/av1/encoder/picklpf.c b/third_party/aom/av1/encoder/picklpf.c index 5f802a707..461c3af83 100644 --- a/third_party/aom/av1/encoder/picklpf.c +++ b/third_party/aom/av1/encoder/picklpf.c @@ -82,10 +82,8 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, plane + 1, partial_frame); #endif - int highbd = 0; - highbd = cm->use_highbitdepth; - - filt_err = aom_get_sse_plane(sd, cm->frame_to_show, plane, highbd); + filt_err = aom_get_sse_plane(sd, cm->frame_to_show, plane, + cm->seq_params.use_highbitdepth); // Re-instate the unfiltered frame yv12_copy_plane(&cpi->last_frame_uf, cm->frame_to_show, plane); @@ -202,7 +200,7 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, } else if (method >= LPF_PICK_FROM_Q) { const int min_filter_level = 0; const int max_filter_level = av1_get_max_filter_level(cpi); - const int q = av1_ac_quant_Q3(cm->base_qindex, 0, cm->bit_depth); + const int q = av1_ac_quant_Q3(cm->base_qindex, 0, cm->seq_params.bit_depth); // These values were determined by linear fitting the result of the // searched level for 8 bit depth: // Keyframes: filt_guess = q * 0.06699 - 1.60817 @@ -211,7 +209,7 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, // And high bit depth separately: // filt_guess = q * 0.316206 + 3.87252 int filt_guess; - switch (cm->bit_depth) { + switch (cm->seq_params.bit_depth) { case AOM_BITS_8: filt_guess = (cm->frame_type == KEY_FRAME) ? ROUND_POWER_OF_TWO(q * 17563 - 421574, 18) @@ -229,7 +227,7 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, "or AOM_BITS_12"); return; } - if (cm->bit_depth != AOM_BITS_8 && cm->frame_type == KEY_FRAME) + if (cm->seq_params.bit_depth != AOM_BITS_8 && cm->frame_type == KEY_FRAME) filt_guess -= 4; // TODO(chengchen): retrain the model for Y, U, V filter levels lf->filter_level[0] = clamp(filt_guess, min_filter_level, max_filter_level); -- cgit v1.2.3 From d2499ead93dc4298c0882fe98902acb1b5209f99 Mon Sep 17 00:00:00 2001 From: trav90 Date: Fri, 19 Oct 2018 23:05:00 -0500 Subject: Update libaom to commit ID 1e227d41f0616de9548a673a83a21ef990b62591 --- third_party/aom/av1/encoder/picklpf.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'third_party/aom/av1/encoder/picklpf.c') diff --git a/third_party/aom/av1/encoder/picklpf.c b/third_party/aom/av1/encoder/picklpf.c index 461c3af83..c5508e25c 100644 --- a/third_party/aom/av1/encoder/picklpf.c +++ b/third_party/aom/av1/encoder/picklpf.c @@ -70,7 +70,7 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, // TODO(any): please enable multi-thread and remove the flag when loop // filter mask is compatible with multi-thread. #if LOOP_FILTER_BITMASK - av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, plane, + av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, 0, plane, plane + 1, partial_frame); #else if (cpi->num_workers > 1) @@ -193,6 +193,7 @@ void av1_pick_filter_level(const YV12_BUFFER_CONFIG *sd, AV1_COMP *cpi, (void)sd; lf->sharpness_level = 0; + cpi->td.mb.rdmult = cpi->rd.RDMULT; if (method == LPF_PICK_MINIMAL_LPF) { lf->filter_level[0] = 0; -- cgit v1.2.3