tor-browser

decode_test.cc (232012B)

---

// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "lib/extras/dec/decode.h"

#include <jxl/cms.h>
#include <jxl/codestream_header.h>
#include <jxl/color_encoding.h>
#include <jxl/decode.h>
#include <jxl/decode_cxx.h>
#include <jxl/memory_manager.h>
#include <jxl/parallel_runner.h>
#include <jxl/resizable_parallel_runner.h>
#include <jxl/resizable_parallel_runner_cxx.h>
#include <jxl/thread_parallel_runner.h>
#include <jxl/thread_parallel_runner_cxx.h>
#include <jxl/types.h>

#include <algorithm>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ostream>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include "lib/extras/dec/color_description.h"
#include "lib/extras/enc/encode.h"
#include "lib/extras/enc/jpg.h"
#include "lib/extras/packed_image.h"
#include "lib/jxl/base/byte_order.h"
#include "lib/jxl/base/common.h"
#include "lib/jxl/base/compiler_specific.h"
#include "lib/jxl/base/override.h"
#include "lib/jxl/base/span.h"
#include "lib/jxl/butteraugli/butteraugli.h"
#include "lib/jxl/cms/color_encoding_cms.h"
#include "lib/jxl/color_encoding_internal.h"
#include "lib/jxl/common.h"  // SpeedTier
#include "lib/jxl/dec_bit_reader.h"
#include "lib/jxl/dec_external_image.h"
#include "lib/jxl/enc_aux_out.h"
#include "lib/jxl/enc_external_image.h"
#include "lib/jxl/enc_fields.h"
#include "lib/jxl/enc_frame.h"
#include "lib/jxl/enc_icc_codec.h"
#include "lib/jxl/enc_params.h"
#include "lib/jxl/enc_progressive_split.h"
#include "lib/jxl/encode_internal.h"
#include "lib/jxl/fields.h"
#include "lib/jxl/frame_dimensions.h"
#include "lib/jxl/frame_header.h"
#include "lib/jxl/headers.h"
#include "lib/jxl/image.h"
#include "lib/jxl/image_bundle.h"
#include "lib/jxl/image_metadata.h"
#include "lib/jxl/image_ops.h"
#include "lib/jxl/jpeg/enc_jpeg_data.h"
#include "lib/jxl/jpeg/jpeg_data.h"
#include "lib/jxl/padded_bytes.h"
#include "lib/jxl/test_image.h"
#include "lib/jxl/test_memory_manager.h"
#include "lib/jxl/test_utils.h"
#include "lib/jxl/testing.h"
#include "lib/jxl/toc.h"
using ::jxl::test::GetIccTestProfile;
////////////////////////////////////////////////////////////////////////////////

namespace {
void AppendU32BE(uint32_t u32, std::vector<uint8_t>* bytes) {
 bytes->push_back(u32 >> 24);
 bytes->push_back(u32 >> 16);
 bytes->push_back(u32 >> 8);
 bytes->push_back(u32 >> 0);
}

// What type of codestream format in the boxes to use for testing
enum CodeStreamBoxFormat {
 // Do not use box format at all, only pure codestream
 kCSBF_None,
 // Have a single codestream box, with its actual size given in the box
 kCSBF_Single,
 // Have a single codestream box, with box size 0 (final box running to end)
 kCSBF_Single_Zero_Terminated,
 // Single codestream box, with another unknown box behind it
 kCSBF_Single_Other,
 // Have multiple partial codestream boxes
 kCSBF_Multi,
 // Have multiple partial codestream boxes, with final box size 0 (running
 // to end)
 kCSBF_Multi_Zero_Terminated,
 // Have multiple partial codestream boxes, terminated by non-codestream box
 kCSBF_Multi_Other_Terminated,
 // Have multiple partial codestream boxes, terminated by non-codestream box
 // that has its size set to 0 (running to end)
 kCSBF_Multi_Other_Zero_Terminated,
 // Have multiple partial codestream boxes, and the first one has a content
 // of zero length
 kCSBF_Multi_First_Empty,
 // Have multiple partial codestream boxes, and the last one has a content
 // of zero length and there is an unknown empty box at the end
 kCSBF_Multi_Last_Empty_Other,
 // Have a compressed exif box before a regular codestream box
 kCSBF_Brob_Exif,
 // Not a value but used for counting amount of enum entries
 kCSBF_NUM_ENTRIES,
};

// Unknown boxes for testing
const char* unk1_box_type = "unk1";
const char* unk1_box_contents = "abcdefghijklmnopqrstuvwxyz";
const size_t unk1_box_size = strlen(unk1_box_contents);
const char* unk2_box_type = "unk2";
const char* unk2_box_contents = "0123456789";
const size_t unk2_box_size = strlen(unk2_box_contents);
const char* unk3_box_type = "unk3";
const char* unk3_box_contents = "ABCDEF123456";
const size_t unk3_box_size = strlen(unk3_box_contents);
// Box with brob-compressed exif, including header
const uint8_t* box_brob_exif = reinterpret_cast<const uint8_t*>(
   "\0\0\0@brobExif\241\350\2\300\177\244v\2525\304\360\27=?\267{"
   "\33\37\314\332\214QX17PT\"\256\0\0\202s\214\313t\333\310\320k\20\276\30"
   "\204\277l$\326c#\1\b");
size_t box_brob_exif_size = 64;
// The uncompressed Exif data from the brob box
const uint8_t* exif_uncompressed = reinterpret_cast<const uint8_t*>(
   "\0\0\0\0MM\0*"
   "\0\0\0\b\0\5\1\22\0\3\0\0\0\1\0\5\0\0\1\32\0\5\0\0\0\1\0\0\0J\1\33\0\5\0\0"
   "\0\1\0\0\0R\1("
   "\0\3\0\0\0\1\0\1\0\0\2\23\0\3\0\0\0\1\0\1\0\0\0\0\0\0\0\0\0\1\0\0\0\1\0\0"
   "\0\1\0\0\0\1");
size_t exif_uncompressed_size = 94;

}  // namespace

namespace jxl {
namespace {

void AppendTestBox(const char* type, const char* contents, size_t contents_size,
                  bool unbounded, std::vector<uint8_t>* bytes) {
 AppendU32BE(contents_size + 8, bytes);
 bytes->push_back(type[0]);
 bytes->push_back(type[1]);
 bytes->push_back(type[2]);
 bytes->push_back(type[3]);
 const uint8_t* contents_u = reinterpret_cast<const uint8_t*>(contents);
 Bytes(contents_u, contents_size).AppendTo(*bytes);
}

enum PreviewMode {
 kNoPreview,
 kSmallPreview,
 kBigPreview,
 kNumPreviewModes,
};

void GeneratePreview(PreviewMode preview_mode, ImageBundle* ib) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 if (preview_mode == kSmallPreview) {
   ASSERT_TRUE(ib->ShrinkTo(ib->xsize() / 7, ib->ysize() / 7));
 } else if (preview_mode == kBigPreview) {
   auto upsample7 = [&](const ImageF& in, ImageF* out) {
     for (size_t y = 0; y < out->ysize(); ++y) {
       for (size_t x = 0; x < out->xsize(); ++x) {
         out->Row(y)[x] = in.ConstRow(y / 7)[x / 7];
       }
     }
   };
   JXL_TEST_ASSIGN_OR_DIE(
       Image3F preview,
       Image3F::Create(memory_manager, ib->xsize() * 7, ib->ysize() * 7));
   for (size_t c = 0; c < 3; ++c) {
     upsample7(ib->color()->Plane(c), &preview.Plane(c));
   }
   std::vector<ImageF> extra_channels;
   for (size_t i = 0; i < ib->extra_channels().size(); ++i) {
     JXL_TEST_ASSIGN_OR_DIE(
         ImageF ec,
         ImageF::Create(memory_manager, ib->xsize() * 7, ib->ysize() * 7));
     upsample7(ib->extra_channels()[i], &ec);
     extra_channels.emplace_back(std::move(ec));
   }
   ib->RemoveColor();
   ib->ClearExtraChannels();
   ASSERT_TRUE(ib->SetFromImage(std::move(preview), ib->c_current()));
   ASSERT_TRUE(ib->SetExtraChannels(std::move(extra_channels)));
 }
}

struct TestCodestreamParams {
 CompressParams cparams;
 CodeStreamBoxFormat box_format = kCSBF_None;
 JxlOrientation orientation = JXL_ORIENT_IDENTITY;
 PreviewMode preview_mode = kNoPreview;
 bool add_intrinsic_size = false;
 bool add_icc_profile = false;
 float intensity_target = 0.0;
 std::string color_space;
 std::vector<uint8_t>* jpeg_codestream = nullptr;
};

// Input pixels always given as 16-bit RGBA, 8 bytes per pixel.
// include_alpha determines if the encoded image should contain the alpha
// channel.
// add_icc_profile: if false, encodes the image as sRGB using the JXL fields,
// for grayscale or RGB images. If true, encodes the image using the ICC profile
// returned by GetIccTestProfile, without the JXL fields, this requires the
// image is RGB, not grayscale.
// Providing jpeg_codestream will populate the jpeg_codestream with compressed
// JPEG bytes, and make it possible to reconstruct those exact JPEG bytes using
// the return value _if_ add_container indicates a box format.
std::vector<uint8_t> CreateTestJXLCodestream(
   Span<const uint8_t> pixels, size_t xsize, size_t ysize, size_t num_channels,
   const TestCodestreamParams& params) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 // Compress the pixels with JPEG XL.
 bool grayscale = (num_channels <= 2);
 bool have_alpha = ((num_channels & 1) == 0);
 bool include_alpha = have_alpha && params.jpeg_codestream == nullptr;
 size_t bitdepth = params.jpeg_codestream == nullptr ? 16 : 8;
 CodecInOut io{jxl::test::MemoryManager()};
 EXPECT_TRUE(io.SetSize(xsize, ysize));
 ColorEncoding color_encoding;
 if (params.add_icc_profile) {
   // the hardcoded ICC profile we attach requires RGB.
   EXPECT_EQ(false, grayscale);
   EXPECT_TRUE(params.color_space.empty());
   EXPECT_TRUE(color_encoding.SetICC(GetIccTestProfile(), JxlGetDefaultCms()));
 } else if (!params.color_space.empty()) {
   JxlColorEncoding c;
   EXPECT_TRUE(jxl::ParseDescription(params.color_space, &c));
   EXPECT_TRUE(color_encoding.FromExternal(c));
   EXPECT_EQ(color_encoding.IsGray(), grayscale);
 } else {
   color_encoding = jxl::ColorEncoding::SRGB(/*is_gray=*/grayscale);
 }
 io.metadata.m.SetUintSamples(bitdepth);
 if (include_alpha) {
   io.metadata.m.SetAlphaBits(bitdepth);
 }
 if (params.intensity_target != 0) {
   io.metadata.m.SetIntensityTarget(params.intensity_target);
 }
 JxlPixelFormat format = {static_cast<uint32_t>(num_channels), JXL_TYPE_UINT16,
                          JXL_BIG_ENDIAN, 0};
 // Make the grayscale-ness of the io metadata color_encoding and the packed
 // image match.
 io.metadata.m.color_encoding = color_encoding;
 EXPECT_TRUE(ConvertFromExternal(pixels, xsize, ysize, color_encoding,
                                 /*bits_per_sample=*/16, format,
                                 /* pool */ nullptr, &io.Main()));
 std::vector<uint8_t> jpeg_data;
 if (params.jpeg_codestream != nullptr) {
   if (jxl::extras::CanDecode(jxl::extras::Codec::kJPG)) {
     std::vector<uint8_t> jpeg_bytes;
     extras::PackedPixelFile ppf;
     JXL_TEST_ASSIGN_OR_DIE(extras::PackedFrame frame,
                            extras::PackedFrame::Create(xsize, ysize, format));
     EXPECT_TRUE(frame.color.pixels_size == pixels.size());
     memcpy(frame.color.pixels(0, 0, 0), pixels.data(), pixels.size());
     ppf.frames.emplace_back(std::move(frame));
     ppf.info.xsize = xsize;
     ppf.info.ysize = ysize;
     ppf.info.num_color_channels = grayscale ? 1 : 3;
     ppf.info.bits_per_sample = 16;
     auto encoder = extras::GetJPEGEncoder();
     encoder->SetOption("quality", "70");
     extras::EncodedImage encoded;
     EXPECT_TRUE(encoder->Encode(ppf, &encoded, nullptr));
     jpeg_bytes = encoded.bitstreams[0];
     Bytes(jpeg_bytes).AppendTo(*params.jpeg_codestream);
     EXPECT_TRUE(jxl::jpeg::DecodeImageJPG(
         jxl::Bytes(jpeg_bytes.data(), jpeg_bytes.size()), &io));
     EXPECT_TRUE(EncodeJPEGData(memory_manager, *io.Main().jpeg_data,
                                &jpeg_data, params.cparams));
     io.metadata.m.xyb_encoded = false;
   } else {
     ADD_FAILURE();
   }
 }
 if (params.preview_mode) {
   JXL_TEST_ASSIGN_OR_DIE(io.preview_frame, io.Main().Copy());
   GeneratePreview(params.preview_mode, &io.preview_frame);
   io.metadata.m.have_preview = true;
   EXPECT_TRUE(io.metadata.m.preview_size.Set(io.preview_frame.xsize(),
                                              io.preview_frame.ysize()));
 }
 if (params.add_intrinsic_size) {
   EXPECT_TRUE(io.metadata.m.intrinsic_size.Set(xsize / 3, ysize / 3));
 }
 io.metadata.m.orientation = params.orientation;
 std::vector<uint8_t> compressed;
 EXPECT_TRUE(test::EncodeFile(params.cparams, &io, &compressed));
 CodeStreamBoxFormat add_container = params.box_format;
 if (add_container != kCSBF_None) {
   // Header with signature box and ftyp box.
   const uint8_t header[] = {0,    0,    0,    0xc,  0x4a, 0x58, 0x4c, 0x20,
                             0xd,  0xa,  0x87, 0xa,  0,    0,    0,    0x14,
                             0x66, 0x74, 0x79, 0x70, 0x6a, 0x78, 0x6c, 0x20,
                             0,    0,    0,    0,    0x6a, 0x78, 0x6c, 0x20};

   bool is_multi = add_container == kCSBF_Multi ||
                   add_container == kCSBF_Multi_Zero_Terminated ||
                   add_container == kCSBF_Multi_Other_Terminated ||
                   add_container == kCSBF_Multi_Other_Zero_Terminated ||
                   add_container == kCSBF_Multi_First_Empty ||
                   add_container == kCSBF_Multi_Last_Empty_Other;

   if (is_multi) {
     size_t third = compressed.size() / 3;
     std::vector<uint8_t> compressed0(compressed.data(),
                                      compressed.data() + third);
     std::vector<uint8_t> compressed1(compressed.data() + third,
                                      compressed.data() + 2 * third);
     std::vector<uint8_t> compressed2(compressed.data() + 2 * third,
                                      compressed.data() + compressed.size());

     std::vector<uint8_t> c;
     Bytes(header).AppendTo(c);
     if (params.jpeg_codestream != nullptr) {
       jxl::AppendBoxHeader(jxl::MakeBoxType("jbrd"), jpeg_data.size(), false,
                            &c);
       Bytes(jpeg_data).AppendTo(c);
     }
     uint32_t jxlp_index = 0;
     if (add_container == kCSBF_Multi_First_Empty) {
       // Empty placeholder codestream part
       AppendU32BE(12, &c);
       c.push_back('j');
       c.push_back('x');
       c.push_back('l');
       c.push_back('p');
       AppendU32BE(jxlp_index++, &c);
     }
     // First codestream part
     AppendU32BE(compressed0.size() + 12, &c);
     c.push_back('j');
     c.push_back('x');
     c.push_back('l');
     c.push_back('p');
     AppendU32BE(jxlp_index++, &c);
     Bytes(compressed0).AppendTo(c);
     // A few non-codestream boxes in between
     AppendTestBox(unk1_box_type, unk1_box_contents, unk1_box_size, false, &c);
     AppendTestBox(unk2_box_type, unk2_box_contents, unk2_box_size, false, &c);
     // Empty placeholder codestream part
     AppendU32BE(12, &c);
     c.push_back('j');
     c.push_back('x');
     c.push_back('l');
     c.push_back('p');
     AppendU32BE(jxlp_index++, &c);
     // Second codestream part
     AppendU32BE(compressed1.size() + 12, &c);
     c.push_back('j');
     c.push_back('x');
     c.push_back('l');
     c.push_back('p');
     AppendU32BE(jxlp_index++, &c);
     Bytes(compressed1).AppendTo(c);
     // Third (last) codestream part
     AppendU32BE(add_container == kCSBF_Multi_Zero_Terminated
                     ? 0
                     : (compressed2.size() + 12),
                 &c);
     c.push_back('j');
     c.push_back('x');
     c.push_back('l');
     c.push_back('p');
     if (add_container != kCSBF_Multi_Last_Empty_Other) {
       AppendU32BE(jxlp_index++ | 0x80000000, &c);
     } else {
       AppendU32BE(jxlp_index++, &c);
     }
     Bytes(compressed2).AppendTo(c);
     if (add_container == kCSBF_Multi_Last_Empty_Other) {
       // Empty placeholder codestream part
       AppendU32BE(12, &c);
       c.push_back('j');
       c.push_back('x');
       c.push_back('l');
       c.push_back('p');
       AppendU32BE(jxlp_index++ | 0x80000000, &c);
       AppendTestBox(unk3_box_type, unk3_box_contents, unk3_box_size, false,
                     &c);
     }
     if (add_container == kCSBF_Multi_Other_Terminated) {
       AppendTestBox(unk3_box_type, unk3_box_contents, unk3_box_size, false,
                     &c);
     }
     if (add_container == kCSBF_Multi_Other_Zero_Terminated) {
       AppendTestBox(unk3_box_type, unk3_box_contents, unk3_box_size, true,
                     &c);
     }
     compressed.swap(c);
   } else {
     std::vector<uint8_t> c;
     Bytes(header).AppendTo(c);
     if (params.jpeg_codestream != nullptr) {
       jxl::AppendBoxHeader(jxl::MakeBoxType("jbrd"), jpeg_data.size(), false,
                            &c);
       Bytes(jpeg_data).AppendTo(c);
     }
     if (add_container == kCSBF_Brob_Exif) {
       Bytes(box_brob_exif, box_brob_exif_size).AppendTo(c);
     }
     AppendU32BE(add_container == kCSBF_Single_Zero_Terminated
                     ? 0
                     : (compressed.size() + 8),
                 &c);
     c.push_back('j');
     c.push_back('x');
     c.push_back('l');
     c.push_back('c');
     Bytes(compressed).AppendTo(c);
     if (add_container == kCSBF_Single_Other) {
       AppendTestBox(unk1_box_type, unk1_box_contents, unk1_box_size, false,
                     &c);
     }
     compressed.swap(c);
   }
 }

 return compressed;
}

JxlDecoderStatus ProcessInputIgnoreBoxes(JxlDecoder* dec) {
 JxlDecoderStatus status = JXL_DEC_BOX;
 while (status == JXL_DEC_BOX) {
   status = JxlDecoderProcessInput(dec);
 }
 return status;
}

// Decodes one-shot with the API for non-streaming decoding tests.
std::vector<uint8_t> DecodeWithAPI(JxlDecoder* dec,
                                  Span<const uint8_t> compressed,
                                  const JxlPixelFormat& format,
                                  bool use_callback, bool set_buffer_early,
                                  bool use_resizable_runner,
                                  bool require_boxes, bool expect_success,
                                  std::vector<uint8_t>* icc = nullptr) {
 JxlThreadParallelRunnerPtr runner_fixed;
 JxlResizableParallelRunnerPtr runner_resizable;
 JxlParallelRunner runner_fn;
 void* runner;

 if (use_resizable_runner) {
   runner_resizable = JxlResizableParallelRunnerMake(nullptr);
   runner = runner_resizable.get();
   runner_fn = JxlResizableParallelRunner;
 } else {
   size_t hw_threads = JxlThreadParallelRunnerDefaultNumWorkerThreads();
   runner_fixed =
       JxlThreadParallelRunnerMake(nullptr, std::min<size_t>(hw_threads, 16));
   runner = runner_fixed.get();
   runner_fn = JxlThreadParallelRunner;
 }
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetParallelRunner(dec, runner_fn, runner));

 auto process_input =
     require_boxes ? ProcessInputIgnoreBoxes : JxlDecoderProcessInput;

 EXPECT_EQ(
     JXL_DEC_SUCCESS,
     JxlDecoderSubscribeEvents(
         dec, JXL_DEC_BASIC_INFO | (set_buffer_early ? JXL_DEC_FRAME : 0) |
                  JXL_DEC_PREVIEW_IMAGE | JXL_DEC_FULL_IMAGE |
                  (require_boxes ? JXL_DEC_BOX : 0) |
                  (icc != nullptr ? JXL_DEC_COLOR_ENCODING : 0)));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
 EXPECT_EQ(JXL_DEC_BASIC_INFO, process_input(dec));
 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 if (use_resizable_runner) {
   JxlResizableParallelRunnerSetThreads(
       runner,
       JxlResizableParallelRunnerSuggestThreads(info.xsize, info.ysize));
 }

 std::vector<uint8_t> pixels(buffer_size);
 size_t bytes_per_pixel = format.num_channels *
                          test::GetDataBits(format.data_type) /
                          jxl::kBitsPerByte;
 size_t stride = bytes_per_pixel * info.xsize;
 if (format.align > 1) {
   stride = jxl::DivCeil(stride, format.align) * format.align;
 }
 auto callback = [&](size_t x, size_t y, size_t num_pixels,
                     const void* pixels_row) {
   memcpy(pixels.data() + stride * y + bytes_per_pixel * x, pixels_row,
          num_pixels * bytes_per_pixel);
 };

 JxlDecoderStatus status = process_input(dec);

 if (status == JXL_DEC_COLOR_ENCODING) {
   size_t icc_size = 0;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                         &icc_size));
   icc->resize(icc_size);
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderGetColorAsICCProfile(dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                            icc->data(), icc_size));

   status = process_input(dec);
 }

 std::vector<uint8_t> preview;
 if (status == JXL_DEC_NEED_PREVIEW_OUT_BUFFER) {
   size_t buffer_size;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderPreviewOutBufferSize(dec, &format, &buffer_size));
   preview.resize(buffer_size);
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetPreviewOutBuffer(dec, &format, preview.data(),
                                           preview.size()));
   EXPECT_EQ(JXL_DEC_PREVIEW_IMAGE, process_input(dec));

   status = process_input(dec);
 }

 if (set_buffer_early) {
   EXPECT_EQ(JXL_DEC_FRAME, status);
 } else {
   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, status);
 }

 if (use_callback) {
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetImageOutCallback(
                 dec, &format,
                 [](void* opaque, size_t x, size_t y, size_t xsize,
                    const void* pixels_row) {
                   auto cb = static_cast<decltype(&callback)>(opaque);
                   (*cb)(x, y, xsize, pixels_row);
                 },
                 /*opaque=*/&callback));
 } else {
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));
 }

 EXPECT_EQ(JXL_DEC_FULL_IMAGE, process_input(dec));

 // After the full image was output, JxlDecoderProcessInput should return
 // success to indicate all is done, unless we requested boxes and the last
 // box was not a terminal unbounded box, in which case it should ask for
 // more input.
 JxlDecoderStatus expected_status =
     expect_success ? JXL_DEC_SUCCESS : JXL_DEC_NEED_MORE_INPUT;
 EXPECT_EQ(expected_status, process_input(dec));

 return pixels;
}

// Decodes one-shot with the API for non-streaming decoding tests.
std::vector<uint8_t> DecodeWithAPI(Span<const uint8_t> compressed,
                                  const JxlPixelFormat& format,
                                  bool use_callback, bool set_buffer_early,
                                  bool use_resizable_runner,
                                  bool require_boxes, bool expect_success) {
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 std::vector<uint8_t> pixels =
     DecodeWithAPI(dec, compressed, format, use_callback, set_buffer_early,
                   use_resizable_runner, require_boxes, expect_success);
 JxlDecoderDestroy(dec);
 return pixels;
}

}  // namespace
}  // namespace jxl

////////////////////////////////////////////////////////////////////////////////

using ::jxl::Image3F;
using ::jxl::ImageF;
using ::jxl::test::BoolToCStr;
using ::jxl::test::ButteraugliDistance;

TEST(DecodeTest, JxlSignatureCheckTest) {
 std::vector<std::pair<int, std::vector<uint8_t>>> tests = {
     // No JPEGXL header starts with 'a'.
     {JXL_SIG_INVALID, {'a'}},
     {JXL_SIG_INVALID, {'a', 'b', 'c', 'd', 'e', 'f'}},

     // Empty file is not enough bytes.
     {JXL_SIG_NOT_ENOUGH_BYTES, {}},

     // JPEGXL headers.
     {JXL_SIG_NOT_ENOUGH_BYTES, {0xff}},  // Part of a signature.
     {JXL_SIG_INVALID, {0xff, 0xD8}},     // JPEG-1
     {JXL_SIG_CODESTREAM, {0xff, 0x0a}},

     // JPEGXL container file.
     {JXL_SIG_CONTAINER,
      {0, 0, 0, 0xc, 'J', 'X', 'L', ' ', 0xD, 0xA, 0x87, 0xA}},
     // Ending with invalid byte.
     {JXL_SIG_INVALID, {0, 0, 0, 0xc, 'J', 'X', 'L', ' ', 0xD, 0xA, 0x87, 0}},
     // Part of signature.
     {JXL_SIG_NOT_ENOUGH_BYTES,
      {0, 0, 0, 0xc, 'J', 'X', 'L', ' ', 0xD, 0xA, 0x87}},
     {JXL_SIG_NOT_ENOUGH_BYTES, {0}},
 };
 for (const auto& test : tests) {
   EXPECT_EQ(test.first,
             JxlSignatureCheck(test.second.data(), test.second.size()))
       << "Where test data is " << ::testing::PrintToString(test.second);
 }
}

TEST(DecodeTest, DefaultAllocTest) {
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_NE(nullptr, dec);
 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, CustomAllocTest) {
 struct CalledCounters {
   int allocs = 0;
   int frees = 0;
 } counters;

 JxlMemoryManager mm;
 mm.opaque = &counters;
 mm.alloc = [](void* opaque, size_t size) {
   reinterpret_cast<CalledCounters*>(opaque)->allocs++;
   return malloc(size);
 };
 mm.free = [](void* opaque, void* address) {
   reinterpret_cast<CalledCounters*>(opaque)->frees++;
   free(address);
 };

 JxlDecoder* dec = JxlDecoderCreate(&mm);
 EXPECT_NE(nullptr, dec);
 EXPECT_LE(1, counters.allocs);
 EXPECT_EQ(0, counters.frees);
 JxlDecoderDestroy(dec);
 EXPECT_LE(1, counters.frees);
}

// TODO(lode): add multi-threaded test when multithreaded pixel decoding from
// API is implemented.
TEST(DecodeTest, DefaultParallelRunnerTest) {
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_NE(nullptr, dec);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetParallelRunner(dec, nullptr, nullptr));
 JxlDecoderDestroy(dec);
}

// Creates the header of a JPEG XL file with various custom parameters for
// testing.
// xsize, ysize: image dimensions to store in the SizeHeader, max 512.
// bits_per_sample, orientation: a selection of header parameters to test with.
// orientation: image orientation to set in the metadata
// alpha_bits: if non-0, alpha extra channel bits to set in the metadata. Also
//   gives the alpha channel the name "alpha_test"
// have_container: add box container format around the codestream.
// metadata_default: if true, ImageMetadata is set to default and
//   bits_per_sample, orientation and alpha_bits are ignored.
// insert_box: insert an extra box before the codestream box, making the header
// farther away from the front than is ideal. Only used if have_container.
std::vector<uint8_t> GetTestHeader(size_t xsize, size_t ysize,
                                  size_t bits_per_sample, size_t orientation,
                                  size_t alpha_bits, bool xyb_encoded,
                                  bool have_container, bool metadata_default,
                                  bool insert_extra_box,
                                  const jxl::IccBytes& icc_profile) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 jxl::BitWriter writer{memory_manager};
 EXPECT_TRUE(writer.WithMaxBits(
     65536,  // Large enough
     jxl::LayerType::Header, nullptr, [&] {
       if (have_container) {
         const std::vector<uint8_t> signature_box = {
             0, 0, 0, 0xc, 'J', 'X', 'L', ' ', 0xd, 0xa, 0x87, 0xa};
         const std::vector<uint8_t> filetype_box = {
             0,   0,   0, 0x14, 'f', 't', 'y', 'p', 'j', 'x',
             'l', ' ', 0, 0,    0,   0,   'j', 'x', 'l', ' '};
         const std::vector<uint8_t> extra_box_header = {0,   0,   0,   0xff,
                                                        't', 'e', 's', 't'};
         // Beginning of codestream box, with an arbitrary size certainly large
         // enough to contain the header
         const std::vector<uint8_t> codestream_box_header = {
             0, 0, 0, 0xff, 'j', 'x', 'l', 'c'};

         for (uint8_t c : signature_box) {
           writer.Write(8, c);
         }
         for (uint8_t c : filetype_box) {
           writer.Write(8, c);
         }
         if (insert_extra_box) {
           for (uint8_t c : extra_box_header) {
             writer.Write(8, c);
           }
           for (size_t i = 0; i < 255 - 8; i++) {
             writer.Write(8, 0);
           }
         }
         for (uint8_t c : codestream_box_header) {
           writer.Write(8, c);
         }
       }

       // JXL signature
       writer.Write(8, 0xff);
       writer.Write(8, 0x0a);

       // SizeHeader
       jxl::CodecMetadata metadata;
       EXPECT_TRUE(metadata.size.Set(xsize, ysize));
       EXPECT_TRUE(WriteSizeHeader(metadata.size, &writer,
                                   jxl::LayerType::Header, nullptr));

       if (!metadata_default) {
         metadata.m.SetUintSamples(bits_per_sample);
         metadata.m.orientation = orientation;
         metadata.m.SetAlphaBits(alpha_bits);
         metadata.m.xyb_encoded = xyb_encoded;
         if (alpha_bits != 0) {
           metadata.m.extra_channel_info[0].name = "alpha_test";
         }
       }

       if (!icc_profile.empty()) {
         jxl::IccBytes copy = icc_profile;
         EXPECT_TRUE(metadata.m.color_encoding.SetICC(std::move(copy),
                                                      JxlGetDefaultCms()));
       }

       EXPECT_TRUE(jxl::Bundle::Write(metadata.m, &writer,
                                      jxl::LayerType::Header, nullptr));
       metadata.transform_data.nonserialized_xyb_encoded =
           metadata.m.xyb_encoded;
       EXPECT_TRUE(jxl::Bundle::Write(metadata.transform_data, &writer,
                                      jxl::LayerType::Header, nullptr));

       if (!icc_profile.empty()) {
         EXPECT_TRUE(metadata.m.color_encoding.WantICC());
         EXPECT_TRUE(jxl::WriteICC(jxl::Span<const uint8_t>(icc_profile),
                                   &writer, jxl::LayerType::Header, nullptr));
       }

       writer.ZeroPadToByte();
       return true;
     }));
 jxl::Bytes bytes = writer.GetSpan();
 return std::vector<uint8_t>(bytes.data(), bytes.data() + bytes.size());
}

TEST(DecodeTest, BasicInfoTest) {
 size_t xsize[2] = {50, 33};
 size_t ysize[2] = {50, 77};
 size_t bits_per_sample[2] = {8, 23};
 size_t orientation[2] = {3, 5};
 size_t alpha_bits[2] = {0, 8};
 bool have_container[2] = {false, true};
 bool xyb_encoded = false;

 std::vector<std::vector<uint8_t>> test_samples;
 // Test with direct codestream
 test_samples.push_back(GetTestHeader(
     xsize[0], ysize[0], bits_per_sample[0], orientation[0], alpha_bits[0],
     xyb_encoded, have_container[0], /*metadata_default=*/false,
     /*insert_extra_box=*/false, {}));
 // Test with container and different parameters
 test_samples.push_back(GetTestHeader(
     xsize[1], ysize[1], bits_per_sample[1], orientation[1], alpha_bits[1],
     xyb_encoded, have_container[1], /*metadata_default=*/false,
     /*insert_extra_box=*/false, {}));

 for (size_t i = 0; i < test_samples.size(); ++i) {
   const std::vector<uint8_t>& data = test_samples[i];
   // Test decoding too small header first, until we reach the final byte.
   for (size_t size = 0; size <= data.size(); ++size) {
     // Test with a new decoder for each tested byte size.
     JxlDecoder* dec = JxlDecoderCreate(nullptr);
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO));
     const uint8_t* next_in = data.data();
     size_t avail_in = size;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
     JxlDecoderStatus status = JxlDecoderProcessInput(dec);

     JxlBasicInfo info;
     JxlDecoderStatus bi_status = JxlDecoderGetBasicInfo(dec, &info);
     bool have_basic_info = (bi_status == JXL_DEC_SUCCESS);

     if (size == data.size()) {
       EXPECT_EQ(JXL_DEC_BASIC_INFO, status);

       // All header bytes given so the decoder must have the basic info.
       EXPECT_EQ(true, have_basic_info);
       EXPECT_EQ(have_container[i], FROM_JXL_BOOL(info.have_container));
       EXPECT_EQ(alpha_bits[i], info.alpha_bits);
       // Orientations 5..8 swap the dimensions
       if (orientation[i] >= 5) {
         EXPECT_EQ(xsize[i], info.ysize);
         EXPECT_EQ(ysize[i], info.xsize);
       } else {
         EXPECT_EQ(xsize[i], info.xsize);
         EXPECT_EQ(ysize[i], info.ysize);
       }
       // The API should set the orientation to identity by default since it
       // already applies the transformation internally by default.
       EXPECT_EQ(1u, info.orientation);

       EXPECT_EQ(3u, info.num_color_channels);

       if (alpha_bits[i] != 0) {
         // Expect an extra channel
         EXPECT_EQ(1u, info.num_extra_channels);
         JxlExtraChannelInfo extra;
         EXPECT_EQ(0, JxlDecoderGetExtraChannelInfo(dec, 0, &extra));
         EXPECT_EQ(alpha_bits[i], extra.bits_per_sample);
         EXPECT_EQ(JXL_CHANNEL_ALPHA, extra.type);
         EXPECT_EQ(0, extra.alpha_premultiplied);
         // Verify the name "alpha_test" given to the alpha channel
         EXPECT_EQ(10u, extra.name_length);
         char name[11];
         EXPECT_EQ(0,
                   JxlDecoderGetExtraChannelName(dec, 0, name, sizeof(name)));
         EXPECT_EQ(std::string("alpha_test"), std::string(name));
       } else {
         EXPECT_EQ(0u, info.num_extra_channels);
       }

       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
     } else {
       // If we did not give the full header, the basic info should not be
       // available. Allow a few bytes of slack due to some bits for default
       // opsinmatrix/extension bits.
       if (size + 2 < data.size()) {
         EXPECT_EQ(false, have_basic_info);
         EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, status);
       }
     }

     // Test that decoder doesn't allow setting a setting required at beginning
     // unless it's reset
     EXPECT_EQ(JXL_DEC_ERROR,
               JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO));
     JxlDecoderReset(dec);
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO));

     JxlDecoderDestroy(dec);
   }
 }
}

TEST(DecodeTest, BufferSizeTest) {
 size_t xsize = 33;
 size_t ysize = 77;
 size_t bits_per_sample = 8;
 size_t orientation = 1;
 size_t alpha_bits = 8;
 bool have_container = false;
 bool xyb_encoded = false;

 std::vector<uint8_t> header =
     GetTestHeader(xsize, ysize, bits_per_sample, orientation, alpha_bits,
                   xyb_encoded, have_container, /*metadata_default=*/false,
                   /*insert_extra_box=*/false, {});

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO));
 const uint8_t* next_in = header.data();
 size_t avail_in = header.size();
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
 JxlDecoderStatus status = JxlDecoderProcessInput(dec);
 EXPECT_EQ(JXL_DEC_BASIC_INFO, status);

 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(xsize, info.xsize);
 EXPECT_EQ(ysize, info.ysize);

 JxlPixelFormat format = {4, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, 0};
 size_t image_out_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &image_out_size));
 EXPECT_EQ(xsize * ysize * 4, image_out_size);

 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, BasicInfoSizeHintTest) {
 // Test on a file where the size hint is too small initially due to inserting
 // a box before the codestream (something that is normally not recommended)
 size_t xsize = 50;
 size_t ysize = 50;
 size_t bits_per_sample = 16;
 size_t orientation = 1;
 size_t alpha_bits = 0;
 bool xyb_encoded = false;
 std::vector<uint8_t> data = GetTestHeader(
     xsize, ysize, bits_per_sample, orientation, alpha_bits, xyb_encoded,
     /*have_container=*/true, /*metadata_default=*/false,
     /*insert_extra_box=*/true, {});

 JxlDecoderStatus status;
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO));

 size_t hint0 = JxlDecoderSizeHintBasicInfo(dec);
 // Test that the test works as intended: we construct a file on purpose to
 // be larger than the first hint by having that extra box.
 EXPECT_LT(hint0, data.size());
 const uint8_t* next_in = data.data();
 // Do as if we have only as many bytes as indicated by the hint available
 size_t avail_in = std::min(hint0, data.size());
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
 status = JxlDecoderProcessInput(dec);
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, status);
 // Basic info cannot be available yet due to the extra inserted box.
 EXPECT_EQ(false, !JxlDecoderGetBasicInfo(dec, nullptr));

 size_t num_read = avail_in - JxlDecoderReleaseInput(dec);
 EXPECT_LT(num_read, data.size());

 size_t hint1 = JxlDecoderSizeHintBasicInfo(dec);
 // The hint must be larger than the previous hint (taking already processed
 // bytes into account, the hint is a hint for the next avail_in) since the
 // decoder now knows there is a box in between.
 EXPECT_GT(hint1 + num_read, hint0);
 avail_in = std::min<size_t>(hint1, data.size() - num_read);
 next_in += num_read;

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
 status = JxlDecoderProcessInput(dec);
 EXPECT_EQ(JXL_DEC_BASIC_INFO, status);
 JxlBasicInfo info;
 // We should have the basic info now, since we only added one box in-between,
 // and the decoder should have known its size, its implementation can return
 // a correct hint.
 EXPECT_EQ(true, !JxlDecoderGetBasicInfo(dec, &info));

 // Also test if the basic info is correct.
 EXPECT_EQ(1, info.have_container);
 EXPECT_EQ(xsize, info.xsize);
 EXPECT_EQ(ysize, info.ysize);
 EXPECT_EQ(orientation, info.orientation);
 EXPECT_EQ(bits_per_sample, info.bits_per_sample);

 JxlDecoderDestroy(dec);
}

std::vector<uint8_t> GetIccTestHeader(const jxl::IccBytes& icc_profile,
                                     bool xyb_encoded) {
 size_t xsize = 50;
 size_t ysize = 50;
 size_t bits_per_sample = 16;
 size_t orientation = 1;
 size_t alpha_bits = 0;
 return GetTestHeader(xsize, ysize, bits_per_sample, orientation, alpha_bits,
                      xyb_encoded,
                      /*have_container=*/false, /*metadata_default=*/false,
                      /*insert_extra_box=*/false, icc_profile);
}

// Tests the case where pixels and metadata ICC profile are the same
TEST(DecodeTest, IccProfileTestOriginal) {
 jxl::IccBytes icc_profile = GetIccTestProfile();
 bool xyb_encoded = false;
 std::vector<uint8_t> data = GetIccTestHeader(icc_profile, xyb_encoded);

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), data.size()));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));

 // Expect the opposite of xyb_encoded for uses_original_profile
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(JXL_TRUE, info.uses_original_profile);

 EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));

 // the encoded color profile expected to be not available, since the image
 // has an ICC profile instead
 EXPECT_EQ(JXL_DEC_ERROR,
           JxlDecoderGetColorAsEncodedProfile(
               dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL, nullptr));

 size_t dec_profile_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL,
                                       &dec_profile_size));

 // Check that can get return status with NULL size
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL,
                                       nullptr));

 // The profiles must be equal. This requires they have equal size, and if
 // they do, we can get the profile and compare the contents.
 EXPECT_EQ(icc_profile.size(), dec_profile_size);
 if (icc_profile.size() == dec_profile_size) {
   jxl::IccBytes icc_profile2(icc_profile.size());
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetColorAsICCProfile(
                                  dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL,
                                  icc_profile2.data(), icc_profile2.size()));
   EXPECT_EQ(icc_profile, icc_profile2);
 }

 // the data is not xyb_encoded, so same result expected for the pixel data
 // color profile
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderGetColorAsEncodedProfile(
                              dec, JXL_COLOR_PROFILE_TARGET_DATA, nullptr));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                       &dec_profile_size));
 EXPECT_EQ(icc_profile.size(), dec_profile_size);

 JxlDecoderDestroy(dec);
}

// Tests the case where pixels and metadata ICC profile are different
TEST(DecodeTest, IccProfileTestXybEncoded) {
 jxl::IccBytes icc_profile = GetIccTestProfile();
 bool xyb_encoded = true;
 std::vector<uint8_t> data = GetIccTestHeader(icc_profile, xyb_encoded);

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), data.size()));
 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));

 // Expect the opposite of xyb_encoded for uses_original_profile
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(JXL_FALSE, info.uses_original_profile);

 EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));

 // the encoded color profile expected to be not available, since the image
 // has an ICC profile instead
 EXPECT_EQ(JXL_DEC_ERROR,
           JxlDecoderGetColorAsEncodedProfile(
               dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL, nullptr));

 // Check that can get return status with NULL size
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL,
                                       nullptr));

 size_t dec_profile_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL,
                                       &dec_profile_size));

 // The profiles must be equal. This requires they have equal size, and if
 // they do, we can get the profile and compare the contents.
 EXPECT_EQ(icc_profile.size(), dec_profile_size);
 if (icc_profile.size() == dec_profile_size) {
   jxl::IccBytes icc_profile2(icc_profile.size());
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetColorAsICCProfile(
                                  dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL,
                                  icc_profile2.data(), icc_profile2.size()));
   EXPECT_EQ(icc_profile, icc_profile2);
 }

 // Data is xyb_encoded, so the data profile is a different profile, encoded
 // as structured profile.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetColorAsEncodedProfile(
                                dec, JXL_COLOR_PROFILE_TARGET_DATA, nullptr));
 JxlColorEncoding pixel_encoding;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetColorAsEncodedProfile(
               dec, JXL_COLOR_PROFILE_TARGET_DATA, &pixel_encoding));
 EXPECT_EQ(JXL_PRIMARIES_SRGB, pixel_encoding.primaries);
 // The API returns LINEAR by default when the colorspace cannot be represented
 // by enum values.
 EXPECT_EQ(JXL_TRANSFER_FUNCTION_LINEAR, pixel_encoding.transfer_function);

 // Test the same but with integer format.
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetColorAsEncodedProfile(
               dec, JXL_COLOR_PROFILE_TARGET_DATA, &pixel_encoding));
 EXPECT_EQ(JXL_PRIMARIES_SRGB, pixel_encoding.primaries);
 EXPECT_EQ(JXL_TRANSFER_FUNCTION_LINEAR, pixel_encoding.transfer_function);

 // Test after setting the preferred color profile to non-linear sRGB:
 // for XYB images with ICC profile, this setting is expected to take effect.
 jxl::ColorEncoding temp_jxl_srgb = jxl::ColorEncoding::SRGB(false);
 JxlColorEncoding pixel_encoding_srgb = temp_jxl_srgb.ToExternal();
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetPreferredColorProfile(dec, &pixel_encoding_srgb));
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetColorAsEncodedProfile(
               dec, JXL_COLOR_PROFILE_TARGET_DATA, &pixel_encoding));
 EXPECT_EQ(JXL_TRANSFER_FUNCTION_SRGB, pixel_encoding.transfer_function);

 // The decoder can also output this as a generated ICC profile anyway, and
 // we're certain that it will differ from the above defined profile since
 // the sRGB data should not have swapped R/G/B primaries.

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                       &dec_profile_size));
 // We don't need to dictate exactly what size the generated ICC profile
 // must be (since there are many ways to represent the same color space),
 // but it should not be zero.
 EXPECT_NE(0u, dec_profile_size);
 jxl::IccBytes icc_profile2(dec_profile_size);
 if (0 != dec_profile_size) {
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetColorAsICCProfile(
                                  dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                  icc_profile2.data(), icc_profile2.size()));
   // expected not equal
   EXPECT_NE(icc_profile, icc_profile2);
 }

 // Test setting another different preferred profile, to verify that the
 // returned JXL_COLOR_PROFILE_TARGET_DATA ICC profile is correctly
 // updated.

 jxl::ColorEncoding temp_jxl_linear = jxl::ColorEncoding::LinearSRGB(false);
 JxlColorEncoding pixel_encoding_linear = temp_jxl_linear.ToExternal();

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetPreferredColorProfile(dec, &pixel_encoding_linear));
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetColorAsEncodedProfile(
               dec, JXL_COLOR_PROFILE_TARGET_DATA, &pixel_encoding));
 EXPECT_EQ(JXL_TRANSFER_FUNCTION_LINEAR, pixel_encoding.transfer_function);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetICCProfileSize(dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                       &dec_profile_size));
 EXPECT_NE(0u, dec_profile_size);
 jxl::IccBytes icc_profile3(dec_profile_size);
 if (0 != dec_profile_size) {
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetColorAsICCProfile(
                                  dec, JXL_COLOR_PROFILE_TARGET_DATA,
                                  icc_profile3.data(), icc_profile3.size()));
   // expected not equal to the previously set preferred profile.
   EXPECT_NE(icc_profile2, icc_profile3);
 }

 JxlDecoderDestroy(dec);
}

// Test decoding ICC from partial files byte for byte.
// This test must pass also if JXL_CRASH_ON_ERROR is enabled, that is, the
// decoding of the ANS histogram and stream of the encoded ICC profile must also
// handle the case of not enough input bytes with StatusCode::kNotEnoughBytes
// rather than fatal error status codes.
TEST(DecodeTest, ICCPartialTest) {
 jxl::IccBytes icc_profile = GetIccTestProfile();
 std::vector<uint8_t> data = GetIccTestHeader(icc_profile, false);

 const uint8_t* next_in = data.data();
 size_t avail_in = 0;

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING));

 bool seen_basic_info = false;
 bool seen_color_encoding = false;
 size_t total_size = 0;

 for (;;) {
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
   JxlDecoderStatus status = JxlDecoderProcessInput(dec);
   size_t remaining = JxlDecoderReleaseInput(dec);
   EXPECT_LE(remaining, avail_in);
   next_in += avail_in - remaining;
   avail_in = remaining;
   if (status == JXL_DEC_NEED_MORE_INPUT) {
     if (total_size >= data.size()) {
       // End of partial codestream with codestrema headers and ICC profile
       // reached, it should not require more input since full image is not
       // requested
       FAIL();
       break;
     }
     size_t increment = 1;
     if (total_size + increment > data.size()) {
       increment = data.size() - total_size;
     }
     total_size += increment;
     avail_in += increment;
   } else if (status == JXL_DEC_BASIC_INFO) {
     EXPECT_FALSE(seen_basic_info);
     seen_basic_info = true;
   } else if (status == JXL_DEC_COLOR_ENCODING) {
     EXPECT_TRUE(seen_basic_info);
     EXPECT_FALSE(seen_color_encoding);
     seen_color_encoding = true;

     // Sanity check that the ICC profile was decoded correctly
     size_t dec_profile_size;
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderGetICCProfileSize(
                   dec, JXL_COLOR_PROFILE_TARGET_ORIGINAL, &dec_profile_size));
     EXPECT_EQ(icc_profile.size(), dec_profile_size);

   } else if (status == JXL_DEC_SUCCESS) {
     EXPECT_TRUE(seen_color_encoding);
     break;
   } else {
     // We do not expect any other events or errors
     FAIL();
     break;
   }
 }

 EXPECT_TRUE(seen_basic_info);
 EXPECT_TRUE(seen_color_encoding);

 JxlDecoderDestroy(dec);
}

struct PixelTestConfig {
 // Input image definition.
 bool grayscale;
 bool include_alpha;
 size_t xsize;
 size_t ysize;
 jxl::PreviewMode preview_mode;
 bool add_intrinsic_size;
 // Output format.
 JxlEndianness endianness;
 JxlDataType data_type;
 uint32_t output_channels;
 // Container options.
 CodeStreamBoxFormat add_container;
 // Decoding mode.
 bool use_callback;
 bool set_buffer_early;
 bool use_resizable_runner;
 // Exif orientation, 1-8
 JxlOrientation orientation;
 bool keep_orientation;
 size_t upsampling;
};

class DecodeTestParam : public ::testing::TestWithParam<PixelTestConfig> {};

TEST_P(DecodeTestParam, PixelTest) {
 PixelTestConfig config = GetParam();
 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 if (config.keep_orientation) {
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetKeepOrientation(dec, JXL_TRUE));
 }

 size_t num_pixels = config.xsize * config.ysize;
 uint32_t orig_channels =
     (config.grayscale ? 1 : 3) + (config.include_alpha ? 1 : 0);
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(config.xsize, config.ysize, orig_channels, 0);
 JxlPixelFormat format_orig = {orig_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN,
                               0};
 jxl::TestCodestreamParams params;
 // Lossless to verify pixels exactly after roundtrip.
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 params.cparams.resampling = config.upsampling;
 params.cparams.ec_resampling = config.upsampling;
 params.box_format = config.add_container;
 params.orientation = config.orientation;
 params.preview_mode = config.preview_mode;
 params.add_intrinsic_size = config.add_intrinsic_size;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), config.xsize, config.ysize,
     orig_channels, params);

 JxlPixelFormat format = {config.output_channels, config.data_type,
                          config.endianness, 0};

 bool swap_xy = !config.keep_orientation && (config.orientation > 4);
 size_t xsize = swap_xy ? config.ysize : config.xsize;
 size_t ysize = swap_xy ? config.xsize : config.ysize;

 std::vector<uint8_t> pixels2 =
     jxl::DecodeWithAPI(dec, jxl::Bytes(compressed.data(), compressed.size()),
                        format, config.use_callback, config.set_buffer_early,
                        config.use_resizable_runner, /*require_boxes=*/false,
                        /*expect_success=*/true);
 JxlDecoderReset(dec);
 EXPECT_EQ(num_pixels * config.output_channels *
               jxl::test::GetDataBits(config.data_type) / jxl::kBitsPerByte,
           pixels2.size());

 // If an orientation transformation is expected, to compare the pixels, also
 // apply this transformation to the original pixels. ConvertToExternal is
 // used to achieve this, with a temporary conversion to CodecInOut and back.
 if (config.orientation > 1 && !config.keep_orientation) {
   jxl::Span<const uint8_t> bytes(pixels.data(), pixels.size());
   jxl::ColorEncoding color_encoding =
       jxl::ColorEncoding::SRGB(config.grayscale);

   jxl::CodecInOut io{jxl::test::MemoryManager()};
   if (config.include_alpha) io.metadata.m.SetAlphaBits(16);
   io.metadata.m.color_encoding = color_encoding;
   ASSERT_TRUE(io.SetSize(config.xsize, config.ysize));

   EXPECT_TRUE(ConvertFromExternal(bytes, config.xsize, config.ysize,
                                   color_encoding, 16, format_orig, nullptr,
                                   &io.Main()));

   for (uint8_t& pixel : pixels) pixel = 0;
   EXPECT_TRUE(ConvertToExternal(
       io.Main(), 16,
       /*float_out=*/false, orig_channels, JXL_BIG_ENDIAN,
       xsize * 2 * orig_channels, nullptr, pixels.data(), pixels.size(),
       /*out_callback=*/{},
       static_cast<jxl::Orientation>(config.orientation)));
 }
 if (config.upsampling == 1) {
   EXPECT_EQ(0u, jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                          ysize, format_orig, format));
 } else {
   // resampling is of course not lossless, so as a rough check:
   // count pixels that are more than off-by-25 in the 8-bit value of one of
   // the channels
   EXPECT_LE(
       jxl::test::ComparePixels(
           pixels.data(), pixels2.data(), xsize, ysize, format_orig, format,
           50.0 * (config.data_type == JXL_TYPE_UINT8 ? 1.0 : 256.0)),
       300u);
 }

 JxlDecoderDestroy(dec);
}

std::vector<PixelTestConfig> GeneratePixelTests() {
 std::vector<PixelTestConfig> all_tests;
 struct ChannelInfo {
   bool grayscale;
   bool include_alpha;
   size_t output_channels;
 };
 ChannelInfo ch_info[] = {
     {false, true, 4},   // RGBA -> RGBA
     {true, false, 1},   // G -> G
     {true, true, 1},    // GA -> G
     {true, true, 2},    // GA -> GA
     {false, false, 3},  // RGB -> RGB
     {false, true, 3},   // RGBA -> RGB
     {false, false, 4},  // RGB -> RGBA
 };

 struct OutputFormat {
   JxlEndianness endianness;
   JxlDataType data_type;
 };
 OutputFormat out_formats[] = {
     {JXL_NATIVE_ENDIAN, JXL_TYPE_UINT8},
     {JXL_LITTLE_ENDIAN, JXL_TYPE_UINT16},
     {JXL_BIG_ENDIAN, JXL_TYPE_UINT16},
     {JXL_NATIVE_ENDIAN, JXL_TYPE_FLOAT16},
     {JXL_LITTLE_ENDIAN, JXL_TYPE_FLOAT},
     {JXL_BIG_ENDIAN, JXL_TYPE_FLOAT},
 };

 auto make_test = [&](ChannelInfo ch, size_t xsize, size_t ysize,
                      jxl::PreviewMode preview_mode, bool intrinsic_size,
                      CodeStreamBoxFormat box, JxlOrientation orientation,
                      bool keep_orientation, OutputFormat format,
                      bool use_callback, bool set_buffer_early,
                      bool resizable_runner, size_t upsampling) {
   PixelTestConfig c;
   c.grayscale = ch.grayscale;
   c.include_alpha = ch.include_alpha;
   c.preview_mode = preview_mode;
   c.add_intrinsic_size = intrinsic_size;
   c.xsize = xsize;
   c.ysize = ysize;
   c.add_container = box;
   c.output_channels = ch.output_channels;
   c.data_type = format.data_type;
   c.endianness = format.endianness;
   c.use_callback = use_callback;
   c.set_buffer_early = set_buffer_early;
   c.use_resizable_runner = resizable_runner;
   c.orientation = orientation;
   c.keep_orientation = keep_orientation;
   c.upsampling = upsampling;
   all_tests.push_back(c);
 };

 // Test output formats and methods.
 for (ChannelInfo ch : ch_info) {
   for (bool use_callback : {false, true}) {
     for (size_t upsampling : {1, 2, 4, 8}) {
       for (OutputFormat fmt : out_formats) {
         make_test(ch, 301, 33, jxl::kNoPreview,
                   /*add_intrinsic_size=*/false,
                   CodeStreamBoxFormat::kCSBF_None, JXL_ORIENT_IDENTITY,
                   /*keep_orientation=*/false, fmt, use_callback,
                   /*set_buffer_early=*/false, /*resizable_runner=*/false,
                   upsampling);
       }
     }
   }
 }
 // Test codestream formats.
 for (size_t box = 1; box < kCSBF_NUM_ENTRIES; ++box) {
   make_test(ch_info[0], 77, 33, jxl::kNoPreview,
             /*add_intrinsic_size=*/false,
             static_cast<CodeStreamBoxFormat>(box), JXL_ORIENT_IDENTITY,
             /*keep_orientation=*/false, out_formats[0],
             /*use_callback=*/false,
             /*set_buffer_early=*/false, /*resizable_runner=*/false, 1);
 }
 // Test previews.
 for (int preview_mode = 0; preview_mode < jxl::kNumPreviewModes;
      preview_mode++) {
   make_test(ch_info[0], 77, 33, static_cast<jxl::PreviewMode>(preview_mode),
             /*add_intrinsic_size=*/false, CodeStreamBoxFormat::kCSBF_None,
             JXL_ORIENT_IDENTITY,
             /*keep_orientation=*/false, out_formats[0],
             /*use_callback=*/false, /*set_buffer_early=*/false,
             /*resizable_runner=*/false, 1);
 }
 // Test intrinsic sizes.
 for (bool add_intrinsic_size : {false, true}) {
   make_test(ch_info[0], 55, 34, jxl::kNoPreview, add_intrinsic_size,
             CodeStreamBoxFormat::kCSBF_None, JXL_ORIENT_IDENTITY,
             /*keep_orientation=*/false, out_formats[0],
             /*use_callback=*/false, /*set_buffer_early=*/false,
             /*resizable_runner=*/false, 1);
 }
 // Test setting buffers early.
 make_test(ch_info[0], 300, 33, jxl::kNoPreview,
           /*add_intrinsic_size=*/false, CodeStreamBoxFormat::kCSBF_None,
           JXL_ORIENT_IDENTITY,
           /*keep_orientation=*/false, out_formats[0],
           /*use_callback=*/false, /*set_buffer_early=*/true,
           /*resizable_runner=*/false, 1);

 // Test using the resizable runner
 for (size_t i = 0; i < 4; i++) {
   make_test(ch_info[0], 300 << i, 33 << i, jxl::kNoPreview,
             /*add_intrinsic_size=*/false, CodeStreamBoxFormat::kCSBF_None,
             JXL_ORIENT_IDENTITY,
             /*keep_orientation=*/false, out_formats[0],
             /*use_callback=*/false, /*set_buffer_early=*/false,
             /*resizable_runner=*/true, 1);
 }

 // Test orientations.
 for (int orientation = 2; orientation <= 8; ++orientation) {
   for (bool keep_orientation : {false, true}) {
     for (bool use_callback : {false, true}) {
       for (ChannelInfo ch : ch_info) {
         for (OutputFormat fmt : out_formats) {
           make_test(ch, 280, 12, jxl::kNoPreview,
                     /*add_intrinsic_size=*/false,
                     CodeStreamBoxFormat::kCSBF_None,
                     static_cast<JxlOrientation>(orientation),
                     /*keep_orientation=*/keep_orientation, fmt,
                     /*use_callback=*/use_callback, /*set_buffer_early=*/true,
                     /*resizable_runner=*/false, 1);
         }
       }
     }
   }
 }

 return all_tests;
}

std::ostream& operator<<(std::ostream& os, const PixelTestConfig& c) {
 os << c.xsize << "x" << c.ysize;
 const char* colors[] = {"", "G", "GA", "RGB", "RGBA"};
 os << colors[(c.grayscale ? 1 : 3) + (c.include_alpha ? 1 : 0)];
 os << "to";
 os << colors[c.output_channels];
 switch (c.data_type) {
   case JXL_TYPE_UINT8:
     os << "u8";
     break;
   case JXL_TYPE_UINT16:
     os << "u16";
     break;
   case JXL_TYPE_FLOAT:
     os << "f32";
     break;
   case JXL_TYPE_FLOAT16:
     os << "f16";
     break;
   default:
     ADD_FAILURE();
 };
 if (jxl::test::GetDataBits(c.data_type) > jxl::kBitsPerByte) {
   if (c.endianness == JXL_NATIVE_ENDIAN) {
     // add nothing
   } else if (c.endianness == JXL_BIG_ENDIAN) {
     os << "BE";
   } else if (c.endianness == JXL_LITTLE_ENDIAN) {
     os << "LE";
   }
 }
 if (c.add_container != CodeStreamBoxFormat::kCSBF_None) {
   os << "Box";
   os << static_cast<size_t>(c.add_container);
 }
 if (c.preview_mode == jxl::kSmallPreview) os << "Preview";
 if (c.preview_mode == jxl::kBigPreview) os << "BigPreview";
 if (c.add_intrinsic_size) os << "IntrinicSize";
 if (c.use_callback) os << "Callback";
 if (c.set_buffer_early) os << "EarlyBuffer";
 if (c.use_resizable_runner) os << "ResizableRunner";
 if (c.orientation != 1) os << "O" << c.orientation;
 if (c.keep_orientation) os << "Keep";
 if (c.upsampling > 1) os << "x" << c.upsampling;
 return os;
}

std::string PixelTestDescription(
   const testing::TestParamInfo<DecodeTestParam::ParamType>& info) {
 std::stringstream name;
 name << info.param;
 return name.str();
}

JXL_GTEST_INSTANTIATE_TEST_SUITE_P(DecodeTest, DecodeTestParam,
                                  testing::ValuesIn(GeneratePixelTests()),
                                  PixelTestDescription);

TEST(DecodeTest, PixelTestWithICCProfileLossless) {
 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 size_t xsize = 123;
 size_t ysize = 77;
 size_t num_pixels = xsize * ysize;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 JxlPixelFormat format_orig = {4, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 jxl::TestCodestreamParams params;
 // Lossless to verify pixels exactly after roundtrip.
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 params.add_icc_profile = true;
 // For variation: some have container and no preview, others have preview
 // and no container.
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);

 for (uint32_t channels = 3; channels <= 4; ++channels) {
   {
     JxlPixelFormat format = {channels, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, 0};

     std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
         dec, jxl::Bytes(compressed.data(), compressed.size()), format,
         /*use_callback=*/false, /*set_buffer_early=*/false,
         /*use_resizable_runner=*/false, /*require_boxes=*/false,
         /*expect_success=*/true);
     JxlDecoderReset(dec);
     EXPECT_EQ(num_pixels * channels, pixels2.size());
     EXPECT_EQ(0u,
               jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                        ysize, format_orig, format));
   }
   {
     JxlPixelFormat format = {channels, JXL_TYPE_UINT16, JXL_LITTLE_ENDIAN, 0};

     // Test with the container for one of the pixel formats.
     std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
         dec, jxl::Bytes(compressed.data(), compressed.size()), format,
         /*use_callback=*/true, /*set_buffer_early=*/true,
         /*use_resizable_runner=*/false, /*require_boxes=*/false,
         /*expect_success=*/true);
     JxlDecoderReset(dec);
     EXPECT_EQ(num_pixels * channels * 2, pixels2.size());
     EXPECT_EQ(0u,
               jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                        ysize, format_orig, format));
   }

   {
     JxlPixelFormat format = {channels, JXL_TYPE_FLOAT, JXL_LITTLE_ENDIAN, 0};

     std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
         dec, jxl::Bytes(compressed.data(), compressed.size()), format,
         /*use_callback=*/false, /*set_buffer_early=*/false,
         /*use_resizable_runner=*/false, /*require_boxes=*/false,
         /*expect_success=*/true);
     JxlDecoderReset(dec);
     EXPECT_EQ(num_pixels * channels * 4, pixels2.size());
     EXPECT_EQ(0u,
               jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                        ysize, format_orig, format));
   }
 }

 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, PixelTestWithICCProfileLossy) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 size_t xsize = 123;
 size_t ysize = 77;
 size_t num_pixels = xsize * ysize;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 JxlPixelFormat format_orig = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 jxl::TestCodestreamParams params;
 params.add_icc_profile = true;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);
 uint32_t channels = 3;

 JxlPixelFormat format = {channels, JXL_TYPE_FLOAT, JXL_LITTLE_ENDIAN, 0};

 std::vector<uint8_t> icc_data;
 std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
     dec, jxl::Bytes(compressed.data(), compressed.size()), format,
     /*use_callback=*/false, /*set_buffer_early=*/true,
     /*use_resizable_runner=*/false, /*require_boxes=*/false,
     /*expect_success=*/true, /*icc=*/&icc_data);
 JxlDecoderReset(dec);
 EXPECT_EQ(num_pixels * channels * 4, pixels2.size());

 // The input pixels use the profile matching GetIccTestProfile, since we set
 // add_icc_profile for CreateTestJXLCodestream to true.
 jxl::ColorEncoding color_encoding0;
 EXPECT_TRUE(color_encoding0.SetICC(GetIccTestProfile(), JxlGetDefaultCms()));
 jxl::Span<const uint8_t> span0(pixels.data(), pixels.size());
 jxl::CodecInOut io0{memory_manager};
 ASSERT_TRUE(io0.SetSize(xsize, ysize));
 EXPECT_TRUE(ConvertFromExternal(span0, xsize, ysize, color_encoding0,
                                 /*bits_per_sample=*/16, format_orig,
                                 /*pool=*/nullptr, &io0.Main()));

 jxl::ColorEncoding color_encoding1;
 jxl::IccBytes icc;
 jxl::Bytes(icc_data).AppendTo(icc);
 EXPECT_TRUE(color_encoding1.SetICC(std::move(icc), JxlGetDefaultCms()));
 jxl::Span<const uint8_t> span1(pixels2.data(), pixels2.size());
 jxl::CodecInOut io1{memory_manager};
 ASSERT_TRUE(io1.SetSize(xsize, ysize));
 EXPECT_TRUE(ConvertFromExternal(span1, xsize, ysize, color_encoding1,
                                 /*bits_per_sample=*/32, format,
                                 /*pool=*/nullptr, &io1.Main()));

 jxl::ButteraugliParams butteraugli_params;
 EXPECT_SLIGHTLY_BELOW(
     ButteraugliDistance(io0.frames, io1.frames, butteraugli_params,
                         *JxlGetDefaultCms(),
                         /*distmap=*/nullptr, nullptr),
     0.58f);

 JxlDecoderDestroy(dec);
}

std::string ColorDescription(JxlColorEncoding c) {
 jxl::ColorEncoding color_encoding;
 EXPECT_TRUE(color_encoding.FromExternal(c));
 return Description(color_encoding);
}

std::string GetOrigProfile(JxlDecoder* dec) {
 JxlColorEncoding c;
 JxlColorProfileTarget target = JXL_COLOR_PROFILE_TARGET_ORIGINAL;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetColorAsEncodedProfile(dec, target, &c));
 return ColorDescription(c);
}

std::string GetDataProfile(JxlDecoder* dec) {
 JxlColorEncoding c;
 JxlColorProfileTarget target = JXL_COLOR_PROFILE_TARGET_DATA;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetColorAsEncodedProfile(dec, target, &c));
 return ColorDescription(c);
}

double ButteraugliDistance(size_t xsize, size_t ysize,
                          const std::vector<uint8_t>& pixels_in,
                          const jxl::ColorEncoding& color_in,
                          float intensity_in,
                          const std::vector<uint8_t>& pixels_out,
                          const jxl::ColorEncoding& color_out,
                          float intensity_out) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 jxl::CodecInOut in{memory_manager};
 in.metadata.m.color_encoding = color_in;
 in.metadata.m.SetIntensityTarget(intensity_in);
 JxlPixelFormat format_in = {static_cast<uint32_t>(color_in.Channels()),
                             JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 EXPECT_TRUE(jxl::ConvertFromExternal(
     jxl::Bytes(pixels_in.data(), pixels_in.size()), xsize, ysize, color_in,
     /*bits_per_sample=*/16, format_in,
     /*pool=*/nullptr, &in.Main()));
 jxl::CodecInOut out{memory_manager};
 out.metadata.m.color_encoding = color_out;
 out.metadata.m.SetIntensityTarget(intensity_out);
 JxlPixelFormat format_out = {static_cast<uint32_t>(color_out.Channels()),
                              JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 EXPECT_TRUE(jxl::ConvertFromExternal(
     jxl::Bytes(pixels_out.data(), pixels_out.size()), xsize, ysize, color_out,
     /*bits_per_sample=*/16, format_out,
     /*pool=*/nullptr, &out.Main()));
 return ButteraugliDistance(in.frames, out.frames, jxl::ButteraugliParams(),
                            *JxlGetDefaultCms(), nullptr, nullptr);
}

class DecodeAllEncodingsTest
   : public ::testing::TestWithParam<jxl::test::ColorEncodingDescriptor> {};
JXL_GTEST_INSTANTIATE_TEST_SUITE_P(
   DecodeAllEncodingsTestInstantiation, DecodeAllEncodingsTest,
   ::testing::ValuesIn(jxl::test::AllEncodings()));
TEST_P(DecodeAllEncodingsTest, PreserveOriginalProfileTest) {
 size_t xsize = 123;
 size_t ysize = 77;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 int events = JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FULL_IMAGE;
 const auto& cdesc = GetParam();
 jxl::ColorEncoding c_in = jxl::test::ColorEncodingFromDescriptor(cdesc);
 if (c_in.GetRenderingIntent() != jxl::RenderingIntent::kRelative) return;
 std::string color_space_in = Description(c_in);
 float intensity_in = c_in.Tf().IsPQ() ? 10000 : 255;
 printf("Testing input color space %s\n", color_space_in.c_str());
 jxl::TestCodestreamParams params;
 params.color_space = color_space_in;
 params.intensity_target = intensity_in;
 std::vector<uint8_t> data = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), data.size()));
 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(xsize, info.xsize);
 EXPECT_EQ(ysize, info.ysize);
 EXPECT_FALSE(info.uses_original_profile);
 EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));
 EXPECT_EQ(GetOrigProfile(dec), color_space_in);
 EXPECT_EQ(GetDataProfile(dec), color_space_in);
 EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
 std::vector<uint8_t> out(pixels.size());
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetImageOutBuffer(dec, &format, out.data(), out.size()));
 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 double dist = ButteraugliDistance(xsize, ysize, pixels, c_in, intensity_in,
                                   out, c_in, intensity_in);
 EXPECT_LT(dist, 1.29);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
 JxlDecoderDestroy(dec);
}

namespace {
void SetPreferredColorProfileTest(
   const jxl::test::ColorEncodingDescriptor& from, bool icc_dst,
   bool use_cms) {
 size_t xsize = 123;
 size_t ysize = 77;
 int events = JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FULL_IMAGE;
 jxl::ColorEncoding c_in = jxl::test::ColorEncodingFromDescriptor(from);
 if (c_in.GetRenderingIntent() != jxl::RenderingIntent::kRelative) return;
 if (c_in.GetWhitePointType() != jxl::WhitePoint::kD65) return;
 uint32_t num_channels = c_in.Channels();
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);

 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 std::string color_space_in = Description(c_in);
 float intensity_in = c_in.Tf().IsPQ() ? 10000 : 255;
 jxl::TestCodestreamParams params;
 params.color_space = color_space_in;
 params.intensity_target = intensity_in;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 auto all_encodings = jxl::test::AllEncodings();
 // TODO(firsching): understand why XYB does not work together with icc_dst.
 if (!icc_dst) {
   all_encodings.push_back(
       {jxl::ColorSpace::kXYB, jxl::WhitePoint::kD65, jxl::Primaries::kCustom,
        jxl::TransferFunction::kUnknown, jxl::RenderingIntent::kPerceptual});
 }
 for (const auto& c1 : all_encodings) {
   jxl::ColorEncoding c_out = jxl::test::ColorEncodingFromDescriptor(c1);
   float intensity_out = intensity_in;
   if (c_out.GetColorSpace() != jxl::ColorSpace::kXYB) {
     if (c_out.GetRenderingIntent() != jxl::RenderingIntent::kRelative) {
       continue;
     }
     if ((c_in.GetPrimariesType() == jxl::Primaries::k2100 &&
          c_out.GetPrimariesType() != jxl::Primaries::k2100) ||
         (c_in.GetPrimariesType() == jxl::Primaries::kP3 &&
          c_out.GetPrimariesType() == jxl::Primaries::kSRGB)) {
       // Converting to a narrower gamut does not work without gamut mapping.
       continue;
     }
   }
   if (c_out.Tf().IsHLG() && intensity_out > 300) {
     // The Linear->HLG OOTF function at this intensity level can push
     // saturated colors out of gamut, so we would need gamut mapping in
     // this case too.
     continue;
   }
   std::string color_space_out = Description(c_out);
   if (color_space_in == color_space_out) continue;
   printf("Testing input color space %s with output color space %s\n",
          color_space_in.c_str(), color_space_out.c_str());
   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events));
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetInput(dec, data.data(), data.size()));
   EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
   JxlBasicInfo info;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
   EXPECT_EQ(xsize, info.xsize);
   EXPECT_EQ(ysize, info.ysize);
   EXPECT_FALSE(info.uses_original_profile);
   EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));
   EXPECT_EQ(GetOrigProfile(dec), color_space_in);
   JxlColorEncoding encoding_out;
   EXPECT_TRUE(jxl::ParseDescription(color_space_out, &encoding_out));
   if (c_out.GetColorSpace() == jxl::ColorSpace::kXYB &&
       (c_in.GetPrimariesType() != jxl::Primaries::kSRGB ||
        c_in.Tf().IsPQ())) {
     EXPECT_EQ(JXL_DEC_ERROR,
               JxlDecoderSetPreferredColorProfile(dec, &encoding_out));
     JxlDecoderDestroy(dec);
     continue;
   }
   if (use_cms) {
     JxlDecoderSetCms(dec, *JxlGetDefaultCms());
   }
   if (icc_dst) {
     jxl::ColorEncoding internal_encoding_out;
     EXPECT_TRUE(internal_encoding_out.FromExternal(encoding_out));
     EXPECT_TRUE(internal_encoding_out.CreateICC());
     std::vector<uint8_t> rewritten_icc = internal_encoding_out.ICC();

     EXPECT_EQ(use_cms ? JXL_DEC_SUCCESS : JXL_DEC_ERROR,
               JxlDecoderSetOutputColorProfile(
                   dec, nullptr, rewritten_icc.data(), rewritten_icc.size()));
     if (!use_cms) {
       // continue if we don't have a cms here
       JxlDecoderDestroy(dec);
       continue;
     }
   } else {
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetPreferredColorProfile(dec, &encoding_out));
   }
   EXPECT_EQ(GetOrigProfile(dec), color_space_in);
   if (icc_dst) {
   } else {
     EXPECT_EQ(GetDataProfile(dec), color_space_out);
   }
   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
   size_t buffer_size;
   JxlPixelFormat out_format = format;
   out_format.num_channels = c_out.Channels();
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderImageOutBufferSize(dec, &out_format, &buffer_size));
   std::vector<uint8_t> out(buffer_size);
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &out_format, out.data(), out.size()));
   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   double dist = ButteraugliDistance(xsize, ysize, pixels, c_in, intensity_in,
                                     out, c_out, intensity_out);

   if (c_in.GetWhitePointType() == c_out.GetWhitePointType()) {
     EXPECT_LT(dist, 1.29);
   } else {
     EXPECT_LT(dist, 4.0);
   }
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
   JxlDecoderDestroy(dec);
 }
}
}  // namespace

TEST(DecodeTest, SetPreferredColorProfileTestFromGray) {
 jxl::test::ColorEncodingDescriptor gray = {
     jxl::ColorSpace::kGray, jxl::WhitePoint::kD65, jxl::Primaries::kSRGB,
     jxl::TransferFunction::kSRGB, jxl::RenderingIntent::kRelative};
 SetPreferredColorProfileTest(gray, true, true);
 SetPreferredColorProfileTest(gray, false, true);
 SetPreferredColorProfileTest(gray, true, false);
 SetPreferredColorProfileTest(gray, false, false);
}

static std::string DecodeAllEncodingsVariantsTestName(
   const ::testing::TestParamInfo<
       std::tuple<jxl::test::ColorEncodingDescriptor, bool, bool>>& info) {
 const auto& encoding = std::get<0>(info.param);
 bool icc_dst = std::get<1>(info.param);
 bool use_cms = std::get<2>(info.param);

 std::string encoding_name =
     Description(ColorEncodingFromDescriptor(encoding));

 return "From_" + encoding_name +
        (icc_dst ? "_with_icc_dst" : "_without_icc_dst") +
        (use_cms ? "_with_cms" : "_without_cms");
}

class DecodeAllEncodingsVariantsTest
   : public ::testing::TestWithParam<
         std::tuple<jxl::test::ColorEncodingDescriptor, bool, bool>> {};
JXL_GTEST_INSTANTIATE_TEST_SUITE_P(
   DecodeAllEncodingsVariantsTestInstantiation, DecodeAllEncodingsVariantsTest,
   ::testing::Combine(::testing::ValuesIn(jxl::test::AllEncodings()),
                      ::testing::Bool(), ::testing::Bool()),
   DecodeAllEncodingsVariantsTestName);
TEST_P(DecodeAllEncodingsVariantsTest, SetPreferredColorProfileTest) {
 const auto& from = std::get<0>(GetParam());
 bool icc_dst = std::get<1>(GetParam());
 bool use_cms = std::get<2>(GetParam());
 SetPreferredColorProfileTest(from, icc_dst, use_cms);
}

void DecodeImageWithColorEncoding(const std::vector<uint8_t>& compressed,
                                 jxl::ColorEncoding& color_encoding,
                                 bool with_cms, std::vector<uint8_t>& out,
                                 JxlBasicInfo& info) {
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 int events = JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FULL_IMAGE;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events));
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));
 // TODO(eustas): why unused?
 std::string color_space_in = GetOrigProfile(dec);
 if (with_cms) {
   JxlDecoderSetCms(dec, *JxlGetDefaultCms());
   EXPECT_TRUE(color_encoding.CreateICC());
   std::vector<uint8_t> rewritten_icc = color_encoding.ICC();
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetOutputColorProfile(
                 dec, nullptr, rewritten_icc.data(), rewritten_icc.size()));
 } else {
   JxlColorEncoding external_color_encoding = color_encoding.ToExternal();
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetOutputColorProfile(
                                  dec, &external_color_encoding, nullptr, 0));
 }
 EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

 size_t buffer_size;
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 JxlPixelFormat out_format = format;
 out_format.num_channels = color_encoding.Channels();
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &out_format, &buffer_size));
 out.resize(buffer_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                dec, &out_format, out.data(), out.size()));
 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 JxlDecoderDestroy(dec);
}

class DecodeAllEncodingsWithCMSTest
   : public ::testing::TestWithParam<jxl::test::ColorEncodingDescriptor> {};

JXL_GTEST_INSTANTIATE_TEST_SUITE_P(
   AllEncodings, DecodeAllEncodingsWithCMSTest,
   testing::ValuesIn(jxl::test::AllEncodings()));

TEST_P(DecodeAllEncodingsWithCMSTest, DecodeWithCMS) {
 auto all_encodings = jxl::test::AllEncodings();
 uint32_t num_channels = 3;
 size_t xsize = 177;
 size_t ysize = 123;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);

 jxl::ColorEncoding color_encoding =
     jxl::test::ColorEncodingFromDescriptor(GetParam());
 fprintf(stderr, "color_description: %s\n",
         Description(color_encoding).c_str());

 std::vector<uint8_t> out_with_cms;
 JxlBasicInfo info_with_cms;
 DecodeImageWithColorEncoding(data, color_encoding, true, out_with_cms,
                              info_with_cms);

 std::vector<uint8_t> out_without_cms;
 JxlBasicInfo info_without_cms;
 DecodeImageWithColorEncoding(data, color_encoding, false, out_without_cms,
                              info_without_cms);

 EXPECT_EQ(info_with_cms.xsize, info_without_cms.xsize);
 EXPECT_EQ(info_with_cms.ysize, info_without_cms.ysize);
 EXPECT_EQ(out_with_cms.size(), out_without_cms.size());
 double dist = ButteraugliDistance(xsize, ysize, out_with_cms, color_encoding,
                                   255, out_without_cms, color_encoding, 255);

 EXPECT_LT(dist, .1);
}

// Tests the case of lossy sRGB image without alpha channel, decoded to RGB8
// and to RGBA8
TEST(DecodeTest, PixelTestOpaqueSrgbLossy) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 for (unsigned channels = 3; channels <= 4; channels++) {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   size_t xsize = 123;
   size_t ysize = 77;
   size_t num_pixels = xsize * ysize;
   std::vector<uint8_t> pixels =
       jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
   JxlPixelFormat format_orig = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3,
       jxl::TestCodestreamParams());

   JxlPixelFormat format = {channels, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, 0};

   std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
       dec, jxl::Bytes(compressed.data(), compressed.size()), format,
       /*use_callback=*/true, /*set_buffer_early=*/false,
       /*use_resizable_runner=*/false, /*require_boxes=*/false,
       /*expect_success*/ true);
   JxlDecoderReset(dec);
   EXPECT_EQ(num_pixels * channels, pixels2.size());

   jxl::ColorEncoding color_encoding0 = jxl::ColorEncoding::SRGB(false);
   jxl::Span<const uint8_t> span0(pixels.data(), pixels.size());
   jxl::CodecInOut io0{memory_manager};
   ASSERT_TRUE(io0.SetSize(xsize, ysize));
   EXPECT_TRUE(ConvertFromExternal(span0, xsize, ysize, color_encoding0,
                                   /*bits_per_sample=*/16, format_orig,
                                   /*pool=*/nullptr, &io0.Main()));

   jxl::ColorEncoding color_encoding1 = jxl::ColorEncoding::SRGB(false);
   jxl::Span<const uint8_t> span1(pixels2.data(), pixels2.size());
   jxl::CodecInOut io1{memory_manager};
   EXPECT_TRUE(ConvertFromExternal(span1, xsize, ysize, color_encoding1,
                                   /*bits_per_sample=*/8, format,
                                   /*pool=*/nullptr, &io1.Main()));

   jxl::ButteraugliParams butteraugli_params;
   EXPECT_SLIGHTLY_BELOW(
       ButteraugliDistance(io0.frames, io1.frames, butteraugli_params,
                           *JxlGetDefaultCms(),
                           /*distmap=*/nullptr, nullptr),
       0.6f);

   JxlDecoderDestroy(dec);
 }
}

// Opaque image with noise enabled, decoded to RGB8 and RGBA8.
TEST(DecodeTest, PixelTestOpaqueSrgbLossyNoise) {
 for (unsigned channels = 3; channels <= 4; channels++) {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   size_t xsize = 512;
   size_t ysize = 300;
   size_t num_pixels = xsize * ysize;
   std::vector<uint8_t> pixels =
       jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
   JxlPixelFormat format_orig = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   jxl::TestCodestreamParams params;
   params.cparams.noise = jxl::Override::kOn;
   std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);

   JxlPixelFormat format = {channels, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, 0};

   std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
       dec, jxl::Bytes(compressed.data(), compressed.size()), format,
       /*use_callback=*/false, /*set_buffer_early=*/true,
       /*use_resizable_runner=*/false, /*require_boxes=*/false,
       /*expect_success=*/true);
   JxlDecoderReset(dec);
   EXPECT_EQ(num_pixels * channels, pixels2.size());

   jxl::ColorEncoding color_encoding0 = jxl::ColorEncoding::SRGB(false);
   jxl::Span<const uint8_t> span0(pixels.data(), pixels.size());
   jxl::CodecInOut io0{jxl::test::MemoryManager()};
   ASSERT_TRUE(io0.SetSize(xsize, ysize));
   EXPECT_TRUE(ConvertFromExternal(span0, xsize, ysize, color_encoding0,
                                   /*bits_per_sample=*/16, format_orig,
                                   /*pool=*/nullptr, &io0.Main()));

   jxl::ColorEncoding color_encoding1 = jxl::ColorEncoding::SRGB(false);
   jxl::Span<const uint8_t> span1(pixels2.data(), pixels2.size());
   jxl::CodecInOut io1{jxl::test::MemoryManager()};
   EXPECT_TRUE(ConvertFromExternal(span1, xsize, ysize, color_encoding1,
                                   /*bits_per_sample=*/8, format,
                                   /*pool=*/nullptr, &io1.Main()));

   jxl::ButteraugliParams butteraugli_params;
   EXPECT_SLIGHTLY_BELOW(
       ButteraugliDistance(io0.frames, io1.frames, butteraugli_params,
                           *JxlGetDefaultCms(),
                           /*distmap=*/nullptr, nullptr),
       1.4f);

   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, ProcessEmptyInputWithBoxes) {
 size_t xsize = 123;
 size_t ysize = 77;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 jxl::CompressParams cparams;
 uint32_t channels = 3;
 JxlPixelFormat format = {channels, JXL_TYPE_FLOAT, JXL_LITTLE_ENDIAN, 0};
 for (int i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   jxl::TestCodestreamParams params;
   params.box_format = static_cast<CodeStreamBoxFormat>(i);
   printf("Testing empty input with box format %d\n",
          static_cast<int>(params.box_format));
   std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);
   const int events =
       JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE | JXL_DEC_COLOR_ENCODING;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events));
   EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
   EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
   EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));
   size_t buffer_size;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
   JxlBasicInfo info;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
   const size_t remaining = JxlDecoderReleaseInput(dec);
   EXPECT_LE(remaining, compressed.size());
   EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));
   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, ExtraBytesAfterCompressedStream) {
 size_t xsize = 123;
 size_t ysize = 77;
 size_t num_pixels = xsize * ysize;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 jxl::CompressParams cparams;
 for (int i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   CodeStreamBoxFormat box_format = static_cast<CodeStreamBoxFormat>(i);
   if (box_format == kCSBF_Multi_Other_Zero_Terminated) continue;
   printf("Testing with box format %d\n", static_cast<int>(box_format));
   size_t last_unknown_box_size = 0;
   if (box_format == kCSBF_Single_Other) {
     last_unknown_box_size = unk1_box_size + 8;
   } else if (box_format == kCSBF_Multi_Other_Terminated) {
     last_unknown_box_size = unk3_box_size + 8;
   } else if (box_format == kCSBF_Multi_Last_Empty_Other) {
     // If boxes are not required, the decoder won't consume the last empty
     // jxlp box.
     last_unknown_box_size = 12 + unk3_box_size + 8;
   }
   jxl::TestCodestreamParams params;
   params.box_format = box_format;
   std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);
   // Add some more bytes after compressed data.
   compressed.push_back(0);
   compressed.push_back(1);
   compressed.push_back(2);
   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   uint32_t channels = 3;
   JxlPixelFormat format = {channels, JXL_TYPE_FLOAT, JXL_LITTLE_ENDIAN, 0};
   std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
       dec, jxl::Bytes(compressed.data(), compressed.size()), format,
       /*use_callback=*/false, /*set_buffer_early=*/true,
       /*use_resizable_runner=*/false, /*require_boxes=*/false,
       /*expect_success=*/true);
   size_t unconsumed_bytes = JxlDecoderReleaseInput(dec);
   EXPECT_EQ(last_unknown_box_size + 3, unconsumed_bytes);
   EXPECT_EQ(num_pixels * channels * 4, pixels2.size());
   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, ExtraBytesAfterCompressedStreamRequireBoxes) {
 size_t xsize = 123;
 size_t ysize = 77;
 size_t num_pixels = xsize * ysize;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 jxl::CompressParams cparams;
 for (int i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   CodeStreamBoxFormat box_format = static_cast<CodeStreamBoxFormat>(i);
   if (box_format == kCSBF_Multi_Other_Zero_Terminated) continue;
   printf("Testing with box format %d\n", static_cast<int>(box_format));
   bool expect_success = (box_format == kCSBF_None ||
                          box_format == kCSBF_Single_Zero_Terminated ||
                          box_format == kCSBF_Multi_Zero_Terminated);
   jxl::TestCodestreamParams params;
   params.box_format = box_format;
   std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);
   // Add some more bytes after compressed data.
   compressed.push_back(0);
   compressed.push_back(1);
   compressed.push_back(2);
   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   uint32_t channels = 3;
   JxlPixelFormat format = {channels, JXL_TYPE_FLOAT, JXL_LITTLE_ENDIAN, 0};
   std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
       dec, jxl::Bytes(compressed.data(), compressed.size()), format,
       /*use_callback=*/false, /*set_buffer_early=*/true,
       /*use_resizable_runner=*/false, /*require_boxes=*/true, expect_success);
   size_t unconsumed_bytes = JxlDecoderReleaseInput(dec);
   EXPECT_EQ(3, unconsumed_bytes);
   EXPECT_EQ(num_pixels * channels * 4, pixels2.size());
   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, ConcatenatedCompressedStreams) {
 size_t xsize = 123;
 size_t ysize = 77;
 size_t num_pixels = xsize * ysize;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 jxl::CompressParams cparams;
 for (int i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   CodeStreamBoxFormat first_box_format = static_cast<CodeStreamBoxFormat>(i);
   if (first_box_format == kCSBF_Multi_Other_Zero_Terminated) continue;
   jxl::TestCodestreamParams params1;
   params1.box_format = first_box_format;
   std::vector<uint8_t> compressed1 = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params1);
   for (int j = 0; j < kCSBF_NUM_ENTRIES; ++j) {
     CodeStreamBoxFormat second_box_format =
         static_cast<CodeStreamBoxFormat>(j);
     if (second_box_format == kCSBF_Multi_Other_Zero_Terminated) continue;
     printf("Testing with box format pair %d, %d\n",
            static_cast<int>(first_box_format),
            static_cast<int>(second_box_format));
     jxl::TestCodestreamParams params2;
     params2.box_format = second_box_format;
     std::vector<uint8_t> compressed2 = jxl::CreateTestJXLCodestream(
         jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params2);
     std::vector<uint8_t> concat;
     jxl::Bytes(compressed1).AppendTo(concat);
     jxl::Bytes(compressed2).AppendTo(concat);
     uint32_t channels = 3;
     JxlPixelFormat format = {channels, JXL_TYPE_FLOAT, JXL_LITTLE_ENDIAN, 0};
     size_t remaining = concat.size();
     for (int part = 0; part < 2; ++part) {
       printf("  Decoding part %d\n", part + 1);
       JxlDecoder* dec = JxlDecoderCreate(nullptr);
       size_t pos = concat.size() - remaining;
       bool expect_success =
           (part == 0 || second_box_format == kCSBF_None ||
            second_box_format == kCSBF_Single_Zero_Terminated ||
            second_box_format == kCSBF_Multi_Zero_Terminated);
       std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
           dec, jxl::Bytes(concat.data() + pos, remaining), format,
           /*use_callback=*/false, /*set_buffer_early=*/true,
           /*use_resizable_runner=*/false, /*require_boxes=*/true,
           expect_success);
       EXPECT_EQ(num_pixels * channels * 4, pixels2.size());
       remaining = JxlDecoderReleaseInput(dec);
       JxlDecoderDestroy(dec);
     }
     EXPECT_EQ(0, remaining);
   }
 }
}

void TestPartialStream(bool reconstructible_jpeg) {
 size_t xsize = 123;
 size_t ysize = 77;
 uint32_t channels = 4;
 if (reconstructible_jpeg) {
   channels = 3;
 }
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, channels, 0);
 JxlPixelFormat format_orig = {channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 jxl::TestCodestreamParams params;
 if (reconstructible_jpeg) {
   params.cparams.color_transform = jxl::ColorTransform::kNone;
 } else {
   // Lossless to verify pixels exactly after roundtrip.
   params.cparams.SetLossless();
 }

 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());

 std::vector<uint8_t> jpeg_output(64);
 size_t used_jpeg_output = 0;

 std::vector<std::vector<uint8_t>> codestreams(kCSBF_NUM_ENTRIES);
 std::vector<std::vector<uint8_t>> jpeg_codestreams(kCSBF_NUM_ENTRIES);
 for (size_t i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   params.box_format = static_cast<CodeStreamBoxFormat>(i);
   if (reconstructible_jpeg) {
     params.jpeg_codestream = &jpeg_codestreams[i];
   }
   codestreams[i] =
       jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                    xsize, ysize, channels, params);
 }

 // Test multiple step sizes, to test different combinations of the streaming
 // box parsing.
 std::vector<size_t> increments = {1, 3, 17, 23, 120, 700, 1050};

 for (size_t increment : increments) {
   for (size_t i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
     if (reconstructible_jpeg && static_cast<CodeStreamBoxFormat>(i) ==
                                     CodeStreamBoxFormat::kCSBF_None) {
       continue;
     }
     const std::vector<uint8_t>& data = codestreams[i];
     const uint8_t* next_in = data.data();
     size_t avail_in = 0;

     JxlDecoder* dec = JxlDecoderCreate(nullptr);

     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSubscribeEvents(
                   dec, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE |
                            JXL_DEC_JPEG_RECONSTRUCTION));

     bool seen_basic_info = false;
     bool seen_full_image = false;
     bool seen_jpeg_recon = false;

     size_t total_size = 0;

     for (;;) {
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
       JxlDecoderStatus status = JxlDecoderProcessInput(dec);
       size_t remaining = JxlDecoderReleaseInput(dec);
       EXPECT_LE(remaining, avail_in);
       next_in += avail_in - remaining;
       avail_in = remaining;
       if (status == JXL_DEC_NEED_MORE_INPUT) {
         if (total_size >= data.size()) {
           // End of test data reached, it should have successfully decoded the
           // image now.
           FAIL();
           break;
         }

         // End of the file reached, should be the final test.
         if (total_size + increment > data.size()) {
           increment = data.size() - total_size;
         }
         total_size += increment;
         avail_in += increment;
       } else if (status == JXL_DEC_BASIC_INFO) {
         // This event should happen exactly once
         EXPECT_FALSE(seen_basic_info);
         if (seen_basic_info) break;
         seen_basic_info = true;
         JxlBasicInfo info;
         EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
         EXPECT_EQ(info.xsize, xsize);
         EXPECT_EQ(info.ysize, ysize);
       } else if (status == JXL_DEC_JPEG_RECONSTRUCTION) {
         EXPECT_FALSE(seen_basic_info);
         EXPECT_FALSE(seen_full_image);
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetJPEGBuffer(dec, jpeg_output.data(),
                                           jpeg_output.size()));
         seen_jpeg_recon = true;
       } else if (status == JXL_DEC_JPEG_NEED_MORE_OUTPUT) {
         EXPECT_TRUE(seen_jpeg_recon);
         used_jpeg_output =
             jpeg_output.size() - JxlDecoderReleaseJPEGBuffer(dec);
         jpeg_output.resize(jpeg_output.size() * 2);
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetJPEGBuffer(
                       dec, jpeg_output.data() + used_jpeg_output,
                       jpeg_output.size() - used_jpeg_output));
       } else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetImageOutBuffer(
                       dec, &format_orig, pixels2.data(), pixels2.size()));
       } else if (status == JXL_DEC_FULL_IMAGE) {
         // This event should happen exactly once
         EXPECT_FALSE(seen_full_image);
         if (seen_full_image) break;
         // This event should happen after basic info
         EXPECT_TRUE(seen_basic_info);
         seen_full_image = true;
         if (reconstructible_jpeg) {
           used_jpeg_output =
               jpeg_output.size() - JxlDecoderReleaseJPEGBuffer(dec);
           EXPECT_EQ(used_jpeg_output, jpeg_codestreams[i].size());
           EXPECT_EQ(0, memcmp(jpeg_output.data(), jpeg_codestreams[i].data(),
                               used_jpeg_output));
         } else {
           EXPECT_EQ(pixels, pixels2);
         }
       } else if (status == JXL_DEC_SUCCESS) {
         EXPECT_TRUE(seen_full_image);
         break;
       } else {
         // We do not expect any other events or errors
         FAIL();
         break;
       }
     }

     // Ensure the decoder emitted the basic info and full image events
     EXPECT_TRUE(seen_basic_info);
     EXPECT_TRUE(seen_full_image);

     JxlDecoderDestroy(dec);
   }
 }
}

// Tests the return status when trying to decode pixels on incomplete file: it
// should return JXL_DEC_NEED_MORE_INPUT, not error.
TEST(DecodeTest, PixelPartialTest) { TestPartialStream(false); }

// Tests the return status when trying to decode JPEG bytes on incomplete file.
JXL_TRANSCODE_JPEG_TEST(DecodeTest, JPEGPartialTest) {
 TEST_LIBJPEG_SUPPORT();
 TestPartialStream(true);
}

// The DC event still exists, but is no longer implemented, it is deprecated.
TEST(DecodeTest, DCNotGettableTest) {
 // 1x1 pixel JXL image
 std::string compressed(
     "\377\n\0\20\260\23\0H\200("
     "\0\334\0U\17\0\0\250P\31e\334\340\345\\\317\227\37:,"
     "\246m\\gh\253m\vK\22E\306\261I\252C&pH\22\353 "
     "\363\6\22\bp\0\200\237\34\231W2d\255$\1",
     68);

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO));
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(
               dec, reinterpret_cast<const uint8_t*>(compressed.data()),
               compressed.size()));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));

 // Since the image is only 1x1 pixel, there is only 1 group, the decoder is
 // unable to get DC size from this, and will not return the DC at all. Since
 // no full image is requested either, it is expected to return success.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, PreviewTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 77;
 size_t ysize = 120;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 JxlPixelFormat format_orig = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 for (jxl::PreviewMode mode : {jxl::kSmallPreview, jxl::kBigPreview}) {
   jxl::TestCodestreamParams params;
   params.preview_mode = mode;

   std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 3, params);

   JxlPixelFormat format = {3, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, 0};

   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   const uint8_t* next_in = compressed.data();
   size_t avail_in = compressed.size();

   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSubscribeEvents(
                 dec, JXL_DEC_BASIC_INFO | JXL_DEC_PREVIEW_IMAGE));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

   EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
   JxlBasicInfo info;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
   size_t buffer_size;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderPreviewOutBufferSize(dec, &format, &buffer_size));

   jxl::ColorEncoding c_srgb = jxl::ColorEncoding::SRGB(false);
   jxl::CodecInOut io0{memory_manager};
   EXPECT_TRUE(jxl::ConvertFromExternal(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, c_srgb,
       /*bits_per_sample=*/16, format_orig, /*pool=*/nullptr, &io0.Main()));
   GeneratePreview(params.preview_mode, &io0.Main());

   size_t xsize_preview = io0.Main().xsize();
   size_t ysize_preview = io0.Main().ysize();
   EXPECT_EQ(xsize_preview, info.preview.xsize);
   EXPECT_EQ(ysize_preview, info.preview.ysize);
   EXPECT_EQ(xsize_preview * ysize_preview * 3, buffer_size);

   EXPECT_EQ(JXL_DEC_NEED_PREVIEW_OUT_BUFFER, JxlDecoderProcessInput(dec));

   std::vector<uint8_t> preview(buffer_size);
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetPreviewOutBuffer(dec, &format, preview.data(),
                                           preview.size()));

   EXPECT_EQ(JXL_DEC_PREVIEW_IMAGE, JxlDecoderProcessInput(dec));

   jxl::CodecInOut io1{memory_manager};
   EXPECT_TRUE(
       jxl::ConvertFromExternal(jxl::Bytes(preview.data(), preview.size()),
                                xsize_preview, ysize_preview, c_srgb,
                                /*bits_per_sample=*/8, format,
                                /*pool=*/nullptr, &io1.Main()));

   jxl::ButteraugliParams butteraugli_params;
   // TODO(lode): this ButteraugliDistance silently returns 0 (dangerous for
   // tests) if xsize or ysize is < 8, no matter how different the images, a
   // tiny size that could happen for a preview. ButteraugliDiffmap does
   // support smaller than 8x8, but jxl's ButteraugliDistance does not. Perhaps
   // move butteraugli's <8x8 handling from ButteraugliDiffmap to
   // ButteraugliComparator::Diffmap in butteraugli.cc.
   EXPECT_LE(ButteraugliDistance(io0.frames, io1.frames, butteraugli_params,
                                 *JxlGetDefaultCms(),
                                 /*distmap=*/nullptr, nullptr),
             mode == jxl::kSmallPreview ? 0.7f : 1.2f);

   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, AlignTest) {
 size_t xsize = 123;
 size_t ysize = 77;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 JxlPixelFormat format_orig = {4, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::TestCodestreamParams params;
 // Lossless to verify pixels exactly after roundtrip.
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);

 size_t align = 17;
 JxlPixelFormat format = {3, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, align};
 // On purpose not using jxl::RoundUpTo to test it independently.
 size_t expected_line_size_last = 1 * 3 * xsize;
 size_t expected_line_size =
     ((expected_line_size_last + align - 1) / align) * align;
 size_t expected_pixels_size =
     expected_line_size * (ysize - 1) + expected_line_size_last;

 for (bool use_callback : {false, true}) {
   std::vector<uint8_t> pixels2 = jxl::DecodeWithAPI(
       jxl::Bytes(compressed.data(), compressed.size()), format, use_callback,
       /*set_buffer_early=*/false,
       /*use_resizable_runner=*/false, /*require_boxes=*/false,
       /*expect_success=*/true);
   EXPECT_EQ(expected_pixels_size, pixels2.size());
   EXPECT_EQ(0u, jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                          ysize, format_orig, format));
 }
}

TEST(DecodeTest, AnimationTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 123;
 size_t ysize = 77;
 static const size_t num_frames = 2;
 std::vector<uint8_t> frames[2];
 frames[0] = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 frames[1] = jxl::test::GetSomeTestImage(xsize, ysize, 3, 1);
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::CodecInOut io{memory_manager};
 ASSERT_TRUE(io.SetSize(xsize, ysize));
 io.metadata.m.SetUintSamples(16);
 io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
 io.metadata.m.have_animation = true;
 io.frames.clear();
 io.frames.reserve(num_frames);
 ASSERT_TRUE(io.SetSize(xsize, ysize));

 std::vector<uint32_t> frame_durations(num_frames);
 for (size_t i = 0; i < num_frames; ++i) {
   frame_durations[i] = 5 + i;
 }

 for (size_t i = 0; i < num_frames; ++i) {
   jxl::ImageBundle bundle(memory_manager, &io.metadata.m);

   EXPECT_TRUE(ConvertFromExternal(
       jxl::Bytes(frames[i].data(), frames[i].size()), xsize, ysize,
       jxl::ColorEncoding::SRGB(/*is_gray=*/false),
       /*bits_per_sample=*/16, format,
       /*pool=*/nullptr, &bundle));
   bundle.duration = frame_durations[i];
   io.frames.push_back(std::move(bundle));
 }

 jxl::CompressParams cparams;
 cparams.SetLossless();  // Lossless to verify pixels exactly after roundtrip.
 cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

 // Decode and test the animation frames

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 const uint8_t* next_in = compressed.data();
 size_t avail_in = compressed.size();

 void* runner = JxlThreadParallelRunnerCreate(
     nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetParallelRunner(dec, JxlThreadParallelRunner, runner));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));

 for (size_t i = 0; i < num_frames; ++i) {
   std::vector<uint8_t> pixels(buffer_size);

   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);
   EXPECT_EQ(0u, frame_header.name_length);
   // For now, test with empty name, there's currently no easy way to encode
   // a jxl file with a frame name because ImageBundle doesn't have a
   // jxl::FrameHeader to set the name in. We can test the null termination
   // character though.
   char name;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameName(dec, &name, 1));
   EXPECT_EQ(0, name);

   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                          xsize, ysize, format, format));
 }

 // After all frames were decoded, JxlDecoderProcessInput should return
 // success to indicate all is done.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 JxlThreadParallelRunnerDestroy(runner);
 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, AnimationTestStreaming) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 123;
 size_t ysize = 77;
 static const size_t num_frames = 2;
 std::vector<uint8_t> frames[2];
 frames[0] = jxl::test::GetSomeTestImage(xsize, ysize, 3, 0);
 frames[1] = jxl::test::GetSomeTestImage(xsize, ysize, 3, 1);
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::CodecInOut io{memory_manager};
 ASSERT_TRUE(io.SetSize(xsize, ysize));
 io.metadata.m.SetUintSamples(16);
 io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
 io.metadata.m.have_animation = true;
 io.frames.clear();
 io.frames.reserve(num_frames);
 ASSERT_TRUE(io.SetSize(xsize, ysize));

 std::vector<uint32_t> frame_durations(num_frames);
 for (size_t i = 0; i < num_frames; ++i) {
   frame_durations[i] = 5 + i;
 }

 for (size_t i = 0; i < num_frames; ++i) {
   jxl::ImageBundle bundle(memory_manager, &io.metadata.m);

   EXPECT_TRUE(ConvertFromExternal(
       jxl::Bytes(frames[i].data(), frames[i].size()), xsize, ysize,
       jxl::ColorEncoding::SRGB(/*is_gray=*/false),
       /*bits_per_sample=*/16, format,
       /*pool=*/nullptr, &bundle));
   bundle.duration = frame_durations[i];
   io.frames.push_back(std::move(bundle));
 }

 jxl::CompressParams cparams;
 cparams.SetLossless();  // Lossless to verify pixels exactly after roundtrip.
 cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

 // Decode and test the animation frames

 const size_t step_size = 16;

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 const uint8_t* next_in = compressed.data();
 size_t avail_in = 0;
 size_t frame_headers_seen = 0;
 size_t frames_seen = 0;
 bool seen_basic_info = false;

 void* runner = JxlThreadParallelRunnerCreate(
     nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetParallelRunner(dec, JxlThreadParallelRunner, runner));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));

 std::vector<uint8_t> frames2[2];
 for (size_t i = 0; i < num_frames; ++i) {
   frames2[i].resize(frames[i].size());
 }

 size_t total_in = 0;
 size_t loop_count = 0;

 for (;;) {
   if (loop_count++ > compressed.size()) {
     fprintf(stderr, "Too many loops\n");
     FAIL();
     break;
   }

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
   auto status = JxlDecoderProcessInput(dec);
   size_t remaining = JxlDecoderReleaseInput(dec);
   EXPECT_LE(remaining, avail_in);
   next_in += avail_in - remaining;
   avail_in = remaining;

   if (status == JXL_DEC_SUCCESS) {
     break;
   } else if (status == JXL_DEC_ERROR) {
     FAIL();
   } else if (status == JXL_DEC_NEED_MORE_INPUT) {
     if (total_in >= compressed.size()) {
       fprintf(stderr, "Already gave all input data\n");
       FAIL();
       break;
     }
     size_t amount = step_size;
     if (total_in + amount > compressed.size()) {
       amount = compressed.size() - total_in;
     }
     avail_in += amount;
     total_in += amount;
   } else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                    dec, &format, frames2[frames_seen].data(),
                                    frames2[frames_seen].size()));
   } else if (status == JXL_DEC_BASIC_INFO) {
     EXPECT_EQ(false, seen_basic_info);
     seen_basic_info = true;
     JxlBasicInfo info;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
     EXPECT_EQ(xsize, info.xsize);
     EXPECT_EQ(ysize, info.ysize);
   } else if (status == JXL_DEC_FRAME) {
     EXPECT_EQ(true, seen_basic_info);
     frame_headers_seen++;
   } else if (status == JXL_DEC_FULL_IMAGE) {
     frames_seen++;
     EXPECT_EQ(frame_headers_seen, frames_seen);
   } else {
     fprintf(stderr, "Unexpected status: %d\n", static_cast<int>(status));
     FAIL();
   }
 }

 EXPECT_EQ(true, seen_basic_info);
 EXPECT_EQ(num_frames, frames_seen);
 EXPECT_EQ(num_frames, frame_headers_seen);
 for (size_t i = 0; i < num_frames; ++i) {
   EXPECT_EQ(frames[i], frames2[i]);
 }

 JxlThreadParallelRunnerDestroy(runner);
 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, ExtraChannelTest) {
 size_t xsize = 55;
 size_t ysize = 257;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 JxlPixelFormat format_orig = {4, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::TestCodestreamParams params;
 // Lossless to verify pixels exactly after roundtrip.
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);

 size_t align = 17;
 JxlPixelFormat format = {3, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, align};

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(
                                dec, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(1u, info.num_extra_channels);
 EXPECT_EQ(JXL_FALSE, info.alpha_premultiplied);

 JxlExtraChannelInfo extra_info;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderGetExtraChannelInfo(dec, 0, &extra_info));
 EXPECT_EQ(0, extra_info.type);

 EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 size_t extra_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderExtraChannelBufferSize(dec, &format, &extra_size, 0));

 std::vector<uint8_t> image(buffer_size);
 std::vector<uint8_t> extra(extra_size);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                dec, &format, image.data(), image.size()));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetExtraChannelBuffer(
                                dec, &format, extra.data(), extra.size(), 0));

 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));

 // After the full image was output, JxlDecoderProcessInput should return
 // success to indicate all is done.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
 JxlDecoderDestroy(dec);

 EXPECT_EQ(0u, jxl::test::ComparePixels(pixels.data(), image.data(), xsize,
                                        ysize, format_orig, format));

 // Compare the extracted extra channel with the original alpha channel

 std::vector<uint8_t> alpha(pixels.size() / 4);
 for (size_t i = 0; i < pixels.size(); i += 8) {
   size_t index_alpha = i / 4;
   alpha[index_alpha + 0] = pixels[i + 6];
   alpha[index_alpha + 1] = pixels[i + 7];
 }
 JxlPixelFormat format_alpha = format;
 format_alpha.num_channels = 1;
 JxlPixelFormat format_orig_alpha = format_orig;
 format_orig_alpha.num_channels = 1;

 EXPECT_EQ(0u,
           jxl::test::ComparePixels(alpha.data(), extra.data(), xsize, ysize,
                                    format_orig_alpha, format_alpha));
}

TEST(DecodeTest, SkipCurrentFrameTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 90;
 size_t ysize = 120;
 constexpr size_t num_frames = 7;
 std::vector<uint8_t> frames[num_frames];
 for (size_t i = 0; i < num_frames; i++) {
   frames[i] = jxl::test::GetSomeTestImage(xsize, ysize, 3, i);
 }
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::CodecInOut io{memory_manager};
 ASSERT_TRUE(io.SetSize(xsize, ysize));
 io.metadata.m.SetUintSamples(16);
 io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
 io.metadata.m.have_animation = true;
 io.frames.clear();
 io.frames.reserve(num_frames);
 ASSERT_TRUE(io.SetSize(xsize, ysize));

 std::vector<uint32_t> frame_durations(num_frames);
 for (size_t i = 0; i < num_frames; ++i) {
   frame_durations[i] = 5 + i;
 }

 for (size_t i = 0; i < num_frames; ++i) {
   jxl::ImageBundle bundle(memory_manager, &io.metadata.m);
   if (i & 1) {
     // Mark some frames as referenceable, others not.
     bundle.use_for_next_frame = true;
   }

   EXPECT_TRUE(ConvertFromExternal(
       jxl::Bytes(frames[i].data(), frames[i].size()), xsize, ysize,
       jxl::ColorEncoding::SRGB(/*is_gray=*/false),
       /*bits_per_sample=*/16, format,
       /*pool=*/nullptr, &bundle));
   bundle.duration = frame_durations[i];
   io.frames.push_back(std::move(bundle));
 }

 jxl::CompressParams cparams;
 cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed;
 jxl::PassDefinition passes[] = {{2, 0, 4}, {4, 0, 4}, {8, 2, 2}, {8, 0, 1}};
 jxl::ProgressiveMode progressive_mode{passes};
 cparams.custom_progressive_mode = &progressive_mode;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 const uint8_t* next_in = compressed.data();
 size_t avail_in = compressed.size();

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME |
                                              JXL_DEC_FRAME_PROGRESSION |
                                              JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetProgressiveDetail(dec, kLastPasses));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));

 for (size_t i = 0; i < num_frames; ++i) {
   printf("Decoding frame %d\n", static_cast<int>(i));
   EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderSkipCurrentFrame(dec));
   std::vector<uint8_t> pixels(buffer_size);
   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));
   EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderSkipCurrentFrame(dec));
   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);
   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);
   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));
   if (i == 2) {
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSkipCurrentFrame(dec));
     continue;
   }
   EXPECT_EQ(JXL_DEC_FRAME_PROGRESSION, JxlDecoderProcessInput(dec));
   EXPECT_EQ(8, JxlDecoderGetIntendedDownsamplingRatio(dec));
   if (i == 3) {
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSkipCurrentFrame(dec));
     continue;
   }
   EXPECT_EQ(JXL_DEC_FRAME_PROGRESSION, JxlDecoderProcessInput(dec));
   EXPECT_EQ(4, JxlDecoderGetIntendedDownsamplingRatio(dec));
   if (i == 4) {
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSkipCurrentFrame(dec));
     continue;
   }
   EXPECT_EQ(JXL_DEC_FRAME_PROGRESSION, JxlDecoderProcessInput(dec));
   EXPECT_EQ(2, JxlDecoderGetIntendedDownsamplingRatio(dec));
   if (i == 5) {
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSkipCurrentFrame(dec));
     continue;
   }
   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderSkipCurrentFrame(dec));
 }

 // After all frames were decoded, JxlDecoderProcessInput should return
 // success to indicate all is done.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, SkipFrameTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 90;
 size_t ysize = 120;
 constexpr size_t num_frames = 16;
 std::vector<uint8_t> frames[num_frames];
 for (size_t i = 0; i < num_frames; i++) {
   frames[i] = jxl::test::GetSomeTestImage(xsize, ysize, 3, i);
 }
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::CodecInOut io{memory_manager};
 ASSERT_TRUE(io.SetSize(xsize, ysize));
 io.metadata.m.SetUintSamples(16);
 io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
 io.metadata.m.have_animation = true;
 io.frames.clear();
 io.frames.reserve(num_frames);
 ASSERT_TRUE(io.SetSize(xsize, ysize));

 std::vector<uint32_t> frame_durations(num_frames);
 for (size_t i = 0; i < num_frames; ++i) {
   frame_durations[i] = 5 + i;
 }

 for (size_t i = 0; i < num_frames; ++i) {
   jxl::ImageBundle bundle(memory_manager, &io.metadata.m);
   if (i & 1) {
     // Mark some frames as referenceable, others not.
     bundle.use_for_next_frame = true;
   }

   EXPECT_TRUE(ConvertFromExternal(
       jxl::Bytes(frames[i].data(), frames[i].size()), xsize, ysize,
       jxl::ColorEncoding::SRGB(/*is_gray=*/false),
       /*bits_per_sample=*/16, format,
       /*pool=*/nullptr, &bundle));
   bundle.duration = frame_durations[i];
   io.frames.push_back(std::move(bundle));
 }

 jxl::CompressParams cparams;
 cparams.SetLossless();  // Lossless to verify pixels exactly after roundtrip.
 cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

 // Decode and test the animation frames

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 const uint8_t* next_in = compressed.data();
 size_t avail_in = compressed.size();

 void* runner = JxlThreadParallelRunnerCreate(
     nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetParallelRunner(dec, JxlThreadParallelRunner, runner));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));

 for (size_t i = 0; i < num_frames; ++i) {
   if (i == 3) {
     JxlDecoderSkipFrames(dec, 5);
     i += 5;
   }
   std::vector<uint8_t> pixels(buffer_size);

   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);

   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                          xsize, ysize, format, format));
 }

 // After all frames were decoded, JxlDecoderProcessInput should return
 // success to indicate all is done.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 // Test rewinding the decoder and skipping different frames

 JxlDecoderRewind(dec);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

 for (size_t i = 0; i < num_frames; ++i) {
   int test_skipping = (i == 9) ? 3 : 0;
   std::vector<uint8_t> pixels(buffer_size);

   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

   // Since this is after JXL_DEC_FRAME but before JXL_DEC_FULL_IMAGE, this
   // should only skip the next frame, not the currently processed one.
   if (test_skipping) JxlDecoderSkipFrames(dec, test_skipping);

   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);

   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                          xsize, ysize, format, format));

   if (test_skipping) i += test_skipping;
 }

 JxlThreadParallelRunnerDestroy(runner);
 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, SkipFrameWithBlendingTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 90;
 size_t ysize = 120;
 constexpr size_t num_frames = 16;
 std::vector<uint8_t> frames[num_frames];
 JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::CodecInOut io{memory_manager};
 ASSERT_TRUE(io.SetSize(xsize, ysize));
 io.metadata.m.SetUintSamples(16);
 io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
 io.metadata.m.have_animation = true;
 io.frames.clear();
 io.frames.reserve(num_frames);
 ASSERT_TRUE(io.SetSize(xsize, ysize));

 std::vector<uint32_t> frame_durations(num_frames);

 for (size_t i = 0; i < num_frames; ++i) {
   if (i < 5) {
     std::vector<uint8_t> frame_internal =
         jxl::test::GetSomeTestImage(xsize, ysize, 3, i * 2 + 1);
     // An internal frame with 0 duration, and use_for_next_frame, this is a
     // frame that is not rendered and not output by the API, but on which the
     // rendered frames depend
     jxl::ImageBundle bundle_internal(memory_manager, &io.metadata.m);
     EXPECT_TRUE(ConvertFromExternal(
         jxl::Bytes(frame_internal.data(), frame_internal.size()), xsize,
         ysize, jxl::ColorEncoding::SRGB(/*is_gray=*/false),
         /*bits_per_sample=*/16, format,
         /*pool=*/nullptr, &bundle_internal));
     bundle_internal.duration = 0;
     bundle_internal.use_for_next_frame = true;
     io.frames.push_back(std::move(bundle_internal));
   }

   std::vector<uint8_t> frame =
       jxl::test::GetSomeTestImage(xsize, ysize, 3, i * 2);
   // Actual rendered frame
   frame_durations[i] = 5 + i;
   jxl::ImageBundle bundle(memory_manager, &io.metadata.m);
   EXPECT_TRUE(ConvertFromExternal(jxl::Bytes(frame.data(), frame.size()),
                                   xsize, ysize,
                                   jxl::ColorEncoding::SRGB(/*is_gray=*/false),
                                   /*bits_per_sample=*/16, format,
                                   /*pool=*/nullptr, &bundle));
   bundle.duration = frame_durations[i];
   // Create some variation in which frames depend on which.
   if (i != 3 && i != 9 && i != 10) {
     bundle.use_for_next_frame = true;
   }
   if (i != 12) {
     bundle.blend = true;
     // Choose a blend mode that depends on the pixels of the saved frame and
     // doesn't use alpha
     bundle.blendmode = jxl::BlendMode::kMul;
   }
   io.frames.push_back(std::move(bundle));
 }

 jxl::CompressParams cparams;
 cparams.SetLossless();  // Lossless to verify pixels exactly after roundtrip.
 cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

 // Independently decode all frames without any skipping, to create the
 // expected blended frames, for the actual tests below to compare with.
 {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   const uint8_t* next_in = compressed.data();
   size_t avail_in = compressed.size();

   void* runner = JxlThreadParallelRunnerCreate(
       nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetParallelRunner(
                                  dec, JxlThreadParallelRunner, runner));
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSubscribeEvents(dec, JXL_DEC_FULL_IMAGE));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
   for (auto& frame : frames) {
     EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
     frame.resize(xsize * ysize * 6);
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                    dec, &format, frame.data(), frame.size()));
     EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   }

   // After all frames were decoded, JxlDecoderProcessInput should return
   // success to indicate all is done.
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
   JxlThreadParallelRunnerDestroy(runner);
   JxlDecoderDestroy(dec);
 }

 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 const uint8_t* next_in = compressed.data();
 size_t avail_in = compressed.size();

 void* runner = JxlThreadParallelRunnerCreate(
     nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetParallelRunner(dec, JxlThreadParallelRunner, runner));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));

 for (size_t i = 0; i < num_frames; ++i) {
   std::vector<uint8_t> pixels(buffer_size);

   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);

   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                          xsize, ysize, format, format));

   // Test rewinding mid-way, not decoding all frames.
   if (i == 8) {
     break;
   }
 }

 JxlDecoderRewind(dec);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

 for (size_t i = 0; i < num_frames; ++i) {
   if (i == 3) {
     JxlDecoderSkipFrames(dec, 5);
     i += 5;
   }
   std::vector<uint8_t> pixels(buffer_size);

   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);

   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                          xsize, ysize, format, format));
 }

 // After all frames were decoded, JxlDecoderProcessInput should return
 // success to indicate all is done.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 // Test rewinding the decoder and skipping different frames

 JxlDecoderRewind(dec);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

 for (size_t i = 0; i < num_frames; ++i) {
   int test_skipping = (i == 9) ? 3 : 0;
   std::vector<uint8_t> pixels(buffer_size);

   EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

   // Since this is after JXL_DEC_FRAME but before JXL_DEC_FULL_IMAGE, this
   // should only skip the next frame, not the currently processed one.
   if (test_skipping) JxlDecoderSkipFrames(dec, test_skipping);

   JxlFrameHeader frame_header;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
   EXPECT_EQ(frame_durations[i], frame_header.duration);

   EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, pixels.data(), pixels.size()));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                          xsize, ysize, format, format));

   if (test_skipping) i += test_skipping;
 }

 JxlThreadParallelRunnerDestroy(runner);
 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, SkipFrameWithAlphaBlendingTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 size_t xsize = 90;
 size_t ysize = 120;
 constexpr size_t num_frames = 16;
 std::vector<uint8_t> frames[num_frames + 5];
 JxlPixelFormat format = {4, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 jxl::CodecInOut io{memory_manager};
 ASSERT_TRUE(io.SetSize(xsize, ysize));
 io.metadata.m.SetUintSamples(16);
 io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
 io.metadata.m.have_animation = true;
 io.frames.clear();
 io.frames.reserve(num_frames + 5);
 ASSERT_TRUE(io.SetSize(xsize, ysize));

 std::vector<uint32_t> frame_durations_c;
 std::vector<uint32_t> frame_durations_nc;
 std::vector<uint32_t> frame_xsize;
 std::vector<uint32_t> frame_ysize;
 std::vector<uint32_t> frame_x0;
 std::vector<uint32_t> frame_y0;

 for (size_t i = 0; i < num_frames; ++i) {
   size_t cropxsize = 1 + xsize * 2 / (i + 1);
   size_t cropysize = 1 + ysize * 3 / (i + 2);
   int cropx0 = i * 3 - 8;
   int cropy0 = i * 4 - 7;
   if (i < 5) {
     std::vector<uint8_t> frame_internal =
         jxl::test::GetSomeTestImage(xsize / 2, ysize / 2, 4, i * 2 + 1);
     // An internal frame with 0 duration, and use_for_next_frame, this is a
     // frame that is not rendered and not output by default by the API, but on
     // which the rendered frames depend
     jxl::ImageBundle bundle_internal(memory_manager, &io.metadata.m);
     EXPECT_TRUE(ConvertFromExternal(
         jxl::Bytes(frame_internal.data(), frame_internal.size()), xsize / 2,
         ysize / 2, jxl::ColorEncoding::SRGB(/*is_gray=*/false),
         /*bits_per_sample=*/16, format,
         /*pool=*/nullptr, &bundle_internal));
     bundle_internal.duration = 0;
     bundle_internal.use_for_next_frame = true;
     bundle_internal.origin = {13, 17};
     io.frames.push_back(std::move(bundle_internal));
     frame_durations_nc.push_back(0);
     frame_xsize.push_back(xsize / 2);
     frame_ysize.push_back(ysize / 2);
     frame_x0.push_back(13);
     frame_y0.push_back(17);
   }

   std::vector<uint8_t> frame =
       jxl::test::GetSomeTestImage(cropxsize, cropysize, 4, i * 2);
   // Actual rendered frame
   jxl::ImageBundle bundle(memory_manager, &io.metadata.m);
   EXPECT_TRUE(ConvertFromExternal(jxl::Bytes(frame.data(), frame.size()),
                                   cropxsize, cropysize,
                                   jxl::ColorEncoding::SRGB(/*is_gray=*/false),
                                   /*bits_per_sample=*/16, format,
                                   /*pool=*/nullptr, &bundle));
   bundle.duration = 5 + i;
   frame_durations_nc.push_back(5 + i);
   frame_durations_c.push_back(5 + i);
   frame_xsize.push_back(cropxsize);
   frame_ysize.push_back(cropysize);
   frame_x0.push_back(cropx0);
   frame_y0.push_back(cropy0);
   bundle.origin = {cropx0, cropy0};
   // Create some variation in which frames depend on which.
   if (i != 3 && i != 9 && i != 10) {
     bundle.use_for_next_frame = true;
   }
   if (i != 12) {
     bundle.blend = true;
     bundle.blendmode = jxl::BlendMode::kBlend;
   }
   io.frames.push_back(std::move(bundle));
 }

 jxl::CompressParams cparams;
 cparams.SetLossless();  // Lossless to verify pixels exactly after roundtrip.
 cparams.speed_tier = jxl::SpeedTier::kThunder;
 std::vector<uint8_t> compressed;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));
 // try both with and without coalescing
 for (auto coalescing : {JXL_TRUE, JXL_FALSE}) {
   // Independently decode all frames without any skipping, to create the
   // expected blended frames, for the actual tests below to compare with.
   {
     JxlDecoder* dec = JxlDecoderCreate(nullptr);
     const uint8_t* next_in = compressed.data();
     size_t avail_in = compressed.size();
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetCoalescing(dec, coalescing));
     void* runner = JxlThreadParallelRunnerCreate(
         nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetParallelRunner(
                                    dec, JxlThreadParallelRunner, runner));
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSubscribeEvents(dec, JXL_DEC_FULL_IMAGE));
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
     for (size_t i = 0; i < num_frames + (coalescing ? 0 : 5); ++i) {
       EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
       size_t buffer_size;
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
       if (coalescing) {
         EXPECT_EQ(xsize * ysize * 8, buffer_size);
       } else {
         EXPECT_EQ(frame_xsize[i] * frame_ysize[i] * 8, buffer_size);
       }
       frames[i].resize(buffer_size);
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetImageOutBuffer(dec, &format, frames[i].data(),
                                             frames[i].size()));
       EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
     }

     // After all frames were decoded, JxlDecoderProcessInput should return
     // success to indicate all is done.
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
     JxlThreadParallelRunnerDestroy(runner);
     JxlDecoderDestroy(dec);
   }

   JxlDecoder* dec = JxlDecoderCreate(nullptr);
   const uint8_t* next_in = compressed.data();
   size_t avail_in = compressed.size();

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetCoalescing(dec, coalescing));
   void* runner = JxlThreadParallelRunnerCreate(
       nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetParallelRunner(
                                  dec, JxlThreadParallelRunner, runner));

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(
                                  dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME |
                                           JXL_DEC_FULL_IMAGE));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
   EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
   JxlBasicInfo info;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));

   for (size_t i = 0; i < num_frames; ++i) {
     EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

     size_t buffer_size;
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
     std::vector<uint8_t> pixels(buffer_size);

     JxlFrameHeader frame_header;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
     EXPECT_EQ((coalescing ? frame_durations_c[i] : frame_durations_nc[i]),
               frame_header.duration);

     EXPECT_EQ(i + 1 == num_frames, frame_header.is_last);

     EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetImageOutBuffer(dec, &format, pixels.data(),
                                           pixels.size()));

     EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
     if (coalescing) {
       EXPECT_EQ(frame_header.layer_info.xsize, xsize);
     } else {
       EXPECT_EQ(frame_header.layer_info.xsize, frame_xsize[i]);
     }
     if (coalescing) {
       EXPECT_EQ(frame_header.layer_info.ysize, ysize);
     } else {
       EXPECT_EQ(frame_header.layer_info.ysize, frame_ysize[i]);
     }
     EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                            frame_header.layer_info.xsize,
                                            frame_header.layer_info.ysize,
                                            format, format));

     // Test rewinding mid-way, not decoding all frames.
     if (i == 8) {
       break;
     }
   }

   JxlDecoderRewind(dec);
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(
                                  dec, JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

   for (size_t i = 0; i < num_frames + (coalescing ? 0 : 5); ++i) {
     if (i == 3) {
       JxlDecoderSkipFrames(dec, 5);
       i += 5;
     }

     EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));
     size_t buffer_size;
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
     std::vector<uint8_t> pixels(buffer_size);

     JxlFrameHeader frame_header;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
     EXPECT_EQ((coalescing ? frame_durations_c[i] : frame_durations_nc[i]),
               frame_header.duration);

     EXPECT_EQ(i + 1 == num_frames + (coalescing ? 0 : 5),
               frame_header.is_last);

     EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetImageOutBuffer(dec, &format, pixels.data(),
                                           pixels.size()));

     EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
     if (coalescing) {
       EXPECT_EQ(frame_header.layer_info.xsize, xsize);
       EXPECT_EQ(frame_header.layer_info.ysize, ysize);
       EXPECT_EQ(frame_header.layer_info.crop_x0, 0);
       EXPECT_EQ(frame_header.layer_info.crop_y0, 0);
     } else {
       EXPECT_EQ(frame_header.layer_info.xsize, frame_xsize[i]);
       EXPECT_EQ(frame_header.layer_info.ysize, frame_ysize[i]);
       EXPECT_EQ(frame_header.layer_info.crop_x0, frame_x0[i]);
       EXPECT_EQ(frame_header.layer_info.crop_y0, frame_y0[i]);
       EXPECT_EQ(frame_header.layer_info.blend_info.blendmode,
                 i != 12 + 5 && frame_header.duration != 0
                     ? 2
                     : 0);  // kBlend or the default kReplace
     }
     EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                            frame_header.layer_info.xsize,
                                            frame_header.layer_info.ysize,
                                            format, format));
   }

   // After all frames were decoded, JxlDecoderProcessInput should return
   // success to indicate all is done.
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

   // Test rewinding the decoder and skipping different frames

   JxlDecoderRewind(dec);
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(
                                  dec, JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));

   for (size_t i = 0; i < num_frames + (coalescing ? 0 : 5); ++i) {
     int test_skipping = (i == 9) ? 3 : 0;

     EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));
     size_t buffer_size;
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
     std::vector<uint8_t> pixels(buffer_size);

     // Since this is after JXL_DEC_FRAME but before JXL_DEC_FULL_IMAGE, this
     // should only skip the next frame, not the currently processed one.
     if (test_skipping) JxlDecoderSkipFrames(dec, test_skipping);

     JxlFrameHeader frame_header;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetFrameHeader(dec, &frame_header));
     EXPECT_EQ((coalescing ? frame_durations_c[i] : frame_durations_nc[i]),
               frame_header.duration);

     EXPECT_EQ(i + 1 == num_frames + (coalescing ? 0 : 5),
               frame_header.is_last);

     EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));

     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetImageOutBuffer(dec, &format, pixels.data(),
                                           pixels.size()));

     EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
     EXPECT_EQ(0u, jxl::test::ComparePixels(frames[i].data(), pixels.data(),
                                            frame_header.layer_info.xsize,
                                            frame_header.layer_info.ysize,
                                            format, format));

     if (test_skipping) i += test_skipping;
   }

   JxlThreadParallelRunnerDestroy(runner);
   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, OrientedCroppedFrameTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 const auto test = [&](bool keep_orientation, uint32_t orientation,
                       uint32_t resampling) {
   size_t xsize = 90;
   size_t ysize = 120;
   JxlPixelFormat format = {4, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   size_t oxsize = (!keep_orientation && orientation > 4 ? ysize : xsize);
   size_t oysize = (!keep_orientation && orientation > 4 ? xsize : ysize);
   jxl::CodecInOut io{memory_manager};
   EXPECT_TRUE(io.SetSize(xsize, ysize));
   io.metadata.m.SetUintSamples(16);
   io.metadata.m.color_encoding = jxl::ColorEncoding::SRGB(false);
   io.metadata.m.orientation = orientation;
   io.frames.clear();
   EXPECT_TRUE(io.SetSize(xsize, ysize));

   for (size_t i = 0; i < 3; ++i) {
     size_t cropxsize = 1 + xsize * 2 / (i + 1);
     size_t cropysize = 1 + ysize * 3 / (i + 2);
     int cropx0 = i * 3 - 8;
     int cropy0 = i * 4 - 7;

     std::vector<uint8_t> frame =
         jxl::test::GetSomeTestImage(cropxsize, cropysize, 4, i * 2);
     jxl::ImageBundle bundle(memory_manager, &io.metadata.m);
     EXPECT_TRUE(ConvertFromExternal(
         jxl::Bytes(frame.data(), frame.size()), cropxsize, cropysize,
         jxl::ColorEncoding::SRGB(/*is_gray=*/false),
         /*bits_per_sample=*/16, format,
         /*pool=*/nullptr, &bundle));
     bundle.origin = {cropx0, cropy0};
     bundle.use_for_next_frame = true;
     io.frames.push_back(std::move(bundle));
   }

   jxl::CompressParams cparams;
   cparams
       .SetLossless();  // Lossless to verify pixels exactly after roundtrip.
   cparams.speed_tier = jxl::SpeedTier::kThunder;
   cparams.resampling = resampling;
   std::vector<uint8_t> compressed;
   EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

   // 0 is merged frame as decoded with coalescing enabled (default)
   // 1-3 are non-coalesced frames as decoded with coalescing disabled
   // 4 is the manually merged frame
   std::vector<uint8_t> frames[5];
   frames[4].resize(xsize * ysize * 8, 0);

   // try both with and without coalescing
   for (auto coalescing : {JXL_TRUE, JXL_FALSE}) {
     // Independently decode all frames without any skipping, to create the
     // expected blended frames, for the actual tests below to compare with.
     {
       JxlDecoder* dec = JxlDecoderCreate(nullptr);
       const uint8_t* next_in = compressed.data();
       size_t avail_in = compressed.size();
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetCoalescing(dec, coalescing));
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetKeepOrientation(dec, keep_orientation));
       void* runner = JxlThreadParallelRunnerCreate(
           nullptr, JxlThreadParallelRunnerDefaultNumWorkerThreads());
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetParallelRunner(
                                      dec, JxlThreadParallelRunner, runner));
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSubscribeEvents(dec, JXL_DEC_FULL_IMAGE));
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
       for (size_t i = (coalescing ? 0 : 1); i < (coalescing ? 1 : 4); ++i) {
         EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
         JxlFrameHeader frame_header;
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderGetFrameHeader(dec, &frame_header));
         size_t buffer_size;
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
         if (coalescing) {
           EXPECT_EQ(xsize * ysize * 8, buffer_size);
         } else {
           EXPECT_EQ(frame_header.layer_info.xsize *
                         frame_header.layer_info.ysize * 8,
                     buffer_size);
         }
         frames[i].resize(buffer_size);
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetImageOutBuffer(dec, &format, frames[i].data(),
                                               frames[i].size()));
         EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
         EXPECT_EQ(frame_header.layer_info.blend_info.blendmode,
                   JXL_BLEND_REPLACE);
         if (coalescing) {
           EXPECT_EQ(frame_header.layer_info.xsize, oxsize);
           EXPECT_EQ(frame_header.layer_info.ysize, oysize);
           EXPECT_EQ(frame_header.layer_info.crop_x0, 0);
           EXPECT_EQ(frame_header.layer_info.crop_y0, 0);
         } else {
           // manually merge this layer
           int x0 = frame_header.layer_info.crop_x0;
           int y0 = frame_header.layer_info.crop_y0;
           int w = frame_header.layer_info.xsize;
           int h = frame_header.layer_info.ysize;
           for (int y = 0; y < static_cast<int>(oysize); y++) {
             if (y < y0 || y >= y0 + h) continue;
             // pointers do whole 16-bit RGBA pixels at a time
             uint64_t* row_merged = reinterpret_cast<uint64_t*>(
                 frames[4].data() + y * oxsize * 8);
             uint64_t* row_layer = reinterpret_cast<uint64_t*>(
                 frames[i].data() + (y - y0) * w * 8);
             for (int x = 0; x < static_cast<int>(oxsize); x++) {
               if (x < x0 || x >= x0 + w) continue;
               row_merged[x] = row_layer[x - x0];
             }
           }
         }
       }

       // After all frames were decoded, JxlDecoderProcessInput should return
       // success to indicate all is done.
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
       JxlThreadParallelRunnerDestroy(runner);
       JxlDecoderDestroy(dec);
     }
   }

   EXPECT_EQ(0u, jxl::test::ComparePixels(frames[0].data(), frames[4].data(),
                                          oxsize, oysize, format, format));
 };

 for (bool keep_orientation : {true, false}) {
   for (uint32_t orientation = 1; orientation <= 8; orientation++) {
     for (uint32_t resampling : {1, 2, 4, 8}) {
       SCOPED_TRACE(testing::Message()
                    << "keep_orientation: " << keep_orientation << ", "
                    << "orientation: " << orientation << ", "
                    << "resampling: " << resampling);
       test(keep_orientation, orientation, resampling);
     }
   }
 }
}

struct FramePositions {
 size_t frame_start;
 size_t header_end;
 size_t toc_end;
 std::vector<size_t> section_end;
};

struct StreamPositions {
 size_t codestream_start;
 size_t codestream_end;
 size_t basic_info;
 size_t jbrd_end = 0;
 std::vector<size_t> box_start;
 std::vector<FramePositions> frames;
};

void AnalyzeCodestream(const std::vector<uint8_t>& data,
                      StreamPositions* streampos) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 // Unbox data to codestream and mark where it is broken up by boxes.
 std::vector<uint8_t> codestream;
 std::vector<std::pair<size_t, size_t>> breakpoints;
 bool codestream_end = false;
 ASSERT_LE(2, data.size());
 if (data[0] == 0xff && data[1] == 0x0a) {
   codestream = std::vector<uint8_t>(data.begin(), data.end());
   streampos->codestream_start = 0;
 } else {
   const uint8_t* in = data.data();
   size_t pos = 0;
   while (pos < data.size()) {
     ASSERT_LE(pos + 8, data.size());
     streampos->box_start.push_back(pos);
     size_t box_size = LoadBE32(in + pos);
     if (box_size == 0) box_size = data.size() - pos;
     ASSERT_LE(pos + box_size, data.size());
     if (memcmp(in + pos + 4, "jxlc", 4) == 0) {
       EXPECT_TRUE(codestream.empty());
       streampos->codestream_start = pos + 8;
       codestream.insert(codestream.end(), in + pos + 8, in + pos + box_size);
       codestream_end = true;
     } else if (memcmp(in + pos + 4, "jxlp", 4) == 0) {
       codestream_end = ((LoadBE32(in + pos + 8) & 0x80000000) != 0);
       if (codestream.empty()) {
         streampos->codestream_start = pos + 12;
       } else if (box_size > 12 || !codestream_end) {
         breakpoints.emplace_back(codestream.size(), 12);
       }
       codestream.insert(codestream.end(), in + pos + 12, in + pos + box_size);
     } else if (memcmp(in + pos + 4, "jbrd", 4) == 0) {
       EXPECT_TRUE(codestream.empty());
       streampos->jbrd_end = pos + box_size;
     } else if (!codestream.empty() && !codestream_end) {
       breakpoints.emplace_back(codestream.size(), box_size);
     }
     pos += box_size;
   }
   ASSERT_EQ(pos, data.size());
 }
 // Translate codestream positions to boxed stream positions.
 size_t offset = streampos->codestream_start;
 size_t bp = 0;
 auto add_offset = [&](size_t pos) {
   while (bp < breakpoints.size() && pos >= breakpoints[bp].first) {
     offset += breakpoints[bp++].second;
   }
   return pos + offset;
 };
 // Analyze the unboxed codestream.
 jxl::BitReader br(jxl::Bytes(codestream.data(), codestream.size()));
 ASSERT_EQ(br.ReadFixedBits<16>(), 0x0AFF);
 jxl::CodecMetadata metadata;
 ASSERT_TRUE(ReadSizeHeader(&br, &metadata.size));
 ASSERT_TRUE(ReadImageMetadata(&br, &metadata.m));
 streampos->basic_info =
     add_offset(br.TotalBitsConsumed() / jxl::kBitsPerByte);
 metadata.transform_data.nonserialized_xyb_encoded = metadata.m.xyb_encoded;
 ASSERT_TRUE(jxl::Bundle::Read(&br, &metadata.transform_data));
 if (metadata.m.color_encoding.WantICC()) {
   std::vector<uint8_t> icc;
   ASSERT_TRUE(jxl::test::ReadICC(&br, &icc));
   ASSERT_TRUE(!icc.empty());
   metadata.m.color_encoding.SetICCRaw(std::move(icc));
 }
 ASSERT_TRUE(br.JumpToByteBoundary());
 bool has_preview = metadata.m.have_preview;
 while (br.TotalBitsConsumed() < br.TotalBytes() * jxl::kBitsPerByte) {
   FramePositions p;
   p.frame_start = add_offset(br.TotalBitsConsumed() / jxl::kBitsPerByte);
   jxl::FrameHeader frame_header(&metadata);
   if (has_preview) {
     frame_header.nonserialized_is_preview = true;
     has_preview = false;
   }
   ASSERT_TRUE(ReadFrameHeader(&br, &frame_header));
   p.header_end =
       add_offset(jxl::DivCeil(br.TotalBitsConsumed(), jxl::kBitsPerByte));
   jxl::FrameDimensions frame_dim = frame_header.ToFrameDimensions();
   uint64_t groups_total_size;
   const size_t toc_entries =
       jxl::NumTocEntries(frame_dim.num_groups, frame_dim.num_dc_groups,
                          frame_header.passes.num_passes);
   std::vector<uint64_t> section_offsets;
   std::vector<uint32_t> section_sizes;
   ASSERT_TRUE(ReadGroupOffsets(memory_manager, toc_entries, &br,
                                &section_offsets, &section_sizes,
                                &groups_total_size));
   EXPECT_EQ(br.TotalBitsConsumed() % jxl::kBitsPerByte, 0);
   size_t sections_start = br.TotalBitsConsumed() / jxl::kBitsPerByte;
   p.toc_end = add_offset(sections_start);
   for (size_t i = 0; i < toc_entries; ++i) {
     size_t end = sections_start + section_offsets[i] + section_sizes[i];
     p.section_end.push_back(add_offset(end));
   }
   br.SkipBits(groups_total_size * jxl::kBitsPerByte);
   streampos->frames.push_back(p);
 }
 streampos->codestream_end = add_offset(codestream.size());
 EXPECT_EQ(br.TotalBitsConsumed(), br.TotalBytes() * jxl::kBitsPerByte);
 EXPECT_TRUE(br.Close());
}

enum ExpectedFlushState { NO_FLUSH, SAME_FLUSH, NEW_FLUSH };
struct Breakpoint {
 size_t file_pos;
 ExpectedFlushState expect_flush;
};

void VerifyProgression(size_t xsize, size_t ysize, uint32_t num_channels,
                      const std::vector<uint8_t>& pixels,
                      const std::vector<uint8_t>& data,
                      std::vector<Breakpoint> breakpoints) {
 // Size large enough for multiple groups, required to have progressive stages.
 ASSERT_LT(256, xsize);
 ASSERT_LT(256, ysize);
 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());
 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 JxlDecoder* dec = JxlDecoderCreate(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));
 int bp = 0;
 const uint8_t* next_in = data.data();
 size_t avail_in = breakpoints[bp].file_pos;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
 double prev_dist = 1.0;
 for (;;) {
   JxlDecoderStatus status = JxlDecoderProcessInput(dec);
   printf("bp: %d  status: 0x%x\n", bp, static_cast<int>(status));
   if (status == JXL_DEC_BASIC_INFO) {
     JxlBasicInfo info;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
     EXPECT_EQ(info.xsize, xsize);
     EXPECT_EQ(info.ysize, ysize);
     // Output buffer/callback not yet set
     EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));
     size_t buffer_size;
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
     EXPECT_EQ(pixels2.size(), buffer_size);
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetImageOutBuffer(dec, &format, pixels2.data(),
                                           pixels2.size()));
   } else if (status == JXL_DEC_FRAME) {
     // Nothing to do.
   } else if (status == JXL_DEC_SUCCESS) {
     EXPECT_EQ(bp + 1, breakpoints.size());
     break;
   } else if (status == JXL_DEC_NEED_MORE_INPUT ||
              status == JXL_DEC_FULL_IMAGE) {
     if (breakpoints[bp].expect_flush == NO_FLUSH) {
       EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));
     } else {
       if (status != JXL_DEC_FULL_IMAGE) {
         EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));
       }
       double dist = jxl::test::DistanceRMS(pixels2.data(), pixels.data(),
                                            xsize, ysize, format);
       if (breakpoints[bp].expect_flush == NEW_FLUSH) {
         EXPECT_LT(dist, prev_dist);
         prev_dist = dist;
       } else {
         EXPECT_EQ(dist, prev_dist);
       }
     }
     if (status == JXL_DEC_FULL_IMAGE) {
       EXPECT_EQ(bp + 1, breakpoints.size());
       continue;
     }
     ASSERT_LT(++bp, breakpoints.size());
     next_in += avail_in - JxlDecoderReleaseInput(dec);
     avail_in = breakpoints[bp].file_pos - (next_in - data.data());
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
   } else {
     printf("Unexpected status: 0x%x\n", static_cast<int>(status));
     FAIL();  // unexpected returned status
   }
 }
 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, ProgressionTest) {
 size_t xsize = 508;
 size_t ysize = 470;
 uint32_t num_channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.cparams.progressive_dc = 1;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 StreamPositions streampos;
 AnalyzeCodestream(data, &streampos);
 const std::vector<FramePositions>& fp = streampos.frames;
 // We have preview, dc frame and regular frame.
 EXPECT_EQ(3, fp.size());
 EXPECT_EQ(7, fp[2].section_end.size());
 EXPECT_EQ(data.size(), fp[2].section_end[6]);
 std::vector<Breakpoint> breakpoints{
     {fp[0].frame_start, NO_FLUSH},           // headers
     {fp[1].frame_start, NO_FLUSH},           // preview
     {fp[2].frame_start, NO_FLUSH},           // dc frame
     {fp[2].section_end[0], NO_FLUSH},        // DC global
     {fp[2].section_end[1] - 1, NO_FLUSH},    // partial DC group
     {fp[2].section_end[1], NEW_FLUSH},       // DC group
     {fp[2].section_end[2], SAME_FLUSH},      // AC global
     {fp[2].section_end[3], NEW_FLUSH},       // AC group 0
     {fp[2].section_end[4] - 1, SAME_FLUSH},  // partial AC group 1
     {fp[2].section_end[4], NEW_FLUSH},       // AC group 1
     {fp[2].section_end[5], NEW_FLUSH},       // AC group 2
     {data.size() - 1, SAME_FLUSH},           // partial AC group 3
     {data.size(), NEW_FLUSH}};               // full image
 VerifyProgression(xsize, ysize, num_channels, pixels, data, breakpoints);
}

TEST(DecodeTest, ProgressionTestLosslessAlpha) {
 size_t xsize = 508;
 size_t ysize = 470;
 uint32_t num_channels = 4;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 params.cparams.responsive = 1;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 StreamPositions streampos;
 AnalyzeCodestream(data, &streampos);
 const std::vector<FramePositions>& fp = streampos.frames;
 // We have preview, dc frame and regular frame.
 EXPECT_EQ(1, fp.size());
 EXPECT_EQ(7, fp[0].section_end.size());
 EXPECT_EQ(data.size(), fp[0].section_end[6]);
 std::vector<Breakpoint> breakpoints{
     {fp[0].frame_start, NO_FLUSH},           // headers
     {fp[0].section_end[0] - 1, NO_FLUSH},    // partial DC global
     {fp[0].section_end[0], NEW_FLUSH},       // DC global
     {fp[0].section_end[1], SAME_FLUSH},      // DC group
     {fp[0].section_end[2], SAME_FLUSH},      // AC global
     {fp[0].section_end[3], NEW_FLUSH},       // AC group 0
     {fp[0].section_end[4] - 1, SAME_FLUSH},  // partial AC group 1
     {fp[0].section_end[4], NEW_FLUSH},       // AC group 1
     {fp[0].section_end[5], NEW_FLUSH},       // AC group 2
     {data.size() - 1, SAME_FLUSH},           // partial AC group 3
     {data.size(), NEW_FLUSH}};               // full image
 VerifyProgression(xsize, ysize, num_channels, pixels, data, breakpoints);
}

void VerifyFilePosition(size_t expected_pos, const std::vector<uint8_t>& data,
                       JxlDecoder* dec) {
 size_t remaining = JxlDecoderReleaseInput(dec);
 size_t pos = data.size() - remaining;
 EXPECT_EQ(expected_pos, pos);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(dec, data.data() + pos, remaining));
}

TEST(DecodeTest, InputHandlingTestOneShot) {
 size_t xsize = 508;
 size_t ysize = 470;
 uint32_t num_channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 for (int i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   printf("Testing with box format %d\n", i);
   jxl::TestCodestreamParams params;
   params.cparams.progressive_dc = 1;
   params.preview_mode = jxl::kSmallPreview;
   params.box_format = static_cast<CodeStreamBoxFormat>(i);
   std::vector<uint8_t> data =
       jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                    xsize, ysize, num_channels, params);
   JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   StreamPositions streampos;
   AnalyzeCodestream(data, &streampos);
   const std::vector<FramePositions>& fp = streampos.frames;
   // We have preview, dc frame and regular frame.
   EXPECT_EQ(3, fp.size());

   std::vector<uint8_t> pixels2;
   pixels2.resize(pixels.size());

   int kNumEvents = 6;
   int events[] = {
       JXL_DEC_BASIC_INFO, JXL_DEC_COLOR_ENCODING, JXL_DEC_PREVIEW_IMAGE,
       JXL_DEC_FRAME,      JXL_DEC_FULL_IMAGE,     JXL_DEC_FRAME_PROGRESSION,
   };
   size_t end_positions[] = {
       streampos.basic_info,     fp[0].frame_start,
       fp[1].frame_start,        fp[2].toc_end,
       streampos.codestream_end, streampos.codestream_end};
   int events_wanted = 0;
   for (int j = 0; j < kNumEvents; ++j) {
     events_wanted |= events[j];
     size_t end_pos = end_positions[j];
     JxlDecoder* dec = JxlDecoderCreate(nullptr);
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events_wanted));
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetInput(dec, data.data(), data.size()));
     EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
     VerifyFilePosition(streampos.basic_info, data, dec);
     if (j >= 1) {
       EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[0].frame_start, data, dec);
     }
     if (j >= 2) {
       EXPECT_EQ(JXL_DEC_NEED_PREVIEW_OUT_BUFFER, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[0].toc_end, data, dec);
       size_t buffer_size;
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderPreviewOutBufferSize(dec, &format, &buffer_size));
       EXPECT_GE(pixels2.size(), buffer_size);
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetPreviewOutBuffer(dec, &format, pixels2.data(),
                                               buffer_size));
       EXPECT_EQ(JXL_DEC_PREVIEW_IMAGE, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[1].frame_start, data, dec);
     }
     if (j >= 3) {
       EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[2].toc_end, data, dec);
       if (j >= 5) {
         EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetProgressiveDetail(dec, kDC));
       }
     }
     if (j >= 4) {
       EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[2].toc_end, data, dec);
       size_t buffer_size;
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
       EXPECT_EQ(pixels2.size(), buffer_size);
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetImageOutBuffer(dec, &format, pixels2.data(),
                                             pixels2.size()));
       if (j >= 5) {
         EXPECT_EQ(JXL_DEC_FRAME_PROGRESSION, JxlDecoderProcessInput(dec));
         VerifyFilePosition(fp[2].section_end[1], data, dec);
       }
       EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
       VerifyFilePosition(streampos.codestream_end, data, dec);
     }
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
     VerifyFilePosition(end_pos, data, dec);
     JxlDecoderDestroy(dec);
   }
 }
}

JXL_TRANSCODE_JPEG_TEST(DecodeTest, InputHandlingTestJPEGOneshot) {
 TEST_LIBJPEG_SUPPORT();
 size_t xsize = 123;
 size_t ysize = 77;
 size_t channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, channels, /*seed=*/0);
 for (int i = 1; i < kCSBF_NUM_ENTRIES; ++i) {
   printf("Testing with box format %d\n", i);
   std::vector<uint8_t> jpeg_codestream;
   jxl::TestCodestreamParams params;
   params.cparams.color_transform = jxl::ColorTransform::kNone;
   params.jpeg_codestream = &jpeg_codestream;
   params.preview_mode = jxl::kSmallPreview;
   params.box_format = static_cast<CodeStreamBoxFormat>(i);
   std::vector<uint8_t> data =
       jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                    xsize, ysize, channels, params);
   JxlPixelFormat format = {3, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   StreamPositions streampos;
   AnalyzeCodestream(data, &streampos);
   const std::vector<FramePositions>& fp = streampos.frames;
   // We have preview and regular frame.
   EXPECT_EQ(2, fp.size());
   EXPECT_LT(0, streampos.jbrd_end);

   std::vector<uint8_t> pixels2;
   pixels2.resize(pixels.size());

   int kNumEvents = 6;
   int events[] = {JXL_DEC_BASIC_INFO,     JXL_DEC_JPEG_RECONSTRUCTION,
                   JXL_DEC_COLOR_ENCODING, JXL_DEC_PREVIEW_IMAGE,
                   JXL_DEC_FRAME,          JXL_DEC_FULL_IMAGE};
   size_t end_positions[] = {streampos.basic_info, streampos.basic_info,
                             fp[0].frame_start,    fp[1].frame_start,
                             fp[1].toc_end,        streampos.codestream_end};
   int events_wanted = 0;
   for (int j = 0; j < kNumEvents; ++j) {
     printf("j = %d\n", j);
     events_wanted |= events[j];
     size_t end_pos = end_positions[j];
     JxlDecoder* dec = JxlDecoderCreate(nullptr);
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events_wanted));
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetInput(dec, data.data(), data.size()));
     if (j >= 1) {
       EXPECT_EQ(JXL_DEC_JPEG_RECONSTRUCTION, JxlDecoderProcessInput(dec));
       VerifyFilePosition(streampos.jbrd_end, data, dec);
     }
     EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
     VerifyFilePosition(streampos.basic_info, data, dec);
     if (j >= 2) {
       EXPECT_EQ(JXL_DEC_COLOR_ENCODING, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[0].frame_start, data, dec);
     }
     if (j >= 3) {
       EXPECT_EQ(JXL_DEC_NEED_PREVIEW_OUT_BUFFER, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[0].toc_end, data, dec);
       size_t buffer_size;
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderPreviewOutBufferSize(dec, &format, &buffer_size));
       EXPECT_GE(pixels2.size(), buffer_size);
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetPreviewOutBuffer(dec, &format, pixels2.data(),
                                               buffer_size));
       EXPECT_EQ(JXL_DEC_PREVIEW_IMAGE, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[1].frame_start, data, dec);
     }
     if (j >= 4) {
       EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[1].toc_end, data, dec);
     }
     if (j >= 5) {
       EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
       VerifyFilePosition(fp[1].toc_end, data, dec);
       size_t buffer_size;
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
       EXPECT_EQ(pixels2.size(), buffer_size);
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetImageOutBuffer(dec, &format, pixels2.data(),
                                             pixels2.size()));
       EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
       VerifyFilePosition(streampos.codestream_end, data, dec);
     }
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
     VerifyFilePosition(end_pos, data, dec);
     JxlDecoderDestroy(dec);
   }
 }
}

TEST(DecodeTest, InputHandlingTestStreaming) {
 size_t xsize = 508;
 size_t ysize = 470;
 uint32_t num_channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 for (int i = 0; i < kCSBF_NUM_ENTRIES; ++i) {
   printf("Testing with box format %d\n", i);
   fflush(stdout);
   jxl::TestCodestreamParams params;
   params.cparams.progressive_dc = 1;
   params.box_format = static_cast<CodeStreamBoxFormat>(i);
   params.preview_mode = jxl::kSmallPreview;
   std::vector<uint8_t> data =
       jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                    xsize, ysize, num_channels, params);
   JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   StreamPositions streampos;
   AnalyzeCodestream(data, &streampos);
   const std::vector<FramePositions>& fp = streampos.frames;
   // We have preview, dc frame and regular frame.
   EXPECT_EQ(3, fp.size());
   std::vector<uint8_t> pixels2;
   pixels2.resize(pixels.size());
   int events_wanted =
       (JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_PREVIEW_IMAGE |
        JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE | JXL_DEC_FRAME_PROGRESSION |
        JXL_DEC_BOX);
   for (size_t increment : {1, 7, 27, 1024}) {
     JxlDecoder* dec = JxlDecoderCreate(nullptr);
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, events_wanted));
     size_t file_pos = 0;
     size_t box_index = 0;
     size_t avail_in = 0;
     for (;;) {
       const uint8_t* next_in = data.data() + file_pos;
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
       JxlDecoderStatus status = JxlDecoderProcessInput(dec);
       size_t remaining = JxlDecoderReleaseInput(dec);
       size_t consumed = avail_in - remaining;
       file_pos += consumed;
       avail_in += increment;
       avail_in = std::min<size_t>(avail_in, data.size() - file_pos);
       if (status == JXL_DEC_BASIC_INFO) {
         EXPECT_EQ(file_pos, streampos.basic_info);
       } else if (status == JXL_DEC_COLOR_ENCODING) {
         EXPECT_EQ(file_pos, streampos.frames[0].frame_start);
       } else if (status == JXL_DEC_NEED_PREVIEW_OUT_BUFFER) {
         EXPECT_EQ(file_pos, streampos.frames[0].toc_end);
         size_t buffer_size;
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderPreviewOutBufferSize(dec, &format, &buffer_size));
         EXPECT_GE(pixels2.size(), buffer_size);
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetPreviewOutBuffer(dec, &format, pixels2.data(),
                                                 buffer_size));
       } else if (status == JXL_DEC_PREVIEW_IMAGE) {
         EXPECT_EQ(file_pos, streampos.frames[1].frame_start);
       } else if (status == JXL_DEC_FRAME) {
         EXPECT_EQ(file_pos, streampos.frames[2].toc_end);
         EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetProgressiveDetail(dec, kDC));
       } else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
         EXPECT_EQ(file_pos, streampos.frames[2].toc_end);
         size_t buffer_size;
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
         EXPECT_EQ(pixels2.size(), buffer_size);
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetImageOutBuffer(dec, &format, pixels2.data(),
                                               pixels2.size()));
       } else if (status == JXL_DEC_FRAME_PROGRESSION) {
         EXPECT_EQ(file_pos, streampos.frames[2].section_end[1]);
       } else if (status == JXL_DEC_FULL_IMAGE) {
         EXPECT_EQ(file_pos, streampos.codestream_end);
       } else if (status == JXL_DEC_SUCCESS) {
         EXPECT_EQ(file_pos, streampos.codestream_end);
         break;
       } else if (status == JXL_DEC_NEED_MORE_INPUT) {
         EXPECT_LT(remaining, 12);
         if ((i == kCSBF_None && file_pos >= 2) ||
             (box_index > 0 && box_index < streampos.box_start.size() &&
              file_pos >= streampos.box_start[box_index - 1] + 12 &&
              file_pos < streampos.box_start[box_index])) {
           EXPECT_EQ(remaining, 0);
         }
         if (file_pos == data.size()) break;
       } else if (status == JXL_DEC_BOX) {
         ASSERT_LT(box_index, streampos.box_start.size());
         EXPECT_EQ(file_pos, streampos.box_start[box_index++]);
       } else {
         printf("Unexpected status: 0x%x\n", static_cast<int>(status));
         FAIL();
       }
     }
     JxlDecoderDestroy(dec);
   }
 }
}

TEST(DecodeTest, FlushTest) {
 // Size large enough for multiple groups, required to have progressive
 // stages
 size_t xsize = 333;
 size_t ysize = 300;
 uint32_t num_channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));

 // Ensure that the first part contains at least the full DC of the image,
 // otherwise flush does not work.
 size_t first_part = data.size() - 1;

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), first_part));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(info.xsize, xsize);
 EXPECT_EQ(info.ysize, ysize);

 EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

 // Output buffer not yet set
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));

 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 EXPECT_EQ(pixels2.size(), buffer_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                dec, &format, pixels2.data(), pixels2.size()));

 // Must process input further until we get JXL_DEC_NEED_MORE_INPUT, even if
 // data was already input before, since the processing of the frame only
 // happens at the JxlDecoderProcessInput call after JXL_DEC_FRAME.
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));

 // Crude test of actual pixel data: pixel threshold of about 4% (2560/65535).
 // 29000 pixels can be above the threshold
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           29000u);

 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 size_t consumed = first_part - JxlDecoderReleaseInput(dec);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data() + consumed,
                                               data.size() - consumed));
 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 // Lower threshold for the final (still lossy) image
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           11000u);

 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, FlushTestImageOutCallback) {
 // Size large enough for multiple groups, required to have progressive
 // stages
 size_t xsize = 333;
 size_t ysize = 300;
 uint32_t num_channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());

 size_t bytes_per_pixel = format.num_channels * 2;
 size_t stride = bytes_per_pixel * xsize;
 auto callback = [&](size_t x, size_t y, size_t num_pixels,
                     const void* pixels_row) {
   memcpy(pixels2.data() + stride * y + bytes_per_pixel * x, pixels_row,
          num_pixels * bytes_per_pixel);
 };

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));

 // Ensure that the first part contains at least the full DC of the image,
 // otherwise flush does not work.
 size_t first_part = data.size() - 1;

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), first_part));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(info.xsize, xsize);
 EXPECT_EQ(info.ysize, ysize);

 EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

 // Output callback not yet set
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutCallback(
                                dec, &format,
                                [](void* opaque, size_t x, size_t y,
                                   size_t xsize, const void* pixels_row) {
                                  auto cb =
                                      static_cast<decltype(&callback)>(opaque);
                                  (*cb)(x, y, xsize, pixels_row);
                                },
                                /*opaque=*/&callback));

 // Must process input further until we get JXL_DEC_NEED_MORE_INPUT, even if
 // data was already input before, since the processing of the frame only
 // happens at the JxlDecoderProcessInput call after JXL_DEC_FRAME.
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));

 // Crude test of actual pixel data: pixel threshold of about 4% (2560/65535).
 // 29000 pixels can be above the threshold
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           29000u);

 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 size_t consumed = first_part - JxlDecoderReleaseInput(dec);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data() + consumed,
                                               data.size() - consumed));
 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 // Lower threshold for the final (still lossy) image
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           11000u);

 JxlDecoderDestroy(dec);
}

TEST(DecodeTest, FlushTestLossyProgressiveAlpha) {
 // Size large enough for multiple groups, required to have progressive
 // stages
 size_t xsize = 333;
 size_t ysize = 300;
 uint32_t num_channels = 4;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));

 // Ensure that the first part contains at least the full DC of the image,
 // otherwise flush does not work.
 size_t first_part = data.size() - 1;

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), first_part));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(info.xsize, xsize);
 EXPECT_EQ(info.ysize, ysize);

 EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

 // Output buffer not yet set
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));

 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 EXPECT_EQ(pixels2.size(), buffer_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                dec, &format, pixels2.data(), pixels2.size()));

 // Must process input further until we get JXL_DEC_NEED_MORE_INPUT, even if
 // data was already input before, since the processing of the frame only
 // happens at the JxlDecoderProcessInput call after JXL_DEC_FRAME.
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));

 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           30000u);

 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 size_t consumed = first_part - JxlDecoderReleaseInput(dec);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data() + consumed,
                                               data.size() - consumed));

 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           11000u);

 JxlDecoderDestroy(dec);
}
TEST(DecodeTest, FlushTestLossyProgressiveAlphaUpsampling) {
 size_t xsize = 533;
 size_t ysize = 401;
 uint32_t num_channels = 4;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.cparams.resampling = 2;
 params.cparams.ec_resampling = 4;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));

 // Ensure that the first part contains at least the full DC of the image,
 // otherwise flush does not work.
 size_t first_part = data.size() * 2 / 3;

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), first_part));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(info.xsize, xsize);
 EXPECT_EQ(info.ysize, ysize);

 EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

 // Output buffer not yet set
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));

 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 EXPECT_EQ(pixels2.size(), buffer_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                dec, &format, pixels2.data(), pixels2.size()));

 // Must process input further until we get JXL_DEC_NEED_MORE_INPUT, even if
 // data was already input before, since the processing of the frame only
 // happens at the JxlDecoderProcessInput call after JXL_DEC_FRAME.
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));

 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           125000u);

 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 size_t consumed = first_part - JxlDecoderReleaseInput(dec);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data() + consumed,
                                               data.size() - consumed));

 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           70000u);

 JxlDecoderDestroy(dec);
}
TEST(DecodeTest, FlushTestLosslessProgressiveAlpha) {
 // Size large enough for multiple groups, required to have progressive
 // stages
 size_t xsize = 333;
 size_t ysize = 300;
 uint32_t num_channels = 4;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
 jxl::TestCodestreamParams params;
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 params.cparams.responsive = 1;
 params.cparams.modular_group_size_shift = 1;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> data =
     jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                  xsize, ysize, num_channels, params);
 JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};

 std::vector<uint8_t> pixels2;
 pixels2.resize(pixels.size());

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME | JXL_DEC_FULL_IMAGE));

 // Ensure that the first part contains at least the full DC of the image,
 // otherwise flush does not work.
 size_t first_part = data.size() / 2;

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data(), first_part));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 JxlBasicInfo info;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
 EXPECT_EQ(info.xsize, xsize);
 EXPECT_EQ(info.ysize, ysize);

 EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));

 // Output buffer not yet set
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderFlushImage(dec));

 size_t buffer_size;
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
 EXPECT_EQ(pixels2.size(), buffer_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                dec, &format, pixels2.data(), pixels2.size()));

 // Must process input further until we get JXL_DEC_NEED_MORE_INPUT, even if
 // data was already input before, since the processing of the frame only
 // happens at the JxlDecoderProcessInput call after JXL_DEC_FRAME.
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));

 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format, 2560.0),
           2700u);

 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));

 size_t consumed = first_part - JxlDecoderReleaseInput(dec);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, data.data() + consumed,
                                               data.size() - consumed));

 EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));
 EXPECT_LE(jxl::test::ComparePixels(pixels2.data(), pixels.data(), xsize,
                                    ysize, format, format),
           0u);

 JxlDecoderDestroy(dec);
}

class DecodeProgressiveTest : public ::testing::TestWithParam<int> {};
JXL_GTEST_INSTANTIATE_TEST_SUITE_P(DecodeProgressiveTestInstantiation,
                                  DecodeProgressiveTest,
                                  ::testing::Range(0, 8));
TEST_P(DecodeProgressiveTest, ProgressiveEventTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 const int params = GetParam();
 bool single_group = ((params & 1) != 0);
 bool lossless = (((params >> 1) & 1) != 0);
 uint32_t num_channels = 3 + ((params >> 2) & 1);
 bool has_alpha = ((num_channels & 1) == 0);
 std::set<JxlProgressiveDetail> progressive_details = {kDC, kLastPasses,
                                                       kPasses};
 for (auto prog_detail : progressive_details) {
   // Only few combinations are expected to support outputting
   // intermediate flushes for complete DC and complete passes.
   // The test can be updated if more cases are expected to support it.
   bool expect_flush = !has_alpha && !lossless;
   size_t xsize;
   size_t ysize;
   if (single_group) {
     // An image smaller than 256x256 ensures it contains only 1 group.
     xsize = 99;
     ysize = 100;
   } else {
     xsize = 277;
     ysize = 280;
   }
   std::vector<uint8_t> pixels =
       jxl::test::GetSomeTestImage(xsize, ysize, num_channels, 0);
   JxlPixelFormat format = {num_channels, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
   jxl::ColorEncoding color_encoding = jxl::ColorEncoding::SRGB(false);
   jxl::CodecInOut io{memory_manager};
   EXPECT_TRUE(jxl::ConvertFromExternal(
       jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, color_encoding,
       /*bits_per_sample=*/16, format,
       /*pool=*/nullptr, &io.Main()));
   jxl::TestCodestreamParams params;
   if (lossless) {
     params.cparams.SetLossless();
   } else {
     params.cparams.butteraugli_distance = 0.5f;
   }
   jxl::PassDefinition passes[] = {
       {2, 0, 4}, {4, 0, 4}, {8, 2, 2}, {8, 1, 2}, {8, 0, 1}};
   const int kNumPasses = 5;
   jxl::ProgressiveMode progressive_mode{passes};
   params.cparams.custom_progressive_mode = &progressive_mode;
   std::vector<uint8_t> data =
       jxl::CreateTestJXLCodestream(jxl::Bytes(pixels.data(), pixels.size()),
                                    xsize, ysize, num_channels, params);

   for (size_t increment : {static_cast<size_t>(1), data.size()}) {
     printf(
         "Testing with single_group=%s, lossless=%s, "
         "num_channels=%d, prog_detail=%d, increment=%d\n",
         BoolToCStr(single_group), BoolToCStr(lossless),
         static_cast<int>(num_channels), static_cast<int>(prog_detail),
         static_cast<int>(increment));
     std::vector<std::vector<uint8_t>> passes(kNumPasses + 1);
     for (int i = 0; i <= kNumPasses; ++i) {
       passes[i].resize(pixels.size());
     }

     JxlDecoder* dec = JxlDecoderCreate(nullptr);

     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSubscribeEvents(
                   dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME |
                            JXL_DEC_FULL_IMAGE | JXL_DEC_FRAME_PROGRESSION));
     EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderSetProgressiveDetail(dec, kFrames));
     EXPECT_EQ(JXL_DEC_ERROR,
               JxlDecoderSetProgressiveDetail(dec, kDCProgressive));
     EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderSetProgressiveDetail(dec, kDCGroups));
     EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderSetProgressiveDetail(dec, kGroups));
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetProgressiveDetail(dec, prog_detail));

     uint8_t* next_in = data.data();
     size_t avail_in = 0;
     size_t pos = 0;

     auto process_input = [&]() {
       for (;;) {
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetInput(dec, next_in, avail_in));
         JxlDecoderStatus status = JxlDecoderProcessInput(dec);
         size_t remaining = JxlDecoderReleaseInput(dec);
         EXPECT_LE(remaining, avail_in);
         next_in += avail_in - remaining;
         avail_in = remaining;
         if (status == JXL_DEC_NEED_MORE_INPUT && pos < data.size()) {
           size_t chunk = std::min<size_t>(increment, data.size() - pos);
           pos += chunk;
           avail_in += chunk;
           continue;
         }
         return status;
       }
     };

     EXPECT_EQ(JXL_DEC_BASIC_INFO, process_input());
     JxlBasicInfo info;
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
     EXPECT_EQ(info.xsize, xsize);
     EXPECT_EQ(info.ysize, ysize);

     EXPECT_EQ(JXL_DEC_FRAME, process_input());

     size_t buffer_size;
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
     EXPECT_EQ(pixels.size(), buffer_size);
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                    dec, &format, passes[kNumPasses].data(),
                                    passes[kNumPasses].size()));

     auto next_pass = [&](int pass) {
       if (prog_detail <= kDC) return kNumPasses;
       if (prog_detail <= kLastPasses) {
         return std::min(pass + 2, kNumPasses);
       }
       return pass + 1;
     };

     if (expect_flush) {
       // Return a particular downsampling ratio only after the last
       // pass for that downsampling was processed.
       int expected_downsampling_ratios[] = {8, 8, 4, 4, 2};
       for (int p = 0; p < kNumPasses; p = next_pass(p)) {
         EXPECT_EQ(JXL_DEC_FRAME_PROGRESSION, process_input());
         EXPECT_EQ(expected_downsampling_ratios[p],
                   JxlDecoderGetIntendedDownsamplingRatio(dec));
         EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderFlushImage(dec));
         passes[p] = passes[kNumPasses];
       }
     }

     EXPECT_EQ(JXL_DEC_FULL_IMAGE, process_input());
     EXPECT_EQ(JXL_DEC_SUCCESS, process_input());

     JxlDecoderDestroy(dec);

     if (!expect_flush) {
       continue;
     }
     jxl::ButteraugliParams butteraugli_params;
     std::vector<float> distances(kNumPasses + 1);
     for (int p = 0;; p = next_pass(p)) {
       jxl::CodecInOut io1{memory_manager};
       EXPECT_TRUE(jxl::ConvertFromExternal(
           jxl::Bytes(passes[p].data(), passes[p].size()), xsize, ysize,
           color_encoding,
           /*bits_per_sample=*/16, format,
           /*pool=*/nullptr, &io1.Main()));
       distances[p] =
           ButteraugliDistance(io.frames, io1.frames, butteraugli_params,
                               *JxlGetDefaultCms(), nullptr, nullptr);
       if (p == kNumPasses) break;
     }
     const float kMaxDistance[kNumPasses + 1] = {30.0f, 20.0f, 10.0f,
                                                 5.0f,  3.0f,  2.0f};
     EXPECT_LT(distances[kNumPasses], kMaxDistance[kNumPasses]);
     for (int p = 0; p < kNumPasses;) {
       int next_p = next_pass(p);
       EXPECT_LT(distances[p], kMaxDistance[p]);
       // Verify that the returned pass image is actually not the
       // same as the next pass image, by checking that it has a bit
       // worse butteraugli score.
       EXPECT_LT(distances[next_p] * 1.1f, distances[p]);
       p = next_p;
     }
   }
 }
}

void VerifyJPEGReconstruction(jxl::Span<const uint8_t> container,
                             jxl::Span<const uint8_t> jpeg_bytes) {
 JxlDecoderPtr dec = JxlDecoderMake(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(
               dec.get(), JXL_DEC_JPEG_RECONSTRUCTION | JXL_DEC_FULL_IMAGE));
 JxlDecoderSetInput(dec.get(), container.data(), container.size());
 EXPECT_EQ(JXL_DEC_JPEG_RECONSTRUCTION, JxlDecoderProcessInput(dec.get()));
 std::vector<uint8_t> reconstructed_buffer(128);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetJPEGBuffer(dec.get(), reconstructed_buffer.data(),
                                   reconstructed_buffer.size()));
 size_t used = 0;
 JxlDecoderStatus process_result = JXL_DEC_JPEG_NEED_MORE_OUTPUT;
 while (process_result == JXL_DEC_JPEG_NEED_MORE_OUTPUT) {
   used = reconstructed_buffer.size() - JxlDecoderReleaseJPEGBuffer(dec.get());
   reconstructed_buffer.resize(reconstructed_buffer.size() * 2);
   EXPECT_EQ(
       JXL_DEC_SUCCESS,
       JxlDecoderSetJPEGBuffer(dec.get(), reconstructed_buffer.data() + used,
                               reconstructed_buffer.size() - used));
   process_result = JxlDecoderProcessInput(dec.get());
 }
 ASSERT_EQ(JXL_DEC_FULL_IMAGE, process_result);
 used = reconstructed_buffer.size() - JxlDecoderReleaseJPEGBuffer(dec.get());
 ASSERT_EQ(used, jpeg_bytes.size());
 EXPECT_EQ(0, memcmp(reconstructed_buffer.data(), jpeg_bytes.data(), used));
}

JXL_TRANSCODE_JPEG_TEST(DecodeTest, JPEGReconstructTestCodestream) {
 TEST_LIBJPEG_SUPPORT();
 size_t xsize = 123;
 size_t ysize = 77;
 size_t channels = 3;
 std::vector<uint8_t> pixels =
     jxl::test::GetSomeTestImage(xsize, ysize, channels, /*seed=*/0);
 std::vector<uint8_t> jpeg_codestream;
 jxl::TestCodestreamParams params;
 params.cparams.color_transform = jxl::ColorTransform::kNone;
 params.box_format = kCSBF_Single;
 params.jpeg_codestream = &jpeg_codestream;
 params.preview_mode = jxl::kSmallPreview;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, channels, params);
 VerifyJPEGReconstruction(jxl::Bytes(compressed), jxl::Bytes(jpeg_codestream));
}

JXL_TRANSCODE_JPEG_TEST(DecodeTest, JPEGReconstructionTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 const std::string jpeg_path = "jxl/flower/flower.png.im_q85_420.jpg";
 const std::vector<uint8_t> orig = jxl::test::ReadTestData(jpeg_path);
 jxl::CodecInOut orig_io{memory_manager};
 ASSERT_TRUE(jxl::jpeg::DecodeImageJPG(jxl::Bytes(orig), &orig_io));
 jxl::jpeg::JPEGData jpeg_data_copy = *orig_io.Main().jpeg_data;
 orig_io.metadata.m.xyb_encoded = false;
 jxl::BitWriter writer{memory_manager};
 ASSERT_TRUE(WriteCodestreamHeaders(&orig_io.metadata, &writer, nullptr));
 writer.ZeroPadToByte();
 jxl::CompressParams cparams;
 cparams.color_transform = jxl::ColorTransform::kNone;
 ASSERT_TRUE(jxl::EncodeFrame(memory_manager, cparams, jxl::FrameInfo{},
                              &orig_io.metadata, orig_io.Main(),
                              *JxlGetDefaultCms(),
                              /*pool=*/nullptr, &writer,
                              /*aux_out=*/nullptr));

 std::vector<uint8_t> jpeg_data;
 ASSERT_TRUE(
     EncodeJPEGData(memory_manager, jpeg_data_copy, &jpeg_data, cparams));
 std::vector<uint8_t> container;
 jxl::Bytes(jxl::kContainerHeader).AppendTo(container);
 jxl::AppendBoxHeader(jxl::MakeBoxType("jbrd"), jpeg_data.size(), false,
                      &container);
 jxl::Bytes(jpeg_data).AppendTo(container);
 jxl::AppendBoxHeader(jxl::MakeBoxType("jxlc"), 0, true, &container);
 jxl::PaddedBytes codestream = std::move(writer).TakeBytes();
 jxl::Bytes(codestream).AppendTo(container);
 VerifyJPEGReconstruction(jxl::Bytes(container), jxl::Bytes(orig));
}

JXL_TRANSCODE_JPEG_TEST(DecodeTest, JPEGReconstructionMetadataTest) {
 const std::string jpeg_path = "jxl/jpeg_reconstruction/1x1_exif_xmp.jpg";
 const std::string jxl_path = "jxl/jpeg_reconstruction/1x1_exif_xmp.jxl";
 const std::vector<uint8_t> jpeg = jxl::test::ReadTestData(jpeg_path);
 const std::vector<uint8_t> jxl = jxl::test::ReadTestData(jxl_path);
 VerifyJPEGReconstruction(jxl::Bytes(jxl), jxl::Bytes(jpeg));
}

TEST(DecodeTest, ContinueFinalNonEssentialBoxTest) {
 size_t xsize = 80;
 size_t ysize = 90;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 jxl::TestCodestreamParams params;
 params.box_format = kCSBF_Multi_Other_Terminated;
 params.add_icc_profile = true;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);
 StreamPositions streampos;
 AnalyzeCodestream(compressed, &streampos);

 // The non-essential final box size including 8-byte header
 size_t final_box_size = unk3_box_size + 8;
 size_t last_box_begin = compressed.size() - final_box_size;
 // Verify that the test is indeed setup correctly to be at the beginning of
 // the 'unkn' box header.
 ASSERT_EQ(compressed[last_box_begin + 3], final_box_size);
 ASSERT_EQ(compressed[last_box_begin + 4], 'u');
 ASSERT_EQ(compressed[last_box_begin + 5], 'n');
 ASSERT_EQ(compressed[last_box_begin + 6], 'k');
 ASSERT_EQ(compressed[last_box_begin + 7], '3');

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec, JXL_DEC_BASIC_INFO | JXL_DEC_FRAME));

 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(dec, compressed.data(), last_box_begin));

 EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
 EXPECT_EQ(JXL_DEC_FRAME, JxlDecoderProcessInput(dec));
 // The decoder returns success despite not having seen the final unknown box
 // yet. This is because calling JxlDecoderCloseInput is not mandatory for
 // backwards compatibility, so it doesn't know more bytes follow, the current
 // bytes ended at a perfectly valid place.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 size_t remaining = JxlDecoderReleaseInput(dec);
 // Since the test was set up to end exactly at the boundary of the final
 // codestream box, and the decoder returned success, all bytes are expected to
 // be consumed until the end of the  frame header.
 EXPECT_EQ(remaining, last_box_begin - streampos.frames[0].toc_end);

 // Now set the remaining non-codestream box as input.
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSetInput(dec, compressed.data() + last_box_begin,
                              compressed.size() - last_box_begin));
 // Even though JxlDecoderProcessInput already returned JXL_DEC_SUCCESS before,
 // when calling it again now after setting more input, success is expected, no
 // event occurs but the box has been successfully skipped.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 JxlDecoderDestroy(dec);
}

namespace {
bool BoxTypeEquals(const std::string& type_string, const JxlBoxType type) {
 return type_string.size() == 4 && type_string[0] == type[0] &&
        type_string[1] == type[1] && type_string[2] == type[2] &&
        type_string[3] == type[3];
}
}  // namespace

TEST(DecodeTest, ExtendedBoxSizeTest) {
 const std::string jxl_path = "jxl/boxes/square-extended-size-container.jxl";
 const std::vector<uint8_t> orig = jxl::test::ReadTestData(jxl_path);
 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, JXL_DEC_BOX));

 JxlBoxType type;
 uint64_t box_size;
 uint64_t contents_size;
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, orig.data(), orig.size()));
 EXPECT_EQ(JXL_DEC_BOX, JxlDecoderProcessInput(dec));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
 EXPECT_TRUE(BoxTypeEquals("JXL ", type));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeRaw(dec, &box_size));
 EXPECT_EQ(12, box_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeContents(dec, &contents_size));
 EXPECT_EQ(contents_size + 8, box_size);
 EXPECT_EQ(JXL_DEC_BOX, JxlDecoderProcessInput(dec));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
 EXPECT_TRUE(BoxTypeEquals("ftyp", type));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeRaw(dec, &box_size));
 EXPECT_EQ(20, box_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeContents(dec, &contents_size));
 EXPECT_EQ(contents_size + 8, box_size);
 EXPECT_EQ(JXL_DEC_BOX, JxlDecoderProcessInput(dec));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
 EXPECT_TRUE(BoxTypeEquals("jxlc", type));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeRaw(dec, &box_size));
 EXPECT_EQ(72, box_size);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeContents(dec, &contents_size));
 // This is an extended box, hence the difference between `box_size` and
 // `contents_size` is 16.
 EXPECT_EQ(contents_size + 8 + 8, box_size);

 JxlDecoderDestroy(dec);
}

JXL_BOXES_TEST(DecodeTest, BoxTest) {
 size_t xsize = 1;
 size_t ysize = 1;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 jxl::TestCodestreamParams params;
 params.box_format = kCSBF_Multi_Other_Terminated;
 params.add_icc_profile = true;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);

 JxlDecoder* dec = JxlDecoderCreate(nullptr);

 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, JXL_DEC_BOX));

 std::vector<std::string> expected_box_types = {
     "JXL ", "ftyp", "jxlp", "unk1", "unk2", "jxlp", "jxlp", "jxlp", "unk3"};

 // Value 0 means to not test the size: codestream is not required to be a
 // particular exact size.
 std::vector<size_t> expected_box_sizes = {12, 20, 0, 34, 18, 0, 0, 0, 20};

 JxlBoxType type;
 uint64_t box_size;
 uint64_t contents_size;
 std::vector<uint8_t> contents(50);
 size_t expected_release_size = 0;

 // Cannot get these when decoding didn't start yet
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderGetBoxSizeRaw(dec, &box_size));

 uint8_t* next_in = compressed.data();
 size_t avail_in = compressed.size();
 for (size_t i = 0; i < expected_box_types.size(); i++) {
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
   EXPECT_EQ(JXL_DEC_BOX, JxlDecoderProcessInput(dec));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxSizeRaw(dec, &box_size));
   EXPECT_TRUE(BoxTypeEquals(expected_box_types[i], type));
   if (expected_box_sizes[i]) {
     EXPECT_EQ(expected_box_sizes[i], box_size);
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderGetBoxSizeContents(dec, &contents_size));
     EXPECT_EQ(contents_size + 8, box_size);
   }

   if (expected_release_size > 0) {
     EXPECT_EQ(expected_release_size, JxlDecoderReleaseBoxBuffer(dec));
     expected_release_size = 0;
   }

   if (type[0] == 'u' && type[1] == 'n' && type[2] == 'k') {
     JxlDecoderSetBoxBuffer(dec, contents.data(), contents.size());
     size_t expected_box_contents_size =
         type[3] == '1' ? unk1_box_size
                        : (type[3] == '2' ? unk2_box_size : unk3_box_size);
     expected_release_size = contents.size() - expected_box_contents_size;
   }
   size_t consumed = avail_in - JxlDecoderReleaseInput(dec);
   next_in += consumed;
   avail_in -= consumed;
 }

 // After the last DEC_BOX event, check that the input position is exactly at
 // the stat of the box header.
 EXPECT_EQ(avail_in, expected_box_sizes.back());

 // Even though all input is given, the decoder cannot assume there aren't
 // more boxes if the input was not closed.
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec, next_in, avail_in));
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec));
 JxlDecoderCloseInput(dec);
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));

 JxlDecoderDestroy(dec);
}

JXL_BOXES_TEST(DecodeTest, ExifBrobBoxTest) {
 size_t xsize = 1;
 size_t ysize = 1;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 jxl::TestCodestreamParams params;
 // Lossless to verify pixels exactly after roundtrip.
 params.cparams.SetLossless();
 params.box_format = kCSBF_Brob_Exif;
 params.add_icc_profile = true;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);

 // Test raw brob box, not brotli-decompressing
 for (int streaming = 0; streaming < 2; ++streaming) {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, JXL_DEC_BOX));
   if (!streaming) {
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
     JxlDecoderCloseInput(dec);
   }
   // for streaming input case
   const uint8_t* next_in = compressed.data();
   size_t avail_in = 0;
   size_t total_in = 0;
   size_t step_size = 64;

   std::vector<uint8_t> box_buffer;
   size_t box_num_output;
   bool seen_brob_begin = false;
   bool seen_brob_end = false;

   for (;;) {
     JxlDecoderStatus status = JxlDecoderProcessInput(dec);
     if (status == JXL_DEC_NEED_MORE_INPUT) {
       if (streaming) {
         size_t remaining = JxlDecoderReleaseInput(dec);
         EXPECT_LE(remaining, avail_in);
         next_in += avail_in - remaining;
         avail_in = remaining;
         size_t amount = step_size;
         if (total_in + amount > compressed.size()) {
           amount = compressed.size() - total_in;
         }
         avail_in += amount;
         total_in += amount;
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetInput(dec, next_in, avail_in));
         if (total_in == compressed.size()) JxlDecoderCloseInput(dec);
       } else {
         FAIL();
         break;
       }
     } else if (status == JXL_DEC_BOX || status == JXL_DEC_SUCCESS) {
       if (!box_buffer.empty()) {
         EXPECT_EQ(false, seen_brob_end);
         seen_brob_end = true;
         size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
         box_num_output = box_buffer.size() - remaining;
         EXPECT_EQ(box_num_output, box_brob_exif_size - 8);
         EXPECT_EQ(
             0, memcmp(box_buffer.data(), box_brob_exif + 8, box_num_output));
         box_buffer.clear();
       }
       if (status == JXL_DEC_SUCCESS) break;
       JxlBoxType type;
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
       if (BoxTypeEquals("brob", type)) {
         EXPECT_EQ(false, seen_brob_begin);
         seen_brob_begin = true;
         box_buffer.resize(8);
         JxlDecoderSetBoxBuffer(dec, box_buffer.data(), box_buffer.size());
       }
     } else if (status == JXL_DEC_BOX_NEED_MORE_OUTPUT) {
       size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
       box_num_output = box_buffer.size() - remaining;
       box_buffer.resize(box_buffer.size() * 2);
       JxlDecoderSetBoxBuffer(dec, box_buffer.data() + box_num_output,
                              box_buffer.size() - box_num_output);
     } else {
       // We do not expect any other events or errors
       FAIL();
       break;
     }
   }

   EXPECT_EQ(true, seen_brob_begin);
   EXPECT_EQ(true, seen_brob_end);

   JxlDecoderDestroy(dec);
 }

 // Test decompressed brob box
 for (int streaming = 0; streaming < 2; ++streaming) {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSubscribeEvents(dec, JXL_DEC_BOX));
   if (!streaming) {
     EXPECT_EQ(JXL_DEC_SUCCESS,
               JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
     JxlDecoderCloseInput(dec);
   }
   // for streaming input case
   const uint8_t* next_in = compressed.data();
   size_t avail_in = 0;
   size_t total_in = 0;
   size_t step_size = 64;

   std::vector<uint8_t> box_buffer;
   size_t box_num_output;
   bool seen_exif_begin = false;
   bool seen_exif_end = false;

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetDecompressBoxes(dec, JXL_TRUE));

   for (;;) {
     JxlDecoderStatus status = JxlDecoderProcessInput(dec);
     if (status == JXL_DEC_NEED_MORE_INPUT) {
       if (streaming) {
         size_t remaining = JxlDecoderReleaseInput(dec);
         EXPECT_LE(remaining, avail_in);
         next_in += avail_in - remaining;
         avail_in = remaining;
         size_t amount = step_size;
         if (total_in + amount > compressed.size()) {
           amount = compressed.size() - total_in;
         }
         avail_in += amount;
         total_in += amount;
         EXPECT_EQ(JXL_DEC_SUCCESS,
                   JxlDecoderSetInput(dec, next_in, avail_in));
         if (total_in == compressed.size()) JxlDecoderCloseInput(dec);
       } else {
         FAIL();
         break;
       }
     } else if (status == JXL_DEC_BOX || status == JXL_DEC_SUCCESS) {
       if (!box_buffer.empty()) {
         EXPECT_EQ(false, seen_exif_end);
         seen_exif_end = true;
         size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
         box_num_output = box_buffer.size() - remaining;
         // Expect that the output has the same size and contents as the
         // uncompressed exif data. Only check contents if the sizes match to
         // avoid comparing uninitialized memory in the test.
         EXPECT_EQ(box_num_output, exif_uncompressed_size);
         if (box_num_output == exif_uncompressed_size) {
           EXPECT_EQ(0, memcmp(box_buffer.data(), exif_uncompressed,
                               exif_uncompressed_size));
         }
         box_buffer.clear();
       }
       if (status == JXL_DEC_SUCCESS) break;
       JxlBoxType type;
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_TRUE));
       if (BoxTypeEquals("Exif", type)) {
         EXPECT_EQ(false, seen_exif_begin);
         seen_exif_begin = true;
         box_buffer.resize(8);
         JxlDecoderSetBoxBuffer(dec, box_buffer.data(), box_buffer.size());
       }
     } else if (status == JXL_DEC_BOX_NEED_MORE_OUTPUT) {
       size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
       box_num_output = box_buffer.size() - remaining;
       box_buffer.resize(box_buffer.size() * 2);
       JxlDecoderSetBoxBuffer(dec, box_buffer.data() + box_num_output,
                              box_buffer.size() - box_num_output);
     } else {
       // We do not expect any other events or errors
       FAIL();
       break;
     }
   }

   EXPECT_EQ(true, seen_exif_begin);
   EXPECT_EQ(true, seen_exif_end);

   JxlDecoderDestroy(dec);
 }
}

JXL_BOXES_TEST(DecodeTest, PartialCodestreamBoxTest) {
 size_t xsize = 23;
 size_t ysize = 81;
 std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
 JxlPixelFormat format_orig = {4, JXL_TYPE_UINT16, JXL_BIG_ENDIAN, 0};
 // Lossless to verify pixels exactly after roundtrip.
 jxl::TestCodestreamParams params;
 params.cparams.SetLossless();
 params.cparams.speed_tier = jxl::SpeedTier::kThunder;
 params.box_format = kCSBF_Multi;
 params.add_icc_profile = true;
 std::vector<uint8_t> compressed = jxl::CreateTestJXLCodestream(
     jxl::Bytes(pixels.data(), pixels.size()), xsize, ysize, 4, params);

 std::vector<uint8_t> extracted_codestream;

 {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSubscribeEvents(
                 dec, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE | JXL_DEC_BOX));
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
   JxlDecoderCloseInput(dec);

   size_t num_jxlp = 0;

   std::vector<uint8_t> pixels2;
   pixels2.resize(pixels.size());

   std::vector<uint8_t> box_buffer;
   size_t box_num_output;

   for (;;) {
     JxlDecoderStatus status = JxlDecoderProcessInput(dec);
     if (status == JXL_DEC_NEED_MORE_INPUT) {
       FAIL();
       break;
     } else if (status == JXL_DEC_BASIC_INFO) {
       JxlBasicInfo info;
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
       EXPECT_EQ(info.xsize, xsize);
       EXPECT_EQ(info.ysize, ysize);
     } else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetImageOutBuffer(dec, &format_orig, pixels2.data(),
                                             pixels2.size()));
     } else if (status == JXL_DEC_FULL_IMAGE) {
       continue;
     } else if (status == JXL_DEC_BOX || status == JXL_DEC_SUCCESS) {
       if (!box_buffer.empty()) {
         size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
         box_num_output = box_buffer.size() - remaining;
         EXPECT_GE(box_num_output, 4);
         // Do not insert the first 4 bytes, which are not part of the
         // codestream, but the partial codestream box index
         extracted_codestream.insert(extracted_codestream.end(),
                                     box_buffer.begin() + 4,
                                     box_buffer.begin() + box_num_output);
         box_buffer.clear();
       }
       if (status == JXL_DEC_SUCCESS) break;
       JxlBoxType type;
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBoxType(dec, type, JXL_FALSE));
       if (BoxTypeEquals("jxlp", type)) {
         num_jxlp++;
         box_buffer.resize(8);
         JxlDecoderSetBoxBuffer(dec, box_buffer.data(), box_buffer.size());
       }
     } else if (status == JXL_DEC_BOX_NEED_MORE_OUTPUT) {
       size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
       box_num_output = box_buffer.size() - remaining;
       box_buffer.resize(box_buffer.size() * 2);
       JxlDecoderSetBoxBuffer(dec, box_buffer.data() + box_num_output,
                              box_buffer.size() - box_num_output);
     } else {
       // We do not expect any other events or errors
       FAIL();
       break;
     }
   }

   // The test file created with kCSBF_Multi is expected to have 4 jxlp boxes.
   EXPECT_EQ(4, num_jxlp);

   EXPECT_EQ(0u, jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                          ysize, format_orig, format_orig));

   JxlDecoderDestroy(dec);
 }

 // Now test whether the codestream extracted from the jxlp boxes can itself
 // also be decoded and gives the same pixels
 {
   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSubscribeEvents(
                 dec, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE | JXL_DEC_BOX));
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetInput(dec, extracted_codestream.data(),
                                extracted_codestream.size()));
   JxlDecoderCloseInput(dec);

   size_t num_boxes = 0;

   std::vector<uint8_t> pixels2;
   pixels2.resize(pixels.size());

   std::vector<uint8_t> box_buffer;
   size_t box_num_output;

   for (;;) {
     JxlDecoderStatus status = JxlDecoderProcessInput(dec);
     if (status == JXL_DEC_NEED_MORE_INPUT) {
       FAIL();
       break;
     } else if (status == JXL_DEC_BASIC_INFO) {
       JxlBasicInfo info;
       EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &info));
       EXPECT_EQ(info.xsize, xsize);
       EXPECT_EQ(info.ysize, ysize);
     } else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
       EXPECT_EQ(JXL_DEC_SUCCESS,
                 JxlDecoderSetImageOutBuffer(dec, &format_orig, pixels2.data(),
                                             pixels2.size()));
     } else if (status == JXL_DEC_FULL_IMAGE) {
       continue;
     } else if (status == JXL_DEC_BOX) {
       num_boxes++;
     } else if (status == JXL_DEC_BOX_NEED_MORE_OUTPUT) {
       size_t remaining = JxlDecoderReleaseBoxBuffer(dec);
       box_num_output = box_buffer.size() - remaining;
       box_buffer.resize(box_buffer.size() * 2);
       JxlDecoderSetBoxBuffer(dec, box_buffer.data() + box_num_output,
                              box_buffer.size() - box_num_output);
     } else if (status == JXL_DEC_SUCCESS) {
       break;
     } else {
       // We do not expect any other events or errors
       FAIL();
       break;
     }
   }

   EXPECT_EQ(0, num_boxes);  // The data does not use the container format.
   EXPECT_EQ(0u, jxl::test::ComparePixels(pixels.data(), pixels2.data(), xsize,
                                          ysize, format_orig, format_orig));

   JxlDecoderDestroy(dec);
 }
}

TEST(DecodeTest, SpotColorTest) {
 JxlMemoryManager* memory_manager = jxl::test::MemoryManager();
 jxl::CodecInOut io{memory_manager};
 size_t xsize = 55;
 size_t ysize = 257;
 io.metadata.m.color_encoding = jxl::ColorEncoding::LinearSRGB();
 JXL_TEST_ASSIGN_OR_DIE(Image3F main,
                        Image3F::Create(memory_manager, xsize, ysize));
 JXL_TEST_ASSIGN_OR_DIE(ImageF spot,
                        ImageF::Create(memory_manager, xsize, ysize));
 jxl::ZeroFillImage(&main);
 jxl::ZeroFillImage(&spot);

 for (size_t y = 0; y < ysize; y++) {
   float* JXL_RESTRICT rowm = main.PlaneRow(1, y);
   float* JXL_RESTRICT rows = spot.Row(y);
   for (size_t x = 0; x < xsize; x++) {
     rowm[x] = (x + y) * (1.f / 255.f);
     rows[x] = ((x ^ y) & 255) * (1.f / 255.f);
   }
 }
 ASSERT_TRUE(
     io.SetFromImage(std::move(main), jxl::ColorEncoding::LinearSRGB()));
 jxl::ExtraChannelInfo info;
 info.bit_depth.bits_per_sample = 8;
 info.dim_shift = 0;
 info.type = jxl::ExtraChannel::kSpotColor;
 info.spot_color[0] = 0.5f;
 info.spot_color[1] = 0.2f;
 info.spot_color[2] = 1.f;
 info.spot_color[3] = 0.5f;

 io.metadata.m.extra_channel_info.push_back(info);
 std::vector<ImageF> ec;
 ec.push_back(std::move(spot));
 ASSERT_TRUE(io.frames[0].SetExtraChannels(std::move(ec)));

 jxl::CompressParams cparams;
 cparams.speed_tier = jxl::SpeedTier::kLightning;
 cparams.modular_mode = true;
 cparams.color_transform = jxl::ColorTransform::kNone;
 cparams.butteraugli_distance = 0.f;

 std::vector<uint8_t> compressed;
 EXPECT_TRUE(jxl::test::EncodeFile(cparams, &io, &compressed));

 for (size_t render_spot = 0; render_spot < 2; render_spot++) {
   JxlPixelFormat format = {3, JXL_TYPE_UINT8, JXL_LITTLE_ENDIAN, 0};

   JxlDecoder* dec = JxlDecoderCreate(nullptr);

   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSubscribeEvents(
                 dec, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE));
   if (!render_spot) {
     EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetRenderSpotcolors(dec, JXL_FALSE));
   }

   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetInput(dec, compressed.data(), compressed.size()));
   EXPECT_EQ(JXL_DEC_BASIC_INFO, JxlDecoderProcessInput(dec));
   JxlBasicInfo binfo;
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderGetBasicInfo(dec, &binfo));
   EXPECT_EQ(1u, binfo.num_extra_channels);
   EXPECT_EQ(xsize, binfo.xsize);
   EXPECT_EQ(ysize, binfo.ysize);

   JxlExtraChannelInfo extra_info;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderGetExtraChannelInfo(dec, 0, &extra_info));
   EXPECT_EQ(static_cast<unsigned int>(jxl::ExtraChannel::kSpotColor),
             extra_info.type);

   EXPECT_EQ(JXL_DEC_NEED_IMAGE_OUT_BUFFER, JxlDecoderProcessInput(dec));
   size_t buffer_size;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderImageOutBufferSize(dec, &format, &buffer_size));
   size_t extra_size;
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderExtraChannelBufferSize(dec, &format, &extra_size, 0));

   std::vector<uint8_t> image(buffer_size);
   std::vector<uint8_t> extra(extra_size);
   size_t bytes_per_pixel = format.num_channels *
                            jxl::test::GetDataBits(format.data_type) /
                            jxl::kBitsPerByte;
   size_t stride = bytes_per_pixel * binfo.xsize;

   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetImageOutBuffer(
                                  dec, &format, image.data(), image.size()));
   EXPECT_EQ(JXL_DEC_SUCCESS,
             JxlDecoderSetExtraChannelBuffer(dec, &format, extra.data(),
                                             extra.size(), 0));

   EXPECT_EQ(JXL_DEC_FULL_IMAGE, JxlDecoderProcessInput(dec));

   // After the full image was output, JxlDecoderProcessInput should return
   // success to indicate all is done.
   EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderProcessInput(dec));
   JxlDecoderDestroy(dec);

   for (size_t y = 0; y < ysize; y++) {
     uint8_t* JXL_RESTRICT rowm = image.data() + stride * y;
     uint8_t* JXL_RESTRICT rows = extra.data() + xsize * y;
     for (size_t x = 0; x < xsize; x++) {
       if (!render_spot) {
         // if spot color isn't rendered, main image should be as we made it
         // (red and blue are all zeroes)

         EXPECT_EQ(rowm[x * 3 + 0], 0);
         EXPECT_EQ(rowm[x * 3 + 1], (x + y > 255 ? 255 : x + y));
         EXPECT_EQ(rowm[x * 3 + 2], 0);
       }
       if (render_spot) {
         // if spot color is rendered, expect red and blue to look like the
         // spot color channel
         EXPECT_LT(abs(rowm[x * 3 + 0] - (rows[x] * 0.25f)), 1);
         EXPECT_LT(abs(rowm[x * 3 + 2] - (rows[x] * 0.5f)), 1);
       }
       EXPECT_EQ(rows[x], ((x ^ y) & 255));
     }
   }
 }
}

TEST(DecodeTest, CloseInput) {
 std::vector<uint8_t> partial_file = {0xff};

 JxlDecoderPtr dec = JxlDecoderMake(nullptr);
 EXPECT_EQ(JXL_DEC_SUCCESS,
           JxlDecoderSubscribeEvents(dec.get(),
                                     JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE));
 EXPECT_EQ(JXL_DEC_SUCCESS, JxlDecoderSetInput(dec.get(), partial_file.data(),
                                               partial_file.size()));
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec.get()));
 EXPECT_EQ(JXL_DEC_NEED_MORE_INPUT, JxlDecoderProcessInput(dec.get()));
 JxlDecoderCloseInput(dec.get());
 EXPECT_EQ(JXL_DEC_ERROR, JxlDecoderProcessInput(dec.get()));
}