// 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());
--> --------------------
--> maximum size reached
--> --------------------
