Coverage Report

Created: 2026-09-28 07:00

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libjxl/lib/jxl/dec_transforms-inl.h
Line
Count
Source
1
// Copyright (c) the JPEG XL Project Authors. All rights reserved.
2
//
3
// Use of this source code is governed by a BSD-style
4
// license that can be found in the LICENSE file.
5
6
#include <cstring>
7
8
#include "lib/jxl/base/compiler_specific.h"
9
#include "lib/jxl/frame_dimensions.h"
10
11
#if defined(LIB_JXL_DEC_TRANSFORMS_INL_H_) == defined(HWY_TARGET_TOGGLE)
12
#ifdef LIB_JXL_DEC_TRANSFORMS_INL_H_
13
#undef LIB_JXL_DEC_TRANSFORMS_INL_H_
14
#else
15
#define LIB_JXL_DEC_TRANSFORMS_INL_H_
16
#endif
17
18
#include <cstddef>
19
#include <hwy/highway.h>
20
21
#include "lib/jxl/ac_strategy.h"
22
#include "lib/jxl/dct-inl.h"
23
#include "lib/jxl/dct_scales.h"
24
HWY_BEFORE_NAMESPACE();
25
namespace jxl {
26
namespace HWY_NAMESPACE {
27
namespace {
28
29
// These templates are not found via ADL.
30
using hwy::HWY_NAMESPACE::MulAdd;
31
32
// Computes the lowest-frequency LF_ROWSxLF_COLS-sized square in output, which
33
// is a DCT_ROWS*DCT_COLS-sized DCT block, by doing a ROWS*COLS DCT on the
34
// input block.
35
template <size_t DCT_ROWS, size_t DCT_COLS, size_t LF_ROWS, size_t LF_COLS,
36
          size_t ROWS, size_t COLS>
37
JXL_INLINE void ReinterpretingDCT(const float* input, const size_t input_stride,
38
                                  float* output, const size_t output_stride,
39
                                  float* JXL_RESTRICT block,
40
9.30M
                                  float* JXL_RESTRICT scratch_space) {
41
9.30M
  static_assert(LF_ROWS == ROWS,
42
9.30M
                "ReinterpretingDCT should only be called with LF == N");
43
9.30M
  static_assert(LF_COLS == COLS,
44
9.30M
                "ReinterpretingDCT should only be called with LF == N");
45
9.30M
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
9.30M
                                 scratch_space);
47
9.30M
  if (ROWS < COLS) {
48
18.2M
    for (size_t y = 0; y < LF_ROWS; y++) {
49
27.5M
      for (size_t x = 0; x < LF_COLS; x++) {
50
18.4M
        output[y * output_stride + x] =
51
18.4M
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
18.4M
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
18.4M
      }
54
9.14M
    }
55
9.12M
  } else {
56
537k
    for (size_t y = 0; y < LF_COLS; y++) {
57
3.29M
      for (size_t x = 0; x < LF_ROWS; x++) {
58
2.92M
        output[y * output_stride + x] =
59
2.92M
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
2.92M
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
2.92M
      }
62
362k
    }
63
175k
  }
64
9.30M
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
18.2k
                                  float* JXL_RESTRICT scratch_space) {
41
18.2k
  static_assert(LF_ROWS == ROWS,
42
18.2k
                "ReinterpretingDCT should only be called with LF == N");
43
18.2k
  static_assert(LF_COLS == COLS,
44
18.2k
                "ReinterpretingDCT should only be called with LF == N");
45
18.2k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
18.2k
                                 scratch_space);
47
18.2k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
18.2k
  } else {
56
36.4k
    for (size_t y = 0; y < LF_COLS; y++) {
57
54.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
36.4k
        output[y * output_stride + x] =
59
36.4k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
36.4k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
36.4k
      }
62
18.2k
    }
63
18.2k
  }
64
18.2k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.64M
                                  float* JXL_RESTRICT scratch_space) {
41
1.64M
  static_assert(LF_ROWS == ROWS,
42
1.64M
                "ReinterpretingDCT should only be called with LF == N");
43
1.64M
  static_assert(LF_COLS == COLS,
44
1.64M
                "ReinterpretingDCT should only be called with LF == N");
45
1.64M
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.64M
                                 scratch_space);
47
1.64M
  if (ROWS < COLS) {
48
3.27M
    for (size_t y = 0; y < LF_ROWS; y++) {
49
4.91M
      for (size_t x = 0; x < LF_COLS; x++) {
50
3.27M
        output[y * output_stride + x] =
51
3.27M
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
3.27M
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
3.27M
      }
54
1.63M
    }
55
1.63M
  } else {
56
2.93k
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
2.93k
  }
64
1.64M
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.42k
                                  float* JXL_RESTRICT scratch_space) {
41
3.42k
  static_assert(LF_ROWS == ROWS,
42
3.42k
                "ReinterpretingDCT should only be called with LF == N");
43
3.42k
  static_assert(LF_COLS == COLS,
44
3.42k
                "ReinterpretingDCT should only be called with LF == N");
45
3.42k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.42k
                                 scratch_space);
47
3.42k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
3.42k
  } else {
56
10.2k
    for (size_t y = 0; y < LF_COLS; y++) {
57
20.5k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
13.7k
        output[y * output_stride + x] =
59
13.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
13.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
13.7k
      }
62
6.85k
    }
63
3.42k
  }
64
3.42k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
2.12k
                                  float* JXL_RESTRICT scratch_space) {
41
2.12k
  static_assert(LF_ROWS == ROWS,
42
2.12k
                "ReinterpretingDCT should only be called with LF == N");
43
2.12k
  static_assert(LF_COLS == COLS,
44
2.12k
                "ReinterpretingDCT should only be called with LF == N");
45
2.12k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
2.12k
                                 scratch_space);
47
2.12k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
2.12k
  } else {
56
4.24k
    for (size_t y = 0; y < LF_COLS; y++) {
57
10.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
8.48k
        output[y * output_stride + x] =
59
8.48k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
8.48k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
8.48k
      }
62
2.12k
    }
63
2.12k
  }
64
2.12k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.37k
                                  float* JXL_RESTRICT scratch_space) {
41
3.37k
  static_assert(LF_ROWS == ROWS,
42
3.37k
                "ReinterpretingDCT should only be called with LF == N");
43
3.37k
  static_assert(LF_COLS == COLS,
44
3.37k
                "ReinterpretingDCT should only be called with LF == N");
45
3.37k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.37k
                                 scratch_space);
47
3.37k
  if (ROWS < COLS) {
48
6.75k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
16.8k
      for (size_t x = 0; x < LF_COLS; x++) {
50
13.5k
        output[y * output_stride + x] =
51
13.5k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
13.5k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
13.5k
      }
54
3.37k
    }
55
3.37k
  } else {
56
1
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
1
  }
64
3.37k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
2.75k
                                  float* JXL_RESTRICT scratch_space) {
41
2.75k
  static_assert(LF_ROWS == ROWS,
42
2.75k
                "ReinterpretingDCT should only be called with LF == N");
43
2.75k
  static_assert(LF_COLS == COLS,
44
2.75k
                "ReinterpretingDCT should only be called with LF == N");
45
2.75k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
2.75k
                                 scratch_space);
47
2.75k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
2.75k
  } else {
56
8.26k
    for (size_t y = 0; y < LF_COLS; y++) {
57
27.5k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
22.0k
        output[y * output_stride + x] =
59
22.0k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
22.0k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
22.0k
      }
62
5.51k
    }
63
2.75k
  }
64
2.75k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.85k
                                  float* JXL_RESTRICT scratch_space) {
41
1.85k
  static_assert(LF_ROWS == ROWS,
42
1.85k
                "ReinterpretingDCT should only be called with LF == N");
43
1.85k
  static_assert(LF_COLS == COLS,
44
1.85k
                "ReinterpretingDCT should only be called with LF == N");
45
1.85k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.85k
                                 scratch_space);
47
1.85k
  if (ROWS < COLS) {
48
5.55k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
18.5k
      for (size_t x = 0; x < LF_COLS; x++) {
50
14.8k
        output[y * output_stride + x] =
51
14.8k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
14.8k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
14.8k
      }
54
3.70k
    }
55
1.85k
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
1.85k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
738
                                  float* JXL_RESTRICT scratch_space) {
41
738
  static_assert(LF_ROWS == ROWS,
42
738
                "ReinterpretingDCT should only be called with LF == N");
43
738
  static_assert(LF_COLS == COLS,
44
738
                "ReinterpretingDCT should only be called with LF == N");
45
738
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
738
                                 scratch_space);
47
738
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
738
  } else {
56
3.69k
    for (size_t y = 0; y < LF_COLS; y++) {
57
14.7k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
11.8k
        output[y * output_stride + x] =
59
11.8k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
11.8k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
11.8k
      }
62
2.95k
    }
63
738
  }
64
738
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
123
                                  float* JXL_RESTRICT scratch_space) {
41
123
  static_assert(LF_ROWS == ROWS,
42
123
                "ReinterpretingDCT should only be called with LF == N");
43
123
  static_assert(LF_COLS == COLS,
44
123
                "ReinterpretingDCT should only be called with LF == N");
45
123
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
123
                                 scratch_space);
47
123
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
123
  } else {
56
615
    for (size_t y = 0; y < LF_COLS; y++) {
57
4.42k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
3.93k
        output[y * output_stride + x] =
59
3.93k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
3.93k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
3.93k
      }
62
492
    }
63
123
  }
64
123
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
54
                                  float* JXL_RESTRICT scratch_space) {
41
54
  static_assert(LF_ROWS == ROWS,
42
54
                "ReinterpretingDCT should only be called with LF == N");
43
54
  static_assert(LF_COLS == COLS,
44
54
                "ReinterpretingDCT should only be called with LF == N");
45
54
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
54
                                 scratch_space);
47
54
  if (ROWS < COLS) {
48
270
    for (size_t y = 0; y < LF_ROWS; y++) {
49
1.94k
      for (size_t x = 0; x < LF_COLS; x++) {
50
1.72k
        output[y * output_stride + x] =
51
1.72k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
1.72k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
1.72k
      }
54
216
    }
55
54
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
54
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.89k
                                  float* JXL_RESTRICT scratch_space) {
41
1.89k
  static_assert(LF_ROWS == ROWS,
42
1.89k
                "ReinterpretingDCT should only be called with LF == N");
43
1.89k
  static_assert(LF_COLS == COLS,
44
1.89k
                "ReinterpretingDCT should only be called with LF == N");
45
1.89k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.89k
                                 scratch_space);
47
1.89k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
1.89k
  } else {
56
17.0k
    for (size_t y = 0; y < LF_COLS; y++) {
57
136k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
121k
        output[y * output_stride + x] =
59
121k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
121k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
121k
      }
62
15.1k
    }
63
1.89k
  }
64
1.89k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
207
                                  float* JXL_RESTRICT scratch_space) {
41
207
  static_assert(LF_ROWS == ROWS,
42
207
                "ReinterpretingDCT should only be called with LF == N");
43
207
  static_assert(LF_COLS == COLS,
44
207
                "ReinterpretingDCT should only be called with LF == N");
45
207
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
207
                                 scratch_space);
47
207
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
207
  } else {
56
1.86k
    for (size_t y = 0; y < LF_COLS; y++) {
57
28.1k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
26.4k
        output[y * output_stride + x] =
59
26.4k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
26.4k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
26.4k
      }
62
1.65k
    }
63
207
  }
64
207
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
30
                                  float* JXL_RESTRICT scratch_space) {
41
30
  static_assert(LF_ROWS == ROWS,
42
30
                "ReinterpretingDCT should only be called with LF == N");
43
30
  static_assert(LF_COLS == COLS,
44
30
                "ReinterpretingDCT should only be called with LF == N");
45
30
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
30
                                 scratch_space);
47
30
  if (ROWS < COLS) {
48
270
    for (size_t y = 0; y < LF_ROWS; y++) {
49
4.08k
      for (size_t x = 0; x < LF_COLS; x++) {
50
3.84k
        output[y * output_stride + x] =
51
3.84k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
3.84k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
3.84k
      }
54
240
    }
55
30
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
30
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.27k
                                  float* JXL_RESTRICT scratch_space) {
41
1.27k
  static_assert(LF_ROWS == ROWS,
42
1.27k
                "ReinterpretingDCT should only be called with LF == N");
43
1.27k
  static_assert(LF_COLS == COLS,
44
1.27k
                "ReinterpretingDCT should only be called with LF == N");
45
1.27k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.27k
                                 scratch_space);
47
1.27k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
1.27k
  } else {
56
21.6k
    for (size_t y = 0; y < LF_COLS; y++) {
57
345k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
325k
        output[y * output_stride + x] =
59
325k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
325k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
325k
      }
62
20.3k
    }
63
1.27k
  }
64
1.27k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
6
                                  float* JXL_RESTRICT scratch_space) {
41
6
  static_assert(LF_ROWS == ROWS,
42
6
                "ReinterpretingDCT should only be called with LF == N");
43
6
  static_assert(LF_COLS == COLS,
44
6
                "ReinterpretingDCT should only be called with LF == N");
45
6
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
6
                                 scratch_space);
47
6
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
6
  } else {
56
102
    for (size_t y = 0; y < LF_COLS; y++) {
57
3.16k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
3.07k
        output[y * output_stride + x] =
59
3.07k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
3.07k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
3.07k
      }
62
96
    }
63
6
  }
64
6
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
24
                                  float* JXL_RESTRICT scratch_space) {
41
24
  static_assert(LF_ROWS == ROWS,
42
24
                "ReinterpretingDCT should only be called with LF == N");
43
24
  static_assert(LF_COLS == COLS,
44
24
                "ReinterpretingDCT should only be called with LF == N");
45
24
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
24
                                 scratch_space);
47
24
  if (ROWS < COLS) {
48
408
    for (size_t y = 0; y < LF_ROWS; y++) {
49
12.6k
      for (size_t x = 0; x < LF_COLS; x++) {
50
12.2k
        output[y * output_stride + x] =
51
12.2k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
12.2k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
12.2k
      }
54
384
    }
55
24
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
24
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
21
                                  float* JXL_RESTRICT scratch_space) {
41
21
  static_assert(LF_ROWS == ROWS,
42
21
                "ReinterpretingDCT should only be called with LF == N");
43
21
  static_assert(LF_COLS == COLS,
44
21
                "ReinterpretingDCT should only be called with LF == N");
45
21
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
21
                                 scratch_space);
47
21
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
21
  } else {
56
693
    for (size_t y = 0; y < LF_COLS; y++) {
57
22.1k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
21.5k
        output[y * output_stride + x] =
59
21.5k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
21.5k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
21.5k
      }
62
672
    }
63
21
  }
64
21
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
71.5k
                                  float* JXL_RESTRICT scratch_space) {
41
71.5k
  static_assert(LF_ROWS == ROWS,
42
71.5k
                "ReinterpretingDCT should only be called with LF == N");
43
71.5k
  static_assert(LF_COLS == COLS,
44
71.5k
                "ReinterpretingDCT should only be called with LF == N");
45
71.5k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
71.5k
                                 scratch_space);
47
71.5k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
71.5k
  } else {
56
143k
    for (size_t y = 0; y < LF_COLS; y++) {
57
214k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
143k
        output[y * output_stride + x] =
59
143k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
143k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
143k
      }
62
71.5k
    }
63
71.5k
  }
64
71.5k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.92M
                                  float* JXL_RESTRICT scratch_space) {
41
3.92M
  static_assert(LF_ROWS == ROWS,
42
3.92M
                "ReinterpretingDCT should only be called with LF == N");
43
3.92M
  static_assert(LF_COLS == COLS,
44
3.92M
                "ReinterpretingDCT should only be called with LF == N");
45
3.92M
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.92M
                                 scratch_space);
47
3.92M
  if (ROWS < COLS) {
48
7.84M
    for (size_t y = 0; y < LF_ROWS; y++) {
49
11.7M
      for (size_t x = 0; x < LF_COLS; x++) {
50
7.83M
        output[y * output_stride + x] =
51
7.83M
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
7.83M
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
7.83M
      }
54
3.92M
    }
55
3.92M
  } else {
56
8.56k
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
8.56k
  }
64
3.92M
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
8.66k
                                  float* JXL_RESTRICT scratch_space) {
41
8.66k
  static_assert(LF_ROWS == ROWS,
42
8.66k
                "ReinterpretingDCT should only be called with LF == N");
43
8.66k
  static_assert(LF_COLS == COLS,
44
8.66k
                "ReinterpretingDCT should only be called with LF == N");
45
8.66k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
8.66k
                                 scratch_space);
47
8.66k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
8.66k
  } else {
56
25.9k
    for (size_t y = 0; y < LF_COLS; y++) {
57
51.9k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
34.6k
        output[y * output_stride + x] =
59
34.6k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
34.6k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
34.6k
      }
62
17.3k
    }
63
8.66k
  }
64
8.66k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
5.24k
                                  float* JXL_RESTRICT scratch_space) {
41
5.24k
  static_assert(LF_ROWS == ROWS,
42
5.24k
                "ReinterpretingDCT should only be called with LF == N");
43
5.24k
  static_assert(LF_COLS == COLS,
44
5.24k
                "ReinterpretingDCT should only be called with LF == N");
45
5.24k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
5.24k
                                 scratch_space);
47
5.24k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
5.24k
  } else {
56
10.4k
    for (size_t y = 0; y < LF_COLS; y++) {
57
26.2k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
20.9k
        output[y * output_stride + x] =
59
20.9k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
20.9k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
20.9k
      }
62
5.24k
    }
63
5.24k
  }
64
5.24k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.26k
                                  float* JXL_RESTRICT scratch_space) {
41
3.26k
  static_assert(LF_ROWS == ROWS,
42
3.26k
                "ReinterpretingDCT should only be called with LF == N");
43
3.26k
  static_assert(LF_COLS == COLS,
44
3.26k
                "ReinterpretingDCT should only be called with LF == N");
45
3.26k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.26k
                                 scratch_space);
47
3.26k
  if (ROWS < COLS) {
48
6.51k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
16.2k
      for (size_t x = 0; x < LF_COLS; x++) {
50
13.0k
        output[y * output_stride + x] =
51
13.0k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
13.0k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
13.0k
      }
54
3.25k
    }
55
3.25k
  } else {
56
5
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
5
  }
64
3.26k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
5.23k
                                  float* JXL_RESTRICT scratch_space) {
41
5.23k
  static_assert(LF_ROWS == ROWS,
42
5.23k
                "ReinterpretingDCT should only be called with LF == N");
43
5.23k
  static_assert(LF_COLS == COLS,
44
5.23k
                "ReinterpretingDCT should only be called with LF == N");
45
5.23k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
5.23k
                                 scratch_space);
47
5.23k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
5.23k
  } else {
56
15.7k
    for (size_t y = 0; y < LF_COLS; y++) {
57
52.3k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
41.9k
        output[y * output_stride + x] =
59
41.9k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
41.9k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
41.9k
      }
62
10.4k
    }
63
5.23k
  }
64
5.23k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
6.43k
                                  float* JXL_RESTRICT scratch_space) {
41
6.43k
  static_assert(LF_ROWS == ROWS,
42
6.43k
                "ReinterpretingDCT should only be called with LF == N");
43
6.43k
  static_assert(LF_COLS == COLS,
44
6.43k
                "ReinterpretingDCT should only be called with LF == N");
45
6.43k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
6.43k
                                 scratch_space);
47
6.43k
  if (ROWS < COLS) {
48
19.2k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
64.2k
      for (size_t x = 0; x < LF_COLS; x++) {
50
51.4k
        output[y * output_stride + x] =
51
51.4k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
51.4k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
51.4k
      }
54
12.8k
    }
55
6.43k
  } else {
56
1
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
1
  }
64
6.43k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.71k
                                  float* JXL_RESTRICT scratch_space) {
41
1.71k
  static_assert(LF_ROWS == ROWS,
42
1.71k
                "ReinterpretingDCT should only be called with LF == N");
43
1.71k
  static_assert(LF_COLS == COLS,
44
1.71k
                "ReinterpretingDCT should only be called with LF == N");
45
1.71k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.71k
                                 scratch_space);
47
1.71k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
1.71k
  } else {
56
8.56k
    for (size_t y = 0; y < LF_COLS; y++) {
57
34.2k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
27.4k
        output[y * output_stride + x] =
59
27.4k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
27.4k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
27.4k
      }
62
6.85k
    }
63
1.71k
  }
64
1.71k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
552
                                  float* JXL_RESTRICT scratch_space) {
41
552
  static_assert(LF_ROWS == ROWS,
42
552
                "ReinterpretingDCT should only be called with LF == N");
43
552
  static_assert(LF_COLS == COLS,
44
552
                "ReinterpretingDCT should only be called with LF == N");
45
552
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
552
                                 scratch_space);
47
552
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
552
  } else {
56
2.76k
    for (size_t y = 0; y < LF_COLS; y++) {
57
19.8k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
17.6k
        output[y * output_stride + x] =
59
17.6k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
17.6k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
17.6k
      }
62
2.20k
    }
63
552
  }
64
552
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
114
                                  float* JXL_RESTRICT scratch_space) {
41
114
  static_assert(LF_ROWS == ROWS,
42
114
                "ReinterpretingDCT should only be called with LF == N");
43
114
  static_assert(LF_COLS == COLS,
44
114
                "ReinterpretingDCT should only be called with LF == N");
45
114
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
114
                                 scratch_space);
47
114
  if (ROWS < COLS) {
48
570
    for (size_t y = 0; y < LF_ROWS; y++) {
49
4.10k
      for (size_t x = 0; x < LF_COLS; x++) {
50
3.64k
        output[y * output_stride + x] =
51
3.64k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
3.64k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
3.64k
      }
54
456
    }
55
114
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
114
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.81k
                                  float* JXL_RESTRICT scratch_space) {
41
3.81k
  static_assert(LF_ROWS == ROWS,
42
3.81k
                "ReinterpretingDCT should only be called with LF == N");
43
3.81k
  static_assert(LF_COLS == COLS,
44
3.81k
                "ReinterpretingDCT should only be called with LF == N");
45
3.81k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.81k
                                 scratch_space);
47
3.81k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
3.81k
  } else {
56
34.3k
    for (size_t y = 0; y < LF_COLS; y++) {
57
274k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
243k
        output[y * output_stride + x] =
59
243k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
243k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
243k
      }
62
30.5k
    }
63
3.81k
  }
64
3.81k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
321
                                  float* JXL_RESTRICT scratch_space) {
41
321
  static_assert(LF_ROWS == ROWS,
42
321
                "ReinterpretingDCT should only be called with LF == N");
43
321
  static_assert(LF_COLS == COLS,
44
321
                "ReinterpretingDCT should only be called with LF == N");
45
321
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
321
                                 scratch_space);
47
321
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
321
  } else {
56
2.88k
    for (size_t y = 0; y < LF_COLS; y++) {
57
43.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
41.0k
        output[y * output_stride + x] =
59
41.0k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
41.0k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
41.0k
      }
62
2.56k
    }
63
321
  }
64
321
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
162
                                  float* JXL_RESTRICT scratch_space) {
41
162
  static_assert(LF_ROWS == ROWS,
42
162
                "ReinterpretingDCT should only be called with LF == N");
43
162
  static_assert(LF_COLS == COLS,
44
162
                "ReinterpretingDCT should only be called with LF == N");
45
162
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
162
                                 scratch_space);
47
162
  if (ROWS < COLS) {
48
1.45k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
22.0k
      for (size_t x = 0; x < LF_COLS; x++) {
50
20.7k
        output[y * output_stride + x] =
51
20.7k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
20.7k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
20.7k
      }
54
1.29k
    }
55
162
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
162
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.07k
                                  float* JXL_RESTRICT scratch_space) {
41
3.07k
  static_assert(LF_ROWS == ROWS,
42
3.07k
                "ReinterpretingDCT should only be called with LF == N");
43
3.07k
  static_assert(LF_COLS == COLS,
44
3.07k
                "ReinterpretingDCT should only be called with LF == N");
45
3.07k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.07k
                                 scratch_space);
47
3.07k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
3.07k
  } else {
56
52.3k
    for (size_t y = 0; y < LF_COLS; y++) {
57
837k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
787k
        output[y * output_stride + x] =
59
787k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
787k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
787k
      }
62
49.2k
    }
63
3.07k
  }
64
3.07k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
21
                                  float* JXL_RESTRICT scratch_space) {
41
21
  static_assert(LF_ROWS == ROWS,
42
21
                "ReinterpretingDCT should only be called with LF == N");
43
21
  static_assert(LF_COLS == COLS,
44
21
                "ReinterpretingDCT should only be called with LF == N");
45
21
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
21
                                 scratch_space);
47
21
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
21
  } else {
56
357
    for (size_t y = 0; y < LF_COLS; y++) {
57
11.0k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
10.7k
        output[y * output_stride + x] =
59
10.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
10.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
10.7k
      }
62
336
    }
63
21
  }
64
21
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
27
                                  float* JXL_RESTRICT scratch_space) {
41
27
  static_assert(LF_ROWS == ROWS,
42
27
                "ReinterpretingDCT should only be called with LF == N");
43
27
  static_assert(LF_COLS == COLS,
44
27
                "ReinterpretingDCT should only be called with LF == N");
45
27
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
27
                                 scratch_space);
47
27
  if (ROWS < COLS) {
48
459
    for (size_t y = 0; y < LF_ROWS; y++) {
49
14.2k
      for (size_t x = 0; x < LF_COLS; x++) {
50
13.8k
        output[y * output_stride + x] =
51
13.8k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
13.8k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
13.8k
      }
54
432
    }
55
27
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
27
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
30
                                  float* JXL_RESTRICT scratch_space) {
41
30
  static_assert(LF_ROWS == ROWS,
42
30
                "ReinterpretingDCT should only be called with LF == N");
43
30
  static_assert(LF_COLS == COLS,
44
30
                "ReinterpretingDCT should only be called with LF == N");
45
30
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
30
                                 scratch_space);
47
30
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
30
  } else {
56
990
    for (size_t y = 0; y < LF_COLS; y++) {
57
31.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
30.7k
        output[y * output_stride + x] =
59
30.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
30.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
30.7k
      }
62
960
    }
63
30
  }
64
30
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
13.8k
                                  float* JXL_RESTRICT scratch_space) {
41
13.8k
  static_assert(LF_ROWS == ROWS,
42
13.8k
                "ReinterpretingDCT should only be called with LF == N");
43
13.8k
  static_assert(LF_COLS == COLS,
44
13.8k
                "ReinterpretingDCT should only be called with LF == N");
45
13.8k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
13.8k
                                 scratch_space);
47
13.8k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
13.8k
  } else {
56
27.6k
    for (size_t y = 0; y < LF_COLS; y++) {
57
41.5k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
27.6k
        output[y * output_stride + x] =
59
27.6k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
27.6k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
27.6k
      }
62
13.8k
    }
63
13.8k
  }
64
13.8k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.54M
                                  float* JXL_RESTRICT scratch_space) {
41
3.54M
  static_assert(LF_ROWS == ROWS,
42
3.54M
                "ReinterpretingDCT should only be called with LF == N");
43
3.54M
  static_assert(LF_COLS == COLS,
44
3.54M
                "ReinterpretingDCT should only be called with LF == N");
45
3.54M
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.54M
                                 scratch_space);
47
3.54M
  if (ROWS < COLS) {
48
7.08M
    for (size_t y = 0; y < LF_ROWS; y++) {
49
10.6M
      for (size_t x = 0; x < LF_COLS; x++) {
50
7.08M
        output[y * output_stride + x] =
51
7.08M
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
7.08M
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
7.08M
      }
54
3.54M
    }
55
3.54M
  } else {
56
3.33k
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
3.33k
  }
64
3.54M
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
4.44k
                                  float* JXL_RESTRICT scratch_space) {
41
4.44k
  static_assert(LF_ROWS == ROWS,
42
4.44k
                "ReinterpretingDCT should only be called with LF == N");
43
4.44k
  static_assert(LF_COLS == COLS,
44
4.44k
                "ReinterpretingDCT should only be called with LF == N");
45
4.44k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
4.44k
                                 scratch_space);
47
4.44k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
4.44k
  } else {
56
13.3k
    for (size_t y = 0; y < LF_COLS; y++) {
57
26.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
17.7k
        output[y * output_stride + x] =
59
17.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
17.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
17.7k
      }
62
8.88k
    }
63
4.44k
  }
64
4.44k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3.65k
                                  float* JXL_RESTRICT scratch_space) {
41
3.65k
  static_assert(LF_ROWS == ROWS,
42
3.65k
                "ReinterpretingDCT should only be called with LF == N");
43
3.65k
  static_assert(LF_COLS == COLS,
44
3.65k
                "ReinterpretingDCT should only be called with LF == N");
45
3.65k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3.65k
                                 scratch_space);
47
3.65k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
3.65k
  } else {
56
7.31k
    for (size_t y = 0; y < LF_COLS; y++) {
57
18.2k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
14.6k
        output[y * output_stride + x] =
59
14.6k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
14.6k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
14.6k
      }
62
3.65k
    }
63
3.65k
  }
64
3.65k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
6.91k
                                  float* JXL_RESTRICT scratch_space) {
41
6.91k
  static_assert(LF_ROWS == ROWS,
42
6.91k
                "ReinterpretingDCT should only be called with LF == N");
43
6.91k
  static_assert(LF_COLS == COLS,
44
6.91k
                "ReinterpretingDCT should only be called with LF == N");
45
6.91k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
6.91k
                                 scratch_space);
47
6.91k
  if (ROWS < COLS) {
48
13.8k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
34.4k
      for (size_t x = 0; x < LF_COLS; x++) {
50
27.5k
        output[y * output_stride + x] =
51
27.5k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
27.5k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
27.5k
      }
54
6.90k
    }
55
6.90k
  } else {
56
11
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
11
  }
64
6.91k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
2.34k
                                  float* JXL_RESTRICT scratch_space) {
41
2.34k
  static_assert(LF_ROWS == ROWS,
42
2.34k
                "ReinterpretingDCT should only be called with LF == N");
43
2.34k
  static_assert(LF_COLS == COLS,
44
2.34k
                "ReinterpretingDCT should only be called with LF == N");
45
2.34k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
2.34k
                                 scratch_space);
47
2.34k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
2.34k
  } else {
56
7.04k
    for (size_t y = 0; y < LF_COLS; y++) {
57
23.4k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
18.7k
        output[y * output_stride + x] =
59
18.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
18.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
18.7k
      }
62
4.69k
    }
63
2.34k
  }
64
2.34k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.80k
                                  float* JXL_RESTRICT scratch_space) {
41
1.80k
  static_assert(LF_ROWS == ROWS,
42
1.80k
                "ReinterpretingDCT should only be called with LF == N");
43
1.80k
  static_assert(LF_COLS == COLS,
44
1.80k
                "ReinterpretingDCT should only be called with LF == N");
45
1.80k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.80k
                                 scratch_space);
47
1.80k
  if (ROWS < COLS) {
48
5.40k
    for (size_t y = 0; y < LF_ROWS; y++) {
49
18.0k
      for (size_t x = 0; x < LF_COLS; x++) {
50
14.4k
        output[y * output_stride + x] =
51
14.4k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
14.4k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
14.4k
      }
54
3.60k
    }
55
1.80k
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
1.80k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
732
                                  float* JXL_RESTRICT scratch_space) {
41
732
  static_assert(LF_ROWS == ROWS,
42
732
                "ReinterpretingDCT should only be called with LF == N");
43
732
  static_assert(LF_COLS == COLS,
44
732
                "ReinterpretingDCT should only be called with LF == N");
45
732
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
732
                                 scratch_space);
47
732
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
732
  } else {
56
3.66k
    for (size_t y = 0; y < LF_COLS; y++) {
57
14.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
11.7k
        output[y * output_stride + x] =
59
11.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
11.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
11.7k
      }
62
2.92k
    }
63
732
  }
64
732
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
84
                                  float* JXL_RESTRICT scratch_space) {
41
84
  static_assert(LF_ROWS == ROWS,
42
84
                "ReinterpretingDCT should only be called with LF == N");
43
84
  static_assert(LF_COLS == COLS,
44
84
                "ReinterpretingDCT should only be called with LF == N");
45
84
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
84
                                 scratch_space);
47
84
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
84
  } else {
56
420
    for (size_t y = 0; y < LF_COLS; y++) {
57
3.02k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
2.68k
        output[y * output_stride + x] =
59
2.68k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
2.68k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
2.68k
      }
62
336
    }
63
84
  }
64
84
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
57
                                  float* JXL_RESTRICT scratch_space) {
41
57
  static_assert(LF_ROWS == ROWS,
42
57
                "ReinterpretingDCT should only be called with LF == N");
43
57
  static_assert(LF_COLS == COLS,
44
57
                "ReinterpretingDCT should only be called with LF == N");
45
57
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
57
                                 scratch_space);
47
57
  if (ROWS < COLS) {
48
285
    for (size_t y = 0; y < LF_ROWS; y++) {
49
2.05k
      for (size_t x = 0; x < LF_COLS; x++) {
50
1.82k
        output[y * output_stride + x] =
51
1.82k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
1.82k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
1.82k
      }
54
228
    }
55
57
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
57
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
1.05k
                                  float* JXL_RESTRICT scratch_space) {
41
1.05k
  static_assert(LF_ROWS == ROWS,
42
1.05k
                "ReinterpretingDCT should only be called with LF == N");
43
1.05k
  static_assert(LF_COLS == COLS,
44
1.05k
                "ReinterpretingDCT should only be called with LF == N");
45
1.05k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
1.05k
                                 scratch_space);
47
1.05k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
1.05k
  } else {
56
9.52k
    for (size_t y = 0; y < LF_COLS; y++) {
57
76.1k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
67.7k
        output[y * output_stride + x] =
59
67.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
67.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
67.7k
      }
62
8.47k
    }
63
1.05k
  }
64
1.05k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
279
                                  float* JXL_RESTRICT scratch_space) {
41
279
  static_assert(LF_ROWS == ROWS,
42
279
                "ReinterpretingDCT should only be called with LF == N");
43
279
  static_assert(LF_COLS == COLS,
44
279
                "ReinterpretingDCT should only be called with LF == N");
45
279
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
279
                                 scratch_space);
47
279
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
279
  } else {
56
2.51k
    for (size_t y = 0; y < LF_COLS; y++) {
57
37.9k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
35.7k
        output[y * output_stride + x] =
59
35.7k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
35.7k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
35.7k
      }
62
2.23k
    }
63
279
  }
64
279
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
27
                                  float* JXL_RESTRICT scratch_space) {
41
27
  static_assert(LF_ROWS == ROWS,
42
27
                "ReinterpretingDCT should only be called with LF == N");
43
27
  static_assert(LF_COLS == COLS,
44
27
                "ReinterpretingDCT should only be called with LF == N");
45
27
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
27
                                 scratch_space);
47
27
  if (ROWS < COLS) {
48
243
    for (size_t y = 0; y < LF_ROWS; y++) {
49
3.67k
      for (size_t x = 0; x < LF_COLS; x++) {
50
3.45k
        output[y * output_stride + x] =
51
3.45k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
3.45k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
3.45k
      }
54
216
    }
55
27
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
27
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
2.82k
                                  float* JXL_RESTRICT scratch_space) {
41
2.82k
  static_assert(LF_ROWS == ROWS,
42
2.82k
                "ReinterpretingDCT should only be called with LF == N");
43
2.82k
  static_assert(LF_COLS == COLS,
44
2.82k
                "ReinterpretingDCT should only be called with LF == N");
45
2.82k
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
2.82k
                                 scratch_space);
47
2.82k
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
2.82k
  } else {
56
48.0k
    for (size_t y = 0; y < LF_COLS; y++) {
57
769k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
724k
        output[y * output_stride + x] =
59
724k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
724k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
724k
      }
62
45.2k
    }
63
2.82k
  }
64
2.82k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
3
                                  float* JXL_RESTRICT scratch_space) {
41
3
  static_assert(LF_ROWS == ROWS,
42
3
                "ReinterpretingDCT should only be called with LF == N");
43
3
  static_assert(LF_COLS == COLS,
44
3
                "ReinterpretingDCT should only be called with LF == N");
45
3
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
3
                                 scratch_space);
47
3
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
3
  } else {
56
51
    for (size_t y = 0; y < LF_COLS; y++) {
57
1.58k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
1.53k
        output[y * output_stride + x] =
59
1.53k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
1.53k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
1.53k
      }
62
48
    }
63
3
  }
64
3
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
18
                                  float* JXL_RESTRICT scratch_space) {
41
18
  static_assert(LF_ROWS == ROWS,
42
18
                "ReinterpretingDCT should only be called with LF == N");
43
18
  static_assert(LF_COLS == COLS,
44
18
                "ReinterpretingDCT should only be called with LF == N");
45
18
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
18
                                 scratch_space);
47
18
  if (ROWS < COLS) {
48
306
    for (size_t y = 0; y < LF_ROWS; y++) {
49
9.50k
      for (size_t x = 0; x < LF_COLS; x++) {
50
9.21k
        output[y * output_stride + x] =
51
9.21k
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
9.21k
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
9.21k
      }
54
288
    }
55
18
  } else {
56
0
    for (size_t y = 0; y < LF_COLS; y++) {
57
0
      for (size_t x = 0; x < LF_ROWS; x++) {
58
0
        output[y * output_stride + x] =
59
0
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
0
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
0
      }
62
0
    }
63
0
  }
64
18
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Line
Count
Source
40
12
                                  float* JXL_RESTRICT scratch_space) {
41
12
  static_assert(LF_ROWS == ROWS,
42
12
                "ReinterpretingDCT should only be called with LF == N");
43
12
  static_assert(LF_COLS == COLS,
44
12
                "ReinterpretingDCT should only be called with LF == N");
45
12
  ComputeScaledDCT<ROWS, COLS>()(DCTFrom(input, input_stride), block,
46
12
                                 scratch_space);
47
12
  if (ROWS < COLS) {
48
0
    for (size_t y = 0; y < LF_ROWS; y++) {
49
0
      for (size_t x = 0; x < LF_COLS; x++) {
50
0
        output[y * output_stride + x] =
51
0
            block[y * COLS + x] * DCTTotalResampleScale<ROWS, DCT_ROWS>(y) *
52
0
            DCTTotalResampleScale<COLS, DCT_COLS>(x);
53
0
      }
54
0
    }
55
12
  } else {
56
396
    for (size_t y = 0; y < LF_COLS; y++) {
57
12.6k
      for (size_t x = 0; x < LF_ROWS; x++) {
58
12.2k
        output[y * output_stride + x] =
59
12.2k
            block[y * ROWS + x] * DCTTotalResampleScale<COLS, DCT_COLS>(y) *
60
12.2k
            DCTTotalResampleScale<ROWS, DCT_ROWS>(x);
61
12.2k
      }
62
384
    }
63
12
  }
64
12
}
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 8ul, 2ul, 1ul, 2ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 16ul, 1ul, 2ul, 1ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 16ul, 2ul, 2ul, 2ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 8ul, 4ul, 1ul, 4ul, 1ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<8ul, 32ul, 1ul, 4ul, 1ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 16ul, 4ul, 2ul, 4ul, 2ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<16ul, 32ul, 2ul, 4ul, 2ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 32ul, 4ul, 4ul, 4ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 32ul, 8ul, 4ul, 8ul, 4ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<32ul, 64ul, 4ul, 8ul, 4ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 64ul, 8ul, 8ul, 8ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 64ul, 16ul, 8ul, 16ul, 8ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<64ul, 128ul, 8ul, 16ul, 8ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 128ul, 16ul, 16ul, 16ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 128ul, 32ul, 16ul, 32ul, 16ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<128ul, 256ul, 16ul, 32ul, 16ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::ReinterpretingDCT<256ul, 256ul, 32ul, 32ul, 32ul, 32ul>(float const*, unsigned long, float*, unsigned long, float*, float*)
65
66
template <size_t S>
67
585k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
585k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
585k
  static_assert(S % 2 == 0, "S should be even");
70
585k
  float temp[kDCTBlockSize];
71
585k
  constexpr size_t num_2x2 = S / 2;
72
1.95M
  for (size_t y = 0; y < num_2x2; y++) {
73
5.46M
    for (size_t x = 0; x < num_2x2; x++) {
74
4.10M
      float c00 = block[y * kBlockDim + x];
75
4.10M
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
4.10M
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
4.10M
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
4.10M
      float r00 = c00 + c01 + c10 + c11;
79
4.10M
      float r01 = c00 + c01 - c10 - c11;
80
4.10M
      float r10 = c00 - c01 + c10 - c11;
81
4.10M
      float r11 = c00 - c01 - c10 + c11;
82
4.10M
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
4.10M
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
4.10M
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
4.10M
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
4.10M
    }
87
1.36M
  }
88
3.31M
  for (size_t y = 0; y < S; y++) {
89
19.1M
    for (size_t x = 0; x < S; x++) {
90
16.3M
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
16.3M
    }
92
2.73M
  }
93
585k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Line
Count
Source
67
47.2k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
47.2k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
47.2k
  static_assert(S % 2 == 0, "S should be even");
70
47.2k
  float temp[kDCTBlockSize];
71
47.2k
  constexpr size_t num_2x2 = S / 2;
72
94.5k
  for (size_t y = 0; y < num_2x2; y++) {
73
94.5k
    for (size_t x = 0; x < num_2x2; x++) {
74
47.2k
      float c00 = block[y * kBlockDim + x];
75
47.2k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
47.2k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
47.2k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
47.2k
      float r00 = c00 + c01 + c10 + c11;
79
47.2k
      float r01 = c00 + c01 - c10 - c11;
80
47.2k
      float r10 = c00 - c01 + c10 - c11;
81
47.2k
      float r11 = c00 - c01 - c10 + c11;
82
47.2k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
47.2k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
47.2k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
47.2k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
47.2k
    }
87
47.2k
  }
88
141k
  for (size_t y = 0; y < S; y++) {
89
283k
    for (size_t x = 0; x < S; x++) {
90
189k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
189k
    }
92
94.5k
  }
93
47.2k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Line
Count
Source
67
47.2k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
47.2k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
47.2k
  static_assert(S % 2 == 0, "S should be even");
70
47.2k
  float temp[kDCTBlockSize];
71
47.2k
  constexpr size_t num_2x2 = S / 2;
72
141k
  for (size_t y = 0; y < num_2x2; y++) {
73
283k
    for (size_t x = 0; x < num_2x2; x++) {
74
188k
      float c00 = block[y * kBlockDim + x];
75
188k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
188k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
188k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
188k
      float r00 = c00 + c01 + c10 + c11;
79
188k
      float r01 = c00 + c01 - c10 - c11;
80
188k
      float r10 = c00 - c01 + c10 - c11;
81
188k
      float r11 = c00 - c01 - c10 + c11;
82
188k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
188k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
188k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
188k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
188k
    }
87
94.4k
  }
88
236k
  for (size_t y = 0; y < S; y++) {
89
944k
    for (size_t x = 0; x < S; x++) {
90
755k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
755k
    }
92
188k
  }
93
47.2k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Line
Count
Source
67
47.2k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
47.2k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
47.2k
  static_assert(S % 2 == 0, "S should be even");
70
47.2k
  float temp[kDCTBlockSize];
71
47.2k
  constexpr size_t num_2x2 = S / 2;
72
236k
  for (size_t y = 0; y < num_2x2; y++) {
73
944k
    for (size_t x = 0; x < num_2x2; x++) {
74
755k
      float c00 = block[y * kBlockDim + x];
75
755k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
755k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
755k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
755k
      float r00 = c00 + c01 + c10 + c11;
79
755k
      float r01 = c00 + c01 - c10 - c11;
80
755k
      float r10 = c00 - c01 + c10 - c11;
81
755k
      float r11 = c00 - c01 - c10 + c11;
82
755k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
755k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
755k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
755k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
755k
    }
87
188k
  }
88
425k
  for (size_t y = 0; y < S; y++) {
89
3.40M
    for (size_t x = 0; x < S; x++) {
90
3.02M
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
3.02M
    }
92
377k
  }
93
47.2k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Line
Count
Source
67
110k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
110k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
110k
  static_assert(S % 2 == 0, "S should be even");
70
110k
  float temp[kDCTBlockSize];
71
110k
  constexpr size_t num_2x2 = S / 2;
72
221k
  for (size_t y = 0; y < num_2x2; y++) {
73
221k
    for (size_t x = 0; x < num_2x2; x++) {
74
110k
      float c00 = block[y * kBlockDim + x];
75
110k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
110k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
110k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
110k
      float r00 = c00 + c01 + c10 + c11;
79
110k
      float r01 = c00 + c01 - c10 - c11;
80
110k
      float r10 = c00 - c01 + c10 - c11;
81
110k
      float r11 = c00 - c01 - c10 + c11;
82
110k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
110k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
110k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
110k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
110k
    }
87
110k
  }
88
332k
  for (size_t y = 0; y < S; y++) {
89
665k
    for (size_t x = 0; x < S; x++) {
90
443k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
443k
    }
92
221k
  }
93
110k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Line
Count
Source
67
110k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
110k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
110k
  static_assert(S % 2 == 0, "S should be even");
70
110k
  float temp[kDCTBlockSize];
71
110k
  constexpr size_t num_2x2 = S / 2;
72
332k
  for (size_t y = 0; y < num_2x2; y++) {
73
665k
    for (size_t x = 0; x < num_2x2; x++) {
74
443k
      float c00 = block[y * kBlockDim + x];
75
443k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
443k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
443k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
443k
      float r00 = c00 + c01 + c10 + c11;
79
443k
      float r01 = c00 + c01 - c10 - c11;
80
443k
      float r10 = c00 - c01 + c10 - c11;
81
443k
      float r11 = c00 - c01 - c10 + c11;
82
443k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
443k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
443k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
443k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
443k
    }
87
221k
  }
88
554k
  for (size_t y = 0; y < S; y++) {
89
2.21M
    for (size_t x = 0; x < S; x++) {
90
1.77M
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
1.77M
    }
92
443k
  }
93
110k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Line
Count
Source
67
110k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
110k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
110k
  static_assert(S % 2 == 0, "S should be even");
70
110k
  float temp[kDCTBlockSize];
71
110k
  constexpr size_t num_2x2 = S / 2;
72
554k
  for (size_t y = 0; y < num_2x2; y++) {
73
2.21M
    for (size_t x = 0; x < num_2x2; x++) {
74
1.77M
      float c00 = block[y * kBlockDim + x];
75
1.77M
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
1.77M
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
1.77M
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
1.77M
      float r00 = c00 + c01 + c10 + c11;
79
1.77M
      float r01 = c00 + c01 - c10 - c11;
80
1.77M
      float r10 = c00 - c01 + c10 - c11;
81
1.77M
      float r11 = c00 - c01 - c10 + c11;
82
1.77M
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
1.77M
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
1.77M
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
1.77M
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
1.77M
    }
87
443k
  }
88
997k
  for (size_t y = 0; y < S; y++) {
89
7.97M
    for (size_t x = 0; x < S; x++) {
90
7.09M
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
7.09M
    }
92
886k
  }
93
110k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Line
Count
Source
67
36.3k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
36.3k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
36.3k
  static_assert(S % 2 == 0, "S should be even");
70
36.3k
  float temp[kDCTBlockSize];
71
36.3k
  constexpr size_t num_2x2 = S / 2;
72
72.7k
  for (size_t y = 0; y < num_2x2; y++) {
73
72.7k
    for (size_t x = 0; x < num_2x2; x++) {
74
36.3k
      float c00 = block[y * kBlockDim + x];
75
36.3k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
36.3k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
36.3k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
36.3k
      float r00 = c00 + c01 + c10 + c11;
79
36.3k
      float r01 = c00 + c01 - c10 - c11;
80
36.3k
      float r10 = c00 - c01 + c10 - c11;
81
36.3k
      float r11 = c00 - c01 - c10 + c11;
82
36.3k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
36.3k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
36.3k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
36.3k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
36.3k
    }
87
36.3k
  }
88
109k
  for (size_t y = 0; y < S; y++) {
89
218k
    for (size_t x = 0; x < S; x++) {
90
145k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
145k
    }
92
72.7k
  }
93
36.3k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Line
Count
Source
67
36.3k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
36.3k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
36.3k
  static_assert(S % 2 == 0, "S should be even");
70
36.3k
  float temp[kDCTBlockSize];
71
36.3k
  constexpr size_t num_2x2 = S / 2;
72
109k
  for (size_t y = 0; y < num_2x2; y++) {
73
218k
    for (size_t x = 0; x < num_2x2; x++) {
74
145k
      float c00 = block[y * kBlockDim + x];
75
145k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
145k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
145k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
145k
      float r00 = c00 + c01 + c10 + c11;
79
145k
      float r01 = c00 + c01 - c10 - c11;
80
145k
      float r10 = c00 - c01 + c10 - c11;
81
145k
      float r11 = c00 - c01 - c10 + c11;
82
145k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
145k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
145k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
145k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
145k
    }
87
72.7k
  }
88
181k
  for (size_t y = 0; y < S; y++) {
89
727k
    for (size_t x = 0; x < S; x++) {
90
581k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
581k
    }
92
145k
  }
93
36.3k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Line
Count
Source
67
36.3k
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
36.3k
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
36.3k
  static_assert(S % 2 == 0, "S should be even");
70
36.3k
  float temp[kDCTBlockSize];
71
36.3k
  constexpr size_t num_2x2 = S / 2;
72
181k
  for (size_t y = 0; y < num_2x2; y++) {
73
727k
    for (size_t x = 0; x < num_2x2; x++) {
74
581k
      float c00 = block[y * kBlockDim + x];
75
581k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
581k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
581k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
581k
      float r00 = c00 + c01 + c10 + c11;
79
581k
      float r01 = c00 + c01 - c10 - c11;
80
581k
      float r10 = c00 - c01 + c10 - c11;
81
581k
      float r11 = c00 - c01 - c10 + c11;
82
581k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
581k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
581k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
581k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
581k
    }
87
145k
  }
88
327k
  for (size_t y = 0; y < S; y++) {
89
2.61M
    for (size_t x = 0; x < S; x++) {
90
2.32M
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
2.32M
    }
92
290k
  }
93
36.3k
}
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Line
Count
Source
67
822
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
822
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
822
  static_assert(S % 2 == 0, "S should be even");
70
822
  float temp[kDCTBlockSize];
71
822
  constexpr size_t num_2x2 = S / 2;
72
1.64k
  for (size_t y = 0; y < num_2x2; y++) {
73
1.64k
    for (size_t x = 0; x < num_2x2; x++) {
74
822
      float c00 = block[y * kBlockDim + x];
75
822
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
822
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
822
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
822
      float r00 = c00 + c01 + c10 + c11;
79
822
      float r01 = c00 + c01 - c10 - c11;
80
822
      float r10 = c00 - c01 + c10 - c11;
81
822
      float r11 = c00 - c01 - c10 + c11;
82
822
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
822
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
822
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
822
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
822
    }
87
822
  }
88
2.46k
  for (size_t y = 0; y < S; y++) {
89
4.93k
    for (size_t x = 0; x < S; x++) {
90
3.28k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
3.28k
    }
92
1.64k
  }
93
822
}
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Line
Count
Source
67
822
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
822
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
822
  static_assert(S % 2 == 0, "S should be even");
70
822
  float temp[kDCTBlockSize];
71
822
  constexpr size_t num_2x2 = S / 2;
72
2.46k
  for (size_t y = 0; y < num_2x2; y++) {
73
4.93k
    for (size_t x = 0; x < num_2x2; x++) {
74
3.28k
      float c00 = block[y * kBlockDim + x];
75
3.28k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
3.28k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
3.28k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
3.28k
      float r00 = c00 + c01 + c10 + c11;
79
3.28k
      float r01 = c00 + c01 - c10 - c11;
80
3.28k
      float r10 = c00 - c01 + c10 - c11;
81
3.28k
      float r11 = c00 - c01 - c10 + c11;
82
3.28k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
3.28k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
3.28k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
3.28k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
3.28k
    }
87
1.64k
  }
88
4.11k
  for (size_t y = 0; y < S; y++) {
89
16.4k
    for (size_t x = 0; x < S; x++) {
90
13.1k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
13.1k
    }
92
3.28k
  }
93
822
}
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Line
Count
Source
67
822
void IDCT2TopBlock(const float* block, size_t stride_out, float* out) {
68
822
  static_assert(kBlockDim % S == 0, "S should be a divisor of kBlockDim");
69
822
  static_assert(S % 2 == 0, "S should be even");
70
822
  float temp[kDCTBlockSize];
71
822
  constexpr size_t num_2x2 = S / 2;
72
4.11k
  for (size_t y = 0; y < num_2x2; y++) {
73
16.4k
    for (size_t x = 0; x < num_2x2; x++) {
74
13.1k
      float c00 = block[y * kBlockDim + x];
75
13.1k
      float c01 = block[y * kBlockDim + num_2x2 + x];
76
13.1k
      float c10 = block[(y + num_2x2) * kBlockDim + x];
77
13.1k
      float c11 = block[(y + num_2x2) * kBlockDim + num_2x2 + x];
78
13.1k
      float r00 = c00 + c01 + c10 + c11;
79
13.1k
      float r01 = c00 + c01 - c10 - c11;
80
13.1k
      float r10 = c00 - c01 + c10 - c11;
81
13.1k
      float r11 = c00 - c01 - c10 + c11;
82
13.1k
      temp[y * 2 * kBlockDim + x * 2] = r00;
83
13.1k
      temp[y * 2 * kBlockDim + x * 2 + 1] = r01;
84
13.1k
      temp[(y * 2 + 1) * kBlockDim + x * 2] = r10;
85
13.1k
      temp[(y * 2 + 1) * kBlockDim + x * 2 + 1] = r11;
86
13.1k
    }
87
3.28k
  }
88
7.39k
  for (size_t y = 0; y < S; y++) {
89
59.1k
    for (size_t x = 0; x < S; x++) {
90
52.6k
      out[y * stride_out + x] = temp[y * kBlockDim + x];
91
52.6k
    }
92
6.57k
  }
93
822
}
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<2ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<4ul>(float const*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::IDCT2TopBlock<8ul>(float const*, unsigned long, float*)
94
95
42.7k
void AFVIDCT4x4(const float* JXL_RESTRICT coeffs, float* JXL_RESTRICT pixels) {
96
42.7k
  HWY_ALIGN static constexpr float k4x4AFVBasis[16][16] = {
97
42.7k
      {
98
42.7k
          0.25,
99
42.7k
          0.25,
100
42.7k
          0.25,
101
42.7k
          0.25,
102
42.7k
          0.25,
103
42.7k
          0.25,
104
42.7k
          0.25,
105
42.7k
          0.25,
106
42.7k
          0.25,
107
42.7k
          0.25,
108
42.7k
          0.25,
109
42.7k
          0.25,
110
42.7k
          0.25,
111
42.7k
          0.25,
112
42.7k
          0.25,
113
42.7k
          0.25,
114
42.7k
      },
115
42.7k
      {
116
42.7k
          0.876902929799142f,
117
42.7k
          0.2206518106944235f,
118
42.7k
          -0.10140050393753763f,
119
42.7k
          -0.1014005039375375f,
120
42.7k
          0.2206518106944236f,
121
42.7k
          -0.10140050393753777f,
122
42.7k
          -0.10140050393753772f,
123
42.7k
          -0.10140050393753763f,
124
42.7k
          -0.10140050393753758f,
125
42.7k
          -0.10140050393753769f,
126
42.7k
          -0.1014005039375375f,
127
42.7k
          -0.10140050393753768f,
128
42.7k
          -0.10140050393753768f,
129
42.7k
          -0.10140050393753759f,
130
42.7k
          -0.10140050393753763f,
131
42.7k
          -0.10140050393753741f,
132
42.7k
      },
133
42.7k
      {
134
42.7k
          0.0,
135
42.7k
          0.0,
136
42.7k
          0.40670075830260755f,
137
42.7k
          0.44444816619734445f,
138
42.7k
          0.0,
139
42.7k
          0.0,
140
42.7k
          0.19574399372042936f,
141
42.7k
          0.2929100136981264f,
142
42.7k
          -0.40670075830260716f,
143
42.7k
          -0.19574399372042872f,
144
42.7k
          0.0,
145
42.7k
          0.11379074460448091f,
146
42.7k
          -0.44444816619734384f,
147
42.7k
          -0.29291001369812636f,
148
42.7k
          -0.1137907446044814f,
149
42.7k
          0.0,
150
42.7k
      },
151
42.7k
      {
152
42.7k
          0.0,
153
42.7k
          0.0,
154
42.7k
          -0.21255748058288748f,
155
42.7k
          0.3085497062849767f,
156
42.7k
          0.0,
157
42.7k
          0.4706702258572536f,
158
42.7k
          -0.1621205195722993f,
159
42.7k
          0.0,
160
42.7k
          -0.21255748058287047f,
161
42.7k
          -0.16212051957228327f,
162
42.7k
          -0.47067022585725277f,
163
42.7k
          -0.1464291867126764f,
164
42.7k
          0.3085497062849487f,
165
42.7k
          0.0,
166
42.7k
          -0.14642918671266536f,
167
42.7k
          0.4251149611657548f,
168
42.7k
      },
169
42.7k
      {
170
42.7k
          0.0,
171
42.7k
          -0.7071067811865474f,
172
42.7k
          0.0,
173
42.7k
          0.0,
174
42.7k
          0.7071067811865476f,
175
42.7k
          0.0,
176
42.7k
          0.0,
177
42.7k
          0.0,
178
42.7k
          0.0,
179
42.7k
          0.0,
180
42.7k
          0.0,
181
42.7k
          0.0,
182
42.7k
          0.0,
183
42.7k
          0.0,
184
42.7k
          0.0,
185
42.7k
          0.0,
186
42.7k
      },
187
42.7k
      {
188
42.7k
          -0.4105377591765233f,
189
42.7k
          0.6235485373547691f,
190
42.7k
          -0.06435071657946274f,
191
42.7k
          -0.06435071657946266f,
192
42.7k
          0.6235485373547694f,
193
42.7k
          -0.06435071657946284f,
194
42.7k
          -0.0643507165794628f,
195
42.7k
          -0.06435071657946274f,
196
42.7k
          -0.06435071657946272f,
197
42.7k
          -0.06435071657946279f,
198
42.7k
          -0.06435071657946266f,
199
42.7k
          -0.06435071657946277f,
200
42.7k
          -0.06435071657946277f,
201
42.7k
          -0.06435071657946273f,
202
42.7k
          -0.06435071657946274f,
203
42.7k
          -0.0643507165794626f,
204
42.7k
      },
205
42.7k
      {
206
42.7k
          0.0,
207
42.7k
          0.0,
208
42.7k
          -0.4517556589999482f,
209
42.7k
          0.15854503551840063f,
210
42.7k
          0.0,
211
42.7k
          -0.04038515160822202f,
212
42.7k
          0.0074182263792423875f,
213
42.7k
          0.39351034269210167f,
214
42.7k
          -0.45175565899994635f,
215
42.7k
          0.007418226379244351f,
216
42.7k
          0.1107416575309343f,
217
42.7k
          0.08298163094882051f,
218
42.7k
          0.15854503551839705f,
219
42.7k
          0.3935103426921022f,
220
42.7k
          0.0829816309488214f,
221
42.7k
          -0.45175565899994796f,
222
42.7k
      },
223
42.7k
      {
224
42.7k
          0.0,
225
42.7k
          0.0,
226
42.7k
          -0.304684750724869f,
227
42.7k
          0.5112616136591823f,
228
42.7k
          0.0,
229
42.7k
          0.0,
230
42.7k
          -0.290480129728998f,
231
42.7k
          -0.06578701549142804f,
232
42.7k
          0.304684750724884f,
233
42.7k
          0.2904801297290076f,
234
42.7k
          0.0,
235
42.7k
          -0.23889773523344604f,
236
42.7k
          -0.5112616136592012f,
237
42.7k
          0.06578701549142545f,
238
42.7k
          0.23889773523345467f,
239
42.7k
          0.0,
240
42.7k
      },
241
42.7k
      {
242
42.7k
          0.0,
243
42.7k
          0.0,
244
42.7k
          0.3017929516615495f,
245
42.7k
          0.25792362796341184f,
246
42.7k
          0.0,
247
42.7k
          0.16272340142866204f,
248
42.7k
          0.09520022653475037f,
249
42.7k
          0.0,
250
42.7k
          0.3017929516615503f,
251
42.7k
          0.09520022653475055f,
252
42.7k
          -0.16272340142866173f,
253
42.7k
          -0.35312385449816297f,
254
42.7k
          0.25792362796341295f,
255
42.7k
          0.0,
256
42.7k
          -0.3531238544981624f,
257
42.7k
          -0.6035859033230976f,
258
42.7k
      },
259
42.7k
      {
260
42.7k
          0.0,
261
42.7k
          0.0,
262
42.7k
          0.40824829046386274f,
263
42.7k
          0.0,
264
42.7k
          0.0,
265
42.7k
          0.0,
266
42.7k
          0.0,
267
42.7k
          -0.4082482904638628f,
268
42.7k
          -0.4082482904638635f,
269
42.7k
          0.0,
270
42.7k
          0.0,
271
42.7k
          -0.40824829046386296f,
272
42.7k
          0.0,
273
42.7k
          0.4082482904638634f,
274
42.7k
          0.408248290463863f,
275
42.7k
          0.0,
276
42.7k
      },
277
42.7k
      {
278
42.7k
          0.0,
279
42.7k
          0.0,
280
42.7k
          0.1747866975480809f,
281
42.7k
          0.0812611176717539f,
282
42.7k
          0.0,
283
42.7k
          0.0,
284
42.7k
          -0.3675398009862027f,
285
42.7k
          -0.307882213957909f,
286
42.7k
          -0.17478669754808135f,
287
42.7k
          0.3675398009862011f,
288
42.7k
          0.0,
289
42.7k
          0.4826689115059883f,
290
42.7k
          -0.08126111767175039f,
291
42.7k
          0.30788221395790305f,
292
42.7k
          -0.48266891150598584f,
293
42.7k
          0.0,
294
42.7k
      },
295
42.7k
      {
296
42.7k
          0.0,
297
42.7k
          0.0,
298
42.7k
          -0.21105601049335784f,
299
42.7k
          0.18567180916109802f,
300
42.7k
          0.0,
301
42.7k
          0.0,
302
42.7k
          0.49215859013738733f,
303
42.7k
          -0.38525013709251915f,
304
42.7k
          0.21105601049335806f,
305
42.7k
          -0.49215859013738905f,
306
42.7k
          0.0,
307
42.7k
          0.17419412659916217f,
308
42.7k
          -0.18567180916109904f,
309
42.7k
          0.3852501370925211f,
310
42.7k
          -0.1741941265991621f,
311
42.7k
          0.0,
312
42.7k
      },
313
42.7k
      {
314
42.7k
          0.0,
315
42.7k
          0.0,
316
42.7k
          -0.14266084808807264f,
317
42.7k
          -0.3416446842253372f,
318
42.7k
          0.0,
319
42.7k
          0.7367497537172237f,
320
42.7k
          0.24627107722075148f,
321
42.7k
          -0.08574019035519306f,
322
42.7k
          -0.14266084808807344f,
323
42.7k
          0.24627107722075137f,
324
42.7k
          0.14883399227113567f,
325
42.7k
          -0.04768680350229251f,
326
42.7k
          -0.3416446842253373f,
327
42.7k
          -0.08574019035519267f,
328
42.7k
          -0.047686803502292804f,
329
42.7k
          -0.14266084808807242f,
330
42.7k
      },
331
42.7k
      {
332
42.7k
          0.0,
333
42.7k
          0.0,
334
42.7k
          -0.13813540350758585f,
335
42.7k
          0.3302282550303788f,
336
42.7k
          0.0,
337
42.7k
          0.08755115000587084f,
338
42.7k
          -0.07946706605909573f,
339
42.7k
          -0.4613374887461511f,
340
42.7k
          -0.13813540350758294f,
341
42.7k
          -0.07946706605910261f,
342
42.7k
          0.49724647109535086f,
343
42.7k
          0.12538059448563663f,
344
42.7k
          0.3302282550303805f,
345
42.7k
          -0.4613374887461554f,
346
42.7k
          0.12538059448564315f,
347
42.7k
          -0.13813540350758452f,
348
42.7k
      },
349
42.7k
      {
350
42.7k
          0.0,
351
42.7k
          0.0,
352
42.7k
          -0.17437602599651067f,
353
42.7k
          0.0702790691196284f,
354
42.7k
          0.0,
355
42.7k
          -0.2921026642334881f,
356
42.7k
          0.3623817333531167f,
357
42.7k
          0.0,
358
42.7k
          -0.1743760259965108f,
359
42.7k
          0.36238173335311646f,
360
42.7k
          0.29210266423348785f,
361
42.7k
          -0.4326608024727445f,
362
42.7k
          0.07027906911962818f,
363
42.7k
          0.0,
364
42.7k
          -0.4326608024727457f,
365
42.7k
          0.34875205199302267f,
366
42.7k
      },
367
42.7k
      {
368
42.7k
          0.0,
369
42.7k
          0.0,
370
42.7k
          0.11354987314994337f,
371
42.7k
          -0.07417504595810355f,
372
42.7k
          0.0,
373
42.7k
          0.19402893032594343f,
374
42.7k
          -0.435190496523228f,
375
42.7k
          0.21918684838857466f,
376
42.7k
          0.11354987314994257f,
377
42.7k
          -0.4351904965232251f,
378
42.7k
          0.5550443808910661f,
379
42.7k
          -0.25468277124066463f,
380
42.7k
          -0.07417504595810233f,
381
42.7k
          0.2191868483885728f,
382
42.7k
          -0.25468277124066413f,
383
42.7k
          0.1135498731499429f,
384
42.7k
      },
385
42.7k
  };
386
387
42.7k
  const HWY_CAPPED(float, 16) d;
388
166k
  for (size_t i = 0; i < 16; i += Lanes(d)) {
389
123k
    auto pixel = Zero(d);
390
2.09M
    for (size_t j = 0; j < 16; j++) {
391
1.97M
      auto cf = Set(d, coeffs[j]);
392
1.97M
      auto basis = Load(d, k4x4AFVBasis[j] + i);
393
1.97M
      pixel = MulAdd(cf, basis, pixel);
394
1.97M
    }
395
123k
    Store(pixel, d, pixels + i);
396
123k
  }
397
42.7k
}
dec_group.cc:jxl::N_SSE4::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Line
Count
Source
95
11.7k
void AFVIDCT4x4(const float* JXL_RESTRICT coeffs, float* JXL_RESTRICT pixels) {
96
11.7k
  HWY_ALIGN static constexpr float k4x4AFVBasis[16][16] = {
97
11.7k
      {
98
11.7k
          0.25,
99
11.7k
          0.25,
100
11.7k
          0.25,
101
11.7k
          0.25,
102
11.7k
          0.25,
103
11.7k
          0.25,
104
11.7k
          0.25,
105
11.7k
          0.25,
106
11.7k
          0.25,
107
11.7k
          0.25,
108
11.7k
          0.25,
109
11.7k
          0.25,
110
11.7k
          0.25,
111
11.7k
          0.25,
112
11.7k
          0.25,
113
11.7k
          0.25,
114
11.7k
      },
115
11.7k
      {
116
11.7k
          0.876902929799142f,
117
11.7k
          0.2206518106944235f,
118
11.7k
          -0.10140050393753763f,
119
11.7k
          -0.1014005039375375f,
120
11.7k
          0.2206518106944236f,
121
11.7k
          -0.10140050393753777f,
122
11.7k
          -0.10140050393753772f,
123
11.7k
          -0.10140050393753763f,
124
11.7k
          -0.10140050393753758f,
125
11.7k
          -0.10140050393753769f,
126
11.7k
          -0.1014005039375375f,
127
11.7k
          -0.10140050393753768f,
128
11.7k
          -0.10140050393753768f,
129
11.7k
          -0.10140050393753759f,
130
11.7k
          -0.10140050393753763f,
131
11.7k
          -0.10140050393753741f,
132
11.7k
      },
133
11.7k
      {
134
11.7k
          0.0,
135
11.7k
          0.0,
136
11.7k
          0.40670075830260755f,
137
11.7k
          0.44444816619734445f,
138
11.7k
          0.0,
139
11.7k
          0.0,
140
11.7k
          0.19574399372042936f,
141
11.7k
          0.2929100136981264f,
142
11.7k
          -0.40670075830260716f,
143
11.7k
          -0.19574399372042872f,
144
11.7k
          0.0,
145
11.7k
          0.11379074460448091f,
146
11.7k
          -0.44444816619734384f,
147
11.7k
          -0.29291001369812636f,
148
11.7k
          -0.1137907446044814f,
149
11.7k
          0.0,
150
11.7k
      },
151
11.7k
      {
152
11.7k
          0.0,
153
11.7k
          0.0,
154
11.7k
          -0.21255748058288748f,
155
11.7k
          0.3085497062849767f,
156
11.7k
          0.0,
157
11.7k
          0.4706702258572536f,
158
11.7k
          -0.1621205195722993f,
159
11.7k
          0.0,
160
11.7k
          -0.21255748058287047f,
161
11.7k
          -0.16212051957228327f,
162
11.7k
          -0.47067022585725277f,
163
11.7k
          -0.1464291867126764f,
164
11.7k
          0.3085497062849487f,
165
11.7k
          0.0,
166
11.7k
          -0.14642918671266536f,
167
11.7k
          0.4251149611657548f,
168
11.7k
      },
169
11.7k
      {
170
11.7k
          0.0,
171
11.7k
          -0.7071067811865474f,
172
11.7k
          0.0,
173
11.7k
          0.0,
174
11.7k
          0.7071067811865476f,
175
11.7k
          0.0,
176
11.7k
          0.0,
177
11.7k
          0.0,
178
11.7k
          0.0,
179
11.7k
          0.0,
180
11.7k
          0.0,
181
11.7k
          0.0,
182
11.7k
          0.0,
183
11.7k
          0.0,
184
11.7k
          0.0,
185
11.7k
          0.0,
186
11.7k
      },
187
11.7k
      {
188
11.7k
          -0.4105377591765233f,
189
11.7k
          0.6235485373547691f,
190
11.7k
          -0.06435071657946274f,
191
11.7k
          -0.06435071657946266f,
192
11.7k
          0.6235485373547694f,
193
11.7k
          -0.06435071657946284f,
194
11.7k
          -0.0643507165794628f,
195
11.7k
          -0.06435071657946274f,
196
11.7k
          -0.06435071657946272f,
197
11.7k
          -0.06435071657946279f,
198
11.7k
          -0.06435071657946266f,
199
11.7k
          -0.06435071657946277f,
200
11.7k
          -0.06435071657946277f,
201
11.7k
          -0.06435071657946273f,
202
11.7k
          -0.06435071657946274f,
203
11.7k
          -0.0643507165794626f,
204
11.7k
      },
205
11.7k
      {
206
11.7k
          0.0,
207
11.7k
          0.0,
208
11.7k
          -0.4517556589999482f,
209
11.7k
          0.15854503551840063f,
210
11.7k
          0.0,
211
11.7k
          -0.04038515160822202f,
212
11.7k
          0.0074182263792423875f,
213
11.7k
          0.39351034269210167f,
214
11.7k
          -0.45175565899994635f,
215
11.7k
          0.007418226379244351f,
216
11.7k
          0.1107416575309343f,
217
11.7k
          0.08298163094882051f,
218
11.7k
          0.15854503551839705f,
219
11.7k
          0.3935103426921022f,
220
11.7k
          0.0829816309488214f,
221
11.7k
          -0.45175565899994796f,
222
11.7k
      },
223
11.7k
      {
224
11.7k
          0.0,
225
11.7k
          0.0,
226
11.7k
          -0.304684750724869f,
227
11.7k
          0.5112616136591823f,
228
11.7k
          0.0,
229
11.7k
          0.0,
230
11.7k
          -0.290480129728998f,
231
11.7k
          -0.06578701549142804f,
232
11.7k
          0.304684750724884f,
233
11.7k
          0.2904801297290076f,
234
11.7k
          0.0,
235
11.7k
          -0.23889773523344604f,
236
11.7k
          -0.5112616136592012f,
237
11.7k
          0.06578701549142545f,
238
11.7k
          0.23889773523345467f,
239
11.7k
          0.0,
240
11.7k
      },
241
11.7k
      {
242
11.7k
          0.0,
243
11.7k
          0.0,
244
11.7k
          0.3017929516615495f,
245
11.7k
          0.25792362796341184f,
246
11.7k
          0.0,
247
11.7k
          0.16272340142866204f,
248
11.7k
          0.09520022653475037f,
249
11.7k
          0.0,
250
11.7k
          0.3017929516615503f,
251
11.7k
          0.09520022653475055f,
252
11.7k
          -0.16272340142866173f,
253
11.7k
          -0.35312385449816297f,
254
11.7k
          0.25792362796341295f,
255
11.7k
          0.0,
256
11.7k
          -0.3531238544981624f,
257
11.7k
          -0.6035859033230976f,
258
11.7k
      },
259
11.7k
      {
260
11.7k
          0.0,
261
11.7k
          0.0,
262
11.7k
          0.40824829046386274f,
263
11.7k
          0.0,
264
11.7k
          0.0,
265
11.7k
          0.0,
266
11.7k
          0.0,
267
11.7k
          -0.4082482904638628f,
268
11.7k
          -0.4082482904638635f,
269
11.7k
          0.0,
270
11.7k
          0.0,
271
11.7k
          -0.40824829046386296f,
272
11.7k
          0.0,
273
11.7k
          0.4082482904638634f,
274
11.7k
          0.408248290463863f,
275
11.7k
          0.0,
276
11.7k
      },
277
11.7k
      {
278
11.7k
          0.0,
279
11.7k
          0.0,
280
11.7k
          0.1747866975480809f,
281
11.7k
          0.0812611176717539f,
282
11.7k
          0.0,
283
11.7k
          0.0,
284
11.7k
          -0.3675398009862027f,
285
11.7k
          -0.307882213957909f,
286
11.7k
          -0.17478669754808135f,
287
11.7k
          0.3675398009862011f,
288
11.7k
          0.0,
289
11.7k
          0.4826689115059883f,
290
11.7k
          -0.08126111767175039f,
291
11.7k
          0.30788221395790305f,
292
11.7k
          -0.48266891150598584f,
293
11.7k
          0.0,
294
11.7k
      },
295
11.7k
      {
296
11.7k
          0.0,
297
11.7k
          0.0,
298
11.7k
          -0.21105601049335784f,
299
11.7k
          0.18567180916109802f,
300
11.7k
          0.0,
301
11.7k
          0.0,
302
11.7k
          0.49215859013738733f,
303
11.7k
          -0.38525013709251915f,
304
11.7k
          0.21105601049335806f,
305
11.7k
          -0.49215859013738905f,
306
11.7k
          0.0,
307
11.7k
          0.17419412659916217f,
308
11.7k
          -0.18567180916109904f,
309
11.7k
          0.3852501370925211f,
310
11.7k
          -0.1741941265991621f,
311
11.7k
          0.0,
312
11.7k
      },
313
11.7k
      {
314
11.7k
          0.0,
315
11.7k
          0.0,
316
11.7k
          -0.14266084808807264f,
317
11.7k
          -0.3416446842253372f,
318
11.7k
          0.0,
319
11.7k
          0.7367497537172237f,
320
11.7k
          0.24627107722075148f,
321
11.7k
          -0.08574019035519306f,
322
11.7k
          -0.14266084808807344f,
323
11.7k
          0.24627107722075137f,
324
11.7k
          0.14883399227113567f,
325
11.7k
          -0.04768680350229251f,
326
11.7k
          -0.3416446842253373f,
327
11.7k
          -0.08574019035519267f,
328
11.7k
          -0.047686803502292804f,
329
11.7k
          -0.14266084808807242f,
330
11.7k
      },
331
11.7k
      {
332
11.7k
          0.0,
333
11.7k
          0.0,
334
11.7k
          -0.13813540350758585f,
335
11.7k
          0.3302282550303788f,
336
11.7k
          0.0,
337
11.7k
          0.08755115000587084f,
338
11.7k
          -0.07946706605909573f,
339
11.7k
          -0.4613374887461511f,
340
11.7k
          -0.13813540350758294f,
341
11.7k
          -0.07946706605910261f,
342
11.7k
          0.49724647109535086f,
343
11.7k
          0.12538059448563663f,
344
11.7k
          0.3302282550303805f,
345
11.7k
          -0.4613374887461554f,
346
11.7k
          0.12538059448564315f,
347
11.7k
          -0.13813540350758452f,
348
11.7k
      },
349
11.7k
      {
350
11.7k
          0.0,
351
11.7k
          0.0,
352
11.7k
          -0.17437602599651067f,
353
11.7k
          0.0702790691196284f,
354
11.7k
          0.0,
355
11.7k
          -0.2921026642334881f,
356
11.7k
          0.3623817333531167f,
357
11.7k
          0.0,
358
11.7k
          -0.1743760259965108f,
359
11.7k
          0.36238173335311646f,
360
11.7k
          0.29210266423348785f,
361
11.7k
          -0.4326608024727445f,
362
11.7k
          0.07027906911962818f,
363
11.7k
          0.0,
364
11.7k
          -0.4326608024727457f,
365
11.7k
          0.34875205199302267f,
366
11.7k
      },
367
11.7k
      {
368
11.7k
          0.0,
369
11.7k
          0.0,
370
11.7k
          0.11354987314994337f,
371
11.7k
          -0.07417504595810355f,
372
11.7k
          0.0,
373
11.7k
          0.19402893032594343f,
374
11.7k
          -0.435190496523228f,
375
11.7k
          0.21918684838857466f,
376
11.7k
          0.11354987314994257f,
377
11.7k
          -0.4351904965232251f,
378
11.7k
          0.5550443808910661f,
379
11.7k
          -0.25468277124066463f,
380
11.7k
          -0.07417504595810233f,
381
11.7k
          0.2191868483885728f,
382
11.7k
          -0.25468277124066413f,
383
11.7k
          0.1135498731499429f,
384
11.7k
      },
385
11.7k
  };
386
387
11.7k
  const HWY_CAPPED(float, 16) d;
388
58.8k
  for (size_t i = 0; i < 16; i += Lanes(d)) {
389
47.0k
    auto pixel = Zero(d);
390
800k
    for (size_t j = 0; j < 16; j++) {
391
752k
      auto cf = Set(d, coeffs[j]);
392
752k
      auto basis = Load(d, k4x4AFVBasis[j] + i);
393
752k
      pixel = MulAdd(cf, basis, pixel);
394
752k
    }
395
47.0k
    Store(pixel, d, pixels + i);
396
47.0k
  }
397
11.7k
}
dec_group.cc:jxl::N_AVX2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Line
Count
Source
95
20.5k
void AFVIDCT4x4(const float* JXL_RESTRICT coeffs, float* JXL_RESTRICT pixels) {
96
20.5k
  HWY_ALIGN static constexpr float k4x4AFVBasis[16][16] = {
97
20.5k
      {
98
20.5k
          0.25,
99
20.5k
          0.25,
100
20.5k
          0.25,
101
20.5k
          0.25,
102
20.5k
          0.25,
103
20.5k
          0.25,
104
20.5k
          0.25,
105
20.5k
          0.25,
106
20.5k
          0.25,
107
20.5k
          0.25,
108
20.5k
          0.25,
109
20.5k
          0.25,
110
20.5k
          0.25,
111
20.5k
          0.25,
112
20.5k
          0.25,
113
20.5k
          0.25,
114
20.5k
      },
115
20.5k
      {
116
20.5k
          0.876902929799142f,
117
20.5k
          0.2206518106944235f,
118
20.5k
          -0.10140050393753763f,
119
20.5k
          -0.1014005039375375f,
120
20.5k
          0.2206518106944236f,
121
20.5k
          -0.10140050393753777f,
122
20.5k
          -0.10140050393753772f,
123
20.5k
          -0.10140050393753763f,
124
20.5k
          -0.10140050393753758f,
125
20.5k
          -0.10140050393753769f,
126
20.5k
          -0.1014005039375375f,
127
20.5k
          -0.10140050393753768f,
128
20.5k
          -0.10140050393753768f,
129
20.5k
          -0.10140050393753759f,
130
20.5k
          -0.10140050393753763f,
131
20.5k
          -0.10140050393753741f,
132
20.5k
      },
133
20.5k
      {
134
20.5k
          0.0,
135
20.5k
          0.0,
136
20.5k
          0.40670075830260755f,
137
20.5k
          0.44444816619734445f,
138
20.5k
          0.0,
139
20.5k
          0.0,
140
20.5k
          0.19574399372042936f,
141
20.5k
          0.2929100136981264f,
142
20.5k
          -0.40670075830260716f,
143
20.5k
          -0.19574399372042872f,
144
20.5k
          0.0,
145
20.5k
          0.11379074460448091f,
146
20.5k
          -0.44444816619734384f,
147
20.5k
          -0.29291001369812636f,
148
20.5k
          -0.1137907446044814f,
149
20.5k
          0.0,
150
20.5k
      },
151
20.5k
      {
152
20.5k
          0.0,
153
20.5k
          0.0,
154
20.5k
          -0.21255748058288748f,
155
20.5k
          0.3085497062849767f,
156
20.5k
          0.0,
157
20.5k
          0.4706702258572536f,
158
20.5k
          -0.1621205195722993f,
159
20.5k
          0.0,
160
20.5k
          -0.21255748058287047f,
161
20.5k
          -0.16212051957228327f,
162
20.5k
          -0.47067022585725277f,
163
20.5k
          -0.1464291867126764f,
164
20.5k
          0.3085497062849487f,
165
20.5k
          0.0,
166
20.5k
          -0.14642918671266536f,
167
20.5k
          0.4251149611657548f,
168
20.5k
      },
169
20.5k
      {
170
20.5k
          0.0,
171
20.5k
          -0.7071067811865474f,
172
20.5k
          0.0,
173
20.5k
          0.0,
174
20.5k
          0.7071067811865476f,
175
20.5k
          0.0,
176
20.5k
          0.0,
177
20.5k
          0.0,
178
20.5k
          0.0,
179
20.5k
          0.0,
180
20.5k
          0.0,
181
20.5k
          0.0,
182
20.5k
          0.0,
183
20.5k
          0.0,
184
20.5k
          0.0,
185
20.5k
          0.0,
186
20.5k
      },
187
20.5k
      {
188
20.5k
          -0.4105377591765233f,
189
20.5k
          0.6235485373547691f,
190
20.5k
          -0.06435071657946274f,
191
20.5k
          -0.06435071657946266f,
192
20.5k
          0.6235485373547694f,
193
20.5k
          -0.06435071657946284f,
194
20.5k
          -0.0643507165794628f,
195
20.5k
          -0.06435071657946274f,
196
20.5k
          -0.06435071657946272f,
197
20.5k
          -0.06435071657946279f,
198
20.5k
          -0.06435071657946266f,
199
20.5k
          -0.06435071657946277f,
200
20.5k
          -0.06435071657946277f,
201
20.5k
          -0.06435071657946273f,
202
20.5k
          -0.06435071657946274f,
203
20.5k
          -0.0643507165794626f,
204
20.5k
      },
205
20.5k
      {
206
20.5k
          0.0,
207
20.5k
          0.0,
208
20.5k
          -0.4517556589999482f,
209
20.5k
          0.15854503551840063f,
210
20.5k
          0.0,
211
20.5k
          -0.04038515160822202f,
212
20.5k
          0.0074182263792423875f,
213
20.5k
          0.39351034269210167f,
214
20.5k
          -0.45175565899994635f,
215
20.5k
          0.007418226379244351f,
216
20.5k
          0.1107416575309343f,
217
20.5k
          0.08298163094882051f,
218
20.5k
          0.15854503551839705f,
219
20.5k
          0.3935103426921022f,
220
20.5k
          0.0829816309488214f,
221
20.5k
          -0.45175565899994796f,
222
20.5k
      },
223
20.5k
      {
224
20.5k
          0.0,
225
20.5k
          0.0,
226
20.5k
          -0.304684750724869f,
227
20.5k
          0.5112616136591823f,
228
20.5k
          0.0,
229
20.5k
          0.0,
230
20.5k
          -0.290480129728998f,
231
20.5k
          -0.06578701549142804f,
232
20.5k
          0.304684750724884f,
233
20.5k
          0.2904801297290076f,
234
20.5k
          0.0,
235
20.5k
          -0.23889773523344604f,
236
20.5k
          -0.5112616136592012f,
237
20.5k
          0.06578701549142545f,
238
20.5k
          0.23889773523345467f,
239
20.5k
          0.0,
240
20.5k
      },
241
20.5k
      {
242
20.5k
          0.0,
243
20.5k
          0.0,
244
20.5k
          0.3017929516615495f,
245
20.5k
          0.25792362796341184f,
246
20.5k
          0.0,
247
20.5k
          0.16272340142866204f,
248
20.5k
          0.09520022653475037f,
249
20.5k
          0.0,
250
20.5k
          0.3017929516615503f,
251
20.5k
          0.09520022653475055f,
252
20.5k
          -0.16272340142866173f,
253
20.5k
          -0.35312385449816297f,
254
20.5k
          0.25792362796341295f,
255
20.5k
          0.0,
256
20.5k
          -0.3531238544981624f,
257
20.5k
          -0.6035859033230976f,
258
20.5k
      },
259
20.5k
      {
260
20.5k
          0.0,
261
20.5k
          0.0,
262
20.5k
          0.40824829046386274f,
263
20.5k
          0.0,
264
20.5k
          0.0,
265
20.5k
          0.0,
266
20.5k
          0.0,
267
20.5k
          -0.4082482904638628f,
268
20.5k
          -0.4082482904638635f,
269
20.5k
          0.0,
270
20.5k
          0.0,
271
20.5k
          -0.40824829046386296f,
272
20.5k
          0.0,
273
20.5k
          0.4082482904638634f,
274
20.5k
          0.408248290463863f,
275
20.5k
          0.0,
276
20.5k
      },
277
20.5k
      {
278
20.5k
          0.0,
279
20.5k
          0.0,
280
20.5k
          0.1747866975480809f,
281
20.5k
          0.0812611176717539f,
282
20.5k
          0.0,
283
20.5k
          0.0,
284
20.5k
          -0.3675398009862027f,
285
20.5k
          -0.307882213957909f,
286
20.5k
          -0.17478669754808135f,
287
20.5k
          0.3675398009862011f,
288
20.5k
          0.0,
289
20.5k
          0.4826689115059883f,
290
20.5k
          -0.08126111767175039f,
291
20.5k
          0.30788221395790305f,
292
20.5k
          -0.48266891150598584f,
293
20.5k
          0.0,
294
20.5k
      },
295
20.5k
      {
296
20.5k
          0.0,
297
20.5k
          0.0,
298
20.5k
          -0.21105601049335784f,
299
20.5k
          0.18567180916109802f,
300
20.5k
          0.0,
301
20.5k
          0.0,
302
20.5k
          0.49215859013738733f,
303
20.5k
          -0.38525013709251915f,
304
20.5k
          0.21105601049335806f,
305
20.5k
          -0.49215859013738905f,
306
20.5k
          0.0,
307
20.5k
          0.17419412659916217f,
308
20.5k
          -0.18567180916109904f,
309
20.5k
          0.3852501370925211f,
310
20.5k
          -0.1741941265991621f,
311
20.5k
          0.0,
312
20.5k
      },
313
20.5k
      {
314
20.5k
          0.0,
315
20.5k
          0.0,
316
20.5k
          -0.14266084808807264f,
317
20.5k
          -0.3416446842253372f,
318
20.5k
          0.0,
319
20.5k
          0.7367497537172237f,
320
20.5k
          0.24627107722075148f,
321
20.5k
          -0.08574019035519306f,
322
20.5k
          -0.14266084808807344f,
323
20.5k
          0.24627107722075137f,
324
20.5k
          0.14883399227113567f,
325
20.5k
          -0.04768680350229251f,
326
20.5k
          -0.3416446842253373f,
327
20.5k
          -0.08574019035519267f,
328
20.5k
          -0.047686803502292804f,
329
20.5k
          -0.14266084808807242f,
330
20.5k
      },
331
20.5k
      {
332
20.5k
          0.0,
333
20.5k
          0.0,
334
20.5k
          -0.13813540350758585f,
335
20.5k
          0.3302282550303788f,
336
20.5k
          0.0,
337
20.5k
          0.08755115000587084f,
338
20.5k
          -0.07946706605909573f,
339
20.5k
          -0.4613374887461511f,
340
20.5k
          -0.13813540350758294f,
341
20.5k
          -0.07946706605910261f,
342
20.5k
          0.49724647109535086f,
343
20.5k
          0.12538059448563663f,
344
20.5k
          0.3302282550303805f,
345
20.5k
          -0.4613374887461554f,
346
20.5k
          0.12538059448564315f,
347
20.5k
          -0.13813540350758452f,
348
20.5k
      },
349
20.5k
      {
350
20.5k
          0.0,
351
20.5k
          0.0,
352
20.5k
          -0.17437602599651067f,
353
20.5k
          0.0702790691196284f,
354
20.5k
          0.0,
355
20.5k
          -0.2921026642334881f,
356
20.5k
          0.3623817333531167f,
357
20.5k
          0.0,
358
20.5k
          -0.1743760259965108f,
359
20.5k
          0.36238173335311646f,
360
20.5k
          0.29210266423348785f,
361
20.5k
          -0.4326608024727445f,
362
20.5k
          0.07027906911962818f,
363
20.5k
          0.0,
364
20.5k
          -0.4326608024727457f,
365
20.5k
          0.34875205199302267f,
366
20.5k
      },
367
20.5k
      {
368
20.5k
          0.0,
369
20.5k
          0.0,
370
20.5k
          0.11354987314994337f,
371
20.5k
          -0.07417504595810355f,
372
20.5k
          0.0,
373
20.5k
          0.19402893032594343f,
374
20.5k
          -0.435190496523228f,
375
20.5k
          0.21918684838857466f,
376
20.5k
          0.11354987314994257f,
377
20.5k
          -0.4351904965232251f,
378
20.5k
          0.5550443808910661f,
379
20.5k
          -0.25468277124066463f,
380
20.5k
          -0.07417504595810233f,
381
20.5k
          0.2191868483885728f,
382
20.5k
          -0.25468277124066413f,
383
20.5k
          0.1135498731499429f,
384
20.5k
      },
385
20.5k
  };
386
387
20.5k
  const HWY_CAPPED(float, 16) d;
388
61.5k
  for (size_t i = 0; i < 16; i += Lanes(d)) {
389
41.0k
    auto pixel = Zero(d);
390
697k
    for (size_t j = 0; j < 16; j++) {
391
656k
      auto cf = Set(d, coeffs[j]);
392
656k
      auto basis = Load(d, k4x4AFVBasis[j] + i);
393
656k
      pixel = MulAdd(cf, basis, pixel);
394
656k
    }
395
41.0k
    Store(pixel, d, pixels + i);
396
41.0k
  }
397
20.5k
}
dec_group.cc:jxl::N_SSE2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Line
Count
Source
95
7.19k
void AFVIDCT4x4(const float* JXL_RESTRICT coeffs, float* JXL_RESTRICT pixels) {
96
7.19k
  HWY_ALIGN static constexpr float k4x4AFVBasis[16][16] = {
97
7.19k
      {
98
7.19k
          0.25,
99
7.19k
          0.25,
100
7.19k
          0.25,
101
7.19k
          0.25,
102
7.19k
          0.25,
103
7.19k
          0.25,
104
7.19k
          0.25,
105
7.19k
          0.25,
106
7.19k
          0.25,
107
7.19k
          0.25,
108
7.19k
          0.25,
109
7.19k
          0.25,
110
7.19k
          0.25,
111
7.19k
          0.25,
112
7.19k
          0.25,
113
7.19k
          0.25,
114
7.19k
      },
115
7.19k
      {
116
7.19k
          0.876902929799142f,
117
7.19k
          0.2206518106944235f,
118
7.19k
          -0.10140050393753763f,
119
7.19k
          -0.1014005039375375f,
120
7.19k
          0.2206518106944236f,
121
7.19k
          -0.10140050393753777f,
122
7.19k
          -0.10140050393753772f,
123
7.19k
          -0.10140050393753763f,
124
7.19k
          -0.10140050393753758f,
125
7.19k
          -0.10140050393753769f,
126
7.19k
          -0.1014005039375375f,
127
7.19k
          -0.10140050393753768f,
128
7.19k
          -0.10140050393753768f,
129
7.19k
          -0.10140050393753759f,
130
7.19k
          -0.10140050393753763f,
131
7.19k
          -0.10140050393753741f,
132
7.19k
      },
133
7.19k
      {
134
7.19k
          0.0,
135
7.19k
          0.0,
136
7.19k
          0.40670075830260755f,
137
7.19k
          0.44444816619734445f,
138
7.19k
          0.0,
139
7.19k
          0.0,
140
7.19k
          0.19574399372042936f,
141
7.19k
          0.2929100136981264f,
142
7.19k
          -0.40670075830260716f,
143
7.19k
          -0.19574399372042872f,
144
7.19k
          0.0,
145
7.19k
          0.11379074460448091f,
146
7.19k
          -0.44444816619734384f,
147
7.19k
          -0.29291001369812636f,
148
7.19k
          -0.1137907446044814f,
149
7.19k
          0.0,
150
7.19k
      },
151
7.19k
      {
152
7.19k
          0.0,
153
7.19k
          0.0,
154
7.19k
          -0.21255748058288748f,
155
7.19k
          0.3085497062849767f,
156
7.19k
          0.0,
157
7.19k
          0.4706702258572536f,
158
7.19k
          -0.1621205195722993f,
159
7.19k
          0.0,
160
7.19k
          -0.21255748058287047f,
161
7.19k
          -0.16212051957228327f,
162
7.19k
          -0.47067022585725277f,
163
7.19k
          -0.1464291867126764f,
164
7.19k
          0.3085497062849487f,
165
7.19k
          0.0,
166
7.19k
          -0.14642918671266536f,
167
7.19k
          0.4251149611657548f,
168
7.19k
      },
169
7.19k
      {
170
7.19k
          0.0,
171
7.19k
          -0.7071067811865474f,
172
7.19k
          0.0,
173
7.19k
          0.0,
174
7.19k
          0.7071067811865476f,
175
7.19k
          0.0,
176
7.19k
          0.0,
177
7.19k
          0.0,
178
7.19k
          0.0,
179
7.19k
          0.0,
180
7.19k
          0.0,
181
7.19k
          0.0,
182
7.19k
          0.0,
183
7.19k
          0.0,
184
7.19k
          0.0,
185
7.19k
          0.0,
186
7.19k
      },
187
7.19k
      {
188
7.19k
          -0.4105377591765233f,
189
7.19k
          0.6235485373547691f,
190
7.19k
          -0.06435071657946274f,
191
7.19k
          -0.06435071657946266f,
192
7.19k
          0.6235485373547694f,
193
7.19k
          -0.06435071657946284f,
194
7.19k
          -0.0643507165794628f,
195
7.19k
          -0.06435071657946274f,
196
7.19k
          -0.06435071657946272f,
197
7.19k
          -0.06435071657946279f,
198
7.19k
          -0.06435071657946266f,
199
7.19k
          -0.06435071657946277f,
200
7.19k
          -0.06435071657946277f,
201
7.19k
          -0.06435071657946273f,
202
7.19k
          -0.06435071657946274f,
203
7.19k
          -0.0643507165794626f,
204
7.19k
      },
205
7.19k
      {
206
7.19k
          0.0,
207
7.19k
          0.0,
208
7.19k
          -0.4517556589999482f,
209
7.19k
          0.15854503551840063f,
210
7.19k
          0.0,
211
7.19k
          -0.04038515160822202f,
212
7.19k
          0.0074182263792423875f,
213
7.19k
          0.39351034269210167f,
214
7.19k
          -0.45175565899994635f,
215
7.19k
          0.007418226379244351f,
216
7.19k
          0.1107416575309343f,
217
7.19k
          0.08298163094882051f,
218
7.19k
          0.15854503551839705f,
219
7.19k
          0.3935103426921022f,
220
7.19k
          0.0829816309488214f,
221
7.19k
          -0.45175565899994796f,
222
7.19k
      },
223
7.19k
      {
224
7.19k
          0.0,
225
7.19k
          0.0,
226
7.19k
          -0.304684750724869f,
227
7.19k
          0.5112616136591823f,
228
7.19k
          0.0,
229
7.19k
          0.0,
230
7.19k
          -0.290480129728998f,
231
7.19k
          -0.06578701549142804f,
232
7.19k
          0.304684750724884f,
233
7.19k
          0.2904801297290076f,
234
7.19k
          0.0,
235
7.19k
          -0.23889773523344604f,
236
7.19k
          -0.5112616136592012f,
237
7.19k
          0.06578701549142545f,
238
7.19k
          0.23889773523345467f,
239
7.19k
          0.0,
240
7.19k
      },
241
7.19k
      {
242
7.19k
          0.0,
243
7.19k
          0.0,
244
7.19k
          0.3017929516615495f,
245
7.19k
          0.25792362796341184f,
246
7.19k
          0.0,
247
7.19k
          0.16272340142866204f,
248
7.19k
          0.09520022653475037f,
249
7.19k
          0.0,
250
7.19k
          0.3017929516615503f,
251
7.19k
          0.09520022653475055f,
252
7.19k
          -0.16272340142866173f,
253
7.19k
          -0.35312385449816297f,
254
7.19k
          0.25792362796341295f,
255
7.19k
          0.0,
256
7.19k
          -0.3531238544981624f,
257
7.19k
          -0.6035859033230976f,
258
7.19k
      },
259
7.19k
      {
260
7.19k
          0.0,
261
7.19k
          0.0,
262
7.19k
          0.40824829046386274f,
263
7.19k
          0.0,
264
7.19k
          0.0,
265
7.19k
          0.0,
266
7.19k
          0.0,
267
7.19k
          -0.4082482904638628f,
268
7.19k
          -0.4082482904638635f,
269
7.19k
          0.0,
270
7.19k
          0.0,
271
7.19k
          -0.40824829046386296f,
272
7.19k
          0.0,
273
7.19k
          0.4082482904638634f,
274
7.19k
          0.408248290463863f,
275
7.19k
          0.0,
276
7.19k
      },
277
7.19k
      {
278
7.19k
          0.0,
279
7.19k
          0.0,
280
7.19k
          0.1747866975480809f,
281
7.19k
          0.0812611176717539f,
282
7.19k
          0.0,
283
7.19k
          0.0,
284
7.19k
          -0.3675398009862027f,
285
7.19k
          -0.307882213957909f,
286
7.19k
          -0.17478669754808135f,
287
7.19k
          0.3675398009862011f,
288
7.19k
          0.0,
289
7.19k
          0.4826689115059883f,
290
7.19k
          -0.08126111767175039f,
291
7.19k
          0.30788221395790305f,
292
7.19k
          -0.48266891150598584f,
293
7.19k
          0.0,
294
7.19k
      },
295
7.19k
      {
296
7.19k
          0.0,
297
7.19k
          0.0,
298
7.19k
          -0.21105601049335784f,
299
7.19k
          0.18567180916109802f,
300
7.19k
          0.0,
301
7.19k
          0.0,
302
7.19k
          0.49215859013738733f,
303
7.19k
          -0.38525013709251915f,
304
7.19k
          0.21105601049335806f,
305
7.19k
          -0.49215859013738905f,
306
7.19k
          0.0,
307
7.19k
          0.17419412659916217f,
308
7.19k
          -0.18567180916109904f,
309
7.19k
          0.3852501370925211f,
310
7.19k
          -0.1741941265991621f,
311
7.19k
          0.0,
312
7.19k
      },
313
7.19k
      {
314
7.19k
          0.0,
315
7.19k
          0.0,
316
7.19k
          -0.14266084808807264f,
317
7.19k
          -0.3416446842253372f,
318
7.19k
          0.0,
319
7.19k
          0.7367497537172237f,
320
7.19k
          0.24627107722075148f,
321
7.19k
          -0.08574019035519306f,
322
7.19k
          -0.14266084808807344f,
323
7.19k
          0.24627107722075137f,
324
7.19k
          0.14883399227113567f,
325
7.19k
          -0.04768680350229251f,
326
7.19k
          -0.3416446842253373f,
327
7.19k
          -0.08574019035519267f,
328
7.19k
          -0.047686803502292804f,
329
7.19k
          -0.14266084808807242f,
330
7.19k
      },
331
7.19k
      {
332
7.19k
          0.0,
333
7.19k
          0.0,
334
7.19k
          -0.13813540350758585f,
335
7.19k
          0.3302282550303788f,
336
7.19k
          0.0,
337
7.19k
          0.08755115000587084f,
338
7.19k
          -0.07946706605909573f,
339
7.19k
          -0.4613374887461511f,
340
7.19k
          -0.13813540350758294f,
341
7.19k
          -0.07946706605910261f,
342
7.19k
          0.49724647109535086f,
343
7.19k
          0.12538059448563663f,
344
7.19k
          0.3302282550303805f,
345
7.19k
          -0.4613374887461554f,
346
7.19k
          0.12538059448564315f,
347
7.19k
          -0.13813540350758452f,
348
7.19k
      },
349
7.19k
      {
350
7.19k
          0.0,
351
7.19k
          0.0,
352
7.19k
          -0.17437602599651067f,
353
7.19k
          0.0702790691196284f,
354
7.19k
          0.0,
355
7.19k
          -0.2921026642334881f,
356
7.19k
          0.3623817333531167f,
357
7.19k
          0.0,
358
7.19k
          -0.1743760259965108f,
359
7.19k
          0.36238173335311646f,
360
7.19k
          0.29210266423348785f,
361
7.19k
          -0.4326608024727445f,
362
7.19k
          0.07027906911962818f,
363
7.19k
          0.0,
364
7.19k
          -0.4326608024727457f,
365
7.19k
          0.34875205199302267f,
366
7.19k
      },
367
7.19k
      {
368
7.19k
          0.0,
369
7.19k
          0.0,
370
7.19k
          0.11354987314994337f,
371
7.19k
          -0.07417504595810355f,
372
7.19k
          0.0,
373
7.19k
          0.19402893032594343f,
374
7.19k
          -0.435190496523228f,
375
7.19k
          0.21918684838857466f,
376
7.19k
          0.11354987314994257f,
377
7.19k
          -0.4351904965232251f,
378
7.19k
          0.5550443808910661f,
379
7.19k
          -0.25468277124066463f,
380
7.19k
          -0.07417504595810233f,
381
7.19k
          0.2191868483885728f,
382
7.19k
          -0.25468277124066413f,
383
7.19k
          0.1135498731499429f,
384
7.19k
      },
385
7.19k
  };
386
387
7.19k
  const HWY_CAPPED(float, 16) d;
388
35.9k
  for (size_t i = 0; i < 16; i += Lanes(d)) {
389
28.7k
    auto pixel = Zero(d);
390
488k
    for (size_t j = 0; j < 16; j++) {
391
460k
      auto cf = Set(d, coeffs[j]);
392
460k
      auto basis = Load(d, k4x4AFVBasis[j] + i);
393
460k
      pixel = MulAdd(cf, basis, pixel);
394
460k
    }
395
28.7k
    Store(pixel, d, pixels + i);
396
28.7k
  }
397
7.19k
}
Unexecuted instantiation: enc_group.cc:jxl::N_SSE4::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Unexecuted instantiation: enc_group.cc:jxl::N_AVX2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Unexecuted instantiation: enc_group.cc:jxl::N_SSE2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_SSE4::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
enc_ac_strategy.cc:jxl::N_AVX2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Line
Count
Source
95
3.28k
void AFVIDCT4x4(const float* JXL_RESTRICT coeffs, float* JXL_RESTRICT pixels) {
96
3.28k
  HWY_ALIGN static constexpr float k4x4AFVBasis[16][16] = {
97
3.28k
      {
98
3.28k
          0.25,
99
3.28k
          0.25,
100
3.28k
          0.25,
101
3.28k
          0.25,
102
3.28k
          0.25,
103
3.28k
          0.25,
104
3.28k
          0.25,
105
3.28k
          0.25,
106
3.28k
          0.25,
107
3.28k
          0.25,
108
3.28k
          0.25,
109
3.28k
          0.25,
110
3.28k
          0.25,
111
3.28k
          0.25,
112
3.28k
          0.25,
113
3.28k
          0.25,
114
3.28k
      },
115
3.28k
      {
116
3.28k
          0.876902929799142f,
117
3.28k
          0.2206518106944235f,
118
3.28k
          -0.10140050393753763f,
119
3.28k
          -0.1014005039375375f,
120
3.28k
          0.2206518106944236f,
121
3.28k
          -0.10140050393753777f,
122
3.28k
          -0.10140050393753772f,
123
3.28k
          -0.10140050393753763f,
124
3.28k
          -0.10140050393753758f,
125
3.28k
          -0.10140050393753769f,
126
3.28k
          -0.1014005039375375f,
127
3.28k
          -0.10140050393753768f,
128
3.28k
          -0.10140050393753768f,
129
3.28k
          -0.10140050393753759f,
130
3.28k
          -0.10140050393753763f,
131
3.28k
          -0.10140050393753741f,
132
3.28k
      },
133
3.28k
      {
134
3.28k
          0.0,
135
3.28k
          0.0,
136
3.28k
          0.40670075830260755f,
137
3.28k
          0.44444816619734445f,
138
3.28k
          0.0,
139
3.28k
          0.0,
140
3.28k
          0.19574399372042936f,
141
3.28k
          0.2929100136981264f,
142
3.28k
          -0.40670075830260716f,
143
3.28k
          -0.19574399372042872f,
144
3.28k
          0.0,
145
3.28k
          0.11379074460448091f,
146
3.28k
          -0.44444816619734384f,
147
3.28k
          -0.29291001369812636f,
148
3.28k
          -0.1137907446044814f,
149
3.28k
          0.0,
150
3.28k
      },
151
3.28k
      {
152
3.28k
          0.0,
153
3.28k
          0.0,
154
3.28k
          -0.21255748058288748f,
155
3.28k
          0.3085497062849767f,
156
3.28k
          0.0,
157
3.28k
          0.4706702258572536f,
158
3.28k
          -0.1621205195722993f,
159
3.28k
          0.0,
160
3.28k
          -0.21255748058287047f,
161
3.28k
          -0.16212051957228327f,
162
3.28k
          -0.47067022585725277f,
163
3.28k
          -0.1464291867126764f,
164
3.28k
          0.3085497062849487f,
165
3.28k
          0.0,
166
3.28k
          -0.14642918671266536f,
167
3.28k
          0.4251149611657548f,
168
3.28k
      },
169
3.28k
      {
170
3.28k
          0.0,
171
3.28k
          -0.7071067811865474f,
172
3.28k
          0.0,
173
3.28k
          0.0,
174
3.28k
          0.7071067811865476f,
175
3.28k
          0.0,
176
3.28k
          0.0,
177
3.28k
          0.0,
178
3.28k
          0.0,
179
3.28k
          0.0,
180
3.28k
          0.0,
181
3.28k
          0.0,
182
3.28k
          0.0,
183
3.28k
          0.0,
184
3.28k
          0.0,
185
3.28k
          0.0,
186
3.28k
      },
187
3.28k
      {
188
3.28k
          -0.4105377591765233f,
189
3.28k
          0.6235485373547691f,
190
3.28k
          -0.06435071657946274f,
191
3.28k
          -0.06435071657946266f,
192
3.28k
          0.6235485373547694f,
193
3.28k
          -0.06435071657946284f,
194
3.28k
          -0.0643507165794628f,
195
3.28k
          -0.06435071657946274f,
196
3.28k
          -0.06435071657946272f,
197
3.28k
          -0.06435071657946279f,
198
3.28k
          -0.06435071657946266f,
199
3.28k
          -0.06435071657946277f,
200
3.28k
          -0.06435071657946277f,
201
3.28k
          -0.06435071657946273f,
202
3.28k
          -0.06435071657946274f,
203
3.28k
          -0.0643507165794626f,
204
3.28k
      },
205
3.28k
      {
206
3.28k
          0.0,
207
3.28k
          0.0,
208
3.28k
          -0.4517556589999482f,
209
3.28k
          0.15854503551840063f,
210
3.28k
          0.0,
211
3.28k
          -0.04038515160822202f,
212
3.28k
          0.0074182263792423875f,
213
3.28k
          0.39351034269210167f,
214
3.28k
          -0.45175565899994635f,
215
3.28k
          0.007418226379244351f,
216
3.28k
          0.1107416575309343f,
217
3.28k
          0.08298163094882051f,
218
3.28k
          0.15854503551839705f,
219
3.28k
          0.3935103426921022f,
220
3.28k
          0.0829816309488214f,
221
3.28k
          -0.45175565899994796f,
222
3.28k
      },
223
3.28k
      {
224
3.28k
          0.0,
225
3.28k
          0.0,
226
3.28k
          -0.304684750724869f,
227
3.28k
          0.5112616136591823f,
228
3.28k
          0.0,
229
3.28k
          0.0,
230
3.28k
          -0.290480129728998f,
231
3.28k
          -0.06578701549142804f,
232
3.28k
          0.304684750724884f,
233
3.28k
          0.2904801297290076f,
234
3.28k
          0.0,
235
3.28k
          -0.23889773523344604f,
236
3.28k
          -0.5112616136592012f,
237
3.28k
          0.06578701549142545f,
238
3.28k
          0.23889773523345467f,
239
3.28k
          0.0,
240
3.28k
      },
241
3.28k
      {
242
3.28k
          0.0,
243
3.28k
          0.0,
244
3.28k
          0.3017929516615495f,
245
3.28k
          0.25792362796341184f,
246
3.28k
          0.0,
247
3.28k
          0.16272340142866204f,
248
3.28k
          0.09520022653475037f,
249
3.28k
          0.0,
250
3.28k
          0.3017929516615503f,
251
3.28k
          0.09520022653475055f,
252
3.28k
          -0.16272340142866173f,
253
3.28k
          -0.35312385449816297f,
254
3.28k
          0.25792362796341295f,
255
3.28k
          0.0,
256
3.28k
          -0.3531238544981624f,
257
3.28k
          -0.6035859033230976f,
258
3.28k
      },
259
3.28k
      {
260
3.28k
          0.0,
261
3.28k
          0.0,
262
3.28k
          0.40824829046386274f,
263
3.28k
          0.0,
264
3.28k
          0.0,
265
3.28k
          0.0,
266
3.28k
          0.0,
267
3.28k
          -0.4082482904638628f,
268
3.28k
          -0.4082482904638635f,
269
3.28k
          0.0,
270
3.28k
          0.0,
271
3.28k
          -0.40824829046386296f,
272
3.28k
          0.0,
273
3.28k
          0.4082482904638634f,
274
3.28k
          0.408248290463863f,
275
3.28k
          0.0,
276
3.28k
      },
277
3.28k
      {
278
3.28k
          0.0,
279
3.28k
          0.0,
280
3.28k
          0.1747866975480809f,
281
3.28k
          0.0812611176717539f,
282
3.28k
          0.0,
283
3.28k
          0.0,
284
3.28k
          -0.3675398009862027f,
285
3.28k
          -0.307882213957909f,
286
3.28k
          -0.17478669754808135f,
287
3.28k
          0.3675398009862011f,
288
3.28k
          0.0,
289
3.28k
          0.4826689115059883f,
290
3.28k
          -0.08126111767175039f,
291
3.28k
          0.30788221395790305f,
292
3.28k
          -0.48266891150598584f,
293
3.28k
          0.0,
294
3.28k
      },
295
3.28k
      {
296
3.28k
          0.0,
297
3.28k
          0.0,
298
3.28k
          -0.21105601049335784f,
299
3.28k
          0.18567180916109802f,
300
3.28k
          0.0,
301
3.28k
          0.0,
302
3.28k
          0.49215859013738733f,
303
3.28k
          -0.38525013709251915f,
304
3.28k
          0.21105601049335806f,
305
3.28k
          -0.49215859013738905f,
306
3.28k
          0.0,
307
3.28k
          0.17419412659916217f,
308
3.28k
          -0.18567180916109904f,
309
3.28k
          0.3852501370925211f,
310
3.28k
          -0.1741941265991621f,
311
3.28k
          0.0,
312
3.28k
      },
313
3.28k
      {
314
3.28k
          0.0,
315
3.28k
          0.0,
316
3.28k
          -0.14266084808807264f,
317
3.28k
          -0.3416446842253372f,
318
3.28k
          0.0,
319
3.28k
          0.7367497537172237f,
320
3.28k
          0.24627107722075148f,
321
3.28k
          -0.08574019035519306f,
322
3.28k
          -0.14266084808807344f,
323
3.28k
          0.24627107722075137f,
324
3.28k
          0.14883399227113567f,
325
3.28k
          -0.04768680350229251f,
326
3.28k
          -0.3416446842253373f,
327
3.28k
          -0.08574019035519267f,
328
3.28k
          -0.047686803502292804f,
329
3.28k
          -0.14266084808807242f,
330
3.28k
      },
331
3.28k
      {
332
3.28k
          0.0,
333
3.28k
          0.0,
334
3.28k
          -0.13813540350758585f,
335
3.28k
          0.3302282550303788f,
336
3.28k
          0.0,
337
3.28k
          0.08755115000587084f,
338
3.28k
          -0.07946706605909573f,
339
3.28k
          -0.4613374887461511f,
340
3.28k
          -0.13813540350758294f,
341
3.28k
          -0.07946706605910261f,
342
3.28k
          0.49724647109535086f,
343
3.28k
          0.12538059448563663f,
344
3.28k
          0.3302282550303805f,
345
3.28k
          -0.4613374887461554f,
346
3.28k
          0.12538059448564315f,
347
3.28k
          -0.13813540350758452f,
348
3.28k
      },
349
3.28k
      {
350
3.28k
          0.0,
351
3.28k
          0.0,
352
3.28k
          -0.17437602599651067f,
353
3.28k
          0.0702790691196284f,
354
3.28k
          0.0,
355
3.28k
          -0.2921026642334881f,
356
3.28k
          0.3623817333531167f,
357
3.28k
          0.0,
358
3.28k
          -0.1743760259965108f,
359
3.28k
          0.36238173335311646f,
360
3.28k
          0.29210266423348785f,
361
3.28k
          -0.4326608024727445f,
362
3.28k
          0.07027906911962818f,
363
3.28k
          0.0,
364
3.28k
          -0.4326608024727457f,
365
3.28k
          0.34875205199302267f,
366
3.28k
      },
367
3.28k
      {
368
3.28k
          0.0,
369
3.28k
          0.0,
370
3.28k
          0.11354987314994337f,
371
3.28k
          -0.07417504595810355f,
372
3.28k
          0.0,
373
3.28k
          0.19402893032594343f,
374
3.28k
          -0.435190496523228f,
375
3.28k
          0.21918684838857466f,
376
3.28k
          0.11354987314994257f,
377
3.28k
          -0.4351904965232251f,
378
3.28k
          0.5550443808910661f,
379
3.28k
          -0.25468277124066463f,
380
3.28k
          -0.07417504595810233f,
381
3.28k
          0.2191868483885728f,
382
3.28k
          -0.25468277124066413f,
383
3.28k
          0.1135498731499429f,
384
3.28k
      },
385
3.28k
  };
386
387
3.28k
  const HWY_CAPPED(float, 16) d;
388
9.86k
  for (size_t i = 0; i < 16; i += Lanes(d)) {
389
6.57k
    auto pixel = Zero(d);
390
111k
    for (size_t j = 0; j < 16; j++) {
391
105k
      auto cf = Set(d, coeffs[j]);
392
105k
      auto basis = Load(d, k4x4AFVBasis[j] + i);
393
105k
      pixel = MulAdd(cf, basis, pixel);
394
105k
    }
395
6.57k
    Store(pixel, d, pixels + i);
396
6.57k
  }
397
3.28k
}
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_SSE2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_SSE4::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_AVX2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_SSE2::(anonymous namespace)::AFVIDCT4x4(float const*, float*)
398
399
template <size_t afv_kind>
400
void AFVTransformToPixels(const float* JXL_RESTRICT coefficients,
401
42.7k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
42.7k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
42.7k
  size_t afv_x = afv_kind & 1;
404
42.7k
  size_t afv_y = afv_kind / 2;
405
42.7k
  float dcs[3] = {};
406
42.7k
  float block00 = coefficients[0];
407
42.7k
  float block01 = coefficients[1];
408
42.7k
  float block10 = coefficients[8];
409
42.7k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
42.7k
  dcs[1] = (block00 + block10 - block01);
411
42.7k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
42.7k
  HWY_ALIGN float coeff[4 * 4];
414
42.7k
  coeff[0] = dcs[0];
415
213k
  for (size_t iy = 0; iy < 4; iy++) {
416
854k
    for (size_t ix = 0; ix < 4; ix++) {
417
683k
      if (ix == 0 && iy == 0) continue;
418
641k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
641k
    }
420
170k
  }
421
42.7k
  HWY_ALIGN float block[4 * 8];
422
42.7k
  AFVIDCT4x4(coeff, block);
423
213k
  for (size_t iy = 0; iy < 4; iy++) {
424
854k
    for (size_t ix = 0; ix < 4; ix++) {
425
683k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
683k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
683k
    }
428
170k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
42.7k
  block[0] = dcs[1];
431
213k
  for (size_t iy = 0; iy < 4; iy++) {
432
854k
    for (size_t ix = 0; ix < 4; ix++) {
433
683k
      if (ix == 0 && iy == 0) continue;
434
640k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
640k
    }
436
170k
  }
437
42.7k
  ComputeScaledIDCT<4, 4>()(
438
42.7k
      block,
439
42.7k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
42.7k
            pixels_stride),
441
42.7k
      scratch_space);
442
  // IDCT4x8.
443
42.7k
  block[0] = dcs[2];
444
213k
  for (size_t iy = 0; iy < 4; iy++) {
445
1.53M
    for (size_t ix = 0; ix < 8; ix++) {
446
1.36M
      if (ix == 0 && iy == 0) continue;
447
1.32M
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
1.32M
    }
449
170k
  }
450
42.7k
  ComputeScaledIDCT<4, 8>()(
451
42.7k
      block,
452
42.7k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
42.7k
      scratch_space);
454
42.7k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Line
Count
Source
401
10.0k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
10.0k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
10.0k
  size_t afv_x = afv_kind & 1;
404
10.0k
  size_t afv_y = afv_kind / 2;
405
10.0k
  float dcs[3] = {};
406
10.0k
  float block00 = coefficients[0];
407
10.0k
  float block01 = coefficients[1];
408
10.0k
  float block10 = coefficients[8];
409
10.0k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
10.0k
  dcs[1] = (block00 + block10 - block01);
411
10.0k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
10.0k
  HWY_ALIGN float coeff[4 * 4];
414
10.0k
  coeff[0] = dcs[0];
415
50.3k
  for (size_t iy = 0; iy < 4; iy++) {
416
201k
    for (size_t ix = 0; ix < 4; ix++) {
417
161k
      if (ix == 0 && iy == 0) continue;
418
151k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
151k
    }
420
40.2k
  }
421
10.0k
  HWY_ALIGN float block[4 * 8];
422
10.0k
  AFVIDCT4x4(coeff, block);
423
50.3k
  for (size_t iy = 0; iy < 4; iy++) {
424
201k
    for (size_t ix = 0; ix < 4; ix++) {
425
161k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
161k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
161k
    }
428
40.3k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
10.0k
  block[0] = dcs[1];
431
50.3k
  for (size_t iy = 0; iy < 4; iy++) {
432
201k
    for (size_t ix = 0; ix < 4; ix++) {
433
161k
      if (ix == 0 && iy == 0) continue;
434
151k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
151k
    }
436
40.3k
  }
437
10.0k
  ComputeScaledIDCT<4, 4>()(
438
10.0k
      block,
439
10.0k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
10.0k
            pixels_stride),
441
10.0k
      scratch_space);
442
  // IDCT4x8.
443
10.0k
  block[0] = dcs[2];
444
50.2k
  for (size_t iy = 0; iy < 4; iy++) {
445
361k
    for (size_t ix = 0; ix < 8; ix++) {
446
321k
      if (ix == 0 && iy == 0) continue;
447
311k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
311k
    }
449
40.2k
  }
450
10.0k
  ComputeScaledIDCT<4, 8>()(
451
10.0k
      block,
452
10.0k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
10.0k
      scratch_space);
454
10.0k
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Line
Count
Source
401
546
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
546
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
546
  size_t afv_x = afv_kind & 1;
404
546
  size_t afv_y = afv_kind / 2;
405
546
  float dcs[3] = {};
406
546
  float block00 = coefficients[0];
407
546
  float block01 = coefficients[1];
408
546
  float block10 = coefficients[8];
409
546
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
546
  dcs[1] = (block00 + block10 - block01);
411
546
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
546
  HWY_ALIGN float coeff[4 * 4];
414
546
  coeff[0] = dcs[0];
415
2.73k
  for (size_t iy = 0; iy < 4; iy++) {
416
10.9k
    for (size_t ix = 0; ix < 4; ix++) {
417
8.73k
      if (ix == 0 && iy == 0) continue;
418
8.19k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
8.19k
    }
420
2.18k
  }
421
546
  HWY_ALIGN float block[4 * 8];
422
546
  AFVIDCT4x4(coeff, block);
423
2.73k
  for (size_t iy = 0; iy < 4; iy++) {
424
10.9k
    for (size_t ix = 0; ix < 4; ix++) {
425
8.73k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
8.73k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
8.73k
    }
428
2.18k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
546
  block[0] = dcs[1];
431
2.73k
  for (size_t iy = 0; iy < 4; iy++) {
432
10.9k
    for (size_t ix = 0; ix < 4; ix++) {
433
8.73k
      if (ix == 0 && iy == 0) continue;
434
8.19k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
8.19k
    }
436
2.18k
  }
437
546
  ComputeScaledIDCT<4, 4>()(
438
546
      block,
439
546
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
546
            pixels_stride),
441
546
      scratch_space);
442
  // IDCT4x8.
443
546
  block[0] = dcs[2];
444
2.73k
  for (size_t iy = 0; iy < 4; iy++) {
445
19.6k
    for (size_t ix = 0; ix < 8; ix++) {
446
17.4k
      if (ix == 0 && iy == 0) continue;
447
16.9k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
16.9k
    }
449
2.18k
  }
450
546
  ComputeScaledIDCT<4, 8>()(
451
546
      block,
452
546
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
546
      scratch_space);
454
546
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Line
Count
Source
401
543
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
543
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
543
  size_t afv_x = afv_kind & 1;
404
543
  size_t afv_y = afv_kind / 2;
405
543
  float dcs[3] = {};
406
543
  float block00 = coefficients[0];
407
543
  float block01 = coefficients[1];
408
543
  float block10 = coefficients[8];
409
543
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
543
  dcs[1] = (block00 + block10 - block01);
411
543
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
543
  HWY_ALIGN float coeff[4 * 4];
414
543
  coeff[0] = dcs[0];
415
2.71k
  for (size_t iy = 0; iy < 4; iy++) {
416
10.8k
    for (size_t ix = 0; ix < 4; ix++) {
417
8.68k
      if (ix == 0 && iy == 0) continue;
418
8.14k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
8.14k
    }
420
2.17k
  }
421
543
  HWY_ALIGN float block[4 * 8];
422
543
  AFVIDCT4x4(coeff, block);
423
2.71k
  for (size_t iy = 0; iy < 4; iy++) {
424
10.8k
    for (size_t ix = 0; ix < 4; ix++) {
425
8.68k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
8.68k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
8.68k
    }
428
2.17k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
543
  block[0] = dcs[1];
431
2.71k
  for (size_t iy = 0; iy < 4; iy++) {
432
10.8k
    for (size_t ix = 0; ix < 4; ix++) {
433
8.68k
      if (ix == 0 && iy == 0) continue;
434
8.14k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
8.14k
    }
436
2.17k
  }
437
543
  ComputeScaledIDCT<4, 4>()(
438
543
      block,
439
543
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
543
            pixels_stride),
441
543
      scratch_space);
442
  // IDCT4x8.
443
543
  block[0] = dcs[2];
444
2.71k
  for (size_t iy = 0; iy < 4; iy++) {
445
19.5k
    for (size_t ix = 0; ix < 8; ix++) {
446
17.3k
      if (ix == 0 && iy == 0) continue;
447
16.8k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
16.8k
    }
449
2.17k
  }
450
543
  ComputeScaledIDCT<4, 8>()(
451
543
      block,
452
543
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
543
      scratch_space);
454
543
}
dec_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Line
Count
Source
401
597
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
597
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
597
  size_t afv_x = afv_kind & 1;
404
597
  size_t afv_y = afv_kind / 2;
405
597
  float dcs[3] = {};
406
597
  float block00 = coefficients[0];
407
597
  float block01 = coefficients[1];
408
597
  float block10 = coefficients[8];
409
597
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
597
  dcs[1] = (block00 + block10 - block01);
411
597
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
597
  HWY_ALIGN float coeff[4 * 4];
414
597
  coeff[0] = dcs[0];
415
2.98k
  for (size_t iy = 0; iy < 4; iy++) {
416
11.9k
    for (size_t ix = 0; ix < 4; ix++) {
417
9.55k
      if (ix == 0 && iy == 0) continue;
418
8.95k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
8.95k
    }
420
2.38k
  }
421
597
  HWY_ALIGN float block[4 * 8];
422
597
  AFVIDCT4x4(coeff, block);
423
2.98k
  for (size_t iy = 0; iy < 4; iy++) {
424
11.9k
    for (size_t ix = 0; ix < 4; ix++) {
425
9.55k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
9.55k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
9.55k
    }
428
2.38k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
597
  block[0] = dcs[1];
431
2.98k
  for (size_t iy = 0; iy < 4; iy++) {
432
11.9k
    for (size_t ix = 0; ix < 4; ix++) {
433
9.55k
      if (ix == 0 && iy == 0) continue;
434
8.95k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
8.95k
    }
436
2.38k
  }
437
597
  ComputeScaledIDCT<4, 4>()(
438
597
      block,
439
597
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
597
            pixels_stride),
441
597
      scratch_space);
442
  // IDCT4x8.
443
597
  block[0] = dcs[2];
444
2.98k
  for (size_t iy = 0; iy < 4; iy++) {
445
21.4k
    for (size_t ix = 0; ix < 8; ix++) {
446
19.1k
      if (ix == 0 && iy == 0) continue;
447
18.5k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
18.5k
    }
449
2.38k
  }
450
597
  ComputeScaledIDCT<4, 8>()(
451
597
      block,
452
597
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
597
      scratch_space);
454
597
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Line
Count
Source
401
10.3k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
10.3k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
10.3k
  size_t afv_x = afv_kind & 1;
404
10.3k
  size_t afv_y = afv_kind / 2;
405
10.3k
  float dcs[3] = {};
406
10.3k
  float block00 = coefficients[0];
407
10.3k
  float block01 = coefficients[1];
408
10.3k
  float block10 = coefficients[8];
409
10.3k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
10.3k
  dcs[1] = (block00 + block10 - block01);
411
10.3k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
10.3k
  HWY_ALIGN float coeff[4 * 4];
414
10.3k
  coeff[0] = dcs[0];
415
51.9k
  for (size_t iy = 0; iy < 4; iy++) {
416
207k
    for (size_t ix = 0; ix < 4; ix++) {
417
166k
      if (ix == 0 && iy == 0) continue;
418
155k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
155k
    }
420
41.5k
  }
421
10.3k
  HWY_ALIGN float block[4 * 8];
422
10.3k
  AFVIDCT4x4(coeff, block);
423
51.9k
  for (size_t iy = 0; iy < 4; iy++) {
424
207k
    for (size_t ix = 0; ix < 4; ix++) {
425
166k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
166k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
166k
    }
428
41.5k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
10.3k
  block[0] = dcs[1];
431
51.9k
  for (size_t iy = 0; iy < 4; iy++) {
432
207k
    for (size_t ix = 0; ix < 4; ix++) {
433
166k
      if (ix == 0 && iy == 0) continue;
434
155k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
155k
    }
436
41.5k
  }
437
10.3k
  ComputeScaledIDCT<4, 4>()(
438
10.3k
      block,
439
10.3k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
10.3k
            pixels_stride),
441
10.3k
      scratch_space);
442
  // IDCT4x8.
443
10.3k
  block[0] = dcs[2];
444
51.9k
  for (size_t iy = 0; iy < 4; iy++) {
445
373k
    for (size_t ix = 0; ix < 8; ix++) {
446
332k
      if (ix == 0 && iy == 0) continue;
447
321k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
321k
    }
449
41.5k
  }
450
10.3k
  ComputeScaledIDCT<4, 8>()(
451
10.3k
      block,
452
10.3k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
10.3k
      scratch_space);
454
10.3k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Line
Count
Source
401
2.30k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
2.30k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
2.30k
  size_t afv_x = afv_kind & 1;
404
2.30k
  size_t afv_y = afv_kind / 2;
405
2.30k
  float dcs[3] = {};
406
2.30k
  float block00 = coefficients[0];
407
2.30k
  float block01 = coefficients[1];
408
2.30k
  float block10 = coefficients[8];
409
2.30k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
2.30k
  dcs[1] = (block00 + block10 - block01);
411
2.30k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
2.30k
  HWY_ALIGN float coeff[4 * 4];
414
2.30k
  coeff[0] = dcs[0];
415
11.5k
  for (size_t iy = 0; iy < 4; iy++) {
416
46.1k
    for (size_t ix = 0; ix < 4; ix++) {
417
36.9k
      if (ix == 0 && iy == 0) continue;
418
34.6k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
34.6k
    }
420
9.22k
  }
421
2.30k
  HWY_ALIGN float block[4 * 8];
422
2.30k
  AFVIDCT4x4(coeff, block);
423
11.5k
  for (size_t iy = 0; iy < 4; iy++) {
424
46.1k
    for (size_t ix = 0; ix < 4; ix++) {
425
36.9k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
36.9k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
36.9k
    }
428
9.22k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
2.30k
  block[0] = dcs[1];
431
11.5k
  for (size_t iy = 0; iy < 4; iy++) {
432
46.1k
    for (size_t ix = 0; ix < 4; ix++) {
433
36.9k
      if (ix == 0 && iy == 0) continue;
434
34.6k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
34.6k
    }
436
9.22k
  }
437
2.30k
  ComputeScaledIDCT<4, 4>()(
438
2.30k
      block,
439
2.30k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
2.30k
            pixels_stride),
441
2.30k
      scratch_space);
442
  // IDCT4x8.
443
2.30k
  block[0] = dcs[2];
444
11.5k
  for (size_t iy = 0; iy < 4; iy++) {
445
83.0k
    for (size_t ix = 0; ix < 8; ix++) {
446
73.8k
      if (ix == 0 && iy == 0) continue;
447
71.5k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
71.5k
    }
449
9.22k
  }
450
2.30k
  ComputeScaledIDCT<4, 8>()(
451
2.30k
      block,
452
2.30k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
2.30k
      scratch_space);
454
2.30k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Line
Count
Source
401
2.52k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
2.52k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
2.52k
  size_t afv_x = afv_kind & 1;
404
2.52k
  size_t afv_y = afv_kind / 2;
405
2.52k
  float dcs[3] = {};
406
2.52k
  float block00 = coefficients[0];
407
2.52k
  float block01 = coefficients[1];
408
2.52k
  float block10 = coefficients[8];
409
2.52k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
2.52k
  dcs[1] = (block00 + block10 - block01);
411
2.52k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
2.52k
  HWY_ALIGN float coeff[4 * 4];
414
2.52k
  coeff[0] = dcs[0];
415
12.6k
  for (size_t iy = 0; iy < 4; iy++) {
416
50.4k
    for (size_t ix = 0; ix < 4; ix++) {
417
40.3k
      if (ix == 0 && iy == 0) continue;
418
37.8k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
37.8k
    }
420
10.0k
  }
421
2.52k
  HWY_ALIGN float block[4 * 8];
422
2.52k
  AFVIDCT4x4(coeff, block);
423
12.6k
  for (size_t iy = 0; iy < 4; iy++) {
424
50.4k
    for (size_t ix = 0; ix < 4; ix++) {
425
40.3k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
40.3k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
40.3k
    }
428
10.0k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
2.52k
  block[0] = dcs[1];
431
12.6k
  for (size_t iy = 0; iy < 4; iy++) {
432
50.4k
    for (size_t ix = 0; ix < 4; ix++) {
433
40.3k
      if (ix == 0 && iy == 0) continue;
434
37.8k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
37.8k
    }
436
10.0k
  }
437
2.52k
  ComputeScaledIDCT<4, 4>()(
438
2.52k
      block,
439
2.52k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
2.52k
            pixels_stride),
441
2.52k
      scratch_space);
442
  // IDCT4x8.
443
2.52k
  block[0] = dcs[2];
444
12.6k
  for (size_t iy = 0; iy < 4; iy++) {
445
90.8k
    for (size_t ix = 0; ix < 8; ix++) {
446
80.7k
      if (ix == 0 && iy == 0) continue;
447
78.2k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
78.2k
    }
449
10.0k
  }
450
2.52k
  ComputeScaledIDCT<4, 8>()(
451
2.52k
      block,
452
2.52k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
2.52k
      scratch_space);
454
2.52k
}
dec_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Line
Count
Source
401
5.27k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
5.27k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
5.27k
  size_t afv_x = afv_kind & 1;
404
5.27k
  size_t afv_y = afv_kind / 2;
405
5.27k
  float dcs[3] = {};
406
5.27k
  float block00 = coefficients[0];
407
5.27k
  float block01 = coefficients[1];
408
5.27k
  float block10 = coefficients[8];
409
5.27k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
5.27k
  dcs[1] = (block00 + block10 - block01);
411
5.27k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
5.27k
  HWY_ALIGN float coeff[4 * 4];
414
5.27k
  coeff[0] = dcs[0];
415
26.3k
  for (size_t iy = 0; iy < 4; iy++) {
416
105k
    for (size_t ix = 0; ix < 4; ix++) {
417
84.4k
      if (ix == 0 && iy == 0) continue;
418
79.1k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
79.1k
    }
420
21.1k
  }
421
5.27k
  HWY_ALIGN float block[4 * 8];
422
5.27k
  AFVIDCT4x4(coeff, block);
423
26.3k
  for (size_t iy = 0; iy < 4; iy++) {
424
105k
    for (size_t ix = 0; ix < 4; ix++) {
425
84.4k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
84.4k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
84.4k
    }
428
21.1k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
5.27k
  block[0] = dcs[1];
431
26.3k
  for (size_t iy = 0; iy < 4; iy++) {
432
105k
    for (size_t ix = 0; ix < 4; ix++) {
433
84.4k
      if (ix == 0 && iy == 0) continue;
434
79.1k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
79.1k
    }
436
21.1k
  }
437
5.27k
  ComputeScaledIDCT<4, 4>()(
438
5.27k
      block,
439
5.27k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
5.27k
            pixels_stride),
441
5.27k
      scratch_space);
442
  // IDCT4x8.
443
5.27k
  block[0] = dcs[2];
444
26.3k
  for (size_t iy = 0; iy < 4; iy++) {
445
189k
    for (size_t ix = 0; ix < 8; ix++) {
446
168k
      if (ix == 0 && iy == 0) continue;
447
163k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
163k
    }
449
21.1k
  }
450
5.27k
  ComputeScaledIDCT<4, 8>()(
451
5.27k
      block,
452
5.27k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
5.27k
      scratch_space);
454
5.27k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Line
Count
Source
401
5.20k
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
5.20k
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
5.20k
  size_t afv_x = afv_kind & 1;
404
5.20k
  size_t afv_y = afv_kind / 2;
405
5.20k
  float dcs[3] = {};
406
5.20k
  float block00 = coefficients[0];
407
5.20k
  float block01 = coefficients[1];
408
5.20k
  float block10 = coefficients[8];
409
5.20k
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
5.20k
  dcs[1] = (block00 + block10 - block01);
411
5.20k
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
5.20k
  HWY_ALIGN float coeff[4 * 4];
414
5.20k
  coeff[0] = dcs[0];
415
26.0k
  for (size_t iy = 0; iy < 4; iy++) {
416
104k
    for (size_t ix = 0; ix < 4; ix++) {
417
83.3k
      if (ix == 0 && iy == 0) continue;
418
78.1k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
78.1k
    }
420
20.8k
  }
421
5.20k
  HWY_ALIGN float block[4 * 8];
422
5.20k
  AFVIDCT4x4(coeff, block);
423
26.0k
  for (size_t iy = 0; iy < 4; iy++) {
424
104k
    for (size_t ix = 0; ix < 4; ix++) {
425
83.2k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
83.2k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
83.2k
    }
428
20.8k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
5.20k
  block[0] = dcs[1];
431
26.0k
  for (size_t iy = 0; iy < 4; iy++) {
432
104k
    for (size_t ix = 0; ix < 4; ix++) {
433
83.2k
      if (ix == 0 && iy == 0) continue;
434
78.0k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
78.0k
    }
436
20.8k
  }
437
5.20k
  ComputeScaledIDCT<4, 4>()(
438
5.20k
      block,
439
5.20k
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
5.20k
            pixels_stride),
441
5.20k
      scratch_space);
442
  // IDCT4x8.
443
5.20k
  block[0] = dcs[2];
444
25.9k
  for (size_t iy = 0; iy < 4; iy++) {
445
186k
    for (size_t ix = 0; ix < 8; ix++) {
446
165k
      if (ix == 0 && iy == 0) continue;
447
160k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
160k
    }
449
20.7k
  }
450
5.20k
  ComputeScaledIDCT<4, 8>()(
451
5.20k
      block,
452
5.20k
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
5.20k
      scratch_space);
454
5.20k
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Line
Count
Source
401
633
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
633
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
633
  size_t afv_x = afv_kind & 1;
404
633
  size_t afv_y = afv_kind / 2;
405
633
  float dcs[3] = {};
406
633
  float block00 = coefficients[0];
407
633
  float block01 = coefficients[1];
408
633
  float block10 = coefficients[8];
409
633
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
633
  dcs[1] = (block00 + block10 - block01);
411
633
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
633
  HWY_ALIGN float coeff[4 * 4];
414
633
  coeff[0] = dcs[0];
415
3.16k
  for (size_t iy = 0; iy < 4; iy++) {
416
12.6k
    for (size_t ix = 0; ix < 4; ix++) {
417
10.1k
      if (ix == 0 && iy == 0) continue;
418
9.49k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
9.49k
    }
420
2.53k
  }
421
633
  HWY_ALIGN float block[4 * 8];
422
633
  AFVIDCT4x4(coeff, block);
423
3.16k
  for (size_t iy = 0; iy < 4; iy++) {
424
12.6k
    for (size_t ix = 0; ix < 4; ix++) {
425
10.1k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
10.1k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
10.1k
    }
428
2.53k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
633
  block[0] = dcs[1];
431
3.16k
  for (size_t iy = 0; iy < 4; iy++) {
432
12.6k
    for (size_t ix = 0; ix < 4; ix++) {
433
10.1k
      if (ix == 0 && iy == 0) continue;
434
9.49k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
9.49k
    }
436
2.53k
  }
437
633
  ComputeScaledIDCT<4, 4>()(
438
633
      block,
439
633
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
633
            pixels_stride),
441
633
      scratch_space);
442
  // IDCT4x8.
443
633
  block[0] = dcs[2];
444
3.16k
  for (size_t iy = 0; iy < 4; iy++) {
445
22.7k
    for (size_t ix = 0; ix < 8; ix++) {
446
20.2k
      if (ix == 0 && iy == 0) continue;
447
19.6k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
19.6k
    }
449
2.53k
  }
450
633
  ComputeScaledIDCT<4, 8>()(
451
633
      block,
452
633
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
633
      scratch_space);
454
633
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Line
Count
Source
401
978
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
978
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
978
  size_t afv_x = afv_kind & 1;
404
978
  size_t afv_y = afv_kind / 2;
405
978
  float dcs[3] = {};
406
978
  float block00 = coefficients[0];
407
978
  float block01 = coefficients[1];
408
978
  float block10 = coefficients[8];
409
978
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
978
  dcs[1] = (block00 + block10 - block01);
411
978
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
978
  HWY_ALIGN float coeff[4 * 4];
414
978
  coeff[0] = dcs[0];
415
4.89k
  for (size_t iy = 0; iy < 4; iy++) {
416
19.5k
    for (size_t ix = 0; ix < 4; ix++) {
417
15.6k
      if (ix == 0 && iy == 0) continue;
418
14.6k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
14.6k
    }
420
3.91k
  }
421
978
  HWY_ALIGN float block[4 * 8];
422
978
  AFVIDCT4x4(coeff, block);
423
4.89k
  for (size_t iy = 0; iy < 4; iy++) {
424
19.5k
    for (size_t ix = 0; ix < 4; ix++) {
425
15.6k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
15.6k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
15.6k
    }
428
3.91k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
978
  block[0] = dcs[1];
431
4.89k
  for (size_t iy = 0; iy < 4; iy++) {
432
19.5k
    for (size_t ix = 0; ix < 4; ix++) {
433
15.6k
      if (ix == 0 && iy == 0) continue;
434
14.6k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
14.6k
    }
436
3.91k
  }
437
978
  ComputeScaledIDCT<4, 4>()(
438
978
      block,
439
978
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
978
            pixels_stride),
441
978
      scratch_space);
442
  // IDCT4x8.
443
978
  block[0] = dcs[2];
444
4.89k
  for (size_t iy = 0; iy < 4; iy++) {
445
35.2k
    for (size_t ix = 0; ix < 8; ix++) {
446
31.2k
      if (ix == 0 && iy == 0) continue;
447
30.3k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
30.3k
    }
449
3.91k
  }
450
978
  ComputeScaledIDCT<4, 8>()(
451
978
      block,
452
978
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
978
      scratch_space);
454
978
}
dec_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Line
Count
Source
401
369
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
369
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
369
  size_t afv_x = afv_kind & 1;
404
369
  size_t afv_y = afv_kind / 2;
405
369
  float dcs[3] = {};
406
369
  float block00 = coefficients[0];
407
369
  float block01 = coefficients[1];
408
369
  float block10 = coefficients[8];
409
369
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
369
  dcs[1] = (block00 + block10 - block01);
411
369
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
369
  HWY_ALIGN float coeff[4 * 4];
414
369
  coeff[0] = dcs[0];
415
1.84k
  for (size_t iy = 0; iy < 4; iy++) {
416
7.38k
    for (size_t ix = 0; ix < 4; ix++) {
417
5.90k
      if (ix == 0 && iy == 0) continue;
418
5.53k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
5.53k
    }
420
1.47k
  }
421
369
  HWY_ALIGN float block[4 * 8];
422
369
  AFVIDCT4x4(coeff, block);
423
1.84k
  for (size_t iy = 0; iy < 4; iy++) {
424
7.38k
    for (size_t ix = 0; ix < 4; ix++) {
425
5.90k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
5.90k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
5.90k
    }
428
1.47k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
369
  block[0] = dcs[1];
431
1.84k
  for (size_t iy = 0; iy < 4; iy++) {
432
7.38k
    for (size_t ix = 0; ix < 4; ix++) {
433
5.90k
      if (ix == 0 && iy == 0) continue;
434
5.53k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
5.53k
    }
436
1.47k
  }
437
369
  ComputeScaledIDCT<4, 4>()(
438
369
      block,
439
369
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
369
            pixels_stride),
441
369
      scratch_space);
442
  // IDCT4x8.
443
369
  block[0] = dcs[2];
444
1.84k
  for (size_t iy = 0; iy < 4; iy++) {
445
13.2k
    for (size_t ix = 0; ix < 8; ix++) {
446
11.8k
      if (ix == 0 && iy == 0) continue;
447
11.4k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
11.4k
    }
449
1.47k
  }
450
369
  ComputeScaledIDCT<4, 8>()(
451
369
      block,
452
369
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
369
      scratch_space);
454
369
}
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_group.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Line
Count
Source
401
822
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
822
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
822
  size_t afv_x = afv_kind & 1;
404
822
  size_t afv_y = afv_kind / 2;
405
822
  float dcs[3] = {};
406
822
  float block00 = coefficients[0];
407
822
  float block01 = coefficients[1];
408
822
  float block10 = coefficients[8];
409
822
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
822
  dcs[1] = (block00 + block10 - block01);
411
822
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
822
  HWY_ALIGN float coeff[4 * 4];
414
822
  coeff[0] = dcs[0];
415
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
416
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
417
13.1k
      if (ix == 0 && iy == 0) continue;
418
12.3k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
12.3k
    }
420
3.28k
  }
421
822
  HWY_ALIGN float block[4 * 8];
422
822
  AFVIDCT4x4(coeff, block);
423
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
424
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
425
13.1k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
13.1k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
13.1k
    }
428
3.28k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
822
  block[0] = dcs[1];
431
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
432
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
433
13.1k
      if (ix == 0 && iy == 0) continue;
434
12.3k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
12.3k
    }
436
3.28k
  }
437
822
  ComputeScaledIDCT<4, 4>()(
438
822
      block,
439
822
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
822
            pixels_stride),
441
822
      scratch_space);
442
  // IDCT4x8.
443
822
  block[0] = dcs[2];
444
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
445
29.5k
    for (size_t ix = 0; ix < 8; ix++) {
446
26.3k
      if (ix == 0 && iy == 0) continue;
447
25.4k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
25.4k
    }
449
3.28k
  }
450
822
  ComputeScaledIDCT<4, 8>()(
451
822
      block,
452
822
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
822
      scratch_space);
454
822
}
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Line
Count
Source
401
822
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
822
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
822
  size_t afv_x = afv_kind & 1;
404
822
  size_t afv_y = afv_kind / 2;
405
822
  float dcs[3] = {};
406
822
  float block00 = coefficients[0];
407
822
  float block01 = coefficients[1];
408
822
  float block10 = coefficients[8];
409
822
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
822
  dcs[1] = (block00 + block10 - block01);
411
822
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
822
  HWY_ALIGN float coeff[4 * 4];
414
822
  coeff[0] = dcs[0];
415
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
416
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
417
13.1k
      if (ix == 0 && iy == 0) continue;
418
12.3k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
12.3k
    }
420
3.28k
  }
421
822
  HWY_ALIGN float block[4 * 8];
422
822
  AFVIDCT4x4(coeff, block);
423
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
424
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
425
13.1k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
13.1k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
13.1k
    }
428
3.28k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
822
  block[0] = dcs[1];
431
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
432
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
433
13.1k
      if (ix == 0 && iy == 0) continue;
434
12.3k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
12.3k
    }
436
3.28k
  }
437
822
  ComputeScaledIDCT<4, 4>()(
438
822
      block,
439
822
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
822
            pixels_stride),
441
822
      scratch_space);
442
  // IDCT4x8.
443
822
  block[0] = dcs[2];
444
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
445
29.5k
    for (size_t ix = 0; ix < 8; ix++) {
446
26.3k
      if (ix == 0 && iy == 0) continue;
447
25.4k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
25.4k
    }
449
3.28k
  }
450
822
  ComputeScaledIDCT<4, 8>()(
451
822
      block,
452
822
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
822
      scratch_space);
454
822
}
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Line
Count
Source
401
822
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
822
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
822
  size_t afv_x = afv_kind & 1;
404
822
  size_t afv_y = afv_kind / 2;
405
822
  float dcs[3] = {};
406
822
  float block00 = coefficients[0];
407
822
  float block01 = coefficients[1];
408
822
  float block10 = coefficients[8];
409
822
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
822
  dcs[1] = (block00 + block10 - block01);
411
822
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
822
  HWY_ALIGN float coeff[4 * 4];
414
822
  coeff[0] = dcs[0];
415
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
416
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
417
13.1k
      if (ix == 0 && iy == 0) continue;
418
12.3k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
12.3k
    }
420
3.28k
  }
421
822
  HWY_ALIGN float block[4 * 8];
422
822
  AFVIDCT4x4(coeff, block);
423
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
424
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
425
13.1k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
13.1k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
13.1k
    }
428
3.28k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
822
  block[0] = dcs[1];
431
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
432
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
433
13.1k
      if (ix == 0 && iy == 0) continue;
434
12.3k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
12.3k
    }
436
3.28k
  }
437
822
  ComputeScaledIDCT<4, 4>()(
438
822
      block,
439
822
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
822
            pixels_stride),
441
822
      scratch_space);
442
  // IDCT4x8.
443
822
  block[0] = dcs[2];
444
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
445
29.5k
    for (size_t ix = 0; ix < 8; ix++) {
446
26.3k
      if (ix == 0 && iy == 0) continue;
447
25.4k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
25.4k
    }
449
3.28k
  }
450
822
  ComputeScaledIDCT<4, 8>()(
451
822
      block,
452
822
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
822
      scratch_space);
454
822
}
enc_ac_strategy.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Line
Count
Source
401
822
                          float* JXL_RESTRICT pixels, size_t pixels_stride) {
402
822
  HWY_ALIGN float scratch_space[4 * 8 * 4];
403
822
  size_t afv_x = afv_kind & 1;
404
822
  size_t afv_y = afv_kind / 2;
405
822
  float dcs[3] = {};
406
822
  float block00 = coefficients[0];
407
822
  float block01 = coefficients[1];
408
822
  float block10 = coefficients[8];
409
822
  dcs[0] = (block00 + block10 + block01) * 4.0f;
410
822
  dcs[1] = (block00 + block10 - block01);
411
822
  dcs[2] = block00 - block10;
412
  // IAFV: (even, even) positions.
413
822
  HWY_ALIGN float coeff[4 * 4];
414
822
  coeff[0] = dcs[0];
415
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
416
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
417
13.1k
      if (ix == 0 && iy == 0) continue;
418
12.3k
      coeff[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2];
419
12.3k
    }
420
3.28k
  }
421
822
  HWY_ALIGN float block[4 * 8];
422
822
  AFVIDCT4x4(coeff, block);
423
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
424
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
425
13.1k
      pixels[(iy + afv_y * 4) * pixels_stride + afv_x * 4 + ix] =
426
13.1k
          block[(afv_y == 1 ? 3 - iy : iy) * 4 + (afv_x == 1 ? 3 - ix : ix)];
427
13.1k
    }
428
3.28k
  }
429
  // IDCT4x4 in (odd, even) positions.
430
822
  block[0] = dcs[1];
431
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
432
16.4k
    for (size_t ix = 0; ix < 4; ix++) {
433
13.1k
      if (ix == 0 && iy == 0) continue;
434
12.3k
      block[iy * 4 + ix] = coefficients[iy * 2 * 8 + ix * 2 + 1];
435
12.3k
    }
436
3.28k
  }
437
822
  ComputeScaledIDCT<4, 4>()(
438
822
      block,
439
822
      DCTTo(pixels + afv_y * 4 * pixels_stride + (afv_x == 1 ? 0 : 4),
440
822
            pixels_stride),
441
822
      scratch_space);
442
  // IDCT4x8.
443
822
  block[0] = dcs[2];
444
4.11k
  for (size_t iy = 0; iy < 4; iy++) {
445
29.5k
    for (size_t ix = 0; ix < 8; ix++) {
446
26.3k
      if (ix == 0 && iy == 0) continue;
447
25.4k
      block[iy * 8 + ix] = coefficients[(1 + iy * 2) * 8 + ix];
448
25.4k
    }
449
3.28k
  }
450
822
  ComputeScaledIDCT<4, 8>()(
451
822
      block,
452
822
      DCTTo(pixels + (afv_y == 1 ? 0 : 4) * pixels_stride, pixels_stride),
453
822
      scratch_space);
454
822
}
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_ac_strategy.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE4::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_AVX2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<0ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<1ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<2ul>(float const*, float*, unsigned long)
Unexecuted instantiation: enc_chroma_from_luma.cc:void jxl::N_SSE2::(anonymous namespace)::AFVTransformToPixels<3ul>(float const*, float*, unsigned long)
455
456
HWY_MAYBE_UNUSED void TransformToPixels(const AcStrategyType strategy,
457
                                        float* JXL_RESTRICT coefficients,
458
                                        float* JXL_RESTRICT pixels,
459
                                        size_t pixels_stride,
460
13.4M
                                        float* scratch_space) {
461
13.4M
  using Type = AcStrategyType;
462
13.4M
  switch (strategy) {
463
1.72M
    case Type::IDENTITY: {
464
1.72M
      float dcs[4] = {};
465
1.72M
      float block00 = coefficients[0];
466
1.72M
      float block01 = coefficients[1];
467
1.72M
      float block10 = coefficients[8];
468
1.72M
      float block11 = coefficients[9];
469
1.72M
      dcs[0] = block00 + block01 + block10 + block11;
470
1.72M
      dcs[1] = block00 + block01 - block10 - block11;
471
1.72M
      dcs[2] = block00 - block01 + block10 - block11;
472
1.72M
      dcs[3] = block00 - block01 - block10 + block11;
473
5.17M
      for (size_t y = 0; y < 2; y++) {
474
10.3M
        for (size_t x = 0; x < 2; x++) {
475
6.90M
          float block_dc = dcs[y * 2 + x];
476
6.90M
          float residual_sum = 0;
477
34.5M
          for (size_t iy = 0; iy < 4; iy++) {
478
138M
            for (size_t ix = 0; ix < 4; ix++) {
479
110M
              if (ix == 0 && iy == 0) continue;
480
103M
              residual_sum += coefficients[(y + iy * 2) * 8 + x + ix * 2];
481
103M
            }
482
27.6M
          }
483
6.90M
          pixels[(4 * y + 1) * pixels_stride + 4 * x + 1] =
484
6.90M
              block_dc - residual_sum * (1.0f / 16);
485
34.5M
          for (size_t iy = 0; iy < 4; iy++) {
486
138M
            for (size_t ix = 0; ix < 4; ix++) {
487
110M
              if (ix == 1 && iy == 1) continue;
488
103M
              pixels[(y * 4 + iy) * pixels_stride + x * 4 + ix] =
489
103M
                  coefficients[(y + iy * 2) * 8 + x + ix * 2] +
490
103M
                  pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
491
103M
            }
492
27.6M
          }
493
6.90M
          pixels[y * 4 * pixels_stride + x * 4] =
494
6.90M
              coefficients[(y + 2) * 8 + x + 2] +
495
6.90M
              pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
496
6.90M
        }
497
3.45M
      }
498
1.72M
      break;
499
0
    }
500
17.6k
    case Type::DCT8X4: {
501
17.6k
      float dcs[2] = {};
502
17.6k
      float block0 = coefficients[0];
503
17.6k
      float block1 = coefficients[8];
504
17.6k
      dcs[0] = block0 + block1;
505
17.6k
      dcs[1] = block0 - block1;
506
52.9k
      for (size_t x = 0; x < 2; x++) {
507
35.2k
        HWY_ALIGN float block[4 * 8];
508
35.2k
        block[0] = dcs[x];
509
176k
        for (size_t iy = 0; iy < 4; iy++) {
510
1.26M
          for (size_t ix = 0; ix < 8; ix++) {
511
1.12M
            if (ix == 0 && iy == 0) continue;
512
1.09M
            block[iy * 8 + ix] = coefficients[(x + iy * 2) * 8 + ix];
513
1.09M
          }
514
141k
        }
515
35.2k
        ComputeScaledIDCT<8, 4>()(block, DCTTo(pixels + x * 4, pixels_stride),
516
35.2k
                                  scratch_space);
517
35.2k
      }
518
17.6k
      break;
519
0
    }
520
54.9k
    case Type::DCT4X8: {
521
54.9k
      float dcs[2] = {};
522
54.9k
      float block0 = coefficients[0];
523
54.9k
      float block1 = coefficients[8];
524
54.9k
      dcs[0] = block0 + block1;
525
54.9k
      dcs[1] = block0 - block1;
526
164k
      for (size_t y = 0; y < 2; y++) {
527
109k
        HWY_ALIGN float block[4 * 8];
528
109k
        block[0] = dcs[y];
529
547k
        for (size_t iy = 0; iy < 4; iy++) {
530
3.93M
          for (size_t ix = 0; ix < 8; ix++) {
531
3.49M
            if (ix == 0 && iy == 0) continue;
532
3.38M
            block[iy * 8 + ix] = coefficients[(y + iy * 2) * 8 + ix];
533
3.38M
          }
534
437k
        }
535
109k
        ComputeScaledIDCT<4, 8>()(
536
109k
            block, DCTTo(pixels + y * 4 * pixels_stride, pixels_stride),
537
109k
            scratch_space);
538
109k
      }
539
54.9k
      break;
540
0
    }
541
113k
    case Type::DCT4X4: {
542
113k
      float dcs[4] = {};
543
113k
      float block00 = coefficients[0];
544
113k
      float block01 = coefficients[1];
545
113k
      float block10 = coefficients[8];
546
113k
      float block11 = coefficients[9];
547
113k
      dcs[0] = block00 + block01 + block10 + block11;
548
113k
      dcs[1] = block00 + block01 - block10 - block11;
549
113k
      dcs[2] = block00 - block01 + block10 - block11;
550
113k
      dcs[3] = block00 - block01 - block10 + block11;
551
339k
      for (size_t y = 0; y < 2; y++) {
552
674k
        for (size_t x = 0; x < 2; x++) {
553
448k
          HWY_ALIGN float block[4 * 4];
554
448k
          block[0] = dcs[y * 2 + x];
555
2.24M
          for (size_t iy = 0; iy < 4; iy++) {
556
8.97M
            for (size_t ix = 0; ix < 4; ix++) {
557
7.18M
              if (ix == 0 && iy == 0) continue;
558
6.73M
              block[iy * 4 + ix] = coefficients[(y + iy * 2) * 8 + x + ix * 2];
559
6.73M
            }
560
1.79M
          }
561
448k
          ComputeScaledIDCT<4, 4>()(
562
448k
              block,
563
448k
              DCTTo(pixels + y * 4 * pixels_stride + x * 4, pixels_stride),
564
448k
              scratch_space);
565
448k
        }
566
225k
      }
567
113k
      break;
568
0
    }
569
195k
    case Type::DCT2X2: {
570
195k
      HWY_ALIGN float coeffs[kDCTBlockSize];
571
195k
      memcpy(coeffs, coefficients, sizeof(float) * kDCTBlockSize);
572
195k
      IDCT2TopBlock<2>(coeffs, kBlockDim, coeffs);
573
195k
      IDCT2TopBlock<4>(coeffs, kBlockDim, coeffs);
574
195k
      IDCT2TopBlock<8>(coeffs, kBlockDim, coeffs);
575
1.75M
      for (size_t y = 0; y < kBlockDim; y++) {
576
14.0M
        for (size_t x = 0; x < kBlockDim; x++) {
577
12.4M
          pixels[y * pixels_stride + x] = coeffs[y * kBlockDim + x];
578
12.4M
        }
579
1.56M
      }
580
195k
      break;
581
0
    }
582
16.5k
    case Type::DCT16X16: {
583
16.5k
      ComputeScaledIDCT<16, 16>()(coefficients, DCTTo(pixels, pixels_stride),
584
16.5k
                                  scratch_space);
585
16.5k
      break;
586
0
    }
587
103k
    case Type::DCT16X8: {
588
103k
      ComputeScaledIDCT<16, 8>()(coefficients, DCTTo(pixels, pixels_stride),
589
103k
                                 scratch_space);
590
103k
      break;
591
0
    }
592
9.07M
    case Type::DCT8X16: {
593
9.07M
      ComputeScaledIDCT<8, 16>()(coefficients, DCTTo(pixels, pixels_stride),
594
9.07M
                                 scratch_space);
595
9.07M
      break;
596
0
    }
597
11.0k
    case Type::DCT32X8: {
598
11.0k
      ComputeScaledIDCT<32, 8>()(coefficients, DCTTo(pixels, pixels_stride),
599
11.0k
                                 scratch_space);
600
11.0k
      break;
601
0
    }
602
13.5k
    case Type::DCT8X32: {
603
13.5k
      ComputeScaledIDCT<8, 32>()(coefficients, DCTTo(pixels, pixels_stride),
604
13.5k
                                 scratch_space);
605
13.5k
      break;
606
0
    }
607
10.3k
    case Type::DCT32X16: {
608
10.3k
      ComputeScaledIDCT<32, 16>()(coefficients, DCTTo(pixels, pixels_stride),
609
10.3k
                                  scratch_space);
610
10.3k
      break;
611
0
    }
612
10.0k
    case Type::DCT16X32: {
613
10.0k
      ComputeScaledIDCT<16, 32>()(coefficients, DCTTo(pixels, pixels_stride),
614
10.0k
                                  scratch_space);
615
10.0k
      break;
616
0
    }
617
3.18k
    case Type::DCT32X32: {
618
3.18k
      ComputeScaledIDCT<32, 32>()(coefficients, DCTTo(pixels, pixels_stride),
619
3.18k
                                  scratch_space);
620
3.18k
      break;
621
0
    }
622
2.02M
    case Type::DCT: {
623
2.02M
      ComputeScaledIDCT<8, 8>()(coefficients, DCTTo(pixels, pixels_stride),
624
2.02M
                                scratch_space);
625
2.02M
      break;
626
0
    }
627
26.4k
    case Type::AFV0: {
628
26.4k
      AFVTransformToPixels<0>(coefficients, pixels, pixels_stride);
629
26.4k
      break;
630
0
    }
631
4.30k
    case Type::AFV1: {
632
4.30k
      AFVTransformToPixels<1>(coefficients, pixels, pixels_stride);
633
4.30k
      break;
634
0
    }
635
4.86k
    case Type::AFV2: {
636
4.86k
      AFVTransformToPixels<2>(coefficients, pixels, pixels_stride);
637
4.86k
      break;
638
0
    }
639
7.06k
    case Type::AFV3: {
640
7.06k
      AFVTransformToPixels<3>(coefficients, pixels, pixels_stride);
641
7.06k
      break;
642
0
    }
643
759
    case Type::DCT64X32: {
644
759
      ComputeScaledIDCT<64, 32>()(coefficients, DCTTo(pixels, pixels_stride),
645
759
                                  scratch_space);
646
759
      break;
647
0
    }
648
225
    case Type::DCT32X64: {
649
225
      ComputeScaledIDCT<32, 64>()(coefficients, DCTTo(pixels, pixels_stride),
650
225
                                  scratch_space);
651
225
      break;
652
0
    }
653
6.76k
    case Type::DCT64X64: {
654
6.76k
      ComputeScaledIDCT<64, 64>()(coefficients, DCTTo(pixels, pixels_stride),
655
6.76k
                                  scratch_space);
656
6.76k
      break;
657
0
    }
658
807
    case Type::DCT128X64: {
659
807
      ComputeScaledIDCT<128, 64>()(coefficients, DCTTo(pixels, pixels_stride),
660
807
                                   scratch_space);
661
807
      break;
662
0
    }
663
219
    case Type::DCT64X128: {
664
219
      ComputeScaledIDCT<64, 128>()(coefficients, DCTTo(pixels, pixels_stride),
665
219
                                   scratch_space);
666
219
      break;
667
0
    }
668
7.17k
    case Type::DCT128X128: {
669
7.17k
      ComputeScaledIDCT<128, 128>()(coefficients, DCTTo(pixels, pixels_stride),
670
7.17k
                                    scratch_space);
671
7.17k
      break;
672
0
    }
673
30
    case Type::DCT256X128: {
674
30
      ComputeScaledIDCT<256, 128>()(coefficients, DCTTo(pixels, pixels_stride),
675
30
                                    scratch_space);
676
30
      break;
677
0
    }
678
69
    case Type::DCT128X256: {
679
69
      ComputeScaledIDCT<128, 256>()(coefficients, DCTTo(pixels, pixels_stride),
680
69
                                    scratch_space);
681
69
      break;
682
0
    }
683
63
    case Type::DCT256X256: {
684
63
      ComputeScaledIDCT<256, 256>()(coefficients, DCTTo(pixels, pixels_stride),
685
63
                                    scratch_space);
686
63
      break;
687
0
    }
688
13.4M
  }
689
13.4M
}
dec_group.cc:jxl::N_SSE4::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Line
Count
Source
460
2.38M
                                        float* scratch_space) {
461
2.38M
  using Type = AcStrategyType;
462
2.38M
  switch (strategy) {
463
112k
    case Type::IDENTITY: {
464
112k
      float dcs[4] = {};
465
112k
      float block00 = coefficients[0];
466
112k
      float block01 = coefficients[1];
467
112k
      float block10 = coefficients[8];
468
112k
      float block11 = coefficients[9];
469
112k
      dcs[0] = block00 + block01 + block10 + block11;
470
112k
      dcs[1] = block00 + block01 - block10 - block11;
471
112k
      dcs[2] = block00 - block01 + block10 - block11;
472
112k
      dcs[3] = block00 - block01 - block10 + block11;
473
335k
      for (size_t y = 0; y < 2; y++) {
474
669k
        for (size_t x = 0; x < 2; x++) {
475
446k
          float block_dc = dcs[y * 2 + x];
476
446k
          float residual_sum = 0;
477
2.23M
          for (size_t iy = 0; iy < 4; iy++) {
478
8.92M
            for (size_t ix = 0; ix < 4; ix++) {
479
7.14M
              if (ix == 0 && iy == 0) continue;
480
6.69M
              residual_sum += coefficients[(y + iy * 2) * 8 + x + ix * 2];
481
6.69M
            }
482
1.78M
          }
483
446k
          pixels[(4 * y + 1) * pixels_stride + 4 * x + 1] =
484
446k
              block_dc - residual_sum * (1.0f / 16);
485
2.23M
          for (size_t iy = 0; iy < 4; iy++) {
486
8.92M
            for (size_t ix = 0; ix < 4; ix++) {
487
7.14M
              if (ix == 1 && iy == 1) continue;
488
6.69M
              pixels[(y * 4 + iy) * pixels_stride + x * 4 + ix] =
489
6.69M
                  coefficients[(y + iy * 2) * 8 + x + ix * 2] +
490
6.69M
                  pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
491
6.69M
            }
492
1.78M
          }
493
446k
          pixels[y * 4 * pixels_stride + x * 4] =
494
446k
              coefficients[(y + 2) * 8 + x + 2] +
495
446k
              pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
496
446k
        }
497
223k
      }
498
112k
      break;
499
0
    }
500
909
    case Type::DCT8X4: {
501
909
      float dcs[2] = {};
502
909
      float block0 = coefficients[0];
503
909
      float block1 = coefficients[8];
504
909
      dcs[0] = block0 + block1;
505
909
      dcs[1] = block0 - block1;
506
2.72k
      for (size_t x = 0; x < 2; x++) {
507
1.81k
        HWY_ALIGN float block[4 * 8];
508
1.81k
        block[0] = dcs[x];
509
9.09k
        for (size_t iy = 0; iy < 4; iy++) {
510
65.4k
          for (size_t ix = 0; ix < 8; ix++) {
511
58.1k
            if (ix == 0 && iy == 0) continue;
512
56.3k
            block[iy * 8 + ix] = coefficients[(x + iy * 2) * 8 + ix];
513
56.3k
          }
514
7.27k
        }
515
1.81k
        ComputeScaledIDCT<8, 4>()(block, DCTTo(pixels + x * 4, pixels_stride),
516
1.81k
                                  scratch_space);
517
1.81k
      }
518
909
      break;
519
0
    }
520
12.5k
    case Type::DCT4X8: {
521
12.5k
      float dcs[2] = {};
522
12.5k
      float block0 = coefficients[0];
523
12.5k
      float block1 = coefficients[8];
524
12.5k
      dcs[0] = block0 + block1;
525
12.5k
      dcs[1] = block0 - block1;
526
37.4k
      for (size_t y = 0; y < 2; y++) {
527
24.9k
        HWY_ALIGN float block[4 * 8];
528
24.9k
        block[0] = dcs[y];
529
124k
        for (size_t iy = 0; iy < 4; iy++) {
530
895k
          for (size_t ix = 0; ix < 8; ix++) {
531
796k
            if (ix == 0 && iy == 0) continue;
532
771k
            block[iy * 8 + ix] = coefficients[(y + iy * 2) * 8 + ix];
533
771k
          }
534
99.6k
        }
535
24.9k
        ComputeScaledIDCT<4, 8>()(
536
24.9k
            block, DCTTo(pixels + y * 4 * pixels_stride, pixels_stride),
537
24.9k
            scratch_space);
538
24.9k
      }
539
12.5k
      break;
540
0
    }
541
53.5k
    case Type::DCT4X4: {
542
53.5k
      float dcs[4] = {};
543
53.5k
      float block00 = coefficients[0];
544
53.5k
      float block01 = coefficients[1];
545
53.5k
      float block10 = coefficients[8];
546
53.5k
      float block11 = coefficients[9];
547
53.5k
      dcs[0] = block00 + block01 + block10 + block11;
548
53.5k
      dcs[1] = block00 + block01 - block10 - block11;
549
53.5k
      dcs[2] = block00 - block01 + block10 - block11;
550
53.5k
      dcs[3] = block00 - block01 - block10 + block11;
551
160k
      for (size_t y = 0; y < 2; y++) {
552
319k
        for (size_t x = 0; x < 2; x++) {
553
212k
          HWY_ALIGN float block[4 * 4];
554
212k
          block[0] = dcs[y * 2 + x];
555
1.06M
          for (size_t iy = 0; iy < 4; iy++) {
556
4.24M
            for (size_t ix = 0; ix < 4; ix++) {
557
3.39M
              if (ix == 0 && iy == 0) continue;
558
3.18M
              block[iy * 4 + ix] = coefficients[(y + iy * 2) * 8 + x + ix * 2];
559
3.18M
            }
560
849k
          }
561
212k
          ComputeScaledIDCT<4, 4>()(
562
212k
              block,
563
212k
              DCTTo(pixels + y * 4 * pixels_stride + x * 4, pixels_stride),
564
212k
              scratch_space);
565
212k
        }
566
106k
      }
567
53.5k
      break;
568
0
    }
569
47.2k
    case Type::DCT2X2: {
570
47.2k
      HWY_ALIGN float coeffs[kDCTBlockSize];
571
47.2k
      memcpy(coeffs, coefficients, sizeof(float) * kDCTBlockSize);
572
47.2k
      IDCT2TopBlock<2>(coeffs, kBlockDim, coeffs);
573
47.2k
      IDCT2TopBlock<4>(coeffs, kBlockDim, coeffs);
574
47.2k
      IDCT2TopBlock<8>(coeffs, kBlockDim, coeffs);
575
425k
      for (size_t y = 0; y < kBlockDim; y++) {
576
3.40M
        for (size_t x = 0; x < kBlockDim; x++) {
577
3.02M
          pixels[y * pixels_stride + x] = coeffs[y * kBlockDim + x];
578
3.02M
        }
579
377k
      }
580
47.2k
      break;
581
0
    }
582
3.42k
    case Type::DCT16X16: {
583
3.42k
      ComputeScaledIDCT<16, 16>()(coefficients, DCTTo(pixels, pixels_stride),
584
3.42k
                                  scratch_space);
585
3.42k
      break;
586
0
    }
587
18.2k
    case Type::DCT16X8: {
588
18.2k
      ComputeScaledIDCT<16, 8>()(coefficients, DCTTo(pixels, pixels_stride),
589
18.2k
                                 scratch_space);
590
18.2k
      break;
591
0
    }
592
1.63M
    case Type::DCT8X16: {
593
1.63M
      ComputeScaledIDCT<8, 16>()(coefficients, DCTTo(pixels, pixels_stride),
594
1.63M
                                 scratch_space);
595
1.63M
      break;
596
0
    }
597
2.11k
    case Type::DCT32X8: {
598
2.11k
      ComputeScaledIDCT<32, 8>()(coefficients, DCTTo(pixels, pixels_stride),
599
2.11k
                                 scratch_space);
600
2.11k
      break;
601
0
    }
602
3.37k
    case Type::DCT8X32: {
603
3.37k
      ComputeScaledIDCT<8, 32>()(coefficients, DCTTo(pixels, pixels_stride),
604
3.37k
                                 scratch_space);
605
3.37k
      break;
606
0
    }
607
2.75k
    case Type::DCT32X16: {
608
2.75k
      ComputeScaledIDCT<32, 16>()(coefficients, DCTTo(pixels, pixels_stride),
609
2.75k
                                  scratch_space);
610
2.75k
      break;
611
0
    }
612
1.84k
    case Type::DCT16X32: {
613
1.84k
      ComputeScaledIDCT<16, 32>()(coefficients, DCTTo(pixels, pixels_stride),
614
1.84k
                                  scratch_space);
615
1.84k
      break;
616
0
    }
617
738
    case Type::DCT32X32: {
618
738
      ComputeScaledIDCT<32, 32>()(coefficients, DCTTo(pixels, pixels_stride),
619
738
                                  scratch_space);
620
738
      break;
621
0
    }
622
468k
    case Type::DCT: {
623
468k
      ComputeScaledIDCT<8, 8>()(coefficients, DCTTo(pixels, pixels_stride),
624
468k
                                scratch_space);
625
468k
      break;
626
0
    }
627
10.0k
    case Type::AFV0: {
628
10.0k
      AFVTransformToPixels<0>(coefficients, pixels, pixels_stride);
629
10.0k
      break;
630
0
    }
631
546
    case Type::AFV1: {
632
546
      AFVTransformToPixels<1>(coefficients, pixels, pixels_stride);
633
546
      break;
634
0
    }
635
543
    case Type::AFV2: {
636
543
      AFVTransformToPixels<2>(coefficients, pixels, pixels_stride);
637
543
      break;
638
0
    }
639
597
    case Type::AFV3: {
640
597
      AFVTransformToPixels<3>(coefficients, pixels, pixels_stride);
641
597
      break;
642
0
    }
643
123
    case Type::DCT64X32: {
644
123
      ComputeScaledIDCT<64, 32>()(coefficients, DCTTo(pixels, pixels_stride),
645
123
                                  scratch_space);
646
123
      break;
647
0
    }
648
54
    case Type::DCT32X64: {
649
54
      ComputeScaledIDCT<32, 64>()(coefficients, DCTTo(pixels, pixels_stride),
650
54
                                  scratch_space);
651
54
      break;
652
0
    }
653
1.89k
    case Type::DCT64X64: {
654
1.89k
      ComputeScaledIDCT<64, 64>()(coefficients, DCTTo(pixels, pixels_stride),
655
1.89k
                                  scratch_space);
656
1.89k
      break;
657
0
    }
658
207
    case Type::DCT128X64: {
659
207
      ComputeScaledIDCT<128, 64>()(coefficients, DCTTo(pixels, pixels_stride),
660
207
                                   scratch_space);
661
207
      break;
662
0
    }
663
30
    case Type::DCT64X128: {
664
30
      ComputeScaledIDCT<64, 128>()(coefficients, DCTTo(pixels, pixels_stride),
665
30
                                   scratch_space);
666
30
      break;
667
0
    }
668
1.27k
    case Type::DCT128X128: {
669
1.27k
      ComputeScaledIDCT<128, 128>()(coefficients, DCTTo(pixels, pixels_stride),
670
1.27k
                                    scratch_space);
671
1.27k
      break;
672
0
    }
673
6
    case Type::DCT256X128: {
674
6
      ComputeScaledIDCT<256, 128>()(coefficients, DCTTo(pixels, pixels_stride),
675
6
                                    scratch_space);
676
6
      break;
677
0
    }
678
24
    case Type::DCT128X256: {
679
24
      ComputeScaledIDCT<128, 256>()(coefficients, DCTTo(pixels, pixels_stride),
680
24
                                    scratch_space);
681
24
      break;
682
0
    }
683
21
    case Type::DCT256X256: {
684
21
      ComputeScaledIDCT<256, 256>()(coefficients, DCTTo(pixels, pixels_stride),
685
21
                                    scratch_space);
686
21
      break;
687
0
    }
688
2.38M
  }
689
2.38M
}
dec_group.cc:jxl::N_AVX2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Line
Count
Source
460
6.86M
                                        float* scratch_space) {
461
6.86M
  using Type = AcStrategyType;
462
6.86M
  switch (strategy) {
463
1.58M
    case Type::IDENTITY: {
464
1.58M
      float dcs[4] = {};
465
1.58M
      float block00 = coefficients[0];
466
1.58M
      float block01 = coefficients[1];
467
1.58M
      float block10 = coefficients[8];
468
1.58M
      float block11 = coefficients[9];
469
1.58M
      dcs[0] = block00 + block01 + block10 + block11;
470
1.58M
      dcs[1] = block00 + block01 - block10 - block11;
471
1.58M
      dcs[2] = block00 - block01 + block10 - block11;
472
1.58M
      dcs[3] = block00 - block01 - block10 + block11;
473
4.74M
      for (size_t y = 0; y < 2; y++) {
474
9.48M
        for (size_t x = 0; x < 2; x++) {
475
6.32M
          float block_dc = dcs[y * 2 + x];
476
6.32M
          float residual_sum = 0;
477
31.6M
          for (size_t iy = 0; iy < 4; iy++) {
478
126M
            for (size_t ix = 0; ix < 4; ix++) {
479
101M
              if (ix == 0 && iy == 0) continue;
480
94.8M
              residual_sum += coefficients[(y + iy * 2) * 8 + x + ix * 2];
481
94.8M
            }
482
25.2M
          }
483
6.32M
          pixels[(4 * y + 1) * pixels_stride + 4 * x + 1] =
484
6.32M
              block_dc - residual_sum * (1.0f / 16);
485
31.6M
          for (size_t iy = 0; iy < 4; iy++) {
486
126M
            for (size_t ix = 0; ix < 4; ix++) {
487
101M
              if (ix == 1 && iy == 1) continue;
488
94.8M
              pixels[(y * 4 + iy) * pixels_stride + x * 4 + ix] =
489
94.8M
                  coefficients[(y + iy * 2) * 8 + x + ix * 2] +
490
94.8M
                  pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
491
94.8M
            }
492
25.2M
          }
493
6.32M
          pixels[y * 4 * pixels_stride + x * 4] =
494
6.32M
              coefficients[(y + 2) * 8 + x + 2] +
495
6.32M
              pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
496
6.32M
        }
497
3.16M
      }
498
1.58M
      break;
499
0
    }
500
11.6k
    case Type::DCT8X4: {
501
11.6k
      float dcs[2] = {};
502
11.6k
      float block0 = coefficients[0];
503
11.6k
      float block1 = coefficients[8];
504
11.6k
      dcs[0] = block0 + block1;
505
11.6k
      dcs[1] = block0 - block1;
506
35.0k
      for (size_t x = 0; x < 2; x++) {
507
23.3k
        HWY_ALIGN float block[4 * 8];
508
23.3k
        block[0] = dcs[x];
509
116k
        for (size_t iy = 0; iy < 4; iy++) {
510
839k
          for (size_t ix = 0; ix < 8; ix++) {
511
746k
            if (ix == 0 && iy == 0) continue;
512
723k
            block[iy * 8 + ix] = coefficients[(x + iy * 2) * 8 + ix];
513
723k
          }
514
93.3k
        }
515
23.3k
        ComputeScaledIDCT<8, 4>()(block, DCTTo(pixels + x * 4, pixels_stride),
516
23.3k
                                  scratch_space);
517
23.3k
      }
518
11.6k
      break;
519
0
    }
520
18.4k
    case Type::DCT4X8: {
521
18.4k
      float dcs[2] = {};
522
18.4k
      float block0 = coefficients[0];
523
18.4k
      float block1 = coefficients[8];
524
18.4k
      dcs[0] = block0 + block1;
525
18.4k
      dcs[1] = block0 - block1;
526
55.1k
      for (size_t y = 0; y < 2; y++) {
527
36.7k
        HWY_ALIGN float block[4 * 8];
528
36.7k
        block[0] = dcs[y];
529
183k
        for (size_t iy = 0; iy < 4; iy++) {
530
1.32M
          for (size_t ix = 0; ix < 8; ix++) {
531
1.17M
            if (ix == 0 && iy == 0) continue;
532
1.14M
            block[iy * 8 + ix] = coefficients[(y + iy * 2) * 8 + ix];
533
1.14M
          }
534
147k
        }
535
36.7k
        ComputeScaledIDCT<4, 8>()(
536
36.7k
            block, DCTTo(pixels + y * 4 * pixels_stride, pixels_stride),
537
36.7k
            scratch_space);
538
36.7k
      }
539
18.4k
      break;
540
0
    }
541
42.5k
    case Type::DCT4X4: {
542
42.5k
      float dcs[4] = {};
543
42.5k
      float block00 = coefficients[0];
544
42.5k
      float block01 = coefficients[1];
545
42.5k
      float block10 = coefficients[8];
546
42.5k
      float block11 = coefficients[9];
547
42.5k
      dcs[0] = block00 + block01 + block10 + block11;
548
42.5k
      dcs[1] = block00 + block01 - block10 - block11;
549
42.5k
      dcs[2] = block00 - block01 + block10 - block11;
550
42.5k
      dcs[3] = block00 - block01 - block10 + block11;
551
127k
      for (size_t y = 0; y < 2; y++) {
552
252k
        for (size_t x = 0; x < 2; x++) {
553
167k
          HWY_ALIGN float block[4 * 4];
554
167k
          block[0] = dcs[y * 2 + x];
555
839k
          for (size_t iy = 0; iy < 4; iy++) {
556
3.35M
            for (size_t ix = 0; ix < 4; ix++) {
557
2.68M
              if (ix == 0 && iy == 0) continue;
558
2.51M
              block[iy * 4 + ix] = coefficients[(y + iy * 2) * 8 + x + ix * 2];
559
2.51M
            }
560
671k
          }
561
167k
          ComputeScaledIDCT<4, 4>()(
562
167k
              block,
563
167k
              DCTTo(pixels + y * 4 * pixels_stride + x * 4, pixels_stride),
564
167k
              scratch_space);
565
167k
        }
566
84.7k
      }
567
42.5k
      break;
568
0
    }
569
110k
    case Type::DCT2X2: {
570
110k
      HWY_ALIGN float coeffs[kDCTBlockSize];
571
110k
      memcpy(coeffs, coefficients, sizeof(float) * kDCTBlockSize);
572
110k
      IDCT2TopBlock<2>(coeffs, kBlockDim, coeffs);
573
110k
      IDCT2TopBlock<4>(coeffs, kBlockDim, coeffs);
574
110k
      IDCT2TopBlock<8>(coeffs, kBlockDim, coeffs);
575
996k
      for (size_t y = 0; y < kBlockDim; y++) {
576
7.97M
        for (size_t x = 0; x < kBlockDim; x++) {
577
7.08M
          pixels[y * pixels_stride + x] = coeffs[y * kBlockDim + x];
578
7.08M
        }
579
885k
      }
580
110k
      break;
581
0
    }
582
8.66k
    case Type::DCT16X16: {
583
8.66k
      ComputeScaledIDCT<16, 16>()(coefficients, DCTTo(pixels, pixels_stride),
584
8.66k
                                  scratch_space);
585
8.66k
      break;
586
0
    }
587
71.5k
    case Type::DCT16X8: {
588
71.5k
      ComputeScaledIDCT<16, 8>()(coefficients, DCTTo(pixels, pixels_stride),
589
71.5k
                                 scratch_space);
590
71.5k
      break;
591
0
    }
592
3.90M
    case Type::DCT8X16: {
593
3.90M
      ComputeScaledIDCT<8, 16>()(coefficients, DCTTo(pixels, pixels_stride),
594
3.90M
                                 scratch_space);
595
3.90M
      break;
596
0
    }
597
5.23k
    case Type::DCT32X8: {
598
5.23k
      ComputeScaledIDCT<32, 8>()(coefficients, DCTTo(pixels, pixels_stride),
599
5.23k
                                 scratch_space);
600
5.23k
      break;
601
0
    }
602
3.26k
    case Type::DCT8X32: {
603
3.26k
      ComputeScaledIDCT<8, 32>()(coefficients, DCTTo(pixels, pixels_stride),
604
3.26k
                                 scratch_space);
605
3.26k
      break;
606
0
    }
607
5.23k
    case Type::DCT32X16: {
608
5.23k
      ComputeScaledIDCT<32, 16>()(coefficients, DCTTo(pixels, pixels_stride),
609
5.23k
                                  scratch_space);
610
5.23k
      break;
611
0
    }
612
6.42k
    case Type::DCT16X32: {
613
6.42k
      ComputeScaledIDCT<16, 32>()(coefficients, DCTTo(pixels, pixels_stride),
614
6.42k
                                  scratch_space);
615
6.42k
      break;
616
0
    }
617
1.71k
    case Type::DCT32X32: {
618
1.71k
      ComputeScaledIDCT<32, 32>()(coefficients, DCTTo(pixels, pixels_stride),
619
1.71k
                                  scratch_space);
620
1.71k
      break;
621
0
    }
622
1.06M
    case Type::DCT: {
623
1.06M
      ComputeScaledIDCT<8, 8>()(coefficients, DCTTo(pixels, pixels_stride),
624
1.06M
                                scratch_space);
625
1.06M
      break;
626
0
    }
627
10.3k
    case Type::AFV0: {
628
10.3k
      AFVTransformToPixels<0>(coefficients, pixels, pixels_stride);
629
10.3k
      break;
630
0
    }
631
2.30k
    case Type::AFV1: {
632
2.30k
      AFVTransformToPixels<1>(coefficients, pixels, pixels_stride);
633
2.30k
      break;
634
0
    }
635
2.52k
    case Type::AFV2: {
636
2.52k
      AFVTransformToPixels<2>(coefficients, pixels, pixels_stride);
637
2.52k
      break;
638
0
    }
639
5.27k
    case Type::AFV3: {
640
5.27k
      AFVTransformToPixels<3>(coefficients, pixels, pixels_stride);
641
5.27k
      break;
642
0
    }
643
552
    case Type::DCT64X32: {
644
552
      ComputeScaledIDCT<64, 32>()(coefficients, DCTTo(pixels, pixels_stride),
645
552
                                  scratch_space);
646
552
      break;
647
0
    }
648
114
    case Type::DCT32X64: {
649
114
      ComputeScaledIDCT<32, 64>()(coefficients, DCTTo(pixels, pixels_stride),
650
114
                                  scratch_space);
651
114
      break;
652
0
    }
653
3.81k
    case Type::DCT64X64: {
654
3.81k
      ComputeScaledIDCT<64, 64>()(coefficients, DCTTo(pixels, pixels_stride),
655
3.81k
                                  scratch_space);
656
3.81k
      break;
657
0
    }
658
321
    case Type::DCT128X64: {
659
321
      ComputeScaledIDCT<128, 64>()(coefficients, DCTTo(pixels, pixels_stride),
660
321
                                   scratch_space);
661
321
      break;
662
0
    }
663
162
    case Type::DCT64X128: {
664
162
      ComputeScaledIDCT<64, 128>()(coefficients, DCTTo(pixels, pixels_stride),
665
162
                                   scratch_space);
666
162
      break;
667
0
    }
668
3.07k
    case Type::DCT128X128: {
669
3.07k
      ComputeScaledIDCT<128, 128>()(coefficients, DCTTo(pixels, pixels_stride),
670
3.07k
                                    scratch_space);
671
3.07k
      break;
672
0
    }
673
21
    case Type::DCT256X128: {
674
21
      ComputeScaledIDCT<256, 128>()(coefficients, DCTTo(pixels, pixels_stride),
675
21
                                    scratch_space);
676
21
      break;
677
0
    }
678
27
    case Type::DCT128X256: {
679
27
      ComputeScaledIDCT<128, 256>()(coefficients, DCTTo(pixels, pixels_stride),
680
27
                                    scratch_space);
681
27
      break;
682
0
    }
683
30
    case Type::DCT256X256: {
684
30
      ComputeScaledIDCT<256, 256>()(coefficients, DCTTo(pixels, pixels_stride),
685
30
                                    scratch_space);
686
30
      break;
687
0
    }
688
6.86M
  }
689
6.86M
}
dec_group.cc:jxl::N_SSE2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Line
Count
Source
460
4.18M
                                        float* scratch_space) {
461
4.18M
  using Type = AcStrategyType;
462
4.18M
  switch (strategy) {
463
32.9k
    case Type::IDENTITY: {
464
32.9k
      float dcs[4] = {};
465
32.9k
      float block00 = coefficients[0];
466
32.9k
      float block01 = coefficients[1];
467
32.9k
      float block10 = coefficients[8];
468
32.9k
      float block11 = coefficients[9];
469
32.9k
      dcs[0] = block00 + block01 + block10 + block11;
470
32.9k
      dcs[1] = block00 + block01 - block10 - block11;
471
32.9k
      dcs[2] = block00 - block01 + block10 - block11;
472
32.9k
      dcs[3] = block00 - block01 - block10 + block11;
473
98.6k
      for (size_t y = 0; y < 2; y++) {
474
197k
        for (size_t x = 0; x < 2; x++) {
475
131k
          float block_dc = dcs[y * 2 + x];
476
131k
          float residual_sum = 0;
477
657k
          for (size_t iy = 0; iy < 4; iy++) {
478
2.62M
            for (size_t ix = 0; ix < 4; ix++) {
479
2.10M
              if (ix == 0 && iy == 0) continue;
480
1.97M
              residual_sum += coefficients[(y + iy * 2) * 8 + x + ix * 2];
481
1.97M
            }
482
525k
          }
483
131k
          pixels[(4 * y + 1) * pixels_stride + 4 * x + 1] =
484
131k
              block_dc - residual_sum * (1.0f / 16);
485
657k
          for (size_t iy = 0; iy < 4; iy++) {
486
2.62M
            for (size_t ix = 0; ix < 4; ix++) {
487
2.10M
              if (ix == 1 && iy == 1) continue;
488
1.97M
              pixels[(y * 4 + iy) * pixels_stride + x * 4 + ix] =
489
1.97M
                  coefficients[(y + iy * 2) * 8 + x + ix * 2] +
490
1.97M
                  pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
491
1.97M
            }
492
525k
          }
493
131k
          pixels[y * 4 * pixels_stride + x * 4] =
494
131k
              coefficients[(y + 2) * 8 + x + 2] +
495
131k
              pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
496
131k
        }
497
65.6k
      }
498
32.9k
      break;
499
0
    }
500
4.24k
    case Type::DCT8X4: {
501
4.24k
      float dcs[2] = {};
502
4.24k
      float block0 = coefficients[0];
503
4.24k
      float block1 = coefficients[8];
504
4.24k
      dcs[0] = block0 + block1;
505
4.24k
      dcs[1] = block0 - block1;
506
12.7k
      for (size_t x = 0; x < 2; x++) {
507
8.47k
        HWY_ALIGN float block[4 * 8];
508
8.47k
        block[0] = dcs[x];
509
42.3k
        for (size_t iy = 0; iy < 4; iy++) {
510
304k
          for (size_t ix = 0; ix < 8; ix++) {
511
271k
            if (ix == 0 && iy == 0) continue;
512
262k
            block[iy * 8 + ix] = coefficients[(x + iy * 2) * 8 + ix];
513
262k
          }
514
33.8k
        }
515
8.47k
        ComputeScaledIDCT<8, 4>()(block, DCTTo(pixels + x * 4, pixels_stride),
516
8.47k
                                  scratch_space);
517
8.47k
      }
518
4.24k
      break;
519
0
    }
520
23.2k
    case Type::DCT4X8: {
521
23.2k
      float dcs[2] = {};
522
23.2k
      float block0 = coefficients[0];
523
23.2k
      float block1 = coefficients[8];
524
23.2k
      dcs[0] = block0 + block1;
525
23.2k
      dcs[1] = block0 - block1;
526
69.3k
      for (size_t y = 0; y < 2; y++) {
527
46.0k
        HWY_ALIGN float block[4 * 8];
528
46.0k
        block[0] = dcs[y];
529
230k
        for (size_t iy = 0; iy < 4; iy++) {
530
1.65M
          for (size_t ix = 0; ix < 8; ix++) {
531
1.46M
            if (ix == 0 && iy == 0) continue;
532
1.42M
            block[iy * 8 + ix] = coefficients[(y + iy * 2) * 8 + ix];
533
1.42M
          }
534
184k
        }
535
46.0k
        ComputeScaledIDCT<4, 8>()(
536
46.0k
            block, DCTTo(pixels + y * 4 * pixels_stride, pixels_stride),
537
46.0k
            scratch_space);
538
46.0k
      }
539
23.2k
      break;
540
0
    }
541
16.3k
    case Type::DCT4X4: {
542
16.3k
      float dcs[4] = {};
543
16.3k
      float block00 = coefficients[0];
544
16.3k
      float block01 = coefficients[1];
545
16.3k
      float block10 = coefficients[8];
546
16.3k
      float block11 = coefficients[9];
547
16.3k
      dcs[0] = block00 + block01 + block10 + block11;
548
16.3k
      dcs[1] = block00 + block01 - block10 - block11;
549
16.3k
      dcs[2] = block00 - block01 + block10 - block11;
550
16.3k
      dcs[3] = block00 - block01 - block10 + block11;
551
49.0k
      for (size_t y = 0; y < 2; y++) {
552
97.9k
        for (size_t x = 0; x < 2; x++) {
553
65.2k
          HWY_ALIGN float block[4 * 4];
554
65.2k
          block[0] = dcs[y * 2 + x];
555
326k
          for (size_t iy = 0; iy < 4; iy++) {
556
1.30M
            for (size_t ix = 0; ix < 4; ix++) {
557
1.04M
              if (ix == 0 && iy == 0) continue;
558
979k
              block[iy * 4 + ix] = coefficients[(y + iy * 2) * 8 + x + ix * 2];
559
979k
            }
560
261k
          }
561
65.2k
          ComputeScaledIDCT<4, 4>()(
562
65.2k
              block,
563
65.2k
              DCTTo(pixels + y * 4 * pixels_stride + x * 4, pixels_stride),
564
65.2k
              scratch_space);
565
65.2k
        }
566
32.6k
      }
567
16.3k
      break;
568
0
    }
569
36.3k
    case Type::DCT2X2: {
570
36.3k
      HWY_ALIGN float coeffs[kDCTBlockSize];
571
36.3k
      memcpy(coeffs, coefficients, sizeof(float) * kDCTBlockSize);
572
36.3k
      IDCT2TopBlock<2>(coeffs, kBlockDim, coeffs);
573
36.3k
      IDCT2TopBlock<4>(coeffs, kBlockDim, coeffs);
574
36.3k
      IDCT2TopBlock<8>(coeffs, kBlockDim, coeffs);
575
327k
      for (size_t y = 0; y < kBlockDim; y++) {
576
2.61M
        for (size_t x = 0; x < kBlockDim; x++) {
577
2.32M
          pixels[y * pixels_stride + x] = coeffs[y * kBlockDim + x];
578
2.32M
        }
579
290k
      }
580
36.3k
      break;
581
0
    }
582
4.44k
    case Type::DCT16X16: {
583
4.44k
      ComputeScaledIDCT<16, 16>()(coefficients, DCTTo(pixels, pixels_stride),
584
4.44k
                                  scratch_space);
585
4.44k
      break;
586
0
    }
587
13.8k
    case Type::DCT16X8: {
588
13.8k
      ComputeScaledIDCT<16, 8>()(coefficients, DCTTo(pixels, pixels_stride),
589
13.8k
                                 scratch_space);
590
13.8k
      break;
591
0
    }
592
3.53M
    case Type::DCT8X16: {
593
3.53M
      ComputeScaledIDCT<8, 16>()(coefficients, DCTTo(pixels, pixels_stride),
594
3.53M
                                 scratch_space);
595
3.53M
      break;
596
0
    }
597
3.65k
    case Type::DCT32X8: {
598
3.65k
      ComputeScaledIDCT<32, 8>()(coefficients, DCTTo(pixels, pixels_stride),
599
3.65k
                                 scratch_space);
600
3.65k
      break;
601
0
    }
602
6.89k
    case Type::DCT8X32: {
603
6.89k
      ComputeScaledIDCT<8, 32>()(coefficients, DCTTo(pixels, pixels_stride),
604
6.89k
                                 scratch_space);
605
6.89k
      break;
606
0
    }
607
2.35k
    case Type::DCT32X16: {
608
2.35k
      ComputeScaledIDCT<32, 16>()(coefficients, DCTTo(pixels, pixels_stride),
609
2.35k
                                  scratch_space);
610
2.35k
      break;
611
0
    }
612
1.80k
    case Type::DCT16X32: {
613
1.80k
      ComputeScaledIDCT<16, 32>()(coefficients, DCTTo(pixels, pixels_stride),
614
1.80k
                                  scratch_space);
615
1.80k
      break;
616
0
    }
617
732
    case Type::DCT32X32: {
618
732
      ComputeScaledIDCT<32, 32>()(coefficients, DCTTo(pixels, pixels_stride),
619
732
                                  scratch_space);
620
732
      break;
621
0
    }
622
495k
    case Type::DCT: {
623
495k
      ComputeScaledIDCT<8, 8>()(coefficients, DCTTo(pixels, pixels_stride),
624
495k
                                scratch_space);
625
495k
      break;
626
0
    }
627
5.20k
    case Type::AFV0: {
628
5.20k
      AFVTransformToPixels<0>(coefficients, pixels, pixels_stride);
629
5.20k
      break;
630
0
    }
631
633
    case Type::AFV1: {
632
633
      AFVTransformToPixels<1>(coefficients, pixels, pixels_stride);
633
633
      break;
634
0
    }
635
978
    case Type::AFV2: {
636
978
      AFVTransformToPixels<2>(coefficients, pixels, pixels_stride);
637
978
      break;
638
0
    }
639
369
    case Type::AFV3: {
640
369
      AFVTransformToPixels<3>(coefficients, pixels, pixels_stride);
641
369
      break;
642
0
    }
643
84
    case Type::DCT64X32: {
644
84
      ComputeScaledIDCT<64, 32>()(coefficients, DCTTo(pixels, pixels_stride),
645
84
                                  scratch_space);
646
84
      break;
647
0
    }
648
57
    case Type::DCT32X64: {
649
57
      ComputeScaledIDCT<32, 64>()(coefficients, DCTTo(pixels, pixels_stride),
650
57
                                  scratch_space);
651
57
      break;
652
0
    }
653
1.05k
    case Type::DCT64X64: {
654
1.05k
      ComputeScaledIDCT<64, 64>()(coefficients, DCTTo(pixels, pixels_stride),
655
1.05k
                                  scratch_space);
656
1.05k
      break;
657
0
    }
658
279
    case Type::DCT128X64: {
659
279
      ComputeScaledIDCT<128, 64>()(coefficients, DCTTo(pixels, pixels_stride),
660
279
                                   scratch_space);
661
279
      break;
662
0
    }
663
27
    case Type::DCT64X128: {
664
27
      ComputeScaledIDCT<64, 128>()(coefficients, DCTTo(pixels, pixels_stride),
665
27
                                   scratch_space);
666
27
      break;
667
0
    }
668
2.82k
    case Type::DCT128X128: {
669
2.82k
      ComputeScaledIDCT<128, 128>()(coefficients, DCTTo(pixels, pixels_stride),
670
2.82k
                                    scratch_space);
671
2.82k
      break;
672
0
    }
673
3
    case Type::DCT256X128: {
674
3
      ComputeScaledIDCT<256, 128>()(coefficients, DCTTo(pixels, pixels_stride),
675
3
                                    scratch_space);
676
3
      break;
677
0
    }
678
18
    case Type::DCT128X256: {
679
18
      ComputeScaledIDCT<128, 256>()(coefficients, DCTTo(pixels, pixels_stride),
680
18
                                    scratch_space);
681
18
      break;
682
0
    }
683
12
    case Type::DCT256X256: {
684
12
      ComputeScaledIDCT<256, 256>()(coefficients, DCTTo(pixels, pixels_stride),
685
12
                                    scratch_space);
686
12
      break;
687
0
    }
688
4.18M
  }
689
4.18M
}
Unexecuted instantiation: enc_group.cc:jxl::N_SSE4::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:jxl::N_AVX2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Unexecuted instantiation: enc_group.cc:jxl::N_SSE2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_SSE4::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
enc_ac_strategy.cc:jxl::N_AVX2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Line
Count
Source
460
8.22k
                                        float* scratch_space) {
461
8.22k
  using Type = AcStrategyType;
462
8.22k
  switch (strategy) {
463
822
    case Type::IDENTITY: {
464
822
      float dcs[4] = {};
465
822
      float block00 = coefficients[0];
466
822
      float block01 = coefficients[1];
467
822
      float block10 = coefficients[8];
468
822
      float block11 = coefficients[9];
469
822
      dcs[0] = block00 + block01 + block10 + block11;
470
822
      dcs[1] = block00 + block01 - block10 - block11;
471
822
      dcs[2] = block00 - block01 + block10 - block11;
472
822
      dcs[3] = block00 - block01 - block10 + block11;
473
2.46k
      for (size_t y = 0; y < 2; y++) {
474
4.93k
        for (size_t x = 0; x < 2; x++) {
475
3.28k
          float block_dc = dcs[y * 2 + x];
476
3.28k
          float residual_sum = 0;
477
16.4k
          for (size_t iy = 0; iy < 4; iy++) {
478
65.7k
            for (size_t ix = 0; ix < 4; ix++) {
479
52.6k
              if (ix == 0 && iy == 0) continue;
480
49.3k
              residual_sum += coefficients[(y + iy * 2) * 8 + x + ix * 2];
481
49.3k
            }
482
13.1k
          }
483
3.28k
          pixels[(4 * y + 1) * pixels_stride + 4 * x + 1] =
484
3.28k
              block_dc - residual_sum * (1.0f / 16);
485
16.4k
          for (size_t iy = 0; iy < 4; iy++) {
486
65.7k
            for (size_t ix = 0; ix < 4; ix++) {
487
52.6k
              if (ix == 1 && iy == 1) continue;
488
49.3k
              pixels[(y * 4 + iy) * pixels_stride + x * 4 + ix] =
489
49.3k
                  coefficients[(y + iy * 2) * 8 + x + ix * 2] +
490
49.3k
                  pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
491
49.3k
            }
492
13.1k
          }
493
3.28k
          pixels[y * 4 * pixels_stride + x * 4] =
494
3.28k
              coefficients[(y + 2) * 8 + x + 2] +
495
3.28k
              pixels[(4 * y + 1) * pixels_stride + 4 * x + 1];
496
3.28k
        }
497
1.64k
      }
498
822
      break;
499
0
    }
500
822
    case Type::DCT8X4: {
501
822
      float dcs[2] = {};
502
822
      float block0 = coefficients[0];
503
822
      float block1 = coefficients[8];
504
822
      dcs[0] = block0 + block1;
505
822
      dcs[1] = block0 - block1;
506
2.46k
      for (size_t x = 0; x < 2; x++) {
507
1.64k
        HWY_ALIGN float block[4 * 8];
508
1.64k
        block[0] = dcs[x];
509
8.22k
        for (size_t iy = 0; iy < 4; iy++) {
510
59.1k
          for (size_t ix = 0; ix < 8; ix++) {
511
52.6k
            if (ix == 0 && iy == 0) continue;
512
50.9k
            block[iy * 8 + ix] = coefficients[(x + iy * 2) * 8 + ix];
513
50.9k
          }
514
6.57k
        }
515
1.64k
        ComputeScaledIDCT<8, 4>()(block, DCTTo(pixels + x * 4, pixels_stride),
516
1.64k
                                  scratch_space);
517
1.64k
      }
518
822
      break;
519
0
    }
520
822
    case Type::DCT4X8: {
521
822
      float dcs[2] = {};
522
822
      float block0 = coefficients[0];
523
822
      float block1 = coefficients[8];
524
822
      dcs[0] = block0 + block1;
525
822
      dcs[1] = block0 - block1;
526
2.46k
      for (size_t y = 0; y < 2; y++) {
527
1.64k
        HWY_ALIGN float block[4 * 8];
528
1.64k
        block[0] = dcs[y];
529
8.22k
        for (size_t iy = 0; iy < 4; iy++) {
530
59.1k
          for (size_t ix = 0; ix < 8; ix++) {
531
52.6k
            if (ix == 0 && iy == 0) continue;
532
50.9k
            block[iy * 8 + ix] = coefficients[(y + iy * 2) * 8 + ix];
533
50.9k
          }
534
6.57k
        }
535
1.64k
        ComputeScaledIDCT<4, 8>()(
536
1.64k
            block, DCTTo(pixels + y * 4 * pixels_stride, pixels_stride),
537
1.64k
            scratch_space);
538
1.64k
      }
539
822
      break;
540
0
    }
541
822
    case Type::DCT4X4: {
542
822
      float dcs[4] = {};
543
822
      float block00 = coefficients[0];
544
822
      float block01 = coefficients[1];
545
822
      float block10 = coefficients[8];
546
822
      float block11 = coefficients[9];
547
822
      dcs[0] = block00 + block01 + block10 + block11;
548
822
      dcs[1] = block00 + block01 - block10 - block11;
549
822
      dcs[2] = block00 - block01 + block10 - block11;
550
822
      dcs[3] = block00 - block01 - block10 + block11;
551
2.46k
      for (size_t y = 0; y < 2; y++) {
552
4.93k
        for (size_t x = 0; x < 2; x++) {
553
3.28k
          HWY_ALIGN float block[4 * 4];
554
3.28k
          block[0] = dcs[y * 2 + x];
555
16.4k
          for (size_t iy = 0; iy < 4; iy++) {
556
65.7k
            for (size_t ix = 0; ix < 4; ix++) {
557
52.6k
              if (ix == 0 && iy == 0) continue;
558
49.3k
              block[iy * 4 + ix] = coefficients[(y + iy * 2) * 8 + x + ix * 2];
559
49.3k
            }
560
13.1k
          }
561
3.28k
          ComputeScaledIDCT<4, 4>()(
562
3.28k
              block,
563
3.28k
              DCTTo(pixels + y * 4 * pixels_stride + x * 4, pixels_stride),
564
3.28k
              scratch_space);
565
3.28k
        }
566
1.64k
      }
567
822
      break;
568
0
    }
569
822
    case Type::DCT2X2: {
570
822
      HWY_ALIGN float coeffs[kDCTBlockSize];
571
822
      memcpy(coeffs, coefficients, sizeof(float) * kDCTBlockSize);
572
822
      IDCT2TopBlock<2>(coeffs, kBlockDim, coeffs);
573
822
      IDCT2TopBlock<4>(coeffs, kBlockDim, coeffs);
574
822
      IDCT2TopBlock<8>(coeffs, kBlockDim, coeffs);
575
7.39k
      for (size_t y = 0; y < kBlockDim; y++) {
576
59.1k
        for (size_t x = 0; x < kBlockDim; x++) {
577
52.6k
          pixels[y * pixels_stride + x] = coeffs[y * kBlockDim + x];
578
52.6k
        }
579
6.57k
      }
580
822
      break;
581
0
    }
582
0
    case Type::DCT16X16: {
583
0
      ComputeScaledIDCT<16, 16>()(coefficients, DCTTo(pixels, pixels_stride),
584
0
                                  scratch_space);
585
0
      break;
586
0
    }
587
0
    case Type::DCT16X8: {
588
0
      ComputeScaledIDCT<16, 8>()(coefficients, DCTTo(pixels, pixels_stride),
589
0
                                 scratch_space);
590
0
      break;
591
0
    }
592
0
    case Type::DCT8X16: {
593
0
      ComputeScaledIDCT<8, 16>()(coefficients, DCTTo(pixels, pixels_stride),
594
0
                                 scratch_space);
595
0
      break;
596
0
    }
597
0
    case Type::DCT32X8: {
598
0
      ComputeScaledIDCT<32, 8>()(coefficients, DCTTo(pixels, pixels_stride),
599
0
                                 scratch_space);
600
0
      break;
601
0
    }
602
0
    case Type::DCT8X32: {
603
0
      ComputeScaledIDCT<8, 32>()(coefficients, DCTTo(pixels, pixels_stride),
604
0
                                 scratch_space);
605
0
      break;
606
0
    }
607
0
    case Type::DCT32X16: {
608
0
      ComputeScaledIDCT<32, 16>()(coefficients, DCTTo(pixels, pixels_stride),
609
0
                                  scratch_space);
610
0
      break;
611
0
    }
612
0
    case Type::DCT16X32: {
613
0
      ComputeScaledIDCT<16, 32>()(coefficients, DCTTo(pixels, pixels_stride),
614
0
                                  scratch_space);
615
0
      break;
616
0
    }
617
0
    case Type::DCT32X32: {
618
0
      ComputeScaledIDCT<32, 32>()(coefficients, DCTTo(pixels, pixels_stride),
619
0
                                  scratch_space);
620
0
      break;
621
0
    }
622
822
    case Type::DCT: {
623
822
      ComputeScaledIDCT<8, 8>()(coefficients, DCTTo(pixels, pixels_stride),
624
822
                                scratch_space);
625
822
      break;
626
0
    }
627
822
    case Type::AFV0: {
628
822
      AFVTransformToPixels<0>(coefficients, pixels, pixels_stride);
629
822
      break;
630
0
    }
631
822
    case Type::AFV1: {
632
822
      AFVTransformToPixels<1>(coefficients, pixels, pixels_stride);
633
822
      break;
634
0
    }
635
822
    case Type::AFV2: {
636
822
      AFVTransformToPixels<2>(coefficients, pixels, pixels_stride);
637
822
      break;
638
0
    }
639
822
    case Type::AFV3: {
640
822
      AFVTransformToPixels<3>(coefficients, pixels, pixels_stride);
641
822
      break;
642
0
    }
643
0
    case Type::DCT64X32: {
644
0
      ComputeScaledIDCT<64, 32>()(coefficients, DCTTo(pixels, pixels_stride),
645
0
                                  scratch_space);
646
0
      break;
647
0
    }
648
0
    case Type::DCT32X64: {
649
0
      ComputeScaledIDCT<32, 64>()(coefficients, DCTTo(pixels, pixels_stride),
650
0
                                  scratch_space);
651
0
      break;
652
0
    }
653
0
    case Type::DCT64X64: {
654
0
      ComputeScaledIDCT<64, 64>()(coefficients, DCTTo(pixels, pixels_stride),
655
0
                                  scratch_space);
656
0
      break;
657
0
    }
658
0
    case Type::DCT128X64: {
659
0
      ComputeScaledIDCT<128, 64>()(coefficients, DCTTo(pixels, pixels_stride),
660
0
                                   scratch_space);
661
0
      break;
662
0
    }
663
0
    case Type::DCT64X128: {
664
0
      ComputeScaledIDCT<64, 128>()(coefficients, DCTTo(pixels, pixels_stride),
665
0
                                   scratch_space);
666
0
      break;
667
0
    }
668
0
    case Type::DCT128X128: {
669
0
      ComputeScaledIDCT<128, 128>()(coefficients, DCTTo(pixels, pixels_stride),
670
0
                                    scratch_space);
671
0
      break;
672
0
    }
673
0
    case Type::DCT256X128: {
674
0
      ComputeScaledIDCT<256, 128>()(coefficients, DCTTo(pixels, pixels_stride),
675
0
                                    scratch_space);
676
0
      break;
677
0
    }
678
0
    case Type::DCT128X256: {
679
0
      ComputeScaledIDCT<128, 256>()(coefficients, DCTTo(pixels, pixels_stride),
680
0
                                    scratch_space);
681
0
      break;
682
0
    }
683
0
    case Type::DCT256X256: {
684
0
      ComputeScaledIDCT<256, 256>()(coefficients, DCTTo(pixels, pixels_stride),
685
0
                                    scratch_space);
686
0
      break;
687
0
    }
688
8.22k
  }
689
8.22k
}
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_SSE2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_SSE4::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_AVX2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_SSE2::(anonymous namespace)::TransformToPixels(jxl::AcStrategyType, float*, float*, unsigned long, float*)
690
691
HWY_MAYBE_UNUSED void LowestFrequenciesFromDC(const AcStrategyType strategy,
692
                                              const float* dc, size_t dc_stride,
693
                                              float* llf,
694
14.8M
                                              float* JXL_RESTRICT scratch) {
695
14.8M
  using Type = AcStrategyType;
696
14.8M
  HWY_ALIGN float warm_block[4 * 4];
697
14.8M
  HWY_ALIGN float warm_scratch_space[4 * 4 * 4];
698
14.8M
  switch (strategy) {
699
103k
    case Type::DCT16X8: {
700
103k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/kBlockDim,
701
103k
                        /*LF_ROWS=*/2, /*LF_COLS=*/1, /*ROWS=*/2, /*COLS=*/1>(
702
103k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
703
103k
      break;
704
0
    }
705
9.11M
    case Type::DCT8X16: {
706
9.11M
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
707
9.11M
                        /*LF_ROWS=*/1, /*LF_COLS=*/2, /*ROWS=*/1, /*COLS=*/2>(
708
9.11M
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
709
9.11M
      break;
710
0
    }
711
16.5k
    case Type::DCT16X16: {
712
16.5k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
713
16.5k
                        /*LF_ROWS=*/2, /*LF_COLS=*/2, /*ROWS=*/2, /*COLS=*/2>(
714
16.5k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
715
16.5k
      break;
716
0
    }
717
11.0k
    case Type::DCT32X8: {
718
11.0k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/kBlockDim,
719
11.0k
                        /*LF_ROWS=*/4, /*LF_COLS=*/1, /*ROWS=*/4, /*COLS=*/1>(
720
11.0k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
721
11.0k
      break;
722
0
    }
723
13.5k
    case Type::DCT8X32: {
724
13.5k
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
725
13.5k
                        /*LF_ROWS=*/1, /*LF_COLS=*/4, /*ROWS=*/1, /*COLS=*/4>(
726
13.5k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
727
13.5k
      break;
728
0
    }
729
10.3k
    case Type::DCT32X16: {
730
10.3k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
731
10.3k
                        /*LF_ROWS=*/4, /*LF_COLS=*/2, /*ROWS=*/4, /*COLS=*/2>(
732
10.3k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
733
10.3k
      break;
734
0
    }
735
10.0k
    case Type::DCT16X32: {
736
10.0k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
737
10.0k
                        /*LF_ROWS=*/2, /*LF_COLS=*/4, /*ROWS=*/2, /*COLS=*/4>(
738
10.0k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
739
10.0k
      break;
740
0
    }
741
3.18k
    case Type::DCT32X32: {
742
3.18k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
743
3.18k
                        /*LF_ROWS=*/4, /*LF_COLS=*/4, /*ROWS=*/4, /*COLS=*/4>(
744
3.18k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
745
3.18k
      break;
746
0
    }
747
759
    case Type::DCT64X32: {
748
759
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
749
759
                        /*LF_ROWS=*/8, /*LF_COLS=*/4, /*ROWS=*/8, /*COLS=*/4>(
750
759
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 4);
751
759
      break;
752
0
    }
753
225
    case Type::DCT32X64: {
754
225
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
755
225
                        /*LF_ROWS=*/4, /*LF_COLS=*/8, /*ROWS=*/4, /*COLS=*/8>(
756
225
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 4 * 8);
757
225
      break;
758
0
    }
759
6.76k
    case Type::DCT64X64: {
760
6.76k
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
761
6.76k
                        /*LF_ROWS=*/8, /*LF_COLS=*/8, /*ROWS=*/8, /*COLS=*/8>(
762
6.76k
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 8);
763
6.76k
      break;
764
0
    }
765
807
    case Type::DCT128X64: {
766
807
      ReinterpretingDCT</*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
767
807
                        /*LF_ROWS=*/16, /*LF_COLS=*/8, /*ROWS=*/16, /*COLS=*/8>(
768
807
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 8);
769
807
      break;
770
0
    }
771
219
    case Type::DCT64X128: {
772
219
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
773
219
                        /*LF_ROWS=*/8, /*LF_COLS=*/16, /*ROWS=*/8, /*COLS=*/16>(
774
219
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 8 * 16);
775
219
      break;
776
0
    }
777
7.17k
    case Type::DCT128X128: {
778
7.17k
      ReinterpretingDCT<
779
7.17k
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
780
7.17k
          /*LF_ROWS=*/16, /*LF_COLS=*/16, /*ROWS=*/16, /*COLS=*/16>(
781
7.17k
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 16);
782
7.17k
      break;
783
0
    }
784
30
    case Type::DCT256X128: {
785
30
      ReinterpretingDCT<
786
30
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
787
30
          /*LF_ROWS=*/32, /*LF_COLS=*/16, /*ROWS=*/32, /*COLS=*/16>(
788
30
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 16);
789
30
      break;
790
0
    }
791
69
    case Type::DCT128X256: {
792
69
      ReinterpretingDCT<
793
69
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
794
69
          /*LF_ROWS=*/16, /*LF_COLS=*/32, /*ROWS=*/16, /*COLS=*/32>(
795
69
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 16 * 32);
796
69
      break;
797
0
    }
798
63
    case Type::DCT256X256: {
799
63
      ReinterpretingDCT<
800
63
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
801
63
          /*LF_ROWS=*/32, /*LF_COLS=*/32, /*ROWS=*/32, /*COLS=*/32>(
802
63
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 32);
803
63
      break;
804
0
    }
805
3.06M
    case Type::DCT:
806
3.25M
    case Type::DCT2X2:
807
3.36M
    case Type::DCT4X4:
808
3.42M
    case Type::DCT4X8:
809
3.43M
    case Type::DCT8X4:
810
3.46M
    case Type::AFV0:
811
3.46M
    case Type::AFV1:
812
3.47M
    case Type::AFV2:
813
3.47M
    case Type::AFV3:
814
5.59M
    case Type::IDENTITY:
815
5.59M
      llf[0] = dc[0];
816
5.59M
      break;
817
14.8M
  };
818
14.8M
}
dec_group.cc:jxl::N_SSE4::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Line
Count
Source
694
2.69M
                                              float* JXL_RESTRICT scratch) {
695
2.69M
  using Type = AcStrategyType;
696
2.69M
  HWY_ALIGN float warm_block[4 * 4];
697
2.69M
  HWY_ALIGN float warm_scratch_space[4 * 4 * 4];
698
2.69M
  switch (strategy) {
699
18.2k
    case Type::DCT16X8: {
700
18.2k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/kBlockDim,
701
18.2k
                        /*LF_ROWS=*/2, /*LF_COLS=*/1, /*ROWS=*/2, /*COLS=*/1>(
702
18.2k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
703
18.2k
      break;
704
0
    }
705
1.64M
    case Type::DCT8X16: {
706
1.64M
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
707
1.64M
                        /*LF_ROWS=*/1, /*LF_COLS=*/2, /*ROWS=*/1, /*COLS=*/2>(
708
1.64M
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
709
1.64M
      break;
710
0
    }
711
3.42k
    case Type::DCT16X16: {
712
3.42k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
713
3.42k
                        /*LF_ROWS=*/2, /*LF_COLS=*/2, /*ROWS=*/2, /*COLS=*/2>(
714
3.42k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
715
3.42k
      break;
716
0
    }
717
2.12k
    case Type::DCT32X8: {
718
2.12k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/kBlockDim,
719
2.12k
                        /*LF_ROWS=*/4, /*LF_COLS=*/1, /*ROWS=*/4, /*COLS=*/1>(
720
2.12k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
721
2.12k
      break;
722
0
    }
723
3.37k
    case Type::DCT8X32: {
724
3.37k
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
725
3.37k
                        /*LF_ROWS=*/1, /*LF_COLS=*/4, /*ROWS=*/1, /*COLS=*/4>(
726
3.37k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
727
3.37k
      break;
728
0
    }
729
2.75k
    case Type::DCT32X16: {
730
2.75k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
731
2.75k
                        /*LF_ROWS=*/4, /*LF_COLS=*/2, /*ROWS=*/4, /*COLS=*/2>(
732
2.75k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
733
2.75k
      break;
734
0
    }
735
1.85k
    case Type::DCT16X32: {
736
1.85k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
737
1.85k
                        /*LF_ROWS=*/2, /*LF_COLS=*/4, /*ROWS=*/2, /*COLS=*/4>(
738
1.85k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
739
1.85k
      break;
740
0
    }
741
738
    case Type::DCT32X32: {
742
738
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
743
738
                        /*LF_ROWS=*/4, /*LF_COLS=*/4, /*ROWS=*/4, /*COLS=*/4>(
744
738
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
745
738
      break;
746
0
    }
747
123
    case Type::DCT64X32: {
748
123
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
749
123
                        /*LF_ROWS=*/8, /*LF_COLS=*/4, /*ROWS=*/8, /*COLS=*/4>(
750
123
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 4);
751
123
      break;
752
0
    }
753
54
    case Type::DCT32X64: {
754
54
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
755
54
                        /*LF_ROWS=*/4, /*LF_COLS=*/8, /*ROWS=*/4, /*COLS=*/8>(
756
54
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 4 * 8);
757
54
      break;
758
0
    }
759
1.89k
    case Type::DCT64X64: {
760
1.89k
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
761
1.89k
                        /*LF_ROWS=*/8, /*LF_COLS=*/8, /*ROWS=*/8, /*COLS=*/8>(
762
1.89k
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 8);
763
1.89k
      break;
764
0
    }
765
207
    case Type::DCT128X64: {
766
207
      ReinterpretingDCT</*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
767
207
                        /*LF_ROWS=*/16, /*LF_COLS=*/8, /*ROWS=*/16, /*COLS=*/8>(
768
207
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 8);
769
207
      break;
770
0
    }
771
30
    case Type::DCT64X128: {
772
30
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
773
30
                        /*LF_ROWS=*/8, /*LF_COLS=*/16, /*ROWS=*/8, /*COLS=*/16>(
774
30
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 8 * 16);
775
30
      break;
776
0
    }
777
1.27k
    case Type::DCT128X128: {
778
1.27k
      ReinterpretingDCT<
779
1.27k
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
780
1.27k
          /*LF_ROWS=*/16, /*LF_COLS=*/16, /*ROWS=*/16, /*COLS=*/16>(
781
1.27k
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 16);
782
1.27k
      break;
783
0
    }
784
6
    case Type::DCT256X128: {
785
6
      ReinterpretingDCT<
786
6
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
787
6
          /*LF_ROWS=*/32, /*LF_COLS=*/16, /*ROWS=*/32, /*COLS=*/16>(
788
6
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 16);
789
6
      break;
790
0
    }
791
24
    case Type::DCT128X256: {
792
24
      ReinterpretingDCT<
793
24
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
794
24
          /*LF_ROWS=*/16, /*LF_COLS=*/32, /*ROWS=*/16, /*COLS=*/32>(
795
24
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 16 * 32);
796
24
      break;
797
0
    }
798
21
    case Type::DCT256X256: {
799
21
      ReinterpretingDCT<
800
21
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
801
21
          /*LF_ROWS=*/32, /*LF_COLS=*/32, /*ROWS=*/32, /*COLS=*/32>(
802
21
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 32);
803
21
      break;
804
0
    }
805
780k
    case Type::DCT:
806
827k
    case Type::DCT2X2:
807
881k
    case Type::DCT4X4:
808
893k
    case Type::DCT4X8:
809
894k
    case Type::DCT8X4:
810
904k
    case Type::AFV0:
811
905k
    case Type::AFV1:
812
905k
    case Type::AFV2:
813
906k
    case Type::AFV3:
814
1.01M
    case Type::IDENTITY:
815
1.01M
      llf[0] = dc[0];
816
1.01M
      break;
817
2.69M
  };
818
2.69M
}
dec_group.cc:jxl::N_AVX2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Line
Count
Source
694
7.67M
                                              float* JXL_RESTRICT scratch) {
695
7.67M
  using Type = AcStrategyType;
696
7.67M
  HWY_ALIGN float warm_block[4 * 4];
697
7.67M
  HWY_ALIGN float warm_scratch_space[4 * 4 * 4];
698
7.67M
  switch (strategy) {
699
71.5k
    case Type::DCT16X8: {
700
71.5k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/kBlockDim,
701
71.5k
                        /*LF_ROWS=*/2, /*LF_COLS=*/1, /*ROWS=*/2, /*COLS=*/1>(
702
71.5k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
703
71.5k
      break;
704
0
    }
705
3.92M
    case Type::DCT8X16: {
706
3.92M
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
707
3.92M
                        /*LF_ROWS=*/1, /*LF_COLS=*/2, /*ROWS=*/1, /*COLS=*/2>(
708
3.92M
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
709
3.92M
      break;
710
0
    }
711
8.66k
    case Type::DCT16X16: {
712
8.66k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
713
8.66k
                        /*LF_ROWS=*/2, /*LF_COLS=*/2, /*ROWS=*/2, /*COLS=*/2>(
714
8.66k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
715
8.66k
      break;
716
0
    }
717
5.24k
    case Type::DCT32X8: {
718
5.24k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/kBlockDim,
719
5.24k
                        /*LF_ROWS=*/4, /*LF_COLS=*/1, /*ROWS=*/4, /*COLS=*/1>(
720
5.24k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
721
5.24k
      break;
722
0
    }
723
3.26k
    case Type::DCT8X32: {
724
3.26k
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
725
3.26k
                        /*LF_ROWS=*/1, /*LF_COLS=*/4, /*ROWS=*/1, /*COLS=*/4>(
726
3.26k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
727
3.26k
      break;
728
0
    }
729
5.23k
    case Type::DCT32X16: {
730
5.23k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
731
5.23k
                        /*LF_ROWS=*/4, /*LF_COLS=*/2, /*ROWS=*/4, /*COLS=*/2>(
732
5.23k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
733
5.23k
      break;
734
0
    }
735
6.43k
    case Type::DCT16X32: {
736
6.43k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
737
6.43k
                        /*LF_ROWS=*/2, /*LF_COLS=*/4, /*ROWS=*/2, /*COLS=*/4>(
738
6.43k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
739
6.43k
      break;
740
0
    }
741
1.71k
    case Type::DCT32X32: {
742
1.71k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
743
1.71k
                        /*LF_ROWS=*/4, /*LF_COLS=*/4, /*ROWS=*/4, /*COLS=*/4>(
744
1.71k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
745
1.71k
      break;
746
0
    }
747
552
    case Type::DCT64X32: {
748
552
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
749
552
                        /*LF_ROWS=*/8, /*LF_COLS=*/4, /*ROWS=*/8, /*COLS=*/4>(
750
552
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 4);
751
552
      break;
752
0
    }
753
114
    case Type::DCT32X64: {
754
114
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
755
114
                        /*LF_ROWS=*/4, /*LF_COLS=*/8, /*ROWS=*/4, /*COLS=*/8>(
756
114
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 4 * 8);
757
114
      break;
758
0
    }
759
3.81k
    case Type::DCT64X64: {
760
3.81k
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
761
3.81k
                        /*LF_ROWS=*/8, /*LF_COLS=*/8, /*ROWS=*/8, /*COLS=*/8>(
762
3.81k
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 8);
763
3.81k
      break;
764
0
    }
765
321
    case Type::DCT128X64: {
766
321
      ReinterpretingDCT</*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
767
321
                        /*LF_ROWS=*/16, /*LF_COLS=*/8, /*ROWS=*/16, /*COLS=*/8>(
768
321
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 8);
769
321
      break;
770
0
    }
771
162
    case Type::DCT64X128: {
772
162
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
773
162
                        /*LF_ROWS=*/8, /*LF_COLS=*/16, /*ROWS=*/8, /*COLS=*/16>(
774
162
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 8 * 16);
775
162
      break;
776
0
    }
777
3.07k
    case Type::DCT128X128: {
778
3.07k
      ReinterpretingDCT<
779
3.07k
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
780
3.07k
          /*LF_ROWS=*/16, /*LF_COLS=*/16, /*ROWS=*/16, /*COLS=*/16>(
781
3.07k
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 16);
782
3.07k
      break;
783
0
    }
784
21
    case Type::DCT256X128: {
785
21
      ReinterpretingDCT<
786
21
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
787
21
          /*LF_ROWS=*/32, /*LF_COLS=*/16, /*ROWS=*/32, /*COLS=*/16>(
788
21
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 16);
789
21
      break;
790
0
    }
791
27
    case Type::DCT128X256: {
792
27
      ReinterpretingDCT<
793
27
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
794
27
          /*LF_ROWS=*/16, /*LF_COLS=*/32, /*ROWS=*/16, /*COLS=*/32>(
795
27
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 16 * 32);
796
27
      break;
797
0
    }
798
30
    case Type::DCT256X256: {
799
30
      ReinterpretingDCT<
800
30
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
801
30
          /*LF_ROWS=*/32, /*LF_COLS=*/32, /*ROWS=*/32, /*COLS=*/32>(
802
30
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 32);
803
30
      break;
804
0
    }
805
1.46M
    case Type::DCT:
806
1.57M
    case Type::DCT2X2:
807
1.62M
    case Type::DCT4X4:
808
1.63M
    case Type::DCT4X8:
809
1.65M
    case Type::DCT8X4:
810
1.66M
    case Type::AFV0:
811
1.66M
    case Type::AFV1:
812
1.66M
    case Type::AFV2:
813
1.67M
    case Type::AFV3:
814
3.63M
    case Type::IDENTITY:
815
3.63M
      llf[0] = dc[0];
816
3.63M
      break;
817
7.67M
  };
818
7.67M
}
dec_group.cc:jxl::N_SSE2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Line
Count
Source
694
4.51M
                                              float* JXL_RESTRICT scratch) {
695
4.51M
  using Type = AcStrategyType;
696
4.51M
  HWY_ALIGN float warm_block[4 * 4];
697
4.51M
  HWY_ALIGN float warm_scratch_space[4 * 4 * 4];
698
4.51M
  switch (strategy) {
699
13.8k
    case Type::DCT16X8: {
700
13.8k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/kBlockDim,
701
13.8k
                        /*LF_ROWS=*/2, /*LF_COLS=*/1, /*ROWS=*/2, /*COLS=*/1>(
702
13.8k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
703
13.8k
      break;
704
0
    }
705
3.54M
    case Type::DCT8X16: {
706
3.54M
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
707
3.54M
                        /*LF_ROWS=*/1, /*LF_COLS=*/2, /*ROWS=*/1, /*COLS=*/2>(
708
3.54M
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
709
3.54M
      break;
710
0
    }
711
4.44k
    case Type::DCT16X16: {
712
4.44k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
713
4.44k
                        /*LF_ROWS=*/2, /*LF_COLS=*/2, /*ROWS=*/2, /*COLS=*/2>(
714
4.44k
          dc, dc_stride, llf, 2 * kBlockDim, warm_block, warm_scratch_space);
715
4.44k
      break;
716
0
    }
717
3.65k
    case Type::DCT32X8: {
718
3.65k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/kBlockDim,
719
3.65k
                        /*LF_ROWS=*/4, /*LF_COLS=*/1, /*ROWS=*/4, /*COLS=*/1>(
720
3.65k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
721
3.65k
      break;
722
0
    }
723
6.91k
    case Type::DCT8X32: {
724
6.91k
      ReinterpretingDCT</*DCT_ROWS=*/kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
725
6.91k
                        /*LF_ROWS=*/1, /*LF_COLS=*/4, /*ROWS=*/1, /*COLS=*/4>(
726
6.91k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
727
6.91k
      break;
728
0
    }
729
2.34k
    case Type::DCT32X16: {
730
2.34k
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/2 * kBlockDim,
731
2.34k
                        /*LF_ROWS=*/4, /*LF_COLS=*/2, /*ROWS=*/4, /*COLS=*/2>(
732
2.34k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
733
2.34k
      break;
734
0
    }
735
1.80k
    case Type::DCT16X32: {
736
1.80k
      ReinterpretingDCT</*DCT_ROWS=*/2 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
737
1.80k
                        /*LF_ROWS=*/2, /*LF_COLS=*/4, /*ROWS=*/2, /*COLS=*/4>(
738
1.80k
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
739
1.80k
      break;
740
0
    }
741
732
    case Type::DCT32X32: {
742
732
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
743
732
                        /*LF_ROWS=*/4, /*LF_COLS=*/4, /*ROWS=*/4, /*COLS=*/4>(
744
732
          dc, dc_stride, llf, 4 * kBlockDim, warm_block, warm_scratch_space);
745
732
      break;
746
0
    }
747
84
    case Type::DCT64X32: {
748
84
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/4 * kBlockDim,
749
84
                        /*LF_ROWS=*/8, /*LF_COLS=*/4, /*ROWS=*/8, /*COLS=*/4>(
750
84
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 4);
751
84
      break;
752
0
    }
753
57
    case Type::DCT32X64: {
754
57
      ReinterpretingDCT</*DCT_ROWS=*/4 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
755
57
                        /*LF_ROWS=*/4, /*LF_COLS=*/8, /*ROWS=*/4, /*COLS=*/8>(
756
57
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 4 * 8);
757
57
      break;
758
0
    }
759
1.05k
    case Type::DCT64X64: {
760
1.05k
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
761
1.05k
                        /*LF_ROWS=*/8, /*LF_COLS=*/8, /*ROWS=*/8, /*COLS=*/8>(
762
1.05k
          dc, dc_stride, llf, 8 * kBlockDim, scratch, scratch + 8 * 8);
763
1.05k
      break;
764
0
    }
765
279
    case Type::DCT128X64: {
766
279
      ReinterpretingDCT</*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/8 * kBlockDim,
767
279
                        /*LF_ROWS=*/16, /*LF_COLS=*/8, /*ROWS=*/16, /*COLS=*/8>(
768
279
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 8);
769
279
      break;
770
0
    }
771
27
    case Type::DCT64X128: {
772
27
      ReinterpretingDCT</*DCT_ROWS=*/8 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
773
27
                        /*LF_ROWS=*/8, /*LF_COLS=*/16, /*ROWS=*/8, /*COLS=*/16>(
774
27
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 8 * 16);
775
27
      break;
776
0
    }
777
2.82k
    case Type::DCT128X128: {
778
2.82k
      ReinterpretingDCT<
779
2.82k
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
780
2.82k
          /*LF_ROWS=*/16, /*LF_COLS=*/16, /*ROWS=*/16, /*COLS=*/16>(
781
2.82k
          dc, dc_stride, llf, 16 * kBlockDim, scratch, scratch + 16 * 16);
782
2.82k
      break;
783
0
    }
784
3
    case Type::DCT256X128: {
785
3
      ReinterpretingDCT<
786
3
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/16 * kBlockDim,
787
3
          /*LF_ROWS=*/32, /*LF_COLS=*/16, /*ROWS=*/32, /*COLS=*/16>(
788
3
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 16);
789
3
      break;
790
0
    }
791
18
    case Type::DCT128X256: {
792
18
      ReinterpretingDCT<
793
18
          /*DCT_ROWS=*/16 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
794
18
          /*LF_ROWS=*/16, /*LF_COLS=*/32, /*ROWS=*/16, /*COLS=*/32>(
795
18
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 16 * 32);
796
18
      break;
797
0
    }
798
12
    case Type::DCT256X256: {
799
12
      ReinterpretingDCT<
800
12
          /*DCT_ROWS=*/32 * kBlockDim, /*DCT_COLS=*/32 * kBlockDim,
801
12
          /*LF_ROWS=*/32, /*LF_COLS=*/32, /*ROWS=*/32, /*COLS=*/32>(
802
12
          dc, dc_stride, llf, 32 * kBlockDim, scratch, scratch + 32 * 32);
803
12
      break;
804
0
    }
805
813k
    case Type::DCT:
806
849k
    case Type::DCT2X2:
807
865k
    case Type::DCT4X4:
808
889k
    case Type::DCT4X8:
809
893k
    case Type::DCT8X4:
810
898k
    case Type::AFV0:
811
899k
    case Type::AFV1:
812
900k
    case Type::AFV2:
813
900k
    case Type::AFV3:
814
933k
    case Type::IDENTITY:
815
933k
      llf[0] = dc[0];
816
933k
      break;
817
4.51M
  };
818
4.51M
}
Unexecuted instantiation: enc_group.cc:jxl::N_SSE4::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:jxl::N_AVX2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_group.cc:jxl::N_SSE2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_SSE4::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_AVX2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_ac_strategy.cc:jxl::N_SSE2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_SSE4::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_AVX2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
Unexecuted instantiation: enc_chroma_from_luma.cc:jxl::N_SSE2::(anonymous namespace)::LowestFrequenciesFromDC(jxl::AcStrategyType, float const*, unsigned long, float*, float*)
819
820
}  // namespace
821
// NOLINTNEXTLINE(google-readability-namespace-comments)
822
}  // namespace HWY_NAMESPACE
823
}  // namespace jxl
824
HWY_AFTER_NAMESPACE();
825
826
#endif  // LIB_JXL_DEC_TRANSFORMS_INL_H_