system: Linux mars.sprixweb.com 3.10.0-1160.119.1.el7.x86_64 #1 SMP Tue Jun 4 14:43:51 UTC 2024 x86_64
// Copyright 2022 Google LLC
// SPDX-License-Identifier: BSD-2-Clause
#include <algorithm>
#include <cmath>
#include <memory>
#include <tuple>
#include "avif/avif.h"
#include "aviftest_helpers.h"
#include "gtest/gtest.h"
using ::testing::Bool;
using ::testing::Combine;
using ::testing::Range;
using ::testing::Values;
namespace libavif {
namespace {
//------------------------------------------------------------------------------
constexpr uint32_t kModifierSize = 4 * 4;
// Modifies the pixel values of a channel in image by modifier[] (row-ordered).
template <typename PixelType>
void ModifyImageChannel(avifRGBImage* image, uint32_t channel_offset,
const uint8_t modifier[kModifierSize]) {
const uint32_t channel_count = avifRGBFormatChannelCount(image->format);
assert(channel_offset < channel_count);
for (uint32_t y = 0, i = 0; y < image->height; ++y) {
PixelType* pixel =
reinterpret_cast<PixelType*>(image->pixels + image->rowBytes * y);
for (uint32_t x = 0; x < image->width; ++x, ++i) {
pixel[channel_offset] += modifier[i % kModifierSize];
pixel += channel_count;
}
}
}
void ModifyImageChannel(avifRGBImage* image, uint32_t channel_offset,
const uint8_t modifier[kModifierSize]) {
if (image->depth <= 8) {
ModifyImageChannel<uint8_t>(image, channel_offset, modifier);
} else {
ModifyImageChannel<uint16_t>(image, channel_offset, modifier);
}
}
// Accumulates stats about the differences between the images a and b.
template <typename PixelType>
void GetDiffSumAndSqDiffSum(const avifRGBImage& a, const avifRGBImage& b,
int64_t* diff_sum, int64_t* abs_diff_sum,
int64_t* sq_diff_sum, int64_t* max_abs_diff) {
const uint32_t channel_count = avifRGBFormatChannelCount(a.format);
for (uint32_t y = 0; y < a.height; ++y) {
const PixelType* row_a =
reinterpret_cast<PixelType*>(a.pixels + a.rowBytes * y);
const PixelType* row_b =
reinterpret_cast<PixelType*>(b.pixels + b.rowBytes * y);
for (uint32_t x = 0; x < a.width * channel_count; ++x) {
const int64_t diff =
static_cast<int64_t>(row_b[x]) - static_cast<int64_t>(row_a[x]);
*diff_sum += diff;
*abs_diff_sum += std::abs(diff);
*sq_diff_sum += diff * diff;
*max_abs_diff = std::max(*max_abs_diff, std::abs(diff));
}
}
}
void GetDiffSumAndSqDiffSum(const avifRGBImage& a, const avifRGBImage& b,
int64_t* diff_sum, int64_t* abs_diff_sum,
int64_t* sq_diff_sum, int64_t* max_abs_diff) {
(a.depth <= 8) ? GetDiffSumAndSqDiffSum<uint8_t>(a, b, diff_sum, abs_diff_sum,
sq_diff_sum, max_abs_diff)
: GetDiffSumAndSqDiffSum<uint16_t>(
a, b, diff_sum, abs_diff_sum, sq_diff_sum, max_abs_diff);
}
// Returns the Peak Signal-to-Noise Ratio from accumulated stats.
double GetPsnr(double sq_diff_sum, double num_diffs, double max_abs_diff) {
if (sq_diff_sum == 0.) {
return 99.; // Lossless.
}
const double distortion =
sq_diff_sum / (num_diffs * max_abs_diff * max_abs_diff);
return (distortion > 0.) ? std::min(-10 * std::log10(distortion), 98.9)
: 98.9; // Not lossless.
}
//------------------------------------------------------------------------------
// To exercise the chroma subsampling loss, the input samples must differ in
// each of the RGB channels. Chroma subsampling expects the input RGB channels
// to be correlated to minimize the quality loss.
constexpr uint8_t kRedNoise[kModifierSize] = {
7, 14, 11, 5, // Random permutation of 16 values.
4, 6, 8, 15, //
2, 9, 13, 3, //
12, 1, 10, 0};
constexpr uint8_t kGreenNoise[kModifierSize] = {
3, 2, 12, 15, // Random permutation of 16 values
14, 10, 7, 13, // that is somewhat close to kRedNoise.
5, 1, 9, 0, //
8, 4, 11, 6};
constexpr uint8_t kBlueNoise[kModifierSize] = {
0, 8, 14, 9, // Random permutation of 16 values
13, 12, 2, 7, // that is somewhat close to kGreenNoise.
3, 1, 11, 10, //
6, 15, 5, 4};
//------------------------------------------------------------------------------
// Converts from RGB to YUV and back to RGB for all RGB combinations, separated
// by a color step for reasonable timing. If add_noise is true, also applies
// some noise to the input samples to exercise chroma subsampling.
void ConvertWholeRange(int rgb_depth, int yuv_depth, avifRGBFormat rgb_format,
avifPixelFormat yuv_format, avifRange yuv_range,
avifMatrixCoefficients matrix_coefficients,
avifChromaDownsampling chroma_downsampling,
bool add_noise, uint32_t rgb_step,
double max_abs_average_diff, double min_psnr, bool log) {
// Deduced constants.
const bool is_monochrome =
(yuv_format == AVIF_PIXEL_FORMAT_YUV400); // If so, only test grey input.
const uint32_t rgb_max = (1 << rgb_depth) - 1;
// The YUV upsampling treats the first and last rows and columns differently
// than the remaining pairs of rows and columns. An image of 16 pixels is used
// to test all these possibilities.
static constexpr int width = 4;
static constexpr int height = 4;
testutil::AvifImagePtr yuv(
avifImageCreate(width, height, yuv_depth, yuv_format), avifImageDestroy);
ASSERT_NE(yuv, nullptr);
yuv->matrixCoefficients = matrix_coefficients;
yuv->yuvRange = yuv_range;
testutil::AvifRgbImage src_rgb(yuv.get(), rgb_depth, rgb_format);
src_rgb.chromaDownsampling = chroma_downsampling;
testutil::AvifRgbImage dst_rgb(yuv.get(), rgb_depth, rgb_format);
const testutil::RgbChannelOffsets offsets =
testutil::GetRgbChannelOffsets(rgb_format);
// Alpha values are not tested here. Keep it opaque.
if (avifRGBFormatHasAlpha(src_rgb.format)) {
testutil::FillImageChannel(&src_rgb, offsets.a, rgb_max);
}
// Estimate the loss from converting RGB values to YUV and back.
int64_t diff_sum = 0, abs_diff_sum = 0, sq_diff_sum = 0, max_abs_diff = 0;
int64_t num_diffs = 0;
const uint32_t max_value = rgb_max - (add_noise ? 15 : 0);
for (uint32_t r = 0; r < max_value + rgb_step; r += rgb_step) {
r = std::min(r, max_value); // Test the maximum sample value even if it is
// not a multiple of rgb_step.
testutil::FillImageChannel(&src_rgb, offsets.r, r);
if (add_noise) {
ModifyImageChannel(&src_rgb, offsets.r, kRedNoise);
}
if (is_monochrome) {
// Test only greyish input when converting to a single channel.
testutil::FillImageChannel(&src_rgb, offsets.g, r);
testutil::FillImageChannel(&src_rgb, offsets.b, r);
if (add_noise) {
ModifyImageChannel(&src_rgb, offsets.g, kGreenNoise);
ModifyImageChannel(&src_rgb, offsets.b, kBlueNoise);
}
ASSERT_EQ(avifImageRGBToYUV(yuv.get(), &src_rgb), AVIF_RESULT_OK);
ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb), AVIF_RESULT_OK);
GetDiffSumAndSqDiffSum(src_rgb, dst_rgb, &diff_sum, &abs_diff_sum,
&sq_diff_sum, &max_abs_diff);
num_diffs += src_rgb.width * src_rgb.height * 3; // Alpha is lossless.
} else {
for (uint32_t g = 0; g < max_value + rgb_step; g += rgb_step) {
g = std::min(g, max_value);
testutil::FillImageChannel(&src_rgb, offsets.g, g);
if (add_noise) {
ModifyImageChannel(&src_rgb, offsets.g, kGreenNoise);
}
for (uint32_t b = 0; b < max_value + rgb_step; b += rgb_step) {
b = std::min(b, max_value);
testutil::FillImageChannel(&src_rgb, offsets.b, b);
if (add_noise) {
ModifyImageChannel(&src_rgb, offsets.b, kBlueNoise);
}
const avifResult result = avifImageRGBToYUV(yuv.get(), &src_rgb);
if (result == AVIF_RESULT_NOT_IMPLEMENTED &&
src_rgb.chromaDownsampling ==
AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV) {
GTEST_SKIP() << "libsharpyuv unavailable, skip test.";
}
ASSERT_EQ(result, AVIF_RESULT_OK);
ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb), AVIF_RESULT_OK);
GetDiffSumAndSqDiffSum(src_rgb, dst_rgb, &diff_sum, &abs_diff_sum,
&sq_diff_sum, &max_abs_diff);
num_diffs +=
src_rgb.width * src_rgb.height * 3; // Alpha is lossless.
}
}
}
}
// Stats and thresholds.
// Note: The thresholds defined in this test are calibrated for libyuv fast
// paths. See reformat_libyuv.c. Slower non-libyuv conversions in
// libavif have a higher precision (using floating point operations).
const double average_diff =
static_cast<double>(diff_sum) / static_cast<double>(num_diffs);
const double average_abs_diff =
static_cast<double>(abs_diff_sum) / static_cast<double>(num_diffs);
const double psnr = GetPsnr(static_cast<double>(sq_diff_sum),
static_cast<double>(num_diffs), rgb_max);
EXPECT_LE(std::abs(average_diff), max_abs_average_diff);
EXPECT_GE(psnr, min_psnr);
if (log) {
// Print stats for convenience and easier threshold tuning.
static constexpr const char* kAvifRgbFormatToString[] = {
"RGB", "RGBA", "ARGB", "BGR", "BGRA", "ABGR"};
std::cout << " RGB " << rgb_depth << " bits, YUV " << yuv_depth << " bits, "
<< kAvifRgbFormatToString[rgb_format] << ", "
<< avifPixelFormatToString(yuv_format) << ", "
<< (yuv_range ? "full" : "lmtd") << ", MC " << matrix_coefficients
<< ", " << (add_noise ? "noisy" : "plain") << ", avg "
<< average_diff << ", abs avg " << average_abs_diff << ", max "
<< max_abs_diff << ", PSNR " << psnr << "dB" << std::endl;
}
}
// Converts from RGB to YUV and back to RGB for multiple buffer dimensions to
// exercise stride computation and subsampling edge cases.
void ConvertWholeBuffer(int rgb_depth, int yuv_depth, avifRGBFormat rgb_format,
avifPixelFormat yuv_format, avifRange yuv_range,
avifMatrixCoefficients matrix_coefficients,
avifChromaDownsampling chroma_downsampling,
bool add_noise, double min_psnr) {
// Deduced constants.
const bool is_monochrome =
(yuv_format == AVIF_PIXEL_FORMAT_YUV400); // If so, only test grey input.
const uint32_t rgb_max = (1 << rgb_depth) - 1;
// Estimate the loss from converting RGB values to YUV and back.
int64_t diff_sum = 0, abs_diff_sum = 0, sq_diff_sum = 0, max_abs_diff = 0;
int64_t num_diffs = 0;
for (int width : {1, 2, 127}) {
for (int height : {1, 2, 251}) {
testutil::AvifImagePtr yuv(
avifImageCreate(width, height, yuv_depth, yuv_format),
avifImageDestroy);
ASSERT_NE(yuv, nullptr);
yuv->matrixCoefficients = matrix_coefficients;
yuv->yuvRange = yuv_range;
testutil::AvifRgbImage src_rgb(yuv.get(), rgb_depth, rgb_format);
src_rgb.chromaDownsampling = chroma_downsampling;
testutil::AvifRgbImage dst_rgb(yuv.get(), rgb_depth, rgb_format);
const testutil::RgbChannelOffsets offsets =
testutil::GetRgbChannelOffsets(rgb_format);
// Fill the input buffer with whatever content.
testutil::FillImageChannel(&src_rgb, offsets.r, /*value=*/0);
testutil::FillImageChannel(&src_rgb, offsets.g, /*value=*/0);
testutil::FillImageChannel(&src_rgb, offsets.b, /*value=*/0);
if (add_noise) {
ModifyImageChannel(&src_rgb, offsets.r, kRedNoise);
ModifyImageChannel(&src_rgb, offsets.g,
is_monochrome ? kRedNoise : kGreenNoise);
ModifyImageChannel(&src_rgb, offsets.b,
is_monochrome ? kRedNoise : kBlueNoise);
}
// Alpha values are not tested here. Keep it opaque.
if (avifRGBFormatHasAlpha(src_rgb.format)) {
testutil::FillImageChannel(&src_rgb, offsets.a, rgb_max);
}
const avifResult result = avifImageRGBToYUV(yuv.get(), &src_rgb);
if (result == AVIF_RESULT_NOT_IMPLEMENTED &&
src_rgb.chromaDownsampling == AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV) {
GTEST_SKIP() << "libsharpyuv unavailable, skip test.";
}
ASSERT_EQ(result, AVIF_RESULT_OK);
ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb), AVIF_RESULT_OK);
GetDiffSumAndSqDiffSum(src_rgb, dst_rgb, &diff_sum, &abs_diff_sum,
&sq_diff_sum, &max_abs_diff);
num_diffs += src_rgb.width * src_rgb.height * 3;
}
}
// max_abs_average_diff is not tested here because it is not meaningful for
// only 3*3 conversions as it takes the maximum difference per conversion.
// PSNR is averaged on all pixels so it can be tested here.
EXPECT_GE(GetPsnr(static_cast<double>(sq_diff_sum),
static_cast<double>(num_diffs), rgb_max),
min_psnr);
}
//------------------------------------------------------------------------------
// Exhaustive settings
// These tests would generate too many GoogleTest instances as parameterized
// tests (TEST_P) so loops are used instead.
TEST(RGBToYUVTest, ExhaustiveSettings) {
// Coverage of all configurations with all min/max input combinations.
for (int rgb_depth : {8, 10, 12, 16}) {
for (int yuv_depth : {8, 10, 12, 16}) {
for (avifRGBFormat rgb_format :
{AVIF_RGB_FORMAT_RGB, AVIF_RGB_FORMAT_RGBA, AVIF_RGB_FORMAT_ARGB,
AVIF_RGB_FORMAT_BGR, AVIF_RGB_FORMAT_BGRA, AVIF_RGB_FORMAT_ABGR}) {
for (avifPixelFormat yuv_format :
{AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}) {
for (avifRange yuv_range : {AVIF_RANGE_LIMITED, AVIF_RANGE_FULL}) {
for (decltype(AVIF_MATRIX_COEFFICIENTS_IDENTITY)
matrix_coefficients : {AVIF_MATRIX_COEFFICIENTS_IDENTITY,
AVIF_MATRIX_COEFFICIENTS_BT601}) {
if (matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY &&
yuv_format != AVIF_PIXEL_FORMAT_YUV444) {
// See avifPrepareReformatState().
continue;
}
for (avifChromaDownsampling chroma_downsampling :
{AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC,
AVIF_CHROMA_DOWNSAMPLING_FASTEST,
AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY,
AVIF_CHROMA_DOWNSAMPLING_AVERAGE,
AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV}) {
if (chroma_downsampling == AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV &&
yuv_depth > 12) {
// SharpYuvConvert() only supports YUV bit depths up to 12.
continue;
}
ConvertWholeRange(
rgb_depth, yuv_depth, rgb_format, yuv_format, yuv_range,
static_cast<avifMatrixCoefficients>(matrix_coefficients),
chroma_downsampling,
/*add_noise=*/true,
// Just try min and max values.
/*rgb_step=*/(1u << rgb_depth) - 1u,
// Barely check the results, this is mostly for coverage.
/*max_abs_average_diff=*/(1u << rgb_depth) - 1u,
/*min_psnr=*/5.0,
// Avoid spam.
/*log=*/false);
}
}
}
}
}
}
}
}
TEST(RGBToYUVTest, AllMatrixCoefficients) {
// Coverage of all configurations with all min/max input combinations.
for (int rgb_depth : {8, 10, 12, 16}) {
for (int yuv_depth : {8, 10, 12, 16}) {
for (avifPixelFormat yuv_format :
{AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}) {
for (avifRange yuv_range : {AVIF_RANGE_LIMITED, AVIF_RANGE_FULL}) {
for (decltype(AVIF_MATRIX_COEFFICIENTS_IDENTITY) matrix_coefficients :
{
AVIF_MATRIX_COEFFICIENTS_BT709,
AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED,
AVIF_MATRIX_COEFFICIENTS_FCC,
AVIF_MATRIX_COEFFICIENTS_BT470BG,
AVIF_MATRIX_COEFFICIENTS_BT601,
AVIF_MATRIX_COEFFICIENTS_SMPTE240,
AVIF_MATRIX_COEFFICIENTS_YCGCO,
AVIF_MATRIX_COEFFICIENTS_BT2020_NCL,
AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL
// These are unsupported. See avifPrepareReformatState().
// AVIF_MATRIX_COEFFICIENTS_BT2020_CL
// AVIF_MATRIX_COEFFICIENTS_SMPTE2085
// AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL
// AVIF_MATRIX_COEFFICIENTS_ICTCP
}) {
if (matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO &&
yuv_range == AVIF_RANGE_LIMITED) {
// See avifPrepareReformatState().
continue;
}
for (avifChromaDownsampling chroma_downsampling :
{AVIF_CHROMA_DOWNSAMPLING_FASTEST,
AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY}) {
ConvertWholeRange(
rgb_depth, yuv_depth, AVIF_RGB_FORMAT_RGBA, yuv_format,
yuv_range,
static_cast<avifMatrixCoefficients>(matrix_coefficients),
chroma_downsampling,
/*add_noise=*/true,
// Just try min and max values.
/*rgb_step=*/(1u << rgb_depth) - 1u,
// Barely check the results, this is mostly for coverage.
/*max_abs_average_diff=*/(1u << rgb_depth) - 1u,
/*min_psnr=*/5.0,
// Avoid spam.
/*log=*/false);
}
}
}
}
}
}
}
//------------------------------------------------------------------------------
// Selected configurations
class RGBToYUVTest
: public testing::TestWithParam<std::tuple<
/*rgb_depth=*/int, /*yuv_depth=*/int, avifRGBFormat, avifPixelFormat,
avifRange, avifMatrixCoefficients, avifChromaDownsampling,
/*add_noise=*/bool, /*rgb_step=*/uint32_t,
/*max_abs_average_diff=*/double, /*min_psnr=*/double>> {};
TEST_P(RGBToYUVTest, ConvertWholeRange) {
ConvertWholeRange(
/*rgb_depth=*/std::get<0>(GetParam()),
/*yuv_depth=*/std::get<1>(GetParam()),
/*rgb_format=*/std::get<2>(GetParam()),
/*yuv_format=*/std::get<3>(GetParam()),
/*yuv_range=*/std::get<4>(GetParam()),
/*matrix_coefficients=*/std::get<5>(GetParam()),
/*chroma_downsampling=*/std::get<6>(GetParam()),
// Whether to add noise to the input RGB samples.
// Should only impact subsampled chroma (4:2:2 and 4:2:0).
/*add_noise=*/std::get<7>(GetParam()),
// Testing each RGB combination would be more accurate but results are
// similar with faster settings.
/*rgb_step=*/std::get<8>(GetParam()),
// Thresholds to pass.
/*max_abs_average_diff=*/std::get<9>(GetParam()),
/*min_psnr=*/std::get<10>(GetParam()),
// Useful to see surrounding results when there is a failure.
/*log=*/true);
}
TEST_P(RGBToYUVTest, ConvertWholeBuffer) {
ConvertWholeBuffer(
/*rgb_depth=*/std::get<0>(GetParam()),
/*yuv_depth=*/std::get<1>(GetParam()),
/*rgb_format=*/std::get<2>(GetParam()),
/*yuv_format=*/std::get<3>(GetParam()),
/*yuv_range=*/std::get<4>(GetParam()),
/*matrix_coefficients=*/std::get<5>(GetParam()),
/*chroma_downsampling=*/std::get<6>(GetParam()),
// Whether to add noise to the input RGB samples.
/*add_noise=*/std::get<7>(GetParam()),
// Threshold to pass.
/*min_psnr=*/std::get<10>(GetParam()));
}
// avifMatrixCoefficients-typed constants for testing::Values() to work on MSVC.
// typedef or using decltype(AVIF_MATRIX_COEFFICIENTS_IDENTITY) does not work
// (GTest template "declared using unnamed type, is used but never defined").
constexpr avifMatrixCoefficients kMatrixCoefficientsBT601 =
AVIF_MATRIX_COEFFICIENTS_BT601;
constexpr avifMatrixCoefficients kMatrixCoefficientsBT709 =
AVIF_MATRIX_COEFFICIENTS_BT709;
constexpr avifMatrixCoefficients kMatrixCoefficientsIdentity =
AVIF_MATRIX_COEFFICIENTS_IDENTITY;
// This is the default avifenc setup when encoding from 8b PNG files to AVIF.
INSTANTIATE_TEST_SUITE_P(
DefaultFormat, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV420), Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(3),
/*max_abs_average_diff=*/Values(0.1), // The color drift is almost
// centered.
/*min_psnr=*/Values(36.) // Subsampling distortion is acceptable.
));
// Keeping RGB samples in full range and same or higher bit depth should not
// bring any loss in the roundtrip.
INSTANTIATE_TEST_SUITE_P(Identity8b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8, 10, 12, 16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsIdentity),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(31),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
INSTANTIATE_TEST_SUITE_P(Identity10b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(10),
/*yuv_depth=*/Values(10, 12, 16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsIdentity),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(101),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
INSTANTIATE_TEST_SUITE_P(Identity12b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(12),
/*yuv_depth=*/Values(12, 16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsIdentity),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(401),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
INSTANTIATE_TEST_SUITE_P(Identity16b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(16),
/*yuv_depth=*/Values(16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsIdentity),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(6421),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
// 4:4:4 and chroma subsampling have similar distortions on plain color inputs.
INSTANTIATE_TEST_SUITE_P(
PlainAnySubsampling8b, RGBToYUVTest,
Combine(
/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_FULL), Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(false),
/*rgb_step=*/Values(17),
/*max_abs_average_diff=*/Values(0.02), // The color drift is centered.
/*min_psnr=*/Values(45.) // RGB>YUV>RGB distortion is barely
// noticeable.
));
// Converting grey RGB samples to full-range monochrome of same or greater bit
// depth should be lossless.
INSTANTIATE_TEST_SUITE_P(MonochromeLossless8b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8, 10, 12, 16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV400),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(false),
/*rgb_step=*/Values(1),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
INSTANTIATE_TEST_SUITE_P(MonochromeLossless10b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(10),
/*yuv_depth=*/Values(10, 12, 16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV400),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(false),
/*rgb_step=*/Values(1),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
INSTANTIATE_TEST_SUITE_P(MonochromeLossless12b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(12),
/*yuv_depth=*/Values(12, 16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV400),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(false),
/*rgb_step=*/Values(1),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
INSTANTIATE_TEST_SUITE_P(MonochromeLossless16b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(16),
/*yuv_depth=*/Values(16),
Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV400),
Values(AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Values(false),
/*rgb_step=*/Values(401),
/*max_abs_average_diff=*/Values(0.),
/*min_psnr=*/Values(99.)));
// Coverage for reformat_libsharpyuv.c.
INSTANTIATE_TEST_SUITE_P(
SharpYuv8Bit, RGBToYUVTest,
Combine(
/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8, 10, 12), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601, kMatrixCoefficientsBT709),
Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(17),
/*max_abs_average_diff=*/Values(1.2), // Sharp YUV introduces some
// color shift.
/*min_psnr=*/Values(34.) // SharpYuv distortion is acceptable.
));
INSTANTIATE_TEST_SUITE_P(
SharpYuv10Bit, RGBToYUVTest,
Combine(
/*rgb_depth=*/Values(10),
/*yuv_depth=*/Values(8, 10, 12), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(211), // High or it would be too slow.
/*max_abs_average_diff=*/Values(1.2), // Sharp YUV introduces some
// color shift.
/*min_psnr=*/Values(34.) // SharpYuv distortion is acceptable.
));
INSTANTIATE_TEST_SUITE_P(
SharpYuv12Bit, RGBToYUVTest,
Combine(
/*rgb_depth=*/Values(12),
/*yuv_depth=*/Values(8, 10, 12), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(840), // High or it would be too slow.
/*max_abs_average_diff=*/Values(1.2), // Sharp YUV introduces some
// color shift.
/*min_psnr=*/Values(34.) // SharpYuv distortion is acceptable.
));
INSTANTIATE_TEST_SUITE_P(
SharpYuv16Bit, RGBToYUVTest,
Combine(
/*rgb_depth=*/Values(16),
// TODO(yguyon): Why max_abs_average_diff>28 if RGB16 to YUV10 full rng?
/*yuv_depth=*/Values(8, /*10,*/ 12), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
/*add_noise=*/Values(true),
/*rgb_step=*/Values(4567), // High or it would be too slow.
/*max_abs_average_diff=*/Values(2.5), // Sharp YUV introduces some
// color shift.
/*min_psnr=*/Values(49.) // SharpYuv distortion is acceptable.
));
// Can be used to print the drift of all RGB to YUV conversion possibilities.
// Also used for coverage.
INSTANTIATE_TEST_SUITE_P(
All8b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8, 10, 12, 16),
Values(AVIF_RGB_FORMAT_RGBA, AVIF_RGB_FORMAT_BGR),
Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Bool(),
/*rgb_step=*/Values(61), // High or it would be too slow.
/*max_abs_average_diff=*/Values(1.), // Not very accurate because
// of high rgb_step.
/*min_psnr=*/Values(36.)));
INSTANTIATE_TEST_SUITE_P(
All10b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(10),
/*yuv_depth=*/Values(8, 10, 12, 16), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Bool(),
/*rgb_step=*/Values(211), // High or it would be too slow.
/*max_abs_average_diff=*/Values(0.2), // Not very accurate because
// of high rgb_step.
/*min_psnr=*/Values(47.)));
INSTANTIATE_TEST_SUITE_P(
All12b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(12),
/*yuv_depth=*/Values(8, 10, 12, 16), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Bool(),
/*rgb_step=*/Values(809), // High or it would be too slow.
/*max_abs_average_diff=*/Values(0.3), // Not very accurate because
// of high rgb_step.
/*min_psnr=*/Values(52.)));
INSTANTIATE_TEST_SUITE_P(
All16b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(16),
/*yuv_depth=*/Values(16), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420),
Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Bool(),
/*rgb_step=*/Values(16001), // High or it would be too slow.
/*max_abs_average_diff=*/Values(0.05),
/*min_psnr=*/Values(80.)));
// This was used to estimate the quality loss of libyuv for RGB-to-YUV.
// Disabled because it takes a few minutes.
INSTANTIATE_TEST_SUITE_P(
DISABLED_All8bTo8b, RGBToYUVTest,
Combine(/*rgb_depth=*/Values(8),
/*yuv_depth=*/Values(8), Values(AVIF_RGB_FORMAT_RGBA),
Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400),
Values(AVIF_RANGE_FULL, AVIF_RANGE_LIMITED),
Values(kMatrixCoefficientsBT601),
Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
/*add_noise=*/Bool(),
/*rgb_step=*/Values(3), // way faster and 99% similar to rgb_step=1
/*max_abs_average_diff=*/Values(10.),
/*min_psnr=*/Values(10.)));
// Converts YUV pixels to RGB using one thread and multiple threads and checks
// whether the results of both are identical.
class YUVToRGBThreadingTest
: public testing::TestWithParam<std::tuple<
/*rgb_depth=*/int, /*yuv_depth=*/int,
/*width=*/int, /*height=*/int, avifRGBFormat, avifPixelFormat,
/*threads=*/int, /*avoidLibYUV=*/bool, avifChromaUpsampling,
/*has_alpha=*/bool>> {};
TEST_P(YUVToRGBThreadingTest, TestIdentical) {
const int rgb_depth = std::get<0>(GetParam());
const int yuv_depth = std::get<1>(GetParam());
const int width = std::get<2>(GetParam());
const int height = std::get<3>(GetParam());
const avifRGBFormat rgb_format = std::get<4>(GetParam());
const avifPixelFormat yuv_format = std::get<5>(GetParam());
const int maxThreads = std::get<6>(GetParam());
const bool avoidLibYUV = std::get<7>(GetParam());
const avifChromaUpsampling chromaUpsampling = std::get<8>(GetParam());
const bool has_alpha = std::get<9>(GetParam());
if (rgb_depth > 8 && rgb_format == AVIF_RGB_FORMAT_RGB_565) {
return;
}
testutil::AvifImagePtr yuv(
avifImageCreate(width, height, yuv_depth, yuv_format), avifImageDestroy);
ASSERT_NE(yuv, nullptr);
yuv->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;
yuv->yuvRange = AVIF_RANGE_FULL;
// Fill YUVA planes with random values.
srand(0xAABBCCDD);
const int yuv_max = (1 << yuv_depth);
ASSERT_EQ(avifImageAllocatePlanes(
yuv.get(), has_alpha ? AVIF_PLANES_ALL : AVIF_PLANES_YUV),
AVIF_RESULT_OK);
for (int plane = AVIF_CHAN_Y; plane <= AVIF_CHAN_A; ++plane) {
const uint32_t plane_width = avifImagePlaneWidth(yuv.get(), plane);
if (plane_width == 0) continue;
const uint32_t plane_height = avifImagePlaneHeight(yuv.get(), plane);
const uint32_t rowBytes = avifImagePlaneRowBytes(yuv.get(), plane);
uint8_t* row = avifImagePlane(yuv.get(), plane);
for (uint32_t y = 0; y < plane_height; ++y, row += rowBytes) {
for (uint32_t x = 0; x < plane_width; ++x) {
if (yuv_depth == 8) {
row[x] = (uint8_t)(rand() % yuv_max);
} else {
((uint16_t*)row)[x] = (uint16_t)(rand() % yuv_max);
}
}
}
}
// Convert to RGB with 1 thread.
testutil::AvifRgbImage rgb(yuv.get(), rgb_depth, rgb_format);
rgb.avoidLibYUV = avoidLibYUV;
rgb.chromaUpsampling = chromaUpsampling;
ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &rgb), AVIF_RESULT_OK);
// Convert to RGB with multiple threads.
testutil::AvifRgbImage rgb_threaded(yuv.get(), rgb_depth, rgb_format);
rgb_threaded.avoidLibYUV = avoidLibYUV;
rgb_threaded.chromaUpsampling = chromaUpsampling;
rgb_threaded.maxThreads = maxThreads;
ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &rgb_threaded), AVIF_RESULT_OK);
EXPECT_TRUE(testutil::AreImagesEqual(rgb, rgb_threaded));
}
INSTANTIATE_TEST_SUITE_P(
YUVToRGBThreadingTestInstance, YUVToRGBThreadingTest,
Combine(/*rgb_depth=*/Values(8, 16),
/*yuv_depth=*/Values(8, 10),
/*width=*/Values(1, 2, 127, 200),
/*height=*/Values(1, 2, 127, 200),
Values(AVIF_RGB_FORMAT_RGB, AVIF_RGB_FORMAT_RGBA),
Range(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_COUNT),
// Test an odd and even number for threads. Not adding all possible
// thread values to keep the number of test instances low.
/*threads=*/Values(2, 7),
/*avoidLibYUV=*/Bool(),
Values(AVIF_CHROMA_UPSAMPLING_FASTEST,
AVIF_CHROMA_UPSAMPLING_BILINEAR),
/*has_alpha=*/Bool()));
// This will generate a large number of test instances and hence it is disabled
// by default. It can be run manually if necessary.
INSTANTIATE_TEST_SUITE_P(
DISABLED_ExhaustiveYUVToRGBThreadingTestInstance, YUVToRGBThreadingTest,
Combine(/*rgb_depth=*/Values(8, 10, 12, 16),
/*yuv_depth=*/Values(8, 10, 12),
/*width=*/Values(1, 2, 127, 200),
/*height=*/Values(1, 2, 127, 200),
Range(AVIF_RGB_FORMAT_RGB, AVIF_RGB_FORMAT_COUNT),
Range(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_COUNT),
/*threads=*/Range(0, 9),
/*avoidLibYUV=*/Bool(),
Values(AVIF_CHROMA_UPSAMPLING_AUTOMATIC,
AVIF_CHROMA_UPSAMPLING_FASTEST,
AVIF_CHROMA_UPSAMPLING_NEAREST,
AVIF_CHROMA_UPSAMPLING_BILINEAR),
/*has_alpha=*/Bool()));
} // namespace
} // namespace libavif