// Copyright 2019 The libgav1 Authors
//
// 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.
#include "src/dsp/inverse_transform.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include "src/dsp/dsp.h"
#include "src/utils/array_2d.h"
#include "src/utils/common.h"
#include "src/utils/compiler_attributes.h"
#include "src/utils/logging.h"
namespace libgav1 {
namespace dsp {
namespace {
// Include the constants and utility functions inside the anonymous namespace.
#include "src/dsp/inverse_transform.inc"
constexpr uint8_t kTransformColumnShift = 4;
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
#undef LIBGAV1_ENABLE_TRANSFORM_RANGE_CHECK
#endif
int32_t RangeCheckValue(int32_t value, int8_t range) {
#if defined(LIBGAV1_ENABLE_TRANSFORM_RANGE_CHECK) && \
LIBGAV1_ENABLE_TRANSFORM_RANGE_CHECK
assert(range <= 32);
const auto min = static_cast<int32_t>(-(uint32_t{1} << (range - 1)));
const auto max = static_cast<int32_t>((uint32_t{1} << (range - 1)) - 1);
if (min > value || value > max) {
LIBGAV1_DLOG(ERROR, "coeff out of bit range, value: %d bit range %d\n",
value, range);
assert(min <= value && value <= max);
}
#endif // LIBGAV1_ENABLE_TRANSFORM_RANGE_CHECK
static_cast<void>(range);
return value;
}
template <typename Residual>
LIBGAV1_ALWAYS_INLINE void ButterflyRotation_C(Residual* const dst, int a,
int b, int angle, bool flip,
int8_t range) {
// Note that we multiply in 32 bits and then add/subtract the products in 64
// bits. The 32-bit multiplications do not overflow. Please see the comment
// and assert() in Cos128().
const int64_t x = static_cast<int64_t>(dst[a] * Cos128(angle)) -
static_cast<int64_t>(dst[b] * Sin128(angle));
const int64_t y = static_cast<int64_t>(dst[a] * Sin128(angle)) +
static_cast<int64_t>(dst[b] * Cos128(angle));
// Section 7.13.2.1: It is a requirement of bitstream conformance that the
// values saved into the array T by this function are representable by a
// signed integer using |range| bits of precision.
dst[a] = RangeCheckValue(RightShiftWithRounding(flip ? y : x, 12), range);
dst[b] = RangeCheckValue(RightShiftWithRounding(flip ? x : y, 12), range);
}
template <typename Residual>
void ButterflyRotationFirstIsZero_C(Residual* const dst, int a, int b,
int angle, bool flip, int8_t range) {
// Note that we multiply in 32 bits and then add/subtract the products in 64
// bits. The 32-bit multiplications do not overflow. Please see the comment
// and assert() in Cos128().
const auto x = static_cast<int64_t>(dst[b] * -Sin128(angle));
const auto y = static_cast<int64_t>(dst[b] * Cos128(angle));
// Section 7.13.2.1: It is a requirement of bitstream conformance that the
// values saved into the array T by this function are representable by a
// signed integer using |range| bits of precision.
dst[a] = RangeCheckValue(RightShiftWithRounding(flip ? y : x, 12), range);
dst[b] = RangeCheckValue(RightShiftWithRounding(flip ? x : y, 12), range);
}
template <typename Residual>
void ButterflyRotationSecondIsZero_C(Residual* const dst, int a, int b,
int angle, bool flip, int8_t range) {
// Note that we multiply in 32 bits and then add/subtract the products in 64
// bits. The 32-bit multiplications do not overflow. Please see the comment
// and assert() in Cos128().
const auto x = static_cast<int64_t>(dst[a] * Cos128(angle));
const auto y = static_cast<int64_t>(dst[a] * Sin128(angle));
// Section 7.13.2.1: It is a requirement of bitstream conformance that the
// values saved into the array T by this function are representable by a
// signed integer using |range| bits of precision.
dst[a] = RangeCheckValue(RightShiftWithRounding(flip ? y : x, 12), range);
dst[b] = RangeCheckValue(RightShiftWithRounding(flip ? x : y, 12), range);
}
template <typename Residual>
void HadamardRotation_C(Residual* const dst, int a, int b, bool flip,
int8_t range) {
if (flip) std::swap(a, b);
--range;
// For Adst and Dct, the maximum possible value for range is 20. So min and
// max should always fit into int32_t.
const int32_t min = -(1 << range);
const int32_t max = (1 << range) - 1;
const int32_t x = dst[a] + dst[b];
const int32_t y = dst[a] - dst[b];
dst[a] = Clip3(x, min, max);
dst[b] = Clip3(y, min, max);
}
template <int bitdepth, typename Residual>
void ClampIntermediate(Residual* const dst, int size) {
// If Residual is int16_t (which implies bitdepth is 8), we don't need to
// clip residual[i][j] to 16 bits.
if (sizeof(Residual) > 2) {
const Residual intermediate_clamp_max =
(1 << (std::max(bitdepth + 6, 16) - 1)) - 1;
const Residual intermediate_clamp_min = -intermediate_clamp_max - 1;
for (int j = 0; j < size; ++j) {
dst[j] = Clip3(dst[j], intermediate_clamp_min, intermediate_clamp_max);
}
}
}
//------------------------------------------------------------------------------
// Discrete Cosine Transforms (DCT).
// Value for index (i, j) is computed as bitreverse(j) and interpreting that as
// an integer with bit-length i + 2.
// For e.g. index (2, 3) will be computed as follows:
// * bitreverse(3) = bitreverse(..000011) = 110000...
// * interpreting that as an integer with bit-length 2+2 = 4 will be 1100 = 12
constexpr uint8_t kBitReverseLookup[kNumTransform1dSizes][64] = {
{0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2,
1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3,
0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3},
{0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6, 1, 5,
3, 7, 0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6,
1, 5, 3, 7, 0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6, 1, 5, 3, 7},
{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15,
0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15,
0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15,
0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15},
{0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14, 30,
1, 17, 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23, 15, 31,
0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14, 30,
1, 17, 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23, 15, 31},
{0, 32, 16, 48, 8, 40, 24, 56, 4, 36, 20, 52, 12, 44, 28, 60,
2, 34, 18, 50, 10, 42, 26, 58, 6, 38, 22, 54, 14, 46, 30, 62,
1, 33, 17, 49, 9, 41, 25, 57, 5, 37, 21, 53, 13, 45, 29, 61,
3, 35, 19, 51, 11, 43, 27, 59, 7, 39, 23, 55, 15, 47, 31, 63}};
template <typename Residual, int size_log2>
void Dct_C(void* dest, int8_t range) {
static_assert(size_log2 >= 2 && size_log2 <= 6, "");
auto* const dst = static_cast<Residual*>(dest);
// stage 1.
const int size = 1 << size_log2;
Residual temp[size];
memcpy(temp, dst, sizeof(temp));
for (int i = 0; i < size; ++i) {
dst[i] = temp[kBitReverseLookup[size_log2 - 2][i]];
}
// stages 2-32 are dependent on the value of size_log2.
// stage 2.
if (size_log2 == 6) {
for (int i = 0; i < 16; ++i) {
ButterflyRotation_C(dst, i + 32, 63 - i,
63 - MultiplyBy4(kBitReverseLookup[2][i]), false,
range);
}
}
// stage 3
if (size_log2 >= 5) {
for (int i = 0; i < 8; ++i) {
ButterflyRotation_C(dst, i + 16, 31 - i,
6 + MultiplyBy8(kBitReverseLookup[1][7 - i]), false,
range);
}
}
// stage 4.
if (size_log2 == 6) {
for (int i = 0; i < 16; ++i) {
HadamardRotation_C(dst, MultiplyBy2(i) + 32, MultiplyBy2(i) + 33,
static_cast<bool>(i & 1), range);
}
}
// stage 5.
if (size_log2 >= 4) {
for (int i = 0; i < 4; ++i) {
ButterflyRotation_C(dst, i + 8, 15 - i,
12 + MultiplyBy16(kBitReverseLookup[0][3 - i]), false,
range);
}
}
// stage 6.
if (size_log2 >= 5) {
for (int i = 0; i < 8; ++i) {
HadamardRotation_C(dst, MultiplyBy2(i) + 16, MultiplyBy2(i) + 17,
static_cast<bool>(i & 1), range);
}
}
// stage 7.
if (size_log2 == 6) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 2; ++j) {
ButterflyRotation_C(
dst, 62 - MultiplyBy4(i) - j, MultiplyBy4(i) + j + 33,
60 - MultiplyBy16(kBitReverseLookup[0][i]) + MultiplyBy64(j), true,
range);
}
}
}
// stage 8.
if (size_log2 >= 3) {
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(dst, i + 4, 7 - i, 56 - 32 * i, false, range);
}
}
// stage 9.
if (size_log2 >= 4) {
for (int i = 0; i < 4; ++i) {
HadamardRotation_C(dst, MultiplyBy2(i) + 8, MultiplyBy2(i) + 9,
static_cast<bool>(i & 1), range);
}
}
// stage 10.
if (size_log2 >= 5) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
ButterflyRotation_C(
dst, 30 - MultiplyBy4(i) - j, MultiplyBy4(i) + j + 17,
24 + MultiplyBy64(j) + MultiplyBy32(1 - i), true, range);
}
}
}
// stage 11.
if (size_log2 == 6) {
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 2; ++j) {
HadamardRotation_C(dst, MultiplyBy4(i) + j + 32,
MultiplyBy4(i) - j + 35, static_cast<bool>(i & 1),
range);
}
}
}
// stage 12.
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(dst, MultiplyBy2(i), MultiplyBy2(i) + 1, 32 + 16 * i,
i == 0, range);
}
// stage 13.
if (size_log2 >= 3) {
for (int i = 0; i < 2; ++i) {
HadamardRotation_C(dst, MultiplyBy2(i) + 4, MultiplyBy2(i) + 5,
/*flip=*/i != 0, range);
}
}
// stage 14.
if (size_log2 >= 4) {
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(dst, 14 - i, i + 9, 48 + 64 * i, true, range);
}
}
// stage 15.
if (size_log2 >= 5) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 2; ++j) {
HadamardRotation_C(dst, MultiplyBy4(i) + j + 16,
MultiplyBy4(i) - j + 19, static_cast<bool>(i & 1),
range);
}
}
}
// stage 16.
if (size_log2 == 6) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 4; ++j) {
ButterflyRotation_C(
dst, 61 - MultiplyBy8(i) - j, MultiplyBy8(i) + j + 34,
56 - MultiplyBy32(i) + MultiplyBy64(DivideBy2(j)), true, range);
}
}
}
// stage 17.
for (int i = 0; i < 2; ++i) {
HadamardRotation_C(dst, i, 3 - i, false, range);
}
// stage 18.
if (size_log2 >= 3) {
ButterflyRotation_C(dst, 6, 5, 32, true, range);
}
// stage 19.
if (size_log2 >= 4) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
HadamardRotation_C(dst, MultiplyBy4(i) + j + 8, MultiplyBy4(i) - j + 11,
/*flip=*/i != 0, range);
}
}
}
// stage 20.
if (size_log2 >= 5) {
for (int i = 0; i < 4; ++i) {
ButterflyRotation_C(dst, 29 - i, i + 18, 48 + 64 * DivideBy2(i), true,
range);
}
}
// stage 21.
if (size_log2 == 6) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
HadamardRotation_C(dst, MultiplyBy8(i) + j + 32,
MultiplyBy8(i) - j + 39, static_cast<bool>(i & 1),
range);
}
}
}
// stage 22.
if (size_log2 >= 3) {
for (int i = 0; i < 4; ++i) {
HadamardRotation_C(dst, i, 7 - i, false, range);
}
}
// stage 23.
if (size_log2 >= 4) {
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(dst, 13 - i, i + 10, 32, true, range);
}
}
// stage 24.
if (size_log2 >= 5) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 4; ++j) {
HadamardRotation_C(dst, MultiplyBy8(i) + j + 16,
MultiplyBy8(i) - j + 23, i == 1, range);
}
}
}
// stage 25.
if (size_log2 == 6) {
for (int i = 0; i < 8; ++i) {
ButterflyRotation_C(dst, 59 - i, i + 36, (i < 4) ? 48 : 112, true, range);
}
}
// stage 26.
if (size_log2 >= 4) {
for (int i = 0; i < 8; ++i) {
HadamardRotation_C(dst, i, 15 - i, false, range);
}
}
// stage 27.
if (size_log2 >= 5) {
for (int i = 0; i < 4; ++i) {
ButterflyRotation_C(dst, 27 - i, i + 20, 32, true, range);
}
}
// stage 28.
if (size_log2 == 6) {
for (int i = 0; i < 8; ++i) {
HadamardRotation_C(dst, i + 32, 47 - i, false, range);
HadamardRotation_C(dst, i + 48, 63 - i, true, range);
}
}
// stage 29.
if (size_log2 >= 5) {
for (int i = 0; i < 16; ++i) {
HadamardRotation_C(dst, i, 31 - i, false, range);
}
}
// stage 30.
if (size_log2 == 6) {
for (int i = 0; i < 8; ++i) {
ButterflyRotation_C(dst, 55 - i, i + 40, 32, true, range);
}
}
// stage 31.
if (size_log2 == 6) {
for (int i = 0; i < 32; ++i) {
HadamardRotation_C(dst, i, 63 - i, false, range);
}
}
}
template <int bitdepth, typename Residual, int size_log2>
void DctDcOnly_C(void* dest, int8_t range, bool should_round, int row_shift,
bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
if (is_row && should_round) {
dst[0] = RightShiftWithRounding(dst[0] * kTransformRowMultiplier, 12);
}
ButterflyRotationSecondIsZero_C(dst, 0, 1, 32, true, range);
if (is_row && row_shift > 0) {
dst[0] = RightShiftWithRounding(dst[0], row_shift);
}
ClampIntermediate<bitdepth, Residual>(dst, 1);
const int size = 1 << size_log2;
for (int i = 1; i < size; ++i) {
dst[i] = dst[0];
}
}
//------------------------------------------------------------------------------
// Asymmetric Discrete Sine Transforms (ADST).
/*
* Row transform max range in bits for bitdepths 8/10/12: 28/30/32.
* Column transform max range in bits for bitdepths 8/10/12: 28/28/30.
*/
template <typename Residual>
void Adst4_C(void* dest, int8_t range) {
auto* const dst = static_cast<Residual*>(dest);
if ((dst[0] | dst[1] | dst[2] | dst[3]) == 0) {
return;
}
// stage 1.
// Section 7.13.2.6: It is a requirement of bitstream conformance that all
// values stored in the s and x arrays by this process are representable by
// a signed integer using range + 12 bits of precision.
int32_t s[7];
s[0] = RangeCheckValue(kAdst4Multiplier[0] * dst[0], range + 12);
s[1] = RangeCheckValue(kAdst4Multiplier[1] * dst[0], range + 12);
s[2] = RangeCheckValue(kAdst4Multiplier[2] * dst[1], range + 12);
s[3] = RangeCheckValue(kAdst4Multiplier[3] * dst[2], range + 12);
s[4] = RangeCheckValue(kAdst4Multiplier[0] * dst[2], range + 12);
s[5] = RangeCheckValue(kAdst4Multiplier[1] * dst[3], range + 12);
s[6] = RangeCheckValue(kAdst4Multiplier[3] * dst[3], range + 12);
// stage 2.
// Section 7.13.2.6: It is a requirement of bitstream conformance that
// values stored in the variable a7 by this process are representable by a
// signed integer using range + 1 bits of precision.
const int32_t a7 = RangeCheckValue(dst[0] - dst[2], range + 1);
// Section 7.13.2.6: It is a requirement of bitstream conformance that
// values stored in the variable b7 by this process are representable by a
// signed integer using |range| bits of precision.
const int32_t b7 = RangeCheckValue(a7 + dst[3], range);
// stage 3.
s[0] = RangeCheckValue(s[0] + s[3], range + 12);
s[1] = RangeCheckValue(s[1] - s[4], range + 12);
s[3] = s[2];
s[2] = RangeCheckValue(kAdst4Multiplier[2] * b7, range + 12);
// stage 4.
s[0] = RangeCheckValue(s[0] + s[5], range + 12);
s[1] = RangeCheckValue(s[1] - s[6], range + 12);
// stages 5 and 6.
const int32_t x0 = RangeCheckValue(s[0] + s[3], range + 12);
const int32_t x1 = RangeCheckValue(s[1] + s[3], range + 12);
int32_t x3 = RangeCheckValue(s[0] + s[1], range + 12);
x3 = RangeCheckValue(x3 - s[3], range + 12);
int32_t dst_0 = RightShiftWithRounding(x0, 12);
int32_t dst_1 = RightShiftWithRounding(x1, 12);
int32_t dst_2 = RightShiftWithRounding(s[2], 12);
int32_t dst_3 = RightShiftWithRounding(x3, 12);
if (sizeof(Residual) == 2) {
// If the first argument to RightShiftWithRounding(..., 12) is only
// slightly smaller than 2^27 - 1 (e.g., 0x7fffe4e), adding 2^11 to it
// in RightShiftWithRounding(..., 12) will cause the function to return
// 0x8000, which cannot be represented as an int16_t. Change it to 0x7fff.
dst_0 -= (dst_0 == 0x8000);
dst_1 -= (dst_1 == 0x8000);
dst_3 -= (dst_3 == 0x8000);
}
dst[0] = dst_0;
dst[1] = dst_1;
dst[2] = dst_2;
dst[3] = dst_3;
}
template <int bitdepth, typename Residual>
void Adst4DcOnly_C(void* dest, int8_t range, bool should_round, int row_shift,
bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
if (is_row && should_round) {
dst[0] = RightShiftWithRounding(dst[0] * kTransformRowMultiplier, 12);
}
// stage 1.
// Section 7.13.2.6: It is a requirement of bitstream conformance that all
// values stored in the s and x arrays by this process are representable by
// a signed integer using range + 12 bits of precision.
int32_t s[3];
s[0] = RangeCheckValue(kAdst4Multiplier[0] * dst[0], range + 12);
s[1] = RangeCheckValue(kAdst4Multiplier[1] * dst[0], range + 12);
s[2] = RangeCheckValue(kAdst4Multiplier[2] * dst[0], range + 12);
// stage 3.
// stage 4.
// stages 5 and 6.
int32_t dst_0 = RightShiftWithRounding(s[0], 12);
int32_t dst_1 = RightShiftWithRounding(s[1], 12);
int32_t dst_2 = RightShiftWithRounding(s[2], 12);
int32_t dst_3 =
RightShiftWithRounding(RangeCheckValue(s[0] + s[1], range + 12), 12);
if (sizeof(Residual) == 2) {
// If the first argument to RightShiftWithRounding(..., 12) is only
// slightly smaller than 2^27 - 1 (e.g., 0x7fffe4e), adding 2^11 to it
// in RightShiftWithRounding(..., 12) will cause the function to return
// 0x8000, which cannot be represented as an int16_t. Change it to 0x7fff.
dst_0 -= (dst_0 == 0x8000);
dst_1 -= (dst_1 == 0x8000);
dst_3 -= (dst_3 == 0x8000);
}
dst[0] = dst_0;
dst[1] = dst_1;
dst[2] = dst_2;
dst[3] = dst_3;
const int size = 4;
if (is_row && row_shift > 0) {
for (int j = 0; j < size; ++j) {
dst[j] = RightShiftWithRounding(dst[j], row_shift);
}
}
ClampIntermediate<bitdepth, Residual>(dst, 4);
}
template <typename Residual>
void AdstInputPermutation(int32_t* LIBGAV1_RESTRICT const dst,
const Residual* LIBGAV1_RESTRICT const src, int n) {
assert(n == 8 || n == 16);
for (int i = 0; i < n; ++i) {
dst[i] = src[((i & 1) == 0) ? n - i - 1 : i - 1];
}
}
constexpr int8_t kAdstOutputPermutationLookup[16] = {
0, 8, 12, 4, 6, 14, 10, 2, 3, 11, 15, 7, 5, 13, 9, 1};
template <typename Residual>
void AdstOutputPermutation(Residual* LIBGAV1_RESTRICT const dst,
const int32_t* LIBGAV1_RESTRICT const src, int n) {
assert(n == 8 || n == 16);
const auto shift = static_cast<int8_t>(n == 8);
for (int i = 0; i < n; ++i) {
const int8_t index = kAdstOutputPermutationLookup[i] >> shift;
int32_t dst_i = ((i & 1) == 0) ? src[index] : -src[index];
if (sizeof(Residual) == 2) {
// If i is odd and src[index] is -32768, dst_i will be 32768, which
// cannot be represented as an int16_t.
dst_i -= (dst_i == 0x8000);
}
dst[i] = dst_i;
}
}
template <typename Residual>
void Adst8_C(void* dest, int8_t range) {
auto* const dst = static_cast<Residual*>(dest);
// stage 1.
int32_t temp[8];
AdstInputPermutation(temp, dst, 8);
// stage 2.
for (int i = 0; i < 4; ++i) {
ButterflyRotation_C(temp, MultiplyBy2(i), MultiplyBy2(i) + 1, 60 - 16 * i,
true, range);
}
// stage 3.
for (int i = 0; i < 4; ++i) {
HadamardRotation_C(temp, i, i + 4, false, range);
}
// stage 4.
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(temp, i * 3 + 4, i + 5, 48 - 32 * i, true, range);
}
// stage 5.
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
HadamardRotation_C(temp, i + MultiplyBy4(j), i + MultiplyBy4(j) + 2,
false, range);
}
}
// stage 6.
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(temp, MultiplyBy4(i) + 2, MultiplyBy4(i) + 3, 32, true,
range);
}
// stage 7.
AdstOutputPermutation(dst, temp, 8);
}
template <int bitdepth, typename Residual>
void Adst8DcOnly_C(void* dest, int8_t range, bool should_round, int row_shift,
bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
// stage 1.
int32_t temp[8];
// After the permutation, the dc value is in temp[1]. The remaining are zero.
AdstInputPermutation(temp, dst, 8);
if (is_row && should_round) {
temp[1] = RightShiftWithRounding(temp[1] * kTransformRowMultiplier, 12);
}
// stage 2.
ButterflyRotationFirstIsZero_C(temp, 0, 1, 60, true, range);
// stage 3.
temp[4] = temp[0];
temp[5] = temp[1];
// stage 4.
ButterflyRotation_C(temp, 4, 5, 48, true, range);
// stage 5.
temp[2] = temp[0];
temp[3] = temp[1];
temp[6] = temp[4];
temp[7] = temp[5];
// stage 6.
ButterflyRotation_C(temp, 2, 3, 32, true, range);
ButterflyRotation_C(temp, 6, 7, 32, true, range);
// stage 7.
AdstOutputPermutation(dst, temp, 8);
const int size = 8;
if (is_row && row_shift > 0) {
for (int j = 0; j < size; ++j) {
dst[j] = RightShiftWithRounding(dst[j], row_shift);
}
}
ClampIntermediate<bitdepth, Residual>(dst, 8);
}
template <typename Residual>
void Adst16_C(void* dest, int8_t range) {
auto* const dst = static_cast<Residual*>(dest);
// stage 1.
int32_t temp[16];
AdstInputPermutation(temp, dst, 16);
// stage 2.
for (int i = 0; i < 8; ++i) {
ButterflyRotation_C(temp, MultiplyBy2(i), MultiplyBy2(i) + 1, 62 - 8 * i,
true, range);
}
// stage 3.
for (int i = 0; i < 8; ++i) {
HadamardRotation_C(temp, i, i + 8, false, range);
}
// stage 4.
for (int i = 0; i < 2; ++i) {
ButterflyRotation_C(temp, MultiplyBy2(i) + 8, MultiplyBy2(i) + 9,
56 - 32 * i, true, range);
ButterflyRotation_C(temp, MultiplyBy2(i) + 13, MultiplyBy2(i) + 12,
8 + 32 * i, true, range);
}
// stage 5.
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 2; ++j) {
HadamardRotation_C(temp, i + MultiplyBy8(j), i + MultiplyBy8(j) + 4,
false, range);
}
}
// stage 6.
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
ButterflyRotation_C(temp, i * 3 + MultiplyBy8(j) + 4,
i + MultiplyBy8(j) + 5, 48 - 32 * i, true, range);
}
}
// stage 7.
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 4; ++j) {
HadamardRotation_C(temp, i + MultiplyBy4(j), i + MultiplyBy4(j) + 2,
false, range);
}
}
// stage 8.
for (int i = 0; i < 4; ++i) {
ButterflyRotation_C(temp, MultiplyBy4(i) + 2, MultiplyBy4(i) + 3, 32, true,
range);
}
// stage 9.
AdstOutputPermutation(dst, temp, 16);
}
template <int bitdepth, typename Residual>
void Adst16DcOnly_C(void* dest, int8_t range, bool should_round, int row_shift,
bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
// stage 1.
int32_t temp[16];
// After the permutation, the dc value is in temp[1]. The remaining are zero.
AdstInputPermutation(temp, dst, 16);
if (is_row && should_round) {
temp[1] = RightShiftWithRounding(temp[1] * kTransformRowMultiplier, 12);
}
// stage 2.
ButterflyRotationFirstIsZero_C(temp, 0, 1, 62, true, range);
// stage 3.
temp[8] = temp[0];
temp[9] = temp[1];
// stage 4.
ButterflyRotation_C(temp, 8, 9, 56, true, range);
// stage 5.
temp[4] = temp[0];
temp[5] = temp[1];
temp[12] = temp[8];
temp[13] = temp[9];
// stage 6.
ButterflyRotation_C(temp, 4, 5, 48, true, range);
ButterflyRotation_C(temp, 12, 13, 48, true, range);
// stage 7.
temp[2] = temp[0];
temp[3] = temp[1];
temp[10] = temp[8];
temp[11] = temp[9];
temp[6] = temp[4];
temp[7] = temp[5];
temp[14] = temp[12];
temp[15] = temp[13];
// stage 8.
for (int i = 0; i < 4; ++i) {
ButterflyRotation_C(temp, MultiplyBy4(i) + 2, MultiplyBy4(i) + 3, 32, true,
range);
}
// stage 9.
AdstOutputPermutation(dst, temp, 16);
const int size = 16;
if (is_row && row_shift > 0) {
for (int j = 0; j < size; ++j) {
dst[j] = RightShiftWithRounding(dst[j], row_shift);
}
}
ClampIntermediate<bitdepth, Residual>(dst, 16);
}
//------------------------------------------------------------------------------
// Identity Transforms.
//
// In the spec, the inverse identity transform is followed by a Round2() call:
// The row transforms with i = 0..(h-1) are applied as follows:
// ...
// * Otherwise, invoke the inverse identity transform process specified in
// section 7.13.2.15 with the input variable n equal to log2W.
// * Set Residual[ i ][ j ] equal to Round2( T[ j ], rowShift )
// for j = 0..(w-1).
// ...
// The column transforms with j = 0..(w-1) are applied as follows:
// ...
// * Otherwise, invoke the inverse identity transform process specified in
// section 7.13.2.15 with the input variable n equal to log2H.
// * Residual[ i ][ j ] is set equal to Round2( T[ i ], colShift )
// for i = 0..(h-1).
//
// Therefore, we define the identity transform functions to perform both the
// inverse identity transform and the Round2() call. This has two advantages:
// 1. The outputs of the inverse identity transform do not need to be stored
// in the Residual array. They can be stored in int32_t local variables,
// which have a larger range if Residual is an int16_t array.
// 2. The inverse identity transform and the Round2() call can be jointly
// optimized.
//
// The identity transform functions have the following prototype:
// void Identity_C(void* dest, int8_t shift);
//
// The |shift| parameter is the amount of shift for the Round2() call. For row
// transforms, |shift| is 0, 1, or 2. For column transforms, |shift| is always
// 4. Therefore, an identity transform function can detect whether it is being
// invoked as a row transform or a column transform by checking whether |shift|
// is equal to 4.
//
// Input Range
//
// The inputs of row transforms, stored in the 2D array Dequant, are
// representable by a signed integer using 8 + BitDepth bits of precision:
// f. Dequant[ i ][ j ] is set equal to
// Clip3( - ( 1 << ( 7 + BitDepth ) ), ( 1 << ( 7 + BitDepth ) ) - 1, dq2 ).
//
// The inputs of column transforms are representable by a signed integer using
// Max( BitDepth + 6, 16 ) bits of precision:
// Set the variable colClampRange equal to Max( BitDepth + 6, 16 ).
// ...
// Between the row and column transforms, Residual[ i ][ j ] is set equal to
// Clip3( - ( 1 << ( colClampRange - 1 ) ),
// ( 1 << (colClampRange - 1 ) ) - 1,
// Residual[ i ][ j ] )
// for i = 0..(h-1), for j = 0..(w-1).
//
// Output Range
//
// The outputs of row transforms are representable by a signed integer using
// 8 + BitDepth + 1 = 9 + BitDepth bits of precision, because the net effect
// of the multiplicative factor of inverse identity transforms minus the
// smallest row shift is an increase of at most one bit.
//
// Transform | Multiplicative factor | Smallest row | Net increase
// width | (in bits) | shift | in bits
// ---------------------------------------------------------------
// 4 | sqrt(2) (0.5 bits) | 0 | +0.5
// 8 | 2 (1 bit) | 0 | +1
// 16 | 2*sqrt(2) (1.5 bits) | 1 | +0.5
// 32 | 4 (2 bits) | 1 | +1
//
// If BitDepth is 8 and Residual is an int16_t array, to avoid truncation we
// clip the outputs (which have 17 bits of precision) to the range of int16_t
// before storing them in the Residual array. This clipping happens to be the
// same as the required clipping after the row transform (see the spec quoted
// above), so we remain compliant with the spec. (In this case,
// TransformLoop_C() skips clipping the outputs of row transforms to avoid
// duplication of effort.)
//
// The outputs of column transforms are representable by a signed integer using
// Max( BitDepth + 6, 16 ) + 2 - 4 = Max( BitDepth + 4, 14 ) bits of precision,
// because the multiplicative factor of inverse identity transforms is at most
// 4 (2 bits) and |shift| is always 4.
template <typename Residual>
void Identity4Row_C(void* dest, int8_t shift) {
assert(shift == 0 || shift == 1);
auto* const dst = static_cast<Residual*>(dest);
// If |shift| is 0, |rounding| should be 1 << 11. If |shift| is 1, |rounding|
// should be (1 + (1 << 1)) << 11. The following expression works for both
// values of |shift|.
const int32_t rounding = (1 + (shift << 1)) << 11;
for (int i = 0; i < 4; ++i) {
// The intermediate value here will have to fit into an int32_t for it to be
// bitstream conformant. The multiplication is promoted to int32_t by
// defining kIdentity4Multiplier as int32_t.
int32_t dst_i = (dst[i] * kIdentity4Multiplier + rounding) >> (12 + shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[i] = static_cast<Residual>(dst_i);
}
}
template <typename Residual>
void Identity4Column_C(void* dest, int8_t /*shift*/) {
auto* const dst = static_cast<Residual*>(dest);
const int32_t rounding = (1 + (1 << kTransformColumnShift)) << 11;
for (int i = 0; i < 4; ++i) {
// The intermediate value here will have to fit into an int32_t for it to be
// bitstream conformant. The multiplication is promoted to int32_t by
// defining kIdentity4Multiplier as int32_t.
dst[i] = static_cast<Residual>((dst[i] * kIdentity4Multiplier + rounding) >>
(12 + kTransformColumnShift));
}
}
template <int bitdepth, typename Residual>
void Identity4DcOnly_C(void* dest, int8_t /*range*/, bool should_round,
int row_shift, bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
if (is_row) {
if (should_round) {
dst[0] = RightShiftWithRounding(dst[0] * kTransformRowMultiplier, 12);
}
const int32_t rounding = (1 + (row_shift << 1)) << 11;
int32_t dst_i =
(dst[0] * kIdentity4Multiplier + rounding) >> (12 + row_shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[0] = static_cast<Residual>(dst_i);
ClampIntermediate<bitdepth, Residual>(dst, 1);
return;
}
const int32_t rounding = (1 + (1 << kTransformColumnShift)) << 11;
dst[0] = static_cast<Residual>((dst[0] * kIdentity4Multiplier + rounding) >>
(12 + kTransformColumnShift));
}
template <typename Residual>
void Identity8Row_C(void* dest, int8_t shift) {
assert(shift == 0 || shift == 1 || shift == 2);
auto* const dst = static_cast<Residual*>(dest);
for (int i = 0; i < 8; ++i) {
int32_t dst_i = RightShiftWithRounding(MultiplyBy2(dst[i]), shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[i] = static_cast<Residual>(dst_i);
}
}
template <typename Residual>
void Identity8Column_C(void* dest, int8_t /*shift*/) {
auto* const dst = static_cast<Residual*>(dest);
for (int i = 0; i < 8; ++i) {
dst[i] = static_cast<Residual>(
RightShiftWithRounding(dst[i], kTransformColumnShift - 1));
}
}
template <int bitdepth, typename Residual>
void Identity8DcOnly_C(void* dest, int8_t /*range*/, bool should_round,
int row_shift, bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
if (is_row) {
if (should_round) {
dst[0] = RightShiftWithRounding(dst[0] * kTransformRowMultiplier, 12);
}
int32_t dst_i = RightShiftWithRounding(MultiplyBy2(dst[0]), row_shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[0] = static_cast<Residual>(dst_i);
// If Residual is int16_t (which implies bitdepth is 8), we don't need to
// clip residual[i][j] to 16 bits.
if (sizeof(Residual) > 2) {
const Residual intermediate_clamp_max =
(1 << (std::max(bitdepth + 6, 16) - 1)) - 1;
const Residual intermediate_clamp_min = -intermediate_clamp_max - 1;
dst[0] = Clip3(dst[0], intermediate_clamp_min, intermediate_clamp_max);
}
return;
}
dst[0] = static_cast<Residual>(
RightShiftWithRounding(dst[0], kTransformColumnShift - 1));
}
template <typename Residual>
void Identity16Row_C(void* dest, int8_t shift) {
assert(shift == 1 || shift == 2);
auto* const dst = static_cast<Residual*>(dest);
const int32_t rounding = (1 + (1 << shift)) << 11;
for (int i = 0; i < 16; ++i) {
// The intermediate value here will have to fit into an int32_t for it to be
// bitstream conformant. The multiplication is promoted to int32_t by
// defining kIdentity16Multiplier as int32_t.
int32_t dst_i = (dst[i] * kIdentity16Multiplier + rounding) >> (12 + shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[i] = static_cast<Residual>(dst_i);
}
}
template <typename Residual>
void Identity16Column_C(void* dest, int8_t /*shift*/) {
auto* const dst = static_cast<Residual*>(dest);
const int32_t rounding = (1 + (1 << kTransformColumnShift)) << 11;
for (int i = 0; i < 16; ++i) {
// The intermediate value here will have to fit into an int32_t for it to be
// bitstream conformant. The multiplication is promoted to int32_t by
// defining kIdentity16Multiplier as int32_t.
dst[i] =
static_cast<Residual>((dst[i] * kIdentity16Multiplier + rounding) >>
(12 + kTransformColumnShift));
}
}
template <int bitdepth, typename Residual>
void Identity16DcOnly_C(void* dest, int8_t /*range*/, bool should_round,
int row_shift, bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
if (is_row) {
if (should_round) {
dst[0] = RightShiftWithRounding(dst[0] * kTransformRowMultiplier, 12);
}
const int32_t rounding = (1 + (1 << row_shift)) << 11;
int32_t dst_i =
(dst[0] * kIdentity16Multiplier + rounding) >> (12 + row_shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[0] = static_cast<Residual>(dst_i);
ClampIntermediate<bitdepth, Residual>(dst, 1);
return;
}
const int32_t rounding = (1 + (1 << kTransformColumnShift)) << 11;
dst[0] = static_cast<Residual>((dst[0] * kIdentity16Multiplier + rounding) >>
(12 + kTransformColumnShift));
}
template <typename Residual>
void Identity32Row_C(void* dest, int8_t shift) {
assert(shift == 1 || shift == 2);
auto* const dst = static_cast<Residual*>(dest);
for (int i = 0; i < 32; ++i) {
int32_t dst_i = RightShiftWithRounding(MultiplyBy4(dst[i]), shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[i] = static_cast<Residual>(dst_i);
}
}
template <typename Residual>
void Identity32Column_C(void* dest, int8_t /*shift*/) {
auto* const dst = static_cast<Residual*>(dest);
for (int i = 0; i < 32; ++i) {
dst[i] = static_cast<Residual>(
RightShiftWithRounding(dst[i], kTransformColumnShift - 2));
}
}
template <int bitdepth, typename Residual>
void Identity32DcOnly_C(void* dest, int8_t /*range*/, bool should_round,
int row_shift, bool is_row) {
auto* const dst = static_cast<Residual*>(dest);
if (is_row) {
if (should_round) {
dst[0] = RightShiftWithRounding(dst[0] * kTransformRowMultiplier, 12);
}
int32_t dst_i = RightShiftWithRounding(MultiplyBy4(dst[0]), row_shift);
if (sizeof(Residual) == 2) {
dst_i = Clip3(dst_i, INT16_MIN, INT16_MAX);
}
dst[0] = static_cast<Residual>(dst_i);
ClampIntermediate<bitdepth, Residual>(dst, 1);
return;
}
dst[0] = static_cast<Residual>(
RightShiftWithRounding(dst[0], kTransformColumnShift - 2));
}
//------------------------------------------------------------------------------
// Walsh Hadamard Transform.
template <typename Residual>
void Wht4_C(void* dest, int8_t shift) {
auto* const dst = static_cast<Residual*>(dest);
Residual temp[4];
temp[0] = dst[0] >> shift;
temp[2] = dst[1] >> shift;
temp[3] = dst[2] >> shift;
temp[1] = dst[3] >> shift;
temp[0] += temp[2];
temp[3] -= temp[1];
// This signed right shift must be an arithmetic shift.
Residual e = (temp[0] - temp[3]) >> 1;
dst[1] = e - temp[1];
dst[2] = e - temp[2];
dst[0] = temp[0] - dst[1];
dst[3] = temp[3] + dst[2];
}
template <int bitdepth, typename Residual>
void Wht4DcOnly_C(void* dest, int8_t range, bool /*should_round*/,
int /*row_shift*/, bool /*is_row*/) {
auto* const dst = static_cast<Residual*>(dest);
const int shift = range;
Residual temp = dst[0] >> shift;
// This signed right shift must be an arithmetic shift.
Residual e = temp >> 1;
dst[0] = temp - e;
dst[1] = e;
dst[2] = e;
dst[3] = e;
ClampIntermediate<bitdepth, Residual>(dst, 4);
}
//------------------------------------------------------------------------------
// row/column transform loop
using InverseTransform1dFunc = void (*)(void* dst, int8_t range);
using InverseTransformDcOnlyFunc = void (*)(void* dest, int8_t range,
bool should_round, int row_shift,
bool is_row);
template <int bitdepth, typename Residual, typename Pixel,
Transform1d transform1d_type,
InverseTransformDcOnlyFunc dconly_transform1d,
InverseTransform1dFunc transform1d_func, bool is_row>
void TransformLoop_C(TransformType tx_type, TransformSize tx_size,
int adjusted_tx_height, void* LIBGAV1_RESTRICT src_buffer,
int start_x, int start_y,
void* LIBGAV1_RESTRICT dst_frame) {
constexpr bool lossless = transform1d_type == kTransform1dWht;
constexpr bool is_identity = transform1d_type == kTransform1dIdentity;
// The transform size of the WHT is always 4x4. Setting tx_width and
// tx_height to the constant 4 for the WHT speeds the code up.
assert(!lossless || tx_size == kTransformSize4x4);
const int tx_width = lossless ? 4 : kTransformWidth[tx_size];
const int tx_height = lossless ? 4 : kTransformHeight[tx_size];
const int tx_width_log2 = kTransformWidthLog2[tx_size];
const int tx_height_log2 = kTransformHeightLog2[tx_size];
auto* frame = static_cast<Array2DView<Pixel>*>(dst_frame);
// Initially this points to the dequantized values. After the transforms are
// applied, this buffer contains the residual.
Array2DView<Residual> residual(tx_height, tx_width,
static_cast<Residual*>(src_buffer));
if (is_row) {
// Row transform.
const uint8_t row_shift = lossless ? 0 : kTransformRowShift[tx_size];
// This is the |range| parameter of the InverseTransform1dFunc. For lossy
// transforms, this will be equal to the clamping range.
const int8_t row_clamp_range = lossless ? 2 : (bitdepth + 8);
// If the width:height ratio of the transform size is 2:1 or 1:2, multiply
// the input to the row transform by 1 / sqrt(2), which is approximated by
// the fraction 2896 / 2^12.
const bool should_round = std::abs(tx_width_log2 - tx_height_log2) == 1;
if (adjusted_tx_height == 1) {
dconly_transform1d(residual[0], row_clamp_range, should_round, row_shift,
true);
return;
}
// Row transforms need to be done only up to 32 because the rest of the rows
// are always all zero if |tx_height| is 64. Otherwise, only process the
// rows that have a non zero coefficients.
for (int i = 0; i < adjusted_tx_height; ++i) {
// If lossless, the transform size is 4x4, so should_round is false.
if (!lossless && should_round) {
// The last 32 values of every row are always zero if the |tx_width| is
// 64.
for (int j = 0; j < std::min(tx_width, 32); ++j) {
residual[i][j] = RightShiftWithRounding(
residual[i][j] * kTransformRowMultiplier, 12);
}
}
// For identity transform, |transform1d_func| also performs the
// Round2(T[j], rowShift) call in the spec.
transform1d_func(residual[i], is_identity ? row_shift : row_clamp_range);
if (!lossless && !is_identity && row_shift > 0) {
for (int j = 0; j < tx_width; ++j) {
residual[i][j] = RightShiftWithRounding(residual[i][j], row_shift);
}
}
ClampIntermediate<bitdepth, Residual>(residual[i], tx_width);
}
return;
}
assert(!is_row);
constexpr uint8_t column_shift = lossless ? 0 : kTransformColumnShift;
// This is the |range| parameter of the InverseTransform1dFunc. For lossy
// transforms, this will be equal to the clamping range.
const int8_t column_clamp_range = lossless ? 0 : std::max(bitdepth + 6, 16);
const bool flip_rows = transform1d_type == kTransform1dAdst &&
kTransformFlipRowsMask.Contains(tx_type);
const bool flip_columns =
!lossless && kTransformFlipColumnsMask.Contains(tx_type);
const int min_value = 0;
const int max_value = (1 << bitdepth) - 1;
// Note: 64 is the maximum size of a 1D transform buffer (the largest
// transform size is kTransformSize64x64).
Residual tx_buffer[64];
for (int j = 0; j < tx_width; ++j) {
const int flipped_j = flip_columns ? tx_width - j - 1 : j;
int i = 0;
do {
tx_buffer[i] = residual[i][flipped_j];
} while (++i != tx_height);
if (adjusted_tx_height == 1) {
dconly_transform1d(tx_buffer, column_clamp_range, false, 0, false);
} else {
// For identity transform, |transform1d_func| also performs the
// Round2(T[i], colShift) call in the spec.
transform1d_func(tx_buffer,
is_identity ? column_shift : column_clamp_range);
}
const int x = start_x + j;
for (int i = 0; i < tx_height; ++i) {
const int y = start_y + i;
const int index = flip_rows ? tx_height - i - 1 : i;
Residual residual_value = tx_buffer[index];
if (!lossless && !is_identity) {
residual_value = RightShiftWithRounding(residual_value, column_shift);
}
(*frame)[y][x] =
Clip3((*frame)[y][x] + residual_value, min_value, max_value);
}
}
}
//------------------------------------------------------------------------------
#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
template <int bitdepth, typename Residual, typename Pixel>
void InitAll(Dsp* const dsp) {
// Maximum transform size for Dct is 64.
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize4][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 2>, Dct_C<Residual, 2>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize4][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 2>, Dct_C<Residual, 2>,
/*is_row=*/false>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize8][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 3>, Dct_C<Residual, 3>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize8][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 3>, Dct_C<Residual, 3>,
/*is_row=*/false>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize16][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 4>, Dct_C<Residual, 4>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize16][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 4>, Dct_C<Residual, 4>,
/*is_row=*/false>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize32][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 5>, Dct_C<Residual, 5>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize32][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 5>, Dct_C<Residual, 5>,
/*is_row=*/false>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize64][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 6>, Dct_C<Residual, 6>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize64][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dDct,
DctDcOnly_C<bitdepth, Residual, 6>, Dct_C<Residual, 6>,
/*is_row=*/false>;
// Maximum transform size for Adst is 16.
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize4][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dAdst,
Adst4DcOnly_C<bitdepth, Residual>, Adst4_C<Residual>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize4][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dAdst,
Adst4DcOnly_C<bitdepth, Residual>, Adst4_C<Residual>,
/*is_row=*/false>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize8][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dAdst,
Adst8DcOnly_C<bitdepth, Residual>, Adst8_C<Residual>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize8][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dAdst,
Adst8DcOnly_C<bitdepth, Residual>, Adst8_C<Residual>,
/*is_row=*/false>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize16][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dAdst,
Adst16DcOnly_C<bitdepth, Residual>, Adst16_C<Residual>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize16][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dAdst,
Adst16DcOnly_C<bitdepth, Residual>, Adst16_C<Residual>,
/*is_row=*/false>;
// Maximum transform size for Identity transform is 32.
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize4][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity4DcOnly_C<bitdepth, Residual>,
Identity4Row_C<Residual>, /*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize4][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity4DcOnly_C<bitdepth, Residual>,
Identity4Column_C<Residual>, /*is_row=*/false>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize8][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity8DcOnly_C<bitdepth, Residual>,
Identity8Row_C<Residual>, /*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize8][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity8DcOnly_C<bitdepth, Residual>,
Identity8Column_C<Residual>, /*is_row=*/false>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize16][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity16DcOnly_C<bitdepth, Residual>,
Identity16Row_C<Residual>, /*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize16][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity16DcOnly_C<bitdepth, Residual>,
Identity16Column_C<Residual>, /*is_row=*/false>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize32][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity32DcOnly_C<bitdepth, Residual>,
Identity32Row_C<Residual>, /*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize32][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dIdentity,
Identity32DcOnly_C<bitdepth, Residual>,
Identity32Column_C<Residual>, /*is_row=*/false>;
// Maximum transform size for Wht is 4.
dsp->inverse_transforms[kTransform1dWht][kTransform1dSize4][kRow] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dWht,
Wht4DcOnly_C<bitdepth, Residual>, Wht4_C<Residual>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dWht][kTransform1dSize4][kColumn] =
TransformLoop_C<bitdepth, Residual, Pixel, kTransform1dWht,
Wht4DcOnly_C<bitdepth, Residual>, Wht4_C<Residual>,
/*is_row=*/false>;
}
#endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
void Init8bpp() {
Dsp* const dsp = dsp_internal::GetWritableDspTable(8);
assert(dsp != nullptr);
static_cast<void>(dsp);
#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
InitAll<8, int16_t, uint8_t>(dsp);
#else // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize4_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize4][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 2>, Dct_C<int16_t, 2>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize4][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 2>, Dct_C<int16_t, 2>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize8_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize8][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 3>, Dct_C<int16_t, 3>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize8][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 3>, Dct_C<int16_t, 3>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize16_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize16][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 4>, Dct_C<int16_t, 4>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize16][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 4>, Dct_C<int16_t, 4>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize32_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize32][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 5>, Dct_C<int16_t, 5>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize32][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 5>, Dct_C<int16_t, 5>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize64_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize64][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 6>, Dct_C<int16_t, 6>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize64][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dDct,
DctDcOnly_C<8, int16_t, 6>, Dct_C<int16_t, 6>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize4_Transform1dAdst
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize4][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dAdst,
Adst4DcOnly_C<8, int16_t>, Adst4_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize4][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dAdst,
Adst4DcOnly_C<8, int16_t>, Adst4_C<int16_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize8_Transform1dAdst
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize8][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dAdst,
Adst8DcOnly_C<8, int16_t>, Adst8_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize8][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dAdst,
Adst8DcOnly_C<8, int16_t>, Adst8_C<int16_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize16_Transform1dAdst
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize16][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dAdst,
Adst16DcOnly_C<8, int16_t>, Adst16_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize16][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dAdst,
Adst16DcOnly_C<8, int16_t>, Adst16_C<int16_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize4_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize4][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity4DcOnly_C<8, int16_t>, Identity4Row_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize4][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity4DcOnly_C<8, int16_t>, Identity4Column_C<int16_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize8_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize8][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity8DcOnly_C<8, int16_t>, Identity8Row_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize8][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity8DcOnly_C<8, int16_t>, Identity8Column_C<int16_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize16_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize16][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity16DcOnly_C<8, int16_t>, Identity16Row_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize16][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity16DcOnly_C<8, int16_t>,
Identity16Column_C<int16_t>, /*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize32_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize32][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity32DcOnly_C<8, int16_t>, Identity32Row_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize32][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dIdentity,
Identity32DcOnly_C<8, int16_t>,
Identity32Column_C<int16_t>, /*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp8bpp_Transform1dSize4_Transform1dWht
dsp->inverse_transforms[kTransform1dWht][kTransform1dSize4][kRow] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dWht,
Wht4DcOnly_C<8, int16_t>, Wht4_C<int16_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dWht][kTransform1dSize4][kColumn] =
TransformLoop_C<8, int16_t, uint8_t, kTransform1dWht,
Wht4DcOnly_C<8, int16_t>, Wht4_C<int16_t>,
/*is_row=*/false>;
#endif
#endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
}
#if LIBGAV1_MAX_BITDEPTH >= 10
void Init10bpp() {
Dsp* const dsp = dsp_internal::GetWritableDspTable(10);
assert(dsp != nullptr);
static_cast<void>(dsp);
#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
InitAll<10, int32_t, uint16_t>(dsp);
#else // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize4_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize4][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 2>, Dct_C<int32_t, 2>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize4][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 2>, Dct_C<int32_t, 2>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize8_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize8][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 3>, Dct_C<int32_t, 3>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize8][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 3>, Dct_C<int32_t, 3>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize16_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize16][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 4>, Dct_C<int32_t, 4>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize16][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 4>, Dct_C<int32_t, 4>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize32_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize32][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 5>, Dct_C<int32_t, 5>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize32][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 5>, Dct_C<int32_t, 5>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize64_Transform1dDct
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize64][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 6>, Dct_C<int32_t, 6>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dDct][kTransform1dSize64][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dDct,
DctDcOnly_C<10, int32_t, 6>, Dct_C<int32_t, 6>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize4_Transform1dAdst
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize4][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dAdst,
Adst4DcOnly_C<10, int32_t>, Adst4_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize4][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dAdst,
Adst4DcOnly_C<10, int32_t>, Adst4_C<int32_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize8_Transform1dAdst
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize8][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dAdst,
Adst8DcOnly_C<10, int32_t>, Adst8_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize8][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dAdst,
Adst8DcOnly_C<10, int32_t>, Adst8_C<int32_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize16_Transform1dAdst
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize16][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dAdst,
Adst16DcOnly_C<10, int32_t>, Adst16_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dAdst][kTransform1dSize16][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dAdst,
Adst16DcOnly_C<10, int32_t>, Adst16_C<int32_t>,
/*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize4_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize4][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity4DcOnly_C<10, int32_t>, Identity4Row_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize4][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity4DcOnly_C<10, int32_t>,
Identity4Column_C<int32_t>, /*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize8_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize8][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity8DcOnly_C<10, int32_t>, Identity8Row_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize8][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity8DcOnly_C<10, int32_t>,
Identity8Column_C<int32_t>, /*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize16_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize16][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity16DcOnly_C<10, int32_t>, Identity16Row_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize16][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity16DcOnly_C<10, int32_t>,
Identity16Column_C<int32_t>, /*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize32_Transform1dIdentity
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize32][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity32DcOnly_C<10, int32_t>, Identity32Row_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dIdentity][kTransform1dSize32][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dIdentity,
Identity32DcOnly_C<10, int32_t>,
Identity32Column_C<int32_t>, /*is_row=*/false>;
#endif
#ifndef LIBGAV1_Dsp10bpp_Transform1dSize4_Transform1dWht
dsp->inverse_transforms[kTransform1dWht][kTransform1dSize4][kRow] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dWht,
Wht4DcOnly_C<10, int32_t>, Wht4_C<int32_t>,
/*is_row=*/true>;
dsp->inverse_transforms[kTransform1dWht][kTransform1dSize4][kColumn] =
TransformLoop_C<10, int32_t, uint16_t, kTransform1dWht,
Wht4DcOnly_C<10, int32_t>, Wht4_C<int32_t>,
/*is_row=*/false>;
#endif
#endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
}
#endif // LIBGAV1_MAX_BITDEPTH >= 10
} // namespace
void InverseTransformInit_C() {
Init8bpp();
#if LIBGAV1_MAX_BITDEPTH >= 10
Init10bpp();
#endif
// Local functions that may be unused depending on the optimizations
// available.
static_cast<void>(RangeCheckValue);
static_cast<void>(kBitReverseLookup);
}
} // namespace dsp
} // namespace libgav1