coffee/libyuv
1
0
Fork 0
mirror of https://chromium.googlesource.com/libyuv/libyuv synced 2026-10-28 18:07:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add a box filter to ScaleUV

Browse Source 
kFilterBox only had 1/2 and 1/4 fast paths. Everything else fell
through to ScaleUVSimple and point sampled, so NV12 chroma was
unfiltered where I420 was not. 13.6 dB against 50.2 dB at 3x.

ScaleUVBox mirrors ScalePlaneBox. Row accumulation reuses ScaleAddRow
and its SIMD variants, since summing is position wise and an
interleaved row is just src_cols * 2 samples. Only the column pass,
which sums U and V at a stride of 2, is new.

Output is now byte identical to the I420 path. Tests compare against
ScalePlane rather than C against SIMD, which is what missed this.

Bug: libyuv:564129034
Change-Id: I26221f5435dbfc845ad2fc13aa347ef56ccf7bc6
Reviewed-on: https://chromium-review.googlesource.com/c/libyuv/libyuv/+/8426668
Reviewed-by: richard winterton <rrwinterton@gmail.com>
Reviewed-by: Frank Barchard <fbarchard@google.com>
This commit is contained in:
Philipp Hancke 2026-10-01 12:33:38 +02:00 committed by Frank Barchard
parent 67b3c0dad8
commit aa6cedb39c
2 changed files with 282 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
source/scale_uv.cc
View File

@ -35,6 +35,9 @@ extern "C" {
#ifndef HAS_SCALEUVDOWNEVEN
#define HAS_SCALEUVDOWNEVEN 1
#endif
#ifndef HAS_SCALEUVBOX
#define HAS_SCALEUVBOX 1
#endif
#ifndef HAS_SCALEUVBILINEARDOWN
#define HAS_SCALEUVBILINEARDOWN 1
#endif
@ -52,6 +55,8 @@ static __inline int Abs(int v) {
return v >= 0 ? v : -v;
}
#define MIN1(x) ((x) < 1 ? 1 : (x))
// ScaleUV, 1/2
// This is an optimized version for scaling down a UV to 1/2 of
// its original size.
@ -249,6 +254,154 @@ static int ScaleUVDown4Box(int src_width,
}
#endif // HAS_SCALEUVDOWN4BOX
// ScaleUV, any dimensions, box filter.
// The counterpart of ScalePlaneBox in scale.cc. Rows are summed into 16 bit
// accumulators, then each destination pixel averages its box of source pixels.
#if HAS_SCALEUVBOX
static void ScaleUVAddCols1_C(int dst_width,
int boxheight,
int x,
int dx,
const uint16_t* src_uv,
uint8_t* dst_uv) {
int i, j;
int boxwidth = MIN1(dx >> 16);
int scaleval = 65536 / (boxwidth * boxheight);
x >>= 16;
for (i = 0; i < dst_width; ++i) {
int u = 0;
int v = 0;
for (j = 0; j < boxwidth; ++j) {
u += src_uv[(x + j) * 2];
v += src_uv[(x + j) * 2 + 1];
}
x += boxwidth;
*dst_uv++ = (uint8_t)(u * scaleval >> 16);
*dst_uv++ = (uint8_t)(v * scaleval >> 16);
}
}
static void ScaleUVAddCols2_C(int dst_width,
int boxheight,
int x,
int dx,
const uint16_t* src_uv,
uint8_t* dst_uv) {
int i, j;
int minboxwidth = dx >> 16;
int scaletbl[2];
scaletbl[0] = 65536 / (MIN1(minboxwidth) * boxheight);
scaletbl[1] = 65536 / (MIN1(minboxwidth + 1) * boxheight);
for (i = 0; i < dst_width; ++i) {
int ix = x >> 16;
int u = 0;
int v = 0;
int boxwidth;
int scaleval;
x += dx;
boxwidth = MIN1((x >> 16) - ix);
assert((boxwidth - minboxwidth == 0) || (boxwidth - minboxwidth == 1));
scaleval = scaletbl[boxwidth - minboxwidth];
for (j = 0; j < boxwidth; ++j) {
u += src_uv[(ix + j) * 2];
v += src_uv[(ix + j) * 2 + 1];
}
*dst_uv++ = (uint8_t)(u * scaleval >> 16);
*dst_uv++ = (uint8_t)(v * scaleval >> 16);
}
}
static int ScaleUVBox(int src_width,
int src_height,
int dst_width,
int dst_height,
ptrdiff_t src_stride,
ptrdiff_t dst_stride,
const uint8_t* src_uv,
uint8_t* dst_uv,
int x,
int dx,
int y,
int dy) {
int j, k;
const int max_y = (src_height << 16);
// Sized on src_width to keep ScaleAddRow aligned.
const int row_samples = src_width * 2;
{
// Row accumulator, two uint16_t per source pixel.
align_buffer_64(row16, row_samples * 2);
if (!row16)
return 1;
{
void (*ScaleUVAddCols)(int dst_width, int boxheight, int x, int dx,
const uint16_t* src_uv, uint8_t* dst_uv) =
(dx & 0xffff) ? ScaleUVAddCols2_C : ScaleUVAddCols1_C;
// Summing a row is position wise, so an interleaved UV row can be fed to
// the plane accumulator as src_width * 2 samples.
void (*ScaleAddRow)(const uint8_t* src_ptr, uint16_t* dst_ptr,
int src_width) = ScaleAddRow_C;
#if defined(HAS_SCALEADDROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
ScaleAddRow = ScaleAddRow_Any_SSE2;
if (IS_ALIGNED(row_samples, 16)) {
ScaleAddRow = ScaleAddRow_SSE2;
}
}
#endif
#if defined(HAS_SCALEADDROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
ScaleAddRow = ScaleAddRow_Any_AVX2;
if (IS_ALIGNED(row_samples, 32)) {
ScaleAddRow = ScaleAddRow_AVX2;
}
}
#endif
#if defined(HAS_SCALEADDROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
ScaleAddRow = ScaleAddRow_Any_NEON;
if (IS_ALIGNED(row_samples, 16)) {
ScaleAddRow = ScaleAddRow_NEON;
}
}
#endif
#if defined(HAS_SCALEADDROW_LSX)
if (TestCpuFlag(kCpuHasLSX)) {
ScaleAddRow = ScaleAddRow_Any_LSX;
if (IS_ALIGNED(row_samples, 16)) {
ScaleAddRow = ScaleAddRow_LSX;
}
}
#endif
#if defined(HAS_SCALEADDROW_RVV)
if (TestCpuFlag(kCpuHasRVV)) {
ScaleAddRow = ScaleAddRow_RVV;
}
#endif
for (j = 0; j < dst_height; ++j) {
int boxheight;
int iy = y >> 16;
const uint8_t* src = src_uv + iy * src_stride;
y += dy;
if (y > max_y) {
y = max_y;
}
boxheight = MIN1((y >> 16) - iy);
memset(row16, 0, row_samples * 2);
for (k = 0; k < boxheight; ++k) {
ScaleAddRow(src, (uint16_t*)(row16), row_samples);
src += src_stride;
}
ScaleUVAddCols(dst_width, boxheight, x, dx, (uint16_t*)(row16), dst_uv);
dst_uv += dst_stride;
}
}
free_aligned_buffer_64(row16);
}
return 0;
}
#endif // HAS_SCALEUVBOX
// ScaleUV Even
// This is an optimized version for scaling down a UV to even
// multiple of its original size.
@ -973,7 +1126,6 @@ static int ScaleUV(const uint8_t* src,
int y = 0;
int dx = 0;
int dy = 0;
// UV does not support box filter yet, but allow the user to pass it.
// Simplify filtering when possible.
filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
filtering);
@ -1000,6 +1152,16 @@ static int ScaleUV(const uint8_t* src,
dst += clip_y * (ptrdiff_t)dst_stride;
}
#if HAS_SCALEUVBOX
// Exactly 4 goes to the faster ScaleUVDown4Box below. Clipping is excluded
// because whole source rows are accumulated.
if (filtering == kFilterBox && !(dx == 0x40000 && dy == 0x40000) &&
clip_x == 0 && clip_y == 0) {
return ScaleUVBox(src_width, src_height, clip_width, clip_height,
src_stride, dst_stride, src, dst, x, dx, y, dy);
}
#endif
// Special case for integer step values.
if (((dx | dy) & 0xffff) == 0) {
if (!dx || !dy) { // 1 pixel wide and/or tall.

119
unit_test/scale_uv_test.cc
View File

@ -13,6 +13,7 @@
#include "../unit_test/unit_test.h"
#include "libyuv/cpu_id.h"
#include "libyuv/scale.h"
#include "libyuv/scale_uv.h"
namespace libyuv {
@ -246,4 +247,122 @@ TEST_F(LibYUVScaleTest, UVTest4x) {
free_aligned_buffer_page_end(orig_pixels);
}
// Box filtering an interleaved UV plane has to produce the same bytes as box
// filtering the U and V planes separately, which is the path I420 takes.
// C and SIMD agreeing is not enough here: before ScaleUVBox existed both
// point sampled, so this compares against an independent implementation.
static int UVTestBoxAgainstPlanes(int src_width,
int src_height,
int dst_width,
int dst_height,
int cpu_info) {
if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
return 0;
}
int64_t src_uv_plane_size = src_width * src_height * 2LL;
int64_t src_plane_size = src_width * src_height * 1LL;
int64_t dst_uv_plane_size = dst_width * dst_height * 2LL;
int64_t dst_plane_size = dst_width * dst_height * 1LL;
align_buffer_page_end(src_uv, src_uv_plane_size);
align_buffer_page_end(src_u, src_plane_size);
align_buffer_page_end(src_v, src_plane_size);
align_buffer_page_end(dst_uv, dst_uv_plane_size);
align_buffer_page_end(dst_u, dst_plane_size);
align_buffer_page_end(dst_v, dst_plane_size);
if (!src_uv || !src_u || !src_v || !dst_uv || !dst_u || !dst_v) {
printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
return 0;
}
MemRandomize(src_uv, src_uv_plane_size);
memset(dst_uv, 123, dst_uv_plane_size);
for (int i = 0; i < src_width * src_height; ++i) {
src_u[i] = src_uv[i * 2 + 0];
src_v[i] = src_uv[i * 2 + 1];
}
MaskCpuFlags(cpu_info);
UVScale(src_uv, src_width * 2, src_width, src_height, dst_uv, dst_width * 2,
dst_width, dst_height, kFilterBox);
ScalePlane(src_u, src_width, src_width, src_height, dst_u, dst_width,
dst_width, dst_height, kFilterBox);
ScalePlane(src_v, src_width, src_width, src_height, dst_v, dst_width,
dst_width, dst_height, kFilterBox);
int max_diff = 0;
for (int i = 0; i < dst_width * dst_height; ++i) {
int du = Abs(dst_uv[i * 2 + 0] - dst_u[i]);
int dv = Abs(dst_uv[i * 2 + 1] - dst_v[i]);
if (du > max_diff) {
max_diff = du;
}
if (dv > max_diff) {
max_diff = dv;
}
}
free_aligned_buffer_page_end(dst_v);
free_aligned_buffer_page_end(dst_u);
free_aligned_buffer_page_end(dst_uv);
free_aligned_buffer_page_end(src_v);
free_aligned_buffer_page_end(src_u);
free_aligned_buffer_page_end(src_uv);
return max_diff;
}
// Chroma dimensions, ie half the frame sizes named in the comments.
// max_diff is 0 for everything ScaleUVBox handles. The 1/2 and 1/4 fast paths
// predate it and keep their own rounding, so 1/4 is allowed to drift by one.
#define TEST_BOXPLANE(name, swidth, sheight, dwidth, dheight, max_diff) \
TEST_F(LibYUVScaleTest, UVScaleBoxMatchesPlane##name) { \
int diff_c = UVTestBoxAgainstPlanes(swidth, sheight, dwidth, dheight, \
disable_cpu_flags_); \
ASSERT_LE(diff_c, max_diff); \
int diff_opt = UVTestBoxAgainstPlanes(swidth, sheight, dwidth, dheight, \
benchmark_cpu_info_); \
ASSERT_LE(diff_opt, max_diff); \
}
TEST_BOXPLANE(By2, 960, 540, 480, 270, 0) /* 1080p to 960x540 */
TEST_BOXPLANE(By3, 960, 540, 320, 180, 0) /* 1080p to 640x360 */
TEST_BOXPLANE(By3Rounded, 640, 360, 214, 120, 0) /* 720p to 427x240 */
TEST_BOXPLANE(By4, 960, 540, 240, 135, 1) /* ScaleUVDown4Box */
TEST_BOXPLANE(By3_75, 960, 540, 256, 144, 0) /* 1080p to 512x288 */
TEST_BOXPLANE(By6, 640, 360, 106, 60, 0) /* 720p to 213x120 */
TEST_BOXPLANE(By8, 640, 360, 80, 45, 0) /* 720p to 160x90 */
TEST_BOXPLANE(OddTail, 33, 17, 7, 5, 0) /* not a multiple of 8 wide */
TEST_BOXPLANE(Tiny, 80, 60, 3, 2, 0) /* dst below one SIMD group */
#undef TEST_BOXPLANE
// A box filter has to read the whole box. Every 3x3 block here is 255 except
// for its top left pixel, so point sampling the block origin yields 0 while
// the box average is 8 * 255 * (65536 / 9) >> 16 = 226.
TEST_F(LibYUVScaleTest, UVScaleBoxAverages) {
const int kSrcWidth = 48;
const int kSrcHeight = 24;
const int kDstWidth = kSrcWidth / 3;
const int kDstHeight = kSrcHeight / 3;
align_buffer_page_end(src_uv, kSrcWidth * kSrcHeight * 2);
align_buffer_page_end(dst_uv, kDstWidth * kDstHeight * 2);
memset(src_uv, 255, kSrcWidth * kSrcHeight * 2);
for (int y = 0; y < kSrcHeight; y += 3) {
for (int x = 0; x < kSrcWidth; x += 3) {
src_uv[(y * kSrcWidth + x) * 2 + 0] = 0;
src_uv[(y * kSrcWidth + x) * 2 + 1] = 0;
}
}
memset(dst_uv, 123, kDstWidth * kDstHeight * 2);
UVScale(src_uv, kSrcWidth * 2, kSrcWidth, kSrcHeight, dst_uv, kDstWidth * 2,
kDstWidth, kDstHeight, kFilterBox);
for (int i = 0; i < kDstWidth * kDstHeight * 2; ++i) {
ASSERT_EQ(226, dst_uv[i]) << "at " << i;
}
free_aligned_buffer_page_end(dst_uv);
free_aligned_buffer_page_end(src_uv);
}
} // namespace libyuv