TestYUVtoRGB32.cpp

mozilla-central/gfx/tests/gtest/TestYUVtoRGB32.cpp (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: Graphics

Revision control

Copy as Markdown

Other Tools

#include "gtest/gtest.h"

#include <array>

#include <cmath>

#include <tuple>

#include <unordered_map>

#include "ImageContainer.h"

#include "YCbCrUtils.h"

#include "nsTArray.h"

using Color = std::tuple<uint8_t, uint8_t, uint8_t>;

using namespace mozilla;

const Color BLACK(0, 0, 0);

const Color BLUE(0, 0, 255);

const Color GREEN(0, 255, 0);

const Color CYAN(0, 255, 255);

const Color RED(255, 0, 0);

const Color MAGENTA(255, 0, 255);

const Color YELLOW(255, 255, 0);

const Color WHITE(255, 255, 255);

const Color CHOCOLATE(210, 105, 30);

const std::array<Color, 9> COLOR_LIST = {BLACK,   BLUE,   GREEN, CYAN,     RED,

                                         MAGENTA, YELLOW, WHITE, CHOCOLATE};

Color RGB2YUV(const Color& aRGBColor) {

  const uint8_t& r = std::get<0>(aRGBColor);

  const uint8_t& g = std::get<1>(aRGBColor);

  const uint8_t& b = std::get<2>(aRGBColor);

  const double y = r * 0.299 + g * 0.587 + b * 0.114;

  const double u = r * -0.168736 + g * -0.331264 + b * 0.5 + 128;

  const double v = r * 0.5 + g * -0.418688 + b * -0.081312 + 128;

  return Color(round(y), round(u), round(v));

int32_t CeilingOfHalf(int32_t aValue) {

  MOZ_ASSERT(aValue >= 0);

  return aValue / 2 + (aValue % 2);

already_AddRefed<layers::PlanarYCbCrImage> CreateI420Image(

    const Color& aRGBColor, const gfx::YUVColorSpace& aColorSpace,

    const gfx::IntSize& aSize, Maybe<uint8_t> aAlphaValue = Nothing()) {

  const int32_t halfWidth = CeilingOfHalf(aSize.width);

  const int32_t halfHeight = CeilingOfHalf(aSize.height);

  const size_t yPlaneSize = aSize.width * aSize.height;

  const size_t uPlaneSize = halfWidth * halfHeight;

  const size_t vPlaneSize = uPlaneSize;

  const size_t aPlaneSize = aAlphaValue.isSome() ? yPlaneSize : 0;

  const size_t imageSize = yPlaneSize + uPlaneSize + vPlaneSize + aPlaneSize;

  const Color yuvColor = RGB2YUV(aRGBColor);

  const uint8_t& yColor = std::get<0>(yuvColor);

  const uint8_t& uColor = std::get<1>(yuvColor);

  const uint8_t& vColor = std::get<2>(yuvColor);

  UniquePtr<uint8_t[]> buffer(new uint8_t[imageSize]);

  layers::PlanarYCbCrData data;

  data.mPictureRect = gfx::IntRect({0, 0}, aSize);

  // Y plane.

  uint8_t* yChannel = buffer.get();

  memset(yChannel, yColor, yPlaneSize);

  data.mYChannel = yChannel;

  data.mYStride = aSize.width;

  data.mYSkip = 0;

  // Cb plane (aka U).

  uint8_t* uChannel = yChannel + yPlaneSize;

  memset(uChannel, uColor, uPlaneSize);

  data.mCbChannel = uChannel;

  data.mCbSkip = 0;

  // Cr plane (aka V).

  uint8_t* vChannel = uChannel + uPlaneSize;

  memset(vChannel, vColor, vPlaneSize);

  data.mCrChannel = vChannel;

  data.mCrSkip = 0;

  // CrCb plane vectors.

  data.mCbCrStride = halfWidth;

  data.mChromaSubsampling = gfx::ChromaSubsampling::HALF_WIDTH_AND_HEIGHT;

  // Alpha plane.

  if (aPlaneSize) {

    uint8_t* aChannel = vChannel + vPlaneSize;

    memset(aChannel, *aAlphaValue, aPlaneSize);

    data.mAlpha.emplace();

    data.mAlpha->mChannel = aChannel;

    data.mAlpha->mSize = aSize;

  data.mYUVColorSpace = aColorSpace;

  RefPtr<layers::PlanarYCbCrImage> image =

      new layers::RecyclingPlanarYCbCrImage(new layers::BufferRecycleBin());

  image->CopyData(data);

  return image.forget();

already_AddRefed<layers::PlanarYCbCrImage> CreateI444Image(

    const Color& aRGBColor, const gfx::YUVColorSpace& aColorSpace,

    const gfx::IntSize& aSize, Maybe<uint8_t> aAlphaValue = Nothing()) {

  const size_t yPlaneSize = aSize.width * aSize.height;

  const size_t uPlaneSize = yPlaneSize;

  const size_t vPlaneSize = yPlaneSize;

  const size_t aPlaneSize = aAlphaValue.isSome() ? yPlaneSize : 0;

  const size_t imageSize = yPlaneSize + uPlaneSize + vPlaneSize + aPlaneSize;

  const Color yuvColor = RGB2YUV(aRGBColor);

  const uint8_t& yColor = std::get<0>(yuvColor);

  const uint8_t& uColor = std::get<1>(yuvColor);

  const uint8_t& vColor = std::get<2>(yuvColor);

  UniquePtr<uint8_t[]> buffer(new uint8_t[imageSize]);

  layers::PlanarYCbCrData data;

  data.mPictureRect = gfx::IntRect({0, 0}, aSize);

  // Y plane.

  uint8_t* yChannel = buffer.get();

  memset(yChannel, yColor, yPlaneSize);

  data.mYChannel = yChannel;

  data.mYStride = aSize.width;

  data.mYSkip = 0;

  // Cb plane (aka U).

  uint8_t* uChannel = yChannel + yPlaneSize;

  memset(uChannel, uColor, uPlaneSize);

  data.mCbChannel = uChannel;

  data.mCbSkip = 0;

  // Cr plane (aka V).

  uint8_t* vChannel = uChannel + uPlaneSize;

  memset(vChannel, vColor, vPlaneSize);

  data.mCrChannel = vChannel;

  data.mCrSkip = 0;

  // CrCb plane vectors.

  data.mCbCrStride = data.mYStride;

  data.mChromaSubsampling = gfx::ChromaSubsampling::FULL;

  // Alpha plane.

  if (aPlaneSize) {

    uint8_t* aChannel = vChannel + vPlaneSize;

    memset(aChannel, *aAlphaValue, aPlaneSize);

    data.mAlpha.emplace();

    data.mAlpha->mChannel = aChannel;

    data.mAlpha->mSize = aSize;

  data.mYUVColorSpace = aColorSpace;

  RefPtr<layers::PlanarYCbCrImage> image =

      new layers::RecyclingPlanarYCbCrImage(new layers::BufferRecycleBin());

  image->CopyData(data);

  return image.forget();

void IsColorEqual(uint8_t* aBGRX, uint8_t* aRGBX, size_t aSize) {

  ASSERT_EQ(aSize % 4, (size_t)0);

  for (size_t i = 0; i < aSize; i += 4) {

    ASSERT_EQ(aBGRX[i + 2], aRGBX[i]);      // R

    ASSERT_EQ(aBGRX[i + 1], aRGBX[i + 1]);  // G

    ASSERT_EQ(aBGRX[i], aRGBX[i + 2]);      // B

    ASSERT_EQ(aBGRX[i + 3], aRGBX[i + 3]);  // X or A

uint32_t Hash(const Color& aColor) {

  const uint8_t& r = std::get<0>(aColor);

  const uint8_t& g = std::get<1>(aColor);

  const uint8_t& b = std::get<2>(aColor);

  return r << 16 | g << 8 | b;

std::unordered_map<uint32_t, std::array<Color, 3>> GetExpectedConvertedRGB() {

  static std::unordered_map<uint32_t, std::array<Color, 3>> map;

  map.emplace(Hash(BLACK), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                                Color(0, 0, 0),

                                                // gfx::YUVColorSpace::BT709

                                                Color(0, 0, 0),

                                                // gfx::YUVColorSpace::BT2020

                                                Color(0, 0, 0)});

  map.emplace(Hash(BLUE), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                               Color(0, 82, 0),

                                               // gfx::YUVColorSpace::BT709

                                               Color(0, 54, 0),

                                               // gfx::YUVColorSpace::BT2020

                                               Color(0, 53, 0)});

  map.emplace(Hash(GREEN), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                                Color(0, 255, 0),

                                                // gfx::YUVColorSpace::BT709

                                                Color(0, 231, 0),

                                                // gfx::YUVColorSpace::BT2020

                                                Color(0, 242, 0)});

  map.emplace(Hash(CYAN), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                               Color(0, 255, 255),

                                               // gfx::YUVColorSpace::BT709

                                               Color(0, 248, 255),

                                               // gfx::YUVColorSpace::BT2020

                                               Color(0, 255, 255)});

  map.emplace(Hash(RED), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                              Color(0, 191, 0),

                                              // gfx::YUVColorSpace::BT709

                                              Color(0, 147, 0),

                                              // gfx::YUVColorSpace::BT2020

                                              Color(0, 162, 0)});

  map.emplace(Hash(MAGENTA), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                                  Color(255, 0, 255),

                                                  // gfx::YUVColorSpace::BT709

                                                  Color(255, 28, 255),

                                                  // gfx::YUVColorSpace::BT2020

                                                  Color(255, 18, 255)});

  map.emplace(Hash(YELLOW), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                                 Color(255, 255, 0),

                                                 // gfx::YUVColorSpace::BT709

                                                 Color(255, 255, 0),

                                                 // gfx::YUVColorSpace::BT2020

                                                 Color(255, 255, 0)});

  map.emplace(Hash(WHITE), std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                                Color(255, 255, 255),

                                                // gfx::YUVColorSpace::BT709

                                                Color(255, 255, 255),

                                                // gfx::YUVColorSpace::BT2020

                                                Color(255, 255, 255)});

  map.emplace(Hash(CHOCOLATE),

              std::array<Color, 3>{// gfx::YUVColorSpace::BT601

                                   Color(224, 104, 20),

                                   // gfx::YUVColorSpace::BT709

                                   Color(236, 111, 20),

                                   // gfx::YUVColorSpace::BT2020

                                   Color(229, 102, 20)});

  return map;

void IsColorMatched(const Color& aColor, uint8_t* aRGBX, size_t aSize,

                    Maybe<uint8_t> aAlphaValue = Nothing()) {

  const uint8_t& r = std::get<0>(aColor);

  const uint8_t& g = std::get<1>(aColor);

  const uint8_t& b = std::get<2>(aColor);

  for (size_t i = 0; i < aSize; i += 4) {

    ASSERT_EQ(r, aRGBX[i]);      // R

    ASSERT_EQ(g, aRGBX[i + 1]);  // G

    ASSERT_EQ(b, aRGBX[i + 2]);  // B

    if (aAlphaValue) {

      ASSERT_EQ(*aAlphaValue, aRGBX[i + 3]);  // A

TEST(YCbCrUtils, ConvertYCbCrToRGB32)

  const gfx::IntSize imgSize(32, 16);

  const int32_t stride =

      imgSize.Width() * gfx::BytesPerPixel(gfx::SurfaceFormat::B8G8R8X8);

  const size_t bufferSize = stride * imgSize.Height();

  const std::array<gfx::YUVColorSpace, 3> colorSpaces{

      gfx::YUVColorSpace::BT601, gfx::YUVColorSpace::BT709,

      gfx::YUVColorSpace::BT2020};

  std::unordered_map<uint32_t, std::array<Color, 3>> expectations =

      GetExpectedConvertedRGB();

  for (const Color& color : COLOR_LIST) {

    const std::array<Color, 3>& expectedColors = expectations[Hash(color)];

    for (const gfx::YUVColorSpace& colorSpace : colorSpaces) {

      RefPtr<layers::PlanarYCbCrImage> img =

          CreateI420Image(color, colorSpace, imgSize);

      UniquePtr<uint8_t[]> BGRX = MakeUnique<uint8_t[]>(bufferSize);

      ConvertYCbCrToRGB32(*img->GetData(), gfx::SurfaceFormat::B8G8R8X8,

                          BGRX.get(), stride, nullptr);

      UniquePtr<uint8_t[]> RGBX = MakeUnique<uint8_t[]>(bufferSize);

      ConvertYCbCrToRGB32(*img->GetData(), gfx::SurfaceFormat::R8G8B8X8,

                          RGBX.get(), stride, nullptr);

      IsColorEqual(BGRX.get(), RGBX.get(), bufferSize);

      Color expectation = expectedColors[static_cast<size_t>(colorSpace)];

      IsColorMatched(expectation, RGBX.get(), bufferSize);

TEST(YCbCrUtils, ConvertYCbCrToRGB32WithAlpha)

  const gfx::IntSize imgSize(32, 16);

  const int32_t stride =

      imgSize.Width() * gfx::BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8);

  const size_t bufferSize = stride * imgSize.Height();

  const std::array<gfx::YUVColorSpace, 3> colorSpaces{

      gfx::YUVColorSpace::BT601, gfx::YUVColorSpace::BT709,

      gfx::YUVColorSpace::BT2020};

  std::unordered_map<uint32_t, std::array<Color, 3>> expectations =

      GetExpectedConvertedRGB();

  for (const Color& color : COLOR_LIST) {

    const std::array<Color, 3>& expectedColors = expectations[Hash(color)];

    for (const gfx::YUVColorSpace& colorSpace : colorSpaces) {

      Maybe<uint8_t> alpha = Some(128);

      RefPtr<layers::PlanarYCbCrImage> img =

          CreateI420Image(color, colorSpace, imgSize, alpha);

      UniquePtr<uint8_t[]> BGRA = MakeUnique<uint8_t[]>(bufferSize);

      ConvertYCbCrToRGB32(*img->GetData(), gfx::SurfaceFormat::B8G8R8A8,

                          BGRA.get(), stride, nullptr);

      UniquePtr<uint8_t[]> RGBA = MakeUnique<uint8_t[]>(bufferSize);

      ConvertYCbCrToRGB32(*img->GetData(), gfx::SurfaceFormat::R8G8B8A8,

                          RGBA.get(), stride, nullptr);

      IsColorEqual(BGRA.get(), RGBA.get(), bufferSize);

      Color expectation = expectedColors[static_cast<size_t>(colorSpace)];

      IsColorMatched(expectation, RGBA.get(), bufferSize, alpha);

TEST(YCbCrUtils, ConvertYCbCrToRGB32WithIdentityColorSpace)

  const gfx::IntSize imgSize(32, 16);

  const int32_t stride =

      imgSize.Width() * gfx::BytesPerPixel(gfx::SurfaceFormat::B8G8R8X8);

  const size_t bufferSize = stride * imgSize.Height();

  for (const Color& color : COLOR_LIST) {

    RefPtr<layers::PlanarYCbCrImage> img =

        CreateI444Image(color, gfx::YUVColorSpace::Identity, imgSize);

    UniquePtr<uint8_t[]> BGRX = MakeUnique<uint8_t[]>(bufferSize);

    ConvertYCbCrToRGB32(*img->GetData(), gfx::SurfaceFormat::B8G8R8X8,

                        BGRX.get(), stride, nullptr);

    UniquePtr<uint8_t[]> RGBX = MakeUnique<uint8_t[]>(bufferSize);

    ConvertYCbCrToRGB32(*img->GetData(), gfx::SurfaceFormat::R8G8B8X8,

                        RGBX.get(), stride, nullptr);

    IsColorEqual(BGRX.get(), RGBX.get(), bufferSize);

    const Color yuvColor = RGB2YUV(color);

    const uint8_t& y = std::get<0>(yuvColor);

    const uint8_t& u = std::get<1>(yuvColor);

    const uint8_t& v = std::get<2>(yuvColor);

    const Color expectation(v, y, u);

    IsColorMatched(expectation, RGBX.get(), bufferSize);