Mirrors/bimg
1
0
Fork 0
mirror of https://github.com/bkaradzic/bimg.git synced 2026-02-17 20:52:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Drop astc-codec and use astc-encoder for decoding too

Browse Source 
Add missing ASTC formats to imageEncode path too
This commit is contained in:
Raziel Alphadios
2022-10-26 04:39:59 +03:00
parent ff0274d647
commit e0e9fef6a8
37 changed files with 58 additions and 7502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
3rdparty/astc-codec/LICENSE vendored
View File

@@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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
http://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.

75
3rdparty/astc-codec/include/astc-codec/astc-codec.h vendored
View File

@@ -1,75 +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.
#ifndef ASTC_CODEC_ASTC_CODEC_H_
#define ASTC_CODEC_ASTC_CODEC_H_
#include <cstddef>
#include <cstdint>
namespace astc_codec {
// These are the valid ASTC footprints according to the specification in
// Section C.2.7.
enum class FootprintType {
k4x4,
k5x4,
k5x5,
k6x5,
k6x6,
k8x5,
k8x6,
k10x5,
k10x6,
k8x8,
k10x8,
k10x10,
k12x10,
k12x12,
kCount
};
// Decompresses ASTC LDR image data to a RGBA32 buffer.
//
// Supports formats defined in the KHR_texture_compression_astc_ldr spec and
// returns UNORM8 values. sRGB is not supported, and should be implemented
// by the caller.
//
// |astc_data| - Compressed ASTC image buffer, must be at least |astc_data_size|
// bytes long.
// |astc_data_size| - The size of |astc_data|, in bytes.
// |width| - Image width, in pixels.
// |height| - Image height, in pixels.
// |footprint| - The ASTC footprint (block size) of the compressed image buffer.
// |out_buffer| - Pointer to a buffer where the decompressed image will be
// stored, must be at least |out_buffer_size| bytes long.
// |out_buffer_size| - The size of |out_buffer|, in bytes, at least
// height*out_buffer_stride. If this is too small, this
// function will return false and no data will be
// decompressed.
// |out_buffer_stride| - The stride that should be used to store rows of the
// decoded image, must be at least 4*width bytes.
//
// Returns true if the decompression succeeded, or false if decompression
// failed, or if the astc_data_size was too small for the given width, height,
// and footprint, or if out_buffer_size is too small.
bool ASTCDecompressToRGBA(const uint8_t* astc_data, size_t astc_data_size,
size_t width, size_t height, FootprintType footprint,
uint8_t* out_buffer, size_t out_buffer_size,
size_t out_buffer_stride);
} // namespace astc_codec
#endif // ASTC_CODEC_ASTC_CODEC_H_

77
3rdparty/astc-codec/src/base/bit_stream.h vendored
View File

@@ -1,77 +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.
#ifndef ASTC_CODEC_BASE_BIT_STREAM_H_
#define ASTC_CODEC_BASE_BIT_STREAM_H_
#include <cassert>
#include <cstdint>
namespace astc_codec {
namespace base {
// Represents a stream of bits that can be read or written in arbitrary-sized
// chunks.
template<typename IntType = uint64_t>
class BitStream {
public:
// Creates an empty BitStream.
BitStream() = default;
BitStream(IntType data, uint32_t data_size)
: data_(data), data_size_(data_size) {
assert(data_size_ <= sizeof(data_) * 8);
}
// Return the number of bits in the stream.
uint32_t Bits() const { return data_size_; }
// Put |size| bits into the stream.
// Fails if there is not enough space in the buffer to store the bits.
template<typename ResultType>
void PutBits(ResultType x, uint32_t size) {
assert(data_size_ + size <= sizeof(data_) * 8);
data_ |= (IntType(x) & MaskFor(size)) << data_size_;
data_size_ += size;
}
// Get |count| bits from the stream.
// Returns true if |count| bits were successfully retrieved.
template<typename ResultType>
bool GetBits(uint32_t count, ResultType* result) {
if (count <= data_size_) {
*result = static_cast<ResultType>(data_ & MaskFor(count));
data_ = data_ >> count;
data_size_ -= count;
return true;
} else {
*result = ResultType();
return false;
}
}
private:
IntType MaskFor(uint32_t bits) const {
return (bits == sizeof(IntType) * 8) ? ~IntType(0)
: (IntType(1) << bits) - 1;
}
IntType data_ = IntType();
uint32_t data_size_ = 0;
};
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_BIT_STREAM_H_

78
3rdparty/astc-codec/src/base/bottom_n.h vendored
View File

@@ -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.
#ifndef ASTC_CODEC_BASE_BOTTOM_N_H_
#define ASTC_CODEC_BASE_BOTTOM_N_H_
#include <algorithm>
#include <functional>
#include <vector>
namespace astc_codec {
namespace base {
// Used to aggregate the lowest N values of data supplied.
template<typename T, typename CompareFn = std::less<T>>
class BottomN {
public:
typedef std::vector<T> ContainerType;
// Creates an empty BottomN with limit |max_size|.
BottomN(size_t max_size) : max_size_(max_size) { }
bool Empty() const { return data_.empty(); }
size_t Size() const { return data_.size(); }
const T& Top() const { return data_.front(); }
void Push(const T& value) {
if (data_.size() < max_size_ || compare_(value, Top())) {
data_.push_back(value);
std::push_heap(data_.begin(), data_.end(), compare_);
if (Size() > max_size_) {
PopTop();
}
}
}
std::vector<T> Pop() {
const size_t len = Size();
std::vector<T> result(len);
for (size_t i = 0; i < len; ++i) {
result[len - i - 1] = PopTop();
}
return result;
}
private:
T PopTop() {
std::pop_heap(data_.begin(), data_.end(), compare_);
T result = data_.back();
data_.pop_back();
return result;
}
ContainerType data_;
CompareFn compare_;
const size_t max_size_;
};
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_BOTTOM_N_H_

80
3rdparty/astc-codec/src/base/math_utils.h vendored
View File

@@ -1,80 +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.
#ifndef ASTC_CODEC_BASE_MATH_UTILS_H_
#define ASTC_CODEC_BASE_MATH_UTILS_H_
#include "src/base/uint128.h"
#include <cassert>
#include <cstdint>
#include <type_traits>
namespace astc_codec {
namespace base {
inline int Log2Floor(uint32_t n) {
if (n == 0) {
return -1;
}
int log = 0;
uint32_t value = n;
for (int i = 4; i >= 0; --i) {
int shift = (1 << i);
uint32_t x = value >> shift;
if (x != 0) {
value = x;
log += shift;
}
}
assert(value == 1);
return log;
}
inline int CountOnes(uint32_t n) {
n -= ((n >> 1) & 0x55555555);
n = ((n >> 2) & 0x33333333) + (n & 0x33333333);
return static_cast<int>((((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24);
}
template<typename T>
inline T ReverseBits(T value) {
uint32_t s = sizeof(value) * 8;
T mask = ~T(0);
while ((s >>= 1) > 0) {
mask ^= (mask << s);
value = ((value >> s) & mask) | ((value << s) & ~mask);
}
return value;
}
template<typename T>
inline T GetBits(T source, uint32_t offset, uint32_t count) {
static_assert(std::is_same<T, UInt128>::value || std::is_unsigned<T>::value,
"T must be unsigned.");
const uint32_t total_bits = sizeof(T) * 8;
assert(count > 0);
assert(offset + count <= total_bits);
const T mask = count == total_bits ? ~T(0) : ~T(0) >> (total_bits - count);
return (source >> offset) & mask;
}
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_MATH_UTILS_H_

520
3rdparty/astc-codec/src/base/optional.h vendored
View File

@@ -1,520 +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.
#ifndef ASTC_CODEC_BASE_OPTIONAL_H_
#define ASTC_CODEC_BASE_OPTIONAL_H_
#include "src/base/type_traits.h"
#include <cassert>
#include <initializer_list>
#include <type_traits>
#include <utility>
#include <cstddef>
// Optional<T> - a template class to store an optional value of type T.
//
// Usage examples:
//
// Initialization and construction:
// Optional<Foo> foo; // |foo| doesn't contain a value.
// Optional<Foo> foo(Foo(10)); // |foo| contains a copy-constructed value.
// Optional<Foo> foo2(foo); // |foo2| contains a copy of |foo|'s value.
// Optional<Foo> foo3(std::move(foo2)); // Guess what?
//
// Assignment:
// Foo foo_value(0);
// Optional<Foo> foo; // |foo| is empty.
// Optional<Foo> foo2; // |foo2| is empty.
// foo2 = foo; // |foo2| is still empty.
// foo = foo_value; // set value of |foo| to a copy of |foo_value|
// foo = std::move(foo_value); // move |foo_value| into |foo|.
// foo2 = foo; // now |foo2| has a copy of |foo|'s value.
// foo = kNullopt; // unset |foo|, it has no value.
//
// Checking and accessing value:
// if (foo) {
// // |foo| has a value.
// doStuff(*foo); // |*foo| is the value inside |foo|.
// foo->callMethod(); // Same as (*foo).callMethod().
// } else {
// // |foo| is empty.
// }
//
// foo.value() // Same as *foo
// foo.valueOr(<default>) // Return <default> is |foo| has no value.
//
// In-place construction:
//
// Optional<Foo> foo; // |foo| is empty.
// foo.emplace(20); // |foo| now contains a value constructed as Foo(20)
//
// Optional<Foo> foo(kInplace, 20); // |foo| is initialized with a value
// // that is constructed in-place as
// // Foo(20).
//
// return makeOptional<Foo>(20); // Takes Foo constructor arguments
// // directly.
//
// Returning values:
//
// Optional<Foo> myFunc(...) {
// if (someCondition) {
// return Foo(10); // call Optional<Foo>(Foo&) constructor.
// } else {
// return {}; // call Optional<Foo>() constructor, which
// // builds an empty value.
// }
// }
//
// Memory layout:
// Optional<Foo> is equivalent to:
//
// struct {
// bool flag;
// Foo value;
// };
//
// in terms of memory layout. This means it *doubles* the size of integral
// types. Also:
//
// - Optional<Foo> can be constructed from anything that constructs a Foo.
//
// - Same with Optional<Foo>(kInplace, Args...) where Args... matches any
// arguments that can be passed to a Foo constructor.
//
// - Comparison operators are provided. Beware: an empty Optional<Foo>
// is always smaller than any Foo value.
namespace astc_codec {
namespace base {
namespace details {
// Base classes to reduce the number of instantiations of the Optional's
// internal members.
class OptionalFlagBase {
public:
void setConstructed(bool constructed) { mConstructed = constructed; }
constexpr bool constructed() const { return mConstructed; }
constexpr operator bool() const { return constructed(); }
bool hasValue() const { return constructed(); }
constexpr OptionalFlagBase(bool constructed = false)
: mConstructed(constructed) { }
private:
bool mConstructed = false;
};
template<size_t Size, size_t Align>
class OptionalStorageBase {
protected:
using StoreT = typename std::aligned_storage<Size, Align>::type;
StoreT mStorage = {};
};
} // namespace details
// A tag type for empty optional construction
struct NulloptT {
constexpr explicit NulloptT(int) { }
};
// A tag type for inplace value construction
struct InplaceT {
constexpr explicit InplaceT(int) { }
};
// Tag values for null optional and inplace construction
constexpr NulloptT kNullopt{1};
constexpr InplaceT kInplace{1};
// Forward declaration for an early use
template<class T>
class Optional;
// A type trait for checking if a type is an optional instantiation
// Note: if you want to refer to the template name inside the template,
// you need to declare this alias outside of it - because the
// class name inside of the template stands for an instantiated template
// E.g, for template <T> class Foo if you say 'Foo' inside the class, it
// actually means Foo<T>;
template<class U>
using is_any_optional =
is_template_instantiation_of<typename std::decay<U>::type, Optional>;
template<class T>
class Optional
: private details::OptionalFlagBase,
private details::OptionalStorageBase<sizeof(T),
std::alignment_of<T>::value> {
// make sure all optionals are buddies - this is needed to implement
// conversion from optionals of other types
template<class U>
friend class Optional;
template<class U>
using self = Optional<U>;
using base_flag = details::OptionalFlagBase;
using base_storage =
details::OptionalStorageBase<sizeof(T), std::alignment_of<T>::value>;
public:
// std::optional will have this, so let's provide it
using value_type = T;
// make sure we forbid some Optional instantiations where things may get
// really messy
static_assert(!std::is_same<typename std::decay<T>::type, NulloptT>::value,
"Optional of NulloptT is not allowed");
static_assert(!std::is_same<typename std::decay<T>::type, InplaceT>::value,
"Optional of InplaceT is not allowed");
static_assert(!std::is_reference<T>::value,
"Optional references are not allowed: use a pointer instead");
// constructors
constexpr Optional() { }
constexpr Optional(NulloptT) { }
Optional(const Optional& other) : base_flag(other.constructed()) {
if (this->constructed()) {
new (&get()) T(other.get());
}
}
Optional(Optional&& other) : base_flag(other.constructed()) {
if (this->constructed()) {
new (&get()) T(std::move(other.get()));
}
}
// Conversion constructor from optional of similar type
template<class U, class = enable_if_c<!is_any_optional<U>::value &&
std::is_constructible<T, U>::value>>
Optional(const Optional<U>& other) : base_flag(other.constructed()) {
if (this->constructed()) {
new (&get()) T(other.get());
}
}
// Move-conversion constructor
template<class U, class = enable_if_c<!is_any_optional<U>::value &&
std::is_constructible<T, U>::value>>
Optional(Optional<U>&& other) : base_flag(other.constructed()) {
if (this->constructed()) {
new (&get()) T(std::move(other.get()));
}
}
// Construction from a raw value
Optional(const T& value) : base_flag(true) { new (&get()) T(value); }
// Move construction from a raw value
Optional(T&& value) : base_flag(true) { new (&get()) T(std::move(value)); }
// Inplace construction from a list of |T|'s ctor arguments
template<class... Args>
Optional(InplaceT, Args&&... args) : base_flag(true) {
new (&get()) T(std::forward<Args>(args)...);
}
// Inplace construction from an initializer list passed into |T|'s ctor
template<class U, class = enable_if<
std::is_constructible<T, std::initializer_list<U>>>>
Optional(InplaceT, std::initializer_list<U> il) : base_flag(true) {
new (&get()) T(il);
}
// direct assignment
Optional& operator=(const Optional& other) {
if (&other == this) {
return *this;
}
if (this->constructed()) {
if (other.constructed()) {
get() = other.get();
} else {
destruct();
this->setConstructed(false);
}
} else {
if (other.constructed()) {
new (&get()) T(other.get());
this->setConstructed(true);
} else {
; // we're good
}
}
return *this;
}
// move assignment
Optional& operator=(Optional&& other) {
if (this->constructed()) {
if (other.constructed()) {
get() = std::move(other.get());
} else {
destruct();
this->setConstructed(false);
}
} else {
if (other.constructed()) {
new (&get()) T(std::move(other.get()));
this->setConstructed(true);
} else {
; // we're good
}
}
return *this;
}
// conversion assignment
template<class U,
class = enable_if_convertible<typename std::decay<U>::type, T>>
Optional& operator=(const Optional<U>& other) {
if (this->constructed()) {
if (other.constructed()) {
get() = other.get();
} else {
destruct();
this->setConstructed(false);
}
} else {
if (other.constructed()) {
new (&get()) T(other.get());
this->setConstructed(true);
} else {
; // we're good
}
}
return *this;
}
// conversion move assignment
template<class U,
class = enable_if_convertible<typename std::decay<U>::type, T>>
Optional& operator=(Optional<U>&& other) {
if (this->constructed()) {
if (other.constructed()) {
get() = std::move(other.get());
} else {
destruct();
this->setConstructed(false);
}
} else {
if (other.constructed()) {
new (&get()) T(std::move(other.get()));
this->setConstructed(true);
} else {
; // we're good
}
}
return *this;
}
// the most complicated one: forwarding constructor for anything convertible
// to |T|, excluding the stuff implemented above explicitly
template<class U,
class = enable_if_c<
!is_any_optional<typename std::decay<U>::type>::value &&
std::is_convertible<typename std::decay<U>::type, T>::value>>
Optional& operator=(U&& other) {
if (this->constructed()) {
get() = std::forward<U>(other);
} else {
new (&get()) T(std::forward<U>(other));
this->setConstructed(true);
}
return *this;
}
// Adopt value checkers from the parent
using base_flag::operator bool;
using base_flag::hasValue;
T& value() {
assert(this->constructed());
return get();
}
constexpr const T& value() const {
assert(this->constructed());
return get();
}
T* ptr() { return this->constructed() ? &get() : nullptr; }
constexpr const T* ptr() const {
return this->constructed() ? &get() : nullptr;
}
// Value getter with fallback
template<class U = T,
class = enable_if_convertible<typename std::decay<U>::type, T>>
constexpr T valueOr(U&& defaultValue) const {
return this->constructed() ? get() : std::move(defaultValue);
}
// Pointer-like operators
T& operator*() {
assert(this->constructed());
return get();
}
constexpr const T& operator*() const {
assert(this->constructed());
return get();
}
T* operator->() {
assert(this->constructed());
return &get();
}
constexpr const T* operator->() const {
assert(this->constructed());
return &get();
}
~Optional() {
if (this->constructed()) {
destruct();
}
}
void clear() {
if (this->constructed()) {
destruct();
this->setConstructed(false);
}
}
template<class U,
class = enable_if_convertible<typename std::decay<U>::type, T>>
void reset(U&& u) {
*this = std::forward<U>(u);
}
// In-place construction with possible destruction of the old value
template<class... Args>
void emplace(Args&&... args) {
if (this->constructed()) {
destruct();
}
new (&get()) T(std::forward<Args>(args)...);
this->setConstructed(true);
}
// In-place construction with possible destruction of the old value
// initializer-list version
template<class U, class = enable_if<
std::is_constructible<T, std::initializer_list<U>>>>
void emplace(std::initializer_list<U> il) {
if (this->constructed()) {
destruct();
}
new (&get()) T(il);
this->setConstructed(true);
}
private:
// A helper function to convert the internal raw storage to T&
constexpr const T& get() const {
return *reinterpret_cast<const T*>(
reinterpret_cast<const char*>(&this->mStorage));
}
// Same thing, mutable
T& get() { return const_cast<T&>(const_cast<const Optional*>(this)->get()); }
// Shortcut for a destructor call for the stored object
void destruct() { get().T::~T(); }
};
template<class T>
Optional<typename std::decay<T>::type> makeOptional(T&& t) {
return Optional<typename std::decay<T>::type>(std::forward<T>(t));
}
template<class T, class... Args>
Optional<typename std::decay<T>::type> makeOptional(Args&&... args) {
return Optional<typename std::decay<T>::type>(kInplace,
std::forward<Args>(args)...);
}
template<class T>
bool operator==(const Optional<T>& l, const Optional<T>& r) {
return l.hasValue() ? r.hasValue() && *l == *r : !r.hasValue();
}
template<class T>
bool operator==(const Optional<T>& l, NulloptT) {
return !l;
}
template<class T>
bool operator==(NulloptT, const Optional<T>& r) {
return !r;
}
template<class T>
bool operator==(const Optional<T>& l, const T& r) {
return bool(l) && *l == r;
}
template<class T>
bool operator==(const T& l, const Optional<T>& r) {
return bool(r) && l == *r;
}
template<class T>
bool operator!=(const Optional<T>& l, const Optional<T>& r) {
return !(l == r);
}
template<class T>
bool operator!=(const Optional<T>& l, NulloptT) {
return bool(l);
}
template<class T>
bool operator!=(NulloptT, const Optional<T>& r) {
return bool(r);
}
template<class T>
bool operator!=(const Optional<T>& l, const T& r) {
return !l || !(*l == r);
}
template<class T>
bool operator!=(const T& l, const Optional<T>& r) {
return !r || !(l == *r);
}
template<class T>
bool operator<(const Optional<T>& l, const Optional<T>& r) {
return !r ? false : (!l ? true : *l < *r);
}
template<class T>
bool operator<(const Optional<T>&, NulloptT) {
return false;
}
template<class T>
bool operator<(NulloptT, const Optional<T>& r) {
return bool(r);
}
template<class T>
bool operator<(const Optional<T>& l, const T& r) {
return !l || *l < r;
}
template<class T>
bool operator<(const T& l, const Optional<T>& r) {
return bool(r) && l < *r;
}
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_OPTIONAL_H_

69
3rdparty/astc-codec/src/base/string_utils.h vendored
View File

@@ -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.
#ifndef ASTC_CODEC_BASE_STRING_UTILS_H_
#define ASTC_CODEC_BASE_STRING_UTILS_H_
#include <limits>
#include <string>
#include <stdlib.h>
namespace astc_codec {
namespace base {
// Iterates over a string's parts using |splitBy| as a delimiter.
// |splitBy| must be a nonempty string well, or it's a no-op.
// Otherwise, |func| is called on each of the splits, excluding the
// characters that are part of |splitBy|. If two |splitBy|'s occur in a row,
// |func| will be called on a StringView("") in between. See
// StringUtils_unittest.cpp for the full story.
template<class Func>
void Split(const std::string& str, const std::string& splitBy, Func func) {
if (splitBy.empty()) {
return;
}
size_t splitSize = splitBy.size();
size_t begin = 0;
size_t end = str.find(splitBy);
while (true) {
func(str.substr(begin, end - begin));
if (end == std::string::npos) {
return;
}
begin = end + splitSize;
end = str.find(splitBy, begin);
}
}
static int32_t ParseInt32(const char* str, int32_t deflt) {
using std::numeric_limits;
char* error = nullptr;
int64_t value = strtol(str, &error, 0);
// Limit long values to int32 min/max. Needed for lp64; no-op on 32 bits.
if (value > std::numeric_limits<int32_t>::max()) {
value = std::numeric_limits<int32_t>::max();
} else if (value < std::numeric_limits<int32_t>::min()) {
value = std::numeric_limits<int32_t>::min();
}
return (error == str) ? deflt : static_cast<int32_t>(value);
}
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_STRING_UTILS_H_

172
3rdparty/astc-codec/src/base/type_traits.h vendored
View File

@@ -1,172 +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.
#ifndef ASTC_CODEC_BASE_TYPE_TRAITS_H_
#define ASTC_CODEC_BASE_TYPE_TRAITS_H_
#include <iterator>
#include <type_traits>
namespace astc_codec {
namespace base {
namespace details {
// a simple helper class for SFINAE below.
template<class X = void>
struct dummy {
using type = X;
};
} // namespace details
// add some convenience shortcuts for an overly complex std::enable_if syntax
// Use 'enable_if<Predicate,Type>' instead of
// 'typename std::enable_if<Predicate::value,Type>::type'
template<class Predicate, class Type = void*>
using enable_if = typename std::enable_if<Predicate::value, Type>::type;
// Use 'enable_if_c<BooleanFlag,Type>' instead of
// 'typename std::enable_if<BooleanFlag,Type>::type'
template<bool predicate, class Type = void*>
using enable_if_c = typename std::enable_if<predicate, Type>::type;
// Use 'enable_if_convertible<From,To,Type>' instead of
// 'typename std::enable_if<std::is_convertible<From,To>::value, Type>::type'
template<class From, class To, class Type = void*>
using enable_if_convertible = enable_if<std::is_convertible<From, To>>;
// -----------------------------------------------------------------------------
// A predicate for checking if some object is callable with a specific
// signature. Examples:
//
// is_callable_as<int, void()>::value == false.
// is_callable_as<strcmp, void()>::value == false.
// is_callable_as<strcmp, int(const char*, const char*)>::value == true
//
template<class F, class Signature, class X = void>
struct is_callable_as : std::false_type {};
// This specialization is SFINAE-d out if template arguments can't be combined
// into a call expression F(), or if the result of that call is not |R|
template<class F, class R, class... Args>
struct is_callable_as<F, R(Args...),
typename std::enable_if<std::is_same<
typename details::dummy<decltype(std::declval<F>()(
std::declval<Args>()...))>::type,
R>::value>::type> : std::true_type {};
//
// A similar predicate to only check arguments of the function call and ignore
// the specified return type
//
// is_callable_as<strcmp, int(const char*, const char*)>::value == true
// is_callable_as<strcmp, void(const char*, const char*)>::value == false
// is_callable_with_args<strcmp, void(const char*, const char*)>::value == true
//
template<class F, class Signature, class X = void>
struct is_callable_with_args : std::false_type {};
template<class F, class R, class... Args>
struct is_callable_with_args<
F, R(Args...),
typename std::enable_if<
!std::is_same<typename details::dummy<decltype(
std::declval<F>()(std::declval<Args>()...))>::type,
F>::value>::type> : std::true_type {};
// -----------------------------------------------------------------------------
// Check if a type |T| is any instantiation of a template |U|. Examples:
//
// is_template_instantiation_of<int, std::vector>::value == false
// is_template_instantiation_of<
// std::list<std::vector<int>>, std::vector>::value == false
// is_template_instantiation_of<std::vector<int>, std::vector>::value == true
// is_template_instantiation_of<
// std::vector<std::vector<int>>, std::vector>::value == true
//
template<class T, template<class...> class U>
struct is_template_instantiation_of : std::false_type {};
template<template<class...> class U, class... Args>
struct is_template_instantiation_of<U<Args...>, U> : std::true_type {};
// -----------------------------------------------------------------------------
//
// is_range<T> - check if type |T| is a range-like type.
//
// It makes sure that expressions std::begin(t) and std::end(t) are well-formed
// and those return the same type.
//
// Note: with expression SFINAE from C++14 is_range_helper<> could be renamed to
// is_range<> with no extra code. C++11 needs an extra level of enable_if<>
// to make it work when the type isn't a range.
//
namespace details {
template<class T>
using is_range_helper = std::is_same<
decltype(std::begin(
std::declval<typename std::add_lvalue_reference<T>::type>())),
decltype(
std::end(std::declval<typename std::add_lvalue_reference<T>::type>()))>;
} // namespace details
template<class T, class = void>
struct is_range : std::false_type {};
template<class T>
struct is_range<
T, typename std::enable_if<details::is_range_helper<T>::value>::type>
: std::true_type {};
////////////////////////////////////////////////////////////////////////////////
//
// A class to incapsulate integer sequence 0, 1, ..., <num_args>
// Seq<int...>
// Useful to pass function parameters in an array/tuple to call it later.
//
template<int...>
struct Seq {};
// A 'maker' class to construct Seq<int...> given only <num_args>
// value.
// MakeSeq<N, S...> works this way, e.g.
//
// MakeSeq<2> inherits MakeSeq<2 - 1, 2 - 1> == MakeSeq<1, 1>
// MakeSeq<1, 1> : MakeSeq<1 - 1, 1 - 1, 1> == MakeSeq<0, 0, 1>
// MakeSeq<0, 0, 1> == MakeSeq<0, S...> and defines |type| = Seq<0, 1>
template<int N, int... S>
struct MakeSeq : MakeSeq<N - 1, N - 1, S...> {};
template<int... S>
struct MakeSeq<0, S...> {
using type = Seq<S...>;
};
//
// MakeSeqT alias to quickly create Seq<...>:
// MakeSeqT<3> == Seq<0, 1, 2>
template<int... S>
using MakeSeqT = typename MakeSeq<S...>::type;
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_TYPE_TRAITS_H_

175
3rdparty/astc-codec/src/base/uint128.h vendored
View File

@@ -1,175 +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.
#ifndef ASTC_CODEC_BASE_UINT128_H_
#define ASTC_CODEC_BASE_UINT128_H_
#include <cassert>
#include <cstdint>
namespace astc_codec {
namespace base {
class UInt128 {
public:
UInt128() = default;
UInt128(uint64_t low) : low_(low) { }
UInt128(uint64_t high, uint64_t low) : low_(low), high_(high) { }
UInt128(const UInt128& other) : low_(other.low_), high_(other.high_) { }
uint64_t LowBits() const { return low_; }
uint64_t HighBits() const { return high_; }
// Allow explicit casts to uint64_t.
explicit operator uint64_t() const { return low_; }
// Copy operators.
UInt128& operator=(const UInt128& other) {
high_ = other.high_;
low_ = other.low_;
return *this;
}
// Equality operators.
bool operator==(const UInt128& other) const {
return high_ == other.high_ && low_ == other.low_;
}
bool operator!=(const UInt128& other) const {
return high_ != other.high_ || low_ != other.low_;
}
// Shifting.
UInt128& operator<<=(int shift) {
high_ = shift >= 64 ? (shift >= 128 ? 0 : low_ << (shift - 64))
: high_ << shift;
if (shift > 0 && shift < 64) {
const uint64_t overlappingBits = low_ >> (64 - shift);
high_ |= overlappingBits;
}
low_ = shift >= 64 ? 0 : low_ << shift;
return *this;
}
UInt128 operator<<(int shift) const {
UInt128 result = *this;
result <<= shift;
return result;
}
UInt128& operator>>=(int shift) {
low_ = shift >= 64 ? (shift >= 128 ? 0 : high_ >> (shift - 64))
: low_ >> shift;
if (shift > 0 && shift < 64) {
const uint64_t overlappingBits = high_ << (64 - shift);
low_ |= overlappingBits;
}
high_ = shift >= 64 ? 0 : high_ >> shift;
return *this;
}
UInt128 operator>>(int shift) const {
UInt128 result = *this;
result >>= shift;
return result;
}
// Binary operations.
UInt128& operator|=(const UInt128& other) {
high_ |= other.high_;
low_ |= other.low_;
return *this;
}
UInt128 operator|(const UInt128& other) const {
UInt128 result = *this;
result |= other;
return result;
}
UInt128& operator&=(const UInt128& other) {
high_ &= other.high_;
low_ &= other.low_;
return *this;
}
UInt128 operator&(const UInt128& other) const {
UInt128 result = *this;
result &= other;
return result;
}
UInt128& operator^=(const UInt128& other) {
high_ ^= other.high_;
low_ ^= other.low_;
return *this;
}
UInt128 operator^(const UInt128& other) const {
UInt128 result = *this;
result ^= other;
return result;
}
UInt128 operator~() const {
UInt128 result = *this;
result.high_ = ~high_;
result.low_ = ~low_;
return result;
}
// Addition/subtraction.
UInt128& operator+=(const UInt128& other) {
const uint64_t carry =
(((low_ & other.low_) & 1) + (low_ >> 1) + (other.low_ >> 1)) >> 63;
high_ += other.high_ + carry;
low_ += other.low_;
return *this;
}
UInt128 operator+(const UInt128& other) const {
UInt128 result = *this;
result += other;
return result;
}
UInt128& operator-=(const UInt128& other) {
low_ -= other.low_;
const uint64_t carry =
(((low_ & other.low_) & 1) + (low_ >> 1) + (other.low_ >> 1)) >> 63;
high_ -= other.high_ + carry;
return *this;
}
UInt128 operator-(const UInt128& other) const {
UInt128 result = *this;
result -= other;
return result;
}
private:
// TODO(google): Different order for little endian.
uint64_t low_ = 0;
uint64_t high_ = 0;
};
} // namespace base
} // namespace astc_codec
#endif // ASTC_CODEC_BASE_UINT128_H_

35
3rdparty/astc-codec/src/base/utils.h vendored
View File

@@ -1,35 +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.
#ifndef ASTC_CODEC_BASE_UTILS_H_
#define ASTC_CODEC_BASE_UTILS_H_
#include <cassert>
#include <cstdio>
#include <cstdlib>
#ifdef NDEBUG
#define UTILS_RELEASE_ASSERT(x) \
do { \
const bool result = (x); \
if (!result) { \
fprintf(stderr, "Error: UTILS_RELEASE_ASSERT failed: %s\n", #x); \
abort(); \
} \
} while (false)
#else
#define UTILS_RELEASE_ASSERT(x) assert(x)
#endif
#endif // ASTC_CODEC_BASE_UTILS_H_

185
3rdparty/astc-codec/src/decoder/astc_file.cc vendored
View File

@@ -1,185 +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/astc_file.h"
#include <cstring>
#include <fstream>
#include <memory>
#include <sstream>
namespace astc_codec {
namespace {
static constexpr size_t kASTCHeaderSize = 16;
// Reads a value of size T from the buffer at the current offset, then
// increments the offset.
template<typename T>
inline T ReadVal(const char* file_data, size_t& offset) {
T x;
memcpy(&x, &file_data[offset], sizeof(T));
offset += sizeof(T);
return x;
}
} // namespace
ASTCFile::ASTCFile(Header&& header, std::string&& blocks)
: header_(std::move(header)), blocks_(std::move(blocks)) {}
std::unique_ptr<ASTCFile> ASTCFile::LoadFromMemory(const char* data,
size_t length,
std::string* error) {
if (length < kASTCHeaderSize) {
*error = "Incomplete header.";
return nullptr;
}
base::Optional<Header> header_opt = ParseHeader(data);
if (!header_opt) {
*error = "Invalid ASTC header.";
return nullptr;
}
Header header = header_opt.value();
if (header.block_width_ == 0 || header.block_height_ == 0) {
*error = "Invalid block size.";
return nullptr;
}
std::string blocks(data + kASTCHeaderSize, data + length);
// Check that this file has the expected number of blocks.
const size_t expected_block_count =
((header.width_ + header.block_width_ - 1) / header.block_width_) *
((header.height_ + header.block_height_ - 1) / header.block_height_);
if (blocks.size() % PhysicalASTCBlock::kSizeInBytes != 0 ||
blocks.size() / PhysicalASTCBlock::kSizeInBytes != expected_block_count) {
std::stringstream ss;
ss << "Unexpected file length " << blocks.size() << " expected "
<< kASTCHeaderSize +
expected_block_count * PhysicalASTCBlock::kSizeInBytes
<< " bytes.";
*error = ss.str();
return nullptr;
}
return std::unique_ptr<ASTCFile>(
new ASTCFile(std::move(header), std::move(blocks)));
}
std::unique_ptr<ASTCFile> ASTCFile::LoadFile(const std::string& path,
std::string* error) {
std::ifstream is(path, std::ios::binary);
if (!is) {
*error = "File not found: " + path;
return nullptr;
}
char header_data[kASTCHeaderSize] = {};
if (!is.read(header_data, kASTCHeaderSize)) {
*error = "Failed to load ASTC header.";
return nullptr;
}
base::Optional<Header> header_opt = ParseHeader(header_data);
if (!header_opt) {
*error = "Invalid ASTC header.";
return nullptr;
}
Header header = header_opt.value();
std::string blocks;
{
std::ostringstream ss;
ss << is.rdbuf();
blocks = ss.str();
}
// Check that this file has the expected number of blocks.
const size_t expected_block_count =
((header.width_ + header.block_width_ - 1) / header.block_width_) *
((header.height_ + header.block_height_ - 1) / header.block_height_);
if (blocks.size() % PhysicalASTCBlock::kSizeInBytes != 0 ||
blocks.size() / PhysicalASTCBlock::kSizeInBytes != expected_block_count) {
std::stringstream ss;
ss << "Unexpected file length " << blocks.size() << " expected "
<< kASTCHeaderSize +
expected_block_count * PhysicalASTCBlock::kSizeInBytes
<< " bytes.";
*error = ss.str();
return nullptr;
}
return std::unique_ptr<ASTCFile>(
new ASTCFile(std::move(header), std::move(blocks)));
}
base::Optional<Footprint> ASTCFile::GetFootprint() const {
return Footprint::FromDimensions(int(header_.block_width_), int(header_.block_height_));
}
std::string ASTCFile::GetFootprintString() const {
std::stringstream footprint;
footprint << header_.block_width_ << "x" << header_.block_height_;
return footprint.str();
}
const std::string& ASTCFile::GetRawBlockData() const {
return blocks_;
}
PhysicalASTCBlock ASTCFile::GetBlock(size_t block_idx) const {
const size_t sz = PhysicalASTCBlock::kSizeInBytes;
const size_t offset = PhysicalASTCBlock::kSizeInBytes * block_idx;
assert(offset <= blocks_.size() - sz);
return PhysicalASTCBlock(blocks_.substr(offset, sz));
}
base::Optional<ASTCFile::Header> ASTCFile::ParseHeader(const char* header) {
size_t offset = 0;
// TODO(google): Handle endianness.
const uint32_t magic = ReadVal<uint32_t>(header, offset);
if (magic != 0x5CA1AB13) {
return {};
}
const uint32_t block_width = ReadVal<uint8_t>(header, offset);
const uint32_t block_height = ReadVal<uint8_t>(header, offset);
const uint32_t block_depth = ReadVal<uint8_t>(header, offset);
uint32_t width = 0;
width |= ReadVal<uint8_t>(header, offset);
width |= ReadVal<uint8_t>(header, offset) << 8;
width |= ReadVal<uint8_t>(header, offset) << 16;
uint32_t height = 0;
height |= ReadVal<uint8_t>(header, offset);
height |= ReadVal<uint8_t>(header, offset) << 8;
height |= ReadVal<uint8_t>(header, offset) << 16;
uint32_t depth = 0;
depth |= ReadVal<uint8_t>(header, offset);
depth |= ReadVal<uint8_t>(header, offset) << 8;
depth |= ReadVal<uint8_t>(header, offset) << 16;
assert(offset == kASTCHeaderSize);
return Header(width, height, depth, block_width, block_height, block_depth);
}
} // namespace astc_codec

97
3rdparty/astc-codec/src/decoder/astc_file.h vendored
View File

@@ -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.
#ifndef ASTC_CODEC_DECODER_ASTC_FILE_H_
#define ASTC_CODEC_DECODER_ASTC_FILE_H_
#include "src/base/optional.h"
#include "src/decoder/footprint.h"
#include "src/decoder/physical_astc_block.h"
#include <memory>
#include <string>
namespace astc_codec {
// A thin wrapper around a .astc file on disk. This class simply reads the ASTC
// header, and stores the block data in memory.
class ASTCFile {
private:
struct Header {
Header(size_t width, size_t height, size_t depth, size_t block_width,
size_t block_height, size_t block_depth)
: width_(width),
height_(height),
depth_(depth),
block_width_(block_width),
block_height_(block_height),
block_depth_(block_depth) {}
size_t width_;
size_t height_;
size_t depth_;
size_t block_width_;
size_t block_height_;
size_t block_depth_;
};
ASTCFile(ASTCFile::Header&& header, std::string&& blocks);
public:
// Load an ASTC file from memory.
// If loading failed, nullptr is returned and an error string is populated
// in the error parameter.
static std::unique_ptr<ASTCFile> LoadFromMemory(const char* data,
size_t length,
std::string* error);
// Load an ASTC file from file.
// If loading failed, nullptr is returned and an error string is populated
// in the error parameter.
static std::unique_ptr<ASTCFile> LoadFile(const std::string& path,
std::string* error);
// Returns the footprint for the file, if it is considered to be a valid
// footprint.
base::Optional<Footprint> GetFootprint() const;
// Returns the string of the form "NxM" where N and M are the width and height
// of the block footprint, respectively.
std::string GetFootprintString() const;
// Get the raw block data for the astc file.
const std::string& GetRawBlockData() const;
// Returns the physical block at the associated block index.
PhysicalASTCBlock GetBlock(size_t block_idx) const;
size_t GetWidth() const { return header_.width_; }
size_t GetHeight() const { return header_.height_; }
size_t GetDepth() const { return header_.depth_; }
size_t NumBlocks() const {
return blocks_.size() / PhysicalASTCBlock::kSizeInBytes;
}
private:
static base::Optional<ASTCFile::Header> ParseHeader(const char* header);
const Header header_;
const std::string blocks_;
};
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_ASTC_FILE_H_

132
3rdparty/astc-codec/src/decoder/codec.cc vendored
View File

@@ -1,132 +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 "src/base/uint128.h"
#include "src/decoder/logical_astc_block.h"
#include "src/decoder/physical_astc_block.h"
#include <cstring>
namespace astc_codec {
namespace {
static constexpr size_t kBytesPerPixelUNORM8 = 4;
}
bool DecompressToImage(const uint8_t* astc_data, size_t astc_data_size,
size_t width, size_t height, Footprint footprint,
uint8_t* out_buffer, size_t out_buffer_size,
size_t out_buffer_stride) {
const size_t block_width = footprint.Width();
const size_t block_height = footprint.Height();
assert(block_width != 0);
assert(block_height != 0);
if (width == 0 || height == 0) {
return false;
}
const size_t blocks_wide = (width + block_width - 1) / block_width;
assert(blocks_wide != 0);
// Check that this buffer has the expected number of blocks.
const size_t expected_block_count =
((width + block_width - 1) / block_width) *
((height + block_height - 1) / block_height);
if (astc_data_size % PhysicalASTCBlock::kSizeInBytes != 0 ||
astc_data_size / PhysicalASTCBlock::kSizeInBytes !=
expected_block_count) {
// TODO(google): Expose error?
return false;
}
if (kBytesPerPixelUNORM8 * width > out_buffer_stride ||
out_buffer_stride * height < out_buffer_size) {
// Output buffer too small.
return false;
}
base::UInt128 block;
static_assert(sizeof(block) == PhysicalASTCBlock::kSizeInBytes,
"Block size mismatch");
for (size_t i0 = 0; i0 < astc_data_size; i0 += PhysicalASTCBlock::kSizeInBytes) {
const size_t block_index = i0 / PhysicalASTCBlock::kSizeInBytes;
const size_t block_x = block_index % blocks_wide;
const size_t block_y = block_index / blocks_wide;
block = *(base::UInt128*)(astc_data + i0);
PhysicalASTCBlock physical_block(block);
auto lb = UnpackLogicalBlock(footprint, physical_block);
if (!lb) {
return false;
}
LogicalASTCBlock logical_block = lb.value();
for (size_t y = 0; y < block_height; ++y) {
const size_t py = block_height * block_y + y;
uint8_t* out_row = out_buffer + py * out_buffer_stride;
for (size_t x = 0; x < block_width; ++x) {
const size_t px = block_width * block_x + x;
// Skip out of bounds.
if (px >= width || py >= height) {
continue;
}
uint8_t* pixel = out_row + px * kBytesPerPixelUNORM8;
const RgbaColor decoded_color = logical_block.ColorAt(int(x), int(y));
for (size_t i = 0; i < kBytesPerPixelUNORM8; ++i) {
pixel[i] = static_cast<uint8_t>(decoded_color[i]);
}
}
}
}
return true;
}
bool DecompressToImage(const ASTCFile& file, uint8_t* out_buffer,
size_t out_buffer_size, size_t out_buffer_stride) {
base::Optional<Footprint> footprint = file.GetFootprint();
if (!footprint) {
return false;
}
return DecompressToImage(
reinterpret_cast<const uint8_t*>(file.GetRawBlockData().c_str()),
file.GetRawBlockData().size(), file.GetWidth(), file.GetHeight(),
footprint.value(), out_buffer, out_buffer_size, out_buffer_stride);
}
bool ASTCDecompressToRGBA(const uint8_t* astc_data, size_t astc_data_size,
size_t width, size_t height, FootprintType footprint,
uint8_t* out_buffer, size_t out_buffer_size,
size_t out_buffer_stride) {
base::Optional<Footprint> footprint_opt =
Footprint::FromFootprintType(footprint);
if (!footprint_opt) {
return false;
}
return DecompressToImage(astc_data, astc_data_size, width, height,
footprint_opt.value(), out_buffer, out_buffer_size,
out_buffer_stride);
}
} // namespace astc_codec

41
3rdparty/astc-codec/src/decoder/codec.h vendored
View File

@@ -1,41 +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.
#ifndef ASTC_CODEC_DECODER_CODEC_H_
#define ASTC_CODEC_DECODER_CODEC_H_
#include "src/decoder/astc_file.h"
#include "src/decoder/footprint.h"
#include <string>
namespace astc_codec {
// Decompresses ASTC blocks to an image buffer.
// Returns true if the decompression succeeded and the out buffer has been
// filled.
bool DecompressToImage(const uint8_t* astc_data, size_t astc_data_size,
size_t width, size_t height, Footprint footprint,
uint8_t* out_buffer, size_t out_buffer_size,
size_t out_buffer_stride);
// Decompresses an ASTC file to an image buffer.
// Returns true if the decompression succeeded and the out buffer has been
// filled.
bool DecompressToImage(const ASTCFile& file, uint8_t* out_buffer,
size_t out_buffer_size, size_t out_buffer_stride);
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_CODEC_H_

963
3rdparty/astc-codec/src/decoder/endpoint_codec.cc vendored
View File

@@ -1,963 +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/quantization.h"
#include <algorithm>
#include <array>
#include <numeric>
#include <utility>
namespace astc_codec {
namespace {
template<typename T>
T Clamp(T value, T min, T max) {
return value < min ? min : (value > max ? max : value);
}
// This is the 'blue_contract' function defined in Section C.2.14 of the ASTC
// specification.
template<typename ArrayType>
void BlueContract(ArrayType* const cptr) {
ArrayType& c = *cptr;
c[0] = (c[0] + c[2]) >> 1;
c[1] = (c[1] + c[2]) >> 1;
}
// Returns the inverse of values in BlueContract, subjected to the constraint
// that the new values are stored in the range [0, 255].
template<typename ArrayType>
ArrayType InvertBlueContract(const ArrayType& c) {
ArrayType result = c;
result[0] = Clamp(2 * c[0] - c[2], 0, 255);
result[1] = Clamp(2 * c[1] - c[2], 0, 255);
return result;
}
// This is the 'bit_transfer_signed' function defined in Section C.2.14 of the
// ASTC specification.
void BitTransferSigned(int* const a, int* const b) {
*b >>= 1;
*b |= *a & 0x80;
*a >>= 1;
*a &= 0x3F;
if ((*a & 0x20) != 0) {
*a -= 0x40;
}
}
// Takes two values, |a| in the range [-32, 31], and |b| in the range [0, 255],
// and returns the two values in [0, 255] that will reconstruct |a| and |b| when
// passed to the BitTransferSigned function.
void InvertBitTransferSigned(int* const a, int* const b) {
assert(*a >= -32); assert(*a < 32);
assert(*b >= 0); assert(*b < 256);
if (*a < 0) {
*a += 0x40;
}
*a <<= 1;
*a |= (*b & 0x80);
*b <<= 1;
*b &= 0xff;
}
template<typename ContainerType>
void Quantize(ContainerType* const c, size_t max_value) {
for (auto& x : *c) {
x = QuantizeCEValueToRange(x, int(max_value));
}
}
template<typename ArrayType>
ArrayType QuantizeColor(const ArrayType& c, size_t max_value) {
ArrayType result = c;
Quantize(&result, max_value);
return result;
}
template<typename ContainerType>
void Unquantize(ContainerType* const c, size_t max_value) {
for (auto& x : *c) {
x = UnquantizeCEValueFromRange(x, int(max_value));
}
}
template<typename ArrayType>
ArrayType UnquantizeColor(const ArrayType& c, size_t max_value) {
ArrayType result = c;
Unquantize(&result, max_value);
return result;
}
// Returns the average of the three RGB channels.
template<typename ContainerType>
int AverageRGB(const ContainerType& c) {
// Each channel can be in the range [0, 255], and we need to divide by three.
// However, we want to round the error properly. Both (x + 1) / 3 and
// (x + 2) / 3 are relatively imprecise when it comes to rounding, so instead
// we increase the precision by multiplying our numerator by some arbitrary
// number. Here, we choose 256 to get 8 additional bits and maintain
// performance since it turns into a shift rather than a multiply. Our
// denominator then becomes 3 * 256 = 768.
return (std::accumulate(c.begin(), c.begin() + 3, 0) * 256 + 384) / 768;
}
// Returns the sum of squared differences between each element of |a| and |b|,
// which are assumed to contain the same number of elements.
template<typename ContainerType>
const typename ContainerType::value_type SquaredError(
const ContainerType& a, const ContainerType& b,
size_t num_channels = std::tuple_size<ContainerType>::value) {
using ValueTy = typename ContainerType::value_type;
static_assert(std::is_signed<ValueTy>::value,
"Value type assumed to be signed to avoid branch below.");
ValueTy result = ValueTy(0);
for (size_t i = 0; i < num_channels; ++i) {
ValueTy error = a[i] - b[i];
result += error * error;
}
return result;
}
constexpr int MaxValuesForModes(ColorEndpointMode mode_a,
ColorEndpointMode mode_b) {
return (NumColorValuesForEndpointMode(mode_a) >
NumColorValuesForEndpointMode(mode_b))
? NumColorValuesForEndpointMode(mode_a)
: NumColorValuesForEndpointMode(mode_b);
}
// This function takes the two colors in |endpoint_low| and |endpoint_high| and
// encodes them into |vals| according to the ASTC spec in section C.2.14. It
// assumes that the two colors are close enough to grayscale that the encoding
// should use the ColorEndpointMode kLDRLumaBaseOffset or kLDRLumaDirect. Which
// one is chosen depends on which produces smaller error for the given
// quantization value stored in |max_value|
bool EncodeColorsLuma(const RgbaColor& endpoint_low,
const RgbaColor& endpoint_high,
int max_value, ColorEndpointMode* const astc_mode,
std::vector<int>* const vals) {
assert(vals->size() ==
size_t(NumValuesForEncodingMode(EndpointEncodingMode::kDirectLuma)));
int avg1 = AverageRGB(endpoint_low);
int avg2 = AverageRGB(endpoint_high);
// For the offset mode, L1 is strictly greater than L2, so if we are using
// it to encode the color values, we need to swap the weights and
// endpoints so that the larger of the two is the second endpoint.
bool needs_weight_swap = false;
if (avg1 > avg2) {
needs_weight_swap = true;
std::swap(avg1, avg2);
}
assert(avg1 <= avg2);
// Now, the first endpoint is based on the low-order six bits of the first
// value, and the high order two bits of the second value. The low order
// six bits of the second value are used as the (strictly positive) offset
// from the first value.
const int offset = std::min(avg2 - avg1, 0x3F);
const int quant_off_low =
QuantizeCEValueToRange((avg1 & 0x3F) << 2, max_value);
const int quant_off_high =
QuantizeCEValueToRange((avg1 & 0xC0) | offset, max_value);
const int quant_low = QuantizeCEValueToRange(avg1, max_value);
const int quant_high = QuantizeCEValueToRange(avg2, max_value);
RgbaColor unquant_off_low, unquant_off_high;
RgbaColor unquant_low, unquant_high;
(*vals)[0] = quant_off_low;
(*vals)[1] = quant_off_high;
DecodeColorsForMode(
*vals, max_value, ColorEndpointMode::kLDRLumaBaseOffset,
&unquant_off_low, &unquant_off_high);
(*vals)[0] = quant_low;
(*vals)[1] = quant_high;
DecodeColorsForMode(*vals, max_value, ColorEndpointMode::kLDRLumaDirect,
&unquant_low, &unquant_high);
const auto calculate_error =
[needs_weight_swap, &endpoint_low, &endpoint_high]
(const RgbaColor& low, const RgbaColor& high) {
int error = 0;
if (needs_weight_swap) {
error += SquaredError(low, endpoint_high);
error += SquaredError(high, endpoint_low);
} else {
error += SquaredError(low, endpoint_low);
error += SquaredError(high, endpoint_high);
}
return error;
};
const int direct_error = calculate_error(unquant_low, unquant_high);
const int off_error = calculate_error(unquant_off_low, unquant_off_high);
if (direct_error <= off_error) {
(*vals)[0] = quant_low;
(*vals)[1] = quant_high;
*astc_mode = ColorEndpointMode::kLDRLumaDirect;
} else {
(*vals)[0] = quant_off_low;
(*vals)[1] = quant_off_high;
*astc_mode = ColorEndpointMode::kLDRLumaBaseOffset;
}
return needs_weight_swap;
}
class QuantizedEndpointPair {
public:
QuantizedEndpointPair(const RgbaColor& c_low, const RgbaColor& c_high,
int max_value)
: orig_low_(c_low),
orig_high_(c_high),
quant_low_(QuantizeColor(c_low, max_value)),
quant_high_(QuantizeColor(c_high, max_value)),
unquant_low_(UnquantizeColor(quant_low_, max_value)),
unquant_high_(UnquantizeColor(quant_high_, max_value)) { }
const RgbaColor& QuantizedLow() const { return quant_low_; }
const RgbaColor& QuantizedHigh() const { return quant_high_; }
const RgbaColor& UnquantizedLow() const { return unquant_low_; }
const RgbaColor& UnquantizedHigh() const { return unquant_high_; }
const RgbaColor& OriginalLow() const { return orig_low_; }
const RgbaColor& OriginalHigh() const { return orig_high_; }
private:
RgbaColor orig_low_;
RgbaColor orig_high_;
RgbaColor quant_low_;
RgbaColor quant_high_;
RgbaColor unquant_low_;
RgbaColor unquant_high_;
};
class CEEncodingOption {
public:
CEEncodingOption() { }
CEEncodingOption(
int squared_error, const QuantizedEndpointPair* quantized_endpoints,
bool swap_endpoints, bool blue_contract, bool use_offset_mode)
: squared_error_(squared_error),
quantized_endpoints_(quantized_endpoints),
swap_endpoints_(swap_endpoints),
blue_contract_(blue_contract),
use_offset_mode_(use_offset_mode) { }
// Returns true if able to generate valid |astc_mode| and |vals|. In some
// instances, such as if the endpoints reprsent a base/offset pair, we may not
// be able to guarantee blue-contract encoding due to how the base/offset pair
// are represented and the specifics of the decoding procedure. Similarly,
// some direct RGBA encodings also may not be able to emit blue-contract modes
// due to an unlucky combination of channels. In these instances, this
// function will return false, and all pointers will remain unmodified.
bool Pack(bool with_alpha, ColorEndpointMode* const astc_mode,
std::vector<int>* const vals, bool* const needs_weight_swap) const {
auto unquantized_low = quantized_endpoints_->UnquantizedLow();
auto unquantized_high = quantized_endpoints_->UnquantizedHigh();
// In offset mode, we do BitTransferSigned before analyzing the values
// of the endpoints in order to determine whether or not we're going to
// be using blue-contract mode.
if (use_offset_mode_) {
for (size_t i = 0; i < std::tuple_size<RgbaColor>::value; ++i) {
BitTransferSigned(&unquantized_high[i], &unquantized_low[i]);
}
}
// Define variables as outlined in the ASTC spec C.2.14 for the RGB[A]
// direct and base-offset modes
int s0 = 0, s1 = 0;
for (int i = 0; i < 3; ++i) {
s0 += unquantized_low[i];
s1 += unquantized_high[i];
}
// Can we guarantee a blue-contract mode if we want it? In other words,
// if we swap which endpoint is high and which endpoint is low, can we
// guarantee that we will hit the corresponding decode path?
bool swap_vals = false;
if (use_offset_mode_) {
if (blue_contract_) {
swap_vals = s1 >= 0;
} else {
swap_vals = s1 < 0;
}
// In offset mode, we have two different measurements that swap the
// endpoints prior to encoding, so we don't need to swap them here.
// If we need to swap them to guarantee a blue-contract mode, then
// abort and wait until we get the other error measurement.
if (swap_vals) {
return false;
}
} else {
if (blue_contract_) {
// If we want a blue_contract path, but s1 == s0, then swapping the
// values will have no effect.
if (s1 == s0) {
return false;
}
swap_vals = s1 > s0;
// If we're encoding blue contract mode directly, then we implicitly
// swap the endpoints during decode, meaning that we need to take
// note of that here.
*needs_weight_swap = !(*needs_weight_swap);
} else {
swap_vals = s1 < s0;
}
}
const auto* quantized_low = &(quantized_endpoints_->QuantizedLow());
const auto* quantized_high = &(quantized_endpoints_->QuantizedHigh());
if (swap_vals) {
assert(!use_offset_mode_);
std::swap(quantized_low, quantized_high);
*needs_weight_swap = !(*needs_weight_swap);
}
(*vals)[0] = quantized_low->at(0);
(*vals)[1] = quantized_high->at(0);
(*vals)[2] = quantized_low->at(1);
(*vals)[3] = quantized_high->at(1);
(*vals)[4] = quantized_low->at(2);
(*vals)[5] = quantized_high->at(2);
if (use_offset_mode_) {
*astc_mode = ColorEndpointMode::kLDRRGBBaseOffset;
} else {
*astc_mode = ColorEndpointMode::kLDRRGBDirect;
}
if (with_alpha) {
(*vals)[6] = quantized_low->at(3);
(*vals)[7] = quantized_high->at(3);
if (use_offset_mode_) {
*astc_mode = ColorEndpointMode::kLDRRGBABaseOffset;
} else {
*astc_mode = ColorEndpointMode::kLDRRGBADirect;
}
}
// If we swapped them to measure, then they need to be swapped after
// decoding
if (swap_endpoints_) {
*needs_weight_swap = !(*needs_weight_swap);
}
return true;
}
bool BlueContract() const { return blue_contract_; }
int Error() const { return squared_error_; }
private:
int squared_error_;
const QuantizedEndpointPair* quantized_endpoints_;
bool swap_endpoints_;
bool blue_contract_;
bool use_offset_mode_;
};
bool EncodeColorsRGBA(const RgbaColor& endpoint_low_rgba,
const RgbaColor& endpoint_high_rgba,
int max_value, bool with_alpha,
ColorEndpointMode* const astc_mode,
std::vector<int>* const vals) {
const size_t num_channels = with_alpha ? std::tuple_size<RgbaColor>::value : 3;
// The difficulty of encoding into this mode is determining whether or
// not we'd like to use the 'blue contract' function to reconstruct
// the endpoints and whether or not we'll be more accurate by using the
// base/offset color modes instead of quantizing the color channels
// directly. With that in mind, we:
// 1. Generate the inverted values for blue-contract and offset modes.
// 2. Quantize all of the different endpoints.
// 3. Unquantize each sets and decide which one gives least error
// 4. Encode the values correspondingly.
// 1. Generate the inverted values for blue-contract and offset modes.
const auto inv_bc_low = InvertBlueContract(endpoint_low_rgba);
const auto inv_bc_high = InvertBlueContract(endpoint_high_rgba);
RgbaColor direct_base, direct_offset;
for (size_t i = 0; i < std::tuple_size<RgbaColor>::value; ++i) {
direct_base[i] = endpoint_low_rgba[i];
direct_offset[i] =
Clamp(endpoint_high_rgba[i] - endpoint_low_rgba[i], -32, 31);
InvertBitTransferSigned(&direct_offset[i], &direct_base[i]);
}
RgbaColor inv_bc_base, inv_bc_offset;
for (size_t i = 0; i < std::tuple_size<RgbaColor>::value; ++i) {
// Remember, for blue-contract'd offset modes, the base is compared
// against the second endpoint and not the first.
inv_bc_base[i] = inv_bc_high[i];
inv_bc_offset[i] = Clamp(inv_bc_low[i] - inv_bc_high[i], -32, 31);
InvertBitTransferSigned(&inv_bc_offset[i], &inv_bc_base[i]);
}
// The order of the endpoints for offset modes may determine how well they
// approximate the given endpoints. It may be that the quantization value
// produces more accurate values for the base than the offset or
// vice/versa. For this reason, we need to generate quantized versions of
// the endpoints as if they were swapped to see if we get better error
// out of it.
RgbaColor direct_base_swapped, direct_offset_swapped;
for (size_t i = 0; i < std::tuple_size<RgbaColor>::value; ++i) {
direct_base_swapped[i] = endpoint_high_rgba[i];
direct_offset_swapped[i] =
Clamp(endpoint_low_rgba[i] - endpoint_high_rgba[i], -32, 31);
InvertBitTransferSigned(&direct_offset_swapped[i], &direct_base_swapped[i]);
}
RgbaColor inv_bc_base_swapped, inv_bc_offset_swapped;
for (size_t i = 0; i < std::tuple_size<RgbaColor>::value; ++i) {
// Remember, for blue-contract'd offset modes, the base is compared
// against the second endpoint and not the first. Hence, the swapped
// version will compare the base against the first endpoint.
inv_bc_base_swapped[i] = inv_bc_low[i];
inv_bc_offset_swapped[i] = Clamp(inv_bc_high[i] - inv_bc_low[i], -32, 31);
InvertBitTransferSigned(&inv_bc_offset_swapped[i], &inv_bc_base_swapped[i]);
}
// 2. Quantize the endpoints directly.
const QuantizedEndpointPair direct_quantized(
endpoint_low_rgba, endpoint_high_rgba, max_value);
const QuantizedEndpointPair bc_quantized(
inv_bc_low, inv_bc_high, max_value);
const QuantizedEndpointPair offset_quantized(
direct_base, direct_offset, max_value);
const QuantizedEndpointPair bc_offset_quantized(
inv_bc_base, inv_bc_offset, max_value);
const QuantizedEndpointPair offset_swapped_quantized(
direct_base_swapped, direct_offset_swapped, max_value);
const QuantizedEndpointPair bc_offset_swapped_quantized(
inv_bc_base_swapped, inv_bc_offset_swapped, max_value);
// 3. Unquantize each set and decide which one gives least error.
std::array<CEEncodingOption, 6> errors;
auto errors_itr = errors.begin();
// 3.1 regular unquantized error
{
const auto rgba_low = direct_quantized.UnquantizedLow();
const auto rgba_high = direct_quantized.UnquantizedHigh();
const int sq_rgb_error =
SquaredError(rgba_low, endpoint_low_rgba, num_channels) +
SquaredError(rgba_high, endpoint_high_rgba, num_channels);
const bool swap_endpoints = false;
const bool blue_contract = false;
const bool offset_mode = false;
*(errors_itr++) = CEEncodingOption(
sq_rgb_error, &direct_quantized,
swap_endpoints, blue_contract, offset_mode);
}
// 3.2 Compute blue-contract'd error.
{
auto bc_low = bc_quantized.UnquantizedLow();
auto bc_high = bc_quantized.UnquantizedHigh();
BlueContract(&bc_low);
BlueContract(&bc_high);
const int sq_bc_error =
SquaredError(bc_low, endpoint_low_rgba, num_channels) +
SquaredError(bc_high, endpoint_high_rgba, num_channels);
const bool swap_endpoints = false;
const bool blue_contract = true;
const bool offset_mode = false;
*(errors_itr++) = CEEncodingOption(
sq_bc_error, &bc_quantized,
swap_endpoints, blue_contract, offset_mode);
}
// 3.3 Compute base/offset unquantized error.
const auto compute_base_offset_error =
[num_channels, &errors_itr, &endpoint_low_rgba, &endpoint_high_rgba]
(const QuantizedEndpointPair& pair, bool swapped) {
auto base = pair.UnquantizedLow();
auto offset = pair.UnquantizedHigh();
for (size_t i = 0; i < num_channels; ++i) {
BitTransferSigned(&offset[i], &base[i]);
offset[i] = Clamp(base[i] + offset[i], 0, 255);
}
int base_offset_error = 0;
// If we swapped the endpoints going in, then without blue contract
// we should be comparing the base against the high endpoint.
if (swapped) {
base_offset_error =
SquaredError(base, endpoint_high_rgba, num_channels) +
SquaredError(offset, endpoint_low_rgba, num_channels);
} else {
base_offset_error =
SquaredError(base, endpoint_low_rgba, num_channels) +
SquaredError(offset, endpoint_high_rgba, num_channels);
}
const bool blue_contract = false;
const bool offset_mode = true;
*(errors_itr++) = CEEncodingOption(
base_offset_error, &pair, swapped, blue_contract, offset_mode);
};
compute_base_offset_error(offset_quantized, false);
// 3.4 Compute base/offset blue-contract error.
const auto compute_base_offset_blue_contract_error =
[num_channels, &errors_itr, &endpoint_low_rgba, &endpoint_high_rgba]
(const QuantizedEndpointPair& pair, bool swapped) {
auto base = pair.UnquantizedLow();
auto offset = pair.UnquantizedHigh();
for (size_t i = 0; i < num_channels; ++i) {
BitTransferSigned(&offset[i], &base[i]);
offset[i] = Clamp(base[i] + offset[i], 0, 255);
}
BlueContract(&base);
BlueContract(&offset);
int sq_bc_error = 0;
// Remember, for blue-contract'd offset modes, the base is compared
// against the second endpoint and not the first. So, we compare
// against the first if we swapped the endpoints going in.
if (swapped) {
sq_bc_error =
SquaredError(base, endpoint_low_rgba, num_channels) +
SquaredError(offset, endpoint_high_rgba, num_channels);
} else {
sq_bc_error =
SquaredError(base, endpoint_high_rgba, num_channels) +
SquaredError(offset, endpoint_low_rgba, num_channels);
}
const bool blue_contract = true;
const bool offset_mode = true;
*(errors_itr++) = CEEncodingOption(sq_bc_error, &pair,
swapped, blue_contract, offset_mode);
};
compute_base_offset_blue_contract_error(bc_offset_quantized, false);
// 3.5 Compute swapped base/offset error.
compute_base_offset_error(offset_swapped_quantized, true);
// 3.6 Compute swapped base/offset blue-contract error.
compute_base_offset_blue_contract_error(
bc_offset_swapped_quantized, true);
std::sort(errors.begin(), errors.end(),
[](const CEEncodingOption& a, const CEEncodingOption& b) {
return a.Error() < b.Error();
});
// 4. Encode the values correspondingly.
// For this part, we go through each measurement in order of increasing
// error. Based on the properties of each measurement, we decide how to
// best encode the quantized endpoints that produced that error value. If
// for some reason we cannot encode that metric, then we skip it and move
// to the next one.
for (const auto& measurement : errors) {
bool needs_weight_swap = false;
if (measurement.Pack(with_alpha, astc_mode, vals, &needs_weight_swap)) {
// Make sure that if we ask for a blue-contract mode that we get it *and*
// if we don't ask for it then we don't get it.
assert(!(measurement.BlueContract() ^
UsesBlueContract(max_value, *astc_mode, *vals)));
// We encoded what we got.
return needs_weight_swap;
}
}
assert(false && "Shouldn't have reached this point -- some combination of "
"endpoints should be possible to encode!");
return false;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
bool UsesBlueContract(int max_value, ColorEndpointMode mode,
const std::vector<int>& vals) {
assert(vals.size() >= size_t(NumColorValuesForEndpointMode(mode)));
switch (mode) {
case ColorEndpointMode::kLDRRGBDirect:
case ColorEndpointMode::kLDRRGBADirect: {
constexpr int kNumVals = MaxValuesForModes(
ColorEndpointMode::kLDRRGBDirect, ColorEndpointMode::kLDRRGBADirect);
std::array<int, kNumVals> v {};
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
const int s0 = v[0] + v[2] + v[4];
const int s1 = v[1] + v[3] + v[5];
return s0 > s1;
}
case ColorEndpointMode::kLDRRGBBaseOffset:
case ColorEndpointMode::kLDRRGBABaseOffset: {
constexpr int kNumVals = MaxValuesForModes(
ColorEndpointMode::kLDRRGBBaseOffset,
ColorEndpointMode::kLDRRGBABaseOffset);
std::array<int, kNumVals> v {};
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
BitTransferSigned(&v[1], &v[0]);
BitTransferSigned(&v[3], &v[2]);
BitTransferSigned(&v[5], &v[4]);
return v[1] + v[3] + v[5] < 0;
}
default:
return false;
}
}
bool EncodeColorsForMode(
const RgbaColor& endpoint_low_rgba, const RgbaColor& endpoint_high_rgba,
int max_value, EndpointEncodingMode encoding_mode,
ColorEndpointMode* const astc_mode, std::vector<int>* const vals) {
bool needs_weight_swap = false;
vals->resize(NumValuesForEncodingMode(encoding_mode));
switch (encoding_mode) {
case EndpointEncodingMode::kDirectLuma:
return EncodeColorsLuma(
endpoint_low_rgba, endpoint_high_rgba, max_value, astc_mode, vals);
case EndpointEncodingMode::kDirectLumaAlpha: {
// TODO(google): See if luma-alpha base-offset is better
const int avg1 = AverageRGB(endpoint_low_rgba);
const int avg2 = AverageRGB(endpoint_high_rgba);
(*vals)[0] = QuantizeCEValueToRange(avg1, max_value);
(*vals)[1] = QuantizeCEValueToRange(avg2, max_value);
(*vals)[2] = QuantizeCEValueToRange(endpoint_low_rgba[3], max_value);
(*vals)[3] = QuantizeCEValueToRange(endpoint_high_rgba[3], max_value);
*astc_mode = ColorEndpointMode::kLDRLumaAlphaDirect;
}
break;
case EndpointEncodingMode::kBaseScaleRGB:
case EndpointEncodingMode::kBaseScaleRGBA: {
RgbaColor base = endpoint_high_rgba;
RgbaColor scaled = endpoint_low_rgba;
// Similar to luma base-offset, the scaled value is strictly less than
// the base value here according to the decode procedure. In this case,
// if the base is larger than the scale then we need to swap.
int num_channels_ge = 0;
for (int i = 0; i < 3; ++i) {
num_channels_ge +=
static_cast<int>(endpoint_high_rgba[i] >= endpoint_low_rgba[i]);
}
if (num_channels_ge < 2) {
needs_weight_swap = true;
std::swap(base, scaled);
}
// Since the second endpoint is just a direct copy of the RGB values, we
// can start by quantizing them.
const auto q_base = QuantizeColor(base, max_value);
const auto uq_base = UnquantizeColor(q_base, max_value);
// The first endpoint (scaled) is defined by piecewise multiplying the
// second endpoint (base) by the scale factor and then dividing by 256.
// This means that the inverse operation is to first piecewise multiply
// the first endpoint by 256 and then divide by the unquantized second
// endpoint. We take the average of each of each of these scale values as
// our final scale value.
// TODO(google): Is this the best way to determine the scale factor?
int num_samples = 0;
int scale_sum = 0;
for (int i = 0; i < 3; ++i) {
int x = uq_base[i];
if (x != 0) {
++num_samples;
scale_sum += (scaled[i] * 256) / x;
}
}
(*vals)[0] = q_base[0];
(*vals)[1] = q_base[1];
(*vals)[2] = q_base[2];
if (num_samples > 0) {
const int avg_scale = Clamp(scale_sum / num_samples, 0, 255);
(*vals)[3] = QuantizeCEValueToRange(avg_scale, max_value);
} else {
// In this case, all of the base values are zero, so we can use whatever
// we want as the scale -- it won't affect the outcome.
(*vals)[3] = max_value;
}
*astc_mode = ColorEndpointMode::kLDRRGBBaseScale;
if (encoding_mode == EndpointEncodingMode::kBaseScaleRGBA) {
(*vals)[4] = QuantizeCEValueToRange(scaled[3], max_value);
(*vals)[5] = QuantizeCEValueToRange(base[3], max_value);
*astc_mode = ColorEndpointMode::kLDRRGBBaseScaleTwoA;
}
}
break;
case EndpointEncodingMode::kDirectRGB:
case EndpointEncodingMode::kDirectRGBA:
return EncodeColorsRGBA(
endpoint_low_rgba, endpoint_high_rgba, max_value,
encoding_mode == EndpointEncodingMode::kDirectRGBA, astc_mode, vals);
default:
assert(false && "Unimplemented color encoding.");
}
return needs_weight_swap;
}
// These decoding procedures follow the code outlined in Section C.2.14 of
// the ASTC specification.
void DecodeColorsForMode(const std::vector<int>& vals,
int max_value, ColorEndpointMode mode,
RgbaColor* const endpoint_low_rgba,
RgbaColor* const endpoint_high_rgba) {
assert(vals.size() >= size_t(NumColorValuesForEndpointMode(mode)));
switch (mode) {
case ColorEndpointMode::kLDRLumaDirect: {
const int l0 = UnquantizeCEValueFromRange(vals[0], max_value);
const int l1 = UnquantizeCEValueFromRange(vals[1], max_value);
*endpoint_low_rgba = {{ l0, l0, l0, 255 }};
*endpoint_high_rgba = {{ l1, l1, l1, 255 }};
}
break;
case ColorEndpointMode::kLDRLumaBaseOffset: {
const int v0 = UnquantizeCEValueFromRange(vals[0], max_value);
const int v1 = UnquantizeCEValueFromRange(vals[1], max_value);
const int l0 = (v0 >> 2) | (v1 & 0xC0);
const int l1 = std::min(l0 + (v1 & 0x3F), 0xFF);
*endpoint_low_rgba = {{ l0, l0, l0, 255 }};
*endpoint_high_rgba = {{ l1, l1, l1, 255 }};
}
break;
case ColorEndpointMode::kLDRLumaAlphaDirect: {
constexpr int kNumVals =
NumColorValuesForEndpointMode(ColorEndpointMode::kLDRLumaAlphaDirect);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
*endpoint_low_rgba = {{ v[0], v[0], v[0], v[2] }};
*endpoint_high_rgba = {{ v[1], v[1], v[1], v[3] }};
}
break;
case ColorEndpointMode::kLDRLumaAlphaBaseOffset: {
constexpr int kNumVals = NumColorValuesForEndpointMode(
ColorEndpointMode::kLDRLumaAlphaBaseOffset);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
BitTransferSigned(&v[1], &v[0]);
BitTransferSigned(&v[3], &v[2]);
*endpoint_low_rgba = {{ v[0], v[0], v[0], v[2] }};
const int high_luma = v[0] + v[1];
*endpoint_high_rgba = {{ high_luma, high_luma, high_luma, v[2] + v[3] }};
for (auto& c : *endpoint_low_rgba) { c = Clamp(c, 0, 255); }
for (auto& c : *endpoint_high_rgba) { c = Clamp(c, 0, 255); }
}
break;
case ColorEndpointMode::kLDRRGBBaseScale: {
constexpr int kNumVals =
NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBBaseScale);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
*endpoint_high_rgba = {{ v[0], v[1], v[2], 255 }};
for (int i = 0; i < 3; ++i) {
const int x = endpoint_high_rgba->at(i);
endpoint_low_rgba->at(i) = (x * v[3]) >> 8;
}
endpoint_low_rgba->at(3) = 255;
}
break;
case ColorEndpointMode::kLDRRGBDirect: {
constexpr int kNumVals =
NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBDirect);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
const int s0 = v[0] + v[2] + v[4];
const int s1 = v[1] + v[3] + v[5];
*endpoint_low_rgba = {{ v[0], v[2], v[4], 255 }};
*endpoint_high_rgba = {{ v[1], v[3], v[5], 255 }};
if (s1 < s0) {
std::swap(*endpoint_low_rgba, *endpoint_high_rgba);
BlueContract(endpoint_low_rgba);
BlueContract(endpoint_high_rgba);
}
}
break;
case ColorEndpointMode::kLDRRGBBaseOffset: {
constexpr int kNumVals =
NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBBaseOffset);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
BitTransferSigned(&v[1], &v[0]);
BitTransferSigned(&v[3], &v[2]);
BitTransferSigned(&v[5], &v[4]);
*endpoint_low_rgba = {{ v[0], v[2], v[4], 255 }};
*endpoint_high_rgba = {{ v[0] + v[1], v[2] + v[3], v[4] + v[5], 255 }};
if (v[1] + v[3] + v[5] < 0) {
std::swap(*endpoint_low_rgba, *endpoint_high_rgba);
BlueContract(endpoint_low_rgba);
BlueContract(endpoint_high_rgba);
}
for (auto& c : *endpoint_low_rgba) { c = Clamp(c, 0, 255); }
for (auto& c : *endpoint_high_rgba) { c = Clamp(c, 0, 255); }
}
break;
case ColorEndpointMode::kLDRRGBBaseScaleTwoA: {
constexpr int kNumVals = NumColorValuesForEndpointMode(
ColorEndpointMode::kLDRRGBBaseScaleTwoA);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
// Base
*endpoint_low_rgba = *endpoint_high_rgba = {{ v[0], v[1], v[2], 255 }};
// Scale
for (int i = 0; i < 3; ++i) {
auto& x = endpoint_low_rgba->at(i);
x = (x * v[3]) >> 8;
}
// Two A
endpoint_low_rgba->at(3) = v[4];
endpoint_high_rgba->at(3) = v[5];
}
break;
case ColorEndpointMode::kLDRRGBADirect: {
constexpr int kNumVals =
NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBADirect);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
const int s0 = v[0] + v[2] + v[4];
const int s1 = v[1] + v[3] + v[5];
*endpoint_low_rgba = {{ v[0], v[2], v[4], v[6] }};
*endpoint_high_rgba = {{ v[1], v[3], v[5], v[7] }};
if (s1 < s0) {
std::swap(*endpoint_low_rgba, *endpoint_high_rgba);
BlueContract(endpoint_low_rgba);
BlueContract(endpoint_high_rgba);
}
}
break;
case ColorEndpointMode::kLDRRGBABaseOffset: {
constexpr int kNumVals =
NumColorValuesForEndpointMode(ColorEndpointMode::kLDRRGBABaseOffset);
std::array<int, kNumVals> v;
std::copy(vals.begin(), vals.end(), v.begin());
Unquantize(&v, max_value);
BitTransferSigned(&v[1], &v[0]);
BitTransferSigned(&v[3], &v[2]);
BitTransferSigned(&v[5], &v[4]);
BitTransferSigned(&v[7], &v[6]);
*endpoint_low_rgba = {{ v[0], v[2], v[4], v[6] }};
*endpoint_high_rgba = {{
v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7] }};
if (v[1] + v[3] + v[5] < 0) {
std::swap(*endpoint_low_rgba, *endpoint_high_rgba);
BlueContract(endpoint_low_rgba);
BlueContract(endpoint_high_rgba);
}
for (auto& c : *endpoint_low_rgba) { c = Clamp(c, 0, 255); }
for (auto& c : *endpoint_high_rgba) { c = Clamp(c, 0, 255); }
}
break;
default:
// Unimplemented color encoding.
// TODO(google): Is this the correct error handling?
*endpoint_high_rgba = *endpoint_low_rgba = {{ 0, 0, 0, 0 }};
}
}
} // namespace astc_codec

90
3rdparty/astc-codec/src/decoder/endpoint_codec.h vendored
View File

@@ -1,90 +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.
#ifndef ASTC_CODEC_DECODER_ENDPOINT_CODEC_H_
#define ASTC_CODEC_DECODER_ENDPOINT_CODEC_H_
#include "src/decoder/physical_astc_block.h"
#include "src/decoder/types.h"
#include <array>
#include <vector>
namespace astc_codec {
// We use a special distinction for encode modes used to pass to the
// EncodeColorsForMode function below. The reason is that some of the color
// modes have sub-modes (like blue-contract) that change whether or not it is
// useful to encode an endpoint pair using one mode versus another. To avoid
// this problem, we approach the problem of encoding by specifying some
// high-level encoding modes. These eventually choose one of the low level
// ColorEndpointModes from Section C.2.14 when used in EncodeColorsForMode.
enum class EndpointEncodingMode {
kDirectLuma,
kDirectLumaAlpha,
kBaseScaleRGB,
kBaseScaleRGBA,
kDirectRGB,
kDirectRGBA
};
// Returns the number of values in the encoded endpoint pair after encoding
// to a specific high-level encoding mode.
constexpr int NumValuesForEncodingMode(EndpointEncodingMode mode) {
return
mode == EndpointEncodingMode::kDirectLuma ? 2 :
mode == EndpointEncodingMode::kDirectLumaAlpha ? 4 :
mode == EndpointEncodingMode::kBaseScaleRGB ? 4 :
mode == EndpointEncodingMode::kBaseScaleRGBA ? 6 :
mode == EndpointEncodingMode::kDirectRGB ? 6 : 8;
}
// Fills |vals| with the quantized endpoint colors values defined in the ASTC
// specification. The values are quantized to the range [0, max_value]. These
// quantization limits can be obtained by querying the associated functions in
// integer_sequence_codec. The returned |astc_mode| will be the ASTC mode used
// to encode the resulting sequence.
//
// The |encoding_mode| is used to determine the way that we encode the values.
// Each encoding mode is used to determine which ASTC mode best corresponds
// to the pair of endpoints. It is a necessary hint to the encoding function
// in order to process the endpoints. Each encoding mode gurantees a certain
// number of values generated per endpoints.
//
// The return value will be true if the endpoints have been switched in order to
// reap the most benefit from the way the hardware decodes the given mode. In
// this case, the associated weights that interpolate this color must also be
// switched. In other words, for each w, it should change to 64 - w.
bool EncodeColorsForMode(
const RgbaColor& endpoint_low_rgba, const RgbaColor& endpoint_high_rgba,
int max_value, EndpointEncodingMode encoding_mode,
ColorEndpointMode* astc_mode, std::vector<int>* vals);
// Decodes the color values quantized to the range [0, max_value] into RGBA
// endpoints for the given mode. This function is the inverse of
// EncodeColorsForMode -- see that function for details. This function should
// work on all LDR endpoint modes, but no HDR modes.
void DecodeColorsForMode(const std::vector<int>& vals,
int max_value, ColorEndpointMode mode,
RgbaColor* endpoint_low_rgba,
RgbaColor* endpoint_high_rgba);
// Returns true if the quantized |vals| in the range [0, max_value] use the
// 'blue_contract' modification during decoding for the given |mode|.
bool UsesBlueContract(int max_value, ColorEndpointMode mode,
const std::vector<int>& vals);
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_ENDPOINT_CODEC_H_

162
3rdparty/astc-codec/src/decoder/footprint.cc vendored
View File

@@ -1,162 +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 "src/base/string_utils.h"
#include <map>
#include <string>
#include <utility>
#include <vector>
namespace astc_codec {
namespace {
// Encodes the width and height into an integer so that we can use a switch
// statement instead of a costly lookup map.
constexpr int EncodeDims(int width, int height) {
return (width << 16) | height;
}
} // namespace
base::Optional<FootprintType>
Footprint::GetValidFootprintForDimensions(int width, int height) {
switch (EncodeDims(width, height)) {
case EncodeDims(4, 4): return FootprintType::k4x4;
case EncodeDims(5, 4): return FootprintType::k5x4;
case EncodeDims(5, 5): return FootprintType::k5x5;
case EncodeDims(6, 5): return FootprintType::k6x5;
case EncodeDims(6, 6): return FootprintType::k6x6;
case EncodeDims(8, 5): return FootprintType::k8x5;
case EncodeDims(8, 6): return FootprintType::k8x6;
case EncodeDims(8, 8): return FootprintType::k8x8;
case EncodeDims(10, 5): return FootprintType::k10x5;
case EncodeDims(10, 6): return FootprintType::k10x6;
case EncodeDims(10, 8): return FootprintType::k10x8;
case EncodeDims(10, 10): return FootprintType::k10x10;
case EncodeDims(12, 10): return FootprintType::k12x10;
case EncodeDims(12, 12): return FootprintType::k12x12;
default: return {};
}
}
int Footprint::GetWidthForFootprint(FootprintType footprint) {
switch (footprint) {
case FootprintType::k4x4: return 4;
case FootprintType::k5x4: return 5;
case FootprintType::k5x5: return 5;
case FootprintType::k6x5: return 6;
case FootprintType::k6x6: return 6;
case FootprintType::k8x5: return 8;
case FootprintType::k8x6: return 8;
case FootprintType::k10x5: return 10;
case FootprintType::k10x6: return 10;
case FootprintType::k8x8: return 8;
case FootprintType::k10x8: return 10;
case FootprintType::k10x10: return 10;
case FootprintType::k12x10: return 12;
case FootprintType::k12x12: return 12;
default:
assert(false);
return -1;
}
}
int Footprint::GetHeightForFootprint(FootprintType footprint) {
switch (footprint) {
case FootprintType::k4x4: return 4;
case FootprintType::k5x4: return 4;
case FootprintType::k5x5: return 5;
case FootprintType::k6x5: return 5;
case FootprintType::k6x6: return 6;
case FootprintType::k8x5: return 5;
case FootprintType::k8x6: return 6;
case FootprintType::k10x5: return 5;
case FootprintType::k10x6: return 6;
case FootprintType::k8x8: return 8;
case FootprintType::k10x8: return 8;
case FootprintType::k10x10: return 10;
case FootprintType::k12x10: return 10;
case FootprintType::k12x12: return 12;
default:
assert(false);
return -1;
}
}
Footprint::Footprint(FootprintType footprint)
: footprint_(footprint), width_(GetWidthForFootprint(footprint)),
height_(GetHeightForFootprint(footprint)) { }
////////////////////////////////////////////////////////////////////////////////
base::Optional<Footprint> Footprint::Parse(const char* footprint_string) {
assert(footprint_string && footprint_string[0] != '\0');
std::vector<std::string> dimension_strings;
base::Split(footprint_string, "x", [&dimension_strings](std::string&& s) {
dimension_strings.push_back(std::move(s));
});
if (dimension_strings.size() != 2) {
assert(false && "Invalid format for footprint");
return {};
}
const int width = base::ParseInt32(dimension_strings[0].c_str(), 0);
const int height = base::ParseInt32(dimension_strings[1].c_str(), 0);
assert(width > 0 && height > 0 && "Invalid width or height.");
return FromDimensions(width, height);
}
base::Optional<Footprint> Footprint::FromDimensions(int width, int height) {
base::Optional<FootprintType> valid_footprint =
GetValidFootprintForDimensions(width, height);
if (valid_footprint) {
return Footprint(valid_footprint.value());
} else {
return {};
}
}
// Returns a Footprint for the given FootprintType.
base::Optional<Footprint> Footprint::FromFootprintType(FootprintType type) {
if (type >= FootprintType::k4x4 && type < FootprintType::kCount) {
return Footprint(type);
} else {
return {};
}
}
size_t Footprint::StorageRequirements(int width, int height) const {
const int blocks_wide = (width + width_ - 1) / width_;
const int blocks_high = (height + height_ - 1) / height_;
constexpr size_t kASTCBlockSizeInBytes = 16;
return blocks_wide * blocks_high * kASTCBlockSizeInBytes;
}
// Returns bits/pixel for a given footprint.
float Footprint::Bitrate() const {
const int kASTCBlockBitCount = 128;
const int footprint_pixel_count = width_ * height_;
return static_cast<float>(kASTCBlockBitCount) /
static_cast<float>(footprint_pixel_count);
}
} // namespace astc_codec

106
3rdparty/astc-codec/src/decoder/footprint.h vendored
View File

@@ -1,106 +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.
#ifndef ASTC_CODEC_DECODER_FOOTPRINT_H_
#define ASTC_CODEC_DECODER_FOOTPRINT_H_
#include "include/astc-codec/astc-codec.h"
#include "src/base/optional.h"
#include <cstddef>
namespace astc_codec {
// An ASTC texture can be encoded with varying choices in block size. A set of
// predefined block sizes are specified in the ASTC specification. These are
// referred to in the literature as "footprints" available to an encoder when
// constructing an ASTC bitstream. This class provides various utility functions
// for interacting with these footprints.
class Footprint {
public:
Footprint() = delete;
Footprint(const Footprint& footprint) = default;
// Return the footprint type.
FootprintType Type() const { return footprint_; }
// Return logical descriptions of the dimensions.
int Width() const { return width_; }
int Height() const { return height_; }
// Returns the number of pixels for a block with this footprint.
int NumPixels() const { return width_ * height_; }
// Returns the number of bytes needed to store an ASTC encoded image with the
// given width and height.
size_t StorageRequirements(int width, int height) const;
// Returns the number of bits used per pixel.
float Bitrate() const;
static constexpr int NumValidFootprints() {
return static_cast<int>(FootprintType::kCount);
}
bool operator==(const Footprint& other) const {
return footprint_ == other.footprint_;
}
// These are the valid and available ASTC footprints.
static Footprint Get4x4() { return Footprint(FootprintType::k4x4); }
static Footprint Get5x4() { return Footprint(FootprintType::k5x4); }
static Footprint Get5x5() { return Footprint(FootprintType::k5x5); }
static Footprint Get6x5() { return Footprint(FootprintType::k6x5); }
static Footprint Get6x6() { return Footprint(FootprintType::k6x6); }
static Footprint Get8x5() { return Footprint(FootprintType::k8x5); }
static Footprint Get8x6() { return Footprint(FootprintType::k8x6); }
static Footprint Get8x8() { return Footprint(FootprintType::k8x8); }
static Footprint Get10x5() { return Footprint(FootprintType::k10x5); }
static Footprint Get10x6() { return Footprint(FootprintType::k10x6); }
static Footprint Get10x8() { return Footprint(FootprintType::k10x8); }
static Footprint Get10x10() { return Footprint(FootprintType::k10x10); }
static Footprint Get12x10() { return Footprint(FootprintType::k12x10); }
static Footprint Get12x12() { return Footprint(FootprintType::k12x12); }
// Constructs a footprint from a string of the form "NxM", or no value if
// width and height are not a valid footprint.
static base::Optional<Footprint> Parse(const char* footprint_string);
// Returns a footprint corresponding to a block of the given width and height,
// or no value if it does not.
static base::Optional<Footprint> FromDimensions(int width, int height);
// Returns a Footprint for the given FootprintType.
static base::Optional<Footprint> FromFootprintType(FootprintType type);
private:
// The only constructor.
explicit Footprint(FootprintType footprint);
// Returns the valid footprint for the width and height if possible.
static base::Optional<FootprintType> GetValidFootprintForDimensions(
int width, int height);
// Returns the associated dimension for the given valid footprint.
static int GetWidthForFootprint(FootprintType footprint);
static int GetHeightForFootprint(FootprintType footprint);
FootprintType footprint_;
int width_;
int height_;
};
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_FOOTPRINT_H_

574
3rdparty/astc-codec/src/decoder/integer_sequence_codec.cc vendored
View File

@@ -1,574 +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/math_utils.h"
#include "src/base/utils.h"
#include <algorithm>
#include <iostream>
namespace astc_codec {
namespace {
// Tables of trit and quint encodings generated by the implementation in
// http://cs/aosp-master/external/skia/src/utils/SkTextureCompressor_ASTC.cpp
//
// These tables are used to decode the blocks of values encoded using the ASTC
// integer sequence encoding. The theory is that five trits (values that can
// take any number in the range [0, 2]) can take on a total of 3^5 = 243 total
// values, which can be stored in eight bits. These eight bits are used to
// decode the five trits based on the ASTC specification in Section C.2.12.
// For simplicity, we have stored a look-up table here so that we don't need
// to implement the decoding logic. Similarly, seven bits are used to decode
// three quints (since 5^3 = 125 < 128).
static const std::array<int, 5> kTritEncodings[256] = {
{{ 0, 0, 0, 0, 0 }}, {{ 1, 0, 0, 0, 0 }}, {{ 2, 0, 0, 0, 0 }},
{{ 0, 0, 2, 0, 0 }}, {{ 0, 1, 0, 0, 0 }}, {{ 1, 1, 0, 0, 0 }},
{{ 2, 1, 0, 0, 0 }}, {{ 1, 0, 2, 0, 0 }}, {{ 0, 2, 0, 0, 0 }},
{{ 1, 2, 0, 0, 0 }}, {{ 2, 2, 0, 0, 0 }}, {{ 2, 0, 2, 0, 0 }},
{{ 0, 2, 2, 0, 0 }}, {{ 1, 2, 2, 0, 0 }}, {{ 2, 2, 2, 0, 0 }},
{{ 2, 0, 2, 0, 0 }}, {{ 0, 0, 1, 0, 0 }}, {{ 1, 0, 1, 0, 0 }},
{{ 2, 0, 1, 0, 0 }}, {{ 0, 1, 2, 0, 0 }}, {{ 0, 1, 1, 0, 0 }},
{{ 1, 1, 1, 0, 0 }}, {{ 2, 1, 1, 0, 0 }}, {{ 1, 1, 2, 0, 0 }},
{{ 0, 2, 1, 0, 0 }}, {{ 1, 2, 1, 0, 0 }}, {{ 2, 2, 1, 0, 0 }},
{{ 2, 1, 2, 0, 0 }}, {{ 0, 0, 0, 2, 2 }}, {{ 1, 0, 0, 2, 2 }},
{{ 2, 0, 0, 2, 2 }}, {{ 0, 0, 2, 2, 2 }}, {{ 0, 0, 0, 1, 0 }},
{{ 1, 0, 0, 1, 0 }}, {{ 2, 0, 0, 1, 0 }}, {{ 0, 0, 2, 1, 0 }},
{{ 0, 1, 0, 1, 0 }}, {{ 1, 1, 0, 1, 0 }}, {{ 2, 1, 0, 1, 0 }},
{{ 1, 0, 2, 1, 0 }}, {{ 0, 2, 0, 1, 0 }}, {{ 1, 2, 0, 1, 0 }},
{{ 2, 2, 0, 1, 0 }}, {{ 2, 0, 2, 1, 0 }}, {{ 0, 2, 2, 1, 0 }},
{{ 1, 2, 2, 1, 0 }}, {{ 2, 2, 2, 1, 0 }}, {{ 2, 0, 2, 1, 0 }},
{{ 0, 0, 1, 1, 0 }}, {{ 1, 0, 1, 1, 0 }}, {{ 2, 0, 1, 1, 0 }},
{{ 0, 1, 2, 1, 0 }}, {{ 0, 1, 1, 1, 0 }}, {{ 1, 1, 1, 1, 0 }},
{{ 2, 1, 1, 1, 0 }}, {{ 1, 1, 2, 1, 0 }}, {{ 0, 2, 1, 1, 0 }},
{{ 1, 2, 1, 1, 0 }}, {{ 2, 2, 1, 1, 0 }}, {{ 2, 1, 2, 1, 0 }},
{{ 0, 1, 0, 2, 2 }}, {{ 1, 1, 0, 2, 2 }}, {{ 2, 1, 0, 2, 2 }},
{{ 1, 0, 2, 2, 2 }}, {{ 0, 0, 0, 2, 0 }}, {{ 1, 0, 0, 2, 0 }},
{{ 2, 0, 0, 2, 0 }}, {{ 0, 0, 2, 2, 0 }}, {{ 0, 1, 0, 2, 0 }},
{{ 1, 1, 0, 2, 0 }}, {{ 2, 1, 0, 2, 0 }}, {{ 1, 0, 2, 2, 0 }},
{{ 0, 2, 0, 2, 0 }}, {{ 1, 2, 0, 2, 0 }}, {{ 2, 2, 0, 2, 0 }},
{{ 2, 0, 2, 2, 0 }}, {{ 0, 2, 2, 2, 0 }}, {{ 1, 2, 2, 2, 0 }},
{{ 2, 2, 2, 2, 0 }}, {{ 2, 0, 2, 2, 0 }}, {{ 0, 0, 1, 2, 0 }},
{{ 1, 0, 1, 2, 0 }}, {{ 2, 0, 1, 2, 0 }}, {{ 0, 1, 2, 2, 0 }},
{{ 0, 1, 1, 2, 0 }}, {{ 1, 1, 1, 2, 0 }}, {{ 2, 1, 1, 2, 0 }},
{{ 1, 1, 2, 2, 0 }}, {{ 0, 2, 1, 2, 0 }}, {{ 1, 2, 1, 2, 0 }},
{{ 2, 2, 1, 2, 0 }}, {{ 2, 1, 2, 2, 0 }}, {{ 0, 2, 0, 2, 2 }},
{{ 1, 2, 0, 2, 2 }}, {{ 2, 2, 0, 2, 2 }}, {{ 2, 0, 2, 2, 2 }},
{{ 0, 0, 0, 0, 2 }}, {{ 1, 0, 0, 0, 2 }}, {{ 2, 0, 0, 0, 2 }},
{{ 0, 0, 2, 0, 2 }}, {{ 0, 1, 0, 0, 2 }}, {{ 1, 1, 0, 0, 2 }},
{{ 2, 1, 0, 0, 2 }}, {{ 1, 0, 2, 0, 2 }}, {{ 0, 2, 0, 0, 2 }},
{{ 1, 2, 0, 0, 2 }}, {{ 2, 2, 0, 0, 2 }}, {{ 2, 0, 2, 0, 2 }},
{{ 0, 2, 2, 0, 2 }}, {{ 1, 2, 2, 0, 2 }}, {{ 2, 2, 2, 0, 2 }},
{{ 2, 0, 2, 0, 2 }}, {{ 0, 0, 1, 0, 2 }}, {{ 1, 0, 1, 0, 2 }},
{{ 2, 0, 1, 0, 2 }}, {{ 0, 1, 2, 0, 2 }}, {{ 0, 1, 1, 0, 2 }},
{{ 1, 1, 1, 0, 2 }}, {{ 2, 1, 1, 0, 2 }}, {{ 1, 1, 2, 0, 2 }},
{{ 0, 2, 1, 0, 2 }}, {{ 1, 2, 1, 0, 2 }}, {{ 2, 2, 1, 0, 2 }},
{{ 2, 1, 2, 0, 2 }}, {{ 0, 2, 2, 2, 2 }}, {{ 1, 2, 2, 2, 2 }},
{{ 2, 2, 2, 2, 2 }}, {{ 2, 0, 2, 2, 2 }}, {{ 0, 0, 0, 0, 1 }},
{{ 1, 0, 0, 0, 1 }}, {{ 2, 0, 0, 0, 1 }}, {{ 0, 0, 2, 0, 1 }},
{{ 0, 1, 0, 0, 1 }}, {{ 1, 1, 0, 0, 1 }}, {{ 2, 1, 0, 0, 1 }},
{{ 1, 0, 2, 0, 1 }}, {{ 0, 2, 0, 0, 1 }}, {{ 1, 2, 0, 0, 1 }},
{{ 2, 2, 0, 0, 1 }}, {{ 2, 0, 2, 0, 1 }}, {{ 0, 2, 2, 0, 1 }},
{{ 1, 2, 2, 0, 1 }}, {{ 2, 2, 2, 0, 1 }}, {{ 2, 0, 2, 0, 1 }},
{{ 0, 0, 1, 0, 1 }}, {{ 1, 0, 1, 0, 1 }}, {{ 2, 0, 1, 0, 1 }},
{{ 0, 1, 2, 0, 1 }}, {{ 0, 1, 1, 0, 1 }}, {{ 1, 1, 1, 0, 1 }},
{{ 2, 1, 1, 0, 1 }}, {{ 1, 1, 2, 0, 1 }}, {{ 0, 2, 1, 0, 1 }},
{{ 1, 2, 1, 0, 1 }}, {{ 2, 2, 1, 0, 1 }}, {{ 2, 1, 2, 0, 1 }},
{{ 0, 0, 1, 2, 2 }}, {{ 1, 0, 1, 2, 2 }}, {{ 2, 0, 1, 2, 2 }},
{{ 0, 1, 2, 2, 2 }}, {{ 0, 0, 0, 1, 1 }}, {{ 1, 0, 0, 1, 1 }},
{{ 2, 0, 0, 1, 1 }}, {{ 0, 0, 2, 1, 1 }}, {{ 0, 1, 0, 1, 1 }},
{{ 1, 1, 0, 1, 1 }}, {{ 2, 1, 0, 1, 1 }}, {{ 1, 0, 2, 1, 1 }},
{{ 0, 2, 0, 1, 1 }}, {{ 1, 2, 0, 1, 1 }}, {{ 2, 2, 0, 1, 1 }},
{{ 2, 0, 2, 1, 1 }}, {{ 0, 2, 2, 1, 1 }}, {{ 1, 2, 2, 1, 1 }},
{{ 2, 2, 2, 1, 1 }}, {{ 2, 0, 2, 1, 1 }}, {{ 0, 0, 1, 1, 1 }},
{{ 1, 0, 1, 1, 1 }}, {{ 2, 0, 1, 1, 1 }}, {{ 0, 1, 2, 1, 1 }},
{{ 0, 1, 1, 1, 1 }}, {{ 1, 1, 1, 1, 1 }}, {{ 2, 1, 1, 1, 1 }},
{{ 1, 1, 2, 1, 1 }}, {{ 0, 2, 1, 1, 1 }}, {{ 1, 2, 1, 1, 1 }},
{{ 2, 2, 1, 1, 1 }}, {{ 2, 1, 2, 1, 1 }}, {{ 0, 1, 1, 2, 2 }},
{{ 1, 1, 1, 2, 2 }}, {{ 2, 1, 1, 2, 2 }}, {{ 1, 1, 2, 2, 2 }},
{{ 0, 0, 0, 2, 1 }}, {{ 1, 0, 0, 2, 1 }}, {{ 2, 0, 0, 2, 1 }},
{{ 0, 0, 2, 2, 1 }}, {{ 0, 1, 0, 2, 1 }}, {{ 1, 1, 0, 2, 1 }},
{{ 2, 1, 0, 2, 1 }}, {{ 1, 0, 2, 2, 1 }}, {{ 0, 2, 0, 2, 1 }},
{{ 1, 2, 0, 2, 1 }}, {{ 2, 2, 0, 2, 1 }}, {{ 2, 0, 2, 2, 1 }},
{{ 0, 2, 2, 2, 1 }}, {{ 1, 2, 2, 2, 1 }}, {{ 2, 2, 2, 2, 1 }},
{{ 2, 0, 2, 2, 1 }}, {{ 0, 0, 1, 2, 1 }}, {{ 1, 0, 1, 2, 1 }},
{{ 2, 0, 1, 2, 1 }}, {{ 0, 1, 2, 2, 1 }}, {{ 0, 1, 1, 2, 1 }},
{{ 1, 1, 1, 2, 1 }}, {{ 2, 1, 1, 2, 1 }}, {{ 1, 1, 2, 2, 1 }},
{{ 0, 2, 1, 2, 1 }}, {{ 1, 2, 1, 2, 1 }}, {{ 2, 2, 1, 2, 1 }},
{{ 2, 1, 2, 2, 1 }}, {{ 0, 2, 1, 2, 2 }}, {{ 1, 2, 1, 2, 2 }},
{{ 2, 2, 1, 2, 2 }}, {{ 2, 1, 2, 2, 2 }}, {{ 0, 0, 0, 1, 2 }},
{{ 1, 0, 0, 1, 2 }}, {{ 2, 0, 0, 1, 2 }}, {{ 0, 0, 2, 1, 2 }},
{{ 0, 1, 0, 1, 2 }}, {{ 1, 1, 0, 1, 2 }}, {{ 2, 1, 0, 1, 2 }},
{{ 1, 0, 2, 1, 2 }}, {{ 0, 2, 0, 1, 2 }}, {{ 1, 2, 0, 1, 2 }},
{{ 2, 2, 0, 1, 2 }}, {{ 2, 0, 2, 1, 2 }}, {{ 0, 2, 2, 1, 2 }},
{{ 1, 2, 2, 1, 2 }}, {{ 2, 2, 2, 1, 2 }}, {{ 2, 0, 2, 1, 2 }},
{{ 0, 0, 1, 1, 2 }}, {{ 1, 0, 1, 1, 2 }}, {{ 2, 0, 1, 1, 2 }},
{{ 0, 1, 2, 1, 2 }}, {{ 0, 1, 1, 1, 2 }}, {{ 1, 1, 1, 1, 2 }},
{{ 2, 1, 1, 1, 2 }}, {{ 1, 1, 2, 1, 2 }}, {{ 0, 2, 1, 1, 2 }},
{{ 1, 2, 1, 1, 2 }}, {{ 2, 2, 1, 1, 2 }}, {{ 2, 1, 2, 1, 2 }},
{{ 0, 2, 2, 2, 2 }}, {{ 1, 2, 2, 2, 2 }}, {{ 2, 2, 2, 2, 2 }},
{{ 2, 1, 2, 2, 2 }}
};
static const std::array<int, 3> kQuintEncodings[128] = {
{{ 0, 0, 0 }}, {{ 1, 0, 0 }}, {{ 2, 0, 0 }}, {{ 3, 0, 0 }}, {{ 4, 0, 0 }},
{{ 0, 4, 0 }}, {{ 4, 4, 0 }}, {{ 4, 4, 4 }}, {{ 0, 1, 0 }}, {{ 1, 1, 0 }},
{{ 2, 1, 0 }}, {{ 3, 1, 0 }}, {{ 4, 1, 0 }}, {{ 1, 4, 0 }}, {{ 4, 4, 1 }},
{{ 4, 4, 4 }}, {{ 0, 2, 0 }}, {{ 1, 2, 0 }}, {{ 2, 2, 0 }}, {{ 3, 2, 0 }},
{{ 4, 2, 0 }}, {{ 2, 4, 0 }}, {{ 4, 4, 2 }}, {{ 4, 4, 4 }}, {{ 0, 3, 0 }},
{{ 1, 3, 0 }}, {{ 2, 3, 0 }}, {{ 3, 3, 0 }}, {{ 4, 3, 0 }}, {{ 3, 4, 0 }},
{{ 4, 4, 3 }}, {{ 4, 4, 4 }}, {{ 0, 0, 1 }}, {{ 1, 0, 1 }}, {{ 2, 0, 1 }},
{{ 3, 0, 1 }}, {{ 4, 0, 1 }}, {{ 0, 4, 1 }}, {{ 4, 0, 4 }}, {{ 0, 4, 4 }},
{{ 0, 1, 1 }}, {{ 1, 1, 1 }}, {{ 2, 1, 1 }}, {{ 3, 1, 1 }}, {{ 4, 1, 1 }},
{{ 1, 4, 1 }}, {{ 4, 1, 4 }}, {{ 1, 4, 4 }}, {{ 0, 2, 1 }}, {{ 1, 2, 1 }},
{{ 2, 2, 1 }}, {{ 3, 2, 1 }}, {{ 4, 2, 1 }}, {{ 2, 4, 1 }}, {{ 4, 2, 4 }},
{{ 2, 4, 4 }}, {{ 0, 3, 1 }}, {{ 1, 3, 1 }}, {{ 2, 3, 1 }}, {{ 3, 3, 1 }},
{{ 4, 3, 1 }}, {{ 3, 4, 1 }}, {{ 4, 3, 4 }}, {{ 3, 4, 4 }}, {{ 0, 0, 2 }},
{{ 1, 0, 2 }}, {{ 2, 0, 2 }}, {{ 3, 0, 2 }}, {{ 4, 0, 2 }}, {{ 0, 4, 2 }},
{{ 2, 0, 4 }}, {{ 3, 0, 4 }}, {{ 0, 1, 2 }}, {{ 1, 1, 2 }}, {{ 2, 1, 2 }},
{{ 3, 1, 2 }}, {{ 4, 1, 2 }}, {{ 1, 4, 2 }}, {{ 2, 1, 4 }}, {{ 3, 1, 4 }},
{{ 0, 2, 2 }}, {{ 1, 2, 2 }}, {{ 2, 2, 2 }}, {{ 3, 2, 2 }}, {{ 4, 2, 2 }},
{{ 2, 4, 2 }}, {{ 2, 2, 4 }}, {{ 3, 2, 4 }}, {{ 0, 3, 2 }}, {{ 1, 3, 2 }},
{{ 2, 3, 2 }}, {{ 3, 3, 2 }}, {{ 4, 3, 2 }}, {{ 3, 4, 2 }}, {{ 2, 3, 4 }},
{{ 3, 3, 4 }}, {{ 0, 0, 3 }}, {{ 1, 0, 3 }}, {{ 2, 0, 3 }}, {{ 3, 0, 3 }},
{{ 4, 0, 3 }}, {{ 0, 4, 3 }}, {{ 0, 0, 4 }}, {{ 1, 0, 4 }}, {{ 0, 1, 3 }},
{{ 1, 1, 3 }}, {{ 2, 1, 3 }}, {{ 3, 1, 3 }}, {{ 4, 1, 3 }}, {{ 1, 4, 3 }},
{{ 0, 1, 4 }}, {{ 1, 1, 4 }}, {{ 0, 2, 3 }}, {{ 1, 2, 3 }}, {{ 2, 2, 3 }},
{{ 3, 2, 3 }}, {{ 4, 2, 3 }}, {{ 2, 4, 3 }}, {{ 0, 2, 4 }}, {{ 1, 2, 4 }},
{{ 0, 3, 3 }}, {{ 1, 3, 3 }}, {{ 2, 3, 3 }}, {{ 3, 3, 3 }}, {{ 4, 3, 3 }},
{{ 3, 4, 3 }}, {{ 0, 3, 4 }}, {{ 1, 3, 4 }}
};
// A cached table containing the max ranges for values encoded using ASTC's
// Bounded Integer Sequence Encoding. These are the numbers between 1 and 255
// that can be represented exactly as a number in the ranges
// [0, 2^k), [0, 3 * 2^k), and [0, 5 * 2^k).
static const std::array<int, kNumPossibleRanges> kMaxRanges = []() {
std::array<int, kNumPossibleRanges> ranges;
// Initialize the table that we need for determining value encodings.
auto next_max_range = ranges.begin();
auto add_val = [&next_max_range](int val) {
if (val <= 0 || (1 << kLog2MaxRangeForBits) <= val) {
return;
}
*(next_max_range++) = val;
};
for (int i = 0; i <= kLog2MaxRangeForBits; ++i) {
add_val(3 * (1 << i) - 1);
add_val(5 * (1 << i) - 1);
add_val((1 << i) - 1);
}
assert(std::distance(next_max_range, ranges.end()) == 0);
std::sort(ranges.begin(), ranges.end());
return ranges;
}();
// Returns true if x == 0 or if x is a power of two. This function is only used
// in the GetCountsForRange function, where we need to have it return true
// on zero since we can have single trit/quint ISE encodings according to
// Table C.2.7.
template<typename T,
typename std::enable_if<std::is_integral<T>::value, T>::type = 0>
inline constexpr bool IsPow2(T x) { return (x & (x - 1)) == 0; }
// For the ISE block encoding, these arrays determine how many bits are
// used after each value to store the interleaved quint/trit block.
const int kInterleavedQuintBits[3] = { 3, 2, 2 };
const int kInterleavedTritBits[5] = { 2, 2, 1, 2, 1 };
// Some template meta programming to get around the fact that MSVC
// will not allow (ValRange == 5) ? 3 : 5 as a template parameter
template<int ValRange>
struct DecodeBlockSize {
enum { value = (ValRange == 5 ? 3 : 5) };
};
// Decodes either a trit or quint block using the BISE (Bounded Integer Sequence
// Encoding) defined in Section C.2.12 of the ASTC specification. ValRange is
// expected to be either 3 or 5 depending on whether or not we're encoding trits
// or quints respectively. In other words, it is the remaining factor in whether
// the passed blocks contain encoded values of the form 3*2^k or 5*2^k.
template<int ValRange>
std::array<int, /* kNumVals = */ DecodeBlockSize<ValRange>::value> DecodeISEBlock(
uint64_t block_bits, int num_bits) {
static_assert(ValRange == 3 || ValRange == 5,
"We only know about trits and quints");
// We either have three quints or five trits
constexpr const int kNumVals = (ValRange == 5) ? 3 : 5;
// Depending on whether or not we're using quints or trits will determine
// the positions of the interleaved bits in the encoded block.
constexpr const int* const kInterleavedBits =
(ValRange == 5) ? kInterleavedQuintBits : kInterleavedTritBits;
// Set up the bits for reading
base::BitStream<base::UInt128> block_bit_src(block_bits, sizeof(block_bits) * 8);
// Decode the block
std::array<int, kNumVals> m;
uint64_t encoded = 0;
uint32_t encoded_bits_read = 0;
for (int i = 0; i < kNumVals; ++i) {
{
uint64_t bits = 0;
const bool result = block_bit_src.GetBits(num_bits, &bits);
assert(result);
(void)result;
m[i] = static_cast<int>(bits);
}
uint64_t encoded_bits;
{
const bool result = block_bit_src.GetBits(kInterleavedBits[i], &encoded_bits);
assert(result);
(void)result;
}
encoded |= encoded_bits << encoded_bits_read;
encoded_bits_read += kInterleavedBits[i];
}
// Make sure that our encoded trit/quint doesn't exceed its bounds
assert(ValRange != 3 || encoded < 256);
assert(ValRange != 5 || encoded < 128);
const int* const kEncodings = (ValRange == 5) ?
kQuintEncodings[encoded].data() : kTritEncodings[encoded].data();
std::array<int, kNumVals> result;
for (int i = 0; i < kNumVals; ++i) {
assert(m[i] < 1 << num_bits);
result[i] = kEncodings[i] << num_bits | m[i];
}
return result;
}
// Encode a single trit or quint block using the BISE (Bounded Integer Sequence
// Encoding) defined in Section C.2.12 of the ASTC specification. ValRange is
// expected to be either 3 or 5 depending on whether or not we're encoding trits
// or quints respectively. In other words, it is the remaining factor in whether
// the passed blocks contain encoded values of the form 3*2^k or 5*2^k.
template <int ValRange>
void EncodeISEBlock(const std::vector<int>& vals, int bits_per_val,
base::BitStream<base::UInt128>* bit_sink) {
static_assert(ValRange == 3 || ValRange == 5,
"We only know about trits and quints");
// We either have three quints or five trits
constexpr const int kNumVals = (ValRange == 5) ? 3 : 5;
// Three quints in seven bits or five trits in eight bits
constexpr const int kNumEncodedBitsPerBlock = (ValRange == 5) ? 7 : 8;
// Depending on whether or not we're using quints or trits will determine
// the positions of the interleaved bits in the encoding
constexpr const int* const kInterleavedBits =
(ValRange == 5) ? kInterleavedQuintBits : kInterleavedTritBits;
// ISE blocks can only have up to a specific number of values...
assert(vals.size() <= kNumVals);
// Split up into bits and non bits. Non bits are used to find the quint/trit
// encoding that we need.
std::array<int, kNumVals> non_bits = {{ 0 }};
std::array<int, kNumVals> bits = {{ 0 }};
for (size_t i = 0; i < vals.size(); ++i) {
bits[i] = vals[i] & ((1 << bits_per_val) - 1);
non_bits[i] = vals[i] >> bits_per_val;
assert(non_bits[i] < ValRange);
}
// We only need to add as many bits as necessary, so let's limit it based
// on the computation described in Section C.2.22 of the ASTC specification
const int total_num_bits =
int(((vals.size() * kNumEncodedBitsPerBlock + kNumVals - 1) / kNumVals)
+ vals.size() * bits_per_val);
int bits_added = 0;
// The number of bits used for the quint/trit encoding is necessary to know
// in order to properly select the encoding we need to represent.
int num_encoded_bits = 0;
for (int i = 0; i < kNumVals; ++i) {
bits_added += bits_per_val;
if (bits_added >= total_num_bits) {
break;
}
num_encoded_bits += kInterleavedBits[i];
bits_added += kInterleavedBits[i];
if (bits_added >= total_num_bits) {
break;
}
}
bits_added = 0;
assert(num_encoded_bits <= kNumEncodedBitsPerBlock);
// TODO(google): The faster way to do this would be to construct trees out
// of the quint/trit encoding patterns, or just invert the decoding logic.
// Here we go from the end backwards because it makes our tests are more
// deterministic.
int non_bit_encoding = -1;
for (int j = (1 << num_encoded_bits) - 1; j >= 0; --j) {
bool matches = true;
// We don't need to match all trits here, just the ones that correspond
// to the values that we passed in
for (size_t i = 0; i < kNumVals; ++i) {
if ((ValRange == 5 && kQuintEncodings[j][i] != non_bits[i]) ||
(ValRange == 3 && kTritEncodings[j][i] != non_bits[i])) {
matches = false;
break;
}
}
if (matches) {
non_bit_encoding = j;
break;
}
}
assert(non_bit_encoding >= 0);
// Now pack the bits into the block
for (size_t i = 0; i < vals.size(); ++i) {
// First add the base bits for this value
if (bits_added + bits_per_val <= total_num_bits) {
bit_sink->PutBits(bits[i], bits_per_val);
bits_added += bits_per_val;
}
// Now add the interleaved bits from the quint/trit
int num_int_bits = kInterleavedBits[i];
int int_bits = non_bit_encoding & ((1 << num_int_bits) - 1);
if (bits_added + num_int_bits <= total_num_bits) {
bit_sink->PutBits(int_bits, num_int_bits);
bits_added += num_int_bits;
non_bit_encoding >>= num_int_bits;
}
}
}
inline void CHECK_COUNTS(int trits, int quints) {
assert(trits == 0 || quints == 0); // Either trits or quints
assert(trits == 0 || trits == 1); // At most one trit
assert(quints == 0 || quints == 1); // At most one quint
(void)trits; (void)quints;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
std::array<int, kNumPossibleRanges>::const_iterator ISERangeBegin() {
return kMaxRanges.cbegin();
}
std::array<int, kNumPossibleRanges>::const_iterator ISERangeEnd() {
return kMaxRanges.cend();
}
void IntegerSequenceCodec::GetCountsForRange(
int range, int* const trits, int* const quints, int* const bits) {
// Make sure the passed pointers are valid
assert(trits != nullptr);
assert(quints != nullptr);
assert(bits != nullptr);
// These are generally errors -- there should never be any ASTC values
// outside of this range
UTILS_RELEASE_ASSERT(range > 0);
UTILS_RELEASE_ASSERT(range < 1 << kLog2MaxRangeForBits);
*bits = 0;
*trits = 0;
*quints = 0;
// Search through the numbers of the form 2^n, 3 * 2^n and 5 * 2^n
const int max_vals_for_range =
*std::lower_bound(kMaxRanges.begin(), kMaxRanges.end(), range) + 1;
// Make sure we found something
assert(max_vals_for_range > 1);
// Find out what kind of range it is
if ((max_vals_for_range % 3 == 0) && IsPow2(max_vals_for_range / 3)) {
*bits = base::Log2Floor(max_vals_for_range / 3);
*trits = 1;
*quints = 0;
} else if ((max_vals_for_range % 5 == 0) && IsPow2(max_vals_for_range / 5)) {
*bits = base::Log2Floor(max_vals_for_range / 5);
*trits = 0;
*quints = 1;
} else if (IsPow2(max_vals_for_range)) {
*bits = base::Log2Floor(max_vals_for_range);
*trits = 0;
*quints = 0;
}
// If we set any of these values then we're done.
if ((*bits | *trits | *quints) != 0) {
CHECK_COUNTS(*trits, *quints);
}
}
// Returns the overall bit count for a range of val_count values encoded
// using the specified number of trits, quints and straight bits (respectively)
int IntegerSequenceCodec::GetBitCount(int num_vals,
int trits, int quints, int bits) {
CHECK_COUNTS(trits, quints);
// See section C.2.22 for the formula used here.
const int trit_bit_count = ((num_vals * 8 * trits) + 4) / 5;
const int quint_bit_count = ((num_vals * 7 * quints) + 2) / 3;
const int base_bit_count = num_vals * bits;
return trit_bit_count + quint_bit_count + base_bit_count;
}
IntegerSequenceCodec::IntegerSequenceCodec(int range) {
int trits, quints, bits;
GetCountsForRange(range, &trits, &quints, &bits);
InitializeWithCounts(trits, quints, bits);
}
IntegerSequenceCodec::IntegerSequenceCodec(
int trits, int quints, int bits) {
InitializeWithCounts(trits, quints, bits);
}
void IntegerSequenceCodec::InitializeWithCounts(
int trits, int quints, int bits) {
CHECK_COUNTS(trits, quints);
if (trits > 0) {
encoding_ = EncodingMode::kTritEncoding;
} else if (quints > 0) {
encoding_ = EncodingMode::kQuintEncoding;
} else {
encoding_ = EncodingMode::kBitEncoding;
}
bits_ = bits;
}
int IntegerSequenceCodec::NumValsPerBlock() const {
const std::array<int, 3> kNumValsByEncoding = {{ 5, 3, 1 }};
return kNumValsByEncoding[static_cast<int>(encoding_)];
}
int IntegerSequenceCodec::EncodedBlockSize() const {
const std::array<int, 3> kExtraBlockSizeByEncoding = {{ 8, 7, 0 }};
const int num_vals = NumValsPerBlock();
return kExtraBlockSizeByEncoding[static_cast<int>(encoding_)]
+ num_vals * bits_;
}
std::vector<int> IntegerSequenceDecoder::Decode(
int num_vals, base::BitStream<base::UInt128> *bit_src) const {
int trits = (encoding_ == kTritEncoding)? 1 : 0;
int quints = (encoding_ == kQuintEncoding)? 1 : 0;
const int total_num_bits = GetBitCount(num_vals, trits, quints, bits_);
const int bits_per_block = EncodedBlockSize();
assert(bits_per_block < 64);
int bits_left = total_num_bits;
std::vector<int> result;
while (bits_left > 0) {
uint64_t block_bits;
{
const bool result0 = bit_src->GetBits(std::min(bits_left, bits_per_block), &block_bits);
assert(result0);
(void)result0;
}
switch (encoding_) {
case kTritEncoding: {
auto trit_vals = DecodeISEBlock<3>(block_bits, bits_);
result.insert(result.end(), trit_vals.begin(), trit_vals.end());
}
break;
case kQuintEncoding: {
auto quint_vals = DecodeISEBlock<5>(block_bits, bits_);
result.insert(result.end(), quint_vals.begin(), quint_vals.end());
}
break;
case kBitEncoding:
result.push_back(static_cast<int>(block_bits));
break;
}
bits_left -= bits_per_block;
}
// Resize result to only contain as many values as requested
assert(result.size() >= static_cast<size_t>(num_vals));
result.resize(num_vals);
// Encoded all the values
return result;
}
void IntegerSequenceEncoder::Encode(base::BitStream<base::UInt128>* bit_sink) const {
// Go through all of the values and chop them up into blocks. The properties
// of the trit and quint encodings mean that if we need to encode fewer values
// in a block than the number of values encoded in the block then we need to
// consider the last few values to be zero.
auto next_val = vals_.begin();
while (next_val != vals_.end()) {
switch (encoding_) {
case kTritEncoding: {
std::vector<int> trit_vals;
for (int i = 0; i < 5; ++i) {
if (next_val != vals_.end()) {
trit_vals.push_back(*next_val);
++next_val;
}
}
EncodeISEBlock<3>(trit_vals, bits_, bit_sink);
}
break;
case kQuintEncoding: {
std::vector<int> quint_vals;
for (int i = 0; i < 3; ++i) {
if (next_val != vals_.end()) {
quint_vals.push_back(*next_val);
++next_val;
}
}
EncodeISEBlock<5>(quint_vals, bits_, bit_sink);
}
break;
case kBitEncoding: {
bit_sink->PutBits(*next_val, EncodedBlockSize());
++next_val;
}
break;
}
}
}
} // namespace astc_codec

169
3rdparty/astc-codec/src/decoder/integer_sequence_codec.h vendored
View File

@@ -1,169 +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.
#ifndef ASTC_CODEC_DECODER_INTEGER_SEQUENCE_CODEC_H_
#define ASTC_CODEC_DECODER_INTEGER_SEQUENCE_CODEC_H_
#include "src/base/bit_stream.h"
#include "src/base/uint128.h"
#include <array>
#include <string>
#include <vector>
namespace astc_codec {
// The maximum number of bits that we would need to encode an ISE value. The
// ASTC specification does not give a maximum number, however unquantized color
// values have a maximum range of 255, meaning that we can't feasibly have more
// than eight bits per value.
constexpr int kLog2MaxRangeForBits = 8;
// Ranges can take any of the the forms 2^k, 3*2^k, or 5*2^k for k up to
// kLog2MaxRangeForBits. Hence we have three types of ranges. Since the
// maximum encoded value is 255, k won't go larger than 8. We don't have quints
// that accompany [6, 8]-bits, as (5 * 2^6 = 320 > 255) and we don't have trits
// that accompany [7, 8]-bits, as (3 * 2^7 = 384 > 255). But we do have trits
// and quints that accompany no bits. Hence we have a total of
// 3 * kLog2MaxRangeForBits - 3 - 2 + 2 total ranges.
constexpr int kNumPossibleRanges = 3 * kLog2MaxRangeForBits - 3;
// Returns an iterator through the available ASTC ranges.
std::array<int, kNumPossibleRanges>::const_iterator ISERangeBegin();
std::array<int, kNumPossibleRanges>::const_iterator ISERangeEnd();
// Base class for ASTC integer sequence encoders and decoders. These codecs
// operate on sequences of integers and produce bit patterns that pack the
// integers based on the encoding scheme specified in the ASTC specification
// Section C.2.12. The resulting bit pattern is a sequence of encoded blocks.
// All blocks in a sequence are one of the following encodings:
//
// (1 -- bit encoding) one encoded value of the form 2^k
// (2 -- trit encoding) five encoded values of the form 3*2^k
// (3 -- quint encoding) three encoded values of the form 5*2^k
//
// The layouts of each block are designed such that the blocks can be truncated
// during encoding in order to support variable length input sequences (i.e. a
// sequence of values that are encoded using trit encoded blocks does not
// need to have a multiple-of-five length).
class IntegerSequenceCodec {
public:
// Returns the number of trits, quints, and bits needed to encode values in
// [0, range]. This is used to determine the layout of ISE encoded bit
// streams. The returned array holds the number of trits, quints, and bits
// respectively. range is expected to be within the interval [1, 5242879]
static void GetCountsForRange(int range, int* trits, int* quints, int* bits);
// Returns the number of bits needed to encode the given number of values with
// respect to the number of trits, quints, and bits specified in ise_counts
// (in that order). It is expected that either trits or quints can be
// nonzero, but not both, and neither can be larger than one. Anything else is
// undefined.
static int GetBitCount(int num_vals, int trits, int quints, int bits);
// Convenience function that returns the number of bits needed to encoded
// num_vals within the range [0, range] (inclusive).
static inline int GetBitCountForRange(int num_vals, int range) {
int trits, quints, bits;
GetCountsForRange(range, &trits, &quints, &bits);
return GetBitCount(num_vals, trits, quints, bits);
}
protected:
explicit IntegerSequenceCodec(int range);
IntegerSequenceCodec(int trits, int quints, int bits);
// The encoding mode -- since having trits and quints are mutually exclusive,
// we can store the encoding we decide on in this enum.
enum EncodingMode {
kTritEncoding = 0,
kQuintEncoding,
kBitEncoding,
};
EncodingMode encoding_;
int bits_;
// Returns the number of values stored in a single ISE block. Since quints and
// trits are packed three/five to a bit pattern (respectively), each sequence
// is chunked into blocks in order to encode it. For only bit-encodings, the
// block size is one.
int NumValsPerBlock() const;
// Returns the size of a single ISE block in bits (see NumValsPerBlock).
int EncodedBlockSize() const;
private:
// Determines the encoding mode.
void InitializeWithCounts(int trits, int quints, int bits);
};
// The integer sequence decoder. The decoder only remembers the given encoding
// but each invocation of Decode operates independently on the input bits.
class IntegerSequenceDecoder : public IntegerSequenceCodec {
public:
// Creates a decoder that decodes values within [0, range] (inclusive).
explicit IntegerSequenceDecoder(int range)
: IntegerSequenceCodec(range) { }
// Creates a decoder based on the number of trits, quints, and bits expected
// in the bit stream passed to Decode.
IntegerSequenceDecoder(int trits, int quints, int bits)
: IntegerSequenceCodec(trits, quints, bits) { }
// Decodes num_vals from the bit_src. The number of bits read is dependent
// on the number of bits required to encode num_vals based on the calculation
// provided in Section C.2.22 of the ASTC specification. The return value
// always contains exactly num_vals.
std::vector<int> Decode(int num_vals,
base::BitStream<base::UInt128>* bit_src) const;
};
// The integer sequence encoder. The encoder accepts values one by one and
// places them into a temporary array that it holds. When needed the user
// may call Encode to produce an encoded bit stream of the associated values.
class IntegerSequenceEncoder : public IntegerSequenceCodec {
public:
// Creates an encoder that encodes values within [0, range] (inclusive).
explicit IntegerSequenceEncoder(int range)
: IntegerSequenceCodec(range) { }
// Creates an encoder based on the number of trits, quints, and bits for
// the bit stream produced by Encode.
IntegerSequenceEncoder(int trits, int quints, int bits)
: IntegerSequenceCodec(trits, quints, bits) { }
// Adds a value to the encoding sequence.
void AddValue(int val) {
// Make sure it's within bounds
assert(encoding_ != EncodingMode::kTritEncoding || val < 3 * (1 << bits_));
assert(encoding_ != EncodingMode::kQuintEncoding || val < 5 * (1 << bits_));
assert(encoding_ != EncodingMode::kBitEncoding || val < (1 << bits_));
vals_.push_back(val);
}
// Writes the encoding for vals_ to the bit_sink. Multiple calls to Encode
// will produce the same result.
void Encode(base::BitStream<base::UInt128>* bit_sink) const;
// Removes all of the previously added values to the encoder.
void Reset() { vals_.clear(); }
private:
std::vector<int> vals_;
};
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_INTEGER_SEQUENCE_CODEC_H_

591
3rdparty/astc-codec/src/decoder/intermediate_astc_block.cc vendored
View File

@@ -1,591 +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/integer_sequence_codec.h"
#include "src/base/bit_stream.h"
#include "src/base/math_utils.h"
#include "src/base/optional.h"
#include "src/base/uint128.h"
#include <algorithm>
#include <numeric>
#include <sstream>
namespace astc_codec {
namespace {
constexpr int kEndpointRange_ReturnInvalidWeightDims = -1;
constexpr int kEndpointRange_ReturnNotEnoughColorBits = -2;
base::UInt128 PackVoidExtentBlock(uint16_t r, uint16_t g, uint16_t b,
uint16_t a, std::array<uint16_t, 4> coords) {
base::BitStream<base::UInt128> bit_sink;
// Put void extent mode...
bit_sink.PutBits(0xDFC, 12);
// Each of the coordinates goes in 13 bits at a time.
for (auto coord : coords) {
assert(coord < 1 << 13);
bit_sink.PutBits(coord, 13);
}
assert(bit_sink.Bits() == 64);
// Then we add R, G, B, and A in order
bit_sink.PutBits(r, 16);
bit_sink.PutBits(g, 16);
bit_sink.PutBits(b, 16);
bit_sink.PutBits(a, 16);
assert(bit_sink.Bits() == 128);
base::UInt128 result;
bit_sink.GetBits(128, &result);
return result;
}
base::Optional<std::string> GetEncodedWeightRange(int range,
std::array<int, 3>* const r) {
const std::array<std::array<int, 3>, 12> kValidRangeEncodings =
{{ {{ 0, 1, 0 }}, {{ 1, 1, 0 }}, {{ 0, 0, 1 }},
{{ 1, 0, 1 }}, {{ 0, 1, 1 }}, {{ 1, 1, 1 }},
{{ 0, 1, 0 }}, {{ 1, 1, 0 }}, {{ 0, 0, 1 }},
{{ 1, 0, 1 }}, {{ 0, 1, 1 }}, {{ 1, 1, 1 }} }};
// If our range is larger than all available ranges, this is an error.
const int smallest_range = kValidWeightRanges.front();
const int largest_range = kValidWeightRanges.back();
if (range < smallest_range || largest_range < range) {
std::stringstream strm;
strm << "Could not find block mode. Invalid weight range: "
<< range << " not in [" << smallest_range << ", "
<< largest_range << std::endl;
return strm.str();
}
// Find the upper bound on the range, otherwise.
const auto range_iter = std::lower_bound(
kValidWeightRanges.cbegin(), kValidWeightRanges.cend(), range);
auto enc_iter = kValidRangeEncodings.cbegin();
enc_iter += std::distance(kValidWeightRanges.cbegin(), range_iter);
*r = *enc_iter;
return {};
}
struct BlockModeInfo {
int min_weight_grid_dim_x;
int max_weight_grid_dim_x;
int min_weight_grid_dim_y;
int max_weight_grid_dim_y;
int r0_bit_pos;
int r1_bit_pos;
int r2_bit_pos;
int weight_grid_x_offset_bit_pos;
int weight_grid_y_offset_bit_pos;
bool require_single_plane_low_prec;
};
constexpr int kNumBlockModes = 10;
const std::array<BlockModeInfo, kNumBlockModes> kBlockModeInfo {{
{ 4, 7, 2, 5, 4, 0, 1, 7, 5, false }, // B+4 A+2
{ 8, 11, 2, 5, 4, 0, 1, 7, 5, false }, // B+8 A+2
{ 2, 5, 8, 11, 4, 0, 1, 5, 7, false }, // A+2 B+8
{ 2, 5, 6, 7, 4, 0, 1, 5, 7, false }, // A+2 B+6
{ 2, 3, 2, 5, 4, 0, 1, 7, 5, false }, // B+2 A+2
{ 12, 12, 2, 5, 4, 2, 3, -1, 5, false }, // 12 A+2
{ 2, 5, 12, 12, 4, 2, 3, 5, -1, false }, // A+2 12
{ 6, 6, 10, 10, 4, 2, 3, -1, -1, false }, // 6 10
{ 10, 10, 6, 6, 4, 2, 3, -1, -1, false }, // 10 6
{ 6, 9, 6, 9, 4, 2, 3, 5, 9, true } // A+6 B+6
}};
// These are the bits that must be set for ASTC to recognize a given
// block mode. They are the 1's set in table C.2.8 of the spec.
const std::array<int, kNumBlockModes> kBlockModeMask = {{
0x0, 0x4, 0x8, 0xC, 0x10C, 0x0, 0x80, 0x180, 0x1A0, 0x100
}};
static base::Optional<std::string> PackBlockMode(int dim_x, int dim_y, int range,
bool dual_plane,
base::BitStream<base::UInt128>* const bit_sink) {
// We need to set the high precision bit if our range is too high...
bool high_prec = range > 7;
std::array<int, 3> r = {};
const auto result = GetEncodedWeightRange(range, &r);
if (result) {
return result;
}
// The high two bits of R must not be zero. If this happens then it's
// an illegal encoding according to Table C.2.7 that should have gotten
// caught in GetEncodedWeightRange
assert((r[1] | r[2]) > 0);
// Just go through the table and see if any of the modes can handle
// the given dimensions.
for (int mode = 0; mode < kNumBlockModes; ++mode) {
const BlockModeInfo& block_mode = kBlockModeInfo[mode];
bool is_valid_mode = true;
is_valid_mode &= block_mode.min_weight_grid_dim_x <= dim_x;
is_valid_mode &= dim_x <= block_mode.max_weight_grid_dim_x;
is_valid_mode &= block_mode.min_weight_grid_dim_y <= dim_y;
is_valid_mode &= dim_y <= block_mode.max_weight_grid_dim_y;
is_valid_mode &= !(block_mode.require_single_plane_low_prec && dual_plane);
is_valid_mode &= !(block_mode.require_single_plane_low_prec && high_prec);
if (!is_valid_mode) {
continue;
}
// Initialize to the bits we must set.
uint32_t encoded_mode = kBlockModeMask[mode];
auto setBit = [&encoded_mode](const uint32_t value, const uint32_t offset) {
encoded_mode = (encoded_mode & ~(1 << offset)) | ((value & 1) << offset);
};
// Set all the bits we need to set
setBit(r[0], block_mode.r0_bit_pos);
setBit(r[1], block_mode.r1_bit_pos);
setBit(r[2], block_mode.r2_bit_pos);
// Find our width and height offset from the base width and height weight
// grid dimension for the given block mode. These are the 1-2 bits that
// get encoded in the block mode used to calculate the final weight grid
// width and height.
const int offset_x = dim_x - block_mode.min_weight_grid_dim_x;
const int offset_y = dim_y - block_mode.min_weight_grid_dim_y;
// If we don't have an offset position then our offset better be zero.
// If this isn't the case, then this isn't a viable block mode and we
// should have caught this sooner.
assert(block_mode.weight_grid_x_offset_bit_pos >= 0 || offset_x == 0);
assert(block_mode.weight_grid_y_offset_bit_pos >= 0 || offset_y == 0);
encoded_mode |= offset_x << block_mode.weight_grid_x_offset_bit_pos;
encoded_mode |= offset_y << block_mode.weight_grid_y_offset_bit_pos;
if (!block_mode.require_single_plane_low_prec) {
setBit(high_prec, 9);
setBit(dual_plane, 10);
}
// Make sure that the mode is the first thing the bit sink is writing to
assert(bit_sink->Bits() == 0);
bit_sink->PutBits(encoded_mode, 11);
return {};
}
return std::string("Could not find viable block mode");
}
// Returns true if all endpoint modes are equal.
bool SharedEndpointModes(const IntermediateBlockData& data) {
return std::accumulate(
data.endpoints.begin(), data.endpoints.end(), true,
[&data](const bool& a, const IntermediateEndpointData& b) {
return a && b.mode == data.endpoints[0].mode;
});
}
// Returns the starting bit (between 0 and 128) where the extra CEM and
// dual plane info is stored in the ASTC block.
int ExtraConfigBitPosition(const IntermediateBlockData& data) {
const bool has_dual_channel = data.dual_plane_channel.hasValue();
const int num_weights = data.weight_grid_dim_x * data.weight_grid_dim_y *
(has_dual_channel ? 2 : 1);
const int num_weight_bits =
IntegerSequenceCodec::GetBitCountForRange(num_weights, data.weight_range);
int extra_config_bits = 0;
if (!SharedEndpointModes(data)) {
const int num_encoded_cem_bits = 2 + int(data.endpoints.size()) * 3;
extra_config_bits = num_encoded_cem_bits - 6;
}
if (has_dual_channel) {
extra_config_bits += 2;
}
return 128 - num_weight_bits - extra_config_bits;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
base::Optional<IntermediateBlockData> UnpackIntermediateBlock(
const PhysicalASTCBlock& pb) {
if (pb.IsIllegalEncoding()) {
return {};
}
if (pb.IsVoidExtent()) {
return {};
}
// Non void extent? Then let's try to decode everything else.
IntermediateBlockData data;
// All blocks have color values...
const base::UInt128 color_bits_mask =
(base::UInt128(1) << pb.NumColorBits().value()) - 1;
const base::UInt128 color_bits =
(pb.GetBlockBits() >> pb.ColorStartBit().value()) & color_bits_mask;
base::BitStream<base::UInt128> bit_src(color_bits, 128);
IntegerSequenceDecoder color_decoder(pb.ColorValuesRange().value());
const int num_colors_in_block = pb.NumColorValues().value();
std::vector<int> colors = color_decoder.Decode(num_colors_in_block, &bit_src);
// Decode simple info
const auto weight_dims = pb.WeightGridDims();
data.weight_grid_dim_x = weight_dims->at(0);
data.weight_grid_dim_y = weight_dims->at(1);
data.weight_range = pb.WeightRange().value();
data.partition_id = pb.PartitionID();
data.dual_plane_channel = pb.DualPlaneChannel();
auto colors_iter = colors.begin();
for (int i = 0; i < pb.NumPartitions().value(); ++i) {
IntermediateEndpointData ep_data;
ep_data.mode = pb.GetEndpointMode(i).value();
const int num_colors = NumColorValuesForEndpointMode(ep_data.mode);
ep_data.colors.insert(ep_data.colors.end(), colors_iter,
colors_iter + num_colors);
colors_iter += num_colors;
data.endpoints.push_back(ep_data);
}
assert(colors_iter == colors.end());
data.endpoint_range = pb.ColorValuesRange().value();
// Finally decode the weights
const base::UInt128 weight_bits_mask =
(base::UInt128(1) << pb.NumWeightBits().value()) - 1;
const base::UInt128 weight_bits =
base::ReverseBits(pb.GetBlockBits()) & weight_bits_mask;
bit_src = base::BitStream<base::UInt128>(weight_bits, 128);
IntegerSequenceDecoder weight_decoder(data.weight_range);
int num_weights = data.weight_grid_dim_x * data.weight_grid_dim_y;
num_weights *= pb.IsDualPlane() ? 2 : 1;
data.weights = weight_decoder.Decode(num_weights, &bit_src);
return data;
}
int EndpointRangeForBlock(const IntermediateBlockData& data) {
// First check to see if we exceed the number of bits allotted for weights, as
// specified in C.2.24. If so, then the endpoint range is meaningless, but not
// because we had an overzealous color endpoint mode, so return a different
// error code.
if (IntegerSequenceCodec::GetBitCountForRange(
data.weight_grid_dim_x * data.weight_grid_dim_y *
(data.dual_plane_channel.hasValue() ? 2 : 1),
data.weight_range) > 96) {
return kEndpointRange_ReturnInvalidWeightDims;
}
const int num_partitions = int(data.endpoints.size());
// Calculate the number of bits that we would write prior to getting to the
// color endpoint data
const int bits_written =
11 // Block mode
+ 2 // Num partitions
+ ((num_partitions > 1) ? 10 : 0) // Partition ID
+ ((num_partitions == 1) ? 4 : 6); // Shared CEM bits
// We can determine the range based on how many bits we have between the start
// of the color endpoint data and the next section, which is the extra config
// bit position
const int color_bits_available = ExtraConfigBitPosition(data) - bits_written;
int num_color_values = 0;
for (const auto& ep_data : data.endpoints) {
num_color_values += NumColorValuesForEndpointMode(ep_data.mode);
}
// There's no way any valid ASTC encoding has no room left for any color
// values. If we hit this then something is wrong in the caller -- abort.
// According to section C.2.24, the smallest number of bits available is
// ceil(13*C/5), where C is the number of color endpoint integers needed.
const int bits_needed = (13 * num_color_values + 4) / 5;
if (color_bits_available < bits_needed) {
return kEndpointRange_ReturnNotEnoughColorBits;
}
int color_value_range = 255;
for (; color_value_range > 1; --color_value_range) {
const int bits_for_range = IntegerSequenceCodec::GetBitCountForRange(
num_color_values, color_value_range);
if (bits_for_range <= color_bits_available) {
break;
}
}
return color_value_range;
}
base::Optional<VoidExtentData> UnpackVoidExtent(const PhysicalASTCBlock& pb) {
if (pb.IsIllegalEncoding()) {
return {};
}
if (!pb.IsVoidExtent()) {
return {};
}
// All blocks have color values...
const base::UInt128 color_bits_mask =
(base::UInt128(1) << pb.NumColorBits().value()) - 1;
const uint64_t color_bits = (
(pb.GetBlockBits() >> pb.ColorStartBit().value()) & color_bits_mask).LowBits();
assert(pb.NumColorValues().value() == 4);
VoidExtentData data;
data.r = static_cast<uint16_t>((color_bits >> 0) & 0xFFFF);
data.g = static_cast<uint16_t>((color_bits >> 16) & 0xFFFF);
data.b = static_cast<uint16_t>((color_bits >> 32) & 0xFFFF);
data.a = static_cast<uint16_t>((color_bits >> 48) & 0xFFFF);
const auto void_extent_coords = pb.VoidExtentCoords();
if (void_extent_coords) {
data.coords[0] = uint16_t(void_extent_coords->at(0));
data.coords[1] = uint16_t(void_extent_coords->at(1));
data.coords[2] = uint16_t(void_extent_coords->at(2));
data.coords[3] = uint16_t(void_extent_coords->at(3));
} else {
uint16_t all_ones = (1 << 13) - 1;
for (auto& coord : data.coords) {
coord = all_ones;
}
}
return data;
}
// Packs the given intermediate block into a physical block. Returns false if
// the provided values in the intermediate block emit an illegal ASTC
// encoding.
base::Optional<std::string> Pack(const IntermediateBlockData& data,
base::UInt128* pb) {
if (data.weights.size() !=
size_t(data.weight_grid_dim_x * data.weight_grid_dim_y *
(data.dual_plane_channel.hasValue() ? 2 : 1))) {
return std::string("Incorrect number of weights!");
}
// If it's not a void extent block, then it gets a bit more tricky...
base::BitStream<base::UInt128> bit_sink;
// First we need to encode the block mode.
const auto error_string = PackBlockMode(
data.weight_grid_dim_x, data.weight_grid_dim_y, data.weight_range,
data.dual_plane_channel.hasValue(), &bit_sink);
if (error_string) {
return error_string;
}
// Next, we place the number of partitions minus one.
const int num_partitions = int(data.endpoints.size());
bit_sink.PutBits(num_partitions - 1, 2);
// If we have more than one partition, then we also have a partition ID.
if (num_partitions > 1) {
const int id = data.partition_id.value();
assert(id >= 0);
bit_sink.PutBits(id, 10);
}
// Take a detour, let's encode the weights so that we know how many bits they
// consume.
base::BitStream<base::UInt128> weight_sink;
IntegerSequenceEncoder weight_enc(data.weight_range);
for (auto weight : data.weights) {
weight_enc.AddValue(weight);
}
weight_enc.Encode(&weight_sink);
const int num_weight_bits = weight_sink.Bits();
assert(num_weight_bits ==
IntegerSequenceCodec::GetBitCountForRange(
int(data.weights.size()), data.weight_range));
// Let's continue... how much after the color data do we need to write?
int extra_config = 0;
// Determine if all endpoint pairs share the same endpoint mode
assert(data.endpoints.size() > 0);
bool shared_endpoint_mode = SharedEndpointModes(data);
// The first part of the endpoint mode (CEM) comes directly after the
// partition info, if it exists. If there is no partition info, the CEM comes
// right after the block mode. In the single-partition case, we just write out
// the entire singular CEM, but in the multi-partition case, if all CEMs are
// the same then their shared CEM is specified directly here, too. In both
// cases, shared_endpoint_mode is true (in the singular case,
// shared_endpoint_mode is trivially true).
if (shared_endpoint_mode) {
if (num_partitions > 1) {
bit_sink.PutBits(0, 2);
}
bit_sink.PutBits(static_cast<int>(data.endpoints[0].mode), 4);
} else {
// Here, the CEM is not shared across all endpoint pairs, and we need to
// figure out what to place here, and what to place in the extra config
// bits before the weight data...
// Non-shared config modes must all be within the same class (out of four)
// See Section C.2.11
int min_class = 2; // We start with 2 here instead of three because it's
// the highest that can be encoded -- even if all modes
// are class 3.
int max_class = 0;
for (const auto& ep_data : data.endpoints) {
const int ep_mode_class = static_cast<int>(ep_data.mode) >> 2;
min_class = std::min(min_class, ep_mode_class);
max_class = std::max(max_class, ep_mode_class);
}
assert(max_class >= min_class);
if (max_class - min_class > 1) {
return std::string("Endpoint modes are invalid");
}
// Construct the CEM mode -- six of its bits will fit here, but otherwise
// the rest will go in the extra configuration bits.
base::BitStream<uint32_t> cem_encoder;
// First encode the base class
assert(min_class >= 0);
assert(min_class < 3);
cem_encoder.PutBits(min_class + 1, 2);
// Next, encode the class selector bits -- this is simply the offset
// from the base class
for (const auto& ep_data : data.endpoints) {
const int ep_mode_class = static_cast<int>(ep_data.mode) >> 2;
const int class_selector_bit = ep_mode_class - min_class;
assert(class_selector_bit == 0 || class_selector_bit == 1);
cem_encoder.PutBits(class_selector_bit, 1);
}
// Finally, we need to choose from each class which actual mode
// we belong to and encode those.
for (const auto& ep_data : data.endpoints) {
const int ep_mode = static_cast<int>(ep_data.mode) & 3;
assert(ep_mode < 4);
cem_encoder.PutBits(ep_mode, 2);
}
assert(cem_encoder.Bits() == uint32_t(2 + num_partitions * 3));
uint32_t encoded_cem;
cem_encoder.GetBits(2 + num_partitions * 3, &encoded_cem);
// Since only six bits fit here before the color endpoint data, the rest
// need to go in the extra config data.
extra_config = encoded_cem >> 6;
// Write out the six bits we had
bit_sink.PutBits(encoded_cem, 6);
}
// If we have a dual-plane channel, we can tack that onto our extra config
// data
if (data.dual_plane_channel.hasValue()) {
const int channel = data.dual_plane_channel.value();
assert(channel < 4);
extra_config <<= 2;
extra_config |= channel;
}
// Get the range of endpoint values. It can't be -1 because we should have
// checked for that much earlier.
const int color_value_range = data.endpoint_range
? data.endpoint_range.value()
: EndpointRangeForBlock(data);
assert(color_value_range != kEndpointRange_ReturnInvalidWeightDims);
if (color_value_range == kEndpointRange_ReturnNotEnoughColorBits) {
return { "Intermediate block emits illegal color range" };
}
IntegerSequenceEncoder color_enc(color_value_range);
for (const auto& ep_data : data.endpoints) {
for (int color : ep_data.colors) {
if (color > color_value_range) {
return { "Color outside available color range!" };
}
color_enc.AddValue(color);
}
}
color_enc.Encode(&bit_sink);
// Now we need to skip some bits to get to the extra configuration bits. The
// number of bits we need to skip depends on where we are in the stream and
// where we need to get to.
const int extra_config_bit_position = ExtraConfigBitPosition(data);
const int extra_config_bits =
128 - num_weight_bits - extra_config_bit_position;
assert(extra_config_bits >= 0);
assert(extra_config < 1 << extra_config_bits);
// Make sure the color encoder didn't write more than we thought it would.
int bits_to_skip = extra_config_bit_position - bit_sink.Bits();
assert(bits_to_skip >= 0);
while (bits_to_skip > 0) {
const int skipping = std::min(32, bits_to_skip);
bit_sink.PutBits(0, skipping);
bits_to_skip -= skipping;
}
// Finally, write out the rest of the config bits.
bit_sink.PutBits(extra_config, extra_config_bits);
// We should be right up to the weight bits...
assert(bit_sink.Bits() == uint32_t(128 - num_weight_bits));
// Flush out our bit writer and write out the weight bits
base::UInt128 astc_bits;
bit_sink.GetBits(128 - num_weight_bits, &astc_bits);
base::UInt128 rev_weight_bits;
weight_sink.GetBits(weight_sink.Bits(), &rev_weight_bits);
astc_bits |= base::ReverseBits(rev_weight_bits);
// And we're done! Whew!
*pb = astc_bits;
return PhysicalASTCBlock(*pb).IsIllegalEncoding();
}
base::Optional<std::string> Pack(const VoidExtentData& data,
base::UInt128* pb) {
*pb = PackVoidExtentBlock(data.r, data.g, data.b, data.a, data.coords);
return PhysicalASTCBlock(*pb).IsIllegalEncoding();
}
} // namespace astc_codec

128
3rdparty/astc-codec/src/decoder/intermediate_astc_block.h vendored
View File

@@ -1,128 +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.
#ifndef ASTC_CODEC_DECODER_INTERMEDIATE_ASTC_BLOCK_H_
#define ASTC_CODEC_DECODER_INTERMEDIATE_ASTC_BLOCK_H_
#include "src/base/optional.h"
#include "src/base/uint128.h"
#include "src/decoder/physical_astc_block.h"
#include <array>
#include <vector>
namespace astc_codec {
// From Table C.2.7 -- These are the only valid ranges that weight
// values can take.
constexpr std::array<int, 12> kValidWeightRanges =
{{ 1, 2, 3, 4, 5, 7, 9, 11, 15, 19, 23, 31 }};
// Void extent data are all the ASTC blocks that are labeled for having a
// constant color. In the ASTC spec, some of these blocks may optionally
// have "void extent coordinates" that describe how far in texture space
// the constant color should span. If these coordinates are not valid,
// then the coordinates are all set to a fully saturated bit mask
// ((1 << 13) - 1) and the block is treated as a singular constant color.
// We call both types of these blocks "void extent" to remove confusion
// in our code.
struct VoidExtentData {
uint16_t r;
uint16_t g;
uint16_t b;
uint16_t a;
std::array<uint16_t, 4> coords;
};
// Intermediate endpoint data. Really this is just an endpoint mode
// and a couple of values that represent the data used to decode the
// RGB values from the color endpoint mode.
struct IntermediateEndpointData {
ColorEndpointMode mode;
std::vector<int> colors;
};
// This is an unpacked physical ASTC block, but it does not have enough
// information to be worked with logically. It is simply a container of
// all of the unpacked ASTC information. It is used as a staging area
// for the information that is later Pack()'d into a PhysicalASTCBlock.
struct IntermediateBlockData {
int weight_grid_dim_x;
int weight_grid_dim_y;
int weight_range;
// Quantized, non-interpolated weights
std::vector<int> weights;
// The 10-bit partition ID if we need one
base::Optional<int> partition_id;
// The dual-plane channel in [0, 3] if it exists.
base::Optional<int> dual_plane_channel;
// The quantized/encoded endpoint values for this block. The range of each
// endpoint value is specified by |endpoint_range|, if it exists. If not, the
// range can be queried by calling EndpointRangeForBlock
std::vector<IntermediateEndpointData> endpoints;
// The range [0, endpoint_range] that any one endpoint value can take. Users
// should not write to this value themselves. If it is empty at the time
// someone calls Pack(), it will be automatically inferred. Otherwise, it is
// set by Unpack() based on what the underlying encoding specified.
base::Optional<int> endpoint_range;
};
// Returns the maximum value that a given endpoint value can take according to
// the other settings in the block. Ignores the |endpoint_range| member
// variable. Returns negative values on error:
// -1 : Too many bits required to store weight grid
// -2 : There are too few bits allocated for color endpoint data according to
// C.2.24 in the ASTC spec
int EndpointRangeForBlock(const IntermediateBlockData& data);
inline int EndpointRangeForBlock(const VoidExtentData& data);
// Unpacks the physical ASTC block into the intermediate block. Returns false
// if the physical block is an error encoded block, or if the physical block
// is a void extent block. On error the contents of ib are undefined.
base::Optional<IntermediateBlockData> UnpackIntermediateBlock(
const PhysicalASTCBlock& pb);
// Unpacks the physical ASTC block into a void extent block. Returns false
// if the physical block is an error encoded block, or if the physical block
// is an intermediate block. On error the contents of ib are undefined.
base::Optional<VoidExtentData> UnpackVoidExtent(const PhysicalASTCBlock& pb);
// Packs the given intermediate block into a physical block. Returns an error
// string if the provided values in the intermediate block emit an illegal ASTC
// encoding. In this case the results in the physical block are undefined.
base::Optional<std::string> Pack(const IntermediateBlockData& data,
base::UInt128* pb);
// Packs the given void extent block into a physical block. Returns an error
// string if the provided values in the void extent block emit an illegal ASTC
// encoding. In this case the results in the physical block are undefined.
base::Optional<std::string> Pack(const VoidExtentData& data, base::UInt128* pb);
////////////////////////////////////////////////////////////////////////////////
//
// Impl
inline int EndpointRangeForBlock(const VoidExtentData&) {
// Void extent blocks use 16-bit ARGB definitions
return (1 << 16) - 1;
}
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_INTERMEDIATE_ASTC_BLOCK_H_

262
3rdparty/astc-codec/src/decoder/logical_astc_block.cc vendored
View File

@@ -1,262 +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/endpoint_codec.h"
#include "src/decoder/footprint.h"
#include "src/decoder/integer_sequence_codec.h"
#include "src/decoder/quantization.h"
#include "src/decoder/weight_infill.h"
namespace astc_codec {
namespace {
Partition GenerateSinglePartition(Footprint footprint) {
return Partition { footprint, /* num_parts = */ 1, /* partition_id = */ 0,
std::vector<int>(footprint.NumPixels(), 0) };
}
static std::vector<EndpointPair> DecodeEndpoints(const IntermediateBlockData& block) {
const int endpoint_range = block.endpoint_range
? block.endpoint_range.value()
: EndpointRangeForBlock(block);
assert(endpoint_range > 0);
std::vector<EndpointPair> endpoints;
for (const auto& eps : block.endpoints) {
RgbaColor decmp_one_rgba, decmp_two_rgba;
DecodeColorsForMode(eps.colors, endpoint_range, eps.mode,
&decmp_one_rgba, &decmp_two_rgba);
endpoints.emplace_back(decmp_one_rgba, decmp_two_rgba);
}
return endpoints;
}
static std::vector<EndpointPair> DecodeEndpoints(const VoidExtentData& block) {
EndpointPair eps;
eps.first[0] = eps.second[0] = (block.r * 255) / 65535;
eps.first[1] = eps.second[1] = (block.g * 255) / 65535;
eps.first[2] = eps.second[2] = (block.b * 255) / 65535;
eps.first[3] = eps.second[3] = (block.a * 255) / 65535;
std::vector<EndpointPair> endpoints;
endpoints.emplace_back(eps);
return endpoints;
}
Partition ComputePartition(const Footprint& footprint,
const IntermediateBlockData& block) {
if (block.partition_id) {
const int part_id = block.partition_id.value();
const int num_parts = int(block.endpoints.size());
return GetASTCPartition(footprint, num_parts, part_id);
} else {
return GenerateSinglePartition(footprint);
}
}
Partition ComputePartition(const Footprint& footprint, const VoidExtentData&) {
return GenerateSinglePartition(footprint);
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
LogicalASTCBlock::LogicalASTCBlock(const Footprint& footprint)
: endpoints_(1),
weights_(footprint.NumPixels(), 0),
partition_(GenerateSinglePartition(footprint)) { }
LogicalASTCBlock::LogicalASTCBlock(const Footprint& footprint,
const IntermediateBlockData& block)
: endpoints_(DecodeEndpoints(block)),
partition_(ComputePartition(footprint, block)) {
CalculateWeights(footprint, block);
}
LogicalASTCBlock::LogicalASTCBlock(const Footprint& footprint,
const VoidExtentData& block)
: endpoints_(DecodeEndpoints(block)),
partition_(ComputePartition(footprint, block)) {
CalculateWeights(footprint, block);
}
void LogicalASTCBlock::CalculateWeights(const Footprint& footprint,
const IntermediateBlockData& block) {
const int grid_size_x = block.weight_grid_dim_x;
const int grid_size_y = block.weight_grid_dim_y;
const int weight_grid_size = grid_size_x * grid_size_y;
// Either we have a dual plane and we have twice as many weights as
// specified or we don't
assert(block.dual_plane_channel
? block.weights.size() == size_t(weight_grid_size * 2)
: block.weights.size() == size_t(weight_grid_size));
std::vector<int> unquantized;
unquantized.reserve(weight_grid_size);
// According to C.2.16, if we have dual-plane weights, then we have two
// weights per texel -- one adjacent to the other. Hence, we have to skip
// some when we decode the separate weight values.
const int weight_frequency = (block.dual_plane_channel) ? 2 : 1;
const int weight_range = block.weight_range;
for (int i = 0; i < weight_grid_size; ++i) {
const int weight = block.weights[i * weight_frequency];
unquantized.push_back(UnquantizeWeightFromRange(weight, weight_range));
}
weights_ = InfillWeights(unquantized, footprint, grid_size_x, grid_size_y);
if (block.dual_plane_channel) {
SetDualPlaneChannel(block.dual_plane_channel.value());
for (int i = 0; i < weight_grid_size; ++i) {
const int weight = block.weights[i * weight_frequency + 1];
unquantized[i] = UnquantizeWeightFromRange(weight, weight_range);
}
dual_plane_->weights =
InfillWeights(unquantized, footprint, grid_size_x, grid_size_y);
}
}
void LogicalASTCBlock::CalculateWeights(const Footprint& footprint,
const VoidExtentData&) {
weights_ = std::vector<int>(footprint.NumPixels(), 0);
}
void LogicalASTCBlock::SetWeightAt(int x, int y, int weight) {
assert(weight >= 0);
assert(weight <= 64);
weights_.at(y * GetFootprint().Width() + x) = weight;
}
int LogicalASTCBlock::WeightAt(int x, int y) const {
return weights_.at(y * GetFootprint().Width() + x);
}
void LogicalASTCBlock::SetDualPlaneWeightAt(int channel, int x, int y,
int weight) {
assert(weight >= 0);
assert(weight <= 64);
// If it's not a dual plane, then this has no logical meaning
assert(IsDualPlane());
// If it is a dual plane and the passed channel matches the query, then we
// return the specialized weights
if (dual_plane_->channel == channel) {
dual_plane_->weights.at(y * GetFootprint().Width() + x) = weight;
} else {
// If the channel is not the special channel, then return the general weight
SetWeightAt(x, y, weight);
}
}
int LogicalASTCBlock::DualPlaneWeightAt(int channel, int x, int y) const {
// If it's not a dual plane, then we just return the weight for all channels
if (!IsDualPlane()) {
// TODO(google): Log warning, Requesting dual-plane channel for a non
// dual-plane block!
return WeightAt(x, y);
}
// If it is a dual plane and the passed channel matches the query, then we
// return the specialized weights
if (dual_plane_->channel == channel) {
return dual_plane_->weights.at(y * GetFootprint().Width() + x);
}
// If the channel is not the special channel, then return the general weight
return WeightAt(x, y);
}
void LogicalASTCBlock::SetDualPlaneChannel(int channel) {
if (channel < 0) {
dual_plane_.clear();
} else if (dual_plane_) {
dual_plane_->channel = channel;
} else {
dual_plane_ = DualPlaneData {channel, weights_};
}
}
RgbaColor LogicalASTCBlock::ColorAt(int x, int y) const {
const auto footprint = GetFootprint();
assert(x >= 0); assert(x < footprint.Width());
assert(y >= 0); assert(y < footprint.Height());
const int texel_idx = y * footprint.Width() + x;
const int part = partition_.assignment[texel_idx];
const auto& endpoints = endpoints_[part];
RgbaColor result;
for (int channel = 0; channel < 4; ++channel) {
const int weight = (dual_plane_ && dual_plane_->channel == channel)
? dual_plane_->weights[texel_idx]
: weights_[texel_idx];
const int p0 = endpoints.first[channel];
const int p1 = endpoints.second[channel];
assert(p0 >= 0); assert(p0 < 256);
assert(p1 >= 0); assert(p1 < 256);
// According to C.2.19
const int c0 = (p0 << 8) | p0;
const int c1 = (p1 << 8) | p1;
const int c = (c0 * (64 - weight) + c1 * weight + 32) / 64;
// TODO(google): Handle conversion to sRGB or FP16 per C.2.19.
const int quantized = ((c * 255) + 32767) / 65536;
assert(quantized < 256);
result[channel] = quantized;
}
return result;
}
void LogicalASTCBlock::SetPartition(const Partition& p) {
assert(p.footprint == partition_.footprint &&
"New partitions may not be for a different footprint");
partition_ = p;
endpoints_.resize(p.num_parts);
}
void LogicalASTCBlock::SetEndpoints(const EndpointPair& eps, int subset) {
assert(subset < partition_.num_parts);
assert(size_t(subset) < endpoints_.size());
endpoints_[subset] = eps;
}
base::Optional<LogicalASTCBlock> UnpackLogicalBlock(
const Footprint& footprint, const PhysicalASTCBlock& pb) {
if (pb.IsVoidExtent()) {
base::Optional<VoidExtentData> ve = UnpackVoidExtent(pb);
if (!ve) {
return {};
}
return LogicalASTCBlock(footprint, ve.value());
} else {
base::Optional<IntermediateBlockData> ib = UnpackIntermediateBlock(pb);
if (!ib) {
return {};
}
return LogicalASTCBlock(footprint, ib.value());
}
}
} // namespace astc_codec

127
3rdparty/astc-codec/src/decoder/logical_astc_block.h vendored
View File

@@ -1,127 +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.
#ifndef ASTC_CODEC_DECODER_LOGICAL_ASTC_BLOCK_H_
#define ASTC_CODEC_DECODER_LOGICAL_ASTC_BLOCK_H_
#include "src/base/optional.h"
#include "src/decoder/footprint.h"
#include "src/decoder/intermediate_astc_block.h"
#include "src/decoder/partition.h"
#include "src/decoder/physical_astc_block.h"
#include <array>
#include <utility>
#include <vector>
namespace astc_codec {
// A logical ASTC block holds the endpoints, indices, and partition information
// of a compressed block. These values generally do not adhere to any
// quality-for-bitrate-imposed limits and are solely logical entities for
// determining the best representation of a given block.
class LogicalASTCBlock {
public:
LogicalASTCBlock(const LogicalASTCBlock&) = default;
LogicalASTCBlock(LogicalASTCBlock&&) = default;
// Unpack an intermediate block into a logical one.
LogicalASTCBlock(const Footprint& footprint,
const IntermediateBlockData& block);
// Unpack a void extent intermediate block into a logical one.
LogicalASTCBlock(const Footprint& footprint, const VoidExtentData& block);
// Create a new, empty ASTC block
explicit LogicalASTCBlock(const Footprint& footprint);
// Returns the footprint associated with this block. The footprint is defined
// via the partition, because the partition definition is dependent on the
// footprint.
const Footprint& GetFootprint() const { return partition_.footprint; }
// Returns the unquantized and infilled weight in the range [0, 64] for the
// given texel location. Assumes that the block is a single-plane block,
// meaning that weights are used equally across all channels.
void SetWeightAt(int x, int y, int weight);
int WeightAt(int x, int y) const;
// Returns the unquantized and infilled weight in the range [0, 64] for the
// given channel at the given texel location. If the block does not have a
// dual-plane channel then the reference-returning version will fail, as it
// cannot return a reference to a value that (potentially) doesn't exist.
void SetDualPlaneWeightAt(int channel, int x, int y, int weight);
int DualPlaneWeightAt(int channel, int x, int y) const;
// Returns the color as it would be in the given pixel coordinates of the
// block. Fails if the coordinates are outside of the range of the block
// footprint
RgbaColor ColorAt(int x, int y) const;
// Sets the current partition for the block. |p|'s footprint must match the
// return value of GetFootprint() or else this call will fail.
void SetPartition(const Partition& p);
// Sets the endpoints for the given subset.
void SetEndpoints(const EndpointPair& eps, int subset);
void SetEndpoints(const Endpoint& ep1, const Endpoint& ep2, int subset) {
SetEndpoints(std::make_pair(ep1, ep2), subset);
}
// Sets the dual plane channel for the block. Value must be within the range
// [0, 3]. If a negative value is passed, then the dual-plane data for the
// block is removed, and the block is treated as a single-plane block.
void SetDualPlaneChannel(int channel);
bool IsDualPlane() const { return dual_plane_.hasValue(); }
private:
// A block may have up to four endpoint pairs.
std::vector<EndpointPair> endpoints_;
// Weights are stored as values in the interval [0, 64].
std::vector<int> weights_;
// The partition information for this block. This determines the
// appropriate subsets that each pixel should belong to.
Partition partition_;
// Dual plane data holds both the channel and the weights that describe
// the dual plane data for the given block. If a block has a dual plane, then
// we need to know both the channel and the weights associated with it.
struct DualPlaneData {
int channel;
std::vector<int> weights;
};
// The dual-plane data is optional from a logical representation of the block.
base::Optional<DualPlaneData> dual_plane_;
// Calculates the unquantized and interpolated weights from the encoded weight
// values and possibly dual-plane weights specified in the passed ASTC block.
void CalculateWeights(const Footprint& footprint,
const IntermediateBlockData& block);
// Calculates the weights for a VoidExtentBlock.
void CalculateWeights(const Footprint& footprint,
const VoidExtentData& block);
};
// Unpacks the physical ASTC block into a logical block. Returns false if the
// physical block is an error encoded block.
base::Optional<LogicalASTCBlock> UnpackLogicalBlock(
const Footprint& footprint, const PhysicalASTCBlock& pb);
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_LOGICAL_ASTC_BLOCK_H_

601
3rdparty/astc-codec/src/decoder/partition.cc vendored
View File

@@ -1,601 +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 "src/base/bottom_n.h"
#include "src/base/utils.h"
#include "src/decoder/footprint.h"
#include <algorithm>
#include <array>
#include <limits>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_set>
#include <utility>
namespace astc_codec {
namespace {
// The maximum number of partitions supported by ASTC is four.
constexpr int kMaxNumSubsets = 4;
// Partition selection function based on the ASTC specification.
// See section C.2.21
int SelectASTCPartition(int seed, int x, int y, int z, int partitioncount,
int num_pixels) {
if (partitioncount <= 1) {
return 0;
}
if (num_pixels < 31) {
x <<= 1;
y <<= 1;
z <<= 1;
}
seed += (partitioncount - 1) * 1024;
uint32_t rnum = seed;
rnum ^= rnum >> 15;
rnum -= rnum << 17;
rnum += rnum << 7;
rnum += rnum << 4;
rnum ^= rnum >> 5;
rnum += rnum << 16;
rnum ^= rnum >> 7;
rnum ^= rnum >> 3;
rnum ^= rnum << 6;
rnum ^= rnum >> 17;
uint8_t seed1 = rnum & 0xF;
uint8_t seed2 = (rnum >> 4) & 0xF;
uint8_t seed3 = (rnum >> 8) & 0xF;
uint8_t seed4 = (rnum >> 12) & 0xF;
uint8_t seed5 = (rnum >> 16) & 0xF;
uint8_t seed6 = (rnum >> 20) & 0xF;
uint8_t seed7 = (rnum >> 24) & 0xF;
uint8_t seed8 = (rnum >> 28) & 0xF;
uint8_t seed9 = (rnum >> 18) & 0xF;
uint8_t seed10 = (rnum >> 22) & 0xF;
uint8_t seed11 = (rnum >> 26) & 0xF;
uint8_t seed12 = ((rnum >> 30) | (rnum << 2)) & 0xF;
seed1 *= seed1;
seed2 *= seed2;
seed3 *= seed3;
seed4 *= seed4;
seed5 *= seed5;
seed6 *= seed6;
seed7 *= seed7;
seed8 *= seed8;
seed9 *= seed9;
seed10 *= seed10;
seed11 *= seed11;
seed12 *= seed12;
int sh1, sh2, sh3;
if (seed & 1) {
sh1 = (seed & 2 ? 4 : 5);
sh2 = (partitioncount == 3 ? 6 : 5);
} else {
sh1 = (partitioncount == 3 ? 6 : 5);
sh2 = (seed & 2 ? 4 : 5);
}
sh3 = (seed & 0x10) ? sh1 : sh2;
seed1 >>= sh1;
seed2 >>= sh2;
seed3 >>= sh1;
seed4 >>= sh2;
seed5 >>= sh1;
seed6 >>= sh2;
seed7 >>= sh1;
seed8 >>= sh2;
seed9 >>= sh3;
seed10 >>= sh3;
seed11 >>= sh3;
seed12 >>= sh3;
int a = seed1 * x + seed2 * y + seed11 * z + (rnum >> 14);
int b = seed3 * x + seed4 * y + seed12 * z + (rnum >> 10);
int c = seed5 * x + seed6 * y + seed9 * z + (rnum >> 06);
int d = seed7 * x + seed8 * y + seed10 * z + (rnum >> 02);
a &= 0x3F;
b &= 0x3F;
c &= 0x3F;
d &= 0x3F;
if (partitioncount <= 3) {
d = 0;
}
if (partitioncount <= 2) {
c = 0;
}
if (a >= b && a >= c && a >= d) {
return 0;
} else if (b >= c && b >= d) {
return 1;
} else if (c >= d) {
return 2;
} else {
return 3;
}
}
// A partition hash that we can pass to containers like std::unordered_set
struct PartitionHasher {
size_t operator()(const Partition& part) const {
// The issue here is that if we have two different partitions, A and B, then
// their hash should be equal if A and B are equal. We define the distance
// between A and B using PartitionMetric, but internally that finds a 1-1
// mapping from labels in A to labels in B.
//
// With that in mind, when we define a hash for partitions, we need to find
// a 1-1 mapping to a 'universal' labeling scheme. Here we define that as
// the heuristic: the first encountered label will be 0, the second will be
// 1, etc. This creates a unique 1-1 mapping scheme from any partition.
//
// Note, we can't use this heuristic for the PartitionMetric, as it will
// generate very large discrepancies between similar labellings (for example
// 000...001 vs 011...111). We are just looking for a boolean distinction
// whether or not two partitions are different and don't care how different
// they are.
std::array<int, kMaxNumSubsets> mapping {{ -1, -1, -1, -1 }};
int next_subset = 0;
for (int subset : part.assignment) {
if (mapping[subset] < 0) {
mapping[subset] = next_subset++;
}
}
assert(next_subset <= kMaxNumSubsets);
// The return value will be the hash of the assignment according to this
// mapping
const size_t seed0 = 0;
return std::accumulate(part.assignment.begin(), part.assignment.end(), seed0,
[&mapping](size_t seed, const int& subset) {
std::hash<size_t> hasher;
const int s = mapping[subset];
return hasher(seed) ^ hasher(static_cast<size_t>(s));
});
}
};
// Construct a VP-Tree of partitions. Since our PartitionMetric satisfies
// the triangle inequality, we can use this general higher-dimensional space
// partitioning tree to organize our partitions.
//
// TODO(google): !SPEED! Right now this tree stores an actual linked
// structure of pointers which is likely very slow during construction and
// very not cache-coherent during traversal, so it'd probably be good to
// switch to a flattened binary tree structure if performance becomes an
// issue.
class PartitionTree {
public:
// Unclear what it means to have an uninitialized tree, so delete default
// constructors, but allow the tree to be moved
PartitionTree() = delete;
PartitionTree(const PartitionTree&) = delete;
PartitionTree(PartitionTree&& t) = default;
// Generate a PartitionTree from iterators over |Partition|s
template<typename Itr>
PartitionTree(Itr begin, Itr end) : parts_(begin, end) {
std::vector<int> part_indices(parts_.size());
std::iota(part_indices.begin(), part_indices.end(), 0);
root_ = std::unique_ptr<PartitionTreeNode>(
new PartitionTreeNode(parts_, part_indices));
}
// Search for the k-nearest partitions that are closest to part based on
// the result of PartitionMetric
void Search(const Partition& part, int k,
std::vector<const Partition*>* const results,
std::vector<int>* const distances) const {
ResultHeap heap(k);
SearchNode(root_, part, &heap);
results->clear();
if (nullptr != distances) {
distances->clear();
}
std::vector<ResultNode> search_results = heap.Pop();
for (const auto& result : search_results) {
results->push_back(&parts_[result.part_idx]);
if (nullptr != distances) {
distances->push_back(result.distance);
}
}
assert(results->size() == size_t(k));
}
private:
// Heap elements to be stored while searching the tree. The two relevant
// pieces of information are the partition index and it's distance from the
// queried partition.
struct ResultNode {
int part_idx;
int distance;
// Heap based on distance from query point.
bool operator<(const ResultNode& other) const {
return distance < other.distance;
}
};
using ResultHeap = base::BottomN<ResultNode>;
struct PartitionTreeNode {
int part_idx;
int split_dist;
std::unique_ptr<PartitionTreeNode> left;
std::unique_ptr<PartitionTreeNode> right;
PartitionTreeNode(const std::vector<Partition> &parts,
const std::vector<int> &part_indices)
: split_dist(-1) {
assert(part_indices.size() > 0);
right.reset(nullptr);
left.reset(nullptr);
// Store the first node as our vantage point
part_idx = part_indices[0];
const Partition& vantage_point = parts[part_indices[0]];
// Calculate the distances of the remaining nodes against the vantage
// point.
std::vector<std::pair<int, int>> part_dists;
for (size_t i = 1; i < part_indices.size(); ++i) {
const int idx = part_indices[i];
const int dist = PartitionMetric(vantage_point, parts[idx]);
if (dist > 0) {
part_dists.push_back(std::make_pair(idx, dist));
}
}
// If there are no more different parts, then this is a leaf node
if (part_dists.empty()) {
return;
}
struct OrderBySecond {
typedef std::pair<int, int> PairType;
bool operator()(const PairType& lhs, const PairType& rhs) {
return lhs.second < rhs.second;
}
};
// We want to partition the set such that the points are ordered
// based on their distances from the vantage point. We can do this
// using the partial sort of nth element.
std::nth_element(
part_dists.begin(), part_dists.begin() + part_dists.size() / 2,
part_dists.end(), OrderBySecond());
// Once that's done, our split position is in the middle
const auto split_iter = part_dists.begin() + part_dists.size() / 2;
split_dist = split_iter->second;
// Recurse down the right and left sub-trees with the indices of the
// parts that are farther and closer respectively
std::vector<int> right_indices;
for (auto itr = split_iter; itr != part_dists.end(); ++itr) {
right_indices.push_back(itr->first);
}
if (!right_indices.empty()) {
right.reset(new PartitionTreeNode(parts, right_indices));
}
std::vector<int> left_indices;
for (auto itr = part_dists.begin(); itr != split_iter; ++itr) {
left_indices.push_back(itr->first);
}
if (!left_indices.empty()) {
left.reset(new PartitionTreeNode(parts, left_indices));
}
}
};
void SearchNode(const std::unique_ptr<PartitionTreeNode>& node,
const Partition& p, ResultHeap* const heap) const {
if (nullptr == node) {
return;
}
// Calculate distance against current node
const int dist = PartitionMetric(parts_[node->part_idx], p);
// Push it onto the heap and remove the top-most nodes to maintain
// closest k indices.
ResultNode result;
result.part_idx = node->part_idx;
result.distance = dist;
heap->Push(result);
// If the split distance is uninitialized, it means we have no children.
if (node->split_dist < 0) {
assert(nullptr == node->left);
assert(nullptr == node->right);
return;
}
// Next we need to check the left and right trees if their distance
// is closer/farther than the farthest element on the heap
const int tau = heap->Top().distance;
if (dist + tau < node->split_dist || dist - tau < node->split_dist) {
SearchNode(node->left, p, heap);
}
if (dist + tau > node->split_dist || dist - tau > node->split_dist) {
SearchNode(node->right, p, heap);
}
}
std::vector<Partition> parts_;
std::unique_ptr<PartitionTreeNode> root_;
};
// A helper function that generates all of the partitions for each number of
// subsets in ASTC blocks and stores them in a PartitionTree for fast retrieval.
const int kNumASTCPartitionIDBits = 10;
PartitionTree GenerateASTCPartitionTree(Footprint footprint) {
std::unordered_set<Partition, PartitionHasher> parts;
for (int num_parts = 2; num_parts <= kMaxNumSubsets; ++num_parts) {
for (int id = 0; id < (1 << kNumASTCPartitionIDBits); ++id) {
Partition part = GetASTCPartition(footprint, num_parts, id);
// Make sure we're not using a degenerate partition assignment that wastes
// an endpoint pair...
bool valid_part = true;
for (int i = 0; i < num_parts; ++i) {
if (std::find(part.assignment.begin(), part.assignment.end(), i) ==
part.assignment.end()) {
valid_part = false;
break;
}
}
if (valid_part) {
parts.insert(std::move(part));
}
}
}
return PartitionTree(parts.begin(), parts.end());
}
// To avoid needing any fancy boilerplate for mapping from a width, height
// tuple, we can define a simple encoding for the block mode:
constexpr int EncodeDims(int width, int height) {
return (width << 16) | height;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
int PartitionMetric(const Partition& a, const Partition& b) {
// Make sure that one partition is at least a subset of the other...
UTILS_RELEASE_ASSERT(a.footprint == b.footprint);
// Make sure that the number of parts is within our limits. ASTC has a maximum
// of four subsets per block according to the specification.
UTILS_RELEASE_ASSERT(a.num_parts <= kMaxNumSubsets);
UTILS_RELEASE_ASSERT(b.num_parts <= kMaxNumSubsets);
const int w = a.footprint.Width();
const int h = b.footprint.Height();
struct PairCount {
int a;
int b;
int count;
// Comparison needed for sort below.
bool operator>(const PairCount& other) const {
return count > other.count;
}
};
// Since we need to find the smallest mapping from labels in A to labels in B,
// we need to store each label pair in a structure that can later be sorted.
// The maximum number of subsets in an ASTC block is four, meaning that
// between the two partitions, we can have up to sixteen different pairs.
std::array<PairCount, 16> pair_counts;
for (int y = 0; y < 4; ++y) {
for (int x = 0; x < 4; ++x) {
const int idx = y * 4 + x;
pair_counts[idx].a = x;
pair_counts[idx].b = y;
pair_counts[idx].count = 0;
}
}
// Count how many times we see each pair of assigned values (order matters!)
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
const int idx = y * w + x;
const int a_val = a.assignment[idx];
const int b_val = b.assignment[idx];
assert(a_val >= 0);
assert(b_val >= 0);
assert(a_val < 4);
assert(b_val < 4);
++(pair_counts[b_val * 4 + a_val].count);
}
}
// Sort the pairs in descending order based on their count
std::sort(pair_counts.begin(), pair_counts.end(), std::greater<PairCount>());
// Now assign pairs one by one until we have no more pairs to assign. Once
// a value from A is assigned to a value in B, it can no longer be reassigned,
// so we can keep track of this in a matrix. Similarly, to keep the assignment
// one-to-one, once a value in B has been assigned to, it cannot be assigned
// to again.
std::array<std::array<bool, kMaxNumSubsets>, kMaxNumSubsets> assigned { };
int pixels_matched = 0;
for (const auto& pair_count : pair_counts) {
bool is_assigned = false;
for (int i = 0; i < kMaxNumSubsets; ++i) {
is_assigned |= assigned.at(pair_count.a).at(i);
is_assigned |= assigned.at(i).at(pair_count.b);
}
if (!is_assigned) {
assigned.at(pair_count.a).at(pair_count.b) = true;
pixels_matched += pair_count.count;
}
}
// The difference is the number of pixels that had an assignment versus the
// total number of pixels.
return w * h - pixels_matched;
}
// Generates the partition assignment for the given block attributes.
Partition GetASTCPartition(const Footprint& footprint, int num_parts,
int partition_id) {
// Partitions must have at least one subset but may have at most four
assert(num_parts >= 0);
assert(num_parts <= kMaxNumSubsets);
// Partition ID can be no more than 10 bits.
assert(partition_id >= 0);
assert(partition_id < 1 << 10);
Partition part = {footprint, num_parts, partition_id, /* assignment = */ {}};
part.assignment.reserve(footprint.NumPixels());
// Maintain column-major order so that we match all of the image processing
// algorithms that depend on this class.
for (int y = 0; y < footprint.Height(); ++y) {
for (int x = 0; x < footprint.Width(); ++x) {
const int p = SelectASTCPartition(partition_id, x, y, 0, num_parts,
footprint.NumPixels());
part.assignment.push_back(p);
}
}
return part;
}
const std::vector<const Partition*> FindKClosestASTCPartitions(
const Partition& candidate, int k) {
const int encoded_dims = EncodeDims(candidate.footprint.Width(),
candidate.footprint.Height());
int index = 0;
switch (encoded_dims) {
case EncodeDims(4, 4): index = 0; break;
case EncodeDims(5, 4): index = 1; break;
case EncodeDims(5, 5): index = 2; break;
case EncodeDims(6, 5): index = 3; break;
case EncodeDims(6, 6): index = 4; break;
case EncodeDims(8, 5): index = 5; break;
case EncodeDims(8, 6): index = 6; break;
case EncodeDims(8, 8): index = 7; break;
case EncodeDims(10, 5): index = 8; break;
case EncodeDims(10, 6): index = 9; break;
case EncodeDims(10, 8): index = 10; break;
case EncodeDims(10, 10): index = 11; break;
case EncodeDims(12, 10): index = 12; break;
case EncodeDims(12, 12): index = 13; break;
default:
assert(false && "Unknown footprint dimensions. This should have been caught sooner.");
break;
}
static const auto* const kASTCPartitionTrees =
new std::array<PartitionTree, Footprint::NumValidFootprints()> {{
GenerateASTCPartitionTree(Footprint::Get4x4()),
GenerateASTCPartitionTree(Footprint::Get5x4()),
GenerateASTCPartitionTree(Footprint::Get5x5()),
GenerateASTCPartitionTree(Footprint::Get6x5()),
GenerateASTCPartitionTree(Footprint::Get6x6()),
GenerateASTCPartitionTree(Footprint::Get8x5()),
GenerateASTCPartitionTree(Footprint::Get8x6()),
GenerateASTCPartitionTree(Footprint::Get8x8()),
GenerateASTCPartitionTree(Footprint::Get10x5()),
GenerateASTCPartitionTree(Footprint::Get10x6()),
GenerateASTCPartitionTree(Footprint::Get10x8()),
GenerateASTCPartitionTree(Footprint::Get10x10()),
GenerateASTCPartitionTree(Footprint::Get12x10()),
GenerateASTCPartitionTree(Footprint::Get12x12()),
}};
const PartitionTree& parts_vptree = kASTCPartitionTrees->at(index);
std::vector<const Partition*> results;
parts_vptree.Search(candidate, k, &results, nullptr);
return results;
}
// Returns the valid ASTC partition that is closest to the candidate based on
// the PartitionMetric defined above.
const Partition& FindClosestASTCPartition(const Partition& candidate) {
// Given a candidate, the closest valid partition will likely not be an exact
// match. Consider all of the texels for which this valid partition differs
// with the candidate.
//
// If the valid partition has more subsets than the candidate, then all of the
// highest subset will be included in the mismatched texels. Since the number
// of possible partitions with increasing subsets grows exponentially, the
// chance that a valid partition with fewer subsets appears within the first
// few closest partitions is relatively high. Empirically, we can usually find
// a partition with at most |candidate.num_parts| number of subsets within the
// first four closest partitions.
constexpr int kSearchItems = 4;
const std::vector<const Partition*> results =
FindKClosestASTCPartitions(candidate, kSearchItems);
// Optimistically, look for result with the same number of subsets.
for (const auto& result : results) {
if (result->num_parts == candidate.num_parts) {
return *result;
}
}
// If all else fails, then at least find the result with fewer subsets than
// we asked for.
for (const auto& result : results) {
if (result->num_parts < candidate.num_parts) {
return *result;
}
}
assert(false &&
"Could not find partition with acceptable number of subsets!");
return *(results[0]);
}
} // namespace astc_codec

97
3rdparty/astc-codec/src/decoder/partition.h vendored
View File

@@ -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.
#ifndef ASTC_CODEC_DECODER_PARTITION_H_
#define ASTC_CODEC_DECODER_PARTITION_H_
#include "src/base/optional.h"
#include "src/decoder/footprint.h"
#include <vector>
namespace astc_codec {
struct Partition;
// Determines the "difference" between any two partitions of the same size.
// This metric attempts to find the best one to one mapping from the labels in
// partition a against the labels in partition b. Once that mapping is found, it
// returns the number of pixels that are mismatched between the two. Each
// partition is expected to start in the upper left corner of the block and
// proceed in raster-scan order. Two partitions are equal if the mapping is
// bijective. This metric is a metric in the mathematical sense. In other words
// it has the following properties:
//
// 1) PartitionMetric(a, b) >= 0
// 2) PartitionMetric(a, b) == PartitionMetric(b, a)
// 3) PartitionMetric(a, b) == 0 iff a == b
// 4) PartitionMetric(a, b) + PartitionMetric(b, c) >= PartitionMetric(a, c)
//
// Throws an error if one partition's footprint is not equal to the other.
int PartitionMetric(const Partition& a, const Partition& b);
// A partition is a way to divide up an ASTC block into disjoint subsets such
// that each subset uses a different set of endpoints. This is used to increase
// the compression quality of blocks. One way to store such a partition is to
// assign an ID to use with a predetermined decoding method. Here we store the
// logical representation of partitions by keeping a per-pixel label. All pixels
// that share a label belong to the same subset.
struct Partition {
// The footprint width and height of this partition. This determines the size
// of the assignment array.
Footprint footprint;
// The number of subsets in this partition. The values in the partition
// assignment fall within the range [0, num_parts). The maximum number of
// parts supported is four.
int num_parts;
// The 10-bit partition ID as stored in bits 13-22 of multi-part ASTC blocks.
// (See Section C.2.9) If there is no guarantee that this partition is a valid
// ASTC partition, this should be set to absl::nullopt.
base::Optional<int> partition_id;
// A value in the range [0, num_parts) corresponding to the label for
// the given texel (x, y) in [0, footprint_width) x [0, footprint_height)
// using a raster-order layout.
std::vector<int> assignment;
// Returns true only if their "distance" is zero, i.e. if they have compatible
// subset assignments.
bool operator==(const Partition& other) const {
return PartitionMetric(*this, other) == 0;
}
};
// Generates the ASTC partition assignment for the given block attributes.
Partition GetASTCPartition(const Footprint& footprint, int num_parts,
int partition_id);
// Returns the |k| valid ASTC partitions that are closest to the candidate based
// on the PartitionMetric defined above.
const std::vector<const Partition*> FindKClosestASTCPartitions(
const Partition& candidate, int k);
// Returns the valid ASTC partition closest to the candidate with at most as
// many subsets as the |candidate|. Note: this is not a deterministic function,
// as the underlying valid partitions are sorted using a hash map and a distance
// function whose range is the natural numbers. The chances that two or more
// partitions are equally 'closest' is possible, in which case this function
// makes no guarantees about which one it will return. For more control, use
// FindKClosestASTCPartitions above.
const Partition& FindClosestASTCPartition(const Partition& candidate);
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_PARTITION_H_

761
3rdparty/astc-codec/src/decoder/physical_astc_block.cc vendored
View File

@@ -1,761 +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/math_utils.h"
#include "src/base/optional.h"
#include "src/base/uint128.h"
#include "src/decoder/integer_sequence_codec.h"
#include <array>
#include <cmath>
namespace astc_codec {
namespace {
static_assert(static_cast<int>(ColorEndpointMode::kNumColorEndpointModes) == 16,
"There are only sixteen color endpoint modes defined in the "
"ASTC specification. If this is false, then the enum may be "
"incorrect.");
constexpr int kASTCBlockSizeBits = 128;
//constexpr int kASTCBlockSizeBytes = kASTCBlockSizeBits / 8;
constexpr uint32_t kVoidExtentMaskBits = 9;
constexpr uint32_t kVoidExtentMask = 0x1FC;
constexpr int kWeightGridMinBitLength = 24;
constexpr int kWeightGridMaxBitLength = 96;
constexpr int kMaxNumPartitions = 4;
constexpr int kMaxNumWeights = 64;
// These are the overall block modes defined in table C.2.8. There are 10
// weight grid encoding schemes + void extent.
enum class BlockMode {
kB4_A2,
kB8_A2,
kA2_B8,
kA2_B6,
kB2_A2,
k12_A2,
kA2_12,
k6_10,
k10_6,
kA6_B6,
kVoidExtent,
};
struct WeightGridProperties {
int width;
int height;
int range;
};
// Local function prototypes
base::Optional<BlockMode> DecodeBlockMode(const base::UInt128 astc_bits);
base::Optional<WeightGridProperties> DecodeWeightProps(
const base::UInt128 astc_bits, std::string* error);
std::array<int, 4> DecodeVoidExtentCoords(const base::UInt128 astc_bits);
bool DecodeDualPlaneBit(const base::UInt128 astc_bits);
int DecodeNumPartitions(const base::UInt128 astc_bits);
int DecodeNumWeightBits(const base::UInt128 astc_bits);
int DecodeDualPlaneBitStartPos(const base::UInt128 astc_bits);
ColorEndpointMode DecodeEndpointMode(const base::UInt128 astc_bits,
int partition);
int DecodeNumColorValues(const base::UInt128 astc_bits);
// Returns the block mode, if it's valid.
base::Optional<BlockMode> DecodeBlockMode(const base::UInt128 astc_bits) {
using Result = base::Optional<BlockMode>;
const uint64_t low_bits = astc_bits.LowBits();
if (base::GetBits(low_bits, 0, kVoidExtentMaskBits) == kVoidExtentMask) {
return Result(BlockMode::kVoidExtent);
}
if (base::GetBits(low_bits, 0, 2) != 0) {
const uint64_t mode_bits = base::GetBits(low_bits, 2, 2);
switch (mode_bits) {
case 0: return Result(BlockMode::kB4_A2);
case 1: return Result(BlockMode::kB8_A2);
case 2: return Result(BlockMode::kA2_B8);
case 3: return base::GetBits(low_bits, 8, 1) ?
Result(BlockMode::kB2_A2) : Result(BlockMode::kA2_B6);
}
} else {
const uint64_t mode_bits = base::GetBits(low_bits, 5, 4);
if ((mode_bits & 0xC) == 0x0) {
if (base::GetBits(low_bits, 0, 4) == 0) {
// Reserved.
return Result();
} else {
return Result(BlockMode::k12_A2);
}
} else if ((mode_bits & 0xC) == 0x4) {
return Result(BlockMode::kA2_12);
} else if (mode_bits == 0xC) {
return Result(BlockMode::k6_10);
} else if (mode_bits == 0xD) {
return Result(BlockMode::k10_6);
} else if ((mode_bits & 0xC) == 0x8) {
return Result(BlockMode::kA6_B6);
}
}
return Result();
}
base::Optional<WeightGridProperties> DecodeWeightProps(
const base::UInt128 astc_bits, std::string* error) {
auto block_mode = DecodeBlockMode(astc_bits);
if (!block_mode) {
*error = "Reserved block mode";
return {};
}
// The dimensions of the weight grid and their range
WeightGridProperties props;
// Determine the weight extents based on the block mode
const uint32_t low_bits =
static_cast<uint32_t>(astc_bits.LowBits() & 0xFFFFFFFF);
switch (block_mode.value()) {
case BlockMode::kB4_A2: {
int a = base::GetBits(low_bits, 5, 2);
int b = base::GetBits(low_bits, 7, 2);
props.width = b + 4;
props.height = a + 2;
}
break;
case BlockMode::kB8_A2: {
int a = base::GetBits(low_bits, 5, 2);
int b = base::GetBits(low_bits, 7, 2);
props.width = b + 8;
props.height = a + 2;
}
break;
case BlockMode::kA2_B8: {
int a = base::GetBits(low_bits, 5, 2);
int b = base::GetBits(low_bits, 7, 2);
props.width = a + 2;
props.height = b + 8;
}
break;
case BlockMode::kA2_B6: {
int a = base::GetBits(low_bits, 5, 2);
int b = base::GetBits(low_bits, 7, 1);
props.width = a + 2;
props.height = b + 6;
}
break;
case BlockMode::kB2_A2: {
int a = base::GetBits(low_bits, 5, 2);
int b = base::GetBits(low_bits, 7, 1);
props.width = b + 2;
props.height = a + 2;
}
break;
case BlockMode::k12_A2: {
int a = base::GetBits(low_bits, 5, 2);
props.width = 12;
props.height = a + 2;
}
break;
case BlockMode::kA2_12: {
int a = base::GetBits(low_bits, 5, 2);
props.width = a + 2;
props.height = 12;
}
break;
case BlockMode::k6_10: {
props.width = 6;
props.height = 10;
}
break;
case BlockMode::k10_6: {
props.width = 10;
props.height = 6;
}
break;
case BlockMode::kA6_B6: {
int a = base::GetBits(low_bits, 5, 2);
int b = base::GetBits(low_bits, 9, 2);
props.width = a + 6;
props.height = b + 6;
}
break;
// Void extent blocks have no weight grid.
case BlockMode::kVoidExtent:
*error = "Void extent block has no weight grid";
return {};
// We have a valid block mode which isn't a void extent? We
// should be able to decode the weight grid dimensions.
default:
assert(false && "Error decoding weight grid");
*error = "Internal error";
return {};
}
// Determine the weight range based on the block mode
uint32_t r = base::GetBits(low_bits, 4, 1);
switch (block_mode.value()) {
case BlockMode::kB4_A2:
case BlockMode::kB8_A2:
case BlockMode::kA2_B8:
case BlockMode::kA2_B6:
case BlockMode::kB2_A2: {
r |= base::GetBits(low_bits, 0, 2) << 1;
}
break;
case BlockMode::k12_A2:
case BlockMode::kA2_12:
case BlockMode::k6_10:
case BlockMode::k10_6:
case BlockMode::kA6_B6: {
r |= base::GetBits(low_bits, 2, 2) << 1;
}
break;
// We have a valid block mode which doesn't have weights? We
// should have caught this earlier.
case BlockMode::kVoidExtent:
default:
assert(false && "Error decoding weight grid");
*error = "Internal error";
return {};
}
// Decode the range...
// High bit is in bit 9 unless we're using a particular block mode
uint32_t h = base::GetBits(low_bits, 9, 1);
if (block_mode == BlockMode::kA6_B6) {
h = 0;
}
// Figure out the range of the weights (Table C.2.7)
constexpr std::array<int, 16> kWeightRanges = {{
-1, -1, 1, 2, 3, 4, 5, 7, -1, -1, 9, 11, 15, 19, 23, 31
}};
assert(((h << 3) | r) < kWeightRanges.size());
props.range = kWeightRanges.at((h << 3) | r);
if (props.range < 0) {
*error = "Reserved range for weight bits";
return {};
}
// Error checking -- do we have too many weights?
int num_weights = props.width * props.height;
if (DecodeDualPlaneBit(astc_bits)) {
num_weights *= 2;
}
if (kMaxNumWeights < num_weights) {
*error = "Too many weights specified";
return {};
}
// Do we have too many weight bits?
const int bit_count =
IntegerSequenceCodec::GetBitCountForRange(num_weights, props.range);
if (bit_count < kWeightGridMinBitLength) {
*error = "Too few bits required for weight grid";
return {};
}
if (kWeightGridMaxBitLength < bit_count) {
*error = "Too many bits required for weight grid";
return {};
}
return props;
}
// Returns the four 13-bit integers that define the range of texture
// coordinates present in a void extent block as defined in Section
// C.2.23 of the specification. The coordinates returned are of
// the form (min_s, max_s, min_t, max_t)
std::array<int, 4> DecodeVoidExtentCoords(const base::UInt128 astc_bits) {
const uint64_t low_bits = astc_bits.LowBits();
std::array<int, 4> coords;
for (int i = 0; i < 4; ++i) {
coords[i] = static_cast<int>(base::GetBits(low_bits, 12 + 13 * i, 13));
}
return coords;
}
bool DecodeDualPlaneBit(const base::UInt128 astc_bits) {
base::Optional<BlockMode> block_mode = DecodeBlockMode(astc_bits);
// Void extent blocks certainly aren't dual-plane.
if (block_mode == BlockMode::kVoidExtent) {
return false;
}
// One special block mode doesn't have any dual plane bit
if (block_mode == BlockMode::kA6_B6) {
return false;
}
// Otherwise, dual plane is determined by the 10th bit.
constexpr int kDualPlaneBitPosition = 10;
return base::GetBits(astc_bits, kDualPlaneBitPosition, 1) != 0;
}
int DecodeNumPartitions(const base::UInt128 astc_bits) {
constexpr int kNumPartitionsBitPosition = 11;
constexpr int kNumPartitionsBitLength = 2;
// Non-void extent blocks
const uint64_t low_bits = astc_bits.LowBits();
const int num_partitions = 1 + static_cast<int>(
base::GetBits(low_bits,
kNumPartitionsBitPosition,
kNumPartitionsBitLength));
assert(num_partitions > 0);
assert(num_partitions <= kMaxNumPartitions);
return num_partitions;
}
int DecodeNumWeightBits(const base::UInt128 astc_bits) {
std::string error;
auto maybe_weight_props = DecodeWeightProps(astc_bits, &error);
if (!maybe_weight_props.hasValue()) {
return 0; // No weights? No weight bits...
}
const auto weight_props = maybe_weight_props.value();
// Figure out the number of weights
int num_weights = weight_props.width * weight_props.height;
if (DecodeDualPlaneBit(astc_bits)) {
num_weights *= 2;
}
// The number of bits is determined by the number of values
// that are going to be encoded using the given ise_counts.
return IntegerSequenceCodec::GetBitCountForRange(
num_weights, weight_props.range);
}
// Returns the number of bits after the weight data used to
// store additional CEM bits.
int DecodeNumExtraCEMBits(const base::UInt128 astc_bits) {
const int num_partitions = DecodeNumPartitions(astc_bits);
// Do we only have one partition?
if (num_partitions == 1) {
return 0;
}
// Do we have a shared CEM?
constexpr int kSharedCEMBitPosition = 23;
constexpr int kSharedCEMBitLength = 2;
const base::UInt128 shared_cem =
base::GetBits(astc_bits, kSharedCEMBitPosition, kSharedCEMBitLength);
if (shared_cem == 0) {
return 0;
}
const std::array<int, 4> extra_cem_bits_for_partition = {{ 0, 2, 5, 8 }};
return extra_cem_bits_for_partition[num_partitions - 1];
}
// Returns the starting position of the dual plane channel. This comes
// before the weight data and extra CEM bits.
int DecodeDualPlaneBitStartPos(const base::UInt128 astc_bits) {
const int start_pos = kASTCBlockSizeBits
- DecodeNumWeightBits(astc_bits)
- DecodeNumExtraCEMBits(astc_bits);
if (DecodeDualPlaneBit(astc_bits)) {
return start_pos - 2;
} else {
return start_pos;
}
}
// Decodes a CEM mode based on the partition number.
ColorEndpointMode DecodeEndpointMode(const base::UInt128 astc_bits,
int partition) {
int num_partitions = DecodeNumPartitions(astc_bits);
assert(partition >= 0);
assert(partition < num_partitions);
// Do we only have one partition?
uint64_t low_bits = astc_bits.LowBits();
if (num_partitions == 1) {
uint64_t cem = base::GetBits(low_bits, 13, 4);
return static_cast<ColorEndpointMode>(cem);
}
// More than one partition ... do we have a shared CEM?
if (DecodeNumExtraCEMBits(astc_bits) == 0) {
const uint64_t shared_cem = base::GetBits(low_bits, 25, 4);
return static_cast<ColorEndpointMode>(shared_cem);
}
// More than one partition and no shared CEM...
uint64_t cem = base::GetBits(low_bits, 23, 6);
const int base_cem = static_cast<int>(((cem & 0x3) - 1) * 4);
cem >>= 2; // Skip the base CEM bits
// The number of extra CEM bits at the end of the weight grid is
// determined by the number of partitions and what the base cem mode is...
const int num_extra_cem_bits = DecodeNumExtraCEMBits(astc_bits);
const int extra_cem_start_pos = kASTCBlockSizeBits
- num_extra_cem_bits
- DecodeNumWeightBits(astc_bits);
base::UInt128 extra_cem =
base::GetBits(astc_bits, extra_cem_start_pos, num_extra_cem_bits);
cem |= extra_cem.LowBits() << 4;
// Decode C and M per Figure C.4
int c = -1, m = -1;
for (int i = 0; i < num_partitions; ++i) {
if (i == partition) {
c = cem & 0x1;
}
cem >>= 1;
}
for (int i = 0; i < num_partitions; ++i) {
if (i == partition) {
m = cem & 0x3;
}
cem >>= 2;
}
assert(c >= 0);
assert(m >= 0);
// Compute the mode based on C and M
const int mode = base_cem + 4 * c + m;
assert(mode < static_cast<int>(ColorEndpointMode::kNumColorEndpointModes));
return static_cast<ColorEndpointMode>(mode);
}
int DecodeNumColorValues(const base::UInt128 astc_bits) {
int num_color_values = 0;
auto num_partitions = DecodeNumPartitions(astc_bits);
for (int i = 0; i < num_partitions; ++i) {
ColorEndpointMode endpoint_mode = DecodeEndpointMode(astc_bits, i);
num_color_values += NumColorValuesForEndpointMode(endpoint_mode);
}
return num_color_values;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
static_assert(sizeof(PhysicalASTCBlock) == PhysicalASTCBlock::kSizeInBytes,
"The size of the struct should be the size of the block so that"
"we can effectively use them contiguously in memory.");
PhysicalASTCBlock::PhysicalASTCBlock(const base::UInt128 astc_block)
: astc_bits_(astc_block) {}
PhysicalASTCBlock::PhysicalASTCBlock(const std::string& encoded_block)
: astc_bits_([&encoded_block]() {
assert(encoded_block.size() == PhysicalASTCBlock::kSizeInBytes);
base::UInt128 astc_bits = 0;
int shift = 0;
for (const unsigned char c : encoded_block) {
astc_bits |= base::UInt128(static_cast<uint64_t>(c)) << shift;
shift += 8;
}
return astc_bits;
}())
{ }
base::Optional<std::string> PhysicalASTCBlock::IsIllegalEncoding() const {
// If the block is not a void extent block, then it must have
// weights specified. DecodeWeightProps will return the weight specifications
// if they exist and are legal according to C.2.24, and will otherwise be
// empty.
base::Optional<BlockMode> block_mode = DecodeBlockMode(astc_bits_);
if (block_mode != BlockMode::kVoidExtent) {
std::string error;
auto maybe_weight_props = DecodeWeightProps(astc_bits_, &error);
if (!maybe_weight_props.hasValue()) {
return error;
}
}
// Check void extent blocks...
if (block_mode == BlockMode::kVoidExtent) {
// ... for reserved bits incorrectly set
if (base::GetBits(astc_bits_, 10, 2) != 0x3) {
return std::string("Reserved bits set for void extent block");
}
// ... for incorrectly defined texture coordinates
std::array<int, 4> coords = DecodeVoidExtentCoords(astc_bits_);
bool coords_all_1s = true;
for (const auto coord : coords) {
coords_all_1s &= coord == ((1 << 13) - 1);
}
if (!coords_all_1s && (coords[0] >= coords[1] || coords[2] >= coords[3])) {
return std::string("Void extent texture coordinates are invalid");
}
}
// If the number of color values exceeds a threshold and it isn't a void
// extent block then we've run into an error
if (block_mode != BlockMode::kVoidExtent) {
int num_color_vals = DecodeNumColorValues(astc_bits_);
if (num_color_vals > 18) {
return std::string("Too many color values");
}
// The maximum number of available color bits is the number of
// bits between the dual plane bits and the base CEM. This must
// be larger than a threshold defined in C.2.24.
// Dual plane bit starts after weight bits and CEM
const int num_partitions = DecodeNumPartitions(astc_bits_);
const int dual_plane_start_pos = DecodeDualPlaneBitStartPos(astc_bits_);
const int color_start_bit = (num_partitions == 1) ? 17 : 29;
const int required_color_bits = ((13 * num_color_vals) + 4) / 5;
const int available_color_bits = dual_plane_start_pos - color_start_bit;
if (available_color_bits < required_color_bits) {
return std::string("Not enough color bits");
}
// If we have four partitions and a dual plane then we have a problem.
if (num_partitions == 4 && DecodeDualPlaneBit(astc_bits_)) {
return std::string("Both four partitions and dual plane specified");
}
}
// Otherwise we're OK
return { };
}
bool PhysicalASTCBlock::IsVoidExtent() const {
// If it's an error block, it's not a void extent block.
if (IsIllegalEncoding()) {
return false;
}
return DecodeBlockMode(astc_bits_) == BlockMode::kVoidExtent;
}
base::Optional<std::array<int, 4>> PhysicalASTCBlock::VoidExtentCoords() const {
if (IsIllegalEncoding() || !IsVoidExtent()) {
return { };
}
// If void extent coords are all 1's then these are not valid void extent
// coords
const uint64_t ve_mask = 0xFFFFFFFFFFFFFDFFULL;
const uint64_t const_blk_mode = 0xFFFFFFFFFFFFFDFCULL;
if ((ve_mask & astc_bits_.LowBits()) == const_blk_mode) {
return {};
}
return DecodeVoidExtentCoords(astc_bits_);
}
bool PhysicalASTCBlock::IsDualPlane() const {
// If it's an error block, then we aren't a dual plane block
if (IsIllegalEncoding()) {
return false;
}
return DecodeDualPlaneBit(astc_bits_);
}
// Returns the number of weight bits present in this block
base::Optional<int> PhysicalASTCBlock::NumWeightBits() const {
// If it's an error block, then we have no weight bits.
if (IsIllegalEncoding()) return { };
// If it's a void extent block, we have no weight bits
if (IsVoidExtent()) return { };
return DecodeNumWeightBits(astc_bits_);
}
base::Optional<int> PhysicalASTCBlock::WeightStartBit() const {
if (IsIllegalEncoding()) return { };
if (IsVoidExtent()) return { };
return kASTCBlockSizeBits - DecodeNumWeightBits(astc_bits_);
}
base::Optional<std::array<int, 2>> PhysicalASTCBlock::WeightGridDims() const {
std::string error;
auto weight_props = DecodeWeightProps(astc_bits_, &error);
if (!weight_props.hasValue()) return { };
if (IsIllegalEncoding()) return { };
const auto props = weight_props.value();
return {{{ props.width, props.height }}};
}
base::Optional<int> PhysicalASTCBlock::WeightRange() const {
std::string error;
auto weight_props = DecodeWeightProps(astc_bits_, &error);
if (!weight_props.hasValue()) return { };
if (IsIllegalEncoding()) return { };
return weight_props.value().range;
}
base::Optional<int> PhysicalASTCBlock::DualPlaneChannel() const {
if (!IsDualPlane()) return { };
int dual_plane_start_pos = DecodeDualPlaneBitStartPos(astc_bits_);
auto plane_bits = base::GetBits(astc_bits_, dual_plane_start_pos, 2);
return base::Optional<int>(static_cast<int>(plane_bits.LowBits()));
}
base::Optional<int> PhysicalASTCBlock::ColorStartBit() const {
if (IsVoidExtent()) {
return 64;
}
auto num_partitions = NumPartitions();
if (!num_partitions) return { };
return (num_partitions == 1) ? 17 : 29;
}
base::Optional<int> PhysicalASTCBlock::NumColorValues() const {
// If we have a void extent block, then we have four color values
if (IsVoidExtent()) {
return 4;
}
// If we have an illegal encoding, then we have no color values
if (IsIllegalEncoding()) return { };
return DecodeNumColorValues(astc_bits_);
}
void PhysicalASTCBlock::GetColorValuesInfo(int* const color_bits,
int* const color_range) const {
// Figure out the range possible for the number of values we have...
const int dual_plane_start_pos = DecodeDualPlaneBitStartPos(astc_bits_);
const int max_color_bits = dual_plane_start_pos - ColorStartBit().value();
const int num_color_values = NumColorValues().value();
for (int range = 255; range > 0; --range) {
const int bitcount =
IntegerSequenceCodec::GetBitCountForRange(num_color_values, range);
if (bitcount <= max_color_bits) {
if (color_bits != nullptr) {
*color_bits = bitcount;
}
if (color_range != nullptr) {
*color_range = range;
}
return;
}
}
assert(false &&
"This means that even if we have a range of one there aren't "
"enough bits to store the color values, and our encoding is "
"illegal.");
}
base::Optional<int> PhysicalASTCBlock::NumColorBits() const {
if (IsIllegalEncoding()) return { };
if (IsVoidExtent()) {
return 64;
}
int color_bits;
GetColorValuesInfo(&color_bits, nullptr);
return color_bits;
}
base::Optional<int> PhysicalASTCBlock::ColorValuesRange() const {
if (IsIllegalEncoding()) return { };
if (IsVoidExtent()) {
return (1 << 16) - 1;
}
int color_range;
GetColorValuesInfo(nullptr, &color_range);
return color_range;
}
base::Optional<int> PhysicalASTCBlock::NumPartitions() const {
// Error blocks have no partitions
if (IsIllegalEncoding()) return { };
// Void extent blocks have no partitions either
if (DecodeBlockMode(astc_bits_) == BlockMode::kVoidExtent) {
return { };
}
// All others have some number of partitions
return DecodeNumPartitions(astc_bits_);
}
base::Optional<int> PhysicalASTCBlock::PartitionID() const {
auto num_partitions = NumPartitions();
if (!num_partitions || num_partitions == 1) return { };
const uint64_t low_bits = astc_bits_.LowBits();
return static_cast<int>(base::GetBits(low_bits, 13, 10));
}
base::Optional<ColorEndpointMode> PhysicalASTCBlock::GetEndpointMode(
int partition) const {
// Error block?
if (IsIllegalEncoding()) return { };
// Void extent blocks have no endpoint modes
if (DecodeBlockMode(astc_bits_) == BlockMode::kVoidExtent) {
return { };
}
// Do we even have a CEM for this partition?
if (partition < 0 || DecodeNumPartitions(astc_bits_) <= partition) {
return { };
}
return DecodeEndpointMode(astc_bits_, partition);
}
} // namespace astc_codec

128
3rdparty/astc-codec/src/decoder/physical_astc_block.h vendored
View File

@@ -1,128 +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.
#ifndef ASTC_CODEC_DECODER_PHYSICAL_ASTC_BLOCK_H_
#define ASTC_CODEC_DECODER_PHYSICAL_ASTC_BLOCK_H_
// The logic in this file is based on the ASTC specification, which can be
// found here:
// https://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt
#include "src/base/optional.h"
#include "src/base/uint128.h"
#include "src/decoder/types.h"
#include <string>
namespace astc_codec {
// A PhysicalASTCBlock contains all 128 bits and the logic for decoding the
// various internals of an ASTC block.
class PhysicalASTCBlock {
public:
// The physical size in bytes of an ASTC block
static const size_t kSizeInBytes = 16;
// Initializes an ASTC block based on the encoded string.
explicit PhysicalASTCBlock(const std::string& encoded_block);
explicit PhysicalASTCBlock(const base::UInt128 astc_block);
// Returns the 128 bits of this ASTC block.
base::UInt128 GetBlockBits() const { return astc_bits_; }
// Weights are stored in a grid that may not have the same dimensions
// as the block dimensions. This allows us to see what the physical
// dimensions are of the grid.
base::Optional<std::array<int, 2>> WeightGridDims() const;
// The weight range is the maximum value a weight can take in the
// weight grid.
base::Optional<int> WeightRange() const;
// Returns true if the block encoding specifies a void-extent block. This
// kind of block stores a single color to be used for every pixel in the
// block.
bool IsVoidExtent() const;
// Returns the values (min_s, max_s, min_t, max_t) as defined in the void
// extent block as the range of texture coordinates for which this block is
// defined. (See Section C.2.23)
base::Optional<std::array<int, 4>> VoidExtentCoords() const;
// Returns true if the block contains two separate weight grids. One used
// for the channel returned by DualPlaneChannel() and one used by the other
// channels.
bool IsDualPlane() const;
// Returns the channel used as the "dual plane". The return value is only
// meaningful if IsDualPlane() returns true...
base::Optional<int> DualPlaneChannel() const;
// Returns a reason that the encoding doesn't adhere to the specification.
// If the encoding is legal, then this returns a nullptr. This allows us to
// still use code of the form:
//
// if (IsIllegalEncoding()) {
// ... error ...
// }
// ... no error ...
//
// However, it also helps with debugging since we can find problems with
// encodings a lot faster.
base::Optional<std::string> IsIllegalEncoding() const;
// Returns the number of weight bits present in this block.
base::Optional<int> NumWeightBits() const;
// Returns the starting position within the range [0, 127] of the
// weight data within the block.
base::Optional<int> WeightStartBit() const;
// Returns the number of endpoint pairs used in this block.
base::Optional<int> NumPartitions() const;
// Returns the seed used to determine the partition for a given
// (x, y) coordinate within the block. Determined using the
// block size and the function as described in the specification.
base::Optional<int> PartitionID() const;
// Returns the color endpoint mode for the given partition index.
base::Optional<ColorEndpointMode> GetEndpointMode(int partition) const;
// Returns the starting position within the range [0, 127] of the
// color data within the block.
base::Optional<int> ColorStartBit() const;
// Returns the number of integers used to represent the color endpoints.
base::Optional<int> NumColorValues() const;
// Returns the number of bits used to represent the color endpoints.
base::Optional<int> NumColorBits() const;
// Returns the maximum value that each of the encoded integers used to
// represent the color endpoints can take.
base::Optional<int> ColorValuesRange() const;
private:
const base::UInt128 astc_bits_;
// The logic to return the number of color bits and the color values range
// is very similar, so it's probably best to abstract it away into its own
// function.
void GetColorValuesInfo(int* color_bits, int* color_range) const;
};
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_PHYSICAL_ASTC_BLOCK_H_

462
3rdparty/astc-codec/src/decoder/quantization.cc vendored
View File

@@ -1,462 +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/base/math_utils.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <map>
#include <memory>
#include <vector>
namespace astc_codec {
namespace {
// Trit unquantization procedure as described in Section C.2.13
int GetUnquantizedTritValue(int trit, int bits, int range) {
int a = (bits & 1) ? 0x1FF : 0;
int b = 0, c = 0;
switch (range) {
case 5: {
b = 0;
c = 204;
}
break;
case 11: {
int x = (bits >> 1) & 0x1;
b = (x << 1) | (x << 2) | (x << 4) | (x << 8);
c = 93;
}
break;
case 23: {
int x = (bits >> 1) & 0x3;
b = x | (x << 2) | (x << 7);
c = 44;
}
break;
case 47: {
int x = (bits >> 1) & 0x7;
b = x | (x << 6);
c = 22;
}
break;
case 95: {
int x = (bits >> 1) & 0xF;
b = (x >> 2) | (x << 5);
c = 11;
}
break;
case 191: {
int x = (bits >> 1) & 0x1F;
b = (x >> 4) | (x << 4);
c = 5;
}
break;
default:
assert(false && "Illegal trit encoding");
break;
}
int t = trit * c + b;
t ^= a;
t = (a & 0x80) | (t >> 2);
return t;
}
// Quint unquantization procedure as described in Section C.2.13
int GetUnquantizedQuintValue(int quint, int bits, int range) {
int a = (bits & 1) ? 0x1FF : 0;
int b = 0, c = 0;
switch (range) {
case 9: {
b = 0;
c = 113;
}
break;
case 19: {
int x = (bits >> 1) & 0x1;
b = (x << 2) | (x << 3) | (x << 8);
c = 54;
}
break;
case 39: {
int x = (bits >> 1) & 0x3;
b = (x >> 1) | (x << 1) | (x << 7);
c = 26;
}
break;
case 79: {
int x = (bits >> 1) & 0x7;
b = (x >> 1) | (x << 6);
c = 13;
}
break;
case 159: {
int x = (bits >> 1) & 0xF;
b = (x >> 3) | (x << 5);
c = 6;
}
break;
default:
assert(false && "Illegal quint encoding");
break;
}
int t = quint * c + b;
t ^= a;
t = (a & 0x80) | (t >> 2);
return t;
}
// Trit unquantization procedure as described in Section C.2.17. In the code
// below, the variables a, b, and c correspond to the columns A, B, and C in
// the specification.
int GetUnquantizedTritWeight(int trit, int bits, int range) {
int a = (bits & 1) ? 0x7F : 0;
int b = 0, c = 0;
switch (range) {
case 2:
return (std::array<int, 3> {{ 0, 32, 63 }})[trit];
case 5:
c = 50;
b = 0;
break;
case 11: {
c = 23;
b = (bits >> 1) & 1;
b |= (b << 2) | (b << 6);
}
break;
case 23: {
c = 11;
b = (bits >> 1) & 0x3;
b |= (b << 5);
}
break;
default:
assert(false && "Illegal trit encoding");
break;
}
int t = trit * c + b;
t ^= a;
t = (a & 0x20) | (t >> 2);
return t;
}
// Quint unquantization procedure as described in Section C.2.17. In the code
// below, the variables a, b, and c correspond to the columns A, B, and C in
// the specification.
int GetUnquantizedQuintWeight(int quint, int bits, int range) {
int a = (bits & 1) ? 0x7F : 0;
int b = 0, c = 0;
switch (range) {
case 4:
return (std::array<int, 5> {{ 0, 16, 32, 47, 63 }})[quint];
case 9:
c = 28;
b = 0;
break;
case 19: {
c = 13;
b = (bits >> 1) & 0x1;
b = (b << 1) | (b << 6);
}
break;
default:
assert(false && "Illegal quint encoding");
break;
}
int t = quint * c + b;
t ^= a;
t = (a & 0x20) | (t >> 2);
return t;
}
// A Quantization map allows us to convert to/from values that are quantized
// according to the ASTC spec.
class QuantizationMap {
public:
int Quantize(size_t x) const {
return x < quantization_map_.size() ? quantization_map_.at(x) : 0;
}
int Unquantize(size_t x) const {
return x < unquantization_map_.size() ? unquantization_map_.at(x) : 0;
}
protected:
QuantizationMap() { }
std::vector<int> quantization_map_;
std::vector<int> unquantization_map_;
void GenerateQuantizationMap() {
assert(unquantization_map_.size() > 1);
quantization_map_.clear();
// TODO(google) For weights, we don't need quantization values all the
// way up to 256, but it doesn't hurt -- just wastes memory, but the code
// is much cleaner this way
for (int i = 0; i < 256; ++i) {
int best_idx = 0;
int best_idx_score = 256;
int idx = 0;
for (int unquantized_val : unquantization_map_) {
const int diff = i - unquantized_val;
const int idx_score = diff * diff;
if (idx_score < best_idx_score) {
best_idx = idx;
best_idx_score = idx_score;
}
idx++;
}
quantization_map_.push_back(best_idx);
}
}
};
template<int (*UnquantizationFunc)(int, int, int)>
class TritQuantizationMap : public QuantizationMap {
public:
explicit TritQuantizationMap(int range) : QuantizationMap() {
assert((range + 1) % 3 == 0);
const int num_bits_pow_2 = (range + 1) / 3;
const int num_bits =
num_bits_pow_2 == 0 ? 0 : base::Log2Floor(num_bits_pow_2);
for (int trit = 0; trit < 3; ++trit) {
for (int bits = 0; bits < (1 << num_bits); ++bits) {
unquantization_map_.push_back(UnquantizationFunc(trit, bits, range));
}
}
GenerateQuantizationMap();
}
};
template<int (*UnquantizationFunc)(int, int, int)>
class QuintQuantizationMap : public QuantizationMap {
public:
explicit QuintQuantizationMap(int range) : QuantizationMap() {
assert((range + 1) % 5 == 0);
const int num_bits_pow_2 = (range + 1) / 5;
const int num_bits =
num_bits_pow_2 == 0 ? 0 : base::Log2Floor(num_bits_pow_2);
for (int quint = 0; quint < 5; ++quint) {
for (int bits = 0; bits < (1 << num_bits); ++bits) {
unquantization_map_.push_back(UnquantizationFunc(quint, bits, range));
}
}
GenerateQuantizationMap();
}
};
template<int TotalUnquantizedBits>
class BitQuantizationMap : public QuantizationMap {
public:
explicit BitQuantizationMap<TotalUnquantizedBits>(int range)
: QuantizationMap() {
// Make sure that if we're using bits then we have a positive power of two.
assert(base::CountOnes(range + 1) == 1);
const int num_bits = base::Log2Floor(range + 1);
for (int bits = 0; bits <= range; ++bits) {
// Need to replicate bits until we fill up the bits
size_t unquantized = bits;
int num_unquantized_bits = num_bits;
while (num_unquantized_bits < TotalUnquantizedBits) {
const int num_dst_bits_to_shift_up =
std::min(num_bits, TotalUnquantizedBits - num_unquantized_bits);
const int num_src_bits_to_shift_down =
num_bits - num_dst_bits_to_shift_up;
unquantized <<= num_dst_bits_to_shift_up;
unquantized |= bits >> num_src_bits_to_shift_down;
num_unquantized_bits += num_dst_bits_to_shift_up;
}
assert(num_unquantized_bits == TotalUnquantizedBits);
unquantization_map_.push_back(int(unquantized));
// Fill half of the quantization map with the previous value for bits
// and the other half with the current value for bits
if (bits > 0) {
const size_t prev_unquant = unquantization_map_.at(bits - 1);
while (quantization_map_.size() <= (prev_unquant + unquantized) / 2) {
quantization_map_.push_back(bits - 1);
}
}
while (quantization_map_.size() <= unquantized) {
quantization_map_.push_back(bits);
}
}
assert(quantization_map_.size() == 1 << TotalUnquantizedBits);
}
};
using QMap = std::shared_ptr<QuantizationMap>;
// Returns the quantization map for quantizing color values in [0, 255] with the
// smallest range that can accommodate |r|
static const QuantizationMap* GetQuantMapForValueRange(int r) {
// Endpoint values can be quantized using bits, trits, or quints. Here we
// store the quantization maps for each of the ranges that are supported by
// such an encoding. That way we can choose the proper quantization procedure
// based on the range of values rather than by having complicated switches and
// logic. We must use a std::map here instead of a std::unordered_map because
// of the assumption made in std::upper_bound about the iterators being from a
// poset.
static const auto* const kASTCEndpointQuantization = new std::map<int, QMap> {
{ 5, QMap(new TritQuantizationMap<GetUnquantizedTritValue>(5)) },
{ 7, QMap(new BitQuantizationMap<8>(7)) },
{ 9, QMap(new QuintQuantizationMap<GetUnquantizedQuintValue>(9)) },
{ 11, QMap(new TritQuantizationMap<GetUnquantizedTritValue>(11)) },
{ 15, QMap(new BitQuantizationMap<8>(15)) },
{ 19, QMap(new QuintQuantizationMap<GetUnquantizedQuintValue>(19)) },
{ 23, QMap(new TritQuantizationMap<GetUnquantizedTritValue>(23)) },
{ 31, QMap(new BitQuantizationMap<8>(31)) },
{ 39, QMap(new QuintQuantizationMap<GetUnquantizedQuintValue>(39)) },
{ 47, QMap(new TritQuantizationMap<GetUnquantizedTritValue>(47)) },
{ 63, QMap(new BitQuantizationMap<8>(63)) },
{ 79, QMap(new QuintQuantizationMap<GetUnquantizedQuintValue>(79)) },
{ 95, QMap(new TritQuantizationMap<GetUnquantizedTritValue>(95)) },
{ 127, QMap(new BitQuantizationMap<8>(127)) },
{ 159, QMap(new QuintQuantizationMap<GetUnquantizedQuintValue>(159)) },
{ 191, QMap(new TritQuantizationMap<GetUnquantizedTritValue>(191)) },
{ 255, QMap(new BitQuantizationMap<8>(255)) },
};
assert(r < 256);
auto itr = kASTCEndpointQuantization->upper_bound(r);
if (itr != kASTCEndpointQuantization->begin()) {
return (--itr)->second.get();
}
return nullptr;
}
// Returns the quantization map for weight values in [0, 63] with the smallest
// range that can accommodate |r|
static const QuantizationMap* GetQuantMapForWeightRange(int r) {
// Similar to endpoint quantization, weights can also be stored using trits,
// quints, or bits. Here we store the quantization maps for each of the ranges
// that are supported by such an encoding.
static const auto* const kASTCWeightQuantization = new std::map<int, QMap> {
{ 1, QMap(new BitQuantizationMap<6>(1)) },
{ 2, QMap(new TritQuantizationMap<GetUnquantizedTritWeight>(2)) },
{ 3, QMap(new BitQuantizationMap<6>(3)) },
{ 4, QMap(new QuintQuantizationMap<GetUnquantizedQuintWeight>(4)) },
{ 5, QMap(new TritQuantizationMap<GetUnquantizedTritWeight>(5)) },
{ 7, QMap(new BitQuantizationMap<6>(7)) },
{ 9, QMap(new QuintQuantizationMap<GetUnquantizedQuintWeight>(9)) },
{ 11, QMap(new TritQuantizationMap<GetUnquantizedTritWeight>(11)) },
{ 15, QMap(new BitQuantizationMap<6>(15)) },
{ 19, QMap(new QuintQuantizationMap<GetUnquantizedQuintWeight>(19)) },
{ 23, QMap(new TritQuantizationMap<GetUnquantizedTritWeight>(23)) },
{ 31, QMap(new BitQuantizationMap<6>(31)) },
};
assert(r < 32);
auto itr = kASTCWeightQuantization->upper_bound(r);
if (itr != kASTCWeightQuantization->begin()) {
return (--itr)->second.get();
}
return nullptr;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
int QuantizeCEValueToRange(int value, int range_max_value) {
assert(range_max_value >= kEndpointRangeMinValue);
assert(range_max_value <= 255);
assert(value >= 0);
assert(value <= 255);
const QuantizationMap* map = GetQuantMapForValueRange(range_max_value);
return map ? map->Quantize(value) : 0;
}
int UnquantizeCEValueFromRange(int value, int range_max_value) {
assert(range_max_value >= kEndpointRangeMinValue);
assert(range_max_value <= 255);
assert(value >= 0);
assert(value <= range_max_value);
const QuantizationMap* map = GetQuantMapForValueRange(range_max_value);
return map ? map->Unquantize(value) : 0;
}
int QuantizeWeightToRange(int weight, int range_max_value) {
assert(range_max_value >= 1);
assert(range_max_value <= kWeightRangeMaxValue);
assert(weight >= 0);
assert(weight <= 64);
// The quantization maps that define weight unquantization expect values in
// the range [0, 64), but the specification quantizes them to the range
// [0, 64] according to C.2.17. This is a slight hack similar to the one in
// the unquantization procedure to return the passed in unquantized value to
// [0, 64) prior to running it through the quantization procedure.
if (weight > 33) {
weight -= 1;
}
const QuantizationMap* map = GetQuantMapForWeightRange(range_max_value);
return map ? map->Quantize(weight) : 0;
}
int UnquantizeWeightFromRange(int weight, int range_max_value) {
assert(range_max_value >= 1);
assert(range_max_value <= kWeightRangeMaxValue);
assert(weight >= 0);
assert(weight <= range_max_value);
const QuantizationMap* map = GetQuantMapForWeightRange(range_max_value);
int dq = map ? map->Unquantize(weight) : 0;
// Quantized weights are returned in the range [0, 64), but they should be
// returned in the range [0, 64], so according to C.2.17 we need to add one
// to the result.
assert(dq < 64);
if (dq > 32) {
dq += 1;
}
return dq;
}
} // namespace astc_codec

65
3rdparty/astc-codec/src/decoder/quantization.h vendored
View File

@@ -1,65 +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.
#ifndef ASTC_CODEC_DECODER_QUANTIZATION_H_
#define ASTC_CODEC_DECODER_QUANTIZATION_H_
////////////////////////////////////////////////////////////////////////////////
//
// ASTC Quantization procedures.
//
// The values stored in ASTC blocks tend to be stored in a range much more
// restricted than the logical range used. For example, sometimes weights are
// stored in the range from [0, 3] but are used in the range [0, 64]. The
// process of translating a value to or from this range is known as quantization
// and dequantization. The ranges to which these values can be (de)quantized
// are defined by ISERange[Begin|End]() in integer_sequence_codec.h
namespace astc_codec {
// The minimum possible range for a pair of endpoints. If endpoints are
// quantized to something smaller than this, then it would constitute an
// illegal ASTC encoding.
constexpr int kEndpointRangeMinValue = 5;
// The maximum possible range for a weight value. If weights are quantized to
// something larger than this, then it would constitute an illegal ASTC
// encoding.
constexpr int kWeightRangeMaxValue = 31;
// Quantizes a value in the range [0, 255] to [0, |range|]. The quantized values
// have no correlation to the input values, and there should be no implicit
// assumptions made about their ordering. Valid values of |range_max_value| are
// in the interval [5, 255]
int QuantizeCEValueToRange(int value, int range_max_value);
// Unquantizes a value in the range [0, |range|] to [0, 255]. Performs the
// inverse procedure of QuantizeValueToRange. Valid values of |range_max_value|
// are in the interval [5, 255]
int UnquantizeCEValueFromRange(int value, int range_max_value);
// Quantizes a weight in the range [0, 64] to [0, |range_max_value|]. The
// quantized values have no correlation to the input values, and there should
// be no implicit assumptions made about their ordering. Valid values of
// |range_max_value| are in the interval [1, 31]
int QuantizeWeightToRange(int weight, int range_max_value);
// Unquantizes a weight in the range [0, |range_max_value|] to [0, 64]. Performs
// the inverse procedure of QuantizeWeightToRange. Valid values of
// |range_max_value| are in the interval [1, 31]
int UnquantizeWeightFromRange(int weight, int range_max_value);
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_QUANTIZATION_H_

74
3rdparty/astc-codec/src/decoder/types.h vendored
View File

@@ -1,74 +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.
#ifndef ASTC_CODEC_DECODER_ASTC_TYPES_H_
#define ASTC_CODEC_DECODER_ASTC_TYPES_H_
#include <array>
#include <string>
#include <utility>
namespace astc_codec {
// The color endpoint mode determines how the values encoded in the ASTC block
// are interpreted in order to create the RGBA values for the given endpoint
// pair. The order of this enum is required to match the ASTC specification in
// Section C.2.14.
enum class ColorEndpointMode {
kLDRLumaDirect = 0,
kLDRLumaBaseOffset,
kHDRLumaLargeRange,
kHDRLumaSmallRange,
kLDRLumaAlphaDirect,
kLDRLumaAlphaBaseOffset,
kLDRRGBBaseScale,
kHDRRGBBaseScale,
kLDRRGBDirect,
kLDRRGBBaseOffset,
kLDRRGBBaseScaleTwoA,
kHDRRGBDirect,
kLDRRGBADirect,
kLDRRGBABaseOffset,
kHDRRGBDirectLDRAlpha,
kHDRRGBDirectHDRAlpha,
// The total number of color endpoints defined by the ASTC specification.
// This isn't a specific endpoint mode and its sole purpose is to be used
// as a constant number.
kNumColorEndpointModes
};
// Returns the class for the given mode as defined in Section C.2.11.
constexpr int EndpointModeClass(ColorEndpointMode mode) {
return static_cast<int>(mode) / 4;
}
// Returns the number of encoded color values for the given endpoint mode. The
// number of encoded color values and their range determines the size of the
// color data in a physical ASTC block. This information is taken from
// Section C.2.17 of the ASTC specification.
constexpr int NumColorValuesForEndpointMode(ColorEndpointMode mode) {
return (EndpointModeClass(mode) + 1) * 2;
}
// We define a number of convenience types here that give more logical meaning
// throughout the ASTC utilities.
using RgbColor = std::array<int, 3>;
using RgbaColor = std::array<int, 4>;
using Endpoint = RgbaColor;
using EndpointPair = std::pair<Endpoint, Endpoint>;
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_ASTC_TYPES_H_

122
3rdparty/astc-codec/src/decoder/weight_infill.cc vendored
View File

@@ -1,122 +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/integer_sequence_codec.h"
#include <array>
#include <cmath>
#include <utility>
namespace astc_codec {
namespace {
// The following functions are based on Section C.2.18 of the ASTC specification
int GetScaleFactorD(int block_dim) {
return static_cast<int>((1024.f + static_cast<float>(block_dim >> 1)) /
static_cast<float>(block_dim - 1));
}
std::pair<int, int> GetGridSpaceCoordinates(
Footprint footprint, int s, int t, int weight_dim_x, int weight_dim_y) {
const int ds = GetScaleFactorD(footprint.Width());
const int dt = GetScaleFactorD(footprint.Height());
const int cs = ds * s;
const int ct = dt * t;
const int gs = (cs * (weight_dim_x - 1) + 32) >> 6;
const int gt = (ct * (weight_dim_y - 1) + 32) >> 6;
assert(gt < 1 << 8);
assert(gs < 1 << 8);
return std::make_pair(gs, gt);
}
// Returns the weight-grid values that are to be used for bilinearly
// interpolating the weight to its final value. If the returned value
// is equal to weight_dim_x * weight_dim_y, it may be ignored.
std::array<int, 4> BilerpGridPointsForWeight(
const std::pair<int, int>& grid_space_coords, int weight_dim_x) {
const int js = grid_space_coords.first >> 4;
const int jt = grid_space_coords.second >> 4;
std::array<int, 4> result;
result[0] = js + weight_dim_x * jt;
result[1] = js + weight_dim_x * jt + 1;
result[2] = js + weight_dim_x * (jt + 1);
result[3] = js + weight_dim_x * (jt + 1) + 1;
return result;
}
std::array<int, 4> BilerpGridPointFactorsForWeight(
const std::pair<int, int>& grid_space_coords) {
const int fs = grid_space_coords.first & 0xF;
const int ft = grid_space_coords.second & 0xF;
std::array<int, 4> result;
result[3] = (fs * ft + 8) >> 4;
result[2] = ft - result[3];
result[1] = fs - result[3];
result[0] = 16 - fs - ft + result[3];
assert(result[0] <= 16);
assert(result[1] <= 16);
assert(result[2] <= 16);
assert(result[3] <= 16);
return result;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
int CountBitsForWeights(int weight_dim_x, int weight_dim_y,
int target_weight_range) {
int num_weights = weight_dim_x * weight_dim_y;
return IntegerSequenceCodec::
GetBitCountForRange(num_weights, target_weight_range);
}
std::vector<int> InfillWeights(const std::vector<int>& weights,
Footprint footprint, int dim_x, int dim_y) {
std::vector<int> result;
result.reserve(footprint.NumPixels());
for (int t = 0; t < footprint.Height(); ++t) {
for (int s = 0; s < footprint.Width(); ++s) {
const auto grid_space_coords =
GetGridSpaceCoordinates(footprint, s, t, dim_x, dim_y);
const auto grid_pts =
BilerpGridPointsForWeight(grid_space_coords, dim_x);
const auto grid_factors =
BilerpGridPointFactorsForWeight(grid_space_coords);
int weight = 0;
for (int i = 0; i < 4; ++i) {
if (grid_pts[i] < dim_x * dim_y) {
weight += weights.at(grid_pts[i]) * grid_factors[i];
}
}
result.push_back((weight + 8) >> 4);
}
}
return result;
}
} // namespace astc_codec

38
3rdparty/astc-codec/src/decoder/weight_infill.h vendored
View File

@@ -1,38 +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.
#ifndef ASTC_CODEC_DECODER_WEIGHT_INFILL_H_
#define ASTC_CODEC_DECODER_WEIGHT_INFILL_H_
#include "src/decoder/footprint.h"
#include <vector>
namespace astc_codec {
// Returns the number of bits used to represent the weight grid at the target
// dimensions and weight range.
int CountBitsForWeights(int weight_dim_x, int weight_dim_y,
int target_weight_range);
// Performs weight infill of a grid of weights of size |dim_x * dim_y|. The
// weights are fit using the algorithm laid out in Section C.2.18 of the ASTC
// specification. Weights are expected to be passed unquantized and the returned
// grid will be unquantized as well (i.e. each weight within the range [0, 64]).
std::vector<int> InfillWeights(const std::vector<int>& weights,
Footprint footprint, int dim_x, int dim_y);
} // namespace astc_codec
#endif // ASTC_CODEC_DECODER_WEIGHT_INFILL_H_

18
scripts/bimg.lua
View File

@@ -8,29 +8,17 @@ project "bimg"
includedirs {
path.join(BIMG_DIR, "include"),
path.join(BIMG_DIR, "3rdparty/astc-codec"),
path.join(BIMG_DIR, "3rdparty/astc-codec/include"),
path.join(BIMG_DIR, "3rdparty/astc-encoder/include"),
path.join(BIMG_DIR, "3rdparty/tinyexr/deps/miniz"),
}
local ASTC_CODEC_DIR = path.join(BIMG_DIR, "3rdparty/astc-codec")
files {
path.join(BIMG_DIR, "include/**"),
path.join(BIMG_DIR, "src/image.*"),
path.join(BIMG_DIR, "src/image_gnf.cpp"),
path.join(ASTC_CODEC_DIR, "src/decoder/astc_file.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/codec.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/endpoint_codec.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/footprint.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/integer_sequence_codec.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/intermediate_astc_block.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/logical_astc_block.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/partition.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/physical_astc_block.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/quantization.*"),
path.join(ASTC_CODEC_DIR, "src/decoder/weight_infill.*"),
path.join(BIMG_DIR, "3rdparty/astc-encoder/source/**.cpp"),
path.join(BIMG_DIR, "3rdparty/astc-encoder/source/**.h"),
path.join(BIMG_DIR, "3rdparty/tinyexr/deps/miniz/miniz.*"),
}

2
scripts/bimg_encode.lua
View File

@@ -35,8 +35,6 @@ project "bimg_encode"
path.join(BIMG_DIR, "3rdparty/nvtt/**.h"),
path.join(BIMG_DIR, "3rdparty/pvrtc/**.cpp"),
path.join(BIMG_DIR, "3rdparty/pvrtc/**.h"),
path.join(BIMG_DIR, "3rdparty/astc-encoder/source/**.cpp"),
path.join(BIMG_DIR, "3rdparty/astc-encoder/source/**.h"),
path.join(BIMG_DIR, "3rdparty/tinyexr/**.h"),
path.join(BIMG_DIR, "3rdparty/iqa/include/**.h"),
path.join(BIMG_DIR, "3rdparty/iqa/source/**.c"),

70
src/image.cpp
View File

@@ -6,7 +6,7 @@
#include "bimg_p.h"
#include <bx/hash.h>
#include <astc-codec/astc-codec.h>
#include <astcenc.h>
#include <bx/debug.h>
@@ -4918,32 +4918,52 @@ namespace bimg
case TextureFormat::ASTC12x12:
if (BX_ENABLED(BIMG_DECODE_ASTC) )
{
if (!astc_codec::ASTCDecompressToRGBA(
(const uint8_t*)_src
, imageGetSize(NULL, uint16_t(_width), uint16_t(_height), 0, false, false, 1, _srcFormat)
, _width
, _height
, TextureFormat::ASTC4x4 == _srcFormat ? astc_codec::FootprintType::k4x4
: TextureFormat::ASTC5x4 == _srcFormat ? astc_codec::FootprintType::k5x4
: TextureFormat::ASTC5x5 == _srcFormat ? astc_codec::FootprintType::k5x5
: TextureFormat::ASTC6x5 == _srcFormat ? astc_codec::FootprintType::k6x5
: TextureFormat::ASTC6x6 == _srcFormat ? astc_codec::FootprintType::k6x6
: TextureFormat::ASTC8x5 == _srcFormat ? astc_codec::FootprintType::k8x5
: TextureFormat::ASTC8x6 == _srcFormat ? astc_codec::FootprintType::k8x6
: TextureFormat::ASTC8x8 == _srcFormat ? astc_codec::FootprintType::k8x8
: TextureFormat::ASTC10x5 == _srcFormat ? astc_codec::FootprintType::k10x5
: TextureFormat::ASTC10x6 == _srcFormat ? astc_codec::FootprintType::k10x6
: TextureFormat::ASTC10x8 == _srcFormat ? astc_codec::FootprintType::k10x8
: TextureFormat::ASTC10x10== _srcFormat ? astc_codec::FootprintType::k10x10
: TextureFormat::ASTC12x10== _srcFormat ? astc_codec::FootprintType::k12x10
: astc_codec::FootprintType::k12x12
, (uint8_t*)_dst
, _width*_height*4
, _dstPitch
) )
{
const unsigned int thread_count = 1;
const bimg::ImageBlockInfo& astcBlockInfo = bimg::getBlockInfo(_srcFormat);
const float quality = ASTCENC_PRE_MEDIUM;
const astcenc_profile profile = ASTCENC_PRF_LDR; //Linear LDR color profile
astcenc_error status;
//Create and init config and context
astcenc_config config{};
const unsigned int astcFlags = ASTCENC_FLG_DECOMPRESS_ONLY;
status = astcenc_config_init(profile, astcBlockInfo.blockWidth, astcBlockInfo.blockHeight, 1, quality, astcFlags, &config);
if (status != ASTCENC_SUCCESS) {
BX_TRACE("astc error in config init %s", astcenc_get_error_string(status));
imageCheckerboard(_dst, _width, _height, 16, UINT32_C(0xff000000), UINT32_C(0xffffff00) );
break;
}
astcenc_context* context;
status = astcenc_context_alloc(&config, thread_count, &context);
if (status != ASTCENC_SUCCESS) {
BX_TRACE("astc error in context alloc %s", astcenc_get_error_string(status));
imageCheckerboard(_dst, _width, _height, 16, UINT32_C(0xff000000), UINT32_C(0xffffff00) );
break;
}
//Put image data into an astcenc_image
astcenc_image image{};
image.dim_x = _width;
image.dim_y = _height;
image.dim_z = 1;
image.data_type = ASTCENC_TYPE_U8;
image.data = &_dst;
const uint32_t size = imageGetSize(NULL, uint16_t(_width), uint16_t(_height), 0, false, false, 1, _srcFormat);
static const astcenc_swizzle swizzle { //0123/rgba swizzle corresponds to ASTC_RGBA
ASTCENC_SWZ_R, ASTCENC_SWZ_G, ASTCENC_SWZ_B, ASTCENC_SWZ_A
};
status = astcenc_decompress_image(context, static_cast<const uint8_t*>(_src), size, &image, &swizzle, 0);
if (status != ASTCENC_SUCCESS) {
BX_TRACE("astc error in compress image %s", astcenc_get_error_string(status));
imageCheckerboard(_dst, _width, _height, 16, UINT32_C(0xff000000), UINT32_C(0xffffff00) );
astcenc_context_free(context);
break;
}
astcenc_context_free(context);
}
else
{

8
src/image_encode.cpp
View File

@@ -308,11 +308,19 @@ namespace bimg
case TextureFormat::PTC14:
case TextureFormat::PTC14A:
case TextureFormat::ASTC4x4:
case TextureFormat::ASTC5x4:
case TextureFormat::ASTC5x5:
case TextureFormat::ASTC6x5:
case TextureFormat::ASTC6x6:
case TextureFormat::ASTC8x5:
case TextureFormat::ASTC8x6:
case TextureFormat::ASTC8x8:
case TextureFormat::ASTC10x5:
case TextureFormat::ASTC10x6:
case TextureFormat::ASTC10x8:
case TextureFormat::ASTC10x10:
case TextureFormat::ASTC12x10:
case TextureFormat::ASTC12x12:
{
uint8_t* temp = (uint8_t*)BX_ALLOC(_allocator, _width*_height*_depth*4);
imageDecodeToRgba8(_allocator, temp, _src, _width, _height, _width*4, _srcFormat);