| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "cobalt/media/base/yuv_convert.h" |
| |
| #include <algorithm> |
| #include <memory> |
| |
| #include "base/base_paths.h" |
| #include "base/cpu.h" |
| #include "base/files/file_util.h" |
| #include "base/logging.h" |
| #include "base/path_service.h" |
| #include "build/build_config.h" |
| #include "cobalt/media/base/djb2.h" |
| #include "cobalt/media/base/simd/convert_rgb_to_yuv.h" |
| #include "cobalt/media/base/simd/convert_yuv_to_rgb.h" |
| #include "cobalt/media/base/simd/filter_yuv.h" |
| #include "starboard/memory.h" |
| #include "starboard/types.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/gfx/rect.h" |
| |
| // Size of raw image. |
| static const int kSourceWidth = 640; |
| static const int kSourceHeight = 360; |
| static const int kSourceYSize = kSourceWidth * kSourceHeight; |
| static const int kSourceUOffset = kSourceYSize; |
| static const int kSourceVOffset = kSourceYSize * 5 / 4; |
| static const int kScaledWidth = 1024; |
| static const int kScaledHeight = 768; |
| static const int kDownScaledWidth = 512; |
| static const int kDownScaledHeight = 320; |
| static const int kBpp = 4; |
| |
| // Surface sizes for various test files. |
| static const int kYUV12Size = kSourceYSize * 12 / 8; |
| static const int kYUV16Size = kSourceYSize * 16 / 8; |
| static const int kRGBSize = kSourceYSize * kBpp; |
| static const int kRGBSizeScaled = kScaledWidth * kScaledHeight * kBpp; |
| static const int kRGB24Size = kSourceYSize * 3; |
| static const int kRGBSizeConverted = kSourceYSize * kBpp; |
| |
| #if !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY) && \ |
| !defined(OS_ANDROID) |
| static const int kSourceAOffset = kSourceYSize * 12 / 8; |
| static const int kYUVA12Size = kSourceYSize * 20 / 8; |
| #endif |
| |
| // Helper for reading test data into a std::unique_ptr<uint8_t[]>. |
| static void ReadData(const base::FilePath::CharType* filename, |
| int expected_size, std::unique_ptr<uint8_t[]>* data) { |
| data->reset(new uint8_t[expected_size]); |
| |
| base::FilePath path; |
| CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &path)); |
| path = path.Append(FILE_PATH_LITERAL("media")) |
| .Append(FILE_PATH_LITERAL("test")) |
| .Append(FILE_PATH_LITERAL("data")) |
| .Append(filename); |
| |
| // Verify file size is correct. |
| int64_t actual_size = 0; |
| base::GetFileSize(path, &actual_size); |
| CHECK_EQ(actual_size, expected_size); |
| |
| // Verify bytes read are correct. |
| int bytes_read = |
| base::ReadFile(path, reinterpret_cast<char*>(data->get()), expected_size); |
| CHECK_EQ(bytes_read, expected_size); |
| } |
| |
| static void ReadYV12Data(std::unique_ptr<uint8_t[]>* data) { |
| ReadData(FILE_PATH_LITERAL("bali_640x360_P420.yuv"), kYUV12Size, data); |
| } |
| |
| static void ReadYV16Data(std::unique_ptr<uint8_t[]>* data) { |
| ReadData(FILE_PATH_LITERAL("bali_640x360_P422.yuv"), kYUV16Size, data); |
| } |
| |
| #if !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY) && \ |
| !defined(OS_ANDROID) |
| static void ReadYV12AData(std::unique_ptr<uint8_t[]>* data) { |
| ReadData(FILE_PATH_LITERAL("bali_640x360_P420_alpha.yuv"), kYUVA12Size, data); |
| } |
| #endif |
| |
| static void ReadRGB24Data(std::unique_ptr<uint8_t[]>* data) { |
| ReadData(FILE_PATH_LITERAL("bali_640x360_RGB24.rgb"), kRGB24Size, data); |
| } |
| |
| #if defined(OS_ANDROID) |
| // Helper for swapping red and blue channels of RGBA or BGRA. |
| static void SwapRedAndBlueChannels(unsigned char* pixels, size_t buffer_size) { |
| for (size_t i = 0; i < buffer_size; i += 4) { |
| std::swap(pixels[i], pixels[i + 2]); |
| } |
| } |
| #endif |
| |
| namespace cobalt { |
| namespace media { |
| |
| TEST(YUVConvertTest, YV12) { |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> yuv_bytes; |
| std::unique_ptr<uint8_t[]> rgb_bytes(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_converted_bytes( |
| new uint8_t[kRGBSizeConverted]); |
| |
| // Read YUV reference data from file. |
| ReadYV12Data(&yuv_bytes); |
| |
| // Convert a frame of YUV to 32 bit ARGB. |
| media::ConvertYUVToRGB32(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_converted_bytes.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UVStride |
| kSourceWidth * kBpp, // RGBStride |
| media::YV12); |
| |
| #if defined(OS_ANDROID) |
| SwapRedAndBlueChannels(rgb_converted_bytes.get(), kRGBSizeConverted); |
| #endif |
| |
| uint32_t rgb_hash = |
| DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted, kDJB2HashSeed); |
| EXPECT_EQ(2413171226u, rgb_hash); |
| } |
| |
| TEST(YUVConvertTest, YV16) { |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> yuv_bytes; |
| std::unique_ptr<uint8_t[]> rgb_bytes(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_converted_bytes( |
| new uint8_t[kRGBSizeConverted]); |
| |
| // Read YUV reference data from file. |
| ReadYV16Data(&yuv_bytes); |
| |
| // Convert a frame of YUV to 32 bit ARGB. |
| media::ConvertYUVToRGB32(yuv_bytes.get(), // Y |
| yuv_bytes.get() + kSourceUOffset, // U |
| yuv_bytes.get() + kSourceYSize * 3 / 2, // V |
| rgb_converted_bytes.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UVStride |
| kSourceWidth * kBpp, // RGBStride |
| media::YV16); |
| |
| #if defined(OS_ANDROID) |
| SwapRedAndBlueChannels(rgb_converted_bytes.get(), kRGBSizeConverted); |
| #endif |
| |
| uint32_t rgb_hash = |
| DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted, kDJB2HashSeed); |
| EXPECT_EQ(4222342047u, rgb_hash); |
| } |
| |
| struct YUVScaleTestData { |
| YUVScaleTestData(media::YUVType y, media::ScaleFilter s, uint32_t r) |
| : yuv_type(y), scale_filter(s), rgb_hash(r) {} |
| |
| media::YUVType yuv_type; |
| media::ScaleFilter scale_filter; |
| uint32_t rgb_hash; |
| }; |
| |
| class YUVScaleTest : public ::testing::TestWithParam<YUVScaleTestData> { |
| public: |
| YUVScaleTest() { |
| switch (GetParam().yuv_type) { |
| case media::YV12: |
| case media::YV12J: |
| case media::YV12HD: |
| ReadYV12Data(&yuv_bytes_); |
| break; |
| case media::YV16: |
| ReadYV16Data(&yuv_bytes_); |
| break; |
| } |
| |
| rgb_bytes_.reset(new uint8_t[kRGBSizeScaled]); |
| } |
| |
| // Helpers for getting the proper Y, U and V plane offsets. |
| uint8_t* y_plane() { return yuv_bytes_.get(); } |
| uint8_t* u_plane() { return yuv_bytes_.get() + kSourceYSize; } |
| uint8_t* v_plane() { |
| switch (GetParam().yuv_type) { |
| case media::YV12: |
| case media::YV12J: |
| case media::YV12HD: |
| return yuv_bytes_.get() + kSourceVOffset; |
| case media::YV16: |
| return yuv_bytes_.get() + kSourceYSize * 3 / 2; |
| } |
| return NULL; |
| } |
| |
| std::unique_ptr<uint8_t[]> yuv_bytes_; |
| std::unique_ptr<uint8_t[]> rgb_bytes_; |
| }; |
| |
| TEST_P(YUVScaleTest, NoScale) { |
| media::ScaleYUVToRGB32(y_plane(), // Y |
| u_plane(), // U |
| v_plane(), // V |
| rgb_bytes_.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kSourceWidth * kBpp, // RgbStride |
| GetParam().yuv_type, media::ROTATE_0, |
| GetParam().scale_filter); |
| |
| uint32_t yuv_hash = DJB2Hash(rgb_bytes_.get(), kRGBSize, kDJB2HashSeed); |
| |
| media::ConvertYUVToRGB32(y_plane(), // Y |
| u_plane(), // U |
| v_plane(), // V |
| rgb_bytes_.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UVStride |
| kSourceWidth * kBpp, // RGBStride |
| GetParam().yuv_type); |
| |
| uint32_t rgb_hash = DJB2Hash(rgb_bytes_.get(), kRGBSize, kDJB2HashSeed); |
| |
| EXPECT_EQ(yuv_hash, rgb_hash); |
| } |
| |
| TEST_P(YUVScaleTest, Normal) { |
| media::ScaleYUVToRGB32(y_plane(), // Y |
| u_plane(), // U |
| v_plane(), // V |
| rgb_bytes_.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kScaledWidth, kScaledHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kScaledWidth * kBpp, // RgbStride |
| GetParam().yuv_type, media::ROTATE_0, |
| GetParam().scale_filter); |
| |
| #if defined(OS_ANDROID) |
| SwapRedAndBlueChannels(rgb_bytes_.get(), kRGBSizeScaled); |
| #endif |
| |
| uint32_t rgb_hash = DJB2Hash(rgb_bytes_.get(), kRGBSizeScaled, kDJB2HashSeed); |
| EXPECT_EQ(GetParam().rgb_hash, rgb_hash); |
| } |
| |
| TEST_P(YUVScaleTest, ZeroSourceSize) { |
| media::ScaleYUVToRGB32(y_plane(), // Y |
| u_plane(), // U |
| v_plane(), // V |
| rgb_bytes_.get(), // RGB output |
| 0, 0, // Dimensions |
| kScaledWidth, kScaledHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kScaledWidth * kBpp, // RgbStride |
| GetParam().yuv_type, media::ROTATE_0, |
| GetParam().scale_filter); |
| |
| // Testing for out-of-bound read/writes with AddressSanitizer. |
| } |
| |
| TEST_P(YUVScaleTest, ZeroDestinationSize) { |
| media::ScaleYUVToRGB32(y_plane(), // Y |
| u_plane(), // U |
| v_plane(), // V |
| rgb_bytes_.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| 0, 0, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kScaledWidth * kBpp, // RgbStride |
| GetParam().yuv_type, media::ROTATE_0, |
| GetParam().scale_filter); |
| |
| // Testing for out-of-bound read/writes with AddressSanitizer. |
| } |
| |
| TEST_P(YUVScaleTest, OddWidthAndHeightNotCrash) { |
| media::ScaleYUVToRGB32(y_plane(), // Y |
| u_plane(), // U |
| v_plane(), // V |
| rgb_bytes_.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| 3, 3, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kScaledWidth * kBpp, // RgbStride |
| GetParam().yuv_type, media::ROTATE_0, |
| GetParam().scale_filter); |
| } |
| |
| INSTANTIATE_TEST_CASE_P( |
| YUVScaleFormats, YUVScaleTest, |
| ::testing::Values( |
| YUVScaleTestData(media::YV12, media::FILTER_NONE, 4136904952u), |
| YUVScaleTestData(media::YV16, media::FILTER_NONE, 1501777547u), |
| YUVScaleTestData(media::YV12, media::FILTER_BILINEAR, 3164274689u), |
| YUVScaleTestData(media::YV16, media::FILTER_BILINEAR, 3095878046u))); |
| |
| // This tests a known worst case YUV value, and for overflow. |
| TEST(YUVConvertTest, Clamp) { |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[1]); |
| std::unique_ptr<uint8_t[]> rgb_bytes(new uint8_t[1]); |
| std::unique_ptr<uint8_t[]> rgb_converted_bytes(new uint8_t[1]); |
| |
| // Values that failed previously in bug report. |
| unsigned char y = 255u; |
| unsigned char u = 255u; |
| unsigned char v = 19u; |
| |
| // Prefill extra large destination buffer to test for overflow. |
| unsigned char rgb[8] = {0, 1, 2, 3, 4, 5, 6, 7}; |
| unsigned char expected[8] = {255, 255, 104, 255, 4, 5, 6, 7}; |
| // Convert a frame of YUV to 32 bit ARGB. |
| media::ConvertYUVToRGB32(&y, // Y |
| &u, // U |
| &v, // V |
| &rgb[0], // RGB output |
| 1, 1, // Dimensions |
| 0, // YStride |
| 0, // UVStride |
| 0, // RGBStride |
| media::YV12); |
| |
| #if defined(OS_ANDROID) |
| SwapRedAndBlueChannels(rgb, kBpp); |
| #endif |
| |
| int expected_test = SbMemoryCompare(rgb, expected, sizeof(expected)); |
| EXPECT_EQ(0, expected_test); |
| } |
| |
| TEST(YUVConvertTest, RGB24ToYUV) { |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> rgb_bytes; |
| std::unique_ptr<uint8_t[]> yuv_converted_bytes(new uint8_t[kYUV12Size]); |
| |
| // Read RGB24 reference data from file. |
| ReadRGB24Data(&rgb_bytes); |
| |
| // Convert to I420. |
| media::ConvertRGB24ToYUV(rgb_bytes.get(), yuv_converted_bytes.get(), |
| yuv_converted_bytes.get() + kSourceUOffset, |
| yuv_converted_bytes.get() + kSourceVOffset, |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth * 3, // RGBStride |
| kSourceWidth, // YStride |
| kSourceWidth / 2); // UVStride |
| |
| uint32_t rgb_hash = |
| DJB2Hash(yuv_converted_bytes.get(), kYUV12Size, kDJB2HashSeed); |
| EXPECT_EQ(320824432u, rgb_hash); |
| } |
| |
| TEST(YUVConvertTest, RGB32ToYUV) { |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> yuv_converted_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_converted_bytes(new uint8_t[kRGBSize]); |
| |
| // Read YUV reference data from file. |
| base::FilePath yuv_url; |
| EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &yuv_url)); |
| yuv_url = yuv_url.Append(FILE_PATH_LITERAL("media")) |
| .Append(FILE_PATH_LITERAL("test")) |
| .Append(FILE_PATH_LITERAL("data")) |
| .Append(FILE_PATH_LITERAL("bali_640x360_P420.yuv")); |
| EXPECT_EQ(static_cast<int>(kYUV12Size), |
| base::ReadFile(yuv_url, reinterpret_cast<char*>(yuv_bytes.get()), |
| static_cast<int>(kYUV12Size))); |
| |
| // Convert a frame of YUV to 32 bit ARGB. |
| media::ConvertYUVToRGB32(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UVStride |
| kSourceWidth * kBpp, // RGBStride |
| media::YV12); |
| |
| // Convert RGB32 to YV12. |
| media::ConvertRGB32ToYUV(rgb_bytes.get(), yuv_converted_bytes.get(), |
| yuv_converted_bytes.get() + kSourceUOffset, |
| yuv_converted_bytes.get() + kSourceVOffset, |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth * 4, // RGBStride |
| kSourceWidth, // YStride |
| kSourceWidth / 2); // UVStride |
| |
| // Convert YV12 back to RGB32. |
| media::ConvertYUVToRGB32(yuv_converted_bytes.get(), |
| yuv_converted_bytes.get() + kSourceUOffset, |
| yuv_converted_bytes.get() + kSourceVOffset, |
| rgb_converted_bytes.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UVStride |
| kSourceWidth * kBpp, // RGBStride |
| media::YV12); |
| |
| int error = 0; |
| for (int i = 0; i < kRGBSize; ++i) { |
| int diff = rgb_converted_bytes[i] - rgb_bytes[i]; |
| if (diff < 0) diff = -diff; |
| error += diff; |
| } |
| |
| // Make sure error is within bound. |
| DVLOG(1) << "Average error per channel: " << error / kRGBSize; |
| EXPECT_GT(5, error / kRGBSize); |
| } |
| |
| TEST(YUVConvertTest, DownScaleYUVToRGB32WithRect) { |
| // Read YUV reference data from file. |
| base::FilePath yuv_url; |
| EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &yuv_url)); |
| yuv_url = yuv_url.Append(FILE_PATH_LITERAL("media")) |
| .Append(FILE_PATH_LITERAL("test")) |
| .Append(FILE_PATH_LITERAL("data")) |
| .Append(FILE_PATH_LITERAL("bali_640x360_P420.yuv")); |
| const size_t size_of_yuv = kSourceYSize * 12 / 8; // 12 bpp. |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[size_of_yuv]); |
| EXPECT_EQ(static_cast<int>(size_of_yuv), |
| base::ReadFile(yuv_url, reinterpret_cast<char*>(yuv_bytes.get()), |
| static_cast<int>(size_of_yuv))); |
| |
| // Scale the full frame of YUV to 32 bit ARGB. |
| // The API currently only supports down-scaling, so we don't test up-scaling. |
| const size_t size_of_rgb_scaled = kDownScaledWidth * kDownScaledHeight * kBpp; |
| std::unique_ptr<uint8_t[]> rgb_scaled_bytes(new uint8_t[size_of_rgb_scaled]); |
| gfx::Rect sub_rect(0, 0, kDownScaledWidth, kDownScaledHeight); |
| |
| // We can't compare with the full-frame scaler because it uses slightly |
| // different sampling coordinates. |
| media::ScaleYUVToRGB32WithRect( |
| yuv_bytes.get(), // Y |
| yuv_bytes.get() + kSourceUOffset, // U |
| yuv_bytes.get() + kSourceVOffset, // V |
| rgb_scaled_bytes.get(), // Rgb output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kDownScaledWidth, kDownScaledHeight, // Dimensions |
| sub_rect.x(), sub_rect.y(), // Dest rect |
| sub_rect.right(), sub_rect.bottom(), // Dest rect |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kDownScaledWidth * kBpp); // RgbStride |
| |
| uint32_t rgb_hash_full_rect = |
| DJB2Hash(rgb_scaled_bytes.get(), size_of_rgb_scaled, kDJB2HashSeed); |
| |
| // Re-scale sub-rectangles and verify the results are the same. |
| int next_sub_rect = 0; |
| while (!sub_rect.IsEmpty()) { |
| // Scale a partial rectangle. |
| media::ScaleYUVToRGB32WithRect( |
| yuv_bytes.get(), // Y |
| yuv_bytes.get() + kSourceUOffset, // U |
| yuv_bytes.get() + kSourceVOffset, // V |
| rgb_scaled_bytes.get(), // Rgb output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kDownScaledWidth, kDownScaledHeight, // Dimensions |
| sub_rect.x(), sub_rect.y(), // Dest rect |
| sub_rect.right(), sub_rect.bottom(), // Dest rect |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UvStride |
| kDownScaledWidth * kBpp); // RgbStride |
| uint32_t rgb_hash_sub_rect = |
| DJB2Hash(rgb_scaled_bytes.get(), size_of_rgb_scaled, kDJB2HashSeed); |
| |
| EXPECT_EQ(rgb_hash_full_rect, rgb_hash_sub_rect); |
| |
| // Now pick choose a quarter rect of this sub-rect. |
| if (next_sub_rect & 1) sub_rect.set_x(sub_rect.x() + sub_rect.width() / 2); |
| if (next_sub_rect & 2) sub_rect.set_y(sub_rect.y() + sub_rect.height() / 2); |
| sub_rect.set_width(sub_rect.width() / 2); |
| sub_rect.set_height(sub_rect.height() / 2); |
| next_sub_rect++; |
| } |
| } |
| |
| #if !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY) |
| #if !defined(OS_ANDROID) |
| TEST(YUVConvertTest, YUVAtoARGB_MMX_MatchReference) { |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> yuv_bytes; |
| std::unique_ptr<uint8_t[]> rgb_bytes(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_converted_bytes( |
| new uint8_t[kRGBSizeConverted]); |
| std::unique_ptr<uint8_t[]> rgb_converted_bytes_ref( |
| new uint8_t[kRGBSizeConverted]); |
| |
| // Read YUV reference data from file. |
| ReadYV12AData(&yuv_bytes); |
| |
| // Convert a frame of YUV to 32 bit ARGB using both C and MMX versions. |
| media::ConvertYUVAToARGB_C( |
| yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, yuv_bytes.get() + kSourceAOffset, |
| rgb_converted_bytes_ref.get(), kSourceWidth, kSourceHeight, kSourceWidth, |
| kSourceWidth / 2, kSourceWidth, kSourceWidth * kBpp, media::YV12); |
| media::ConvertYUVAToARGB_MMX( |
| yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, yuv_bytes.get() + kSourceAOffset, |
| rgb_converted_bytes.get(), kSourceWidth, kSourceHeight, kSourceWidth, |
| kSourceWidth / 2, kSourceWidth, kSourceWidth * kBpp, media::YV12); |
| |
| EXPECT_EQ(0, |
| SbMemoryCompare(rgb_converted_bytes.get(), |
| rgb_converted_bytes_ref.get(), kRGBSizeConverted)); |
| } |
| #endif // !defined(OS_ANDROID) |
| |
| TEST(YUVConvertTest, RGB32ToYUV_SSE2_MatchReference) { |
| base::CPU cpu; |
| if (!cpu.has_sse2()) { |
| LOG(WARNING) << "System doesn't support SSE2, test not executed."; |
| return; |
| } |
| |
| // Allocate all surfaces. |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> yuv_converted_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> yuv_reference_bytes(new uint8_t[kYUV12Size]); |
| |
| ReadYV12Data(&yuv_bytes); |
| |
| // Convert a frame of YUV to 32 bit ARGB. |
| media::ConvertYUVToRGB32(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes.get(), // RGB output |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth, // YStride |
| kSourceWidth / 2, // UVStride |
| kSourceWidth * kBpp, // RGBStride |
| media::YV12); |
| |
| // Convert RGB32 to YV12 with SSE2 version. |
| media::ConvertRGB32ToYUV_SSE2(rgb_bytes.get(), yuv_converted_bytes.get(), |
| yuv_converted_bytes.get() + kSourceUOffset, |
| yuv_converted_bytes.get() + kSourceVOffset, |
| kSourceWidth, kSourceHeight, // Dimensions |
| kSourceWidth * 4, // RGBStride |
| kSourceWidth, // YStride |
| kSourceWidth / 2); // UVStride |
| |
| // Convert RGB32 to YV12 with reference version. |
| media::ConvertRGB32ToYUV_SSE2_Reference( |
| rgb_bytes.get(), yuv_reference_bytes.get(), |
| yuv_reference_bytes.get() + kSourceUOffset, |
| yuv_reference_bytes.get() + kSourceVOffset, kSourceWidth, |
| kSourceHeight, // Dimensions |
| kSourceWidth * 4, // RGBStride |
| kSourceWidth, // YStride |
| kSourceWidth / 2); // UVStride |
| |
| // Now convert a odd width and height, this overrides part of the buffer |
| // generated above but that is fine because the point of this test is to |
| // match the result with the reference code. |
| |
| // Convert RGB32 to YV12 with SSE2 version. |
| media::ConvertRGB32ToYUV_SSE2(rgb_bytes.get(), yuv_converted_bytes.get(), |
| yuv_converted_bytes.get() + kSourceUOffset, |
| yuv_converted_bytes.get() + kSourceVOffset, 7, |
| 7, // Dimensions |
| kSourceWidth * 4, // RGBStride |
| kSourceWidth, // YStride |
| kSourceWidth / 2); // UVStride |
| |
| // Convert RGB32 to YV12 with reference version. |
| media::ConvertRGB32ToYUV_SSE2_Reference( |
| rgb_bytes.get(), yuv_reference_bytes.get(), |
| yuv_reference_bytes.get() + kSourceUOffset, |
| yuv_reference_bytes.get() + kSourceVOffset, 7, 7, // Dimensions |
| kSourceWidth * 4, // RGBStride |
| kSourceWidth, // YStride |
| kSourceWidth / 2); // UVStride |
| |
| int error = 0; |
| for (int i = 0; i < kYUV12Size; ++i) { |
| int diff = yuv_reference_bytes[i] - yuv_converted_bytes[i]; |
| if (diff < 0) diff = -diff; |
| error += diff; |
| } |
| |
| // Make sure there's no difference from the reference. |
| EXPECT_EQ(0, error); |
| } |
| |
| TEST(YUVConvertTest, ConvertYUVToRGB32Row_SSE) { |
| base::CPU cpu; |
| if (!cpu.has_sse()) { |
| LOG(WARNING) << "System not supported. Test skipped."; |
| return; |
| } |
| |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_reference(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_converted(new uint8_t[kRGBSize]); |
| ReadYV12Data(&yuv_bytes); |
| |
| const int kWidth = 167; |
| ConvertYUVToRGB32Row_C(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_reference.get(), kWidth, |
| GetLookupTable(YV12)); |
| ConvertYUVToRGB32Row_SSE(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_converted.get(), kWidth, |
| GetLookupTable(YV12)); |
| media::EmptyRegisterState(); |
| EXPECT_EQ(0, SbMemoryCompare(rgb_bytes_reference.get(), |
| rgb_bytes_converted.get(), kWidth * kBpp)); |
| } |
| |
| // 64-bit release + component builds on Windows are too smart and optimizes |
| // away the function being tested. |
| #if defined(OS_WIN) && (defined(ARCH_CPU_X86) || !defined(COMPONENT_BUILD)) |
| TEST(YUVConvertTest, ScaleYUVToRGB32Row_SSE) { |
| base::CPU cpu; |
| if (!cpu.has_sse()) { |
| LOG(WARNING) << "System not supported. Test skipped."; |
| return; |
| } |
| |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_reference(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_converted(new uint8_t[kRGBSize]); |
| ReadYV12Data(&yuv_bytes); |
| |
| const int kWidth = 167; |
| const int kSourceDx = 80000; // This value means a scale down. |
| ScaleYUVToRGB32Row_C(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_reference.get(), kWidth, kSourceDx, |
| GetLookupTable(YV12)); |
| ScaleYUVToRGB32Row_SSE(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_converted.get(), kWidth, kSourceDx, |
| GetLookupTable(YV12)); |
| media::EmptyRegisterState(); |
| EXPECT_EQ(0, SbMemoryCompare(rgb_bytes_reference.get(), |
| rgb_bytes_converted.get(), kWidth * kBpp)); |
| } |
| |
| TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_SSE) { |
| base::CPU cpu; |
| if (!cpu.has_sse()) { |
| LOG(WARNING) << "System not supported. Test skipped."; |
| return; |
| } |
| |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_reference(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_converted(new uint8_t[kRGBSize]); |
| ReadYV12Data(&yuv_bytes); |
| |
| const int kWidth = 167; |
| const int kSourceDx = 80000; // This value means a scale down. |
| LinearScaleYUVToRGB32Row_C(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_reference.get(), kWidth, kSourceDx, |
| GetLookupTable(YV12)); |
| LinearScaleYUVToRGB32Row_SSE( |
| yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, rgb_bytes_converted.get(), kWidth, |
| kSourceDx, GetLookupTable(YV12)); |
| media::EmptyRegisterState(); |
| EXPECT_EQ(0, SbMemoryCompare(rgb_bytes_reference.get(), |
| rgb_bytes_converted.get(), kWidth * kBpp)); |
| } |
| #endif // defined(OS_WIN) && (ARCH_CPU_X86 || COMPONENT_BUILD) |
| |
| TEST(YUVConvertTest, FilterYUVRows_C_OutOfBounds) { |
| std::unique_ptr<uint8_t[]> src(new uint8_t[16]); |
| std::unique_ptr<uint8_t[]> dst(new uint8_t[16]); |
| |
| SbMemorySet(src.get(), 0xff, 16); |
| SbMemorySet(dst.get(), 0, 16); |
| |
| media::FilterYUVRows_C(dst.get(), src.get(), src.get(), 1, 255); |
| |
| EXPECT_EQ(255u, dst[0]); |
| for (int i = 1; i < 16; ++i) { |
| EXPECT_EQ(0u, dst[i]) << " not equal at " << i; |
| } |
| } |
| |
| TEST(YUVConvertTest, FilterYUVRows_SSE2_OutOfBounds) { |
| base::CPU cpu; |
| if (!cpu.has_sse2()) { |
| LOG(WARNING) << "System not supported. Test skipped."; |
| return; |
| } |
| |
| std::unique_ptr<uint8_t[]> src(new uint8_t[16]); |
| std::unique_ptr<uint8_t[]> dst(new uint8_t[16]); |
| |
| SbMemorySet(src.get(), 0xff, 16); |
| SbMemorySet(dst.get(), 0, 16); |
| |
| media::FilterYUVRows_SSE2(dst.get(), src.get(), src.get(), 1, 255); |
| |
| EXPECT_EQ(255u, dst[0]); |
| for (int i = 1; i < 16; ++i) { |
| EXPECT_EQ(0u, dst[i]); |
| } |
| } |
| |
| TEST(YUVConvertTest, FilterYUVRows_SSE2_UnalignedDestination) { |
| base::CPU cpu; |
| if (!cpu.has_sse2()) { |
| LOG(WARNING) << "System not supported. Test skipped."; |
| return; |
| } |
| |
| const int kSize = 64; |
| std::unique_ptr<uint8_t[]> src(new uint8_t[kSize]); |
| std::unique_ptr<uint8_t[]> dst_sample(new uint8_t[kSize]); |
| std::unique_ptr<uint8_t[]> dst(new uint8_t[kSize]); |
| |
| SbMemorySet(dst_sample.get(), 0, kSize); |
| SbMemorySet(dst.get(), 0, kSize); |
| for (int i = 0; i < kSize; ++i) src[i] = 100 + i; |
| |
| media::FilterYUVRows_C(dst_sample.get(), src.get(), src.get(), 37, 128); |
| |
| // Generate an unaligned output address. |
| uint8_t* dst_ptr = reinterpret_cast<uint8_t*>( |
| (reinterpret_cast<uintptr_t>(dst.get() + 16) & ~15) + 1); |
| media::FilterYUVRows_SSE2(dst_ptr, src.get(), src.get(), 37, 128); |
| media::EmptyRegisterState(); |
| |
| EXPECT_EQ(0, SbMemoryCompare(dst_sample.get(), dst_ptr, 37)); |
| } |
| |
| #if defined(ARCH_CPU_X86_64) |
| |
| TEST(YUVConvertTest, ScaleYUVToRGB32Row_SSE2_X64) { |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_reference(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_converted(new uint8_t[kRGBSize]); |
| ReadYV12Data(&yuv_bytes); |
| |
| const int kWidth = 167; |
| const int kSourceDx = 80000; // This value means a scale down. |
| ScaleYUVToRGB32Row_C(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_reference.get(), kWidth, kSourceDx, |
| GetLookupTable(YV12)); |
| ScaleYUVToRGB32Row_SSE2_X64(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_converted.get(), kWidth, kSourceDx, |
| GetLookupTable(YV12)); |
| media::EmptyRegisterState(); |
| EXPECT_EQ(0, SbMemoryCompare(rgb_bytes_reference.get(), |
| rgb_bytes_converted.get(), kWidth * kBpp)); |
| } |
| |
| TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX_X64) { |
| std::unique_ptr<uint8_t[]> yuv_bytes(new uint8_t[kYUV12Size]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_reference(new uint8_t[kRGBSize]); |
| std::unique_ptr<uint8_t[]> rgb_bytes_converted(new uint8_t[kRGBSize]); |
| ReadYV12Data(&yuv_bytes); |
| |
| const int kWidth = 167; |
| const int kSourceDx = 80000; // This value means a scale down. |
| LinearScaleYUVToRGB32Row_C(yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, |
| rgb_bytes_reference.get(), kWidth, kSourceDx, |
| GetLookupTable(YV12)); |
| LinearScaleYUVToRGB32Row_MMX_X64( |
| yuv_bytes.get(), yuv_bytes.get() + kSourceUOffset, |
| yuv_bytes.get() + kSourceVOffset, rgb_bytes_converted.get(), kWidth, |
| kSourceDx, GetLookupTable(YV12)); |
| media::EmptyRegisterState(); |
| EXPECT_EQ(0, SbMemoryCompare(rgb_bytes_reference.get(), |
| rgb_bytes_converted.get(), kWidth * kBpp)); |
| } |
| |
| #endif // defined(ARCH_CPU_X86_64) |
| |
| #endif // defined(ARCH_CPU_X86_FAMILY) |
| |
| } // namespace media |
| } // namespace cobalt |
