gecko-dev/image/test/gtest/TestDecodeToSurface.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gtest/gtest.h"

#include "Common.h"
#include "imgIContainer.h"
#include "imgITools.h"
#include "ImageOps.h"
#include "mozilla/gfx/2D.h"
#include "nsComponentManagerUtils.h"
#include "nsCOMPtr.h"
#include "nsIInputStream.h"
#include "nsIRunnable.h"
#include "nsIThread.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsThreadUtils.h"

using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::image;

class DecodeToSurfaceRunnable : public Runnable
{
public:
  DecodeToSurfaceRunnable(RefPtr<SourceSurface>& aSurface,
                          nsIInputStream* aInputStream,
                          ImageOps::ImageBuffer* aImageBuffer,
                          const ImageTestCase& aTestCase)
    : mSurface(aSurface)
    , mInputStream(aInputStream)
    , mImageBuffer(aImageBuffer)
    , mTestCase(aTestCase)
  { }

  NS_IMETHOD Run() override
  {
    Go();
    return NS_OK;
  }

  void Go()
  {
    Maybe<IntSize> outputSize;
    if (mTestCase.mOutputSize != mTestCase.mSize) {
      outputSize.emplace(mTestCase.mOutputSize);
    }

    if (mImageBuffer) {
      mSurface =
        ImageOps::DecodeToSurface(mImageBuffer,
                                  nsDependentCString(mTestCase.mMimeType),
                                  imgIContainer::DECODE_FLAGS_DEFAULT,
                                  outputSize);
    } else {
      mSurface =
        ImageOps::DecodeToSurface(mInputStream,
                                  nsDependentCString(mTestCase.mMimeType),
                                  imgIContainer::DECODE_FLAGS_DEFAULT,
                                  outputSize);
    }
    ASSERT_TRUE(mSurface != nullptr);

    EXPECT_TRUE(mSurface->IsDataSourceSurface());
    EXPECT_TRUE(mSurface->GetFormat() == SurfaceFormat::B8G8R8X8 ||
                mSurface->GetFormat() == SurfaceFormat::B8G8R8A8);

    if (outputSize) {
      EXPECT_EQ(*outputSize, mSurface->GetSize());
    } else {
      EXPECT_EQ(mTestCase.mSize, mSurface->GetSize());
    }

    EXPECT_TRUE(IsSolidColor(mSurface, BGRAColor::Green(),
                             mTestCase.mFlags & TEST_CASE_IS_FUZZY ? 1 : 0));
  }

private:
  RefPtr<SourceSurface>& mSurface;
  nsCOMPtr<nsIInputStream> mInputStream;
  RefPtr<ImageOps::ImageBuffer> mImageBuffer;
  ImageTestCase mTestCase;
};

static void
RunDecodeToSurface(const ImageTestCase& aTestCase,
                   ImageOps::ImageBuffer* aImageBuffer = nullptr)
{
  nsCOMPtr<nsIInputStream> inputStream;
  if (!aImageBuffer) {
    inputStream = LoadFile(aTestCase.mPath);
    ASSERT_TRUE(inputStream != nullptr);
  }

  nsCOMPtr<nsIThread> thread;
  nsresult rv =
    NS_NewNamedThread("DecodeToSurface", getter_AddRefs(thread), nullptr);
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  // We run the DecodeToSurface tests off-main-thread to ensure that
  // DecodeToSurface doesn't require any main-thread-only code.
  RefPtr<SourceSurface> surface;
  nsCOMPtr<nsIRunnable> runnable =
    new DecodeToSurfaceRunnable(surface, inputStream, aImageBuffer, aTestCase);
  thread->Dispatch(runnable, nsIThread::DISPATCH_SYNC);

  thread->Shutdown();

  // Explicitly release the SourceSurface on the main thread.
  surface = nullptr;
}

class ImageDecodeToSurface : public ::testing::Test
{
protected:
  AutoInitializeImageLib mInit;
};

TEST_F(ImageDecodeToSurface, PNG) { RunDecodeToSurface(GreenPNGTestCase()); }
TEST_F(ImageDecodeToSurface, GIF) { RunDecodeToSurface(GreenGIFTestCase()); }
TEST_F(ImageDecodeToSurface, JPG) { RunDecodeToSurface(GreenJPGTestCase()); }
TEST_F(ImageDecodeToSurface, BMP) { RunDecodeToSurface(GreenBMPTestCase()); }
TEST_F(ImageDecodeToSurface, ICO) { RunDecodeToSurface(GreenICOTestCase()); }
TEST_F(ImageDecodeToSurface, Icon) { RunDecodeToSurface(GreenIconTestCase()); }

TEST_F(ImageDecodeToSurface, AnimatedGIF)
{
  RunDecodeToSurface(GreenFirstFrameAnimatedGIFTestCase());
}

TEST_F(ImageDecodeToSurface, AnimatedPNG)
{
  RunDecodeToSurface(GreenFirstFrameAnimatedPNGTestCase());
}

TEST_F(ImageDecodeToSurface, Corrupt)
{
  ImageTestCase testCase = CorruptTestCase();

  nsCOMPtr<nsIInputStream> inputStream = LoadFile(testCase.mPath);
  ASSERT_TRUE(inputStream != nullptr);

  RefPtr<SourceSurface> surface =
    ImageOps::DecodeToSurface(inputStream,
                              nsDependentCString(testCase.mMimeType),
                              imgIContainer::DECODE_FLAGS_DEFAULT);
  EXPECT_TRUE(surface == nullptr);
}

TEST_F(ImageDecodeToSurface, ICOMultipleSizes)
{
  ImageTestCase testCase = GreenMultipleSizesICOTestCase();

  nsCOMPtr<nsIInputStream> inputStream = LoadFile(testCase.mPath);
  ASSERT_TRUE(inputStream != nullptr);

  RefPtr<ImageOps::ImageBuffer> buffer =
    ImageOps::CreateImageBuffer(inputStream);
  ASSERT_TRUE(buffer != nullptr);

  ImageMetadata metadata;
  nsresult rv = ImageOps::DecodeMetadata(buffer,
                                         nsDependentCString(testCase.mMimeType),
                                         metadata);
  EXPECT_TRUE(NS_SUCCEEDED(rv));
  ASSERT_TRUE(metadata.HasSize());
  EXPECT_EQ(testCase.mSize, metadata.GetSize());

  const nsTArray<IntSize>& nativeSizes = metadata.GetNativeSizes();
  ASSERT_EQ(6u, nativeSizes.Length());

  IntSize expectedSizes[] = {
    IntSize(16, 16),
    IntSize(32, 32),
    IntSize(64, 64),
    IntSize(128, 128),
    IntSize(256, 256),
    IntSize(256, 128),
  };

  for (int i = 0; i < 6; ++i) {
    EXPECT_EQ(expectedSizes[i], nativeSizes[i]);

    // Request decoding at native size
    testCase.mOutputSize = nativeSizes[i];
    RunDecodeToSurface(testCase, buffer);
  }
}