path: root/src/decoder/test/endpoint_codec_test.cc

// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/decoder/endpoint_codec.h"
#include "src/decoder/intermediate_astc_block.h"
#include "src/decoder/test/image_utils.h"

#include <random>
#include <string>
#include <utility>
#include <vector>

#include <gtest/gtest.h>
#include <gmock/gmock.h>

namespace astc_codec {

namespace {

using ::testing::AllOf;
using ::testing::AnyOf;
using ::testing::Each;
using ::testing::Eq;
using ::testing::Ge;
using ::testing::Le;
using ::testing::Ne;
using ::testing::Optional;
using ::testing::Pointwise;
using ::testing::SizeIs;
using ::testing::Pair;

constexpr std::array<EndpointEncodingMode, 6> kEndpointEncodingModes = {{
    EndpointEncodingMode::kDirectLuma,
    EndpointEncodingMode::kDirectLumaAlpha,
    EndpointEncodingMode::kBaseScaleRGB,
    EndpointEncodingMode::kBaseScaleRGBA,
    EndpointEncodingMode::kDirectRGB,
    EndpointEncodingMode::kDirectRGBA }};

const std::array<std::pair<RgbaColor, RgbaColor>, 3> kBlueContractPairs = {{
    std::make_pair(RgbaColor{{ 22, 18, 30, 59 }},
                   RgbaColor{{ 162, 148, 155, 59 }}),
    std::make_pair(RgbaColor{{ 22, 30, 27, 36 }},
                   RgbaColor{{ 228, 221, 207, 36 }}),
    std::make_pair(RgbaColor{{ 54, 60, 55, 255 }},
                   RgbaColor{{ 23, 30, 27, 255 }})
  }};

// Used to directly initialize std::pairs of colors with initializer lists
//   e.g. MakeColors({{ r, g, b, a }}, {{ r, g, b, a }});
std::pair<RgbaColor, RgbaColor> MakeColors(RgbaColor&& a, RgbaColor&& b) {
  return std::make_pair(a, b);
}

// Returns |high| and |low| as they would be decoded using the quantization
// factor |quant| for the ColorEndpointMode |mode|.
std::pair<RgbaColor, RgbaColor> TestColors(
    RgbaColor low, RgbaColor high, int quant, EndpointEncodingMode mode) {
  ColorEndpointMode astc_mode;
  std::vector<int> encoded;
  const bool needs_swap =
      EncodeColorsForMode(low, high, quant, mode, &astc_mode, &encoded);

  RgbaColor decoded_low, decoded_high;
  DecodeColorsForMode(encoded, quant, astc_mode, &decoded_low, &decoded_high);

  if (needs_swap) {
    return std::make_pair(decoded_high, decoded_low);
  } else {
    return std::make_pair(decoded_low, decoded_high);
  }
}

// Returns true if the argument tuple entries only differ by at most x.
MATCHER_P(IsCloseTo, x, "") {
  const auto& a = ::testing::get<0>(arg);
  const auto& b = ::testing::get<1>(arg);
  return (a > b) ? ((a - b) <= x) : ((b - a) <= x);
}

// Test to make sure that the range of values that we get as they are
// quantized remains within what we pass as |quant|.
TEST(EndpointCodecTest, QuantRanges) {
  const RgbaColor low {{ 0, 0, 0, 0 }};
  const RgbaColor high {{ 255, 255, 255, 255 }};

  std::vector<int> result;
  for (const auto& mode : kEndpointEncodingModes) {
    for (int i = 5; i < 256; ++i) {
      ColorEndpointMode astc_mode;
      const bool needs_swap =
          EncodeColorsForMode(low, high, i, mode, &astc_mode, &result);
      EXPECT_EQ(result.size(), NumValuesForEncodingMode(mode)) << i;
      EXPECT_EQ(result.size(), NumColorValuesForEndpointMode(astc_mode)) << i;

      // ASTC mode shouldn't use base/offset when endpoints are so far apart.
      EXPECT_THAT(astc_mode, Ne(ColorEndpointMode::kLDRRGBBaseOffset));
      EXPECT_THAT(astc_mode, Ne(ColorEndpointMode::kLDRRGBABaseOffset));

      EXPECT_THAT(result, Each(AllOf(Ge(0), Le(i))))
          << "Mode: " << static_cast<int>(mode);
      // We don't care if we need to swap the weights in this test
      EXPECT_TRUE(needs_swap || !needs_swap);
    }
  }
}

// Test to make sure that each mode that directly encodes colors can effectively
// encode both black and white
TEST(EndpointCodecTest, ExtremeDirectEncodings) {
  const RgbaColor kWhite {{ 255, 255, 255, 255 }};
  const RgbaColor kBlack {{ 0, 0, 0, 255 }};

  std::vector<int> encoded;
  for (const auto& mode : kEndpointEncodingModes) {
    for (int i = 5; i < 256; ++i) {
      const auto expected = std::make_pair(kWhite, kBlack);
      EXPECT_EQ(TestColors(kWhite, kBlack, i, mode), expected)
          << "Range: " << i << ", Mode: " << static_cast<int>(mode);
    }
  }
}

// According to the spec, this is used for colors close to gray. The values
// chosen here were according to the spec.
TEST(EndpointCodecTest, UsesBlueContract) {
  std::vector<int> vals = { 132, 127, 116, 112, 183, 180, 31, 22 };
  EXPECT_TRUE(UsesBlueContract(255, ColorEndpointMode::kLDRRGBDirect, vals));
  EXPECT_TRUE(UsesBlueContract(255, ColorEndpointMode::kLDRRGBADirect, vals));

  // For the offset modes the only way to trigger the blue contract mode is if
  // we force the subtraction in the decoding procedure (See section C.2.14 of
  // the spec), so we need to set the 7th bit to 1 for all of the odd-numbered
  // values
  vals[1] &= 0xBF;
  vals[3] &= 0xBF;
  vals[5] &= 0xBF;
  vals[7] &= 0xBF;

  EXPECT_FALSE(
      UsesBlueContract(255, ColorEndpointMode::kLDRRGBBaseOffset, vals));
  EXPECT_FALSE(
      UsesBlueContract(255, ColorEndpointMode::kLDRRGBABaseOffset, vals));

  vals[1] |= 0x40;
  vals[3] |= 0x40;
  vals[5] |= 0x40;
  vals[7] |= 0x40;

  EXPECT_TRUE(
      UsesBlueContract(255, ColorEndpointMode::kLDRRGBBaseOffset, vals));
  EXPECT_TRUE(
      UsesBlueContract(255, ColorEndpointMode::kLDRRGBABaseOffset, vals));

  // All other LDR endpoint modes should return no blue contract
  for (int max_val : { 255, 127, 11 }) {
    for (auto mode : { ColorEndpointMode::kLDRLumaDirect,
            ColorEndpointMode::kLDRLumaBaseOffset,
            ColorEndpointMode::kLDRLumaAlphaDirect,
            ColorEndpointMode::kLDRLumaAlphaBaseOffset,
            ColorEndpointMode::kLDRRGBBaseScale,
            ColorEndpointMode::kLDRRGBBaseScaleTwoA }) {
      EXPECT_FALSE(UsesBlueContract(max_val, mode, vals));
    }
  }
}

// Make sure that encoding and decoding for the direct luminance mode works.
TEST(EndpointCodecTest, LumaDirect) {
  const auto mode = EndpointEncodingMode::kDirectLuma;

  // With a 255 quantizer, all greys should be exact.
  for (int i = 0; i < 255; ++i) {
    for (int j = 0; j < 255; ++j) {
      EXPECT_EQ(TestColors({{ i, i, i, 255 }}, {{ j, j, j, 255 }}, 255, mode),
                MakeColors({{ i, i, i, 255 }}, {{ j, j, j, 255 }}));
    }
  }

  // If we have almost grey, then they should encode to grey.
  EXPECT_EQ(TestColors({{ 247, 248, 246, 255 }}, {{ 2, 3, 1, 255 }}, 255, mode),
            MakeColors({{ 247, 247, 247, 255 }}, {{ 2, 2, 2, 255 }}));

  EXPECT_EQ(TestColors({{ 80, 80, 50, 255 }}, {{ 99, 255, 6, 255 }}, 255, mode),
            MakeColors({{ 70, 70, 70, 255 }}, {{ 120, 120, 120, 255 }}));

  // If we have almost greys and a really small quantizer, it should be white
  // and black (literally).
  EXPECT_EQ(TestColors({{ 247, 248, 246, 255 }}, {{ 2, 3, 1, 255 }}, 15, mode),
            MakeColors({{ 255, 255, 255, 255 }}, {{ 0, 0, 0, 255 }}));

  // The average of 64, 127, and 192 is 127.666..., so it should round to
  // 130 instead of 125.
  EXPECT_EQ(TestColors({{ 64, 127, 192, 255 }}, {{ 0, 0, 0, 255 }}, 63, mode),
            MakeColors({{ 130, 130, 130, 255 }}, {{ 0, 0, 0, 255 }}));

  // If we have almost grey, then they should encode to grey -- similar to
  // direct encoding since the encoded colors differ by < 63.
  EXPECT_EQ(TestColors({{ 80, 80, 50, 255 }}, {{ 99, 255, 6, 255 }}, 255, mode),
            MakeColors({{ 70, 70, 70, 255 }}, {{ 120, 120, 120, 255 }}));

  // Low precision colors should still encode pretty well with base/offset.
  EXPECT_EQ(TestColors({{ 35, 36, 38, 255 }}, {{ 42, 43, 40, 255 }}, 47, mode),
            MakeColors({{ 38, 38, 38, 255 }}, {{ 43, 43, 43, 255 }}));

  EXPECT_EQ(TestColors({{ 39, 42, 40, 255 }}, {{ 18, 20, 21, 255 }}, 39, mode),
            MakeColors({{ 39, 39, 39, 255 }}, {{ 19, 19, 19, 255 }}));
}

// Test encoding and decoding for the base-offset luminance mode.
TEST(EndpointCodecTest, LumaAlphaDirect) {
  const auto mode = EndpointEncodingMode::kDirectLumaAlpha;

  // With a 255 quantizer, all greys should be exact.
  for (int i = 0; i < 255; ++i) {
    for (int j = 0; j < 255; ++j) {
      EXPECT_EQ(TestColors({{ i, i, i, j }}, {{ j, j, j, i }}, 255, mode),
                MakeColors({{ i, i, i, j }}, {{ j, j, j, i }}));
    }
  }

  // If we have almost grey, then they should encode to grey.
  EXPECT_EQ(TestColors({{ 247, 248, 246, 250 }}, {{ 2, 3, 1, 172 }}, 255, mode),
            MakeColors({{ 247, 247, 247, 250 }}, {{ 2, 2, 2, 172 }}));

  EXPECT_EQ(TestColors({{ 80, 80, 50, 0 }}, {{ 99, 255, 6, 255 }}, 255, mode),
            MakeColors({{ 70, 70, 70, 0 }}, {{ 120, 120, 120, 255 }}));

  // If we have almost greys and a really small quantizer, it should be white
  // and black (literally).
  EXPECT_EQ(TestColors({{ 247, 248, 246, 253 }}, {{ 2, 3, 1, 3 }}, 15, mode),
            MakeColors({{ 255, 255, 255, 255 }}, {{ 0, 0, 0, 0 }}));

  // The average of 64, 127, and 192 is 127.666..., so it should round to
  // 130 instead of 125. The alpha in this case is independent.
  EXPECT_EQ(TestColors({{ 64, 127, 192, 127 }}, {{ 0, 0, 0, 20 }}, 63, mode),
            MakeColors({{ 130, 130, 130, 125 }}, {{ 0, 0, 0, 20 }}));
}

// Test encoding for the direct RGB mode.
TEST(EndpointCodecTest, RGBDirect) {
  const auto mode = EndpointEncodingMode::kDirectRGB;

  // Colors should be encoded exactly with a 255 quantizer.
  std::mt19937 random(0xdeadbeef);
  std::uniform_int_distribution<int> byte_distribution(0, 255);

  for (int i = 0; i < 100; ++i) {
    RgbaColor low, high;
    for (auto& x : high) { x = byte_distribution(random); }
    for (auto& x : low) { x = byte_distribution(random); }
    high[3] = low[3] = 255;  // RGB Direct mode has opaque alpha.

    EXPECT_EQ(TestColors(low, high, 255, mode), std::make_pair(low, high))
        << "Random iter: " << i;
  }

  // For each of the following tests, order of endpoints shouldn't have any
  // bearing on the quantization properties, so we should be able to switch
  // endpoints as we see fit and have them generate the same flipped encoded
  // pairs.

  EXPECT_EQ(TestColors({{ 64, 127, 192, 255 }}, {{ 0, 0, 0, 255 }}, 63, mode),
            MakeColors({{ 65, 125, 190, 255 }}, {{ 0, 0, 0, 255 }}));

  EXPECT_EQ(TestColors({{ 0, 0, 0, 255 }}, {{ 64, 127, 192, 255 }}, 63, mode),
            MakeColors({{ 0, 0, 0, 255 }}, {{ 65, 125, 190, 255 }}));

  EXPECT_EQ(TestColors({{ 1, 2, 94, 255 }}, {{ 168, 255, 13, 255 }}, 7, mode),
            MakeColors({{ 0, 0, 109, 255 }}, {{ 182, 255, 0, 255 }}));

  // Colors close to grey will likely need a blue contract.
  EXPECT_EQ(TestColors(kBlueContractPairs[0].first,
                       kBlueContractPairs[0].second, 31, mode),
            MakeColors({{ 24, 20, 33, 255 }}, {{ 160, 148, 156, 255 }}));

  EXPECT_EQ(TestColors(kBlueContractPairs[0].second,
                       kBlueContractPairs[0].first, 31, mode),
            MakeColors({{ 160, 148, 156, 255 }}, {{ 24, 20, 33, 255 }}));

  EXPECT_EQ(TestColors(kBlueContractPairs[1].first,
                       kBlueContractPairs[1].second, 7, mode),
            MakeColors({{ 18, 36, 36, 255 }}, {{ 237, 219, 219, 255 }}));

  EXPECT_EQ(TestColors(kBlueContractPairs[1].second,
                       kBlueContractPairs[1].first, 7, mode),
            MakeColors({{ 237, 219, 219, 255 }}, {{ 18, 36, 36, 255 }}));

  // Colors close to grey (and each other) will likely need a blue contract AND
  // use the offset mode for encoding
  EXPECT_EQ(TestColors(kBlueContractPairs[2].first,
                       kBlueContractPairs[2].second, 31, mode),
            MakeColors({{ 53, 59, 53, 255 }}, {{ 24, 30, 26, 255 }}));

  EXPECT_EQ(TestColors(kBlueContractPairs[2].second,
                       kBlueContractPairs[2].first, 31, mode),
            MakeColors({{ 24, 30, 26, 255 }}, {{ 53, 59, 53, 255 }}));

  // Colors close to each other, but not to grey will likely only use the offset
  // mode and not the blue-contract modes.
  EXPECT_EQ(TestColors({{ 22, 148, 30, 59 }}, {{ 162, 18, 155, 59 }}, 31, mode),
            MakeColors({{ 24, 148, 33, 255 }}, {{ 165, 16, 156, 255 }}));

  EXPECT_EQ(TestColors({{ 162, 18, 155, 59 }}, {{ 22, 148, 30, 59 }}, 31, mode),
            MakeColors({{ 165, 16, 156, 255 }}, {{ 24, 148, 33, 255 }}));
}

// Make sure that certain endpoint pairs result in the blue-contract path as
// we'd expect, such that we can make sure that we're hitting all of the encode
// paths.
TEST(EndpointCodecTest, RGBDirectMakesBlueContract) {
  constexpr int kEndpointRange = 31;
  for (const auto& endpoint_pair : kBlueContractPairs) {
    ColorEndpointMode astc_mode;
    std::vector<int> vals;
    bool needs_swap = EncodeColorsForMode(
        endpoint_pair.first, endpoint_pair.second,
        kEndpointRange, EndpointEncodingMode::kDirectRGB, &astc_mode, &vals);
    (void)(needs_swap);  // Don't really care.

    EXPECT_TRUE(UsesBlueContract(kEndpointRange, astc_mode, vals));
  }
}

// Make sure that encoding and decoding for the RGB base-scale mode works.
TEST(EndpointCodecTest, RGBBaseScale) {
  const auto mode = EndpointEncodingMode::kBaseScaleRGB;
  const auto close_to = [](RgbaColor c, int x) {
    return Pointwise(IsCloseTo(x), c);
  };

  // Identical colors should be encoded with a 255 scale factor. Since ASTC
  // decodes the scaled color by doing (x * s) >> 8, the decoded color will be
  // multiplied by 255/256. This might cause rounding errors sometimes, so we
  // check that every channel only deviates by 1.
  std::mt19937 random(0xdeadbeef);
  std::uniform_int_distribution<int> byte_distribution(0, 255);

  for (int i = 0; i < 100; ++i) {
    RgbaColor color{{byte_distribution(random), byte_distribution(random),
                     byte_distribution(random), 255}};
    const auto test_result = TestColors(color, color, 255, mode);
    EXPECT_THAT(test_result, Pair(close_to(color, 1), close_to(color, 1)));
  }

  // Make sure that if we want to scale by e.g. 1/4 then we can do that exactly:
  const RgbaColor low = {{ 20, 4, 40, 255 }};
  const RgbaColor high = {{ 80, 16, 160, 255 }};
  EXPECT_THAT(TestColors(low, high, 255, mode),
              Pair(close_to(low, 0), close_to(high, 0)));

  // And if we quantize it, then we get roughly the same thing. The scale factor
  // should be representable with most quantization levels. The problem is that
  // if we're off on the 'high' color, then we will be off on the 'low' color.
  EXPECT_THAT(TestColors(low, high, 127, mode),
              Pair(close_to(low, 1), close_to(high, 1)));

  EXPECT_THAT(TestColors(low, high, 63, mode),
              Pair(close_to(low, 1), close_to(high, 2)));

  EXPECT_THAT(TestColors(low, high, 31, mode),
              Pair(close_to(low, 1), close_to(high, 4)));

  EXPECT_THAT(TestColors(low, high, 15, mode),
              Pair(close_to(low, 2), close_to(high, 8)));
}

// Make sure that encoding and decoding for the RGB base-offset mode works.
// Since we don't have a decoder, this is currently only a test that should work
// based on reasoning about what's written in the spec.
// TODO(krajcevski): Write an encoder.
TEST(EndpointCodecTest, RGBBaseOffset) {
  const auto test_colors = [](const RgbaColor& low, const RgbaColor& high) {
    const RgbaColor diff = {{ high[0] - low[0], high[1] - low[1],
                              high[2] - low[2], high[3] - low[3] }};

    std::vector<int> vals;
    for (int i = 0; i < 3; ++i) {
      // If the base is "large", then it grabs it's most significant bit from
      // the offset value. Hence, we need to save it here.
      const bool is_large = low[i] >= 128;
      vals.push_back((low[i] * 2) & 0xFF);
      vals.push_back(diff[i] * 2);

      // Give the "large" bases their bits back.
      if (is_large) {
        vals.back() |= 0x80;
      }
    }

    RgbaColor dec_low, dec_high;
    DecodeColorsForMode(vals, 255, ColorEndpointMode::kLDRRGBBaseOffset,
                        &dec_low, &dec_high);

    EXPECT_THAT(std::make_pair(dec_low, dec_high), Pair(Eq(low), Eq(high)));
  };

  // Test the "direct encoding" path.
  test_colors({{ 80, 16, 112, 255 }}, {{ 87, 18, 132, 255 }});
  test_colors({{ 80, 74, 82, 255 }}, {{ 90, 92, 110, 255 }});
  test_colors({{ 0, 0, 0, 255 }}, {{ 2, 2, 2, 255 }});

  // Identical endpoints should always encode exactly, provided they satisfy the
  // requirements for the base encoding.
  std::mt19937 random(0xdeadbeef);
  std::uniform_int_distribution<int> byte_distribution(0, 255);
  for (int i = 0; i < 100; ++i) {
    RgbaColor color{{byte_distribution(random), byte_distribution(random),
                     byte_distribution(random), 255}};
    if ((color[0] | color[1] | color[2]) & 1) {
      continue;
    }
    test_colors(color, color);
  }

  // TODO(google): Test the "blue contract" path.
}

// Make sure that we can decode colors that are given to us straight out of the
// ASTC codec.
TEST(EndpointCodecTest, DecodeCheckerboard) {
  const RgbaColor kWhite {{ 255, 255, 255, 255 }};
  const RgbaColor kBlack {{ 0, 0, 0, 255 }};

  const std::string astc = LoadASTCFile("checkerboard");
  for (int i = 0; i < astc.size(); i += 16) {
    base::UInt128 block;
    memcpy(&block, &astc[i], sizeof(block));

    const auto intermediate = UnpackIntermediateBlock(PhysicalASTCBlock(block));
    ASSERT_TRUE(intermediate) << "Block is void extent???";

    const auto block_data = &intermediate.value();
    ASSERT_THAT(block_data->endpoints, SizeIs(Eq(1)));

    const int color_range = EndpointRangeForBlock(*block_data);
    const auto& endpoints = block_data->endpoints[0];

    RgbaColor low, high;
    DecodeColorsForMode(endpoints.colors, color_range, endpoints.mode,
                        &low, &high);

    // Expect that the endpoints are black and white, but either order.
    EXPECT_THAT(std::make_pair(low, high),
                AnyOf(
                    Pair(Eq(kWhite), Eq(kBlack)),
                    Pair(Eq(kBlack), Eq(kWhite))));
  }
}

}  // namespace

}  // namespace astc_codec