HDR Namespace Reference

Classes
struct	readLayerImpl

Functions
template<ConversionPolicy policy>
ALWAYS_INLINE float	applyCurveAsNeeded (float value)
template<typename... Args>
auto	readInterleavedLayer (const int luma, LinearizePolicy linearizePolicy, bool applyOOTF, const int channels, const int width, const int height, const uint8_t *img, const int stride, KisHLineIteratorSP it, float displayGamma, float displayNits, const KoColorSpace *colorSpace)
template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, ConversionPolicy conversionPolicy, typename DestTrait , bool removeOOTF>
QByteArray	writeLayer (const int width, const int height, KisHLineConstIteratorSP it, float hlgGamma, float hlgNominalPeak, const KoColorSpace *cs)
template<typename... Args>
auto	writeLayer (const KoID &id, Args &&...args)
template<typename CSTrait , bool swap>
QByteArray	writeLayerNoConversion (const int width, const int height, KisHLineConstIteratorSP it, float hlgGamma, float hlgNominalPeak, const KoColorSpace *cs)
template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, ConversionPolicy linearizePolicy, typename DestTrait , bool removeOOTF, typename... Args>
ALWAYS_INLINE auto	writeLayerSimplify (Args &&...args)
template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, typename... Args>
ALWAYS_INLINE auto	writeLayerWithLinear (ConversionPolicy linearizePolicy, Args &&...args)
template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, ConversionPolicy linearizePolicy, typename DestTrait , typename... Args>
ALWAYS_INLINE auto	writeLayerWithPolicy (bool removeOOTF, Args &&...args)
template<typename CSTrait , bool swap, bool convertToRec2020, typename... Args>
ALWAYS_INLINE auto	writeLayerWithRec2020 (bool isLinear, Args &&...args)
template<typename CSTrait , bool swap, typename... Args>
ALWAYS_INLINE auto	writeLayerWithSwap (bool convertToRec2020, Args &&...args)

Function Documentation

applyCurveAsNeeded()

template<ConversionPolicy policy>

ALWAYS_INLINE float HDR::applyCurveAsNeeded

(

float

value

)

Definition at line 146 of file kis_jpegxl_export_tools.h.

{
    if (policy == ConversionPolicy::ApplyPQ) {
        return applySmpte2048Curve(value);
    } else if (policy == ConversionPolicy::ApplyHLG) {
        return applyHLGCurve(value);
    } else if (policy == ConversionPolicy::ApplySMPTE428) {
        return applySMPTE_ST_428Curve(value);
    }
    return value;
}

References ApplyHLG, applyHLGCurve(), ApplyPQ, applySmpte2048Curve(), ApplySMPTE428, applySMPTE_ST_428Curve(), and value().

readInterleavedLayer()

template<typename... Args>

auto HDR::readInterleavedLayer ( const int luma, LinearizePolicy linearizePolicy, bool applyOOTF, const int channels, const int width, const int height, const uint8_t * img, const int stride, KisHLineIteratorSP it, float displayGamma, float displayNits, const KoColorSpace * colorSpace )

inline

Definition at line 153 of file HeifImport.cpp.

{
    return createOptimizedClass<HDR::readLayerImpl>(luma,
                                                    linearizePolicy,
                                                    applyOOTF,
                                                    channels,
                                                    width,
                                                    height,
                                                    img,
                                                    stride,
                                                    it,
                                                    displayGamma,
                                                    displayNits,
                                                    colorSpace);
}

writeLayer() [1/2]

template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, ConversionPolicy conversionPolicy, typename DestTrait , bool removeOOTF>

QByteArray HDR::writeLayer ( const int width, const int height, KisHLineConstIteratorSP it, float hlgGamma, float hlgNominalPeak, const KoColorSpace * cs )

inline

Definition at line 165 of file kis_jpegxl_export_tools.h.

{
    const int channels = static_cast<int>(CSTrait::channels_nb);
    QVector<float> pixelValues(channels);
    QVector<qreal> pixelValuesLinear(channels);
    const KoColorProfile *profile = cs->profile();
    const QVector<qreal> lCoef = cs->lumaCoefficients();
    double *src = pixelValuesLinear.data();
    float *dst = pixelValues.data();
 
    QByteArray res;
    res.resize(width * height * static_cast<int>(DestTrait::pixelSize));
 
    quint8 *ptr = reinterpret_cast<quint8 *>(res.data());
 
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            CSTrait::normalisedChannelsValue(it->rawDataConst(), pixelValues);
            if (!convertToRec2020 && !isLinear) {
                for (int i = 0; i < channels; i++) {
                    src[i] = static_cast<double>(dst[i]);
                }
                profile->linearizeFloatValue(pixelValuesLinear);
                for (int i = 0; i < channels; i++) {
                    dst[i] = static_cast<float>(src[i]);
                }
            }
 
            if (conversionPolicy == ConversionPolicy::ApplyHLG && removeOOTF) {
                removeHLGOOTF(dst, lCoef.constData(), hlgGamma, hlgNominalPeak);
            }
 
            for (int ch = 0; ch < channels; ch++) {
                if (ch == CSTrait::alpha_pos) {
                    dst[ch] = applyCurveAsNeeded<ConversionPolicy::KeepTheSame>(
                        dst[ch]);
                } else {
                    dst[ch] = applyCurveAsNeeded<conversionPolicy>(dst[ch]);
                }
            }
 
            if (swap) {
                std::swap(dst[0], dst[2]);
            }
 
            DestTrait::fromNormalisedChannelsValue(ptr, pixelValues);
 
            ptr += DestTrait::pixelSize;
 
            it->nextPixel();
        }
 
        it->nextRow();
    }
 
    return res;
}

References ApplyHLG, KoColorProfile::linearizeFloatValue(), KoColorSpace::lumaCoefficients, KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), KoColorSpace::profile(), KisBaseConstAccessor::rawDataConst(), and removeHLGOOTF().

writeLayer() [2/2]

template<typename... Args>

auto HDR::writeLayer ( const KoID & id, Args &&... args )

inline

Definition at line 357 of file kis_jpegxl_export_tools.h.

{
    if (id == Integer8BitsColorDepthID) {
        return writeLayerWithSwap<KoBgrU8Traits, true>(std::forward<Args>(args)...);
    } else if (id == Integer16BitsColorDepthID) {
        return writeLayerWithSwap<KoBgrU16Traits, true>(std::forward<Args>(args)...);
#ifdef HAVE_OPENEXR
    } else if (id == Float16BitsColorDepthID) {
        return writeLayerWithSwap<KoBgrF16Traits, false>(std::forward<Args>(args)...);
#endif
    } else if (id == Float32BitsColorDepthID) {
        return writeLayerWithSwap<KoBgrF32Traits, false>(std::forward<Args>(args)...);
    } else {
        KIS_ASSERT_X(false, "JPEGXLExport::writeLayer", "unsupported bit depth!");
        return QByteArray();
    }
}

References Float16BitsColorDepthID, Float32BitsColorDepthID, Integer16BitsColorDepthID, Integer8BitsColorDepthID, and KIS_ASSERT_X.

writeLayerNoConversion()

template<typename CSTrait , bool swap>

QByteArray HDR::writeLayerNoConversion ( const int width, const int height, KisHLineConstIteratorSP it, float hlgGamma, float hlgNominalPeak, const KoColorSpace * cs )

inline

Definition at line 229 of file kis_jpegxl_export_tools.h.

{
    Q_UNUSED(hlgGamma);
    Q_UNUSED(hlgNominalPeak);
    Q_UNUSED(cs);
 
    const int channels = static_cast<int>(CSTrait::channels_nb);
    QVector<float> pixelValues(channels);
    QVector<qreal> pixelValuesLinear(channels);
 
    QByteArray res;
    res.resize(width * height * static_cast<int>(CSTrait::pixelSize));
 
    quint8 *ptr = reinterpret_cast<quint8 *>(res.data());
 
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            auto *dst = reinterpret_cast<typename CSTrait::channels_type *>(ptr);
 
            std::memcpy(dst, it->rawDataConst(), CSTrait::pixelSize);
 
            if (swap) {
                std::swap(dst[0], dst[2]);
            }
 
            ptr += CSTrait::pixelSize;
 
            it->nextPixel();
        }
 
        it->nextRow();
    }
 
    return res;
}

References KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), and KisBaseConstAccessor::rawDataConst().

writeLayerSimplify()

template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, ConversionPolicy linearizePolicy, typename DestTrait , bool removeOOTF, typename... Args>

ALWAYS_INLINE auto HDR::writeLayerSimplify

(

Args &&...

args

)

Definition at line 278 of file kis_jpegxl_export_tools.h.

{
    if (linearizePolicy != ConversionPolicy::KeepTheSame) {
        return writeLayer<CSTrait, swap, convertToRec2020, isLinear, linearizePolicy, DestTrait, removeOOTF>(
            std::forward<Args>(args)...);
    } else {
        return writeLayerNoConversion<CSTrait, swap>(std::forward<Args>(args)...);
    }
}

References KeepTheSame.

writeLayerWithLinear()

template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, typename... Args>

ALWAYS_INLINE auto HDR::writeLayerWithLinear	(	ConversionPolicy	linearizePolicy,
		Args &&...	args )

Definition at line 307 of file kis_jpegxl_export_tools.h.

{
    if (linearizePolicy == ConversionPolicy::ApplyHLG) {
        return writeLayerWithPolicy<CSTrait,
                                    swap,
                                    convertToRec2020,
                                    isLinear,
                                    ConversionPolicy::ApplyHLG,
                                    KoBgrU16Traits>(std::forward<Args>(args)...);
    } else if (linearizePolicy == ConversionPolicy::ApplyPQ) {
        return writeLayerWithPolicy<CSTrait,
                                    swap,
                                    convertToRec2020,
                                    isLinear,
                                    ConversionPolicy::ApplyPQ,
                                    KoBgrU16Traits>(std::forward<Args>(args)...);
    } else if (linearizePolicy == ConversionPolicy::ApplySMPTE428) {
        return writeLayerWithPolicy<CSTrait,
                                    swap,
                                    convertToRec2020,
                                    isLinear,
                                    ConversionPolicy::ApplySMPTE428,
                                    KoBgrU16Traits>(std::forward<Args>(args)...);
    } else {
        return writeLayerWithPolicy<CSTrait, swap, convertToRec2020, isLinear, ConversionPolicy::KeepTheSame, CSTrait>(
            std::forward<Args>(args)...);
    }
}

References ApplyHLG, ApplyPQ, ApplySMPTE428, and writeLayerWithPolicy().

writeLayerWithPolicy()

template<typename CSTrait , bool swap, bool convertToRec2020, bool isLinear, ConversionPolicy linearizePolicy, typename DestTrait , typename... Args>

ALWAYS_INLINE auto HDR::writeLayerWithPolicy	(	bool	removeOOTF,
		Args &&...	args )

Definition at line 295 of file kis_jpegxl_export_tools.h.

{
    if (removeOOTF) {
        return writeLayerSimplify<CSTrait, swap, convertToRec2020, isLinear, linearizePolicy, DestTrait, true>(
            std::forward<Args>(args)...);
    } else {
        return writeLayerSimplify<CSTrait, swap, convertToRec2020, isLinear, linearizePolicy, DestTrait, false>(
            std::forward<Args>(args)...);
    }
}

writeLayerWithRec2020()

template<typename CSTrait , bool swap, bool convertToRec2020, typename... Args>

ALWAYS_INLINE auto HDR::writeLayerWithRec2020	(	bool	isLinear,
		Args &&...	args )

Definition at line 337 of file kis_jpegxl_export_tools.h.

{
    if (isLinear) {
        return writeLayerWithLinear<CSTrait, swap, convertToRec2020, true>(std::forward<Args>(args)...);
    } else {
        return writeLayerWithLinear<CSTrait, swap, convertToRec2020, false>(std::forward<Args>(args)...);
    }
}

writeLayerWithSwap()

template<typename CSTrait , bool swap, typename... Args>

ALWAYS_INLINE auto HDR::writeLayerWithSwap	(	bool	convertToRec2020,
		Args &&...	args )

Definition at line 347 of file kis_jpegxl_export_tools.h.

{
    if (convertToRec2020) {
        return writeLayerWithRec2020<CSTrait, swap, true>(std::forward<Args>(args)...);
    } else {
        return writeLayerWithRec2020<CSTrait, swap, false>(std::forward<Args>(args)...);
    }
}