OpenEXR 3.5.1__tar.gz → 3.5.2__tar.gz

{openexr-3.5.1 → openexr-3.5.2}/CHANGES.md

@@ -3,6 +3,7 @@
 
 # OpenEXR Release Notes
 
+* [Version 3.5.2](#version-352-october-2-2026) October 2, 2026
 * [Version 3.5.1](#version-351-september-25-2026) September 25, 2026
 * [Version 3.5.0](#version-350-september-21-2026) September 21, 2026
 * [Version 3.4.15](#version-3415-august-21-2026) August 21, 2026
@@ -115,6 +116,63 @@
 * [Version 1.0.1](#version-101)
 * [Version 1.0](#version-10)
 
+## Version 3.5.2 (October 2, 2026)
+
+Patch release that introduces the use of OpenJPH's built-in LUT to
+apply the decode/encode transfer function for lossy LJ2K compression.
+
+:warning: WARNING: EXR files written by OpenEXR v3.5.0 and v3.5.1
+using lossy LJ2K compression lack the LUT in their codestream and
+should be regenerated. This v3.5.2 release includes a backwards
+compatibility fallback so that such files can be successfully decoded,
+but for best results, please regenerate any files using LJ2K written
+by v3.5.0 and v3.5.1.
+
+Also in this release:
+
+* Prebuilt wheels Python 3.14.
+* Fix for a bug when when statically linking when libdeflate, zstd, or
+  OpenJPH is found via pkg-config rather than CMake config.
+* Pin the `IMATH_TAG` to `v3.2.3`; it was previously incorrectly set to `main`.
+* Pin the JPEG 2000 progression order to RPCL and adds TLM markers to
+  allow efficient random access to resolution layers for J2K compression. 
+
+### Merged Pull Requests
+
+* [2694](https://github.com/AcademySoftwareFoundation/openexr/pull/2694)
+  LJ2K: add compatibility with v3.5.0 an v3.5.1 files (by @palemieux/Pierre-Anthony Lemieux)
+* [2688](https://github.com/AcademySoftwareFoundation/openexr/pull/2688)
+  Fix integer overflow in exrcheck's readCoreTiledPart tile size accumulation (by @cary-ilm/Cary Phillips)
+* [2679](https://github.com/AcademySoftwareFoundation/openexr/pull/2679)
+  Remove forward declarations in `IMATH_INTERNAL_NAMESPACE` (by @cary-ilm/Cary Phillips)
+* [2673](https://github.com/AcademySoftwareFoundation/openexr/pull/2673)
+  Recreate pkg-config dependency targets in OpenEXRConfig.cmake (by @lgritz/Larry Gritz)
+* [2672](https://github.com/AcademySoftwareFoundation/openexr/pull/2672)
+  J2K: pin progression order to RPCL and add TLM (by @palemieux/Pierre-Anthony Lemieux)
+* [2637](https://github.com/AcademySoftwareFoundation/openexr/pull/2637)
+  LJ2K: Use J2K Type 4 NLT LUT to apply the transfer function (by @palemieux/Pierre-Anthony Lemieux)
+
+### Merged Workflow Pull Requests
+
+* [2692](https://github.com/AcademySoftwareFoundation/openexr/pull/2692)
+  Bump jmertic/slack-release-notifier from 20260820 to 20260930 (by @app/dependabot)
+* [2689](https://github.com/AcademySoftwareFoundation/openexr/pull/2689)
+  Bump msys2/setup-msys2 from 2.32.0 to 2.33.0 (by @app/dependabot)
+* [2685](https://github.com/AcademySoftwareFoundation/openexr/pull/2685)
+  Build wheel for Python 3.14 (by @cary-ilm/Cary Phillips)
+* [2677](https://github.com/AcademySoftwareFoundation/openexr/pull/2677)
+  Bump vmactions/freebsd-vm from 1.5.7 to 1.5.8 (by @app/dependabot)
+* [2676](https://github.com/AcademySoftwareFoundation/openexr/pull/2676)
+  Bump the codeql group with 3 updates (by @app/dependabot)
+* [2664](https://github.com/AcademySoftwareFoundation/openexr/pull/2664)
+  Bump vmactions/freebsd-vm from 1.5.6 to 1.5.7 (by @app/dependabot)
+* [2663](https://github.com/AcademySoftwareFoundation/openexr/pull/2663)
+  Bump the codeql group with 3 updates (by @app/dependabot)
+* [2662](https://github.com/AcademySoftwareFoundation/openexr/pull/2662)
+  Update urllib3 requirement from >=2.7 to >=2.8.0 in /website (by @app/dependabot)
+* [2661](https://github.com/AcademySoftwareFoundation/openexr/pull/2661)
+  Update idna requirement from >=3.19 to >=3.20 in /website (by @app/dependabot)
+
 ## Version 3.5.1 (September 25, 2026)
 
 Patch release that addresses a security vulnerability in ZSTD:
@@ -246,8 +304,6 @@ This release addresses the following security vulnerabilities:
 * [2640](https://github.com/AcademySoftwareFoundation/openexr/pull/2640)
   LJ2K: declare the chunk padding in a COM marker segment (by
   @osamu620/Osamu Watanabe)
-* [2637](https://github.com/AcademySoftwareFoundation/openexr/pull/2637)
-  LJ2K: Use J2K Type 4 NLT LUT to apply the transfer function (by @palemieux/Pierre-Anthony Lemieux)
 * [2633](https://github.com/AcademySoftwareFoundation/openexr/pull/2633)
   LJ2K: pad lossy chunks so that wavelet folds stay on low-pass
   positions (by @osamu620/Osamu Watanabe)

{openexr-3.5.1 → openexr-3.5.2}/MODULE.bazel

@@ -9,7 +9,7 @@ module(
 bazel_dep(name = "bazel_skylib", version = "1.9.2")
 bazel_dep(name = "imath", version = "3.2.3")
 bazel_dep(name = "libdeflate", version = "1.26")
-bazel_dep(name = "openjph", version = "0.31.0")
+bazel_dep(name = "openjph", version = "0.32.0")
 bazel_dep(name = "platforms", version = "1.1.0")
 bazel_dep(name = "rules_cc", version = "0.2.25")
 bazel_dep(name = "zstd", version = "1.5.7.bcr.2")

{openexr-3.5.1 → openexr-3.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: OpenEXR
-Version: 3.5.1
+Version: 3.5.2
 Summary: Python bindings for the OpenEXR image file format
 Author-Email: Contributors to the OpenEXR project <info@openexr.com>
 Project-URL: Homepage, https://openexr.com

openexr-3.5.2/cmake/OpenEXRConfig.cmake.in

@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) Contributors to the OpenEXR Project.
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+set(openexr_needthreads @OPENEXR_ENABLE_THREADING@)
+if (openexr_needthreads)
+  set(THREADS_PREFER_PTHREAD_FLAG ON)
+  find_dependency(Threads)
+endif()
+unset(openexr_needthreads)
+
+find_dependency(Imath)
+
+# A static OpenEXRCore links to any dependency found via pkg-config through
+# a PkgConfig:: imported target, which must be recreated here.
+macro(openexr_find_pkgconfig_dependency prefix module)
+  if (NOT TARGET PkgConfig::${prefix})
+    find_dependency(PkgConfig)
+    pkg_check_modules(${prefix} REQUIRED QUIET IMPORTED_TARGET GLOBAL ${module})
+  endif()
+endmacro()
+
+if ("@EXR_DEFLATE_LIB@" STREQUAL "PkgConfig::deflate")
+  if (NOT @BUILD_SHARED_LIBS@)
+    openexr_find_pkgconfig_dependency(deflate libdeflate)
+  endif()
+elseif (@libdeflate_FOUND@)
+  find_dependency(libdeflate)
+endif()
+
+if ("@EXR_OPENJPH_LIB@" STREQUAL "PkgConfig::openjph")
+  if (NOT @BUILD_SHARED_LIBS@)
+    openexr_find_pkgconfig_dependency(openjph "openjph=@openjph_VERSION@")
+  endif()
+elseif (NOT @OPENEXR_USE_INTERNAL_OPENJPH@)
+  find_dependency(openjph)
+endif()
+
+if ("@EXR_ZSTD_LIB@" STREQUAL "PkgConfig::libzstd")
+  if (NOT @BUILD_SHARED_LIBS@)
+    openexr_find_pkgconfig_dependency(libzstd libzstd)
+  endif()
+elseif (@zstd_FOUND@)
+  find_dependency(zstd CONFIG)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+check_required_components("@PROJECT_NAME@")

{openexr-3.5.1 → openexr-3.5.2}/cmake/OpenEXRSetup.cmake

@@ -336,7 +336,7 @@ endif()
 option(OPENEXR_FORCE_INTERNAL_IMATH "Force using an internal imath" OFF)
 # Check to see if Imath is installed outside of the current build directory.
 set(OPENEXR_IMATH_REPO "https://github.com/AcademySoftwareFoundation/Imath.git" CACHE STRING "Repo for auto-build of Imath")
-set(OPENEXR_IMATH_TAG "main" CACHE STRING "Tag for auto-build of Imath (branch, tag, or SHA)")
+set(OPENEXR_IMATH_TAG "v3.2.3" CACHE STRING "Tag for auto-build of Imath (branch, tag, or SHA)")
 if(NOT OPENEXR_FORCE_INTERNAL_IMATH)
   #TODO: ^^ Release should not clone from main, this is a place holder
   set(CMAKE_IGNORE_PATH "${CMAKE_CURRENT_BINARY_DIR}/_deps/imath-src/config;${CMAKE_CURRENT_BINARY_DIR}/_deps/imath-build/config")

{openexr-3.5.1 → openexr-3.5.2}/src/lib/OpenEXR/ImfBoxAttribute.cpp

@@ -13,12 +13,6 @@
 #include <Imath/ImathExport.h>
 #include <Imath/ImathNamespace.h>
 
-IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Vec2;
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Vec3;
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Box;
-IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
-
 #define COMPILING_IMF_BOX_ATTRIBUTE
 
 #include "ImfBoxAttribute.h"

{openexr-3.5.1 → openexr-3.5.2}/src/lib/OpenEXR/ImfMatrixAttribute.cpp

@@ -15,11 +15,6 @@
 #include <Imath/ImathExport.h>
 #include <Imath/ImathNamespace.h>
 
-IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Matrix33;
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Matrix44;
-IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
-
 #define COMPILING_IMF_MATRIX_ATTRIBUTE
 
 #include "ImfMatrixAttribute.h"

{openexr-3.5.1 → openexr-3.5.2}/src/lib/OpenEXR/ImfVecAttribute.cpp

@@ -17,11 +17,6 @@
 #include <Imath/ImathExport.h>
 #include <Imath/ImathNamespace.h>
 
-IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Vec2;
-template <class V> class IMF_EXPORT_TEMPLATE_TYPE Vec3;
-IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
-
 #define COMPILING_IMF_VECTOR_ATTRIBUTE
 #include "ImfVecAttribute.h"
 

{openexr-3.5.1 → openexr-3.5.2}/src/lib/OpenEXRCore/internal_ht.cpp

@@ -24,6 +24,116 @@
 #include "internal_ht_quality.h"
 #include "internal_legacy_structs.h"
 
+namespace
+{
+/* NLT type 4 point tables for lossy RGB channels. Most float imagery lies
+ * within half's range, so the float table for that range is precomputed;
+ * only chunks exceeding it get a table built for their own range. */
+const int32_t float_nlt_lut_points = 257;
+const std::vector<uint16_t> half_nlt_lut = build_nlt_lut_16 (513);
+const std::vector<uint32_t> float_nlt_lut_half_range =
+    build_nlt_lut_32 (float_nlt_lut_points, HALF_MAX);
+
+/* Returns the range the float NLT table has to cover for a chunk: half's
+ * max unless the chunk's RGB samples exceed it. */
+double
+chunk_max_linear_float (
+    exr_encode_pipeline_t*                    encode,
+    const std::vector<CodestreamChannelInfo>& cs_channel_info,
+    bool                                       isPlanar,
+    int                                        chunk_height)
+{
+    const uint8_t* packed =
+        static_cast<const uint8_t*> (encode->packed_buffer);
+    double max_abs = 0.0;
+
+    if (isPlanar)
+    {
+        for (int16_t c = 0; c < 3; c++)
+        {
+            int file_c = cs_channel_info[c].file_index;
+            if (encode->channels[file_c].data_type != EXR_PIXEL_FLOAT)
+                continue;
+            if (encode->channels[file_c].height == 0) continue;
+
+            const uint8_t* line_pixels = packed;
+
+            for (int64_t y = encode->chunk.start_y;
+                 y < chunk_height + encode->chunk.start_y;
+                 y++)
+            {
+                for (int16_t line_c = 0; line_c < encode->channel_count;
+                     line_c++)
+                {
+                    if (y % encode->channels[line_c].y_samples != 0)
+                        continue;
+
+                    if (line_c == file_c)
+                    {
+                        const float* p =
+                            reinterpret_cast<const float*> (line_pixels);
+                        for (int32_t x = 0;
+                             x < encode->channels[file_c].width;
+                             x++)
+                        {
+                            float v = p[x];
+                            if (std::isfinite (v))
+                            {
+                                double av = std::fabs ((double) v);
+                                if (av > max_abs) max_abs = av;
+                            }
+                        }
+                    }
+
+                    line_pixels +=
+                        (int64_t) encode->channels[line_c].bytes_per_element *
+                        encode->channels[line_c].width;
+                }
+            }
+        }
+    }
+    else
+    {
+        int64_t bpl = 0;
+        for (int16_t c = 0; c < encode->channel_count; c++)
+        {
+            int file_c = cs_channel_info[c].file_index;
+            bpl += (int64_t) encode->channels[file_c].bytes_per_element *
+                   encode->channels[file_c].width;
+        }
+
+        for (int16_t c = 0; c < 3; c++)
+        {
+            int file_c = cs_channel_info[c].file_index;
+            if (encode->channels[file_c].data_type != EXR_PIXEL_FLOAT)
+                continue;
+
+            const int32_t cw = encode->channels[file_c].width;
+            for (int y = 0; y < chunk_height; y++)
+            {
+                const float* p = reinterpret_cast<const float*> (
+                    packed + (int64_t) y * bpl +
+                    cs_channel_info[c].raster_line_offset);
+                for (int32_t x = 0; x < cw; x++)
+                {
+                    float v = p[x];
+                    if (std::isfinite (v))
+                    {
+                        double av = std::fabs ((double) v);
+                        if (av > max_abs) max_abs = av;
+                    }
+                }
+            }
+        }
+    }
+
+    /* Safety margin so the observed max doesn't sit exactly on the table's
+     * saturation boundary. */
+    const double margin = 1.05;
+    return max_abs > HALF_MAX ? max_abs * margin : (double) HALF_MAX;
+}
+} // namespace
+
 /**
  * OpenJPH output file that is backed by a fixed-size memory buffer
  */
@@ -168,6 +278,7 @@ struct ht_context_cache
     std::vector<CodestreamChannelInfo> cs_to_file_ch;
     ojph::codestream cs;
     size_t header_sz = 0;
+    HeaderMagic magic = HeaderMagic::V1;
 };
 
 /*
@@ -225,6 +336,40 @@ static void destroy_ht_decompress_context (exr_decode_pipeline_t* decode)
     decode->free_compression_context = NULL;
 }
 
+/* Decodes one line of samples into the EXR pixel buffer; with legacy_tf
+ * the legacy transfer function is undone on the way. */
+static inline void
+decode_line (
+    void*             dst,
+    const ojph::si32* src,
+    int32_t           width,
+    exr_pixel_type_t  type,
+    bool              legacy_tf)
+{
+    if (type == EXR_PIXEL_HALF)
+    {
+        int16_t* out = static_cast<int16_t*> (dst);
+        if (legacy_tf)
+            for (int32_t p = 0; p < width; p++)
+                *out++ = (int16_t) legacy_int16_to_half (src[p]).bits ();
+        else
+            for (int32_t p = 0; p < width; p++)
+                *out++ = src[p];
+    }
+    else if (legacy_tf)
+    {
+        float* out = static_cast<float*> (dst);
+        for (int32_t p = 0; p < width; p++)
+            *out++ = legacy_int32_to_float (src[p]);
+    }
+    else
+    {
+        uint32_t* out = static_cast<uint32_t*> (dst);
+        for (int32_t p = 0; p < width; p++)
+            *out++ = (uint32_t) src[p];
+    }
+}
+
 static exr_result_t
 ht_undo_impl (
     exr_decode_pipeline_t* decode,
@@ -254,8 +399,11 @@ ht_undo_impl (
         ctxt = legacy_support.get();
     }
 
-    std::vector<CodestreamChannelInfo> &cs_to_file_ch = ctxt->cs_to_file_ch;
-    bool resetOffsets = false;
+    exr_compression_t comp = EXR_COMPRESSION_HTJ2K256;
+    exr_get_compression (decode->context, decode->part_index, &comp);
+
+    std::vector<CodestreamChannelInfo>& cs_to_file_ch = ctxt->cs_to_file_ch;
+    bool                                resetOffsets = false;
     if (static_cast<std::size_t>(decode->channel_count) != cs_to_file_ch.size ())
     {
         resetOffsets = true;
@@ -265,12 +413,18 @@ ht_undo_impl (
         try
         {
             ctxt->header_sz = read_header (
-                (uint8_t*) compressed_data, comp_buf_size, cs_to_file_ch);
+                (uint8_t*) compressed_data, comp_buf_size, cs_to_file_ch, ctxt->magic);
         }
         catch (...)
         {
             return EXR_ERR_CORRUPT_CHUNK;
         }
+
+        /* V1 is the only valid magic number, except for LJ2K, where V2 is
+           also valid */
+        if (ctxt->magic != HeaderMagic::V1 &&
+            !(comp == EXR_COMPRESSION_LJ2K && ctxt->magic == HeaderMagic::V2))
+            return EXR_ERR_CORRUPT_CHUNK;
     }
     else
     {
@@ -402,6 +556,16 @@ ht_undo_impl (
     cs.create ();
 
     ojph::param_cod cod = cs.access_cod ();
+    /* v3.5.0/v3.5.1 LJ2K files (HeaderMagic::V1) have the transfer function
+     * applied outside the codestream, so it is undone after decoding on their
+     * lossy components. */
+    std::vector<bool> is_ch_legacy_lossy (decode->channel_count, false);
+    if (comp == EXR_COMPRESSION_LJ2K && ctxt->magic == HeaderMagic::V1)
+    {
+        for (int c = 0; c < decode->channel_count; c++)
+            is_ch_legacy_lossy[c] = !cod.is_reversible (c);
+    }
+
     assert (sizeof (uint16_t) == 2);
     assert (sizeof (uint32_t) == 4);
     ojph::ui32      next_comp = 0;
@@ -437,33 +601,12 @@ ht_undo_impl (
                         cur_line = cs.pull (next_comp);
                         assert (next_comp == c);
 
-                        if (decode->channels[file_c].data_type ==
-                            EXR_PIXEL_HALF)
-                        {
-                            int16_t* channel_pixels = (int16_t*) line_pixels;
-                            for (int32_t p = 0;
-                                 p < decode->channels[file_c].width;
-                                 p++)
-                            {
-                                if (!cod.is_reversible(c))
-                                    *channel_pixels++ = (int16_t) int16_to_half(cur_line->i32[p]).bits();
-                                else
-                                    *channel_pixels++ = cur_line->i32[p];
-                            }
-                        }
-                        else
-                        {
-                            uint32_t* channel_pixels = (uint32_t*) line_pixels;
-                            for (int32_t p = 0;
-                                 p < decode->channels[file_c].width;
-                                 p++)
-                            {
-                                if (!cod.is_reversible(c))
-                                    *((float*) channel_pixels++) = int32_to_float(cur_line->i32[p]);
-                                else
-                                    *channel_pixels++ = (uint32_t) cur_line->i32[p];
-                            }
-                        }
+                        decode_line (
+                            line_pixels,
+                            cur_line->i32,
+                            decode->channels[file_c].width,
+                            static_cast<exr_pixel_type_t> (decode->channels[file_c].data_type),
+                            is_ch_legacy_lossy[c]);
                     }
 
                     line_pixels += (size_t) decode->channels[line_c].bytes_per_element *
@@ -490,32 +633,12 @@ ht_undo_impl (
                 cur_line   = cs.pull (next_comp);
                 assert (next_comp == c);
                 if (y >= out_height) continue;
-                if (decode->channels[file_c].data_type == EXR_PIXEL_HALF)
-                {
-                    int16_t* channel_pixels =
-                        (int16_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);
-                    for (int32_t p = 0; p < decode->channels[file_c].width;
-                         p++)
-                    {
-                        if (!cod.is_reversible(c))
-                            *channel_pixels++ = (int16_t) int16_to_half(cur_line->i32[p]).bits();
-                        else
-                            *channel_pixels++ = cur_line->i32[p];
-                    }
-                }
-                else
-                {
-                    uint32_t* channel_pixels =
-                        (uint32_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);
-                    for (int32_t p = 0; p < decode->channels[file_c].width;
-                         p++)
-                    {
-                        if (!cod.is_reversible(c))
-                            *((float*) channel_pixels++) = int32_to_float(cur_line->i32[p]);
-                        else
-                            *channel_pixels++ = (uint32_t) cur_line->i32[p];
-                    }
-                }
+                decode_line (
+                    line_pixels + cs_to_file_ch[c].raster_line_offset,
+                    cur_line->i32,
+                    decode->channels[file_c].width,
+                    static_cast<exr_pixel_type_t> (decode->channels[file_c].data_type),
+                    is_ch_legacy_lossy[c]);
             }
             line_pixels += bpl;
         }
@@ -582,6 +705,8 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
 
     siz.set_num_components (encode->channel_count);
     cs.set_planar (isPlanar);
+    cs.request_tlm_marker (true);
+    cs.set_tilepart_divisions (true, false);
 
     exr_compression_t comp = EXR_COMPRESSION_HTJ2K256;
     exr_get_compression (encode->context, encode->part_index, &comp);
@@ -593,6 +718,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
     cod.set_color_transform (isRGB && !isPlanar);
     cod.set_block_dims (128, 32);
     cod.set_num_decomposition (num_decomps);
+    cod.set_progression_order ("RPCL");
 
     /* enable lossy compression on the first 3 channels, only if the compressor
     is EXR_COMPRESSION_LJ2K, we have RGB channels, all RGB channels are
@@ -610,6 +736,16 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
         }
     }
 
+    /* Compute the maximum sample value or HALF_MAX whichever is larger if RGB
+    float samples are used. This is used in generating the decoding LUT.*/
+    bool rgbIsFloat = lossy &&
+        encode->channels[cs_channel_info[0].file_index].data_type ==
+            EXR_PIXEL_FLOAT;
+    double chunk_max_linear = HALF_MAX;
+    if (rgbIsFloat)
+        chunk_max_linear = chunk_max_linear_float (
+            encode, cs_channel_info, isPlanar, chunk_height);
+
     /* Lossy coding: pad the coded array by replicating the last row and the
      * last column so that every dimension is == 1 (mod 2^L); see
      * ht_padded_length().  The padding is only applied to interleaved
@@ -656,6 +792,17 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
             double scaled_q = (qfactor - 97.)/53.;
             double delta_ref = 0.005 * pow(2, -28.478*scaled_q) + 0.001 * pow(2, -10.534*scaled_q);
 
+            if (rgbIsFloat)
+            {
+                /* The quantization step is a fraction of the table's full
+                 * scale. Scale it so a given Qfactor means the same step in
+                 * the transfer function domain as for half, whose table spans
+                 * half's max. This is 1 unless the chunk exceeds half's range. */
+                double lut_gain =
+                    tf_from_linear (HALF_MAX) / tf_from_linear (chunk_max_linear);
+                delta_ref *= lut_gain;
+            }
+
             /*
              * Setting Qstep taking into account the gain from the ICT
              * converting encoded color-difference components to RGB (see
@@ -682,6 +829,16 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
         cod.set_reversible (true);
     }
 
+    const std::vector<uint32_t>* float_nlt_lut = &float_nlt_lut_half_range;
+    std::vector<uint32_t>        float_nlt_lut_chunk;
+    /* Only compute the float LUT if the max sample value is greater than HALF_MAX. */
+    if (rgbIsFloat && chunk_max_linear > HALF_MAX)
+    {
+        float_nlt_lut_chunk =
+            build_nlt_lut_32 (float_nlt_lut_points, chunk_max_linear);
+        float_nlt_lut = &float_nlt_lut_chunk;
+    }
+
     int64_t bpl = 0;
     for (int16_t c = 0; c < encode->channel_count; c++)
     {
@@ -691,6 +848,22 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
             nlt.set_nonlinear_transform (
                 c,
                 ojph::param_nlt::nonlinearity::OJPH_NLT_BINARY_COMPLEMENT_NLT);
+        else if (encode->channels[file_c].data_type != EXR_PIXEL_UINT && !cod.is_reversible(c))
+        {
+            /* OpenJPH's Type 4 NLT LUT is used*/
+            if (encode->channels[file_c].data_type == EXR_PIXEL_HALF)
+                nlt.set_nonlinear_transform (
+                    c, 16, true, 0u, 0xFFFFFFFFu, 16,
+                    (ojph::ui16) half_nlt_lut.size (),
+                    (void*) half_nlt_lut.data (),
+                    ojph::param_nlt::nonlinearity::OJPH_NLT_BINARY_COMPLEMENT_PLUS_LUT);
+            else
+                nlt.set_nonlinear_transform (
+                    c, 32, true, 0u, 0xFFFFFFFFu, 32,
+                    (ojph::ui16) float_nlt_lut->size (),
+                    (void*) float_nlt_lut->data (),
+                    ojph::param_nlt::nonlinearity::OJPH_NLT_BINARY_COMPLEMENT_PLUS_LUT);
+        }
 
         siz.set_component (
             c,
@@ -712,7 +885,9 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
         size_t header_sz = write_header (
             (uint8_t*) encode->compressed_buffer,
             encode->packed_bytes,
-            cs_channel_info);
+            cs_channel_info,
+            comp == EXR_COMPRESSION_LJ2K ? HeaderMagic::V2 : HeaderMagic::V1
+        );
 
         /* write the codestream */
         staticmem_outfile output;
@@ -774,10 +949,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                                      p < encode->channels[file_c].width;
                                     p++)
                                 {
-                                    if (! cod.is_reversible(c))
-                                        cur_line->i32[p] = half_to_int16(half (half::FromBits, (uint16_t) (*channel_pixels++)));
-                                    else
-                                        cur_line->i32[p] = *channel_pixels++;
+                                    cur_line->i32[p] = *channel_pixels++;
                                 }
                             }
                             else
@@ -787,10 +959,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                                      p < encode->channels[file_c].width;
                                     p++)
                                 {
-                                    if (! cod.is_reversible(c))
-                                        cur_line->i32[p] = float_to_int32(*((float *)channel_pixels++));
-                                    else
-                                        cur_line->i32[p] = *channel_pixels++;
+                                    cur_line->i32[p] = *channel_pixels++;
                                 }
                             }
 
@@ -832,10 +1001,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                                         cs_channel_info[c].raster_line_offset);
                         for (int32_t p = 0; p < cw; p++)
                         {
-                            if (! cod.is_reversible(c))
-                                cur_line->i32[p] = half_to_int16(half (half::FromBits, (uint16_t) (*channel_pixels++)));
-                            else
-                                cur_line->i32[p] = *channel_pixels++;
+                            cur_line->i32[p] = *channel_pixels++;
                         }
                     }
                     else
@@ -845,10 +1011,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                                         cs_channel_info[c].raster_line_offset);
                         for (int32_t p = 0; p < cw; p++)
                         {
-                            if (! cod.is_reversible(c))
-                                cur_line->i32[p] = float_to_int32(*((float *)channel_pixels++));
-                            else
-                                cur_line->i32[p] = *channel_pixels++;
+                            cur_line->i32[p] = *channel_pixels++;
                         }
                     }
                     for (int32_t p = cw; p < image_width; p++)