Debian Codegraph @

lib/jxl/modular/transform/palette.h

raw
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 #ifndef LIB_JXL_MODULAR_TRANSFORM_PALETTE_H_
7 #define LIB_JXL_MODULAR_TRANSFORM_PALETTE_H_
8
9 #include <algorithm>
10 #include <array>
11 #include <cstddef>
12 #include <cstdint>
13
14 #include "lib/jxl/base/compiler_specific.h"
15 #include "lib/jxl/base/data_parallel.h"
16 #include "lib/jxl/base/status.h"
17 #include "lib/jxl/modular/encoding/context_predict.h"
18 #include "lib/jxl/modular/modular_image.h"
19 #include "lib/jxl/modular/options.h"
20
21 namespace jxl {
22
23 namespace palette_internal {
24
25 static constexpr int kMaxPaletteLookupTableSize = 1 << 16;
26
27 static constexpr int kRgbChannels = 3;
28
29 // 5x5x5 color cube for the larger cube.
30 static constexpr int kLargeCube = 5;
31
32 // Smaller interleaved color cube to fill the holes of the larger cube.
33 static constexpr int kSmallCube = 4;
34 static constexpr int kSmallCubeBits = 2;
35 // kSmallCube ** 3
36 static constexpr int kLargeCubeOffset = kSmallCube * kSmallCube * kSmallCube;
37 static constexpr int kImplicitPaletteSize =
38 kLargeCubeOffset + kLargeCube * kLargeCube * kLargeCube;
39
40 template <int denom>
41 static inline pixel_type Scale(uint64_t value, uint64_t bit_depth) {
42 // return (value * ((static_cast<pixel_type_w>(1) << bit_depth) - 1)) / denom;
43 // We only call this function with kSmallCube or kLargeCube - 1 as denom,
44 // allowing us to avoid a division here.
45 static_assert(denom == 4);
46 return (value * ((static_cast<uint64_t>(1) << bit_depth) - 1)) >> 2;
47 }
48
49 // The purpose of this function is solely to extend the interpretation of
50 // palette indices to implicit values. If index < nb_deltas, indicating that the
51 // result is a delta palette entry, it is the responsibility of the caller to
52 // treat it as such.
53 static JXL_MAYBE_UNUSED pixel_type
54 GetPaletteValue(const pixel_type *const palette, int index, const size_t c,
55 const int palette_size, const int onerow, const int bit_depth) {
56 if (index < 0) {
57 static constexpr std::array<std::array<pixel_type, 3>, 72> kDeltaPalette = {
58 {
59 {{0, 0, 0}}, {{4, 4, 4}}, {{11, 0, 0}},
60 {{0, 0, -13}}, {{0, -12, 0}}, {{-10, -10, -10}},
61 {{-18, -18, -18}}, {{-27, -27, -27}}, {{-18, -18, 0}},
62 {{0, 0, -32}}, {{-32, 0, 0}}, {{-37, -37, -37}},
63 {{0, -32, -32}}, {{24, 24, 45}}, {{50, 50, 50}},
64 {{-45, -24, -24}}, {{-24, -45, -45}}, {{0, -24, -24}},
65 {{-34, -34, 0}}, {{-24, 0, -24}}, {{-45, -45, -24}},
66 {{64, 64, 64}}, {{-32, 0, -32}}, {{0, -32, 0}},
67 {{-32, 0, 32}}, {{-24, -45, -24}}, {{45, 24, 45}},
68 {{24, -24, -45}}, {{-45, -24, 24}}, {{80, 80, 80}},
69 {{64, 0, 0}}, {{0, 0, -64}}, {{0, -64, -64}},
70 {{-24, -24, 45}}, {{96, 96, 96}}, {{64, 64, 0}},
71 {{45, -24, -24}}, {{34, -34, 0}}, {{112, 112, 112}},
72 {{24, -45, -45}}, {{45, 45, -24}}, {{0, -32, 32}},
73 {{24, -24, 45}}, {{0, 96, 96}}, {{45, -24, 24}},
74 {{24, -45, -24}}, {{-24, -45, 24}}, {{0, -64, 0}},
75 {{96, 0, 0}}, {{128, 128, 128}}, {{64, 0, 64}},
76 {{144, 144, 144}}, {{96, 96, 0}}, {{-36, -36, 36}},
77 {{45, -24, -45}}, {{45, -45, -24}}, {{0, 0, -96}},
78 {{0, 128, 128}}, {{0, 96, 0}}, {{45, 24, -45}},
79 {{-128, 0, 0}}, {{24, -45, 24}}, {{-45, 24, -45}},
80 {{64, 0, -64}}, {{64, -64, -64}}, {{96, 0, 96}},
81 {{45, -45, 24}}, {{24, 45, -45}}, {{64, 64, -64}},
82 {{128, 128, 0}}, {{0, 0, -128}}, {{-24, 45, -45}},
83 }};
84 if (c >= kRgbChannels) {
85 return 0;
86 }
87 // Do not open the brackets, otherwise INT32_MIN negation could overflow.
88 index = -(index + 1);
89 index %= 1 + 2 * (kDeltaPalette.size() - 1);
90 static constexpr int kMultiplier[] = {-1, 1};
91 pixel_type result =
92 kDeltaPalette[((index + 1) >> 1)][c] * kMultiplier[index & 1];
93 if (bit_depth > 8) {
94 result *= static_cast<pixel_type>(1) << (bit_depth - 8);
95 }
96 return result;
97 } else if (palette_size <= index && index < palette_size + kLargeCubeOffset) {
98 if (c >= kRgbChannels) return 0;
99 index -= palette_size;
100 index >>= c * kSmallCubeBits;
101 return Scale<kSmallCube>(index % kSmallCube, bit_depth) +
102 (1 << (std::max(0, bit_depth - 3)));
103 } else if (palette_size + kLargeCubeOffset <= index) {
104 if (c >= kRgbChannels) return 0;
105 index -= palette_size + kLargeCubeOffset;
106 // TODO(eustas): should we take care of ambiguity created by
107 // index >= kLargeCube ** 3 ?
108 switch (c) {
109 case 0:
110 default:
111 break;
112 case 1:
113 index /= kLargeCube;
114 break;
115 case 2:
116 index /= kLargeCube * kLargeCube;
117 break;
118 }
119 return Scale<kLargeCube - 1>(index % kLargeCube, bit_depth);
120 }
121 return palette[c * onerow + static_cast<size_t>(index)];
122 }
123
124 } // namespace palette_internal
125
126 Status InvPalette(Image &input, uint32_t begin_c, uint32_t nb_colors,
127 uint32_t nb_deltas, Predictor predictor,
128 const weighted::Header &wp_header, ThreadPool *pool);
129
130 Status MetaPalette(Image &input, uint32_t begin_c, uint32_t end_c,
131 uint32_t nb_colors, uint32_t nb_deltas, bool lossy);
132
133 } // namespace jxl
134
135 #endif // LIB_JXL_MODULAR_TRANSFORM_PALETTE_H_