Debian Codegraph @

lib/jxl/modular/encoding/context_predict.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_ENCODING_CONTEXT_PREDICT_H_
7 #define LIB_JXL_MODULAR_ENCODING_CONTEXT_PREDICT_H_
8
9 #include <algorithm>
10 #include <array>
11 #include <cmath>
12 #include <cstddef>
13 #include <cstdint>
14 #include <vector>
15
16 #include "lib/jxl/base/bits.h"
17 #include "lib/jxl/base/compiler_specific.h"
18 #include "lib/jxl/base/status.h"
19 #include "lib/jxl/field_encodings.h"
20 #include "lib/jxl/fields.h"
21 #include "lib/jxl/image_ops.h"
22 #include "lib/jxl/modular/modular_image.h"
23 #include "lib/jxl/modular/options.h"
24
25 namespace jxl {
26
27 namespace weighted {
28 constexpr static size_t kNumPredictors = 4;
29 constexpr static int64_t kPredExtraBits = 3;
30 constexpr static int64_t kPredictionRound = ((1 << kPredExtraBits) >> 1) - 1;
31 constexpr static size_t kNumProperties = 1;
32
33 struct Header : public Fields {
34 JXL_FIELDS_NAME(WeightedPredictorHeader)
35 // TODO(janwas): move to cc file, avoid including fields.h.
36 Header() { Bundle::Init(this); }
37
38 Status VisitFields(Visitor *JXL_RESTRICT visitor) override {
39 if (visitor->AllDefault(*this, &all_default)) {
40 // Overwrite all serialized fields, but not any nonserialized_*.
41 visitor->SetDefault(this);
42 return true;
43 }
44 auto visit_p = [visitor](pixel_type val, pixel_type *p) {
45 uint32_t up = *p;
46 JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(5, val, &up));
47 *p = up;
48 return Status(true);
49 };
50 JXL_QUIET_RETURN_IF_ERROR(visit_p(16, &p1C));
51 JXL_QUIET_RETURN_IF_ERROR(visit_p(10, &p2C));
52 JXL_QUIET_RETURN_IF_ERROR(visit_p(7, &p3Ca));
53 JXL_QUIET_RETURN_IF_ERROR(visit_p(7, &p3Cb));
54 JXL_QUIET_RETURN_IF_ERROR(visit_p(7, &p3Cc));
55 JXL_QUIET_RETURN_IF_ERROR(visit_p(0, &p3Cd));
56 JXL_QUIET_RETURN_IF_ERROR(visit_p(0, &p3Ce));
57 JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(4, 0xd, &w[0]));
58 JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(4, 0xc, &w[1]));
59 JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(4, 0xc, &w[2]));
60 JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(4, 0xc, &w[3]));
61 return true;
62 }
63
64 bool all_default;
65 pixel_type p1C = 0, p2C = 0, p3Ca = 0, p3Cb = 0, p3Cc = 0, p3Cd = 0, p3Ce = 0;
66 uint32_t w[kNumPredictors] = {};
67 };
68
69 struct State {
70 pixel_type_w prediction[kNumPredictors] = {};
71 pixel_type_w pred = 0; // *before* removing the added bits.
72 std::vector<uint32_t> pred_errors[kNumPredictors];
73 std::vector<int32_t> error;
74 const Header &header;
75
76 // Allows to approximate division by a number from 1 to 64.
77 // for (int i = 0; i < 64; i++) divlookup[i] = (1 << 24) / (i + 1);
78
79 const uint32_t divlookup[64] = {
80 16777216, 8388608, 5592405, 4194304, 3355443, 2796202, 2396745, 2097152,
81 1864135, 1677721, 1525201, 1398101, 1290555, 1198372, 1118481, 1048576,
82 986895, 932067, 883011, 838860, 798915, 762600, 729444, 699050,
83 671088, 645277, 621378, 599186, 578524, 559240, 541200, 524288,
84 508400, 493447, 479349, 466033, 453438, 441505, 430185, 419430,
85 409200, 399457, 390167, 381300, 372827, 364722, 356962, 349525,
86 342392, 335544, 328965, 322638, 316551, 310689, 305040, 299593,
87 294337, 289262, 284359, 279620, 275036, 270600, 266305, 262144};
88
89 constexpr static pixel_type_w AddBits(pixel_type_w x) {
90 return static_cast<uint64_t>(x) << kPredExtraBits;
91 }
92
93 State(const Header &header, size_t xsize, size_t ysize) : header(header) {
94 // Extra margin to avoid out-of-bounds writes.
95 // All have space for two rows of data.
96 for (auto &pred_error : pred_errors) {
97 pred_error.resize((xsize + 2) * 2);
98 }
99 error.resize((xsize + 2) * 2);
100 }
101
102 // Approximates 4+(maxweight<<24)/(x+1), avoiding division
103 JXL_INLINE uint32_t ErrorWeight(uint64_t x, uint32_t maxweight) const {
104 int shift = static_cast<int>(FloorLog2Nonzero(x + 1)) - 5;
105 if (shift < 0) shift = 0;
106 return 4 + ((maxweight * divlookup[x >> shift]) >> shift);
107 }
108
109 // Approximates the weighted average of the input values with the given
110 // weights, avoiding division. Weights must sum to at least 16.
111 JXL_INLINE pixel_type_w
112 WeightedAverage(const pixel_type_w *JXL_RESTRICT p,
113 std::array<uint32_t, kNumPredictors> w) const {
114 uint32_t weight_sum = 0;
115 for (size_t i = 0; i < kNumPredictors; i++) {
116 weight_sum += w[i];
117 }
118 JXL_DASSERT(weight_sum > 15);
119 uint32_t log_weight = FloorLog2Nonzero(weight_sum); // at least 4.
120 weight_sum = 0;
121 for (size_t i = 0; i < kNumPredictors; i++) {
122 w[i] >>= log_weight - 4;
123 weight_sum += w[i];
124 }
125 // for rounding.
126 pixel_type_w sum = (weight_sum >> 1) - 1;
127 for (size_t i = 0; i < kNumPredictors; i++) {
128 sum += p[i] * w[i];
129 }
130 return (sum * divlookup[weight_sum - 1]) >> 24;
131 }
132
133 template <bool compute_properties>
134 JXL_INLINE pixel_type_w Predict(size_t x, size_t y, size_t xsize,
135 pixel_type_w N, pixel_type_w W,
136 pixel_type_w NE, pixel_type_w NW,
137 pixel_type_w NN, Properties *properties,
138 size_t offset) {
139 size_t cur_row = y & 1 ? 0 : (xsize + 2);
140 size_t prev_row = y & 1 ? (xsize + 2) : 0;
141 size_t pos_N = prev_row + x;
142 size_t pos_NE = x < xsize - 1 ? pos_N + 1 : pos_N;
143 size_t pos_NW = x > 0 ? pos_N - 1 : pos_N;
144 std::array<uint32_t, kNumPredictors> weights;
145 for (size_t i = 0; i < kNumPredictors; i++) {
146 // pred_errors[pos_N] also contains the error of pixel W.
147 // pred_errors[pos_NW] also contains the error of pixel WW.
148 weights[i] = pred_errors[i][pos_N] + pred_errors[i][pos_NE] +
149 pred_errors[i][pos_NW];
150 weights[i] = ErrorWeight(weights[i], header.w[i]);
151 }
152
153 N = AddBits(N);
154 W = AddBits(W);
155 NE = AddBits(NE);
156 NW = AddBits(NW);
157 NN = AddBits(NN);
158
159 pixel_type_w teW = x == 0 ? 0 : error[cur_row + x - 1];
160 pixel_type_w teN = error[pos_N];
161 pixel_type_w teNW = error[pos_NW];
162 pixel_type_w sumWN = teN + teW;
163 pixel_type_w teNE = error[pos_NE];
164
165 if (compute_properties) {
166 pixel_type_w p = teW;
167 if (std::abs(teN) > std::abs(p)) p = teN;
168 if (std::abs(teNW) > std::abs(p)) p = teNW;
169 if (std::abs(teNE) > std::abs(p)) p = teNE;
170 (*properties)[offset++] = p;
171 }
172
173 prediction[0] = W + NE - N;
174 prediction[1] = N - (((sumWN + teNE) * header.p1C) >> 5);
175 prediction[2] = W - (((sumWN + teNW) * header.p2C) >> 5);
176 prediction[3] =
177 N - ((teNW * header.p3Ca + teN * header.p3Cb + teNE * header.p3Cc +
178 (NN - N) * header.p3Cd + (NW - W) * header.p3Ce) >>
179 5);
180
181 pred = WeightedAverage(prediction, weights);
182
183 // If all three have the same sign, skip clamping.
184 if (((teN ^ teW) | (teN ^ teNW)) > 0) {
185 return (pred + kPredictionRound) >> kPredExtraBits;
186 }
187
188 // Otherwise, clamp to min/max of neighbouring pixels (just W, NE, N).
189 pixel_type_w mx = std::max(W, std::max(NE, N));
190 pixel_type_w mn = std::min(W, std::min(NE, N));
191 pred = std::max(mn, std::min(mx, pred));
192 return (pred + kPredictionRound) >> kPredExtraBits;
193 }
194
195 JXL_INLINE void UpdateErrors(pixel_type_w val, size_t x, size_t y,
196 size_t xsize) {
197 size_t cur_row = y & 1 ? 0 : (xsize + 2);
198 size_t prev_row = y & 1 ? (xsize + 2) : 0;
199 val = AddBits(val);
200 error[cur_row + x] = pred - val;
201 for (size_t i = 0; i < kNumPredictors; i++) {
202 pixel_type_w err =
203 (std::abs(prediction[i] - val) + kPredictionRound) >> kPredExtraBits;
204 // For predicting in the next row.
205 pred_errors[i][cur_row + x] = err;
206 // Add the error on this pixel to the error on the NE pixel. This has the
207 // effect of adding the error on this pixel to the E and EE pixels.
208 pred_errors[i][prev_row + x + 1] += err;
209 }
210 }
211 };
212
213 // Encoder helper function to set the parameters to some presets.
214 inline void PredictorMode(int i, Header *header) {
215 switch (i) {
216 case 0:
217 // ~ lossless16 predictor
218 header->w[0] = 0xd;
219 header->w[1] = 0xc;
220 header->w[2] = 0xc;
221 header->w[3] = 0xc;
222 header->p1C = 16;
223 header->p2C = 10;
224 header->p3Ca = 7;
225 header->p3Cb = 7;
226 header->p3Cc = 7;
227 header->p3Cd = 0;
228 header->p3Ce = 0;
229 break;
230 case 1:
231 // ~ default lossless8 predictor
232 header->w[0] = 0xd;
233 header->w[1] = 0xc;
234 header->w[2] = 0xc;
235 header->w[3] = 0xb;
236 header->p1C = 8;
237 header->p2C = 8;
238 header->p3Ca = 4;
239 header->p3Cb = 0;
240 header->p3Cc = 3;
241 header->p3Cd = 23;
242 header->p3Ce = 2;
243 break;
244 case 2:
245 // ~ west lossless8 predictor
246 header->w[0] = 0xd;
247 header->w[1] = 0xc;
248 header->w[2] = 0xd;
249 header->w[3] = 0xc;
250 header->p1C = 10;
251 header->p2C = 9;
252 header->p3Ca = 7;
253 header->p3Cb = 0;
254 header->p3Cc = 0;
255 header->p3Cd = 16;
256 header->p3Ce = 9;
257 break;
258 case 3:
259 // ~ north lossless8 predictor
260 header->w[0] = 0xd;
261 header->w[1] = 0xd;
262 header->w[2] = 0xc;
263 header->w[3] = 0xc;
264 header->p1C = 16;
265 header->p2C = 8;
266 header->p3Ca = 0;
267 header->p3Cb = 16;
268 header->p3Cc = 0;
269 header->p3Cd = 23;
270 header->p3Ce = 0;
271 break;
272 case 4:
273 default:
274 // something else, because why not
275 header->w[0] = 0xd;
276 header->w[1] = 0xc;
277 header->w[2] = 0xc;
278 header->w[3] = 0xc;
279 header->p1C = 10;
280 header->p2C = 10;
281 header->p3Ca = 5;
282 header->p3Cb = 5;
283 header->p3Cc = 5;
284 header->p3Cd = 12;
285 header->p3Ce = 4;
286 break;
287 }
288 }
289 } // namespace weighted
290
291 // Stores a node and its two children at the same time. This significantly
292 // reduces the number of branches needed during decoding.
293 struct FlatDecisionNode {
294 // Property + splitval of the top node.
295 int32_t property0; // -1 if leaf.
296 union {
297 PropertyVal splitval0;
298 Predictor predictor;
299 };
300 // Property+splitval of the two child nodes.
301 union {
302 PropertyVal splitvals[2];
303 int32_t multiplier;
304 };
305 uint32_t childID; // childID is ctx id if leaf.
306 union {
307 int16_t properties[2];
308 int32_t predictor_offset;
309 };
310 };
311 using FlatTree = std::vector<FlatDecisionNode>;
312
313 class MATreeLookup {
314 public:
315 explicit MATreeLookup(const FlatTree &tree) : nodes_(tree) {}
316 struct LookupResult {
317 uint32_t context;
318 Predictor predictor;
319 int32_t offset;
320 int32_t multiplier;
321 };
322 JXL_INLINE LookupResult Lookup(const Properties &properties) const {
323 uint32_t pos = 0;
324 while (true) {
325 #define TRAVERSE_THE_TREE \
326 { \
327 const FlatDecisionNode &node = nodes_[pos]; \
328 if (node.property0 < 0) { \
329 return {node.childID, node.predictor, node.predictor_offset, \
330 node.multiplier}; \
331 } \
332 bool p0 = properties[node.property0] <= node.splitval0; \
333 uint32_t off0 = properties[node.properties[0]] <= node.splitvals[0]; \
334 uint32_t off1 = 2 | (properties[node.properties[1]] <= node.splitvals[1]); \
335 pos = node.childID + (p0 ? off1 : off0); \
336 }
337
338 TRAVERSE_THE_TREE;
339 TRAVERSE_THE_TREE;
340 }
341 }
342
343 private:
344 const FlatTree &nodes_;
345 };
346
347 static constexpr size_t kExtraPropsPerChannel = 4;
348 static constexpr size_t kNumNonrefProperties =
349 kNumStaticProperties + 13 + weighted::kNumProperties;
350
351 constexpr size_t kWPProp = kNumNonrefProperties - weighted::kNumProperties;
352 constexpr size_t kGradientProp = 9;
353
354 // Clamps gradient to the min/max of n, w (and l, implicitly).
355 static JXL_INLINE int32_t ClampedGradient(const int32_t n, const int32_t w,
356 const int32_t l) {
357 const int32_t m = std::min(n, w);
358 const int32_t M = std::max(n, w);
359 // The end result of this operation doesn't overflow or underflow if the
360 // result is between m and M, but the intermediate value may overflow, so we
361 // do the intermediate operations in uint32_t and check later if we had an
362 // overflow or underflow condition comparing m, M and l directly.
363 // grad = M + m - l = n + w - l
364 const int32_t grad =
365 static_cast<int32_t>(static_cast<uint32_t>(n) + static_cast<uint32_t>(w) -
366 static_cast<uint32_t>(l));
367 // We use two sets of ternary operators to force the evaluation of them in
368 // any case, allowing the compiler to avoid branches and use cmovl/cmovg in
369 // x86.
370 const int32_t grad_clamp_M = (l < m) ? M : grad;
371 return (l > M) ? m : grad_clamp_M;
372 }
373
374 inline pixel_type_w Select(pixel_type_w a, pixel_type_w b, pixel_type_w c) {
375 pixel_type_w p = a + b - c;
376 pixel_type_w pa = std::abs(p - a);
377 pixel_type_w pb = std::abs(p - b);
378 return pa < pb ? a : b;
379 }
380
381 inline void PrecomputeReferences(const Channel &ch, size_t y,
382 const Image &image, uint32_t i,
383 Channel *references) {
384 ZeroFillImage(&references->plane);
385 uint32_t offset = 0;
386 size_t num_extra_props = references->w;
387 intptr_t onerow = references->plane.PixelsPerRow();
388 for (int32_t j = static_cast<int32_t>(i) - 1;
389 j >= 0 && offset < num_extra_props; j--) {
390 if (image.channel[j].w != image.channel[i].w ||
391 image.channel[j].h != image.channel[i].h) {
392 continue;
393 }
394 if (image.channel[j].hshift != image.channel[i].hshift) continue;
395 if (image.channel[j].vshift != image.channel[i].vshift) continue;
396 pixel_type *JXL_RESTRICT rp = references->Row(0) + offset;
397 const pixel_type *JXL_RESTRICT rpp = image.channel[j].Row(y);
398 const pixel_type *JXL_RESTRICT rpprev = image.channel[j].Row(y ? y - 1 : 0);
399 for (size_t x = 0; x < ch.w; x++, rp += onerow) {
400 pixel_type_w v = rpp[x];
401 rp[0] = std::abs(v);
402 rp[1] = v;
403 pixel_type_w vleft = (x ? rpp[x - 1] : 0);
404 pixel_type_w vtop = (y ? rpprev[x] : vleft);
405 pixel_type_w vtopleft = (x && y ? rpprev[x - 1] : vleft);
406 pixel_type_w vpredicted = ClampedGradient(vleft, vtop, vtopleft);
407 rp[2] = std::abs(v - vpredicted);
408 rp[3] = v - vpredicted;
409 }
410
411 offset += kExtraPropsPerChannel;
412 }
413 }
414
415 struct PredictionResult {
416 int context = 0;
417 pixel_type_w guess = 0;
418 Predictor predictor;
419 int32_t multiplier;
420 };
421
422 inline void InitPropsRow(
423 Properties *p,
424 const std::array<pixel_type, kNumStaticProperties> &static_props,
425 const int y) {
426 for (size_t i = 0; i < kNumStaticProperties; i++) {
427 (*p)[i] = static_props[i];
428 }
429 (*p)[2] = y;
430 (*p)[9] = 0; // local gradient.
431 }
432
433 namespace detail {
434 enum PredictorMode {
435 kUseTree = 1,
436 kUseWP = 2,
437 kForceComputeProperties = 4,
438 kAllPredictions = 8,
439 kNoEdgeCases = 16
440 };
441
442 JXL_INLINE pixel_type_w PredictOne(Predictor p, pixel_type_w left,
443 pixel_type_w top, pixel_type_w toptop,
444 pixel_type_w topleft, pixel_type_w topright,
445 pixel_type_w leftleft,
446 pixel_type_w toprightright,
447 pixel_type_w wp_pred) {
448 switch (p) {
449 case Predictor::Zero:
450 return pixel_type_w{0};
451 case Predictor::Left:
452 return left;
453 case Predictor::Top:
454 return top;
455 case Predictor::Select:
456 return Select(left, top, topleft);
457 case Predictor::Weighted:
458 return wp_pred;
459 case Predictor::Gradient:
460 return pixel_type_w{ClampedGradient(left, top, topleft)};
461 case Predictor::TopLeft:
462 return topleft;
463 case Predictor::TopRight:
464 return topright;
465 case Predictor::LeftLeft:
466 return leftleft;
467 case Predictor::Average0:
468 return (left + top) / 2;
469 case Predictor::Average1:
470 return (left + topleft) / 2;
471 case Predictor::Average2:
472 return (topleft + top) / 2;
473 case Predictor::Average3:
474 return (top + topright) / 2;
475 case Predictor::Average4:
476 return (6 * top - 2 * toptop + 7 * left + 1 * leftleft +
477 1 * toprightright + 3 * topright + 8) /
478 16;
479 default:
480 return pixel_type_w{0};
481 }
482 }
483
484 template <int mode>
485 JXL_INLINE PredictionResult Predict(
486 Properties *p, size_t w, const pixel_type *JXL_RESTRICT pp,
487 const intptr_t onerow, const size_t x, const size_t y, Predictor predictor,
488 const MATreeLookup *lookup, const Channel *references,
489 weighted::State *wp_state, pixel_type_w *predictions) {
490 // We start in position 3 because of 2 static properties + y.
491 size_t offset = 3;
492 constexpr bool compute_properties =
493 mode & kUseTree || mode & kForceComputeProperties;
494 constexpr bool nec = mode & kNoEdgeCases;
495 pixel_type_w left = (nec || x ? pp[-1] : (y ? pp[-onerow] : 0));
496 pixel_type_w top = (nec || y ? pp[-onerow] : left);
497 pixel_type_w topleft = (nec || (x && y) ? pp[-1 - onerow] : left);
498 pixel_type_w topright = (nec || (x + 1 < w && y) ? pp[1 - onerow] : top);
499 pixel_type_w leftleft = (nec || x > 1 ? pp[-2] : left);
500 pixel_type_w toptop = (nec || y > 1 ? pp[-onerow - onerow] : top);
501 pixel_type_w toprightright =
502 (nec || (x + 2 < w && y) ? pp[2 - onerow] : topright);
503
504 if (compute_properties) {
505 // location
506 (*p)[offset++] = x;
507 // neighbors
508 (*p)[offset++] = top > 0 ? top : -top;
509 (*p)[offset++] = left > 0 ? left : -left;
510 (*p)[offset++] = top;
511 (*p)[offset++] = left;
512
513 // local gradient
514 (*p)[offset] = left - (*p)[offset + 1];
515 offset++;
516 // local gradient
517 (*p)[offset++] = left + top - topleft;
518
519 // FFV1 context properties
520 (*p)[offset++] = left - topleft;
521 (*p)[offset++] = topleft - top;
522 (*p)[offset++] = top - topright;
523 (*p)[offset++] = top - toptop;
524 (*p)[offset++] = left - leftleft;
525 }
526
527 pixel_type_w wp_pred = 0;
528 if (mode & kUseWP) {
529 wp_pred = wp_state->Predict<compute_properties>(
530 x, y, w, top, left, topright, topleft, toptop, p, offset);
531 }
532 if (!nec && compute_properties) {
533 offset += weighted::kNumProperties;
534 // Extra properties.
535 const pixel_type *JXL_RESTRICT rp = references->Row(x);
536 for (size_t i = 0; i < references->w; i++) {
537 (*p)[offset++] = rp[i];
538 }
539 }
540 PredictionResult result;
541 if (mode & kUseTree) {
542 MATreeLookup::LookupResult lr = lookup->Lookup(*p);
543 result.context = lr.context;
544 result.guess = lr.offset;
545 result.multiplier = lr.multiplier;
546 predictor = lr.predictor;
547 }
548 if (mode & kAllPredictions) {
549 for (size_t i = 0; i < kNumModularPredictors; i++) {
550 predictions[i] =
551 PredictOne(static_cast<Predictor>(i), left, top, toptop, topleft,
552 topright, leftleft, toprightright, wp_pred);
553 }
554 }
555 result.guess += PredictOne(predictor, left, top, toptop, topleft, topright,
556 leftleft, toprightright, wp_pred);
557 result.predictor = predictor;
558
559 return result;
560 }
561 } // namespace detail
562
563 inline PredictionResult PredictNoTreeNoWP(size_t w,
564 const pixel_type *JXL_RESTRICT pp,
565 const intptr_t onerow, const int x,
566 const int y, Predictor predictor) {
567 return detail::Predict</*mode=*/0>(
568 /*p=*/nullptr, w, pp, onerow, x, y, predictor, /*lookup=*/nullptr,
569 /*references=*/nullptr, /*wp_state=*/nullptr, /*predictions=*/nullptr);
570 }
571
572 inline PredictionResult PredictNoTreeWP(size_t w,
573 const pixel_type *JXL_RESTRICT pp,
574 const intptr_t onerow, const int x,
575 const int y, Predictor predictor,
576 weighted::State *wp_state) {
577 return detail::Predict<detail::kUseWP>(
578 /*p=*/nullptr, w, pp, onerow, x, y, predictor, /*lookup=*/nullptr,
579 /*references=*/nullptr, wp_state, /*predictions=*/nullptr);
580 }
581
582 inline PredictionResult PredictTreeNoWP(Properties *p, size_t w,
583 const pixel_type *JXL_RESTRICT pp,
584 const intptr_t onerow, const int x,
585 const int y,
586 const MATreeLookup &tree_lookup,
587 const Channel &references) {
588 return detail::Predict<detail::kUseTree>(
589 p, w, pp, onerow, x, y, Predictor::Zero, &tree_lookup, &references,
590 /*wp_state=*/nullptr, /*predictions=*/nullptr);
591 }
592 // Only use for y > 1, x > 1, x < w-2, and empty references
593 JXL_INLINE PredictionResult
594 PredictTreeNoWPNEC(Properties *p, size_t w, const pixel_type *JXL_RESTRICT pp,
595 const intptr_t onerow, const int x, const int y,
596 const MATreeLookup &tree_lookup, const Channel &references) {
597 return detail::Predict<detail::kUseTree | detail::kNoEdgeCases>(
598 p, w, pp, onerow, x, y, Predictor::Zero, &tree_lookup, &references,
599 /*wp_state=*/nullptr, /*predictions=*/nullptr);
600 }
601
602 inline PredictionResult PredictTreeWP(Properties *p, size_t w,
603 const pixel_type *JXL_RESTRICT pp,
604 const intptr_t onerow, const int x,
605 const int y,
606 const MATreeLookup &tree_lookup,
607 const Channel &references,
608 weighted::State *wp_state) {
609 return detail::Predict<detail::kUseTree | detail::kUseWP>(
610 p, w, pp, onerow, x, y, Predictor::Zero, &tree_lookup, &references,
611 wp_state, /*predictions=*/nullptr);
612 }
613 JXL_INLINE PredictionResult PredictTreeWPNEC(Properties *p, size_t w,
614 const pixel_type *JXL_RESTRICT pp,
615 const intptr_t onerow, const int x,
616 const int y,
617 const MATreeLookup &tree_lookup,
618 const Channel &references,
619 weighted::State *wp_state) {
620 return detail::Predict<detail::kUseTree | detail::kUseWP |
621 detail::kNoEdgeCases>(
622 p, w, pp, onerow, x, y, Predictor::Zero, &tree_lookup, &references,
623 wp_state, /*predictions=*/nullptr);
624 }
625
626 inline PredictionResult PredictLearn(Properties *p, size_t w,
627 const pixel_type *JXL_RESTRICT pp,
628 const intptr_t onerow, const int x,
629 const int y, Predictor predictor,
630 const Channel &references,
631 weighted::State *wp_state) {
632 return detail::Predict<detail::kForceComputeProperties | detail::kUseWP>(
633 p, w, pp, onerow, x, y, predictor, /*lookup=*/nullptr, &references,
634 wp_state, /*predictions=*/nullptr);
635 }
636
637 inline void PredictLearnAll(Properties *p, size_t w,
638 const pixel_type *JXL_RESTRICT pp,
639 const intptr_t onerow, const int x, const int y,
640 const Channel &references,
641 weighted::State *wp_state,
642 pixel_type_w *predictions) {
643 detail::Predict<detail::kForceComputeProperties | detail::kUseWP |
644 detail::kAllPredictions>(
645 p, w, pp, onerow, x, y, Predictor::Zero,
646 /*lookup=*/nullptr, &references, wp_state, predictions);
647 }
648 inline PredictionResult PredictLearnNEC(Properties *p, size_t w,
649 const pixel_type *JXL_RESTRICT pp,
650 const intptr_t onerow, const int x,
651 const int y, Predictor predictor,
652 const Channel &references,
653 weighted::State *wp_state) {
654 return detail::Predict<detail::kForceComputeProperties | detail::kUseWP |
655 detail::kNoEdgeCases>(
656 p, w, pp, onerow, x, y, predictor, /*lookup=*/nullptr, &references,
657 wp_state, /*predictions=*/nullptr);
658 }
659
660 inline void PredictLearnAllNEC(Properties *p, size_t w,
661 const pixel_type *JXL_RESTRICT pp,
662 const intptr_t onerow, const int x, const int y,
663 const Channel &references,
664 weighted::State *wp_state,
665 pixel_type_w *predictions) {
666 detail::Predict<detail::kForceComputeProperties | detail::kUseWP |
667 detail::kAllPredictions | detail::kNoEdgeCases>(
668 p, w, pp, onerow, x, y, Predictor::Zero,
669 /*lookup=*/nullptr, &references, wp_state, predictions);
670 }
671
672 inline void PredictAllNoWP(size_t w, const pixel_type *JXL_RESTRICT pp,
673 const intptr_t onerow, const int x, const int y,
674 pixel_type_w *predictions) {
675 detail::Predict<detail::kAllPredictions>(
676 /*p=*/nullptr, w, pp, onerow, x, y, Predictor::Zero,
677 /*lookup=*/nullptr,
678 /*references=*/nullptr, /*wp_state=*/nullptr, predictions);
679 }
680 } // namespace jxl
681
682 #endif // LIB_JXL_MODULAR_ENCODING_CONTEXT_PREDICT_H_