libgav1/src/dsp/cdef.cc - platform/external/libgav1 - Git at Google

 // 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/cdef.h"

 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>

 #include "src/dsp/constants.h"
 #include "src/dsp/dsp.h"
 #include "src/utils/common.h"
 #include "src/utils/constants.h"

 namespace libgav1 {
 namespace dsp {
 namespace {

 #include "src/dsp/cdef.inc"

 // Silence unused function warnings when CdefDirection_C is obviated.
 #if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS ||        \
     !defined(LIBGAV1_Dsp8bpp_CdefDirection) || \
     (LIBGAV1_MAX_BITDEPTH >= 10 && !defined(LIBGAV1_Dsp10bpp_CdefDirection))
 constexpr int16_t kDivisionTable[] = {840, 420, 280, 210, 168, 140, 120, 105};

 int32_t Square(int32_t x) { return x * x; }

 template <int bitdepth, typename Pixel>
 void CdefDirection_C(const void* const source, ptrdiff_t stride,
                      int* const direction, int* const variance) {
   assert(direction != nullptr);
   assert(variance != nullptr);
   const auto* src = static_cast<const Pixel*>(source);
   stride /= sizeof(Pixel);
   int32_t cost[8] = {};
   // |partial| does not have to be int32_t for 8bpp. int16_t will suffice. We
   // use int32_t to keep it simple since |cost| will have to be int32_t.
   int32_t partial[8][15] = {};
   for (int i = 0; i < 8; ++i) {
     for (int j = 0; j < 8; ++j) {
       const int x = (src[j] >> (bitdepth - 8)) - 128;
       partial[0][i + j] += x;
       partial[1][i + j / 2] += x;
       partial[2][i] += x;
       partial[3][3 + i - j / 2] += x;
       partial[4][7 + i - j] += x;
       partial[5][3 - i / 2 + j] += x;
       partial[6][j] += x;
       partial[7][i / 2 + j] += x;
     }
     src += stride;
   }
   for (int i = 0; i < 8; ++i) {
     cost[2] += Square(partial[2][i]);
     cost[6] += Square(partial[6][i]);
   }
   cost[2] *= kDivisionTable[7];
   cost[6] *= kDivisionTable[7];
   for (int i = 0; i < 7; ++i) {
     cost[0] += (Square(partial[0][i]) + Square(partial[0][14 - i])) *
                kDivisionTable[i];
     cost[4] += (Square(partial[4][i]) + Square(partial[4][14 - i])) *
                kDivisionTable[i];
   }
   cost[0] += Square(partial[0][7]) * kDivisionTable[7];
   cost[4] += Square(partial[4][7]) * kDivisionTable[7];
   for (int i = 1; i < 8; i += 2) {
     for (int j = 0; j < 5; ++j) {
       cost[i] += Square(partial[i][3 + j]);
     }
     cost[i] *= kDivisionTable[7];
     for (int j = 0; j < 3; ++j) {
       cost[i] += (Square(partial[i][j]) + Square(partial[i][10 - j])) *
                  kDivisionTable[2 * j + 1];
     }
   }
   int32_t best_cost = 0;
   *direction = 0;
   for (int i = 0; i < 8; ++i) {
     if (cost[i] > best_cost) {
       best_cost = cost[i];
       *direction = i;
     }
   }
   *variance = (best_cost - cost[(*direction + 4) & 7]) >> 10;
 }
 #endif  // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS ||
         // !defined(LIBGAV1_Dsp8bpp_CdefDirection) ||
         // (LIBGAV1_MAX_BITDEPTH >= 10 &&
         // !defined(LIBGAV1_Dsp10bpp_CdefDirection))

 // Silence unused function warnings when CdefFilter_C is obviated.
 #if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS ||      \
     !defined(LIBGAV1_Dsp8bpp_CdefFilters) || \
     (LIBGAV1_MAX_BITDEPTH >= 10 && !defined(LIBGAV1_Dsp10bpp_CdefFilters))

 int Constrain(int diff, int threshold, int damping) {
   assert(threshold != 0);
   damping = std::max(0, damping - FloorLog2(threshold));
   const int sign = (diff < 0) ? -1 : 1;
   return sign *
          Clip3(threshold - (std::abs(diff) >> damping), 0, std::abs(diff));
 }

 // Filters the source block. It doesn't check whether the candidate pixel is
 // inside the frame. However it requires the source input to be padded with a
 // constant large value (kCdefLargeValue) if at the boundary.
 template <int block_width, int bitdepth, typename Pixel,
           bool enable_primary = true, bool enable_secondary = true>
 void CdefFilter_C(const uint16_t* src, const ptrdiff_t src_stride,
                   const int block_height, const int primary_strength,
                   const int secondary_strength, const int damping,
                   const int direction, void* const dest,
                   const ptrdiff_t dest_stride) {
   static_assert(block_width == 4 || block_width == 8, "Invalid CDEF width.");
   static_assert(enable_primary || enable_secondary, "");
   assert(block_height == 4 || block_height == 8);
   assert(direction >= 0 && direction <= 7);
   constexpr int coeff_shift = bitdepth - 8;
   // Section 5.9.19. CDEF params syntax.
   assert(primary_strength >= 0 && primary_strength <= 15 << coeff_shift);
   assert(secondary_strength >= 0 && secondary_strength <= 4 << coeff_shift &&
          secondary_strength != 3 << coeff_shift);
   assert(primary_strength != 0 || secondary_strength != 0);
   // damping is decreased by 1 for chroma.
   assert((damping >= 3 && damping <= 6 + coeff_shift) ||
          (damping >= 2 && damping <= 5 + coeff_shift));
   // When only primary_strength or secondary_strength are non-zero the number
   // of pixels inspected (4 for primary_strength, 8 for secondary_strength) and
   // the taps used don't exceed the amount the sum is
   // descaled by (16) so we can skip tracking and clipping to the minimum and
   // maximum value observed.
   constexpr bool clipping_required = enable_primary && enable_secondary;
   static constexpr int kCdefSecondaryTaps[2] = {kCdefSecondaryTap0,
                                                 kCdefSecondaryTap1};
   auto* dst = static_cast<Pixel*>(dest);
   const ptrdiff_t dst_stride = dest_stride / sizeof(Pixel);
   int y = block_height;
   do {
     int x = 0;
     do {
       int16_t sum = 0;
       const uint16_t pixel_value = src[x];
       uint16_t max_value = pixel_value;
       uint16_t min_value = pixel_value;
       for (int k = 0; k < 2; ++k) {
         static constexpr int signs[] = {-1, 1};
         for (const int& sign : signs) {
           if (enable_primary) {
             const int dy = sign * kCdefDirections[direction][k][0];
             const int dx = sign * kCdefDirections[direction][k][1];
             const uint16_t value = src[dy * src_stride + dx + x];
             // Note: the summation can ignore the condition check in SIMD
             // implementation, because Constrain() will return 0 when
             // value == kCdefLargeValue.
             if (value != kCdefLargeValue) {
               sum += Constrain(value - pixel_value, primary_strength, damping) *
                      kCdefPrimaryTaps[(primary_strength >> coeff_shift) & 1][k];
               if (clipping_required) {
                 max_value = std::max(value, max_value);
                 min_value = std::min(value, min_value);
               }
             }
           }

           if (enable_secondary) {
             static constexpr int offsets[] = {-2, 2};
             for (const int& offset : offsets) {
               const int dy = sign * kCdefDirections[direction + offset][k][0];
               const int dx = sign * kCdefDirections[direction + offset][k][1];
               const uint16_t value = src[dy * src_stride + dx + x];
               // Note: the summation can ignore the condition check in SIMD
               // implementation.
               if (value != kCdefLargeValue) {
                 sum += Constrain(value - pixel_value, secondary_strength,
                                  damping) *
                        kCdefSecondaryTaps[k];
                 if (clipping_required) {
                   max_value = std::max(value, max_value);
                   min_value = std::min(value, min_value);
                 }
               }
             }
           }
         }
       }

       const int offset = (8 + sum - (sum < 0)) >> 4;
       if (clipping_required) {
         dst[x] = static_cast<Pixel>(
             Clip3(pixel_value + offset, min_value, max_value));
       } else {
         dst[x] = static_cast<Pixel>(pixel_value + offset);
       }
     } while (++x < block_width);

     src += src_stride;
     dst += dst_stride;
   } while (--y != 0);
 }
 #endif  // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS ||
         // !defined(LIBGAV1_Dsp8bpp_CdefFilters) ||
         // (LIBGAV1_MAX_BITDEPTH >= 10 &&
         // !defined(LIBGAV1_Dsp10bpp_CdefFilters))

 void Init8bpp() {
   Dsp* const dsp = dsp_internal::GetWritableDspTable(8);
   assert(dsp != nullptr);
 #if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
   dsp->cdef_direction = CdefDirection_C<8, uint8_t>;
   dsp->cdef_filters[0][0] = CdefFilter_C<4, 8, uint8_t>;
   dsp->cdef_filters[0][1] = CdefFilter_C<4, 8, uint8_t, /*enable_primary=*/true,
                                          /*enable_secondary=*/false>;
   dsp->cdef_filters[0][2] =
       CdefFilter_C<4, 8, uint8_t, /*enable_primary=*/false>;
   dsp->cdef_filters[1][0] = CdefFilter_C<8, 8, uint8_t>;
   dsp->cdef_filters[1][1] = CdefFilter_C<8, 8, uint8_t, /*enable_primary=*/true,
                                          /*enable_secondary=*/false>;
   dsp->cdef_filters[1][2] =
       CdefFilter_C<8, 8, uint8_t, /*enable_primary=*/false>;
 #else  // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
   static_cast<void>(dsp);
 #ifndef LIBGAV1_Dsp8bpp_CdefDirection
   dsp->cdef_direction = CdefDirection_C<8, uint8_t>;
 #endif
 #ifndef LIBGAV1_Dsp8bpp_CdefFilters
   dsp->cdef_filters[0][0] = CdefFilter_C<4, 8, uint8_t>;
   dsp->cdef_filters[0][1] = CdefFilter_C<4, 8, uint8_t, /*enable_primary=*/true,
                                          /*enable_secondary=*/false>;
   dsp->cdef_filters[0][2] =
       CdefFilter_C<4, 8, uint8_t, /*enable_primary=*/false>;
   dsp->cdef_filters[1][0] = CdefFilter_C<8, 8, uint8_t>;
   dsp->cdef_filters[1][1] = CdefFilter_C<8, 8, uint8_t, /*enable_primary=*/true,
                                          /*enable_secondary=*/false>;
   dsp->cdef_filters[1][2] =
       CdefFilter_C<8, 8, uint8_t, /*enable_primary=*/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);
 #if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
   dsp->cdef_direction = CdefDirection_C<10, uint16_t>;
   dsp->cdef_filters[0][0] = CdefFilter_C<4, 10, uint16_t>;
   dsp->cdef_filters[0][1] =
       CdefFilter_C<4, 10, uint16_t, /*enable_primary=*/true,
                    /*enable_secondary=*/false>;
   dsp->cdef_filters[0][2] =
       CdefFilter_C<4, 10, uint16_t, /*enable_primary=*/false>;
   dsp->cdef_filters[1][0] = CdefFilter_C<8, 10, uint16_t>;
   dsp->cdef_filters[1][1] =
       CdefFilter_C<8, 10, uint16_t, /*enable_primary=*/true,
                    /*enable_secondary=*/false>;
   dsp->cdef_filters[1][2] =
       CdefFilter_C<8, 10, uint16_t, /*enable_primary=*/false>;
 #else  // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
   static_cast<void>(dsp);
 #ifndef LIBGAV1_Dsp10bpp_CdefDirection
   dsp->cdef_direction = CdefDirection_C<10, uint16_t>;
 #endif
 #ifndef LIBGAV1_Dsp10bpp_CdefFilters
   dsp->cdef_filters[0][0] = CdefFilter_C<4, 10, uint16_t>;
   dsp->cdef_filters[0][1] =
       CdefFilter_C<4, 10, uint16_t, /*enable_primary=*/true,
                    /*enable_secondary=*/false>;
   dsp->cdef_filters[0][2] =
       CdefFilter_C<4, 10, uint16_t, /*enable_primary=*/false>;
   dsp->cdef_filters[1][0] = CdefFilter_C<8, 10, uint16_t>;
   dsp->cdef_filters[1][1] =
       CdefFilter_C<8, 10, uint16_t, /*enable_primary=*/true,
                    /*enable_secondary=*/false>;
   dsp->cdef_filters[1][2] =
       CdefFilter_C<8, 10, uint16_t, /*enable_primary=*/false>;
 #endif
 #endif  // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
 }
 #endif

 }  // namespace

 void CdefInit_C() {
   Init8bpp();
 #if LIBGAV1_MAX_BITDEPTH >= 10
   Init10bpp();
 #endif
 }

 }  // namespace dsp
 }  // namespace libgav1
	// 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/cdef.h"

	#include <algorithm>
	#include <cassert>
	#include <cstddef>
	#include <cstdint>
	#include <cstring>

	#include "src/dsp/constants.h"
	#include "src/dsp/dsp.h"
	#include "src/utils/common.h"
	#include "src/utils/constants.h"

	namespace libgav1 {
	namespace dsp {
	namespace {

	#include "src/dsp/cdef.inc"

	// Silence unused function warnings when CdefDirection_C is obviated.
	#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS \|\| \
	!defined(LIBGAV1_Dsp8bpp_CdefDirection) \|\| \
	(LIBGAV1_MAX_BITDEPTH >= 10 && !defined(LIBGAV1_Dsp10bpp_CdefDirection))
	constexpr int16_t kDivisionTable[] = {840, 420, 280, 210, 168, 140, 120, 105};

	int32_t Square(int32_t x) { return x * x; }

	template <int bitdepth, typename Pixel>
	void CdefDirection_C(const void* const source, ptrdiff_t stride,
	int* const direction, int* const variance) {
	assert(direction != nullptr);
	assert(variance != nullptr);
	const auto* src = static_cast<const Pixel*>(source);
	stride /= sizeof(Pixel);
	int32_t cost[8] = {};
	// \|partial\| does not have to be int32_t for 8bpp. int16_t will suffice. We
	// use int32_t to keep it simple since \|cost\| will have to be int32_t.
	int32_t partial[8][15] = {};
	for (int i = 0; i < 8; ++i) {
	for (int j = 0; j < 8; ++j) {
	const int x = (src[j] >> (bitdepth - 8)) - 128;
	partial[0][i + j] += x;
	partial[1][i + j / 2] += x;
	partial[2][i] += x;
	partial[3][3 + i - j / 2] += x;
	partial[4][7 + i - j] += x;
	partial[5][3 - i / 2 + j] += x;
	partial[6][j] += x;
	partial[7][i / 2 + j] += x;
	}
	src += stride;
	}
	for (int i = 0; i < 8; ++i) {
	cost[2] += Square(partial[2][i]);
	cost[6] += Square(partial[6][i]);
	}
	cost[2] *= kDivisionTable[7];
	cost[6] *= kDivisionTable[7];
	for (int i = 0; i < 7; ++i) {
	cost[0] += (Square(partial[0][i]) + Square(partial[0][14 - i])) *
	kDivisionTable[i];
	cost[4] += (Square(partial[4][i]) + Square(partial[4][14 - i])) *
	kDivisionTable[i];
	}
	cost[0] += Square(partial[0][7]) * kDivisionTable[7];
	cost[4] += Square(partial[4][7]) * kDivisionTable[7];
	for (int i = 1; i < 8; i += 2) {
	for (int j = 0; j < 5; ++j) {
	cost[i] += Square(partial[i][3 + j]);
	}
	cost[i] *= kDivisionTable[7];
	for (int j = 0; j < 3; ++j) {
	cost[i] += (Square(partial[i][j]) + Square(partial[i][10 - j])) *
	kDivisionTable[2 * j + 1];
	}
	}
	int32_t best_cost = 0;
	*direction = 0;
	for (int i = 0; i < 8; ++i) {
	if (cost[i] > best_cost) {
	best_cost = cost[i];
	*direction = i;
	}
	}
	variance = (best_cost - cost[(direction + 4) & 7]) >> 10;
	}
	#endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS \|\|
	// !defined(LIBGAV1_Dsp8bpp_CdefDirection) \|\|
	// (LIBGAV1_MAX_BITDEPTH >= 10 &&
	// !defined(LIBGAV1_Dsp10bpp_CdefDirection))

	// Silence unused function warnings when CdefFilter_C is obviated.
	#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS \|\| \
	!defined(LIBGAV1_Dsp8bpp_CdefFilters) \|\| \
	(LIBGAV1_MAX_BITDEPTH >= 10 && !defined(LIBGAV1_Dsp10bpp_CdefFilters))

	int Constrain(int diff, int threshold, int damping) {
	assert(threshold != 0);
	damping = std::max(0, damping - FloorLog2(threshold));
	const int sign = (diff < 0) ? -1 : 1;
	return sign *
	Clip3(threshold - (std::abs(diff) >> damping), 0, std::abs(diff));
	}

	// Filters the source block. It doesn't check whether the candidate pixel is
	// inside the frame. However it requires the source input to be padded with a
	// constant large value (kCdefLargeValue) if at the boundary.
	template <int block_width, int bitdepth, typename Pixel,
	bool enable_primary = true, bool enable_secondary = true>
	void CdefFilter_C(const uint16_t* src, const ptrdiff_t src_stride,
	const int block_height, const int primary_strength,
	const int secondary_strength, const int damping,
	const int direction, void* const dest,
	const ptrdiff_t dest_stride) {
	static_assert(block_width == 4 \|\| block_width == 8, "Invalid CDEF width.");
	static_assert(enable_primary \|\| enable_secondary, "");
	assert(block_height == 4 \|\| block_height == 8);
	assert(direction >= 0 && direction <= 7);
	constexpr int coeff_shift = bitdepth - 8;
	// Section 5.9.19. CDEF params syntax.
	assert(primary_strength >= 0 && primary_strength <= 15 << coeff_shift);
	assert(secondary_strength >= 0 && secondary_strength <= 4 << coeff_shift &&
	secondary_strength != 3 << coeff_shift);
	assert(primary_strength != 0 \|\| secondary_strength != 0);
	// damping is decreased by 1 for chroma.
	assert((damping >= 3 && damping <= 6 + coeff_shift) \|\|
	(damping >= 2 && damping <= 5 + coeff_shift));
	// When only primary_strength or secondary_strength are non-zero the number
	// of pixels inspected (4 for primary_strength, 8 for secondary_strength) and
	// the taps used don't exceed the amount the sum is
	// descaled by (16) so we can skip tracking and clipping to the minimum and
	// maximum value observed.
	constexpr bool clipping_required = enable_primary && enable_secondary;
	static constexpr int kCdefSecondaryTaps[2] = {kCdefSecondaryTap0,
	kCdefSecondaryTap1};
	auto* dst = static_cast<Pixel*>(dest);
	const ptrdiff_t dst_stride = dest_stride / sizeof(Pixel);
	int y = block_height;
	do {
	int x = 0;
	do {
	int16_t sum = 0;
	const uint16_t pixel_value = src[x];
	uint16_t max_value = pixel_value;
	uint16_t min_value = pixel_value;
	for (int k = 0; k < 2; ++k) {
	static constexpr int signs[] = {-1, 1};
	for (const int& sign : signs) {
	if (enable_primary) {
	const int dy = sign * kCdefDirections[direction][k][0];
	const int dx = sign * kCdefDirections[direction][k][1];
	const uint16_t value = src[dy * src_stride + dx + x];
	// Note: the summation can ignore the condition check in SIMD
	// implementation, because Constrain() will return 0 when
	// value == kCdefLargeValue.
	if (value != kCdefLargeValue) {
	sum += Constrain(value - pixel_value, primary_strength, damping) *
	kCdefPrimaryTaps[(primary_strength >> coeff_shift) & 1][k];
	if (clipping_required) {
	max_value = std::max(value, max_value);
	min_value = std::min(value, min_value);
	}
	}
	}

	if (enable_secondary) {
	static constexpr int offsets[] = {-2, 2};
	for (const int& offset : offsets) {
	const int dy = sign * kCdefDirections[direction + offset][k][0];
	const int dx = sign * kCdefDirections[direction + offset][k][1];
	const uint16_t value = src[dy * src_stride + dx + x];
	// Note: the summation can ignore the condition check in SIMD
	// implementation.
	if (value != kCdefLargeValue) {
	sum += Constrain(value - pixel_value, secondary_strength,
	damping) *
	kCdefSecondaryTaps[k];
	if (clipping_required) {
	max_value = std::max(value, max_value);
	min_value = std::min(value, min_value);
	}
	}
	}
	}
	}
	}

	const int offset = (8 + sum - (sum < 0)) >> 4;
	if (clipping_required) {
	dst[x] = static_cast<Pixel>(
	Clip3(pixel_value + offset, min_value, max_value));
	} else {
	dst[x] = static_cast<Pixel>(pixel_value + offset);
	}
	} while (++x < block_width);

	src += src_stride;
	dst += dst_stride;
	} while (--y != 0);
	}
	#endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS \|\|
	// !defined(LIBGAV1_Dsp8bpp_CdefFilters) \|\|
	// (LIBGAV1_MAX_BITDEPTH >= 10 &&
	// !defined(LIBGAV1_Dsp10bpp_CdefFilters))

	void Init8bpp() {
	Dsp* const dsp = dsp_internal::GetWritableDspTable(8);
	assert(dsp != nullptr);
	#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
	dsp->cdef_direction = CdefDirection_C<8, uint8_t>;
	dsp->cdef_filters[0][0] = CdefFilter_C<4, 8, uint8_t>;
	dsp->cdef_filters[0][1] = CdefFilter_C<4, 8, uint8_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[0][2] =
	CdefFilter_C<4, 8, uint8_t, /enable_primary=/false>;
	dsp->cdef_filters[1][0] = CdefFilter_C<8, 8, uint8_t>;
	dsp->cdef_filters[1][1] = CdefFilter_C<8, 8, uint8_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[1][2] =
	CdefFilter_C<8, 8, uint8_t, /enable_primary=/false>;
	#else // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
	static_cast<void>(dsp);
	#ifndef LIBGAV1_Dsp8bpp_CdefDirection
	dsp->cdef_direction = CdefDirection_C<8, uint8_t>;
	#endif
	#ifndef LIBGAV1_Dsp8bpp_CdefFilters
	dsp->cdef_filters[0][0] = CdefFilter_C<4, 8, uint8_t>;
	dsp->cdef_filters[0][1] = CdefFilter_C<4, 8, uint8_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[0][2] =
	CdefFilter_C<4, 8, uint8_t, /enable_primary=/false>;
	dsp->cdef_filters[1][0] = CdefFilter_C<8, 8, uint8_t>;
	dsp->cdef_filters[1][1] = CdefFilter_C<8, 8, uint8_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[1][2] =
	CdefFilter_C<8, 8, uint8_t, /enable_primary=/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);
	#if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
	dsp->cdef_direction = CdefDirection_C<10, uint16_t>;
	dsp->cdef_filters[0][0] = CdefFilter_C<4, 10, uint16_t>;
	dsp->cdef_filters[0][1] =
	CdefFilter_C<4, 10, uint16_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[0][2] =
	CdefFilter_C<4, 10, uint16_t, /enable_primary=/false>;
	dsp->cdef_filters[1][0] = CdefFilter_C<8, 10, uint16_t>;
	dsp->cdef_filters[1][1] =
	CdefFilter_C<8, 10, uint16_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[1][2] =
	CdefFilter_C<8, 10, uint16_t, /enable_primary=/false>;
	#else // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
	static_cast<void>(dsp);
	#ifndef LIBGAV1_Dsp10bpp_CdefDirection
	dsp->cdef_direction = CdefDirection_C<10, uint16_t>;
	#endif
	#ifndef LIBGAV1_Dsp10bpp_CdefFilters
	dsp->cdef_filters[0][0] = CdefFilter_C<4, 10, uint16_t>;
	dsp->cdef_filters[0][1] =
	CdefFilter_C<4, 10, uint16_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[0][2] =
	CdefFilter_C<4, 10, uint16_t, /enable_primary=/false>;
	dsp->cdef_filters[1][0] = CdefFilter_C<8, 10, uint16_t>;
	dsp->cdef_filters[1][1] =
	CdefFilter_C<8, 10, uint16_t, /enable_primary=/true,
	/enable_secondary=/false>;
	dsp->cdef_filters[1][2] =
	CdefFilter_C<8, 10, uint16_t, /enable_primary=/false>;
	#endif
	#endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS
	}
	#endif

	} // namespace

	void CdefInit_C() {
	Init8bpp();
	#if LIBGAV1_MAX_BITDEPTH >= 10
	Init10bpp();
	#endif
	}

	} // namespace dsp
	} // namespace libgav1