Debian Codegraph @

lib/jxl/render_pipeline/render_pipeline_test.cc

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 #include "lib/jxl/render_pipeline/render_pipeline.h"
7
8 #include <jxl/cms.h>
9
10 #include <algorithm>
11 #include <cctype>
12 #include <cstdint>
13 #include <cstdio>
14 #include <ostream>
15 #include <sstream>
16 #include <string>
17 #include <utility>
18 #include <vector>
19
20 #include "jxl/memory_manager.h"
21 #include "lib/extras/codec.h"
22 #include "lib/jxl/base/common.h"
23 #include "lib/jxl/base/compiler_specific.h"
24 #include "lib/jxl/base/override.h"
25 #include "lib/jxl/base/span.h"
26 #include "lib/jxl/base/status.h"
27 #include "lib/jxl/chroma_from_luma.h"
28 #include "lib/jxl/color_encoding_internal.h"
29 #include "lib/jxl/common.h" // JXL_HIGH_PRECISION, JPEGXL_ENABLE_TRANSCODE_JPEG
30 #include "lib/jxl/dec_bit_reader.h"
31 #include "lib/jxl/dec_cache.h"
32 #include "lib/jxl/dec_frame.h"
33 #include "lib/jxl/enc_params.h"
34 #include "lib/jxl/fake_parallel_runner_testonly.h"
35 #include "lib/jxl/fields.h"
36 #include "lib/jxl/frame_dimensions.h"
37 #include "lib/jxl/frame_header.h"
38 #include "lib/jxl/headers.h"
39 #include "lib/jxl/image.h"
40 #include "lib/jxl/image_metadata.h"
41 #include "lib/jxl/image_ops.h"
42 #include "lib/jxl/image_test_utils.h"
43 #include "lib/jxl/jpeg/enc_jpeg_data.h"
44 #include "lib/jxl/render_pipeline/test_render_pipeline_stages.h"
45 #include "lib/jxl/splines.h"
46 #include "lib/jxl/test_memory_manager.h"
47 #include "lib/jxl/test_utils.h"
48 #include "lib/jxl/testing.h"
49
50 namespace jxl {
51 namespace {
52
53 Status DecodeFile(const Span<const uint8_t> file, bool use_slow_pipeline,
54 CodecInOut* io, ThreadPool* pool) {
55 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
56 Status ret = true;
57 {
58 BitReader reader(file);
59 BitReaderScopedCloser reader_closer(reader, ret);
60 JXL_RETURN_IF_ERROR(reader.ReadFixedBits<16>() == 0x0AFF);
61 JXL_RETURN_IF_ERROR(ReadSizeHeader(&reader, &io->metadata.size));
62 JXL_RETURN_IF_ERROR(ReadImageMetadata(&reader, &io->metadata.m));
63 io->metadata.transform_data.nonserialized_xyb_encoded =
64 io->metadata.m.xyb_encoded;
65 JXL_RETURN_IF_ERROR(Bundle::Read(&reader, &io->metadata.transform_data));
66 if (io->metadata.m.color_encoding.WantICC()) {
67 std::vector<uint8_t> icc;
68 JXL_RETURN_IF_ERROR(test::ReadICC(&reader, &icc));
69 JXL_RETURN_IF_ERROR(io->metadata.m.color_encoding.SetICC(
70 std::move(icc), JxlGetDefaultCms()));
71 }
72 PassesDecoderState dec_state(memory_manager);
73 JXL_RETURN_IF_ERROR(
74 dec_state.output_encoding_info.SetFromMetadata(io->metadata));
75 JXL_RETURN_IF_ERROR(reader.JumpToByteBoundary());
76 io->frames.clear();
77 FrameHeader frame_header(&io->metadata);
78 do {
79 io->frames.emplace_back(memory_manager, &io->metadata.m);
80 // Skip frames that are not displayed.
81 do {
82 size_t frame_start = reader.TotalBitsConsumed() / kBitsPerByte;
83 size_t size_left = file.size() - frame_start;
84 JXL_RETURN_IF_ERROR(DecodeFrame(&dec_state, pool,
85 file.data() + frame_start, size_left,
86 &frame_header, &io->frames.back(),
87 io->metadata, use_slow_pipeline));
88 reader.SkipBits(io->frames.back().decoded_bytes() * kBitsPerByte);
89 } while (frame_header.frame_type != FrameType::kRegularFrame &&
90 frame_header.frame_type != FrameType::kSkipProgressive);
91 } while (!frame_header.is_last);
92
93 if (io->frames.empty()) return JXL_FAILURE("Not enough data.");
94
95 if (reader.TotalBitsConsumed() != file.size() * kBitsPerByte) {
96 return JXL_FAILURE("Reader position not at EOF.");
97 }
98 if (!reader.AllReadsWithinBounds()) {
99 return JXL_FAILURE("Reader out of bounds read.");
100 }
101 JXL_RETURN_IF_ERROR(io->CheckMetadata());
102 // reader is closed here.
103 }
104 return ret;
105 }
106
107 TEST(RenderPipelineTest, Build) {
108 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
109 RenderPipeline::Builder builder(memory_manager, /*num_c=*/1);
110 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleXSlowStage>()));
111 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleYSlowStage>()));
112 ASSERT_TRUE(builder.AddStage(jxl::make_unique<Check0FinalStage>()));
113 builder.UseSimpleImplementation();
114 FrameDimensions frame_dimensions;
115 frame_dimensions.Set(/*xsize=*/1024, /*ysize=*/1024, /*group_size_shift=*/0,
116 /*max_hshift=*/0, /*max_vshift=*/0,
117 /*modular_mode=*/false, /*upsampling=*/1);
118 JXL_TEST_ASSIGN_OR_DIE(auto pipeline,
119 std::move(builder).Finalize(frame_dimensions));
120 (void)pipeline;
121 }
122
123 TEST(RenderPipelineTest, CallAllGroups) {
124 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
125 RenderPipeline::Builder builder(memory_manager, /*num_c=*/1);
126 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleXSlowStage>()));
127 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleYSlowStage>()));
128 ASSERT_TRUE(builder.AddStage(jxl::make_unique<Check0FinalStage>()));
129 builder.UseSimpleImplementation();
130 FrameDimensions frame_dimensions;
131 frame_dimensions.Set(/*xsize=*/1024, /*ysize=*/1024, /*group_size_shift=*/0,
132 /*max_hshift=*/0, /*max_vshift=*/0,
133 /*modular_mode=*/false, /*upsampling=*/1);
134 JXL_TEST_ASSIGN_OR_DIE(auto pipeline,
135 std::move(builder).Finalize(frame_dimensions));
136 ASSERT_TRUE(pipeline->PrepareForThreads(1, /*use_group_ids=*/false));
137
138 for (size_t i = 0; i < frame_dimensions.num_groups; i++) {
139 auto input_buffers = pipeline->GetInputBuffers(i, 0);
140 const auto& buffer = input_buffers.GetBuffer(0);
141 FillPlane(0.0f, buffer.first, buffer.second);
142 ASSERT_TRUE(input_buffers.Done());
143 }
144
145 EXPECT_EQ(pipeline->PassesWithAllInput(), 1);
146 }
147
148 TEST(RenderPipelineTest, BuildFast) {
149 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
150 RenderPipeline::Builder builder(memory_manager, /*num_c=*/1);
151 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleXSlowStage>()));
152 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleYSlowStage>()));
153 ASSERT_TRUE(builder.AddStage(jxl::make_unique<Check0FinalStage>()));
154 FrameDimensions frame_dimensions;
155 frame_dimensions.Set(/*xsize=*/1024, /*ysize=*/1024, /*group_size_shift=*/0,
156 /*max_hshift=*/0, /*max_vshift=*/0,
157 /*modular_mode=*/false, /*upsampling=*/1);
158 JXL_TEST_ASSIGN_OR_DIE(auto pipeline,
159 std::move(builder).Finalize(frame_dimensions));
160 (void)pipeline;
161 }
162
163 TEST(RenderPipelineTest, CallAllGroupsFast) {
164 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
165 RenderPipeline::Builder builder(memory_manager, /*num_c=*/1);
166 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleXSlowStage>()));
167 ASSERT_TRUE(builder.AddStage(jxl::make_unique<UpsampleYSlowStage>()));
168 ASSERT_TRUE(builder.AddStage(jxl::make_unique<Check0FinalStage>()));
169 builder.UseSimpleImplementation();
170 FrameDimensions frame_dimensions;
171 frame_dimensions.Set(/*xsize=*/1024, /*ysize=*/1024, /*group_size_shift=*/0,
172 /*max_hshift=*/0, /*max_vshift=*/0,
173 /*modular_mode=*/false, /*upsampling=*/1);
174 JXL_TEST_ASSIGN_OR_DIE(auto pipeline,
175 std::move(builder).Finalize(frame_dimensions));
176 ASSERT_TRUE(pipeline->PrepareForThreads(1, /*use_group_ids=*/false));
177
178 for (size_t i = 0; i < frame_dimensions.num_groups; i++) {
179 auto input_buffers = pipeline->GetInputBuffers(i, 0);
180 const auto& buffer = input_buffers.GetBuffer(0);
181 FillPlane(0.0f, buffer.first, buffer.second);
182 ASSERT_TRUE(input_buffers.Done());
183 }
184
185 EXPECT_EQ(pipeline->PassesWithAllInput(), 1);
186 }
187
188 struct RenderPipelineTestInputSettings {
189 // Input image.
190 std::string input_path;
191 size_t xsize, ysize;
192 bool jpeg_transcode = false;
193 // Encoding settings.
194 CompressParams cparams;
195 // Short name for the encoder settings.
196 std::string cparams_descr;
197
198 bool add_spot_color = false;
199
200 Splines splines;
201 };
202
203 class RenderPipelineTestParam
204 : public ::testing::TestWithParam<RenderPipelineTestInputSettings> {};
205
206 TEST_P(RenderPipelineTestParam, PipelineTest) {
207 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
208 RenderPipelineTestInputSettings config = GetParam();
209
210 // Use a parallel runner that randomly shuffles tasks to detect possible
211 // border handling bugs.
212 FakeParallelRunner fake_pool(/*order_seed=*/123, /*num_threads=*/8);
213 ThreadPool pool(&JxlFakeParallelRunner, &fake_pool);
214 const std::vector<uint8_t> orig = jxl::test::ReadTestData(config.input_path);
215
216 CodecInOut io{memory_manager};
217 if (config.jpeg_transcode) {
218 ASSERT_TRUE(jpeg::DecodeImageJPG(Bytes(orig), &io));
219 } else {
220 ASSERT_TRUE(SetFromBytes(Bytes(orig), &io, &pool));
221 }
222 ASSERT_TRUE(io.ShrinkTo(config.xsize, config.ysize));
223
224 if (config.add_spot_color) {
225 JXL_TEST_ASSIGN_OR_DIE(
226 ImageF spot,
227 ImageF::Create(memory_manager, config.xsize, config.ysize));
228 jxl::ZeroFillImage(&spot);
229
230 for (size_t y = 0; y < config.ysize; y++) {
231 float* JXL_RESTRICT row = spot.Row(y);
232 for (size_t x = 0; x < config.xsize; x++) {
233 row[x] = ((x ^ y) & 255) * (1.f / 255.f);
234 }
235 }
236 ExtraChannelInfo info;
237 info.bit_depth.bits_per_sample = 8;
238 info.dim_shift = 0;
239 info.type = jxl::ExtraChannel::kSpotColor;
240 info.spot_color[0] = 0.5f;
241 info.spot_color[1] = 0.2f;
242 info.spot_color[2] = 1.f;
243 info.spot_color[3] = 0.5f;
244
245 io.metadata.m.extra_channel_info.push_back(info);
246 std::vector<ImageF> ec;
247 ec.push_back(std::move(spot));
248 ASSERT_TRUE(io.frames[0].SetExtraChannels(std::move(ec)));
249 }
250
251 std::vector<uint8_t> compressed;
252
253 config.cparams.custom_splines = config.splines;
254 ASSERT_TRUE(test::EncodeFile(config.cparams, &io, &compressed, &pool));
255
256 CodecInOut io_default{memory_manager};
257 ASSERT_TRUE(DecodeFile(Bytes(compressed),
258 /*use_slow_pipeline=*/false, &io_default, &pool));
259 CodecInOut io_slow_pipeline{memory_manager};
260 ASSERT_TRUE(DecodeFile(Bytes(compressed),
261 /*use_slow_pipeline=*/true, &io_slow_pipeline, &pool));
262
263 ASSERT_EQ(io_default.frames.size(), io_slow_pipeline.frames.size());
264 for (size_t i = 0; i < io_default.frames.size(); i++) {
265 #if JXL_HIGH_PRECISION
266 constexpr float kMaxError = 2e-4;
267 #else
268 constexpr float kMaxError = 5e-4;
269 #endif
270 Image3F def = std::move(*io_default.frames[i].color());
271 Image3F pip = std::move(*io_slow_pipeline.frames[i].color());
272 JXL_TEST_ASSERT_OK(VerifyRelativeError(pip, def, kMaxError, kMaxError, _));
273 for (size_t ec = 0; ec < io_default.frames[i].extra_channels().size();
274 ec++) {
275 JXL_TEST_ASSERT_OK(VerifyRelativeError(
276 io_slow_pipeline.frames[i].extra_channels()[ec],
277 io_default.frames[i].extra_channels()[ec], kMaxError, kMaxError, _));
278 }
279 }
280 }
281
282 StatusOr<Splines> CreateTestSplines() {
283 const ColorCorrelation color_correlation{};
284 std::vector<Spline::Point> control_points{{9, 54}, {118, 159}, {97, 3},
285 {10, 40}, {150, 25}, {120, 300}};
286 const Spline spline{control_points,
287 /*color_dct=*/
288 {Dct32{0.03125f, 0.00625f, 0.003125f},
289 Dct32{1.f, 0.321875f}, Dct32{1.f, 0.24375f}},
290 /*sigma_dct=*/{0.3125f, 0.f, 0.f, 0.0625f}};
291 std::vector<Spline> spline_data = {spline};
292 std::vector<QuantizedSpline> quantized_splines;
293 std::vector<Spline::Point> starting_points;
294 for (const Spline& spline : spline_data) {
295 JXL_ASSIGN_OR_RETURN(
296 QuantizedSpline qspline,
297 QuantizedSpline::Create(spline, /*quantization_adjustment=*/0,
298 color_correlation.YtoXRatio(0),
299 color_correlation.YtoBRatio(0)));
300 quantized_splines.emplace_back(std::move(qspline));
301 starting_points.push_back(spline.control_points.front());
302 }
303 return Splines(/*quantization_adjustment=*/0, std::move(quantized_splines),
304 std::move(starting_points));
305 }
306
307 std::vector<RenderPipelineTestInputSettings> GeneratePipelineTests() {
308 std::vector<RenderPipelineTestInputSettings> all_tests;
309
310 std::pair<size_t, size_t> sizes[] = {
311 {3, 8}, {128, 128}, {256, 256}, {258, 258}, {533, 401}, {777, 777},
312 };
313
314 for (auto size : sizes) {
315 RenderPipelineTestInputSettings settings;
316 settings.input_path = "jxl/flower/flower.png";
317 settings.xsize = size.first;
318 settings.ysize = size.second;
319
320 // Base settings.
321 settings.cparams.butteraugli_distance = 1.0;
322 settings.cparams.patches = Override::kOff;
323 settings.cparams.dots = Override::kOff;
324 settings.cparams.gaborish = Override::kOff;
325 settings.cparams.epf = 0;
326 settings.cparams.color_transform = ColorTransform::kXYB;
327
328 {
329 auto s = settings;
330 s.cparams_descr = "NoGabNoEpfNoPatches";
331 all_tests.push_back(s);
332 }
333
334 {
335 auto s = settings;
336 s.cparams.color_transform = ColorTransform::kNone;
337 s.cparams_descr = "NoGabNoEpfNoPatchesNoXYB";
338 all_tests.push_back(s);
339 }
340
341 {
342 auto s = settings;
343 s.cparams.gaborish = Override::kOn;
344 s.cparams_descr = "GabNoEpfNoPatches";
345 all_tests.push_back(s);
346 }
347
348 {
349 auto s = settings;
350 s.cparams.epf = 1;
351 s.cparams_descr = "NoGabEpf1NoPatches";
352 all_tests.push_back(s);
353 }
354
355 {
356 auto s = settings;
357 s.cparams.epf = 2;
358 s.cparams_descr = "NoGabEpf2NoPatches";
359 all_tests.push_back(s);
360 }
361
362 {
363 auto s = settings;
364 s.cparams.epf = 3;
365 s.cparams_descr = "NoGabEpf3NoPatches";
366 all_tests.push_back(s);
367 }
368
369 {
370 auto s = settings;
371 s.cparams.gaborish = Override::kOn;
372 s.cparams.epf = 3;
373 s.cparams_descr = "GabEpf3NoPatches";
374 all_tests.push_back(s);
375 }
376
377 {
378 auto s = settings;
379 s.cparams_descr = "Splines";
380 JXL_TEST_ASSIGN_OR_DIE(s.splines, CreateTestSplines());
381 all_tests.push_back(s);
382 }
383
384 for (size_t ups : {2, 4, 8}) {
385 {
386 auto s = settings;
387 s.cparams.resampling = ups;
388 s.cparams_descr = "Ups" + std::to_string(ups);
389 all_tests.push_back(s);
390 }
391 {
392 auto s = settings;
393 s.cparams.resampling = ups;
394 s.cparams.epf = 1;
395 s.cparams_descr = "Ups" + std::to_string(ups) + "EPF1";
396 all_tests.push_back(s);
397 }
398 {
399 auto s = settings;
400 s.cparams.resampling = ups;
401 s.cparams.gaborish = Override::kOn;
402 s.cparams.epf = 1;
403 s.cparams_descr = "Ups" + std::to_string(ups) + "GabEPF1";
404 all_tests.push_back(s);
405 }
406 }
407
408 {
409 auto s = settings;
410 s.cparams_descr = "Noise";
411 s.cparams.photon_noise_iso = 3200;
412 all_tests.push_back(s);
413 }
414
415 {
416 auto s = settings;
417 s.cparams_descr = "NoiseUps";
418 s.cparams.photon_noise_iso = 3200;
419 s.cparams.resampling = 2;
420 all_tests.push_back(s);
421 }
422
423 {
424 auto s = settings;
425 s.cparams_descr = "ModularLossless";
426 s.cparams.modular_mode = true;
427 s.cparams.butteraugli_distance = 0;
428 all_tests.push_back(s);
429 }
430
431 {
432 auto s = settings;
433 s.cparams_descr = "ProgressiveDC";
434 s.cparams.progressive_dc = 1;
435 all_tests.push_back(s);
436 }
437
438 {
439 auto s = settings;
440 s.cparams_descr = "ModularLossy";
441 s.cparams.modular_mode = true;
442 s.cparams.butteraugli_distance = 1.f;
443 all_tests.push_back(s);
444 }
445
446 {
447 auto s = settings;
448 s.input_path = "jxl/flower/flower_alpha.png";
449 s.cparams_descr = "AlphaVarDCT";
450 all_tests.push_back(s);
451 }
452
453 {
454 auto s = settings;
455 s.input_path = "jxl/flower/flower_alpha.png";
456 s.cparams_descr = "AlphaVarDCTUpsamplingEPF";
457 s.cparams.epf = 1;
458 s.cparams.ec_resampling = 2;
459 all_tests.push_back(s);
460 }
461
462 {
463 auto s = settings;
464 s.cparams.modular_mode = true;
465 s.cparams.butteraugli_distance = 0;
466 s.input_path = "jxl/flower/flower_alpha.png";
467 s.cparams_descr = "AlphaLossless";
468 all_tests.push_back(s);
469 }
470
471 {
472 auto s = settings;
473 s.input_path = "jxl/flower/flower_alpha.png";
474 s.cparams_descr = "AlphaDownsample";
475 s.cparams.ec_resampling = 2;
476 all_tests.push_back(s);
477 }
478
479 {
480 auto s = settings;
481 s.cparams_descr = "SpotColor";
482 s.add_spot_color = true;
483 all_tests.push_back(s);
484 }
485 }
486
487 #if JPEGXL_ENABLE_TRANSCODE_JPEG
488 for (const char* input : {"jxl/flower/flower.png.im_q85_444.jpg",
489 "jxl/flower/flower.png.im_q85_420.jpg",
490 "jxl/flower/flower.png.im_q85_422.jpg",
491 "jxl/flower/flower.png.im_q85_440.jpg"}) {
492 RenderPipelineTestInputSettings settings;
493 settings.input_path = input;
494 settings.jpeg_transcode = true;
495 settings.xsize = 2268;
496 settings.ysize = 1512;
497 settings.cparams_descr = "Default";
498 all_tests.push_back(settings);
499 }
500
501 #endif
502
503 {
504 RenderPipelineTestInputSettings settings;
505 settings.input_path = "jxl/grayscale_patches.png";
506 settings.xsize = 1011;
507 settings.ysize = 277;
508 settings.cparams_descr = "Patches";
509 all_tests.push_back(settings);
510 }
511
512 {
513 RenderPipelineTestInputSettings settings;
514 settings.input_path = "jxl/grayscale_patches.png";
515 settings.xsize = 1011;
516 settings.ysize = 277;
517 settings.cparams.photon_noise_iso = 1000;
518 settings.cparams_descr = "PatchesAndNoise";
519 all_tests.push_back(settings);
520 }
521
522 {
523 RenderPipelineTestInputSettings settings;
524 settings.input_path = "jxl/grayscale_patches.png";
525 settings.xsize = 1011;
526 settings.ysize = 277;
527 settings.cparams.resampling = 2;
528 settings.cparams_descr = "PatchesAndUps2";
529 all_tests.push_back(settings);
530 }
531
532 return all_tests;
533 }
534
535 std::ostream& operator<<(std::ostream& os,
536 const RenderPipelineTestInputSettings& c) {
537 std::string filename;
538 size_t pos = c.input_path.find_last_of('/');
539 if (pos == std::string::npos) {
540 filename = c.input_path;
541 } else {
542 filename = c.input_path.substr(pos + 1);
543 }
544 std::replace_if(
545 filename.begin(), filename.end(), [](char c) { return isalnum(c) == 0; },
546 '_');
547 os << filename << "_" << (c.jpeg_transcode ? "JPEG_" : "") << c.xsize << "x"
548 << c.ysize << "_" << c.cparams_descr;
549 return os;
550 }
551
552 std::string PipelineTestDescription(
553 const testing::TestParamInfo<RenderPipelineTestParam::ParamType>& info) {
554 std::stringstream name;
555 name << info.param;
556 return name.str();
557 }
558
559 JXL_GTEST_INSTANTIATE_TEST_SUITE_P(RenderPipelineTest, RenderPipelineTestParam,
560 testing::ValuesIn(GeneratePipelineTests()),
561 PipelineTestDescription);
562
563 TEST(RenderPipelineDecodingTest, Animation) {
564 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
565 FakeParallelRunner fake_pool(/*order_seed=*/123, /*num_threads=*/8);
566 ThreadPool pool(&JxlFakeParallelRunner, &fake_pool);
567
568 std::vector<uint8_t> compressed =
569 jxl::test::ReadTestData("jxl/blending/cropped_traffic_light.jxl");
570
571 CodecInOut io_default{memory_manager};
572 ASSERT_TRUE(DecodeFile(Bytes(compressed),
573 /*use_slow_pipeline=*/false, &io_default, &pool));
574 CodecInOut io_slow_pipeline{memory_manager};
575 ASSERT_TRUE(DecodeFile(Bytes(compressed),
576 /*use_slow_pipeline=*/true, &io_slow_pipeline, &pool));
577
578 ASSERT_EQ(io_default.frames.size(), io_slow_pipeline.frames.size());
579 for (size_t i = 0; i < io_default.frames.size(); i++) {
580 #if JXL_HIGH_PRECISION
581 constexpr float kMaxError = 1e-5;
582 #else
583 constexpr float kMaxError = 1e-4;
584 #endif
585
586 Image3F fast_pipeline = std::move(*io_default.frames[i].color());
587 Image3F slow_pipeline = std::move(*io_slow_pipeline.frames[i].color());
588 JXL_TEST_ASSERT_OK(VerifyRelativeError(slow_pipeline, fast_pipeline,
589 kMaxError, kMaxError, _))
590 for (size_t ec = 0; ec < io_default.frames[i].extra_channels().size();
591 ec++) {
592 JXL_TEST_ASSERT_OK(VerifyRelativeError(
593 io_slow_pipeline.frames[i].extra_channels()[ec],
594 io_default.frames[i].extra_channels()[ec], kMaxError, kMaxError, _));
595 }
596 }
597 }
598
599 } // namespace
600 } // namespace jxl