| // 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/intrapred.h" |
| |
| #include <algorithm> |
| #include <cassert> |
| #include <cstddef> |
| #include <cstdint> |
| #include <cstdlib> |
| #include <cstring> // memset |
| |
| #include "src/dsp/constants.h" |
| #include "src/dsp/dsp.h" |
| #include "src/utils/common.h" |
| #include "src/utils/memory.h" |
| |
| namespace libgav1 { |
| namespace dsp { |
| namespace { |
| |
| constexpr TransformSize kTransformSizesLargerThan32x32[] = { |
| kTransformSize16x64, kTransformSize32x64, kTransformSize64x16, |
| kTransformSize64x32, kTransformSize64x64}; |
| |
| template <int block_width, int block_height, typename Pixel> |
| struct IntraPredFuncs_C { |
| IntraPredFuncs_C() = delete; |
| |
| static void DcTop(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void DcLeft(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void Dc(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void Vertical(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void Horizontal(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void Paeth(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void Smooth(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void SmoothVertical(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| static void SmoothHorizontal(void* dest, ptrdiff_t stride, |
| const void* top_row, const void* left_column); |
| }; |
| |
| // Intra-predictors that require bitdepth. |
| template <int block_width, int block_height, int bitdepth, typename Pixel> |
| struct IntraPredBppFuncs_C { |
| IntraPredBppFuncs_C() = delete; |
| |
| static void DcFill(void* dest, ptrdiff_t stride, const void* top_row, |
| const void* left_column); |
| }; |
| |
| //------------------------------------------------------------------------------ |
| // IntraPredFuncs_C::DcPred |
| |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::DcTop( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* /*left_column*/) { |
| int sum = block_width >> 1; // rounder |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| for (int x = 0; x < block_width; ++x) sum += top[x]; |
| const int dc = sum >> FloorLog2(block_width); |
| |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| for (int y = 0; y < block_height; ++y) { |
| Memset(dst, dc, block_width); |
| dst += stride; |
| } |
| } |
| |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::DcLeft( |
| void* const dest, ptrdiff_t stride, const void* /*top_row*/, |
| const void* const left_column) { |
| int sum = block_height >> 1; // rounder |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| for (int y = 0; y < block_height; ++y) sum += left[y]; |
| const int dc = sum >> FloorLog2(block_height); |
| |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| for (int y = 0; y < block_height; ++y) { |
| Memset(dst, dc, block_width); |
| dst += stride; |
| } |
| } |
| |
| // Note for square blocks the divide in the Dc() function reduces to a shift. |
| // For rectangular block sizes the following multipliers can be used with the |
| // corresponding shifts. |
| // 8-bit |
| // 1:2 (e.g,, 4x8): scale = 0x5556 |
| // 1:4 (e.g., 4x16): scale = 0x3334 |
| // final_descale = 16 |
| // 10/12-bit |
| // 1:2: scale = 0xaaab |
| // 1:4: scale = 0x6667 |
| // final_descale = 17 |
| // Note these may be halved to the values used in 8-bit in all cases except |
| // when bitdepth == 12 and block_width + block_height is divisible by 5 (as |
| // opposed to 3). |
| // |
| // The calculation becomes: |
| // (dc_sum >> intermediate_descale) * scale) >> final_descale |
| // where intermediate_descale is: |
| // sum = block_width + block_height |
| // intermediate_descale = |
| // (sum <= 20) ? 2 : (sum <= 40) ? 3 : (sum <= 80) ? 4 : 5 |
| // |
| // The constants (multiplier and shifts) for a given block size are obtained |
| // as follows: |
| // - Let sum = block width + block height |
| // - Shift 'sum' right until we reach an odd number |
| // - Let the number of shifts for that block size be called 'intermediate_scale' |
| // and let the odd number be 'd' (d has only 2 possible values: d = 3 for a |
| // 1:2 rectangular block and d = 5 for a 1:4 rectangular block). |
| // - Find multipliers by dividing by 'd' using "Algorithm 1" in: |
| // http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1467632 |
| // by ensuring that m + n = 16 (in that algorithm). This ensures that our 2nd |
| // shift will be 16, regardless of the block size. |
| // TODO(jzern): the base implementation could be updated to use this method. |
| |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::Dc( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* const left_column) { |
| const int divisor = block_width + block_height; |
| int sum = divisor >> 1; // rounder |
| |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| for (int x = 0; x < block_width; ++x) sum += top[x]; |
| for (int y = 0; y < block_height; ++y) sum += left[y]; |
| |
| const int dc = sum / divisor; |
| |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| for (int y = 0; y < block_height; ++y) { |
| Memset(dst, dc, block_width); |
| dst += stride; |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| // IntraPredFuncs_C directional predictors |
| |
| // IntraPredFuncs_C::Vertical -- apply top row vertically |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::Vertical( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* /*left_column*/) { |
| auto* dst = static_cast<uint8_t*>(dest); |
| for (int y = 0; y < block_height; ++y) { |
| memcpy(dst, top_row, block_width * sizeof(Pixel)); |
| dst += stride; |
| } |
| } |
| |
| // IntraPredFuncs_C::Horizontal -- apply left column horizontally |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::Horizontal( |
| void* const dest, ptrdiff_t stride, const void* /*top_row*/, |
| const void* const left_column) { |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| for (int y = 0; y < block_height; ++y) { |
| Memset(dst, left[y], block_width); |
| dst += stride; |
| } |
| } |
| |
| template <typename Pixel> |
| inline Pixel Average(Pixel a, Pixel b) { |
| return static_cast<Pixel>((a + b + 1) >> 1); |
| } |
| |
| template <typename Pixel> |
| inline Pixel Average(Pixel a, Pixel b, Pixel c) { |
| return static_cast<Pixel>((a + 2 * b + c + 2) >> 2); |
| } |
| |
| // IntraPredFuncs_C::Paeth |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::Paeth( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* const left_column) { |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| const Pixel top_left = top[-1]; |
| const int top_left_x2 = top_left + top_left; |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| |
| for (int y = 0; y < block_height; ++y) { |
| const int left_pixel = left[y]; |
| for (int x = 0; x < block_width; ++x) { |
| // The Paeth filter selects the value closest to: |
| // top[x] + left[y] - top_left |
| // To calculate the absolute distance for the left value this would be: |
| // abs((top[x] + left[y] - top_left) - left[y]) |
| // or, because left[y] cancels out: |
| // abs(top[x] - top_left) |
| const int left_dist = std::abs(top[x] - top_left); |
| const int top_dist = std::abs(left_pixel - top_left); |
| const int top_left_dist = std::abs(top[x] + left_pixel - top_left_x2); |
| |
| // Select the closest value to the initial estimate of 'T + L - TL'. |
| if (left_dist <= top_dist && left_dist <= top_left_dist) { |
| dst[x] = left_pixel; |
| } else if (top_dist <= top_left_dist) { |
| dst[x] = top[x]; |
| } else { |
| dst[x] = top_left; |
| } |
| } |
| dst += stride; |
| } |
| } |
| |
| constexpr uint8_t kSmoothWeights[] = { |
| // block dimension = 4 |
| 255, 149, 85, 64, |
| // block dimension = 8 |
| 255, 197, 146, 105, 73, 50, 37, 32, |
| // block dimension = 16 |
| 255, 225, 196, 170, 145, 123, 102, 84, 68, 54, 43, 33, 26, 20, 17, 16, |
| // block dimension = 32 |
| 255, 240, 225, 210, 196, 182, 169, 157, 145, 133, 122, 111, 101, 92, 83, 74, |
| 66, 59, 52, 45, 39, 34, 29, 25, 21, 17, 14, 12, 10, 9, 8, 8, |
| // block dimension = 64 |
| 255, 248, 240, 233, 225, 218, 210, 203, 196, 189, 182, 176, 169, 163, 156, |
| 150, 144, 138, 133, 127, 121, 116, 111, 106, 101, 96, 91, 86, 82, 77, 73, |
| 69, 65, 61, 57, 54, 50, 47, 44, 41, 38, 35, 32, 29, 27, 25, 22, 20, 18, 16, |
| 15, 13, 12, 10, 9, 8, 7, 6, 6, 5, 5, 4, 4, 4}; |
| |
| // IntraPredFuncs_C::Smooth |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::Smooth( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* const left_column) { |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| const Pixel top_right = top[block_width - 1]; |
| const Pixel bottom_left = left[block_height - 1]; |
| static_assert( |
| block_width >= 4 && block_height >= 4, |
| "Weights for smooth predictor undefined for block width/height < 4"); |
| const uint8_t* const weights_x = kSmoothWeights + block_width - 4; |
| const uint8_t* const weights_y = kSmoothWeights + block_height - 4; |
| const uint16_t scale_value = (1 << kSmoothWeightScale); |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| |
| for (int y = 0; y < block_height; ++y) { |
| for (int x = 0; x < block_width; ++x) { |
| assert(scale_value >= weights_y[y] && scale_value >= weights_x[x]); |
| uint32_t pred = weights_y[y] * top[x]; |
| pred += weights_x[x] * left[y]; |
| pred += static_cast<uint8_t>(scale_value - weights_y[y]) * bottom_left; |
| pred += static_cast<uint8_t>(scale_value - weights_x[x]) * top_right; |
| // The maximum value of pred with the rounder is 2^9 * (2^bitdepth - 1) |
| // + 256. With the descale there's no need for saturation. |
| dst[x] = static_cast<Pixel>( |
| RightShiftWithRounding(pred, kSmoothWeightScale + 1)); |
| } |
| dst += stride; |
| } |
| } |
| |
| // IntraPredFuncs_C::SmoothVertical |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::SmoothVertical( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* const left_column) { |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| const Pixel bottom_left = left[block_height - 1]; |
| static_assert(block_height >= 4, |
| "Weights for smooth predictor undefined for block height < 4"); |
| const uint8_t* const weights_y = kSmoothWeights + block_height - 4; |
| const uint16_t scale_value = (1 << kSmoothWeightScale); |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| |
| for (int y = 0; y < block_height; ++y) { |
| for (int x = 0; x < block_width; ++x) { |
| assert(scale_value >= weights_y[y]); |
| uint32_t pred = weights_y[y] * top[x]; |
| pred += static_cast<uint8_t>(scale_value - weights_y[y]) * bottom_left; |
| dst[x] = |
| static_cast<Pixel>(RightShiftWithRounding(pred, kSmoothWeightScale)); |
| } |
| dst += stride; |
| } |
| } |
| |
| // IntraPredFuncs_C::SmoothHorizontal |
| template <int block_width, int block_height, typename Pixel> |
| void IntraPredFuncs_C<block_width, block_height, Pixel>::SmoothHorizontal( |
| void* const dest, ptrdiff_t stride, const void* const top_row, |
| const void* const left_column) { |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| const Pixel top_right = top[block_width - 1]; |
| static_assert(block_width >= 4, |
| "Weights for smooth predictor undefined for block width < 4"); |
| const uint8_t* const weights_x = kSmoothWeights + block_width - 4; |
| const uint16_t scale_value = (1 << kSmoothWeightScale); |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| |
| for (int y = 0; y < block_height; ++y) { |
| for (int x = 0; x < block_width; ++x) { |
| assert(scale_value >= weights_x[x]); |
| uint32_t pred = weights_x[x] * left[y]; |
| pred += static_cast<uint8_t>(scale_value - weights_x[x]) * top_right; |
| dst[x] = |
| static_cast<Pixel>(RightShiftWithRounding(pred, kSmoothWeightScale)); |
| } |
| dst += stride; |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| // IntraPredBppFuncs_C |
| template <int fill, typename Pixel> |
| inline void DcFill_C(void* const dest, ptrdiff_t stride, const int block_width, |
| const int block_height) { |
| static_assert(sizeof(Pixel) == 1 || sizeof(Pixel) == 2, |
| "Only 1 & 2 byte pixels are supported"); |
| |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| for (int y = 0; y < block_height; ++y) { |
| Memset(dst, fill, block_width); |
| dst += stride; |
| } |
| } |
| |
| template <int block_width, int block_height, int bitdepth, typename Pixel> |
| void IntraPredBppFuncs_C<block_width, block_height, bitdepth, Pixel>::DcFill( |
| void* const dest, ptrdiff_t stride, const void* /*top_row*/, |
| const void* /*left_column*/) { |
| DcFill_C<0x80 << (bitdepth - 8), Pixel>(dest, stride, block_width, |
| block_height); |
| } |
| |
| //------------------------------------------------------------------------------ |
| // FilterIntraPredictor_C |
| |
| template <int bitdepth, typename Pixel> |
| void FilterIntraPredictor_C(void* const dest, ptrdiff_t stride, |
| const void* const top_row, |
| const void* const left_column, |
| const FilterIntraPredictor pred, const int width, |
| const int height) { |
| const int kMaxPixel = (1 << bitdepth) - 1; |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| |
| assert(width <= 32 && height <= 32); |
| |
| Pixel buffer[3][33]; // cache 2 rows + top & left boundaries |
| memcpy(buffer[0], &top[-1], (width + 1) * sizeof(top[0])); |
| |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| int row0 = 0, row2 = 2; |
| int ystep = 1; |
| int y = 0; |
| do { |
| buffer[1][0] = left[y]; |
| buffer[row2][0] = left[y + 1]; |
| int x = 1; |
| do { |
| const Pixel p0 = buffer[row0][x - 1]; // top-left |
| const Pixel p1 = buffer[row0][x + 0]; // top 0 |
| const Pixel p2 = buffer[row0][x + 1]; // top 1 |
| const Pixel p3 = buffer[row0][x + 2]; // top 2 |
| const Pixel p4 = buffer[row0][x + 3]; // top 3 |
| const Pixel p5 = buffer[1][x - 1]; // left 0 |
| const Pixel p6 = buffer[row2][x - 1]; // left 1 |
| for (int i = 0; i < 8; ++i) { |
| const int xoffset = i & 0x03; |
| const int yoffset = (i >> 2) * ystep; |
| const int value = kFilterIntraTaps[pred][i][0] * p0 + |
| kFilterIntraTaps[pred][i][1] * p1 + |
| kFilterIntraTaps[pred][i][2] * p2 + |
| kFilterIntraTaps[pred][i][3] * p3 + |
| kFilterIntraTaps[pred][i][4] * p4 + |
| kFilterIntraTaps[pred][i][5] * p5 + |
| kFilterIntraTaps[pred][i][6] * p6; |
| buffer[1 + yoffset][x + xoffset] = static_cast<Pixel>( |
| Clip3(RightShiftWithRounding(value, 4), 0, kMaxPixel)); |
| } |
| x += 4; |
| } while (x < width); |
| memcpy(dst, &buffer[1][1], width * sizeof(dst[0])); |
| dst += stride; |
| memcpy(dst, &buffer[row2][1], width * sizeof(dst[0])); |
| dst += stride; |
| |
| // The final row becomes the top for the next pass. |
| row0 ^= 2; |
| row2 ^= 2; |
| ystep = -ystep; |
| y += 2; |
| } while (y < height); |
| } |
| |
| //------------------------------------------------------------------------------ |
| // CflIntraPredictor_C |
| |
| // |luma| can be within +/-(((1 << bitdepth) - 1) << 3), inclusive. |
| // |alpha| can be -16 to 16 (inclusive). |
| template <int block_width, int block_height, int bitdepth, typename Pixel> |
| void CflIntraPredictor_C( |
| void* const dest, ptrdiff_t stride, |
| const int16_t luma[kCflLumaBufferStride][kCflLumaBufferStride], |
| const int alpha) { |
| auto* dst = static_cast<Pixel*>(dest); |
| const int dc = dst[0]; |
| stride /= sizeof(Pixel); |
| const int max_value = (1 << bitdepth) - 1; |
| for (int y = 0; y < block_height; ++y) { |
| for (int x = 0; x < block_width; ++x) { |
| assert(luma[y][x] >= -(((1 << bitdepth) - 1) << 3)); |
| assert(luma[y][x] <= ((1 << bitdepth) - 1) << 3); |
| dst[x] = Clip3(dc + RightShiftWithRoundingSigned(alpha * luma[y][x], 6), |
| 0, max_value); |
| } |
| dst += stride; |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| // CflSubsampler_C |
| |
| template <int block_width, int block_height, int bitdepth, typename Pixel, |
| int subsampling_x, int subsampling_y> |
| void CflSubsampler_C(int16_t luma[kCflLumaBufferStride][kCflLumaBufferStride], |
| const int max_luma_width, const int max_luma_height, |
| const void* const source, ptrdiff_t stride) { |
| assert(max_luma_width >= 4); |
| assert(max_luma_height >= 4); |
| const auto* src = static_cast<const Pixel*>(source); |
| stride /= sizeof(Pixel); |
| int sum = 0; |
| for (int y = 0; y < block_height; ++y) { |
| for (int x = 0; x < block_width; ++x) { |
| const ptrdiff_t luma_x = |
| std::min(x << subsampling_x, max_luma_width - (1 << subsampling_x)); |
| const ptrdiff_t luma_x_next = luma_x + stride; |
| luma[y][x] = |
| (src[luma_x] + ((subsampling_x != 0) ? src[luma_x + 1] : 0) + |
| ((subsampling_y != 0) ? (src[luma_x_next] + src[luma_x_next + 1]) |
| : 0)) |
| << (3 - subsampling_x - subsampling_y); |
| sum += luma[y][x]; |
| } |
| if ((y << subsampling_y) < (max_luma_height - (1 << subsampling_y))) { |
| src += stride << subsampling_y; |
| } |
| } |
| const int average = RightShiftWithRounding( |
| sum, FloorLog2(block_width) + FloorLog2(block_height)); |
| for (int y = 0; y < block_height; ++y) { |
| for (int x = 0; x < block_width; ++x) { |
| luma[y][x] -= average; |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| // 7.11.2.4. Directional intra prediction process |
| |
| template <typename Pixel> |
| void DirectionalIntraPredictorZone1_C(void* const dest, ptrdiff_t stride, |
| const void* const top_row, |
| const int width, const int height, |
| const int xstep, |
| const bool upsampled_top) { |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| |
| assert(xstep > 0); |
| |
| // If xstep == 64 then |shift| always evaluates to 0 which sets |val| to |
| // |top[top_base_x]|. This corresponds to a 45 degree prediction. |
| if (xstep == 64) { |
| // 7.11.2.10. Intra edge upsample selection process |
| // if ( d <= 0 || d >= 40 ) useUpsample = 0 |
| // For |upsampled_top| the delta is |predictor_angle - 90|. Since the |
| // |predictor_angle| is 45 the delta is also 45. |
| assert(!upsampled_top); |
| const Pixel* top_ptr = top + 1; |
| for (int y = 0; y < height; ++y, dst += stride, ++top_ptr) { |
| memcpy(dst, top_ptr, sizeof(*top_ptr) * width); |
| } |
| return; |
| } |
| |
| const int upsample_shift = static_cast<int>(upsampled_top); |
| const int max_base_x = ((width + height) - 1) << upsample_shift; |
| const int scale_bits = 6 - upsample_shift; |
| const int base_step = 1 << upsample_shift; |
| int top_x = xstep; |
| int y = 0; |
| do { |
| int top_base_x = top_x >> scale_bits; |
| |
| if (top_base_x >= max_base_x) { |
| for (int i = y; i < height; ++i) { |
| Memset(dst, top[max_base_x], width); |
| dst += stride; |
| } |
| return; |
| } |
| |
| const int shift = ((top_x << upsample_shift) & 0x3F) >> 1; |
| int x = 0; |
| do { |
| if (top_base_x >= max_base_x) { |
| Memset(dst + x, top[max_base_x], width - x); |
| break; |
| } |
| |
| const int val = |
| top[top_base_x] * (32 - shift) + top[top_base_x + 1] * shift; |
| dst[x] = RightShiftWithRounding(val, 5); |
| top_base_x += base_step; |
| } while (++x < width); |
| |
| dst += stride; |
| top_x += xstep; |
| } while (++y < height); |
| } |
| |
| template <typename Pixel> |
| void DirectionalIntraPredictorZone2_C(void* const dest, ptrdiff_t stride, |
| const void* const top_row, |
| const void* const left_column, |
| const int width, const int height, |
| const int xstep, const int ystep, |
| const bool upsampled_top, |
| const bool upsampled_left) { |
| const auto* const top = static_cast<const Pixel*>(top_row); |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| auto* dst = static_cast<Pixel*>(dest); |
| stride /= sizeof(Pixel); |
| |
| assert(xstep > 0); |
| assert(ystep > 0); |
| |
| const int upsample_top_shift = static_cast<int>(upsampled_top); |
| const int upsample_left_shift = static_cast<int>(upsampled_left); |
| const int scale_bits_x = 6 - upsample_top_shift; |
| const int scale_bits_y = 6 - upsample_left_shift; |
| const int min_base_x = -(1 << upsample_top_shift); |
| const int base_step_x = 1 << upsample_top_shift; |
| int y = 0; |
| int top_x = -xstep; |
| do { |
| int top_base_x = top_x >> scale_bits_x; |
| int left_y = (y << 6) - ystep; |
| int x = 0; |
| do { |
| int val; |
| if (top_base_x >= min_base_x) { |
| const int shift = ((top_x * (1 << upsample_top_shift)) & 0x3F) >> 1; |
| val = top[top_base_x] * (32 - shift) + top[top_base_x + 1] * shift; |
| } else { |
| // Note this assumes an arithmetic shift to handle negative values. |
| const int left_base_y = left_y >> scale_bits_y; |
| const int shift = ((left_y * (1 << upsample_left_shift)) & 0x3F) >> 1; |
| assert(left_base_y >= -(1 << upsample_left_shift)); |
| val = left[left_base_y] * (32 - shift) + left[left_base_y + 1] * shift; |
| } |
| dst[x] = RightShiftWithRounding(val, 5); |
| top_base_x += base_step_x; |
| left_y -= ystep; |
| } while (++x < width); |
| |
| top_x -= xstep; |
| dst += stride; |
| } while (++y < height); |
| } |
| |
| template <typename Pixel> |
| void DirectionalIntraPredictorZone3_C(void* const dest, ptrdiff_t stride, |
| const void* const left_column, |
| const int width, const int height, |
| const int ystep, |
| const bool upsampled_left) { |
| const auto* const left = static_cast<const Pixel*>(left_column); |
| stride /= sizeof(Pixel); |
| |
| assert(ystep > 0); |
| |
| const int upsample_shift = static_cast<int>(upsampled_left); |
| const int scale_bits = 6 - upsample_shift; |
| const int base_step = 1 << upsample_shift; |
| // Zone3 never runs out of left_column values. |
| assert((width + height - 1) << upsample_shift > // max_base_y |
| ((ystep * width) >> scale_bits) + |
| base_step * (height - 1)); // left_base_y |
| |
| int left_y = ystep; |
| int x = 0; |
| do { |
| auto* dst = static_cast<Pixel*>(dest); |
| |
| int left_base_y = left_y >> scale_bits; |
| int y = 0; |
| do { |
| const int shift = ((left_y << upsample_shift) & 0x3F) >> 1; |
| const int val = |
| left[left_base_y] * (32 - shift) + left[left_base_y + 1] * shift; |
| dst[x] = RightShiftWithRounding(val, 5); |
| dst += stride; |
| left_base_y += base_step; |
| } while (++y < height); |
| |
| left_y += ystep; |
| } while (++x < width); |
| } |
| |
| //------------------------------------------------------------------------------ |
| |
| template <typename Pixel> |
| struct IntraPredDefs { |
| IntraPredDefs() = delete; |
| |
| using _4x4 = IntraPredFuncs_C<4, 4, Pixel>; |
| using _4x8 = IntraPredFuncs_C<4, 8, Pixel>; |
| using _4x16 = IntraPredFuncs_C<4, 16, Pixel>; |
| using _8x4 = IntraPredFuncs_C<8, 4, Pixel>; |
| using _8x8 = IntraPredFuncs_C<8, 8, Pixel>; |
| using _8x16 = IntraPredFuncs_C<8, 16, Pixel>; |
| using _8x32 = IntraPredFuncs_C<8, 32, Pixel>; |
| using _16x4 = IntraPredFuncs_C<16, 4, Pixel>; |
| using _16x8 = IntraPredFuncs_C<16, 8, Pixel>; |
| using _16x16 = IntraPredFuncs_C<16, 16, Pixel>; |
| using _16x32 = IntraPredFuncs_C<16, 32, Pixel>; |
| using _16x64 = IntraPredFuncs_C<16, 64, Pixel>; |
| using _32x8 = IntraPredFuncs_C<32, 8, Pixel>; |
| using _32x16 = IntraPredFuncs_C<32, 16, Pixel>; |
| using _32x32 = IntraPredFuncs_C<32, 32, Pixel>; |
| using _32x64 = IntraPredFuncs_C<32, 64, Pixel>; |
| using _64x16 = IntraPredFuncs_C<64, 16, Pixel>; |
| using _64x32 = IntraPredFuncs_C<64, 32, Pixel>; |
| using _64x64 = IntraPredFuncs_C<64, 64, Pixel>; |
| }; |
| |
| template <int bitdepth, typename Pixel> |
| struct IntraPredBppDefs { |
| IntraPredBppDefs() = delete; |
| |
| using _4x4 = IntraPredBppFuncs_C<4, 4, bitdepth, Pixel>; |
| using _4x8 = IntraPredBppFuncs_C<4, 8, bitdepth, Pixel>; |
| using _4x16 = IntraPredBppFuncs_C<4, 16, bitdepth, Pixel>; |
| using _8x4 = IntraPredBppFuncs_C<8, 4, bitdepth, Pixel>; |
| using _8x8 = IntraPredBppFuncs_C<8, 8, bitdepth, Pixel>; |
| using _8x16 = IntraPredBppFuncs_C<8, 16, bitdepth, Pixel>; |
| using _8x32 = IntraPredBppFuncs_C<8, 32, bitdepth, Pixel>; |
| using _16x4 = IntraPredBppFuncs_C<16, 4, bitdepth, Pixel>; |
| using _16x8 = IntraPredBppFuncs_C<16, 8, bitdepth, Pixel>; |
| using _16x16 = IntraPredBppFuncs_C<16, 16, bitdepth, Pixel>; |
| using _16x32 = IntraPredBppFuncs_C<16, 32, bitdepth, Pixel>; |
| using _16x64 = IntraPredBppFuncs_C<16, 64, bitdepth, Pixel>; |
| using _32x8 = IntraPredBppFuncs_C<32, 8, bitdepth, Pixel>; |
| using _32x16 = IntraPredBppFuncs_C<32, 16, bitdepth, Pixel>; |
| using _32x32 = IntraPredBppFuncs_C<32, 32, bitdepth, Pixel>; |
| using _32x64 = IntraPredBppFuncs_C<32, 64, bitdepth, Pixel>; |
| using _64x16 = IntraPredBppFuncs_C<64, 16, bitdepth, Pixel>; |
| using _64x32 = IntraPredBppFuncs_C<64, 32, bitdepth, Pixel>; |
| using _64x64 = IntraPredBppFuncs_C<64, 64, bitdepth, Pixel>; |
| }; |
| |
| using Defs = IntraPredDefs<uint8_t>; |
| using Defs8bpp = IntraPredBppDefs<8, uint8_t>; |
| |
| // Initializes dsp entries for kTransformSize|W|x|H| from |DEFS|/|DEFSBPP| of |
| // the same size. |
| #define INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, W, H) \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorDcFill] = \ |
| DEFSBPP::_##W##x##H::DcFill; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorDcTop] = \ |
| DEFS::_##W##x##H::DcTop; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorDcLeft] = \ |
| DEFS::_##W##x##H::DcLeft; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorDc] = \ |
| DEFS::_##W##x##H::Dc; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorVertical] = \ |
| DEFS::_##W##x##H::Vertical; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorHorizontal] = \ |
| DEFS::_##W##x##H::Horizontal; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorPaeth] = \ |
| DEFS::_##W##x##H::Paeth; \ |
| dsp->intra_predictors[kTransformSize##W##x##H][kIntraPredictorSmooth] = \ |
| DEFS::_##W##x##H::Smooth; \ |
| dsp->intra_predictors[kTransformSize##W##x##H] \ |
| [kIntraPredictorSmoothVertical] = \ |
| DEFS::_##W##x##H::SmoothVertical; \ |
| dsp->intra_predictors[kTransformSize##W##x##H] \ |
| [kIntraPredictorSmoothHorizontal] = \ |
| DEFS::_##W##x##H::SmoothHorizontal |
| |
| #define INIT_INTRAPREDICTORS(DEFS, DEFSBPP) \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 4, 4); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 4, 8); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 4, 16); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 8, 4); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 8, 8); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 8, 16); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 8, 32); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 16, 4); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 16, 8); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 16, 16); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 16, 32); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 16, 64); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 32, 8); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 32, 16); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 32, 32); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 32, 64); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 64, 16); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 64, 32); \ |
| INIT_INTRAPREDICTORS_WxH(DEFS, DEFSBPP, 64, 64) |
| |
| #define INIT_CFL_INTRAPREDICTOR_WxH(W, H, BITDEPTH, PIXEL) \ |
| dsp->cfl_intra_predictors[kTransformSize##W##x##H] = \ |
| CflIntraPredictor_C<W, H, BITDEPTH, PIXEL>; \ |
| dsp->cfl_subsamplers[kTransformSize##W##x##H][kSubsamplingType444] = \ |
| CflSubsampler_C<W, H, BITDEPTH, PIXEL, 0, 0>; \ |
| dsp->cfl_subsamplers[kTransformSize##W##x##H][kSubsamplingType422] = \ |
| CflSubsampler_C<W, H, BITDEPTH, PIXEL, 1, 0>; \ |
| dsp->cfl_subsamplers[kTransformSize##W##x##H][kSubsamplingType420] = \ |
| CflSubsampler_C<W, H, BITDEPTH, PIXEL, 1, 1> |
| |
| #define INIT_CFL_INTRAPREDICTORS(BITDEPTH, PIXEL) \ |
| INIT_CFL_INTRAPREDICTOR_WxH(4, 4, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(4, 8, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(4, 16, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(8, 4, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(8, 8, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(8, 16, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(8, 32, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(16, 4, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(16, 8, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(16, 16, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(16, 32, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(32, 8, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(32, 16, BITDEPTH, PIXEL); \ |
| INIT_CFL_INTRAPREDICTOR_WxH(32, 32, BITDEPTH, PIXEL) |
| |
| void Init8bpp() { |
| Dsp* const dsp = dsp_internal::GetWritableDspTable(8); |
| assert(dsp != nullptr); |
| #if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS |
| INIT_INTRAPREDICTORS(Defs, Defs8bpp); |
| dsp->directional_intra_predictor_zone1 = |
| DirectionalIntraPredictorZone1_C<uint8_t>; |
| dsp->directional_intra_predictor_zone2 = |
| DirectionalIntraPredictorZone2_C<uint8_t>; |
| dsp->directional_intra_predictor_zone3 = |
| DirectionalIntraPredictorZone3_C<uint8_t>; |
| dsp->filter_intra_predictor = FilterIntraPredictor_C<8, uint8_t>; |
| INIT_CFL_INTRAPREDICTORS(8, uint8_t); |
| #else // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDcFill] = |
| Defs8bpp::_4x4::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDcTop] = |
| Defs::_4x4::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDcLeft] = |
| Defs::_4x4::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDc] = Defs::_4x4::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorVertical] = |
| Defs::_4x4::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorHorizontal] = |
| Defs::_4x4::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorPaeth] = |
| Defs::_4x4::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorSmooth] = |
| Defs::_4x4::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorSmoothVertical] = |
| Defs::_4x4::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorSmoothHorizontal] = |
| Defs::_4x4::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDcFill] = |
| Defs8bpp::_4x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDcTop] = |
| Defs::_4x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDcLeft] = |
| Defs::_4x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDc] = Defs::_4x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorVertical] = |
| Defs::_4x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorHorizontal] = |
| Defs::_4x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorPaeth] = |
| Defs::_4x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorSmooth] = |
| Defs::_4x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorSmoothVertical] = |
| Defs::_4x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorSmoothHorizontal] = |
| Defs::_4x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDcFill] = |
| Defs8bpp::_4x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDcTop] = |
| Defs::_4x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDcLeft] = |
| Defs::_4x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDc] = |
| Defs::_4x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorVertical] = |
| Defs::_4x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorHorizontal] = |
| Defs::_4x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorPaeth] = |
| Defs::_4x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorSmooth] = |
| Defs::_4x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorSmoothVertical] = |
| Defs::_4x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorSmoothHorizontal] = |
| Defs::_4x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDcFill] = |
| Defs8bpp::_8x4::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDcTop] = |
| Defs::_8x4::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDcLeft] = |
| Defs::_8x4::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDc] = Defs::_8x4::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorVertical] = |
| Defs::_8x4::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorHorizontal] = |
| Defs::_8x4::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorPaeth] = |
| Defs::_8x4::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorSmooth] = |
| Defs::_8x4::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorSmoothVertical] = |
| Defs::_8x4::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorSmoothHorizontal] = |
| Defs::_8x4::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDcFill] = |
| Defs8bpp::_8x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDcTop] = |
| Defs::_8x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDcLeft] = |
| Defs::_8x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDc] = Defs::_8x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorVertical] = |
| Defs::_8x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorHorizontal] = |
| Defs::_8x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorPaeth] = |
| Defs::_8x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorSmooth] = |
| Defs::_8x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorSmoothVertical] = |
| Defs::_8x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorSmoothHorizontal] = |
| Defs::_8x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDcFill] = |
| Defs8bpp::_8x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDcTop] = |
| Defs::_8x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDcLeft] = |
| Defs::_8x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDc] = |
| Defs::_8x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorVertical] = |
| Defs::_8x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorHorizontal] = |
| Defs::_8x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorPaeth] = |
| Defs::_8x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorSmooth] = |
| Defs::_8x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorSmoothVertical] = |
| Defs::_8x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorSmoothHorizontal] = |
| Defs::_8x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDcFill] = |
| Defs8bpp::_8x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDcTop] = |
| Defs::_8x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDcLeft] = |
| Defs::_8x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDc] = |
| Defs::_8x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorVertical] = |
| Defs::_8x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorHorizontal] = |
| Defs::_8x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorPaeth] = |
| Defs::_8x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorSmooth] = |
| Defs::_8x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorSmoothVertical] = |
| Defs::_8x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorSmoothHorizontal] = |
| Defs::_8x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDcFill] = |
| Defs8bpp::_16x4::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDcTop] = |
| Defs::_16x4::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDcLeft] = |
| Defs::_16x4::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDc] = |
| Defs::_16x4::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorVertical] = |
| Defs::_16x4::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorHorizontal] = |
| Defs::_16x4::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorPaeth] = |
| Defs::_16x4::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorSmooth] = |
| Defs::_16x4::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorSmoothVertical] = |
| Defs::_16x4::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorSmoothHorizontal] = |
| Defs::_16x4::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDcFill] = |
| Defs8bpp::_16x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDcTop] = |
| Defs::_16x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDcLeft] = |
| Defs::_16x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDc] = |
| Defs::_16x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorVertical] = |
| Defs::_16x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorHorizontal] = |
| Defs::_16x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorPaeth] = |
| Defs::_16x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorSmooth] = |
| Defs::_16x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorSmoothVertical] = |
| Defs::_16x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorSmoothHorizontal] = |
| Defs::_16x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDcFill] = |
| Defs8bpp::_16x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDcTop] = |
| Defs::_16x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDcLeft] = |
| Defs::_16x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDc] = |
| Defs::_16x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorVertical] = |
| Defs::_16x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorHorizontal] = |
| Defs::_16x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorPaeth] = |
| Defs::_16x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorSmooth] = |
| Defs::_16x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorSmoothVertical] = |
| Defs::_16x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorSmoothHorizontal] = |
| Defs::_16x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDcFill] = |
| Defs8bpp::_16x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDcTop] = |
| Defs::_16x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDcLeft] = |
| Defs::_16x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDc] = |
| Defs::_16x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorVertical] = |
| Defs::_16x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorHorizontal] = |
| Defs::_16x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorPaeth] = |
| Defs::_16x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorSmooth] = |
| Defs::_16x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorSmoothVertical] = |
| Defs::_16x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorSmoothHorizontal] = |
| Defs::_16x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDcFill] = |
| Defs8bpp::_16x64::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDcTop] = |
| Defs::_16x64::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDcLeft] = |
| Defs::_16x64::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDc] = |
| Defs::_16x64::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorVertical] = |
| Defs::_16x64::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorHorizontal] = |
| Defs::_16x64::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorPaeth] = |
| Defs::_16x64::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorSmooth] = |
| Defs::_16x64::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorSmoothVertical] = |
| Defs::_16x64::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x64_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorSmoothHorizontal] = |
| Defs::_16x64::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDcFill] = |
| Defs8bpp::_32x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDcTop] = |
| Defs::_32x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDcLeft] = |
| Defs::_32x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDc] = |
| Defs::_32x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorVertical] = |
| Defs::_32x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorHorizontal] = |
| Defs::_32x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorPaeth] = |
| Defs::_32x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorSmooth] = |
| Defs::_32x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorSmoothVertical] = |
| Defs::_32x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorSmoothHorizontal] = |
| Defs::_32x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDcFill] = |
| Defs8bpp::_32x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDcTop] = |
| Defs::_32x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDcLeft] = |
| Defs::_32x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDc] = |
| Defs::_32x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorVertical] = |
| Defs::_32x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorHorizontal] = |
| Defs::_32x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorPaeth] = |
| Defs::_32x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorSmooth] = |
| Defs::_32x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorSmoothVertical] = |
| Defs::_32x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorSmoothHorizontal] = |
| Defs::_32x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDcFill] = |
| Defs8bpp::_32x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDcTop] = |
| Defs::_32x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDcLeft] = |
| Defs::_32x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDc] = |
| Defs::_32x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorVertical] = |
| Defs::_32x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorHorizontal] = |
| Defs::_32x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorPaeth] = |
| Defs::_32x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorSmooth] = |
| Defs::_32x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorSmoothVertical] = |
| Defs::_32x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorSmoothHorizontal] = |
| Defs::_32x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDcFill] = |
| Defs8bpp::_32x64::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDcTop] = |
| Defs::_32x64::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDcLeft] = |
| Defs::_32x64::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDc] = |
| Defs::_32x64::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorVertical] = |
| Defs::_32x64::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorHorizontal] = |
| Defs::_32x64::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorPaeth] = |
| Defs::_32x64::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorSmooth] = |
| Defs::_32x64::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorSmoothVertical] = |
| Defs::_32x64::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x64_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorSmoothHorizontal] = |
| Defs::_32x64::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDcFill] = |
| Defs8bpp::_64x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDcTop] = |
| Defs::_64x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDcLeft] = |
| Defs::_64x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDc] = |
| Defs::_64x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorVertical] = |
| Defs::_64x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorHorizontal] = |
| Defs::_64x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorPaeth] = |
| Defs::_64x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorSmooth] = |
| Defs::_64x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorSmoothVertical] = |
| Defs::_64x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorSmoothHorizontal] = |
| Defs::_64x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDcFill] = |
| Defs8bpp::_64x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDcTop] = |
| Defs::_64x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDcLeft] = |
| Defs::_64x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDc] = |
| Defs::_64x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorVertical] = |
| Defs::_64x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorHorizontal] = |
| Defs::_64x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorPaeth] = |
| Defs::_64x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorSmooth] = |
| Defs::_64x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorSmoothVertical] = |
| Defs::_64x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorSmoothHorizontal] = |
| Defs::_64x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDcFill] = |
| Defs8bpp::_64x64::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDcTop] = |
| Defs::_64x64::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDcLeft] = |
| Defs::_64x64::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDc] = |
| Defs::_64x64::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorVertical] = |
| Defs::_64x64::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorHorizontal] = |
| Defs::_64x64::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorPaeth] = |
| Defs::_64x64::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorSmooth] = |
| Defs::_64x64::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorSmoothVertical] = |
| Defs::_64x64::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize64x64_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorSmoothHorizontal] = |
| Defs::_64x64::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_DirectionalIntraPredictorZone1 |
| dsp->directional_intra_predictor_zone1 = |
| DirectionalIntraPredictorZone1_C<uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_DirectionalIntraPredictorZone2 |
| dsp->directional_intra_predictor_zone2 = |
| DirectionalIntraPredictorZone2_C<uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_DirectionalIntraPredictorZone3 |
| dsp->directional_intra_predictor_zone3 = |
| DirectionalIntraPredictorZone3_C<uint8_t>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_FilterIntraPredictor |
| dsp->filter_intra_predictor = FilterIntraPredictor_C<8, uint8_t>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize4x4] = |
| CflIntraPredictor_C<4, 4, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize4x4][kSubsamplingType444] = |
| CflSubsampler_C<4, 4, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize4x4][kSubsamplingType422] = |
| CflSubsampler_C<4, 4, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x4_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize4x4][kSubsamplingType420] = |
| CflSubsampler_C<4, 4, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize4x8] = |
| CflIntraPredictor_C<4, 8, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize4x8][kSubsamplingType444] = |
| CflSubsampler_C<4, 8, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize4x8][kSubsamplingType422] = |
| CflSubsampler_C<4, 8, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize4x8][kSubsamplingType420] = |
| CflSubsampler_C<4, 8, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize4x16] = |
| CflIntraPredictor_C<4, 16, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize4x16][kSubsamplingType444] = |
| CflSubsampler_C<4, 16, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize4x16][kSubsamplingType422] = |
| CflSubsampler_C<4, 16, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize4x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize4x16][kSubsamplingType420] = |
| CflSubsampler_C<4, 16, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x4] = |
| CflIntraPredictor_C<8, 4, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x4][kSubsamplingType444] = |
| CflSubsampler_C<8, 4, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x4][kSubsamplingType422] = |
| CflSubsampler_C<8, 4, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x4_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x4][kSubsamplingType420] = |
| CflSubsampler_C<8, 4, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x8] = |
| CflIntraPredictor_C<8, 8, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x8][kSubsamplingType444] = |
| CflSubsampler_C<8, 8, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x8][kSubsamplingType422] = |
| CflSubsampler_C<8, 8, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x8][kSubsamplingType420] = |
| CflSubsampler_C<8, 8, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x16] = |
| CflIntraPredictor_C<8, 16, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x16][kSubsamplingType444] = |
| CflSubsampler_C<8, 16, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x16][kSubsamplingType422] = |
| CflSubsampler_C<8, 16, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x16][kSubsamplingType420] = |
| CflSubsampler_C<8, 16, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x32] = |
| CflIntraPredictor_C<8, 32, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x32][kSubsamplingType444] = |
| CflSubsampler_C<8, 32, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x32][kSubsamplingType422] = |
| CflSubsampler_C<8, 32, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize8x32_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x32][kSubsamplingType420] = |
| CflSubsampler_C<8, 32, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x4] = |
| CflIntraPredictor_C<16, 4, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x4][kSubsamplingType444] = |
| CflSubsampler_C<16, 4, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x4][kSubsamplingType422] = |
| CflSubsampler_C<16, 4, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x4_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x4][kSubsamplingType420] = |
| CflSubsampler_C<16, 4, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x8] = |
| CflIntraPredictor_C<16, 8, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x8][kSubsamplingType444] = |
| CflSubsampler_C<16, 8, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x8][kSubsamplingType422] = |
| CflSubsampler_C<16, 8, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x8][kSubsamplingType420] = |
| CflSubsampler_C<16, 8, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x16] = |
| CflIntraPredictor_C<16, 16, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x16][kSubsamplingType444] = |
| CflSubsampler_C<16, 16, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x16][kSubsamplingType422] = |
| CflSubsampler_C<16, 16, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x16][kSubsamplingType420] = |
| CflSubsampler_C<16, 16, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x32] = |
| CflIntraPredictor_C<16, 32, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x32][kSubsamplingType444] = |
| CflSubsampler_C<16, 32, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x32][kSubsamplingType422] = |
| CflSubsampler_C<16, 32, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize16x32_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x32][kSubsamplingType420] = |
| CflSubsampler_C<16, 32, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize32x8] = |
| CflIntraPredictor_C<32, 8, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize32x8][kSubsamplingType444] = |
| CflSubsampler_C<32, 8, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize32x8][kSubsamplingType422] = |
| CflSubsampler_C<32, 8, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize32x8][kSubsamplingType420] = |
| CflSubsampler_C<32, 8, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize32x16] = |
| CflIntraPredictor_C<32, 16, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize32x16][kSubsamplingType444] = |
| CflSubsampler_C<32, 16, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize32x16][kSubsamplingType422] = |
| CflSubsampler_C<32, 16, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize32x16][kSubsamplingType420] = |
| CflSubsampler_C<32, 16, 8, uint8_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize32x32] = |
| CflIntraPredictor_C<32, 32, 8, uint8_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize32x32][kSubsamplingType444] = |
| CflSubsampler_C<32, 32, 8, uint8_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize32x32][kSubsamplingType422] = |
| CflSubsampler_C<32, 32, 8, uint8_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp8bpp_TransformSize32x32_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize32x32][kSubsamplingType420] = |
| CflSubsampler_C<32, 32, 8, uint8_t, 1, 1>; |
| #endif |
| #endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS |
| // Cfl predictors are available only for transform sizes with max(width, |
| // height) <= 32. Set all others to nullptr. |
| for (const auto i : kTransformSizesLargerThan32x32) { |
| dsp->cfl_intra_predictors[i] = nullptr; |
| for (int j = 0; j < kNumSubsamplingTypes; ++j) { |
| dsp->cfl_subsamplers[i][j] = nullptr; |
| } |
| } |
| } // NOLINT(readability/fn_size) |
| |
| #if LIBGAV1_MAX_BITDEPTH >= 10 |
| using DefsHbd = IntraPredDefs<uint16_t>; |
| using Defs10bpp = IntraPredBppDefs<10, uint16_t>; |
| |
| void Init10bpp() { |
| Dsp* const dsp = dsp_internal::GetWritableDspTable(10); |
| assert(dsp != nullptr); |
| #if LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS |
| INIT_INTRAPREDICTORS(DefsHbd, Defs10bpp); |
| dsp->directional_intra_predictor_zone1 = |
| DirectionalIntraPredictorZone1_C<uint16_t>; |
| dsp->directional_intra_predictor_zone2 = |
| DirectionalIntraPredictorZone2_C<uint16_t>; |
| dsp->directional_intra_predictor_zone3 = |
| DirectionalIntraPredictorZone3_C<uint16_t>; |
| dsp->filter_intra_predictor = FilterIntraPredictor_C<10, uint16_t>; |
| INIT_CFL_INTRAPREDICTORS(10, uint16_t); |
| #else // !LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDcFill] = |
| Defs10bpp::_4x4::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDcTop] = |
| DefsHbd::_4x4::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDcLeft] = |
| DefsHbd::_4x4::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorDc] = |
| DefsHbd::_4x4::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorVertical] = |
| DefsHbd::_4x4::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorHorizontal] = |
| DefsHbd::_4x4::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorPaeth] = |
| DefsHbd::_4x4::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorSmooth] = |
| DefsHbd::_4x4::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorSmoothVertical] = |
| DefsHbd::_4x4::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize4x4][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_4x4::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDcFill] = |
| Defs10bpp::_4x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDcTop] = |
| DefsHbd::_4x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDcLeft] = |
| DefsHbd::_4x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorDc] = |
| DefsHbd::_4x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorVertical] = |
| DefsHbd::_4x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorHorizontal] = |
| DefsHbd::_4x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorPaeth] = |
| DefsHbd::_4x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorSmooth] = |
| DefsHbd::_4x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorSmoothVertical] = |
| DefsHbd::_4x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize4x8][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_4x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDcFill] = |
| Defs10bpp::_4x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDcTop] = |
| DefsHbd::_4x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDcLeft] = |
| DefsHbd::_4x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorDc] = |
| DefsHbd::_4x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorVertical] = |
| DefsHbd::_4x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorHorizontal] = |
| DefsHbd::_4x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorPaeth] = |
| DefsHbd::_4x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorSmooth] = |
| DefsHbd::_4x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorSmoothVertical] = |
| DefsHbd::_4x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize4x16][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_4x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDcFill] = |
| Defs10bpp::_8x4::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDcTop] = |
| DefsHbd::_8x4::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDcLeft] = |
| DefsHbd::_8x4::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorDc] = |
| DefsHbd::_8x4::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorVertical] = |
| DefsHbd::_8x4::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorHorizontal] = |
| DefsHbd::_8x4::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorPaeth] = |
| DefsHbd::_8x4::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorSmooth] = |
| DefsHbd::_8x4::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorSmoothVertical] = |
| DefsHbd::_8x4::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x4][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_8x4::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDcFill] = |
| Defs10bpp::_8x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDcTop] = |
| DefsHbd::_8x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDcLeft] = |
| DefsHbd::_8x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorDc] = |
| DefsHbd::_8x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorVertical] = |
| DefsHbd::_8x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorHorizontal] = |
| DefsHbd::_8x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorPaeth] = |
| DefsHbd::_8x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorSmooth] = |
| DefsHbd::_8x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorSmoothVertical] = |
| DefsHbd::_8x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x8][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_8x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDcFill] = |
| Defs10bpp::_8x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDcTop] = |
| DefsHbd::_8x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDcLeft] = |
| DefsHbd::_8x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorDc] = |
| DefsHbd::_8x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorVertical] = |
| DefsHbd::_8x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorHorizontal] = |
| DefsHbd::_8x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorPaeth] = |
| DefsHbd::_8x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorSmooth] = |
| DefsHbd::_8x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorSmoothVertical] = |
| DefsHbd::_8x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x16][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_8x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDcFill] = |
| Defs10bpp::_8x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDcTop] = |
| DefsHbd::_8x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDcLeft] = |
| DefsHbd::_8x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorDc] = |
| DefsHbd::_8x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorVertical] = |
| DefsHbd::_8x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorHorizontal] = |
| DefsHbd::_8x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorPaeth] = |
| DefsHbd::_8x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorSmooth] = |
| DefsHbd::_8x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorSmoothVertical] = |
| DefsHbd::_8x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize8x32][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_8x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDcFill] = |
| Defs10bpp::_16x4::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDcTop] = |
| DefsHbd::_16x4::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDcLeft] = |
| DefsHbd::_16x4::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorDc] = |
| DefsHbd::_16x4::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorVertical] = |
| DefsHbd::_16x4::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorHorizontal] = |
| DefsHbd::_16x4::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorPaeth] = |
| DefsHbd::_16x4::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorSmooth] = |
| DefsHbd::_16x4::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorSmoothVertical] = |
| DefsHbd::_16x4::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x4][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_16x4::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDcFill] = |
| Defs10bpp::_16x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDcTop] = |
| DefsHbd::_16x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDcLeft] = |
| DefsHbd::_16x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorDc] = |
| DefsHbd::_16x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorVertical] = |
| DefsHbd::_16x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorHorizontal] = |
| DefsHbd::_16x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorPaeth] = |
| DefsHbd::_16x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorSmooth] = |
| DefsHbd::_16x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorSmoothVertical] = |
| DefsHbd::_16x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x8][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_16x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDcFill] = |
| Defs10bpp::_16x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDcTop] = |
| DefsHbd::_16x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDcLeft] = |
| DefsHbd::_16x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorDc] = |
| DefsHbd::_16x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorVertical] = |
| DefsHbd::_16x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorHorizontal] = |
| DefsHbd::_16x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorPaeth] = |
| DefsHbd::_16x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorSmooth] = |
| DefsHbd::_16x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorSmoothVertical] = |
| DefsHbd::_16x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x16][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_16x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDcFill] = |
| Defs10bpp::_16x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDcTop] = |
| DefsHbd::_16x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDcLeft] = |
| DefsHbd::_16x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorDc] = |
| DefsHbd::_16x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorVertical] = |
| DefsHbd::_16x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorHorizontal] = |
| DefsHbd::_16x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorPaeth] = |
| DefsHbd::_16x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorSmooth] = |
| DefsHbd::_16x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorSmoothVertical] = |
| DefsHbd::_16x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x32][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_16x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDcFill] = |
| Defs10bpp::_16x64::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDcTop] = |
| DefsHbd::_16x64::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDcLeft] = |
| DefsHbd::_16x64::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorDc] = |
| DefsHbd::_16x64::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorVertical] = |
| DefsHbd::_16x64::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorHorizontal] = |
| DefsHbd::_16x64::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorPaeth] = |
| DefsHbd::_16x64::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorSmooth] = |
| DefsHbd::_16x64::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorSmoothVertical] = |
| DefsHbd::_16x64::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x64_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize16x64][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_16x64::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDcFill] = |
| Defs10bpp::_32x8::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDcTop] = |
| DefsHbd::_32x8::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDcLeft] = |
| DefsHbd::_32x8::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorDc] = |
| DefsHbd::_32x8::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorVertical] = |
| DefsHbd::_32x8::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorHorizontal] = |
| DefsHbd::_32x8::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorPaeth] = |
| DefsHbd::_32x8::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorSmooth] = |
| DefsHbd::_32x8::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorSmoothVertical] = |
| DefsHbd::_32x8::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x8][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_32x8::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDcFill] = |
| Defs10bpp::_32x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDcTop] = |
| DefsHbd::_32x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDcLeft] = |
| DefsHbd::_32x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorDc] = |
| DefsHbd::_32x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorVertical] = |
| DefsHbd::_32x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorHorizontal] = |
| DefsHbd::_32x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorPaeth] = |
| DefsHbd::_32x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorSmooth] = |
| DefsHbd::_32x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorSmoothVertical] = |
| DefsHbd::_32x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x16][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_32x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDcFill] = |
| Defs10bpp::_32x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDcTop] = |
| DefsHbd::_32x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDcLeft] = |
| DefsHbd::_32x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorDc] = |
| DefsHbd::_32x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorVertical] = |
| DefsHbd::_32x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorHorizontal] = |
| DefsHbd::_32x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorPaeth] = |
| DefsHbd::_32x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorSmooth] = |
| DefsHbd::_32x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorSmoothVertical] = |
| DefsHbd::_32x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x32][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_32x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDcFill] = |
| Defs10bpp::_32x64::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDcTop] = |
| DefsHbd::_32x64::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDcLeft] = |
| DefsHbd::_32x64::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorDc] = |
| DefsHbd::_32x64::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorVertical] = |
| DefsHbd::_32x64::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorHorizontal] = |
| DefsHbd::_32x64::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorPaeth] = |
| DefsHbd::_32x64::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorSmooth] = |
| DefsHbd::_32x64::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorSmoothVertical] = |
| DefsHbd::_32x64::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x64_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize32x64][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_32x64::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDcFill] = |
| Defs10bpp::_64x16::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDcTop] = |
| DefsHbd::_64x16::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDcLeft] = |
| DefsHbd::_64x16::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorDc] = |
| DefsHbd::_64x16::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorVertical] = |
| DefsHbd::_64x16::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorHorizontal] = |
| DefsHbd::_64x16::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorPaeth] = |
| DefsHbd::_64x16::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorSmooth] = |
| DefsHbd::_64x16::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorSmoothVertical] = |
| DefsHbd::_64x16::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x16_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize64x16][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_64x16::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDcFill] = |
| Defs10bpp::_64x32::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDcTop] = |
| DefsHbd::_64x32::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDcLeft] = |
| DefsHbd::_64x32::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorDc] = |
| DefsHbd::_64x32::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorVertical] = |
| DefsHbd::_64x32::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorHorizontal] = |
| DefsHbd::_64x32::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorPaeth] = |
| DefsHbd::_64x32::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorSmooth] = |
| DefsHbd::_64x32::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorSmoothVertical] = |
| DefsHbd::_64x32::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x32_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize64x32][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_64x32::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorDcFill |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDcFill] = |
| Defs10bpp::_64x64::DcFill; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorDcTop |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDcTop] = |
| DefsHbd::_64x64::DcTop; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorDcLeft |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDcLeft] = |
| DefsHbd::_64x64::DcLeft; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorDc |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorDc] = |
| DefsHbd::_64x64::Dc; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorVertical |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorVertical] = |
| DefsHbd::_64x64::Vertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorHorizontal |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorHorizontal] = |
| DefsHbd::_64x64::Horizontal; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorPaeth |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorPaeth] = |
| DefsHbd::_64x64::Paeth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorSmooth |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorSmooth] = |
| DefsHbd::_64x64::Smooth; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorSmoothVertical |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorSmoothVertical] = |
| DefsHbd::_64x64::SmoothVertical; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize64x64_IntraPredictorSmoothHorizontal |
| dsp->intra_predictors[kTransformSize64x64][kIntraPredictorSmoothHorizontal] = |
| DefsHbd::_64x64::SmoothHorizontal; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_DirectionalIntraPredictorZone1 |
| dsp->directional_intra_predictor_zone1 = |
| DirectionalIntraPredictorZone1_C<uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_DirectionalIntraPredictorZone2 |
| dsp->directional_intra_predictor_zone2 = |
| DirectionalIntraPredictorZone2_C<uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_DirectionalIntraPredictorZone3 |
| dsp->directional_intra_predictor_zone3 = |
| DirectionalIntraPredictorZone3_C<uint16_t>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_FilterIntraPredictor |
| dsp->filter_intra_predictor = FilterIntraPredictor_C<10, uint16_t>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize4x4] = |
| CflIntraPredictor_C<4, 4, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize4x4][kSubsamplingType444] = |
| CflSubsampler_C<4, 4, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize4x4][kSubsamplingType422] = |
| CflSubsampler_C<4, 4, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x4_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize4x4][kSubsamplingType420] = |
| CflSubsampler_C<4, 4, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize4x8] = |
| CflIntraPredictor_C<4, 8, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize4x8][kSubsamplingType444] = |
| CflSubsampler_C<4, 8, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize4x8][kSubsamplingType422] = |
| CflSubsampler_C<4, 8, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize4x8][kSubsamplingType420] = |
| CflSubsampler_C<4, 8, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize4x16] = |
| CflIntraPredictor_C<4, 16, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize4x16][kSubsamplingType444] = |
| CflSubsampler_C<4, 16, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize4x16][kSubsamplingType422] = |
| CflSubsampler_C<4, 16, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize4x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize4x16][kSubsamplingType420] = |
| CflSubsampler_C<4, 16, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x4] = |
| CflIntraPredictor_C<8, 4, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x4][kSubsamplingType444] = |
| CflSubsampler_C<8, 4, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x4][kSubsamplingType422] = |
| CflSubsampler_C<8, 4, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x4_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x4][kSubsamplingType420] = |
| CflSubsampler_C<8, 4, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x8] = |
| CflIntraPredictor_C<8, 8, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x8][kSubsamplingType444] = |
| CflSubsampler_C<8, 8, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x8][kSubsamplingType422] = |
| CflSubsampler_C<8, 8, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x8][kSubsamplingType420] = |
| CflSubsampler_C<8, 8, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x16] = |
| CflIntraPredictor_C<8, 16, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x16][kSubsamplingType444] = |
| CflSubsampler_C<8, 16, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x16][kSubsamplingType422] = |
| CflSubsampler_C<8, 16, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x16][kSubsamplingType420] = |
| CflSubsampler_C<8, 16, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize8x32] = |
| CflIntraPredictor_C<8, 32, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize8x32][kSubsamplingType444] = |
| CflSubsampler_C<8, 32, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize8x32][kSubsamplingType422] = |
| CflSubsampler_C<8, 32, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize8x32_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize8x32][kSubsamplingType420] = |
| CflSubsampler_C<8, 32, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x4] = |
| CflIntraPredictor_C<16, 4, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x4][kSubsamplingType444] = |
| CflSubsampler_C<16, 4, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x4][kSubsamplingType422] = |
| CflSubsampler_C<16, 4, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x4_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x4][kSubsamplingType420] = |
| CflSubsampler_C<16, 4, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x8] = |
| CflIntraPredictor_C<16, 8, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x8][kSubsamplingType444] = |
| CflSubsampler_C<16, 8, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x8][kSubsamplingType422] = |
| CflSubsampler_C<16, 8, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x8][kSubsamplingType420] = |
| CflSubsampler_C<16, 8, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x16] = |
| CflIntraPredictor_C<16, 16, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x16][kSubsamplingType444] = |
| CflSubsampler_C<16, 16, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x16][kSubsamplingType422] = |
| CflSubsampler_C<16, 16, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x16][kSubsamplingType420] = |
| CflSubsampler_C<16, 16, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize16x32] = |
| CflIntraPredictor_C<16, 32, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize16x32][kSubsamplingType444] = |
| CflSubsampler_C<16, 32, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize16x32][kSubsamplingType422] = |
| CflSubsampler_C<16, 32, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize16x32_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize16x32][kSubsamplingType420] = |
| CflSubsampler_C<16, 32, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize32x8] = |
| CflIntraPredictor_C<32, 8, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize32x8][kSubsamplingType444] = |
| CflSubsampler_C<32, 8, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize32x8][kSubsamplingType422] = |
| CflSubsampler_C<32, 8, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x8_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize32x8][kSubsamplingType420] = |
| CflSubsampler_C<32, 8, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize32x16] = |
| CflIntraPredictor_C<32, 16, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize32x16][kSubsamplingType444] = |
| CflSubsampler_C<32, 16, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize32x16][kSubsamplingType422] = |
| CflSubsampler_C<32, 16, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x16_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize32x16][kSubsamplingType420] = |
| CflSubsampler_C<32, 16, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_CflIntraPredictor |
| dsp->cfl_intra_predictors[kTransformSize32x32] = |
| CflIntraPredictor_C<32, 32, 10, uint16_t>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_CflSubsampler444 |
| dsp->cfl_subsamplers[kTransformSize32x32][kSubsamplingType444] = |
| CflSubsampler_C<32, 32, 10, uint16_t, 0, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_CflSubsampler422 |
| dsp->cfl_subsamplers[kTransformSize32x32][kSubsamplingType422] = |
| CflSubsampler_C<32, 32, 10, uint16_t, 1, 0>; |
| #endif |
| #ifndef LIBGAV1_Dsp10bpp_TransformSize32x32_CflSubsampler420 |
| dsp->cfl_subsamplers[kTransformSize32x32][kSubsamplingType420] = |
| CflSubsampler_C<32, 32, 10, uint16_t, 1, 1>; |
| #endif |
| |
| #endif // LIBGAV1_ENABLE_ALL_DSP_FUNCTIONS |
| // Cfl predictors are available only for transform sizes with max(width, |
| // height) <= 32. Set all others to nullptr. |
| for (const auto i : kTransformSizesLargerThan32x32) { |
| dsp->cfl_intra_predictors[i] = nullptr; |
| for (int j = 0; j < kNumSubsamplingTypes; ++j) { |
| dsp->cfl_subsamplers[i][j] = nullptr; |
| } |
| } |
| } // NOLINT(readability/fn_size) |
| #endif // LIBGAV1_MAX_BITDEPTH >= 10 |
| |
| #undef INIT_CFL_INTRAPREDICTOR_WxH |
| #undef INIT_CFL_INTRAPREDICTORS |
| #undef INIT_INTRAPREDICTORS_WxH |
| #undef INIT_INTRAPREDICTORS |
| |
| } // namespace |
| |
| void IntraPredInit_C() { |
| Init8bpp(); |
| #if LIBGAV1_MAX_BITDEPTH >= 10 |
| Init10bpp(); |
| #endif |
| } |
| |
| } // namespace dsp |
| } // namespace libgav1 |
