beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-21 23:20:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Userland/Utilities/icc.cpp

445 lines
24 KiB
C++
Raw Normal View History

LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
/*
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
* Copyright (c) 2022-2023, Nico Weber <thakis@chromium.org>
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
LibGfx+icc: Make device manufacturer and device model clickable
2023-01-21 21:14:39 +00:00
#include <AK/String.h>
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
#include <AK/StringView.h>
#include <LibCore/ArgsParser.h>
icc: Print profile creation time
2022-12-27 18:38:08 +00:00
#include <LibCore/DateTime.h>
icc: Add flags for writing and dumping profiles This adds three flags to icc: * --reencode-to=<file> re-serializes a profile to a given file, using Gfx::ICC::encode(). This is mainly useful for testing that code. * --dump-to=<file> dumps the raw ICC profile bytes read from the input to disk. This is useful for extracting ICC profiles from images, and for comparing the raw profile bytes to the profile bytes written by --reencode-to=. If either of these flags is passed, icc by default no longer dumps the icc data to stdout. To force priting of the data even if either of these flags is present, this also adds: * --print, which forces printing ICC contents, even if either or both of the icc-data writing flags are present.
2023-02-17 18:24:08 +00:00
#include <LibCore/File.h>
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
#include <LibCore/MappedFile.h>
icc: Add flags for writing and dumping profiles This adds three flags to icc: * --reencode-to=<file> re-serializes a profile to a given file, using Gfx::ICC::encode(). This is mainly useful for testing that code. * --dump-to=<file> dumps the raw ICC profile bytes read from the input to disk. This is useful for extracting ICC profiles from images, and for comparing the raw profile bytes to the profile bytes written by --reencode-to=. If either of these flags is passed, icc by default no longer dumps the icc data to stdout. To force priting of the data even if either of these flags is present, this also adds: * --print, which forces printing ICC contents, even if either or both of the icc-data writing flags are present.
2023-02-17 18:24:08 +00:00
#include <LibGfx/ICC/BinaryWriter.h>
LibGfx: Move ICCProfile.{h,cpp} to ICC/Profile.{h,cpp}
2023-01-27 19:41:42 +00:00
#include <LibGfx/ICC/Profile.h>
LibGfx: Split ICC/Profile.{h,cpp} into several files s15Fixed16Number and XYZNumber are somewhat awkwardly duplicated in both Profile.cpp and TagTypes.cpp. Other than that, this is a pure code move. No behavior change.
2023-01-27 19:58:02 +00:00
#include <LibGfx/ICC/Tags.h>
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
#include <LibGfx/ICC/WellKnownProfiles.h>
LibGfx: Move all image loaders and writers to a subdirectory
2023-03-21 18:58:06 +00:00
#include <LibGfx/ImageFormats/ImageDecoder.h>
LibGfx+icc: Read cicpType This is a very new tag used for HDR content. The only files I know that use it are the jpegs on https://ccameron-chromium.github.io/hdr-jpeg/ But they have an invalid ICC creation date, so `icc` can't process them. (Commenting out the check for that does allow to print them.) If the CIPC tag is present, it takes precedence about the actual data in the profile and from what I understand, the ICC profile is basically ignored. See https://www.color.org/events/HDR_experts.xalter for background, in particular https://www.color.org/hdr/02-Luke_Wallis.pdf (but the other talks are very interesting too). (PNG also has a cICP chunk that's supposed to take precedence over iCCP.)
2023-02-08 02:35:14 +00:00
#include <LibVideo/Color/CodingIndependentCodePoints.h>
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
LibGfx+icc: Make device manufacturer and device model clickable
2023-01-21 21:14:39 +00:00
template<class T>
static ErrorOr<String> hyperlink(URL const& target, T const& label)
{
return String::formatted("\033]8;;{}\033\\{}\033]8;;\033\\", target, label);
}
icc: Extract out_optional() function
2023-01-06 20:57:31 +00:00
template<class T>
LibGfx+icc: Add ICCProfile support for textDescriptionType and print it This is used in v2 profiles for the required 'desc' tag. In v2 profiles, it's also used by the 'dmnd', 'dmdd', 'scrd', 'vued' tags. In v4 profiles, these all use 'mluc' instead (except for 'scrd', which is no longer part of the spec in v4).
2023-01-23 02:49:05 +00:00
static void out_optional(char const* label, Optional<T> const& optional)
icc: Extract out_optional() function
2023-01-06 20:57:31 +00:00
{
out("{}: ", label);
if (optional.has_value())
outln("{}", *optional);
else
outln("(not set)");
}
icc: Dump embedded non-parametric curves in lutAToBType and lutAToBType
2023-02-12 16:39:53 +00:00
static void out_curve(Gfx::ICC::CurveTagData const& curve, int indent_amount)
{
auto indent = MUST(String::repeated(' ', indent_amount));
if (curve.values().is_empty()) {
outln("{}identity curve", indent);
} else if (curve.values().size() == 1) {
outln("{}gamma: {}", indent, FixedPoint<8, u16>::create_raw(curve.values()[0]));
} else {
// FIXME: Maybe print the actual points if -v is passed?
outln("{}curve with {} points", indent, curve.values().size());
}
}
icc: Dump embedded parametric curves in lutAToBType and lutAToBType
2023-02-12 16:34:24 +00:00
static void out_parametric_curve(Gfx::ICC::ParametricCurveTagData const& parametric_curve, int indent_amount)
{
auto indent = MUST(String::repeated(' ', indent_amount));
switch (parametric_curve.function_type()) {
case Gfx::ICC::ParametricCurveTagData::FunctionType::Type0:
outln("{}Y = X**{}", indent, parametric_curve.g());
break;
case Gfx::ICC::ParametricCurveTagData::FunctionType::Type1:
outln("{}Y = ({}*X + {})**{} if X >= -{}/{}", indent,
parametric_curve.a(), parametric_curve.b(), parametric_curve.g(), parametric_curve.b(), parametric_curve.a());
outln("{}Y = 0 else", indent);
break;
case Gfx::ICC::ParametricCurveTagData::FunctionType::Type2:
outln("{}Y = ({}*X + {})**{} + {} if X >= -{}/{}", indent,
parametric_curve.a(), parametric_curve.b(), parametric_curve.g(), parametric_curve.c(), parametric_curve.b(), parametric_curve.a());
outln("{}Y = {} else", indent, parametric_curve.c());
break;
case Gfx::ICC::ParametricCurveTagData::FunctionType::Type3:
outln("{}Y = ({}*X + {})**{} if X >= {}", indent,
parametric_curve.a(), parametric_curve.b(), parametric_curve.g(), parametric_curve.d());
outln("{}Y = {}*X else", indent, parametric_curve.c());
break;
case Gfx::ICC::ParametricCurveTagData::FunctionType::Type4:
outln("{}Y = ({}*X + {})**{} + {} if X >= {}", indent,
parametric_curve.a(), parametric_curve.b(), parametric_curve.g(), parametric_curve.e(), parametric_curve.d());
outln("{}Y = {}*X + {} else", indent, parametric_curve.c(), parametric_curve.f());
break;
}
}
icc: Extract out_curve_tag() helper function
2023-04-11 12:52:56 +00:00
static void out_curve_tag(Gfx::ICC::TagData const& tag, int indent_amount)
{
VERIFY(tag.type() == Gfx::ICC::CurveTagData::Type || tag.type() == Gfx::ICC::ParametricCurveTagData::Type);
if (tag.type() == Gfx::ICC::CurveTagData::Type)
out_curve(static_cast<Gfx::ICC::CurveTagData const&>(tag), indent_amount);
if (tag.type() == Gfx::ICC::ParametricCurveTagData::Type)
out_parametric_curve(static_cast<Gfx::ICC::ParametricCurveTagData const&>(tag), indent_amount);
}
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
static void out_curves(Vector<Gfx::ICC::LutCurveType> const& curves)
{
for (auto const& curve : curves) {
VERIFY(curve->type() == Gfx::ICC::CurveTagData::Type || curve->type() == Gfx::ICC::ParametricCurveTagData::Type);
outln(" type {}, relative offset {}, size {}", curve->type(), curve->offset(), curve->size());
icc: Extract out_curve_tag() helper function
2023-04-11 12:52:56 +00:00
out_curve_tag(*curve, /*indent=*/12);
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
}
}
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
ErrorOr<int> serenity_main(Main::Arguments arguments)
{
Core::ArgsParser args_parser;
icc: Add flags for writing and dumping profiles This adds three flags to icc: * --reencode-to=<file> re-serializes a profile to a given file, using Gfx::ICC::encode(). This is mainly useful for testing that code. * --dump-to=<file> dumps the raw ICC profile bytes read from the input to disk. This is useful for extracting ICC profiles from images, and for comparing the raw profile bytes to the profile bytes written by --reencode-to=. If either of these flags is passed, icc by default no longer dumps the icc data to stdout. To force priting of the data even if either of these flags is present, this also adds: * --print, which forces printing ICC contents, even if either or both of the icc-data writing flags are present.
2023-02-17 18:24:08 +00:00
StringView path;
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
args_parser.add_positional_argument(path, "Path to ICC profile or to image containing ICC profile", "FILE", Core::ArgsParser::Required::No);
StringView name;
args_parser.add_option(name, "Name of a built-in profile, such as 'sRGB'", "name", 'n', "NAME");
icc: Add flags for writing and dumping profiles This adds three flags to icc: * --reencode-to=<file> re-serializes a profile to a given file, using Gfx::ICC::encode(). This is mainly useful for testing that code. * --dump-to=<file> dumps the raw ICC profile bytes read from the input to disk. This is useful for extracting ICC profiles from images, and for comparing the raw profile bytes to the profile bytes written by --reencode-to=. If either of these flags is passed, icc by default no longer dumps the icc data to stdout. To force priting of the data even if either of these flags is present, this also adds: * --print, which forces printing ICC contents, even if either or both of the icc-data writing flags are present.
2023-02-17 18:24:08 +00:00
StringView dump_out_path;
args_parser.add_option(dump_out_path, "Dump unmodified ICC profile bytes to this path", "dump-to", 0, "FILE");
StringView reencode_out_path;
args_parser.add_option(reencode_out_path, "Reencode ICC profile to this path", "reencode-to", 0, "FILE");
bool force_print = false;
args_parser.add_option(force_print, "Print profile even when writing ICC files", "print", 0);
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
args_parser.parse(arguments);
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
if (path.is_empty() && name.is_empty()) {
warnln("need either a path or a profile name");
return 1;
}
if (!path.is_empty() && !name.is_empty()) {
warnln("can't have both a path and a profile name");
return 1;
}
if (path.is_empty() && !dump_out_path.is_empty()) {
warnln("--dump-to only valid with path, not with profile name; use --reencode-to instead");
return 1;
}
icc: Accept path to images in addition to path to ICC profile
2023-01-26 20:16:21 +00:00
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
ReadonlyBytes icc_bytes;
NonnullRefPtr<Gfx::ICC::Profile> profile = TRY([&]() -> ErrorOr<NonnullRefPtr<Gfx::ICC::Profile>> {
if (!name.is_empty()) {
if (name == "sRGB")
return Gfx::ICC::sRGB();
return Error::from_string_literal("unknown profile name");
}
auto file = TRY(Core::MappedFile::map(path));
auto decoder = Gfx::ImageDecoder::try_create_for_raw_bytes(file->bytes());
if (decoder) {
if (auto embedded_icc_bytes = TRY(decoder->icc_data()); embedded_icc_bytes.has_value()) {
icc_bytes = *embedded_icc_bytes;
} else {
outln("image contains no embedded ICC profile");
exit(1);
}
icc: Accept path to images in addition to path to ICC profile
2023-01-26 20:16:21 +00:00
} else {
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
icc_bytes = file->bytes();
icc: Accept path to images in addition to path to ICC profile
2023-01-26 20:16:21 +00:00
}
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
if (!dump_out_path.is_empty()) {
auto output_stream = TRY(Core::File::open(dump_out_path, Core::File::OpenMode::Write));
AK: Rename Stream::write_entire_buffer to Stream::write_until_depleted No functional changes.
2023-03-01 14:37:45 +00:00
TRY(output_stream->write_until_depleted(icc_bytes));
icc: Introduce --name flag to load a built-in profile by name ...instead of from a file. For now, `--name=sRGB` is the only valid value, but more will probably follow in the future. Just `icc --name=sRGB` prints the built-in sRGB profile. `icc --name=sRGB --reencode-to=file.icc` writes it to file.icc.
2023-02-27 13:51:36 +00:00
}
return Gfx::ICC::Profile::try_load_from_externally_owned_memory(icc_bytes);
}());
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
icc: Add flags for writing and dumping profiles This adds three flags to icc: * --reencode-to=<file> re-serializes a profile to a given file, using Gfx::ICC::encode(). This is mainly useful for testing that code. * --dump-to=<file> dumps the raw ICC profile bytes read from the input to disk. This is useful for extracting ICC profiles from images, and for comparing the raw profile bytes to the profile bytes written by --reencode-to=. If either of these flags is passed, icc by default no longer dumps the icc data to stdout. To force priting of the data even if either of these flags is present, this also adds: * --print, which forces printing ICC contents, even if either or both of the icc-data writing flags are present.
2023-02-17 18:24:08 +00:00
if (!reencode_out_path.is_empty()) {
auto reencoded_bytes = TRY(Gfx::ICC::encode(profile));
auto output_stream = TRY(Core::File::open(reencode_out_path, Core::File::OpenMode::Write));
AK: Rename Stream::write_entire_buffer to Stream::write_until_depleted No functional changes.
2023-03-01 14:37:45 +00:00
TRY(output_stream->write_until_depleted(reencoded_bytes));
icc: Add flags for writing and dumping profiles This adds three flags to icc: * --reencode-to=<file> re-serializes a profile to a given file, using Gfx::ICC::encode(). This is mainly useful for testing that code. * --dump-to=<file> dumps the raw ICC profile bytes read from the input to disk. This is useful for extracting ICC profiles from images, and for comparing the raw profile bytes to the profile bytes written by --reencode-to=. If either of these flags is passed, icc by default no longer dumps the icc data to stdout. To force priting of the data even if either of these flags is present, this also adds: * --print, which forces printing ICC contents, even if either or both of the icc-data writing flags are present.
2023-02-17 18:24:08 +00:00
}
bool do_print = (dump_out_path.is_empty() && reencode_out_path.is_empty()) || force_print;
if (!do_print)
return 0;
icc: Print profile size
2023-01-28 01:51:34 +00:00
outln(" size: {} bytes", profile->on_disk_size());
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
out_optional(" preferred CMM type", profile->preferred_cmm_type());
outln(" version: {}", profile->version());
outln(" device class: {}", Gfx::ICC::device_class_name(profile->device_class()));
outln(" data color space: {}", Gfx::ICC::data_color_space_name(profile->data_color_space()));
outln(" connection space: {}", Gfx::ICC::profile_connection_space_name(profile->connection_space()));
icc: Remove needless use of DateTime::to_deprecated_string() Turns out DateTime has a Formatter that prints the same thing that to_deprecated_string() returns. No behavior change.
2023-01-21 01:46:39 +00:00
outln("creation date and time: {}", Core::DateTime::from_timestamp(profile->creation_timestamp()));
LibGfx+icc: ICCProfile's primary_platform() should be optional Found by running `icc` on a jpeg file produced by a Pixel phone after #17195.
2023-01-26 21:25:48 +00:00
out_optional(" primary platform", profile->primary_platform().map([](auto platform) { return primary_platform_name(platform); }));
LibGfx+icc: Print profile flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways.
2022-12-31 18:50:52 +00:00
auto flags = profile->flags();
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
outln(" flags: 0x{:08x}", flags.bits());
outln(" - {}embedded in file", flags.is_embedded_in_file() ? "" : "not ");
outln(" - can{} be used independently of embedded color data", flags.can_be_used_independently_of_embedded_color_data() ? "" : "not");
LibGfx+icc: Print profile flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways.
2022-12-31 18:50:52 +00:00
if (auto unknown_icc_bits = flags.icc_bits() & ~Gfx::ICC::Flags::KnownBitsMask)
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
outln(" other unknown ICC bits: 0x{:04x}", unknown_icc_bits);
LibGfx+icc: Print profile flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways.
2022-12-31 18:50:52 +00:00
if (auto color_management_module_bits = flags.color_management_module_bits())
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
outln(" CMM bits: 0x{:04x}", color_management_module_bits);
LibGfx+icc: Print profile flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways.
2022-12-31 18:50:52 +00:00
LibGfx+icc: Make device manufacturer and device model clickable
2023-01-21 21:14:39 +00:00
out_optional(" device manufacturer", TRY(profile->device_manufacturer().map([](auto device_manufacturer) {
return hyperlink(device_manufacturer_url(device_manufacturer), device_manufacturer);
})));
out_optional(" device model", TRY(profile->device_model().map([](auto device_model) {
return hyperlink(device_model_url(device_model), device_model);
})));
LibGfx+icc: Print fields that are fourccs registered with the ICC Namely: - preferred CMM type - device manufacturer - device model - profile creator These all have in common that they can take arbitrary values, so I added a FourCC class to deal with them, instead of using an enum class. I made distinct types for each of them, so that they aren't accidentally mixed up.
2023-01-06 20:57:45 +00:00
LibGfx+icc: Print device attribute flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways. And hey, it's just 86 lines to print 4 bits.
2023-01-06 20:06:30 +00:00
auto device_attributes = profile->device_attributes();
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
outln(" device attributes: 0x{:016x}", device_attributes.bits());
outln(" media is:");
outln(" - {}",
device_attributes.media_reflectivity() == Gfx::ICC::DeviceAttributes::MediaReflectivity::Reflective ? "reflective" : "transparent");
outln(" - {}",
device_attributes.media_glossiness() == Gfx::ICC::DeviceAttributes::MediaGlossiness::Glossy ? "glossy" : "matte");
outln(" - {}",
device_attributes.media_polarity() == Gfx::ICC::DeviceAttributes::MediaPolarity::Positive ? "of positive polarity" : "of negative polarity");
outln(" - {}",
LibGfx+icc: Print device attribute flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways. And hey, it's just 86 lines to print 4 bits.
2023-01-06 20:06:30 +00:00
device_attributes.media_color() == Gfx::ICC::DeviceAttributes::MediaColor::Colored ? "colored" : "black and white");
VERIFY((flags.icc_bits() & ~Gfx::ICC::DeviceAttributes::KnownBitsMask) == 0);
if (auto vendor_bits = device_attributes.vendor_bits())
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
outln(" vendor bits: 0x{:08x}", vendor_bits);
LibGfx+icc: Print device attribute flags These flags are always 0 in practice in all profiles I've seen so far, but hey, probably nice to dump them anyways. And hey, it's just 86 lines to print 4 bits.
2023-01-06 20:06:30 +00:00
icc: Tweak output to look nicer Align header on the `:`, and make bitmask output more structured.
2023-01-21 01:24:55 +00:00
outln(" rendering intent: {}", Gfx::ICC::rendering_intent_name(profile->rendering_intent()));
outln(" pcs illuminant: {}", profile->pcs_illuminant());
out_optional(" creator", profile->creator());
out_optional(" id", profile->id());
icc: Print profile id
2023-01-04 19:56:27 +00:00
icc: Accept path to images in addition to path to ICC profile
2023-01-26 20:16:21 +00:00
size_t profile_disk_size = icc_bytes.size();
LibGfx+icc: Look at profile_size field This trims the input bytes to the profile size stored in the file. Alternatively, we could reject files where the stored size doesn't match the handed in size. But ICC profiles can be embedded in other files, and those could conceivably pad the ICC profile data some.
2023-01-08 12:07:21 +00:00
if (profile_disk_size != profile->on_disk_size()) {
VERIFY(profile_disk_size > profile->on_disk_size());
outln("{} trailing bytes after profile data", profile_disk_size - profile->on_disk_size());
}
LibGfx: Add scaffolding for reading ICC tag table The idea is that we'll have one type for each tag type. For now, this treats all tag types as unknown, but it puts most of the infrastructure for reading tags in place.
2023-01-20 19:37:25 +00:00
outln("");
outln("tags:");
icc: Print every TagData object only once When several tags refer to the same TagData object, we now only print it the first time, and print "(see 'foob' above)" the following times, where `foob` is the tag identifier where we printed it the first time.
2023-01-24 00:34:48 +00:00
HashMap<Gfx::ICC::TagData*, Gfx::ICC::TagSignature> tag_data_to_first_signature;
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
TRY(profile->try_for_each_tag([&tag_data_to_first_signature](auto tag_signature, auto tag_data) -> ErrorOr<void> {
icc: Print each tag signature's spec name The spec names are still a bit cryptic ("deviceMfgDescTag" for "device manufacturer description"), but less cryptic than just the fourcc. There's a private tag area, so this will only print the spec name of tags in the current spec. Private tags are in active use, e.g.: $ icc /Library/ColorSync/Profiles/WebSafeColors.icc ... Unknown tag ('dscm'): type 'mluc', offset 312, size 1490 (That's a v2 file. In v2, 'desc' has that strange textDescriptionType. In v4, 'desc' has type 'mluc' -- but in v2, it didn't yet, so Apple invented the private 'dscm' tag which has the description as an 'mluc'.)
2023-01-24 20:24:39 +00:00
if (auto name = tag_signature_spec_name(tag_signature); name.has_value())
out("{} ({}): ", *name, tag_signature);
else
out("Unknown tag ({}): ", tag_signature);
outln("type {}, offset {}, size {}", tag_data->type(), tag_data->offset(), tag_data->size());
icc: Print TextTagData contents
2023-01-22 02:40:36 +00:00
icc: Print every TagData object only once When several tags refer to the same TagData object, we now only print it the first time, and print "(see 'foob' above)" the following times, where `foob` is the tag identifier where we printed it the first time.
2023-01-24 00:34:48 +00:00
// Print tag data only the first time it's seen.
// (Different sigatures can refer to the same data.)
auto it = tag_data_to_first_signature.find(tag_data);
if (it != tag_data_to_first_signature.end()) {
outln(" (see {} above)", it->value);
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
return {};
icc: Print every TagData object only once When several tags refer to the same TagData object, we now only print it the first time, and print "(see 'foob' above)" the following times, where `foob` is the tag identifier where we printed it the first time.
2023-01-24 00:34:48 +00:00
}
tag_data_to_first_signature.set(tag_data, tag_signature);
LibGfx+icc: Read chromaticityTag This isn't terribly useful. But some profiles, for example the ones at https://vpifg.com/help/icc-profiles/, do contain this tag and it seems nice to be able to dump it, just for completeness. I haven't seen any files that contain a phosphor or colorant type different from "Unknown", even for the Rec2020 profile on that page. (It has x,y coordinates that match the values required for Rec2020, but it doesn't set the phosphor or colorant type to that.)
2023-02-09 17:26:43 +00:00
if (tag_data->type() == Gfx::ICC::ChromaticityTagData::Type) {
auto& chromaticity = static_cast<Gfx::ICC::ChromaticityTagData&>(*tag_data);
outln(" phosphor or colorant type: {}", Gfx::ICC::ChromaticityTagData::phosphor_or_colorant_type_name(chromaticity.phosphor_or_colorant_type()));
for (auto const& xy : chromaticity.xy_coordinates())
outln(" x, y: {}, {}", xy.x, xy.y);
} else if (tag_data->type() == Gfx::ICC::CicpTagData::Type) {
LibGfx+icc: Read cicpType This is a very new tag used for HDR content. The only files I know that use it are the jpegs on https://ccameron-chromium.github.io/hdr-jpeg/ But they have an invalid ICC creation date, so `icc` can't process them. (Commenting out the check for that does allow to print them.) If the CIPC tag is present, it takes precedence about the actual data in the profile and from what I understand, the ICC profile is basically ignored. See https://www.color.org/events/HDR_experts.xalter for background, in particular https://www.color.org/hdr/02-Luke_Wallis.pdf (but the other talks are very interesting too). (PNG also has a cICP chunk that's supposed to take precedence over iCCP.)
2023-02-08 02:35:14 +00:00
auto& cicp = static_cast<Gfx::ICC::CicpTagData&>(*tag_data);
outln(" color primaries: {} - {}", cicp.color_primaries(),
Video::color_primaries_to_string((Video::ColorPrimaries)cicp.color_primaries()));
outln(" transfer characteristics: {} - {}", cicp.transfer_characteristics(),
Video::transfer_characteristics_to_string((Video::TransferCharacteristics)cicp.transfer_characteristics()));
outln(" matrix coefficients: {} - {}", cicp.matrix_coefficients(),
Video::matrix_coefficients_to_string((Video::MatrixCoefficients)cicp.matrix_coefficients()));
icc: Call video_full_range_flag_to_string()
2023-02-08 19:20:53 +00:00
outln(" video full range flag: {} - {}", cicp.video_full_range_flag(),
Video::video_full_range_flag_to_string((Video::VideoFullRangeFlag)cicp.video_full_range_flag()));
LibGfx+icc: Read cicpType This is a very new tag used for HDR content. The only files I know that use it are the jpegs on https://ccameron-chromium.github.io/hdr-jpeg/ But they have an invalid ICC creation date, so `icc` can't process them. (Commenting out the check for that does allow to print them.) If the CIPC tag is present, it takes precedence about the actual data in the profile and from what I understand, the ICC profile is basically ignored. See https://www.color.org/events/HDR_experts.xalter for background, in particular https://www.color.org/hdr/02-Luke_Wallis.pdf (but the other talks are very interesting too). (PNG also has a cICP chunk that's supposed to take precedence over iCCP.)
2023-02-08 02:35:14 +00:00
} else if (tag_data->type() == Gfx::ICC::CurveTagData::Type) {
icc: Extract out_curve_tag() helper function
2023-04-11 12:52:56 +00:00
out_curve_tag(*tag_data, /*indent=*/4);
LibGfx+icc: Read and display lut16Type and lut8Type ICC tag types
2023-01-28 20:27:36 +00:00
} else if (tag_data->type() == Gfx::ICC::Lut16TagData::Type) {
auto& lut16 = static_cast<Gfx::ICC::Lut16TagData&>(*tag_data);
outln(" input table: {} channels x {} entries", lut16.number_of_input_channels(), lut16.number_of_input_table_entries());
outln(" output table: {} channels x {} entries", lut16.number_of_output_channels(), lut16.number_of_output_table_entries());
outln(" color lookup table: {} grid points, {} total entries", lut16.number_of_clut_grid_points(), lut16.clut_values().size());
auto const& e = lut16.e_matrix();
outln(" e = [ {}, {}, {},", e[0], e[1], e[2]);
outln(" {}, {}, {},", e[3], e[4], e[5]);
outln(" {}, {}, {} ]", e[6], e[7], e[8]);
} else if (tag_data->type() == Gfx::ICC::Lut8TagData::Type) {
auto& lut8 = static_cast<Gfx::ICC::Lut8TagData&>(*tag_data);
outln(" input table: {} channels x {} entries", lut8.number_of_input_channels(), lut8.number_of_input_table_entries());
outln(" output table: {} channels x {} entries", lut8.number_of_output_channels(), lut8.number_of_output_table_entries());
outln(" color lookup table: {} grid points, {} total entries", lut8.number_of_clut_grid_points(), lut8.clut_values().size());
auto const& e = lut8.e_matrix();
outln(" e = [ {}, {}, {},", e[0], e[1], e[2]);
outln(" {}, {}, {},", e[3], e[4], e[5]);
outln(" {}, {}, {} ]", e[6], e[7], e[8]);
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
} else if (tag_data->type() == Gfx::ICC::LutAToBTagData::Type) {
auto& a_to_b = static_cast<Gfx::ICC::LutAToBTagData&>(*tag_data);
outln(" {} input channels, {} output channels", a_to_b.number_of_input_channels(), a_to_b.number_of_output_channels());
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
if (auto const& optional_a_curves = a_to_b.a_curves(); optional_a_curves.has_value()) {
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
outln(" a curves: {} curves", optional_a_curves->size());
out_curves(optional_a_curves.value());
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
} else {
outln(" a curves: (not set)");
}
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
if (auto const& optional_clut = a_to_b.clut(); optional_clut.has_value()) {
auto const& clut = optional_clut.value();
outln(" color lookup table: {} grid points, {}",
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
TRY(String::join(" x "sv, clut.number_of_grid_points_in_dimension)),
TRY(clut.values.visit(
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
[](Vector<u8> const& v) { return String::formatted("{} u8 entries", v.size()); },
[](Vector<u16> const& v) { return String::formatted("{} u16 entries", v.size()); })));
} else {
outln(" color lookup table: (not set)");
}
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
if (auto const& optional_m_curves = a_to_b.m_curves(); optional_m_curves.has_value()) {
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
outln(" m curves: {} curves", optional_m_curves->size());
out_curves(optional_m_curves.value());
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
} else {
outln(" m curves: (not set)");
}
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
if (auto const& optional_e = a_to_b.e_matrix(); optional_e.has_value()) {
auto const& e = optional_e.value();
outln(" e = [ {}, {}, {}, {},", e[0], e[1], e[2], e[9]);
outln(" {}, {}, {}, {},", e[3], e[4], e[5], e[10]);
outln(" {}, {}, {}, {} ]", e[6], e[7], e[8], e[11]);
} else {
outln(" e = (not set)");
}
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
outln(" b curves: {} curves", a_to_b.b_curves().size());
out_curves(a_to_b.b_curves());
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
} else if (tag_data->type() == Gfx::ICC::LutBToATagData::Type) {
auto& b_to_a = static_cast<Gfx::ICC::LutBToATagData&>(*tag_data);
outln(" {} input channels, {} output channels", b_to_a.number_of_input_channels(), b_to_a.number_of_output_channels());
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
outln(" b curves: {} curves", b_to_a.b_curves().size());
out_curves(b_to_a.b_curves());
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
if (auto const& optional_e = b_to_a.e_matrix(); optional_e.has_value()) {
auto const& e = optional_e.value();
outln(" e = [ {}, {}, {}, {},", e[0], e[1], e[2], e[9]);
outln(" {}, {}, {}, {},", e[3], e[4], e[5], e[10]);
outln(" {}, {}, {}, {} ]", e[6], e[7], e[8], e[11]);
} else {
outln(" e = (not set)");
}
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
if (auto const& optional_m_curves = b_to_a.m_curves(); optional_m_curves.has_value()) {
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
outln(" m curves: {} curves", optional_m_curves->size());
out_curves(optional_m_curves.value());
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
} else {
outln(" m curves: (not set)");
}
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
if (auto const& optional_clut = b_to_a.clut(); optional_clut.has_value()) {
auto const& clut = optional_clut.value();
outln(" color lookup table: {} grid points, {}",
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
TRY(String::join(" x "sv, clut.number_of_grid_points_in_dimension)),
TRY(clut.values.visit(
LibGfx+icc: Implement half of lutAToBType and lutBToAType These are among the permitted tag types of ATo0Tag and BToA0Tag, which are among the required tags of most profiles. They are the last permitted tag types for those profiles (the other are lut8Type or lut16Type, which are already implemented). They are pretty chonky types though, so this only implements support for the E matrix and the CLUT. Support for the various curves will be in a future PR.
2023-01-29 02:41:19 +00:00
[](Vector<u8> const& v) { return String::formatted("{} u8 entries", v.size()); },
[](Vector<u16> const& v) { return String::formatted("{} u16 entries", v.size()); })));
} else {
outln(" color lookup table: (not set)");
}
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
if (auto const& optional_a_curves = b_to_a.a_curves(); optional_a_curves.has_value()) {
icc: Dump more information about curves in lutAToBType and lutAToBType
2023-02-12 16:12:16 +00:00
outln(" a curves: {} curves", optional_a_curves->size());
out_curves(optional_a_curves.value());
icc: Dump some of lutAToBType and lutBToAType curve data
2023-02-12 15:05:13 +00:00
} else {
outln(" a curves: (not set)");
}
LibGfx+icc: Read measurementType Also not terribly useful in practice and mostly for completionism. Lightroom Classic-exported jpegs contain this type in their ICC data.
2023-02-09 21:14:32 +00:00
} else if (tag_data->type() == Gfx::ICC::MeasurementTagData::Type) {
auto& measurement = static_cast<Gfx::ICC::MeasurementTagData&>(*tag_data);
outln(" standard observer: {}", Gfx::ICC::MeasurementTagData::standard_observer_name(measurement.standard_observer()));
outln(" tristimulus value for measurement backing: {}", measurement.tristimulus_value_for_measurement_backing());
outln(" measurement geometry: {}", Gfx::ICC::MeasurementTagData::measurement_geometry_name(measurement.measurement_geometry()));
outln(" measurement flare: {} %", measurement.measurement_flare() * 100);
outln(" standard illuminant: {}", Gfx::ICC::MeasurementTagData::standard_illuminant_name(measurement.standard_illuminant()));
LibGfx+icc: Add ICCProfile support for curveType and print it
2023-01-23 18:14:20 +00:00
} else if (tag_data->type() == Gfx::ICC::MultiLocalizedUnicodeTagData::Type) {
icc: Print MultiLocalizedUnicodeTagData contents
2023-01-22 02:48:08 +00:00
auto& multi_localized_unicode = static_cast<Gfx::ICC::MultiLocalizedUnicodeTagData&>(*tag_data);
for (auto& record : multi_localized_unicode.records()) {
outln(" {:c}{:c}/{:c}{:c}: \"{}\"",
record.iso_639_1_language_code >> 8, record.iso_639_1_language_code & 0xff,
record.iso_3166_1_country_code >> 8, record.iso_3166_1_country_code & 0xff,
record.text);
}
LibGfx+icc: Read namedColor2Type This is the type of namedColor2Tag, which is a required tag in NamedColor profiles. The implementation is pretty basic for now and only exposes the numbers stored in the file directly (after endian conversion).
2023-02-07 14:49:03 +00:00
} else if (tag_data->type() == Gfx::ICC::NamedColor2TagData::Type) {
auto& named_colors = static_cast<Gfx::ICC::NamedColor2TagData&>(*tag_data);
outln(" vendor specific flag: 0x{:08x}", named_colors.vendor_specific_flag());
outln(" common name prefix: \"{}\"", named_colors.prefix());
outln(" common name suffix: \"{}\"", named_colors.suffix());
outln(" {} colors:", named_colors.size());
for (size_t i = 0; i < min(named_colors.size(), 5u); ++i) {
const auto& pcs = named_colors.pcs_coordinates(i);
// FIXME: Display decoded values? (See ICC v4 6.3.4.2 and 10.8.)
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
out(" \"{}\", PCS coordinates: 0x{:04x} 0x{:04x} 0x{:04x}", TRY(named_colors.color_name(i)), pcs.xyz.x, pcs.xyz.y, pcs.xyz.z);
LibGfx+icc: Read namedColor2Type This is the type of namedColor2Tag, which is a required tag in NamedColor profiles. The implementation is pretty basic for now and only exposes the numbers stored in the file directly (after endian conversion).
2023-02-07 14:49:03 +00:00
if (auto number_of_device_coordinates = named_colors.number_of_device_coordinates(); number_of_device_coordinates > 0) {
out(", device coordinates:");
for (size_t j = 0; j < number_of_device_coordinates; ++j)
out(" 0x{:04x}", named_colors.device_coordinates(i)[j]);
}
outln();
}
if (named_colors.size() > 5u)
outln(" ...");
LibGfx+icc: Add ICCProfile support for parametricCurveType and print it With this, we can parse all types required in v4 "Three-component matrix-based Input profiles".
2023-01-23 18:55:57 +00:00
} else if (tag_data->type() == Gfx::ICC::ParametricCurveTagData::Type) {
icc: Extract out_curve_tag() helper function
2023-04-11 12:52:56 +00:00
out_curve_tag(*tag_data, /*indent=*/4);
LibGfx+icc: Add ICCProfile support for s15Fixed16ArrayType and print it This is the type of the chromaticAdaptationTag, which is a required tag in v4 profiles for all non-DeviceLink profiles.
2023-01-23 16:00:22 +00:00
} else if (tag_data->type() == Gfx::ICC::S15Fixed16ArrayTagData::Type) {
// This tag can contain arbitrarily many fixed-point numbers, but in practice it's
// exclusively used for the 'chad' tag, where it always contains 9 values that
// represent a 3x3 matrix. So print the values in groups of 3.
auto& fixed_array = static_cast<Gfx::ICC::S15Fixed16ArrayTagData&>(*tag_data);
out(" [");
int i = 0;
for (auto value : fixed_array.values()) {
if (i > 0) {
out(",");
if (i % 3 == 0) {
outln();
out(" ");
}
}
out(" {}", value);
i++;
}
outln(" ]");
LibGfx+icc: Read signatureType This isn't used by any mandatory tags, and it's not terribly useful. But jpegs exported by Lightroom Classic write the 'tech' tag, and it seems nice to be able to dump its contents. signatureType stores a single u32 which for different tags with this type means different things. In each case, the value is one from a short table of valid values, suggesting this should be a per-tag enum class instead of a per-tag DistinctFourCC, per the comment at the top of DistincFourCC.h. On the other hand, 3 of the 4 tables have an explicit "It is possible that the ICC will define other signature values in the future" note, which suggests the FourCC might actually be the way to go. For now, just punt on that and manually dump the u32 in fourcc style in icc.cpp and don't add any to_string() methods that return a readable string based on the contents of these tables.
2023-02-07 20:15:55 +00:00
} else if (tag_data->type() == Gfx::ICC::SignatureTagData::Type) {
auto& signature = static_cast<Gfx::ICC::SignatureTagData&>(*tag_data);
LibGfx+icc: Stringify known signatureType values
2023-02-10 15:13:26 +00:00
if (auto name = signature.name_for_tag(tag_signature); name.has_value()) {
outln(" signature: {}", name.value());
} else {
outln(" signature: Unknown ('{:c}{:c}{:c}{:c}' / 0x{:08x})",
signature.signature() >> 24, (signature.signature() >> 16) & 0xff, (signature.signature() >> 8) & 0xff, signature.signature() & 0xff,
signature.signature());
}
LibGfx+icc: Add ICCProfile support for textDescriptionType and print it This is used in v2 profiles for the required 'desc' tag. In v2 profiles, it's also used by the 'dmnd', 'dmdd', 'scrd', 'vued' tags. In v4 profiles, these all use 'mluc' instead (except for 'scrd', which is no longer part of the spec in v4).
2023-01-23 02:49:05 +00:00
} else if (tag_data->type() == Gfx::ICC::TextDescriptionTagData::Type) {
auto& text_description = static_cast<Gfx::ICC::TextDescriptionTagData&>(*tag_data);
outln(" ascii: \"{}\"", text_description.ascii_description());
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
out_optional(" unicode", TRY(text_description.unicode_description().map([](auto description) { return String::formatted("\"{}\"", description); })));
LibGfx+icc: Add ICCProfile support for textDescriptionType and print it This is used in v2 profiles for the required 'desc' tag. In v2 profiles, it's also used by the 'dmnd', 'dmdd', 'scrd', 'vued' tags. In v4 profiles, these all use 'mluc' instead (except for 'scrd', which is no longer part of the spec in v4).
2023-01-23 02:49:05 +00:00
outln(" unicode language code: 0x{}", text_description.unicode_language_code());
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
out_optional(" macintosh", TRY(text_description.macintosh_description().map([](auto description) { return String::formatted("\"{}\"", description); })));
icc: Print MultiLocalizedUnicodeTagData contents
2023-01-22 02:48:08 +00:00
} else if (tag_data->type() == Gfx::ICC::TextTagData::Type) {
icc: Print TextTagData contents
2023-01-22 02:40:36 +00:00
outln(" text: \"{}\"", static_cast<Gfx::ICC::TextTagData&>(*tag_data).text());
LibGfx+icc: Read viewingConditionsType Not terribly useful in practice either and also mostly for completionism. But with this, we can dump all types present in Lightroom Classic-exported jpegs :^)
2023-02-10 01:18:11 +00:00
} else if (tag_data->type() == Gfx::ICC::ViewingConditionsTagData::Type) {
auto& viewing_conditions = static_cast<Gfx::ICC::ViewingConditionsTagData&>(*tag_data);
outln(" unnormalized CIEXYZ values for illuminant (in which Y is in cd/m²): {}", viewing_conditions.unnormalized_ciexyz_values_for_illuminant());
outln(" unnormalized CIEXYZ values for surround (in which Y is in cd/m²): {}", viewing_conditions.unnormalized_ciexyz_values_for_surround());
outln(" illuminant type: {}", Gfx::ICC::MeasurementTagData::standard_illuminant_name(viewing_conditions.illuminant_type()));
LibGfx+icc: Add ICCProfile support for XYZType and print it
2023-01-23 03:25:44 +00:00
} else if (tag_data->type() == Gfx::ICC::XYZTagData::Type) {
for (auto& xyz : static_cast<Gfx::ICC::XYZTagData&>(*tag_data).xyzs())
outln(" {}", xyz);
icc: Print TextTagData contents
2023-01-22 02:40:36 +00:00
}
LibGfx: Use ICC::Profile::try_for_each_tag in icc main loop I didn't use it in out_curve(), out_parametric_curve() since it wouldn't be necessary if I printed the indent with a loop instead of String::repeated() there.
2023-02-19 12:11:13 +00:00
return {};
}));
LibGfx: Add scaffolding for reading ICC tag table The idea is that we'll have one type for each tag type. For now, this treats all tag types as unknown, but it puts most of the infrastructure for reading tags in place.
2023-01-20 19:37:25 +00:00
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
return 0;
}
Reference in a new issue Copy permalink