Krita Source Code Documentation
Loading...
Searching...
No Matches
Functions
HDRFloat Namespace Reference

Functions

template<ConversionPolicy policy>
float applyCurveAsNeeded (float value)
 
template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, bool isLinear, ConversionPolicy conversionPolicy, bool removeOOTF>
void writeFloatLayerImpl (const int width, const int height, uint8_t *ptr, const int stride, KisHLineConstIteratorSP it, float hlgGamma, float hlgNominalPeak, const KoColorSpace *cs)
 
template<typename... Args>
auto writeInterleavedLayer (const KoID &id, Args &&...args)
 
template<typename CSTrait , QSysInfo::Endian endianness, int channels, typename... Args>
auto writeInterleavedWithAlpha (bool convertToRec2020, Args &&...args)
 
template<typename CSTrait , typename... Args>
auto writeInterleavedWithDepth (QSysInfo::Endian endian, Args &&...args)
 
template<typename CSTrait , QSysInfo::Endian endianness, typename... Args>
auto writeInterleavedWithEndian (bool hasAlpha, Args &&...args)
 
template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, bool isLinear, typename... Args>
auto writeInterleavedWithLinear (ConversionPolicy linearizePolicy, Args &&...args)
 
template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, bool isLinear, ConversionPolicy linearizePolicy, typename... Args>
auto writeInterleavedWithPolicy (bool removeOOTF, Args &&...args)
 
template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, typename... Args>
auto writeInterleavedWithRec2020 (bool isLinear, Args &&...args)
 

Function Documentation

◆ applyCurveAsNeeded()

template<ConversionPolicy policy>
float HDRFloat::applyCurveAsNeeded ( float value)
inline

Definition at line 236 of file kis_heif_export_tools.h.

237{
238 if (policy == ConversionPolicy::ApplyPQ) {
239 return applySmpte2048Curve(value);
240 } else if (policy == ConversionPolicy::ApplyHLG) {
241 return applyHLGCurve(value);
242 } else if (policy == ConversionPolicy::ApplySMPTE428) {
243 return applySMPTE_ST_428Curve(value);
244 }
245 return value;
246}
value
float value(const T *src, size_t ch)
Definition JPEGXLImport.cpp:93
applySmpte2048Curve
ALWAYS_INLINE float applySmpte2048Curve(float x) noexcept
Definition KoColorTransferFunctions.h:38
applySMPTE_ST_428Curve
ALWAYS_INLINE float applySMPTE_ST_428Curve(float x) noexcept
Definition KoColorTransferFunctions.h:133
applyHLGCurve
ALWAYS_INLINE float applyHLGCurve(float x) noexcept
Definition KoColorTransferFunctions.h:106

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

◆ writeFloatLayerImpl()

template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, bool isLinear, ConversionPolicy conversionPolicy, bool removeOOTF>
void HDRFloat::writeFloatLayerImpl ( const int width,
const int height,
uint8_t * ptr,
const int stride,
KisHLineConstIteratorSP it,
float hlgGamma,
float hlgNominalPeak,
const KoColorSpace * cs )
inline

Definition at line 255 of file kis_heif_export_tools.h.

263{
264 const int endValue0 = endianness == QSysInfo::LittleEndian ? 1 : 0;
265 const int endValue1 = endianness == QSysInfo::LittleEndian ? 0 : 1;
266 QVector<float> pixelValues(4);
267 QVector<qreal> pixelValuesLinear(4);
268 const KoColorProfile *profile = cs->profile();
269 const QVector<qreal> lCoef{cs->lumaCoefficients()};
270 double *src = pixelValuesLinear.data();
271 float *dst = pixelValues.data();
272
273 for (int y = 0; y < height; y++) {
274 for (int x = 0; x < width; x++) {
275 CSTrait::normalisedChannelsValue(it->rawDataConst(), pixelValues);
276 if (!convertToRec2020 && !isLinear) {
277 for (int i = 0; i < 4; i++) {
278 src[i] = static_cast<double>(dst[i]);
279 }
280 profile->linearizeFloatValue(pixelValuesLinear);
281 for (int i = 0; i < 4; i++) {
282 dst[i] = static_cast<float>(src[i]);
283 }
284 }
285
286 if (conversionPolicy == ConversionPolicy::ApplyHLG && removeOOTF) {
287 removeHLGOOTF(dst, lCoef.constData(), hlgGamma, hlgNominalPeak);
288 }
289
290 for (int ch = 0; ch < channels; ch++) {
291 uint16_t v = 0;
292 if (ch == CSTrait::alpha_pos) {
293 v = qBound<uint16_t>(
294 0,
295 static_cast<uint16_t>(
296 applyCurveAsNeeded<ConversionPolicy::KeepTheSame>(
297 dst[ch])
298 * max12bit),
299 max12bit);
300 } else {
301 v = qBound<uint16_t>(
302 0,
303 static_cast<uint16_t>(
304 applyCurveAsNeeded<conversionPolicy>(dst[ch])
305 * max12bit),
306 max12bit);
307 }
308 ptr[2 * (x * channels) + y * stride + endValue0 + (ch * 2)] =
309 (uint8_t)(v >> 8);
310 ptr[2 * (x * channels) + y * stride + endValue1 + (ch * 2)] =
311 (uint8_t)(v & 0xFF);
312 }
313
314 it->nextPixel();
315 }
316
317 it->nextRow();
318 }
319}
v
qreal v
Definition KisBezierUtils.cpp:702
removeHLGOOTF
ALWAYS_INLINE void removeHLGOOTF(float *rgb, const double *lumaCoefficients, float gamma=1.2f, float nominalPeak=1000.0f) noexcept
Definition KoColorTransferFunctions.h:92
max12bit
static constexpr uint16_t max12bit
Definition KoColorTransferFunctions.h:30
KisBaseConstAccessor::rawDataConst
virtual const quint8 * rawDataConst() const =0
KisBaseConstIteratorNG::nextPixel
virtual bool nextPixel()=0
KisHLineConstIteratorNG::nextRow
virtual void nextRow()=0
KoColorSpace::lumaCoefficients
QVector< qreal > lumaCoefficients
Definition KoColorSpace_p.h:61
KoColorSpace::profile
virtual const KoColorProfile * profile() const =0
resize_to_all_layers.x
x
Definition resize_to_all_layers.py:18
KoColorProfile::linearizeFloatValue
virtual void linearizeFloatValue(QVector< qreal > &Value) const =0

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

◆ writeInterleavedLayer()

template<typename... Args>
auto HDRFloat::writeInterleavedLayer ( const KoID & id,
Args &&... args )
inline

Definition at line 452 of file kis_heif_export_tools.h.

453{
454#ifdef HAVE_OPENEXR
455 if (id == Float16BitsColorDepthID) {
456 return writeInterleavedWithDepth<KoBgrF16Traits>(
457 std::forward<Args>(args)...);
458 } else
459#else
460 Q_UNUSED(id);
461#endif
462 {
463 return writeInterleavedWithDepth<KoBgrF32Traits>(
464 std::forward<Args>(args)...);
465 }
466}
Float16BitsColorDepthID
const KoID Float16BitsColorDepthID("F16", ki18n("16-bit float/channel"))

References Float16BitsColorDepthID.

◆ writeInterleavedWithAlpha()

template<typename CSTrait , QSysInfo::Endian endianness, int channels, typename... Args>
auto HDRFloat::writeInterleavedWithAlpha ( bool convertToRec2020,
Args &&... args )
inline

Definition at line 414 of file kis_heif_export_tools.h.

415{
416 if (convertToRec2020) {
417 return writeInterleavedWithRec2020<CSTrait, endianness, channels, true>(
418 std::forward<Args>(args)...);
419 } else {
420 return writeInterleavedWithRec2020<CSTrait,
421 endianness,
422 channels,
423 false>(std::forward<Args>(args)...);
424 }
425}

References writeInterleavedWithRec2020().

◆ writeInterleavedWithDepth()

template<typename CSTrait , typename... Args>
auto HDRFloat::writeInterleavedWithDepth ( QSysInfo::Endian endian,
Args &&... args )
inline

Definition at line 440 of file kis_heif_export_tools.h.

441{
442 if (endian == QSysInfo::LittleEndian) {
443 return writeInterleavedWithEndian<CSTrait, QSysInfo::LittleEndian>(
444 std::forward<Args>(args)...);
445 } else {
446 return writeInterleavedWithEndian<CSTrait, QSysInfo::BigEndian>(
447 std::forward<Args>(args)...);
448 }
449}

◆ writeInterleavedWithEndian()

template<typename CSTrait , QSysInfo::Endian endianness, typename... Args>
auto HDRFloat::writeInterleavedWithEndian ( bool hasAlpha,
Args &&... args )
inline

Definition at line 428 of file kis_heif_export_tools.h.

429{
430 if (hasAlpha) {
431 return writeInterleavedWithAlpha<CSTrait, endianness, 4>(
432 std::forward<Args>(args)...);
433 } else {
434 return writeInterleavedWithAlpha<CSTrait, endianness, 3>(
435 std::forward<Args>(args)...);
436 }
437}

◆ writeInterleavedWithLinear()

template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, bool isLinear, typename... Args>
auto HDRFloat::writeInterleavedWithLinear ( ConversionPolicy linearizePolicy,
Args &&... args )
inline

Definition at line 354 of file kis_heif_export_tools.h.

356{
357 if (linearizePolicy == ConversionPolicy::ApplyHLG) {
358 return writeInterleavedWithPolicy<CSTrait,
359 endianness,
360 channels,
361 convertToRec2020,
362 isLinear,
363 ConversionPolicy::ApplyHLG>(std::forward<Args>(args)...);
364 } else if (linearizePolicy == ConversionPolicy::ApplyPQ) {
365 return writeInterleavedWithPolicy<CSTrait,
366 endianness,
367 channels,
368 convertToRec2020,
369 isLinear,
370 ConversionPolicy::ApplyPQ>(std::forward<Args>(args)...);
371 } else if (linearizePolicy == ConversionPolicy::ApplySMPTE428) {
372 return writeInterleavedWithPolicy<CSTrait,
373 endianness,
374 channels,
375 convertToRec2020,
376 isLinear,
377 ConversionPolicy::ApplySMPTE428>(std::forward<Args>(args)...);
378 } else {
379 return writeInterleavedWithPolicy<CSTrait,
380 endianness,
381 channels,
382 convertToRec2020,
383 isLinear,
384 ConversionPolicy::KeepTheSame>(std::forward<Args>(args)...);
385 }
386}
HDRFloat::writeInterleavedWithPolicy
auto writeInterleavedWithPolicy(bool removeOOTF, Args &&...args)
Definition kis_heif_export_tools.h:327

References ApplyHLG, ApplyPQ, ApplySMPTE428, KeepTheSame, and writeInterleavedWithPolicy().

◆ writeInterleavedWithPolicy()

template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, bool isLinear, ConversionPolicy linearizePolicy, typename... Args>
auto HDRFloat::writeInterleavedWithPolicy ( bool removeOOTF,
Args &&... args )
inline

Definition at line 327 of file kis_heif_export_tools.h.

328{
329 if (removeOOTF) {
330 return writeFloatLayerImpl<CSTrait,
331 endianness,
332 channels,
333 convertToRec2020,
334 isLinear,
335 linearizePolicy,
336 true>(std::forward<Args>(args)...);
337 } else {
338 return writeFloatLayerImpl<CSTrait,
339 endianness,
340 channels,
341 convertToRec2020,
342 isLinear,
343 linearizePolicy,
344 false>(std::forward<Args>(args)...);
345 }
346}
HDRFloat::writeFloatLayerImpl
void writeFloatLayerImpl(const int width, const int height, uint8_t *ptr, const int stride, KisHLineConstIteratorSP it, float hlgGamma, float hlgNominalPeak, const KoColorSpace *cs)
Definition kis_heif_export_tools.h:255

References writeFloatLayerImpl().

◆ writeInterleavedWithRec2020()

template<typename CSTrait , QSysInfo::Endian endianness, int channels, bool convertToRec2020, typename... Args>
auto HDRFloat::writeInterleavedWithRec2020 ( bool isLinear,
Args &&... args )
inline

Definition at line 393 of file kis_heif_export_tools.h.

394{
395 if (isLinear) {
396 return writeInterleavedWithLinear<CSTrait,
397 endianness,
398 channels,
399 convertToRec2020,
400 true>(std::forward<Args>(args)...);
401 } else {
402 return writeInterleavedWithLinear<CSTrait,
403 endianness,
404 channels,
405 convertToRec2020,
406 false>(std::forward<Args>(args)...);
407 }
408}
HDRFloat::writeInterleavedWithLinear
auto writeInterleavedWithLinear(ConversionPolicy linearizePolicy, Args &&...args)
Definition kis_heif_export_tools.h:354

References writeInterleavedWithLinear().