path: root/image/test/gtest/TestADAM7InterpolatingFilter.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 <algorithm>
#include <vector>

#include "gtest/gtest.h"

#include "mozilla/gfx/2D.h"
#include "mozilla/Maybe.h"
#include "Common.h"
#include "Decoder.h"
#include "DecoderFactory.h"
#include "SourceBuffer.h"
#include "SurfaceFilters.h"
#include "SurfacePipe.h"

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

using std::generate;
using std::vector;

template <typename Func>
void WithADAM7InterpolatingFilter(const IntSize& aSize, Func aFunc) {
  RefPtr<image::Decoder> decoder = CreateTrivialDecoder();
  ASSERT_TRUE(bool(decoder));

  WithFilterPipeline(
      decoder, std::forward<Func>(aFunc), ADAM7InterpolatingConfig{},
      SurfaceConfig{decoder, aSize, SurfaceFormat::OS_RGBA, false});
}

void AssertConfiguringADAM7InterpolatingFilterFails(const IntSize& aSize) {
  RefPtr<image::Decoder> decoder = CreateTrivialDecoder();
  ASSERT_TRUE(bool(decoder));

  AssertConfiguringPipelineFails(
      decoder, ADAM7InterpolatingConfig{},
      SurfaceConfig{decoder, aSize, SurfaceFormat::OS_RGBA, false});
}

uint8_t InterpolateByte(uint8_t aByteA, uint8_t aByteB, float aWeight) {
  return uint8_t(aByteA * aWeight + aByteB * (1.0f - aWeight));
}

BGRAColor InterpolateColors(BGRAColor aColor1, BGRAColor aColor2,
                            float aWeight) {
  return BGRAColor(InterpolateByte(aColor1.mBlue, aColor2.mBlue, aWeight),
                   InterpolateByte(aColor1.mGreen, aColor2.mGreen, aWeight),
                   InterpolateByte(aColor1.mRed, aColor2.mRed, aWeight),
                   InterpolateByte(aColor1.mAlpha, aColor2.mAlpha, aWeight));
}

enum class ShouldInterpolate { eYes, eNo };

BGRAColor HorizontallyInterpolatedPixel(uint32_t aCol, uint32_t aWidth,
                                        const vector<float>& aWeights,
                                        ShouldInterpolate aShouldInterpolate,
                                        const vector<BGRAColor>& aColors) {
  // We cycle through the vector of weights forever.
  float weight = aWeights[aCol % aWeights.size()];

  // Find the columns of the two final pixels for this set of weights.
  uint32_t finalPixel1 = aCol - aCol % aWeights.size();
  uint32_t finalPixel2 = finalPixel1 + aWeights.size();

  // If |finalPixel2| is past the end of the row, that means that there is no
  // final pixel after the pixel at |finalPixel1|. In that case, we just want to
  // duplicate |finalPixel1|'s color until the end of the row. We can do that by
  // setting |finalPixel2| equal to |finalPixel1| so that the interpolation has
  // no effect.
  if (finalPixel2 >= aWidth) {
    finalPixel2 = finalPixel1;
  }

  // We cycle through the vector of colors forever (subject to the above
  // constraint about the end of the row).
  BGRAColor color1 = aColors[finalPixel1 % aColors.size()];
  BGRAColor color2 = aColors[finalPixel2 % aColors.size()];

  // If we're not interpolating, we treat all pixels which aren't final as
  // transparent. Since the number of weights we have is equal to the stride
  // between final pixels, we can check if |aCol| is a final pixel by checking
  // whether |aCol| is a multiple of |aWeights.size()|.
  if (aShouldInterpolate == ShouldInterpolate::eNo) {
    return aCol % aWeights.size() == 0 ? color1 : BGRAColor::Transparent();
  }

  // Interpolate.
  return InterpolateColors(color1, color2, weight);
}

vector<float>& InterpolationWeights(int32_t aStride) {
  // Precalculated interpolation weights. These are used to interpolate
  // between final pixels or between important rows. Although no interpolation
  // is actually applied to the previous final pixel or important row value,
  // the arrays still start with 1.0f, which is always skipped, primarily
  // because otherwise |stride1Weights| would have zero elements.
  static vector<float> stride8Weights = {1.0f,     7 / 8.0f, 6 / 8.0f,
                                         5 / 8.0f, 4 / 8.0f, 3 / 8.0f,
                                         2 / 8.0f, 1 / 8.0f};
  static vector<float> stride4Weights = {1.0f, 3 / 4.0f, 2 / 4.0f, 1 / 4.0f};
  static vector<float> stride2Weights = {1.0f, 1 / 2.0f};
  static vector<float> stride1Weights = {1.0f};

  switch (aStride) {
    case 8:
      return stride8Weights;
    case 4:
      return stride4Weights;
    case 2:
      return stride2Weights;
    case 1:
      return stride1Weights;
    default:
      MOZ_CRASH();
  }
}

int32_t ImportantRowStride(uint8_t aPass) {
  // The stride between important rows for each pass, with a dummy value for
  // the nonexistent pass 0 and for pass 8, since the tests run an extra pass to
  // make sure nothing breaks.
  static int32_t strides[] = {1, 8, 8, 4, 4, 2, 2, 1, 1};

  return strides[aPass];
}

size_t FinalPixelStride(uint8_t aPass) {
  // The stride between the final pixels in important rows for each pass, with
  // a dummy value for the nonexistent pass 0 and for pass 8, since the tests
  // run an extra pass to make sure nothing breaks.
  static size_t strides[] = {1, 8, 4, 4, 2, 2, 1, 1, 1};

  return strides[aPass];
}

bool IsImportantRow(int32_t aRow, uint8_t aPass) {
  return aRow % ImportantRowStride(aPass) == 0;
}

/**
 * ADAM7 breaks up the image into 8x8 blocks. On each of the 7 passes, a new
 * set of pixels in each block receives their final values, according to the
 * following pattern:
 *
 *    1 6 4 6 2 6 4 6
 *    7 7 7 7 7 7 7 7
 *    5 6 5 6 5 6 5 6
 *    7 7 7 7 7 7 7 7
 *    3 6 4 6 3 6 4 6
 *    7 7 7 7 7 7 7 7
 *    5 6 5 6 5 6 5 6
 *    7 7 7 7 7 7 7 7
 *
 * This function produces a row of pixels @aWidth wide, suitable for testing
 * horizontal interpolation on pass @aPass. The pattern of pixels used is
 * determined by @aPass and @aRow, which determine which pixels are final
 * according to the table above, and @aColors, from which the pixel values
 * are selected.
 *
 * There are two different behaviors: if |eNo| is passed for
 * @aShouldInterpolate, non-final pixels are treated as transparent. If |eNo|
 * is passed, non-final pixels get interpolated in from the surrounding final
 * pixels. The intention is that |eNo| is passed to generate input which will
 * be run through ADAM7InterpolatingFilter, and |eYes| is passed to generate
 * reference data to check that the filter is performing horizontal
 * interpolation correctly.
 *
 * This function does not perform vertical interpolation. Rows which aren't on
 * the current pass are filled with transparent pixels.
 *
 * @return a vector<BGRAColor> representing a row of pixels.
 */
vector<BGRAColor> ADAM7HorizontallyInterpolatedRow(
    uint8_t aPass, uint32_t aRow, uint32_t aWidth,
    ShouldInterpolate aShouldInterpolate, const vector<BGRAColor>& aColors) {
  EXPECT_GT(aPass, 0);
  EXPECT_LE(aPass, 8);
  EXPECT_GT(aColors.size(), 0u);

  vector<BGRAColor> result(aWidth);

  if (IsImportantRow(aRow, aPass)) {
    vector<float>& weights = InterpolationWeights(FinalPixelStride(aPass));

    // Compute the horizontally interpolated row.
    uint32_t col = 0;
    generate(result.begin(), result.end(), [&] {
      return HorizontallyInterpolatedPixel(col++, aWidth, weights,
                                           aShouldInterpolate, aColors);
    });
  } else {
    // This is an unimportant row; just make the entire thing transparent.
    generate(result.begin(), result.end(),
             [] { return BGRAColor::Transparent(); });
  }

  EXPECT_EQ(result.size(), size_t(aWidth));

  return result;
}

WriteState WriteUninterpolatedPixels(SurfaceFilter* aFilter,
                                     const IntSize& aSize, uint8_t aPass,
                                     const vector<BGRAColor>& aColors) {
  WriteState result = WriteState::NEED_MORE_DATA;

  for (int32_t row = 0; row < aSize.height; ++row) {
    // Compute uninterpolated pixels for this row.
    vector<BGRAColor> pixels = ADAM7HorizontallyInterpolatedRow(
        aPass, row, aSize.width, ShouldInterpolate::eNo, aColors);

    // Write them to the surface.
    auto pixelIterator = pixels.cbegin();
    result = aFilter->WritePixelsToRow<uint32_t>(
        [&] { return AsVariant((*pixelIterator++).AsPixel()); });

    if (result != WriteState::NEED_MORE_DATA) {
      break;
    }
  }

  return result;
}

bool CheckHorizontallyInterpolatedImage(image::Decoder* aDecoder,
                                        const IntSize& aSize, uint8_t aPass,
                                        const vector<BGRAColor>& aColors) {
  RawAccessFrameRef currentFrame = aDecoder->GetCurrentFrameRef();
  RefPtr<SourceSurface> surface = currentFrame->GetSourceSurface();

  for (int32_t row = 0; row < aSize.height; ++row) {
    if (!IsImportantRow(row, aPass)) {
      continue;  // Don't check rows which aren't important on this pass.
    }

    // Compute the expected pixels, *with* interpolation to match what the
    // filter should have done.
    vector<BGRAColor> expectedPixels = ADAM7HorizontallyInterpolatedRow(
        aPass, row, aSize.width, ShouldInterpolate::eYes, aColors);

    if (!RowHasPixels(surface, row, expectedPixels)) {
      return false;
    }
  }

  return true;
}

void CheckHorizontalInterpolation(const IntSize& aSize,
                                  const vector<BGRAColor>& aColors) {
  const IntRect surfaceRect(IntPoint(0, 0), aSize);

  WithADAM7InterpolatingFilter(
      aSize, [&](image::Decoder* aDecoder, SurfaceFilter* aFilter) {
        // We check horizontal interpolation behavior for each pass
        // individually. In addition to the normal 7 passes that ADAM7 includes,
        // we also check an eighth pass to verify that nothing breaks if extra
        // data is written.
        for (uint8_t pass = 1; pass <= 8; ++pass) {
          // Write our color pattern to the surface. We don't perform any
          // interpolation when writing to the filter so that we can check that
          // the filter itself *does*.
          WriteState result =
              WriteUninterpolatedPixels(aFilter, aSize, pass, aColors);

          EXPECT_EQ(WriteState::FINISHED, result);
          AssertCorrectPipelineFinalState(aFilter, surfaceRect, surfaceRect);

          // Check that the generated image matches the expected pattern, with
          // interpolation applied.
          EXPECT_TRUE(CheckHorizontallyInterpolatedImage(aDecoder, aSize, pass,
                                                         aColors));

          // Prepare for the next pass.
          aFilter->ResetToFirstRow();
        }
      });
}

BGRAColor ADAM7RowColor(int32_t aRow, uint8_t aPass,
                        const vector<BGRAColor>& aColors) {
  EXPECT_LT(0, aPass);
  EXPECT_GE(8, aPass);
  EXPECT_LT(0u, aColors.size());

  // If this is an important row, select the color from the provided vector of
  // colors, which we cycle through infinitely. If not, just fill the row with
  // transparent pixels.
  return IsImportantRow(aRow, aPass) ? aColors[aRow % aColors.size()]
                                     : BGRAColor::Transparent();
}

WriteState WriteRowColorPixels(SurfaceFilter* aFilter, const IntSize& aSize,
                               uint8_t aPass,
                               const vector<BGRAColor>& aColors) {
  WriteState result = WriteState::NEED_MORE_DATA;

  for (int32_t row = 0; row < aSize.height; ++row) {
    const uint32_t color = ADAM7RowColor(row, aPass, aColors).AsPixel();

    // Fill the surface with |color| pixels.
    result =
        aFilter->WritePixelsToRow<uint32_t>([&] { return AsVariant(color); });

    if (result != WriteState::NEED_MORE_DATA) {
      break;
    }
  }

  return result;
}

bool CheckVerticallyInterpolatedImage(image::Decoder* aDecoder,
                                      const IntSize& aSize, uint8_t aPass,
                                      const vector<BGRAColor>& aColors) {
  vector<float>& weights = InterpolationWeights(ImportantRowStride(aPass));

  for (int32_t row = 0; row < aSize.height; ++row) {
    // Vertically interpolation takes place between two important rows. The
    // separation between the important rows is determined by the stride of this
    // pass. When there is no "next" important row because we'd run off the
    // bottom of the image, we use the same row for both. This matches
    // ADAM7InterpolatingFilter's behavior of duplicating the last important row
    // since there isn't another important row to vertically interpolate it
    // with.
    const int32_t stride = ImportantRowStride(aPass);
    const int32_t prevImportantRow = row - row % stride;
    const int32_t maybeNextImportantRow = prevImportantRow + stride;
    const int32_t nextImportantRow = maybeNextImportantRow < aSize.height
                                         ? maybeNextImportantRow
                                         : prevImportantRow;

    // Retrieve the colors for the important rows we're going to interpolate.
    const BGRAColor prevImportantRowColor =
        ADAM7RowColor(prevImportantRow, aPass, aColors);
    const BGRAColor nextImportantRowColor =
        ADAM7RowColor(nextImportantRow, aPass, aColors);

    // The weight we'll use for interpolation is also determined by the stride.
    // A row halfway between two important rows should have pixels that have a
    // 50% contribution from each of the important rows, for example.
    const float weight = weights[row % stride];
    const BGRAColor interpolatedColor =
        InterpolateColors(prevImportantRowColor, nextImportantRowColor, weight);

    // Generate a row of expected pixels. Every pixel in the row is always the
    // same color since we're only testing vertical interpolation between
    // solid-colored rows.
    vector<BGRAColor> expectedPixels(aSize.width);
    generate(expectedPixels.begin(), expectedPixels.end(),
             [&] { return interpolatedColor; });

    // Check that the pixels match.
    RawAccessFrameRef currentFrame = aDecoder->GetCurrentFrameRef();
    RefPtr<SourceSurface> surface = currentFrame->GetSourceSurface();
    if (!RowHasPixels(surface, row, expectedPixels)) {
      return false;
    }
  }

  return true;
}

void CheckVerticalInterpolation(const IntSize& aSize,
                                const vector<BGRAColor>& aColors) {
  const IntRect surfaceRect(IntPoint(0, 0), aSize);

  WithADAM7InterpolatingFilter(aSize, [&](image::Decoder* aDecoder,
                                          SurfaceFilter* aFilter) {
    for (uint8_t pass = 1; pass <= 8; ++pass) {
      // Write a pattern of rows to the surface. Important rows will receive a
      // color selected from |aColors|; unimportant rows will be transparent.
      WriteState result = WriteRowColorPixels(aFilter, aSize, pass, aColors);

      EXPECT_EQ(WriteState::FINISHED, result);
      AssertCorrectPipelineFinalState(aFilter, surfaceRect, surfaceRect);

      // Check that the generated image matches the expected pattern, with
      // interpolation applied.
      EXPECT_TRUE(
          CheckVerticallyInterpolatedImage(aDecoder, aSize, pass, aColors));

      // Prepare for the next pass.
      aFilter->ResetToFirstRow();
    }
  });
}

void CheckInterpolation(const IntSize& aSize,
                        const vector<BGRAColor>& aColors) {
  CheckHorizontalInterpolation(aSize, aColors);
  CheckVerticalInterpolation(aSize, aColors);
}

void CheckADAM7InterpolatingWritePixels(const IntSize& aSize) {
  // This test writes 8 passes of green pixels (the seven ADAM7 passes, plus one
  // extra to make sure nothing goes wrong if we write too much input) and
  // verifies that the output is a solid green surface each time. Because all
  // the pixels are the same color, interpolation doesn't matter; we test the
  // correctness of the interpolation algorithm itself separately.
  WithADAM7InterpolatingFilter(
      aSize, [&](image::Decoder* aDecoder, SurfaceFilter* aFilter) {
        IntRect rect(IntPoint(0, 0), aSize);

        for (int32_t pass = 1; pass <= 8; ++pass) {
          // We only actually write up to the last important row for each pass,
          // because that row unambiguously determines the remaining rows.
          const int32_t lastRow = aSize.height - 1;
          const int32_t lastImportantRow =
              lastRow - (lastRow % ImportantRowStride(pass));
          const IntRect inputWriteRect(0, 0, aSize.width, lastImportantRow + 1);

          CheckWritePixels(aDecoder, aFilter,
                           /* aOutputRect = */ Some(rect),
                           /* aInputRect = */ Some(rect),
                           /* aInputWriteRect = */ Some(inputWriteRect));

          aFilter->ResetToFirstRow();
          EXPECT_FALSE(aFilter->IsSurfaceFinished());
          Maybe<SurfaceInvalidRect> invalidRect = aFilter->TakeInvalidRect();
          EXPECT_TRUE(invalidRect.isNothing());
        }
      });
}

TEST(ImageADAM7InterpolatingFilter, WritePixels100_100)
{ CheckADAM7InterpolatingWritePixels(IntSize(100, 100)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels99_99)
{ CheckADAM7InterpolatingWritePixels(IntSize(99, 99)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels66_33)
{ CheckADAM7InterpolatingWritePixels(IntSize(66, 33)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels33_66)
{ CheckADAM7InterpolatingWritePixels(IntSize(33, 66)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels15_15)
{ CheckADAM7InterpolatingWritePixels(IntSize(15, 15)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels9_9)
{ CheckADAM7InterpolatingWritePixels(IntSize(9, 9)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels8_8)
{ CheckADAM7InterpolatingWritePixels(IntSize(8, 8)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels7_7)
{ CheckADAM7InterpolatingWritePixels(IntSize(7, 7)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels3_3)
{ CheckADAM7InterpolatingWritePixels(IntSize(3, 3)); }

TEST(ImageADAM7InterpolatingFilter, WritePixels1_1)
{ CheckADAM7InterpolatingWritePixels(IntSize(1, 1)); }

TEST(ImageADAM7InterpolatingFilter, TrivialInterpolation48_48)
{ CheckInterpolation(IntSize(48, 48), {BGRAColor::Green()}); }

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput33_17)
{
  // We check interpolation using irregular patterns to make sure that the
  // interpolation will look different for different passes.
  CheckInterpolation(
      IntSize(33, 17),
      {BGRAColor::Green(), BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Blue(),  BGRAColor::Blue(),  BGRAColor::Blue(),
       BGRAColor::Red(),   BGRAColor::Green(), BGRAColor::Red(),
       BGRAColor::Red(),   BGRAColor::Blue(),  BGRAColor::Blue(),
       BGRAColor::Green(), BGRAColor::Blue(),  BGRAColor::Red(),
       BGRAColor::Blue(),  BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Blue(),  BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Red(),   BGRAColor::Red(),   BGRAColor::Blue(),
       BGRAColor::Blue(),  BGRAColor::Blue(),  BGRAColor::Red(),
       BGRAColor::Green(), BGRAColor::Green(), BGRAColor::Blue(),
       BGRAColor::Red(),   BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput32_16)
{
  CheckInterpolation(
      IntSize(32, 16),
      {BGRAColor::Green(), BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Blue(),  BGRAColor::Blue(),  BGRAColor::Blue(),
       BGRAColor::Red(),   BGRAColor::Green(), BGRAColor::Red(),
       BGRAColor::Red(),   BGRAColor::Blue(),  BGRAColor::Blue(),
       BGRAColor::Green(), BGRAColor::Blue(),  BGRAColor::Red(),
       BGRAColor::Blue(),  BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Blue(),  BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Red(),   BGRAColor::Red(),   BGRAColor::Blue(),
       BGRAColor::Blue(),  BGRAColor::Blue(),  BGRAColor::Red(),
       BGRAColor::Green(), BGRAColor::Green(), BGRAColor::Blue(),
       BGRAColor::Red(),   BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput31_15)
{
  CheckInterpolation(
      IntSize(31, 15),
      {BGRAColor::Green(), BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Blue(),  BGRAColor::Blue(),  BGRAColor::Blue(),
       BGRAColor::Red(),   BGRAColor::Green(), BGRAColor::Red(),
       BGRAColor::Red(),   BGRAColor::Blue(),  BGRAColor::Blue(),
       BGRAColor::Green(), BGRAColor::Blue(),  BGRAColor::Red(),
       BGRAColor::Blue(),  BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Blue(),  BGRAColor::Red(),   BGRAColor::Green(),
       BGRAColor::Red(),   BGRAColor::Red(),   BGRAColor::Blue(),
       BGRAColor::Blue(),  BGRAColor::Blue(),  BGRAColor::Red(),
       BGRAColor::Green(), BGRAColor::Green(), BGRAColor::Blue(),
       BGRAColor::Red(),   BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput17_33)
{
  CheckInterpolation(IntSize(17, 33),
                     {BGRAColor::Green(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Blue(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Green(), BGRAColor::Red(), BGRAColor::Red(),
                      BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput16_32)
{
  CheckInterpolation(IntSize(16, 32),
                     {BGRAColor::Green(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Blue(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Green(), BGRAColor::Red(), BGRAColor::Red(),
                      BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput15_31)
{
  CheckInterpolation(IntSize(15, 31),
                     {BGRAColor::Green(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Blue(),
                      BGRAColor::Blue(), BGRAColor::Red(), BGRAColor::Green(),
                      BGRAColor::Green(), BGRAColor::Red(), BGRAColor::Red(),
                      BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput9_9)
{
  CheckInterpolation(IntSize(9, 9),
                     {BGRAColor::Blue(), BGRAColor::Blue(), BGRAColor::Red(),
                      BGRAColor::Green(), BGRAColor::Green(), BGRAColor::Red(),
                      BGRAColor::Red(), BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput8_8)
{
  CheckInterpolation(IntSize(8, 8),
                     {BGRAColor::Blue(), BGRAColor::Blue(), BGRAColor::Red(),
                      BGRAColor::Green(), BGRAColor::Green(), BGRAColor::Red(),
                      BGRAColor::Red(), BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput7_7)
{
  CheckInterpolation(IntSize(7, 7),
                     {BGRAColor::Blue(), BGRAColor::Blue(), BGRAColor::Red(),
                      BGRAColor::Green(), BGRAColor::Green(), BGRAColor::Red(),
                      BGRAColor::Red(), BGRAColor::Blue()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput3_3)
{
  CheckInterpolation(IntSize(3, 3), {BGRAColor::Green(), BGRAColor::Red(),
                                     BGRAColor::Blue(), BGRAColor::Red()});
}

TEST(ImageADAM7InterpolatingFilter, InterpolationOutput1_1)
{ CheckInterpolation(IntSize(1, 1), {BGRAColor::Blue()}); }

TEST(ImageADAM7InterpolatingFilter, ADAM7InterpolationFailsFor0_0)
{
  // A 0x0 input size is invalid, so configuration should fail.
  AssertConfiguringADAM7InterpolatingFilterFails(IntSize(0, 0));
}

TEST(ImageADAM7InterpolatingFilter, ADAM7InterpolationFailsForMinus1_Minus1)
{
  // A negative input size is invalid, so configuration should fail.
  AssertConfiguringADAM7InterpolatingFilterFails(IntSize(-1, -1));
}