tree e0683316a415ebbfa9c2575a5e7046f4b6578567
parent 0956945bb6746f7094a10329feaf919e95f67dca
author Marco Paniconi <marpan@google.com> 1661930986 -0700
committer Marco Paniconi <marpan@google.com> 1662604327 +0000

rtc: Allow for split to 8x8 blocks for speed >=9 low-resoln

For sf.prefer_large_partition_blocks >= 3 (speed >= 9) and
low-resolutions: split to 8x8 is disallowed. This can
cause visual quality artifacts near moving boundary, as
seen in, for example, desktopqvga_320_240.y4m.

This patch allows for split to 8x8 for some superblocks,
depending on sb source_sad content, and if so, 4x4 avg
is used (instead of the default 8x8 avg used for delta frames)
to get the 8x8 variances. The decision to split 16x16 block
is then based on the min/max over the 4 8x8 subblock variances.
This is done to get better signal on whether moving boundary
exists within 16x16 block.

This significantly reduces artifact in desktopqvga,
overall small bdrate change, and small speed loss.

Stats changed for speed 9/10 rtc_derf.
avg_psnr/ovr_psnr/ssim,  IC speedup
speed 9:  -0.40/-0.41/-0.39,  -1.0
speed 10: -0.25/-0.37/-0.38,  -1.1

Change-Id: Ib132aab11ab8083c2ddd666bcd433509fee6c950
