diff --git a/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpace.h b/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpace.h
index a6985450a1..736b0fbc04 100644
--- a/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpace.h
+++ b/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpace.h
@@ -1,127 +1,141 @@
 /*
  *  Copyright (c) 2019 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef LCMSRGBP2020PQCOLORSPACE_H
 #define LCMSRGBP2020PQCOLORSPACE_H
 
+
 #include <colorspaces/rgb_u8/RgbU8ColorSpace.h>
 #include <colorspaces/rgb_u16/RgbU16ColorSpace.h>
+
+#ifdef HAVE_OPENEXR
 #include <colorspaces/rgb_f16/RgbF16ColorSpace.h>
+#endif
+
 #include <colorspaces/rgb_f32/RgbF32ColorSpace.h>
 
 #include "KoColorConversionTransformationFactory.h"
 
 #include <LcmsRGBP2020PQColorSpaceTransformation.h>
 
 template <class T>
 struct ColorSpaceFromFactory {
 };
 
 template<>
 struct ColorSpaceFromFactory<RgbU8ColorSpaceFactory> {
   typedef RgbU8ColorSpace type;
 };
 
 template<>
 struct ColorSpaceFromFactory<RgbU16ColorSpaceFactory> {
   typedef RgbU16ColorSpace type;
 };
 
+#ifdef HAVE_OPENEXR
 template<>
 struct ColorSpaceFromFactory<RgbF16ColorSpaceFactory> {
   typedef RgbF16ColorSpace type;
 };
+#endif
 
 template<>
 struct ColorSpaceFromFactory<RgbF32ColorSpaceFactory> {
   typedef RgbF32ColorSpace type;
 };
 
 /**
  *  Define a singly linked list of supported bit depth traits
  */
 template<class T> struct NextTrait { using type = void; };
 template<> struct NextTrait<KoBgrU8Traits> { using type = KoBgrU16Traits; };
+
+#ifdef HAVE_OPENEXR
 template<> struct NextTrait<KoBgrU16Traits> { using type = KoRgbF16Traits; };
 template<> struct NextTrait<KoRgbF16Traits> { using type = KoRgbF32Traits; };
+#else
+template<> struct NextTrait<KoBgrU16Traits> { using type = KoRgbF32Traits; };
+#endif
 
 /**
  * Recursively add bit-depths conversions to the color space. We add only
  * **outgoing** conversions for every RGB color space. That is, every color
  * space has exactly three outgoing edges for color conversion.
  */
 template<typename ParentColorSpace, typename CurrentTraits>
 void addInternalConversion(QList<KoColorConversionTransformationFactory*> &list, CurrentTraits*)
 {
     // general case: add a converter and recurse for the next traits
     list << new LcmsScaleRGBP2020PQTransformationFactory<ParentColorSpace, CurrentTraits>();
 
     using NextTraits = typename NextTrait<CurrentTraits>::type;
     addInternalConversion<ParentColorSpace>(list, static_cast<NextTraits*>(0));
 }
 
 template<typename ParentColorSpace>
 void addInternalConversion(QList<KoColorConversionTransformationFactory*> &list, typename ParentColorSpace::ColorSpaceTraits*)
 {
     // exception: skip adding an edge to the same bit depth
 
     using CurrentTraits = typename ParentColorSpace::ColorSpaceTraits;
     using NextTraits = typename NextTrait<CurrentTraits>::type;
     addInternalConversion<ParentColorSpace>(list, static_cast<NextTraits*>(0));
 }
 
 template<typename ParentColorSpace>
 void addInternalConversion(QList<KoColorConversionTransformationFactory*> &, void*)
 {
     // stop recursion
 }
 
 template <class BaseColorSpaceFactory>
 class LcmsRGBP2020PQColorSpaceFactoryWrapper : public BaseColorSpaceFactory
 {
     typedef typename ColorSpaceFromFactory<BaseColorSpaceFactory>::type RelatedColorSpaceType;
 
     KoColorSpace *createColorSpace(const KoColorProfile *p) const override
     {
         return new RelatedColorSpaceType(this->name(), p->clone());
     }
 
     QList<KoColorConversionTransformationFactory *> colorConversionLinks() const override
     {
         QList<KoColorConversionTransformationFactory *> list;
 
         /**
          * We explicitly disable direct conversions to/from integer color spaces, because
          * they may cause the the conversion system to choose them as an intermediate
          * color space for the conversion chain, e.g.
          * p709-g10 F32 -> p2020-g10 U16 -> Rec2020-pq U16, which is incorrect and loses
          * all the HDR data
          */
         list << new LcmsFromRGBP2020PQTransformationFactory<RelatedColorSpaceType, KoRgbF16Traits>();
         list << new LcmsFromRGBP2020PQTransformationFactory<RelatedColorSpaceType, KoRgbF32Traits>();
+#ifdef HAVE_OPENEXR
         list << new LcmsToRGBP2020PQTransformationFactory<RelatedColorSpaceType, KoRgbF16Traits>();
+#endif
         list << new LcmsToRGBP2020PQTransformationFactory<RelatedColorSpaceType, KoRgbF32Traits>();
 
         // internally, we can convert to RGB U8 if needed
         addInternalConversion<RelatedColorSpaceType>(list, static_cast<KoBgrU8Traits*>(0));
 
         return list;
     }
 };
 
 #endif // LCMSRGBP2020PQCOLORSPACE_H
diff --git a/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpaceTransformation.h b/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpaceTransformation.h
index 7620cecfab..a340c5fc36 100644
--- a/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpaceTransformation.h
+++ b/plugins/color/lcms2engine/LcmsRGBP2020PQColorSpaceTransformation.h
@@ -1,269 +1,276 @@
 /*
  *  Copyright (c) 2019 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef LCMSRGBP2020PQCOLORSPACETRANSFORMATION_H
 #define LCMSRGBP2020PQCOLORSPACETRANSFORMATION_H
 
 #include "KoAlwaysInline.h"
 #include "KoColorModelStandardIds.h"
 #include "KoColorSpaceMaths.h"
 #include "KoColorModelStandardIdsUtils.h"
 #include "KoColorConversionTransformationFactory.h"
 
 #include <colorspaces/rgb_u8/RgbU8ColorSpace.h>
 #include <colorspaces/rgb_u16/RgbU16ColorSpace.h>
+#ifdef HAVE_OPENEXR
 #include <colorspaces/rgb_f16/RgbF16ColorSpace.h>
+#endif
 #include <colorspaces/rgb_f32/RgbF32ColorSpace.h>
 
 
 namespace
 {
 
 ALWAYS_INLINE float applySmpte2048Curve(float x) {
     const float m1 = 2610.0 / 4096.0 / 4.0;
     const float m2 = 2523.0 / 4096.0 * 128.0;
     const float a1 = 3424.0 / 4096.0;
     const float c2 = 2413.0 / 4096.0 * 32.0;
     const float c3 = 2392.0 / 4096.0 * 32.0;
     const float a4 = 1.0;
     const float x_p = powf(0.008 * std::max(0.0f, x), m1);
     const float res = powf((a1 + c2 * x_p) / (a4 + c3 * x_p), m2);
     return res;
 }
 
 ALWAYS_INLINE float removeSmpte2048Curve(float x) {
     const float m1_r = 4096.0 * 4.0 / 2610.0;
     const float m2_r = 4096.0 / 2523.0 / 128.0;
     const float a1 = 3424.0 / 4096.0;
     const float c2 = 2413.0 / 4096.0 * 32.0;
     const float c3 = 2392.0 / 4096.0 * 32.0;
 
     const float x_p = powf(x, m2_r);
     const float res = powf(qMax(0.0f, x_p - a1) / (c2 - c3 * x_p), m1_r);
     return res * 125.0f;
 }
 
 template <class T>
 struct DstTraitsForSource {
     typedef KoRgbF32Traits result;
 };
 
+/**
+ * If half format is present, we use it instead
+ */
+#ifdef HAVE_OPENEXR
 template <>
 struct DstTraitsForSource<KoBgrU16Traits> {
     typedef KoRgbF16Traits result;
 };
 
 template <>
 struct DstTraitsForSource<KoBgrU8Traits> {
     typedef KoRgbF16Traits result;
 };
+#endif
 
 template <typename src_channel_type,
           typename dst_channel_type>
 struct RemoveSmpte2048Policy {
     static ALWAYS_INLINE dst_channel_type process(src_channel_type value) {
         return
             KoColorSpaceMaths<float, dst_channel_type>::scaleToA(
             removeSmpte2048Curve(
             KoColorSpaceMaths<src_channel_type, float>::scaleToA(
             value)));
     }
 };
 
 template <typename src_channel_type,
           typename dst_channel_type>
 struct ApplySmpte2048Policy {
     static ALWAYS_INLINE dst_channel_type process(src_channel_type value) {
         return
             KoColorSpaceMaths<float, dst_channel_type>::scaleToA(
             applySmpte2048Curve(
             KoColorSpaceMaths<src_channel_type, float>::scaleToA(
             value)));
     }
 };
 
 template <typename src_channel_type,
           typename dst_channel_type>
 struct NoopPolicy {
     static ALWAYS_INLINE dst_channel_type process(src_channel_type value) {
         return KoColorSpaceMaths<src_channel_type, dst_channel_type>::scaleToA(value);
     }
 };
 
 }
 
 template<typename SrcCSTraits,
          typename DstCSTraits,
          template<typename, typename> class Policy>
 struct ApplyRgbShaper : public KoColorConversionTransformation
 {
     ApplyRgbShaper(const KoColorSpace* srcCs,
                    const KoColorSpace* dstCs,
                    Intent renderingIntent,
                    ConversionFlags conversionFlags)
         : KoColorConversionTransformation(srcCs,
                                           dstCs,
                                           renderingIntent,
                                           conversionFlags)
     {
     }
 
     void transform(const quint8 *src, quint8 *dst, qint32 nPixels) const override {
         KIS_ASSERT(src != dst);
 
         const typename SrcCSTraits::Pixel *srcPixel = reinterpret_cast<const typename SrcCSTraits::Pixel*>(src);
         typename DstCSTraits::Pixel *dstPixel = reinterpret_cast<typename DstCSTraits::Pixel*>(dst);
 
         typedef typename SrcCSTraits::channels_type src_channel_type;
         typedef typename DstCSTraits::channels_type dst_channel_type;
         typedef Policy<src_channel_type, dst_channel_type> ConcretePolicy;
 
         for (int i = 0; i < nPixels; i++) {
             dstPixel->red = ConcretePolicy::process(srcPixel->red);
             dstPixel->green = ConcretePolicy::process(srcPixel->green);
             dstPixel->blue = ConcretePolicy::process(srcPixel->blue);
             dstPixel->alpha =
                 KoColorSpaceMaths<src_channel_type, dst_channel_type>::scaleToA(
                 srcPixel->alpha);
 
             srcPixel++;
             dstPixel++;
         }
     }
 
 };
 
 template<class ParentColorSpace, class DstColorSpaceTraits = typename DstTraitsForSource<typename ParentColorSpace::ColorSpaceTraits>::result>
 class LcmsFromRGBP2020PQTransformationFactory : public KoColorConversionTransformationFactory
 {
 public:
     LcmsFromRGBP2020PQTransformationFactory()
         : KoColorConversionTransformationFactory(RGBAColorModelID.id(),
                                                  colorDepthIdForChannelType<typename ParentColorSpace::ColorSpaceTraits::channels_type>().id(),
                                                  "High Dynamic Range UHDTV Wide Color Gamut Display (Rec. 2020) - SMPTE ST 2084 PQ EOTF",
                                                  RGBAColorModelID.id(),
                                                  colorDepthIdForChannelType<typename DstColorSpaceTraits::channels_type>().id(),
                                                  "Rec2020-elle-V4-g10.icc")
     {
     }
 
     bool conserveColorInformation() const override {
         return true;
     }
 
     bool conserveDynamicRange() const override {
         return
             dstColorDepthId() == Float16BitsColorDepthID.id() ||
             dstColorDepthId() == Float32BitsColorDepthID.id() ||
             dstColorDepthId() == Float64BitsColorDepthID.id();
     }
 
     KoColorConversionTransformation* createColorTransformation(const KoColorSpace* srcColorSpace,
                                                                const KoColorSpace* dstColorSpace,
                                                                KoColorConversionTransformation::Intent renderingIntent,
                                                                KoColorConversionTransformation::ConversionFlags conversionFlags) const override
     {
         return new ApplyRgbShaper<
                 typename ParentColorSpace::ColorSpaceTraits,
                 DstColorSpaceTraits,
                 RemoveSmpte2048Policy>(srcColorSpace,
                                        dstColorSpace,
                                        renderingIntent,
                                        conversionFlags);
     }
 };
 
 template<class ParentColorSpace, class DstColorSpaceTraits = typename DstTraitsForSource<typename ParentColorSpace::ColorSpaceTraits>::result>
 class LcmsToRGBP2020PQTransformationFactory : public KoColorConversionTransformationFactory
 {
 public:
     LcmsToRGBP2020PQTransformationFactory()
         : KoColorConversionTransformationFactory(RGBAColorModelID.id(),
                                                  colorDepthIdForChannelType<typename DstColorSpaceTraits::channels_type>().id(),
                                                  "Rec2020-elle-V4-g10.icc",
                                                  RGBAColorModelID.id(),
                                                  colorDepthIdForChannelType<typename ParentColorSpace::ColorSpaceTraits::channels_type>().id(),
                                                  "High Dynamic Range UHDTV Wide Color Gamut Display (Rec. 2020) - SMPTE ST 2084 PQ EOTF")
     {
     }
 
     bool conserveColorInformation() const override {
         return true;
     }
 
     bool conserveDynamicRange() const override {
         return true;
     }
 
     KoColorConversionTransformation* createColorTransformation(const KoColorSpace* srcColorSpace,
                                                                const KoColorSpace* dstColorSpace,
                                                                KoColorConversionTransformation::Intent renderingIntent,
                                                                KoColorConversionTransformation::ConversionFlags conversionFlags) const override
     {
         return new ApplyRgbShaper<
                 DstColorSpaceTraits,
                 typename ParentColorSpace::ColorSpaceTraits,
                 ApplySmpte2048Policy>(srcColorSpace,
                                       dstColorSpace,
                                       renderingIntent,
                                       conversionFlags);
     }
 };
 
 template<class ParentColorSpace, class DstColorSpaceTraits>
 class LcmsScaleRGBP2020PQTransformationFactory : public KoColorConversionTransformationFactory
 {
 public:
     LcmsScaleRGBP2020PQTransformationFactory()
         : KoColorConversionTransformationFactory(RGBAColorModelID.id(),
                                                  colorDepthIdForChannelType<typename ParentColorSpace::ColorSpaceTraits::channels_type>().id(),
                                                  "High Dynamic Range UHDTV Wide Color Gamut Display (Rec. 2020) - SMPTE ST 2084 PQ EOTF",
                                                  RGBAColorModelID.id(),
                                                  colorDepthIdForChannelType<typename DstColorSpaceTraits::channels_type>().id(),
                                                  "High Dynamic Range UHDTV Wide Color Gamut Display (Rec. 2020) - SMPTE ST 2084 PQ EOTF")
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(srcColorDepthId() != dstColorDepthId());
     }
 
     bool conserveColorInformation() const override {
         return true;
     }
 
     bool conserveDynamicRange() const override {
         return
             srcColorDepthId() == Float16BitsColorDepthID.id() ||
             srcColorDepthId() == Float32BitsColorDepthID.id() ||
             srcColorDepthId() == Float64BitsColorDepthID.id();
     }
 
     KoColorConversionTransformation* createColorTransformation(const KoColorSpace* srcColorSpace,
                                                                const KoColorSpace* dstColorSpace,
                                                                KoColorConversionTransformation::Intent renderingIntent,
                                                                KoColorConversionTransformation::ConversionFlags conversionFlags) const override
     {
         return new ApplyRgbShaper<
                 typename ParentColorSpace::ColorSpaceTraits,
                 DstColorSpaceTraits,
                 NoopPolicy>(srcColorSpace,
                             dstColorSpace,
                             renderingIntent,
                             conversionFlags);
     }
 };
 
 #endif // LCMSRGBP2020PQCOLORSPACETRANSFORMATION_H