impex/jxl/JPEGXLImport.cpp

0001 /*
0002  *  SPDX-FileCopyrightText: 2021 the JPEG XL Project Authors
0003  *  SPDX-License-Identifier: BSD-3-Clause
0004  *
0005  *  SPDX-FileCopyrightText: 2022 L. E. Segovia <amy@amyspark.me>
0006  *  SPDX-License-Identifier: GPL-2.0-or-later
0007  */
0008
0009 #include "JPEGXLImport.h"
0010
0011 #include <KisGlobalResourcesInterface.h>
0012
0013 #include <jxl/decode_cxx.h>
0014 #include <jxl/resizable_parallel_runner_cxx.h>
0015 #include <jxl/types.h>
0016 #include <kpluginfactory.h>
0017
0018 #include <QBuffer>
0019 #include <algorithm>
0020 #include <array>
0021 #include <cstring>
0022 #include <map>
0023
0024 #include <KisDocument.h>
0025 #include <KisImportExportErrorCode.h>
0026 #include <KoColorModelStandardIds.h>
0027 #include <KoColorProfile.h>
0028 #include <KoColorSpaceRegistry.h>
0029 #include <KoColorTransferFunctions.h>
0030 #include <KoConfig.h>
0031 #include <dialogs/kis_dlg_hlg_import.h>
0032 #include <filter/kis_filter.h>
0033 #include <filter/kis_filter_configuration.h>
0034 #include <filter/kis_filter_registry.h>
0035 #include <kis_assert.h>
0036 #include <kis_debug.h>
0037 #include <kis_group_layer.h>
0038 #include <kis_image_animation_interface.h>
0039 #include <kis_iterator_ng.h>
0040 #include <kis_meta_data_backend_registry.h>
0041 #include <kis_paint_layer.h>
0042 #include <kis_raster_keyframe_channel.h>
0043
0044 K_PLUGIN_FACTORY_WITH_JSON(ImportFactory, "krita_jxl_import.json", registerPlugin<JPEGXLImport>();)
0045
0046 static constexpr std::array<char, 4> exifTag = {'e', 'x', 'i', 'f'};
0047 static constexpr std::array<char, 4> xmpTag = {'x', 'm', 'l', ' '};
0048
0049 class Q_DECL_HIDDEN JPEGXLImportData
0050 {
0051 public:
0052     JxlBasicInfo m_info{};
0053     JxlExtraChannelInfo m_extra{};
0054     JxlPixelFormat m_pixelFormat{};
0055     JxlPixelFormat m_pixelFormat_target{};
0056     JxlFrameHeader m_header{};
0057     std::vector<quint8> m_rawData{};
0058     KisPaintDeviceSP m_currentFrame{nullptr};
0059     uint32_t cmykChannelID = 0;
0060     int m_nextFrameTime{0};
0061     int m_durationFrameInTicks{0};
0062     KoID m_colorID;
0063     KoID m_colorID_target;
0064     KoID m_depthID;
0065     KoID m_depthID_target;
0066     KoColorConversionTransformation::Intent m_intent;
0067     bool isCMYK = false;
0068     bool applyOOTF = true;
0069     float displayGamma = 1.2f;
0070     float displayNits = 1000.0;
0071     LinearizePolicy linearizePolicy = LinearizePolicy::KeepTheSame;
0072     const KoColorSpace *cs = nullptr;
0073     const KoColorSpace *cs_target = nullptr;
0074     const KoColorSpace *cs_intermediate = nullptr;
0075     std::vector<quint8> kPlane;
0076     QVector<qreal> lCoef;
0077 };
0078
0079 template<LinearizePolicy policy>
0080 inline float linearizeValueAsNeeded(float value)
0081 {
0082     if (policy == LinearizePolicy::LinearFromPQ) {
0083         return removeSmpte2048Curve(value);
0084     } else if (policy == LinearizePolicy::LinearFromHLG) {
0085         return removeHLGCurve(value);
0086     } else if (policy == LinearizePolicy::LinearFromSMPTE428) {
0087         return removeSMPTE_ST_428Curve(value);
0088     }
0089     return value;
0090 }
0091
0092 template<LinearizePolicy policy, typename T, typename std::enable_if_t<std::numeric_limits<T>::is_integer, int> = 1>
0093 inline float value(const T *src, size_t ch)
0094 {
0095     float v = float(src[ch]) / float(std::numeric_limits<T>::max());
0096
0097     return linearizeValueAsNeeded<policy>(v);
0098 }
0099
0100 template<LinearizePolicy policy, typename T, typename std::enable_if_t<!std::numeric_limits<T>::is_integer, int> = 1>
0101 inline float value(const T *src, size_t ch)
0102 {
0103     float v = float(src[ch]);
0104
0105     return linearizeValueAsNeeded<policy>(v);
0106 }
0107
0108 template<typename channelsType, bool swap, LinearizePolicy policy, bool applyOOTF>
0109 inline void imageOutCallback(JPEGXLImportData &d)
0110 {
0111     const uint32_t xPos = d.m_header.layer_info.crop_x0;
0112     const uint32_t yPos = d.m_header.layer_info.crop_y0;
0113     const uint32_t width = d.m_header.layer_info.xsize;
0114     const uint32_t height = d.m_header.layer_info.ysize;
0115     KisHLineIteratorSP it = d.m_currentFrame->createHLineIteratorNG(xPos, yPos, width);
0116
0117     const auto *src = reinterpret_cast<const channelsType *>(d.m_rawData.data());
0118     const uint32_t channels = d.m_pixelFormat.num_channels;
0119
0120     if (policy != LinearizePolicy::KeepTheSame) {
0121         const KoColorSpace *cs = d.cs;
0122         const double *lCoef = d.lCoef.constData();
0123         QVector<float> pixelValues(static_cast<int>(cs->channelCount()));
0124         float *tmp = pixelValues.data();
0125         const quint32 alphaPos = cs->alphaPos();
0126
0127         for (size_t j = 0; j < height; j++) {
0128             for (size_t i = 0; i < width; i++) {
0129                 for (size_t i = 0; i < channels; i++) {
0130                     tmp[i] = 1.0;
0131                 }
0132
0133                 for (size_t ch = 0; ch < channels; ch++) {
0134                     if (ch == alphaPos) {
0135                         tmp[ch] = value<LinearizePolicy::KeepTheSame, channelsType>(src, ch);
0136                     } else {
0137                         tmp[ch] = value<policy, channelsType>(src, ch);
0138                     }
0139                 }
0140
0141                 if (swap) {
0142                     std::swap(tmp[0], tmp[2]);
0143                 }
0144
0145                 if (policy == LinearizePolicy::LinearFromHLG && applyOOTF) {
0146                     applyHLGOOTF(tmp, lCoef, d.displayGamma, d.displayNits);
0147                 }
0148
0149                 cs->fromNormalisedChannelsValue(it->rawData(), pixelValues);
0150
0151                 src += d.m_pixelFormat.num_channels;
0152
0153                 it->nextPixel();
0154             }
0155             it->nextRow();
0156         }
0157     } else {
0158         for (size_t j = 0; j < height; j++) {
0159             for (size_t i = 0; i < width; i++) {
0160                 auto *dst = reinterpret_cast<channelsType *>(it->rawData());
0161
0162                 std::memcpy(dst, src, channels * sizeof(channelsType));
0163
0164                 if (swap) {
0165                     std::swap(dst[0], dst[2]);
0166                 } else if (d.isCMYK && d.m_info.uses_original_profile) {
0167                     // Swap alpha and key channel for CMYK
0168                     std::swap(dst[3], dst[4]);
0169                 }
0170
0171                 src += d.m_pixelFormat.num_channels;
0172
0173                 it->nextPixel();
0174             }
0175             it->nextRow();
0176         }
0177     }
0178 }
0179
0180 template<typename channelsType, bool swap, LinearizePolicy policy>
0181 inline void generateCallbackWithPolicy(JPEGXLImportData &d)
0182 {
0183     if (d.applyOOTF) {
0184         imageOutCallback<channelsType, swap, policy, true>(d);
0185     } else {
0186         imageOutCallback<channelsType, swap, policy, false>(d);
0187     }
0188 }
0189
0190 template<typename channelsType, bool swap>
0191 inline void generateCallbackWithSwap(JPEGXLImportData &d)
0192 {
0193     switch (d.linearizePolicy) {
0194     case LinearizePolicy::LinearFromPQ:
0195         generateCallbackWithPolicy<channelsType, swap, LinearizePolicy::LinearFromPQ>(d);
0196         break;
0197     case LinearizePolicy::LinearFromHLG:
0198         generateCallbackWithPolicy<channelsType, swap, LinearizePolicy::LinearFromHLG>(d);
0199         break;
0200     case LinearizePolicy::LinearFromSMPTE428:
0201         generateCallbackWithPolicy<channelsType, swap, LinearizePolicy::LinearFromSMPTE428>(d);
0202         break;
0203     case LinearizePolicy::KeepTheSame:
0204     default:
0205         generateCallbackWithPolicy<channelsType, swap, LinearizePolicy::KeepTheSame>(d);
0206         break;
0207     };
0208 }
0209
0210 template<typename channelsType>
0211 inline void generateCallbackWithType(JPEGXLImportData &d)
0212 {
0213     if (d.m_colorID == RGBAColorModelID
0214         && (d.m_depthID == Integer8BitsColorDepthID || d.m_depthID == Integer16BitsColorDepthID)
0215         && d.linearizePolicy == LinearizePolicy::KeepTheSame) {
0216         generateCallbackWithSwap<channelsType, true>(d);
0217     } else {
0218         generateCallbackWithSwap<channelsType, false>(d);
0219     }
0220 }
0221
0222 inline void generateCallback(JPEGXLImportData &d)
0223 {
0224     switch (d.m_pixelFormat.data_type) {
0225     case JXL_TYPE_FLOAT:
0226         return generateCallbackWithType<float>(d);
0227     case JXL_TYPE_UINT8:
0228         return generateCallbackWithType<uint8_t>(d);
0229     case JXL_TYPE_UINT16:
0230         return generateCallbackWithType<uint16_t>(d);
0231 #ifdef HAVE_OPENEXR
0232     case JXL_TYPE_FLOAT16:
0233         return generateCallbackWithType<half>(d);
0234         break;
0235 #endif
0236     default:
0237         KIS_ASSERT_X(false, "JPEGXL::generateCallback", "Unknown image format!");
0238     }
0239 }
0240
0241 JPEGXLImport::JPEGXLImport(QObject *parent, const QVariantList &)
0242     : KisImportExportFilter(parent)
0243 {
0244 }
0245
0246 KisImportExportErrorCode
0247 JPEGXLImport::convert(KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP /*configuration*/)
0248 {
0249     if (!io->isReadable()) {
0250         errFile << "Cannot read image contents";
0251         return ImportExportCodes::NoAccessToRead;
0252     }
0253
0254     JPEGXLImportData d{};
0255
0256     // Multi-threaded parallel runner.
0257     auto runner = JxlResizableParallelRunnerMake(nullptr);
0258     auto dec = JxlDecoderMake(nullptr);
0259
0260     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(runner && dec, ImportExportCodes::InternalError);
0261
0262     // Set coalescing FALSE to enable layered JXL
0263     if (JXL_DEC_SUCCESS != JxlDecoderSetCoalescing(dec.get(), JXL_FALSE)) {
0264         errFile << "JxlDecoderSetCoalescing failed";
0265         return ImportExportCodes::InternalError;
0266     }
0267     bool decSetCoalescing = false;
0268
0269     if (JXL_DEC_SUCCESS
0270         != JxlDecoderSubscribeEvents(dec.get(),
0271                                      JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FULL_IMAGE | JXL_DEC_BOX
0272                                          | JXL_DEC_FRAME)) {
0273         errFile << "JxlDecoderSubscribeEvents failed";
0274         return ImportExportCodes::InternalError;
0275     }
0276
0277     if (JXL_DEC_SUCCESS != JxlDecoderSetParallelRunner(dec.get(), JxlResizableParallelRunner, runner.get())) {
0278         errFile << "JxlDecoderSetParallelRunner failed";
0279         return ImportExportCodes::InternalError;
0280     }
0281
0282     const auto data = io->readAll();
0283
0284     const auto validation =
0285         JxlSignatureCheck(reinterpret_cast<const uint8_t *>(data.constData()), static_cast<size_t>(data.size()));
0286
0287     switch (validation) {
0288     case JXL_SIG_NOT_ENOUGH_BYTES:
0289         errFile << "Failed magic byte validation, not enough data";
0290         return ImportExportCodes::FileFormatIncorrect;
0291     case JXL_SIG_INVALID:
0292         errFile << "Failed magic byte validation, incorrect format";
0293         return ImportExportCodes::FileFormatIncorrect;
0294     default:
0295         break;
0296     }
0297
0298     if (JXL_DEC_SUCCESS
0299         != JxlDecoderSetInput(dec.get(),
0300                               reinterpret_cast<const uint8_t *>(data.constData()),
0301                               static_cast<size_t>(data.size()))) {
0302         errFile << "JxlDecoderSetInput failed";
0303         return ImportExportCodes::InternalError;
0304     };
0305     JxlDecoderCloseInput(dec.get());
0306     if (JXL_DEC_SUCCESS != JxlDecoderSetDecompressBoxes(dec.get(), JXL_TRUE)) {
0307         errFile << "JxlDecoderSetDecompressBoxes failed";
0308         return ImportExportCodes::InternalError;
0309     };
0310
0311     KisImageSP image{nullptr};
0312     KisLayerSP layer{nullptr};
0313     std::multimap<QByteArray, QByteArray> metadataBoxes;
0314     std::vector<KisLayerSP> additionalLayers;
0315     bool bgLayerSet = false;
0316     bool needColorTransform = false;
0317     bool needIntermediateTransform = false;
0318     QByteArray boxType(5, 0x0);
0319     QByteArray box(16384, 0x0);
0320     auto boxSize = box.size();
0321
0322     // List of blend mode that we can currently support
0323     static constexpr std::array<JxlBlendMode, 3> supportedBlendMode = {JXL_BLEND_REPLACE, JXL_BLEND_BLEND, JXL_BLEND_MULADD};
0324
0325     // Internal function to rewind decoder and enable coalescing
0326     auto rewindDecoderWithCoalesce = [&]() {
0327         // Check to make sure coalescing only called once,
0328         // otherwise it can trigger an infinite loop if we forgot to check decSetCoalescing when decoding below
0329         if (decSetCoalescing) {
0330             return false;
0331         }
0332         JxlDecoderRewind(dec.get());
0333         if (JXL_DEC_SUCCESS != JxlDecoderSetCoalescing(dec.get(), JXL_TRUE)) {
0334             errFile << "JxlDecoderSetCoalescing failed";
0335             return false;
0336         }
0337         if (JXL_DEC_SUCCESS
0338             != JxlDecoderSubscribeEvents(dec.get(),
0339                                          JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FULL_IMAGE | JXL_DEC_BOX
0340                                              | JXL_DEC_FRAME)) {
0341             errFile << "JxlDecoderSubscribeEvents failed";
0342             return false;
0343         }
0344         if (JXL_DEC_SUCCESS != JxlDecoderSetParallelRunner(dec.get(), JxlResizableParallelRunner, runner.get())) {
0345             errFile << "JxlDecoderSetParallelRunner failed";
0346             return false;
0347         }
0348         if (JXL_DEC_SUCCESS
0349             != JxlDecoderSetInput(dec.get(),
0350                                   reinterpret_cast<const uint8_t *>(data.constData()),
0351                                   static_cast<size_t>(data.size()))) {
0352             errFile << "JxlDecoderSetInput failed";
0353             return false;
0354         };
0355         JxlDecoderCloseInput(dec.get());
0356         if (JXL_DEC_SUCCESS != JxlDecoderSetDecompressBoxes(dec.get(), JXL_TRUE)) {
0357             errFile << "JxlDecoderSetDecompressBoxes failed";
0358             return false;
0359         };
0360         decSetCoalescing = true;
0361         return true;
0362     };
0363
0364     for (;;) {
0365         JxlDecoderStatus status = JxlDecoderProcessInput(dec.get());
0366
0367         if (status == JXL_DEC_ERROR) {
0368             errFile << "Decoder error";
0369             return ImportExportCodes::InternalError;
0370         } else if (status == JXL_DEC_NEED_MORE_INPUT) {
0371             errFile << "Error, already provided all input";
0372             return ImportExportCodes::InternalError;
0373         } else if (status == JXL_DEC_BASIC_INFO) {
0374             if (JXL_DEC_SUCCESS != JxlDecoderGetBasicInfo(dec.get(), &d.m_info)) {
0375                 errFile << "JxlDecoderGetBasicInfo failed";
0376                 return ImportExportCodes::ErrorWhileReading;
0377             }
0378             // Coalesce frame on animation import
0379             if (d.m_info.have_animation && !decSetCoalescing) {
0380                 if (!rewindDecoderWithCoalesce()) {
0381                     return ImportExportCodes::InternalError;
0382                 } else {
0383                     continue;
0384                 }
0385             }
0386
0387             dbgFile << "Extra Channel[s] info:";
0388             for (uint32_t i = 0; i < d.m_info.num_extra_channels; i++) {
0389                 if (JXL_DEC_SUCCESS != JxlDecoderGetExtraChannelInfo(dec.get(), i, &d.m_extra)) {
0390                     errFile << "JxlDecoderGetExtraChannelInfo failed";
0391                     break;
0392                 }
0393                 // Channel name references taken from libjxl repo:
0394                 // https://github.com/libjxl/libjxl/blob/v0.8.0/lib/extras/enc/pnm.cc#L262
0395                 // With added "JXL-" prefix to indicate that it comes from JXL image.
0396                 const QString channelTypeString = [&]() {
0397                     switch (d.m_extra.type) {
0398                     case JXL_CHANNEL_ALPHA:
0399                         return QString("JXL-Alpha");
0400                     case JXL_CHANNEL_DEPTH:
0401                         return QString("JXL-Depth");
0402                     case JXL_CHANNEL_SPOT_COLOR:
0403                         return QString("JXL-SpotColor");
0404                     case JXL_CHANNEL_SELECTION_MASK:
0405                         return QString("JXL-SelectionMask");
0406                     case JXL_CHANNEL_BLACK:
0407                         return QString("JXL-Black");
0408                     case JXL_CHANNEL_CFA:
0409                         return QString("JXL-CFA");
0410                     case JXL_CHANNEL_THERMAL:
0411                         return QString("JXL-Thermal");
0412                     default:
0413                         return QString("JXL-UNKNOWN");
0414                     }
0415                 }();
0416
0417                 // List all extra channels
0418                 dbgFile << "index:" << i << " | type:" << channelTypeString;
0419                 if (d.m_extra.type == JXL_CHANNEL_BLACK) {
0420                     d.isCMYK = true;
0421                     d.cmykChannelID = i;
0422                 }
0423                 if (d.m_extra.type == JXL_CHANNEL_SPOT_COLOR && !decSetCoalescing) {
0424                     warnFile << "Spot color channels unsupported! Rewinding decoder with coalescing enabled";
0425                     document->setWarningMessage(i18nc("JPEG-XL errors",
0426                                                       "Detected JPEG-XL image with spot color channels, "
0427                                                       "importing flattened image."));
0428                     if (!rewindDecoderWithCoalesce()) {
0429                         return ImportExportCodes::InternalError;
0430                     } else {
0431                         continue;
0432                     }
0433                 }
0434             }
0435
0436             dbgFile << "Info";
0437             dbgFile << "Size:" << d.m_info.xsize << "x" << d.m_info.ysize;
0438             dbgFile << "Depth:" << d.m_info.bits_per_sample << d.m_info.exponent_bits_per_sample;
0439             dbgFile << "Number of color channels:" << d.m_info.num_color_channels;
0440             dbgFile << "Number of extra channels:" << d.m_info.num_extra_channels;
0441             dbgFile << "Extra channels depth:" << d.m_info.alpha_bits << d.m_info.alpha_exponent_bits;
0442             dbgFile << "Has animation:" << d.m_info.have_animation << "loops:" << d.m_info.animation.num_loops
0443                     << "tick:" << d.m_info.animation.tps_numerator << d.m_info.animation.tps_denominator;
0444             dbgFile << "Internal pixel format:" << (d.m_info.uses_original_profile ? "Original" : "XYB");
0445             JxlResizableParallelRunnerSetThreads(
0446                 runner.get(),
0447                 JxlResizableParallelRunnerSuggestThreads(d.m_info.xsize, d.m_info.ysize));
0448
0449             if (d.m_info.exponent_bits_per_sample != 0) {
0450                 if (d.m_info.bits_per_sample <= 16) {
0451                     d.m_pixelFormat.data_type = JXL_TYPE_FLOAT16;
0452                     d.m_depthID = Float16BitsColorDepthID;
0453                 } else if (d.m_info.bits_per_sample <= 32) {
0454                     d.m_pixelFormat.data_type = JXL_TYPE_FLOAT;
0455                     d.m_depthID = Float32BitsColorDepthID;
0456                 } else {
0457                     errFile << "Unsupported JPEG-XL input depth" << d.m_info.bits_per_sample
0458                             << d.m_info.exponent_bits_per_sample;
0459                     return ImportExportCodes::FormatFeaturesUnsupported;
0460                 }
0461             } else if (d.m_info.bits_per_sample <= 8) {
0462                 d.m_pixelFormat.data_type = JXL_TYPE_UINT8;
0463                 d.m_depthID = Integer8BitsColorDepthID;
0464             } else if (d.m_info.bits_per_sample <= 16) {
0465                 d.m_pixelFormat.data_type = JXL_TYPE_UINT16;
0466                 d.m_depthID = Integer16BitsColorDepthID;
0467             } else {
0468                 errFile << "Unsupported JPEG-XL input depth" << d.m_info.bits_per_sample
0469                         << d.m_info.exponent_bits_per_sample;
0470                 return ImportExportCodes::FormatFeaturesUnsupported;
0471             }
0472
0473             if (d.m_info.num_color_channels == 1) {
0474                 // Grayscale
0475                 d.m_pixelFormat.num_channels = 2;
0476                 d.m_colorID = GrayAColorModelID;
0477             } else if (d.m_info.num_color_channels == 3 && !d.isCMYK) {
0478                 // RGBA
0479                 d.m_pixelFormat.num_channels = 4;
0480                 d.m_colorID = RGBAColorModelID;
0481             } else if (d.m_info.num_color_channels == 3 && d.isCMYK) {
0482                 // CMYKA
0483                 d.m_pixelFormat.num_channels = 4;
0484                 d.m_colorID = CMYKAColorModelID;
0485             } else {
0486                 warnFile << "Forcing a RGBA conversion, unknown color space";
0487                 d.m_pixelFormat.num_channels = 4;
0488                 d.m_colorID = RGBAColorModelID;
0489             }
0490
0491             if (!d.m_info.uses_original_profile) {
0492                 d.m_pixelFormat_target.data_type = d.m_pixelFormat.data_type;
0493                 d.m_pixelFormat.data_type = JXL_TYPE_FLOAT;
0494                 d.m_depthID_target = d.m_depthID;
0495                 d.m_colorID_target = d.m_colorID;
0496                 d.m_depthID = Float32BitsColorDepthID;
0497
0498                 if (d.m_colorID != GrayAColorModelID) {
0499                     d.m_colorID = RGBAColorModelID;
0500                 }
0501             }
0502         } else if (status == JXL_DEC_COLOR_ENCODING) {
0503             // Determine color space information
0504             const KoColorProfile *profile = nullptr;
0505             const KoColorProfile *profileTarget = nullptr;
0506             const KoColorProfile *profileIntermediate = nullptr;
0507
0508             // Chrome way of decoding JXL implies first scanning
0509             // the CICP encoding for HDR, and only afterwards
0510             // falling back to ICC.
0511             JxlColorEncoding colorEncoding{};
0512             if (JXL_DEC_SUCCESS
0513                 == JxlDecoderGetColorAsEncodedProfile(dec.get(),
0514 #if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0, 9, 0)
0515                                                       nullptr,
0516 #endif
0517                                                       JXL_COLOR_PROFILE_TARGET_DATA,
0518                                                       &colorEncoding)) {
0519                 const TransferCharacteristics transferFunction = [&]() {
0520                     switch (colorEncoding.transfer_function) {
0521                     case JXL_TRANSFER_FUNCTION_PQ: {
0522                         dbgFile << "linearizing from PQ";
0523                         d.linearizePolicy = LinearizePolicy::LinearFromPQ;
0524                         return TRC_LINEAR;
0525                     }
0526                     case JXL_TRANSFER_FUNCTION_HLG: {
0527                         dbgFile << "linearizing from HLG";
0528                         if (!document->fileBatchMode()) {
0529                             KisDlgHLGImport dlg(d.applyOOTF, d.displayGamma, d.displayNits);
0530                             dlg.exec();
0531                             d.applyOOTF = dlg.applyOOTF();
0532                             d.displayGamma = dlg.gamma();
0533                             d.displayNits = dlg.nominalPeakBrightness();
0534                         }
0535                         d.linearizePolicy = LinearizePolicy::LinearFromHLG;
0536                         return TRC_LINEAR;
0537                     }
0538                     case JXL_TRANSFER_FUNCTION_DCI: {
0539                         dbgFile << "linearizing from SMPTE 428";
0540                         d.linearizePolicy = LinearizePolicy::LinearFromSMPTE428;
0541                         return TRC_LINEAR;
0542                     }
0543                     case JXL_TRANSFER_FUNCTION_709:
0544                         return TRC_ITU_R_BT_709_5;
0545                     case JXL_TRANSFER_FUNCTION_SRGB:
0546                         return TRC_IEC_61966_2_1;
0547                     case JXL_TRANSFER_FUNCTION_GAMMA: {
0548                         // Using roughly the same logic in KoColorProfile.
0549                         const double estGamma = 1.0 / colorEncoding.gamma;
0550                         const double error = 0.0001;
0551                         // ICC v2 u8Fixed8Number calculation
0552                         // Or can be prequantized as 1.80078125, courtesy of Elle Stone
0553                         if ((std::fabs(estGamma - 1.8) < error) || (std::fabs(estGamma - (461.0 / 256.0)) < error)) {
0554                             return TRC_GAMMA_1_8;
0555                         } else if (std::fabs(estGamma - 2.2) < error) {
0556                             return TRC_ITU_R_BT_470_6_SYSTEM_M;
0557                         } else if (std::fabs(estGamma - (563.0 / 256.0)) < error) {
0558                             return TRC_A98;
0559                         } else if (std::fabs(estGamma - 2.4) < error) {
0560                             return TRC_GAMMA_2_4;
0561                         } else if (std::fabs(estGamma - 2.8) < error) {
0562                             return TRC_ITU_R_BT_470_6_SYSTEM_B_G;
0563                         } else {
0564                             warnFile << "Found custom estimated gamma value for JXL color space" << estGamma;
0565                             return TRC_UNSPECIFIED;
0566                         }
0567                     }
0568                     case JXL_TRANSFER_FUNCTION_LINEAR:
0569                         return TRC_LINEAR;
0570                     case JXL_TRANSFER_FUNCTION_UNKNOWN:
0571                     default:
0572                         warnFile << "Found unknown OETF";
0573                         return TRC_UNSPECIFIED;
0574                     }
0575                 }();
0576
0577                 const ColorPrimaries colorPrimaries = [&]() {
0578                     switch (colorEncoding.primaries) {
0579                     case JXL_PRIMARIES_SRGB:
0580                         return PRIMARIES_ITU_R_BT_709_5;
0581                     case JXL_PRIMARIES_2100:
0582                         return PRIMARIES_ITU_R_BT_2020_2_AND_2100_0;
0583                     case JXL_PRIMARIES_P3:
0584                         return PRIMARIES_SMPTE_RP_431_2;
0585                     default:
0586                         return PRIMARIES_UNSPECIFIED;
0587                     }
0588                 }();
0589
0590                 const QVector<double> colorants = [&]() -> QVector<double> {
0591                     if (colorEncoding.primaries != JXL_PRIMARIES_CUSTOM) {
0592                         return {};
0593                     } else {
0594                         return {colorEncoding.white_point_xy[0],
0595                                 colorEncoding.white_point_xy[1],
0596                                 colorEncoding.primaries_red_xy[0],
0597                                 colorEncoding.primaries_red_xy[1],
0598                                 colorEncoding.primaries_green_xy[0],
0599                                 colorEncoding.primaries_green_xy[1],
0600                                 colorEncoding.primaries_blue_xy[0],
0601                                 colorEncoding.primaries_blue_xy[1]};
0602                     }
0603                 }();
0604
0605                 if (colorEncoding.rendering_intent == JXL_RENDERING_INTENT_PERCEPTUAL) {
0606                     d.m_intent = KoColorConversionTransformation::IntentPerceptual;
0607                 } else if (colorEncoding.rendering_intent == JXL_RENDERING_INTENT_RELATIVE) {
0608                     d.m_intent = KoColorConversionTransformation::IntentRelativeColorimetric;
0609                 } else if (colorEncoding.rendering_intent == JXL_RENDERING_INTENT_ABSOLUTE) {
0610                     d.m_intent = KoColorConversionTransformation::IntentAbsoluteColorimetric;
0611                 } else if (colorEncoding.rendering_intent == JXL_RENDERING_INTENT_SATURATION) {
0612                     d.m_intent = KoColorConversionTransformation::IntentSaturation;
0613                 } else {
0614                     warnFile << "Cannot determine color rendering intent, set to Perceptual instead";
0615                     d.m_intent = KoColorConversionTransformation::IntentPerceptual;
0616                 }
0617
0618                 profile = KoColorSpaceRegistry::instance()->profileFor(colorants, colorPrimaries, transferFunction);
0619
0620                 dbgFile << "CICP profile data:" << colorants << colorPrimaries << transferFunction;
0621
0622                 if (profile) {
0623                     dbgFile << "JXL CICP profile found" << profile->name();
0624
0625                     if (d.linearizePolicy != LinearizePolicy::KeepTheSame) {
0626                         // Override output format!
0627                         d.m_depthID = Float32BitsColorDepthID;
0628                         d.m_pixelFormat.data_type = d.m_pixelFormat_target.data_type;
0629
0630                         // HDR is a special case because we need to linearize in-house
0631                         d.cs = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID.id(), d.m_depthID.id(), profile);
0632                     }
0633                 }
0634             }
0635
0636             if (!d.cs) {
0637                 size_t iccSize = 0;
0638                 QByteArray iccProfile;
0639                 if (JXL_DEC_SUCCESS
0640                     != JxlDecoderGetICCProfileSize(dec.get(),
0641 #if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0,9,0)
0642                                                    nullptr,
0643 #endif
0644                                                    JXL_COLOR_PROFILE_TARGET_DATA,
0645                                                    &iccSize)) {
0646                     errFile << "ICC profile size retrieval failed";
0647                     document->setErrorMessage(i18nc("JPEG-XL errors", "Unable to read the image profile."));
0648                     return ImportExportCodes::ErrorWhileReading;
0649                 }
0650                 iccProfile.resize(static_cast<int>(iccSize));
0651                 if (JXL_DEC_SUCCESS
0652                     != JxlDecoderGetColorAsICCProfile(dec.get(),
0653 #if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0,9,0)
0654                                                       nullptr,
0655 #endif
0656                                                       JXL_COLOR_PROFILE_TARGET_DATA,
0657                                                       reinterpret_cast<uint8_t *>(iccProfile.data()),
0658                                                       static_cast<size_t>(iccProfile.size()))) {
0659                     document->setErrorMessage(i18nc("JPEG-XL errors", "Unable to read the image profile."));
0660                     return ImportExportCodes::ErrorWhileReading;
0661                 }
0662
0663                 // Get original profile if XYB is used
0664                 size_t iccTargetSize = 0;
0665                 QByteArray iccTargetProfile;
0666                 if (!d.m_info.uses_original_profile) {
0667                     if (JXL_DEC_SUCCESS
0668                         != JxlDecoderGetICCProfileSize(dec.get(),
0669 #if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0,9,0)
0670                                                        nullptr,
0671 #endif
0672                                                        JXL_COLOR_PROFILE_TARGET_ORIGINAL,
0673                                                        &iccTargetSize)) {
0674                         errFile << "ICC profile size retrieval failed";
0675                         document->setErrorMessage(i18nc("JPEG-XL errors", "Unable to read the image profile."));
0676                         return ImportExportCodes::ErrorWhileReading;
0677                     }
0678                     iccTargetProfile.resize(static_cast<int>(iccTargetSize));
0679                     if (JXL_DEC_SUCCESS
0680                         != JxlDecoderGetColorAsICCProfile(dec.get(),
0681 #if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0,9,0)
0682                                                           nullptr,
0683 #endif
0684                                                           JXL_COLOR_PROFILE_TARGET_ORIGINAL,
0685                                                           reinterpret_cast<uint8_t *>(iccTargetProfile.data()),
0686                                                           static_cast<size_t>(iccTargetProfile.size()))) {
0687                         document->setErrorMessage(i18nc("JPEG-XL errors", "Unable to read the image profile."));
0688                         return ImportExportCodes::ErrorWhileReading;
0689                     }
0690                 }
0691
0692                 if (iccTargetSize && (iccProfile != iccTargetProfile)) {
0693                     // If the icc target is not 0 and different than target data.
0694                     // Meaning that the JXL is in XYB format and needing to convert back to
0695                     // the original color profile.
0696                     //
0697                     // Here we need to provide an intermediate transform space in float to prevent
0698                     // gamut clipping to sRGB if the target depth is integer.
0699                     dbgFile << "XYB with color transform needed";
0700                     needColorTransform = true;
0701                     profile = KoColorSpaceRegistry::instance()->createColorProfile(d.m_colorID.id(),
0702                                                                                    d.m_depthID.id(),
0703                                                                                    iccProfile);
0704                     d.cs = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID.id(), d.m_depthID.id(), profile);
0705                     profileIntermediate = KoColorSpaceRegistry::instance()->createColorProfile(d.m_colorID_target.id(),
0706                                                                                                d.m_depthID.id(),
0707                                                                                                iccTargetProfile);
0708                     d.cs_intermediate = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID_target.id(),
0709                                                                                      d.m_depthID.id(),
0710                                                                                      profileIntermediate);
0711                     profileTarget = KoColorSpaceRegistry::instance()->createColorProfile(d.m_colorID_target.id(),
0712                                                                                          d.m_depthID_target.id(),
0713                                                                                          iccTargetProfile);
0714                     d.cs_target = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID_target.id(),
0715                                                                                d.m_depthID_target.id(),
0716                                                                                profileTarget);
0717
0718                     // No need for intermediate transform on float since it won't get clipped.
0719                     if (!(d.m_depthID_target == Float16BitsColorDepthID
0720                           || d.m_depthID_target == Float32BitsColorDepthID)) {
0721                         needIntermediateTransform = true;
0722                     }
0723                 } else if (!d.m_info.uses_original_profile) {
0724                     // If XYB is used but the profiles are same, skip conversion.
0725                     // Also set the color depth target to default.
0726                     //
0727                     // Try to fetch profile from CICP first...
0728                     dbgFile << "XYB without color transform needed";
0729                     needColorTransform = false;
0730                     d.m_depthID = d.m_depthID_target;
0731                     d.m_colorID = d.m_colorID_target;
0732                     d.m_pixelFormat.data_type = d.m_pixelFormat_target.data_type;
0733                     d.cs = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID.id(), d.m_depthID.id(), profile);
0734
0735                     // ...or use ICC instead if CICP fetch failed.
0736                     if (!d.cs) {
0737                         dbgFile << "JXL CICP data couldn't be handled, falling back to ICC profile retrieval";
0738                         profile = KoColorSpaceRegistry::instance()->createColorProfile(d.m_colorID_target.id(),
0739                                                                                        d.m_depthID_target.id(),
0740                                                                                        iccProfile);
0741                         d.cs = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID_target.id(),
0742                                                                             d.m_depthID_target.id(),
0743                                                                             profile);
0744                     }
0745                 } else {
0746                     // Skip conversion on original profile.
0747                     dbgFile << "Original without color transform needed";
0748                     needColorTransform = false;
0749                     profile = KoColorSpaceRegistry::instance()->createColorProfile(d.m_colorID.id(),
0750                                                                                    d.m_depthID.id(),
0751                                                                                    iccProfile);
0752                     d.cs = KoColorSpaceRegistry::instance()->colorSpace(d.m_colorID.id(), d.m_depthID.id(), profile);
0753                 }
0754             }
0755
0756             if (d.cs_target) {
0757                 dbgFile << "Source profile:" << d.cs->profile()->name();
0758                 dbgFile << "Source space:" << d.cs->name() << d.cs->colorModelId() << d.cs->colorDepthId();
0759                 dbgFile << "Target profile:" << d.cs_target->profile()->name();
0760                 dbgFile << "Color space:" << d.cs_target->name() << d.cs_target->colorModelId()
0761                         << d.cs_target->colorDepthId();
0762             } else {
0763                 dbgFile << "Color space:" << d.cs->name() << d.cs->colorModelId() << d.cs->colorDepthId();
0764             }
0765             dbgFile << "JXL depth" << d.m_pixelFormat.data_type;
0766
0767             d.lCoef = d.cs->lumaCoefficients();
0768
0769             image = new KisImage(document->createUndoStore(),
0770                                  static_cast<int>(d.m_info.xsize),
0771                                  static_cast<int>(d.m_info.ysize),
0772                                  d.cs,
0773                                  "JPEG-XL image");
0774
0775             layer = new KisPaintLayer(image, image->nextLayerName(), UCHAR_MAX);
0776         } else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
0777             d.m_currentFrame = new KisPaintDevice(image->colorSpace());
0778
0779             // Use raw byte buffer instead of image callback
0780             size_t rawSize = 0;
0781             if (JXL_DEC_SUCCESS != JxlDecoderImageOutBufferSize(dec.get(), &d.m_pixelFormat, &rawSize)) {
0782                 qWarning() << "JxlDecoderImageOutBufferSize failed";
0783                 return ImportExportCodes::InternalError;
0784             }
0785             d.m_rawData.resize(rawSize);
0786             if (JXL_DEC_SUCCESS
0787                 != JxlDecoderSetImageOutBuffer(dec.get(),
0788                                                &d.m_pixelFormat,
0789                                                reinterpret_cast<uint8_t *>(d.m_rawData.data()),
0790                                                static_cast<size_t>(d.m_rawData.size()))) {
0791                 qWarning() << "JxlDecoderSetImageOutBuffer failed";
0792                 return ImportExportCodes::InternalError;
0793             }
0794
0795             if (d.isCMYK) {
0796                 // Prepare planar buffer for key channel
0797                 size_t bufferSize = 0;
0798                 if (JXL_DEC_SUCCESS
0799                     != JxlDecoderExtraChannelBufferSize(dec.get(), &d.m_pixelFormat, &bufferSize, d.cmykChannelID)) {
0800                     errFile << "JxlDecoderExtraChannelBufferSize failed";
0801                     return ImportExportCodes::ErrorWhileReading;
0802                     break;
0803                 }
0804                 d.kPlane.resize(bufferSize);
0805                 if (JXL_DEC_SUCCESS
0806                     != JxlDecoderSetExtraChannelBuffer(dec.get(),
0807                                                        &d.m_pixelFormat,
0808                                                        d.kPlane.data(),
0809                                                        bufferSize,
0810                                                        d.cmykChannelID)) {
0811                     errFile << "JxlDecoderSetExtraChannelBuffer failed";
0812                     return ImportExportCodes::ErrorWhileReading;
0813                     break;
0814                 }
0815             }
0816         } else if (status == JXL_DEC_FRAME) {
0817             if (JXL_DEC_SUCCESS != JxlDecoderGetFrameHeader(dec.get(), &d.m_header)) {
0818                 errFile << "JxlDecoderGetFrameHeader failed";
0819                 return ImportExportCodes::ErrorWhileReading;
0820             }
0821
0822             const JxlBlendMode blendMode = d.m_header.layer_info.blend_info.blendmode;
0823             const bool isBlendSupported =
0824                 std::find(supportedBlendMode.begin(), supportedBlendMode.end(), blendMode) != supportedBlendMode.end();
0825
0826             if (!isBlendSupported && !decSetCoalescing) {
0827                 warnFile << "Blending mode unsupported! Rewinding decoder with coalescing enabled";
0828                 document->setWarningMessage(i18nc("JPEG-XL errors",
0829                                                   "Detected multi layer JPEG-XL image with unsupported blending mode, "
0830                                                   "importing flattened image."));
0831                 if (!rewindDecoderWithCoalesce()) {
0832                     return ImportExportCodes::InternalError;
0833                 } else {
0834                     additionalLayers.clear();
0835                     bgLayerSet = false;
0836                     continue;
0837                 }
0838             }
0839
0840             if (!d.m_info.have_animation) {
0841                 QString layerName;
0842                 QByteArray layerNameRaw;
0843                 if (d.m_header.name_length) {
0844                     KIS_SAFE_ASSERT_RECOVER(d.m_header.name_length < std::numeric_limits<int>::max())
0845                     {
0846                         document->setErrorMessage(i18nc("JPEG-XL", "Invalid JPEG-XL layer name length"));
0847                         return ImportExportCodes::FormatFeaturesUnsupported;
0848                     }
0849                     layerNameRaw.resize(static_cast<int>(d.m_header.name_length + 1));
0850                     if (JXL_DEC_SUCCESS
0851                         != JxlDecoderGetFrameName(dec.get(),
0852                                                   layerNameRaw.data(),
0853                                                   static_cast<size_t>(layerNameRaw.size()))) {
0854                         errFile << "JxlDecoderGetFrameName failed";
0855                         break;
0856                     }
0857                     dbgFile << "\tlayer name:" << QString(layerNameRaw);
0858                     layerName = QString(layerNameRaw);
0859                 } else {
0860                     layerName = QString("Layer");
0861                 }
0862                 // Set the first layer name (if any)
0863                 if (!bgLayerSet) {
0864                     if (!layerNameRaw.isEmpty()) {
0865                         layer->setName(layerName);
0866                     }
0867                 } else {
0868                     additionalLayers.emplace_back(new KisPaintLayer(image, layerName, UCHAR_MAX));
0869                     if (blendMode == JXL_BLEND_MULADD) {
0870                         additionalLayers.back()->setCompositeOpId(QString("add"));
0871                     }
0872                 }
0873             }
0874         } else if (status == JXL_DEC_FULL_IMAGE) {
0875             // Parse raw data using existing callback function
0876             generateCallback(d);
0877             const JxlLayerInfo layerInfo = d.m_header.layer_info;
0878             const QRect layerBounds = QRect(static_cast<int>(layerInfo.crop_x0),
0879                                             static_cast<int>(layerInfo.crop_y0),
0880                                             static_cast<int>(layerInfo.xsize),
0881                                             static_cast<int>(layerInfo.ysize));
0882             if (d.m_info.have_animation) {
0883                 dbgFile << "Importing frame @" << d.m_nextFrameTime
0884                         << d.m_header.duration;
0885
0886                 if (d.m_nextFrameTime == 0) {
0887                     dbgFile << "Animation detected, ticks per second:"
0888                             << d.m_info.animation.tps_numerator
0889                             << d.m_info.animation.tps_denominator;
0890                     // XXX: How many ticks per second (FPS)?
0891                     // If > 240, block the derivation-- it's a stock JXL and
0892                     // Krita only supports up to 240 FPS.
0893                     // We'll try to derive the framerate from the first frame
0894                     // instead.
0895                     int framerate =
0896                         std::lround(d.m_info.animation.tps_numerator
0897                                     / static_cast<double>(
0898                                         d.m_info.animation.tps_denominator));
0899                     if (framerate > 240) {
0900                         warnFile << "JXL ticks per second value exceeds 240, "
0901                                     "approximating FPS from the duration of "
0902                                     "the first frame";
0903                         document->setWarningMessage(
0904                             i18nc("JPEG-XL errors",
0905                                   "The animation declares a frame rate of more "
0906                                   "than 240 FPS."));
0907                         const int approximatedFramerate = std::lround(
0908                             1000.0 / static_cast<double>(d.m_header.duration));
0909                         d.m_durationFrameInTicks =
0910                             static_cast<int>(d.m_header.duration);
0911                         framerate = std::max(approximatedFramerate, 1);
0912                     } else {
0913                         d.m_durationFrameInTicks = 1;
0914                     }
0915                     dbgFile << "Framerate:" << framerate;
0916                     layer->enableAnimation();
0917                     image->animationInterface()->setDocumentRangeStartFrame(0);
0918                     image->animationInterface()->setFramerate(framerate);
0919                 }
0920
0921                 const int currentFrameTime = std::lround(
0922                     static_cast<double>(d.m_nextFrameTime)
0923                     / static_cast<double>(d.m_durationFrameInTicks));
0924
0925                 auto *channel = layer->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true);
0926                 auto *frame = dynamic_cast<KisRasterKeyframeChannel *>(channel);
0927                 image->animationInterface()->setDocumentRangeEndFrame(
0928                     std::lround(static_cast<double>(d.m_nextFrameTime
0929                                                     + d.m_header.duration)
0930                                 / static_cast<double>(d.m_durationFrameInTicks))
0931                     - 1);
0932                 frame->importFrame(currentFrameTime, d.m_currentFrame, nullptr);
0933                 d.m_nextFrameTime += static_cast<int>(d.m_header.duration);
0934             } else {
0935                 if (d.isCMYK && d.m_info.uses_original_profile) {
0936                     QVector<quint8 *> planes = d.m_currentFrame->readPlanarBytes(layerBounds.x(),
0937                                                                                  layerBounds.y(),
0938                                                                                  layerBounds.width(),
0939                                                                                  layerBounds.height());
0940
0941                     // Planar buffer insertion for key channel
0942                     planes[3] = reinterpret_cast<quint8 *>(d.kPlane.data());
0943                     d.m_currentFrame->writePlanarBytes(planes,
0944                                                        layerBounds.x(),
0945                                                        layerBounds.y(),
0946                                                        layerBounds.width(),
0947                                                        layerBounds.height());
0948
0949                     // JPEG-XL decode outputs an inverted CMYK colors
0950                     // This one I took from kis_filter_test for inverting the colors..
0951                     const KisFilterSP f = KisFilterRegistry::instance()->value("invert");
0952                     KIS_ASSERT(f);
0953                     const KisFilterConfigurationSP kfc =
0954                         f->defaultConfiguration(KisGlobalResourcesInterface::instance());
0955                     KIS_ASSERT(kfc);
0956                     f->process(d.m_currentFrame, layerBounds, kfc->cloneWithResourcesSnapshot());
0957                 }
0958                 if (!bgLayerSet) {
0959                     layer->paintDevice()->makeCloneFrom(d.m_currentFrame, layerBounds);
0960                     bgLayerSet = true;
0961                 } else {
0962                     additionalLayers.back()->paintDevice()->makeCloneFrom(d.m_currentFrame, layerBounds);
0963                 }
0964             }
0965         } else if (status == JXL_DEC_SUCCESS || status == JXL_DEC_BOX) {
0966             if (std::strlen(boxType.data()) != 0) {
0967                 // Release buffer and get its final size.
0968                 const auto availOut = JxlDecoderReleaseBoxBuffer(dec.get());
0969                 const int finalSize = box.size() - static_cast<int>(availOut);
0970                 // Only resize and write boxes if it's not empty.
0971                 // And only input metadata boxes while skipping other boxes.
0972                 QByteArray type = boxType.toLower();
0973                 if ((std::equal(exifTag.begin(), exifTag.end(), type.constBegin())
0974                      || std::equal(xmpTag.begin(), xmpTag.end(), type.constBegin()))
0975                     && finalSize != 0) {
0976                     metadataBoxes.emplace(type, QByteArray(box.data(), finalSize));
0977                 }
0978                 // Preemptively zero the box type out to prevent dangling
0979                 // boxes.
0980                 boxType.fill('\0');
0981             }
0982             if (status == JXL_DEC_SUCCESS) {
0983                 // All decoding successfully finished.
0984
0985                 // Insert layer metadata if available (delayed
0986                 // in case the boxes came before the BASIC_INFO event)
0987                 for (auto &metaBox : metadataBoxes) {
0988                     const QByteArray &type = metaBox.first;
0989                     QByteArray &value = metaBox.second;
0990                     QBuffer buf(&value);
0991                     if (std::equal(exifTag.begin(), exifTag.end(), type.constBegin())) {
0992                         dbgFile << "Loading EXIF data. Size: " << value.size();
0993
0994                         const auto *backend =
0995                             KisMetadataBackendRegistry::instance()->value(
0996                                 "exif");
0997
0998                         backend->loadFrom(layer->metaData(), &buf);
0999                     } else if (std::equal(xmpTag.begin(), xmpTag.end(), type.constBegin())) {
1000                         dbgFile << "Loading XMP or IPTC data. Size: " << value.size();
1001
1002                         const auto *xmpBackend =
1003                             KisMetadataBackendRegistry::instance()->value(
1004                                 "xmp");
1005
1006                         if (!xmpBackend->loadFrom(layer->metaData(), &buf)) {
1007                             const KisMetaData::IOBackend *iptcBackend =
1008                                 KisMetadataBackendRegistry::instance()->value(
1009                                     "iptc");
1010                             iptcBackend->loadFrom(layer->metaData(), &buf);
1011                         }
1012                     }
1013                 }
1014
1015                 // It's not required to call JxlDecoderReleaseInput(dec.get()) here since
1016                 // the decoder will be destroyed.
1017                 image->addNode(layer, image->rootLayer().data());
1018                 // Slip additional layers into layer stack
1019                 for (const KisLayerSP &addLayer : additionalLayers) {
1020                     image->addNode(addLayer, image->rootLayer().data());
1021                 }
1022                 if (needColorTransform) {
1023                     if (needIntermediateTransform) {
1024                         dbgFile << "Transforming to intermediate color space";
1025                         image->convertImageColorSpace(d.cs_intermediate,
1026                                                       d.m_intent,
1027                                                       KoColorConversionTransformation::internalConversionFlags());
1028                         image->waitForDone();
1029                     }
1030                     dbgFile << "Transforming to target color space";
1031                     image->convertImageColorSpace(d.cs_target,
1032                                                   d.m_intent,
1033                                                   KoColorConversionTransformation::internalConversionFlags());
1034                     image->waitForDone();
1035                 }
1036                 document->setCurrentImage(image);
1037                 return ImportExportCodes::OK;
1038             } else {
1039                 if (JxlDecoderGetBoxType(dec.get(), boxType.data(), JXL_TRUE) != JXL_DEC_SUCCESS) {
1040                     errFile << "JxlDecoderGetBoxType failed";
1041                     return ImportExportCodes::ErrorWhileReading;
1042                 }
1043                 const QByteArray type = boxType.toLower();
1044                 if (std::equal(exifTag.begin(), exifTag.end(), type.constBegin())
1045                     || std::equal(xmpTag.begin(), xmpTag.end(), type.constBegin())) {
1046                     if (JxlDecoderSetBoxBuffer(
1047                             dec.get(),
1048                             reinterpret_cast<uint8_t *>(box.data()),
1049                             static_cast<size_t>(box.size()))
1050                         != JXL_DEC_SUCCESS) {
1051                         errFile << "JxlDecoderSetBoxBuffer failed";
1052                         return ImportExportCodes::InternalError;
1053                     }
1054                 } else {
1055                     dbgFile << "Skipping box" << boxType.data();
1056                 }
1057             }
1058         } else if (status == JXL_DEC_BOX_NEED_MORE_OUTPUT) {
1059             // Update the box size if it was truncated in a previous buffering.
1060             boxSize = box.size();
1061             box.resize(boxSize * 2);
1062             // Release buffer before setting it up again
1063             JxlDecoderReleaseBoxBuffer(dec.get());
1064             if (JxlDecoderSetBoxBuffer(
1065                     dec.get(),
1066                     reinterpret_cast<uint8_t *>(box.data() + boxSize),
1067                     static_cast<size_t>(box.size() - boxSize))
1068                 != JXL_DEC_SUCCESS) {
1069                 errFile << "JxlDecoderGetBoxType failed";
1070                 return ImportExportCodes::ErrorWhileReading;
1071             }
1072         } else {
1073             errFile << "Unknown decoder status" << status;
1074             return ImportExportCodes::InternalError;
1075         }
1076     }
1077
1078     return ImportExportCodes::OK;
1079 }
1080
1081 #include <JPEGXLImport.moc>