diff --git a/3rdparty/astc-codec/.gitignore b/3rdparty/astc-codec/.gitignore deleted file mode 100644 index 9e28100..0000000 --- a/3rdparty/astc-codec/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -bazel-* -.bazelrc -build -.vs -.vscode diff --git a/3rdparty/astc-codec/BUILD.bazel b/3rdparty/astc-codec/BUILD.bazel deleted file mode 100644 index ea5a2c4..0000000 --- a/3rdparty/astc-codec/BUILD.bazel +++ /dev/null @@ -1,29 +0,0 @@ -# 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. - -licenses(["notice"]) - -cc_library( - name = "api", - hdrs = ["include/astc-codec/astc-codec.h"], - visibility = ["//src/decoder:__pkg__"], -) - -cc_library( - name = "astc_codec", - hdrs = ["include/astc-codec/astc-codec.h"], - includes = ["include"], - visibility = ["//visibility:public"], - deps = ["//src/decoder:codec"], -) diff --git a/3rdparty/astc-codec/CMakeLists.txt b/3rdparty/astc-codec/CMakeLists.txt deleted file mode 100644 index 4ecb921..0000000 --- a/3rdparty/astc-codec/CMakeLists.txt +++ /dev/null @@ -1,46 +0,0 @@ -# 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. -cmake_minimum_required(VERSION 3.1.0) -project(astc-codec) - -option(OPTION_ASTC_TESTS "Build all the unit tests." ON) - -# TODO add support for the fuzzer, it has some additional dependencies we are not -# yet bringing in. -option(OPTION_BUILD_FUZZER "Build the fuzzer tests." OFF) - -set (CMAKE_CXX_STANDARD 11) -if(OPTION_ASTC_TESTS) - enable_testing() - - # No need to build gmock if an external project defines it. - if(NOT TARGET gmock_main) - # We use the approach suggested by https://crascit.com/2015/07/25/cmake-gtest/ to download gtest. - include(ExternalProject) - # Download and unpack googletest at configure time - configure_file(GoogleTest-CMakeLists.txt.in googletest-download/CMakeLists.txt) - execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" . - WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/googletest-download") - execute_process(COMMAND "${CMAKE_COMMAND}" --build . WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/googletest-download") - - # Prevent GoogleTest from overriding our compiler/linker options when building with Visual Studio - set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) - - # Add googletest directly to our build. This adds the following targets: gtest, gtest_main, gmock and gmock_main - add_subdirectory("${CMAKE_BINARY_DIR}/googletest-src" "${CMAKE_BINARY_DIR}/googletest-build") - endif() -endif() - -add_subdirectory(src/base) -add_subdirectory(src/decoder) diff --git a/3rdparty/astc-codec/CONTRIBUTING.md b/3rdparty/astc-codec/CONTRIBUTING.md deleted file mode 100644 index 939e534..0000000 --- a/3rdparty/astc-codec/CONTRIBUTING.md +++ /dev/null @@ -1,28 +0,0 @@ -# How to Contribute - -We'd love to accept your patches and contributions to this project. There are -just a few small guidelines you need to follow. - -## Contributor License Agreement - -Contributions to this project must be accompanied by a Contributor License -Agreement. You (or your employer) retain the copyright to your contribution; -this simply gives us permission to use and redistribute your contributions as -part of the project. Head over to to see -your current agreements on file or to sign a new one. - -You generally only need to submit a CLA once, so if you've already submitted one -(even if it was for a different project), you probably don't need to do it -again. - -## Code reviews - -All submissions, including submissions by project members, require review. We -use GitHub pull requests for this purpose. Consult -[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more -information on using pull requests. - -## Community Guidelines - -This project follows [Google's Open Source Community -Guidelines](https://opensource.google.com/conduct/). diff --git a/3rdparty/astc-codec/GoogleTest-CMakeLists.txt.in b/3rdparty/astc-codec/GoogleTest-CMakeLists.txt.in deleted file mode 100644 index 569f4df..0000000 --- a/3rdparty/astc-codec/GoogleTest-CMakeLists.txt.in +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required(VERSION 2.8.2) - -project(googletest-download NONE) - -include(ExternalProject) -ExternalProject_Add(googletest - GIT_REPOSITORY https://github.com/google/googletest.git - GIT_TAG "release-1.8.1" - SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-src" - BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-build" - CONFIGURE_COMMAND "" - BUILD_COMMAND "" - INSTALL_COMMAND "" - TEST_COMMAND "" -) \ No newline at end of file diff --git a/3rdparty/astc-codec/README.md b/3rdparty/astc-codec/README.md deleted file mode 100644 index 398de14..0000000 --- a/3rdparty/astc-codec/README.md +++ /dev/null @@ -1,71 +0,0 @@ -# astc-codec - -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 success = astc_codec::ASTCDecompressToRGBA( - astc.data(), astc.size(), width, height, astc_codec::FootprintType::k4x4, - result.data(), result.size(), /* stride */ width * 4); -``` - -## Building - -### With bazel - -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 //... -``` - -### With CMake - -Install [CMake](https://cmake.org/), and the run: - -``` -mkdir build && cd build && cmake .. && make -``` - -Or open the project in your favorite IDE and import CMakeLists.txt. - -### Run Tests - -In the build directory, execute: - -``` -ctest -``` - - -## Contributing - -See [CONTRIBUTING.md](CONTRIBUTING.md) for important contributing requirements. - -## License - -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 officially supported Google product. diff --git a/3rdparty/astc-codec/WORKSPACE b/3rdparty/astc-codec/WORKSPACE deleted file mode 100644 index 83fd282..0000000 --- a/3rdparty/astc-codec/WORKSPACE +++ /dev/null @@ -1,37 +0,0 @@ -# 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. - -load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository") -load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") - -git_repository( - name = "gtest", - remote = "https://github.com/google/googletest.git", - commit = "ba96d0b1161f540656efdaed035b3c062b60e006", -) - -http_archive( - name = "honggfuzz", - url = "https://github.com/google/honggfuzz/archive/1.7.zip", - sha256 = "9d420326979fed4a065fa6176d5e09bd513cd2820fe216ae8b684aa6780d72b2", - build_file = "//third_party:honggfuzz.BUILD", - strip_prefix = "honggfuzz-1.7", -) - -http_archive( - name = "benchmark", - url = "https://github.com/google/benchmark/archive/v1.4.1.zip", - sha256 = "61ae07eb5d4a0b02753419eb17a82b7d322786bb36ab62bd3df331a4d47c00a7", - strip_prefix = "benchmark-1.4.1", -) diff --git a/3rdparty/astc-codec/cmake-format.json b/3rdparty/astc-codec/cmake-format.json deleted file mode 100644 index de38ed2..0000000 --- a/3rdparty/astc-codec/cmake-format.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "line_width": 120, - "dangle_parens": false, - "first_comment_is_literal": true, - "algorithm_order": [ - 0, - 1, - 2, - 3 - ], - "command_case": "lower", - "additional_commands": { - "foo": { - "flags": [ - "BAR", - "BAZ" - ], - "kwargs": { - "HEADERS": "*", - "DEPENDS": "*", - "SOURCES": "*" - } - } - }, - "separate_fn_name_with_space": false, - "always_wrap": [], - "separate_ctrl_name_with_space": false, - "max_subargs_per_line": 5, - "fence_pattern": "^\\s*([`~]{3}[`~]*)(.*)$", - "enable_markup": true, - "ruler_pattern": "^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$", - "tab_size": 2, - "keyword_case": "unchanged", - "enum_char": ".", - "literal_comment_pattern": null, - "bullet_char": "*", - "line_ending": "unix" -} diff --git a/3rdparty/astc-codec/src/.clang-format b/3rdparty/astc-codec/src/.clang-format deleted file mode 100644 index 9a00ee2..0000000 --- a/3rdparty/astc-codec/src/.clang-format +++ /dev/null @@ -1,4 +0,0 @@ -BasedOnStyle: Google -AllowShortCaseLabelsOnASingleLine: true -AllowShortFunctionsOnASingleLine: Inline -SpaceAfterTemplateKeyword: false diff --git a/3rdparty/astc-codec/src/base/BUILD.bazel b/3rdparty/astc-codec/src/base/BUILD.bazel deleted file mode 100644 index 84d2131..0000000 --- a/3rdparty/astc-codec/src/base/BUILD.bazel +++ /dev/null @@ -1,49 +0,0 @@ -# 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. - -licenses(["notice"]) - -cc_library( - name = "base", - hdrs = [ - "bit_stream.h", - "bottom_n.h", - "math_utils.h", - "optional.h", - "string_utils.h", - "type_traits.h", - "uint128.h", - "utils.h", - ], - features = ["-parse_headers"], - 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/3rdparty/astc-codec/src/base/CMakeLists.txt b/3rdparty/astc-codec/src/base/CMakeLists.txt deleted file mode 100644 index 5a45f85..0000000 --- a/3rdparty/astc-codec/src/base/CMakeLists.txt +++ /dev/null @@ -1,27 +0,0 @@ -# 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. -add_library(base INTERFACE) -target_include_directories(base INTERFACE ../..) - -if(OPTION_ASTC_TESTS) - add_executable(base_test - 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) - target_link_libraries(base_test base gmock_main) - add_test(NAME base_test COMMAND base_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) -endif() diff --git a/3rdparty/astc-codec/src/base/test/bit_stream_test.cpp b/3rdparty/astc-codec/src/base/test/bit_stream_test.cpp deleted file mode 100644 index 0c4b3c9..0000000 --- a/3rdparty/astc-codec/src/base/test/bit_stream_test.cpp +++ /dev/null @@ -1,141 +0,0 @@ -// 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/3rdparty/astc-codec/src/base/test/bottom_n_test.cpp b/3rdparty/astc-codec/src/base/test/bottom_n_test.cpp deleted file mode 100644 index 71265d7..0000000 --- a/3rdparty/astc-codec/src/base/test/bottom_n_test.cpp +++ /dev/null @@ -1,108 +0,0 @@ -// 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()); - int list[] = { 1,2 }; - pushAll(heap, list); - - EXPECT_EQ(heap.Size(), 2); - EXPECT_FALSE(heap.Empty()); - EXPECT_THAT(heap.Pop(), ElementsAre(1, 2)); - } - - { - BottomN heap(6); - int list[] = {1, 4, 3, 2, 2, 1}; - pushAll(heap, list); - - EXPECT_EQ(heap.Size(), 6); - EXPECT_THAT(heap.Pop(), ElementsAre(1, 1, 2, 2, 3, 4)); - } -} - -TEST(BottomN, Bounds) { - { - BottomN heap(4); - int list[] = { 1, 2, 3, 4 }; - pushAll(heap, list); - 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); - int list[] = { 4, 3, 2,1 }; - pushAll(heap, list); - EXPECT_EQ(heap.Size(), 4); - - int list2[] = { 4,4,4,4 }; - pushAll(heap, list2); - EXPECT_EQ(heap.Size(), 4); - - EXPECT_THAT(heap.Pop(), ElementsAre(1, 2, 3, 4)); - } - - { - BottomN heap(4); - int list[] = { 4, 3, 2, 1 }; - pushAll(heap, list); - EXPECT_EQ(heap.Size(), 4); - - int list2[] = { 5, 5, 5, 5 }; - pushAll(heap, list2); - EXPECT_EQ(heap.Size(), 4); - - EXPECT_THAT(heap.Pop(), ElementsAre(1, 2, 3, 4)); - } - - { - BottomN heap(4); - int list[] = { 4, 3, 2, 1 }; - pushAll(heap, list); - EXPECT_EQ(heap.Size(), 4); - - int list2[] = { 0, 0, 0, 0 }; - pushAll(heap, list2); - EXPECT_EQ(heap.Size(), 4); - - EXPECT_THAT(heap.Pop(), ElementsAre(0, 0, 0, 0)); - } -} - -} // namespace base -} // namespace astc_codec diff --git a/3rdparty/astc-codec/src/base/test/math_utils_test.cpp b/3rdparty/astc-codec/src/base/test/math_utils_test.cpp deleted file mode 100644 index 0371e11..0000000 --- a/3rdparty/astc-codec/src/base/test/math_utils_test.cpp +++ /dev/null @@ -1,78 +0,0 @@ -// 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/3rdparty/astc-codec/src/base/test/optional_test.cpp b/3rdparty/astc-codec/src/base/test/optional_test.cpp deleted file mode 100644 index 1eeefbd..0000000 --- a/3rdparty/astc-codec/src/base/test/optional_test.cpp +++ /dev/null @@ -1,481 +0,0 @@ -// 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/3rdparty/astc-codec/src/base/test/string_utils_test.cpp b/3rdparty/astc-codec/src/base/test/string_utils_test.cpp deleted file mode 100644 index 209da54..0000000 --- a/3rdparty/astc-codec/src/base/test/string_utils_test.cpp +++ /dev/null @@ -1,110 +0,0 @@ -// 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/3rdparty/astc-codec/src/base/test/type_traits_test.cpp b/3rdparty/astc-codec/src/base/test/type_traits_test.cpp deleted file mode 100644 index c724cbe..0000000 --- a/3rdparty/astc-codec/src/base/test/type_traits_test.cpp +++ /dev/null @@ -1,130 +0,0 @@ -// 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"); -} - -#ifndef _MSC_VER -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"); -} -#endif - -} // namespace base -} // namespace astc_codec diff --git a/3rdparty/astc-codec/src/base/test/uint128_test.cpp b/3rdparty/astc-codec/src/base/test/uint128_test.cpp deleted file mode 100644 index 0a52244..0000000 --- a/3rdparty/astc-codec/src/base/test/uint128_test.cpp +++ /dev/null @@ -1,140 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/BUILD.bazel b/3rdparty/astc-codec/src/decoder/BUILD.bazel deleted file mode 100644 index ccc764e..0000000 --- a/3rdparty/astc-codec/src/decoder/BUILD.bazel +++ /dev/null @@ -1,246 +0,0 @@ -# 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. - -licenses(["notice"]) - -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", - ], - copts = [ - "-Wno-unused-variable", - "-O3", - ], - deps = [ - ":footprint", - "//src/base", - ], -) - -cc_library( - name = "codec", - srcs = ["codec.cc"], - hdrs = ["codec.h"], - visibility = ["//:__pkg__"], - deps = [ - ":astc_utils", - ":footprint", - "//src/base", - ], -) - -cc_binary( - name = "astc_inspector_cli", - srcs = ["tools/astc_inspector_cli.cc"], - deps = [ - ":astc_utils", - "//src/base", - ], -) - -################################################################################ -## -## Testing -## -################################################################################ - -cc_library( - name = "test", - testonly = 1, - hdrs = ["test/image_utils.h"], - deps = ["@gtest//:gtest"], -) - -cc_test( - name = "physical_astc_block_test", - size = "small", - srcs = ["test/physical_astc_block_test.cc"], - deps = [ - ":astc_utils", - "@gtest//:gtest_main", - "//src/base", - ], -) - -cc_test( - name = "partition_test", - size = "medium", - 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", - "//src/base", - ], -) - -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 = [ - ":astc_utils", - ":test", - "@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 = [ - ":codec", - ":test", - "@gtest//:gtest_main", - "//:api", - ], -) - -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/3rdparty/astc-codec/src/decoder/CMakeLists.txt b/3rdparty/astc-codec/src/decoder/CMakeLists.txt deleted file mode 100644 index e82a692..0000000 --- a/3rdparty/astc-codec/src/decoder/CMakeLists.txt +++ /dev/null @@ -1,95 +0,0 @@ -# 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. -add_library(footprint footprint.cc) -target_link_libraries(footprint base) - -add_library(astc_utils - 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) -target_link_libraries(astc_utils PRIVATE base footprint) -target_include_directories(astc_utils PRIVATE ../..) - -add_library(astc-codec codec.cc) -target_link_libraries(astc-codec PRIVATE astc_utils) -target_include_directories(astc-codec PUBLIC ../../include) -target_include_directories(astc-codec PRIVATE ../..) - -add_executable(astc_inspector_cli tools/astc_inspector_cli.cc) -target_include_directories(astc_inspector_cli PRIVATE ../..) -target_link_libraries(astc_inspector_cli PRIVATE astc_utils) - -# -# Testing -# -if(OPTION_ASTC_TESTS) - # Note that we will execute all the tests in the project directory. - # We do this to ensure the unit tests can pick up the required test data - - # Create interface library exposing the root as an include directory - add_library(codec_test_dependencies INTERFACE) - target_include_directories(codec_test_dependencies INTERFACE ../..) - - add_executable(physical_astc_block_test test/physical_astc_block_test.cc) - add_test(NAME physical_astc_block_test COMMAND physical_astc_block_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(physical_astc_block_test astc_utils codec_test_dependencies gmock_main) - - add_executable(partition_test test/partition_test.cc) - add_test(NAME partition_test COMMAND partition_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(partition_test PRIVATE astc_utils codec_test_dependencies gmock_main) - - add_executable(integer_sequence_codec_test test/integer_sequence_codec_test.cc) - target_link_libraries(integer_sequence_codec_test PRIVATE astc_utils codec_test_dependencies gmock_main) - - add_executable(intermediate_astc_block_test test/intermediate_astc_block_test.cc) - add_test(NAME intermediate_astc_block_test COMMAND intermediate_astc_block_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(intermediate_astc_block_test PRIVATE astc_utils codec_test_dependencies gmock_main) - - add_executable(quantization_test test/quantization_test.cc) - add_test(NAME quantization_test COMMAND quantization_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(quantization_test PRIVATE astc_utils codec_test_dependencies gmock_main) - - add_executable(weight_infill_test test/weight_infill_test.cc) - add_test(NAME weight_infill_test COMMAND weight_infill_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(weight_infill_test PRIVATE astc_utils footprint codec_test_dependencies gmock_main) - - add_executable(endpoint_codec_test test/endpoint_codec_test.cc) - add_test(NAME endpoint_codec_test COMMAND endpoint_codec_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(endpoint_codec_test PRIVATE astc_utils codec_test_dependencies gmock_main) - - add_executable(logical_astc_block_test test/logical_astc_block_test.cc) - add_test(NAME logical_astc_block_test COMMAND logical_astc_block_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(logical_astc_block_test PRIVATE astc_utils codec_test_dependencies gmock_main) - - add_executable(codec_test test/codec_test.cc) - add_test(NAME codec_test COMMAND codec_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - - target_link_libraries(codec_test PRIVATE astc-codec codec_test_dependencies gmock_main) - - add_executable(footprint_test test/footprint_test.cc) - add_test(NAME footprint_test COMMAND footprint_test WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) - target_link_libraries(footprint_test PRIVATE footprint codec_test_dependencies gmock_main) - - if(OPTION_BUILD_FUZZER) - message(FATAL_ERROR "Not yet supported due to missing dependencies") - add_executable(astc_fuzzer test/astc_fuzzer.cc codec_test_dependencies gmock_main) - target_link_libraries(astc_fuzzer PRIVATE astc-codec honggfuzz benchmark) - endif() -endif() diff --git a/3rdparty/astc-codec/src/decoder/test/astc_fuzzer.cc b/3rdparty/astc-codec/src/decoder/test/astc_fuzzer.cc deleted file mode 100644 index f152675..0000000 --- a/3rdparty/astc-codec/src/decoder/test/astc_fuzzer.cc +++ /dev/null @@ -1,36 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/codec_test.cc b/3rdparty/astc-codec/src/decoder/test/codec_test.cc deleted file mode 100644 index 936eed3..0000000 --- a/3rdparty/astc-codec/src/decoder/test/codec_test.cc +++ /dev/null @@ -1,181 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/endpoint_codec_test.cc b/3rdparty/astc-codec/src/decoder/test/endpoint_codec_test.cc deleted file mode 100644 index de7d9ca..0000000 --- a/3rdparty/astc-codec/src/decoder/test/endpoint_codec_test.cc +++ /dev/null @@ -1,463 +0,0 @@ -// 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::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/3rdparty/astc-codec/src/decoder/test/footprint_test.cc b/3rdparty/astc-codec/src/decoder/test/footprint_test.cc deleted file mode 100644 index 6aef98a..0000000 --- a/3rdparty/astc-codec/src/decoder/test/footprint_test.cc +++ /dev/null @@ -1,97 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/image_utils.h b/3rdparty/astc-codec/src/decoder/test/image_utils.h deleted file mode 100644 index 1e5000a..0000000 --- a/3rdparty/astc-codec/src/decoder/test/image_utils.h +++ /dev/null @@ -1,217 +0,0 @@ -// 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 inline 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 inline 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); - } -} - -static inline 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 inline 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/3rdparty/astc-codec/src/decoder/test/integer_sequence_codec_test.cc b/3rdparty/astc-codec/src/decoder/test/integer_sequence_codec_test.cc deleted file mode 100644 index 120e8b0..0000000 --- a/3rdparty/astc-codec/src/decoder/test/integer_sequence_codec_test.cc +++ /dev/null @@ -1,336 +0,0 @@ -// 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_DEATH(IntegerSequenceCodec::GetCountsForRange(0, &t, &q, &b), ""); - ASSERT_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/3rdparty/astc-codec/src/decoder/test/intermediate_astc_block_test.cc b/3rdparty/astc-codec/src/decoder/test/intermediate_astc_block_test.cc deleted file mode 100644 index 41861cb..0000000 --- a/3rdparty/astc-codec/src/decoder/test/intermediate_astc_block_test.cc +++ /dev/null @@ -1,454 +0,0 @@ -// 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::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_TRUE(blk.ColorValuesRange().hasValue()); - EXPECT_EQ(blk.ColorValuesRange().valueOr(0), 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_TRUE(data.endpoint_range.hasValue()); - EXPECT_EQ(data.endpoint_range.valueOr(0), 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/3rdparty/astc-codec/src/decoder/test/logical_astc_block_test.cc b/3rdparty/astc-codec/src/decoder/test/logical_astc_block_test.cc deleted file mode 100644 index ed85f3f..0000000 --- a/3rdparty/astc-codec/src/decoder/test/logical_astc_block_test.cc +++ /dev/null @@ -1,273 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/partition_test.cc b/3rdparty/astc-codec/src/decoder/test/partition_test.cc deleted file mode 100644 index 63adfb5..0000000 --- a/3rdparty/astc-codec/src/decoder/test/partition_test.cc +++ /dev/null @@ -1,263 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/physical_astc_block_test.cc b/3rdparty/astc-codec/src/decoder/test/physical_astc_block_test.cc deleted file mode 100644 index 8eafe46..0000000 --- a/3rdparty/astc-codec/src/decoder/test/physical_astc_block_test.cc +++ /dev/null @@ -1,361 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/quantization_test.cc b/3rdparty/astc-codec/src/decoder/test/quantization_test.cc deleted file mode 100644 index f882876..0000000 --- a/3rdparty/astc-codec/src/decoder/test/quantization_test.cc +++ /dev/null @@ -1,288 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/test/weight_infill_test.cc b/3rdparty/astc-codec/src/decoder/test/weight_infill_test.cc deleted file mode 100644 index 79c7745..0000000 --- a/3rdparty/astc-codec/src/decoder/test/weight_infill_test.cc +++ /dev/null @@ -1,69 +0,0 @@ -// 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/3rdparty/astc-codec/src/decoder/testdata/atlas_small_4x4.astc b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_4x4.astc deleted file mode 100644 index 0dd080b..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_4x4.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_4x4.bmp b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_4x4.bmp deleted file mode 100644 index 32412b3..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_4x4.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_5x5.astc b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_5x5.astc deleted file mode 100644 index 2831c90..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_5x5.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_5x5.bmp b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_5x5.bmp deleted file mode 100644 index 95b0186..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_5x5.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_6x6.astc b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_6x6.astc deleted file mode 100644 index b2cc9c2..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_6x6.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_6x6.bmp b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_6x6.bmp deleted file mode 100644 index 796812e..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_6x6.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_8x8.astc b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_8x8.astc deleted file mode 100644 index a8805f2..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_8x8.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_8x8.bmp b/3rdparty/astc-codec/src/decoder/testdata/atlas_small_8x8.bmp deleted file mode 100644 index 8f92698..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/atlas_small_8x8.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkerboard.astc b/3rdparty/astc-codec/src/decoder/testdata/checkerboard.astc deleted file mode 100644 index 79acdca..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkerboard.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_10.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_10.astc deleted file mode 100644 index e3b1965..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_10.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_11.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_11.astc deleted file mode 100644 index c80c6a4..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_11.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_12.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_12.astc deleted file mode 100644 index a82583a..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_12.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_4.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_4.astc deleted file mode 100644 index ac60716..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_4.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_5.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_5.astc deleted file mode 100644 index 0389c53..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_5.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_6.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_6.astc deleted file mode 100644 index 210dd34..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_6.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_7.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_7.astc deleted file mode 100644 index 8ea10f8..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_7.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_8.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_8.astc deleted file mode 100644 index 3708882..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_8.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/checkered_9.astc b/3rdparty/astc-codec/src/decoder/testdata/checkered_9.astc deleted file mode 100644 index b5c962a..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/checkered_9.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x10.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x10.astc deleted file mode 100644 index 6799cd0..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x10.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x10.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x10.bmp deleted file mode 100644 index 7ded6ad..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x10.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x5.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x5.astc deleted file mode 100644 index cbfe4f2..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x5.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x5.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x5.bmp deleted file mode 100644 index 68202f8..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x5.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x6.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x6.astc deleted file mode 100644 index 53e37b4..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x6.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x6.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x6.bmp deleted file mode 100644 index 3dffe72..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x6.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x8.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x8.astc deleted file mode 100644 index b9613e5..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x8.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x8.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_10x8.bmp deleted file mode 100644 index b7d75f7..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_10x8.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x10.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_12x10.astc deleted file mode 100644 index 54f5919..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x10.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x10.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_12x10.bmp deleted file mode 100644 index 2007a3d..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x10.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x12.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_12x12.astc deleted file mode 100644 index d94d0a6..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x12.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x12.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_12x12.bmp deleted file mode 100644 index 57e24a2..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_12x12.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_4x4.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_4x4.astc deleted file mode 100644 index fdf3cd6..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_4x4.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_4x4.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_4x4.bmp deleted file mode 100644 index fcb4e07..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_4x4.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x4.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_5x4.astc deleted file mode 100644 index 0683059..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x4.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x4.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_5x4.bmp deleted file mode 100644 index 9cae5f9..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x4.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x5.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_5x5.astc deleted file mode 100644 index 03c3395..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x5.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x5.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_5x5.bmp deleted file mode 100644 index c5ddeec..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_5x5.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x5.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_6x5.astc deleted file mode 100644 index d0d455d..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x5.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x5.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_6x5.bmp deleted file mode 100644 index 94a005d..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x5.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x6.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_6x6.astc deleted file mode 100644 index 47e038e..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x6.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x6.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_6x6.bmp deleted file mode 100644 index fb1f41c..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_6x6.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x5.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_8x5.astc deleted file mode 100644 index 4ef49d6..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x5.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x5.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_8x5.bmp deleted file mode 100644 index 6d4f609..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x5.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x6.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_8x6.astc deleted file mode 100644 index 1135509..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x6.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x6.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_8x6.bmp deleted file mode 100644 index 35e7121..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x6.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x8.astc b/3rdparty/astc-codec/src/decoder/testdata/footprint_8x8.astc deleted file mode 100644 index bdeb9c9..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x8.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x8.bmp b/3rdparty/astc-codec/src/decoder/testdata/footprint_8x8.bmp deleted file mode 100644 index 3b3a1c8..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/footprint_8x8.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_12x12.astc b/3rdparty/astc-codec/src/decoder/testdata/rgb_12x12.astc deleted file mode 100644 index cc0fc3d..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_12x12.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_12x12.bmp b/3rdparty/astc-codec/src/decoder/testdata/rgb_12x12.bmp deleted file mode 100644 index 50538de..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_12x12.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_4x4.astc b/3rdparty/astc-codec/src/decoder/testdata/rgb_4x4.astc deleted file mode 100644 index 84527d3..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_4x4.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_4x4.bmp b/3rdparty/astc-codec/src/decoder/testdata/rgb_4x4.bmp deleted file mode 100644 index fae4f91..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_4x4.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_5x4.astc b/3rdparty/astc-codec/src/decoder/testdata/rgb_5x4.astc deleted file mode 100644 index 377938d..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_5x4.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_5x4.bmp b/3rdparty/astc-codec/src/decoder/testdata/rgb_5x4.bmp deleted file mode 100644 index a0c1fdb..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_5x4.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_6x6.astc b/3rdparty/astc-codec/src/decoder/testdata/rgb_6x6.astc deleted file mode 100644 index 8a70c0f..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_6x6.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_6x6.bmp b/3rdparty/astc-codec/src/decoder/testdata/rgb_6x6.bmp deleted file mode 100644 index e1a5dcd..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_6x6.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_8x8.astc b/3rdparty/astc-codec/src/decoder/testdata/rgb_8x8.astc deleted file mode 100644 index 1bca381..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_8x8.astc and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/testdata/rgb_8x8.bmp b/3rdparty/astc-codec/src/decoder/testdata/rgb_8x8.bmp deleted file mode 100644 index 12b6eb2..0000000 Binary files a/3rdparty/astc-codec/src/decoder/testdata/rgb_8x8.bmp and /dev/null differ diff --git a/3rdparty/astc-codec/src/decoder/tools/astc_inspector_cli.cc b/3rdparty/astc-codec/src/decoder/tools/astc_inspector_cli.cc deleted file mode 100644 index 105f574..0000000 --- a/3rdparty/astc-codec/src/decoder/tools/astc_inspector_cli.cc +++ /dev/null @@ -1,785 +0,0 @@ -// 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_inspector_cli collects the various statistics of a stream of ASTC data -// stored in an ASTC file. -// -// Example usage: -// To dump statistics about an ASTC file, use: -// astc_inspector_cli -// -// 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/3rdparty/astc-codec/third_party/BUILD b/3rdparty/astc-codec/third_party/BUILD deleted file mode 100644 index e69de29..0000000 diff --git a/3rdparty/astc-codec/third_party/honggfuzz.BUILD b/3rdparty/astc-codec/third_party/honggfuzz.BUILD deleted file mode 100644 index 07d9042..0000000 --- a/3rdparty/astc-codec/third_party/honggfuzz.BUILD +++ /dev/null @@ -1,39 +0,0 @@ -config_setting( - name = "opt", - values = {"compilation_mode": "opt"} -) - -cc_library( - name = "honggfuzz", - srcs = glob([ - "libhfuzz/*.c", - "libhfcommon/*.c", - ], - exclude = ["libhfuzz/linux.c"], - ) + select({ - "@bazel_tools//src/conditions:darwin_x86_64": [], - "@bazel_tools//src/conditions:darwin": [], - "//conditions:default": ["libhfuzz/linux.c"], - }), - hdrs = glob([ - "libhfuzz/*.h", - "libhfcommon/*.h", - "honggfuzz.h", - ]), - copts = [ - "-std=c11", - ], - defines = select({ - "@bazel_tools//src/conditions:darwin_x86_64": ["_HF_ARCH_DARWIN"], - "@bazel_tools//src/conditions:darwin": ["_HF_ARCH_DARWIN"], - "//conditions:default": ["_HF_ARCH_LINUX"], - }) + select({ - ":opt": [], - "//conditions:default": ["DEBUG=DEBUG"], - }) + [ - "_GNU_SOURCE", - ], - includes = ["."], - visibility = ["//visibility:public"], - linkstatic = 1 -) diff --git a/3rdparty/astc-codec/tools/build-ci/linux/build.sh b/3rdparty/astc-codec/tools/build-ci/linux/build.sh deleted file mode 100755 index 9f08806..0000000 --- a/3rdparty/astc-codec/tools/build-ci/linux/build.sh +++ /dev/null @@ -1,76 +0,0 @@ -#!/bin/bash -# Configures builds for our CI environment. - -# Print commands and exit on error. -set -ex - -if [ "$KOKORO_BUILD_ID" ]; then - echo "Running job $KOKORO_JOB_NAME" - TARGET=`echo "$KOKORO_JOB_NAME" | awk -F "/" '{print $NF}'` -fi - -if [ ! "$TARGET" ]; then - if [ "$1" ]; then - TARGET=$1 - else - TARGET=release - fi -fi - -echo "Building $TARGET target" - -pushd `dirname $0`/../../.. > /dev/null - -BUILD_RELEASE= -BUILD_DEBUG= -BUILD_CMAKE= -RUN_TESTS= - -if [ "$TARGET" == "presubmit" ]; then - BUILD_DEBUG=1 - BUILD_RELEASE=1 - BUILD_CMAKE=1 - RUN_TESTS=1 -fi - -if [ "$TARGET" == "debug" ]; then - BUILD_DEBUG=1 -fi - -if [ "$TARGET" == "release" ]; then - BUILD_RELEASE=1 -fi - -if [ "$TARGET" == "continuous" ]; then - BUILD_DEBUG=1 - BUILD_RELEASE=1 - BUILD_CMAKE=1 - RUN_TESTS=1 -fi - -if [ "$BUILD_DEBUG" == "1" ]; then - echo "Starting debug build" - bazel build -c dbg //... - - if [ "$RUN_TESTS" == "1" ]; then - bazel test -c dbg //... - fi -fi - -if [ "$BUILD_RELEASE" == "1" ]; then - echo "Starting release build" - bazel build -c opt //... - - if [ "$RUN_TESTS" == "1" ]; then - bazel test -c opt //... - fi -fi - -if [ "$BUILD_CMAKE" == "1" ]; then - echo "Starting cmake build" - mkdir build - pushd build - cmake .. - make -j$((`nproc`+1)) - popd -fi diff --git a/3rdparty/astc-codec/tools/build-ci/linux/continuous.cfg b/3rdparty/astc-codec/tools/build-ci/linux/continuous.cfg deleted file mode 100644 index cde6840..0000000 --- a/3rdparty/astc-codec/tools/build-ci/linux/continuous.cfg +++ /dev/null @@ -1,3 +0,0 @@ -# Format: //devtools/kokoro/config/proto/build.proto - -build_file: "astc-codec/tools/build-ci/linux/build.sh" diff --git a/3rdparty/astc-codec/tools/build-ci/linux/presubmit.cfg b/3rdparty/astc-codec/tools/build-ci/linux/presubmit.cfg deleted file mode 100644 index cde6840..0000000 --- a/3rdparty/astc-codec/tools/build-ci/linux/presubmit.cfg +++ /dev/null @@ -1,3 +0,0 @@ -# Format: //devtools/kokoro/config/proto/build.proto - -build_file: "astc-codec/tools/build-ci/linux/build.sh"