coffee/libyuv
1
0
Fork 0
mirror of https://chromium.googlesource.com/libyuv/libyuv synced 2025-12-06 08:46:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

RGBScale function using 3 steps: RGB24ToARGB, ARGBScale, ARGBToRGB24

Browse Source 
1920x1080 to/from 1280x720 to ARGB on Intel Skylake Xeon
RGBScaleTo1920x1080_Bilinear (2625 ms)
RGBScaleFrom1920x1080_Bilinear (2115 ms)
ARGBScaleTo1920x1080_Bilinear (1668 ms)
ARGBScaleFrom1920x1080_Bilinear (1164 ms)

Bug: b/224814071
Change-Id: Ifc7611b597409771728b13c9c39e5a7e06131021
Reviewed-on: https://chromium-review.googlesource.com/c/libyuv/libyuv/+/3537341
Reviewed-by: Wan-Teh Chang <wtc@google.com>
Commit-Queue: Frank Barchard <fbarchard@chromium.org>
This commit is contained in:
Frank Barchard 2022-03-18 18:25:49 -07:00 committed by libyuv LUCI CQ
parent 95b14b2446
commit 124bf08fee
10 changed files with 417 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Android.bp
View File

@ -71,6 +71,7 @@ cc_library {
"source/scale_msa.cc",
"source/scale_neon.cc",
"source/scale_neon64.cc",
"source/scale_rgb.cc",
"source/scale_uv.cc",
"source/video_common.cc",
],
@ -130,6 +131,7 @@ cc_test {
"unit_test/rotate_argb_test.cc",
"unit_test/rotate_test.cc",
"unit_test/scale_argb_test.cc",
"unit_test/scale_rgb_test.cc",
"unit_test/scale_test.cc",
"unit_test/scale_uv_test.cc",
"unit_test/unit_test.cc",

2
Android.mk
View File

@ -45,6 +45,7 @@ LOCAL_SRC_FILES := \
source/scale_msa.cc \
source/scale_neon.cc \
source/scale_neon64.cc \
source/scale_rgb.cc \
source/scale_uv.cc \
source/scale_win.cc \
source/video_common.cc
@ -97,6 +98,7 @@ LOCAL_SRC_FILES := \
unit_test/rotate_argb_test.cc \
unit_test/rotate_test.cc \
unit_test/scale_argb_test.cc \
unit_test/scale_rgb_test.cc \
unit_test/scale_test.cc \
unit_test/scale_uv_test.cc \
unit_test/unit_test.cc \

3
BUILD.gn
View File

@ -94,6 +94,7 @@ static_library("libyuv_internal") {
"include/libyuv/row.h",
"include/libyuv/scale.h",
"include/libyuv/scale_argb.h",
"include/libyuv/scale_rgb.h",
"include/libyuv/scale_row.h",
"include/libyuv/scale_uv.h",
"include/libyuv/version.h",
@ -130,6 +131,7 @@ static_library("libyuv_internal") {
"source/scale_argb.cc",
"source/scale_common.cc",
"source/scale_gcc.cc",
"source/scale_rgb.cc",
"source/scale_uv.cc",
"source/scale_win.cc",
"source/video_common.cc",
@ -258,6 +260,7 @@ if (libyuv_include_tests) {
"unit_test/rotate_argb_test.cc",
"unit_test/rotate_test.cc",
"unit_test/scale_argb_test.cc",
"unit_test/scale_rgb_test.cc",
"unit_test/scale_test.cc",
"unit_test/scale_uv_test.cc",
"unit_test/unit_test.cc",

3
README.chromium
View File

@ -1,8 +1,9 @@
Name: libyuv
URL: http://code.google.com/p/libyuv/
Version: 1814
Version: 1815
License: BSD
License File: LICENSE
Description:
libyuv is an open source project that includes YUV conversion and scaling functionality.

42
include/libyuv/scale_rgb.h Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright 2022 The LibYuv Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef INCLUDE_LIBYUV_SCALE_RGB_H_
#define INCLUDE_LIBYUV_SCALE_RGB_H_
#include "libyuv/basic_types.h"
#include "libyuv/scale.h" // For FilterMode
#ifdef __cplusplus
namespace libyuv {
extern "C" {
#endif
// RGB can be RAW, RGB24 or YUV24
// RGB scales 24 bit images by converting a row at a time to ARGB
// and using ARGB row functions to scale, then convert to RGB.
// TODO(fbarchard): Allow input/output formats to be specified.
LIBYUV_API
int RGBScale(const uint8_t* src_rgb,
int src_stride_rgb,
int src_width,
int src_height,
uint8_t* dst_rgb,
int dst_stride_rgb,
int dst_width,
int dst_height,
enum FilterMode filtering);
#ifdef __cplusplus
} // extern "C"
} // namespace libyuv
#endif
#endif // INCLUDE_LIBYUV_SCALE_UV_H_

2
include/libyuv/version.h
View File

@ -11,6 +11,6 @@
#ifndef INCLUDE_LIBYUV_VERSION_H_
#define INCLUDE_LIBYUV_VERSION_H_
#define LIBYUV_VERSION 1814
#define LIBYUV_VERSION 1815
#endif // INCLUDE_LIBYUV_VERSION_H_

1
linux.mk
View File

@ -52,6 +52,7 @@ LOCAL_OBJ_FILES := \
source/scale_msa.o \
source/scale_neon.o \
source/scale_neon64.o \
source/scale_rgb.o \
source/scale_uv.o \
source/scale_win.o \
source/video_common.o

40
source/convert.cc
View File

@ -2091,18 +2091,18 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
#endif
#endif // HAS_RGB24TOYJROW
{
{
#if !defined(HAS_RGB24TOYJROW)
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
for (y = 0; y < height - 1; y += 2) {
#if defined(HAS_RGB24TOYJROW)
RGB24ToUVJRow(src_rgb24, src_stride_rgb24, dst_u, dst_v, width);
RGB24ToYJRow(src_rgb24, dst_y, width);
RGB24ToYJRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
RGB24ToUVJRow(src_rgb24, src_stride_rgb24, dst_u, dst_v, width);
RGB24ToYJRow(src_rgb24, dst_y, width);
RGB24ToYJRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
#else
RGB24ToARGBRow(src_rgb24, row, width);
RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
@ -2110,26 +2110,26 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
ARGBToYJRow(row, dst_y, width);
ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
#endif
src_rgb24 += src_stride_rgb24 * 2;
dst_y += dst_stride_y * 2;
dst_u += dst_stride_u;
dst_v += dst_stride_v;
}
if (height & 1) {
src_rgb24 += src_stride_rgb24 * 2;
dst_y += dst_stride_y * 2;
dst_u += dst_stride_u;
dst_v += dst_stride_v;
}
if (height & 1) {
#if defined(HAS_RGB24TOYJROW)
RGB24ToUVJRow(src_rgb24, 0, dst_u, dst_v, width);
RGB24ToYJRow(src_rgb24, dst_y, width);
RGB24ToUVJRow(src_rgb24, 0, dst_u, dst_v, width);
RGB24ToYJRow(src_rgb24, dst_y, width);
#else
RGB24ToARGBRow(src_rgb24, row, width);
ARGBToUVJRow(row, 0, dst_u, dst_v, width);
ARGBToYJRow(row, dst_y, width);
#endif
}
}
#if !defined(HAS_RGB24TOYJROW)
free_aligned_buffer_64(row);
free_aligned_buffer_64(row);
#endif
}
return 0;
}
return 0;
}
#undef HAS_RGB24TOYJROW

66
source/scale_rgb.cc Normal file
View File

@ -0,0 +1,66 @@
/*
* Copyright 2022 The LibYuv Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "libyuv/scale.h" /* For FilterMode */
#include <assert.h>
#include <string.h>
#include "libyuv/convert_argb.h"
#include "libyuv/convert_from_argb.h"
#include "libyuv/row.h"
#include "libyuv/scale_argb.h"
#include "libyuv/scale_rgb.h"
#ifdef __cplusplus
namespace libyuv {
extern "C" {
#endif
// Scale a 24 bit image.
// Converts to ARGB as intermediate step
LIBYUV_API
int RGBScale(const uint8_t* src_rgb,
int src_stride_rgb,
int src_width,
int src_height,
uint8_t* dst_rgb,
int dst_stride_rgb,
int dst_width,
int dst_height,
enum FilterMode filtering) {
int r;
uint8_t* src_argb =
(uint8_t*)malloc(src_width * src_height * 4 + dst_width * dst_height * 4);
uint8_t* dst_argb = src_argb + src_width * src_height * 4;
if (!src_argb) {
return 1;
}
r = RGB24ToARGB(src_rgb, src_stride_rgb, src_argb, src_width * 4, src_width,
src_height);
if (!r) {
r = ARGBScale(src_argb, src_width * 4, src_width, src_height, dst_argb,
dst_width * 4, dst_width, dst_height, filtering);
if (!r) {
r = ARGBToRGB24(dst_argb, dst_width * 4, dst_rgb, dst_stride_rgb,
dst_width, dst_height);
}
}
free(src_argb);
return r;
}
#ifdef __cplusplus
} // extern "C"
} // namespace libyuv
#endif

278
unit_test/scale_rgb_test.cc Normal file
View File

@ -0,0 +1,278 @@
/*
* Copyright 2022 The LibYuv Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <stdlib.h>
#include <time.h>
#include "../unit_test/unit_test.h"
#include "libyuv/cpu_id.h"
#include "libyuv/scale_rgb.h"
namespace libyuv {
#define STRINGIZE(line) #line
#define FILELINESTR(file, line) file ":" STRINGIZE(line)
#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
// SLOW TESTS are those that are unoptimized C code.
// FULL TESTS are optimized but test many variations of the same code.
#define ENABLE_FULL_TESTS
#endif
// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
static int RGBTestFilter(int src_width,
int src_height,
int dst_width,
int dst_height,
FilterMode f,
int benchmark_iterations,
int disable_cpu_flags,
int benchmark_cpu_info) {
if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
return 0;
}
int i, j;
const int b = 0; // 128 to test for padding/stride.
int64_t src_rgb_plane_size =
(Abs(src_width) + b * 3) * (Abs(src_height) + b * 3) * 3LL;
int src_stride_rgb = (b * 3 + Abs(src_width)) * 3;
align_buffer_page_end(src_rgb, src_rgb_plane_size);
if (!src_rgb) {
printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
return 0;
}
MemRandomize(src_rgb, src_rgb_plane_size);
int64_t dst_rgb_plane_size = (dst_width + b * 3) * (dst_height + b * 3) * 3LL;
int dst_stride_rgb = (b * 3 + dst_width) * 3;
align_buffer_page_end(dst_rgb_c, dst_rgb_plane_size);
align_buffer_page_end(dst_rgb_opt, dst_rgb_plane_size);
if (!dst_rgb_c || !dst_rgb_opt) {
printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
return 0;
}
memset(dst_rgb_c, 2, dst_rgb_plane_size);
memset(dst_rgb_opt, 3, dst_rgb_plane_size);
// Warm up both versions for consistent benchmarks.
MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization.
RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
src_height, dst_rgb_c + (dst_stride_rgb * b) + b * 3, dst_stride_rgb,
dst_width, dst_height, f);
MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization.
RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
src_height, dst_rgb_opt + (dst_stride_rgb * b) + b * 3, dst_stride_rgb,
dst_width, dst_height, f);
MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization.
double c_time = get_time();
RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
src_height, dst_rgb_c + (dst_stride_rgb * b) + b * 3, dst_stride_rgb,
dst_width, dst_height, f);
c_time = (get_time() - c_time);
MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization.
double opt_time = get_time();
for (i = 0; i < benchmark_iterations; ++i) {
RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
src_height, dst_rgb_opt + (dst_stride_rgb * b) + b * 3, dst_stride_rgb,
dst_width, dst_height, f);
}
opt_time = (get_time() - opt_time) / benchmark_iterations;
// Report performance of C vs OPT
printf("filter %d - %8d us C - %8d us OPT\n", f,
static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
// C version may be a little off from the optimized. Order of
// operations may introduce rounding somewhere. So do a difference
// of the buffers and look to see that the max difference isn't
// over 2.
int max_diff = 0;
for (i = b; i < (dst_height + b); ++i) {
for (j = b * 3; j < (dst_width + b) * 3; ++j) {
int abs_diff = Abs(dst_rgb_c[(i * dst_stride_rgb) + j] -
dst_rgb_opt[(i * dst_stride_rgb) + j]);
if (abs_diff > max_diff) {
max_diff = abs_diff;
}
}
}
free_aligned_buffer_page_end(dst_rgb_c);
free_aligned_buffer_page_end(dst_rgb_opt);
free_aligned_buffer_page_end(src_rgb);
return max_diff;
}
// The following adjustments in dimensions ensure the scale factor will be
// exactly achieved.
#define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom)
#define SX(x, nom, denom) static_cast<int>((x / nom) * denom)
#define TEST_FACTOR1(name, filter, nom, denom, max_diff) \
TEST_F(LibYUVScaleTest, RGBScaleDownBy##name##_##filter) { \
int diff = RGBTestFilter( \
SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \
DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \
kFilter##filter, benchmark_iterations_, disable_cpu_flags_, \
benchmark_cpu_info_); \
EXPECT_LE(diff, max_diff); \
}
#if defined(ENABLE_FULL_TESTS)
// Test a scale factor with all 4 filters. Expect unfiltered to be exact, but
// filtering is different fixed point implementations for SSSE3, Neon and C.
#define TEST_FACTOR(name, nom, denom) \
TEST_FACTOR1(name, None, nom, denom, 0) \
TEST_FACTOR1(name, Linear, nom, denom, 3) \
TEST_FACTOR1(name, Bilinear, nom, denom, 3) \
TEST_FACTOR1(name, Box, nom, denom, 3)
#else
// Test a scale factor with Bilinear.
#define TEST_FACTOR(name, nom, denom) \
TEST_FACTOR1(name, Bilinear, nom, denom, 3)
#endif
TEST_FACTOR(2, 1, 2)
TEST_FACTOR(4, 1, 4)
// TEST_FACTOR(8, 1, 8) Disable for benchmark performance.
TEST_FACTOR(3by4, 3, 4)
TEST_FACTOR(3by8, 3, 8)
TEST_FACTOR(3, 1, 3)
#undef TEST_FACTOR1
#undef TEST_FACTOR
#undef SX
#undef DX
#define TEST_SCALETO1(name, width, height, filter, max_diff) \
TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) { \
int diff = RGBTestFilter(benchmark_width_, benchmark_height_, width, \
height, kFilter##filter, benchmark_iterations_, \
disable_cpu_flags_, benchmark_cpu_info_); \
EXPECT_LE(diff, max_diff); \
} \
TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) { \
int diff = RGBTestFilter(width, height, Abs(benchmark_width_), \
Abs(benchmark_height_), kFilter##filter, \
benchmark_iterations_, disable_cpu_flags_, \
benchmark_cpu_info_); \
EXPECT_LE(diff, max_diff); \
}
#if defined(ENABLE_FULL_TESTS)
/// Test scale to a specified size with all 4 filters.
#define TEST_SCALETO(name, width, height) \
TEST_SCALETO1(name, width, height, None, 0) \
TEST_SCALETO1(name, width, height, Linear, 3) \
TEST_SCALETO1(name, width, height, Bilinear, 3)
#else
#define TEST_SCALETO(name, width, height) \
TEST_SCALETO1(name, width, height, Bilinear, 3)
#endif
TEST_SCALETO(RGBScale, 1, 1)
// TEST_SCALETO(RGBScale, 256, 144) /* 128x72 * 3 */
TEST_SCALETO(RGBScale, 320, 240)
TEST_SCALETO(RGBScale, 569, 480)
TEST_SCALETO(RGBScale, 640, 360)
#ifndef DISABLE_SLOW_TESTS
TEST_SCALETO(RGBScale, 1280, 720)
TEST_SCALETO(RGBScale, 1920, 1080)
#endif // DISABLE_SLOW_TESTS
#undef TEST_SCALETO1
#undef TEST_SCALETO
#define TEST_SCALESWAPXY1(name, filter, max_diff) \
TEST_F(LibYUVScaleTest, name##SwapXY_##filter) { \
int diff = \
RGBTestFilter(benchmark_width_, benchmark_height_, benchmark_height_, \
benchmark_width_, kFilter##filter, benchmark_iterations_, \
disable_cpu_flags_, benchmark_cpu_info_); \
EXPECT_LE(diff, max_diff); \
}
#if defined(ENABLE_FULL_TESTS)
// Test scale with swapped width and height with all 3 filters.
TEST_SCALESWAPXY1(RGBScale, None, 0)
TEST_SCALESWAPXY1(RGBScale, Linear, 0)
TEST_SCALESWAPXY1(RGBScale, Bilinear, 0)
#else
TEST_SCALESWAPXY1(RGBScale, Bilinear, 0)
#endif
#undef TEST_SCALESWAPXY1
TEST_F(LibYUVScaleTest, RGBTest3x) {
const int kSrcStride = 480 * 3;
const int kDstStride = 160 * 3;
const int kSize = kSrcStride * 3;
align_buffer_page_end(orig_pixels, kSize);
for (int i = 0; i < 480 * 3; ++i) {
orig_pixels[i * 3 + 0] = i;
orig_pixels[i * 3 + 1] = 255 - i;
}
align_buffer_page_end(dest_pixels, kDstStride);
int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
benchmark_iterations_;
for (int i = 0; i < iterations160; ++i) {
RGBScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
kFilterBilinear);
}
EXPECT_EQ(225, dest_pixels[0]);
EXPECT_EQ(255 - 225, dest_pixels[1]);
RGBScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
kFilterNone);
EXPECT_EQ(225, dest_pixels[0]);
EXPECT_EQ(255 - 225, dest_pixels[1]);
free_aligned_buffer_page_end(dest_pixels);
free_aligned_buffer_page_end(orig_pixels);
}
TEST_F(LibYUVScaleTest, RGBTest4x) {
const int kSrcStride = 640 * 3;
const int kDstStride = 160 * 3;
const int kSize = kSrcStride * 4;
align_buffer_page_end(orig_pixels, kSize);
for (int i = 0; i < 640 * 4; ++i) {
orig_pixels[i * 3 + 0] = i;
orig_pixels[i * 3 + 1] = 255 - i;
}
align_buffer_page_end(dest_pixels, kDstStride);
int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
benchmark_iterations_;
for (int i = 0; i < iterations160; ++i) {
RGBScale(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
kFilterBilinear);
}
EXPECT_EQ(66, dest_pixels[0]);
EXPECT_EQ(190, dest_pixels[1]);
RGBScale(orig_pixels, kSrcStride, 64, 4, dest_pixels, kDstStride, 16, 1,
kFilterNone);
EXPECT_EQ(2, dest_pixels[0]); // expect the 3rd pixel of the 3rd row
EXPECT_EQ(255 - 2, dest_pixels[1]);
free_aligned_buffer_page_end(dest_pixels);
free_aligned_buffer_page_end(orig_pixels);
}
} // namespace libyuv