From b56a50064caf2a590ba43699e0074690fcd431bf Mon Sep 17 00:00:00 2001 From: Jeff McGlynn Date: Wed, 20 Jun 2018 11:34:20 -0700 Subject: [PATCH] Initial version of astc-codec for open source release Contains an implementation of an ASTC decoder that is able to pass the dEQP ASTC LDR tests. astc-codec has no external dependencies for the main library, only for test code, and is licensed under the Apache license. Components: include/ - Public API that can decode ASTC LDR data into a RGBA UNORM8 buffer. src/base/ - Base library with common functionality not directly related to ASTC decoding. Contains a uint128 implementation, BitStream for reading/writing bits with a primitive (or uint128 type), Optional implementation (to not take a dependency on C++17), and more. src/decoder/ - Internal implementation of the ASTC decoder. src/base/test/, src/decoder/test/ - Unit tests (and a fuzzing test) for the astc decoder. src/decoder/testdata/ - Sample ASTC images and golden image results for testing. src/decoder/tools/ - A tool to inspect contents of an ASTC file. third_party/ - Third party libraries, only used for tests. Change-Id: Ia98e5a7dc847daa3d3a48c5e62d94b8fb1cb98bd --- BUILD.bazel | 13 + README.md | 37 +- include/astc-codec/astc-codec.h | 75 ++ src/.clang-format | 4 + src/base/BUILD.bazel | 45 + src/base/bit_stream.h | 77 ++ src/base/bottom_n.h | 78 ++ src/base/math_utils.h | 80 ++ src/base/optional.h | 520 ++++++++++ src/base/string_utils.h | 68 ++ src/base/test/bit_stream_test.cpp | 141 +++ src/base/test/bottom_n_test.cpp | 99 ++ src/base/test/math_utils_test.cpp | 78 ++ src/base/test/optional_test.cpp | 481 +++++++++ src/base/test/string_utils_test.cpp | 110 ++ src/base/test/type_traits_test.cpp | 128 +++ src/base/test/uint128_test.cpp | 140 +++ src/base/type_traits.h | 172 ++++ src/base/uint128.h | 175 ++++ src/decoder/BUILD.bazel | 238 +++++ src/decoder/astc_file.cc | 185 ++++ src/decoder/astc_file.h | 97 ++ src/decoder/codec.cc | 132 +++ src/decoder/codec.h | 41 + src/decoder/endpoint_codec.cc | 967 ++++++++++++++++++ src/decoder/endpoint_codec.h | 90 ++ src/decoder/footprint.cc | 162 +++ src/decoder/footprint.h | 106 ++ src/decoder/integer_sequence_codec.cc | 562 ++++++++++ src/decoder/integer_sequence_codec.h | 169 +++ src/decoder/intermediate_astc_block.cc | 591 +++++++++++ src/decoder/intermediate_astc_block.h | 128 +++ src/decoder/logical_astc_block.cc | 262 +++++ src/decoder/logical_astc_block.h | 127 +++ src/decoder/partition.cc | 600 +++++++++++ src/decoder/partition.h | 97 ++ src/decoder/physical_astc_block.cc | 761 ++++++++++++++ src/decoder/physical_astc_block.h | 128 +++ src/decoder/quantization.cc | 462 +++++++++ src/decoder/quantization.h | 65 ++ src/decoder/test/astc_fuzzer.cc | 36 + src/decoder/test/codec_test.cc | 181 ++++ src/decoder/test/endpoint_codec_test.cc | 464 +++++++++ src/decoder/test/footprint_test.cc | 97 ++ src/decoder/test/image_utils.h | 217 ++++ .../test/integer_sequence_codec_test.cc | 337 ++++++ .../test/intermediate_astc_block_test.cc | 453 ++++++++ src/decoder/test/logical_astc_block_test.cc | 273 +++++ src/decoder/test/partition_test.cc | 263 +++++ src/decoder/test/physical_astc_block_test.cc | 361 +++++++ src/decoder/test/quantization_test.cc | 288 ++++++ src/decoder/test/weight_infill_test.cc | 69 ++ src/decoder/testdata/atlas_small_4x4.astc | Bin 0 -> 65552 bytes src/decoder/testdata/atlas_small_4x4.bmp | Bin 0 -> 262282 bytes src/decoder/testdata/atlas_small_5x5.astc | Bin 0 -> 43280 bytes src/decoder/testdata/atlas_small_5x5.bmp | Bin 0 -> 262282 bytes src/decoder/testdata/atlas_small_6x6.astc | Bin 0 -> 29600 bytes src/decoder/testdata/atlas_small_6x6.bmp | Bin 0 -> 262282 bytes src/decoder/testdata/atlas_small_8x8.astc | Bin 0 -> 16400 bytes src/decoder/testdata/atlas_small_8x8.bmp | Bin 0 -> 262282 bytes src/decoder/testdata/checkerboard.astc | Bin 0 -> 80 bytes src/decoder/testdata/checkered_10.astc | Bin 0 -> 1616 bytes src/decoder/testdata/checkered_11.astc | Bin 0 -> 1952 bytes src/decoder/testdata/checkered_12.astc | Bin 0 -> 2320 bytes src/decoder/testdata/checkered_4.astc | Bin 0 -> 272 bytes src/decoder/testdata/checkered_5.astc | Bin 0 -> 416 bytes src/decoder/testdata/checkered_6.astc | Bin 0 -> 592 bytes src/decoder/testdata/checkered_7.astc | Bin 0 -> 800 bytes src/decoder/testdata/checkered_8.astc | Bin 0 -> 1040 bytes src/decoder/testdata/checkered_9.astc | Bin 0 -> 1312 bytes src/decoder/testdata/footprint_10x10.astc | Bin 0 -> 272 bytes src/decoder/testdata/footprint_10x10.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_10x5.astc | Bin 0 -> 464 bytes src/decoder/testdata/footprint_10x5.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_10x6.astc | Bin 0 -> 400 bytes src/decoder/testdata/footprint_10x6.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_10x8.astc | Bin 0 -> 272 bytes src/decoder/testdata/footprint_10x8.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_12x10.astc | Bin 0 -> 208 bytes src/decoder/testdata/footprint_12x10.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_12x12.astc | Bin 0 -> 160 bytes src/decoder/testdata/footprint_12x12.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_4x4.astc | Bin 0 -> 1040 bytes src/decoder/testdata/footprint_4x4.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_5x4.astc | Bin 0 -> 912 bytes src/decoder/testdata/footprint_5x4.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_5x5.astc | Bin 0 -> 800 bytes src/decoder/testdata/footprint_5x5.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_6x5.astc | Bin 0 -> 688 bytes src/decoder/testdata/footprint_6x5.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_6x6.astc | Bin 0 -> 592 bytes src/decoder/testdata/footprint_6x6.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_8x5.astc | Bin 0 -> 464 bytes src/decoder/testdata/footprint_8x5.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_8x6.astc | Bin 0 -> 400 bytes src/decoder/testdata/footprint_8x6.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/footprint_8x8.astc | Bin 0 -> 272 bytes src/decoder/testdata/footprint_8x8.bmp | Bin 0 -> 3210 bytes src/decoder/testdata/rgb_12x12.astc | Bin 0 -> 7312 bytes src/decoder/testdata/rgb_12x12.bmp | Bin 0 -> 193674 bytes src/decoder/testdata/rgb_4x4.astc | Bin 0 -> 64528 bytes src/decoder/testdata/rgb_4x4.bmp | Bin 0 -> 193674 bytes src/decoder/testdata/rgb_5x4.astc | Bin 0 -> 51856 bytes src/decoder/testdata/rgb_5x4.bmp | Bin 0 -> 193674 bytes src/decoder/testdata/rgb_6x6.astc | Bin 0 -> 29200 bytes src/decoder/testdata/rgb_6x6.bmp | Bin 0 -> 193674 bytes src/decoder/testdata/rgb_8x8.astc | Bin 0 -> 16144 bytes src/decoder/testdata/rgb_8x8.bmp | Bin 0 -> 193674 bytes src/decoder/tools/astc_inspector_cli.cc | 785 ++++++++++++++ src/decoder/types.h | 74 ++ src/decoder/weight_infill.cc | 122 +++ src/decoder/weight_infill.h | 38 + 112 files changed, 12548 insertions(+), 1 deletion(-) create mode 100644 include/astc-codec/astc-codec.h create mode 100644 src/.clang-format create mode 100644 src/base/BUILD.bazel create mode 100644 src/base/bit_stream.h create mode 100644 src/base/bottom_n.h create mode 100644 src/base/math_utils.h create mode 100644 src/base/optional.h create mode 100644 src/base/string_utils.h create mode 100644 src/base/test/bit_stream_test.cpp create mode 100644 src/base/test/bottom_n_test.cpp create mode 100644 src/base/test/math_utils_test.cpp create mode 100644 src/base/test/optional_test.cpp create mode 100644 src/base/test/string_utils_test.cpp create mode 100644 src/base/test/type_traits_test.cpp create mode 100644 src/base/test/uint128_test.cpp create mode 100644 src/base/type_traits.h create mode 100644 src/base/uint128.h create mode 100644 src/decoder/BUILD.bazel create mode 100644 src/decoder/astc_file.cc create mode 100644 src/decoder/astc_file.h create mode 100644 src/decoder/codec.cc create mode 100644 src/decoder/codec.h create mode 100644 src/decoder/endpoint_codec.cc create mode 100644 src/decoder/endpoint_codec.h create mode 100644 src/decoder/footprint.cc create mode 100644 src/decoder/footprint.h create mode 100644 src/decoder/integer_sequence_codec.cc create mode 100644 src/decoder/integer_sequence_codec.h create mode 100644 src/decoder/intermediate_astc_block.cc create mode 100644 src/decoder/intermediate_astc_block.h create mode 100644 src/decoder/logical_astc_block.cc create mode 100644 src/decoder/logical_astc_block.h create mode 100644 src/decoder/partition.cc create mode 100644 src/decoder/partition.h create mode 100644 src/decoder/physical_astc_block.cc create mode 100644 src/decoder/physical_astc_block.h create mode 100644 src/decoder/quantization.cc create mode 100644 src/decoder/quantization.h create mode 100644 src/decoder/test/astc_fuzzer.cc create mode 100644 src/decoder/test/codec_test.cc create mode 100644 src/decoder/test/endpoint_codec_test.cc create mode 100644 src/decoder/test/footprint_test.cc create mode 100644 src/decoder/test/image_utils.h create mode 100644 src/decoder/test/integer_sequence_codec_test.cc create mode 100644 src/decoder/test/intermediate_astc_block_test.cc create mode 100644 src/decoder/test/logical_astc_block_test.cc create mode 100644 src/decoder/test/partition_test.cc create mode 100644 src/decoder/test/physical_astc_block_test.cc create mode 100644 src/decoder/test/quantization_test.cc create mode 100644 src/decoder/test/weight_infill_test.cc create mode 100644 src/decoder/testdata/atlas_small_4x4.astc create mode 100644 src/decoder/testdata/atlas_small_4x4.bmp create mode 100644 src/decoder/testdata/atlas_small_5x5.astc create mode 100644 src/decoder/testdata/atlas_small_5x5.bmp create mode 100644 src/decoder/testdata/atlas_small_6x6.astc create mode 100644 src/decoder/testdata/atlas_small_6x6.bmp create mode 100644 src/decoder/testdata/atlas_small_8x8.astc create mode 100644 src/decoder/testdata/atlas_small_8x8.bmp create mode 100644 src/decoder/testdata/checkerboard.astc create mode 100644 src/decoder/testdata/checkered_10.astc create mode 100644 src/decoder/testdata/checkered_11.astc create mode 100644 src/decoder/testdata/checkered_12.astc create mode 100644 src/decoder/testdata/checkered_4.astc create mode 100644 src/decoder/testdata/checkered_5.astc create mode 100644 src/decoder/testdata/checkered_6.astc create mode 100644 src/decoder/testdata/checkered_7.astc create mode 100644 src/decoder/testdata/checkered_8.astc create mode 100644 src/decoder/testdata/checkered_9.astc create mode 100644 src/decoder/testdata/footprint_10x10.astc create mode 100644 src/decoder/testdata/footprint_10x10.bmp create mode 100644 src/decoder/testdata/footprint_10x5.astc create mode 100644 src/decoder/testdata/footprint_10x5.bmp create mode 100644 src/decoder/testdata/footprint_10x6.astc create mode 100644 src/decoder/testdata/footprint_10x6.bmp create mode 100644 src/decoder/testdata/footprint_10x8.astc create mode 100644 src/decoder/testdata/footprint_10x8.bmp create mode 100644 src/decoder/testdata/footprint_12x10.astc create mode 100644 src/decoder/testdata/footprint_12x10.bmp create mode 100644 src/decoder/testdata/footprint_12x12.astc create mode 100644 src/decoder/testdata/footprint_12x12.bmp create mode 100644 src/decoder/testdata/footprint_4x4.astc create mode 100644 src/decoder/testdata/footprint_4x4.bmp create mode 100644 src/decoder/testdata/footprint_5x4.astc create mode 100644 src/decoder/testdata/footprint_5x4.bmp create mode 100644 src/decoder/testdata/footprint_5x5.astc create mode 100644 src/decoder/testdata/footprint_5x5.bmp create mode 100644 src/decoder/testdata/footprint_6x5.astc create mode 100644 src/decoder/testdata/footprint_6x5.bmp create mode 100644 src/decoder/testdata/footprint_6x6.astc create mode 100644 src/decoder/testdata/footprint_6x6.bmp create mode 100644 src/decoder/testdata/footprint_8x5.astc create mode 100644 src/decoder/testdata/footprint_8x5.bmp create mode 100644 src/decoder/testdata/footprint_8x6.astc create mode 100644 src/decoder/testdata/footprint_8x6.bmp create mode 100644 src/decoder/testdata/footprint_8x8.astc create mode 100644 src/decoder/testdata/footprint_8x8.bmp create mode 100644 src/decoder/testdata/rgb_12x12.astc create mode 100644 src/decoder/testdata/rgb_12x12.bmp create mode 100644 src/decoder/testdata/rgb_4x4.astc create mode 100644 src/decoder/testdata/rgb_4x4.bmp create mode 100644 src/decoder/testdata/rgb_5x4.astc create mode 100644 src/decoder/testdata/rgb_5x4.bmp create mode 100644 src/decoder/testdata/rgb_6x6.astc create mode 100644 src/decoder/testdata/rgb_6x6.bmp create mode 100644 src/decoder/testdata/rgb_8x8.astc create mode 100644 src/decoder/testdata/rgb_8x8.bmp create mode 100644 src/decoder/tools/astc_inspector_cli.cc create mode 100644 src/decoder/types.h create mode 100644 src/decoder/weight_infill.cc create mode 100644 src/decoder/weight_infill.h diff --git a/BUILD.bazel b/BUILD.bazel index c947e83..8fc9eca 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -13,3 +13,16 @@ # limitations under the License. licenses(["notice"]) + +cc_library( + name = "api", + hdrs = ["include/astc-codec/astc-codec.h"], + visibility = ["//src/decoder:__pkg__"], +) + +cc_library( + name = "astc_codec", + deps = ["//src/decoder:codec"], + includes = ["include"], + visibility = ["//visibility:public"], +) diff --git a/README.md b/README.md index 41daba0..7d53cb8 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,41 @@ astc-codec is a software ASTC decoder implementation, which supports the ASTC LDR profile. +Example usage: + +``` +#include + +// ... + +std::vector astc = LoadMyASTCData(); +const size_t width = 640; +const size_t height = 480; + +std::vector result; +result.resize(width * height * 4); + +bool result = astc_codec::ASTCDecompressToRGBA( + astc.data(), astc.size(), width, height, astc_codec::FootprintType::k4x4, + result.data(), result.size(), /* stride */ width * 4); +``` + +## Building + +Install [Bazel](https://bazel.build/), and then run: + +``` +bazel build :astc_codec -c opt +``` + +astc-codec has been tested on Mac and Linux. + +## Run Tests + +``` +bazel test //... +``` + ## Contributing See [CONTRIBUTING.md](CONTRIBUTING.md) for important contributing requirements. @@ -12,4 +47,4 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for important contributing requirements. astc-codec project is licensed under the Apache License Version 2.0. You can find a copy of it in [LICENSE](LICENSE). -This is not an official Google product. +This is not an officially supported Google product. diff --git a/include/astc-codec/astc-codec.h b/include/astc-codec/astc-codec.h new file mode 100644 index 0000000..1d41218 --- /dev/null +++ b/include/astc-codec/astc-codec.h @@ -0,0 +1,75 @@ +// 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. + +#ifndef ASTC_CODEC_ASTC_CODEC_H_ +#define ASTC_CODEC_ASTC_CODEC_H_ + +#include +#include + +namespace astc_codec { + +// These are the valid ASTC footprints according to the specification in +// Section C.2.7. +enum class FootprintType { + k4x4, + k5x4, + k5x5, + k6x5, + k6x6, + k8x5, + k8x6, + k10x5, + k10x6, + k8x8, + k10x8, + k10x10, + k12x10, + k12x12, + + kCount +}; + +// Decompresses ASTC LDR image data to a RGBA32 buffer. +// +// Supports formats defined in the KHR_texture_compression_astc_ldr spec and +// returns UNORM8 values. sRGB is not supported, and should be implemented +// by the caller. +// +// |astc_data| - Compressed ASTC image buffer, must be at least |astc_data_size| +// bytes long. +// |astc_data_size| - The size of |astc_data|, in bytes. +// |width| - Image width, in pixels. +// |height| - Image height, in pixels. +// |footprint| - The ASTC footprint (block size) of the compressed image buffer. +// |out_buffer| - Pointer to a buffer where the decompressed image will be +// stored, must be at least |out_buffer_size| bytes long. +// |out_buffer_size| - The size of |out_buffer|, in bytes, at least +// height*out_buffer_stride. If this is too small, this +// function will return false and no data will be +// decompressed. +// |out_buffer_stride| - The stride that should be used to store rows of the +// decoded image, must be at least 4*width bytes. +// +// Returns true if the decompression succeeded, or false if decompression +// failed, or if the astc_data_size was too small for the given width, height, +// and footprint, or if out_buffer_size is too small. +bool ASTCDecompressToRGBA(const uint8_t* astc_data, size_t astc_data_size, + size_t width, size_t height, FootprintType footprint, + uint8_t* out_buffer, size_t out_buffer_size, + size_t out_buffer_stride); + +} // namespace astc_codec + +#endif // ASTC_CODEC_ASTC_CODEC_H_ diff --git a/src/.clang-format b/src/.clang-format new file mode 100644 index 0000000..9a00ee2 --- /dev/null +++ b/src/.clang-format @@ -0,0 +1,4 @@ +BasedOnStyle: Google +AllowShortCaseLabelsOnASingleLine: true +AllowShortFunctionsOnASingleLine: Inline +SpaceAfterTemplateKeyword: false diff --git a/src/base/BUILD.bazel b/src/base/BUILD.bazel new file mode 100644 index 0000000..9d8b9a0 --- /dev/null +++ b/src/base/BUILD.bazel @@ -0,0 +1,45 @@ +# 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. + +cc_library( + name = "base", + hdrs = [ + "bit_stream.h", + "bottom_n.h", + "math_utils.h", + "optional.h", + "string_utils.h", + "type_traits.h", + "uint128.h", + ], + visibility = ["//src/decoder:__pkg__"], +) + +cc_test( + name = "base_test", + srcs = [ + "test/bit_stream_test.cpp", + "test/bottom_n_test.cpp", + "test/math_utils_test.cpp", + "test/optional_test.cpp", + "test/string_utils_test.cpp", + "test/type_traits_test.cpp", + "test/uint128_test.cpp", + ], + deps = [ + "@gtest//:gtest_main", + ":base", + ], +) + diff --git a/src/base/bit_stream.h b/src/base/bit_stream.h new file mode 100644 index 0000000..c878197 --- /dev/null +++ b/src/base/bit_stream.h @@ -0,0 +1,77 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_BIT_STREAM_H_ +#define ASTC_CODEC_BASE_BIT_STREAM_H_ + +#include +#include + +namespace astc_codec { +namespace base { + +// Represents a stream of bits that can be read or written in arbitrary-sized +// chunks. +template +class BitStream { + public: + // Creates an empty BitStream. + BitStream() = default; + BitStream(IntType data, uint32_t data_size) + : data_(data), data_size_(data_size) { + assert(data_size_ <= sizeof(data_) * 8); + } + + // Return the number of bits in the stream. + uint32_t Bits() const { return data_size_; } + + // Put |size| bits into the stream. + // Fails if there is not enough space in the buffer to store the bits. + template + void PutBits(ResultType x, uint32_t size) { + assert(data_size_ + size <= sizeof(data_) * 8); + + data_ |= (IntType(x) & MaskFor(size)) << data_size_; + data_size_ += size; + } + + // Get |count| bits from the stream. + // Returns true if |count| bits were successfully retrieved. + template + bool GetBits(uint32_t count, ResultType* result) { + if (count <= data_size_) { + *result = static_cast(data_ & MaskFor(count)); + data_ = data_ >> count; + data_size_ -= count; + return true; + } else { + *result = 0; + return false; + } + } + + private: + IntType MaskFor(uint32_t bits) const { + return (bits == sizeof(IntType) * 8) ? ~IntType(0) + : (IntType(1) << bits) - 1; + } + + IntType data_ = 0; + uint32_t data_size_ = 0; +}; + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_BIT_STREAM_H_ diff --git a/src/base/bottom_n.h b/src/base/bottom_n.h new file mode 100644 index 0000000..4edc8ef --- /dev/null +++ b/src/base/bottom_n.h @@ -0,0 +1,78 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_BOTTOM_N_H_ +#define ASTC_CODEC_BASE_BOTTOM_N_H_ + +#include +#include +#include + +namespace astc_codec { +namespace base { + +// Used to aggregate the lowest N values of data supplied. +template> +class BottomN { + public: + typedef std::vector ContainerType; + + // Creates an empty BottomN with limit |max_size|. + BottomN(size_t max_size) : max_size_(max_size) { } + + bool Empty() const { return data_.empty(); } + size_t Size() const { return data_.size(); } + + const T& Top() const { return data_.front(); } + + void Push(const T& value) { + if (data_.size() < max_size_ || compare_(value, Top())) { + data_.push_back(value); + std::push_heap(data_.begin(), data_.end(), compare_); + + if (Size() > max_size_) { + PopTop(); + } + } + } + + std::vector Pop() { + const size_t len = Size(); + std::vector result(len); + + for (size_t i = 0; i < len; ++i) { + result[len - i - 1] = PopTop(); + } + + return result; + } + + private: + T PopTop() { + std::pop_heap(data_.begin(), data_.end(), compare_); + T result = data_.back(); + data_.pop_back(); + return result; + } + + ContainerType data_; + CompareFn compare_; + + const size_t max_size_; +}; + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_BOTTOM_N_H_ diff --git a/src/base/math_utils.h b/src/base/math_utils.h new file mode 100644 index 0000000..48f1a24 --- /dev/null +++ b/src/base/math_utils.h @@ -0,0 +1,80 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_MATH_UTILS_H_ +#define ASTC_CODEC_BASE_MATH_UTILS_H_ + +#include "src/base/uint128.h" + +#include +#include +#include + +namespace astc_codec { +namespace base { + +inline int Log2Floor(uint32_t n) { + if (n == 0) { + return -1; + } + + int log = 0; + uint32_t value = n; + for (int i = 4; i >= 0; --i) { + int shift = (1 << i); + uint32_t x = value >> shift; + if (x != 0) { + value = x; + log += shift; + } + } + assert(value == 1); + return log; +} + +inline int CountOnes(uint32_t n) { + n -= ((n >> 1) & 0x55555555); + n = ((n >> 2) & 0x33333333) + (n & 0x33333333); + return static_cast((((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24); +} + +template +inline T ReverseBits(T value) { + uint32_t s = sizeof(value) * 8; + T mask = ~T(0); + while ((s >>= 1) > 0) { + mask ^= (mask << s); + value = ((value >> s) & mask) | ((value << s) & ~mask); + } + + return value; +} + +template +inline T GetBits(T source, uint32_t offset, uint32_t count) { + static_assert(std::is_same::value || std::is_unsigned::value, + "T must be unsigned."); + + const uint32_t total_bits = sizeof(T) * 8; + assert(count > 0); + assert(offset + count <= total_bits); + + const T mask = count == total_bits ? ~T(0) : ~T(0) >> (total_bits - count); + return (source >> offset) & mask; +} + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_MATH_UTILS_H_ diff --git a/src/base/optional.h b/src/base/optional.h new file mode 100644 index 0000000..5ede4af --- /dev/null +++ b/src/base/optional.h @@ -0,0 +1,520 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_OPTIONAL_H_ +#define ASTC_CODEC_BASE_OPTIONAL_H_ + +#include "src/base/type_traits.h" + +#include +#include +#include +#include + +#include + +// Optional - a template class to store an optional value of type T. +// +// Usage examples: +// +// Initialization and construction: +// Optional foo; // |foo| doesn't contain a value. +// Optional foo(Foo(10)); // |foo| contains a copy-constructed value. +// Optional foo2(foo); // |foo2| contains a copy of |foo|'s value. +// Optional foo3(std::move(foo2)); // Guess what? +// +// Assignment: +// Foo foo_value(0); +// Optional foo; // |foo| is empty. +// Optional foo2; // |foo2| is empty. +// foo2 = foo; // |foo2| is still empty. +// foo = foo_value; // set value of |foo| to a copy of |foo_value| +// foo = std::move(foo_value); // move |foo_value| into |foo|. +// foo2 = foo; // now |foo2| has a copy of |foo|'s value. +// foo = kNullopt; // unset |foo|, it has no value. +// +// Checking and accessing value: +// if (foo) { +// // |foo| has a value. +// doStuff(*foo); // |*foo| is the value inside |foo|. +// foo->callMethod(); // Same as (*foo).callMethod(). +// } else { +// // |foo| is empty. +// } +// +// foo.value() // Same as *foo +// foo.valueOr() // Return is |foo| has no value. +// +// In-place construction: +// +// Optional foo; // |foo| is empty. +// foo.emplace(20); // |foo| now contains a value constructed as Foo(20) +// +// Optional foo(kInplace, 20); // |foo| is initialized with a value +// // that is constructed in-place as +// // Foo(20). +// +// return makeOptional(20); // Takes Foo constructor arguments +// // directly. +// +// Returning values: +// +// Optional myFunc(...) { +// if (someCondition) { +// return Foo(10); // call Optional(Foo&) constructor. +// } else { +// return {}; // call Optional() constructor, which +// // builds an empty value. +// } +// } +// +// Memory layout: +// Optional is equivalent to: +// +// struct { +// bool flag; +// Foo value; +// }; +// +// in terms of memory layout. This means it *doubles* the size of integral +// types. Also: +// +// - Optional can be constructed from anything that constructs a Foo. +// +// - Same with Optional(kInplace, Args...) where Args... matches any +// arguments that can be passed to a Foo constructor. +// +// - Comparison operators are provided. Beware: an empty Optional +// is always smaller than any Foo value. + +namespace astc_codec { +namespace base { + +namespace details { + +// Base classes to reduce the number of instantiations of the Optional's +// internal members. +class OptionalFlagBase { + public: + void setConstructed(bool constructed) { mConstructed = constructed; } + constexpr bool constructed() const { return mConstructed; } + constexpr operator bool() const { return constructed(); } + bool hasValue() const { return constructed(); } + + constexpr OptionalFlagBase(bool constructed = false) + : mConstructed(constructed) { } + + private: + bool mConstructed = false; +}; + +template +class OptionalStorageBase { + protected: + using StoreT = typename std::aligned_storage::type; + StoreT mStorage = {}; +}; + +} // namespace details + +// A tag type for empty optional construction +struct NulloptT { + constexpr explicit NulloptT(int) { } +}; + +// A tag type for inplace value construction +struct InplaceT { + constexpr explicit InplaceT(int) { } +}; + +// Tag values for null optional and inplace construction +constexpr NulloptT kNullopt{1}; +constexpr InplaceT kInplace{1}; + +// Forward declaration for an early use +template +class Optional; + +// A type trait for checking if a type is an optional instantiation +// Note: if you want to refer to the template name inside the template, +// you need to declare this alias outside of it - because the +// class name inside of the template stands for an instantiated template +// E.g, for template class Foo if you say 'Foo' inside the class, it +// actually means Foo; +template +using is_any_optional = + is_template_instantiation_of::type, Optional>; + +template +class Optional + : private details::OptionalFlagBase, + private details::OptionalStorageBase::value> { + // make sure all optionals are buddies - this is needed to implement + // conversion from optionals of other types + template + friend class Optional; + + template + using self = Optional; + + using base_flag = details::OptionalFlagBase; + using base_storage = + details::OptionalStorageBase::value>; + + public: + // std::optional will have this, so let's provide it + using value_type = T; + + // make sure we forbid some Optional instantiations where things may get + // really messy + static_assert(!std::is_same::type, NulloptT>::value, + "Optional of NulloptT is not allowed"); + static_assert(!std::is_same::type, InplaceT>::value, + "Optional of InplaceT is not allowed"); + static_assert(!std::is_reference::value, + "Optional references are not allowed: use a pointer instead"); + + // constructors + constexpr Optional() { } + constexpr Optional(NulloptT) { } + + Optional(const Optional& other) : base_flag(other.constructed()) { + if (this->constructed()) { + new (&get()) T(other.get()); + } + } + Optional(Optional&& other) : base_flag(other.constructed()) { + if (this->constructed()) { + new (&get()) T(std::move(other.get())); + } + } + + // Conversion constructor from optional of similar type + template::value && + std::is_constructible::value>> + Optional(const Optional& other) : base_flag(other.constructed()) { + if (this->constructed()) { + new (&get()) T(other.get()); + } + } + + // Move-conversion constructor + template::value && + std::is_constructible::value>> + Optional(Optional&& other) : base_flag(other.constructed()) { + if (this->constructed()) { + new (&get()) T(std::move(other.get())); + } + } + + // Construction from a raw value + Optional(const T& value) : base_flag(true) { new (&get()) T(value); } + // Move construction from a raw value + Optional(T&& value) : base_flag(true) { new (&get()) T(std::move(value)); } + + // Inplace construction from a list of |T|'s ctor arguments + template + Optional(InplaceT, Args&&... args) : base_flag(true) { + new (&get()) T(std::forward(args)...); + } + + // Inplace construction from an initializer list passed into |T|'s ctor + template>>> + Optional(InplaceT, std::initializer_list il) : base_flag(true) { + new (&get()) T(il); + } + + // direct assignment + Optional& operator=(const Optional& other) { + if (&other == this) { + return *this; + } + + if (this->constructed()) { + if (other.constructed()) { + get() = other.get(); + } else { + destruct(); + this->setConstructed(false); + } + } else { + if (other.constructed()) { + new (&get()) T(other.get()); + this->setConstructed(true); + } else { + ; // we're good + } + } + return *this; + } + + // move assignment + Optional& operator=(Optional&& other) { + if (this->constructed()) { + if (other.constructed()) { + get() = std::move(other.get()); + } else { + destruct(); + this->setConstructed(false); + } + } else { + if (other.constructed()) { + new (&get()) T(std::move(other.get())); + this->setConstructed(true); + } else { + ; // we're good + } + } + return *this; + } + + // conversion assignment + template::type, T>> + Optional& operator=(const Optional& other) { + if (this->constructed()) { + if (other.constructed()) { + get() = other.get(); + } else { + destruct(); + this->setConstructed(false); + } + } else { + if (other.constructed()) { + new (&get()) T(other.get()); + this->setConstructed(true); + } else { + ; // we're good + } + } + return *this; + } + + // conversion move assignment + template::type, T>> + Optional& operator=(Optional&& other) { + if (this->constructed()) { + if (other.constructed()) { + get() = std::move(other.get()); + } else { + destruct(); + this->setConstructed(false); + } + } else { + if (other.constructed()) { + new (&get()) T(std::move(other.get())); + this->setConstructed(true); + } else { + ; // we're good + } + } + return *this; + } + + // the most complicated one: forwarding constructor for anything convertible + // to |T|, excluding the stuff implemented above explicitly + template::type>::value && + std::is_convertible::type, T>::value>> + Optional& operator=(U&& other) { + if (this->constructed()) { + get() = std::forward(other); + } else { + new (&get()) T(std::forward(other)); + this->setConstructed(true); + } + return *this; + } + + // Adopt value checkers from the parent + using base_flag::operator bool; + using base_flag::hasValue; + + T& value() { + assert(this->constructed()); + return get(); + } + constexpr const T& value() const { + assert(this->constructed()); + return get(); + } + + T* ptr() { return this->constructed() ? &get() : nullptr; } + constexpr const T* ptr() const { + return this->constructed() ? &get() : nullptr; + } + + // Value getter with fallback + template::type, T>> + constexpr T valueOr(U&& defaultValue) const { + return this->constructed() ? get() : std::move(defaultValue); + } + + // Pointer-like operators + T& operator*() { + assert(this->constructed()); + return get(); + } + constexpr const T& operator*() const { + assert(this->constructed()); + return get(); + } + + T* operator->() { + assert(this->constructed()); + return &get(); + } + constexpr const T* operator->() const { + assert(this->constructed()); + return &get(); + } + + ~Optional() { + if (this->constructed()) { + destruct(); + } + } + + void clear() { + if (this->constructed()) { + destruct(); + this->setConstructed(false); + } + } + + template::type, T>> + void reset(U&& u) { + *this = std::forward(u); + } + + // In-place construction with possible destruction of the old value + template + void emplace(Args&&... args) { + if (this->constructed()) { + destruct(); + } + new (&get()) T(std::forward(args)...); + this->setConstructed(true); + } + + // In-place construction with possible destruction of the old value + // initializer-list version + template>>> + void emplace(std::initializer_list il) { + if (this->constructed()) { + destruct(); + } + new (&get()) T(il); + this->setConstructed(true); + } + + private: + // A helper function to convert the internal raw storage to T& + constexpr const T& get() const { + return *reinterpret_cast( + reinterpret_cast(&this->mStorage)); + } + + // Same thing, mutable + T& get() { return const_cast(const_cast(this)->get()); } + + // Shortcut for a destructor call for the stored object + void destruct() { get().T::~T(); } +}; + +template +Optional::type> makeOptional(T&& t) { + return Optional::type>(std::forward(t)); +} + +template +Optional::type> makeOptional(Args&&... args) { + return Optional::type>(kInplace, + std::forward(args)...); +} + +template +bool operator==(const Optional& l, const Optional& r) { + return l.hasValue() ? r.hasValue() && *l == *r : !r.hasValue(); +} +template +bool operator==(const Optional& l, NulloptT) { + return !l; +} +template +bool operator==(NulloptT, const Optional& r) { + return !r; +} +template +bool operator==(const Optional& l, const T& r) { + return bool(l) && *l == r; +} +template +bool operator==(const T& l, const Optional& r) { + return bool(r) && l == *r; +} + +template +bool operator!=(const Optional& l, const Optional& r) { + return !(l == r); +} +template +bool operator!=(const Optional& l, NulloptT) { + return bool(l); +} +template +bool operator!=(NulloptT, const Optional& r) { + return bool(r); +} +template +bool operator!=(const Optional& l, const T& r) { + return !l || !(*l == r); +} +template +bool operator!=(const T& l, const Optional& r) { + return !r || !(l == *r); +} + +template +bool operator<(const Optional& l, const Optional& r) { + return !r ? false : (!l ? true : *l < *r); +} +template +bool operator<(const Optional&, NulloptT) { + return false; +} +template +bool operator<(NulloptT, const Optional& r) { + return bool(r); +} +template +bool operator<(const Optional& l, const T& r) { + return !l || *l < r; +} +template +bool operator<(const T& l, const Optional& r) { + return bool(r) && l < *r; +} + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_OPTIONAL_H_ diff --git a/src/base/string_utils.h b/src/base/string_utils.h new file mode 100644 index 0000000..c450b27 --- /dev/null +++ b/src/base/string_utils.h @@ -0,0 +1,68 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_STRING_UTILS_H_ +#define ASTC_CODEC_BASE_STRING_UTILS_H_ + +#include +#include + +namespace astc_codec { +namespace base { + +// Iterates over a string's parts using |splitBy| as a delimiter. +// |splitBy| must be a nonempty string well, or it's a no-op. +// Otherwise, |func| is called on each of the splits, excluding the +// characters that are part of |splitBy|. If two |splitBy|'s occur in a row, +// |func| will be called on a StringView("") in between. See +// StringUtils_unittest.cpp for the full story. +template +void Split(const std::string& str, const std::string& splitBy, Func func) { + if (splitBy.empty()) { + return; + } + + size_t splitSize = splitBy.size(); + size_t begin = 0; + size_t end = str.find(splitBy); + + while (true) { + func(str.substr(begin, end - begin)); + if (end == std::string::npos) { + return; + } + + begin = end + splitSize; + end = str.find(splitBy, begin); + } +} + +static int32_t ParseInt32(const char* str, int32_t deflt) { + using std::numeric_limits; + + char* error = nullptr; + int64_t value = strtol(str, &error, 0); + // Limit long values to int32 min/max. Needed for lp64; no-op on 32 bits. + if (value > std::numeric_limits::max()) { + value = std::numeric_limits::max(); + } else if (value < std::numeric_limits::min()) { + value = std::numeric_limits::min(); + } + return (error == str) ? deflt : static_cast(value); +} + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_STRING_UTILS_H_ diff --git a/src/base/test/bit_stream_test.cpp b/src/base/test/bit_stream_test.cpp new file mode 100644 index 0000000..0c4b3c9 --- /dev/null +++ b/src/base/test/bit_stream_test.cpp @@ -0,0 +1,141 @@ +// 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/base/bit_stream.h" + +#include + +namespace astc_codec { +namespace base { + +namespace { + static constexpr uint64_t kAllBits = 0xFFFFFFFFFFFFFFFF; + static constexpr uint64_t k40Bits = 0x000000FFFFFFFFFF; +} + +TEST(BitStream, Decode) { + { + BitStream stream(0, 1); + + uint64_t bits = kAllBits; + EXPECT_TRUE(stream.GetBits(1, &bits)); + EXPECT_EQ(bits, 0); + EXPECT_FALSE(stream.GetBits(1, &bits)); + } + + { + BitStream stream(0b1010101010101010, 32); + EXPECT_EQ(stream.Bits(), 32); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(1, &bits)); + EXPECT_EQ(bits, 0); + + EXPECT_TRUE(stream.GetBits(3, &bits)); + EXPECT_EQ(bits, 0b101); + + EXPECT_TRUE(stream.GetBits(8, &bits)); + EXPECT_EQ(bits, 0b10101010); + + EXPECT_EQ(stream.Bits(), 20); + + EXPECT_TRUE(stream.GetBits(20, &bits)); + EXPECT_EQ(bits, 0b1010); + EXPECT_EQ(stream.Bits(), 0); + } + + { + BitStream stream(kAllBits, 64); + EXPECT_EQ(stream.Bits(), 64); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(64, &bits)); + EXPECT_EQ(bits, kAllBits); + EXPECT_EQ(stream.Bits(), 0); + } + + { + BitStream stream(kAllBits, 64); + EXPECT_EQ(stream.Bits(), 64); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(40, &bits)); + EXPECT_EQ(bits, k40Bits); + EXPECT_EQ(stream.Bits(), 24); + } + + { + BitStream stream(kAllBits, 32); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(0, &bits)); + EXPECT_EQ(bits, 0); + EXPECT_TRUE(stream.GetBits(32, &bits)); + EXPECT_EQ(bits, k40Bits & 0xFFFFFFFF); + EXPECT_TRUE(stream.GetBits(0, &bits)); + EXPECT_EQ(bits, 0); + EXPECT_EQ(stream.Bits(), 0); + } +} + +TEST(BitStream, Encode) { + { + BitStream stream; + + stream.PutBits(0, 1); + stream.PutBits(0b11, 2); + EXPECT_EQ(stream.Bits(), 3); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(3, &bits)); + EXPECT_EQ(bits, 0b110); + } + + { + BitStream stream; + + uint64_t bits = 0; + stream.PutBits(kAllBits, 64); + EXPECT_EQ(stream.Bits(), 64); + + EXPECT_TRUE(stream.GetBits(64, &bits)); + EXPECT_EQ(bits, kAllBits); + EXPECT_EQ(stream.Bits(), 0); + } + + { + BitStream stream; + stream.PutBits(kAllBits, 40); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(40, &bits)); + EXPECT_EQ(bits, k40Bits); + EXPECT_EQ(stream.Bits(), 0); + } + + { + BitStream stream; + stream.PutBits(0, 0); + stream.PutBits(kAllBits, 32); + stream.PutBits(0, 0); + + uint64_t bits = 0; + EXPECT_TRUE(stream.GetBits(32, &bits)); + EXPECT_EQ(bits, k40Bits & 0xFFFFFFFF); + EXPECT_EQ(stream.Bits(), 0); + } +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/test/bottom_n_test.cpp b/src/base/test/bottom_n_test.cpp new file mode 100644 index 0000000..8a48d30 --- /dev/null +++ b/src/base/test/bottom_n_test.cpp @@ -0,0 +1,99 @@ +// 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/base/bottom_n.h" + +#include +#include + +namespace astc_codec { +namespace base { + +using ::testing::ElementsAre; + +template +static void pushAll(BottomN& heap, const T (&arr)[N]) { + for (auto i : arr) { + heap.Push(i); + } +} + +TEST(BottomN, Sort) { + { + BottomN heap(10); + EXPECT_TRUE(heap.Empty()); + pushAll(heap, {1, 2}); + + EXPECT_EQ(heap.Size(), 2); + EXPECT_FALSE(heap.Empty()); + EXPECT_THAT(heap.Pop(), ElementsAre(1, 2)); + } + + { + BottomN heap(6); + pushAll(heap, {1, 4, 3, 2, 2, 1}); + + EXPECT_EQ(heap.Size(), 6); + EXPECT_THAT(heap.Pop(), ElementsAre(1, 1, 2, 2, 3, 4)); + } +} + +TEST(BottomN, Bounds) { + { + BottomN heap(4); + pushAll(heap, {1, 2, 3, 4}); + EXPECT_EQ(heap.Size(), 4); + + heap.Push(0); + EXPECT_EQ(heap.Size(), 4); + + EXPECT_THAT(heap.Pop(), ElementsAre(0, 1, 2, 3)); + } + + { + BottomN heap(4); + pushAll(heap, {4, 3, 2, 1}); + EXPECT_EQ(heap.Size(), 4); + + pushAll(heap, {4, 4, 4, 4}); + EXPECT_EQ(heap.Size(), 4); + + EXPECT_THAT(heap.Pop(), ElementsAre(1, 2, 3, 4)); + } + + { + BottomN heap(4); + pushAll(heap, {4, 3, 2, 1}); + EXPECT_EQ(heap.Size(), 4); + + pushAll(heap, {5, 5, 5, 5}); + EXPECT_EQ(heap.Size(), 4); + + EXPECT_THAT(heap.Pop(), ElementsAre(1, 2, 3, 4)); + } + + { + BottomN heap(4); + pushAll(heap, {4, 3, 2, 1}); + EXPECT_EQ(heap.Size(), 4); + + pushAll(heap, {0, 0, 0, 0}); + EXPECT_EQ(heap.Size(), 4); + + EXPECT_THAT(heap.Pop(), ElementsAre(0, 0, 0, 0)); + } +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/test/math_utils_test.cpp b/src/base/test/math_utils_test.cpp new file mode 100644 index 0000000..0371e11 --- /dev/null +++ b/src/base/test/math_utils_test.cpp @@ -0,0 +1,78 @@ +// 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/base/math_utils.h" + +#include + +namespace astc_codec { +namespace base { + +TEST(MathUtils, Log2Floor) { + EXPECT_EQ(-1, Log2Floor(0)); + + for (int i = 0; i < 32; i++) { + uint32_t n = 1U << i; + EXPECT_EQ(i, Log2Floor(n)); + if (n > 2) { + EXPECT_EQ(i - 1, Log2Floor(n - 1)); + EXPECT_EQ(i, Log2Floor(n + 1)); + } + } +} + +TEST(MathUtils, CountOnes) { + EXPECT_EQ(0, CountOnes(0)); + EXPECT_EQ(1, CountOnes(1)); + EXPECT_EQ(32, CountOnes(static_cast(~0U))); + EXPECT_EQ(1, CountOnes(0x8000000)); + + for (int i = 0; i < 32; i++) { + EXPECT_EQ(1, CountOnes(1U << i)); + EXPECT_EQ(31, CountOnes(static_cast(~0U) ^ (1U << i))); + } +} + +TEST(MathUtils, ReverseBits) { + EXPECT_EQ(ReverseBits(0u), 0u); + EXPECT_EQ(ReverseBits(1u), 1u << 31); + EXPECT_EQ(ReverseBits(0xffffffff), 0xffffffff); + EXPECT_EQ(ReverseBits(0x00000001), 0x80000000); + EXPECT_EQ(ReverseBits(0x80000000), 0x00000001); + EXPECT_EQ(ReverseBits(0xaaaaaaaa), 0x55555555); + EXPECT_EQ(ReverseBits(0x55555555), 0xaaaaaaaa); + EXPECT_EQ(ReverseBits(0x7d5d7f53), 0xcafebabe); + EXPECT_EQ(ReverseBits(0xcafebabe), 0x7d5d7f53); +} + +TEST(MathUtils, GetBits) { + EXPECT_EQ(GetBits(0u, 0, 1), 0u); + EXPECT_EQ(GetBits(0u, 0, 32), 0u); + EXPECT_EQ(GetBits(0x00000001u, 0, 1), 0x00000001); + EXPECT_EQ(GetBits(0x00000001u, 0, 32), 0x00000001); + EXPECT_EQ(GetBits(0x00000001u, 1, 31), 0x00000000); + EXPECT_EQ(GetBits(0x00000001u, 31, 1), 0x00000000); + + EXPECT_DEBUG_DEATH(GetBits(0x00000000u, 1, 32), ""); + EXPECT_DEBUG_DEATH(GetBits(0x00000000u, 32, 0), ""); + EXPECT_DEBUG_DEATH(GetBits(0x00000000u, 32, 1), ""); + + EXPECT_EQ(GetBits(0XFFFFFFFFu, 0, 4), 0x0000000F); + EXPECT_EQ(GetBits(0XFFFFFFFFu, 16, 16), 0xFFFF); + EXPECT_EQ(GetBits(0x80000000u, 31, 1), 1); + EXPECT_EQ(GetBits(0xCAFEBABEu, 24, 8), 0xCA); +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/test/optional_test.cpp b/src/base/test/optional_test.cpp new file mode 100644 index 0000000..1eeefbd --- /dev/null +++ b/src/base/test/optional_test.cpp @@ -0,0 +1,481 @@ +// 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/base/optional.h" + +#include + +#include +#include + +namespace astc_codec { +namespace base { + +TEST(Optional, TypeProperties) { + // Making sure optional has the correct alignment and doesn't waste too much + // space + + static_assert(sizeof(Optional) == 2, "bad Optional size"); + static_assert(std::alignment_of>::value == + std::alignment_of::value, + "bad Optional alignment"); + + static_assert(sizeof(Optional) == 2, "bad Optional size"); + static_assert(std::alignment_of>::value == + std::alignment_of::value, + "bad Optional alignment"); + + static_assert(sizeof(Optional) == 4, "bad Optional size"); + static_assert(std::alignment_of>::value == + std::alignment_of::value, + "bad Optional alignment"); + + static_assert(sizeof(Optional) == 8, "bad Optional size"); + static_assert(std::alignment_of>::value == + std::alignment_of::value, + "bad Optional alignment"); + + static_assert(sizeof(Optional) == 16, "bad Optional size"); + static_assert(std::alignment_of>::value == + std::alignment_of::value, + "bad Optional alignment"); + + struct S128 { + int64_t data[2]; + }; + + static_assert(sizeof(Optional) == 3 * sizeof(int64_t), + "bad Optional size"); + static_assert(std::alignment_of>::value == + std::alignment_of::value, + "bad Optional alignment"); +} + +TEST(Optional, ConstructFromValue) { + { + Optional o; + EXPECT_FALSE(o); + } + { + Optional o = {}; + EXPECT_FALSE(o); + } + { + Optional o = kNullopt; + EXPECT_FALSE(o); + } + { + Optional o(1); + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } + { + // check the std::decay<> constructor + Optional o = static_cast(1); + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } + { + Optional o = 1; + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } + { + Optional o{1}; + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } + { + short val = 10; + Optional o = val; + EXPECT_TRUE(o); + EXPECT_EQ(10, *o); + } + { + Optional> o(kInplace, 10); + EXPECT_TRUE(o); + EXPECT_EQ((std::vector(10)), *o); + } + { + Optional> o(kInplace, {1, 2, 3, 4}); + EXPECT_TRUE(o); + EXPECT_EQ((std::vector{1, 2, 3, 4}), *o); + } +} + +TEST(Optional, ConstructFromOptional) { + { + Optional o = Optional(); + EXPECT_FALSE(o); + } + { + Optional o2; + Optional o(o2); + EXPECT_FALSE(o); + } + { + Optional o2 = 42; + Optional o(o2); + EXPECT_TRUE(o); + EXPECT_EQ(42, *o); + } + { + Optional o(Optional(1)); + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } + { + Optional o2 = 2; + Optional o = o2; + EXPECT_TRUE(o); + EXPECT_EQ(2, *o); + } + { + Optional> o2 = std::vector{20, 30, 40}; + Optional> o = o2; + EXPECT_TRUE(o); + EXPECT_EQ((std::vector{20, 30, 40}), *o); + } +} + +TEST(Optional, Assign) { + { + Optional o; + o = 1; + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + + o = 2; + EXPECT_TRUE(o); + EXPECT_EQ(2, *o); + + o = kNullopt; + EXPECT_FALSE(o); + + o = Optional(10); + EXPECT_TRUE(o); + EXPECT_EQ(10, *o); + + Optional o2; + o = o2; + EXPECT_FALSE(o); + + o = 2u; + EXPECT_TRUE(o); + EXPECT_EQ(2, *o); + + o = Optional(); + EXPECT_FALSE(o); + + o = Optional(20); + EXPECT_TRUE(o); + EXPECT_EQ(20, *o); + + Optional o3(200); + o = o3; + EXPECT_TRUE(o); + EXPECT_EQ(200, *o); + + o = {}; + EXPECT_FALSE(o); + + // check the std::decay<> assignment + o = static_cast(1); + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } +} + +TEST(Optional, MakeOptional) { + { + auto o = makeOptional(1); + static_assert(std::is_same>::value, + "Bad type deduction in makeOptional()"); + EXPECT_TRUE(o); + EXPECT_EQ(1, *o); + } + { + auto o = makeOptional(std::vector{'1', '2'}); + static_assert(std::is_same>>::value, + "Bad type deduction in makeOptional()"); + EXPECT_TRUE(o); + EXPECT_EQ((std::vector{'1', '2'}), *o); + } + { + // check std::decay<> in the factory function + auto o = makeOptional("String"); + static_assert(std::is_same>::value, + "Bad type deduction in makeOptional()"); + EXPECT_TRUE(o); + EXPECT_STREQ("String", *o); + } + { + auto o = makeOptional("String"); + static_assert(std::is_same>::value, + "Bad type deduction in makeOptional()"); + EXPECT_TRUE(o); + EXPECT_STREQ("String", o->c_str()); + } + { + auto o = makeOptional(5, 'b'); + static_assert(std::is_same>::value, + "Bad type deduction in makeOptional()"); + EXPECT_TRUE(o); + EXPECT_STREQ("bbbbb", o->c_str()); + } + { + auto o = makeOptional(); + static_assert(std::is_same>::value, + "Bad type deduction in makeOptional()"); + EXPECT_TRUE(o); + EXPECT_STREQ("", o->c_str()); + } +} + +TEST(Optional, Move) { + auto o = makeOptional(std::unique_ptr(new int(10))); + { + decltype(o) o2 = std::move(o); + EXPECT_TRUE(o); + EXPECT_TRUE(o2); + EXPECT_FALSE(bool(*o)); + EXPECT_TRUE(bool(*o2)); + EXPECT_EQ(10, **o2); + + decltype(o) o3; + o3 = std::move(o2); + EXPECT_TRUE(o2); + EXPECT_TRUE(o3); + EXPECT_FALSE(bool(*o2)); + EXPECT_TRUE(bool(*o3)); + EXPECT_EQ(10, **o3); + + o3 = std::move(o2); + EXPECT_TRUE(o2); + EXPECT_TRUE(o3); + EXPECT_FALSE(bool(*o2)); + EXPECT_FALSE(bool(*o3)); + } + + { + decltype(o) o1; + decltype(o) o2 = std::move(o1); + EXPECT_FALSE(o1); + EXPECT_FALSE(o2); + + o2 = std::move(o1); + EXPECT_FALSE(o1); + EXPECT_FALSE(o2); + + decltype(o) o3{kInplace, new int(20)}; + o3 = std::move(o1); + EXPECT_FALSE(o1); + EXPECT_FALSE(o3); + } +} + +TEST(Optional, Value) { + auto o = makeOptional(1); + EXPECT_EQ(1, o.value()); + EXPECT_EQ(1, o.valueOr(2)); + + o = kNullopt; + EXPECT_EQ(2, o.valueOr(2)); +} + +TEST(Optional, Clear) { + auto o = makeOptional(1); + o.clear(); + EXPECT_FALSE(o); + + o.clear(); + EXPECT_FALSE(o); +} + +TEST(Optional, Emplace) { + auto o = makeOptional(std::vector{1, 2, 3, 4}); + o.emplace(3, 1); + EXPECT_TRUE(o); + EXPECT_EQ((std::vector{1, 1, 1}), *o); + EXPECT_EQ(3U, o->capacity()); + + o.clear(); + o.emplace({1, 2}); + EXPECT_TRUE(o); + EXPECT_EQ((std::vector{1, 2}), *o); + EXPECT_EQ(2U, o->capacity()); +} + +TEST(Optional, Reset) { + auto o = makeOptional(std::vector{1, 2, 3, 4}); + o.reset(std::vector{4, 3}); + EXPECT_TRUE(o); + EXPECT_EQ((std::vector{4, 3}), *o); + EXPECT_EQ(2U, o->capacity()); + + o.clear(); + o.reset(std::vector{1}); + EXPECT_EQ((std::vector{1}), *o); + EXPECT_EQ(1U, o->capacity()); +} + +TEST(Optional, CompareEqual) { + EXPECT_TRUE(makeOptional(1) == makeOptional(1)); + EXPECT_TRUE(makeOptional(1) == 1); + EXPECT_TRUE(1 == makeOptional(1)); + EXPECT_FALSE(makeOptional(1) == makeOptional(2)); + EXPECT_FALSE(makeOptional(2) == 1); + EXPECT_FALSE(2 == makeOptional(1)); + EXPECT_TRUE(makeOptional(1) != makeOptional(2)); + EXPECT_TRUE(makeOptional(1) != 2); + EXPECT_TRUE(1 != makeOptional(2)); + + EXPECT_FALSE(makeOptional(1) == kNullopt); + EXPECT_FALSE(makeOptional(1) == Optional()); + EXPECT_FALSE(kNullopt == makeOptional(1)); + EXPECT_FALSE(Optional() == makeOptional(1)); + EXPECT_TRUE(makeOptional(1) != kNullopt); + EXPECT_TRUE(makeOptional(1) != Optional()); + EXPECT_TRUE(kNullopt != makeOptional(1)); + EXPECT_TRUE(Optional() != makeOptional(1)); + + EXPECT_TRUE(kNullopt == Optional()); + EXPECT_TRUE(kNullopt == Optional()); + EXPECT_FALSE(kNullopt != Optional()); + EXPECT_FALSE(kNullopt != Optional()); + EXPECT_TRUE(Optional() == Optional()); + EXPECT_FALSE(Optional() != Optional()); +} + +TEST(Optional, CompareLess) { + EXPECT_TRUE(makeOptional(1) < makeOptional(2)); + EXPECT_TRUE(1 < makeOptional(2)); + EXPECT_TRUE(makeOptional(1) < 2); + + EXPECT_FALSE(makeOptional(1) < makeOptional(1)); + EXPECT_FALSE(1 < makeOptional(1)); + EXPECT_FALSE(makeOptional(1) < 1); + EXPECT_FALSE(makeOptional(2) < makeOptional(1)); + EXPECT_FALSE(2 < makeOptional(1)); + EXPECT_FALSE(makeOptional(2) < 1); + + EXPECT_TRUE(kNullopt < makeOptional(2)); + EXPECT_TRUE(Optional() < makeOptional(2)); + EXPECT_TRUE(Optional() < 2); + EXPECT_FALSE(makeOptional(2) < kNullopt); + EXPECT_FALSE(makeOptional(2) < Optional()); + EXPECT_FALSE(2 < Optional()); + + EXPECT_FALSE(kNullopt < Optional()); + EXPECT_FALSE(Optional() < kNullopt); +} + +TEST(Optional, Destruction) { + // create a reference counting class to check if we delete everything + // we've created + struct Track { + Track(int& val) : mVal(val) { ++mVal.get(); } + Track(std::initializer_list vals) : mVal(**vals.begin()) { + ++mVal.get(); + } + Track(const Track& other) : mVal(other.mVal) { ++mVal.get(); } + Track(Track&& other) : mVal(other.mVal) { ++mVal.get(); } + Track& operator=(const Track& other) { + --mVal.get(); + mVal = other.mVal; + ++mVal.get(); + return *this; + } + Track& operator=(Track&& other) { + --mVal.get(); + mVal = other.mVal; + ++mVal.get(); + return *this; + } + + ~Track() { --mVal.get(); } + + std::reference_wrapper mVal; + }; + + int counter = 0; + { + auto o = makeOptional(Track(counter)); + EXPECT_EQ(1, counter); + } + EXPECT_EQ(0, counter); + + { + auto o = makeOptional(Track(counter)); + EXPECT_EQ(1, counter); + o.clear(); + EXPECT_EQ(0, counter); + } + EXPECT_EQ(0, counter); + + { + auto o = makeOptional(Track(counter)); + EXPECT_EQ(1, counter); + int counter2 = 0; + o.emplace(counter2); + EXPECT_EQ(0, counter); + EXPECT_EQ(1, counter2); + o = Track(counter); + EXPECT_EQ(1, counter); + EXPECT_EQ(0, counter2); + + auto o2 = o; + EXPECT_EQ(2, counter); + EXPECT_EQ(0, counter2); + } + EXPECT_EQ(0, counter); + + { + auto o = makeOptional(Track(counter)); + auto o2 = std::move(o); + EXPECT_EQ(2, counter); + o = o2; + EXPECT_EQ(2, counter); + } + EXPECT_EQ(0, counter); + + int counter2 = 0; + { + Optional o; + o.emplace(counter); + EXPECT_EQ(1, counter); + + o.emplace(counter2); + EXPECT_EQ(0, counter); + EXPECT_EQ(1, counter2); + } + EXPECT_EQ(0, counter); + EXPECT_EQ(0, counter2); + + { + Optional o; + o.emplace({&counter}); + EXPECT_EQ(1, counter); + + counter2 = 0; + o.emplace({&counter2}); + EXPECT_EQ(0, counter); + EXPECT_EQ(1, counter2); + } + EXPECT_EQ(0, counter); + EXPECT_EQ(0, counter2); +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/test/string_utils_test.cpp b/src/base/test/string_utils_test.cpp new file mode 100644 index 0000000..209da54 --- /dev/null +++ b/src/base/test/string_utils_test.cpp @@ -0,0 +1,110 @@ +// 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/base/string_utils.h" + +#include + +#include +#include +#include + +namespace astc_codec { +namespace base { + +TEST(StringUtils, Split) { + std::vector results; + + auto testFunc = [&results](std::string&& s) { + results.push_back(std::move(s)); + }; + + Split("", "abc", testFunc); + EXPECT_EQ(results.size(), 1); + + Split("abc", "", testFunc); + EXPECT_EQ(results.size(), 1); + + results.clear(); + Split("abc", "a", testFunc); + EXPECT_EQ(results.size(), 2); + EXPECT_EQ(results[0], ""); + EXPECT_EQ(results[1], "bc"); + + results.clear(); + Split("aaa", "a", testFunc); + EXPECT_EQ(4, results.size()); + EXPECT_EQ("", results[0]); + EXPECT_EQ("", results[1]); + EXPECT_EQ("", results[2]); + EXPECT_EQ("", results[3]); + + results.clear(); + Split("1a2a3a4", "a", testFunc); + EXPECT_EQ(4, results.size()); + EXPECT_EQ("1", results[0]); + EXPECT_EQ("2", results[1]); + EXPECT_EQ("3", results[2]); + EXPECT_EQ("4", results[3]); + + results.clear(); + Split("1a2aa3a4", "a", testFunc); + EXPECT_EQ(5, results.size()); + EXPECT_EQ("1", results[0]); + EXPECT_EQ("2", results[1]); + EXPECT_EQ("", results[2]); + EXPECT_EQ("3", results[3]); + EXPECT_EQ("4", results[4]); + + results.clear(); + Split("The quick brown fox jumped over the lazy dog", + " ", testFunc); + EXPECT_EQ(9, results.size()); + EXPECT_EQ("The", results[0]); + EXPECT_EQ("quick", results[1]); + EXPECT_EQ("brown", results[2]); + EXPECT_EQ("fox", results[3]); + EXPECT_EQ("jumped", results[4]); + EXPECT_EQ("over", results[5]); + EXPECT_EQ("the", results[6]); + EXPECT_EQ("lazy", results[7]); + EXPECT_EQ("dog", results[8]); + + results.clear(); + Split("a; b; c; d", "; ", testFunc); + EXPECT_EQ(4, results.size()); + EXPECT_EQ("a", results[0]); + EXPECT_EQ("b", results[1]); + EXPECT_EQ("c", results[2]); + EXPECT_EQ("d", results[3]); +} + +TEST(StringUtils, ParseInt32) { + EXPECT_EQ(ParseInt32("0", -1), 0); + EXPECT_EQ(ParseInt32("100", -1), 100); + EXPECT_EQ(ParseInt32("-100", -1), -100); + + EXPECT_EQ(ParseInt32("", -1), -1); + EXPECT_EQ(ParseInt32("a", -1), -1); + EXPECT_EQ(ParseInt32("10x1", -1), 10); + + EXPECT_EQ(ParseInt32("2147483647", -1), 2147483647); + EXPECT_EQ(ParseInt32("2147483648", -1), 2147483647); + + EXPECT_EQ(ParseInt32("-2147483648", -1), -2147483648); + EXPECT_EQ(ParseInt32("-2147483649", -1), -2147483648); +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/test/type_traits_test.cpp b/src/base/test/type_traits_test.cpp new file mode 100644 index 0000000..b858c01 --- /dev/null +++ b/src/base/test/type_traits_test.cpp @@ -0,0 +1,128 @@ +// 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/base/type_traits.h" + +#include + +#include +#include +#include +#include + +namespace astc_codec { +namespace base { + +TEST(TypeTraits, IsCallable) { + class C; + C* c = nullptr; + + auto lambda = [c](bool) -> C* { return nullptr; }; + + static_assert(is_callable_as::value, "simple function"); + static_assert(is_callable_as::value, + "function reference"); + static_assert(is_callable_as::value, "function pointer"); + static_assert(is_callable_as::value, + "function with arguments and return type"); + static_assert(is_callable_as::value, "lambda"); + static_assert(is_callable_as, bool(int)>::value, + "std::function"); + + static_assert(!is_callable_as::value, + "int should not be callable"); + static_assert(!is_callable_as::value, "incomplete type"); + static_assert(!is_callable_as::value, + "different arguments"); + static_assert(!is_callable_as::value, + "different return types"); + static_assert(!is_callable_as::value, + "slightly different return types"); + static_assert(!is_callable_as::value, + "more arguments"); + static_assert(!is_callable_as::value, + "less arguments"); + + static_assert(!is_callable_as::value, + "bad required signature"); + + static_assert(is_callable_with_args::value, + "simple function"); + static_assert(is_callable_with_args::value, + "function reference"); + static_assert(is_callable_with_args::value, + "function pointer"); + static_assert(is_callable_with_args::value, + "function with arguments and return type"); + static_assert(is_callable_with_args::value, + "lambda"); + static_assert( + is_callable_with_args, bool(int)>::value, + "std::function"); + + static_assert(!is_callable_with_args::value, + "int should not be callable"); + static_assert(!is_callable_with_args::value, "incomplete type"); + static_assert(!is_callable_with_args::value, + "different arguments"); + static_assert(is_callable_with_args::value, + "different return types are ignored"); + static_assert(is_callable_with_args::value, + "slightly different return types are ignored"); + static_assert(!is_callable_with_args::value, + "more arguments"); + static_assert(!is_callable_with_args::value, + "less arguments"); + + static_assert(!is_callable_with_args::value, + "bad required signature"); +} + +TEST(TypeTraits, IsTemplateInstantiation) { + static_assert(!is_template_instantiation_of::value, + "int is not an instance of vector"); + static_assert(!is_template_instantiation_of>, + std::vector>::value, + "list is not an instance of vector"); + + static_assert( + is_template_instantiation_of, std::vector>::value, + "std::vector is an instance of vector"); + static_assert( + is_template_instantiation_of>>, + std::vector>::value, + "nested std::vector<> is an instance of vector"); +} + +TEST(TypeTraits, IsRange) { + static_assert(is_range>::value, + "vector<> should be detected as a range"); + static_assert(is_range>>::value, + "const list<> should be detected as a range"); + static_assert(is_range, 10>>::value, + "array<> should be detected as a range"); + char arr[100]; + static_assert(is_range::value, + "C array should be detected as a range"); + static_assert(is_range::value, + "String literal should be detected as a range"); + + static_assert(!is_range::value, "int shouldn't be a range"); + static_assert(!is_range::value, "int* shouldn't be a range"); + static_assert(!is_range::value, + "even const int* shouldn't be a range"); +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/test/uint128_test.cpp b/src/base/test/uint128_test.cpp new file mode 100644 index 0000000..0a52244 --- /dev/null +++ b/src/base/test/uint128_test.cpp @@ -0,0 +1,140 @@ +// 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/base/uint128.h" + +#include + +namespace astc_codec { +namespace base { + +TEST(UInt128, Equality) { + const UInt128 zero(0); + const UInt128 max64(~0ULL); + + EXPECT_EQ(zero, zero); + EXPECT_NE(zero, max64); + EXPECT_EQ(zero, UInt128(0)); + EXPECT_NE(zero, UInt128(1)); + EXPECT_EQ(max64, max64); +} + +TEST(UInt128, Shifting) { + const UInt128 max64(~0ULL); + const UInt128 upper64(~0ULL, 0); + EXPECT_EQ(upper64.HighBits(), ~0ULL); + EXPECT_EQ(upper64.LowBits(), 0); + + EXPECT_EQ(upper64 >> 64, max64); + + EXPECT_EQ(UInt128(1) << 1, UInt128(2)); + EXPECT_EQ(UInt128(0) << 0, UInt128(0)); + EXPECT_EQ(max64 << 0, max64); + EXPECT_EQ(max64 >> 0, max64); + EXPECT_EQ(upper64 << 0, upper64); + EXPECT_EQ(upper64 >> 0, upper64); + + { + const UInt128 bit63 = UInt128(1ULL << 62) << 1; + EXPECT_EQ(bit63.LowBits(), 1ULL << 63); + EXPECT_EQ(bit63.HighBits(), 0); + } + + { + const UInt128 bit64 = UInt128(1ULL << 63) << 1; + EXPECT_EQ(bit64.LowBits(), 0); + EXPECT_EQ(bit64.HighBits(), 1); + EXPECT_EQ(bit64 >> 1, UInt128(1ULL << 63)); + } + + { + const UInt128 overshift = max64 << 128; + EXPECT_EQ(overshift.HighBits(), 0); + EXPECT_EQ(overshift.LowBits(), 0); + } + + { + const UInt128 overlap = upper64 >> 32; + EXPECT_EQ(overlap.HighBits(), 0x00000000FFFFFFFF); + EXPECT_EQ(overlap.LowBits(), 0xFFFFFFFF00000000); + } + + { + const UInt128 overlap = max64 << 32; + EXPECT_EQ(overlap.HighBits(), 0x00000000FFFFFFFF); + EXPECT_EQ(overlap.LowBits(), 0xFFFFFFFF00000000); + } +} + +TEST(UInt128, LargeShift) { + const UInt128 base(0xFF); + EXPECT_EQ(base << 64, UInt128(0xFFULL, 0)); + EXPECT_EQ(base << 72, UInt128(0xFF00ULL, 0)); + EXPECT_EQ(base << 80, UInt128(0xFF0000ULL, 0)); + EXPECT_EQ(base << 88, UInt128(0xFF000000ULL, 0)); + EXPECT_EQ(base << 96, UInt128(0xFF00000000ULL, 0)); + EXPECT_EQ(base << 104, UInt128(0xFF0000000000ULL, 0)); + EXPECT_EQ(base << 112, UInt128(0xFF000000000000ULL, 0)); + EXPECT_EQ(base << 120, UInt128(0xFF00000000000000ULL, 0)); + + const UInt128 upper(0xFF00000000000000ULL, 0); + EXPECT_EQ(upper >> 64, UInt128(0, 0xFF00000000000000ULL)); + EXPECT_EQ(upper >> 72, UInt128(0, 0xFF000000000000ULL)); + EXPECT_EQ(upper >> 80, UInt128(0, 0xFF0000000000ULL)); + EXPECT_EQ(upper >> 88, UInt128(0, 0xFF00000000ULL)); + EXPECT_EQ(upper >> 96, UInt128(0, 0xFF000000ULL)); + EXPECT_EQ(upper >> 104, UInt128(0, 0xFF0000ULL)); + EXPECT_EQ(upper >> 112, UInt128(0, 0xFF00ULL)); + EXPECT_EQ(upper >> 120, UInt128(0, 0xFFULL)); +} + +TEST(UInt128, BooleanOperators) { + const UInt128 allOnes(~0ULL, ~0ULL); + EXPECT_EQ(allOnes.HighBits(), ~0ULL); + EXPECT_EQ(allOnes.LowBits(), ~0ULL); + + EXPECT_EQ(~allOnes, UInt128(0)); + EXPECT_EQ(~UInt128(0), allOnes); + + EXPECT_EQ(UInt128(0xFFFF00) & UInt128(0x00FFFF), UInt128(0x00FF00)); + EXPECT_EQ(UInt128(0xFFFF00) | UInt128(0x00FFFF), UInt128(0xFFFFFF)); + EXPECT_EQ(UInt128(0xFFFF00) ^ UInt128(0x00FFFF), UInt128(0xFF00FF)); +} + +TEST(UInt128, Addition) { + const UInt128 bit63(1ULL << 63); + + EXPECT_EQ(UInt128(1) + 1, UInt128(2)); + EXPECT_EQ(bit63 + bit63, UInt128(1) << 64); + + const UInt128 carryUp = UInt128(~0ULL) + 1; + EXPECT_EQ(carryUp.HighBits(), 1); + EXPECT_EQ(carryUp.LowBits(), 0); + + const UInt128 allOnes(~0ULL, ~0ULL); + EXPECT_EQ(allOnes + 1, UInt128(0)); +} + +TEST(UInt128, Subtraction) { + const UInt128 bit64 = UInt128(1) << 64; + EXPECT_EQ(bit64 - 1, UInt128(~0ULL)); + + EXPECT_EQ(UInt128(1) - 1, UInt128(0)); + + const UInt128 allOnes(~0ULL, ~0ULL); + EXPECT_EQ(UInt128(0) - 1, allOnes); +} + +} // namespace base +} // namespace astc_codec diff --git a/src/base/type_traits.h b/src/base/type_traits.h new file mode 100644 index 0000000..917125d --- /dev/null +++ b/src/base/type_traits.h @@ -0,0 +1,172 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_TYPE_TRAITS_H_ +#define ASTC_CODEC_BASE_TYPE_TRAITS_H_ + +#include +#include + +namespace astc_codec { +namespace base { + +namespace details { + +// a simple helper class for SFINAE below. +template +struct dummy { + using type = X; +}; + +} // namespace details + +// add some convenience shortcuts for an overly complex std::enable_if syntax + +// Use 'enable_if' instead of +// 'typename std::enable_if::type' +template +using enable_if = typename std::enable_if::type; + +// Use 'enable_if_c' instead of +// 'typename std::enable_if::type' +template +using enable_if_c = typename std::enable_if::type; + +// Use 'enable_if_convertible' instead of +// 'typename std::enable_if::value, Type>::type' +template +using enable_if_convertible = enable_if>; + +// ----------------------------------------------------------------------------- +// A predicate for checking if some object is callable with a specific +// signature. Examples: +// +// is_callable_as::value == false. +// is_callable_as::value == false. +// is_callable_as::value == true +// +template +struct is_callable_as : std::false_type {}; + +// This specialization is SFINAE-d out if template arguments can't be combined +// into a call expression F(), or if the result of that call is not |R| +template +struct is_callable_as()( + std::declval()...))>::type, + R>::value>::type> : std::true_type {}; + +// +// A similar predicate to only check arguments of the function call and ignore +// the specified return type +// +// is_callable_as::value == true +// is_callable_as::value == false +// is_callable_with_args::value == true +// +template +struct is_callable_with_args : std::false_type {}; + +template +struct is_callable_with_args< + F, R(Args...), + typename std::enable_if< + !std::is_same()(std::declval()...))>::type, + F>::value>::type> : std::true_type {}; + +// ----------------------------------------------------------------------------- +// Check if a type |T| is any instantiation of a template |U|. Examples: +// +// is_template_instantiation_of::value == false +// is_template_instantiation_of< +// std::list>, std::vector>::value == false +// is_template_instantiation_of, std::vector>::value == true +// is_template_instantiation_of< +// std::vector>, std::vector>::value == true +// +template class U> +struct is_template_instantiation_of : std::false_type {}; + +template class U, class... Args> +struct is_template_instantiation_of, U> : std::true_type {}; +// ----------------------------------------------------------------------------- + +// +// is_range - check if type |T| is a range-like type. +// +// It makes sure that expressions std::begin(t) and std::end(t) are well-formed +// and those return the same type. +// +// Note: with expression SFINAE from C++14 is_range_helper<> could be renamed to +// is_range<> with no extra code. C++11 needs an extra level of enable_if<> +// to make it work when the type isn't a range. +// + +namespace details { + +template +using is_range_helper = std::is_same< + decltype(std::begin( + std::declval::type>())), + decltype( + std::end(std::declval::type>()))>; + +} // namespace details + +template +struct is_range : std::false_type {}; + +template +struct is_range< + T, typename std::enable_if::value>::type> + : std::true_type {}; + +//////////////////////////////////////////////////////////////////////////////// +// +// A class to incapsulate integer sequence 0, 1, ..., +// Seq +// Useful to pass function parameters in an array/tuple to call it later. +// + +template +struct Seq {}; + +// A 'maker' class to construct Seq given only +// value. +// MakeSeq works this way, e.g. +// +// MakeSeq<2> inherits MakeSeq<2 - 1, 2 - 1> == MakeSeq<1, 1> +// MakeSeq<1, 1> : MakeSeq<1 - 1, 1 - 1, 1> == MakeSeq<0, 0, 1> +// MakeSeq<0, 0, 1> == MakeSeq<0, S...> and defines |type| = Seq<0, 1> + +template +struct MakeSeq : MakeSeq {}; + +template +struct MakeSeq<0, S...> { + using type = Seq; +}; + +// +// MakeSeqT alias to quickly create Seq<...>: +// MakeSeqT<3> == Seq<0, 1, 2> +template +using MakeSeqT = typename MakeSeq::type; + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_TYPE_TRAITS_H_ diff --git a/src/base/uint128.h b/src/base/uint128.h new file mode 100644 index 0000000..481e4ea --- /dev/null +++ b/src/base/uint128.h @@ -0,0 +1,175 @@ +// 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. + +#ifndef ASTC_CODEC_BASE_UINT128_H_ +#define ASTC_CODEC_BASE_UINT128_H_ + +#include +#include + +namespace astc_codec { +namespace base { + +class UInt128 { + public: + UInt128() = default; + UInt128(uint64_t low) : low_(low) { } + UInt128(uint64_t high, uint64_t low) : low_(low), high_(high) { } + UInt128(const UInt128& other) : low_(other.low_), high_(other.high_) { } + + uint64_t LowBits() const { return low_; } + uint64_t HighBits() const { return high_; } + + // Allow explicit casts to uint64_t. + explicit operator uint64_t() const { return low_; } + + // Copy operators. + UInt128& operator=(const UInt128& other) { + high_ = other.high_; + low_ = other.low_; + return *this; + } + + // Equality operators. + bool operator==(const UInt128& other) const { + return high_ == other.high_ && low_ == other.low_; + } + + bool operator!=(const UInt128& other) const { + return high_ != other.high_ || low_ != other.low_; + } + + // Shifting. + UInt128& operator<<=(int shift) { + high_ = shift >= 64 ? (shift >= 128 ? 0 : low_ << (shift - 64)) + : high_ << shift; + + if (shift > 0 && shift < 64) { + const uint64_t overlappingBits = low_ >> (64 - shift); + high_ |= overlappingBits; + } + + low_ = shift >= 64 ? 0 : low_ << shift; + return *this; + } + + UInt128 operator<<(int shift) const { + UInt128 result = *this; + result <<= shift; + return result; + } + + UInt128& operator>>=(int shift) { + low_ = shift >= 64 ? (shift >= 128 ? 0 : high_ >> (shift - 64)) + : low_ >> shift; + + if (shift > 0 && shift < 64) { + const uint64_t overlappingBits = high_ << (64 - shift); + low_ |= overlappingBits; + } + + high_ = shift >= 64 ? 0 : high_ >> shift; + + return *this; + } + + UInt128 operator>>(int shift) const { + UInt128 result = *this; + result >>= shift; + return result; + } + + // Binary operations. + UInt128& operator|=(const UInt128& other) { + high_ |= other.high_; + low_ |= other.low_; + return *this; + } + + UInt128 operator|(const UInt128& other) const { + UInt128 result = *this; + result |= other; + return result; + } + + UInt128& operator&=(const UInt128& other) { + high_ &= other.high_; + low_ &= other.low_; + return *this; + } + + UInt128 operator&(const UInt128& other) const { + UInt128 result = *this; + result &= other; + return result; + } + + UInt128& operator^=(const UInt128& other) { + high_ ^= other.high_; + low_ ^= other.low_; + return *this; + } + + UInt128 operator^(const UInt128& other) const { + UInt128 result = *this; + result ^= other; + return result; + } + + UInt128 operator~() const { + UInt128 result = *this; + result.high_ = ~high_; + result.low_ = ~low_; + return result; + } + + // Addition/subtraction. + UInt128& operator+=(const UInt128& other) { + const uint64_t carry = + (((low_ & other.low_) & 1) + (low_ >> 1) + (other.low_ >> 1)) >> 63; + high_ += other.high_ + carry; + low_ += other.low_; + return *this; + } + + UInt128 operator+(const UInt128& other) const { + UInt128 result = *this; + result += other; + return result; + } + + UInt128& operator-=(const UInt128& other) { + low_ -= other.low_; + const uint64_t carry = + (((low_ & other.low_) & 1) + (low_ >> 1) + (other.low_ >> 1)) >> 63; + high_ -= other.high_ + carry; + return *this; + } + + UInt128 operator-(const UInt128& other) const { + UInt128 result = *this; + result -= other; + return result; + } + + private: + // TODO(google): Different order for little endian. + uint64_t low_ = 0; + uint64_t high_ = 0; +}; + +} // namespace base +} // namespace astc_codec + +#endif // ASTC_CODEC_BASE_UINT128_H_ diff --git a/src/decoder/BUILD.bazel b/src/decoder/BUILD.bazel new file mode 100644 index 0000000..f2fded5 --- /dev/null +++ b/src/decoder/BUILD.bazel @@ -0,0 +1,238 @@ +# 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. + +cc_library( + name = "footprint", + srcs = ["footprint.cc"], + hdrs = ["footprint.h"], + deps = [ + "//:api", + "//src/base", + ], +) + +cc_library( + name = "astc_utils", + srcs = [ + "astc_file.cc", + "endpoint_codec.cc", + "integer_sequence_codec.cc", + "intermediate_astc_block.cc", + "logical_astc_block.cc", + "partition.cc", + "physical_astc_block.cc", + "quantization.cc", + "weight_infill.cc", + ], + hdrs = [ + "astc_file.h", + "endpoint_codec.h", + "integer_sequence_codec.h", + "intermediate_astc_block.h", + "logical_astc_block.h", + "partition.h", + "physical_astc_block.h", + "quantization.h", + "types.h", + "weight_infill.h", + ], + deps = [ + ":footprint", + "//src/base", + ], +) + +cc_library( + name = "codec", + srcs = ["codec.cc"], + hdrs = ["codec.h"], + deps = [ + ":astc_utils", + ":footprint", + "//src/base", + ], + visibility = ["//:__pkg__"], +) + +cc_binary( + name = "astc_inspector_cli", + srcs = ["tools/astc_inspector_cli.cc"], + deps = [ + ":astc_utils", + "//src/base", + ], +) + +################################################################################ +## +## Testing +## +################################################################################ + +cc_library( + name = "test", + hdrs = ["test/image_utils.h"], + deps = [ + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "physical_astc_block_test", + size = "small", + srcs = ["test/physical_astc_block_test.cc"], + deps = [ + ":astc_utils", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "partition_test", + size = "small", + srcs = ["test/partition_test.cc"], + deps = [ + ":astc_utils", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "integer_sequence_codec_test", + size = "small", + srcs = ["test/integer_sequence_codec_test.cc"], + deps = [ + ":astc_utils", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "intermediate_astc_block_test", + size = "small", + srcs = ["test/intermediate_astc_block_test.cc"], + data = glob([ + "testdata/checkered_*.astc", + ]), + deps = [ + ":astc_utils", + ":test", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "quantization_test", + size = "medium", + srcs = ["test/quantization_test.cc"], + deps = [ + ":astc_utils", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "weight_infill_test", + size = "small", + srcs = ["test/weight_infill_test.cc"], + deps = [ + ":astc_utils", + ":footprint", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "endpoint_codec_test", + size = "small", + srcs = ["test/endpoint_codec_test.cc"], + data = [ + ":testdata/checkerboard.astc", + ], + deps = [ + ":astc_utils", + ":test", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "logical_astc_block_test", + size = "large", + srcs = ["test/logical_astc_block_test.cc"], + data = glob([ + "testdata/atlas_small_*.astc", + "testdata/atlas_small_*.bmp", + "testdata/footprint_*.astc", + "testdata/footprint_*.bmp", + "testdata/rgb_*.astc", + "testdata/rgb_*.bmp", + ]), + deps = [ + ":test", + ":astc_utils", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "codec_test", + size = "large", + srcs = ["test/codec_test.cc"], + data = glob([ + "testdata/atlas_small_*.astc", + "testdata/atlas_small_*.bmp", + ]), + deps = [ + ":test", + ":codec", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "footprint_test", + size = "small", + srcs = ["test/footprint_test.cc"], + deps = [ + ":footprint", + "@gtest//:gtest_main", + ], +) + +cc_test( + name = "astc_fuzzer", + srcs = ["test/astc_fuzzer.cc"], + copts = select({ + # Clang-only flags. TODO: Find a better way to detect GCC/clang. + "@bazel_tools//src/conditions:darwin_x86_64": [ + "-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp", + "-fsanitize-coverage=bb", + ], + "@bazel_tools//src/conditions:darwin": [ + "-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp", + "-fsanitize-coverage=bb", + ], + # GCC-only flags. + "//conditions:default": [ + "-finstrument-functions" + ], + }), + deps = [ + ":codec", + "@honggfuzz//:honggfuzz", + "@benchmark//:benchmark", + ], + linkstatic = 1, +) diff --git a/src/decoder/astc_file.cc b/src/decoder/astc_file.cc new file mode 100644 index 0000000..4770064 --- /dev/null +++ b/src/decoder/astc_file.cc @@ -0,0 +1,185 @@ +// 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/astc_file.h" + +#include +#include +#include +#include + +namespace astc_codec { + +namespace { +static constexpr size_t kASTCHeaderSize = 16; + +// Reads a value of size T from the buffer at the current offset, then +// increments the offset. +template +inline T ReadVal(const char* file_data, size_t& offset) { + T x; + memcpy(&x, &file_data[offset], sizeof(T)); + offset += sizeof(T); + return x; +} +} // namespace + +ASTCFile::ASTCFile(Header&& header, std::string&& blocks) + : header_(std::move(header)), blocks_(std::move(blocks)) {} + +std::unique_ptr ASTCFile::LoadFromMemory(const char* data, + size_t length, + std::string* error) { + if (length < kASTCHeaderSize) { + *error = "Incomplete header."; + return nullptr; + } + + base::Optional
header_opt = ParseHeader(data); + if (!header_opt) { + *error = "Invalid ASTC header."; + return nullptr; + } + + Header header = header_opt.value(); + + if (header.block_width_ == 0 || header.block_height_ == 0) { + *error = "Invalid block size."; + return nullptr; + } + + std::string blocks(data + kASTCHeaderSize, data + length); + + // Check that this file has the expected number of blocks. + const size_t expected_block_count = + ((header.width_ + header.block_width_ - 1) / header.block_width_) * + ((header.height_ + header.block_height_ - 1) / header.block_height_); + + if (blocks.size() % PhysicalASTCBlock::kSizeInBytes != 0 || + blocks.size() / PhysicalASTCBlock::kSizeInBytes != expected_block_count) { + std::stringstream ss; + ss << "Unexpected file length " << blocks.size() << " expected " + << kASTCHeaderSize + + expected_block_count * PhysicalASTCBlock::kSizeInBytes + << " bytes."; + *error = ss.str(); + return nullptr; + } + + return std::unique_ptr( + new ASTCFile(std::move(header), std::move(blocks))); +} + +std::unique_ptr ASTCFile::LoadFile(const std::string& path, + std::string* error) { + std::ifstream is(path, std::ios::binary); + if (!is) { + *error = "File not found: " + path; + return nullptr; + } + + char header_data[kASTCHeaderSize] = {}; + if (!is.read(header_data, kASTCHeaderSize)) { + *error = "Failed to load ASTC header."; + return nullptr; + } + + base::Optional
header_opt = ParseHeader(header_data); + if (!header_opt) { + *error = "Invalid ASTC header."; + return nullptr; + } + + Header header = header_opt.value(); + + std::string blocks; + { + std::ostringstream ss; + ss << is.rdbuf(); + blocks = ss.str(); + } + + // Check that this file has the expected number of blocks. + const size_t expected_block_count = + ((header.width_ + header.block_width_ - 1) / header.block_width_) * + ((header.height_ + header.block_height_ - 1) / header.block_height_); + + if (blocks.size() % PhysicalASTCBlock::kSizeInBytes != 0 || + blocks.size() / PhysicalASTCBlock::kSizeInBytes != expected_block_count) { + std::stringstream ss; + ss << "Unexpected file length " << blocks.size() << " expected " + << kASTCHeaderSize + + expected_block_count * PhysicalASTCBlock::kSizeInBytes + << " bytes."; + *error = ss.str(); + return nullptr; + } + + return std::unique_ptr( + new ASTCFile(std::move(header), std::move(blocks))); +} + +base::Optional ASTCFile::GetFootprint() const { + return Footprint::FromDimensions(header_.block_width_, header_.block_height_); +} + +std::string ASTCFile::GetFootprintString() const { + std::stringstream footprint; + footprint << header_.block_width_ << "x" << header_.block_height_; + return footprint.str(); +} + +const std::string& ASTCFile::GetRawBlockData() const { + return blocks_; +} + +PhysicalASTCBlock ASTCFile::GetBlock(size_t block_idx) const { + const size_t sz = PhysicalASTCBlock::kSizeInBytes; + const size_t offset = PhysicalASTCBlock::kSizeInBytes * block_idx; + assert(offset <= blocks_.size() - sz); + return PhysicalASTCBlock(blocks_.substr(offset, sz)); +} + +base::Optional ASTCFile::ParseHeader(const char* header) { + size_t offset = 0; + // TODO(google): Handle endianness. + const uint32_t magic = ReadVal(header, offset); + if (magic != 0x5CA1AB13) { + return {}; + } + + const uint32_t block_width = ReadVal(header, offset); + const uint32_t block_height = ReadVal(header, offset); + const uint32_t block_depth = ReadVal(header, offset); + + uint32_t width = 0; + width |= ReadVal(header, offset); + width |= ReadVal(header, offset) << 8; + width |= ReadVal(header, offset) << 16; + + uint32_t height = 0; + height |= ReadVal(header, offset); + height |= ReadVal(header, offset) << 8; + height |= ReadVal(header, offset) << 16; + + uint32_t depth = 0; + depth |= ReadVal(header, offset); + depth |= ReadVal(header, offset) << 8; + depth |= ReadVal(header, offset) << 16; + assert(offset == kASTCHeaderSize); + + return Header(width, height, depth, block_width, block_height, block_depth); +} + +} // namespace astc_codec diff --git a/src/decoder/astc_file.h b/src/decoder/astc_file.h new file mode 100644 index 0000000..c31c2ba --- /dev/null +++ b/src/decoder/astc_file.h @@ -0,0 +1,97 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_ASTC_FILE_H_ +#define ASTC_CODEC_DECODER_ASTC_FILE_H_ + +#include "src/base/optional.h" +#include "src/decoder/footprint.h" +#include "src/decoder/physical_astc_block.h" + +#include +#include + +namespace astc_codec { + +// A thin wrapper around a .astc file on disk. This class simply reads the ASTC +// header, and stores the block data in memory. +class ASTCFile { + private: + struct Header { + Header(size_t width, size_t height, size_t depth, size_t block_width, + size_t block_height, size_t block_depth) + : width_(width), + height_(height), + depth_(depth), + block_width_(block_width), + block_height_(block_height), + block_depth_(block_depth) {} + + size_t width_; + size_t height_; + size_t depth_; + + size_t block_width_; + size_t block_height_; + size_t block_depth_; + }; + + ASTCFile(ASTCFile::Header&& header, std::string&& blocks); + + public: + // Load an ASTC file from memory. + // If loading failed, nullptr is returned and an error string is populated + // in the error parameter. + static std::unique_ptr LoadFromMemory(const char* data, + size_t length, + std::string* error); + + // Load an ASTC file from file. + // If loading failed, nullptr is returned and an error string is populated + // in the error parameter. + static std::unique_ptr LoadFile(const std::string& path, + std::string* error); + + // Returns the footprint for the file, if it is considered to be a valid + // footprint. + base::Optional GetFootprint() const; + + // Returns the string of the form "NxM" where N and M are the width and height + // of the block footprint, respectively. + std::string GetFootprintString() const; + + // Get the raw block data for the astc file. + const std::string& GetRawBlockData() const; + + // Returns the physical block at the associated block index. + PhysicalASTCBlock GetBlock(size_t block_idx) const; + + size_t GetWidth() const { return header_.width_; } + size_t GetHeight() const { return header_.height_; } + size_t GetDepth() const { return header_.depth_; } + + size_t NumBlocks() const { + return blocks_.size() / PhysicalASTCBlock::kSizeInBytes; + } + + private: + static base::Optional ParseHeader(const char* header); + + const Header header_; + const std::string blocks_; +}; + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_ASTC_FILE_H_ diff --git a/src/decoder/codec.cc b/src/decoder/codec.cc new file mode 100644 index 0000000..c0f8c07 --- /dev/null +++ b/src/decoder/codec.cc @@ -0,0 +1,132 @@ +// 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/codec.h" +#include "src/base/uint128.h" +#include "src/decoder/logical_astc_block.h" +#include "src/decoder/physical_astc_block.h" + +#include + +namespace astc_codec { + +namespace { +static constexpr size_t kBytesPerPixelUNORM8 = 4; +} + +bool DecompressToImage(const uint8_t* astc_data, size_t astc_data_size, + size_t width, size_t height, Footprint footprint, + uint8_t* out_buffer, size_t out_buffer_size, + size_t out_buffer_stride) { + const size_t block_width = footprint.Width(); + const size_t block_height = footprint.Height(); + assert(block_width != 0); + assert(block_height != 0); + + if (width == 0 || height == 0) { + return false; + } + + const size_t blocks_wide = (width + block_width - 1) / block_width; + assert(blocks_wide != 0); + + // Check that this buffer has the expected number of blocks. + const size_t expected_block_count = + ((width + block_width - 1) / block_width) * + ((height + block_height - 1) / block_height); + + if (astc_data_size % PhysicalASTCBlock::kSizeInBytes != 0 || + astc_data_size / PhysicalASTCBlock::kSizeInBytes != + expected_block_count) { + // TODO(google): Expose error? + return false; + } + + if (kBytesPerPixelUNORM8 * width > out_buffer_stride || + out_buffer_stride * height < out_buffer_size) { + // Output buffer too small. + return false; + } + + base::UInt128 block; + static_assert(sizeof(block) == PhysicalASTCBlock::kSizeInBytes, + "Block size mismatch"); + + for (size_t i = 0; i < astc_data_size; i += PhysicalASTCBlock::kSizeInBytes) { + const size_t block_index = i / PhysicalASTCBlock::kSizeInBytes; + const size_t block_x = block_index % blocks_wide; + const size_t block_y = block_index / blocks_wide; + memcpy(&block, astc_data + i, sizeof(block)); + + PhysicalASTCBlock physical_block(block); + auto lb = UnpackLogicalBlock(footprint, physical_block); + if (!lb) { + return false; + } + + LogicalASTCBlock logical_block = lb.value(); + + for (size_t y = 0; y < block_height; ++y) { + const size_t py = block_height * block_y + y; + uint8_t* out_row = out_buffer + py * out_buffer_stride; + + for (size_t x = 0; x < block_width; ++x) { + const size_t px = block_width * block_x + x; + + // Skip out of bounds. + if (px >= width || py >= height) { + continue; + } + + uint8_t* pixel = out_row + px * kBytesPerPixelUNORM8; + const RgbaColor decoded_color = logical_block.ColorAt(x, y); + for (size_t i = 0; i < kBytesPerPixelUNORM8; ++i) { + pixel[i] = static_cast(decoded_color[i]); + } + } + } + } + + return true; +} + +bool DecompressToImage(const ASTCFile& file, uint8_t* out_buffer, + size_t out_buffer_size, size_t out_buffer_stride) { + base::Optional footprint = file.GetFootprint(); + if (!footprint) { + return false; + } + + return DecompressToImage( + reinterpret_cast(file.GetRawBlockData().c_str()), + file.GetRawBlockData().size(), file.GetWidth(), file.GetHeight(), + footprint.value(), out_buffer, out_buffer_size, out_buffer_stride); +} + +bool ASTCDecompressToRGBA(const uint8_t* astc_data, size_t astc_data_size, + size_t width, size_t height, FootprintType footprint, + uint8_t* out_buffer, size_t out_buffer_size, + size_t out_buffer_stride) { + base::Optional footprint_opt = + Footprint::FromFootprintType(footprint); + if (!footprint_opt) { + return false; + } + + return DecompressToImage(astc_data, astc_data_size, width, height, + footprint_opt.value(), out_buffer, out_buffer_size, + out_buffer_stride); +} + +} // namespace astc_codec diff --git a/src/decoder/codec.h b/src/decoder/codec.h new file mode 100644 index 0000000..eed601a --- /dev/null +++ b/src/decoder/codec.h @@ -0,0 +1,41 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_CODEC_H_ +#define ASTC_CODEC_DECODER_CODEC_H_ + +#include "src/decoder/astc_file.h" +#include "src/decoder/footprint.h" + +#include + +namespace astc_codec { + +// Decompresses ASTC blocks to an image buffer. +// Returns true if the decompression succeeded and the out buffer has been +// filled. +bool DecompressToImage(const uint8_t* astc_data, size_t astc_data_size, + size_t width, size_t height, Footprint footprint, + uint8_t* out_buffer, size_t out_buffer_size, + size_t out_buffer_stride); + +// Decompresses an ASTC file to an image buffer. +// Returns true if the decompression succeeded and the out buffer has been +// filled. +bool DecompressToImage(const ASTCFile& file, uint8_t* out_buffer, + size_t out_buffer_size, size_t out_buffer_stride); + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_CODEC_H_ diff --git a/src/decoder/endpoint_codec.cc b/src/decoder/endpoint_codec.cc new file mode 100644 index 0000000..1513d15 --- /dev/null +++ b/src/decoder/endpoint_codec.cc @@ -0,0 +1,967 @@ +// 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/quantization.h" + +#include +#include +#include +#include + +namespace astc_codec { + +namespace { + +template +T Clamp(T value, T min, T max) { + return value < min ? min : (value > max ? max : value); +} + +// This is the 'blue_contract' function defined in Section C.2.14 of the ASTC +// specification. +template +void BlueContract(ArrayType* const cptr) { + ArrayType& c = *cptr; + c[0] = (c[0] + c[2]) >> 1; + c[1] = (c[1] + c[2]) >> 1; +} + +// Returns the inverse of values in BlueContract, subjected to the constraint +// that the new values are stored in the range [0, 255]. +template +ArrayType InvertBlueContract(const ArrayType& c) { + ArrayType result = c; + result[0] = Clamp(2 * c[0] - c[2], 0, 255); + result[1] = Clamp(2 * c[1] - c[2], 0, 255); + return result; +} + +// This is the 'bit_transfer_signed' function defined in Section C.2.14 of the +// ASTC specification. +void BitTransferSigned(int* const a, int* const b) { + *b >>= 1; + *b |= *a & 0x80; + *a >>= 1; + *a &= 0x3F; + if ((*a & 0x20) != 0) { + *a -= 0x40; + } +} + +// Takes two values, |a| in the range [-32, 31], and |b| in the range [0, 255], +// and returns the two values in [0, 255] that will reconstruct |a| and |b| when +// passed to the BitTransferSigned function. +void InvertBitTransferSigned(int* const a, int* const b) { + assert(*a >= -32); assert(*a < 32); + assert(*b >= 0); assert(*b < 256); + + if (*a < 0) { + *a += 0x40; + } + *a <<= 1; + *a |= (*b & 0x80); + *b <<= 1; + *b &= 0xff; +} + +RgbColor StripAlpha(const RgbaColor& c) { + return RgbColor {{ c[0], c[1], c[2] }}; +} + +template +void Quantize(ContainerType* const c, size_t max_value) { + for (auto& x : *c) { + x = QuantizeCEValueToRange(x, max_value); + } +} + +template +ArrayType QuantizeColor(const ArrayType& c, size_t max_value) { + ArrayType result = c; + Quantize(&result, max_value); + return result; +} + +template +void Unquantize(ContainerType* const c, size_t max_value) { + for (auto& x : *c) { + x = UnquantizeCEValueFromRange(x, max_value); + } +} + +template +ArrayType UnquantizeColor(const ArrayType& c, size_t max_value) { + ArrayType result = c; + Unquantize(&result, max_value); + return result; +} + +// Returns the average of the three RGB channels. +template +const int AverageRGB(const ContainerType& c) { + // Each channel can be in the range [0, 255], and we need to divide by three. + // However, we want to round the error properly. Both (x + 1) / 3 and + // (x + 2) / 3 are relatively imprecise when it comes to rounding, so instead + // we increase the precision by multiplying our numerator by some arbitrary + // number. Here, we choose 256 to get 8 additional bits and maintain + // performance since it turns into a shift rather than a multiply. Our + // denominator then becomes 3 * 256 = 768. + return (std::accumulate(c.begin(), c.begin() + 3, 0) * 256 + 384) / 768; +} + +// Returns the sum of squared differences between each element of |a| and |b|, +// which are assumed to contain the same number of elements. +template +const typename ContainerType::value_type SquaredError( + const ContainerType& a, const ContainerType& b, + size_t num_channels = std::tuple_size::value) { + using ValueTy = typename ContainerType::value_type; + static_assert(std::is_signed::value, + "Value type assumed to be signed to avoid branch below."); + ValueTy result = ValueTy(0); + for (int i = 0; i < num_channels; ++i) { + ValueTy error = a[i] - b[i]; + result += error * error; + } + return result; +} + +constexpr int MaxValuesForModes(ColorEndpointMode mode_a, + ColorEndpointMode mode_b) { + return (NumColorValuesForEndpointMode(mode_a) > + NumColorValuesForEndpointMode(mode_b)) + ? NumColorValuesForEndpointMode(mode_a) + : NumColorValuesForEndpointMode(mode_b); +} + +// This function takes the two colors in |endpoint_low| and |endpoint_high| and +// encodes them into |vals| according to the ASTC spec in section C.2.14. It +// assumes that the two colors are close enough to grayscale that the encoding +// should use the ColorEndpointMode kLDRLumaBaseOffset or kLDRLumaDirect. Which +// one is chosen depends on which produces smaller error for the given +// quantization value stored in |max_value| +bool EncodeColorsLuma(const RgbaColor& endpoint_low, + const RgbaColor& endpoint_high, + int max_value, ColorEndpointMode* const astc_mode, + std::vector* const vals) { + assert(vals->size() == + NumValuesForEncodingMode(EndpointEncodingMode::kDirectLuma)); + int avg1 = AverageRGB(endpoint_low); + int avg2 = AverageRGB(endpoint_high); + + // For the offset mode, L1 is strictly greater than L2, so if we are using + // it to encode the color values, we need to swap the weights and + // endpoints so that the larger of the two is the second endpoint. + bool needs_weight_swap = false; + if (avg1 > avg2) { + needs_weight_swap = true; + std::swap(avg1, avg2); + } + assert(avg1 <= avg2); + + // Now, the first endpoint is based on the low-order six bits of the first + // value, and the high order two bits of the second value. The low order + // six bits of the second value are used as the (strictly positive) offset + // from the first value. + const int offset = std::min(avg2 - avg1, 0x3F); + const int quant_off_low = + QuantizeCEValueToRange((avg1 & 0x3F) << 2, max_value); + const int quant_off_high = + QuantizeCEValueToRange((avg1 & 0xC0) | offset, max_value); + + const int quant_low = QuantizeCEValueToRange(avg1, max_value); + const int quant_high = QuantizeCEValueToRange(avg2, max_value); + + RgbaColor unquant_off_low, unquant_off_high; + RgbaColor unquant_low, unquant_high; + + (*vals)[0] = quant_off_low; + (*vals)[1] = quant_off_high; + DecodeColorsForMode( + *vals, max_value, ColorEndpointMode::kLDRLumaBaseOffset, + &unquant_off_low, &unquant_off_high); + + (*vals)[0] = quant_low; + (*vals)[1] = quant_high; + DecodeColorsForMode(*vals, max_value, ColorEndpointMode::kLDRLumaDirect, + &unquant_low, &unquant_high); + + const auto calculate_error = + [needs_weight_swap, &endpoint_low, &endpoint_high] + (const RgbaColor& low, const RgbaColor& high) { + int error = 0; + if (needs_weight_swap) { + error += SquaredError(low, endpoint_high); + error += SquaredError(high, endpoint_low); + } else { + error += SquaredError(low, endpoint_low); + error += SquaredError(high, endpoint_high); + } + return error; + }; + + const int direct_error = calculate_error(unquant_low, unquant_high); + const int off_error = calculate_error(unquant_off_low, unquant_off_high); + + if (direct_error <= off_error) { + (*vals)[0] = quant_low; + (*vals)[1] = quant_high; + *astc_mode = ColorEndpointMode::kLDRLumaDirect; + } else { + (*vals)[0] = quant_off_low; + (*vals)[1] = quant_off_high; + *astc_mode = ColorEndpointMode::kLDRLumaBaseOffset; + } + + return needs_weight_swap; +} + +class QuantizedEndpointPair { + public: + QuantizedEndpointPair(const RgbaColor& c_low, const RgbaColor& c_high, + int max_value) + : orig_low_(c_low), + orig_high_(c_high), + quant_low_(QuantizeColor(c_low, max_value)), + quant_high_(QuantizeColor(c_high, max_value)), + unquant_low_(UnquantizeColor(quant_low_, max_value)), + unquant_high_(UnquantizeColor(quant_high_, max_value)) { } + + const RgbaColor& QuantizedLow() const { return quant_low_; } + const RgbaColor& QuantizedHigh() const { return quant_high_; } + + const RgbaColor& UnquantizedLow() const { return unquant_low_; } + const RgbaColor& UnquantizedHigh() const { return unquant_high_; } + + const RgbaColor& OriginalLow() const { return orig_low_; } + const RgbaColor& OriginalHigh() const { return orig_high_; } + + private: + RgbaColor orig_low_; + RgbaColor orig_high_; + + RgbaColor quant_low_; + RgbaColor quant_high_; + + RgbaColor unquant_low_; + RgbaColor unquant_high_; +}; + +class CEEncodingOption { + public: + CEEncodingOption() { } + CEEncodingOption( + int squared_error, const QuantizedEndpointPair* quantized_endpoints, + bool swap_endpoints, bool blue_contract, bool use_offset_mode) + : squared_error_(squared_error), + quantized_endpoints_(quantized_endpoints), + swap_endpoints_(swap_endpoints), + blue_contract_(blue_contract), + use_offset_mode_(use_offset_mode) { } + + // Returns true if able to generate valid |astc_mode| and |vals|. In some + // instances, such as if the endpoints reprsent a base/offset pair, we may not + // be able to guarantee blue-contract encoding due to how the base/offset pair + // are represented and the specifics of the decoding procedure. Similarly, + // some direct RGBA encodings also may not be able to emit blue-contract modes + // due to an unlucky combination of channels. In these instances, this + // function will return false, and all pointers will remain unmodified. + bool Pack(bool with_alpha, ColorEndpointMode* const astc_mode, + std::vector* const vals, bool* const needs_weight_swap) const { + auto unquantized_low = quantized_endpoints_->UnquantizedLow(); + auto unquantized_high = quantized_endpoints_->UnquantizedHigh(); + + // In offset mode, we do BitTransferSigned before analyzing the values + // of the endpoints in order to determine whether or not we're going to + // be using blue-contract mode. + if (use_offset_mode_) { + for (int i = 0; i < std::tuple_size::value; ++i) { + BitTransferSigned(&unquantized_high[i], &unquantized_low[i]); + } + } + + // Define variables as outlined in the ASTC spec C.2.14 for the RGB[A] + // direct and base-offset modes + int s0 = 0, s1 = 0; + for (int i = 0; i < 3; ++i) { + s0 += unquantized_low[i]; + s1 += unquantized_high[i]; + } + + // Can we guarantee a blue-contract mode if we want it? In other words, + // if we swap which endpoint is high and which endpoint is low, can we + // guarantee that we will hit the corresponding decode path? + bool swap_vals = false; + if (use_offset_mode_) { + if (blue_contract_) { + swap_vals = s1 >= 0; + } else { + swap_vals = s1 < 0; + } + + // In offset mode, we have two different measurements that swap the + // endpoints prior to encoding, so we don't need to swap them here. + // If we need to swap them to guarantee a blue-contract mode, then + // abort and wait until we get the other error measurement. + if (swap_vals) { + return false; + } + } else { + if (blue_contract_) { + // If we want a blue_contract path, but s1 == s0, then swapping the + // values will have no effect. + if (s1 == s0) { + return false; + } + + swap_vals = s1 > s0; + // If we're encoding blue contract mode directly, then we implicitly + // swap the endpoints during decode, meaning that we need to take + // note of that here. + *needs_weight_swap = !(*needs_weight_swap); + } else { + swap_vals = s1 < s0; + } + } + + const auto* quantized_low = &(quantized_endpoints_->QuantizedLow()); + const auto* quantized_high = &(quantized_endpoints_->QuantizedHigh()); + + if (swap_vals) { + assert(!use_offset_mode_); + std::swap(quantized_low, quantized_high); + *needs_weight_swap = !(*needs_weight_swap); + } + + (*vals)[0] = quantized_low->at(0); + (*vals)[1] = quantized_high->at(0); + (*vals)[2] = quantized_low->at(1); + (*vals)[3] = quantized_high->at(1); + (*vals)[4] = quantized_low->at(2); + (*vals)[5] = quantized_high->at(2); + + if (use_offset_mode_) { + *astc_mode = ColorEndpointMode::kLDRRGBBaseOffset; + } else { + *astc_mode = ColorEndpointMode::kLDRRGBDirect; + } + + if (with_alpha) { + (*vals)[6] = quantized_low->at(3); + (*vals)[7] = quantized_high->at(3); + + if (use_offset_mode_) { + *astc_mode = ColorEndpointMode::kLDRRGBABaseOffset; + } else { + *astc_mode = ColorEndpointMode::kLDRRGBADirect; + } + } + + // If we swapped them to measure, then they need to be swapped after + // decoding + if (swap_endpoints_) { + *needs_weight_swap = !(*needs_weight_swap); + } + + return true; + } + + bool BlueContract() const { return blue_contract_; } + int Error() const { return squared_error_; } + + private: + int squared_error_; + const QuantizedEndpointPair* quantized_endpoints_; + bool swap_endpoints_; + bool blue_contract_; + bool use_offset_mode_; +}; + +bool EncodeColorsRGBA(const RgbaColor& endpoint_low_rgba, + const RgbaColor& endpoint_high_rgba, + int max_value, bool with_alpha, + ColorEndpointMode* const astc_mode, + std::vector* const vals) { + const int num_channels = with_alpha ? std::tuple_size::value : 3; + // The difficulty of encoding into this mode is determining whether or + // not we'd like to use the 'blue contract' function to reconstruct + // the endpoints and whether or not we'll be more accurate by using the + // base/offset color modes instead of quantizing the color channels + // directly. With that in mind, we: + // 1. Generate the inverted values for blue-contract and offset modes. + // 2. Quantize all of the different endpoints. + // 3. Unquantize each sets and decide which one gives least error + // 4. Encode the values correspondingly. + + // 1. Generate the inverted values for blue-contract and offset modes. + const auto inv_bc_low = InvertBlueContract(endpoint_low_rgba); + const auto inv_bc_high = InvertBlueContract(endpoint_high_rgba); + + RgbaColor direct_base, direct_offset; + for (int i = 0; i < std::tuple_size::value; ++i) { + direct_base[i] = endpoint_low_rgba[i]; + direct_offset[i] = + Clamp(endpoint_high_rgba[i] - endpoint_low_rgba[i], -32, 31); + InvertBitTransferSigned(&direct_offset[i], &direct_base[i]); + } + + RgbaColor inv_bc_base, inv_bc_offset; + for (int i = 0; i < std::tuple_size::value; ++i) { + // Remember, for blue-contract'd offset modes, the base is compared + // against the second endpoint and not the first. + inv_bc_base[i] = inv_bc_high[i]; + inv_bc_offset[i] = Clamp(inv_bc_low[i] - inv_bc_high[i], -32, 31); + InvertBitTransferSigned(&inv_bc_offset[i], &inv_bc_base[i]); + } + + // The order of the endpoints for offset modes may determine how well they + // approximate the given endpoints. It may be that the quantization value + // produces more accurate values for the base than the offset or + // vice/versa. For this reason, we need to generate quantized versions of + // the endpoints as if they were swapped to see if we get better error + // out of it. + + RgbaColor direct_base_swapped, direct_offset_swapped; + for (int i = 0; i < std::tuple_size::value; ++i) { + direct_base_swapped[i] = endpoint_high_rgba[i]; + direct_offset_swapped[i] = + Clamp(endpoint_low_rgba[i] - endpoint_high_rgba[i], -32, 31); + InvertBitTransferSigned(&direct_offset_swapped[i], &direct_base_swapped[i]); + } + + RgbaColor inv_bc_base_swapped, inv_bc_offset_swapped; + for (int i = 0; i < std::tuple_size::value; ++i) { + // Remember, for blue-contract'd offset modes, the base is compared + // against the second endpoint and not the first. Hence, the swapped + // version will compare the base against the first endpoint. + inv_bc_base_swapped[i] = inv_bc_low[i]; + inv_bc_offset_swapped[i] = Clamp(inv_bc_high[i] - inv_bc_low[i], -32, 31); + InvertBitTransferSigned(&inv_bc_offset_swapped[i], &inv_bc_base_swapped[i]); + } + + // 2. Quantize the endpoints directly. + const QuantizedEndpointPair direct_quantized( + endpoint_low_rgba, endpoint_high_rgba, max_value); + const QuantizedEndpointPair bc_quantized( + inv_bc_low, inv_bc_high, max_value); + + const QuantizedEndpointPair offset_quantized( + direct_base, direct_offset, max_value); + const QuantizedEndpointPair bc_offset_quantized( + inv_bc_base, inv_bc_offset, max_value); + + const QuantizedEndpointPair offset_swapped_quantized( + direct_base_swapped, direct_offset_swapped, max_value); + const QuantizedEndpointPair bc_offset_swapped_quantized( + inv_bc_base_swapped, inv_bc_offset_swapped, max_value); + + // 3. Unquantize each set and decide which one gives least error. + std::array errors; + auto errors_itr = errors.begin(); + + // 3.1 regular unquantized error + { + const auto rgba_low = direct_quantized.UnquantizedLow(); + const auto rgba_high = direct_quantized.UnquantizedHigh(); + + const int sq_rgb_error = + SquaredError(rgba_low, endpoint_low_rgba, num_channels) + + SquaredError(rgba_high, endpoint_high_rgba, num_channels); + + const bool swap_endpoints = false; + const bool blue_contract = false; + const bool offset_mode = false; + *(errors_itr++) = CEEncodingOption( + sq_rgb_error, &direct_quantized, + swap_endpoints, blue_contract, offset_mode); + } + + // 3.2 Compute blue-contract'd error. + { + auto bc_low = bc_quantized.UnquantizedLow(); + auto bc_high = bc_quantized.UnquantizedHigh(); + BlueContract(&bc_low); + BlueContract(&bc_high); + + const int sq_bc_error = + SquaredError(bc_low, endpoint_low_rgba, num_channels) + + SquaredError(bc_high, endpoint_high_rgba, num_channels); + + const bool swap_endpoints = false; + const bool blue_contract = true; + const bool offset_mode = false; + *(errors_itr++) = CEEncodingOption( + sq_bc_error, &bc_quantized, + swap_endpoints, blue_contract, offset_mode); + } + + // 3.3 Compute base/offset unquantized error. + const auto compute_base_offset_error = + [num_channels, &errors_itr, &endpoint_low_rgba, &endpoint_high_rgba] + (const QuantizedEndpointPair& pair, bool swapped) { + auto base = pair.UnquantizedLow(); + auto offset = pair.UnquantizedHigh(); + + for (int i = 0; i < num_channels; ++i) { + BitTransferSigned(&offset[i], &base[i]); + offset[i] = Clamp(base[i] + offset[i], 0, 255); + } + + int base_offset_error = 0; + // If we swapped the endpoints going in, then without blue contract + // we should be comparing the base against the high endpoint. + if (swapped) { + base_offset_error = + SquaredError(base, endpoint_high_rgba, num_channels) + + SquaredError(offset, endpoint_low_rgba, num_channels); + } else { + base_offset_error = + SquaredError(base, endpoint_low_rgba, num_channels) + + SquaredError(offset, endpoint_high_rgba, num_channels); + } + + const bool blue_contract = false; + const bool offset_mode = true; + *(errors_itr++) = CEEncodingOption( + base_offset_error, &pair, swapped, blue_contract, offset_mode); + }; + + compute_base_offset_error(offset_quantized, false); + + // 3.4 Compute base/offset blue-contract error. + const auto compute_base_offset_blue_contract_error = + [num_channels, &errors_itr, &endpoint_low_rgba, &endpoint_high_rgba] + (const QuantizedEndpointPair& pair, bool swapped) { + auto base = pair.UnquantizedLow(); + auto offset = pair.UnquantizedHigh(); + + for (int i = 0; i < num_channels; ++i) { + BitTransferSigned(&offset[i], &base[i]); + offset[i] = Clamp(base[i] + offset[i], 0, 255); + } + + BlueContract(&base); + BlueContract(&offset); + + int sq_bc_error = 0; + // Remember, for blue-contract'd offset modes, the base is compared + // against the second endpoint and not the first. So, we compare + // against the first if we swapped the endpoints going in. + if (swapped) { + sq_bc_error = + SquaredError(base, endpoint_low_rgba, num_channels) + + SquaredError(offset, endpoint_high_rgba, num_channels); + } else { + sq_bc_error = + SquaredError(base, endpoint_high_rgba, num_channels) + + SquaredError(offset, endpoint_low_rgba, num_channels); + } + + const bool blue_contract = true; + const bool offset_mode = true; + *(errors_itr++) = CEEncodingOption(sq_bc_error, &pair, + swapped, blue_contract, offset_mode); + }; + + compute_base_offset_blue_contract_error(bc_offset_quantized, false); + + // 3.5 Compute swapped base/offset error. + compute_base_offset_error(offset_swapped_quantized, true); + + // 3.6 Compute swapped base/offset blue-contract error. + compute_base_offset_blue_contract_error( + bc_offset_swapped_quantized, true); + + std::sort(errors.begin(), errors.end(), + [](const CEEncodingOption& a, const CEEncodingOption& b) { + return a.Error() < b.Error(); + }); + + // 4. Encode the values correspondingly. + // For this part, we go through each measurement in order of increasing + // error. Based on the properties of each measurement, we decide how to + // best encode the quantized endpoints that produced that error value. If + // for some reason we cannot encode that metric, then we skip it and move + // to the next one. + for (const auto& measurement : errors) { + bool needs_weight_swap = false; + if (measurement.Pack(with_alpha, astc_mode, vals, &needs_weight_swap)) { + // Make sure that if we ask for a blue-contract mode that we get it *and* + // if we don't ask for it then we don't get it. + assert(!(measurement.BlueContract() ^ + UsesBlueContract(max_value, *astc_mode, *vals))); + + // We encoded what we got. + return needs_weight_swap; + } + } + + assert(false && "Shouldn't have reached this point -- some combination of " + "endpoints should be possible to encode!"); + return false; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +bool UsesBlueContract(int max_value, ColorEndpointMode mode, + const std::vector& vals) { + assert(vals.size() >= NumColorValuesForEndpointMode(mode)); + + switch (mode) { + case ColorEndpointMode::kLDRRGBDirect: + case ColorEndpointMode::kLDRRGBADirect: { + constexpr int kNumVals = MaxValuesForModes( + ColorEndpointMode::kLDRRGBDirect, ColorEndpointMode::kLDRRGBADirect); + std::array v {}; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + const int s0 = v[0] + v[2] + v[4]; + const int s1 = v[1] + v[3] + v[5]; + + return s0 > s1; + } + + case ColorEndpointMode::kLDRRGBBaseOffset: + case ColorEndpointMode::kLDRRGBABaseOffset: { + constexpr int kNumVals = MaxValuesForModes( + ColorEndpointMode::kLDRRGBBaseOffset, + ColorEndpointMode::kLDRRGBABaseOffset); + std::array v {}; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + BitTransferSigned(&v[1], &v[0]); + BitTransferSigned(&v[3], &v[2]); + BitTransferSigned(&v[5], &v[4]); + + return v[1] + v[3] + v[5] < 0; + } + + default: + return false; + } +} + +bool EncodeColorsForMode( + const RgbaColor& endpoint_low_rgba, const RgbaColor& endpoint_high_rgba, + int max_value, EndpointEncodingMode encoding_mode, + ColorEndpointMode* const astc_mode, std::vector* const vals) { + bool needs_weight_swap = false; + vals->resize(NumValuesForEncodingMode(encoding_mode)); + + switch (encoding_mode) { + case EndpointEncodingMode::kDirectLuma: + return EncodeColorsLuma( + endpoint_low_rgba, endpoint_high_rgba, max_value, astc_mode, vals); + + case EndpointEncodingMode::kDirectLumaAlpha: { + // TODO(google): See if luma-alpha base-offset is better + const int avg1 = AverageRGB(endpoint_low_rgba); + const int avg2 = AverageRGB(endpoint_high_rgba); + + (*vals)[0] = QuantizeCEValueToRange(avg1, max_value); + (*vals)[1] = QuantizeCEValueToRange(avg2, max_value); + (*vals)[2] = QuantizeCEValueToRange(endpoint_low_rgba[3], max_value); + (*vals)[3] = QuantizeCEValueToRange(endpoint_high_rgba[3], max_value); + *astc_mode = ColorEndpointMode::kLDRLumaAlphaDirect; + } + break; + + case EndpointEncodingMode::kBaseScaleRGB: + case EndpointEncodingMode::kBaseScaleRGBA: { + RgbaColor base = endpoint_high_rgba; + RgbaColor scaled = endpoint_low_rgba; + + // Similar to luma base-offset, the scaled value is strictly less than + // the base value here according to the decode procedure. In this case, + // if the base is larger than the scale then we need to swap. + int num_channels_ge = 0; + for (int i = 0; i < 3; ++i) { + num_channels_ge += + static_cast(endpoint_high_rgba[i] >= endpoint_low_rgba[i]); + } + + if (num_channels_ge < 2) { + needs_weight_swap = true; + std::swap(base, scaled); + } + + // Since the second endpoint is just a direct copy of the RGB values, we + // can start by quantizing them. + const auto q_base = QuantizeColor(base, max_value); + const auto uq_base = UnquantizeColor(q_base, max_value); + + // The first endpoint (scaled) is defined by piecewise multiplying the + // second endpoint (base) by the scale factor and then dividing by 256. + // This means that the inverse operation is to first piecewise multiply + // the first endpoint by 256 and then divide by the unquantized second + // endpoint. We take the average of each of each of these scale values as + // our final scale value. + // TODO(google): Is this the best way to determine the scale factor? + int num_samples = 0; + int scale_sum = 0; + for (int i = 0; i < 3; ++i) { + int x = uq_base[i]; + if (x != 0) { + ++num_samples; + scale_sum += (scaled[i] * 256) / x; + } + } + + (*vals)[0] = q_base[0]; + (*vals)[1] = q_base[1]; + (*vals)[2] = q_base[2]; + if (num_samples > 0) { + const int avg_scale = Clamp(scale_sum / num_samples, 0, 255); + (*vals)[3] = QuantizeCEValueToRange(avg_scale, max_value); + } else { + // In this case, all of the base values are zero, so we can use whatever + // we want as the scale -- it won't affect the outcome. + (*vals)[3] = max_value; + } + *astc_mode = ColorEndpointMode::kLDRRGBBaseScale; + + if (encoding_mode == EndpointEncodingMode::kBaseScaleRGBA) { + (*vals)[4] = QuantizeCEValueToRange(scaled[3], max_value); + (*vals)[5] = QuantizeCEValueToRange(base[3], max_value); + *astc_mode = ColorEndpointMode::kLDRRGBBaseScaleTwoA; + } + } + break; + + case EndpointEncodingMode::kDirectRGB: + case EndpointEncodingMode::kDirectRGBA: + return EncodeColorsRGBA( + endpoint_low_rgba, endpoint_high_rgba, max_value, + encoding_mode == EndpointEncodingMode::kDirectRGBA, astc_mode, vals); + + default: + assert(false && "Unimplemented color encoding."); + } + + return needs_weight_swap; +} + +// These decoding procedures follow the code outlined in Section C.2.14 of +// the ASTC specification. +void DecodeColorsForMode(const std::vector& vals, + int max_value, ColorEndpointMode mode, + RgbaColor* const endpoint_low_rgba, + RgbaColor* const endpoint_high_rgba) { + assert(vals.size() >= NumColorValuesForEndpointMode(mode)); + switch (mode) { + case ColorEndpointMode::kLDRLumaDirect: { + const int l0 = UnquantizeCEValueFromRange(vals[0], max_value); + const int l1 = UnquantizeCEValueFromRange(vals[1], max_value); + + *endpoint_low_rgba = {{ l0, l0, l0, 255 }}; + *endpoint_high_rgba = {{ l1, l1, l1, 255 }}; + } + break; + + case ColorEndpointMode::kLDRLumaBaseOffset: { + const int v0 = UnquantizeCEValueFromRange(vals[0], max_value); + const int v1 = UnquantizeCEValueFromRange(vals[1], max_value); + + const int l0 = (v0 >> 2) | (v1 & 0xC0); + const int l1 = std::min(l0 + (v1 & 0x3F), 0xFF); + + *endpoint_low_rgba = {{ l0, l0, l0, 255 }}; + *endpoint_high_rgba = {{ l1, l1, l1, 255 }}; + } + break; + + case ColorEndpointMode::kLDRLumaAlphaDirect: { + constexpr int kNumVals = + NumColorValuesForEndpointMode(ColorEndpointMode::kLDRLumaAlphaDirect); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + *endpoint_low_rgba = {{ v[0], v[0], v[0], v[2] }}; + *endpoint_high_rgba = {{ v[1], v[1], v[1], v[3] }}; + } + break; + + case ColorEndpointMode::kLDRLumaAlphaBaseOffset: { + constexpr int kNumVals = NumColorValuesForEndpointMode( + ColorEndpointMode::kLDRLumaAlphaBaseOffset); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + BitTransferSigned(&v[1], &v[0]); + BitTransferSigned(&v[3], &v[2]); + + *endpoint_low_rgba = {{ v[0], v[0], v[0], v[2] }}; + const int high_luma = v[0] + v[1]; + *endpoint_high_rgba = {{ high_luma, high_luma, high_luma, v[2] + v[3] }}; + + for (auto& c : *endpoint_low_rgba) { c = Clamp(c, 0, 255); } + for (auto& c : *endpoint_high_rgba) { c = Clamp(c, 0, 255); } + } + break; + + case ColorEndpointMode::kLDRRGBBaseScale: { + constexpr int kNumVals = + NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBBaseScale); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + *endpoint_high_rgba = {{ v[0], v[1], v[2], 255 }}; + for (int i = 0; i < 3; ++i) { + const int x = endpoint_high_rgba->at(i); + endpoint_low_rgba->at(i) = (x * v[3]) >> 8; + } + endpoint_low_rgba->at(3) = 255; + } + break; + + case ColorEndpointMode::kLDRRGBDirect: { + constexpr int kNumVals = + NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBDirect); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + const int s0 = v[0] + v[2] + v[4]; + const int s1 = v[1] + v[3] + v[5]; + + *endpoint_low_rgba = {{ v[0], v[2], v[4], 255 }}; + *endpoint_high_rgba = {{ v[1], v[3], v[5], 255 }}; + + if (s1 < s0) { + std::swap(*endpoint_low_rgba, *endpoint_high_rgba); + BlueContract(endpoint_low_rgba); + BlueContract(endpoint_high_rgba); + } + } + break; + + case ColorEndpointMode::kLDRRGBBaseOffset: { + constexpr int kNumVals = + NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBBaseOffset); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + BitTransferSigned(&v[1], &v[0]); + BitTransferSigned(&v[3], &v[2]); + BitTransferSigned(&v[5], &v[4]); + + *endpoint_low_rgba = {{ v[0], v[2], v[4], 255 }}; + *endpoint_high_rgba = {{ v[0] + v[1], v[2] + v[3], v[4] + v[5], 255 }}; + + if (v[1] + v[3] + v[5] < 0) { + std::swap(*endpoint_low_rgba, *endpoint_high_rgba); + BlueContract(endpoint_low_rgba); + BlueContract(endpoint_high_rgba); + } + + for (auto& c : *endpoint_low_rgba) { c = Clamp(c, 0, 255); } + for (auto& c : *endpoint_high_rgba) { c = Clamp(c, 0, 255); } + } + break; + + case ColorEndpointMode::kLDRRGBBaseScaleTwoA: { + constexpr int kNumVals = NumColorValuesForEndpointMode( + ColorEndpointMode::kLDRRGBBaseScaleTwoA); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + // Base + *endpoint_low_rgba = *endpoint_high_rgba = {{ v[0], v[1], v[2], 255 }}; + + // Scale + for (int i = 0; i < 3; ++i) { + auto& x = endpoint_low_rgba->at(i); + x = (x * v[3]) >> 8; + } + + // Two A + endpoint_low_rgba->at(3) = v[4]; + endpoint_high_rgba->at(3) = v[5]; + } + break; + + case ColorEndpointMode::kLDRRGBADirect: { + constexpr int kNumVals = + NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBADirect); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + const int s0 = v[0] + v[2] + v[4]; + const int s1 = v[1] + v[3] + v[5]; + + *endpoint_low_rgba = {{ v[0], v[2], v[4], v[6] }}; + *endpoint_high_rgba = {{ v[1], v[3], v[5], v[7] }}; + + if (s1 < s0) { + std::swap(*endpoint_low_rgba, *endpoint_high_rgba); + BlueContract(endpoint_low_rgba); + BlueContract(endpoint_high_rgba); + } + } + break; + + case ColorEndpointMode::kLDRRGBABaseOffset: { + constexpr int kNumVals = + NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBABaseOffset); + + std::array v; + std::copy(vals.begin(), vals.end(), v.begin()); + Unquantize(&v, max_value); + + BitTransferSigned(&v[1], &v[0]); + BitTransferSigned(&v[3], &v[2]); + BitTransferSigned(&v[5], &v[4]); + BitTransferSigned(&v[7], &v[6]); + + *endpoint_low_rgba = {{ v[0], v[2], v[4], v[6] }}; + *endpoint_high_rgba = {{ + v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7] }}; + + if (v[1] + v[3] + v[5] < 0) { + std::swap(*endpoint_low_rgba, *endpoint_high_rgba); + BlueContract(endpoint_low_rgba); + BlueContract(endpoint_high_rgba); + } + + for (auto& c : *endpoint_low_rgba) { c = Clamp(c, 0, 255); } + for (auto& c : *endpoint_high_rgba) { c = Clamp(c, 0, 255); } + } + break; + + default: + // Unimplemented color encoding. + // TODO(google): Is this the correct error handling? + *endpoint_high_rgba = *endpoint_low_rgba = {{ 0, 0, 0, 0 }}; + } +} + +} // namespace astc_codec diff --git a/src/decoder/endpoint_codec.h b/src/decoder/endpoint_codec.h new file mode 100644 index 0000000..a1232d0 --- /dev/null +++ b/src/decoder/endpoint_codec.h @@ -0,0 +1,90 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_ENDPOINT_CODEC_H_ +#define ASTC_CODEC_DECODER_ENDPOINT_CODEC_H_ + +#include "src/decoder/physical_astc_block.h" +#include "src/decoder/types.h" + +#include +#include + +namespace astc_codec { + +// We use a special distinction for encode modes used to pass to the +// EncodeColorsForMode function below. The reason is that some of the color +// modes have sub-modes (like blue-contract) that change whether or not it is +// useful to encode an endpoint pair using one mode versus another. To avoid +// this problem, we approach the problem of encoding by specifying some +// high-level encoding modes. These eventually choose one of the low level +// ColorEndpointModes from Section C.2.14 when used in EncodeColorsForMode. +enum class EndpointEncodingMode { + kDirectLuma, + kDirectLumaAlpha, + kBaseScaleRGB, + kBaseScaleRGBA, + kDirectRGB, + kDirectRGBA +}; + +// Returns the number of values in the encoded endpoint pair after encoding +// to a specific high-level encoding mode. +constexpr int NumValuesForEncodingMode(EndpointEncodingMode mode) { + return + mode == EndpointEncodingMode::kDirectLuma ? 2 : + mode == EndpointEncodingMode::kDirectLumaAlpha ? 4 : + mode == EndpointEncodingMode::kBaseScaleRGB ? 4 : + mode == EndpointEncodingMode::kBaseScaleRGBA ? 6 : + mode == EndpointEncodingMode::kDirectRGB ? 6 : 8; +} + +// Fills |vals| with the quantized endpoint colors values defined in the ASTC +// specification. The values are quantized to the range [0, max_value]. These +// quantization limits can be obtained by querying the associated functions in +// integer_sequence_codec. The returned |astc_mode| will be the ASTC mode used +// to encode the resulting sequence. +// +// The |encoding_mode| is used to determine the way that we encode the values. +// Each encoding mode is used to determine which ASTC mode best corresponds +// to the pair of endpoints. It is a necessary hint to the encoding function +// in order to process the endpoints. Each encoding mode gurantees a certain +// number of values generated per endpoints. +// +// The return value will be true if the endpoints have been switched in order to +// reap the most benefit from the way the hardware decodes the given mode. In +// this case, the associated weights that interpolate this color must also be +// switched. In other words, for each w, it should change to 64 - w. +bool EncodeColorsForMode( + const RgbaColor& endpoint_low_rgba, const RgbaColor& endpoint_high_rgba, + int max_value, EndpointEncodingMode encoding_mode, + ColorEndpointMode* astc_mode, std::vector* vals); + +// Decodes the color values quantized to the range [0, max_value] into RGBA +// endpoints for the given mode. This function is the inverse of +// EncodeColorsForMode -- see that function for details. This function should +// work on all LDR endpoint modes, but no HDR modes. +void DecodeColorsForMode(const std::vector& vals, + int max_value, ColorEndpointMode mode, + RgbaColor* endpoint_low_rgba, + RgbaColor* endpoint_high_rgba); + +// Returns true if the quantized |vals| in the range [0, max_value] use the +// 'blue_contract' modification during decoding for the given |mode|. +bool UsesBlueContract(int max_value, ColorEndpointMode mode, + const std::vector& vals); + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_ENDPOINT_CODEC_H_ diff --git a/src/decoder/footprint.cc b/src/decoder/footprint.cc new file mode 100644 index 0000000..e4f076e --- /dev/null +++ b/src/decoder/footprint.cc @@ -0,0 +1,162 @@ +// 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/footprint.h" +#include "src/base/string_utils.h" + +#include +#include +#include +#include + +namespace astc_codec { + +namespace { + +// Encodes the width and height into an integer so that we can use a switch +// statement instead of a costly lookup map. +constexpr int EncodeDims(int width, int height) { + return (width << 16) | height; +} + +} // namespace + +base::Optional +Footprint::GetValidFootprintForDimensions(int width, int height) { + switch (EncodeDims(width, height)) { + case EncodeDims(4, 4): return FootprintType::k4x4; + case EncodeDims(5, 4): return FootprintType::k5x4; + case EncodeDims(5, 5): return FootprintType::k5x5; + case EncodeDims(6, 5): return FootprintType::k6x5; + case EncodeDims(6, 6): return FootprintType::k6x6; + case EncodeDims(8, 5): return FootprintType::k8x5; + case EncodeDims(8, 6): return FootprintType::k8x6; + case EncodeDims(8, 8): return FootprintType::k8x8; + case EncodeDims(10, 5): return FootprintType::k10x5; + case EncodeDims(10, 6): return FootprintType::k10x6; + case EncodeDims(10, 8): return FootprintType::k10x8; + case EncodeDims(10, 10): return FootprintType::k10x10; + case EncodeDims(12, 10): return FootprintType::k12x10; + case EncodeDims(12, 12): return FootprintType::k12x12; + default: return {}; + } +} + +int Footprint::GetWidthForFootprint(FootprintType footprint) { + switch (footprint) { + case FootprintType::k4x4: return 4; + case FootprintType::k5x4: return 5; + case FootprintType::k5x5: return 5; + case FootprintType::k6x5: return 6; + case FootprintType::k6x6: return 6; + case FootprintType::k8x5: return 8; + case FootprintType::k8x6: return 8; + case FootprintType::k10x5: return 10; + case FootprintType::k10x6: return 10; + case FootprintType::k8x8: return 8; + case FootprintType::k10x8: return 10; + case FootprintType::k10x10: return 10; + case FootprintType::k12x10: return 12; + case FootprintType::k12x12: return 12; + default: + assert(false); + return -1; + } +} + +int Footprint::GetHeightForFootprint(FootprintType footprint) { + switch (footprint) { + case FootprintType::k4x4: return 4; + case FootprintType::k5x4: return 4; + case FootprintType::k5x5: return 5; + case FootprintType::k6x5: return 5; + case FootprintType::k6x6: return 6; + case FootprintType::k8x5: return 5; + case FootprintType::k8x6: return 6; + case FootprintType::k10x5: return 5; + case FootprintType::k10x6: return 6; + case FootprintType::k8x8: return 8; + case FootprintType::k10x8: return 8; + case FootprintType::k10x10: return 10; + case FootprintType::k12x10: return 10; + case FootprintType::k12x12: return 12; + default: + assert(false); + return -1; + } +} + +Footprint::Footprint(FootprintType footprint) + : footprint_(footprint), width_(GetWidthForFootprint(footprint)), + height_(GetHeightForFootprint(footprint)) { } + +//////////////////////////////////////////////////////////////////////////////// + +base::Optional Footprint::Parse(const char* footprint_string) { + assert(footprint_string && footprint_string[0] != '\0'); + + std::vector dimension_strings; + base::Split(footprint_string, "x", [&dimension_strings](std::string&& s) { + dimension_strings.push_back(std::move(s)); + }); + + if (dimension_strings.size() != 2) { + assert(false && "Invalid format for footprint"); + return {}; + } + + const int width = base::ParseInt32(dimension_strings[0].c_str(), 0); + const int height = base::ParseInt32(dimension_strings[1].c_str(), 0); + + assert(width > 0 && height > 0 && "Invalid width or height."); + + return FromDimensions(width, height); +} + +base::Optional Footprint::FromDimensions(int width, int height) { + base::Optional valid_footprint = + GetValidFootprintForDimensions(width, height); + if (valid_footprint) { + return Footprint(valid_footprint.value()); + } else { + return {}; + } +} + +// Returns a Footprint for the given FootprintType. +base::Optional Footprint::FromFootprintType(FootprintType type) { + if (type >= FootprintType::k4x4 && type < FootprintType::kCount) { + return Footprint(type); + } else { + return {}; + } +} + +size_t Footprint::StorageRequirements(int width, int height) const { + const int blocks_wide = (width + width_ - 1) / width_; + const int blocks_high = (height + height_ - 1) / height_; + + constexpr size_t kASTCBlockSizeInBytes = 16; + return blocks_wide * blocks_high * kASTCBlockSizeInBytes; +} + +// Returns bits/pixel for a given footprint. +float Footprint::Bitrate() const { + const int kASTCBlockBitCount = 128; + const int footprint_pixel_count = width_ * height_; + return static_cast(kASTCBlockBitCount) / + static_cast(footprint_pixel_count); +} + +} // namespace astc_codec diff --git a/src/decoder/footprint.h b/src/decoder/footprint.h new file mode 100644 index 0000000..47302cc --- /dev/null +++ b/src/decoder/footprint.h @@ -0,0 +1,106 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_FOOTPRINT_H_ +#define ASTC_CODEC_DECODER_FOOTPRINT_H_ + +#include "include/astc-codec/astc-codec.h" +#include "src/base/optional.h" + +#include + +namespace astc_codec { + +// An ASTC texture can be encoded with varying choices in block size. A set of +// predefined block sizes are specified in the ASTC specification. These are +// referred to in the literature as "footprints" available to an encoder when +// constructing an ASTC bitstream. This class provides various utility functions +// for interacting with these footprints. +class Footprint { + public: + Footprint() = delete; + Footprint(const Footprint& footprint) = default; + + // Return the footprint type. + FootprintType Type() const { return footprint_; } + + // Return logical descriptions of the dimensions. + int Width() const { return width_; } + int Height() const { return height_; } + + // Returns the number of pixels for a block with this footprint. + int NumPixels() const { return width_ * height_; } + + // Returns the number of bytes needed to store an ASTC encoded image with the + // given width and height. + size_t StorageRequirements(int width, int height) const; + + // Returns the number of bits used per pixel. + float Bitrate() const; + + static constexpr int NumValidFootprints() { + return static_cast(FootprintType::kCount); + } + + bool operator==(const Footprint& other) const { + return footprint_ == other.footprint_; + } + + // These are the valid and available ASTC footprints. + static Footprint Get4x4() { return Footprint(FootprintType::k4x4); } + static Footprint Get5x4() { return Footprint(FootprintType::k5x4); } + static Footprint Get5x5() { return Footprint(FootprintType::k5x5); } + static Footprint Get6x5() { return Footprint(FootprintType::k6x5); } + static Footprint Get6x6() { return Footprint(FootprintType::k6x6); } + static Footprint Get8x5() { return Footprint(FootprintType::k8x5); } + static Footprint Get8x6() { return Footprint(FootprintType::k8x6); } + static Footprint Get8x8() { return Footprint(FootprintType::k8x8); } + static Footprint Get10x5() { return Footprint(FootprintType::k10x5); } + static Footprint Get10x6() { return Footprint(FootprintType::k10x6); } + static Footprint Get10x8() { return Footprint(FootprintType::k10x8); } + static Footprint Get10x10() { return Footprint(FootprintType::k10x10); } + static Footprint Get12x10() { return Footprint(FootprintType::k12x10); } + static Footprint Get12x12() { return Footprint(FootprintType::k12x12); } + + // Constructs a footprint from a string of the form "NxM", or no value if + // width and height are not a valid footprint. + static base::Optional Parse(const char* footprint_string); + + // Returns a footprint corresponding to a block of the given width and height, + // or no value if it does not. + static base::Optional FromDimensions(int width, int height); + + // Returns a Footprint for the given FootprintType. + static base::Optional FromFootprintType(FootprintType type); + + private: + // The only constructor. + explicit Footprint(FootprintType footprint); + + // Returns the valid footprint for the width and height if possible. + static base::Optional GetValidFootprintForDimensions( + int width, int height); + + // Returns the associated dimension for the given valid footprint. + static int GetWidthForFootprint(FootprintType footprint); + static int GetHeightForFootprint(FootprintType footprint); + + FootprintType footprint_; + int width_; + int height_; +}; + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_FOOTPRINT_H_ diff --git a/src/decoder/integer_sequence_codec.cc b/src/decoder/integer_sequence_codec.cc new file mode 100644 index 0000000..da7bc56 --- /dev/null +++ b/src/decoder/integer_sequence_codec.cc @@ -0,0 +1,562 @@ +// 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/integer_sequence_codec.h" +#include "src/base/math_utils.h" + +#include +#include + +namespace astc_codec { + +namespace { + +// Tables of trit and quint encodings generated by the implementation in +// http://cs/aosp-master/external/skia/src/utils/SkTextureCompressor_ASTC.cpp +// +// These tables are used to decode the blocks of values encoded using the ASTC +// integer sequence encoding. The theory is that five trits (values that can +// take any number in the range [0, 2]) can take on a total of 3^5 = 243 total +// values, which can be stored in eight bits. These eight bits are used to +// decode the five trits based on the ASTC specification in Section C.2.12. +// For simplicity, we have stored a look-up table here so that we don't need +// to implement the decoding logic. Similarly, seven bits are used to decode +// three quints (since 5^3 = 125 < 128). +static const std::array kTritEncodings[256] = { + {{ 0, 0, 0, 0, 0 }}, {{ 1, 0, 0, 0, 0 }}, {{ 2, 0, 0, 0, 0 }}, + {{ 0, 0, 2, 0, 0 }}, {{ 0, 1, 0, 0, 0 }}, {{ 1, 1, 0, 0, 0 }}, + {{ 2, 1, 0, 0, 0 }}, {{ 1, 0, 2, 0, 0 }}, {{ 0, 2, 0, 0, 0 }}, + {{ 1, 2, 0, 0, 0 }}, {{ 2, 2, 0, 0, 0 }}, {{ 2, 0, 2, 0, 0 }}, + {{ 0, 2, 2, 0, 0 }}, {{ 1, 2, 2, 0, 0 }}, {{ 2, 2, 2, 0, 0 }}, + {{ 2, 0, 2, 0, 0 }}, {{ 0, 0, 1, 0, 0 }}, {{ 1, 0, 1, 0, 0 }}, + {{ 2, 0, 1, 0, 0 }}, {{ 0, 1, 2, 0, 0 }}, {{ 0, 1, 1, 0, 0 }}, + {{ 1, 1, 1, 0, 0 }}, {{ 2, 1, 1, 0, 0 }}, {{ 1, 1, 2, 0, 0 }}, + {{ 0, 2, 1, 0, 0 }}, {{ 1, 2, 1, 0, 0 }}, {{ 2, 2, 1, 0, 0 }}, + {{ 2, 1, 2, 0, 0 }}, {{ 0, 0, 0, 2, 2 }}, {{ 1, 0, 0, 2, 2 }}, + {{ 2, 0, 0, 2, 2 }}, {{ 0, 0, 2, 2, 2 }}, {{ 0, 0, 0, 1, 0 }}, + {{ 1, 0, 0, 1, 0 }}, {{ 2, 0, 0, 1, 0 }}, {{ 0, 0, 2, 1, 0 }}, + {{ 0, 1, 0, 1, 0 }}, {{ 1, 1, 0, 1, 0 }}, {{ 2, 1, 0, 1, 0 }}, + {{ 1, 0, 2, 1, 0 }}, {{ 0, 2, 0, 1, 0 }}, {{ 1, 2, 0, 1, 0 }}, + {{ 2, 2, 0, 1, 0 }}, {{ 2, 0, 2, 1, 0 }}, {{ 0, 2, 2, 1, 0 }}, + {{ 1, 2, 2, 1, 0 }}, {{ 2, 2, 2, 1, 0 }}, {{ 2, 0, 2, 1, 0 }}, + {{ 0, 0, 1, 1, 0 }}, {{ 1, 0, 1, 1, 0 }}, {{ 2, 0, 1, 1, 0 }}, + {{ 0, 1, 2, 1, 0 }}, {{ 0, 1, 1, 1, 0 }}, {{ 1, 1, 1, 1, 0 }}, + {{ 2, 1, 1, 1, 0 }}, {{ 1, 1, 2, 1, 0 }}, {{ 0, 2, 1, 1, 0 }}, + {{ 1, 2, 1, 1, 0 }}, {{ 2, 2, 1, 1, 0 }}, {{ 2, 1, 2, 1, 0 }}, + {{ 0, 1, 0, 2, 2 }}, {{ 1, 1, 0, 2, 2 }}, {{ 2, 1, 0, 2, 2 }}, + {{ 1, 0, 2, 2, 2 }}, {{ 0, 0, 0, 2, 0 }}, {{ 1, 0, 0, 2, 0 }}, + {{ 2, 0, 0, 2, 0 }}, {{ 0, 0, 2, 2, 0 }}, {{ 0, 1, 0, 2, 0 }}, + {{ 1, 1, 0, 2, 0 }}, {{ 2, 1, 0, 2, 0 }}, {{ 1, 0, 2, 2, 0 }}, + {{ 0, 2, 0, 2, 0 }}, {{ 1, 2, 0, 2, 0 }}, {{ 2, 2, 0, 2, 0 }}, + {{ 2, 0, 2, 2, 0 }}, {{ 0, 2, 2, 2, 0 }}, {{ 1, 2, 2, 2, 0 }}, + {{ 2, 2, 2, 2, 0 }}, {{ 2, 0, 2, 2, 0 }}, {{ 0, 0, 1, 2, 0 }}, + {{ 1, 0, 1, 2, 0 }}, {{ 2, 0, 1, 2, 0 }}, {{ 0, 1, 2, 2, 0 }}, + {{ 0, 1, 1, 2, 0 }}, {{ 1, 1, 1, 2, 0 }}, {{ 2, 1, 1, 2, 0 }}, + {{ 1, 1, 2, 2, 0 }}, {{ 0, 2, 1, 2, 0 }}, {{ 1, 2, 1, 2, 0 }}, + {{ 2, 2, 1, 2, 0 }}, {{ 2, 1, 2, 2, 0 }}, {{ 0, 2, 0, 2, 2 }}, + {{ 1, 2, 0, 2, 2 }}, {{ 2, 2, 0, 2, 2 }}, {{ 2, 0, 2, 2, 2 }}, + {{ 0, 0, 0, 0, 2 }}, {{ 1, 0, 0, 0, 2 }}, {{ 2, 0, 0, 0, 2 }}, + {{ 0, 0, 2, 0, 2 }}, {{ 0, 1, 0, 0, 2 }}, {{ 1, 1, 0, 0, 2 }}, + {{ 2, 1, 0, 0, 2 }}, {{ 1, 0, 2, 0, 2 }}, {{ 0, 2, 0, 0, 2 }}, + {{ 1, 2, 0, 0, 2 }}, {{ 2, 2, 0, 0, 2 }}, {{ 2, 0, 2, 0, 2 }}, + {{ 0, 2, 2, 0, 2 }}, {{ 1, 2, 2, 0, 2 }}, {{ 2, 2, 2, 0, 2 }}, + {{ 2, 0, 2, 0, 2 }}, {{ 0, 0, 1, 0, 2 }}, {{ 1, 0, 1, 0, 2 }}, + {{ 2, 0, 1, 0, 2 }}, {{ 0, 1, 2, 0, 2 }}, {{ 0, 1, 1, 0, 2 }}, + {{ 1, 1, 1, 0, 2 }}, {{ 2, 1, 1, 0, 2 }}, {{ 1, 1, 2, 0, 2 }}, + {{ 0, 2, 1, 0, 2 }}, {{ 1, 2, 1, 0, 2 }}, {{ 2, 2, 1, 0, 2 }}, + {{ 2, 1, 2, 0, 2 }}, {{ 0, 2, 2, 2, 2 }}, {{ 1, 2, 2, 2, 2 }}, + {{ 2, 2, 2, 2, 2 }}, {{ 2, 0, 2, 2, 2 }}, {{ 0, 0, 0, 0, 1 }}, + {{ 1, 0, 0, 0, 1 }}, {{ 2, 0, 0, 0, 1 }}, {{ 0, 0, 2, 0, 1 }}, + {{ 0, 1, 0, 0, 1 }}, {{ 1, 1, 0, 0, 1 }}, {{ 2, 1, 0, 0, 1 }}, + {{ 1, 0, 2, 0, 1 }}, {{ 0, 2, 0, 0, 1 }}, {{ 1, 2, 0, 0, 1 }}, + {{ 2, 2, 0, 0, 1 }}, {{ 2, 0, 2, 0, 1 }}, {{ 0, 2, 2, 0, 1 }}, + {{ 1, 2, 2, 0, 1 }}, {{ 2, 2, 2, 0, 1 }}, {{ 2, 0, 2, 0, 1 }}, + {{ 0, 0, 1, 0, 1 }}, {{ 1, 0, 1, 0, 1 }}, {{ 2, 0, 1, 0, 1 }}, + {{ 0, 1, 2, 0, 1 }}, {{ 0, 1, 1, 0, 1 }}, {{ 1, 1, 1, 0, 1 }}, + {{ 2, 1, 1, 0, 1 }}, {{ 1, 1, 2, 0, 1 }}, {{ 0, 2, 1, 0, 1 }}, + {{ 1, 2, 1, 0, 1 }}, {{ 2, 2, 1, 0, 1 }}, {{ 2, 1, 2, 0, 1 }}, + {{ 0, 0, 1, 2, 2 }}, {{ 1, 0, 1, 2, 2 }}, {{ 2, 0, 1, 2, 2 }}, + {{ 0, 1, 2, 2, 2 }}, {{ 0, 0, 0, 1, 1 }}, {{ 1, 0, 0, 1, 1 }}, + {{ 2, 0, 0, 1, 1 }}, {{ 0, 0, 2, 1, 1 }}, {{ 0, 1, 0, 1, 1 }}, + {{ 1, 1, 0, 1, 1 }}, {{ 2, 1, 0, 1, 1 }}, {{ 1, 0, 2, 1, 1 }}, + {{ 0, 2, 0, 1, 1 }}, {{ 1, 2, 0, 1, 1 }}, {{ 2, 2, 0, 1, 1 }}, + {{ 2, 0, 2, 1, 1 }}, {{ 0, 2, 2, 1, 1 }}, {{ 1, 2, 2, 1, 1 }}, + {{ 2, 2, 2, 1, 1 }}, {{ 2, 0, 2, 1, 1 }}, {{ 0, 0, 1, 1, 1 }}, + {{ 1, 0, 1, 1, 1 }}, {{ 2, 0, 1, 1, 1 }}, {{ 0, 1, 2, 1, 1 }}, + {{ 0, 1, 1, 1, 1 }}, {{ 1, 1, 1, 1, 1 }}, {{ 2, 1, 1, 1, 1 }}, + {{ 1, 1, 2, 1, 1 }}, {{ 0, 2, 1, 1, 1 }}, {{ 1, 2, 1, 1, 1 }}, + {{ 2, 2, 1, 1, 1 }}, {{ 2, 1, 2, 1, 1 }}, {{ 0, 1, 1, 2, 2 }}, + {{ 1, 1, 1, 2, 2 }}, {{ 2, 1, 1, 2, 2 }}, {{ 1, 1, 2, 2, 2 }}, + {{ 0, 0, 0, 2, 1 }}, {{ 1, 0, 0, 2, 1 }}, {{ 2, 0, 0, 2, 1 }}, + {{ 0, 0, 2, 2, 1 }}, {{ 0, 1, 0, 2, 1 }}, {{ 1, 1, 0, 2, 1 }}, + {{ 2, 1, 0, 2, 1 }}, {{ 1, 0, 2, 2, 1 }}, {{ 0, 2, 0, 2, 1 }}, + {{ 1, 2, 0, 2, 1 }}, {{ 2, 2, 0, 2, 1 }}, {{ 2, 0, 2, 2, 1 }}, + {{ 0, 2, 2, 2, 1 }}, {{ 1, 2, 2, 2, 1 }}, {{ 2, 2, 2, 2, 1 }}, + {{ 2, 0, 2, 2, 1 }}, {{ 0, 0, 1, 2, 1 }}, {{ 1, 0, 1, 2, 1 }}, + {{ 2, 0, 1, 2, 1 }}, {{ 0, 1, 2, 2, 1 }}, {{ 0, 1, 1, 2, 1 }}, + {{ 1, 1, 1, 2, 1 }}, {{ 2, 1, 1, 2, 1 }}, {{ 1, 1, 2, 2, 1 }}, + {{ 0, 2, 1, 2, 1 }}, {{ 1, 2, 1, 2, 1 }}, {{ 2, 2, 1, 2, 1 }}, + {{ 2, 1, 2, 2, 1 }}, {{ 0, 2, 1, 2, 2 }}, {{ 1, 2, 1, 2, 2 }}, + {{ 2, 2, 1, 2, 2 }}, {{ 2, 1, 2, 2, 2 }}, {{ 0, 0, 0, 1, 2 }}, + {{ 1, 0, 0, 1, 2 }}, {{ 2, 0, 0, 1, 2 }}, {{ 0, 0, 2, 1, 2 }}, + {{ 0, 1, 0, 1, 2 }}, {{ 1, 1, 0, 1, 2 }}, {{ 2, 1, 0, 1, 2 }}, + {{ 1, 0, 2, 1, 2 }}, {{ 0, 2, 0, 1, 2 }}, {{ 1, 2, 0, 1, 2 }}, + {{ 2, 2, 0, 1, 2 }}, {{ 2, 0, 2, 1, 2 }}, {{ 0, 2, 2, 1, 2 }}, + {{ 1, 2, 2, 1, 2 }}, {{ 2, 2, 2, 1, 2 }}, {{ 2, 0, 2, 1, 2 }}, + {{ 0, 0, 1, 1, 2 }}, {{ 1, 0, 1, 1, 2 }}, {{ 2, 0, 1, 1, 2 }}, + {{ 0, 1, 2, 1, 2 }}, {{ 0, 1, 1, 1, 2 }}, {{ 1, 1, 1, 1, 2 }}, + {{ 2, 1, 1, 1, 2 }}, {{ 1, 1, 2, 1, 2 }}, {{ 0, 2, 1, 1, 2 }}, + {{ 1, 2, 1, 1, 2 }}, {{ 2, 2, 1, 1, 2 }}, {{ 2, 1, 2, 1, 2 }}, + {{ 0, 2, 2, 2, 2 }}, {{ 1, 2, 2, 2, 2 }}, {{ 2, 2, 2, 2, 2 }}, + {{ 2, 1, 2, 2, 2 }} +}; + +static const std::array kQuintEncodings[128] = { + {{ 0, 0, 0 }}, {{ 1, 0, 0 }}, {{ 2, 0, 0 }}, {{ 3, 0, 0 }}, {{ 4, 0, 0 }}, + {{ 0, 4, 0 }}, {{ 4, 4, 0 }}, {{ 4, 4, 4 }}, {{ 0, 1, 0 }}, {{ 1, 1, 0 }}, + {{ 2, 1, 0 }}, {{ 3, 1, 0 }}, {{ 4, 1, 0 }}, {{ 1, 4, 0 }}, {{ 4, 4, 1 }}, + {{ 4, 4, 4 }}, {{ 0, 2, 0 }}, {{ 1, 2, 0 }}, {{ 2, 2, 0 }}, {{ 3, 2, 0 }}, + {{ 4, 2, 0 }}, {{ 2, 4, 0 }}, {{ 4, 4, 2 }}, {{ 4, 4, 4 }}, {{ 0, 3, 0 }}, + {{ 1, 3, 0 }}, {{ 2, 3, 0 }}, {{ 3, 3, 0 }}, {{ 4, 3, 0 }}, {{ 3, 4, 0 }}, + {{ 4, 4, 3 }}, {{ 4, 4, 4 }}, {{ 0, 0, 1 }}, {{ 1, 0, 1 }}, {{ 2, 0, 1 }}, + {{ 3, 0, 1 }}, {{ 4, 0, 1 }}, {{ 0, 4, 1 }}, {{ 4, 0, 4 }}, {{ 0, 4, 4 }}, + {{ 0, 1, 1 }}, {{ 1, 1, 1 }}, {{ 2, 1, 1 }}, {{ 3, 1, 1 }}, {{ 4, 1, 1 }}, + {{ 1, 4, 1 }}, {{ 4, 1, 4 }}, {{ 1, 4, 4 }}, {{ 0, 2, 1 }}, {{ 1, 2, 1 }}, + {{ 2, 2, 1 }}, {{ 3, 2, 1 }}, {{ 4, 2, 1 }}, {{ 2, 4, 1 }}, {{ 4, 2, 4 }}, + {{ 2, 4, 4 }}, {{ 0, 3, 1 }}, {{ 1, 3, 1 }}, {{ 2, 3, 1 }}, {{ 3, 3, 1 }}, + {{ 4, 3, 1 }}, {{ 3, 4, 1 }}, {{ 4, 3, 4 }}, {{ 3, 4, 4 }}, {{ 0, 0, 2 }}, + {{ 1, 0, 2 }}, {{ 2, 0, 2 }}, {{ 3, 0, 2 }}, {{ 4, 0, 2 }}, {{ 0, 4, 2 }}, + {{ 2, 0, 4 }}, {{ 3, 0, 4 }}, {{ 0, 1, 2 }}, {{ 1, 1, 2 }}, {{ 2, 1, 2 }}, + {{ 3, 1, 2 }}, {{ 4, 1, 2 }}, {{ 1, 4, 2 }}, {{ 2, 1, 4 }}, {{ 3, 1, 4 }}, + {{ 0, 2, 2 }}, {{ 1, 2, 2 }}, {{ 2, 2, 2 }}, {{ 3, 2, 2 }}, {{ 4, 2, 2 }}, + {{ 2, 4, 2 }}, {{ 2, 2, 4 }}, {{ 3, 2, 4 }}, {{ 0, 3, 2 }}, {{ 1, 3, 2 }}, + {{ 2, 3, 2 }}, {{ 3, 3, 2 }}, {{ 4, 3, 2 }}, {{ 3, 4, 2 }}, {{ 2, 3, 4 }}, + {{ 3, 3, 4 }}, {{ 0, 0, 3 }}, {{ 1, 0, 3 }}, {{ 2, 0, 3 }}, {{ 3, 0, 3 }}, + {{ 4, 0, 3 }}, {{ 0, 4, 3 }}, {{ 0, 0, 4 }}, {{ 1, 0, 4 }}, {{ 0, 1, 3 }}, + {{ 1, 1, 3 }}, {{ 2, 1, 3 }}, {{ 3, 1, 3 }}, {{ 4, 1, 3 }}, {{ 1, 4, 3 }}, + {{ 0, 1, 4 }}, {{ 1, 1, 4 }}, {{ 0, 2, 3 }}, {{ 1, 2, 3 }}, {{ 2, 2, 3 }}, + {{ 3, 2, 3 }}, {{ 4, 2, 3 }}, {{ 2, 4, 3 }}, {{ 0, 2, 4 }}, {{ 1, 2, 4 }}, + {{ 0, 3, 3 }}, {{ 1, 3, 3 }}, {{ 2, 3, 3 }}, {{ 3, 3, 3 }}, {{ 4, 3, 3 }}, + {{ 3, 4, 3 }}, {{ 0, 3, 4 }}, {{ 1, 3, 4 }} +}; + +// A cached table containing the max ranges for values encoded using ASTC's +// Bounded Integer Sequence Encoding. These are the numbers between 1 and 255 +// that can be represented exactly as a number in the ranges +// [0, 2^k), [0, 3 * 2^k), and [0, 5 * 2^k). +static const std::array kMaxRanges = []() { + std::array ranges; + + // Initialize the table that we need for determining value encodings. + auto next_max_range = ranges.begin(); + auto add_val = [&next_max_range](int val) { + if (val <= 0 || (1 << kLog2MaxRangeForBits) <= val) { + return; + } + + *(next_max_range++) = val; + }; + + for (int i = 0; i <= kLog2MaxRangeForBits; ++i) { + add_val(3 * (1 << i) - 1); + add_val(5 * (1 << i) - 1); + add_val((1 << i) - 1); + } + + assert(std::distance(next_max_range, ranges.end()) == 0); + std::sort(ranges.begin(), ranges.end()); + return ranges; +}(); + +// Returns true if x == 0 or if x is a power of two. This function is only used +// in the GetCountsForRange function, where we need to have it return true +// on zero since we can have single trit/quint ISE encodings according to +// Table C.2.7. +template::value, T>::type = 0> +inline constexpr bool IsPow2(T x) { return (x & (x - 1)) == 0; } + +// For the ISE block encoding, these arrays determine how many bits are +// used after each value to store the interleaved quint/trit block. +const int kInterleavedQuintBits[3] = { 3, 2, 2 }; +const int kInterleavedTritBits[5] = { 2, 2, 1, 2, 1 }; + +// Decodes either a trit or quint block using the BISE (Bounded Integer Sequence +// Encoding) defined in Section C.2.12 of the ASTC specification. ValRange is +// expected to be either 3 or 5 depending on whether or not we're encoding trits +// or quints respectively. In other words, it is the remaining factor in whether +// the passed blocks contain encoded values of the form 3*2^k or 5*2^k. +template +std::array DecodeISEBlock( + uint64_t block_bits, int num_bits) { + static_assert(ValRange == 3 || ValRange == 5, + "We only know about trits and quints"); + + // We either have three quints or five trits + constexpr const int kNumVals = (ValRange == 5) ? 3 : 5; + + // Depending on whether or not we're using quints or trits will determine + // the positions of the interleaved bits in the encoded block. + constexpr const int* const kInterleavedBits = + (ValRange == 5) ? kInterleavedQuintBits : kInterleavedTritBits; + + // Set up the bits for reading + base::BitStream block_bit_src(block_bits, sizeof(block_bits) * 8); + + // Decode the block + std::array m; + uint64_t encoded = 0; + uint32_t encoded_bits_read = 0; + for (int i = 0; i < kNumVals; ++i) { + { + uint64_t bits = 0; + const bool result = block_bit_src.GetBits(num_bits, &bits); + assert(result); + + m[i] = static_cast(bits); + } + + uint64_t encoded_bits; + { + const bool result = block_bit_src.GetBits(kInterleavedBits[i], &encoded_bits); + assert(result); + } + encoded |= encoded_bits << encoded_bits_read; + encoded_bits_read += kInterleavedBits[i]; + } + + // Make sure that our encoded trit/quint doesn't exceed its bounds + assert(ValRange != 3 || encoded < 256); + assert(ValRange != 5 || encoded < 128); + + const int* const kEncodings = (ValRange == 5) ? + kQuintEncodings[encoded].data() : kTritEncodings[encoded].data(); + + std::array result; + for (int i = 0; i < kNumVals; ++i) { + assert(m[i] < 1 << num_bits); + result[i] = kEncodings[i] << num_bits | m[i]; + } + return result; +} + +// Encode a single trit or quint block using the BISE (Bounded Integer Sequence +// Encoding) defined in Section C.2.12 of the ASTC specification. ValRange is +// expected to be either 3 or 5 depending on whether or not we're encoding trits +// or quints respectively. In other words, it is the remaining factor in whether +// the passed blocks contain encoded values of the form 3*2^k or 5*2^k. +template +void EncodeISEBlock(const std::vector& vals, int bits_per_val, + base::BitStream* bit_sink) { + static_assert(ValRange == 3 || ValRange == 5, + "We only know about trits and quints"); + + // We either have three quints or five trits + constexpr const int kNumVals = (ValRange == 5) ? 3 : 5; + + // Three quints in seven bits or five trits in eight bits + constexpr const int kNumEncodedBitsPerBlock = (ValRange == 5) ? 7 : 8; + + // Depending on whether or not we're using quints or trits will determine + // the positions of the interleaved bits in the encoding + constexpr const int* const kInterleavedBits = + (ValRange == 5) ? kInterleavedQuintBits : kInterleavedTritBits; + + // ISE blocks can only have up to a specific number of values... + assert(vals.size() <= kNumVals); + + // Split up into bits and non bits. Non bits are used to find the quint/trit + // encoding that we need. + std::array non_bits = {{ 0 }}; + std::array bits = {{ 0 }}; + for (size_t i = 0; i < vals.size(); ++i) { + bits[i] = vals[i] & ((1 << bits_per_val) - 1); + non_bits[i] = vals[i] >> bits_per_val; + assert(non_bits[i] < ValRange); + } + + // We only need to add as many bits as necessary, so let's limit it based + // on the computation described in Section C.2.22 of the ASTC specification + const int total_num_bits = + ((vals.size() * kNumEncodedBitsPerBlock + kNumVals - 1) / kNumVals) + + vals.size() * bits_per_val; + int bits_added = 0; + + // The number of bits used for the quint/trit encoding is necessary to know + // in order to properly select the encoding we need to represent. + int num_encoded_bits = 0; + for (int i = 0; i < kNumVals; ++i) { + bits_added += bits_per_val; + if (bits_added >= total_num_bits) { + break; + } + + num_encoded_bits += kInterleavedBits[i]; + bits_added += kInterleavedBits[i]; + if (bits_added >= total_num_bits) { + break; + } + } + bits_added = 0; + assert(num_encoded_bits <= kNumEncodedBitsPerBlock); + + // TODO(google): The faster way to do this would be to construct trees out + // of the quint/trit encoding patterns, or just invert the decoding logic. + // Here we go from the end backwards because it makes our tests are more + // deterministic. + int non_bit_encoding = -1; + for (int j = (1 << num_encoded_bits) - 1; j >= 0; --j) { + bool matches = true; + + // We don't need to match all trits here, just the ones that correspond + // to the values that we passed in + for (size_t i = 0; i < kNumVals; ++i) { + if ((ValRange == 5 && kQuintEncodings[j][i] != non_bits[i]) || + (ValRange == 3 && kTritEncodings[j][i] != non_bits[i])) { + matches = false; + break; + } + } + + if (matches) { + non_bit_encoding = j; + break; + } + } + + assert(non_bit_encoding >= 0); + + // Now pack the bits into the block + for (int i = 0; i < vals.size(); ++i) { + // First add the base bits for this value + if (bits_added + bits_per_val <= total_num_bits) { + bit_sink->PutBits(bits[i], bits_per_val); + bits_added += bits_per_val; + } + + // Now add the interleaved bits from the quint/trit + int num_int_bits = kInterleavedBits[i]; + int int_bits = non_bit_encoding & ((1 << num_int_bits) - 1); + if (bits_added + num_int_bits <= total_num_bits) { + bit_sink->PutBits(int_bits, num_int_bits); + bits_added += num_int_bits; + non_bit_encoding >>= num_int_bits; + } + } +} + +inline void CHECK_COUNTS(int trits, int quints) { + assert(trits == 0 || quints == 0); // Either trits or quints + assert(trits == 0 || trits == 1); // At most one trit + assert(quints == 0 || quints == 1); // At most one quint +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +std::array::const_iterator ISERangeBegin() { + return kMaxRanges.cbegin(); +} + +std::array::const_iterator ISERangeEnd() { + return kMaxRanges.cend(); +} + +void IntegerSequenceCodec::GetCountsForRange( + int range, int* const trits, int* const quints, int* const bits) { + // Make sure the passed pointers are valid + assert(trits != nullptr); + assert(quints != nullptr); + assert(bits != nullptr); + + // These are generally errors -- there should never be any ASTC values + // outside of this range + assert(range > 0); + assert(range < 1 << kLog2MaxRangeForBits); + + *bits = 0; + *trits = 0; + *quints = 0; + + // Search through the numbers of the form 2^n, 3 * 2^n and 5 * 2^n + const int max_vals_for_range = + *std::lower_bound(kMaxRanges.begin(), kMaxRanges.end(), range) + 1; + + // Make sure we found something + assert(max_vals_for_range > 1); + + // Find out what kind of range it is + if ((max_vals_for_range % 3 == 0) && IsPow2(max_vals_for_range / 3)) { + *bits = base::Log2Floor(max_vals_for_range / 3); + *trits = 1; + *quints = 0; + } else if ((max_vals_for_range % 5 == 0) && IsPow2(max_vals_for_range / 5)) { + *bits = base::Log2Floor(max_vals_for_range / 5); + *trits = 0; + *quints = 1; + } else if (IsPow2(max_vals_for_range)) { + *bits = base::Log2Floor(max_vals_for_range); + *trits = 0; + *quints = 0; + } + + // If we set any of these values then we're done. + if ((*bits | *trits | *quints) != 0) { + CHECK_COUNTS(*trits, *quints); + } +} + +// Returns the overall bit count for a range of val_count values encoded +// using the specified number of trits, quints and straight bits (respectively) +int IntegerSequenceCodec::GetBitCount(int num_vals, + int trits, int quints, int bits) { + CHECK_COUNTS(trits, quints); + + // See section C.2.22 for the formula used here. + const int trit_bit_count = ((num_vals * 8 * trits) + 4) / 5; + const int quint_bit_count = ((num_vals * 7 * quints) + 2) / 3; + const int base_bit_count = num_vals * bits; + return trit_bit_count + quint_bit_count + base_bit_count; +} + +IntegerSequenceCodec::IntegerSequenceCodec(int range) { + int trits, quints, bits; + GetCountsForRange(range, &trits, &quints, &bits); + InitializeWithCounts(trits, quints, bits); +} + +IntegerSequenceCodec::IntegerSequenceCodec( + int trits, int quints, int bits) { + InitializeWithCounts(trits, quints, bits); +} + +void IntegerSequenceCodec::InitializeWithCounts( + int trits, int quints, int bits) { + CHECK_COUNTS(trits, quints); + + if (trits > 0) { + encoding_ = EncodingMode::kTritEncoding; + } else if (quints > 0) { + encoding_ = EncodingMode::kQuintEncoding; + } else { + encoding_ = EncodingMode::kBitEncoding; + } + + bits_ = bits; +} + +int IntegerSequenceCodec::NumValsPerBlock() const { + const std::array kNumValsByEncoding = {{ 5, 3, 1 }}; + return kNumValsByEncoding[static_cast(encoding_)]; +} + +int IntegerSequenceCodec::EncodedBlockSize() const { + const std::array kExtraBlockSizeByEncoding = {{ 8, 7, 0 }}; + const int num_vals = NumValsPerBlock(); + return kExtraBlockSizeByEncoding[static_cast(encoding_)] + + num_vals * bits_; +} + +std::vector IntegerSequenceDecoder::Decode( + int num_vals, base::BitStream *bit_src) const { + int trits = (encoding_ == kTritEncoding)? 1 : 0; + int quints = (encoding_ == kQuintEncoding)? 1 : 0; + const int total_num_bits = GetBitCount(num_vals, trits, quints, bits_); + const int bits_per_block = EncodedBlockSize(); + assert(bits_per_block < 64); + + int bits_left = total_num_bits; + std::vector result; + while (bits_left > 0) { + uint64_t block_bits; + { + const bool result = bit_src->GetBits(std::min(bits_left, bits_per_block), &block_bits); + assert(result); + } + + switch (encoding_) { + case kTritEncoding: { + auto trit_vals = DecodeISEBlock<3>(block_bits, bits_); + result.insert(result.end(), trit_vals.begin(), trit_vals.end()); + } + break; + + case kQuintEncoding: { + auto quint_vals = DecodeISEBlock<5>(block_bits, bits_); + result.insert(result.end(), quint_vals.begin(), quint_vals.end()); + } + break; + + case kBitEncoding: + result.push_back(static_cast(block_bits)); + break; + } + + bits_left -= bits_per_block; + } + + // Resize result to only contain as many values as requested + assert(result.size() >= static_cast(num_vals)); + result.resize(num_vals); + + // Encoded all the values + return result; +} + +void IntegerSequenceEncoder::Encode(base::BitStream* bit_sink) const { + // Go through all of the values and chop them up into blocks. The properties + // of the trit and quint encodings mean that if we need to encode fewer values + // in a block than the number of values encoded in the block then we need to + // consider the last few values to be zero. + + auto next_val = vals_.begin(); + while (next_val != vals_.end()) { + switch (encoding_) { + case kTritEncoding: { + std::vector trit_vals; + for (int i = 0; i < 5; ++i) { + if (next_val != vals_.end()) { + trit_vals.push_back(*next_val); + ++next_val; + } + } + + EncodeISEBlock<3>(trit_vals, bits_, bit_sink); + } + break; + + case kQuintEncoding: { + std::vector quint_vals; + for (int i = 0; i < 3; ++i) { + if (next_val != vals_.end()) { + quint_vals.push_back(*next_val); + ++next_val; + } + } + + EncodeISEBlock<5>(quint_vals, bits_, bit_sink); + } + break; + + case kBitEncoding: { + bit_sink->PutBits(*next_val, EncodedBlockSize()); + ++next_val; + } + break; + } + } +} + +} // namespace astc_codec diff --git a/src/decoder/integer_sequence_codec.h b/src/decoder/integer_sequence_codec.h new file mode 100644 index 0000000..a815e09 --- /dev/null +++ b/src/decoder/integer_sequence_codec.h @@ -0,0 +1,169 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_INTEGER_SEQUENCE_CODEC_H_ +#define ASTC_CODEC_DECODER_INTEGER_SEQUENCE_CODEC_H_ + +#include "src/base/bit_stream.h" +#include "src/base/uint128.h" + +#include +#include +#include + +namespace astc_codec { + +// The maximum number of bits that we would need to encode an ISE value. The +// ASTC specification does not give a maximum number, however unquantized color +// values have a maximum range of 255, meaning that we can't feasibly have more +// than eight bits per value. +constexpr int kLog2MaxRangeForBits = 8; + +// Ranges can take any of the the forms 2^k, 3*2^k, or 5*2^k for k up to +// kLog2MaxRangeForBits. Hence we have three types of ranges. Since the +// maximum encoded value is 255, k won't go larger than 8. We don't have quints +// that accompany [6, 8]-bits, as (5 * 2^6 = 320 > 255) and we don't have trits +// that accompany [7, 8]-bits, as (3 * 2^7 = 384 > 255). But we do have trits +// and quints that accompany no bits. Hence we have a total of +// 3 * kLog2MaxRangeForBits - 3 - 2 + 2 total ranges. +constexpr int kNumPossibleRanges = 3 * kLog2MaxRangeForBits - 3; + +// Returns an iterator through the available ASTC ranges. +std::array::const_iterator ISERangeBegin(); +std::array::const_iterator ISERangeEnd(); + +// Base class for ASTC integer sequence encoders and decoders. These codecs +// operate on sequences of integers and produce bit patterns that pack the +// integers based on the encoding scheme specified in the ASTC specification +// Section C.2.12. The resulting bit pattern is a sequence of encoded blocks. +// All blocks in a sequence are one of the following encodings: +// +// (1 -- bit encoding) one encoded value of the form 2^k +// (2 -- trit encoding) five encoded values of the form 3*2^k +// (3 -- quint encoding) three encoded values of the form 5*2^k +// +// The layouts of each block are designed such that the blocks can be truncated +// during encoding in order to support variable length input sequences (i.e. a +// sequence of values that are encoded using trit encoded blocks does not +// need to have a multiple-of-five length). +class IntegerSequenceCodec { + public: + // Returns the number of trits, quints, and bits needed to encode values in + // [0, range]. This is used to determine the layout of ISE encoded bit + // streams. The returned array holds the number of trits, quints, and bits + // respectively. range is expected to be within the interval [1, 5242879] + static void GetCountsForRange(int range, int* trits, int* quints, int* bits); + + // Returns the number of bits needed to encode the given number of values with + // respect to the number of trits, quints, and bits specified in ise_counts + // (in that order). It is expected that either trits or quints can be + // nonzero, but not both, and neither can be larger than one. Anything else is + // undefined. + static int GetBitCount(int num_vals, int trits, int quints, int bits); + + // Convenience function that returns the number of bits needed to encoded + // num_vals within the range [0, range] (inclusive). + static inline int GetBitCountForRange(int num_vals, int range) { + int trits, quints, bits; + GetCountsForRange(range, &trits, &quints, &bits); + return GetBitCount(num_vals, trits, quints, bits); + } + + protected: + explicit IntegerSequenceCodec(int range); + IntegerSequenceCodec(int trits, int quints, int bits); + + // The encoding mode -- since having trits and quints are mutually exclusive, + // we can store the encoding we decide on in this enum. + enum EncodingMode { + kTritEncoding = 0, + kQuintEncoding, + kBitEncoding, + }; + + EncodingMode encoding_; + int bits_; + + // Returns the number of values stored in a single ISE block. Since quints and + // trits are packed three/five to a bit pattern (respectively), each sequence + // is chunked into blocks in order to encode it. For only bit-encodings, the + // block size is one. + int NumValsPerBlock() const; + + // Returns the size of a single ISE block in bits (see NumValsPerBlock). + int EncodedBlockSize() const; + + private: + // Determines the encoding mode. + void InitializeWithCounts(int trits, int quints, int bits); +}; + +// The integer sequence decoder. The decoder only remembers the given encoding +// but each invocation of Decode operates independently on the input bits. +class IntegerSequenceDecoder : public IntegerSequenceCodec { + public: + // Creates a decoder that decodes values within [0, range] (inclusive). + explicit IntegerSequenceDecoder(int range) + : IntegerSequenceCodec(range) { } + + // Creates a decoder based on the number of trits, quints, and bits expected + // in the bit stream passed to Decode. + IntegerSequenceDecoder(int trits, int quints, int bits) + : IntegerSequenceCodec(trits, quints, bits) { } + + // Decodes num_vals from the bit_src. The number of bits read is dependent + // on the number of bits required to encode num_vals based on the calculation + // provided in Section C.2.22 of the ASTC specification. The return value + // always contains exactly num_vals. + std::vector Decode(int num_vals, + base::BitStream* bit_src) const; +}; + +// The integer sequence encoder. The encoder accepts values one by one and +// places them into a temporary array that it holds. When needed the user +// may call Encode to produce an encoded bit stream of the associated values. +class IntegerSequenceEncoder : public IntegerSequenceCodec { + public: + // Creates an encoder that encodes values within [0, range] (inclusive). + explicit IntegerSequenceEncoder(int range) + : IntegerSequenceCodec(range) { } + + // Creates an encoder based on the number of trits, quints, and bits for + // the bit stream produced by Encode. + IntegerSequenceEncoder(int trits, int quints, int bits) + : IntegerSequenceCodec(trits, quints, bits) { } + + // Adds a value to the encoding sequence. + void AddValue(int val) { + // Make sure it's within bounds + assert(encoding_ != EncodingMode::kTritEncoding || val < 3 * (1 << bits_)); + assert(encoding_ != EncodingMode::kQuintEncoding || val < 5 * (1 << bits_)); + assert(encoding_ != EncodingMode::kBitEncoding || val < (1 << bits_)); + vals_.push_back(val); + } + + // Writes the encoding for vals_ to the bit_sink. Multiple calls to Encode + // will produce the same result. + void Encode(base::BitStream* bit_sink) const; + + // Removes all of the previously added values to the encoder. + void Reset() { vals_.clear(); } + + private: + std::vector vals_; +}; + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_INTEGER_SEQUENCE_CODEC_H_ diff --git a/src/decoder/intermediate_astc_block.cc b/src/decoder/intermediate_astc_block.cc new file mode 100644 index 0000000..e03af1e --- /dev/null +++ b/src/decoder/intermediate_astc_block.cc @@ -0,0 +1,591 @@ +// 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/intermediate_astc_block.h" +#include "src/decoder/integer_sequence_codec.h" +#include "src/base/bit_stream.h" +#include "src/base/math_utils.h" +#include "src/base/optional.h" +#include "src/base/uint128.h" + +#include +#include +#include + +namespace astc_codec { + +namespace { + +constexpr int kEndpointRange_ReturnInvalidWeightDims = -1; +constexpr int kEndpointRange_ReturnNotEnoughColorBits = -2; + +base::UInt128 PackVoidExtentBlock(uint16_t r, uint16_t g, uint16_t b, + uint16_t a, std::array coords) { + base::BitStream bit_sink; + + // Put void extent mode... + bit_sink.PutBits(0xDFC, 12); + + // Each of the coordinates goes in 13 bits at a time. + for (auto coord : coords) { + assert(coord < 1 << 13); + bit_sink.PutBits(coord, 13); + } + assert(bit_sink.Bits() == 64); + + // Then we add R, G, B, and A in order + bit_sink.PutBits(r, 16); + bit_sink.PutBits(g, 16); + bit_sink.PutBits(b, 16); + bit_sink.PutBits(a, 16); + + assert(bit_sink.Bits() == 128); + + base::UInt128 result; + bit_sink.GetBits(128, &result); + return result; +} + +base::Optional GetEncodedWeightRange(int range, + std::array* const r) { + const std::array, 12> kValidRangeEncodings = + {{ {{ 0, 1, 0 }}, {{ 1, 1, 0 }}, {{ 0, 0, 1 }}, + {{ 1, 0, 1 }}, {{ 0, 1, 1 }}, {{ 1, 1, 1 }}, + {{ 0, 1, 0 }}, {{ 1, 1, 0 }}, {{ 0, 0, 1 }}, + {{ 1, 0, 1 }}, {{ 0, 1, 1 }}, {{ 1, 1, 1 }} }}; + + // If our range is larger than all available ranges, this is an error. + const int smallest_range = kValidWeightRanges.front(); + const int largest_range = kValidWeightRanges.back(); + if (range < smallest_range || largest_range < range) { + std::stringstream strm; + strm << "Could not find block mode. Invalid weight range: " + << range << " not in [" << smallest_range << ", " + << largest_range << std::endl; + return strm.str(); + } + + // Find the upper bound on the range, otherwise. + const auto range_iter = std::lower_bound( + kValidWeightRanges.cbegin(), kValidWeightRanges.cend(), range); + auto enc_iter = kValidRangeEncodings.cbegin(); + enc_iter += std::distance(kValidWeightRanges.cbegin(), range_iter); + *r = *enc_iter; + return {}; +} + +struct BlockModeInfo { + int min_weight_grid_dim_x; + int max_weight_grid_dim_x; + int min_weight_grid_dim_y; + int max_weight_grid_dim_y; + int r0_bit_pos; + int r1_bit_pos; + int r2_bit_pos; + int weight_grid_x_offset_bit_pos; + int weight_grid_y_offset_bit_pos; + bool require_single_plane_low_prec; +}; + +constexpr int kNumBlockModes = 10; +const std::array kBlockModeInfo {{ + { 4, 7, 2, 5, 4, 0, 1, 7, 5, false }, // B+4 A+2 + { 8, 11, 2, 5, 4, 0, 1, 7, 5, false }, // B+8 A+2 + { 2, 5, 8, 11, 4, 0, 1, 5, 7, false }, // A+2 B+8 + { 2, 5, 6, 7, 4, 0, 1, 5, 7, false }, // A+2 B+6 + { 2, 3, 2, 5, 4, 0, 1, 7, 5, false }, // B+2 A+2 + { 12, 12, 2, 5, 4, 2, 3, -1, 5, false }, // 12 A+2 + { 2, 5, 12, 12, 4, 2, 3, 5, -1, false }, // A+2 12 + { 6, 6, 10, 10, 4, 2, 3, -1, -1, false }, // 6 10 + { 10, 10, 6, 6, 4, 2, 3, -1, -1, false }, // 10 6 + { 6, 9, 6, 9, 4, 2, 3, 5, 9, true } // A+6 B+6 +}}; + +// These are the bits that must be set for ASTC to recognize a given +// block mode. They are the 1's set in table C.2.8 of the spec. +const std::array kBlockModeMask = {{ + 0x0, 0x4, 0x8, 0xC, 0x10C, 0x0, 0x80, 0x180, 0x1A0, 0x100 +}}; + +static base::Optional PackBlockMode(int dim_x, int dim_y, int range, + bool dual_plane, + base::BitStream* const bit_sink) { + // We need to set the high precision bit if our range is too high... + bool high_prec = range > 7; + + std::array r; + const auto result = GetEncodedWeightRange(range, &r); + if (result) { + return result; + } + + // The high two bits of R must not be zero. If this happens then it's + // an illegal encoding according to Table C.2.7 that should have gotten + // caught in GetEncodedWeightRange + assert((r[1] | r[2]) > 0); + + // Just go through the table and see if any of the modes can handle + // the given dimensions. + for (int mode = 0; mode < kNumBlockModes; ++mode) { + const BlockModeInfo& block_mode = kBlockModeInfo[mode]; + + bool is_valid_mode = true; + is_valid_mode &= block_mode.min_weight_grid_dim_x <= dim_x; + is_valid_mode &= dim_x <= block_mode.max_weight_grid_dim_x; + is_valid_mode &= block_mode.min_weight_grid_dim_y <= dim_y; + is_valid_mode &= dim_y <= block_mode.max_weight_grid_dim_y; + is_valid_mode &= !(block_mode.require_single_plane_low_prec && dual_plane); + is_valid_mode &= !(block_mode.require_single_plane_low_prec && high_prec); + + if (!is_valid_mode) { + continue; + } + + // Initialize to the bits we must set. + uint32_t encoded_mode = kBlockModeMask[mode]; + auto setBit = [&encoded_mode](const uint32_t value, const uint32_t offset) { + encoded_mode = (encoded_mode & ~(1 << offset)) | ((value & 1) << offset); + }; + + // Set all the bits we need to set + setBit(r[0], block_mode.r0_bit_pos); + setBit(r[1], block_mode.r1_bit_pos); + setBit(r[2], block_mode.r2_bit_pos); + + // Find our width and height offset from the base width and height weight + // grid dimension for the given block mode. These are the 1-2 bits that + // get encoded in the block mode used to calculate the final weight grid + // width and height. + const int offset_x = dim_x - block_mode.min_weight_grid_dim_x; + const int offset_y = dim_y - block_mode.min_weight_grid_dim_y; + + // If we don't have an offset position then our offset better be zero. + // If this isn't the case, then this isn't a viable block mode and we + // should have caught this sooner. + assert(block_mode.weight_grid_x_offset_bit_pos >= 0 || offset_x == 0); + assert(block_mode.weight_grid_y_offset_bit_pos >= 0 || offset_y == 0); + + encoded_mode |= offset_x << block_mode.weight_grid_x_offset_bit_pos; + encoded_mode |= offset_y << block_mode.weight_grid_y_offset_bit_pos; + + if (!block_mode.require_single_plane_low_prec) { + setBit(high_prec, 9); + setBit(dual_plane, 10); + } + + // Make sure that the mode is the first thing the bit sink is writing to + assert(bit_sink->Bits() == 0); + bit_sink->PutBits(encoded_mode, 11); + + return {}; + } + + return std::string("Could not find viable block mode"); +} + +// Returns true if all endpoint modes are equal. +bool SharedEndpointModes(const IntermediateBlockData& data) { + return std::accumulate( + data.endpoints.begin(), data.endpoints.end(), true, + [&data](const bool& a, const IntermediateEndpointData& b) { + return a && b.mode == data.endpoints[0].mode; + }); +} + +// Returns the starting bit (between 0 and 128) where the extra CEM and +// dual plane info is stored in the ASTC block. +int ExtraConfigBitPosition(const IntermediateBlockData& data) { + const bool has_dual_channel = data.dual_plane_channel.hasValue(); + const int num_weights = data.weight_grid_dim_x * data.weight_grid_dim_y * + (has_dual_channel ? 2 : 1); + const int num_weight_bits = + IntegerSequenceCodec::GetBitCountForRange(num_weights, data.weight_range); + + int extra_config_bits = 0; + if (!SharedEndpointModes(data)) { + const int num_encoded_cem_bits = 2 + data.endpoints.size() * 3; + extra_config_bits = num_encoded_cem_bits - 6; + } + + if (has_dual_channel) { + extra_config_bits += 2; + } + + return 128 - num_weight_bits - extra_config_bits; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +base::Optional UnpackIntermediateBlock( + const PhysicalASTCBlock& pb) { + if (pb.IsIllegalEncoding()) { + return {}; + } + + if (pb.IsVoidExtent()) { + return {}; + } + + // Non void extent? Then let's try to decode everything else. + IntermediateBlockData data; + + // All blocks have color values... + const base::UInt128 color_bits_mask = + (base::UInt128(1) << pb.NumColorBits().value()) - 1; + const base::UInt128 color_bits = + (pb.GetBlockBits() >> pb.ColorStartBit().value()) & color_bits_mask; + base::BitStream bit_src(color_bits, 128); + + IntegerSequenceDecoder color_decoder(pb.ColorValuesRange().value()); + const int num_colors_in_block = pb.NumColorValues().value(); + std::vector colors = color_decoder.Decode(num_colors_in_block, &bit_src); + + // Decode simple info + const auto weight_dims = pb.WeightGridDims(); + data.weight_grid_dim_x = weight_dims->at(0); + data.weight_grid_dim_y = weight_dims->at(1); + data.weight_range = pb.WeightRange().value(); + + data.partition_id = pb.PartitionID(); + data.dual_plane_channel = pb.DualPlaneChannel(); + + auto colors_iter = colors.begin(); + for (int i = 0; i < pb.NumPartitions().value(); ++i) { + IntermediateEndpointData ep_data; + ep_data.mode = pb.GetEndpointMode(i).value(); + + const int num_colors = NumColorValuesForEndpointMode(ep_data.mode); + ep_data.colors.insert(ep_data.colors.end(), colors_iter, + colors_iter + num_colors); + colors_iter += num_colors; + + data.endpoints.push_back(ep_data); + } + assert(colors_iter == colors.end()); + data.endpoint_range = pb.ColorValuesRange().value(); + + // Finally decode the weights + const base::UInt128 weight_bits_mask = + (base::UInt128(1) << pb.NumWeightBits().value()) - 1; + const base::UInt128 weight_bits = + base::ReverseBits(pb.GetBlockBits()) & weight_bits_mask; + bit_src = base::BitStream(weight_bits, 128); + + IntegerSequenceDecoder weight_decoder(data.weight_range); + int num_weights = data.weight_grid_dim_x * data.weight_grid_dim_y; + num_weights *= pb.IsDualPlane() ? 2 : 1; + data.weights = weight_decoder.Decode(num_weights, &bit_src); + + return data; +} + +int EndpointRangeForBlock(const IntermediateBlockData& data) { + // First check to see if we exceed the number of bits allotted for weights, as + // specified in C.2.24. If so, then the endpoint range is meaningless, but not + // because we had an overzealous color endpoint mode, so return a different + // error code. + if (IntegerSequenceCodec::GetBitCountForRange( + data.weight_grid_dim_x * data.weight_grid_dim_y * + (data.dual_plane_channel.hasValue() ? 2 : 1), + data.weight_range) > 96) { + return kEndpointRange_ReturnInvalidWeightDims; + } + + const int num_partitions = data.endpoints.size(); + + // Calculate the number of bits that we would write prior to getting to the + // color endpoint data + const int bits_written = + 11 // Block mode + + 2 // Num partitions + + ((num_partitions > 1) ? 10 : 0) // Partition ID + + ((num_partitions == 1) ? 4 : 6); // Shared CEM bits + + // We can determine the range based on how many bits we have between the start + // of the color endpoint data and the next section, which is the extra config + // bit position + const int color_bits_available = ExtraConfigBitPosition(data) - bits_written; + + int num_color_values = 0; + for (const auto& ep_data : data.endpoints) { + num_color_values += NumColorValuesForEndpointMode(ep_data.mode); + } + + // There's no way any valid ASTC encoding has no room left for any color + // values. If we hit this then something is wrong in the caller -- abort. + // According to section C.2.24, the smallest number of bits available is + // ceil(13*C/5), where C is the number of color endpoint integers needed. + const int bits_needed = (13 * num_color_values + 4) / 5; + if (color_bits_available < bits_needed) { + return kEndpointRange_ReturnNotEnoughColorBits; + } + + int color_value_range = 255; + for (; color_value_range > 1; --color_value_range) { + const int bits_for_range = IntegerSequenceCodec::GetBitCountForRange( + num_color_values, color_value_range); + if (bits_for_range <= color_bits_available) { + break; + } + } + + return color_value_range; +} + +base::Optional UnpackVoidExtent(const PhysicalASTCBlock& pb) { + if (pb.IsIllegalEncoding()) { + return {}; + } + + if (!pb.IsVoidExtent()) { + return {}; + } + + // All blocks have color values... + const base::UInt128 color_bits_mask = + (base::UInt128(1) << pb.NumColorBits().value()) - 1; + const uint64_t color_bits = ( + (pb.GetBlockBits() >> pb.ColorStartBit().value()) & color_bits_mask).LowBits(); + + assert(pb.NumColorValues().value() == 4); + VoidExtentData data; + data.r = static_cast((color_bits >> 0) & 0xFFFF); + data.g = static_cast((color_bits >> 16) & 0xFFFF); + data.b = static_cast((color_bits >> 32) & 0xFFFF); + data.a = static_cast((color_bits >> 48) & 0xFFFF); + + const auto void_extent_coords = pb.VoidExtentCoords(); + if (void_extent_coords) { + data.coords[0] = void_extent_coords->at(0); + data.coords[1] = void_extent_coords->at(1); + data.coords[2] = void_extent_coords->at(2); + data.coords[3] = void_extent_coords->at(3); + } else { + uint16_t all_ones = (1 << 13) - 1; + for (auto& coord : data.coords) { + coord = all_ones; + } + } + + return data; +} + +// Packs the given intermediate block into a physical block. Returns false if +// the provided values in the intermediate block emit an illegal ASTC +// encoding. +base::Optional Pack(const IntermediateBlockData& data, + base::UInt128* pb) { + if (data.weights.size() != + data.weight_grid_dim_x * data.weight_grid_dim_y * + (data.dual_plane_channel.hasValue() ? 2 : 1)) { + return std::string("Incorrect number of weights!"); + } + + // If it's not a void extent block, then it gets a bit more tricky... + base::BitStream bit_sink; + + // First we need to encode the block mode. + const auto error_string = PackBlockMode( + data.weight_grid_dim_x, data.weight_grid_dim_y, data.weight_range, + data.dual_plane_channel.hasValue(), &bit_sink); + if (error_string) { + return error_string; + } + + // Next, we place the number of partitions minus one. + const int num_partitions = data.endpoints.size(); + bit_sink.PutBits(num_partitions - 1, 2); + + // If we have more than one partition, then we also have a partition ID. + if (num_partitions > 1) { + const int id = data.partition_id.value(); + assert(id >= 0); + bit_sink.PutBits(id, 10); + } + + // Take a detour, let's encode the weights so that we know how many bits they + // consume. + base::BitStream weight_sink; + + IntegerSequenceEncoder weight_enc(data.weight_range); + for (auto weight : data.weights) { + weight_enc.AddValue(weight); + } + weight_enc.Encode(&weight_sink); + + const int num_weight_bits = weight_sink.Bits(); + assert(num_weight_bits == + IntegerSequenceCodec::GetBitCountForRange( + data.weights.size(), data.weight_range)); + + // Let's continue... how much after the color data do we need to write? + int extra_config = 0; + + // Determine if all endpoint pairs share the same endpoint mode + assert(data.endpoints.size() > 0); + bool shared_endpoint_mode = SharedEndpointModes(data); + + // The first part of the endpoint mode (CEM) comes directly after the + // partition info, if it exists. If there is no partition info, the CEM comes + // right after the block mode. In the single-partition case, we just write out + // the entire singular CEM, but in the multi-partition case, if all CEMs are + // the same then their shared CEM is specified directly here, too. In both + // cases, shared_endpoint_mode is true (in the singular case, + // shared_endpoint_mode is trivially true). + if (shared_endpoint_mode) { + if (num_partitions > 1) { + bit_sink.PutBits(0, 2); + } + bit_sink.PutBits(static_cast(data.endpoints[0].mode), 4); + } else { + // Here, the CEM is not shared across all endpoint pairs, and we need to + // figure out what to place here, and what to place in the extra config + // bits before the weight data... + + // Non-shared config modes must all be within the same class (out of four) + // See Section C.2.11 + int min_class = 2; // We start with 2 here instead of three because it's + // the highest that can be encoded -- even if all modes + // are class 3. + int max_class = 0; + for (const auto& ep_data : data.endpoints) { + const int ep_mode_class = static_cast(ep_data.mode) >> 2; + min_class = std::min(min_class, ep_mode_class); + max_class = std::max(max_class, ep_mode_class); + } + + assert(max_class >= min_class); + + if (max_class - min_class > 1) { + return std::string("Endpoint modes are invalid"); + } + + // Construct the CEM mode -- six of its bits will fit here, but otherwise + // the rest will go in the extra configuration bits. + base::BitStream cem_encoder; + + // First encode the base class + assert(min_class >= 0); + assert(min_class < 3); + cem_encoder.PutBits(min_class + 1, 2); + + // Next, encode the class selector bits -- this is simply the offset + // from the base class + for (const auto& ep_data : data.endpoints) { + const int ep_mode_class = static_cast(ep_data.mode) >> 2; + const int class_selector_bit = ep_mode_class - min_class; + assert(class_selector_bit == 0 || class_selector_bit == 1); + cem_encoder.PutBits(class_selector_bit, 1); + } + + // Finally, we need to choose from each class which actual mode + // we belong to and encode those. + for (const auto& ep_data : data.endpoints) { + const int ep_mode = static_cast(ep_data.mode) & 3; + assert(ep_mode < 4); + cem_encoder.PutBits(ep_mode, 2); + } + assert(cem_encoder.Bits() == 2 + num_partitions * 3); + + uint32_t encoded_cem; + cem_encoder.GetBits(2 + num_partitions * 3, &encoded_cem); + + // Since only six bits fit here before the color endpoint data, the rest + // need to go in the extra config data. + extra_config = encoded_cem >> 6; + + // Write out the six bits we had + bit_sink.PutBits(encoded_cem, 6); + } + + // If we have a dual-plane channel, we can tack that onto our extra config + // data + if (data.dual_plane_channel.hasValue()) { + const int channel = data.dual_plane_channel.value(); + assert(channel < 4); + extra_config <<= 2; + extra_config |= channel; + } + + // Get the range of endpoint values. It can't be -1 because we should have + // checked for that much earlier. + const int color_value_range = data.endpoint_range + ? data.endpoint_range.value() + : EndpointRangeForBlock(data); + + assert(color_value_range != kEndpointRange_ReturnInvalidWeightDims); + if (color_value_range == kEndpointRange_ReturnNotEnoughColorBits) { + return { "Intermediate block emits illegal color range" }; + } + + IntegerSequenceEncoder color_enc(color_value_range); + for (const auto& ep_data : data.endpoints) { + for (int color : ep_data.colors) { + if (color > color_value_range) { + return { "Color outside available color range!" }; + } + + color_enc.AddValue(color); + } + } + color_enc.Encode(&bit_sink); + + // Now we need to skip some bits to get to the extra configuration bits. The + // number of bits we need to skip depends on where we are in the stream and + // where we need to get to. + const int extra_config_bit_position = ExtraConfigBitPosition(data); + const int extra_config_bits = + 128 - num_weight_bits - extra_config_bit_position; + assert(extra_config_bits >= 0); + assert(extra_config < 1 << extra_config_bits); + + // Make sure the color encoder didn't write more than we thought it would. + int bits_to_skip = extra_config_bit_position - bit_sink.Bits(); + assert(bits_to_skip >= 0); + + while (bits_to_skip > 0) { + const int skipping = std::min(32, bits_to_skip); + bit_sink.PutBits(0, skipping); + bits_to_skip -= skipping; + } + + // Finally, write out the rest of the config bits. + bit_sink.PutBits(extra_config, extra_config_bits); + + // We should be right up to the weight bits... + assert(bit_sink.Bits() == 128 - num_weight_bits); + + // Flush out our bit writer and write out the weight bits + base::UInt128 astc_bits; + bit_sink.GetBits(128 - num_weight_bits, &astc_bits); + + base::UInt128 rev_weight_bits; + weight_sink.GetBits(weight_sink.Bits(), &rev_weight_bits); + + astc_bits |= base::ReverseBits(rev_weight_bits); + + // And we're done! Whew! + *pb = astc_bits; + return PhysicalASTCBlock(*pb).IsIllegalEncoding(); +} + +base::Optional Pack(const VoidExtentData& data, + base::UInt128* pb) { + *pb = PackVoidExtentBlock(data.r, data.g, data.b, data.a, data.coords); + return PhysicalASTCBlock(*pb).IsIllegalEncoding(); +} + +} // namespace astc_codec diff --git a/src/decoder/intermediate_astc_block.h b/src/decoder/intermediate_astc_block.h new file mode 100644 index 0000000..ec6eb3e --- /dev/null +++ b/src/decoder/intermediate_astc_block.h @@ -0,0 +1,128 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_INTERMEDIATE_ASTC_BLOCK_H_ +#define ASTC_CODEC_DECODER_INTERMEDIATE_ASTC_BLOCK_H_ + +#include "src/base/optional.h" +#include "src/base/uint128.h" +#include "src/decoder/physical_astc_block.h" + +#include +#include + +namespace astc_codec { + +// From Table C.2.7 -- These are the only valid ranges that weight +// values can take. +constexpr std::array kValidWeightRanges = +{{ 1, 2, 3, 4, 5, 7, 9, 11, 15, 19, 23, 31 }}; + +// Void extent data are all the ASTC blocks that are labeled for having a +// constant color. In the ASTC spec, some of these blocks may optionally +// have "void extent coordinates" that describe how far in texture space +// the constant color should span. If these coordinates are not valid, +// then the coordinates are all set to a fully saturated bit mask +// ((1 << 13) - 1) and the block is treated as a singular constant color. +// We call both types of these blocks "void extent" to remove confusion +// in our code. +struct VoidExtentData { + uint16_t r; + uint16_t g; + uint16_t b; + uint16_t a; + std::array coords; +}; + +// Intermediate endpoint data. Really this is just an endpoint mode +// and a couple of values that represent the data used to decode the +// RGB values from the color endpoint mode. +struct IntermediateEndpointData { + ColorEndpointMode mode; + std::vector colors; +}; + +// This is an unpacked physical ASTC block, but it does not have enough +// information to be worked with logically. It is simply a container of +// all of the unpacked ASTC information. It is used as a staging area +// for the information that is later Pack()'d into a PhysicalASTCBlock. +struct IntermediateBlockData { + int weight_grid_dim_x; + int weight_grid_dim_y; + int weight_range; + + // Quantized, non-interpolated weights + std::vector weights; + + // The 10-bit partition ID if we need one + base::Optional partition_id; + + // The dual-plane channel in [0, 3] if it exists. + base::Optional dual_plane_channel; + + // The quantized/encoded endpoint values for this block. The range of each + // endpoint value is specified by |endpoint_range|, if it exists. If not, the + // range can be queried by calling EndpointRangeForBlock + std::vector endpoints; + + // The range [0, endpoint_range] that any one endpoint value can take. Users + // should not write to this value themselves. If it is empty at the time + // someone calls Pack(), it will be automatically inferred. Otherwise, it is + // set by Unpack() based on what the underlying encoding specified. + base::Optional endpoint_range; +}; + +// Returns the maximum value that a given endpoint value can take according to +// the other settings in the block. Ignores the |endpoint_range| member +// variable. Returns negative values on error: +// -1 : Too many bits required to store weight grid +// -2 : There are too few bits allocated for color endpoint data according to +// C.2.24 in the ASTC spec +int EndpointRangeForBlock(const IntermediateBlockData& data); +inline int EndpointRangeForBlock(const VoidExtentData& data); + +// Unpacks the physical ASTC block into the intermediate block. Returns false +// if the physical block is an error encoded block, or if the physical block +// is a void extent block. On error the contents of ib are undefined. +base::Optional UnpackIntermediateBlock( + const PhysicalASTCBlock& pb); + +// Unpacks the physical ASTC block into a void extent block. Returns false +// if the physical block is an error encoded block, or if the physical block +// is an intermediate block. On error the contents of ib are undefined. +base::Optional UnpackVoidExtent(const PhysicalASTCBlock& pb); + +// Packs the given intermediate block into a physical block. Returns an error +// string if the provided values in the intermediate block emit an illegal ASTC +// encoding. In this case the results in the physical block are undefined. +base::Optional Pack(const IntermediateBlockData& data, + base::UInt128* pb); + +// Packs the given void extent block into a physical block. Returns an error +// string if the provided values in the void extent block emit an illegal ASTC +// encoding. In this case the results in the physical block are undefined. +base::Optional Pack(const VoidExtentData& data, base::UInt128* pb); + +//////////////////////////////////////////////////////////////////////////////// +// +// Impl + +inline int EndpointRangeForBlock(const VoidExtentData& data) { + // Void extent blocks use 16-bit ARGB definitions + return (1 << 16) - 1; +} + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_INTERMEDIATE_ASTC_BLOCK_H_ diff --git a/src/decoder/logical_astc_block.cc b/src/decoder/logical_astc_block.cc new file mode 100644 index 0000000..9271e18 --- /dev/null +++ b/src/decoder/logical_astc_block.cc @@ -0,0 +1,262 @@ +// 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/logical_astc_block.h" +#include "src/decoder/endpoint_codec.h" +#include "src/decoder/footprint.h" +#include "src/decoder/integer_sequence_codec.h" +#include "src/decoder/quantization.h" +#include "src/decoder/weight_infill.h" + +namespace astc_codec { + +namespace { + +Partition GenerateSinglePartition(Footprint footprint) { + return Partition { footprint, /* num_parts = */ 1, /* partition_id = */ 0, + std::vector(footprint.NumPixels(), 0) }; +} + +static std::vector DecodeEndpoints(const IntermediateBlockData& block) { + const int endpoint_range = block.endpoint_range + ? block.endpoint_range.value() + : EndpointRangeForBlock(block); + assert(endpoint_range > 0); + + std::vector endpoints; + for (const auto& eps : block.endpoints) { + RgbaColor decmp_one_rgba, decmp_two_rgba; + DecodeColorsForMode(eps.colors, endpoint_range, eps.mode, + &decmp_one_rgba, &decmp_two_rgba); + endpoints.emplace_back(decmp_one_rgba, decmp_two_rgba); + } + return endpoints; +} + +static std::vector DecodeEndpoints(const VoidExtentData& block) { + EndpointPair eps; + eps.first[0] = eps.second[0] = (block.r * 255) / 65535; + eps.first[1] = eps.second[1] = (block.g * 255) / 65535; + eps.first[2] = eps.second[2] = (block.b * 255) / 65535; + eps.first[3] = eps.second[3] = (block.a * 255) / 65535; + + std::vector endpoints; + endpoints.emplace_back(eps); + return endpoints; +} + +Partition ComputePartition(const Footprint& footprint, + const IntermediateBlockData& block) { + if (block.partition_id) { + const int part_id = block.partition_id.value(); + const size_t num_parts = block.endpoints.size(); + return GetASTCPartition(footprint, num_parts, part_id); + } else { + return GenerateSinglePartition(footprint); + } +} + +Partition ComputePartition(const Footprint& footprint, const VoidExtentData&) { + return GenerateSinglePartition(footprint); +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +LogicalASTCBlock::LogicalASTCBlock(const Footprint& footprint) + : endpoints_(1), + weights_(footprint.NumPixels(), 0), + partition_(GenerateSinglePartition(footprint)) { } + +LogicalASTCBlock::LogicalASTCBlock(const Footprint& footprint, + const IntermediateBlockData& block) + : endpoints_(DecodeEndpoints(block)), + partition_(ComputePartition(footprint, block)) { + CalculateWeights(footprint, block); +} + +LogicalASTCBlock::LogicalASTCBlock(const Footprint& footprint, + const VoidExtentData& block) + : endpoints_(DecodeEndpoints(block)), + partition_(ComputePartition(footprint, block)) { + CalculateWeights(footprint, block); +} + +void LogicalASTCBlock::CalculateWeights(const Footprint& footprint, + const IntermediateBlockData& block) { + const int grid_size_x = block.weight_grid_dim_x; + const int grid_size_y = block.weight_grid_dim_y; + const int weight_grid_size = grid_size_x * grid_size_y; + + // Either we have a dual plane and we have twice as many weights as + // specified or we don't + assert(block.dual_plane_channel + ? block.weights.size() == weight_grid_size * 2 + : block.weights.size() == weight_grid_size); + + std::vector unquantized; + unquantized.reserve(weight_grid_size); + + // According to C.2.16, if we have dual-plane weights, then we have two + // weights per texel -- one adjacent to the other. Hence, we have to skip + // some when we decode the separate weight values. + const int weight_frequency = (block.dual_plane_channel) ? 2 : 1; + const int weight_range = block.weight_range; + + for (int i = 0; i < weight_grid_size; ++i) { + const int weight = block.weights[i * weight_frequency]; + unquantized.push_back(UnquantizeWeightFromRange(weight, weight_range)); + } + weights_ = InfillWeights(unquantized, footprint, grid_size_x, grid_size_y); + + if (block.dual_plane_channel) { + SetDualPlaneChannel(block.dual_plane_channel.value()); + for (int i = 0; i < weight_grid_size; ++i) { + const int weight = block.weights[i * weight_frequency + 1]; + unquantized[i] = UnquantizeWeightFromRange(weight, weight_range); + } + dual_plane_->weights = + InfillWeights(unquantized, footprint, grid_size_x, grid_size_y); + } +} + +void LogicalASTCBlock::CalculateWeights(const Footprint& footprint, + const VoidExtentData&) { + weights_ = std::vector(footprint.NumPixels(), 0); +} + +void LogicalASTCBlock::SetWeightAt(int x, int y, int weight) { + assert(weight >= 0); + assert(weight <= 64); + weights_.at(y * GetFootprint().Width() + x) = weight; +} + +int LogicalASTCBlock::WeightAt(int x, int y) const { + return weights_.at(y * GetFootprint().Width() + x); +} + +void LogicalASTCBlock::SetDualPlaneWeightAt(int channel, int x, int y, + int weight) { + assert(weight >= 0); + assert(weight <= 64); + + // If it's not a dual plane, then this has no logical meaning + assert(IsDualPlane()); + + // If it is a dual plane and the passed channel matches the query, then we + // return the specialized weights + if (dual_plane_->channel == channel) { + dual_plane_->weights.at(y * GetFootprint().Width() + x) = weight; + } else { + // If the channel is not the special channel, then return the general weight + SetWeightAt(x, y, weight); + } +} + +int LogicalASTCBlock::DualPlaneWeightAt(int channel, int x, int y) const { + // If it's not a dual plane, then we just return the weight for all channels + if (!IsDualPlane()) { + // TODO(google): Log warning, Requesting dual-plane channel for a non + // dual-plane block! + return WeightAt(x, y); + } + + // If it is a dual plane and the passed channel matches the query, then we + // return the specialized weights + if (dual_plane_->channel == channel) { + return dual_plane_->weights.at(y * GetFootprint().Width() + x); + } + + // If the channel is not the special channel, then return the general weight + return WeightAt(x, y); +} + +void LogicalASTCBlock::SetDualPlaneChannel(int channel) { + if (channel < 0) { + dual_plane_.clear(); + } else if (dual_plane_) { + dual_plane_->channel = channel; + } else { + dual_plane_ = DualPlaneData {channel, weights_}; + } +} + +RgbaColor LogicalASTCBlock::ColorAt(int x, int y) const { + const auto footprint = GetFootprint(); + assert(x >= 0); assert(x < footprint.Width()); + assert(y >= 0); assert(y < footprint.Height()); + + const int texel_idx = y * footprint.Width() + x; + const int part = partition_.assignment[texel_idx]; + const auto& endpoints = endpoints_[part]; + + RgbaColor result; + for (int channel = 0; channel < 4; ++channel) { + const int weight = (dual_plane_ && dual_plane_->channel == channel) + ? dual_plane_->weights[texel_idx] + : weights_[texel_idx]; + const int p0 = endpoints.first[channel]; + const int p1 = endpoints.second[channel]; + + assert(p0 >= 0); assert(p0 < 256); + assert(p1 >= 0); assert(p1 < 256); + + // According to C.2.19 + const int c0 = (p0 << 8) | p0; + const int c1 = (p1 << 8) | p1; + const int c = (c0 * (64 - weight) + c1 * weight + 32) / 64; + // TODO(google): Handle conversion to sRGB or FP16 per C.2.19. + const int quantized = ((c * 255) + 32767) / 65536; + assert(quantized < 256); + result[channel] = quantized; + } + + return result; +} + +void LogicalASTCBlock::SetPartition(const Partition& p) { + assert(p.footprint == partition_.footprint && + "New partitions may not be for a different footprint"); + partition_ = p; + endpoints_.resize(p.num_parts); +} + +void LogicalASTCBlock::SetEndpoints(const EndpointPair& eps, int subset) { + assert(subset < partition_.num_parts); + assert(subset < endpoints_.size()); + + endpoints_[subset] = eps; +} + +base::Optional UnpackLogicalBlock( + const Footprint& footprint, const PhysicalASTCBlock& pb) { + if (pb.IsVoidExtent()) { + base::Optional ve = UnpackVoidExtent(pb); + if (!ve) { + return {}; + } + + return LogicalASTCBlock(footprint, ve.value()); + } else { + base::Optional ib = UnpackIntermediateBlock(pb); + if (!ib) { + return {}; + } + + return LogicalASTCBlock(footprint, ib.value()); + } +} + +} // namespace astc_codec diff --git a/src/decoder/logical_astc_block.h b/src/decoder/logical_astc_block.h new file mode 100644 index 0000000..2243eb4 --- /dev/null +++ b/src/decoder/logical_astc_block.h @@ -0,0 +1,127 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_LOGICAL_ASTC_BLOCK_H_ +#define ASTC_CODEC_DECODER_LOGICAL_ASTC_BLOCK_H_ + +#include "src/base/optional.h" +#include "src/decoder/footprint.h" +#include "src/decoder/intermediate_astc_block.h" +#include "src/decoder/partition.h" +#include "src/decoder/physical_astc_block.h" + +#include +#include +#include + +namespace astc_codec { + +// A logical ASTC block holds the endpoints, indices, and partition information +// of a compressed block. These values generally do not adhere to any +// quality-for-bitrate-imposed limits and are solely logical entities for +// determining the best representation of a given block. +class LogicalASTCBlock { + public: + LogicalASTCBlock(const LogicalASTCBlock&) = default; + LogicalASTCBlock(LogicalASTCBlock&&) = default; + + // Unpack an intermediate block into a logical one. + LogicalASTCBlock(const Footprint& footprint, + const IntermediateBlockData& block); + + // Unpack a void extent intermediate block into a logical one. + LogicalASTCBlock(const Footprint& footprint, const VoidExtentData& block); + + // Create a new, empty ASTC block + explicit LogicalASTCBlock(const Footprint& footprint); + + // Returns the footprint associated with this block. The footprint is defined + // via the partition, because the partition definition is dependent on the + // footprint. + const Footprint& GetFootprint() const { return partition_.footprint; } + + // Returns the unquantized and infilled weight in the range [0, 64] for the + // given texel location. Assumes that the block is a single-plane block, + // meaning that weights are used equally across all channels. + void SetWeightAt(int x, int y, int weight); + int WeightAt(int x, int y) const; + + // Returns the unquantized and infilled weight in the range [0, 64] for the + // given channel at the given texel location. If the block does not have a + // dual-plane channel then the reference-returning version will fail, as it + // cannot return a reference to a value that (potentially) doesn't exist. + void SetDualPlaneWeightAt(int channel, int x, int y, int weight); + int DualPlaneWeightAt(int channel, int x, int y) const; + + // Returns the color as it would be in the given pixel coordinates of the + // block. Fails if the coordinates are outside of the range of the block + // footprint + RgbaColor ColorAt(int x, int y) const; + + // Sets the current partition for the block. |p|'s footprint must match the + // return value of GetFootprint() or else this call will fail. + void SetPartition(const Partition& p); + + // Sets the endpoints for the given subset. + void SetEndpoints(const EndpointPair& eps, int subset); + void SetEndpoints(const Endpoint& ep1, const Endpoint& ep2, int subset) { + SetEndpoints(std::make_pair(ep1, ep2), subset); + } + + // Sets the dual plane channel for the block. Value must be within the range + // [0, 3]. If a negative value is passed, then the dual-plane data for the + // block is removed, and the block is treated as a single-plane block. + void SetDualPlaneChannel(int channel); + bool IsDualPlane() const { return dual_plane_.hasValue(); } + + private: + // A block may have up to four endpoint pairs. + std::vector endpoints_; + + // Weights are stored as values in the interval [0, 64]. + std::vector weights_; + + // The partition information for this block. This determines the + // appropriate subsets that each pixel should belong to. + Partition partition_; + + // Dual plane data holds both the channel and the weights that describe + // the dual plane data for the given block. If a block has a dual plane, then + // we need to know both the channel and the weights associated with it. + struct DualPlaneData { + int channel; + std::vector weights; + }; + + // The dual-plane data is optional from a logical representation of the block. + base::Optional dual_plane_; + + // Calculates the unquantized and interpolated weights from the encoded weight + // values and possibly dual-plane weights specified in the passed ASTC block. + void CalculateWeights(const Footprint& footprint, + const IntermediateBlockData& block); + + // Calculates the weights for a VoidExtentBlock. + void CalculateWeights(const Footprint& footprint, + const VoidExtentData& block); +}; + +// Unpacks the physical ASTC block into a logical block. Returns false if the +// physical block is an error encoded block. +base::Optional UnpackLogicalBlock( + const Footprint& footprint, const PhysicalASTCBlock& pb); + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_LOGICAL_ASTC_BLOCK_H_ diff --git a/src/decoder/partition.cc b/src/decoder/partition.cc new file mode 100644 index 0000000..90d39fd --- /dev/null +++ b/src/decoder/partition.cc @@ -0,0 +1,600 @@ +// 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/partition.h" +#include "src/base/bottom_n.h" +#include "src/decoder/footprint.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace astc_codec { + +namespace { + +// The maximum number of partitions supported by ASTC is four. +constexpr int kMaxNumSubsets = 4; + +// Partition selection function based on the ASTC specification. +// See section C.2.21 +int SelectASTCPartition(int seed, int x, int y, int z, int partitioncount, + int num_pixels) { + if (partitioncount <= 1) { + return 0; + } + + if (num_pixels < 31) { + x <<= 1; + y <<= 1; + z <<= 1; + } + + seed += (partitioncount - 1) * 1024; + + uint32_t rnum = seed; + rnum ^= rnum >> 15; + rnum -= rnum << 17; + rnum += rnum << 7; + rnum += rnum << 4; + rnum ^= rnum >> 5; + rnum += rnum << 16; + rnum ^= rnum >> 7; + rnum ^= rnum >> 3; + rnum ^= rnum << 6; + rnum ^= rnum >> 17; + + uint8_t seed1 = rnum & 0xF; + uint8_t seed2 = (rnum >> 4) & 0xF; + uint8_t seed3 = (rnum >> 8) & 0xF; + uint8_t seed4 = (rnum >> 12) & 0xF; + uint8_t seed5 = (rnum >> 16) & 0xF; + uint8_t seed6 = (rnum >> 20) & 0xF; + uint8_t seed7 = (rnum >> 24) & 0xF; + uint8_t seed8 = (rnum >> 28) & 0xF; + uint8_t seed9 = (rnum >> 18) & 0xF; + uint8_t seed10 = (rnum >> 22) & 0xF; + uint8_t seed11 = (rnum >> 26) & 0xF; + uint8_t seed12 = ((rnum >> 30) | (rnum << 2)) & 0xF; + + seed1 *= seed1; + seed2 *= seed2; + seed3 *= seed3; + seed4 *= seed4; + seed5 *= seed5; + seed6 *= seed6; + seed7 *= seed7; + seed8 *= seed8; + seed9 *= seed9; + seed10 *= seed10; + seed11 *= seed11; + seed12 *= seed12; + + int sh1, sh2, sh3; + if (seed & 1) { + sh1 = (seed & 2 ? 4 : 5); + sh2 = (partitioncount == 3 ? 6 : 5); + } else { + sh1 = (partitioncount == 3 ? 6 : 5); + sh2 = (seed & 2 ? 4 : 5); + } + sh3 = (seed & 0x10) ? sh1 : sh2; + + seed1 >>= sh1; + seed2 >>= sh2; + seed3 >>= sh1; + seed4 >>= sh2; + seed5 >>= sh1; + seed6 >>= sh2; + seed7 >>= sh1; + seed8 >>= sh2; + + seed9 >>= sh3; + seed10 >>= sh3; + seed11 >>= sh3; + seed12 >>= sh3; + + int a = seed1 * x + seed2 * y + seed11 * z + (rnum >> 14); + int b = seed3 * x + seed4 * y + seed12 * z + (rnum >> 10); + int c = seed5 * x + seed6 * y + seed9 * z + (rnum >> 06); + int d = seed7 * x + seed8 * y + seed10 * z + (rnum >> 02); + + a &= 0x3F; + b &= 0x3F; + c &= 0x3F; + d &= 0x3F; + + if (partitioncount <= 3) { + d = 0; + } + if (partitioncount <= 2) { + c = 0; + } + + if (a >= b && a >= c && a >= d) { + return 0; + } else if (b >= c && b >= d) { + return 1; + } else if (c >= d) { + return 2; + } else { + return 3; + } +} + +// A partition hash that we can pass to containers like std::unordered_set +struct PartitionHasher { + size_t operator()(const Partition& part) const { + // The issue here is that if we have two different partitions, A and B, then + // their hash should be equal if A and B are equal. We define the distance + // between A and B using PartitionMetric, but internally that finds a 1-1 + // mapping from labels in A to labels in B. + // + // With that in mind, when we define a hash for partitions, we need to find + // a 1-1 mapping to a 'universal' labeling scheme. Here we define that as + // the heuristic: the first encountered label will be 0, the second will be + // 1, etc. This creates a unique 1-1 mapping scheme from any partition. + // + // Note, we can't use this heuristic for the PartitionMetric, as it will + // generate very large discrepancies between similar labellings (for example + // 000...001 vs 011...111). We are just looking for a boolean distinction + // whether or not two partitions are different and don't care how different + // they are. + std::array mapping {{ -1, -1, -1, -1 }}; + int next_subset = 0; + for (int subset : part.assignment) { + if (mapping[subset] < 0) { + mapping[subset] = next_subset++; + } + } + assert(next_subset <= kMaxNumSubsets); + + // The return value will be the hash of the assignment according to this + // mapping + const auto seed = 0; + return std::accumulate(part.assignment.begin(), part.assignment.end(), seed, + [&mapping](size_t seed, const int& subset) { + std::hash hasher; + const int s = mapping[subset]; + return hasher(seed) ^ hasher(static_cast(s)); + }); + } +}; + +// Construct a VP-Tree of partitions. Since our PartitionMetric satisfies +// the triangle inequality, we can use this general higher-dimensional space +// partitioning tree to organize our partitions. +// +// TODO(google): !SPEED! Right now this tree stores an actual linked +// structure of pointers which is likely very slow during construction and +// very not cache-coherent during traversal, so it'd probably be good to +// switch to a flattened binary tree structure if performance becomes an +// issue. +class PartitionTree { + public: + // Unclear what it means to have an uninitialized tree, so delete default + // constructors, but allow the tree to be moved + PartitionTree() = delete; + PartitionTree(const PartitionTree&) = delete; + PartitionTree(PartitionTree&& t) = default; + + // Generate a PartitionTree from iterators over |Partition|s + template + PartitionTree(Itr begin, Itr end) : parts_(begin, end) { + std::vector part_indices(parts_.size()); + std::iota(part_indices.begin(), part_indices.end(), 0); + root_ = std::unique_ptr( + new PartitionTreeNode(parts_, part_indices)); + } + + // Search for the k-nearest partitions that are closest to part based on + // the result of PartitionMetric + void Search(const Partition& part, int k, + std::vector* const results, + std::vector* const distances) const { + ResultHeap heap(k); + SearchNode(root_, part, &heap); + + results->clear(); + if (nullptr != distances) { + distances->clear(); + } + + std::vector search_results = heap.Pop(); + for (const auto& result : search_results) { + results->push_back(&parts_[result.part_idx]); + if (nullptr != distances) { + distances->push_back(result.distance); + } + } + + assert(results->size() == k); + } + + private: + // Heap elements to be stored while searching the tree. The two relevant + // pieces of information are the partition index and it's distance from the + // queried partition. + struct ResultNode { + int part_idx; + int distance; + + // Heap based on distance from query point. + bool operator<(const ResultNode& other) const { + return distance < other.distance; + } + }; + + using ResultHeap = base::BottomN; + + struct PartitionTreeNode { + int part_idx; + int split_dist; + + std::unique_ptr left; + std::unique_ptr right; + + PartitionTreeNode(const std::vector &parts, + const std::vector &part_indices) + : split_dist(-1) { + assert(part_indices.size() > 0); + + right.reset(nullptr); + left.reset(nullptr); + + // Store the first node as our vantage point + part_idx = part_indices[0]; + const Partition& vantage_point = parts[part_indices[0]]; + + // Calculate the distances of the remaining nodes against the vantage + // point. + std::vector> part_dists; + for (int i = 1; i < part_indices.size(); ++i) { + const int idx = part_indices[i]; + const int dist = PartitionMetric(vantage_point, parts[idx]); + if (dist > 0) { + part_dists.push_back(std::make_pair(idx, dist)); + } + } + + // If there are no more different parts, then this is a leaf node + if (part_dists.empty()) { + return; + } + + struct OrderBySecond { + typedef std::pair PairType; + bool operator()(const PairType& lhs, const PairType& rhs) { + return lhs.second < rhs.second; + } + }; + + // We want to partition the set such that the points are ordered + // based on their distances from the vantage point. We can do this + // using the partial sort of nth element. + std::nth_element( + part_dists.begin(), part_dists.begin() + part_dists.size() / 2, + part_dists.end(), OrderBySecond()); + + // Once that's done, our split position is in the middle + const auto split_iter = part_dists.begin() + part_dists.size() / 2; + split_dist = split_iter->second; + + // Recurse down the right and left sub-trees with the indices of the + // parts that are farther and closer respectively + std::vector right_indices; + for (auto itr = split_iter; itr != part_dists.end(); ++itr) { + right_indices.push_back(itr->first); + } + + if (!right_indices.empty()) { + right.reset(new PartitionTreeNode(parts, right_indices)); + } + + std::vector left_indices; + for (auto itr = part_dists.begin(); itr != split_iter; ++itr) { + left_indices.push_back(itr->first); + } + + if (!left_indices.empty()) { + left.reset(new PartitionTreeNode(parts, left_indices)); + } + } + }; + + void SearchNode(const std::unique_ptr& node, + const Partition& p, ResultHeap* const heap) const { + if (nullptr == node) { + return; + } + + // Calculate distance against current node + const int dist = PartitionMetric(parts_[node->part_idx], p); + + // Push it onto the heap and remove the top-most nodes to maintain + // closest k indices. + ResultNode result; + result.part_idx = node->part_idx; + result.distance = dist; + heap->Push(result); + + // If the split distance is uninitialized, it means we have no children. + if (node->split_dist < 0) { + assert(nullptr == node->left); + assert(nullptr == node->right); + return; + } + + // Next we need to check the left and right trees if their distance + // is closer/farther than the farthest element on the heap + const int tau = heap->Top().distance; + if (dist + tau < node->split_dist || dist - tau < node->split_dist) { + SearchNode(node->left, p, heap); + } + + if (dist + tau > node->split_dist || dist - tau > node->split_dist) { + SearchNode(node->right, p, heap); + } + } + + std::vector parts_; + std::unique_ptr root_; +}; + +// A helper function that generates all of the partitions for each number of +// subsets in ASTC blocks and stores them in a PartitionTree for fast retrieval. +const int kNumASTCPartitionIDBits = 10; +PartitionTree GenerateASTCPartitionTree(Footprint footprint) { + std::unordered_set parts; + for (int num_parts = 2; num_parts <= kMaxNumSubsets; ++num_parts) { + for (int id = 0; id < (1 << kNumASTCPartitionIDBits); ++id) { + Partition part = GetASTCPartition(footprint, num_parts, id); + + // Make sure we're not using a degenerate partition assignment that wastes + // an endpoint pair... + bool valid_part = true; + for (int i = 0; i < num_parts; ++i) { + if (std::find(part.assignment.begin(), part.assignment.end(), i) == + part.assignment.end()) { + valid_part = false; + break; + } + } + + if (valid_part) { + parts.insert(std::move(part)); + } + } + } + + return PartitionTree(parts.begin(), parts.end()); +} + +// To avoid needing any fancy boilerplate for mapping from a width, height +// tuple, we can define a simple encoding for the block mode: +constexpr int EncodeDims(int width, int height) { + return (width << 16) | height; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +int PartitionMetric(const Partition& a, const Partition& b) { + // Make sure that one partition is at least a subset of the other... + assert(a.footprint == b.footprint); + + // Make sure that the number of parts is within our limits. ASTC has a maximum + // of four subsets per block according to the specification. + assert(a.num_parts <= kMaxNumSubsets); + assert(b.num_parts <= kMaxNumSubsets); + + const int w = a.footprint.Width(); + const int h = b.footprint.Height(); + + struct PairCount { + int a; + int b; + int count; + + // Comparison needed for sort below. + bool operator>(const PairCount& other) const { + return count > other.count; + } + }; + + // Since we need to find the smallest mapping from labels in A to labels in B, + // we need to store each label pair in a structure that can later be sorted. + // The maximum number of subsets in an ASTC block is four, meaning that + // between the two partitions, we can have up to sixteen different pairs. + std::array pair_counts; + for (int y = 0; y < 4; ++y) { + for (int x = 0; x < 4; ++x) { + const int idx = y * 4 + x; + pair_counts[idx].a = x; + pair_counts[idx].b = y; + pair_counts[idx].count = 0; + } + } + + // Count how many times we see each pair of assigned values (order matters!) + for (int y = 0; y < h; ++y) { + for (int x = 0; x < w; ++x) { + const int idx = y * w + x; + + const int a_val = a.assignment[idx]; + const int b_val = b.assignment[idx]; + + assert(a_val >= 0); + assert(b_val >= 0); + + assert(a_val < 4); + assert(b_val < 4); + + ++(pair_counts[b_val * 4 + a_val].count); + } + } + + // Sort the pairs in descending order based on their count + std::sort(pair_counts.begin(), pair_counts.end(), std::greater()); + + // Now assign pairs one by one until we have no more pairs to assign. Once + // a value from A is assigned to a value in B, it can no longer be reassigned, + // so we can keep track of this in a matrix. Similarly, to keep the assignment + // one-to-one, once a value in B has been assigned to, it cannot be assigned + // to again. + std::array, kMaxNumSubsets> assigned { }; + + int pixels_matched = 0; + for (const auto& pair_count : pair_counts) { + bool is_assigned = false; + for (int i = 0; i < kMaxNumSubsets; ++i) { + is_assigned |= assigned.at(pair_count.a).at(i); + is_assigned |= assigned.at(i).at(pair_count.b); + } + + if (!is_assigned) { + assigned.at(pair_count.a).at(pair_count.b) = true; + pixels_matched += pair_count.count; + } + } + + // The difference is the number of pixels that had an assignment versus the + // total number of pixels. + return w * h - pixels_matched; +} + +// Generates the partition assignment for the given block attributes. +Partition GetASTCPartition(const Footprint& footprint, int num_parts, + int partition_id) { + // Partitions must have at least one subset but may have at most four + assert(num_parts >= 0); + assert(num_parts <= kMaxNumSubsets); + + // Partition ID can be no more than 10 bits. + assert(partition_id >= 0); + assert(partition_id < 1 << 10); + + Partition part = {footprint, num_parts, partition_id, /* assignment = */ {}}; + part.assignment.reserve(footprint.NumPixels()); + + // Maintain column-major order so that we match all of the image processing + // algorithms that depend on this class. + for (int y = 0; y < footprint.Height(); ++y) { + for (int x = 0; x < footprint.Width(); ++x) { + const int p = SelectASTCPartition(partition_id, x, y, 0, num_parts, + footprint.NumPixels()); + part.assignment.push_back(p); + } + } + + return part; +} + +const std::vector FindKClosestASTCPartitions( + const Partition& candidate, int k) { + const int encoded_dims = EncodeDims(candidate.footprint.Width(), + candidate.footprint.Height()); + + int index = 0; + switch (encoded_dims) { + case EncodeDims(4, 4): index = 0; break; + case EncodeDims(5, 4): index = 1; break; + case EncodeDims(5, 5): index = 2; break; + case EncodeDims(6, 5): index = 3; break; + case EncodeDims(6, 6): index = 4; break; + case EncodeDims(8, 5): index = 5; break; + case EncodeDims(8, 6): index = 6; break; + case EncodeDims(8, 8): index = 7; break; + case EncodeDims(10, 5): index = 8; break; + case EncodeDims(10, 6): index = 9; break; + case EncodeDims(10, 8): index = 10; break; + case EncodeDims(10, 10): index = 11; break; + case EncodeDims(12, 10): index = 12; break; + case EncodeDims(12, 12): index = 13; break; + default: + assert(false && "Unknown footprint dimensions. This should have been caught sooner."); + break; + } + + static const auto* const kASTCPartitionTrees = + new std::array {{ + GenerateASTCPartitionTree(Footprint::Get4x4()), + GenerateASTCPartitionTree(Footprint::Get5x4()), + GenerateASTCPartitionTree(Footprint::Get5x5()), + GenerateASTCPartitionTree(Footprint::Get6x5()), + GenerateASTCPartitionTree(Footprint::Get6x6()), + GenerateASTCPartitionTree(Footprint::Get8x5()), + GenerateASTCPartitionTree(Footprint::Get8x6()), + GenerateASTCPartitionTree(Footprint::Get8x8()), + GenerateASTCPartitionTree(Footprint::Get10x5()), + GenerateASTCPartitionTree(Footprint::Get10x6()), + GenerateASTCPartitionTree(Footprint::Get10x8()), + GenerateASTCPartitionTree(Footprint::Get10x10()), + GenerateASTCPartitionTree(Footprint::Get12x10()), + GenerateASTCPartitionTree(Footprint::Get12x12()), + }}; + + const PartitionTree& parts_vptree = kASTCPartitionTrees->at(index); + std::vector results; + parts_vptree.Search(candidate, k, &results, nullptr); + return results; +} + +// Returns the valid ASTC partition that is closest to the candidate based on +// the PartitionMetric defined above. +const Partition& FindClosestASTCPartition(const Partition& candidate) { + // Given a candidate, the closest valid partition will likely not be an exact + // match. Consider all of the texels for which this valid partition differs + // with the candidate. + // + // If the valid partition has more subsets than the candidate, then all of the + // highest subset will be included in the mismatched texels. Since the number + // of possible partitions with increasing subsets grows exponentially, the + // chance that a valid partition with fewer subsets appears within the first + // few closest partitions is relatively high. Empirically, we can usually find + // a partition with at most |candidate.num_parts| number of subsets within the + // first four closest partitions. + constexpr int kSearchItems = 4; + + const std::vector results = + FindKClosestASTCPartitions(candidate, kSearchItems); + + // Optimistically, look for result with the same number of subsets. + for (const auto& result : results) { + if (result->num_parts == candidate.num_parts) { + return *result; + } + } + + // If all else fails, then at least find the result with fewer subsets than + // we asked for. + for (const auto& result : results) { + if (result->num_parts < candidate.num_parts) { + return *result; + } + } + + assert(false && + "Could not find partition with acceptable number of subsets!"); + return *(results[0]); +} + +} // namespace astc_codec diff --git a/src/decoder/partition.h b/src/decoder/partition.h new file mode 100644 index 0000000..4f64acb --- /dev/null +++ b/src/decoder/partition.h @@ -0,0 +1,97 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_PARTITION_H_ +#define ASTC_CODEC_DECODER_PARTITION_H_ + +#include "src/base/optional.h" +#include "src/decoder/footprint.h" + +#include + +namespace astc_codec { + +struct Partition; + +// Determines the "difference" between any two partitions of the same size. +// This metric attempts to find the best one to one mapping from the labels in +// partition a against the labels in partition b. Once that mapping is found, it +// returns the number of pixels that are mismatched between the two. Each +// partition is expected to start in the upper left corner of the block and +// proceed in raster-scan order. Two partitions are equal if the mapping is +// bijective. This metric is a metric in the mathematical sense. In other words +// it has the following properties: +// +// 1) PartitionMetric(a, b) >= 0 +// 2) PartitionMetric(a, b) == PartitionMetric(b, a) +// 3) PartitionMetric(a, b) == 0 iff a == b +// 4) PartitionMetric(a, b) + PartitionMetric(b, c) >= PartitionMetric(a, c) +// +// Throws an error if one partition's footprint is not equal to the other. +int PartitionMetric(const Partition& a, const Partition& b); + +// A partition is a way to divide up an ASTC block into disjoint subsets such +// that each subset uses a different set of endpoints. This is used to increase +// the compression quality of blocks. One way to store such a partition is to +// assign an ID to use with a predetermined decoding method. Here we store the +// logical representation of partitions by keeping a per-pixel label. All pixels +// that share a label belong to the same subset. +struct Partition { + // The footprint width and height of this partition. This determines the size + // of the assignment array. + Footprint footprint; + + // The number of subsets in this partition. The values in the partition + // assignment fall within the range [0, num_parts). The maximum number of + // parts supported is four. + int num_parts; + + // The 10-bit partition ID as stored in bits 13-22 of multi-part ASTC blocks. + // (See Section C.2.9) If there is no guarantee that this partition is a valid + // ASTC partition, this should be set to absl::nullopt. + base::Optional partition_id; + + // A value in the range [0, num_parts) corresponding to the label for + // the given texel (x, y) in [0, footprint_width) x [0, footprint_height) + // using a raster-order layout. + std::vector assignment; + + // Returns true only if their "distance" is zero, i.e. if they have compatible + // subset assignments. + bool operator==(const Partition& other) const { + return PartitionMetric(*this, other) == 0; + } +}; + +// Generates the ASTC partition assignment for the given block attributes. +Partition GetASTCPartition(const Footprint& footprint, int num_parts, + int partition_id); + +// Returns the |k| valid ASTC partitions that are closest to the candidate based +// on the PartitionMetric defined above. +const std::vector FindKClosestASTCPartitions( + const Partition& candidate, int k); + +// Returns the valid ASTC partition closest to the candidate with at most as +// many subsets as the |candidate|. Note: this is not a deterministic function, +// as the underlying valid partitions are sorted using a hash map and a distance +// function whose range is the natural numbers. The chances that two or more +// partitions are equally 'closest' is possible, in which case this function +// makes no guarantees about which one it will return. For more control, use +// FindKClosestASTCPartitions above. +const Partition& FindClosestASTCPartition(const Partition& candidate); + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_PARTITION_H_ diff --git a/src/decoder/physical_astc_block.cc b/src/decoder/physical_astc_block.cc new file mode 100644 index 0000000..7cc4d8e --- /dev/null +++ b/src/decoder/physical_astc_block.cc @@ -0,0 +1,761 @@ +// 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/physical_astc_block.h" +#include "src/base/math_utils.h" +#include "src/base/optional.h" +#include "src/base/uint128.h" +#include "src/decoder/integer_sequence_codec.h" + +#include +#include + +namespace astc_codec { + +namespace { + +static_assert(static_cast(ColorEndpointMode::kNumColorEndpointModes) == 16, + "There are only sixteen color endpoint modes defined in the " + "ASTC specification. If this is false, then the enum may be " + "incorrect."); + +constexpr int kASTCBlockSizeBits = 128; +constexpr int kASTCBlockSizeBytes = kASTCBlockSizeBits / 8; +constexpr uint32_t kVoidExtentMaskBits = 9; +constexpr uint32_t kVoidExtentMask = 0x1FC; +constexpr int kWeightGridMinBitLength = 24; +constexpr int kWeightGridMaxBitLength = 96; +constexpr int kMaxNumPartitions = 4; +constexpr int kMaxNumWeights = 64; + +// These are the overall block modes defined in table C.2.8. There are 10 +// weight grid encoding schemes + void extent. +enum class BlockMode { + kB4_A2, + kB8_A2, + kA2_B8, + kA2_B6, + kB2_A2, + k12_A2, + kA2_12, + k6_10, + k10_6, + kA6_B6, + kVoidExtent, +}; + +struct WeightGridProperties { + int width; + int height; + int range; +}; + +// Local function prototypes +base::Optional DecodeBlockMode(const base::UInt128 astc_bits); +base::Optional DecodeWeightProps( + const base::UInt128 astc_bits, std::string* error); +std::array DecodeVoidExtentCoords(const base::UInt128 astc_bits); +bool DecodeDualPlaneBit(const base::UInt128 astc_bits); +int DecodeNumPartitions(const base::UInt128 astc_bits); +int DecodeNumWeightBits(const base::UInt128 astc_bits); +int DecodeDualPlaneBitStartPos(const base::UInt128 astc_bits); +ColorEndpointMode DecodeEndpointMode(const base::UInt128 astc_bits, + int partition); +int DecodeNumColorValues(const base::UInt128 astc_bits); + +// Returns the block mode, if it's valid. +base::Optional DecodeBlockMode(const base::UInt128 astc_bits) { + using Result = base::Optional; + const uint64_t low_bits = astc_bits.LowBits(); + if (base::GetBits(low_bits, 0, kVoidExtentMaskBits) == kVoidExtentMask) { + return Result(BlockMode::kVoidExtent); + } + + if (base::GetBits(low_bits, 0, 2) != 0) { + const uint64_t mode_bits = base::GetBits(low_bits, 2, 2); + switch (mode_bits) { + case 0: return Result(BlockMode::kB4_A2); + case 1: return Result(BlockMode::kB8_A2); + case 2: return Result(BlockMode::kA2_B8); + case 3: return base::GetBits(low_bits, 8, 1) ? + Result(BlockMode::kB2_A2) : Result(BlockMode::kA2_B6); + } + } else { + const uint64_t mode_bits = base::GetBits(low_bits, 5, 4); + if ((mode_bits & 0xC) == 0x0) { + if (base::GetBits(low_bits, 0, 4) == 0) { + // Reserved. + return Result(); + } else { + return Result(BlockMode::k12_A2); + } + } else if ((mode_bits & 0xC) == 0x4) { + return Result(BlockMode::kA2_12); + } else if (mode_bits == 0xC) { + return Result(BlockMode::k6_10); + } else if (mode_bits == 0xD) { + return Result(BlockMode::k10_6); + } else if ((mode_bits & 0xC) == 0x8) { + return Result(BlockMode::kA6_B6); + } + } + + return Result(); +} + +base::Optional DecodeWeightProps( + const base::UInt128 astc_bits, std::string* error) { + auto block_mode = DecodeBlockMode(astc_bits); + if (!block_mode) { + *error = "Reserved block mode"; + return {}; + } + + // The dimensions of the weight grid and their range + WeightGridProperties props; + + // Determine the weight extents based on the block mode + const uint32_t low_bits = + static_cast(astc_bits.LowBits() & 0xFFFFFFFF); + switch (block_mode.value()) { + case BlockMode::kB4_A2: { + int a = base::GetBits(low_bits, 5, 2); + int b = base::GetBits(low_bits, 7, 2); + props.width = b + 4; + props.height = a + 2; + } + break; + + case BlockMode::kB8_A2: { + int a = base::GetBits(low_bits, 5, 2); + int b = base::GetBits(low_bits, 7, 2); + props.width = b + 8; + props.height = a + 2; + } + break; + + case BlockMode::kA2_B8: { + int a = base::GetBits(low_bits, 5, 2); + int b = base::GetBits(low_bits, 7, 2); + props.width = a + 2; + props.height = b + 8; + } + break; + + case BlockMode::kA2_B6: { + int a = base::GetBits(low_bits, 5, 2); + int b = base::GetBits(low_bits, 7, 1); + props.width = a + 2; + props.height = b + 6; + } + break; + + case BlockMode::kB2_A2: { + int a = base::GetBits(low_bits, 5, 2); + int b = base::GetBits(low_bits, 7, 1); + props.width = b + 2; + props.height = a + 2; + } + break; + + case BlockMode::k12_A2: { + int a = base::GetBits(low_bits, 5, 2); + props.width = 12; + props.height = a + 2; + } + break; + + case BlockMode::kA2_12: { + int a = base::GetBits(low_bits, 5, 2); + props.width = a + 2; + props.height = 12; + } + break; + + case BlockMode::k6_10: { + props.width = 6; + props.height = 10; + } + break; + + case BlockMode::k10_6: { + props.width = 10; + props.height = 6; + } + break; + + case BlockMode::kA6_B6: { + int a = base::GetBits(low_bits, 5, 2); + int b = base::GetBits(low_bits, 9, 2); + props.width = a + 6; + props.height = b + 6; + } + break; + + // Void extent blocks have no weight grid. + case BlockMode::kVoidExtent: + *error = "Void extent block has no weight grid"; + return {}; + + // We have a valid block mode which isn't a void extent? We + // should be able to decode the weight grid dimensions. + default: + assert(false && "Error decoding weight grid"); + *error = "Internal error"; + return {}; + } + + // Determine the weight range based on the block mode + uint32_t r = base::GetBits(low_bits, 4, 1); + switch (block_mode.value()) { + case BlockMode::kB4_A2: + case BlockMode::kB8_A2: + case BlockMode::kA2_B8: + case BlockMode::kA2_B6: + case BlockMode::kB2_A2: { + r |= base::GetBits(low_bits, 0, 2) << 1; + } + break; + + case BlockMode::k12_A2: + case BlockMode::kA2_12: + case BlockMode::k6_10: + case BlockMode::k10_6: + case BlockMode::kA6_B6: { + r |= base::GetBits(low_bits, 2, 2) << 1; + } + break; + + // We have a valid block mode which doesn't have weights? We + // should have caught this earlier. + case BlockMode::kVoidExtent: + default: + assert(false && "Error decoding weight grid"); + *error = "Internal error"; + return {}; + } + + // Decode the range... + // High bit is in bit 9 unless we're using a particular block mode + uint32_t h = base::GetBits(low_bits, 9, 1); + if (block_mode == BlockMode::kA6_B6) { + h = 0; + } + + // Figure out the range of the weights (Table C.2.7) + constexpr std::array kWeightRanges = {{ + -1, -1, 1, 2, 3, 4, 5, 7, -1, -1, 9, 11, 15, 19, 23, 31 + }}; + + assert(((h << 3) | r) < kWeightRanges.size()); + + props.range = kWeightRanges.at((h << 3) | r); + if (props.range < 0) { + *error = "Reserved range for weight bits"; + return {}; + } + + // Error checking -- do we have too many weights? + int num_weights = props.width * props.height; + if (DecodeDualPlaneBit(astc_bits)) { + num_weights *= 2; + } + + if (kMaxNumWeights < num_weights) { + *error = "Too many weights specified"; + return {}; + } + + // Do we have too many weight bits? + const int bit_count = + IntegerSequenceCodec::GetBitCountForRange(num_weights, props.range); + + if (bit_count < kWeightGridMinBitLength) { + *error = "Too few bits required for weight grid"; + return {}; + } + + if (kWeightGridMaxBitLength < bit_count) { + *error = "Too many bits required for weight grid"; + return {}; + } + + return props; +} + +// Returns the four 13-bit integers that define the range of texture +// coordinates present in a void extent block as defined in Section +// C.2.23 of the specification. The coordinates returned are of +// the form (min_s, max_s, min_t, max_t) +std::array DecodeVoidExtentCoords(const base::UInt128 astc_bits) { + const uint64_t low_bits = astc_bits.LowBits(); + + std::array coords; + for (int i = 0; i < 4; ++i) { + coords[i] = static_cast(base::GetBits(low_bits, 12 + 13 * i, 13)); + } + + return coords; +} + +bool DecodeDualPlaneBit(const base::UInt128 astc_bits) { + base::Optional block_mode = DecodeBlockMode(astc_bits); + + // Void extent blocks certainly aren't dual-plane. + if (block_mode == BlockMode::kVoidExtent) { + return false; + } + + // One special block mode doesn't have any dual plane bit + if (block_mode == BlockMode::kA6_B6) { + return false; + } + + // Otherwise, dual plane is determined by the 10th bit. + constexpr int kDualPlaneBitPosition = 10; + return base::GetBits(astc_bits, kDualPlaneBitPosition, 1) != 0; +} + +int DecodeNumPartitions(const base::UInt128 astc_bits) { + constexpr int kNumPartitionsBitPosition = 11; + constexpr int kNumPartitionsBitLength = 2; + + // Non-void extent blocks + const uint64_t low_bits = astc_bits.LowBits(); + const int num_partitions = 1 + static_cast( + base::GetBits(low_bits, + kNumPartitionsBitPosition, + kNumPartitionsBitLength)); + assert(num_partitions > 0); + assert(num_partitions <= kMaxNumPartitions); + + return num_partitions; +} + +int DecodeNumWeightBits(const base::UInt128 astc_bits) { + std::string error; + auto maybe_weight_props = DecodeWeightProps(astc_bits, &error); + if (!maybe_weight_props.hasValue()) { + return 0; // No weights? No weight bits... + } + + const auto weight_props = maybe_weight_props.value(); + + // Figure out the number of weights + int num_weights = weight_props.width * weight_props.height; + if (DecodeDualPlaneBit(astc_bits)) { + num_weights *= 2; + } + + // The number of bits is determined by the number of values + // that are going to be encoded using the given ise_counts. + return IntegerSequenceCodec::GetBitCountForRange( + num_weights, weight_props.range); +} + +// Returns the number of bits after the weight data used to +// store additional CEM bits. +int DecodeNumExtraCEMBits(const base::UInt128 astc_bits) { + const int num_partitions = DecodeNumPartitions(astc_bits); + + // Do we only have one partition? + if (num_partitions == 1) { + return 0; + } + + // Do we have a shared CEM? + constexpr int kSharedCEMBitPosition = 23; + constexpr int kSharedCEMBitLength = 2; + const base::UInt128 shared_cem = + base::GetBits(astc_bits, kSharedCEMBitPosition, kSharedCEMBitLength); + if (shared_cem == 0) { + return 0; + } + + const std::array extra_cem_bits_for_partition = {{ 0, 2, 5, 8 }}; + return extra_cem_bits_for_partition[num_partitions - 1]; +} + +// Returns the starting position of the dual plane channel. This comes +// before the weight data and extra CEM bits. +int DecodeDualPlaneBitStartPos(const base::UInt128 astc_bits) { + const int start_pos = kASTCBlockSizeBits + - DecodeNumWeightBits(astc_bits) + - DecodeNumExtraCEMBits(astc_bits); + + if (DecodeDualPlaneBit(astc_bits)) { + return start_pos - 2; + } else { + return start_pos; + } +} + +// Decodes a CEM mode based on the partition number. +ColorEndpointMode DecodeEndpointMode(const base::UInt128 astc_bits, + int partition) { + int num_partitions = DecodeNumPartitions(astc_bits); + assert(partition >= 0); + assert(partition < num_partitions); + + // Do we only have one partition? + uint64_t low_bits = astc_bits.LowBits(); + if (num_partitions == 1) { + uint64_t cem = base::GetBits(low_bits, 13, 4); + return static_cast(cem); + } + + // More than one partition ... do we have a shared CEM? + if (DecodeNumExtraCEMBits(astc_bits) == 0) { + const uint64_t shared_cem = base::GetBits(low_bits, 25, 4); + return static_cast(shared_cem); + } + + // More than one partition and no shared CEM... + uint64_t cem = base::GetBits(low_bits, 23, 6); + const int base_cem = static_cast(((cem & 0x3) - 1) * 4); + cem >>= 2; // Skip the base CEM bits + + // The number of extra CEM bits at the end of the weight grid is + // determined by the number of partitions and what the base cem mode is... + const int num_extra_cem_bits = DecodeNumExtraCEMBits(astc_bits); + const int extra_cem_start_pos = kASTCBlockSizeBits + - num_extra_cem_bits + - DecodeNumWeightBits(astc_bits); + + base::UInt128 extra_cem = + base::GetBits(astc_bits, extra_cem_start_pos, num_extra_cem_bits); + cem |= extra_cem.LowBits() << 4; + + // Decode C and M per Figure C.4 + int c = -1, m = -1; + for (int i = 0; i < num_partitions; ++i) { + if (i == partition) { + c = cem & 0x1; + } + cem >>= 1; + } + + for (int i = 0; i < num_partitions; ++i) { + if (i == partition) { + m = cem & 0x3; + } + cem >>= 2; + } + + assert(c >= 0); + assert(m >= 0); + + // Compute the mode based on C and M + const int mode = base_cem + 4 * c + m; + assert(mode < static_cast(ColorEndpointMode::kNumColorEndpointModes)); + return static_cast(mode); +} + +int DecodeNumColorValues(const base::UInt128 astc_bits) { + int num_color_values = 0; + auto num_partitions = DecodeNumPartitions(astc_bits); + for (int i = 0; i < num_partitions; ++i) { + ColorEndpointMode endpoint_mode = DecodeEndpointMode(astc_bits, i); + num_color_values += NumColorValuesForEndpointMode(endpoint_mode); + } + + return num_color_values; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +static_assert(sizeof(PhysicalASTCBlock) == PhysicalASTCBlock::kSizeInBytes, + "The size of the struct should be the size of the block so that" + "we can effectively use them contiguously in memory."); + +PhysicalASTCBlock::PhysicalASTCBlock(const base::UInt128 astc_block) + : astc_bits_(astc_block) {} + +PhysicalASTCBlock::PhysicalASTCBlock(const std::string& encoded_block) + : astc_bits_([&encoded_block]() { + assert(encoded_block.size() == PhysicalASTCBlock::kSizeInBytes); + base::UInt128 astc_bits = 0; + int shift = 0; + for (const unsigned char c : encoded_block) { + astc_bits |= base::UInt128(static_cast(c)) << shift; + shift += 8; + } + return astc_bits; + }()) +{ } + +base::Optional PhysicalASTCBlock::IsIllegalEncoding() const { + // If the block is not a void extent block, then it must have + // weights specified. DecodeWeightProps will return the weight specifications + // if they exist and are legal according to C.2.24, and will otherwise be + // empty. + base::Optional block_mode = DecodeBlockMode(astc_bits_); + if (block_mode != BlockMode::kVoidExtent) { + std::string error; + auto maybe_weight_props = DecodeWeightProps(astc_bits_, &error); + if (!maybe_weight_props.hasValue()) { + return error; + } + } + + // Check void extent blocks... + if (block_mode == BlockMode::kVoidExtent) { + // ... for reserved bits incorrectly set + if (base::GetBits(astc_bits_, 10, 2) != 0x3) { + return std::string("Reserved bits set for void extent block"); + } + + // ... for incorrectly defined texture coordinates + std::array coords = DecodeVoidExtentCoords(astc_bits_); + + bool coords_all_1s = true; + for (const auto coord : coords) { + coords_all_1s &= coord == ((1 << 13) - 1); + } + + if (!coords_all_1s && (coords[0] >= coords[1] || coords[2] >= coords[3])) { + return std::string("Void extent texture coordinates are invalid"); + } + } + + // If the number of color values exceeds a threshold and it isn't a void + // extent block then we've run into an error + if (block_mode != BlockMode::kVoidExtent) { + int num_color_vals = DecodeNumColorValues(astc_bits_); + if (num_color_vals > 18) { + return std::string("Too many color values"); + } + + // The maximum number of available color bits is the number of + // bits between the dual plane bits and the base CEM. This must + // be larger than a threshold defined in C.2.24. + + // Dual plane bit starts after weight bits and CEM + const int num_partitions = DecodeNumPartitions(astc_bits_); + const int dual_plane_start_pos = DecodeDualPlaneBitStartPos(astc_bits_); + const int color_start_bit = (num_partitions == 1) ? 17 : 29; + + const int required_color_bits = ((13 * num_color_vals) + 4) / 5; + const int available_color_bits = dual_plane_start_pos - color_start_bit; + if (available_color_bits < required_color_bits) { + return std::string("Not enough color bits"); + } + + // If we have four partitions and a dual plane then we have a problem. + if (num_partitions == 4 && DecodeDualPlaneBit(astc_bits_)) { + return std::string("Both four partitions and dual plane specified"); + } + } + + // Otherwise we're OK + return { }; +} + +bool PhysicalASTCBlock::IsVoidExtent() const { + // If it's an error block, it's not a void extent block. + if (IsIllegalEncoding()) { + return false; + } + + return DecodeBlockMode(astc_bits_) == BlockMode::kVoidExtent; +} + +base::Optional> PhysicalASTCBlock::VoidExtentCoords() const { + if (IsIllegalEncoding() || !IsVoidExtent()) { + return { }; + } + + // If void extent coords are all 1's then these are not valid void extent + // coords + const uint64_t ve_mask = 0xFFFFFFFFFFFFFDFFULL; + const uint64_t const_blk_mode = 0xFFFFFFFFFFFFFDFCULL; + if ((ve_mask & astc_bits_.LowBits()) == const_blk_mode) { + return {}; + } + + return DecodeVoidExtentCoords(astc_bits_); +} + +bool PhysicalASTCBlock::IsDualPlane() const { + // If it's an error block, then we aren't a dual plane block + if (IsIllegalEncoding()) { + return false; + } + + return DecodeDualPlaneBit(astc_bits_); +} + +// Returns the number of weight bits present in this block +base::Optional PhysicalASTCBlock::NumWeightBits() const { + // If it's an error block, then we have no weight bits. + if (IsIllegalEncoding()) return { }; + + // If it's a void extent block, we have no weight bits + if (IsVoidExtent()) return { }; + + return DecodeNumWeightBits(astc_bits_); +} + +base::Optional PhysicalASTCBlock::WeightStartBit() const { + if (IsIllegalEncoding()) return { }; + if (IsVoidExtent()) return { }; + + return kASTCBlockSizeBits - DecodeNumWeightBits(astc_bits_); +} + +base::Optional> PhysicalASTCBlock::WeightGridDims() const { + std::string error; + auto weight_props = DecodeWeightProps(astc_bits_, &error); + + if (!weight_props.hasValue()) return { }; + if (IsIllegalEncoding()) return { }; + + const auto props = weight_props.value(); + return {{{ props.width, props.height }}}; +} + +base::Optional PhysicalASTCBlock::WeightRange() const { + std::string error; + auto weight_props = DecodeWeightProps(astc_bits_, &error); + + if (!weight_props.hasValue()) return { }; + if (IsIllegalEncoding()) return { }; + + return weight_props.value().range; +} + +base::Optional PhysicalASTCBlock::DualPlaneChannel() const { + if (!IsDualPlane()) return { }; + + int dual_plane_start_pos = DecodeDualPlaneBitStartPos(astc_bits_); + auto plane_bits = base::GetBits(astc_bits_, dual_plane_start_pos, 2); + return base::Optional(static_cast(plane_bits.LowBits())); +} + +base::Optional PhysicalASTCBlock::ColorStartBit() const { + if (IsVoidExtent()) { + return 64; + } + + auto num_partitions = NumPartitions(); + if (!num_partitions) return { }; + + return (num_partitions == 1) ? 17 : 29; +} + +base::Optional PhysicalASTCBlock::NumColorValues() const { + // If we have a void extent block, then we have four color values + if (IsVoidExtent()) { + return 4; + } + + // If we have an illegal encoding, then we have no color values + if (IsIllegalEncoding()) return { }; + + return DecodeNumColorValues(astc_bits_); +} + +void PhysicalASTCBlock::GetColorValuesInfo(int* const color_bits, + int* const color_range) const { + // Figure out the range possible for the number of values we have... + const int dual_plane_start_pos = DecodeDualPlaneBitStartPos(astc_bits_); + const int max_color_bits = dual_plane_start_pos - ColorStartBit().value(); + const int num_color_values = NumColorValues().value(); + for (int range = 255; range > 0; --range) { + const int bitcount = + IntegerSequenceCodec::GetBitCountForRange(num_color_values, range); + if (bitcount <= max_color_bits) { + if (color_bits != nullptr) { + *color_bits = bitcount; + } + + if (color_range != nullptr) { + *color_range = range; + } + return; + } + } + + assert(false && + "This means that even if we have a range of one there aren't " + "enough bits to store the color values, and our encoding is " + "illegal."); +} + +base::Optional PhysicalASTCBlock::NumColorBits() const { + if (IsIllegalEncoding()) return { }; + + if (IsVoidExtent()) { + return 64; + } + + int color_bits; + GetColorValuesInfo(&color_bits, nullptr); + return color_bits; +} + +base::Optional PhysicalASTCBlock::ColorValuesRange() const { + if (IsIllegalEncoding()) return { }; + + if (IsVoidExtent()) { + return (1 << 16) - 1; + } + + int color_range; + GetColorValuesInfo(nullptr, &color_range); + return color_range; +} + +base::Optional PhysicalASTCBlock::NumPartitions() const { + // Error blocks have no partitions + if (IsIllegalEncoding()) return { }; + + // Void extent blocks have no partitions either + if (DecodeBlockMode(astc_bits_) == BlockMode::kVoidExtent) { + return { }; + } + + // All others have some number of partitions + return DecodeNumPartitions(astc_bits_); +} + +base::Optional PhysicalASTCBlock::PartitionID() const { + auto num_partitions = NumPartitions(); + if (!num_partitions || num_partitions == 1) return { }; + + const uint64_t low_bits = astc_bits_.LowBits(); + return static_cast(base::GetBits(low_bits, 13, 10)); +} + +base::Optional PhysicalASTCBlock::GetEndpointMode( + int partition) const { + // Error block? + if (IsIllegalEncoding()) return { }; + + // Void extent blocks have no endpoint modes + if (DecodeBlockMode(astc_bits_) == BlockMode::kVoidExtent) { + return { }; + } + + // Do we even have a CEM for this partition? + if (partition < 0 || DecodeNumPartitions(astc_bits_) <= partition) { + return { }; + } + + return DecodeEndpointMode(astc_bits_, partition); +} + +} // namespace astc_codec diff --git a/src/decoder/physical_astc_block.h b/src/decoder/physical_astc_block.h new file mode 100644 index 0000000..1b04bdd --- /dev/null +++ b/src/decoder/physical_astc_block.h @@ -0,0 +1,128 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_PHYSICAL_ASTC_BLOCK_H_ +#define ASTC_CODEC_DECODER_PHYSICAL_ASTC_BLOCK_H_ + +// The logic in this file is based on the ASTC specification, which can be +// found here: +// https://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt + +#include "src/base/optional.h" +#include "src/base/uint128.h" +#include "src/decoder/types.h" + +#include + +namespace astc_codec { + +// A PhysicalASTCBlock contains all 128 bits and the logic for decoding the +// various internals of an ASTC block. +class PhysicalASTCBlock { + public: + // The physical size in bytes of an ASTC block + static const size_t kSizeInBytes = 16; + + // Initializes an ASTC block based on the encoded string. + explicit PhysicalASTCBlock(const std::string& encoded_block); + explicit PhysicalASTCBlock(const base::UInt128 astc_block); + + // Returns the 128 bits of this ASTC block. + base::UInt128 GetBlockBits() const { return astc_bits_; } + + // Weights are stored in a grid that may not have the same dimensions + // as the block dimensions. This allows us to see what the physical + // dimensions are of the grid. + base::Optional> WeightGridDims() const; + + // The weight range is the maximum value a weight can take in the + // weight grid. + base::Optional WeightRange() const; + + // Returns true if the block encoding specifies a void-extent block. This + // kind of block stores a single color to be used for every pixel in the + // block. + bool IsVoidExtent() const; + + // Returns the values (min_s, max_s, min_t, max_t) as defined in the void + // extent block as the range of texture coordinates for which this block is + // defined. (See Section C.2.23) + base::Optional> VoidExtentCoords() const; + + // Returns true if the block contains two separate weight grids. One used + // for the channel returned by DualPlaneChannel() and one used by the other + // channels. + bool IsDualPlane() const; + + // Returns the channel used as the "dual plane". The return value is only + // meaningful if IsDualPlane() returns true... + base::Optional DualPlaneChannel() const; + + // Returns a reason that the encoding doesn't adhere to the specification. + // If the encoding is legal, then this returns a nullptr. This allows us to + // still use code of the form: + // + // if (IsIllegalEncoding()) { + // ... error ... + // } + // ... no error ... + // + // However, it also helps with debugging since we can find problems with + // encodings a lot faster. + base::Optional IsIllegalEncoding() const; + + // Returns the number of weight bits present in this block. + base::Optional NumWeightBits() const; + + // Returns the starting position within the range [0, 127] of the + // weight data within the block. + base::Optional WeightStartBit() const; + + // Returns the number of endpoint pairs used in this block. + base::Optional NumPartitions() const; + + // Returns the seed used to determine the partition for a given + // (x, y) coordinate within the block. Determined using the + // block size and the function as described in the specification. + base::Optional PartitionID() const; + + // Returns the color endpoint mode for the given partition index. + base::Optional GetEndpointMode(int partition) const; + + // Returns the starting position within the range [0, 127] of the + // color data within the block. + base::Optional ColorStartBit() const; + + // Returns the number of integers used to represent the color endpoints. + base::Optional NumColorValues() const; + + // Returns the number of bits used to represent the color endpoints. + base::Optional NumColorBits() const; + + // Returns the maximum value that each of the encoded integers used to + // represent the color endpoints can take. + base::Optional ColorValuesRange() const; + + private: + const base::UInt128 astc_bits_; + + // The logic to return the number of color bits and the color values range + // is very similar, so it's probably best to abstract it away into its own + // function. + void GetColorValuesInfo(int* color_bits, int* color_range) const; +}; + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_PHYSICAL_ASTC_BLOCK_H_ diff --git a/src/decoder/quantization.cc b/src/decoder/quantization.cc new file mode 100644 index 0000000..db99682 --- /dev/null +++ b/src/decoder/quantization.cc @@ -0,0 +1,462 @@ +// 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/quantization.h" +#include "src/base/math_utils.h" + +#include +#include +#include +#include +#include +#include + +namespace astc_codec { + +namespace { + +// Trit unquantization procedure as described in Section C.2.13 +int GetUnquantizedTritValue(int trit, int bits, int range) { + int a = (bits & 1) ? 0x1FF : 0; + int b = 0, c = 0; + switch (range) { + case 5: { + b = 0; + c = 204; + } + break; + + case 11: { + int x = (bits >> 1) & 0x1; + b = (x << 1) | (x << 2) | (x << 4) | (x << 8); + c = 93; + } + break; + + case 23: { + int x = (bits >> 1) & 0x3; + b = x | (x << 2) | (x << 7); + c = 44; + } + break; + + case 47: { + int x = (bits >> 1) & 0x7; + b = x | (x << 6); + c = 22; + } + break; + + case 95: { + int x = (bits >> 1) & 0xF; + b = (x >> 2) | (x << 5); + c = 11; + } + break; + + case 191: { + int x = (bits >> 1) & 0x1F; + b = (x >> 4) | (x << 4); + c = 5; + } + break; + + default: + assert(false && "Illegal trit encoding"); + break; + } + + int t = trit * c + b; + t ^= a; + t = (a & 0x80) | (t >> 2); + return t; +} + +// Quint unquantization procedure as described in Section C.2.13 +int GetUnquantizedQuintValue(int quint, int bits, int range) { + int a = (bits & 1) ? 0x1FF : 0; + int b = 0, c = 0; + switch (range) { + case 9: { + b = 0; + c = 113; + } + break; + + case 19: { + int x = (bits >> 1) & 0x1; + b = (x << 2) | (x << 3) | (x << 8); + c = 54; + } + break; + + case 39: { + int x = (bits >> 1) & 0x3; + b = (x >> 1) | (x << 1) | (x << 7); + c = 26; + } + break; + + case 79: { + int x = (bits >> 1) & 0x7; + b = (x >> 1) | (x << 6); + c = 13; + } + break; + + case 159: { + int x = (bits >> 1) & 0xF; + b = (x >> 3) | (x << 5); + c = 6; + } + break; + + default: + assert(false && "Illegal quint encoding"); + break; + } + + int t = quint * c + b; + t ^= a; + t = (a & 0x80) | (t >> 2); + return t; +} + +// Trit unquantization procedure as described in Section C.2.17. In the code +// below, the variables a, b, and c correspond to the columns A, B, and C in +// the specification. +int GetUnquantizedTritWeight(int trit, int bits, int range) { + int a = (bits & 1) ? 0x7F : 0; + int b = 0, c = 0; + switch (range) { + case 2: + return (std::array {{ 0, 32, 63 }})[trit]; + + case 5: + c = 50; + b = 0; + break; + + case 11: { + c = 23; + b = (bits >> 1) & 1; + b |= (b << 2) | (b << 6); + } + break; + + case 23: { + c = 11; + b = (bits >> 1) & 0x3; + b |= (b << 5); + } + break; + + default: + assert(false && "Illegal trit encoding"); + break; + } + + int t = trit * c + b; + t ^= a; + t = (a & 0x20) | (t >> 2); + return t; +} + +// Quint unquantization procedure as described in Section C.2.17. In the code +// below, the variables a, b, and c correspond to the columns A, B, and C in +// the specification. +int GetUnquantizedQuintWeight(int quint, int bits, int range) { + int a = (bits & 1) ? 0x7F : 0; + int b = 0, c = 0; + switch (range) { + case 4: + return (std::array {{ 0, 16, 32, 47, 63 }})[quint]; + + case 9: + c = 28; + b = 0; + break; + + case 19: { + c = 13; + b = (bits >> 1) & 0x1; + b = (b << 1) | (b << 6); + } + break; + + default: + assert(false && "Illegal quint encoding"); + break; + } + + int t = quint * c + b; + t ^= a; + t = (a & 0x20) | (t >> 2); + return t; +} + +// A Quantization map allows us to convert to/from values that are quantized +// according to the ASTC spec. +class QuantizationMap { + public: + int Quantize(int x) const { + return x < quantization_map_.size() ? quantization_map_.at(x) : 0; + } + + int Unquantize(int x) const { + return x < unquantization_map_.size() ? unquantization_map_.at(x) : 0; + } + + protected: + QuantizationMap() { } + std::vector quantization_map_; + std::vector unquantization_map_; + + void GenerateQuantizationMap() { + assert(unquantization_map_.size() > 1); + quantization_map_.clear(); + + // TODO(google) For weights, we don't need quantization values all the + // way up to 256, but it doesn't hurt -- just wastes memory, but the code + // is much cleaner this way + for (int i = 0; i < 256; ++i) { + int best_idx = 0; + int best_idx_score = 256; + int idx = 0; + for (int unquantized_val : unquantization_map_) { + const int diff = i - unquantized_val; + const int idx_score = diff * diff; + if (idx_score < best_idx_score) { + best_idx = idx; + best_idx_score = idx_score; + } + idx++; + } + + quantization_map_.push_back(best_idx); + } + } +}; + +template +class TritQuantizationMap : public QuantizationMap { + public: + explicit TritQuantizationMap(int range) : QuantizationMap() { + assert((range + 1) % 3 == 0); + const int num_bits_pow_2 = (range + 1) / 3; + const int num_bits = + num_bits_pow_2 == 0 ? 0 : base::Log2Floor(num_bits_pow_2); + + for (int trit = 0; trit < 3; ++trit) { + for (int bits = 0; bits < (1 << num_bits); ++bits) { + unquantization_map_.push_back(UnquantizationFunc(trit, bits, range)); + } + } + + GenerateQuantizationMap(); + } +}; + +template +class QuintQuantizationMap : public QuantizationMap { + public: + explicit QuintQuantizationMap(int range) : QuantizationMap() { + assert((range + 1) % 5 == 0); + const int num_bits_pow_2 = (range + 1) / 5; + const int num_bits = + num_bits_pow_2 == 0 ? 0 : base::Log2Floor(num_bits_pow_2); + + for (int quint = 0; quint < 5; ++quint) { + for (int bits = 0; bits < (1 << num_bits); ++bits) { + unquantization_map_.push_back(UnquantizationFunc(quint, bits, range)); + } + } + + GenerateQuantizationMap(); + } +}; + +template +class BitQuantizationMap : public QuantizationMap { + public: + explicit BitQuantizationMap(int range) + : QuantizationMap() { + // Make sure that if we're using bits then we have a positive power of two. + assert(base::CountOnes(range + 1) == 1); + + const int num_bits = base::Log2Floor(range + 1); + for (int bits = 0; bits <= range; ++bits) { + // Need to replicate bits until we fill up the bits + int unquantized = bits; + int num_unquantized_bits = num_bits; + while (num_unquantized_bits < TotalUnquantizedBits) { + const int num_dst_bits_to_shift_up = + std::min(num_bits, TotalUnquantizedBits - num_unquantized_bits); + const int num_src_bits_to_shift_down = + num_bits - num_dst_bits_to_shift_up; + unquantized <<= num_dst_bits_to_shift_up; + unquantized |= bits >> num_src_bits_to_shift_down; + num_unquantized_bits += num_dst_bits_to_shift_up; + } + assert(num_unquantized_bits == TotalUnquantizedBits); + + unquantization_map_.push_back(unquantized); + + // Fill half of the quantization map with the previous value for bits + // and the other half with the current value for bits + if (bits > 0) { + const int prev_unquant = unquantization_map_.at(bits - 1); + while (quantization_map_.size() <= (prev_unquant + unquantized) / 2) { + quantization_map_.push_back(bits - 1); + } + } + while (quantization_map_.size() <= unquantized) { + quantization_map_.push_back(bits); + } + } + + assert(quantization_map_.size() == 1 << TotalUnquantizedBits); + } +}; + +using QMap = std::shared_ptr; + +// Returns the quantization map for quantizing color values in [0, 255] with the +// smallest range that can accommodate |r| +static const QuantizationMap* GetQuantMapForValueRange(int r) { + // Endpoint values can be quantized using bits, trits, or quints. Here we + // store the quantization maps for each of the ranges that are supported by + // such an encoding. That way we can choose the proper quantization procedure + // based on the range of values rather than by having complicated switches and + // logic. We must use a std::map here instead of a std::unordered_map because + // of the assumption made in std::upper_bound about the iterators being from a + // poset. + static const auto* const kASTCEndpointQuantization = new std::map { + { 5, QMap(new TritQuantizationMap(5)) }, + { 7, QMap(new BitQuantizationMap<8>(7)) }, + { 9, QMap(new QuintQuantizationMap(9)) }, + { 11, QMap(new TritQuantizationMap(11)) }, + { 15, QMap(new BitQuantizationMap<8>(15)) }, + { 19, QMap(new QuintQuantizationMap(19)) }, + { 23, QMap(new TritQuantizationMap(23)) }, + { 31, QMap(new BitQuantizationMap<8>(31)) }, + { 39, QMap(new QuintQuantizationMap(39)) }, + { 47, QMap(new TritQuantizationMap(47)) }, + { 63, QMap(new BitQuantizationMap<8>(63)) }, + { 79, QMap(new QuintQuantizationMap(79)) }, + { 95, QMap(new TritQuantizationMap(95)) }, + { 127, QMap(new BitQuantizationMap<8>(127)) }, + { 159, QMap(new QuintQuantizationMap(159)) }, + { 191, QMap(new TritQuantizationMap(191)) }, + { 255, QMap(new BitQuantizationMap<8>(255)) }, + }; + + assert(r < 256); + auto itr = kASTCEndpointQuantization->upper_bound(r); + if (itr != kASTCEndpointQuantization->begin()) { + return (--itr)->second.get(); + } + return nullptr; +} + +// Returns the quantization map for weight values in [0, 63] with the smallest +// range that can accommodate |r| +static const QuantizationMap* GetQuantMapForWeightRange(int r) { + // Similar to endpoint quantization, weights can also be stored using trits, + // quints, or bits. Here we store the quantization maps for each of the ranges + // that are supported by such an encoding. + static const auto* const kASTCWeightQuantization = new std::map { + { 1, QMap(new BitQuantizationMap<6>(1)) }, + { 2, QMap(new TritQuantizationMap(2)) }, + { 3, QMap(new BitQuantizationMap<6>(3)) }, + { 4, QMap(new QuintQuantizationMap(4)) }, + { 5, QMap(new TritQuantizationMap(5)) }, + { 7, QMap(new BitQuantizationMap<6>(7)) }, + { 9, QMap(new QuintQuantizationMap(9)) }, + { 11, QMap(new TritQuantizationMap(11)) }, + { 15, QMap(new BitQuantizationMap<6>(15)) }, + { 19, QMap(new QuintQuantizationMap(19)) }, + { 23, QMap(new TritQuantizationMap(23)) }, + { 31, QMap(new BitQuantizationMap<6>(31)) }, + }; + + assert(r < 32); + auto itr = kASTCWeightQuantization->upper_bound(r); + if (itr != kASTCWeightQuantization->begin()) { + return (--itr)->second.get(); + } + return nullptr; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +int QuantizeCEValueToRange(int value, int range_max_value) { + assert(range_max_value >= kEndpointRangeMinValue); + assert(range_max_value <= 255); + assert(value >= 0); + assert(value <= 255); + + const QuantizationMap* map = GetQuantMapForValueRange(range_max_value); + return map ? map->Quantize(value) : 0; +} + +int UnquantizeCEValueFromRange(int value, int range_max_value) { + assert(range_max_value >= kEndpointRangeMinValue); + assert(range_max_value <= 255); + assert(value >= 0); + assert(value <= range_max_value); + + const QuantizationMap* map = GetQuantMapForValueRange(range_max_value); + return map ? map->Unquantize(value) : 0; +} + +int QuantizeWeightToRange(int weight, int range_max_value) { + assert(range_max_value >= 1); + assert(range_max_value <= kWeightRangeMaxValue); + assert(weight >= 0); + assert(weight <= 64); + + // The quantization maps that define weight unquantization expect values in + // the range [0, 64), but the specification quantizes them to the range + // [0, 64] according to C.2.17. This is a slight hack similar to the one in + // the unquantization procedure to return the passed in unquantized value to + // [0, 64) prior to running it through the quantization procedure. + if (weight > 33) { + weight -= 1; + } + const QuantizationMap* map = GetQuantMapForWeightRange(range_max_value); + return map ? map->Quantize(weight) : 0; +} + +int UnquantizeWeightFromRange(int weight, int range_max_value) { + assert(range_max_value >= 1); + assert(range_max_value <= kWeightRangeMaxValue); + assert(weight >= 0); + assert(weight <= range_max_value); + const QuantizationMap* map = GetQuantMapForWeightRange(range_max_value); + int dq = map ? map->Unquantize(weight) : 0; + + // Quantized weights are returned in the range [0, 64), but they should be + // returned in the range [0, 64], so according to C.2.17 we need to add one + // to the result. + assert(dq < 64); + if (dq > 32) { + dq += 1; + } + return dq; +} + +} // namespace astc_codec diff --git a/src/decoder/quantization.h b/src/decoder/quantization.h new file mode 100644 index 0000000..5f7239f --- /dev/null +++ b/src/decoder/quantization.h @@ -0,0 +1,65 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_QUANTIZATION_H_ +#define ASTC_CODEC_DECODER_QUANTIZATION_H_ + +//////////////////////////////////////////////////////////////////////////////// +// +// ASTC Quantization procedures. +// +// The values stored in ASTC blocks tend to be stored in a range much more +// restricted than the logical range used. For example, sometimes weights are +// stored in the range from [0, 3] but are used in the range [0, 64]. The +// process of translating a value to or from this range is known as quantization +// and dequantization. The ranges to which these values can be (de)quantized +// are defined by ISERange[Begin|End]() in integer_sequence_codec.h + +namespace astc_codec { + +// The minimum possible range for a pair of endpoints. If endpoints are +// quantized to something smaller than this, then it would constitute an +// illegal ASTC encoding. +constexpr int kEndpointRangeMinValue = 5; + +// The maximum possible range for a weight value. If weights are quantized to +// something larger than this, then it would constitute an illegal ASTC +// encoding. +constexpr int kWeightRangeMaxValue = 31; + +// Quantizes a value in the range [0, 255] to [0, |range|]. The quantized values +// have no correlation to the input values, and there should be no implicit +// assumptions made about their ordering. Valid values of |range_max_value| are +// in the interval [5, 255] +int QuantizeCEValueToRange(int value, int range_max_value); + +// Unquantizes a value in the range [0, |range|] to [0, 255]. Performs the +// inverse procedure of QuantizeValueToRange. Valid values of |range_max_value| +// are in the interval [5, 255] +int UnquantizeCEValueFromRange(int value, int range_max_value); + +// Quantizes a weight in the range [0, 64] to [0, |range_max_value|]. The +// quantized values have no correlation to the input values, and there should +// be no implicit assumptions made about their ordering. Valid values of +// |range_max_value| are in the interval [1, 31] +int QuantizeWeightToRange(int weight, int range_max_value); + +// Unquantizes a weight in the range [0, |range_max_value|] to [0, 64]. Performs +// the inverse procedure of QuantizeWeightToRange. Valid values of +// |range_max_value| are in the interval [1, 31] +int UnquantizeWeightFromRange(int weight, int range_max_value); + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_QUANTIZATION_H_ diff --git a/src/decoder/test/astc_fuzzer.cc b/src/decoder/test/astc_fuzzer.cc new file mode 100644 index 0000000..f152675 --- /dev/null +++ b/src/decoder/test/astc_fuzzer.cc @@ -0,0 +1,36 @@ +// 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. + +// ASTC fuzzing wrapper to help with fuzz testing. + +#include "src/decoder/codec.h" + +#include + +#include + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + std::string error; + std::unique_ptr file = + astc_codec::ASTCFile::LoadFromMemory(reinterpret_cast(data), + size, &error); + if (file) { + std::vector out_buffer(file->GetWidth() * file->GetHeight() * 4); + bool result = astc_codec::DecompressToImage( + *file, out_buffer.data(), out_buffer.size(), file->GetWidth() * 4); + benchmark::DoNotOptimize(result); + } + + return 0; +} diff --git a/src/decoder/test/codec_test.cc b/src/decoder/test/codec_test.cc new file mode 100644 index 0000000..936eed3 --- /dev/null +++ b/src/decoder/test/codec_test.cc @@ -0,0 +1,181 @@ +// 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/codec.h" +#include "include/astc-codec/astc-codec.h" +#include "src/decoder/test/image_utils.h" + +#include + +#include + +namespace astc_codec { + +static void PrintTo(FootprintType footprint, std::ostream* os) { + switch (footprint) { + case FootprintType::k4x4: *os << "FootprintType::k4x4"; break; + case FootprintType::k5x4: *os << "FootprintType::k5x4"; break; + case FootprintType::k5x5: *os << "FootprintType::k5x5"; break; + case FootprintType::k6x5: *os << "FootprintType::k6x5"; break; + case FootprintType::k6x6: *os << "FootprintType::k6x6"; break; + case FootprintType::k8x5: *os << "FootprintType::k8x5"; break; + case FootprintType::k8x6: *os << "FootprintType::k8x6"; break; + case FootprintType::k10x5: *os << "FootprintType::k10x5"; break; + case FootprintType::k10x6: *os << "FootprintType::k10x6"; break; + case FootprintType::k8x8: *os << "FootprintType::k8x8"; break; + case FootprintType::k10x8: *os << "FootprintType::k10x8"; break; + case FootprintType::k10x10: *os << "FootprintType::k10x10"; break; + case FootprintType::k12x10: *os << "FootprintType::k12x10"; break; + case FootprintType::k12x12: *os << "FootprintType::k12x12"; break; + default: + *os << "(footprint) << ">"; + } +} + +namespace { + +using ::testing::TestWithParam; +using ::testing::ValuesIn; + +ImageBuffer LoadGoldenImageWithAlpha(std::string basename) { + const std::string filename = + std::string("src/decoder/testdata/") + basename + ".bmp"; + ImageBuffer result; + LoadGoldenBmp(filename, &result); + EXPECT_EQ(result.BytesPerPixel(), 4); + return result; +} + +struct ImageTestParams { + std::string image_name; + FootprintType footprint; + size_t width; + size_t height; +}; + +static void PrintTo(const ImageTestParams& params, std::ostream* os) { + *os << "ImageTestParams(" << params.image_name << ", " << params.width << "x" + << params.height << ", "; + PrintTo(params.footprint, os); + *os << ")"; +} + +TEST(CodecTest, InvalidInput) { + const size_t valid_width = 16; + const size_t valid_height = 16; + const size_t valid_stride = valid_width * 4; + + const std::vector data(256); + std::vector output(valid_width * valid_height * 4); + + // Invalid footprint. + EXPECT_FALSE(ASTCDecompressToRGBA( + data.data(), data.size(), valid_width, valid_height, + FootprintType::kCount, output.data(), output.size(), valid_stride)); + + // Fail for 0 width or height. + EXPECT_FALSE(ASTCDecompressToRGBA(data.data(), data.size(), 0, valid_height, + FootprintType::k4x4, output.data(), + output.size(), valid_stride)); + EXPECT_FALSE(ASTCDecompressToRGBA(data.data(), data.size(), valid_width, 0, + FootprintType::k4x4, output.data(), + output.size(), valid_stride)); + + // Fail for data size that's not a multiple of block size. + EXPECT_FALSE(ASTCDecompressToRGBA( + data.data(), data.size() - 1, valid_width, valid_height, + FootprintType::k4x4, output.data(), output.size(), valid_stride)); + // Fail for data size that doesn't match the block count. + EXPECT_FALSE(ASTCDecompressToRGBA( + data.data(), data.size() - 16, valid_width, valid_height, + FootprintType::k4x4, output.data(), output.size(), valid_stride)); + + // Fail for invalid stride. + EXPECT_FALSE(ASTCDecompressToRGBA( + data.data(), data.size(), valid_width, valid_height, FootprintType::k4x4, + output.data(), output.size(), valid_stride - 1)); + + // Fail for invalid output size. + EXPECT_FALSE(ASTCDecompressToRGBA( + data.data(), data.size(), valid_width, valid_height, FootprintType::k4x4, + output.data(), output.size() - 1, valid_stride)); +} + +class CodecTest : public TestWithParam {}; + +TEST_P(CodecTest, PublicAPI) { + const auto& params = GetParam(); + const std::string astc = LoadASTCFile(params.image_name); + + ImageBuffer our_decoded_image; + our_decoded_image.Allocate(params.width, params.height, 4); + ASSERT_TRUE(ASTCDecompressToRGBA( + reinterpret_cast(astc.data()), astc.size(), params.width, + params.height, params.footprint, our_decoded_image.Data().data(), + our_decoded_image.DataSize(), our_decoded_image.Stride())); + + // Check that the decoded image is *very* similar to the library decoding + // of an ASTC texture. They may not be exact due to differences in how we + // convert a 16-bit float to an 8-bit integer. + ImageBuffer decoded_image = LoadGoldenImageWithAlpha(params.image_name); + CompareSumOfSquaredDifferences(decoded_image, our_decoded_image, 1.0); +} + +TEST_P(CodecTest, DecompressToImage) { + const auto& params = GetParam(); + + std::string error; + std::unique_ptr image_file = ASTCFile::LoadFile( + std::string("src/decoder/testdata/") + params.image_name + ".astc", + &error); + ASSERT_TRUE(image_file) << "Failed to load " << params.image_name << ": " + << error; + + ASSERT_TRUE(image_file->GetFootprint()); + EXPECT_EQ(params.footprint, image_file->GetFootprint().value().Type()); + + ImageBuffer our_decoded_image; + our_decoded_image.Allocate(image_file->GetWidth(), image_file->GetHeight(), + 4); + + ASSERT_TRUE(DecompressToImage(*image_file, our_decoded_image.Data().data(), + our_decoded_image.DataSize(), + our_decoded_image.Stride())); + + // Check that the decoded image is *very* similar to the library decoding + // of an ASTC texture. They may not be exact due to differences in how we + // convert a 16-bit float to an 8-bit integer. + ImageBuffer decoded_image = LoadGoldenImageWithAlpha(params.image_name); + CompareSumOfSquaredDifferences(decoded_image, our_decoded_image, 1.0); +} + +// Test to make sure that reading out color values from blocks in a real-world +// image isn't terribly wrong, either. +std::vector GetTransparentImageTestParams() { + return { + // image_name astc footprint width height + { "atlas_small_4x4", FootprintType::k4x4, 256, 256 }, + { "atlas_small_5x5", FootprintType::k5x5, 256, 256 }, + { "atlas_small_6x6", FootprintType::k6x6, 256, 256 }, + { "atlas_small_8x8", FootprintType::k8x8, 256, 256 }, + }; +} + +INSTANTIATE_TEST_CASE_P(Transparent, CodecTest, + ValuesIn(GetTransparentImageTestParams())); + +} // namespace + +} // namespace astc_codec diff --git a/src/decoder/test/endpoint_codec_test.cc b/src/decoder/test/endpoint_codec_test.cc new file mode 100644 index 0000000..f2fef54 --- /dev/null +++ b/src/decoder/test/endpoint_codec_test.cc @@ -0,0 +1,464 @@ +// 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 +#include +#include +#include + +#include +#include + +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 kEndpointEncodingModes = {{ + EndpointEncodingMode::kDirectLuma, + EndpointEncodingMode::kDirectLumaAlpha, + EndpointEncodingMode::kBaseScaleRGB, + EndpointEncodingMode::kBaseScaleRGBA, + EndpointEncodingMode::kDirectRGB, + EndpointEncodingMode::kDirectRGBA }}; + +const std::array, 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 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 TestColors( + RgbaColor low, RgbaColor high, int quant, EndpointEncodingMode mode) { + ColorEndpointMode astc_mode; + std::vector 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 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(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 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(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 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 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 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 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 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 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 diff --git a/src/decoder/test/footprint_test.cc b/src/decoder/test/footprint_test.cc new file mode 100644 index 0000000..6aef98a --- /dev/null +++ b/src/decoder/test/footprint_test.cc @@ -0,0 +1,97 @@ +// 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/footprint.h" + +#include +#include +#include + +#include + +namespace astc_codec { + +namespace { + +TEST(FootprintTest, ParseAstcFootprintString) { + using ASTCTestPair = std::pair; + const std::array + valid_footprints {{ + std::make_pair("4x4", Footprint::Get4x4()), + std::make_pair("5x4", Footprint::Get5x4()), + std::make_pair("5x5", Footprint::Get5x5()), + std::make_pair("6x5", Footprint::Get6x5()), + std::make_pair("6x6", Footprint::Get6x6()), + std::make_pair("8x5", Footprint::Get8x5()), + std::make_pair("8x6", Footprint::Get8x6()), + std::make_pair("8x8", Footprint::Get8x8()), + std::make_pair("10x5", Footprint::Get10x5()), + std::make_pair("10x6", Footprint::Get10x6()), + std::make_pair("10x8", Footprint::Get10x8()), + std::make_pair("10x10", Footprint::Get10x10()), + std::make_pair("12x10", Footprint::Get12x10()), + std::make_pair("12x12", Footprint::Get12x12()) + }}; + + for (const auto& test : valid_footprints) { + base::Optional footprint = Footprint::Parse(test.first.c_str()); + EXPECT_TRUE(footprint); + EXPECT_EQ(test.second, footprint.value()); + } + + EXPECT_DEBUG_DEATH(EXPECT_FALSE(Footprint::Parse("")), ""); + EXPECT_DEBUG_DEATH(EXPECT_FALSE(Footprint::Parse("3")), ""); + EXPECT_DEBUG_DEATH(EXPECT_FALSE(Footprint::Parse("x")), ""); + // Validly formed but out-of-bounds dimensions do not assert, otherwise + // malformed ASTC files could crash the decoder in debug builds. + EXPECT_FALSE(Footprint::Parse("9999999999x10")); + EXPECT_DEBUG_DEATH(EXPECT_FALSE(Footprint::Parse("ax8")), ""); + EXPECT_DEBUG_DEATH(EXPECT_FALSE(Footprint::Parse("2x3x4")), ""); + EXPECT_DEBUG_DEATH(EXPECT_FALSE(Footprint::Parse("-3x4")), ""); + EXPECT_FALSE(Footprint::Parse("10x4")); +} + +TEST(FootprintTest, Bitrates) { + EXPECT_NEAR(Footprint::Get4x4().Bitrate(), 8.f, 0.01f); + EXPECT_NEAR(Footprint::Get5x4().Bitrate(), 6.4f, 0.01f); + EXPECT_NEAR(Footprint::Get5x5().Bitrate(), 5.12f, 0.01f); + EXPECT_NEAR(Footprint::Get6x5().Bitrate(), 4.27f, 0.01f); + EXPECT_NEAR(Footprint::Get6x6().Bitrate(), 3.56f, 0.01f); + EXPECT_NEAR(Footprint::Get8x5().Bitrate(), 3.20f, 0.01f); + EXPECT_NEAR(Footprint::Get8x6().Bitrate(), 2.67f, 0.01f); + EXPECT_NEAR(Footprint::Get8x8().Bitrate(), 2.00f, 0.01f); + EXPECT_NEAR(Footprint::Get10x5().Bitrate(), 2.56f, 0.01f); + EXPECT_NEAR(Footprint::Get10x6().Bitrate(), 2.13f, 0.01f); + EXPECT_NEAR(Footprint::Get10x8().Bitrate(), 1.60f, 0.01f); + EXPECT_NEAR(Footprint::Get10x10().Bitrate(), 1.28f, 0.01f); + EXPECT_NEAR(Footprint::Get12x10().Bitrate(), 1.07f, 0.01f); + EXPECT_NEAR(Footprint::Get12x12().Bitrate(), 0.89f, 0.01f); +} + +TEST(FootprintTest, StorageRequirements) { + auto footprint = Footprint::Get10x8(); + EXPECT_EQ(footprint.Width(), 10); + EXPECT_EQ(footprint.Height(), 8); + + // If we have 8x8 blocks, then we have 64*16 = 1024 bytes. + EXPECT_EQ(footprint.StorageRequirements(80, 64), 1024); + + // If our block is a little smaller this still counts because we need to + // cover a partial block with a fully encoded one. + EXPECT_EQ(footprint.StorageRequirements(79, 63), 1024); +} + +} // namespace + +} // namespace astc_codec diff --git a/src/decoder/test/image_utils.h b/src/decoder/test/image_utils.h new file mode 100644 index 0000000..718696e --- /dev/null +++ b/src/decoder/test/image_utils.h @@ -0,0 +1,217 @@ +// 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 + +#include +#include + +static constexpr size_t kMaxVectorOutput = 128; + +class ImageBuffer { + public: + static constexpr size_t Align = 4; + + void Allocate(size_t width, size_t height, size_t bytes_per_pixel) { + width_ = width; + height_ = height; + bytes_per_pixel_ = bytes_per_pixel; + stride_ = AlignBytes(width * bytes_per_pixel); + data_.resize(stride_ * height); + } + + uint8_t* operator()(size_t x, size_t y) { + assert(x < width_ && y < height_); + return &data_[y * Stride() + x * bytes_per_pixel_]; + } + + size_t Stride() const { return stride_; } + size_t BytesPerPixel() const { return bytes_per_pixel_; } + + std::vector& Data() { return data_; } + const std::vector& Data() const { return data_; } + size_t DataSize() const { return data_.size(); } + + private: + size_t AlignBytes(size_t bytes) const { + return (bytes + (Align - 1)) / Align * Align; + } + + size_t width_ = 0; + size_t height_ = 0; + size_t stride_ = 0; + size_t bytes_per_pixel_ = 0; + std::vector data_; +}; + +namespace std { +static void PrintTo(const vector& vec, ostream* os) { + ios::fmtflags origFlags(os->flags()); + + *os << '{'; + size_t count = 0; + for (vector::const_iterator it = vec.begin(); it != vec.end(); + ++it, ++count) { + if (count > 0) { + *os << ", "; + } + + if (count == kMaxVectorOutput) { + *os << "... "; + break; + } + + if ((count % 16) == 0) { + *os << "\n"; + } + + if (*it == 0) { + *os << " "; + } else { + *os << "0x" << std::hex << std::uppercase << std::setw(2) + << std::setfill('0') << int(*it) << std::dec; + } + } + + *os << '}'; + + os->flags(origFlags); +} +} // namespace std + +static std::string LoadFile(const std::string& path) { + std::ifstream is(path, std::ios::binary); + EXPECT_TRUE(is) << "Failed to load file " << path; + if (!is) { + return ""; + } + + std::ostringstream ss; + ss << is.rdbuf(); + return ss.str(); +} + +static std::string LoadASTCFile(const std::string& basename) { + const std::string filename = + std::string("src/decoder/testdata/") + basename + ".astc"; + + std::string result = LoadFile(filename); + // Don't parse the header here, we already know what kind of astc encoding it + // is. + if (result.size() < 16) { + return ""; + } else { + return result.substr(16); + } +} + +void LoadGoldenBmp(const std::string& path, ImageBuffer* result) { + constexpr size_t kBmpHeaderSize = 54; + + SCOPED_TRACE(testing::Message() << "LoadGoldenBmp " << path); + + const std::string data = LoadFile(path); + ASSERT_FALSE(data.empty()) << "Failed to open golden image: " << path; + + ASSERT_GE(data.size(), kBmpHeaderSize); + ASSERT_EQ('B', data[0]); + ASSERT_EQ('M', data[1]); + + uint32_t dataPos = *reinterpret_cast(&data[0x0A]); + uint32_t imageSize = *reinterpret_cast(&data[0x22]); + const uint16_t bitsPerPixel = *reinterpret_cast(&data[0x1C]); + int width = *reinterpret_cast(&data[0x12]); + int height = *reinterpret_cast(&data[0x16]); + + SCOPED_TRACE(testing::Message() + << "dataPos=" << dataPos << ", imageSize=" << imageSize + << ", bitsPerPixel=" << bitsPerPixel << ", width=" << width + << ", height=" << height); + + if (height < 0) { + height = -height; + } + + if (imageSize == 0) { + imageSize = width * height * 3; + } + + if (dataPos < kBmpHeaderSize) { + dataPos = kBmpHeaderSize; + } + + ASSERT_TRUE(bitsPerPixel == 24 || bitsPerPixel == 32) + << "BMP bits per pixel mismatch, expected 24 or 32"; + + result->Allocate(width, height, bitsPerPixel == 24 ? 3 : 4); + ASSERT_LE(imageSize, result->DataSize()); + + std::vector& resultData = result->Data(); + const size_t stride = result->Stride(); + + // Copy the data row-by-row to make sure that stride is right. + for (size_t row = 0; row < static_cast(height); ++row) { + memcpy(&resultData[row * stride], &data[dataPos + row * stride], + width * bitsPerPixel / 8); + } + + if (bitsPerPixel == 32) { + // Swizzle the data from ABGR to ARGB. + for (size_t row = 0; row < static_cast(height); ++row) { + uint8_t* rowData = resultData.data() + row * stride; + + for (size_t i = 3; i < stride; i += 4) { + const uint8_t b = rowData[i - 3]; + rowData[i - 3] = rowData[i - 1]; + rowData[i - 1] = b; + } + } + } else { + // Swizzle the data from BGR to RGB. + for (size_t row = 0; row < static_cast(height); ++row) { + uint8_t* rowData = resultData.data() + row * stride; + + for (size_t i = 2; i < stride; i += 3) { + const uint8_t tmp = rowData[i - 2]; + rowData[i - 2] = rowData[i]; + rowData[i] = tmp; + } + } + } +} + +static void CompareSumOfSquaredDifferences(const ImageBuffer& golden, + const ImageBuffer& image, + double threshold) { + ASSERT_EQ(golden.DataSize(), image.DataSize()); + ASSERT_EQ(golden.Stride(), image.Stride()); + ASSERT_EQ(golden.BytesPerPixel(), image.BytesPerPixel()); + + const std::vector& image_data = image.Data(); + const std::vector& golden_data = golden.Data(); + + double sum = 0.0; + for (size_t i = 0; i < image_data.size(); ++i) { + const double diff = static_cast(image_data[i]) - golden_data[i]; + sum += diff * diff; + } + + EXPECT_LE(sum, threshold * image_data.size()) + << "Per pixel " << (sum / image_data.size()) + << ", expected <= " << threshold; + if (sum > threshold * image_data.size()) { + // Fall back to comparison which will dump first chunk of vector. + EXPECT_EQ(golden_data, image_data); + } +} diff --git a/src/decoder/test/integer_sequence_codec_test.cc b/src/decoder/test/integer_sequence_codec_test.cc new file mode 100644 index 0000000..b66ff2b --- /dev/null +++ b/src/decoder/test/integer_sequence_codec_test.cc @@ -0,0 +1,337 @@ +// 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/integer_sequence_codec.h" +#include "src/base/uint128.h" + +#include +#include +#include + +#include + +using astc_codec::base::UInt128; +using astc_codec::base::BitStream; +using astc_codec::IntegerSequenceCodec; +using astc_codec::IntegerSequenceEncoder; +using astc_codec::IntegerSequenceDecoder; + +namespace { + +// Make sure that the counts returned for a specific range match what's +// expected. In particular, make sure that it fits with Table C.2.7 +TEST(ASTCIntegerSequenceCodecTest, TestGetCountsForRange) { + std::array kExpectedCounts[31] = { + {{ 0, 0, 1 }}, // 1 + {{ 1, 0, 0 }}, // 2 + {{ 0, 0, 2 }}, // 3 + {{ 0, 1, 0 }}, // 4 + {{ 1, 0, 1 }}, // 5 + {{ 0, 0, 3 }}, // 6 + {{ 0, 0, 3 }}, // 7 + {{ 0, 1, 1 }}, // 8 + {{ 0, 1, 1 }}, // 9 + {{ 1, 0, 2 }}, // 10 + {{ 1, 0, 2 }}, // 11 + {{ 0, 0, 4 }}, // 12 + {{ 0, 0, 4 }}, // 13 + {{ 0, 0, 4 }}, // 14 + {{ 0, 0, 4 }}, // 15 + {{ 0, 1, 2 }}, // 16 + {{ 0, 1, 2 }}, // 17 + {{ 0, 1, 2 }}, // 18 + {{ 0, 1, 2 }}, // 19 + {{ 1, 0, 3 }}, // 20 + {{ 1, 0, 3 }}, // 21 + {{ 1, 0, 3 }}, // 22 + {{ 1, 0, 3 }}, // 23 + {{ 0, 0, 5 }}, // 24 + {{ 0, 0, 5 }}, // 25 + {{ 0, 0, 5 }}, // 26 + {{ 0, 0, 5 }}, // 27 + {{ 0, 0, 5 }}, // 28 + {{ 0, 0, 5 }}, // 29 + {{ 0, 0, 5 }}, // 30 + {{ 0, 0, 5 }}, // 31 + }; + + int t, q, b; + for (int i = 1; i < 32; ++i) { + IntegerSequenceCodec::GetCountsForRange(i, &t, &q, &b); + EXPECT_EQ(t, kExpectedCounts[i - 1][0]); + EXPECT_EQ(q, kExpectedCounts[i - 1][1]); + EXPECT_EQ(b, kExpectedCounts[i - 1][2]); + } + + ASSERT_DEBUG_DEATH(IntegerSequenceCodec::GetCountsForRange(0, &t, &q, &b), ""); + ASSERT_DEBUG_DEATH( + IntegerSequenceCodec::GetCountsForRange(256, &t, &q, &b), ""); + + IntegerSequenceCodec::GetCountsForRange(1, &t, &q, &b); + EXPECT_EQ(t, 0); + EXPECT_EQ(q, 0); + EXPECT_EQ(b, 1); +} + +// Test to make sure that we're calculating the number of bits needed to +// encode a given number of values based on the range of the values. +TEST(ASTCIntegerSequenceCodecTest, TestNumBitsForCounts) { + int trits = 0; + int quints = 0; + int bits = 0; + + // A range of one should have single bits, so n 1-bit values should be n bits. + trits = 0; + quints = 0; + bits = 1; + for (int i = 0; i < 64; ++i) { + EXPECT_EQ(IntegerSequenceCodec::GetBitCount(i, trits, quints, bits), i); + EXPECT_EQ(IntegerSequenceCodec::GetBitCountForRange(i, 1), i); + } + + // Similarly, N two-bit values should be 2n bits... + trits = 0; + quints = 0; + bits = 2; + for (int i = 0; i < 64; ++i) { + int bit_counts = IntegerSequenceCodec::GetBitCount(i, trits, quints, bits); + EXPECT_EQ(bit_counts, 2 * i); + EXPECT_EQ(IntegerSequenceCodec::GetBitCountForRange(i, 3), 2 * i); + } + + // Trits are a bit more complicated -- there are five trits in a block, so + // if we encode 15 values with 3 bits each in trits, we'd get three blocks, + // each with eight bits of trits. + trits = 1; + quints = 0; + bits = 3; + EXPECT_EQ(IntegerSequenceCodec::GetBitCount(15, trits, quints, bits), + 8 * 3 + 15 * 3); + EXPECT_EQ(IntegerSequenceCodec::GetBitCountForRange(15, 23), + IntegerSequenceCodec::GetBitCount(15, trits, quints, bits)); + + // However, if instead we encode 13 values, we don't need to use the remaining + // two values, so we only need bits as they will be encoded. As it turns out, + // this means we can avoid three bits in the final block (one for the high + // order trit encoding and two for one of the values), resulting in 47 bits. + trits = 1; + quints = 0; + bits = 2; + EXPECT_EQ(IntegerSequenceCodec::GetBitCount(13, trits, quints, bits), 47); + EXPECT_EQ(IntegerSequenceCodec::GetBitCountForRange(13, 11), + IntegerSequenceCodec::GetBitCount(13, trits, quints, bits)); + + // Quints have a similar property -- if we encode six values using a quint and + // four bits, then we have two quint blocks each with three values and a seven + // bit encoded quint triplet... + trits = 0; + quints = 1; + bits = 4; + EXPECT_EQ(IntegerSequenceCodec::GetBitCount(6, trits, quints, bits), + 7 * 2 + 6 * 4); + EXPECT_EQ(IntegerSequenceCodec::GetBitCountForRange(6, 79), + IntegerSequenceCodec::GetBitCount(6, trits, quints, bits)); + + // If we have fewer values than blocks we can again avoid about 2 + nbits + // bits... + trits = 0; + quints = 1; + bits = 3; + EXPECT_EQ(IntegerSequenceCodec::GetBitCount(7, trits, quints, bits), + /* first two quint blocks */ 7 * 2 + + /* first two blocks of bits */ 6 * 3 + + /* last quint block without the high order four bits */ 3 + + /* last block with one set of three bits */ 3); +} + +// Tests that the encoder knows how to encode values of the form 5*2^k. +TEST(ASTCIntegerSequenceCodecTest, TestQuintCodec) { + // In this case, k = 4 + + // Setup bit src/sink + BitStream bit_sink; + + const int kValueRange = 79; + IntegerSequenceEncoder enc(kValueRange); + enc.AddValue(3); + enc.AddValue(79); + enc.AddValue(37); + enc.Encode(&bit_sink); + + // quint: 1000101 m0: 0011 m1: 1111 m2: 0101 + // 100 0100 0111 1101 0010 + // interleaved 10m200m1101m0 + // should be 100 1010 0111 1101 0011 = 0x4A7D3 + EXPECT_EQ(bit_sink.Bits(), 19); + + uint64_t encoded = 0; + bit_sink.GetBits(19, &encoded); + EXPECT_EQ(encoded, 0x4A7D3); + + // Now check that decoding it works as well + BitStream bit_src(encoded, 19); + + IntegerSequenceDecoder dec(kValueRange); + auto decoded_vals = dec.Decode(3, &bit_src); + ASSERT_EQ(decoded_vals.size(), 3); + EXPECT_EQ(decoded_vals[0], 3); + EXPECT_EQ(decoded_vals[1], 79); + EXPECT_EQ(decoded_vals[2], 37); +} + +// Tests that the encoder knows how to encode values of the form 3*2^k. +TEST(ASTCIntegerSequenceCodecTest, TestTritCodec) { + uint64_t encoded = 0; + + // Setup bit src/sink + BitStream bit_sink(encoded, 0); + + const int kValueRange = 11; + IntegerSequenceEncoder enc(kValueRange); + enc.AddValue(7); + enc.AddValue(5); + enc.AddValue(3); + enc.AddValue(6); + enc.AddValue(10); + enc.Encode(&bit_sink); + + EXPECT_EQ(bit_sink.Bits(), 18); + + bit_sink.GetBits(18, &encoded); + EXPECT_EQ(encoded, 0x37357); + + // Now check that decoding it works as well + BitStream bit_src(encoded, 19); + + IntegerSequenceDecoder dec(kValueRange); + auto decoded_vals = dec.Decode(5, &bit_src); + ASSERT_EQ(decoded_vals.size(), 5); + EXPECT_EQ(decoded_vals[0], 7); + EXPECT_EQ(decoded_vals[1], 5); + EXPECT_EQ(decoded_vals[2], 3); + EXPECT_EQ(decoded_vals[3], 6); + EXPECT_EQ(decoded_vals[4], 10); +} + +// Test a specific quint encoding/decoding. This test makes sure that the way we +// encode and decode integer sequences matches what we should expect out of the +// reference ASTC encoder. +TEST(ASTCIntegerSequenceCodecTest, TestDecodeThenEncode) { + std::vector vals = {{ 16, 18, 17, 4, 7, 14, 10, 0 }}; + const uint64_t kValEncoding = 0x2b9c83dc; + + BitStream bit_src(kValEncoding, 64); + IntegerSequenceDecoder dec(19); + auto decoded_vals = dec.Decode(8, &bit_src); + ASSERT_EQ(decoded_vals.size(), vals.size()); + for (size_t i = 0; i < decoded_vals.size(); ++i) { + EXPECT_EQ(decoded_vals[i], vals[i]); + } + + // Setup bit src/sink + BitStream bit_sink; + IntegerSequenceEncoder enc(19); + for (const auto& v : vals) { + enc.AddValue(v); + } + enc.Encode(&bit_sink); + EXPECT_EQ(bit_sink.Bits(), 35); + + uint64_t encoded = 0; + EXPECT_TRUE(bit_sink.GetBits(35, &encoded)); + EXPECT_EQ(encoded, kValEncoding) + << std::hex << encoded << " -- " << kValEncoding; +} + +// Same as the previous test, except it uses a trit encoding rather than a +// quint encoding. +TEST(ASTCIntegerSequenceCodecTest, TestDecodeThenEncodeTrits) { + std::vector vals = {{ 6, 0, 0, 2, 0, 0, 0, 0, 8, 0, 0, 0, 0, 8, 8, 0 }}; + const uint64_t kValEncoding = 0x0004c0100001006ULL; + + BitStream bit_src(kValEncoding, 64); + IntegerSequenceDecoder dec(11); + auto decoded_vals = dec.Decode(vals.size(), &bit_src); + ASSERT_EQ(decoded_vals.size(), vals.size()); + for (size_t i = 0; i < decoded_vals.size(); ++i) { + EXPECT_EQ(decoded_vals[i], vals[i]); + } + + // Setup bit src/sink + BitStream bit_sink; + IntegerSequenceEncoder enc(11); + for (const auto& v : vals) { + enc.AddValue(v); + } + enc.Encode(&bit_sink); + EXPECT_EQ(bit_sink.Bits(), 58); + + uint64_t encoded = 0; + EXPECT_TRUE(bit_sink.GetBits(58, &encoded)); + EXPECT_EQ(encoded, kValEncoding) + << std::hex << encoded << " -- " << kValEncoding; +} + +// Generate a random sequence of integer codings with different ranges to test +// the reciprocability of our codec (encoded sequences should be able to +// decoded) +TEST(ASTCIntegerSequenceCodecTest, TestRandomReciprocation) { + std::mt19937 mt(0xbad7357); + std::uniform_int_distribution rand(0, 255); + + for (int test = 0; test < 1600; ++test) { + // Generate a random number of values and a random range + int num_vals = 4 + rand(mt) % 44; // Up to 48 weights in a grid + int range = 1 + rand(mt) % 63; + + // If this produces a bit pattern larger than our buffer, then ignore + // it... we already know what our bounds are for the integer sequences + int num_bits = IntegerSequenceCodec::GetBitCountForRange(num_vals, range); + if (num_bits >= 64) { + continue; + } + + std::vector generated_vals(num_vals); + for (auto& val : generated_vals) { + val = rand(mt) % (range + 1); + } + + // Encode the values using the + BitStream bit_sink; + + // Add them to the encoder + IntegerSequenceEncoder enc(range); + for (int v : generated_vals) { + enc.AddValue(v); + } + enc.Encode(&bit_sink); + + uint64_t encoded = 0; + bit_sink.GetBits(bit_sink.Bits(), &encoded); + ASSERT_GE(encoded, 0); + EXPECT_LT(encoded, 1ULL << num_bits); + + BitStream bit_src(encoded, 64); + + IntegerSequenceDecoder dec(range); + auto decoded_vals = dec.Decode(num_vals, &bit_src); + + ASSERT_EQ(decoded_vals.size(), generated_vals.size()); + for (size_t i = 0; i < decoded_vals.size(); ++i) { + EXPECT_EQ(decoded_vals[i], generated_vals[i]); + } + } +} + +} // namespace diff --git a/src/decoder/test/intermediate_astc_block_test.cc b/src/decoder/test/intermediate_astc_block_test.cc new file mode 100644 index 0000000..69935ef --- /dev/null +++ b/src/decoder/test/intermediate_astc_block_test.cc @@ -0,0 +1,453 @@ +// 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/intermediate_astc_block.h" +#include "src/decoder/test/image_utils.h" + +#include +#include + +#include + +namespace astc_codec { + +namespace { + +using ::testing::ElementsAre; +using ::testing::Eq; +using ::testing::HasSubstr; +using ::testing::Optional; +using ::testing::SizeIs; +using ::testing::TestWithParam; +using ::testing::ValuesIn; + +// Test to make sure that unpacking an error block returns false. +TEST(IntermediateASTCBlockTest, TestUnpackError) { + const PhysicalASTCBlock kErrorBlock(base::UInt128(0)); + EXPECT_FALSE(UnpackVoidExtent(kErrorBlock)); + EXPECT_FALSE(UnpackIntermediateBlock(kErrorBlock)); +} + +// Test to make sure that if we don't populate our weight data in the +// intermediate block than the resulting color range should error due to the +// mismatch. +TEST(IntermediateASTCBlockTest, TestEndpointRangeErrorOnNotSettingWeights) { + IntermediateBlockData data; + data.weight_range = 15; + for (auto& ep : data.endpoints) { + ep.mode = ColorEndpointMode::kLDRRGBDirect; + } + data.weight_grid_dim_x = 6; + data.weight_grid_dim_y = 6; + EXPECT_EQ(-1, EndpointRangeForBlock(data)); + + base::UInt128 dummy; + auto err_str = Pack(data, &dummy); + EXPECT_TRUE(err_str.hasValue()); + EXPECT_THAT(err_str.value(), HasSubstr("Incorrect number of weights")); +} + +// Test to make sure that if we run out of bits, then we should say so. +TEST(IntermediateASTCBlockTest, TestEndpointRangeErrorOnNotEnoughBits) { + IntermediateBlockData data; + data.weight_range = 1; + data.partition_id = 0; + data.endpoints.resize(3); + for (auto& ep : data.endpoints) { + ep.mode = ColorEndpointMode::kLDRRGBDirect; + } + data.weight_grid_dim_x = 8; + data.weight_grid_dim_y = 8; + EXPECT_EQ(-2, EndpointRangeForBlock(data)); + + // Resize the weights to get past the error that they do not match the grid + // dimensions. + data.weights.resize(64); + + base::UInt128 dummy; + auto err_str = Pack(data, &dummy); + EXPECT_TRUE(err_str.hasValue()); + EXPECT_THAT(err_str.value(), HasSubstr("illegal color range")); +} + +// Test to make sure that as we increase the number of weights, we decrease the +// allowable range of colors +TEST(IntermediateASTCBlockTest, TestEndpointRangeForBlock) { + IntermediateBlockData data; + data.weight_range = 2; + data.endpoints.resize(2); + data.dual_plane_channel.clear(); + for (auto& ep : data.endpoints) { + ep.mode = ColorEndpointMode::kLDRRGBDirect; + } + + // Weight params control how many weights are present in a block + struct WeightParams { + int width; + int height; + + // We should sort based on number of weights for these params + int NumWeights() const { return width * height; } + bool operator<(const WeightParams& other) const { + return NumWeights() < other.NumWeights(); + } + }; + + std::vector weight_params; + for (int y = 2; y < 8; ++y) { + for (int x = 2; x < 8; ++x) { + weight_params.emplace_back(WeightParams{x, y}); + } + } + + // Sort weights from fewest to largest such that the allowable color range + // should be monotonically decreasing + std::sort(weight_params.begin(), weight_params.end()); + + // Keep track of the largest available color range and measure that it + // decreases as we add more weights to our block + int last_color_range = 255; + for (const auto& params : weight_params) { + data.weight_grid_dim_x = params.width; + data.weight_grid_dim_y = params.height; + + const int color_range = EndpointRangeForBlock(data); + EXPECT_LE(color_range, last_color_range); + last_color_range = std::min(color_range, last_color_range); + } + + // Make sure that we actually changed it at some point. + EXPECT_LT(last_color_range, 255); +} + +// Test to make sure that unpacking an legitimate ASTC block returns the encoded +// values that we expect. +TEST(IntermediateASTCBlockTest, TestUnpackNonVoidExtentBlock) { + PhysicalASTCBlock blk(0x0000000001FE000173ULL); + auto b = UnpackIntermediateBlock(blk); + ASSERT_TRUE(b); + + const auto& data = b.value(); + EXPECT_EQ(data.weight_grid_dim_x, 6); + EXPECT_EQ(data.weight_grid_dim_y, 5); + EXPECT_EQ(data.weight_range, 7); + + EXPECT_FALSE(data.partition_id); + EXPECT_FALSE(data.dual_plane_channel); + + ASSERT_EQ(data.weights.size(), 30); + for (auto weight : data.weights) { + EXPECT_EQ(weight, 0); + } + + ASSERT_EQ(data.endpoints.size(), 1); + for (const auto& ep_data : data.endpoints) { + EXPECT_EQ(ep_data.mode, ColorEndpointMode::kLDRLumaDirect); + ASSERT_EQ(ep_data.colors.size(), 2); + EXPECT_EQ(ep_data.colors[0], 0); + EXPECT_EQ(ep_data.colors[1], 255); + } +} + +// Make sure that we can pack blocks that aren't void extent blocks. (In other +// words, can we actually deal with intermediate ASTC data). +TEST(IntermediateASTCBlockTest, TestPackNonVoidExtentBlock) { + IntermediateBlockData data; + + data.weight_grid_dim_x = 6; + data.weight_grid_dim_y = 5; + data.weight_range = 7; + + data.partition_id = {}; + data.dual_plane_channel = {}; + + data.weights.resize(30); + for (auto& weight : data.weights) { + weight = 0; + } + + data.endpoints.resize(1); + for (auto& ep_data : data.endpoints) { + ep_data.mode = ColorEndpointMode::kLDRLumaDirect; + ep_data.colors.resize(2); + ep_data.colors[0] = 0; + ep_data.colors[1] = 255; + } + + base::UInt128 packed; + auto error_str = Pack(data, &packed); + ASSERT_FALSE(error_str) << (error_str ? error_str.value() : std::string("")); + EXPECT_EQ(packed, 0x0000000001FE000173ULL); +} + +// Make sure that we can unpack void extent blocks +TEST(IntermediateASTCBlockTest, TestUnpackVoidExtentBlock) { + PhysicalASTCBlock void_extent_block(0xFFFFFFFFFFFFFDFCULL); + + auto b = UnpackVoidExtent(void_extent_block); + ASSERT_TRUE(b); + + const auto& data = b.value(); + EXPECT_EQ(data.r, 0); + EXPECT_EQ(data.g, 0); + EXPECT_EQ(data.b, 0); + EXPECT_EQ(data.a, 0); + for (const auto& coord : data.coords) { + EXPECT_EQ(coord, (1 << 13) - 1); + } + + base::UInt128 more_interesting(0xdeadbeefdeadbeefULL, 0xFFF8003FFE000DFCULL); + b = UnpackVoidExtent(PhysicalASTCBlock(more_interesting)); + ASSERT_TRUE(b); + + const auto& other_data = b.value(); + EXPECT_EQ(other_data.r, 0xbeef); + EXPECT_EQ(other_data.g, 0xdead); + EXPECT_EQ(other_data.b, 0xbeef); + EXPECT_EQ(other_data.a, 0xdead); + EXPECT_EQ(other_data.coords[0], 0); + EXPECT_EQ(other_data.coords[1], 8191); + EXPECT_EQ(other_data.coords[2], 0); + EXPECT_EQ(other_data.coords[3], 8191); +} + +// Make sure that we can pack void extent blocks and void extent data. +TEST(IntermediateASTCBlockTest, TestPackVoidExtentBlock) { + VoidExtentData data; + data.r = 0; + data.g = 0; + data.b = 0; + data.a = 0; + for (auto& coord : data.coords) { + coord = (1 << 13) - 1; + } + + base::UInt128 packed; + auto error_str = Pack(data, &packed); + ASSERT_FALSE(error_str) << (error_str ? error_str.value() : std::string("")); + EXPECT_EQ(packed, 0xFFFFFFFFFFFFFDFCULL); + + data.r = 0xbeef; + data.g = 0xdead; + data.b = 0xbeef; + data.a = 0xdead; + data.coords[0] = 0; + data.coords[1] = 8191; + data.coords[2] = 0; + data.coords[3] = 8191; + + error_str = Pack(data, &packed); + ASSERT_FALSE(error_str) << (error_str ? error_str.value() : std::string("")); + EXPECT_EQ(packed, + base::UInt128(0xdeadbeefdeadbeefULL, 0xFFF8003FFE000DFCULL)); +} + +// Make sure that the color endpoint mode is properly repacked. This test case +// was created as a bug during testing. +TEST(IntermediateASTCBlockTest, TestPackUnpackWithSameCEM) { + base::UInt128 orig(0xe8e8eaea20000980ULL, 0x20000200cb73f045ULL); + + auto b = UnpackIntermediateBlock(PhysicalASTCBlock(orig)); + ASSERT_TRUE(b); + + base::UInt128 repacked; + auto err_str = Pack(b.value(), &repacked); + ASSERT_FALSE(err_str) << (err_str ? err_str.value() : std::string("")); + + EXPECT_EQ(repacked, orig); + + // Test case #2 + orig = base::UInt128(0x3300c30700cb01c5ULL, 0x0573907b8c0f6879ULL); + b = UnpackIntermediateBlock(PhysicalASTCBlock(orig)); + ASSERT_TRUE(b); + + err_str = Pack(b.value(), &repacked); + ASSERT_FALSE(err_str) << (err_str ? err_str.value() : std::string("")); + EXPECT_EQ(repacked, orig); +} + +// Test that we can encode/decode a block that uses a very large gap +// between weight and endpoint data. +TEST(IntermediateASTCBlockTest, TestPackingWithLargeGap) { + // We can construct this block by doing the following: + // -- choose a block mode that only gives 24 weight bits + // -- choose the smallest endpoint mode: grayscale direct + // -- make sure there are no partitions + const base::UInt128 orig(0xBEDEAD0000000000ULL, 0x0000000001FE032EULL); + const auto b = UnpackIntermediateBlock(PhysicalASTCBlock(orig)); + ASSERT_TRUE(b); + + const auto& data = b.value(); + EXPECT_EQ(data.weight_grid_dim_x, 2); + EXPECT_EQ(data.weight_grid_dim_y, 3); + EXPECT_EQ(data.weight_range, 15); + + EXPECT_FALSE(data.partition_id); + EXPECT_FALSE(data.dual_plane_channel); + + ASSERT_EQ(data.endpoints.size(), 1); + EXPECT_EQ(data.endpoints.at(0).mode, ColorEndpointMode::kLDRLumaDirect); + + ASSERT_EQ(data.endpoints.at(0).colors.size(), 2); + EXPECT_EQ(data.endpoints.at(0).colors.at(0), 255); + EXPECT_EQ(data.endpoints.at(0).colors.at(1), 0); + + // Now encode it again + base::UInt128 repacked; + const auto err_str = Pack(b.value(), &repacked); + EXPECT_EQ(orig, repacked) << (err_str ? err_str.value() : std::string("")); +} + +// Take a block that is encoded using direct luma with full byte values and see +// if we properly set the endpoint range. +TEST(IntermediateASTCBlockTest, TestEndpointRange) { + PhysicalASTCBlock blk(0x0000000001FE000173ULL); + EXPECT_THAT(blk.ColorValuesRange(), Optional(Eq(255))); + + auto b = UnpackIntermediateBlock(blk); + ASSERT_TRUE(b); + + const auto& data = b.value(); + ASSERT_THAT(data.endpoints, SizeIs(1)); + EXPECT_THAT(data.endpoints[0].mode, Eq(ColorEndpointMode::kLDRLumaDirect)); + EXPECT_THAT(data.endpoints[0].colors, ElementsAre(0, 255)); + EXPECT_THAT(data.endpoint_range, Optional(Eq(255))); +} + +struct ImageTestParams { + std::string image_name; + int checkered_dim; +}; + +static void PrintTo(const ImageTestParams& params, std::ostream* os) { + *os << "ImageTestParams(" << params.image_name << ")"; +} + +class IntermediateASTCBlockTest : public TestWithParam { }; + +// Test whether or not a real-world ASTC implementation can be unpacked and +// then repacked into the same implementation. In conjunction with the other +// tests, we make sure that we can recreate ASTC blocks that we have previously +// unpacked. +TEST_P(IntermediateASTCBlockTest, TestPackUnpack) { + const auto& params = GetParam(); + const int astc_dim = 8; + const int img_dim = params.checkered_dim * astc_dim; + const std::string astc = LoadASTCFile(params.image_name); + + // Make sure that unpacking and repacking all of the blocks works... + const int kNumASTCBlocks = (img_dim / astc_dim) * (img_dim / astc_dim); + for (int i = 0; i < kNumASTCBlocks; ++i) { + base::UInt128 block_bits; + memcpy(&block_bits, astc.data() + PhysicalASTCBlock::kSizeInBytes * i, + PhysicalASTCBlock::kSizeInBytes); + + const PhysicalASTCBlock block(block_bits); + + base::UInt128 repacked; + if (block.IsVoidExtent()) { + auto b = UnpackVoidExtent(block); + ASSERT_TRUE(b); + + auto err_str = Pack(b.value(), &repacked); + ASSERT_FALSE(err_str) << (err_str ? err_str.value() : std::string("")); + } else { + auto b = UnpackIntermediateBlock(block); + ASSERT_TRUE(b); + + // Check to see that we properly set the endpoint range when we decoded + // the block. + auto& block_data = b.value(); + EXPECT_EQ(block_data.endpoint_range, block.ColorValuesRange()); + + // Reset the endpoint range here to see if we correctly reconstruct it + // below + block_data.endpoint_range = {}; + + auto err_str = Pack(b.value(), &repacked); + ASSERT_FALSE(err_str) << (err_str ? err_str.value() : std::string("")); + } + + // You would expect the following line to be enough: + // EXPECT_EQ(repacked, block.GetBlockBits()) + // ... except that the ASTC encoder makes some interesting decisions + // about how to encode the same logical bits. One example is that + // sometimes if all partitions share an endpoint mode, the encoded + // block will not use the shared CEM mode, and rather list each + // partition's mode explicitly. For that reason, we just need to make as + // close of an approximation as possible that we decode to the same + // physical values. + + PhysicalASTCBlock pb(repacked); + ASSERT_FALSE(pb.IsIllegalEncoding()); + + base::UInt128 pb_color_mask = + (base::UInt128(1) << pb.NumColorBits().value()) - 1; + base::UInt128 pb_color_bits = + pb.GetBlockBits() >> pb.ColorStartBit().value(); + pb_color_bits &= pb_color_mask; + + base::UInt128 b_color_mask = + (base::UInt128(1) << pb.NumColorBits().value()) - 1; + base::UInt128 b_color_bits = + block.GetBlockBits() >> block.ColorStartBit().value(); + b_color_bits &= b_color_mask; + + EXPECT_EQ(pb_color_mask, b_color_mask); + EXPECT_EQ(pb_color_bits, b_color_bits); + + EXPECT_EQ(pb.IsVoidExtent(), block.IsVoidExtent()); + EXPECT_EQ(pb.VoidExtentCoords(), block.VoidExtentCoords()); + + EXPECT_EQ(pb.WeightGridDims(), block.WeightGridDims()); + EXPECT_EQ(pb.WeightRange(), block.WeightRange()); + EXPECT_EQ(pb.NumWeightBits(), block.NumWeightBits()); + EXPECT_EQ(pb.WeightStartBit(), block.WeightStartBit()); + + EXPECT_EQ(pb.IsDualPlane(), block.IsDualPlane()); + EXPECT_EQ(pb.DualPlaneChannel(), block.DualPlaneChannel()); + + EXPECT_EQ(pb.NumPartitions(), block.NumPartitions()); + EXPECT_EQ(pb.PartitionID(), block.PartitionID()); + + EXPECT_EQ(pb.NumColorValues(), block.NumColorValues()); + EXPECT_EQ(pb.ColorValuesRange(), block.ColorValuesRange()); + + for (int j = 0; j < pb.NumPartitions().valueOr(0); ++j) { + EXPECT_EQ(pb.GetEndpointMode(j), block.GetEndpointMode(j)); + } + } +} + +std::vector GetImageTestParams() { + return { + // image_name checkered_dim + { "checkered_4", 4 }, + { "checkered_5", 5 }, + { "checkered_6", 6 }, + { "checkered_7", 7 }, + { "checkered_8", 8 }, + { "checkered_9", 9 }, + { "checkered_10", 10 }, + { "checkered_11", 11 }, + { "checkered_12", 12 }, + }; +} + +INSTANTIATE_TEST_CASE_P(Checkered, IntermediateASTCBlockTest, + ValuesIn(GetImageTestParams())); + +} // namespace + +} // namespace astc_codec diff --git a/src/decoder/test/logical_astc_block_test.cc b/src/decoder/test/logical_astc_block_test.cc new file mode 100644 index 0000000..ed85f3f --- /dev/null +++ b/src/decoder/test/logical_astc_block_test.cc @@ -0,0 +1,273 @@ +// 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/logical_astc_block.h" +#include "src/decoder/test/image_utils.h" + +#include +#include + +#include +#include + +namespace astc_codec { + +namespace { + +using ::testing::Eq; +using ::testing::ElementsAre; +using ::testing::TestWithParam; +using ::testing::ValuesIn; + +ImageBuffer LoadGoldenImageWithAlpha(std::string basename) { + const std::string filename = std::string("src/decoder/testdata/") + basename + ".bmp"; + ImageBuffer result; + LoadGoldenBmp(filename, &result); + EXPECT_EQ(result.BytesPerPixel(), 4); + return result; +} + +ImageBuffer LoadGoldenImage(std::string basename) { + const std::string filename = std::string("src/decoder/testdata/") + basename + ".bmp"; + ImageBuffer result; + LoadGoldenBmp(filename, &result); + EXPECT_EQ(result.BytesPerPixel(), 3); + return result; +} + +struct ImageTestParams { + std::string image_name; + bool has_alpha; + Footprint footprint; + int width; + int height; +}; + +static void PrintTo(const ImageTestParams& params, std::ostream* os) { + *os << "ImageTestParams(" << params.image_name << ", " + << params.width << "x" << params.height << ", " + << (params.has_alpha ? "RGBA" : "RGB") << ", " + << "footprint " << params.footprint.Width() << "x" + << params.footprint.Height() << ")"; +} + +class LogicalASTCBlockTest : public TestWithParam { }; + +// Test to make sure that reading out color values from blocks is not +// terribly wrong. To do so, we compress an image and then decompress it +// using our logical blocks and the library. The difference between the +// decoded images should be minimal. +TEST_P(LogicalASTCBlockTest, ImageWithFootprint) { + const auto& params = GetParam(); + const std::string astc = LoadASTCFile(params.image_name); + + ImageBuffer our_decoded_image; + our_decoded_image.Allocate(params.width, params.height, params.has_alpha ? 4 : 3); + + const int block_width = params.footprint.Width(); + const int block_height = params.footprint.Height(); + + base::UInt128 block; + for (int i = 0; i < astc.size(); i += 16) { + const int block_index = i / 16; + const int blocks_wide = + (params.width + block_width - 1) / block_width; + const int block_x = block_index % blocks_wide; + const int block_y = block_index / blocks_wide; + memcpy(&block, astc.data() + i, sizeof(block)); + + PhysicalASTCBlock physical_block(block); + if (physical_block.IsVoidExtent()) { + auto ve = UnpackVoidExtent(physical_block); + ASSERT_TRUE(ve) << "ASTC encoder produced invalid block!"; + } else { + auto ib = UnpackIntermediateBlock(physical_block); + ASSERT_TRUE(ib) << "ASTC encoder produced invalid block!"; + } + + // Make sure that the library doesn't produce incorrect ASTC blocks. + // This is covered in more depth in other tests in + // intermediate_astc_block_test and physical_astc_block_test + auto lb = UnpackLogicalBlock(params.footprint, physical_block); + ASSERT_TRUE(lb) << "ASTC encoder produced invalid block!"; + + LogicalASTCBlock logical_block = lb.value(); + const size_t color_size = params.has_alpha ? 4 : 3; + + for (int y = 0; y < block_height; ++y) { + for (int x = 0; x < block_width; ++x) { + const int px = block_width * block_x + x; + const int py = block_height * block_y + y; + + // Skip out of bounds. + if (px >= params.width || py >= params.height) { + continue; + } + + uint8_t* pixel = our_decoded_image(px, py); + const RgbaColor decoded_color = logical_block.ColorAt(x, y); + ASSERT_LE(color_size, decoded_color.size()); + + for (int c = 0; c < color_size; ++c) { + // All of the pixels should also be 8-bit values. + ASSERT_GE(decoded_color[c], 0); + ASSERT_LT(decoded_color[c], 256); + pixel[c] = decoded_color[c]; + } + } + } + } + + // Check that the decoded image is *very* similar to the library decoding + // of an ASTC texture. They may not be exact due to differences in how we + // convert a 16-bit float to an 8-bit integer. + ImageBuffer decoded_image = params.has_alpha ? LoadGoldenImageWithAlpha(params.image_name) : LoadGoldenImage(params.image_name); + CompareSumOfSquaredDifferences(decoded_image, our_decoded_image, 1.0); +} + +// Test to make sure that a simple gradient image can be compressed and decoded +// by our logical block representation. This should work with every footprint. +std::vector GetSyntheticImageTestParams() { + return { + // image_name alpha astc footprint width height + { "footprint_4x4", false, Footprint::Get4x4(), 32, 32 }, + { "footprint_5x4", false, Footprint::Get5x4(), 32, 32 }, + { "footprint_5x5", false, Footprint::Get5x5(), 32, 32 }, + { "footprint_6x5", false, Footprint::Get6x5(), 32, 32 }, + { "footprint_6x6", false, Footprint::Get6x6(), 32, 32 }, + { "footprint_8x5", false, Footprint::Get8x5(), 32, 32 }, + { "footprint_8x6", false, Footprint::Get8x6(), 32, 32 }, + { "footprint_10x5", false, Footprint::Get10x5(), 32, 32 }, + { "footprint_10x6", false, Footprint::Get10x6(), 32, 32 }, + { "footprint_8x8", false, Footprint::Get8x8(), 32, 32 }, + { "footprint_10x8", false, Footprint::Get10x8(), 32, 32 }, + { "footprint_10x10", false, Footprint::Get10x10(), 32, 32 }, + { "footprint_12x10", false, Footprint::Get12x10(), 32, 32 }, + { "footprint_12x12", false, Footprint::Get12x12(), 32, 32 }, + }; +} + +INSTANTIATE_TEST_CASE_P(Synthetic, LogicalASTCBlockTest, + ValuesIn(GetSyntheticImageTestParams())); + +// Test to make sure that reading out color values from blocks in a real-world +// image isn't terribly wrong, either. +std::vector GetRealWorldImageTestParams() { + return { + // image_name alpha astc footprint width height + { "rgb_4x4", false, Footprint::Get4x4(), 224, 288 }, + { "rgb_6x6", false, Footprint::Get6x6(), 224, 288 }, + { "rgb_8x8", false, Footprint::Get8x8(), 224, 288 }, + { "rgb_12x12", false, Footprint::Get12x12(), 224, 288 }, + { "rgb_5x4", false, Footprint::Get5x4(), 224, 288 } + }; +} + +INSTANTIATE_TEST_CASE_P(RealWorld, LogicalASTCBlockTest, + ValuesIn(GetRealWorldImageTestParams())); + +// Test to make sure that reading out color values from blocks in a real-world +// image isn't terribly wrong, either. +std::vector GetTransparentImageTestParams() { + return { + // image_name alpha astc footprint width height + { "atlas_small_4x4", true, Footprint::Get4x4(), 256, 256 }, + { "atlas_small_5x5", true, Footprint::Get5x5(), 256, 256 }, + { "atlas_small_6x6", true, Footprint::Get6x6(), 256, 256 }, + { "atlas_small_8x8", true, Footprint::Get8x8(), 256, 256 }, + }; +} + +INSTANTIATE_TEST_CASE_P(Transparent, LogicalASTCBlockTest, + ValuesIn(GetTransparentImageTestParams())); + +// Test to make sure that if we set our endpoints then it's reflected in our +// color selection +TEST(LogicalASTCBlockTest, SetEndpoints) { + LogicalASTCBlock logical_block(Footprint::Get8x8()); + + // Setup a weight checkerboard + for (int j = 0; j < 8; ++j) { + for (int i = 0; i < 8; ++i) { + if (((i ^ j) & 1) == 1) { + logical_block.SetWeightAt(i, j, 0); + } else { + logical_block.SetWeightAt(i, j, 64); + } + } + } + + // Now set the colors to something ridiculous + logical_block.SetEndpoints({{ 123, 45, 67, 89 }}, {{ 101, 121, 31, 41 }}, 0); + + // For each pixel, we expect it to mirror the endpoints in a checkerboard + // pattern + for (int j = 0; j < 8; ++j) { + for (int i = 0; i < 8; ++i) { + if (((i ^ j) & 1) == 1) { + EXPECT_THAT(logical_block.ColorAt(i, j), ElementsAre(123, 45, 67, 89)); + } else { + EXPECT_THAT(logical_block.ColorAt(i, j), ElementsAre(101, 121, 31, 41)); + } + } + } +} + +// Test whether or not setting weight values under different circumstances is +// supported and reflected in the query functions. +TEST(LogicalASTCBlockTest, SetWeightVals) { + LogicalASTCBlock logical_block(Footprint::Get4x4()); + + EXPECT_THAT(logical_block.GetFootprint(), Eq(Footprint::Get4x4())); + + // Not a dual plane by default + EXPECT_FALSE(logical_block.IsDualPlane()); + logical_block.SetWeightAt(2, 3, 2); + + // Set the dual plane + logical_block.SetDualPlaneChannel(0); + EXPECT_TRUE(logical_block.IsDualPlane()); + + // This shouldn't have reset our weight + const LogicalASTCBlock other_block = logical_block; + EXPECT_THAT(other_block.WeightAt(2, 3), Eq(2)); + EXPECT_THAT(other_block.DualPlaneWeightAt(0, 2, 3), Eq(2)); + + // If we set the dual plane weight, it shouldn't change the original weight + // value or the other channels + logical_block.SetDualPlaneWeightAt(0, 2, 3, 1); + EXPECT_THAT(logical_block.WeightAt(2, 3), Eq(2)); + EXPECT_THAT(logical_block.DualPlaneWeightAt(0, 2, 3), Eq(1)); + for (int i = 1; i < 4; ++i) { + EXPECT_THAT(logical_block.DualPlaneWeightAt(i, 2, 3), Eq(2)); + } + + // Remove the dual plane + logical_block.SetDualPlaneChannel(-1); + EXPECT_FALSE(logical_block.IsDualPlane()); + + // Now the original dual plane weight should be reset back to the others. Note + // that we have to call DualPlaneWeightAt from a const logical block since + // returning a reference to a weight that doesn't exist is illegal. + const LogicalASTCBlock other_block2 = logical_block; + EXPECT_THAT(logical_block.WeightAt(2, 3), Eq(2)); + for (int i = 0; i < 4; ++i) { + EXPECT_EQ(logical_block.WeightAt(2, 3), + other_block2.DualPlaneWeightAt(i, 2, 3)); + } +} + +} // namespace + +} // namespace astc_codec diff --git a/src/decoder/test/partition_test.cc b/src/decoder/test/partition_test.cc new file mode 100644 index 0000000..63adfb5 --- /dev/null +++ b/src/decoder/test/partition_test.cc @@ -0,0 +1,263 @@ +// 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/partition.h" + +#include +#include + +#include +#include +#include +#include + +namespace { + +using ::testing::ElementsAreArray; +using ::testing::Eq; +using ::testing::Le; +using ::testing::Not; + +using astc_codec::Footprint; +using astc_codec::Partition; +using astc_codec::PartitionMetric; +using astc_codec::GetASTCPartition; +using astc_codec::FindClosestASTCPartition; + +// Test to make sure that a simple difference between two partitions where +// most of the values are the same returns what we expect. +TEST(PartitionTest, TestSimplePartitionMetric) { + Partition a = {Footprint::Get6x6(), /* num_parts = */ 2, + /* partition_id = */ {}, /* assignment = */ {}}; + Partition b = a; + + a.assignment = { + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, + }; + + b.assignment = { + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + }; + + const int dist = PartitionMetric(a, b); + EXPECT_EQ(dist, 2); +} + +// Test to make sure that if one partition is a subset of another that we still +// return the proper difference against the subset of the larger one. +TEST(PartitionDeathTest, TestPartitionMetric) { + Partition a = {Footprint::Get4x4(), /* num_parts = */ 2, + /* partition_id = */ {}, /* assignment = */ {}}; + Partition b = {Footprint::Get6x6(), /* num_parts = */ 2, + /* partition_id = */ {}, /* assignment = */ {}}; + + a.assignment = {{ + 1, 1, 1, 1, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 1, + }}; + + b.assignment = {{ + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + }}; + + EXPECT_DEATH(PartitionMetric(a, b), ""); +} + +// Test to make sure that even if we have different numbers of subsets for each +// partition, that the returned value is what we'd expect. +TEST(PartitionTest, TestDiffPartsPartitionMetric) { + Partition a = {Footprint::Get4x4(), /* num_parts = */ 2, + /* partition_id = */ {}, /* assignment = */ {}}; + Partition b = {Footprint::Get4x4(), /* num_parts = */ 3, + /* partition_id = */ {}, /* assignment = */ {}}; + + a.assignment = {{ + 2, 2, 2, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 1, + }}; + + b.assignment = {{ + 1, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0 + }}; + + const int dist = PartitionMetric(a, b); + EXPECT_EQ(dist, 3); +} + +// An additional sanity check test that makes sure that we're not always mapping +// zero to zero in our tests. +TEST(PartitionTest, TestDiffMappingPartitionMetric) { + Partition a = {Footprint::Get4x4(), /* num_parts = */ 2, + /* partition_id = */ {}, /* assignment = */ {}}; + Partition b = {Footprint::Get4x4(), /* num_parts = */ 3, + /* partition_id = */ {}, /* assignment = */ {}}; + + a.assignment = {{ + 0, 1, 2, 2, + 2, 2, 2, 2, + 2, 2, 2, 2, + 2, 2, 2, 2, + }}; + + b.assignment = {{ + 1, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + }}; + + const int dist = PartitionMetric(a, b); + EXPECT_EQ(dist, 1); +} + +// Finally, if we grab an ASTC partition and modify it a tad, the closest +// partition should still be the same ASTC partition. +TEST(PartitionTest, TestFindingASTCPartition) { + const Partition astc = GetASTCPartition(Footprint::Get12x12(), 3, 0x3CB); + Partition almost_astc = astc; + almost_astc.assignment[0]++; + + const Partition& closest_astc = FindClosestASTCPartition(almost_astc); + EXPECT_EQ(astc, closest_astc); +} + +// Test a partition that was obtained from the reference ASTC encoder. We should +// be able to match it exactly +TEST(PartitionTest, TestSpecificPartition) { + const Partition astc = GetASTCPartition(Footprint::Get10x6(), 3, 557); + EXPECT_THAT(astc.assignment, ElementsAreArray(std::array {{ + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2 }})); +} + +// Make sure that when we match against this specific partition, it'll return a +// partition with the same number of subsets +TEST(PartitionTest, EstimatedPartitionSubsets) { + Partition partition = { + /* footprint = */ Footprint::Get6x6(), + /* num_parts = */ 2, + /* partition_id = */ {}, + /* assignment = */ { + 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1 + }}; + + const Partition astc = FindClosestASTCPartition(partition); + EXPECT_THAT(astc.num_parts, Eq(partition.num_parts)); +} + +// Make sure that regardless of what partition we match against, it'll return a +// partition with at most a fewer number of subsets +TEST(PartitionTest, EstimatedPartitionFewerSubsets) { + std::mt19937 random(0xdeadbeef); + auto randUniform = [&random](int max) { + std::uniform_int_distribution<> dist(0, max - 1); + return dist(random); + }; + + constexpr int kNumFootprints = Footprint::NumValidFootprints(); + const auto kFootprints = std::array {{ + Footprint::Get4x4(), + Footprint::Get5x4(), + Footprint::Get5x5(), + Footprint::Get6x5(), + Footprint::Get6x6(), + Footprint::Get8x5(), + Footprint::Get8x6(), + Footprint::Get8x8(), + Footprint::Get10x5(), + Footprint::Get10x6(), + Footprint::Get10x8(), + Footprint::Get10x10(), + Footprint::Get12x10(), + Footprint::Get12x12() + }}; + + constexpr int kNumTests = 200; + for (int i = 0; i < kNumTests; ++i) { + const auto& footprint = kFootprints[randUniform(kNumFootprints)]; + const int num_parts = 2 + randUniform(3); + Partition partition = { + footprint, + num_parts, + /* partition_id = */ {}, + /* assignment = */ std::vector(footprint.NumPixels(), 0)}; + + for (auto& p : partition.assignment) { + p = randUniform(num_parts); + } + + const Partition astc = FindClosestASTCPartition(partition); + EXPECT_THAT(astc.num_parts, Le(partition.num_parts)) + << "Test #" << i << ": " + << "Selected partition with ID " << astc.partition_id.value(); + } +} + +// Make sure that we generate unique partitions that are close to the +// candidates. +TEST(PartitionTest, UniquePartitionResults) { + Partition partition = { + /* footprint = */ Footprint::Get6x6(), + /* num_parts = */ 2, + /* partition_id = */ {}, + /* assignment = */ { + 0, 1, 1, 1, 1, 1, + 0, 1, 1, 1, 1, 1, + 0, 1, 1, 1, 1, 1, + 0, 1, 1, 1, 1, 1, + 0, 1, 1, 1, 1, 1, + 0, 1, 1, 1, 1, 1 + }}; + + const auto parts = FindKClosestASTCPartitions(partition, 2); + EXPECT_THAT(*parts[0], Not(Eq(*parts[1]))); +} + +// TODO(google): Verify somehow that the assignment generated from +// GetASTCPartition actually matches what's in the spec. The selection +// function was more or less copy/pasted though so it's unclear how to +// measure that against e.g. the ASTC encoder. + +} // namespace diff --git a/src/decoder/test/physical_astc_block_test.cc b/src/decoder/test/physical_astc_block_test.cc new file mode 100644 index 0000000..8eafe46 --- /dev/null +++ b/src/decoder/test/physical_astc_block_test.cc @@ -0,0 +1,361 @@ +// 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/physical_astc_block.h" +#include "src/base/uint128.h" + +#include + +#include +#include + +using astc_codec::PhysicalASTCBlock; +using astc_codec::ColorEndpointMode; +using astc_codec::base::UInt128; + +namespace { + +static const PhysicalASTCBlock kErrorBlock(UInt128(0)); + +// Test to make sure that each of the constructors work and that +// they produce the same block encodings, since the ASTC blocks +// are little-endian +TEST(PhysicalASTCBlockTest, TestConstructors) { + // Little-endian reading of bytes + PhysicalASTCBlock blk1(0x0000000001FE000173ULL); + PhysicalASTCBlock blk2( + std::string("\x73\x01\x00\xFE\x01\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16)); + EXPECT_EQ(blk1.GetBlockBits(), blk2.GetBlockBits()); +} + +// Test to see if we properly decode the maximum value that a weight +// can take in an ASTC block based on the block mode encoding. We test +// against a valid case and various error cases +TEST(PhysicalASTCBlockTest, TestWeightRange) { + PhysicalASTCBlock blk1(0x0000000001FE000173ULL); + auto weight_range = blk1.WeightRange(); + ASSERT_TRUE(weight_range); + EXPECT_EQ(weight_range.value(), 7); + + // If we flip the high bit then we should have a range of 31, + // although then we have too many bits and this should error. + PhysicalASTCBlock blk2(0x0000000001FE000373ULL); + EXPECT_FALSE(blk2.WeightRange()); + + // One bit per weight -- range of 1 + PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL); + weight_range = non_shared_cem.WeightRange(); + ASSERT_TRUE(weight_range); + EXPECT_EQ(weight_range.value(), 1); + + // Error blocks have no weight range + EXPECT_FALSE(kErrorBlock.WeightRange()); +} + +// Test to see if we properly decode the weight grid width and height +// in an ASTC block based on the block mode encoding. We test against +// a valid case and various error cases +TEST(PhysicalASTCBlockTest, TestWeightDims) { + PhysicalASTCBlock blk1(0x0000000001FE000173ULL); + auto weight_dims = blk1.WeightGridDims(); + EXPECT_TRUE(weight_dims); + EXPECT_EQ(weight_dims.value()[0], 6); + EXPECT_EQ(weight_dims.value()[1], 5); + + // If we flip the high bit then we should have a range of 31, + // although then we have too many bits for the weight grid + // and this should error. + PhysicalASTCBlock blk2(0x0000000001FE000373ULL); + EXPECT_FALSE(blk2.WeightGridDims()); + EXPECT_EQ(blk2.IsIllegalEncoding().value(), + "Too many bits required for weight grid"); + + // Dual plane block with 3x5 weight dims + PhysicalASTCBlock blk3(0x0000000001FE0005FFULL); + weight_dims = blk3.WeightGridDims(); + ASSERT_TRUE(weight_dims); + EXPECT_EQ(weight_dims->at(0), 3); + EXPECT_EQ(weight_dims->at(1), 5); + + // Error blocks shouldn't have any weight dims + EXPECT_FALSE(kErrorBlock.WeightGridDims()); + + PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL); + weight_dims = non_shared_cem.WeightGridDims(); + ASSERT_TRUE(weight_dims); + EXPECT_EQ(weight_dims->at(0), 8); + EXPECT_EQ(weight_dims->at(1), 8); +} + +// Test to see whether or not the presence of a dual-plane bit +// is decoded properly. Error encodings are tested to *not* return +// that they have dual planes. +TEST(PhysicalASTCBlockTest, TestDualPlane) { + PhysicalASTCBlock blk1(0x0000000001FE000173ULL); + EXPECT_FALSE(blk1.IsDualPlane()); + EXPECT_FALSE(kErrorBlock.IsDualPlane()); + + // If we flip the dual plane bit, we will have too many bits + // for the weight grid and this should error + PhysicalASTCBlock blk2(0x0000000001FE000573ULL); + EXPECT_FALSE(blk2.IsDualPlane()); + EXPECT_FALSE(blk2.WeightGridDims()); + EXPECT_EQ(blk2.IsIllegalEncoding().value(), + "Too many bits required for weight grid"); + + // A dual plane with 3x5 weight grid should be supported + PhysicalASTCBlock blk3(0x0000000001FE0005FFULL); + EXPECT_TRUE(blk3.IsDualPlane()); + + // If we use the wrong block mode, then a valid block + // shouldn't have any dual plane + PhysicalASTCBlock blk4(0x0000000001FE000108ULL); + EXPECT_FALSE(blk4.IsDualPlane()); + EXPECT_FALSE(blk4.IsIllegalEncoding()); +} + +// Make sure that we properly calculate the number of bits used to encode +// the weight grid. Given error encodings or void extent blocks, this number +// should be zero +TEST(PhysicalASTCBlockTest, TestNumWeightBits) { + // 6x5 single-plane weight grid with 3-bit weights + // should have 90 bits for the weights. + PhysicalASTCBlock blk1(0x0000000001FE000173ULL); + EXPECT_EQ(90, blk1.NumWeightBits()); + + // Error block has no weight bits + EXPECT_FALSE(kErrorBlock.NumWeightBits()); + + // Void extent blocks have no weight bits + EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumWeightBits()); + + // If we flip the dual plane bit, we will have too many bits + // for the weight grid and this should error and return no bits + PhysicalASTCBlock blk2(0x0000000001FE000573ULL); + EXPECT_FALSE(blk2.NumWeightBits()); + + // 3x5 dual-plane weight grid with 3-bit weights + // should have 90 bits for the weights. + PhysicalASTCBlock blk3(0x0000000001FE0005FFULL); + EXPECT_EQ(90, blk3.NumWeightBits()); +} + +// Test to make sure that our weight bits start where we expect them to. +// In other words, make sure that the calculation based on the block mode for +// where the weight bits start is accurate. +TEST(PhysicalASTCBlockTest, TestStartWeightBit) { + EXPECT_EQ(PhysicalASTCBlock(0x4000000000800D44ULL).WeightStartBit(), 64); + + // Error blocks have no weight start bit + EXPECT_FALSE(kErrorBlock.WeightStartBit()); + + // Void extent blocks have no weight start bit + EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).WeightStartBit()); +} + +// Test to make sure that we catch various different reasons for error encoding +// of ASTC blocks, but also that certain encodings aren't errors. +TEST(PhysicalASTCBlockTest, TestErrorBlocks) { + // Various valid block modes + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).IsIllegalEncoding()); + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE0005FFULL).IsIllegalEncoding()); + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000108ULL).IsIllegalEncoding()); + + // This is an error because it uses an invalid block mode + EXPECT_EQ(kErrorBlock.IsIllegalEncoding().value(), "Reserved block mode"); + + // This is an error because we have too many weight bits + PhysicalASTCBlock err_blk(0x0000000001FE000573ULL); + EXPECT_EQ(err_blk.IsIllegalEncoding().value(), + "Too many bits required for weight grid"); + + // This is an error because we have too many weights + PhysicalASTCBlock err_blk2 = PhysicalASTCBlock(0x0000000001FE0005A8ULL); + EXPECT_EQ(err_blk2.IsIllegalEncoding().value(), "Too many weights specified"); + + PhysicalASTCBlock err_blk3 = PhysicalASTCBlock(0x0000000001FE000588ULL); + EXPECT_EQ(err_blk3.IsIllegalEncoding().value(), "Too many weights specified"); + + // This is an error because we have too few weights + PhysicalASTCBlock err_blk4 = PhysicalASTCBlock(0x0000000001FE00002ULL); + EXPECT_EQ(err_blk4.IsIllegalEncoding().value(), + "Too few bits required for weight grid"); + + // Four partitions, dual plane -- should be error + // 2x2 weight grid, 3 bits per weight + PhysicalASTCBlock dual_plane_four_parts(0x000000000000001D1FULL); + EXPECT_FALSE(dual_plane_four_parts.NumPartitions()); + EXPECT_EQ(dual_plane_four_parts.IsIllegalEncoding().value(), + "Both four partitions and dual plane specified"); +} + +// Test to make sure that we properly identify and can manipulate void-extent +// blocks. These are ASTC blocks that only define a single color for the entire +// block. +TEST(PhysicalASTCBlockTest, TestVoidExtentBlocks) { + // Various valid block modes that aren't void extent blocks + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).IsVoidExtent()); + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE0005FFULL).IsVoidExtent()); + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000108ULL).IsVoidExtent()); + + // Error block is not a void extent block + EXPECT_FALSE(kErrorBlock.IsVoidExtent()); + + // Void extent block is void extent block... + UInt128 void_extent_encoding(0, 0xFFF8003FFE000DFCULL); + EXPECT_FALSE(PhysicalASTCBlock(void_extent_encoding).IsIllegalEncoding()); + EXPECT_TRUE(PhysicalASTCBlock(void_extent_encoding).IsVoidExtent()); + + // If we modify the high 64 bits it shouldn't change anything + void_extent_encoding |= UInt128(0xdeadbeefdeadbeef, 0); + EXPECT_FALSE(PhysicalASTCBlock(void_extent_encoding).IsIllegalEncoding()); + EXPECT_TRUE(PhysicalASTCBlock(void_extent_encoding).IsVoidExtent()); +} + +TEST(PhysicalASTCBlockTest, TestVoidExtentCoordinates) { + // The void extent block should have texture coordinates from 0-8191 + auto coords = PhysicalASTCBlock(0xFFF8003FFE000DFCULL).VoidExtentCoords(); + EXPECT_EQ(coords->at(0), 0); + EXPECT_EQ(coords->at(1), 8191); + EXPECT_EQ(coords->at(2), 0); + EXPECT_EQ(coords->at(3), 8191); + + // If we set the coords to all 1's then it's still a void extent + // block, but there aren't any void extent coords. + EXPECT_FALSE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).IsIllegalEncoding()); + EXPECT_TRUE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).IsVoidExtent()); + EXPECT_FALSE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).VoidExtentCoords()); + + // If we set the void extent coords to something where the coords are + // >= each other, then the encoding is illegal. + EXPECT_TRUE(PhysicalASTCBlock(0x0008004002001DFCULL).IsIllegalEncoding()); + EXPECT_TRUE(PhysicalASTCBlock(0x0007FFC001FFFDFCULL).IsIllegalEncoding()); +} + +// Test to see if we can properly identify the number of partitions in a block +// In particular -- we need to make sure we properly identify single and +// multi-partition blocks, but also that void extent and error blocks don't +// return valid numbers of partitions +TEST(PhysicalASTCBlockTest, TestNumPartitions) { + // Various valid block modes, but all single partition + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumPartitions(), 1); + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE0005FFULL).NumPartitions(), 1); + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000108ULL).NumPartitions(), 1); + + // Two to four partitions don't have enough bits for color. + EXPECT_FALSE(PhysicalASTCBlock(0x000000000000000973ULL).NumPartitions()); + EXPECT_FALSE(PhysicalASTCBlock(0x000000000000001173ULL).NumPartitions()); + EXPECT_FALSE(PhysicalASTCBlock(0x000000000000001973ULL).NumPartitions()); + + // Test against having more than one partition + PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL); + EXPECT_EQ(non_shared_cem.NumPartitions(), 2); +} + +// Test the color endpoint modes specified for how the endpoints are encoded. +// In particular, test that shared color endpoint modes work for multi-partition +// blocks and that non-shared color endpoint modes also work. +TEST(PhysicalASTCBlockTest, TestColorEndpointModes) { + // Four partitions -- one shared CEM + const auto blk1 = PhysicalASTCBlock(0x000000000000001961ULL); + for (int i = 0; i < 4; ++i) { + EXPECT_EQ(blk1.GetEndpointMode(i), ColorEndpointMode::kLDRLumaDirect); + } + + // Void extent blocks have no endpoint modes + EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).GetEndpointMode(0)); + + // Test out of range partitions + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(1)); + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(-1)); + EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(100)); + + // Error blocks have no endpoint modes + EXPECT_FALSE(kErrorBlock.GetEndpointMode(0)); + + // Test non-shared CEMs + PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL); + EXPECT_EQ(non_shared_cem.GetEndpointMode(0), + ColorEndpointMode::kLDRLumaDirect); + EXPECT_EQ(non_shared_cem.GetEndpointMode(1), + ColorEndpointMode::kLDRLumaBaseOffset); +} + +// Make sure that if we have more than one partition then we have proper +// partition IDs (these determine which pixels correspond to which partition) +TEST(PhysicalASTCBlockTest, TestPartitionID) { + // Valid partitions + EXPECT_EQ(PhysicalASTCBlock(0x4000000000FFED44ULL).PartitionID(), 0x3FF); + EXPECT_EQ(PhysicalASTCBlock(0x4000000000AAAD44ULL).PartitionID(), 0x155); + + // Error blocks have no partition IDs + EXPECT_FALSE(kErrorBlock.PartitionID()); + + // Void extent blocks have no endpoint modes + EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).PartitionID()); +} + +// Make sure that we're properly attributing the number of bits associated with +// the encoded color values. +TEST(PhysicalASTCBlockTest, TestNumColorBits) { + // If we're using a direct luma channel, then the number of color bits is 16 + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumColorValues(), 2); + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumColorBits(), 16); + + // Error blocks have nothing + EXPECT_FALSE(kErrorBlock.NumColorValues()); + EXPECT_FALSE(kErrorBlock.NumColorBits()); + + // Void extent blocks have four color values and 64 bits of color + EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumColorValues(), 4); + EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumColorBits(), 64); +} + +// Make sure that we're properly decoding the range of values that each of the +// encoded color values can take +TEST(PhysicalASTCBlockTest, TestColorValuesRange) { + // If we're using a direct luma channel, then we use two color values up to + // a full byte each. + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).ColorValuesRange(), 255); + + // Error blocks have nothing + EXPECT_FALSE(kErrorBlock.ColorValuesRange()); + + // Void extent blocks have four color values and 64 bits of color, so the + // color range for each is sixteen bits. + EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).ColorValuesRange(), + (1 << 16) - 1); +} + +// Test that we know where the color data starts. This is different mostly +// depending on whether or not the block is single-partition or void extent. +TEST(PhysicalASTCBlockTest, TestColorStartBits) { + // Void extent blocks start at bit 64 + EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).ColorStartBit(), 64); + + // Error blocks don't start anywhere + EXPECT_FALSE(kErrorBlock.ColorStartBit()); + + // Single partition blocks start at bit 17 + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).ColorStartBit(), 17); + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE0005FFULL).ColorStartBit(), 17); + EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000108ULL).ColorStartBit(), 17); + + // Multi-partition blocks start at bit 29 + EXPECT_EQ(PhysicalASTCBlock(0x4000000000FFED44ULL).ColorStartBit(), 29); + EXPECT_EQ(PhysicalASTCBlock(0x4000000000AAAD44ULL).ColorStartBit(), 29); +} + +} // namespace diff --git a/src/decoder/test/quantization_test.cc b/src/decoder/test/quantization_test.cc new file mode 100644 index 0000000..f882876 --- /dev/null +++ b/src/decoder/test/quantization_test.cc @@ -0,0 +1,288 @@ +// 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/quantization.h" +#include "src/decoder/integer_sequence_codec.h" + +#include + +#include +#include +#include + +namespace astc_codec { + +namespace { + +// Make sure that we never exceed the maximum range that we pass in. +TEST(QuantizationTest, TestQuantizeMaxRange) { + for (int i = kEndpointRangeMinValue; i < 256; ++i) { + EXPECT_LE(QuantizeCEValueToRange(255, i), i); + } + + for (int i = 1; i < kWeightRangeMaxValue; ++i) { + EXPECT_LE(QuantizeWeightToRange(64, i), i); + } +} + +// Make sure that whenever we unquantize and requantize a value we get back +// what we started with. +TEST(QuantizationTest, TestReversibility) { + for (auto itr = ISERangeBegin(); itr != ISERangeEnd(); itr++) { + const int range = *itr; + if (range <= kWeightRangeMaxValue) { + for (int j = 0; j <= range; ++j) { + const int q = UnquantizeWeightFromRange(j, range); + EXPECT_EQ(QuantizeWeightToRange(q, range), j); + } + } + + if (range >= kEndpointRangeMinValue) { + for (int j = 0; j <= range; ++j) { + const int q = UnquantizeCEValueFromRange(j, range); + EXPECT_EQ(QuantizeCEValueToRange(q, range), j); + } + } + } +} + +// Make sure that whenever we quantize a non-maximal value it gets sent to the +// proper range +TEST(QuantizationTest, TestQuantizationRange) { + for (auto itr = ISERangeBegin(); itr != ISERangeEnd(); itr++) { + const int range = *itr; + if (range >= kEndpointRangeMinValue) { + EXPECT_LE(QuantizeCEValueToRange(0, range), range); + EXPECT_LE(QuantizeCEValueToRange(4, range), range); + EXPECT_LE(QuantizeCEValueToRange(15, range), range); + EXPECT_LE(QuantizeCEValueToRange(22, range), range); + EXPECT_LE(QuantizeCEValueToRange(66, range), range); + EXPECT_LE(QuantizeCEValueToRange(91, range), range); + EXPECT_LE(QuantizeCEValueToRange(126, range), range); + } + + if (range <= kWeightRangeMaxValue) { + EXPECT_LE(QuantizeWeightToRange(0, range), range); + EXPECT_LE(QuantizeWeightToRange(4, range), range); + EXPECT_LE(QuantizeWeightToRange(15, range), range); + EXPECT_LE(QuantizeWeightToRange(22, range), range); + } + } +} + +// Make sure that whenever we unquantize a value it remains within [0, 255] +TEST(QuantizationTest, TestUnquantizationRange) { + EXPECT_LT(UnquantizeCEValueFromRange(2, 7), 256); + EXPECT_LT(UnquantizeCEValueFromRange(7, 7), 256); + EXPECT_LT(UnquantizeCEValueFromRange(39, 63), 256); + EXPECT_LT(UnquantizeCEValueFromRange(66, 79), 256); + EXPECT_LT(UnquantizeCEValueFromRange(91, 191), 256); + EXPECT_LT(UnquantizeCEValueFromRange(126, 255), 256); + EXPECT_LT(UnquantizeCEValueFromRange(255, 255), 256); + + EXPECT_LE(UnquantizeWeightFromRange(0, 1), 64); + EXPECT_LE(UnquantizeWeightFromRange(2, 7), 64); + EXPECT_LE(UnquantizeWeightFromRange(7, 7), 64); + EXPECT_LE(UnquantizeWeightFromRange(29, 31), 64); +} + +// When we quantize a value, it should use the largest quantization range that +// does not exceed the desired range. +TEST(QuantizationTest, TestUpperBoundRanges) { + auto expected_range_itr = ISERangeBegin(); + for (int desired_range = 1; desired_range < 256; ++desired_range) { + if (desired_range == *(expected_range_itr + 1)) { + ++expected_range_itr; + } + const int expected_range = *expected_range_itr; + ASSERT_LE(expected_range, desired_range); + + if (desired_range >= kEndpointRangeMinValue) { + EXPECT_EQ(QuantizeCEValueToRange(0, desired_range), + QuantizeCEValueToRange(0, expected_range)); + + EXPECT_EQ(QuantizeCEValueToRange(208, desired_range), + QuantizeCEValueToRange(208, expected_range)); + + EXPECT_EQ(QuantizeCEValueToRange(173, desired_range), + QuantizeCEValueToRange(173, expected_range)); + + EXPECT_EQ(QuantizeCEValueToRange(13, desired_range), + QuantizeCEValueToRange(13, expected_range)); + + EXPECT_EQ(QuantizeCEValueToRange(255, desired_range), + QuantizeCEValueToRange(255, expected_range)); + } + + if (desired_range <= kWeightRangeMaxValue) { + EXPECT_EQ(QuantizeWeightToRange(0, desired_range), + QuantizeWeightToRange(0, expected_range)); + + EXPECT_EQ(QuantizeWeightToRange(63, desired_range), + QuantizeWeightToRange(63, expected_range)); + + EXPECT_EQ(QuantizeWeightToRange(12, desired_range), + QuantizeWeightToRange(12, expected_range)); + + EXPECT_EQ(QuantizeWeightToRange(23, desired_range), + QuantizeWeightToRange(23, expected_range)); + } + } + + // Make sure that we covered all the possible ranges + ASSERT_EQ(std::next(expected_range_itr), ISERangeEnd()); +} + +// Make sure that quantizing to the largest range is the identity function. +TEST(QuantizationTest, TestIdentity) { + for (int i = 0; i < 256; ++i) { + EXPECT_EQ(QuantizeCEValueToRange(i, 255), i); + } + + // Note: This doesn't apply to weights since there's a weird hack to convert + // values from [0, 31] to [0, 64]. +} + +// Make sure that bit quantization is monotonic with respect to the input, +// since quantizing and dequantizing bits is a matter of truncation and bit +// replication +TEST(QuantizationTest, TestMonotonicBitPacking) { + for (int num_bits = 3; num_bits < 8; ++num_bits) { + const int range = (1 << num_bits) - 1; + int last_quant_val = -1; + for (int i = 0; i < 256; ++i) { + const int quant_val = QuantizeCEValueToRange(i, range); + EXPECT_LE(last_quant_val, quant_val); + last_quant_val = quant_val; + } + + // Also expect the last quantization val to be equal to the range + EXPECT_EQ(last_quant_val, range); + + if (range <= kWeightRangeMaxValue) { + last_quant_val = -1; + for (int i = 0; i <= 64; ++i) { + const int quant_val = QuantizeWeightToRange(i, range); + EXPECT_LE(last_quant_val, quant_val); + last_quant_val = quant_val; + } + EXPECT_EQ(last_quant_val, range); + } + } +} + +// Make sure that bit quantization reflects that quantized values below the bit +// replication threshold get mapped to zero +TEST(QuantizationTest, TestSmallBitPacking) { + for (int num_bits = 1; num_bits <= 8; ++num_bits) { + const int range = (1 << num_bits) - 1; + + // The largest number that should map to zero is one less than half of the + // smallest representation w.r.t. range. For example: if we have a range + // of 7, it means that we have 3 total bits abc for quantized values. If we + // unquantize to 8 bits, it means that our resulting value will be abcabcab. + // Hence, we map 000 to 0 and 001 to 0b00100100 = 36. The earliest value + // that should not map to zero with three bits is therefore 0b00001111 = 15. + // This ends up being (1 << (8 - 3 - 1)) - 1. We don't use 0b00011111 = 31 + // because this would "round up" to 1 during quantization. This value is not + // necessarily the largest, but it is the largest that we can *guarantee* + // should map to zero. + + if (range >= kEndpointRangeMinValue) { + constexpr int cev_bits = 8; + const int half_max_quant_bits = std::max(0, cev_bits - num_bits - 1); + const int largest_cev_to_zero = (1 << half_max_quant_bits) - 1; + EXPECT_EQ(QuantizeCEValueToRange(largest_cev_to_zero, range), 0) + << " Largest CEV to zero: " << largest_cev_to_zero + << " Range: " << range; + } + + if (range <= kWeightRangeMaxValue) { + constexpr int weight_bits = 6; + const int half_max_quant_bits = std::max(0, weight_bits - num_bits - 1); + const int largest_weight_to_zero = (1 << half_max_quant_bits) - 1; + EXPECT_EQ(QuantizeWeightToRange(largest_weight_to_zero, range), 0) + << " Largest weight to zero: " << largest_weight_to_zero + << " Range: " << range; + } + } +} + +// Test specific quint and trit weight encodings with values that were obtained +// using the reference ASTC codec. +TEST(QuantizationTest, TestSpecificQuintTritPackings) { + std::vector vals = { 4, 6, 4, 6, 7, 5, 7, 5 }; + std::vector quantized; + + // Test a quint packing + std::transform( + vals.begin(), vals.end(), std::back_inserter(quantized), + std::bind(UnquantizeWeightFromRange, std::placeholders::_1, 9)); + const std::vector quintExpected = {14, 21, 14, 21, 43, 50, 43, 50 }; + EXPECT_EQ(quantized, quintExpected); + + // Test a trit packing + std::transform( + vals.begin(), vals.end(), quantized.begin(), + std::bind(UnquantizeWeightFromRange, std::placeholders::_1, 11)); + const std::vector tritExpected = { 5, 23, 5, 23, 41, 59, 41, 59 }; + EXPECT_EQ(quantized, tritExpected); +} + +// Make sure that we properly die when we pass in values below the minimum +// allowed ranges for our quantization intervals. +TEST(QuantizationDeathTest, TestInvalidMinRange) { + for (int i = 0; i < kEndpointRangeMinValue; ++i) { + EXPECT_DEBUG_DEATH(QuantizeCEValueToRange(0, i), ""); + EXPECT_DEBUG_DEATH(UnquantizeCEValueFromRange(0, i), ""); + } + + EXPECT_DEBUG_DEATH(QuantizeWeightToRange(0, 0), ""); + EXPECT_DEBUG_DEATH(UnquantizeWeightFromRange(0, 0), ""); +} + +// Make sure that we properly die when we pass in bogus values. +TEST(QuantizationDeathTest, TestOutOfRange) { + EXPECT_DEBUG_DEATH(QuantizeCEValueToRange(-1, 10), ""); + EXPECT_DEBUG_DEATH(QuantizeCEValueToRange(256, 7), ""); + EXPECT_DEBUG_DEATH(QuantizeCEValueToRange(10000, 17), ""); + + EXPECT_DEBUG_DEATH(UnquantizeCEValueFromRange(-1, 10), ""); + EXPECT_DEBUG_DEATH(UnquantizeCEValueFromRange(8, 7), ""); + EXPECT_DEBUG_DEATH(UnquantizeCEValueFromRange(-1000, 17), ""); + + EXPECT_DEBUG_DEATH(QuantizeCEValueToRange(0, -7), ""); + EXPECT_DEBUG_DEATH(UnquantizeCEValueFromRange(0, -17), ""); + + EXPECT_DEBUG_DEATH(QuantizeCEValueToRange(0, 257), ""); + EXPECT_DEBUG_DEATH(UnquantizeCEValueFromRange(0, 256), ""); + + EXPECT_DEBUG_DEATH(QuantizeWeightToRange(-1, 10), ""); + EXPECT_DEBUG_DEATH(QuantizeWeightToRange(256, 7), ""); + EXPECT_DEBUG_DEATH(QuantizeWeightToRange(10000, 17), ""); + + EXPECT_DEBUG_DEATH(UnquantizeWeightFromRange(-1, 10), ""); + EXPECT_DEBUG_DEATH(UnquantizeWeightFromRange(8, 7), ""); + EXPECT_DEBUG_DEATH(UnquantizeWeightFromRange(-1000, 17), ""); + + EXPECT_DEBUG_DEATH(QuantizeWeightToRange(0, -7), ""); + EXPECT_DEBUG_DEATH(UnquantizeWeightFromRange(0, -17), ""); + + EXPECT_DEBUG_DEATH(QuantizeWeightToRange(0, 32), ""); + EXPECT_DEBUG_DEATH(UnquantizeWeightFromRange(0, 64), ""); +} + +} // namespace + +} // namespace astc_codec diff --git a/src/decoder/test/weight_infill_test.cc b/src/decoder/test/weight_infill_test.cc new file mode 100644 index 0000000..79c7745 --- /dev/null +++ b/src/decoder/test/weight_infill_test.cc @@ -0,0 +1,69 @@ +// 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/weight_infill.h" +#include "src/decoder/footprint.h" + +#include + +#include + +namespace astc_codec { + +namespace { + +// Make sure that the physical size of the bit representations for certain +// dimensions of weight grids matches our expectations +TEST(ASTCWeightInfillTest, TestGetBitCount) { + // Bit encodings + EXPECT_EQ(32, CountBitsForWeights(4, 4, 3)); + EXPECT_EQ(48, CountBitsForWeights(4, 4, 7)); + EXPECT_EQ(24, CountBitsForWeights(2, 4, 7)); + EXPECT_EQ(8, CountBitsForWeights(2, 4, 1)); + + // Trit encodings + EXPECT_EQ(32, CountBitsForWeights(4, 5, 2)); + EXPECT_EQ(26, CountBitsForWeights(4, 4, 2)); + EXPECT_EQ(52, CountBitsForWeights(4, 5, 5)); + EXPECT_EQ(42, CountBitsForWeights(4, 4, 5)); + + // Quint encodings + EXPECT_EQ(21, CountBitsForWeights(3, 3, 4)); + EXPECT_EQ(38, CountBitsForWeights(4, 4, 4)); + EXPECT_EQ(49, CountBitsForWeights(3, 7, 4)); + EXPECT_EQ(52, CountBitsForWeights(4, 3, 19)); + EXPECT_EQ(70, CountBitsForWeights(4, 4, 19)); +} + +// Make sure that we bilerp our weights properly +TEST(ASTCWeightInfillTest, TestInfillBilerp) { + std::vector weights = InfillWeights( + {{ 1, 3, 5, 3, 5, 7, 5, 7, 9 }}, Footprint::Get5x5(), 3, 3); + + std::vector expected_weights = { + 1, 2, 3, 4, 5, + 2, 3, 4, 5, 6, + 3, 4, 5, 6, 7, + 4, 5, 6, 7, 8, + 5, 6, 7, 8, 9 }; + + ASSERT_EQ(weights.size(), expected_weights.size()); + for (int i = 0; i < weights.size(); ++i) { + EXPECT_EQ(weights[i], expected_weights[i]); + } +} + +} // namespace + +} // namespace astc_codec diff --git a/src/decoder/testdata/atlas_small_4x4.astc b/src/decoder/testdata/atlas_small_4x4.astc new file mode 100644 index 0000000000000000000000000000000000000000..0dd080b12d23fa6b1227b676c7fe7e53eb8ab3fe GIT binary patch literal 65552 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�#<4OZ5m3ax`x~GM zECK%F)dxa4Ldq<<3dDjpx+M7J4i#(AGx>J=vkbx6lMI)&of4LP6`XShR-ZX|gAC6k zY8-~PlbNLxg@d@wI)fj?JP7q%p(iiO2P*q!0=%fiK0NGhzT|w$kJXch|E(jI3cT_) zHB++^!*2up=2zs_wPnkKah+$jm&-u@8R-;=;Ku(sXdRH%I)_zfB!2yx+`-VN`9~Gj z1pSZJivSaQ1Qzr?=vj8Gqz>fwaAdG*5lLW`Zn6!33Yljd07`y?!aKD+az9MrpR zqaLHa-)t5#R*;qn`1!6n3KGS1pI5t|b31I6JR4#506qKqb!^&AmyI4Kz&|Yen0_Wn zteu%?dM?XWj*5)3lxVI|Yo0uQYud*VT1e$;@XTT_@LlQI`F zVM9X&78QGFKRXQx2AidV91st4A5u)ZU!Jwadp0H0e|_ttG&Zu#I^fB<f1@P}?#>RfiUA%*>b*?_x zXsdnFJ7_JMCn$Dj(JND4Qos7-{+GUb5o3on-^zv;*1#DtI_f=3Z{7Bzt?eUaZ5v${ zSRy;YjF6p0izQj+2J%^+`H%qk5GGeXK1Hopz8Yuc4bKAn>+PG|g&wN~-G0dJ&^j=W zENttB>zwcA-MXz`4nUtLAy|Ci08>=2l1?F;_%2>#>ik(R^mDZ9D+j6rl`4$NO_z>7 z%w+ZSjwUP#>J`k|*>>MMYYn@!)3*(HpOQpe=Twdz+P*))?MP+Gd@M(uKr~1BDjxa0 z{MqH8>ONk*&C0pa>N}@!4X-04$)VNDSR2(Vg!Ha?)8R%C z*F<+CZ1sv)jS(mr9~k&qRaJzj+_LevE=_!YKaA#>E8??F!Tq8jOfQ6RrPG*&iH4}J z!2|uBiUJ<8K}iz3eC$o=+LB^reZ+fu~ z1W!)T56e!Y4UKeC^4le=`DO{yw*#pIC8l4ebBwB|$kZ&h%%q z%`a>YgZ|}kXRnVpZTUmNy3;@(0Y0PVEa(@aBND!CcO0`sg3CBg{7A=@m8M!e?lQZ9 zrBa!XTo)JLUi=WtXSaQZP~ZD4*3hS)+bQT_$h=2Bfy)$ul`@g>uYz$5M+h1!lEBZs z?vUzb7#h7ZPq>Ydf|l)f>7Oc66!kJT&$k{b96sq zZY=H@M#fb%*Dul0j5{_u^=3MnBo0M~^O_}fejJRfu4mu`d_+X4{2O+*`=c&(E0-ZG z{EXM1-Rts0u60Ps`U6yI3O?YMuLev;%3^7+@duYPd8TTA};)PhKur{&2_ zBdA%?(yzCy{{FBFnPCnnzi55B9adh@1>3!RRKB(xuT&A$4VU4ax} z4-X%@cs}cb0c9oVGT*z-2tN4PUJyVLrqk z*B)yafAXv^_7wUH@Y}b@d181$(1=#|#;gta=l!yoGW8|CAW^oAZ;jzdkuhPL6vk*0 zKRaSoK(3Au8B=gR66*MVGm@00ONHcy=ljnKLRRdo*AS?L%XRqfeW^YQ0%wABQyHM2 zQO1f3%L=U-yfcj8tI(`V1^H`4L{iX-tFzmK`&wsb+6$S+mip!@d!mL%jmYz-hJe5+U-3hU z!34C=y?(tVte2!Cn z?5TsQVJHol6`0f))ze2X-v%MpDSQKnnh{tknA zco}Dtzq-|(7dO~S-O0iDF1Y3D@CBzsdT2c@g?7MCdwxsK7BBdykW#Luw<4$I(-8QR zWj_lJB~wkd7ll#xzn4X0v?|6Vmw2O8(g^@hof>4)J?MOF{#+do@4x=c*wUcSwc92B zhYJf4;PoQ*t`LT`14rl-sbWV$$!1BXW}2=$MAZyWl!F{G&z z^=+-KK)u#Z?YY|bDy49d5Xm}4Zt=@#$^J~LmTuqu#WY@|@o%6EE&*b}P!fIJ;eY+8 z=U?_OsoyZpQp4>!|62!vbytM9KUmWzTAB4;4>5Lg%Bl0A9<3{b*9Y7xmsGBHdx@x- z>@I+L>m#3k`YgK3(pT)%6oi2P;Y=T`x)sqIFY$|2Qw~3Siul*lL%HVC*R+8tonp|x zmXg?(^-%ZV$hv#`&FcvU2kRfBPn=cq%JT}e5Z5s%JBzP_E)EDv7MFz^_*(fc?AUP=f1V!n2~QSBgiTpW2R1))i)1v)k?LS|2 zU~nqe2mVoswU5SF+yzS*cYiBR$0{+#ks>aT>lAmBz`$M26=wwfLkZ0%V8a12y~ruP`cR9|?1K za`T+Y`QtMUWH`UHNKy~!^1AM&%=FQ31o%$J)G(EoUMSJY`#3WT^m80fUk?*F)s`zT zTm8bCXVyQsZe@9Y(r&5!2IpEN;Clqu_&(VW&3@w;Akb#jfn=}#k=679e0?I<1bt8> zcuwj|2k*U3Fje>vZch=cL31z?wId&UsO`s-a**F$^~0#<9qb&w?Zsq&2`kbw7pF#j zdJ-uoJzy~Z7w|g|4RwSc3>Y~PITL>!)fIK(b2Rh)mtMqM>4mPv<3Rrqmtm`$B&Y?| zTz?RP`PUEc%ZOCYWIJ+vy3L^v|I4`cTepfhXCIL;vKO?4 z*RuA`*Tn~xowLEBBs5-D1*Xp^r0SClev`G4L1p8rqC9_%|A6y>Fu4-RN#|^5!y@UN;QjTJ zXK)Gbae7JP*?M}~C(B}fA8h7kL3e76C1;4ykmknvmlTd81Sd(0Ps8PDNSo{AOQ((_ zAQRFay-~r9J55)5m9!Q zUx!^B5#l4FT`wwb13j==f4_^J4}RdV6^l3-FXFg=?S`j%JH2l2-;=D~yH@+b+k2dE zn2BRG;_n0zzgT6Mbfdid##7mIxdRxMQ&Nc~i3JW<+|%hju4DL?1oQXrw42`7p2PHy z4gQ~5A z`l`M>KBPiF{LfeP)E+s&Cr3jPPZxO4)zn`i@qmRuF8^!LlNmb;?+bO0eZ90#h(q=kFBy2;GXu$ z7ByMDJ43h9(2^Pic;xyLi6s#!P#Qz)ItA*_9=35U>K?b752mb*s7`KCF8f_;Ki)w3 zSpJz`!vN$9rGLH*EYSI-n;txQQUdCAd5Os>Zd*l;s?ZWaED<)^#|*4iLGG;v{*i*J zG~^A26SU>})d>%GQ#Kh!Vbm4H_HF+};_tt*!e<*tscqrTN zfBc@?U@T?Nn!U1BwicDlLe|R6pioKHA}K|SGDHm_in3FLY*D1_NkXy|sg%(s%9^ZU zerI?*Pfwrk=k@vj?|D40*Xf$Mm+QXX=Q`K9&Uv5u)h)Rc`OPuU1|Q?Z^`k?#zVO&a z!6_VDll|6)#F331aj`y4s>xHM^v%uwnv%)SVGo$oGGc#xOvT7VHrStQwvN$HGBWxx z<>DM}SuCt++>&^OB;U&2UPVVN=u1WqPC_7M&_ zS{_J|FCCWhaKNh;)+*VU6%a`1x7iSi-1i#3p4}Cb?A!(UUB^p8kLmMQa7j3>K3fd@(-+F(j#(g?B8N9;J@Wv5w2PIzdHeY(6Oz>{V;3(@9s`X(aJnO!d%WQzV0+LbxAMZ zR^AMAyyGr2^a8`+XQ@}IAF)O4yT?}p%G_3-l$#UZM-*^FV+oZqr!7krQGO2o2pI1} z%b)RXd|tI~&Dw%3UlnkuKx035{NX&+1U!;;RTEqKpsgt(igwJ>`3NQW;Eq+FewtRO z$#5_^m`nARCWF0dR&RfJg0$*f3cC@mT&t$)#pyl%{5ihM2)8caU&DSM;b7W+V;VpG zb>NJCzm`%%pM029r;%1%T9WM)3HY54j}>x^obDaHcv+J7DYb5M=%WK}!s~9Cg`Azd z#I99yE#_SIR7gdM_^v%7SkU70Dt!KPG({eSwc}pLt^O zeb;sMhR^H25|wzo+ACT&zAicv{G7=|nhlyij*4HTt+QV7C9N%#U$ZXQczL~c*$GW* zsD6mSX1m*&T%os4l+xB7ylK`={jzy9>T-WjyH`ERpiBT7K2k?L=ktAc-!X z!*(~u@K&?+Oy3Usj}&xd$8v7DC$o=V)r4SUHW9u#G}anl78$)EP%-M!Zwd8Bz7>_| zdkl&*zvilKhJ1!2-(tfgxe!UzJJ4MK;yn#CEW0F(uFUp+OQB`K{oHUl9kb0(J@=%q&v#01>7Ee;QV3i6jf}X^D*Z zT!mP``x0@HSr+~grk)72iwa1JuwgJ3<;Q|oV-(5A^=lOsa|jDhuu1^`f`%H+7h=&- z8luh%G7=k8RfWKo&qDj6zrxIH|9*c6v0s$!>`tD%af8XEB7{u|N%|z#_Yn?$;Jen{ zn!=LxkstWEV{=4w`Eqjl&;}+SYlj2;9jMpDboqMgfV#)L9ta%|_Q~Uqks=p6Ev+ZG zfldJUW+%JaFu?;G2UeOgR&kT-&I=f9=kK{#9$tj#opfHj{?46_ju$R4nPjZSnhOEE zJQ!qLph<9!ve>?3hl4{<5R*y3u2m19adW}_;mzCH+JF!9<+JYt8)iGsCLY47U_tI^ za?9N)%-hR5n6*oQB7e$wz-T$Y|1yQzhn1FTc5H`@?M=6@gWpHUy`6qb0KVbrnH^Nt z`Sw4Rf%;vft?B7IcCwyd&`3U*jQk_Bx{!iAt(}}Un{T)HFgn#VvW!dmr$2&KdGhOW z@Cc%TCg1KbdkgVZG^{Mf0wDqaTU14G=OxAu-e~EFZxHX5r~5))4R;dv6Idx?$S8rB zleK#nCWUUK2z-3dzc+Rt>SN{bA}Lu}S&Pr_>`bF&XaDoQ7G>a9SGeKp`rzr*ih_$7 z>DLvoqrbc>H*QwbS&I+xFe+und_?(p9-GR(Ro1mcV3 zQW<6=rDfJCLMgWD=Fxp8Ur8gfgu9Q3vYN?`{N1?rP;PrdGZ)&bf9p&6D%all+ar{d zWOSW6J&<<^^fzr>A(BqOuG0*>zOtG9RE|1I z1do0eVlsC&v!60|8+)@mJ44eUg%Zkcr+kUvF%;A0%sHelE_ML}`Ik)FBQqvNK5u;} zoD?5MUaN%EIn)$y z>sjXd9lj^A`_d61x>9yf!s>GRnwa|+yjwVkzu}*$$H(_K{sn_fWtT<#8~>-*SCf&o zYXZ)p3;JLgOFwMhl9WIs%=a(9`Y|F>Sus3}pT|E7;$%c`Q&JLfK_4Ip3i@C{Kky@h z+w{EkC^h4QO~V>T1cuT|&iln40M0{jCfHT2g!zLCU)+FIPa%xc#}G}HrWI2Qg9 zB(~mO0c+UYkTI~~TReX5@R17G|F@tTPTYQb>1)TsGi%0x|8MWky<~z8fzem-e#0u@ z3*Bb8dCWM(Q~7H7Po3zuf8g8uH+<8GpGK#sh#o#GZO8Wc>(LIcT716_4!*wW>3|od zn~_%pIpTFL>shejmM$&l>}2eAlw!+b&tJo@%(s$+eu?vXz`3n)7enSEuRiSGI-N36 z;t*4sQzYyTkd0Y9-y)ug=ndJntn78e3jl=vAmOueSmO(hmRXPu@Hv?l3oiz+#Oo6|?Go*^m*GrLow zF4EHVo%LTa-!EQ&5&wV6zw3ixCi3@up{KW?FQC2?9w{wC_%|UQNVnd9@NH?)*)UZS zxKS>ywK`%30=!!2y)9+t6}$1cS^gVK5neK?rMd9F|I&ZRq72Vl#hMSa)Gq{rzQ-aX zg5!RE6huosfF-l~BV`2qgJEkVnI=WZ{b_5rj=UmGEQU>wa4Fv3_f6oP^HbuG|5tSU z^c%Cq`HI0_`NH>081WRwVoAZ0#tpzfqpA9{;o4a_uTD$a*iLzV2(+p^gMIQI`&7bL zp%eIDou}68Ns%4zxW3Fe_<;oe2KVZp-VZG>KC=g&vBUe4vrzfIj&(b53=@%m@IE{< z1M?|qQ`S7*cMQ%sHU2?g}Q;DSC- ztjZXfS{xsX_5$$1v+aLr6M3k_#49&_=9md_Fo!e3Q#* zYw7^?8E-Kv1Z7wAzoG!XGZ*oVvxMu*$y#I%te=0ItoMn^C6HAHtepSGBVlV=`a*mt ztYGGd_zhB0U`zbsPk$>SETu{-xi+-l8HJnt|tVoEXIW2kR9OP>=&yGJ+2^l@Eq`o5S4_ zH=>8r!8K91C5V8+C?-XwLOr&b(dNoi6x4?~GhKwW6?;Ukx^*s{LJ#L!+0^AXrp$+@ zFmK)`n;TGmu8MlMR_etaPOB|@NHvY>Wn3vUmYPlz=gxjEP{4K`nkw;?h`Vq|_VQNd zH4?Phx z@ppZI0PhzW(cO~rmwtesK)v2Y{m`;Rc6|gL;zchnUCrhG?$@~P3&kjiA2J!!$z$Ui z>Lkxr*M1hID6PE0=W*=L1eYt7IE4!3>%+ba7w>Y0ukSDd1lP0YBo`$_UGDSx9wx-`S zF~vZ7Fc$1{u!sJV=SMhx@%M}4T|voY2{)o&tNms-EWl_e#J?^o%Yu zTYxpEvFiDf--Sj!G&ypXd#;KH3-;sB(P?F!Qq+5YEQ4+FA2!lZMY>hLw@P6Ui(; zDXHsHM66cvXw2*6&J~?2QhQTBLp-zQ^zo`f6n);_2t5RA1upye~bO+ z=y>j2W+v1NRQKsC`03=k{LKL#)#k|-(l9A!eX0jNxfF9Nt&k=J{3YscabI#eb}T!1 zo&A*qC10cek>lZ@-83?w@K3a z4#eBdjr3pqIKs{DcWhXc4gA;kegg-SV?MHfI1tCzPhi;t3;GoL6GHmX=g+(IEB8V7 z39ydeygP;bdWbxLVEkwa1KnhJ@& zS$X?F4vrMl0RIcx+QPxP*A62{Lu6qENk$Ec_w)AI5!_l3eqL^bqUd)fa+hbFs{%1j z)*VZ0X7dlck`>j9?DiRKj3O3kVIO@>+d}`Y9ezeW&Tlme`=>vB3__p$4Dy~iA{%|~ ze?8yge9xNeSv~*?;&(3P=G%90yMfJ@>kpzU-ypg>N&Lu>uL!vx;Q8w1CRr>$#E;$yFAFaV7#`F?@K`zh zF1CV*nuw-A;3Ku?z#$mmvuhQxs=&(&BrBDR+gDTMI|eG9R?5lkDxUa}bu5sg_^f5u zakUWMl);8hpV4HByq(;d!&0{zxmpYEueAg|tk##O3`Hl9>kk|itx3KVbVFe1tQ)4A z`--F)HP#R84cX(a@8J1XdLkT94;&#YhR(|<(hK?B(Eo~ou3hi&8@O0Q24S!jZTMpS zIG|-B{#Ts_eu$*5(yx~V>#Aad2u$MvZs5u~+XD%gj!4=>%b?`>c!DQQ)E)`rTwR&>eIQ9D;Ms07ArR}dk$R~DR z?-ISjVT~MFu-H?KWF(bZw|Ojg?|MhQiS(2x;=DhArElQ?1^X|Vwf_3O9r5)0Qzl?n zukk%SGY!AS-?^j8z4*Qt@lHUaqsq!==H~SQj9^%=tT}gjZVoOsBBM9V_UHNjl>c=< z^Y#hLfAP=#{(*1v#p^HXSC)S*Gu<5gb=rn3{~Gxpe;=$bJs4DEmHeSYEc{RM%^*v` zKKe%=%*+f|k$=+%$mGUti|1d|2Q2)DEZ`r&1LCF1AKnYp1m0JNzHAWJRzR^ zpzArkK4DnD^05qV7XI%7{xO37nQ~|Z_!mb$9w`eOqJMSfy(+0+s);?SmVfNyTbcvM zbq#wg2I`@%?DF{W5m85;BJ7!PK4#1(sV!2-F`O{{bDZts^%tK9>^sHNFurN6tN{TQ z>VNYGvh)EQfcK4|p<*JKK%XSN_>Hz?@ZW`o0R9p0WgD(+w4oxYHyfMyMPPiPRS3+n zu-*^3AjpTI@uqUnILtA3a~m&ooa_pC?8T|=O?|s>)dr8A+owM6eI^zAuvmG2E@y6f z*@KpvsM%-Ldhf?Qf&bBX;N6a%%!cU`iA?5DGrP=M!`#jLl!^DpeG<79fiLMMX;tyQ zqRNjSZhBy9NY$Q(k{y`1%0V+P@1{>t<(xa^uO>(v;?ur7J94_9SqrsQusS#cc-Kc- zu(Y#e)KWIW8SsDYiqt{lJt%|it7wg#e1~U-4aXU}5}t(meDXF5qd%=1+Y;ZtN136F zI()8wn`Qj6BzDhmm@cVW-LP_x|Ct`E45mb1K(9 zY`9jjskwKlTBr2N=((DUA&reEx!5P){cs)-UfZKL5!i~I!Rqlz{Euak@YFx^8W63hRKi?On zR#(3|a^%R+ItQEprls7AT3zze<<^tpBTf&H{610~rTP#-^auuT@hwm1Lg-Kjp@Gf) z*V*F}E4^-Sl7(eRliFWZ2zkb+7?W4XxzEYJr zt(WWQdmh!JK1JWHIVS3sNtgL^Q(W0oS9j)>DBWV;)P@O+RxQQUcSI_+1az~wW^EtpJD%7;atU%?P#L}YUzq_ld+pu1|0g> z1?~#YOe|fI;Lf4u$~{=w`)$B3`%Wc1zgHw9&Q}V4PNzA`GX7=XRHH~UyHo5;!Y1oe zAH0<`1b4yyN%D%4gB+cBfwP@E3Rcx>Vs$mWy}O%eJa1xSoI_P%{$C#+E+L9h+PhNA z@xeQEW$fAIcE`;5VYyx<@L>+x7x0f*0NzoffAA0LYxhPkA+$NCHnT7R?q^djAN_6@ zdqHN-&6GI&)~<)SiWuNWv23+eQo5RR`)o1Q4R55We>?N$$3Ce4cV}nz)rJ(b_B2`H z3kIqW9n||}*3iUQvBB#gyGZ=K+`(-vddRE-PA}4@FtS{9tTnMW&1wwzBJbXRa=O4} z@1;xDyZOZ_nTY3OsT&Td%R63=D`Bw=w&tZoZ+gy9b!;OB(;ns3HN*vF(#aX15C z)A*tGTc!OaZkJ2NjtX7`f5Vub@5#}=9`s9-`^N{QUTkP~`E(F5W$#OU`)_M0N~n9z zma{*ZqcVX^!mdf+*AcjWKiV#WKO(8ea>-tZ*SZ>?yCcI-wxz@6*v4&Lq?d)^`ucO2 z6r6yZyf6a#k*c)J4NG(}<#2V`kWM15Q$=ZZUR^@+YWJ2Q{F+L_B1bNwIo#|ty}D*y zgxc#crhV^yUPd4mU+4WcmzpW)9)Iln+=s5$XuG+4r_k_Lcg5TjY8jQ5<>Jfp)ggZ4 zQ|{2$o~?zl0+#CI(@;;UC?;XM%eu~%GnG-b@s2TV4sJ5&0xsHy_iL!s%a zMb_$(V&ayusjbv%?;+PSsn%*#vTQ%LdJXIs_t}f6CB5kZ*%5<2^6p5TGC~))eH_=R31IoA#*KYqQ@dr;xhoGfAG} zBOBfqaY<_FL;zpw2ZIZy&zmm~C9@pf5TENG#KFUoW$2$qrnEr5Vj46wI>z-N1ll1V zVc9G42^w7g_x_H({pr(bX)Jwg-+ij=jup)QtdGFr^X=b% z>Qrj#eEa@M-yu;@o%09Ot4?Tfz9S0mx zwNh4I7Wu59?|*PhaF=m>@Hm~MOO=a33)fzognBrStE6l3K7CQ-^{OaBXcI1o+4Ed( zDCI^*G@^2jfa-3Fx*{bB=ikioud(*0V-{rCa5s!wyq=|{n_E~I+%J-y_3D)v>-z}H z#)bTOLvM|S*o1EA<9eC|`J z<+>usB<*;n^hXcyZ@RnsK5{A~Uklxw#{Ut<^PckTdxD-xoL^7D|0s1tv*`ACoZ#am zN1o+cwNT&GgVztX*}ENkl17fad%h}n>%j=_4+mu29UTpA)LDFK{t`ad3~!n7vC}W~ z5|sk_?zcM)7BW8XtJo^30RI2}wCX?|=@9Ech1M(GB;pD>h9*X%0f7lb#F!I^%O!-7 z#rh{FbD+Kx76AsDzmAs0{#g76A#-&@RaD8oY%7AeBK-VB*J$z;6uEYDIz1V_^OA%M zxZ!IjG_X-OMNpty9^&O<`&O-IZ!sWb=i{=OONr<$r}rf;!lkU^;AUC~%+aWXA>N?zJs~dY@ijylLv8F~lgY2C-QZ-64m4^!Rq=a1m~?f#_tp z5LsTz;M>TTQWAyXlJuicFSIf0W9IhTm#=={YwdGj@gw82`RiLQhug%{#HbKI@_t8O zp*LQ3<<(2C<-#ET_s*urQ3r+x^;{H(Xxb1D-cXp%!JW@zlw_$Dn?R~AYY2BG2;mjm z&kXI=%!PUf{hddJUbQ|bpA3G}DoFSy-v4Xrq3DXzzBpTWgU_U2w9{=i9 z5Wf{R_{KzsCAN`#j!}d3%XvKm8@cErXH=du~DgQyK696 zzUG6)k9s=fBTx=@{=hla`o;eEKk*F)A=pD3uS7_QLp+&aS3JZIp@fZ55n>=C`JL@^ z3~Kc&>bVU=$*Zrd!}BPreI!+@t@}VExWCgV>Dz;>+Cr*!J;LYZe_gA$Z3;QC>k#ly z@Np8jU1B$STx{K^{{-;QYh+R6R1~?Z_GJIjIBMo$vut_E3s3fKPgq8_7f?_#h%|Zj zRkU8&B~HVA>r1)XjWRruP)Y81M)@P6}WN^G!+I0L`!r{8v#(iBQ7+%uhFyZVt zx|-)J74Q%4KUiPtrx^rdFGZ+Q|4V^|~C zfr?q+UuitmFV8co>hmP;Cf1cwUDJ3?0u$j{SDY9a!B@kDugRvcf zY($>Y;D0cl`+T?B@W#SX<+tCD+`EnX*dIYUoIcc8zycfUDTh63@e~VVLum3ig!aGA zPaM7y>Yw!V#@Y`I`_;M9KZzlw`!5=w=Q!StJ+v(2R4nMrHp|Lpa-#D7$OD$qKkq09 za1HEUlJsKr7qcC0m=~=5-Lw>=`S~9#0INlOA_B6Y0r+A6=P&#(`0M|{J8L%pJ~01o zOi9rZNe`&T+Yhpd-XTm+umVmm%itGDU-WCw<${yfODHHA!! zCQm<`a@nuUU7uE#`|i98<9EM)#-7TsO~ZjP{Qv@Ym1n(LR{tX7b&LN3I;=sbyL$!uyOulO#Vry!0y^>UI9utGiZW z9ov(7?jI-y_~-je8mt+6HJFOUA!%UW7rQ~d4hw`|8ZX8r-$uj*M5c2i^|x|1`7@`x zS$y585dyH#M$%i7Z@7IX5T9lRK)xsB-^Q~;2mP<{rA61er&h4!m#J`keQ4cO)N{_+ z`_+~K`uuOSb45QZI8cmC&TEU^U40>SX+U%9i5?RA$Z^k2HhpWYo?caXTO0+|YItj( ziaf`uc%>gRD+K@8?awh%h7I&QGx7Aqad;lyovL9kfAl5^?2oP`Q>$C7AKfb|-glMf zRUGcbx#!t}(O*YKbEW&l9BXg4qw*~~jaNI0+CGmtA*+n%l%XhbxwWO%#_x|6aJx&IDdcj`Df#HauFJA9Ydw(9jfPXTovoR$B@DKKzfTat-CKv+#e*t;(w17T@LXBuq2rS{jeGQ70X!ohr`d0T5Ypy_J-JJUh6!$B1x|wr0O+#edd@a zlg4*04JPj?qM+AjettE5q+9gnf*)pR1MIgPcQG(iuG(*&>+B_)0P#V;c21~hUj4N> ze}=Cd_~QJ2JYQL$r1ML_m&YQ$fn^^QeJiwF-D11+u#Qa%@cWP-7DYWU%kRTxKS9>O z`gO+o;TI9}9n@PxqPDu!>TcJXJC&v-S)W(9nTmk@`XQ&Q(C{7cWk|0d&4xg7<^7Ri zOghuQN0`yXxh#_E%AQj?Z9CMl`piAQ@)J0S$DwSi46%&8zIo@xlxTh`ojs@HLGX(2 zt3!TdBy$p3-!CdnJkYd8_Vz8WyRsylje}jbulM`I^38=w7$c(575hD<(v<}R{Suaz z<|}}&lFOlA!T0*+CFROE`3KFBDg9w5%DS?$r*7~HA6yUd4)~-LO%3p056i%M3gRJC zT6#vUS>4TA5E9VRl5gKM*Ddt7EZB4J-~F5()nWBMs~w|xY1<9QD}{RMlX`?2IVna^ zWA8Zg(buC}CZ_y0Oi+mtR|8+Yx)3i`)s8`!?QLBK-+Mn7b}}E`&B}B8gdqXn@_<3% z2@cKlCmHHLHG|}8!y9*Br6fGtS-OVsin)%|yF6MuE$>K$8QbaCV?7jjAHcWbd)^?{ z2HBC{1N#Gdo334xmSNo=MBB}f5S=a8qGTao66uz7KMMYW#O3vhQ+rtVI>wxa@xxj_ zO0e2tbRtl%OW|1+W2=7qp|np4XX%`ve;zc1e8BtA?~m2$#*UIQk$$0XX^^ifVVGX= z(;oPZ-nX1xD;XWoUT#bM=;tbMwh2>il1O1?ibslDQ%CRBEVqPfc>V!cU&O+XXk_3G))hS0<;!a)%jZ>>D- zFD`1Y`?b9tYX6Ec*bKRLa&5;HG%Mda8L%7ye!%`8=hkLgX6;yS+J>B@Mno|xP5uV=&xY9i0|12{;TEccf^y-ag`NR$h9~TQOCsMfD`D zarF@+YPCvUMfAgF%i29ojqJA}9_x31>}l_R`!i2_FY2$w{msSw%!Ty}%YO~=3@P*R z4Ddcr{v98pr)O?{`0zjRmy0q5ISb!^4HV7@jpN?P6!6QcHQV2yrR-uH8IblDCxm#J zQ6qc0L`!8u15-TL63umc|u6VcH4PaWd#_dPAEsw%_~Cob%!>wguhUuat0@WUpby}H zF~y3x_SJk-Ci);#~YzCUJIy;(URxKf2bGRE-$ z6(1FaG${uh`*q2Djb(NB^U6d?=uVfQ zob$2nx?EO@~-Ea5LgH8j|n@oCpOF^ZieA}(zC5pZUFof7f9i6_E7B1pBhJTXnPZJJ;b|dPb{Jr&=-Sc&`Ct7S=j&gp z7ptLiwS{kUBo#L(Vkc&P4Gl50TsIUHYA;XRVXS-Fz96x%D>Ad662EFx?y3`y%K4PH zz%O#tV{RF8-u_YuGjaG9rB2MrpX|xlDu&*6&Ww{rEdM zb~dShF>`I|64=y#_}Ko{pWa-Pk{f1R0{^Z1a6C=?4k`XNgYoJigYC(-7v`TW5HrUc z-!u={!FpovhqQ3ie6^E;#2IHdBJjt5IQ0lQENHUTxx5?V^+ni>Wkxdbrqw~#v1Xwp z`7p7NKHTQcbS<@t$TQ$?JMe18t60ZcL@tO;T`f(Et~6#=88hn~88y7_(xf2N3lq4~ zs-Apu<7*k&Dg!&H4_Y8_)KhQcq)&3=;LvqK1M#TZEiAW)qT)?K_v%pKTZq;~)muHz zY72fgTyhKMPr&z@)$@1 zo7(N>Mx(>n2n}MqkGH>CKXk*ApLnKm^7*sz5BJv?ejTXbZOQ4}N`rjlq6x;F%~wv5 zqXk||H&W=ETPW@_0Y5)3XCDYLOr^Sp)r-Bk^lp#wm7Tw;Xx9ncs%9|q1r#|HpGP}{ zzW{s0eN07}pulTcWX#92L<{|L8VL(DF>j)jIDL!fAfcVyP3sLyMb328l~swNB-fRV z*G!*Wwp8DXE~%F8r1WB2)=i}lU2a%*%ivYkK|OnZY59Vh&-IC+*Xh1GT8b{KD_cTB zZobYUKFdRAslAb!mPJ1+qL!U{E_!kV^lxXrh;5jokSAZ=Ytxl}^1V6rrR7^bt(|RH zv4@=<_%_@KUYp$%9ua({(wgn3o0UyR`rXz1w1loCId4$E3ig1&fSJ3U7UZYzKXas* zRj;<+tltju+mq5P+Fp?B_P5vTeS&!%Q7HPUxySJvyR#UhR4<4UPO&yYH0??&O&kenREHinWwmdBhCUONh38 zK!f^ETW2(Ed`YD{?rw86#{++!gPzf9jaR2kqqVif4iM|a97;26IR^3ugE-TKnwCtSrQkEfNLl4}TVm5hsCB7peg`PI9E?apIfAhpPS z@EEWF><;x!U*5+dd#))9eS5X-xdi0LZB2?>qdMPuKT(m)!h4*WDh7`Z>-+inL43}Z zgaozK7>EyM?axpVUCqS3B>!|R(_^q5bvR{uRHpTpQV|i0 zf&EyQU2Y@?xsm2BFFe%CB=-htZ0}GMQ9cIin|tMSG<

$4@hR|`blEKUkG95KlV#ce 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%0DEWFb@1dFyd*x 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 F{trzpJG=k@ literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/atlas_small_4x4.bmp b/src/decoder/testdata/atlas_small_4x4.bmp new file mode 100644 index 0000000000000000000000000000000000000000..32412b3e5350a6b985d4514def0aa624df080167 GIT binary patch literal 262282 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 z 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/atlas_small_5x5.astc b/src/decoder/testdata/atlas_small_5x5.astc new file mode 100644 index 0000000000000000000000000000000000000000..2831c90ed5159bea214808788e7ffc257cb529fc GIT binary patch literal 43280 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≻)Blf_L02SD6KP z13&-Do4zi1`Pw_~C(Ql6a`jE$1Mt#MuX^7={=sGV58^|sAK~m&+}$>t;=ZAI>U8wL z@)@^Klj*@9-iIHoeG_`!O8vy7ntDx9Ww|S&_pF2(cbRf*t9E{KoYPmM1M>xpH2 z3H;X7=@mD!x{O|+-ZsH}-T0Bs`oHf3Anz|7pqiif-yc)mFP95cU5H$3^8xnbN0}2~ Kmsc0{i2neC`LQMd literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/atlas_small_6x6.astc b/src/decoder/testdata/atlas_small_6x6.astc new file mode 100644 index 0000000000000000000000000000000000000000..b2cc9c2d52d710562087ce03c54ad4c9dbbcbfe2 GIT binary patch literal 29600 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ℑUi#R&CI2SDCWHU#4eBBfK)ngR|6%;o_Z$8H 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࿉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Μlr>2Qc6pOjsN|^*W0*%>3U{?&|{U*+GY}3 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/atlas_small_8x8.astc b/src/decoder/testdata/atlas_small_8x8.astc new file mode 100644 index 0000000000000000000000000000000000000000..a8805f2851754a6e72240edcc481bd5b9d1c875c GIT binary patch literal 16400 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/atlas_small_8x8.bmp b/src/decoder/testdata/atlas_small_8x8.bmp new file mode 100644 index 0000000000000000000000000000000000000000..8f92698c01f22844485051e91cc69d67d43353b7 GIT binary patch literal 262282 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 G*#8A7Q_Qje literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkerboard.astc b/src/decoder/testdata/checkerboard.astc new file mode 100644 index 0000000000000000000000000000000000000000..79acdca3732f0b72f25640c5df6b4b188aa1b847 GIT binary patch literal 80 icmWe$y)cG@gHeEi0f-nG7+hEx{sAe5&{YsfDjxtEr564G literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkered_10.astc b/src/decoder/testdata/checkered_10.astc new file mode 100644 index 0000000000000000000000000000000000000000..e3b196578c32a6a1d8dc9b911c1a164bb2fc5310 GIT binary patch literal 1616 zcmY*Z3rtg27(VTVS`>Ogpges*QDJC!CeTeOVmqLiw#=Y*j16$8cZ$L?(I``Jf;@yZ zTCxewj-{mHU}Fr2m}SEkkIngDOlN}efdMn-T6Cy{>fQg}w!luCreE&;zw`b7`M%@% zb>lliAx}dHe0hXeU$XWU96U0@vI5e;Hp!J&;1MAfVi6E+L%NYD5fYZbb8WI_D{l`% z8a|GCiKL@rP123i3q1_iMxRcWoM$Si0#)r-r<>;x=tD-B3Vxga z$K+Cx-j&1QB-zNs?Wqq9The6I6T%Q}p!%`=AKV?^S7>gmel`Ey?McnCiQT=|WKK1d zrejZHsM5Q)FtE3DSkbmlx8O-<R%3&N5hluV=+k(MR-c&K6h#z{h=@V!yf6?v4F2q$xFSsD3lYN29(bW#!mC zGp7$Q)VKAFJZayNt@Y@JmFFJdW;phn)$^Q?rd?@T?h>ujrTDo%rL0yfMS;G3ft?5A zQ6HQi%f?bU6aKF7|A1{VTlsarA z#N4pxy&#krPWD~z6iY>+VVuHg|M>crlz4fute8Xswk%OO3`E|83fI^(v2t{>$hYIw9p_J^EQpG7|2Hq}u@< zqD%UD0wTLX`{ax8@ofJ+dQ@FKXU+`Y!-rE-Vlnc?^`}4gS&r}9_~O**7ky5G9y^~z z<$aNd7{+gz&Vz?XRTWyskq?vU#0jMm`&De&gqkd?}Xk4)Z^D*9+`TTpE9>|A6NK^MeXxLyV8z@J=IJwa}VRd9ifNy;5aQyzj zJRz<7P}Wy)hc^#S!)j%Sq|NI#Sqk)aKdYOiJN18t+4B;zjjwsbwDK=YV5G0B;6Q@Y zJlZ|?r!CA&6~*z13$m98f8MamUn=9HK8AD!q#804KrhF~ke!zGZ#T6AKMsTyL<(Hm z%R;=Lw3tHS3ex217FTO`C)Z|-1ewidizQDOjr!_aDrvhu>FejKgO+jnAP?cB>D02F z*|%{XM!o(h=Ix|A=x+MfUE+5i>9K-LZ zkJH1D%ke2L#YW_(;0OGy379{sA6Oqmv2b6({h|?-4fkIy_2B$2|5aq^xSQ|hN1>Z> zeyukP$AXSK>LI@`mLALT!2XdB^5hQM&is(OZV`7LH54`Y$En=!%Hc5Jih=zsZf6Py z9}g~_i+*8pztP~B8f-|U@az$ZG!w523P#z*E zK_)7X`a;n`VaSGVqR13W5D{lYGnt4AI|pV05HwNx3PTr_&9_NPzxKSF}G0)C4or*RJCzuKn#Yx+Nn7+zq#4V3joYl zMJdyW9Gr(@C=OZ?9hG^iz_>d#BrvJixEtlAv9&Tj&ePFlu0M5ZV1UiW_0dw%ak(AN z0|PK1+$7448OBhIE;IlB{jjj~bO=e{yHFyHT+{~^AnE1Iv*hz<4fa+Ob-Vm}8G6Cp zuY&3Af0og$4A6l1sv+ev>Tb||5&-9qIa+ksU10FBUTNQvf;gQ{R~5-cVK7(>2$U}j zk?T~ntCMf?c@`odlXe|Xr1XR8>Z-5PXv*EmWfl^hgIFx??q*b4%M+#}Hu?z@-LYO0 zoL{=9@Ie{sNc9r|Uqx|76wOOWX#iO7>g}|xk?SlW9o-{C&%t^F%B$Nf7xfP5-Ri*@ zO1;Y?y+OJg?G9M4Owak|>fO@~>h=2_uwqo-);m7ko{_4uH9-?ZdLz5|2|D51egZwG zvbiYctWVDT+$TAw4I7qO^wX-k;>jfsH*gS7f&(2PQfKUKpUuJ$! z%SZWr;=NOZ0Q9}8&l|(|13x@}u25uUK^R1rNPM-;ji0ofuV_I(0?@d6|N7BwxSp%& zL-kP-yN=eU2x|sw-uvnFX*PR!82ce=o}be?fzO9r$Q1y)D^{OQgdzxfwAYPhePLlK zDXy-#-=-JN);NnpsmAl|pJc6F6<~?~Ffy8iJP*$zpZD_()<@I_;Q8V(lB~l0BesGp z*J93O*X&<=$~0xKZayLet2jW_+KA$96kI)%}Em4DA?`z~W5y(ma<*(F+=5{~%Pd1im)|D{n6(hcsqZxR&&nhYg2en$f&oT`O z$&Kw4A9O>~Z(GUM`X3(GzAQj~T-J-{o5`3spewUR)5rT|%Xd2UAf7LUWh`!6QMyfy z$IK0T87_xRQs# zMdNEfv(kvge%-P*CcW!ZicL7=bb?Ss?ist$w%qJ zpQyeU`7s@$3+YvIik|h|DX;|^q>uzBj~==fcn8;G>`}oqbUfK<<83xGGQ!fNy?!n>Lw#V@K-P#Bv1IXu+s$wZWVZG-1#zt>%PfzSWxkNRi d$i;lDmjV7+Q!|rK;cnRdj-Q<^my5*^{tsNiNA~~# literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkered_12.astc b/src/decoder/testdata/checkered_12.astc new file mode 100644 index 0000000000000000000000000000000000000000..a82583a9ed5bb9ef978b8f11021695d78527b236 GIT binary patch literal 2320 zcmZXVdrVVz6vuy^h*lRX7AOL4+JXfNL1nX$2p!UbwAxmj3WE_16S+|#7)2(JBAJ6p zcqu*sYq7Psf#Prx7{<-XkjO(AigQfHL%^XcP8}>h?tbT%>up)XKfjz$&-tG3IX!T{ z(Z$T3&Dw$x{$nBZ>NPp_;q!-wNzxXTk_M@~6^9Ta5lP3}+9D#{-O0D_swxi;3}8Mg zOr5|=ox3l^+TN|6r@NRAn4h948;gzEO@}B8@ zcXwdmjvXXPAm2AR(onPBagwxgaA{IzxDN|+o0DDr3kC^PT4?A}#6mYD2O$DQb*kSp zcSpU|G25$c^t^@}*;HJF!t{hV^^}LFy8&uq-c|KP`WO9uDSL(bRTX8$|&?~BnX(2B?P*8i?97ngPG7`~t& zC1u|}@KfRUC*QOQc+2_n`LVGg5yQ*n3Wd=KdXBmt&sOGPy;gb(3W9^1niyUvymE!b z0$w$ml<`jHbpHACprC8l7=CC-sZ34=JuTtoy#w)>x6-fICnna`GQ3WA|Nc0huPq7- z;aFww@q9Bz`!ZUgA1Y2D@y+1!6$8K{(32~j|9GU?{lblJ9l-w&1Sh|D z6Yth&G*^89AyD(`^6zH+LFom4_KKRsEm7;2r!-M|L}+8^?+g4dF!?2~=Y76wnC7?L zcJooZYCv^dHiv^(jzDR*uQ&$G!>Or#qW8neDJ#p~9{OFLj`}=Xp|<5d1O=H)@$rm5 zE-q)zEL;fl5=REl@LPlHSc9cLp5f!-+S_5iwrJzey=4KEUzUD)c_k)-pR^vW zHYaE0O5i1(9NsR_Yo%v&G%s(~EQTK%dim1P5qNRS`U##l@Rs>YODikq&SiL`vA@5g z19*Yb;V0H<$}fw1WoLKj5LiU(F&fLt3 z^?So*(RIN8pbeg+^Y!-X^*%nZKTmH)Pt;O+sr@OMOJw#k<+ za~_Ei6}tu$4B``q?_V7fkW@dAk3gb5`BF|jJYH6oM#Jz94xynrIlzmY^G|amn77)`{QQm%t(M`%Vv#5! z0{Eosn?3Z6IK36$-*0ap8_V#mt$lqXBhYVLz=a<>mQa3K^t)+OU0qQT!$(9MIZ{&t zJX>ET^xQI?x3Ot&hu9_yv%yRB$( zUg)Je?{b@#m`wQo5NP{#l}F=M9H;h$K)Mr!*ZkV4`gp#wqQzsnI}_?gXZyt_6YNj* z-Q=+)C+U0yGE6Q#vegdr=6zDfsLv|8gTG!j(`k@{Yzf4cmq&Rh89wCJ#GW)tFSSpT z#9CQr@tx1!#KxKTOB-#v*p&%#;7#|dRwpM11%W@h_yJ{lBj~gIefjwbg%2KB^3BcW z`=h&CIOcZ(<5u$;8+-9$?OKLUPj6{~{lovi{*64Wnm^rtgTdQdC}en@E-fuE5cnsn VkN=aoALLrzlav&NLLwo_{{U*k>68Ef literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkered_4.astc b/src/decoder/testdata/checkered_4.astc new file mode 100644 index 0000000000000000000000000000000000000000..ac60716458fc4b169f60f9f1f045d58ad1f34e48 GIT binary patch literal 272 zcmWe$y)cG@gHeHj0f-nG7+6H5kNVZBK2z^FUMOSH_c${kCVef-67gL}n*RUiXJByQ zGztibba?!U<->;${QUfx9n1m3PhzhN7YT#qT{F}KRP3AlI(r#dfzteJ9WDZIo*!3T zcVv_3e}?}IY#c@#@)9Bg4a<%)0J;BDFR18x|JlW`Lzt7FA84fO1a?hU*^QD)ZJ-MD7;>H^?Se`DG`PD?>~G1`X^wq_Z7!g2CNc~`5D+Ue`NZ&UYvL}0k?l}QUCw| literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkered_5.astc b/src/decoder/testdata/checkered_5.astc new file mode 100644 index 0000000000000000000000000000000000000000..0389c53d54b7d1ab03a84b91b3aefa2c07135632 GIT binary patch literal 416 zcmV;R0bl+TtD#&72mvSn04M+e0RRAHustobP)Lf_CJF}!`1tr~a22o%fhJ8{IRW1L z5JCuLh=++fJ|y=eXBH0+@bK_uFbXis%5)CGIskx!e0+RGs4h^MSZ;>6gf9ypA0HoS zum?-Z5#=c6=_26&|Nj^UP&=?vuEbs0)I%5nPyzU5P%&_|bFq2NOalN94-XFp&{FUe zomkozzlaP4Kn1`>IAF<4r5qz4$_0wx;NTxb2{Hq7%V=`Kg82CO2L}fv@pmhwVSQ$M z9Eiu`2?T>hkRZ#ii>E{Qb`T&B@9^+N5CD+ZOSJ7P{XGzag98I;C>rqhFEaApLJI%? z4*&pZP)SSay(c=3WFup6&N=60P)ShQw3UY4cm_W{z`#BRP)X3s$e`~*Y}*}G0RI3a z%?{9OPT+kI!yym|1OiuS5MPij=du=Il>%6wbI!qOXcN%j0>o8n92A^$&c_&Ka1~Il zVY%1h!~+2V0sj7Jhy#$uO3#`9Z5RLl{{a97up|&VM}Ko^|6CLXzz;x05IRjotv89T K_7Vu=;Naldf38pf literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkered_6.astc b/src/decoder/testdata/checkered_6.astc new file mode 100644 index 0000000000000000000000000000000000000000..210dd340e128b789e0e9d22e81780a7ebae342cb GIT binary patch literal 592 zcmWe$y)cG@gVBJ20f-nG7+g;CZAiMfL`IOA`40%No#5MWyNmf$tU0p~!+(bVnHfwQ zq-q(CluhCJ&&dK6=l{sgf;o70Bp{yYDPrv8z zP%~l$y6(V#HV%FP74=p_;J^Xb6MUs&ozh3H=B(!fxhJ!Oc|yHj z`<^9HJPd#S|NpO&%M?0SpNp4iK0h!tnh&~kGkvIfbmu+GpFhkXz;c#vgV|NGcX58!KkeDYkQAUM2S0|K8fygD__LyD`x-rnEYe&=^S=l4){ckCeuECm2` zFaU72a9R8)@wAQ3tqt-)o+6a)y~*(Y`#KmEL}Ch*_LwukS=ti47$AwI%^m55>%UD! z3|D$n8ogPoV(60>zpfQ|7Kf!R644{4G7_>|Nli3fHNX%eQ`*w>h)kO*oUeAtO?l4R z72``y5uic@aF<-*=^I+?5dl8HBc9ut@5#x`m+=tsD0IKiedBuhj#?Fo#3=T$u|8AH zo8K@TNAIz>En9A`J;lv%dHs>vS91Dj+1QXI!{h%q%b6KMtQhnY+3|XW<9VK{iPQ-! z?Q)A;s1HZJ&-p;v@ZyC;1yq2cKNw4VjmbHrO5;s@z6izbNAh+V6HA`~5ClP#Z!c}n zHKtBIi!mT+Wg^x$Z+sQr|A{2TqRK3Z9u^N49Di~)6bfM&hCH2+wtDA64TMnWr#)?( zZMazTxJueqobGF**to&F^_`j1rHVMx9|#~{b!+pv9`)a??ZD&l;Dnw=tSg6l8z4{e zBs}r$qAzTY|cQRWJ!Lc3X3cZmd_LInXeait-ivALcXMcIa?8P<^k|^u%PR zLDv7t{||~PDU;^{=xZIny6GOqaa@S05wS<{iF#XIG`3%nS=%XewtZAkOvd^~+UFHwZM|?g~ s;Eh?iV{0r?VNcO1)i*L{nvJ%oij8P~c-IQ|dX-a_P=OXz(=Tf+!M~AdEtAF`+0M!YH!BQNhkm zF33PAC?seK2~r^hL8K7u9|aZFRB<&F&wYH$kLTt4Ufx%=$GaLD6#WG8dldxn^)3A! zlDxf@q<`mf9M{nSr&67r1Oe;yhlhQAu+b=rBnc-Hxtvl7x3_CF$s}AX()9E+tkqhr zdOe)YK0I`H!yeDZhW!7_OP$W)KpqbJ{j;+$NxIzz18lRgtSG|a@W8;?8B9?}M+yb} z{?0I`r*N${H01Nag5dQY9KbwZF2B6MJ3C5csRS=9oSeM9!8AQS-qr@Uv;>1{HOw&2 z&y$m|PPe_?+6t#qOG|EyuNMmOIBYf>3>*hnt7^5|4PRVb zU*FxqBO}Mho0~AlMIz}mTvwOR%lCP6lgY^YkHymIsVUSuojxDKz&$+_b#( l|BsI!A9g$P`T6s6`Mi=zqmiPJ^ZeW#O~Zaa%UUdw^aCvTFy{aO literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/checkered_9.astc b/src/decoder/testdata/checkered_9.astc new file mode 100644 index 0000000000000000000000000000000000000000..b5c962a14fec5b1639e250cde842eb541d4aa59a GIT binary patch literal 1312 zcmXw(3s4(X6o&6+VY9Z71i}R5A&8f+o_aiXX-duc7Q?e z|FS8KB(c{4fFBHijZNl%d3nvxGYkP5m{wWL2n+$B2YLb|HymyOF~|ZVFhU`Mg(iu}ejLYI1?;kmiJER#iSLfqWzfj)z;d46@V;Kes~TD*YdYJSMQ z;Z3)`mQJWKAkUpyX?pbR^Yfe4fW=~AG$?fKE(t+AP_Egg==X`H+Ao^e)>AnXD0y(62sH>G=G}p}IS>E9%?7(bV+e{Q2?0M6R{dTh*fy zVn{#*C(vEePenVvrvL zGzb{N)_h;FcrF047XtBj3>kSpmZ;Tgl}aTS6SUhWcb$B0YD5yqLufqk`(Y!OE-psu z60ihJuJJH*R$Z2wlspgave78}h)oX;-tsE&VYAur$OtkJ@ziH^SL0m3Mft^U3SDA> zv)OFMFxa2*9>-{I%65GbSQ$!P`x^1Iw7~wzE7%2s9WMR%vpPADNG+>mixUo9Agg$K zy#$J&_S6Xa9_CG7cObzA*r2I2!|Bph&i+bIh6xySO79BKUN+UbuGf(!6T5sNy@IVd z*BL4{eka)2fc+6(&92PuEqY>3it(6%14@G)m*~dS2sA$`2tk7!W#; za;U{#+QH?PJCC$t6%!h<)F6E*OWAcq2Pi-ZG-AWBHnS@8W+~9Sfk##~xcFM=XJJup zAw{lt6s~A~I?i7Tcv>#l%4gt+OL*M+;EF!==)&LY=|db|!~>P`db15`5A08<%bShA zARf#5AbkI2=dZ5VA|50;$=BRF>M3=xUvPlOrGoDl#VMN|{<+w02I4X@k@MJt@vO&A z?lTs_^cW25YMlTn+m_O9quTftcrzez5Bbhs5ww*{ht%N|FFHGaDXQU z=ch4sx$|BTTx!X`{r*#wLJ<+cFapr@_V01;e-C*}N6S~95YX4g2O@9z|AFzzx}|*= zpevPpu!0G|`sBw;b{A1t-xz5kKA2GB R*8#t_>noM9u@VWx{0C`gEPMa} literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_10x10.astc b/src/decoder/testdata/footprint_10x10.astc new file mode 100644 index 0000000000000000000000000000000000000000..6799cd08644ee3b49c2cd00ef70f057d2986eaa7 GIT binary patch literal 272 zcmWe$y)cH0i&24r0f-nG80^_2=ZjkGd-;`@VL#JPc@KN`#^bgL$o!S>Q#%lR6XoT_ zZ!a-4sH|O^d$+j0-k#mCT-0LPL70B7O!G-*Lf><}bHxRXjg5B$`Jcjq%j2ap#SKAx z6Xo5-Z?7Zt1LcLxMgAo??}VuTpSk@Z?;%Osp8Bqc&2DE~LGDZK$eRf>-$eO*v2Q&C z1B2?ywd;ZQn<#&5PW}FR0_)Bfj_RudSWT3dI;Q~nytXeK^;ZS(nkesljKV)$H!<() P+O@iC*Y>Vm8@e9=ccO2b literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_10x10.bmp b/src/decoder/testdata/footprint_10x10.bmp new file mode 100644 index 0000000000000000000000000000000000000000..7ded6adf872e7704c7f62245acebbcda8df7ec7e GIT binary patch literal 3210 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_10x6.astc b/src/decoder/testdata/footprint_10x6.astc new file mode 100644 index 0000000000000000000000000000000000000000..53e37b4a9824d1daa772d1d4ba4fa9dc2a44584c GIT binary patch literal 400 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_10x8.astc b/src/decoder/testdata/footprint_10x8.astc new file mode 100644 index 0000000000000000000000000000000000000000..b9613e5817471d426c880da02b4c9714e9dd748a GIT binary patch literal 272 zcmWe$y)cH0gHeHj0f-nG80NFb&lk43c3p7&7lyyLo0{jdw;#7oLguf3pWKDuhaCJc z`N2y@hR!8x-`=mUub61cs~A^QQfKI;rH6Zqw9B%J*Ii^;=4rZSHFE}_P+Bs)0Teg zpZIwE*=K+9(&597_~FApI(zcuk0U+ZAJ~6=)c@$$4?chR{}1Y(Jw@tD)R$?fu(!(o z8VBk$HfUDi!nlfEtbw;9-B@HRta_zt6Y8N0{$H%#1T z^4ovE_+N!RLS2#i5)EbcR@h(VK#j&aO%0lxw6th#)7GJVm5wf5YjlI2b$U1G+oXSs zfo%qN7`n|c8NI{UUB>S*@ePyrAI+bpPN<)up~T)B?5l8Kj>dVK>NGFXvP5f(wiVht zbljq|OZNx#d`Ry)eIL{R2?JXUe#X!a!=E!k#=d0yD<K zD6+T2zA^`9X{^#zqq$B?gVrW(E!x|3bm&~A`+a)W=mmZ2^lvb*$>0`4+YIk8a+|R) z7{9~BT_*2+k^1_pU;KwXIqLG%7ibXn7TH(gK$*r0O;ws}wA5*B(AK2AMMs;?4&AHt zbm?8A5A?4yu)*LaLt6}QGqS_jZN|yO9VYLp`3ifo)a9tp(@De5{+e=Dl}JV zsnJ@etwDQ}juxG5x;pf%(%YqPjean&&fo?^n+$I;vd!oY zWvRbHL!SGl*(dCup|M0$ndS;DRa$GbEzsWJ;1ZoJx>o4v(7Q@sm;N;dz~Dy=ZE)xl zMz$FJjPV^NZZpZxe)gqGuqRDjhWacGIqu7|ufTqxu}D*i<}xi6TC23xXs>gyL1&Y$ z7CmixJM^v6-(_HpK`^w=p$$eh8Qo%hn~5DJZ>#wVdZwUDL!W^mi{2di^B5?=C@>Xa zF2PcUwE|le_8J^@xEgRb;c3C!hOYzvDgs>u*AN22>xgb3wu$%_65B}be3JTHLC+*~ zQ_!bj$e=fi{u~DKFcx4En2WHKU@gN|fxQYx4X!%e4S1UHw%}{S-$7s%!7f5;2m{e| z#5NG$L}Clc?ML&^LpKTi1sKxky@b9j2Cl$(6{Z5r*I=1}wFKJ@*eh_%!C8ZQ0iH#8 zoA52ezk)yq!CMG*5&i%XAodaBA0x4equ-Mx%px0(~ndC zLeCg<81y}{PBJ3qN%5YZTuEJA;w+>$e{w4w~1ltI8 z5MD*3i`W|CKw=%q4K-gu&nR?b(2v6~f!;~)CbD4{*2Pz`>qc7`)L4mQ|v;TWLJsP?nxw z(h`fQo6D*97x%oSEa^{bi!2!5RqDo3ZHq#_P`Z1MYqny=LNyrJw?j?WJaE4BS+cN6F8#&dPsgho{soLQyjyj*wXRH%9I z+Wd3Hh2V9SQ0AlawPwEuR+Iv(ZrV}%!w>4rpE!JVNofZ42IL?W4T-@iy z^H1?kiSMHLFG(OP!7CEVOL$r$BC#2XUzbE#lCv|Zx$CLs)ap&Rz&|-(H~Lr#@DBf$5cWimXl&VCAKqS9~Q@mI7h`jCZ2KePKa+({8JK0 zOE4p$tb}tC$xEytagjt(k|i}?ncnk9Ww-K|+`v)g>i*ZJjc;hga$Kw@#db>UXT&iq z&Jl5qif2r`^M#5Q%6@)%|LV2gGtrtZ$0#xY$q1;3;vQ5!bMIM#MWRzA^ESOJG8RlMo!H#k4aDd4~6y+iyFUA@jHYuk73Nej@9e zzPma9dhRppHw(MX*^N*izuCDAncsiEe9E-b4_P&)^{t5ee4m*;TG*{*GD5w1w{saX zKYe@ol)S|-^(M+6+e*H_p1^Cn!Il420I!MiQRmd}uLD?ZH#h?MtR~96&lA5Fg<9?} KbpKlvXbS+Paax!F literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_12x10.bmp b/src/decoder/testdata/footprint_12x10.bmp new file mode 100644 index 0000000000000000000000000000000000000000..2007a3dc39321e04b39413d34ddde32af841306f GIT binary patch literal 3210 zcmb8t*;7+z7zS{ib~>Z71R){pL_t7VLc$^y$gWqt>2)u93|*KX1cTZN{rLi2X!f3yTT7|gnt4hk~2XNF)9|L9Y{DLH4cJ^)%jxe2ND}G-e#P)waHIx zLE_C0IY@*e#R+*dPZ^`C<1{Utq5xkMn4-j%D4mT|&*FqTTI-3``Q!BqaEiu7u%#_9 zMe|ysWqpGijq>6+fe!+A^%m@EJzEl?$To5&(Uu5;uEz-wgcSs_UNsY`wr|up(Uu5; z86=49rWFuGgcE@TH;xaox2tgGD?}uN*dvTY*5S%&L?nYqCsxCp@H!_F;ci5^F>+Tx z*$rom;e<3oK|!R{Ne}B(WC>STZ~`m}1(8yxAgmMn^;#z&*48=efFO1SluiEj+KJI{ z=JzohbylD-g%p@sYy`yiNs%wNu8! z3A|2?i?2JDRyvkfJ6G^QlDmqp9vcP(xh0r&N}VuRC%S%>p$7!MB`Xm`N}YVLPR!tP zd+5Ie+Lb5wi6`%wmp1InAMw-2<_llV7m62(Wr32(K$$#Pt_(3S&pEZHR_m?T`x=aX zre&TrJc-|9g^ZEIKc|j;3SPTl6L!y<%i)%|4!^@W448XH|gkLc-u{Fd>3H1Bn)Au+<%E^ZI!6>4az%5bm6Zh@d_{ zgiyF^6o{zP9YV}`xPb8c`3v*>;DTT=AY2X#Ux!4iZpr{oJoe;0^-_m@v=KN(!8qI! zn4)ANP&(zVp27*tQ>*dT>3#J^I7OosENTHv(d-DcxaPR~i6ua|viseX!MU6v6a+!g zM-fph1wpu~Cf(KYxf&%3f*_b?oB%=0f*{-+_dX&N5H7hgA0Pq`0%n~~$Xt~&MBqWd ztkVg*v(w??xaK%;3NO#^->#wZ}b zmYie|DRt7pIx)?*3+4j}P3|w6yt`W3eO-RHp8mU`@PVPQ&saQYDj71BJvNs=wJ@G* z&JAm7N3`{$x`uH*Q(|Dr46F%blibv-G__*p^BPN=PR}i7QTAS7zQ&WqnTuk*pJFEK#RE#pym}<$&tULo$eD zoj_xWI!(wsCiW3JP%6doYljnfoeFvtr+N=3@H#b0C)=e{?F1oLarWYnAG-<&uq8MJ zo^?u{?!h|Id*qBBKqxElDe$aQ>hu!Ui7B4AAU=?gWL||Q>#8*OhLm=5?-bsamEDn* z-vvif)w_49A4uySN*jjYVLg$x49i+yfFt>QOxh`ya;5O_WipXmc1Zyax<4SYuSs&Q XOQ~Im`2Y8pTo{+Mzmjq!srUaE6W;ih literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_12x12.astc b/src/decoder/testdata/footprint_12x12.astc new file mode 100644 index 0000000000000000000000000000000000000000..d94d0a6c0534e4f2db4a35e618a3170f50598d8a GIT binary patch literal 160 zcmWe$y)cG{hf#rn0f-nG7>t?xSBpCBc>Yk7Rafex+ec%j`rEEW2>yNMjsL5AwtReO z=`n3?%6}hYCi!Ynr;hCi_5Q0}ixB+v%#CNOds_B0GB_x2{J-FtG1F%kc9*PrL0)F% h=zr;D#!Skk<|PQeBUAYF!U-v@j8Dq{t^B1s8vqSLKaBtY literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_12x12.bmp b/src/decoder/testdata/footprint_12x12.bmp new file mode 100644 index 0000000000000000000000000000000000000000..57e24a22969e44012fbf6a01c2ed0c64a7a915ad GIT binary patch literal 3210 zcmaje*;7+z7zS{hb~+Uh6oPDm6c7-CY=TxLJGD2x>2)u9#Xr#7Uf8|0i*>A(#RYMp z2*?_;ClZp7g(N@%2_X;yBmu$_P+NOt-}9ZElkWsOW*{Um%x|9Oc_aAbYH|X4T!rT^ z;kzLEeJCLdUcn>!ck&JO{5m0l{33qwT5$Q(FRo}`mVGYG&nWmVe27<9mwu(WxrEo; z{9Z?E>)}g@u6K$*yH-p6H}Ugb{0+PgWvJGVYc?{+HnVi$Y{OR0#CEP}=Y(Z9Z!(f^ z+dDbEU*HT?&aR(vZB%(StG(fxrL9`ucAbCc?CNg)TBISkcWz_E9qrjuGSGY&}L;Bl&h9g6tWLSP0iFVniU)5CURTu#Jca5WB+X z5z$Meyb7et4iLIHB2a-7^PAN`c;kq5ei(?bU}sAZA%l?0TABnA3M_>-oXsHC%I%17 zP$_`$#1SF>1`r#9t+*ho$HWvN53-ch7L1}+Pg^NsCdhW8EyxtHqJq3oh`+wh-`v20 zKvyeAhbclDNGG-kWvJ2IKtxlllvyZZDo{ae5vrWqsA3eg#tQ^^!61Jf1=*y7_)~{) zBFMsv0)n_Gf2kQKf^51dxG30yxTqEG$|`RS6gmjG$a2bnKXs5KR?|igYyn5BUoJ8F zOHCxPT5dbA1sv_-GI!a}U0LC+#s%>m>03_eN5l|S6kHS|h3^y)kOBxZRTNwlBZZH% zw9NJSxqcuZ2+xEz}_5jVY$cqCAamAiSIfNI?-qSN4pD zQ^&ieGoQ?4^*XYjI&=DGa|h>647>71-1(#PCuN=jrM*%$bw)E?H8xYNbJQ4|wG*>- zrn$2gSN){B!8U(x+H>CN6uM`H^K-%lm&iLWTJnf|o~Gr6Ccll^_VTyYnSL z*w}K67TLy>W!K;vk`m zBc}KcARK}@6vRUZnM}KfhzC>(AfCh#ljRabD6kY-M-79p^QWiyGt&ZRToB8#I~37r zW06~sDPl!gPKzl*ZeuH{Ef_^vc{Uq=3J5BQiwt5u+D;K2)^uVEd&cAGOh!@WvSEsl zS}TYx?3HRXHxSVj7T)9}LD(5Vglp zOu_+O!5qev7E@{~Nm$bEQd`h-!_oE`O9o7(gCt=oA3d-I9If8SHJZ6*L|Co7Sc-`w zH;pN`5Ya{z1sBCgF>wkANCCtURTNwlBgF*Q0ECHavY;Sn4ni>`-}rwbI=7*?=dFaE zqcd;}6Wj?P@F4o6>lo33Z4vui=!?2BVgTDB_PNk;w0h3CfupB`kc;RNuQ3VOf-b59 z74=Y8*u^C9qNHR|+Qw(&jbl2_I30vsM0V_FdD^dX)-^@Obw%b4W%i%SoEFuIHdWqj z^~t-M4>~l3owCyp@G!Rx1y>?S@Tp`JD@r{q^ciLpA&07lxi->6?~Oapiv3O z)FQ2>N%!m{!`Nk`_G7aw^(UNAX8r+$DwiPC`M1>t_kfU<-p2`LRWA^#I)YF)jHu5` zfROVPOhS(clPu*&+0m==v|r@uzbRP1D~{h#X5Ccg+*0MXBH|7ZvXTy2S*N`Gp}gX; zg8i4`Opmg662D@uL&aM2YQHD zOVrkq!ghivxknEXYl+%=^wO}TafC`i7d0k1{FNl>8)i$?Ek%cDk$li9DQai7MBP$! zhyn4%K}5u-ki36|h>(O@g017u6%mqx7D-{7wCHw}h&xv_#K?ty@x=iu#V9@ZfB(4n AIsgCw literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_4x4.astc b/src/decoder/testdata/footprint_4x4.astc new file mode 100644 index 0000000000000000000000000000000000000000..fdf3cd6b5f796f4bc1249b9a8466a1f4ffce06f0 GIT binary patch literal 1040 zcmYk4Ur19?9LHz(3Q9gKXLaYi$Ln;6rM<{tPOLRjQ!A)m!ary3x<9@+Oj<5u8b~#) zr36mVha)~7UTkh9!ei7f&!}t6)YF2wOZz8=bZT`xGx_#=lA)3&+p2DcbaKB zjgv^wmnM;YO1U&sqTUl zb?sVhEuMeV?-Ll&x7F7p`UH6(#kjAhdIsj!p!>tIb}zd2zJfVaH&+oZ>f838Gya7!<6nULBmea>TSRT!@Z&sHwq*4tlRRRRzywCgK4eST z$1KrcCNJDu?Ztij@IFS&tB|p*0=!?$ zH!Z7BUh4&Q;rTbnU;1iR>qvjLbmX>>HeX@09g3p!E^yA06yxgdFh<;BI`oFLPx)s?Yp> zsNwact4HW@HQrYXA2IW=urL_3TJgR*_@sT4%Uu~E#nYy>*w+I(>DW86kA}I*uxdS( z2j?#yI80G)P9uF@LHcvM^wiGm0?o#ItZ;HYC3B}3zyF|V1m>7W$p4D^hNk)E@C#7F q4;=qN{+|vQvBUrJIAQWKgaw87M$OiV;tHFAnm)nMI+gq9#r%J!SettQ literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_4x4.bmp b/src/decoder/testdata/footprint_4x4.bmp new file mode 100644 index 0000000000000000000000000000000000000000..fcb4e0775eb1d4d256e9af0db534bf4ce0e68b31 GIT binary patch literal 3210 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_5x4.astc b/src/decoder/testdata/footprint_5x4.astc new file mode 100644 index 0000000000000000000000000000000000000000..0683059469ee0cba5e0732cc0e373c48438b3b28 GIT binary patch literal 912 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 a0P}m#6_>~2_SgVm1O!HxJq{RfBL4^16!-c7 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_5x5.astc b/src/decoder/testdata/footprint_5x5.astc new file mode 100644 index 0000000000000000000000000000000000000000..03c3395ab9576e5ddb62e2e17c740f137f6ded86 GIT binary patch literal 800 zcmWe$y)cHAl~I9#0f-nG80^`zdxh1myyX;X*p(fYXV_ez?ql|&&hCeu-VZs33$rHn zFzZ;S+`oG}<$o+6i+(Rq{!QEux%40R!XWZrGIXYDo-^_b?Dk}1vib~E&m-?4zi+>W zd>kK(ZZDG>|L52TrEW)0o^~)bw7y`^9^NjhvhVI!)`t6x|F|~*)vvjsv@f<&`Ccp^ zlYTdl|He|~-rQR%Kt9kukp0!H|L#h&{R8v;)bsNznr?*UGsr90C)7`{XW#w0vIAk> zTK3Z)d#CKVzct4}noa%RM0yh-M_{(@1AYmJl%J3UKeHo{Xg5*2O)3I zUcWvt0hvE}cXHL5qntJkyE3BO0`1wCUoW2mwrrU+gThpxeL1FC^K7%?bYI9Z?3g~egSkg+$*j2TN37&LRQA;Y`DenH?wa>w zX_Z`u!oJ$ZE@q#Z$D;08E}u1zL#b#jke~DG_$<5GC#vRgvb~dBk7q}l<-UmaNT7YMLH6m~Oy7BLW=7;ZSC%56eZA{@C)CY_*$4C=kLnvM z-8a8v-bg|GcgEzwUz-Peb?(J++?d_m!7R$f_}u)=#0SeloGx4jhJUtyT0ti){DAS9 zbDeFbYz6yFV0`MX1*O08E}%R#{V}Q8=EXXk^;JEoeIPV2dV&&%tdT@-;_t?d3R~p0 z#n~ru$Zk>)P5RAgq`5`@W$|Qtc2!5qkd)k+S&9mbKYpj%vs;GxW+3x@GZSl&`H8iq Y6A=75&ipsuIm+cNUQUx|P~lh!0GYQ@6#xJL literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_5x5.bmp b/src/decoder/testdata/footprint_5x5.bmp new file mode 100644 index 0000000000000000000000000000000000000000..c5ddeec4f38d435dc4c7b11aa20767240d9dbd0d GIT binary patch literal 3210 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_6x5.bmp b/src/decoder/testdata/footprint_6x5.bmp new file mode 100644 index 0000000000000000000000000000000000000000..94a005dcee59e4887c5468e6b242d7aa39666960 GIT binary patch literal 3210 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 SOe}cM$nffSUA=eK{oMdz%lqB{ literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_6x6.bmp b/src/decoder/testdata/footprint_6x6.bmp new file mode 100644 index 0000000000000000000000000000000000000000..fb1f41c424f90da4b6f166980d1df99b64a74690 GIT binary patch literal 3210 zcmY+<`%_xk0l@L>w9}bY1}Us;d(ORc&v&lsr*|k< z{(Iel^RM9Gb;ny*Sa1ce?)z^y-_74#x$-Ua;2RbA*)QLBd?osYj{6Sp1L7^^^mPCG zw{HuTw{QPo_3`7kOMuLspAgYwXi`iq zs+pu&+jLup;UJjqCd=Dm`$$fp%?);VhXntqDTud(2~w15i_@LaV`4ntoGi2?C35Dp zEvog0CArI)Y+oQjIN|nWS4thONQG36`tL_Ov)Y zlItgV!3IA<2%=44tR+g2;v_kmZj7H0lli8k(3&Zc(lR+;X~=4Xyxvq0EoF;Tk)*mq zfG?Wh%X*KtPB~~$bp*}Oq?=j{bDim^vz!e!PH@~!uD8YW)%k~YLAW7|5Tc`|INlmf z)W?tOli7ykgqX=UrG?gfsV+OK%g-B%8lh}7Rn3;VRRxRokHH2)dqN z7|)ru8p~d1I~p9E;JOH&`zY@ zCa=~NXANbIP}K=_;~cbWpmR>yM`&7vVSvg^>nY1#VLPfEyvlW*@!Vy8;8YN*2oI~G zNL3s?8$CLoOd&H_1Rg$LD9cVy<<*Mftg5V4RrNDEBD8&^UkeqOh9b*UVw=kx>nYb(;W-L?cTwOi34LWz;8Yx}j2@OJV#st7nLCCG zvV2iqC@D&1<>{%aQc<6kK)nna#onD_-(FY0rr58^Gj#=)p~yCtIOa0fQs&w6e7qoV z6@{LX$X6Eo%cH^Kc%&$acS+MlX*w@EDai9hMWLiDl~v`kx>5k=MNrH2Zs+=TyXgBl zh^fu74)SbWfnz9gO(mW=$9Loe&b$yWh}=c7w>0X@jUVPD(JpBs2g#0e@@!slQc&iL zszOO!%7JPgoMn5rvVA*U^t~*^)SR%e99x^`=n7nYfoII}Z6^YIPUy&s@PgP?7>uV zbL%7xicqX)ElycaP&bma7b*Hynz5a{x{D0#BZFEfAuuEb#+1O65ZjVsdrIs`PI!>% z05TVb;_{=UJf6ClNT||DRR&fPAeRLBqn_0m6=N$R{ZKtd|pcEXG(1Gq=L*oi6TP7~*RnmRuFhN#M(qS+X!zL5$q!(c)m6~ zYCt9}$cz&T%sIpJp1^`9EDs=y;ea|EelHdRi9?VKQXV0+Cs2s7im;v|oGpa6g9!GJ z>l$Q4hfJ8D;Iu6?ZTHVPLUS&^%pF?rA)LCWK*amVxE7z% zK^}?8HEVWDEv|XH`-a1rQdp|Vx-R$X_uE z*C3cMieX~QF!s_Y*)>b{5UB<-$aF@z!K5&nm1c{|VpZFWz-a=wzV{D$>YXn7Jw5%N zj`@j>{QxozJTh>XU_!@#q7$w{CgHkacoQb{V_Sx)*T$(`STRcXA-znimme4uI-}BH zQkl$ZvmV$Dz@hE^y_Wi67yYglVt%A$--iqX5B1!~koMgr?X?xiAY9WAZy;k^`l+3+ z***R2-hoV`lVf^?)}YiGReGb^cmS+AV8eRe$0)zW`aZyZ_(!b&PuM$mFy>v1bq^c( z1pCo_Z14g0?n8|K2oo$}*O#&3r`X6dY-|l1e~wLVV$(0N*;m-yYwX4@Cfmd0``C{$ zZ1DiQrN`bgV!#X&*xSFxdVhmafA>b>&)C(!VC;|oFER8O6Fzw(v5rk_V3HSaB>sji P{2fzh{+Ia2Pf+4NcEI?v literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_8x5.astc b/src/decoder/testdata/footprint_8x5.astc new file mode 100644 index 0000000000000000000000000000000000000000..4ef49d657dd4a259865df557c89edb457b41f523 GIT binary patch literal 464 zcmWe$y)cG@l~I9#0f-nG80NF*&J;Gg@|08S0>hurkDt$H@7-w}hRk1kGq?nLaZ1*k&H5MmN>-^LoT<}dle6I>nVp-J`~)>W%-`5yamnW3 zLYb4BmCp&X>i-4ujVuM3Wcarz90Box`gLqm;#^bag{H_U75xY57jiaal3Bl5$pxez zD4)}o5!;qBZ(54nq5_b4lPm<2q*=Ep?1Gv%$x<;%T6Bvdm_MK0voyG@pb_T2`Rtif ti>D#@#!SDJ_|3Ai4L2`S_SnT5Wfy?MwUflFrog(a(}S{(k-S{OWDh zYd^i-2Iud=rGIt(?6r1q2VSqfKYjS$`JdNbJ5~MQKc2Z?|L%?G59fdD(`xj8e)%)E z&DQ+J>#rN#ufP7wo7b+Lan_vt{M>KexBlVisrNNETwO%bIfrnDxN zwv=-AKXc zH;VgP#q*sq^S$EzQJMRva`oS`Dj=(2xgL=lQMoxPYvOWiQf|-4T?eu@C+qTZPf_kG z%Z7?<#N_i2v#AD zh;Q2GTl{=0%(o%@S(NXN@VXeUPw>4d{#=GP=6KT~f1$_^miVC~-g3-aPxz4syo2ON zDSnLRC!X+=PkHw<-t(NFdBJ-{e(oFos?4c2IrTPIzsoi5am_wX6X055u070kp`13# z>Ec{ZlIu%zh6B!+XD2uZ$z6KPIcd(taFZ-I#c|U-H!E;n zk-PFOTf5HIZL#WYwgF|lvC zms!g(Ydv8{9?p;KQ|!bO*2S>yXRPNrJM)5_eaX&!!_=%XstrcH#nkUIjeAV9 zkI@8}R+#AsFqcK`4QuM z%uGCCCRt{RW2Sj#Mqs=meP)%eU8hx>w0fIvfas=uy4g=_g7jIK?nLM=l-5RReVp!1 z(R~@(kfkr==>9xCP^8Ue+Hy==PiWf%+WwFpBk6I9cG9$qq1`O)c}`Eipl4rFbxTzJ zJ*r`aYFeXOHmKHZs%?ilyGM2JQ#wDT4^q7$>RgyIMk!N_x{#y>Q`As~vScaiAvIE< z9A#?sh#JGFi4$t_0p)&3c^*+Sk0~!h%{`^Aa-`}msa_`Q?~{$IWb-S@ckJL@5Z=9y>jHQWjQ1h90mY3`{9+6rNZ^AheCPll&f&H^ZZG1F zGJg38cOK&tC-@|RPm%aEh0oBqm%+~5#%dQa)m==zj5VxaO>0>52Bz7<&TeC!yI9vA zruAd`Al4hg`ofqYf?bGW{c&s{iJ8-wC5u@PFvH|ga^vlC^I}wY|Lb2seQL|KRyI1U7snTr}b(=@J?SgSXZ`>=J0>%E|s|qt( zuqTRuBMDjxmowFhpH}2&DgdYe`T3e_dDT~W^^JV}&3xnSeDh*nb2s0*obR|_rCkR~ zy3Io)lr!#vmO{V3*dHhk1P`s@{74iijKqqL6v!`*XFRKe37gD zGN-zpQ_trbZswX6a?N*gnx$OFa+P)!DCjm03_BUaHfSka^Z{8*AZw{s9NNNpTLi2C z`9OB+5XgB7rxU=LR(}R$)L ujiWPfpq&VAlr4fN`L=U#ZDh}Hrv`V@=Dmz1 za9|CcN?(cqsfk$DmCCq5MHa|hDW$IzvsaH&s*lojpJvpbAJktvX!t7GdLz~LQ$^Qe z2GB33^~>N)nbwo0bHLI5mnUoY9Ock#binfYg;jaxM>A z5;gCoR3D$Nh__q=Kn3{!iOyT8&V{7zE|AhKC5&qc<7&#Zk?h|(tw@>o682ycaKNA? z?u;ZSqKV0B1(29K1V9VOPu6|_R>YbBD0yeHy2XB z10d>m(Z-J=O`igx_Rp)d*8xQPHQIAK(t8I8onHdb!F%Y?3TjzHtsCgb7V6kVM$spTR(=|sugh87oqO25bcey zZa%EP6*MlurfLN;u#A}RBSWjm@H%4KMC{v$V;8x!k2rmZD}YSG$P|K1qsVL&@y3xW zsX)z}uWaX{JAr|vz~H^W&}v|KJz(1m*tY|Y-N0oi;M@;P_yd!0U-}MbF`^@)!mNlPs!)M#_*>`+n zyT0)~pVQ}a1%2+2&lC1dM|`s}sOAkw^+!nkCe-*>sQE2O^LME2U8wy%sN(~u>mx|} z3DomB)OQUsdQ0>hv0pT+01cWyThLFTW#9$bRVKl#0Q z3Nk;iUf5*ES%m(=`Nkp0{E7R6OOW{+?-x%&=3Ax^VvPigG&lpVeSKkSMd}CUzqv347Wj6w&CQvL VZmS)D%r}qqEv)yj9 zN3z+?W|Pf*5^e}`gb?zHF^BPiF}4vxD2k#eilS(bZu@5YQ^d|x^U=?eJ$}CP4F3Lt z>e&110yzHyZo|?2!Lf4i1g@jsm6u=7UydD9$Y1<2IP!--e;E9+@lUY6)bNkjAGmBb z&4=gD8(rtm|L)GUYsVcYc7Id%$BXU1{#*Y1?f<`kXXzv&6)j7}K1mahN-K^BZNqwBu|3(^k zE4klEL*GloKS`rMOXvP8susn~bzf{JMH?mBX|e02*z-zsyb_(SMb{f~P!!#g==nh$`L}rPKY|Jt z3K5|Q6^ea=CLolAgt8T(JSym-f_`17-V|!$LTys0+ZK#FLSt4iWd(Cyu;4=5fnYln zI-U!iFNAJZaIk`t6Z&~!;H}_(Ck%Zr4F4#M{>&G6dDS9cxWucM`C=ch3G$_3UK`=7 zBD`*m*KhEK7+(|TYg2rEns3PPEg9aF{kb6;2oBPOo#-o19^bJCo$Kp zu6c(uWx3WoXTdou!L^fI$8*m9f;;l{ zn(d+4UWRqBtn)SNdczL9W!>*s&kxMWX{Kn7DSpamAg1IQQ-(0*C{uwkr!l5Fz|@48 z+7+g5l`*a}jhjr<7Sp=LSdvWJHe=giI(C`PJkyOcJp|K7F#U(jz;nj^f*E?r40FsV z&zuuz)f8PgL#yZLQwy}lOP4Ov+9kSTnbs}SdLL~F&}YJQZG^6m(hVDQQ;asnXmgyl zCh7JxZOhR19No1?_w3V-ecE|IyAJ6=nszg^howhe)92n$s!6JFnkt&5il0&%h$?wT zl`T@`D5XOwJw{dgshSW~yF%5iQpPo^ag#D_QsynnlAzkQDccU!u}gL4sBWBc;FOb~ z`blcwIpuyq4ZWm>Us0nxSujqjrpUq>Qawi&KP5F@vJ@t@2w8=Yx@A)DBMkwvCPdao z$oeSRuuitDlcpGHj+53T*|tsEGNe6AcIC<5Jn7gcod=}rkQ{hUx*5{Lk|P{(;t8Re zBu-8fMYDu@o;U>&CC`Y`MWS+%(4oX>jHvb#h9Ge!Ow_Fs^=m})8e!TbTDJ&Gg0QBD z_8p>Qm$2uEvpK?n6MY2HPZBPQ7^I1zmxSjPetZls7{^tUc;O7Lp2Lfu;u;7qh4Bg) zuR?GgitBy2A%NF}@Y)r;K8iO*@s@Smw27PJxHXBlZR55b+@8gIvUqPEci_150CyeY z1J7~y3*5uzPu|NHJSsF*7)azA0=bqInPp98UEl3WWV+&@lIcrlotd0-7sz<<-S-Jl$*68; z3h!l#9%PCiXEaYTB@>ylsZ9B7rfObR?N#g;F(r{{3CS$0yO!0gC7S8l+UbmeM7l2p z5?~8p$CJ-^_CO*#Or#5LrB!#+h4<6yhw0+SY0Y@LbTX}-PFKy!suzwJm(%ZUH~VGg zaM~QsSR(1p%~a>cHaH!LZAVh6Y!79Dv|PbcCvK)xw^JwYrHUS;)Q?i9#!@8{snV%r z<+Mycf5fYlAZvkT7F4m(6#_sd*1INi#S|N(+Z!X>pt7#I zDpOxqtZDBmHmV-WswWhy#+i+Vd0C5BW_dY6%fSI(&>aX4g@VJ8;Ak{> zZr!i?3<#(%DSX;*Fzq*i@@oOz4VmGN!rw4<#Pq~(p72|z{Oz-T+q~bt;O~0o?^*Oa z7X8j8ziZh)==ZyWeoxpxvg$v#hN&(9KJ`Tfs{I-OEBLCe%c^fFu!e_6Ok3x|Y!aALAzFJ#yg1d9+;0bKSWGpNb5LanMAD9Nc$Yp@f5K` z$XN(+z(^m0^rMIiLk9iGPzdp?cndxP7K<(@yk!@km0bcWELL8T>8~lg^|uy{cfowP z=>gpG2sVwu<_Xw31-H$>wmI0o0QW4wy!_FnxwG0pVV0QragrO53LaM(*g&#r1 zA48`;fl5Dxw4X!eUqF?YAl+q1|20%|6*}`RRR0~+a1(001vTG+O!px31E}p0)IJ8; zC!nq=sCybZI}17HA?E@#@C+J+A+m`PN5J+heHX3Dh|$CwgWe$DBOh<&_gd2sDg>#Qy*% C#Q8!1 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/footprint_8x8.astc b/src/decoder/testdata/footprint_8x8.astc new file mode 100644 index 0000000000000000000000000000000000000000..bdeb9c9b79e5db8fb8bcdaa86aa8320d863bfb11 GIT binary patch literal 272 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

v%fcTaL{NYj%p<=}R-K{2h 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/rgb_4x4.bmp b/src/decoder/testdata/rgb_4x4.bmp new file mode 100644 index 0000000000000000000000000000000000000000..fae4f9191dc9877dc83b47a672295928ba3b1347 GIT binary patch literal 193674 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ΠN+9jbLT=lT2WSbSfHcHt~n!61tSls+nm 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 eO}r-#=IO_43H)S411Dr^Hh!~hw`BS literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/rgb_5x4.astc b/src/decoder/testdata/rgb_5x4.astc new file mode 100644 index 0000000000000000000000000000000000000000..377938de67eb5be9460189cd73d3351ddce7496d GIT binary patch literal 51856 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 literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/rgb_5x4.bmp b/src/decoder/testdata/rgb_5x4.bmp new file mode 100644 index 0000000000000000000000000000000000000000..a0c1fdbb89da7feff4db2cbd1346f255312b1f89 GIT binary patch literal 193674 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 z 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 z zzPR6?z=DBPFqjGj(^xo^i2$mwnvF)0Q?YogfC;FHVj!5{rVRW$mQEEj3?t3R_x+t^ zEBR~p+~Jj? zlH8kc>SxI0LGdZ8#G+uSR}oU>^r2Kh)jvd)OtzAd#HyT1S5oO}B31Tt%UC!QOBS(c z!VrVfXii%&oCyZ`f0FYD(p+lKXek*k%}7a4uVK$3)zOU0m*F}dhnwnX7PIU}xA#2Q z#-3|=+qSf2-Ld=FK*7;_;~6fYOOPDpia{b$ST)Mrme|uzMI)@r5m(jjhXEd6P#ZXZ(fm8FDEcpX* z;WLS-{)>F(z*6`WN|Df9PJNiGbA?tB@if}Feh>w%N~u#}RS)nvF!(GO4K5G@V-VGb zgqD#7}+{NN}r_cW(tgqc_QBjUV!l!I1ks0;*R1zvVJ~v+B++{AJ#cgHEoXuk&@VW0pKiL&k;;9f- z5(=L#cL+WMfuz>Ya7gqss`PWfr`FGea`fqB+2@ZVp`xE4nlgS-KX34fXYV#d3`SrP++I$}P+wijmQSC<8y>6H6owjEqTxs`*rF7A-|Txjkpk5z-CMlMvWf3WVw?$O)qEnJAiA)zw}i{1chnz6MKR4M;z^D#WNMSn5arhUIgzAAQcZ~d-PgD@$4(=`T+dG6qpD*Z$}J@5Dw=dKMtiA(YC0e_EA?b-W$=HhX3rJjGsxnt=xe8!MauzZitbom4S zUdYyQ?yM4vQvb<|qc8Pj6Xoog=%G)KBBX49hRBjqId?QglP7|Sk+WkkNkNH2i`0}jv6OvUN`BDmZz@q#JX7g%EUMX=Pz~g_L{&Qw_i>GvW~0 zIu0EzU0z|9*QUU!w3I{%+rYL>+PQCT6MWjZq8daQd4w_Ph?RC_3$tWJJl!~Vl^^-Y z;$8azw=1Cale??D-UvlhWYFu4V!==<5J-fADa13vcPE^UN+O?$#3YOHG`uPzbYNHMy5BWOT{UGdAOd^$i zs{o;>rLs=7cEAu#$^tx;Nb{9u4%QyG{ir|^e`qhOdK5BSl=h@xX znXK70w{6*0w5&ie=S%_w5eR00AdzzpQ;0p>YiC^d~2P1NKsNt+I;G* z_(qS@=x6*i!-(Rm*9;84)ttD-!GM#@ygdac1LN=B1cp?)y?gr?<|j;fbC5Gb8y!*W z2Ubh4XFF9kV#Ostg_SZ+CL25$Vbk7>F&9kccf=_X-zN0w=3t zC#M$h^>eI1oL!oqUp78h$#A-O!l%Q@XXfTt*EhoOX=Fw=HZg+tAipFy!|_ODPjE&B zXNDr4Lx^bbKx>k8`P1-tFwH6!6JSZHkPL%|d3#=Y{df zfz$cCIIr>omi(Ih`qAA(UQSX45G@s&ZjWR-qW{Hb`n-&U!YATcDz+=7W~JET1uK?> zajDRj=J7>){|=!q*>@z1P*uGUJmccRCBvE%MB?J#a~cLU_B!M9mLwBSd+bBkyEbI-(O? zo4d7Zb0R15@6M;HLilf~rHdy+-!}IxID=q^Y^MSrG?Rm+8{#Px-;vmSPhm*mk9&4@ zbcomypA?LYVSscS`!wM0h?95USyNgOwt z36{Xgz!*k82mP#+AWc^0S;jhU$UT>n&VBafA0wOCMMiab>& z>j?ph0#pb1rr_H_M%bRBcN!;tj$leN@$&NcSXNKoIg6TA__8!fFzTTx;(9`-GN3{x ze9~d=hytgZUvrOmV!9aD5M={ufas18{SQ77QplulhZlqt&2&VmhoYimZ28;RSype} zG0G`pT?R7|ba>i&jVI3lPWk1(C=a2QVsd0`%Y;mfQoFwlpV|gIG);&H%4wfOOQ}@a zBF*s+rlR!6)hH#c}>j9scBJU&TK62|M2OtwfF-~_# zD8H;5p?!ulsnwnc)z6j2ujTXAT%H_hB}-bV&^S)zkx*Xv3~(0mI=k}B7x>Y7zNoLU z<7*3mgJgc8#ji6oexi=1Rvi%Al$3pmLv8KNq_e`3Y)w4U}dJu^K!Gcz|ki_Oo?&Cky*&dx7QBcTf`iwmm@ ziz_(yrKRuzdz=HEdBal2QH$&A1+wvO@K%!H)7`kb5GG3{ zx%I$G_;-6Z5k`kgrA`oA1&0KyPg(w-LTVNx@2XU4BTpL2O7;>`8QIZCMJ0iMdR{y} z%g?QB(u0Acq~1ZMYh;JS^#|ws`{(;f*#TA2{WDq}mbi;2oZO5ayKQq-S&W8KW3xg(O>b(2I-N6VX025^?Q<8y1FiG|fq^D7>VTaD7;w0fmVKOYTIPK?9jr6y`^ z!HXQXij@kF3w892GO=+oHLr!jldY%H7lM1^Q*Flkt7Wq~S~ z(+iXAftPYFOwTOL=|9Ni1zVis*g3yEqr)f8{gKb*<#n)}Um$Lp=gc`YhCX(&?Je2Q zd?usOJ>ye|CX=afI8HTcfA17KNT!as1cX($+IE`~qK9WE^6%#-3X8~dUbs1*iNr}d zh>tjh7S3_;^76$D!BM7gu25aZZJ1duN3&Q7I4>{n>-Ec4Yf!1cQmb5U%jD(p=ACM( zi`7a!eTaXr$oy++)h^lf6eHr*9$)VUtMDl++GjY9VuhA02(L&8H0)d|EQ$Kb^Jj_u zRUPo`E4?Uk{UCbIQ`sjdRhkqy)7kP-DjOjBVf-nge6xsEa->FSlH)p6`y~0#BOE=A zxa+jw;?vFGlc^B+Eh{px_&CvX#tTb zCv~C&yedgf;u;(}23_zOiyj;%(?KS771{wkL)>ze)x1yYn3in zYU=Z)M?O(es1VHMt{d;1NEJ6pIfbZUX_PvvuDvBvQqoM%Sy=|vBvb_{9RNt_b6$l{ zWuJzJQuGsZM5h*3nC@W;(h=pbLCAk_a&f?+6iR7Vur&UGi7I_!@JS7n1Ls=wc%As& z_ykVPE}^1vA}!zo8l9gKU~w zj`&18>5W%={6{oXl}dHU3q1H7!6`%?&MBO`-iL$aiiw_($p%FdN0VgZC-Lb^*gQ#2 z;N%hwY++T#Z5p=d)obp~CuFX#Z$TzJ4?Vm5J7k9KKvH99kh?FBa;K zC{IKTBiIo_CTNH!5{e;@0iULpqj&g(Qa(gEM}~fKSglnrtCb!mO8FI#Vh|mIsuwx^ zj!A2i?*%LmqLza~LY-1xIEz|4ijKSVmLQ}cI;6A)nV736TjW`X<%n*D6Y!Zj%^%Ue zB}A3LhtHvrGR^M9Pe4?Z;^-OoP)pt^%DGL(NqZh-PAM;RoWknj=I;FZj$(6Zrk8%W z7l1|mpVW+m6Q`G0-Ej!!h{oWBjoF|}vzsiKEt(u-mYg;Zp1MtvW9OLaL3nUnxxBgO zjz}LV{f>Cbm75U(DYrR2kImrCNxx6c;MS#_bIbGC{AyqeT&00{t{I? zb8|C1JGZj3vbnXji*0X5F&w&-Q+4*e$Zj$cO-5q}oE6XqXh)FbU)uPj5b%11! z;FFjICypKKiOUX>?F8xcRGbs_s7%Rmk%M9^aZKK+NUsrB(xXCPnQs(xbr~-xrxHOJ zk$8tEZkH2drPSp^q8N^mRrBmT>+o4cEj#t9Xsq(AcFI*g*{RifkXePsYR~Kvv`$Yh zbb_t*Fc=;gKNnDevsmt6g<`i@ZUttDLMe#S$TvFBW-X*5y`axyUN6W}8?Bt>YG*kP zr6vC0Y5wdNrM>+$Lt!uf{J><{=63w_w16ES=Q)TT(U?cythMLK-DC9a?~%aYBY{u$ zew)@2iuEye=`c~EGW||GgRwV{X*+!V?*2KrF0Ds~e3HxrQNf96dfl2jfRn)7`P7SH zDKagu{@0jKZHP$UQFB(u&Y79{ zITnV@EtA6(nP6#~huK2BDDhlpFR{V7y~@m{x%Kr8@<<{0+}xyyDL6x+I2Lg-4Nd}f z9I@AWdwVGgLl{_+jf7HOFyJJFIXyLReo7ym;8fN~OcI;hVUm=lbp9LT=`8K^}ds-U!>N>fRpzUT3UfjJia}JE0h|yrB(qUEy^US#b&`+<@*It3IC;~ zLbQ5;Wihf+IzRJ-Qe6K}h_WV1eY{3F4BSLjc9O;l5n6m5M{Z2a^TLH%y)1Y-z-A7PL zMtuk;$#%|`76AoJI+;8JGJ%tPJDV0P8WN(oa`e+Abcqc79Cr`RugzoJK%~Ybkx86x zaBkAJw7L>nTNRcdy0x{lxVTQ1X?r_n;u!C)??ZQ@asaod$dom~*y#^y4O&d?v6G zFXS*0%yzBZu2tG~6jCOy4cOw-fNWN~jcTt^y=>aEQR~-heSh+TL1w)^z`(V^KvTY+ zqH({{b^SzUtMx7x9B9#A%a=lFNw}h=?V>)TBxIeu@hblOLy)ZJLS_6N&LG`n?oi?aLTQlW@?Px+BL1wed_%k$y)xXYuStDL#Exwi@t>PhVJr%n_W3 zr^uAim=waZV~8!3nsNeXOmK#A>j|=*BR-YtR5awZAt@((qLw&x_>@m4Hb1%$oD?oc zKHY+Gu*{y(!>LYV&;NMJopMin?*u*(Mn7RXlhkyoO0A=ot!kODNI-%p&qlS=e6&j) zM9XbNuU_l6YF)@|*7_|Ft@WF=0oJMynlM>2s}I1^_!OupCoUdJc`+|9jdckXq9&vu z$_oa@l2gvH$_DV#!Z?dcIfqVv#42%(Q)Xn;=lm2=D)r0U6-6`NuD6UzMbS@feju*jW9cZ{n<<8#yuqP+zTFO- zFzF6m{(Xoj$OX0XF<)M!UUxF;ig8A5?Gvn~nPCGk^>lR~S%fY=8F{nVTrWQUX5O4Q z2qO-{c$u3fLSLDjTJ#sI3R%FuNcu=;&V}W5T0JmgqSfW?H45vi1VlSDeypvB5llY6 zyt;*WQX!%}emg{xQwEuoFI_xibQxKwPC!H_Cjk*9AzG5?hv&&VB_Yh*I?73DPwnNZ z3h|^CLw84pyXvatT(y`ZNY_!*p9pd~T|gWCoGJIMbEX0lNIgkzby* zDu>lxqsGBN9zQr3=#w04yQOlkSccDbp{ls46eOTVk-qX#z{x2T6&;##Q1}b^dWut= zNXe0!ZS5o}VblLcgV`1%OlO4?b(pABdUQ$$DWUyOM%sa(UInI|BrltUOA6#u3^>cb zv$-*G#sDKv?TDMR=NF@;m$)|H2h6hB1=c_AQYuGBs z&XD+Aj{qmNbryj0giqikjXBJ~TkSG-7*+3wD<@}83YQ|&jcO5mCihdk47)oD8rn|;W<%xzDCh}#AjJ`@Fu)r%J4uYCro=nVA+hor%~%b zj>(;THz4t42w*cXBT(;>&6eN{_|$s?8-OJ*4QZ*cq$0rY!aI;R@%vB;?WU+TJC6D{ zf4irf;XRL zz)b;>=aDF>uP#`e?qq@}Ma-3zt@YKd^|j44TIK}j&c=qAL^;tj*_3h;ryqH z95N+bW&}RX8i*?522OMmmiUQ4)oKhd;fEQVaM)^IH;1P81|MDpp8?UvpxwSf&=7e( z{{(WpKOWyhsz9j8M43ri^-U4**+EG8Zc;M8*k%^b&H0pze_~!X<#Y;`ZULg%3YR-G zPEM_SVrDTM+e;jzNJH%%rm@7nES_ZZ74G{KINi2(51^D~lBDi^FD~gOyP6@;PeLKe zJ8b>YO!|k%kx-S(ZTP~xIkiYQ#3Y`GBz!`q;2gPf9J(>7p$s#cignI( zqnUG72Tr$XVxonWsc8ZtN5e+SxXXienb$mK}Zfvg8Z@dv91CM5+ zpDv!>2JbC%d?+KnFK)7^YbLvYfJbf`%UjS;C3nREZn%ZN{8lj=FjDU))RIdJ02 z3(CD$DRU3uB&FHpUlu;W!-8=sCwzJ^PWaqC|+(D!Cvv%2n#(>X} zP6lv7X1jT9tlk)$H?5|>z$(Yl%cG+VVLrbU#7c)D(@qP1DCJqDmRjkTD}BV1Zx&1m zC|o>26UitEey3FGmdluFz8y~N&>|tF%ya>kdB&OL;=wXS0V`7?`6&;6dJ#*WtZhZ+ z$)JQ|JMpCPnHd)7l@~=teX`y=obmF3qu*qu+ujBXh=T3Sisi%RwkhlV;f9ZQ-z)Z=l^%{5dcRT3I9`4rBe zDwNneW@@8W?x`GE#(D@QWHvC1$3D-w}FpG;I+3U)5>^{=D#+F861ZxI&Ak4y8IL z!y!+9QHsfoXoyL=G;M)YIsIUnW)(pGFqOkNVaih3REF8=!X9nflytL|w0=sN7dP>I z&OR2lMzBLb=h7o4wU4rl$?V3Cm$zbu=;4+M^rsAmatdW<{%cx}8EsQx-3=A>;Y!vf zaH)hTr@;xLstQ@K!wcDU#xCqQI>pO>^J#&PA2PX@N^njGH&%10`Z7Rb1U|D1tH$Tb z?BXh{3Qo%)nQZE=KzusxdsRu!5O6X~XuHQVTvA zEE1oBvm->69U>C9V7%IEA(CiXpp9bEO%A;|fJuJz|C7%~YtU%Qnyssrc$TjASn62m zF@FJ>AUgbwI4$(sjee)W$)OLQI-u&j%C`xp(@XJ*c#;BDAC$^QK(0toy>=y9I+J=m|U7vPUQRI0K&S%L*m5#*H;Z;!}t^mT%tK4yC^sT_1tUJ`hXJ>i|GhuDbx- z%e#02B+AJYFxR5F>1ry1aZ2ZAWQ`uNWb-hCLIgo}!gM~Z6146TItQE<3Mu_Ahii)`YG*c$oqzzt%cv`11T^}(%L_9}uici70k8%QMjIOyv&InHU?tO93V^J~s0(-Sy!FH?$7hm)3I@yTW@WV1{Xi3}$hq@JaT zhE5#KlsT5BkapA@@#zxE7f3(bSF%>$+&z9g5Yl$*rqjM{cW#Du-R_7?w?XeSP?4+e zUp{m@w@#^;to2&T8_0=|P}D>cqj}c$nYyUDsoa3?<|I>ST8!^$QpHdNQ-u7MHEr?d zEfia1^+}wP$;X^bf0C6#OB2ac^i~T@p75#ntPo{|#fj!etP%P&$E^L~agKf`5JgCJ z7LAerRLec1lnktyTPJ=e<*r*K{6noxF#qmw+B2Bi08z5{T(8D?l>o|BlxorV#Edt( ztF?oCriO!7P)KY+^J{BV&&i_8mN!sE31*OQ*Jy^DLLreEGBZ9Es)si$AR6%rqGaHS zo;EgioKK#zXmZG>&$uy0B=JyD`N$w>e{E#)pgmE@%Cs4}HeMu-)h;N{V`mI8AFwMljeAg^%inCoZ1 zciZdT_4^N3S6>4ge7(NPaA20gGa5Md1vx z&-WJ3QyjHvMI+@e$)bdVJS)p@C!wXq&x+unF>!J ziiDn1qO}1io=_@8PjktG^m&enCz*k&kl$MPLSI7r(PlueqUshDy(PcGp2pI`s@*R$upJbV7@Z-3|>1YHXM z>bKut|MC2_ZpVK4>eZ{auV24^`<7Ya_wU}({7L604fE4elQT1fNUCEl&;!4?NSpE6 z>I%op&5gC~jdd)txj{Qz%xz~YzOxAAHTSzim0a;Gq4ZN^?0av;gT z%WUFOL&1a(l1-7R+K|Xh6@ZF<4<;^o!SdN+o_|vYDp@0wZ4|lLvrxBWyXxi?$K6N} zwM-9dl@6-N>29A@VugCA+3(?S8<#vUJ2#izn||+ZaCtZA-wy_#-L9^_V7J%bp4#2* zkE{OYo_@+*zjqI-=&I`P;8biBvK4Q2W>X*iDs=r}$-Sc(sofniX|ZsKzpI_y-2~6A ztq5_q`*A%IqJlp(3i=mi5XDX~j#yBdDjc2^ z4vzDiI|oZDFdc-V$EYGY>1IrdOcm2Dw+Ty_WinNigiq$sd2)j)e7<<`lDpdN3N~&b z^b2J4|DOH!lW|=KcMU!Jov)N}-=%&QR}FE0)=OQYZ8P|9GytU$5(el#ynp|RHfECi z$Tynk|XaC&-3*W5WR9~^$*)8T|qPMbpXBA>e`8J{3ZhLa3@rI;^UWW+5D&2nK_ zuMGMLB>e4#D0*I2M zBa_hP7+}_E-gaAeoz`tz!Tu9INunB@p2c#7cRojmnu>}~;(fXM08U;|U~e^P=F3eg zq!@4ls@kGd9z|L?00>dyclgW{4AG~QvO-NK((>sA3)V_(FJYO#Tkno z!1#iv2AP4qc>P?L6u*3GT)6qvbk)bpH?Lm3;U;5-Oj-KG3vJKKOX~|DuPmaJW{FL*;$_HHam#& zl+i@T7!eH;Pi>S7#eu@7ynq^{IlXX(SzTFJS)N~BoL^d)TbiF`EQS7R`u}MfoSB}U zo}8MVVk}^0c4l@Cqwkuzl?A4um-+77bUuMo1V$3Td9+WH9%nWC93c>!FoJvKw2l%JK@5z$oX4PaRp?H!XrDWlfbC7-skp(qWcW#Zyl&NJ0S>6@^Lat?=m` zQ*`cuXu(ueZ6~8{sIqFKAnFxTM-(QXB6?A35ljUt3Z)}l3G;IT_2gVDB3bqbqNE5Y zkAf(dgV2KnmTq1cGCtXjAlbyN>l$dghL0*FaB?FIm#^`}Akz$B;Zqm2KmAYB^Nh)} z#=*=!;8nL>Q>mq`l*6m_LTji~^K>j5QL~>qQUBsbHnTsuk>NG7r3^m5)eV>okiHX~ zTs{k*?&Yn#9*CzLy^5HsW3o34|IXMilR+8{w$&fz-xax&?WB%Ll(c_%M%q)EPkKA8 znhBW~=Oy-c<+!$6D$1FYoKm?^wh0RkpEP?=Pghk)hJS}oyZ}9fnuDI4v7-we1q+Y~ zpHNEM-_!q=SJoIV-PqjT3hjg=yJ5zoLKGTy(9DDV6Et%_d5nQ5E;|xt<|N=Vw!4RT z>L9ef&37DzY{KUP!&wuvs3`ggqQp1>pY7XDME94!5%rswH$Fks3?@k_SO#q9 z=q)`(PPJO4S4vq^MM;5|hgF$;J)jQZ^cSl64ku4QMM96#c@T9K)e}~WO)>x(Jbs~` z$yd*E3hSz^MpMP zm&m0J8bj1uwDAS9iCAi{o&M8(*2vv!(9+%3nC-n`(8=Gq5m=i^{(Se>+jm@7#O;BP z_KB&vv5E1IpV)xIniA;!$h@cRtec)&;5X%TfJWKeI?)j2A@y@wo|CRQ#@vX87$71b zGAwNh!S0rm~s@=Jg8U zdC=oQ$V2k~-CrNM)H}Q#0VixX9CzEu`QTi}>oQNj3H^b|zo15$OB!uV;=WhnJ z1X09uWD5UV;*)qvDk>~T2T}h}b*q+|Pe_)EQj($=ifT@udQ)FXepSIJK#<E&*X8AeYqa&li^28pPJ+pgH@~MGips?)OVQR)`ew|e%H)} zdgPRZ=N?|oTwtCxVk(N82LD3W>^}$`V_Jg|OYSz(x&|#?V7in0t)`}?_!9Kc?H$8$ z6h^tvh|H>e5>V-Ue)kdjxH+B6f7vMV2Qh{_C6gcL;SX;cOC!uNF1FGrqJvkx>T zc_&g;-Eq{3EGie4WZgThO4|{2KHt85KTk4ZZEI^Iv=iD5ZALJ{Jz7~nbYx+Mp*F%a zQG;k?hxSyna1=86i5R@??;T=$agLe^Ky^OP(-$e`Ne@l|6=?-geuXpcyH91)CmgEN z#|NkI$wdD$rHzFZQc2zJUAJ>L;**!IaJ^}_ugN}PIDG^45l&B>HcUt@$Rd-EeyY7h zJyGJ5?r43cTNzqvLMUJ{bdA_=L>#X$Ct;9_=R%kM~be&h5>e>{-5$EoM^Z>C?0H38SMa z`u}0FoG)|7D3qR`<+JBSKI8hy*TbhjQPC*r-`(Wo56qF*NE}s4ZoYo^PTr0%&RS)X*ba!7G#!UisXdqfBw;WN}<2`GU zK77hN>UU7__)aNWYD0O5CxH)Gnop;QiHj#xmv|zii09<&GCd?*_xt;EeE2H@q8Iib zUf#*X%k%Pqt7JG^!Y8CoO;OEvGNF_g#(}41=RpoKdC`-0kY(CC7XcN6$q7Ei9;MZd zrKMH+M&5(y#MHzz2ruFHn0a^q&h4N4ZipwdY=PPCIECtaC(K>4w9}OnI6;(Z5&fKL z$)=gfrZ&i(l^I1xKV3QDQ!Po5>EjqEr^K^mE}j>8d4sd9dZnDZupHU|{|=wX-NhM= zqkLbSp0EjLKLwc}nmsG#GX?HeP92>gk9@}U6Am$c3K|GtAc{{vJ0;IWqiHsm$vKet zbZF$=4LGsGgVR_viI5gKB=ecGJiiEz9ykf~X8HSC-XOH;b#Dz$kqMsxqNu1G{k6qS z!=S!pp_83O5moA6EKv+cSO(uLSFbRRra1RTJ?J9f3oxU!SA#cU`R*epe5T-a@*MVRQruy_ z_y$VC) z@Tmc}p;2BZ8>#(rC?_2t)@e*u=gh}6;4{r)Lv_L{zeMJf4l#;Est|dR$i{^zpkPI- z5cwI5Gbix^SgPsB%qr>X7itV>cqXF|-`%@NWpigap64g$XSidsl;K!5l`V6`J2z;pb|^J1z3E6xN5@h1 zqEK(u(X`QzL=IlP`na|h8A&LAQXNfYuqrFp`bF;1laP99^zq5el=nZY1%=8!Wqq!6 z&sVvE;k;1GfhFsA$}NnGATLU7EXziz3VA9E_7&qd98PNPP{+m7OlXeaq?L#YCb@SK z@6M;l)CVt+Qe8j&LVTM2`Qjxv(b$q(+cO60N;Vm*JONd?O^jET;_1MuQvs0=h9BpA ziQ)SvXpZ_c!CBJ|56sq004kRnx{-7`&DlZee=slzmUMt5STjMYO|@&qQa18xoAP|D>EEY%_HNhHOR6V3@cF-B84(>kc} zNFqvFUgy}*>dG3Dn~WXs46~PSo$+c?RTR}iV;{$P(xD_cdv|V~-feIwC8&qe&Q0L) zExM;6%98mUM|C1)q%<7f^$C+E_C{YK(l za5|vCi9IKq^qTA?*KNOij=QH+^hy#6huRPhrECzD6vHA+>f#TKRidt~P|F#TOp`DL zR89r-)9|}QcJ)HjRgK5iP^__L2BXC5p^L2PMZ0F6GXQ{QN%Nzpp+?7dQ-bT$hu25 zv7`NSgHt1KuAdGk-W)!)@?E8(fKQ)K5BPNDw3BDWwM#c8G_D2BPq}u}ZtY_>>u(Jj1L#S>Aw8 z#M3F|Nwh_x2?@o^Bcc1TgFS^>iAV?u-9|I@Zu&`lM41>Ykx*Vp5l12kQqYJa-pwZ@uPaPmp7bCRXXyO;5_-cdKaQ- zDk)Q6r{hnyeSaXr!g$dSnb#ltKx9v|~QF z!#k5yM`n}Um#VE1tZ|l6IU)Ea@+p|m-u;OOxt7Uowulm>+-g-gW>X{by0@=8O=`%4>x7ll#Xld~MA0jPQx zw_d1q-13NOt&`KU3zKfj!%xluClcy#{_*P7?*=Cj>eMJB>#k795ap95e-c2PIBuOi zqHov-jxO?_oHm`MZ{^vakcn7QWCu%uYDT(VxSC{AKQdyeAkkAo9bRctxc&6(kKb8+ zzqt`gh|EJXiY(^V_f=u{6|(TDy&u-kNs;|bdlei`O|KJ2Q>mmpL|>UVEZMe0mJg9q0cA1=e3*Q8Xe)7b{^G^2W#fw)IXn0p6oWaS!+K zt!&}Scfz!AghvLP3^|ZRo4!&(P6C>kng!ba42;|;j_j&ZPm`FPNb-)5XILQm3`6@iBbi-ELQwWDMU<1!?>v;`#19;yE!nO|YQaAABZ`WmdQpoRlx=?WD2u@FGPv3E3p^EXI_xT!mywtN27VL!|Vz#EgklxZQ@slfxAG zs58o5hbcZpdqI>`=S3!uWztH^pB$wUiGAQdVZJ1t#T4Lk!6gS?HoqUHe4hZG_X(d5 zmzNKhJz4Map~tiP&>5ac-RUEwAnlZ@a3AogLusAr65?rms!iJXbO{aktY4OuHC5u2 z9Db?Nhf=(@nd@i3ClX3fPqXOBc@aJxQG^uP%s=6iDIrX7&MboEFVCLw9P#%L<|+Izj;G19b`G5A1Dmjf_f08PUK{gvd7?)lF$dkm9!^0&N`smz6uHQdbQ4QxF}@r4eW^Gjp5oKVlz2)xDXhDhbH7L*U1UzOXTV8IyxKd1 zun6&l&m8$iYdq%jP-^-aWaG8p12~J?!KK1F`!{sLS58Tt#`MF}h^|mV#yePg-zLv! zLi)*gKAwG-xn}e4h$n`4LTNmzeightruWF6lX<#-nm$bLADm(bhp9boOQ&CMI|7zP zQnKeIp1F)N@K6e(ycDu!!FhV_e4?4VkrM*NIm^{cLe*I+ zUk{dg0nVJyY~dt&rj7utt1+}(DEuHQ0fyX4gI@Q z+O@=fAfZB(m8#jwqlDHja~5jlYdwxA7Nq|pC7d-nX*YwY(IFR?#pf_uqwdPygI z3R5|Etpr!Mh73Qg9~GT^Xxo*MJ71gQi@_0ElBi?SNnMek8{xGFPnRE!k)+dq(@KQe zRvhN?_#Dd>S>cJ1u;=~Rv)`sB=XN6pal4ktZX>dV#soyntsmN2c=dK_-c3dJ6B3(R zwH*ZPHm_l6?NaW%LMkc8^+V~RX{Kd6ZOezPQ_wy`M%7ew)&S9^+Tc|rQfo0y#l9y2 z^=R1;Wv6+Ak&THak4b>wph>@bsgX91pi7hEWjK~TInS{C^9al+31vuHCSxQpcLRky zNVB{VJKj&lxyE8AN<$!tdh-0d5T0Yqn}xQ*yW!}e8b}VKJK~%tG5hAmHeFAAK_W(e zJ{Ah?;PDq0Xoy-|UESpGlU=@i#|`?Q`@M&LPfr{=Pkg=Hy$~fYdgGKjoYa_j;mJvr z7xnW~(D(Kd&5#DM;pl}Q<*x;IUu#@e8{JyHS8McOl_&2doW62UUJ`X&pFA7Ay;PQk z<=ILL%ayqgx|b=mxc~7foWDN%&EXs&`V>yyUnnP!kfN24X}iAdL<*mPs;m*&A!#GK z897OEDU#MNTYC~0%4nl9OxjK-tsR3|RP_@#Bd~jfKK!8}pW_t$IT))AV1{e}=U+OO zM;8)#9!Yt4a$hwlOh)EsO0(Jr->O>kQvN23X*Wr^J39}j24$G%wG@Jt` zLPPhvb=_D^7}fUAPSs(rFV#5HKd&;LaLO`a$38mG>ph`-gtr6z;36w}B z81xm5! zA{h|KZ3qS-%fMYZ#V6uPi%7sHtlDPgzd)2Dsn}C>UQ^845N#c+ zTCg1Q`K2p9@10M9s#EA=_TI_lsbamGQcvQLCx39VOv=?;2H08E=Z7h&Myp?MUb;y? zE8PMWOnT|r*_bI46P={^UI)>z7|}?!ZH+ z;)nvL>W@>i@X2wJrz+{x&F2^j<|;Q9hA=c|GxA(>FwNJlP*@+I0;&mADQmI=iV(ih z;{^!?&T_Md6&qbj;Y?&u15(eh(&iuk{FBTM<;CfViMbChso_l; zI1wCrLKHet$DCAFIWXIA1K!V`Kj+B~C0EX5BDKFqS0_C`TrX%>wb~dvWYPg*MfPB7 z!_r4VlV>)geL>XONh>kYCjHECnTyvkl}*w*1*vr?#-rf@?clHT_4F8&%r6+w>e;t7&J``iY?EeuD8hinT! zJv%u|L=*e*{aUG3A_vRqD^sA^qry!bnfzWn*{C#c`geowb)(WM<*WRg)k=;16B?u9b7LT`u)$!^DC~u?zFDSd{*m3=;{DrD?XjZvf*{}+R?-) zs7yo0bc4{wTvk?uO=X-&IiPmS^=?VQe!tx811C@Hfuw8Eqgz9S*Y{affMljDsuJ-*ACZLib=& zWCzYPd>$sfLd5l~Lex*5Hu46X)&_5Rcvns>ozv}CGA4zoU9x~Kf1#yGR>!ndCw!WC z4*7&khttC%Tc;pC8CwI+K}U!_!a3p-1!JU+{x^)SkHUGW#LY5ih5h7lv(oAjFO(W^ z2!Sw(fhcy{zrE?*bolqmS8K(3queaz%LjXh)nW}kd+k1C7TJww48teIO|ZmBN1Uf~ zgk5RY7$%N6HeeviFrCKsq4d1OZb`7@@X2#_W}Y5wu6ju5u*R=U;p~oufJjrDzKuZZ{Cn^f6u+} zdZi!!FS3-lW6=nl41EBn>!(&9L*3l+(!wg)KdoA_(1s^F*eEi8m|+n&d$a;g+-h;tqDZCyc!o7Ed%k!V=Xq+f(6>=Y_pt+XRYFJ;?}#(I(2sK zpE3Q^B85&1KC$bOc#il4%j>JpbtENUt%6XlT45Q^dC~d2Y7bh(1#Gd+mh$KMi}b}2 zou8(kRjz|!qh>05rsM;EC>rf{kx+y*lfKaBX^27(Q`zL+F;yq7Y;Z&w!BZ)=&^%8U zXy>CU3ZG1)z$af!0s--)D-}5D!>3-tK>`WAx%qL$w6X@4zYH!v4xp7w+7kFsDzR-a z#jK}3g!cLX@q|xKr^?a8ci@Cf_~gZK)lD40iGHpyM7*&>DG(;r zZ?nM8I_W1}4Zz8BWp#@S=5X%3B-l<9rvoH_(-A!aQR7pKWNpiFO1HTwW>;jSJ`iGd zktsfzB!W+dG5PDw!zUw|);MQy8lP>8h4DuCwPd1CJ0 zaqBLgWXri*0Xz=(IWr%H!ZCb0uw~Cl#!}L{aODKf=uQ++aqCab{kuyjDvGWmxg0Wi zfz`vkV;F`^M>NYF*{4|z%I(A{NRi{>xwf*g$cC1w*-7GD26ot}H8#PMV-*cr$``e6 zkVKo!)T$*LnJ3lO;&xiQpqBEP_$1{{RF2Uss?+Hc>-6qM2At&ZgT*G6%=a9r_%s`d zCofV|@!6MWw-=&&@rkdee9udB;D{cbmuLgV-i>pw!Nglab(Yh<|M>ddhnIi7^IH!8 zVCLx6tKVL}{EeC7=P!Q!9xlv)E+Oo+S=yxkzo z_7B=W4sGM{a0@qKkr3s;Ny1Y(PdeFb`jUi_JiD3r)ZvqDs|_5z<&-QY;_#`HCpjgZ zJW0iCmVrJcTTP?oa>JaG)^^zy%9cR3q9Wvr?}m`8{^EB zy;29MYOabE&x$g>M=}+9>JpLU`AM#HUM*zGIliqpMN^!m)0kuwJ4tM}Hfo&XR=6_; z_UU*z+mGYo$(_cxHX^K=WFru_NDwTzeVSBgYkLK#ly0nsBI}XpCiVQo!~OHK^hE*7 zTPX3}WiuPv6 zY~PyEnQu*`&T31P^0!B4Da67jA5tf+GzMjwpsc3PyEc~Fc4*#}FKt|=a}|%rN6%@d z|IC6rg6Eee=N2azub7=1o1Gn-nf*9D^I;OCC*O^8iOd+r7}B2~Xi1`m{sA&y(hoQM#oM@T8;xgArnL`EP_wlo}>%b>7Wy$z^OZ5SRJ5y2CLe2skEndbvmEwlV|z% z6FAi&ALNuYgsb5FXFkF5Klr2r6Fzh4g7Zl#9y{Dm5w;)17#uo1WRjiEWHRW)C%=hsnxA^`;Go}cW`@ob>F{wz<9a7{#vQgfmvc%1n;-k-!WfKqQfUN%7Sw# zY0^Q@GNl|xWkKA;(Nu_b)lZ_XJbFi^pBPwPH#;}Yw%M>SDpuP+50bRRr;?&(?%$=N zd`QnT4SPcO5=0>rAhj7uiw)OUIHPqmex3S~w!+G6Ard>07FKlSklVcW%dK;}`Z8Az z@i$2@zPv`3iRj#o@O^S_etd?uJ=xeKml3mXnN5r&rp6g1e)HG+SAV^K`R8BHU;p{X ztJlB1eD&Llm%l!L{)>e91)D}fp@j44Se_haPmgkX!lb1-HB1yNl9e|%IBjo|B{_+P z2-R)xoI-Un@T{FtD_x;U93;)OXq_ZHhIo2p1kwI44}pUCz%tPmCesjFD}lm ztjw>iEpBXZEhBg0u%!nHJ){XglS?s?RH)|4jbg1`hP}>Z7u0CH~ z!`qjeo3FRG-$!45_;f@yMPfTlY|9x!Dki-ff5d7atpT6VsD)iry64w; zcR1%4SzP>|d@inREv{~3OKTwvGB>uPJpF}!v8T4V9erwRL_JT9^Cx$JVnp#QVp`*F z<+YiW)#;_>sYPx{Sj5Gzu7+4Yi-oom;Sh7*?9Gs|1PqIDwHBl9G5Y5j1GnKL1d7EA zM`y>!8I5YPY=MC|PNWLwgZr$JR`k;iR^1rbG;Xz3slv5H8r8Jz#}ZY$aYI)d=%N9u zds1DJv0KR+>zl7Px8H8>zTXA*ntl$IbHpbvrlJn2m7hduz^B^tf`;d2_qN%APkYMC z-!wZeo7W<9Wajtzb8#4uuQw*WCkhn}! zH>#tWgU$1W+ zxo>xOKcGv1J;)yJ|9QCk`~Lp#ySu-yuf9Iq{J_55efx6z?d}=~|Ng>{-u?hrfc$d% z<+s{E&oO^&0INMJoTeD=FM^Fl#sZy7W`D60-PfCIEKsn~Hn98aZx7es?ykPOK?^^0fAbyE z3@{ku{l|knZ*IO{4L;vrfB$^@PvPkt75d-LPo?9M^G z)-QW|{X>ra8qUgH&9`97&l$cJCO71^O*SD z08w6saBeMtC1$HQM{usP_lUddHp0s++=fgyDW~`ZPUq9%WT7#a5SbDtq0S95q15(JQ>P%P zO;k=a1eR4>hN-~~DwtqqJ@7Ph+6x&@s}OPcRG~yh#Y9HK`ID-OYAc<)LGR&q@Rg=q zE|-B%uvDGp@^g^!zG5%pSLGP{{Bu8C5BTDT+pEvF?5`VqyB&PL8+^af;>54;X%tEK zc!AXid-5Si-23aVg7Eeml#jzT9|^;)V!sruP66*UQk&!P7hnb^H| z>*3@q#Ib8gqnXxId$m(a4xT~K--KKZjOt(3@f&|83j%d zeZpsSeJi%H1)N5yd3KbOTh6s`8`r$68?xLO3N~Z!$4NYX3Y;jXizkB2SAu0SnQ}^< zPnsA{jtxDap zx`c9Dhf64wN=UH*-%uFG(P8v7MD&sniDbS^zFtBqO1<|f2<pCe5@=I}8 zrL*_?QeKieHFh)ja>LQCk9|cgNhID~eYv}WOu=~@*biO+!?-XrP?Hsl)2sKTwTv1jYEdJo(iO(ZBgnpFvk|p;Ri(3uSa}+CuO-)AB!W zXu)w*nNKHk^fWoupH8(=oc&Hbwv04b>ZBHNhgb;fV0IEo*~-0 zX;8N^M9JVGr}%n5j*3q-6Y(6WDCNi{X(ne*xpg~pF0T;~DJEK#TJCIzV>o&!8Y$<- z1}(Dix$9&Cr}HT|Bl~XR6Eb5*ZqiJ%M1l#06mTZ@b>R!YEdHHI4G`75hK&h}Oj~zM zD*j0wGYHJBJ&CjudCsaznF`N+dncD?akgapoTWNBab48Z8&8wGO$`Tps{NR|hpfnM za9XJdFK@C*XAb#2EiAHhpJkco*x|38)g182URm*(E?l-B;FE+Qi0TxlEys_1!s_i6 zh?-hneS=BJyeHVX<|*;S3lI7H8?a(7*jf@QFFwn{g2dlkiN72n@`I0eD_H_loMe-ZMttJa(NCUiHULrQbB$)O$R2!-#1s7_AG@sqqbsaWTFf z=%-yp#NQa@Y2P`_^5MX^hQRowRdUe19dtQo${ziD_g>0rc0=GZ&_D52AG3GklYe(V zdEQ_Djd;SR#MAsc@Bju9`f&RXdgwk{j+;CZd_wZbxjUJGm;Yx7?LSDUGbxg9byj;IxS+o7^dzPw8)6%frw`Sr|x{=*r_Hu>!VW%sb_(_)Y1$@jZYB0 z?{^SmtX)fB!qe5*+nM4-YB}i;Up=L08+=r z+rLH5_4lvh6U{W)9Eqp2)cyNEBumMo-rxNgWmDbndz^*$S9%IQZ@*uY=T|0Q0JHLo z);OHL?8dg@UvXgOD53)if1LkRQU8qiG&3#5%X`wvDTP?;B+=dyR8(?`mUgeCs4}n7 z^St8}iWFcZ@Eh%*!-S-0#ZsfZ4EZG0i3Mj)MeA!6iNq&9-Je9_kjZ-hCvD-Ljc0zr zOGTk5F_Ap`PC`aACkgporPE<@7_c8H+i85FpESdJ<1v|Y>O_S3!0D^K98P*Wb><9| zllfUL+OYDvAu2e}eiBatb}fykh$;P)0jGLmD;+TADgD&ue|?50d1$C87nUfkdlIC)xN<$Ri`k|w?V zeq+HD$s+i~!@}ydQ)+zPOX@8-X5FEp^lHfJ2u?ofeA=|K!x=>P5>karz)7OsR8*i^ zT@3y7pkAPIlu{tC?ESzI#ks?0%_P(-L=LB7B7C~;!wTRW@d<&@NX$Nhlb1j?iPlMY zQY{L{fzwi*Nk|KG!=PfKKsjL&lXBwLjZ9?I`Q%!nMB)VT#Mc9=7ASG@Jd$bCf);#H zrX=ABoFIy9>e@kj27LO-Q_fvZ-1*dvD%Jra@#KYEsPpMhK()JlhkP2M0iOmZd|o!M zx)^yR6Hn7j8rlucuHgKcPjZ{ir($8}(_$ij5A+iU3ZJ6U0wRlvVDcX*RfbbJA~HpS z7N-nXGG(6#k;u=3?%!YT|FIOPA!_f&p_J2KTt)reeg$c)YcIbPf(-d2vYgNVmQV#y zgRk(3c=GKAnfj*t|K>B0&|wbWB=nI_Lli!}uB1%9#8Z5dy*EDFI(+K<`Gn7fph&dA z*;2;glm6i~Ws^)WRVt#O`RLirzYALP?AzP%ZR$kKy6V-&$wS{r=v~TXLST=n6Qy)P}4}ggocK0;2wi%rnJ2ADPM0c-qBLZ^xFCS=fC&_SA>*P zYrrj8Q{aSQp6=FzgMod>8I@0dR&DeLD8eTa%5V@NHemBVDX7}>eKh#ueLgLea`%cSgUm=M)lZd~>?sM=BQ`hl+1{co?Ya|rqq)M*KvyQT||AG+nu z{JV9~1e0afs>NUKBw~KY0qvueV?C zteB3n2}^r^zWcWcrkps*C4Sw=pOmOt znv`lO?|0Y#@Qr{_=Sv-o-&)6yq47sh9!!)9RN^@93;Rz*p_GjMFe$2osF@P@NT`i9 zc@E!|Q`x899X(DQMEy9b#u6eXHRE~E#8X{Q6ho2FClz)MpW@RIm3SJTo1r*eA4`;q zHY05GQK%loMA1!EGgW7Y%y2l#u1HVCE1@Jl4`U-Z&ABTNZ-yTa_~b&jgL4H_p%_@| z}IYlY(XoCTXaX4eaC@U>U#}@QD&SpRlUPS8ysJe}m?z$WEZai-ko` z`1G2iA3@1&TI7PJ>BSG979W8e;Gv5D1}c6v2l5G}|NeZdP7=OAeBS+UW7Xk&!l&Xa znIS4-)m7qzTWHVcJDq#(ekGkdf|D10e<{6SnvXlMJM8@E@)M=Few$j7mJa1K;M3Ag zq(fauK@{U%r%108Hy)dK4jYg0>@u5I zRb<3GyQP&lbE2HM^&l*=4o}ibK4F9(uW>71u7Qd|Cb@JnOPoB($vdCG$+45cBA+cX z&rahp_gYfEgiJS%omAV0%4z+O9>DT1$i*w@Cx!9{MHVKW_OHpmtnq1H(v(yG=yvjy z`?f-)zaX1|3pPY8^9e}sNh~jg{>`EG!`HSyF}ntr;Lny)u*O+R&l9Z4vk zQ5x#Oe;tDs{X|I7&qAsFlu!O>fk{P&x@w&R#^;lMr%}XYF9D^#;>i)U!H|H@AbSs= zSB5BV9p^sc(^Zt?=yknyjc3l6J9UL!bp!K^EuW2g8$Q->R5md;WoJ*|^7dsZDCJL!$L zZ2XWtI&~r<}Xsh`FZW`>htGoDwyzzY|6Rc%O}bxyYpo@bcfSCJ9$V2@35gb$j*ewnja2%n%2SI zzd0YGr5HaK8%d~r5^0reN;v^ltm5C{mRu;|lGQ`y=mW#cgQZ-&GEsW+yZHYAo+Kg9 zvo*>Mk6!*p-xPrjl&7Vq#p1sIO5Ix+rEgeXh7r9o_8_W$X6wDTSYG8M_T%Xks;+ww TwbG}-sYEEs>7e4`vFrZ>i_-Ka literal 0 HcmV?d00001 diff --git a/src/decoder/testdata/rgb_6x6.astc b/src/decoder/testdata/rgb_6x6.astc new file mode 100644 index 0000000000000000000000000000000000000000..8a70c0fda6f0e57e41e3d5981284d91738496e2d GIT binary patch literal 29200 zcmX6^2{csi`@eT)F!p_`WM&K@yGoLs?8}gZuY{C+EFp=ZQm7%a2I=qcRL}U(7nyH2tHZIe2Q6!3bHm`;jXmYLjzW$^_2#wFnJ$pJL8mjB7M5)x zDEfv{S#O5_;Y)KicT{2i%6j{dM!JqhmrZ0AC;MT>6!{S@(x!!225+Lw;cP7W4I7 z>I1yezNvxdzx#iUl$^DyZ{T;|SF~&17+V-y&Fq_Al!&`5X>a#$fBpQ|cjy-O>}tDZ zc+$%7L}xn-;psZ_=g1|dJsR!xUHl|&rcjeSNa~L;;I+2U-m3*sx_(u&d6c(Qj^=!4Evi&6U+JT&eUg1mZ!#K|nXw zWjn0=#nFi3$Tu~`j~;oFJE|K8zklDYdq3%D5}`vWfLs2#efXEpxvrJykud+qH7%ax<>9&h_BYyv#G0^! zxS?*WVdQb9peP|A!!`lIj)e5NIoP>8u|l^fC8?p=8Kj-5znn8wF;azb^JOzB-=>LB}=yb_tn( zx;HJ*Ab;}7Km7kq#2!$WAAOCa-lQ3V;QX)px&G6N+MhrD+AohGZH�f&Uft**^6@ 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

W%ZaXlfeJ zJ+6niaO=jo8_d=DDT#`D(FXHZbpIM%n?y6)M@06UB$9MBJk&?`m<&9Ac0H5ijLoW zaF{cT{RL)o+{ng#RR=fd%^T3w11{9N%7uW>A3T5i`Yn3%@_XpngVz+nN#)ry#2{jw)^>HQ9()- zw9w1POou+ad-d+worB%=J#^*lm22m&T|Z9(EAsK}N}j1@x;g~njGWo=OLx=xiYtXYW0lROWL_8`NS=0 z;2`-VGrG>DUH>$nu!`P;Q@oXN|Hu<2AKhk?l%9BOMcu!5{a)be3a;2-Jqk*{%_k{8 zy+Lk^n^~TSqw9}8fy^71A3nbOirvp|^U3-Zgo~LlzRf*ES00Mns}F8*6Ry&5@;sN} zURJIgJ=o>g^`Xw}oIkyJc6((T?QiX0*t-Cz>!(o6U_@d#m#(pWe3i zu6AxCo?e_;+2poC{B!vfOeQ3yC8*PpIyEa@Q;?FSfysb{o(u`bIeF39rl6n#IP>!K z7^yVRyu30^P6l_*G6|+z=5gnYt zKj9Oxqr|PUJn_$q`=`%rGvVBtnOH}7DSR%@Y_jykb`lqKNpu(r< zAFdeh!y6w7(K+_+3tUuOl*#p)H$H^V5ASolNWw`G)MuC{6tS)akZj0uPz4|_?q5GR zb%hS7JlV#DNp5GRhYv1_mmo%V#g&xNzg<#hZ(BG+*T> zwSHm$(zWyS3b?`YI2(l|Bb0eSAc%_8=G~6DD3X8pQW)kDIFEZg;(LcK7`D+U^cFuPtqFEOHUXCWYwJBXdOUfv%w*UvH;SB?QZUWrQh5Pd=lLGw(IkoG4X21 zOiIm4PSaqX8Jfb3TrEqXfh|t>jE;_`5ff1!EH#>voSahpQ}T&!F2m`In6H@Hx;u2BM>Vlkf9MWAKS3$>((rb#S@I^48qcI$k~1e{8v@0Z+hfQ4eD_ijFw zwNFs`(*OW!#sl};S2*jU`&UESs9Mu;aFm#dUqgbkL<^H>MH;Dlzmw}o@%Lo-9&W4-=C zUt5>2%@30vyU%U&BA3+zpTk}K?GB&Y>h?R^iSPI)d?J&v)nc;S%x(78Hg0$y=pH7x zFU_nH-5`tZ&6aX)^+%0ShJ2v*^^-J~+^&l#a00L?R#X&&d@T>oH8o zJhi@q2KttZ%0?^ooTFbq$|sBP@F|@W^Hiezb;!g#p%ge7JmikEv)5TMo*tQAnp(QB zdjTNN?;M<3+?XF4AM`lY&pgO{ouV2pbm%P8G?y=!=JxO^Sm^27qOm#Ov;=dzGNT+J!G<5K2~He{wbec&-}0D6C+h>NX{uUPbQxt zGa^Oe5@Zhj5$G8JBq{vt>}*j{QBF=yO-+rfzTR(Yaph;W=cIRKr}br~E)}NDYE#DZ zk_R+NU0DgfjQCcK#;z}Sx7e7y`@4oZx%GZvVqtn^cjL_Yy({eUgD7O)<<82B_wHVP zaBlbN=}r7(b7N)q?CzyY%r`FFA=$rk{X^!T*DpOl0?q?A@2)8^{U&8vOVg_ada)xw z5Pt`!7$`BF0S!HHQOPGQXZZ?EhGnx9$o&2n-)GuMh(9=WFxWE)pRJb0?X~RypX_c+ zIH{FDsdMV8dp%?T`j2=S2vaU3+>-@eFaoFAjx?&c}=#qHZ@eSF+vG?wJ&Bbz$NmlM^mPoFUv_WOOe zSLa`EEJ?jsoP5;px#Ox|&dpsZQwez*S9+YtgY7Ho>>L^&UtFaj&(@jM)l-X$n`nA^ zxxath=^U)AG&vjty}e5V1FKV0XRclR@IBqQ^nje`?zJadYiCD>7uW)j7tL^g0UJ_s zA4;-HLkT)8i4}XMd?KcQ`S$g95L-fGeV&~9#oIeqZy%gKv$MX@*X7MCjH62I(JjgW zzn}yi(G-q80LqRbJ$%G5K-pbE6pkv}qdZ?7dA)r3^2w7YkFPvNpWOT8=9!z5{gW3d zCR*BCpIVYINH0rhn>!j_V&Jsi3PCC&Mqt~t7~j@N$u@iM;8z7-@3*P8lNL&XNu(FB@@xx zSGcnm$(n;MPHrY19niET2$1^CB!Eb z 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 z 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 oyi%I=Rq`S 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 NQAgv#!r +// +// To dump statistics on a specific block in an ASTC file, use: +// astc_inspector_cli + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "src/base/string_utils.h" +#include "src/decoder/astc_file.h" +#include "src/decoder/endpoint_codec.h" +#include "src/decoder/intermediate_astc_block.h" +#include "src/decoder/partition.h" +#include "src/decoder/quantization.h" +#include "src/decoder/weight_infill.h" + +using astc_codec::ASTCFile; +using astc_codec::ColorEndpointMode; +using astc_codec::IntermediateBlockData; +using astc_codec::PhysicalASTCBlock; +using astc_codec::RgbaColor; +using astc_codec::VoidExtentData; +using astc_codec::base::Optional; + +namespace { + +constexpr int kNumEndpointModes = + static_cast(ColorEndpointMode::kNumColorEndpointModes); +constexpr std::array kModeStrings {{ + "kLDRLumaDirect", "kLDRLumaBaseOffset", "kHDRLumaLargeRange", + "kHDRLumaSmallRange", "kLDRLumaAlphaDirect", "kLDRLumaAlphaBaseOffset", + "kLDRRGBBaseScale", "kHDRRGBBaseScale", "kLDRRGBDirect", + "kLDRRGBBaseOffset", "kLDRRGBBaseScaleTwoA", "kHDRRGBDirect", + "kLDRRGBADirect", "kLDRRGBABaseOffset", "kHDRRGBDirectLDRAlpha", + "kHDRRGBDirectHDRAlpha" }}; + +//////////////////////////////////////////////////////////////////////////////// +// +// A generic stat that should be tracked via an instance of ASTCFileStats. +class Stat { + public: + explicit Stat(const std::vector* blocks, size_t total) + : blocks_(blocks), total_(total) { } + virtual ~Stat() { } + + virtual std::ostream& PrintToStream(std::ostream& out) const = 0; + + protected: + // Utility function to iterate over all of the blocks that are not void-extent + // blocks. FoldFn optionally allows a value to accumulate. It should be of the + // type: + // (const IntermediateBlockData&, T x) -> T + template + T IterateBlocks(T initial, FoldFn f) const { + T result = initial; + for (const auto& block : *blocks_) { + result = f(block, std::move(result)); + } + return result; + } + + size_t NumBlocks() const { return total_; } + + private: + const std::vector* const blocks_; + const size_t total_; +}; + +//////////////////////////////////////////////////////////////////////////////// +// +// Computes the number of void extent blocks. +class VoidExtentCount : public Stat { + public: + VoidExtentCount(const std::vector* blocks, + size_t total, std::string description) + : Stat(blocks, total), description_(std::move(description)), + count_(total - blocks->size()) { } + + std::ostream& PrintToStream(std::ostream& out) const override { + return out << description_ << ": " << count_ + << " (" << (count_ * 100 / NumBlocks()) << "%)" << std::endl; + }; + + private: + const std::string description_; + const size_t count_; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// Computes a per-block stat and reports it as an average over all blocks. +class PerBlockAverage : public Stat { + public: + PerBlockAverage(const std::vector* blocks, + size_t total, std::string description, + const std::function &fn) + : Stat(blocks, total), + description_(std::move(description)) { + int sum = 0; + size_t count = 0; + for (const auto& block : *blocks) { + sum += fn(block); + ++count; + } + average_ = sum / count; + } + + std::ostream& PrintToStream(std::ostream& out) const override { + return out << description_ << ": " << average_ << std::endl; + } + + private: + size_t average_; + std::string description_; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// Computes a per-block true or false value and reports how many blocks return +// true with a percentage of total blocks. +class PerBlockPredicate : public Stat { + public: + PerBlockPredicate(const std::vector* blocks, + size_t total, std::string description, + const std::function &fn) + : Stat(blocks, total), + description_(std::move(description)), + count_(std::count_if(blocks->begin(), blocks->end(), fn)) { } + + std::ostream& PrintToStream(std::ostream& out) const override { + return out << description_ << ": " << count_ + << " (" << (count_ * 100 / NumBlocks()) << "%)" << std::endl; + }; + + private: + const std::string description_; + const size_t count_; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// Returns a histogram of the number of occurrences of each endpoint mode in +// the list of blocks. Note, due to multi-subset blocks, the sum of these +// values will not match the total number of blocks. +class ModeCountsStat : public Stat { + public: + explicit ModeCountsStat(const std::vector* blocks, + size_t total) + : Stat(blocks, total), + mode_counts_(IterateBlocks( + {}, [](const IntermediateBlockData& data, ModeArray&& m) { + auto result = m; + for (const auto& ep : data.endpoints) { + result[static_cast(ep.mode)]++; + } + return result; + })) { } + + std::ostream& PrintToStream(std::ostream& out) const override { + const size_t total_modes_used = + std::accumulate(mode_counts_.begin(), mode_counts_.end(), 0); + + out << "Endpoint modes used: " << std::endl; + for (size_t i = 0; i < kNumEndpointModes; ++i) { + out << " "; + out << std::setw(30) << std::left << std::setfill('.') << kModeStrings[i]; + out << std::setw(8) << std::right << std::setfill('.') << mode_counts_[i]; + + std::stringstream pct; + pct << " (" << (mode_counts_[i] * 100 / total_modes_used) << "%)"; + + out << std::setw(6) << std::right << std::setfill(' ') << pct.str(); + out << std::endl; + } + + return out; + } + + private: + using ModeArray = std::array; + const ModeArray mode_counts_; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// Counts the number of unique endpoints used across all blocks. +class UniqueEndpointsCount : public Stat { + public: + explicit UniqueEndpointsCount( + const std::vector* blocks, size_t total) + : Stat(blocks, total), + unique_endpoints_(IterateBlocks( + UniqueEndpointSet(), + [](const IntermediateBlockData& data, UniqueEndpointSet&& eps) { + UniqueEndpointSet result(eps); + for (const auto& ep : data.endpoints) { + RgbaColor ep_one, ep_two; + DecodeColorsForMode(ep.colors, data.endpoint_range.value(), + ep.mode, &ep_one, &ep_two); + result.insert(PackEndpoint(ep_one)); + result.insert(PackEndpoint(ep_two)); + } + return result; + })) { } + + std::ostream& PrintToStream(std::ostream& out) const override { + out << "Num unique endpoints: " << unique_endpoints_.size() << std::endl; + return out; + } + + private: + static uint32_t PackEndpoint(const RgbaColor& color) { + uint32_t result = 0; + for (const int& c : color) { + constexpr int kSaturatedChannelValue = 0xFF; + assert(c >= 0); + assert(c <= kSaturatedChannelValue); + result <<= 8; + result |= c; + } + return result; + } + + using UniqueEndpointSet = std::unordered_set; + const UniqueEndpointSet unique_endpoints_; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// Computes a histogram of the number of occurrences of 1-4 subset partitions. +class PartitionCountStat : public Stat { + public: + explicit PartitionCountStat(const std::vector* blocks, + size_t total) + : Stat(blocks, total) + , part_counts_(IterateBlocks( + {}, [](const IntermediateBlockData& data, PartCount&& m) { + PartCount result = m; + result[data.endpoints.size() - 1]++; + return result; + })) { } + + std::ostream& PrintToStream(std::ostream& out) const override { + out << "Num partitions used: " << std::endl; + for (size_t i = 0; i < part_counts_.size(); ++i) { + out << " " << i + 1 << ": " << part_counts_[i] << std::endl; + } + return out; + } + + private: + using PartCount = std::array; + const PartCount part_counts_; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// For each block that uses dual-plane mode, computes and stores the dual-plane +// channels in a vector. Outputs the number of each channel used across all +// blocks +class DualChannelStat : public Stat { + private: + static constexpr auto kNumDualPlaneChannels = + std::tuple_size::value; + using CountsArray = std::array; + + public: + explicit DualChannelStat(const std::vector* blocks, + size_t total) + : Stat(blocks, total), + dual_channels_(IterateBlocks( + std::vector(), + [](const IntermediateBlockData& data, std::vector&& input) { + auto result = input; + if (data.dual_plane_channel) { + result.push_back(data.dual_plane_channel.value()); + } + return result; + })) { } + + std::ostream& PrintToStream(std::ostream& out) const override { + // Similar to the number of partitions, the number of dual plane blocks + // can be determined by parsing the next four fields and summing them. + const int num_dual_plane_blocks = dual_channels_.size(); + out << "Number of dual-plane blocks: " << num_dual_plane_blocks + << " (" << (num_dual_plane_blocks * 100) / NumBlocks() << "%)" + << std::endl; + + CountsArray counts = GetCounts(); + assert(counts.size() == kNumDualPlaneChannels); + + for (size_t i = 0; i < counts.size(); ++i) { + out << " " << i << ": " << counts[i] << std::endl; + } + return out; + } + + private: + CountsArray GetCounts() const { + CountsArray counts; + for (size_t i = 0; i < kNumDualPlaneChannels; ++i) { + counts[i] = + std::count_if(dual_channels_.begin(), dual_channels_.end(), + [i](int channel) { return i == channel; }); + } + return counts; + } + + const std::vector dual_channels_; +}; + + +// Stores the intermediate block representations of the blocks associated with +// an ASTCFile. Also provides various facilities for extracting aggregate data +// from these blocks. +class ASTCFileStats { + public: + explicit ASTCFileStats(const std::unique_ptr& astc_file) { + const size_t total = astc_file->NumBlocks(); + + for (size_t block_idx = 0; block_idx < astc_file->NumBlocks(); ++block_idx) { + const PhysicalASTCBlock pb = astc_file->GetBlock(block_idx); + assert(!pb.IsIllegalEncoding()); + if (pb.IsIllegalEncoding()) { + std::cerr << "WARNING: Block " << block_idx << " has illegal encoding." << std::endl; + continue; + } + + if (!pb.IsVoidExtent()) { + Optional block = UnpackIntermediateBlock(pb); + if (!block) { + std::cerr << "WARNING: Block " << block_idx << " failed to unpack." << std::endl; + continue; + } + + blocks_.push_back(block.value()); + } + } + + stats_.emplace_back(new UniqueEndpointsCount(&blocks_, total)); + stats_.emplace_back(new VoidExtentCount( + &blocks_, total, "Num void extent blocks")); + + stats_.emplace_back(new PerBlockAverage( + &blocks_, total, "Average weight range", + [](const IntermediateBlockData& b) { return b.weight_range; })); + + stats_.emplace_back(new PerBlockAverage( + &blocks_, total, "Average number of weights", + [](const IntermediateBlockData& b) { return b.weights.size(); })); + + stats_.emplace_back(new PerBlockPredicate( + &blocks_, total, "Num blocks that use blue contract mode", + [](const IntermediateBlockData& block) { + for (const auto& ep : block.endpoints) { + if (UsesBlueContract( + block.endpoint_range.valueOr(255), ep.mode, ep.colors)) { + return true; + } + } + + return false; + })); + + stats_.emplace_back(new ModeCountsStat(&blocks_, total)); + + stats_.emplace_back(new PerBlockPredicate( + &blocks_, total, "Num multi-part blocks", + [](const IntermediateBlockData& block) { + return block.endpoints.size() > 1; + })); + stats_.emplace_back(new PartitionCountStat(&blocks_, total)); + + stats_.emplace_back(new DualChannelStat(&blocks_, total)); + } + + // Returns a sorted list of pairs of the form (part_id, count) where the + // |part_id| is the partition ID used for 2-subset blocks, and |count| is the + // number of times that particular ID was used. + std::vector> ComputePartIDHistogram() const { + std::vector part_ids(1 << 11, 0); + std::iota(part_ids.begin(), part_ids.end(), 0); + + // The histogram will then pair IDs with counts so that we can sort by + // the number of instances later on. + std::vector> part_id_histogram; + std::transform(part_ids.begin(), part_ids.end(), + std::back_inserter(part_id_histogram), + [](const int& x) { return std::make_pair(x, 0); }); + + // Actually count the IDs in the list of blocks. + for (const auto& block : blocks_) { + if (block.endpoints.size() == 2) { + const int id = block.partition_id.value(); + assert(part_id_histogram[id].first == id); + part_id_histogram[id].second++; + } + } + + struct OrderBySecondGreater { + typedef std::pair PairType; + bool operator()(const PairType& lhs, const PairType& rhs) { + return lhs.second > rhs.second; + } + }; + + // Sort by descending numbers of occurrence for each partition ID + std::sort(part_id_histogram.begin(), part_id_histogram.end(), + OrderBySecondGreater()); + + return part_id_histogram; + } + + // Weights range from 2x2 - 12x12. For simplicity define buckets for every + // pair in [0, 12]^2. + constexpr static int kResolutionBuckets = 13; + // Returns a linear array of buckets over all pairs of grid resolutions, + // x-major in memory. + std::vector ComputeWeightResolutionHistogram() const { + // Allocate one bucket for every grid resolution. + std::vector resolution_histogram( + kResolutionBuckets * kResolutionBuckets, 0); + + // Count the weight resolutions in the list of blocks. + for (const auto& block : blocks_) { + const int dim_x = block.weight_grid_dim_x; + const int dim_y = block.weight_grid_dim_y; + assert(dim_x > 0); + assert(dim_x < kResolutionBuckets); + assert(dim_y > 0); + assert(dim_y < kResolutionBuckets); + ++resolution_histogram[dim_x + dim_y * kResolutionBuckets]; + } + + return resolution_histogram; + } + + // Runs through each defined statistic and prints it out to stdout. Also + // prints a histogram of partition ids used for the given blocks. + void PrintStats() const { + for (const auto& stat : stats_) { + stat->PrintToStream(std::cout); + } + + // We also want to find if there are any 2-subset partition IDs that are + // used disproportionately often. Since partition IDs are 11 bits long, we + // can have as many as (1 << 11) used IDs in a given sequence of blocks. + const auto part_id_histogram = ComputePartIDHistogram(); + const int total_part_ids = std::accumulate( + part_id_histogram.begin(), part_id_histogram.end(), 0, + [](const int& x, const std::pair& hist) { + return x + hist.second; + }); + + if (total_part_ids > 0) { + // Display numbers until we either: + // A. Display the top 90% of used partitions + // B. Reach a point where the remaining partition IDs constitute < 1% of + // the total number of IDs used. + const auto prepare_part_entry = []() -> std::ostream& { + return std::cout << std::setw(6) << std::left << std::setfill('.'); + }; + int part_accum = 0; + std::cout << "Two subset partition ID histogram: " << std::endl; + std::cout << " "; + prepare_part_entry() << "ID" << "Count" << std::endl; + for (const auto& hist : part_id_histogram) { + part_accum += hist.second; + if ((hist.second * 100 / total_part_ids) < 1 || + (100 * (total_part_ids - part_accum)) / total_part_ids < 10) { + const int num_to_display = (total_part_ids - part_accum); + std::cout << " rest: " << num_to_display + << " (" << (num_to_display * 100 / total_part_ids) + << "%)" << std::endl; + break; + } else { + std::cout << " "; + prepare_part_entry() << hist.first << hist.second + << " (" << (hist.second * 100 / total_part_ids) + << "%)" << std::endl; + } + } + } + + // Build the 2D histogram of resolutions. + std::vector weight_histogram = ComputeWeightResolutionHistogram(); + // Labels the weight resolution table. + std::cout << "Weight resolutions:" << std::endl; + const auto prepare_weight_entry = []() -> std::ostream& { + return std::cout << std::setw(6) << std::left << std::setfill(' '); + }; + prepare_weight_entry() << "H W"; + for (int resolution_x = 2; resolution_x < kResolutionBuckets; + ++resolution_x) { + prepare_weight_entry() << resolution_x; + } + std::cout << std::endl; + + // Displays table; skips rows/cols {0, 1} since they will always be empty. + for (int resolution_y = 2; resolution_y < kResolutionBuckets; + ++resolution_y) { + prepare_weight_entry() << resolution_y; + for (int resolution_x = 2; resolution_x < kResolutionBuckets; + ++resolution_x) { + const int count = + weight_histogram[resolution_x + resolution_y * kResolutionBuckets]; + prepare_weight_entry(); + if (!count) { + std::cout << "*"; + } else { + std::cout << count; + } + } + std::cout << std::endl; + } + } + + size_t NumBlocks() const { return blocks_.size(); } + + private: + std::vector> stats_; + std::vector blocks_; +}; + +std::ostream& operator<<(std::ostream& stream, const RgbaColor& color) { + stream << "{"; + constexpr int kNumChannels = std::tuple_size::value; + for (int i = 0; i < kNumChannels; ++i) { + stream << color[i]; + if (i < (kNumChannels - 1)) { + stream << ", "; + } + } + return stream << "}"; +} + +void PrintStatsForBlock(const PhysicalASTCBlock& pb, + astc_codec::Footprint footprint) { + const auto print_void_extent = [&pb](const VoidExtentData& void_extent_data) { + std::cout << "Void extent block:" << std::endl; + std::cout << " 16-bit RGBA: {" + << void_extent_data.r << ", " + << void_extent_data.g << ", " + << void_extent_data.b << ", " + << void_extent_data.a << "}" << std::endl; + if (pb.VoidExtentCoords()) { + std::cout << " Extent (S): {" + << void_extent_data.coords[0] << ", " + << void_extent_data.coords[1] << "}" << std::endl; + std::cout << " Extent (T): {" + << void_extent_data.coords[2] << ", " + << void_extent_data.coords[3] << "}" << std::endl; + } else { + std::cout << " No valid extent data" << std::endl; + } + }; + + const auto print_endpoint_data = + [](ColorEndpointMode mode, int endpoint_range, + const std::vector& encoded_vals) { + std::cout << " Endpoint mode: " + << kModeStrings[static_cast(mode)] << std::endl; + std::cout << " Uses blue-contract mode: " + << (UsesBlueContract(endpoint_range, mode, encoded_vals) + ? "true" : "false") + << std::endl; + + RgbaColor endpoint_low, endpoint_high; + DecodeColorsForMode(encoded_vals, endpoint_range, mode, + &endpoint_low, &endpoint_high); + + std::cout << " Low endpoint: " << endpoint_low << std::endl; + std::cout << " High endpoint: " << endpoint_high << std::endl; + }; + + const auto print_color_data = + [&print_endpoint_data, &footprint](const IntermediateBlockData& ib_data) { + const int endpoint_range = ib_data.endpoint_range.value(); + std::cout << "Endpoint range: " << endpoint_range << std::endl; + + const int num_parts = ib_data.endpoints.size(); + if (ib_data.partition_id.hasValue()) { + const int part_id = ib_data.partition_id.value(); + std::cout << "Parititon ID: " << part_id << std::endl; + + const auto part = GetASTCPartition(footprint, num_parts, part_id); + assert(part.assignment.size() == footprint.Height() * footprint.Width()); + + std::cout << "Assignment:" << std::endl; + for (int y = 0; y < footprint.Height(); ++y) { + std::cout << " "; + for (int x = 0; x < footprint.Width(); ++x) { + const int texel_index = y * footprint.Width() + x; + std::cout << " " << part.assignment[texel_index]; + } + std::cout << std::endl; + } + } else { + std::cout << "Single partition" << std::endl; + } + + int endpoint_index = 0; + for (const auto& ep_data : ib_data.endpoints) { + if (num_parts == 1) { + std::cout << "Endpoints:" << std::endl; + } else { + std::cout << "Endpoint " << (endpoint_index++) << ": " << std::endl; + } + print_endpoint_data(ep_data.mode, endpoint_range, ep_data.colors); + } + + if (ib_data.dual_plane_channel) { + std::cout << "Dual plane channel: " + << ib_data.dual_plane_channel.value() << std::endl; + } else { + std::cout << "Single plane" << std::endl; + } + }; + + const auto print_weight_data = + [&footprint](const IntermediateBlockData& ib_data) { + std::cout << "Weight grid dimensions: " + << ib_data.weight_grid_dim_x << "x" << ib_data.weight_grid_dim_y + << std::endl; + std::cout << "Weight range: " << ib_data.weight_range << std::endl; + + std::cout << "Encoded weight grid: " << std::endl; + int weight_idx = 0; + for (int j = 0; j < ib_data.weight_grid_dim_y; ++j) { + std::cout << " "; + for (int i = 0; i < ib_data.weight_grid_dim_x; ++i) { + std::cout << std::setw(3) << std::left << std::setfill(' ') + << ib_data.weights[weight_idx++]; + } + std::cout << std::endl; + } + + std::cout << "Actual weight grid: " << std::endl; + std::vector actual_weights = ib_data.weights; + for (auto& weight : actual_weights) { + weight = astc_codec::UnquantizeWeightFromRange( + weight, ib_data.weight_range); + } + + actual_weights = astc_codec::InfillWeights( + actual_weights, footprint, ib_data.weight_grid_dim_x, + ib_data.weight_grid_dim_y); + + weight_idx = 0; + for (int j = 0; j < footprint.Height(); ++j) { + std::cout << " "; + for (int i = 0; i < footprint.Width(); ++i) { + std::cout << std::setw(3) << std::left << std::setfill(' ') + << actual_weights[weight_idx++]; + } + std::cout << std::endl; + } + }; + + if (pb.IsVoidExtent()) { + Optional ve = astc_codec::UnpackVoidExtent(pb); + if (!ve) { + std::cerr << "ERROR: Failed to unpack void extent block." << std::endl; + } else { + print_void_extent(ve.value()); + } + } else { + Optional ib = + astc_codec::UnpackIntermediateBlock(pb); + if (!ib) { + std::cerr << "ERROR: Failed to unpack intermediate block." << std::endl; + } else { + const auto& ib_data = ib.value(); + print_color_data(ib_data); + print_weight_data(ib_data); + } + } +} + +} // namespace + +int main(int argc, char* argv[]) { + bool error = false; + + std::string filename; + size_t block_index = 0; + bool has_block_index = false; + + if (argc >= 2) { + filename = argv[1]; + + if (argc == 3) { + int32_t param = astc_codec::base::ParseInt32(argv[2], -1); + if (param < 0) { + std::cerr << "ERROR: Invalid block index." << std::endl; + error = true; + } else { + block_index = static_cast(param); + has_block_index = true; + } + } else if (argc != 2) { + std::cerr << "ERROR: Too many parameters." << std::endl; + error = true; + } + } else { + error = true; + } + + if (error) { + std::cout << ((argc >= 0) ? argv[0] : "astc_inspector_cli") + << " []" << std::endl + << std::endl + << "Collects the various statistics of a stream of ASTC data " + << "stored in an ASTC file." << std::endl + << std::endl + << " filename ASTC file path." << std::endl + << " block index If specified, show detailed information about a block" + << std::endl; + return 1; + } + + std::string error_string; + std::unique_ptr astc_file = ASTCFile::LoadFile(argv[1], &error_string); + if (!astc_file) { + std::cerr << "ERROR: " << error_string << std::endl; + return 2; + } + + if (has_block_index) { + Optional footprint = + astc_codec::Footprint::Parse(astc_file->GetFootprintString().c_str()); + if (!footprint) { + std::cerr << "ERROR: Invalid footprint \"" << astc_file->GetFootprintString() << "\"" << std::endl; + return 3; + } + + PrintStatsForBlock(astc_file->GetBlock(block_index), footprint.value()); + } else { + std::cout << "Dimensions: " << astc_file->GetWidth() << "x" + << astc_file->GetHeight() << ", depth " << astc_file->GetDepth() + << std::endl; + + ASTCFileStats stats(astc_file); + + std::cout << std::endl + << "Total bits used: " << 128 * astc_file->NumBlocks() + << " (" << astc_file->NumBlocks() << " blocks, " + << (astc_file->NumBlocks() * 16) << " bytes)" + << std::endl << std::endl; + + stats.PrintStats(); + } + + return 0; +} diff --git a/src/decoder/types.h b/src/decoder/types.h new file mode 100644 index 0000000..728d5ad --- /dev/null +++ b/src/decoder/types.h @@ -0,0 +1,74 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_ASTC_TYPES_H_ +#define ASTC_CODEC_DECODER_ASTC_TYPES_H_ + +#include +#include +#include + +namespace astc_codec { + +// The color endpoint mode determines how the values encoded in the ASTC block +// are interpreted in order to create the RGBA values for the given endpoint +// pair. The order of this enum is required to match the ASTC specification in +// Section C.2.14. +enum class ColorEndpointMode { + kLDRLumaDirect = 0, + kLDRLumaBaseOffset, + kHDRLumaLargeRange, + kHDRLumaSmallRange, + kLDRLumaAlphaDirect, + kLDRLumaAlphaBaseOffset, + kLDRRGBBaseScale, + kHDRRGBBaseScale, + kLDRRGBDirect, + kLDRRGBBaseOffset, + kLDRRGBBaseScaleTwoA, + kHDRRGBDirect, + kLDRRGBADirect, + kLDRRGBABaseOffset, + kHDRRGBDirectLDRAlpha, + kHDRRGBDirectHDRAlpha, + + // The total number of color endpoints defined by the ASTC specification. + // This isn't a specific endpoint mode and its sole purpose is to be used + // as a constant number. + kNumColorEndpointModes +}; + +// Returns the class for the given mode as defined in Section C.2.11. +constexpr int EndpointModeClass(ColorEndpointMode mode) { + return static_cast(mode) / 4; +} + +// Returns the number of encoded color values for the given endpoint mode. The +// number of encoded color values and their range determines the size of the +// color data in a physical ASTC block. This information is taken from +// Section C.2.17 of the ASTC specification. +constexpr int NumColorValuesForEndpointMode(ColorEndpointMode mode) { + return (EndpointModeClass(mode) + 1) * 2; +} + +// We define a number of convenience types here that give more logical meaning +// throughout the ASTC utilities. +using RgbColor = std::array; +using RgbaColor = std::array; +using Endpoint = RgbaColor; +using EndpointPair = std::pair; + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_ASTC_TYPES_H_ diff --git a/src/decoder/weight_infill.cc b/src/decoder/weight_infill.cc new file mode 100644 index 0000000..62909aa --- /dev/null +++ b/src/decoder/weight_infill.cc @@ -0,0 +1,122 @@ +// 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/weight_infill.h" +#include "src/decoder/integer_sequence_codec.h" + +#include +#include +#include + +namespace astc_codec { + +namespace { + +// The following functions are based on Section C.2.18 of the ASTC specification +int GetScaleFactorD(int block_dim) { + return static_cast((1024.f + static_cast(block_dim >> 1)) / + static_cast(block_dim - 1)); +} + +std::pair GetGridSpaceCoordinates( + Footprint footprint, int s, int t, int weight_dim_x, int weight_dim_y) { + const int ds = GetScaleFactorD(footprint.Width()); + const int dt = GetScaleFactorD(footprint.Height()); + + const int cs = ds * s; + const int ct = dt * t; + + const int gs = (cs * (weight_dim_x - 1) + 32) >> 6; + const int gt = (ct * (weight_dim_y - 1) + 32) >> 6; + + assert(gt < 1 << 8); + assert(gs < 1 << 8); + + return std::make_pair(gs, gt); +} + +// Returns the weight-grid values that are to be used for bilinearly +// interpolating the weight to its final value. If the returned value +// is equal to weight_dim_x * weight_dim_y, it may be ignored. +std::array BilerpGridPointsForWeight( + const std::pair& grid_space_coords, int weight_dim_x) { + const int js = grid_space_coords.first >> 4; + const int jt = grid_space_coords.second >> 4; + + std::array result; + result[0] = js + weight_dim_x * jt; + result[1] = js + weight_dim_x * jt + 1; + result[2] = js + weight_dim_x * (jt + 1); + result[3] = js + weight_dim_x * (jt + 1) + 1; + + return result; +} + +std::array BilerpGridPointFactorsForWeight( + const std::pair& grid_space_coords) { + const int fs = grid_space_coords.first & 0xF; + const int ft = grid_space_coords.second & 0xF; + + std::array result; + result[3] = (fs * ft + 8) >> 4; + result[2] = ft - result[3]; + result[1] = fs - result[3]; + result[0] = 16 - fs - ft + result[3]; + + assert(result[0] <= 16); + assert(result[1] <= 16); + assert(result[2] <= 16); + assert(result[3] <= 16); + + return result; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +int CountBitsForWeights(int weight_dim_x, int weight_dim_y, + int target_weight_range) { + int num_weights = weight_dim_x * weight_dim_y; + return IntegerSequenceCodec:: + GetBitCountForRange(num_weights, target_weight_range); +} + +std::vector InfillWeights(const std::vector& weights, + Footprint footprint, int dim_x, int dim_y) { + std::vector result; + result.reserve(footprint.NumPixels()); + for (int t = 0; t < footprint.Height(); ++t) { + for (int s = 0; s < footprint.Width(); ++s) { + const auto grid_space_coords = + GetGridSpaceCoordinates(footprint, s, t, dim_x, dim_y); + const auto grid_pts = + BilerpGridPointsForWeight(grid_space_coords, dim_x); + const auto grid_factors = + BilerpGridPointFactorsForWeight(grid_space_coords); + + int weight = 0; + for (int i = 0; i < 4; ++i) { + if (grid_pts[i] < dim_x * dim_y) { + weight += weights.at(grid_pts[i]) * grid_factors[i]; + } + } + result.push_back((weight + 8) >> 4); + } + } + + return result; +} + +} // namespace astc_codec diff --git a/src/decoder/weight_infill.h b/src/decoder/weight_infill.h new file mode 100644 index 0000000..4a09d35 --- /dev/null +++ b/src/decoder/weight_infill.h @@ -0,0 +1,38 @@ +// 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. + +#ifndef ASTC_CODEC_DECODER_WEIGHT_INFILL_H_ +#define ASTC_CODEC_DECODER_WEIGHT_INFILL_H_ + +#include "src/decoder/footprint.h" + +#include + +namespace astc_codec { + +// Returns the number of bits used to represent the weight grid at the target +// dimensions and weight range. +int CountBitsForWeights(int weight_dim_x, int weight_dim_y, + int target_weight_range); + +// Performs weight infill of a grid of weights of size |dim_x * dim_y|. The +// weights are fit using the algorithm laid out in Section C.2.18 of the ASTC +// specification. Weights are expected to be passed unquantized and the returned +// grid will be unquantized as well (i.e. each weight within the range [0, 64]). +std::vector InfillWeights(const std::vector& weights, + Footprint footprint, int dim_x, int dim_y); + +} // namespace astc_codec + +#endif // ASTC_CODEC_DECODER_WEIGHT_INFILL_H_