opencodecs 0.1.3__tar.gz → 0.1.5__tar.gz

opencodecs-0.1.5/3rdparty/cfitsio/pliocomp.c

@@ -0,0 +1,331 @@
+/* stdlib is needed for the abs function */
+#include <stdlib.h>
+/*
+   The following prototype code was provided by Doug Tody, NRAO, for
+   performing conversion between pixel arrays and line lists.  The
+   compression technique is used in IRAF.
+*/
+int pl_p2li (int *pxsrc, int xs, short *lldst, int npix);
+int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix);
+
+
+/*
+ * PL_P2L -- Convert a pixel array to a line list.  The length of the list is
+ * returned as the function value.
+ *
+ * Translated from the SPP version using xc -f, f2c.  8Sep99 DCT.
+ */
+
+#ifndef min
+#define min(a,b)        (((a)<(b))?(a):(b))
+#endif
+#ifndef max
+#define max(a,b)        (((a)>(b))?(a):(b))
+#endif
+
+int pl_p2li (int *pxsrc, int xs, short *lldst, int npix)
+/* int *pxsrc;                      input pixel array */
+/* int xs;                          starting index in pxsrc (?) */
+/* short *lldst;                    encoded line list */
+/* int npix;                        number of pixels to convert */
+{
+    /* System generated locals */
+    int ret_val, i__1, i__2, i__3;
+
+    /* Local variables */
+    int zero, v, x1, hi, ip, dv, xe, np, op, iz, nv = 0, pv, nz;
+
+    /* Parameter adjustments */
+    --lldst;
+    --pxsrc;
+
+    /* Function Body */
+    if (! (npix <= 0)) {
+        goto L110;
+    }
+    ret_val = 0;
+    goto L100;
+L110:
+    lldst[3] = -100;
+    lldst[2] = 7;
+    lldst[1] = 0;
+    lldst[6] = 0;
+    lldst[7] = 0;
+    xe = xs + npix - 1;
+    op = 8;
+    zero = 0;
+/* Computing MAX */
+    i__1 = zero, i__2 = pxsrc[xs];
+    pv = max(i__1,i__2);
+    x1 = xs;
+    iz = xs;
+    hi = 1;
+    i__1 = xe;
+    for (ip = xs; ip <= i__1; ++ip) {
+        if (! (ip < xe)) {
+            goto L130;
+        }
+/* Computing MAX */
+        i__2 = zero, i__3 = pxsrc[ip + 1];
+        nv = max(i__2,i__3);
+        if (! (nv == pv)) {
+            goto L140;
+        }
+        goto L120;
+L140:
+        if (! (pv == 0)) {
+            goto L150;
+        }
+        pv = nv;
+        x1 = ip + 1;
+        goto L120;
+L150:
+        goto L131;
+L130:
+        if (! (pv == 0)) {
+            goto L160;
+        }
+        x1 = xe + 1;
+L160:
+L131:
+        np = ip - x1 + 1;
+        nz = x1 - iz;
+        if (! (pv > 0)) {
+            goto L170;
+        }
+        dv = pv - hi;
+        if (! (dv != 0)) {
+            goto L180;
+        }
+        hi = pv;
+        if (! (abs(dv) > 4095)) {
+            goto L190;
+        }
+        lldst[op] = (short) ((pv & 4095) + 4096);
+        ++op;
+        lldst[op] = (short) (pv / 4096);
+        ++op;
+        goto L191;
+L190:
+        if (! (dv < 0)) {
+            goto L200;
+        }
+        lldst[op] = (short) (-dv + 12288);
+        goto L201;
+L200:
+        lldst[op] = (short) (dv + 8192);
+L201:
+        ++op;
+        if (! (np == 1 && nz == 0)) {
+            goto L210;
+        }
+        v = lldst[op - 1];
+        lldst[op - 1] = (short) (v | 16384);
+        goto L91;
+L210:
+L191:
+L180:
+L170:
+        if (! (nz > 0)) {
+            goto L220;
+        }
+L230:
+        if (! (nz > 0)) {
+            goto L232;
+        }
+        lldst[op] = (short) min(4095,nz);
+        ++op;
+/* L231: */
+        nz += -4095;
+        goto L230;
+L232:
+        if (! (np == 1 && pv > 0)) {
+            goto L240;
+        }
+        lldst[op - 1] = (short) (lldst[op - 1] + 20481);
+        goto L91;
+L240:
+L220:
+L250:
+        if (! (np > 0)) {
+            goto L252;
+        }
+        lldst[op] = (short) (min(4095,np) + 16384);
+        ++op;
+/* L251: */
+        np += -4095;
+        goto L250;
+L252:
+L91:
+        x1 = ip + 1;
+        iz = x1;
+        pv = nv;
+L120:
+        ;
+    }
+/* L121: */
+    lldst[4] = (short) ((op - 1) % 32768);
+    lldst[5] = (short) ((op - 1) / 32768);
+    ret_val = op - 1;
+    goto L100;
+L100:
+    return ret_val;
+} /* plp2li_ */
+
+/*
+ * PL_L2PI -- Translate a PLIO line list into an integer pixel array.
+ * The number of pixels output (always npix) is returned as the function
+ * value.
+ *
+ * Translated from the SPP version using xc -f, f2c.  8Sep99 DCT.
+ */
+
+int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix)
+/* short *ll_src;                   encoded line list */
+/* int xs;                          starting index in ll_src */
+/* int *px_dst;                    output pixel array */
+/* int npix;                       number of pixels to convert */
+{
+    /* System generated locals */
+    int ret_val, i__1, i__2;
+
+    /* Local variables */
+    int data, sw0001, otop, i__, lllen, i1, i2, x1, x2, ip, xe, np,
+             op, pv, opcode, llfirt;
+    int skipwd;
+
+    /* Parameter adjustments */
+    --px_dst;
+    --ll_src;
+
+    /* Function Body */
+    if (! (ll_src[3] > 0)) {
+        goto L110;
+    }
+    lllen = ll_src[3];
+    llfirt = 4;
+    goto L111;
+L110:
+    lllen = (ll_src[5] << 15) + ll_src[4];
+    llfirt = ll_src[2] + 1;
+L111:
+    if (! (npix <= 0 || lllen <= 0)) {
+        goto L120;
+    }
+    ret_val = 0;
+    goto L100;
+L120:
+    xe = xs + npix - 1;
+    skipwd = 0;
+    op = 1;
+    x1 = 1;
+    pv = 1;
+    i__1 = lllen;
+    for (ip = llfirt; ip <= i__1; ++ip) {
+        if (! skipwd) {
+            goto L140;
+        }
+        skipwd = 0;
+        goto L130;
+L140:
+        opcode = ll_src[ip] / 4096;
+        data = ll_src[ip] & 4095;
+        sw0001 = opcode;
+        goto L150;
+L160:
+        x2 = x1 + data - 1;
+        i1 = max(x1,xs);
+        i2 = min(x2,xe);
+        np = i2 - i1 + 1;
+        if (! (np > 0)) {
+            goto L170;
+        }
+        otop = op + np - 1;
+        if (! (opcode == 4)) {
+            goto L180;
+        }
+        i__2 = otop;
+        for (i__ = op; i__ <= i__2; ++i__) {
+            px_dst[i__] = pv;
+/* L190: */
+        }
+/* L191: */
+        goto L181;
+L180:
+        i__2 = otop;
+        for (i__ = op; i__ <= i__2; ++i__) {
+            px_dst[i__] = 0;
+/* L200: */
+        }
+/* L201: */
+        if (! (opcode == 5 && i2 == x2)) {
+            goto L210;
+        }
+        px_dst[otop] = pv;
+L210:
+L181:
+        op = otop + 1;
+L170:
+        x1 = x2 + 1;
+        goto L151;
+L220:
+        pv = (ll_src[ip + 1] << 12) + data;
+        skipwd = 1;
+        goto L151;
+L230:
+        pv += data;
+        goto L151;
+L240:
+        pv -= data;
+        goto L151;
+L250:
+        pv += data;
+        goto L91;
+L260:
+        pv -= data;
+L91:
+        if (! (x1 >= xs && x1 <= xe)) {
+            goto L270;
+        }
+        px_dst[op] = pv;
+        ++op;
+L270:
+        ++x1;
+        goto L151;
+L150:
+        ++sw0001;
+        if (sw0001 < 1 || sw0001 > 8) {
+            goto L151;
+        }
+        switch ((int)sw0001) {
+            case 1:  goto L160;
+            case 2:  goto L220;
+            case 3:  goto L230;
+            case 4:  goto L240;
+            case 5:  goto L160;
+            case 6:  goto L160;
+            case 7:  goto L250;
+            case 8:  goto L260;
+        }
+L151:
+        if (! (x1 > xe)) {
+            goto L280;
+        }
+        goto L131;
+L280:
+L130:
+        ;
+    }
+L131:
+    i__1 = npix;
+    for (i__ = op; i__ <= i__1; ++i__) {
+        px_dst[i__] = 0;
+/* L290: */
+    }
+/* L291: */
+    ret_val = npix;
+    goto L100;
+L100:
+    return ret_val;
+} /* pll2pi_ */
+

{opencodecs-0.1.3 → opencodecs-0.1.5}/CHANGES.rst

@@ -10,6 +10,154 @@ Versions follow the same ``YYYY.M.D`` cadence as upstream when we
 publish; the entries below cluster work by date rather than by
 release because most of it has shipped continuously to ``main``.
 
+0.1.5 (2026-05-31)
+------------------
+
+**New codecs**
+
+* ``opencodecs.uhdr`` — Ultra-HDR / ISO 21496-1 (gainmap JPEG) via a
+  direct Cython binding to Google's libultrahdr. ``encode(hdr, ...)``
+  wraps libuhdr's full pipeline; ``encode_native(hdr, sdr=None, ...)``
+  is a fused-Cython fast path that computes SDR base + gain map in
+  ``nogil`` kernels (IEEE-754 polynomial log2/pow, cross-platform —
+  no Apple Accelerate intrinsics), JPEG-encodes both layers in
+  parallel via a 3-worker ThreadPoolExecutor, then hands the
+  pre-encoded JPEGs to libuhdr's api-4 for container assembly.
+  Measured 31 ms median for a 2000² float HDR on M-series Mac vs
+  ~173 ms for the libuhdr reference path — 5.5× faster. The
+  ``sdr=`` argument lets callers (notably tilescan pipelines) supply
+  their own SDR base instead of accepting the peak-normalised default.
+
+* ``PLIO_1`` — IRAF run-length mask coding closes the last FITS
+  tile-compression gap. Vendors cfitsio's ``pliocomp.c`` (Doug Tody /
+  NRAO, public-domain) and adds the tiny
+  ``opencodecs.codecs._plio.decode_raw`` shim. Round-trip tested
+  against astropy. The ``COMPRESSED_DATA`` BINTABLE column walker
+  now tracks per-column element byte width so the ``1PI`` (int16
+  opcodes) layout PLIO uses works alongside the ``1PB`` byte VLA the
+  other compressors use.
+
+**New API**
+
+* ``EerReader.sum(start, stop, *, weights=None, dtype=...)`` —
+  per-frame dose curve. ``weights[k]`` multiplies the k-th frame in
+  the requested range; output promotes to float64 when weights are
+  given so fractional contributions don't truncate. Use case:
+  beam-induced-motion correction and temporal-binning schemes that
+  emphasise different exposures across the acquisition.
+
+**Bug fixes**
+
+* HEIF encode against libheif ≥ 1.18 — newer libheif calls
+  ``strlen()`` on the user write-callback's ``heif_error.message``
+  even on success and rejects a ``NULL`` pointer with *"heif_writer
+  callback returned a null error text"*. The callback now hands back
+  a static empty string on success and a descriptive string on OOM.
+  Six tests (``test_heif_*``, ``test_phase5_icc.py[heif]``) go back
+  to green across every CI matrix entry.
+
+**CI / build**
+
+* ``bench/build_codec_libs.sh`` — the ``is_built`` cache-marker now
+  records the install dir alongside the version and re-verifies the
+  install dir exists before short-circuiting a recipe. Without this,
+  cibuildwheel's manylinux cache (which only covers ``/cibw-jxl-prefix``)
+  preserved the marker for recipes that install to
+  ``~/.cache/opencodecs/<lib>/`` outside the cached prefix —
+  ``lerc``, ``mozjpeg``, ``brotli``, ``zstd``, ``giflib`` — so the
+  recipe thought it was done while the actual library files were
+  gone. ``_lerc`` + ``_mozjpeg`` had been silently dropped from
+  Linux wheels for this reason; the fix restores them.
+
+* ``test_omezarr.py`` skips at module level on zarr-python < 3 —
+  fixtures use the v3 API surface, which doesn't exist on the v2
+  branch pip resolves on Python 3.10.
+
+* ``test_eer_imagecodecs_cross_validate`` is now symmetric on
+  decoder error: if either implementation raises, both must raise
+  for the combo to count. Tolerates imagecodecs ≥ 2026.5's tighter
+  output-buffer sizing.
+
+0.1.4 (2026-05-25)
+------------------
+
+**libvips-inspired streaming improvements**
+
+* ``HTTPDataSource(access='sequential', sequential_chunk_bytes=4*1024*1024)``
+  — opt-in libvips-style sequential read mode. Replaces the LRU +
+  adaptive read-ahead with a single rolling buffer that slides forward
+  as the caller reads. Memory stays bounded to one chunk regardless of
+  file size. Target workload: tile-by-tile raster scan over a huge
+  COG / OME-TIFF served over HTTP. Backward seeks still work but
+  invalidate the buffer; ``stats['sequential_backward_seeks']`` tracks
+  the count so users can spot a workload that's actually random and
+  would benefit from ``access='random'``.
+
+* ``TiffPyramidReader.read_region`` now parallelises tile decode
+  across a thread pool (default ``min(cpu_count(), 8)``). The
+  compressed-tile decoders (JPEG, JPEG-2000, deflate, zstd, LZW, WebP,
+  LERC) all release the GIL in their C path, so threads scale across
+  cores on CPython. Kicks in only when the region covers 4+ tiles —
+  fewer than that and thread-pool spin-up cost dominates. Pass
+  ``num_decode_workers=1`` to force the serial path for benchmarks /
+  regression-diff.
+
+* ``TiffWriter.write_pyramid_auto`` gained ``stream_levels=True``
+  (default for COG layout). Computes and writes one level at a time
+  via a new ``iter_pyramid_levels`` generator, dropping each finished
+  level before computing the next. Peak memory drops from
+  ``~1.33 × level0`` (entire geometric series materialised) to
+  ``~2 × current_level``. Useful when level 0 already dominates RAM
+  (whole-slide pathology, cryo-EM tomograms). Output file is
+  byte-identical to the materialize-all path. SubIFD layout
+  (``subifds=True``) still uses the materialize path because that
+  layout writes sub-resolution IFD offsets into the main IFD's tag
+  330 — sub-level offsets have to be known up front.
+
+  Validated via tests:
+  ``test_http_sequential_serves_from_rolling_buffer``,
+  ``test_http_sequential_backward_seek_counted``,
+  ``test_pyramid_reader_parallel_decode_matches_serial``,
+  ``test_pyramid_auto_stream_matches_materialize``,
+  ``test_iter_pyramid_levels_matches_make_pyramid_levels``.
+
+**MozJPEG ships on every wheel**
+
+* Added MozJPEG (Mozilla's libjpeg-turbo fork) to the cibuildwheel
+  codec-lib build set on Linux, macOS, and Windows. MozJPEG produces
+  JPEG files ~10-15% smaller than baseline libjpeg-turbo at the same
+  quality setting (progressive encoding + trellis quantization +
+  better quantization tables). The ``_mozjpeg`` extension has shipped
+  on macOS wheels for a while via brew; v0.1.4 brings it to
+  Linux + Windows so the codec is available everywhere.
+* New ``build_mozjpeg`` recipe in ``bench/build_codec_libs.sh``
+  installs into a keg-style ``mozjpeg/`` subdir under the prefix
+  (rather than the shared ``$PREFIX/{include,lib}``) to avoid the
+  libturbojpeg / libjpeg name collision with the libjpeg-turbo 3.x
+  install. setup.py's mozjpeg probe was extended to recognise the
+  new candidate paths on Linux (``~/.cache/opencodecs/mozjpeg``),
+  Windows (``$CONDA_PREFIX/Library/mozjpeg``), and the Windows
+  fallback (no ``nm``: trust the keg-style directory name).
+* Locally validated on win-vm (MSVC 14.44 — same as CI) and
+  kevin-tower (Linux x86_64): ``bash bench/build_codec_libs.sh
+  --only=mozjpeg`` followed by ``setup.py build_ext --inplace``
+  produces ``_mozjpeg.{pyd,so}`` cleanly. Per the new lesson in
+  CLAUDE.md, this iteration was validated end-to-end through the
+  same script CI runs, with the same env vars, before any push.
+
+**Post-publish wheel coverage check (CI hardening)**
+
+* New ``ci/check_wheel_contents.py`` runs in the wheel-build job
+  immediately after ``cibuildwheel`` produces each wheel. It unzips
+  the wheel, walks ``opencodecs/codecs/``, and asserts every codec
+  in the ``MUST_SHIP_ALL_PLATFORMS`` set has a ``.pyd``/``.so``
+  present. Missing codec → matrix job fails → publish step gated.
+* Catches the v0.1.2-style "changelog overclaim" silent-drop class
+  of bugs at build time instead of after publish. v0.1.2's Windows
+  wheels shipped without ``_sperr``/``_brunsli`` despite the
+  changelog claim; this check would have failed that build.
+
+
 0.1.3 (2026-05-22)
 ------------------
 

{opencodecs-0.1.3/src/opencodecs.egg-info → opencodecs-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencodecs
-Version: 0.1.3
+Version: 0.1.5
 Summary: Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)
 Author: Kevin Cutler
 License: BSD-3-Clause

{opencodecs-0.1.3 → opencodecs-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencodecs"
-version = "0.1.3"
+version = "0.1.5"
 description = "Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -142,7 +142,7 @@ before-all = [
     # bench/build_codec_libs.sh into the cached /cibw-jxl-prefix mount.
     # Skips encoders (aom, x265) — wheel ships decode-only AVIF/HEIF to
     # keep build < 12 min cold + avoid GPL x265.
-    "bash -c 'PATH=$HOME/.cargo/bin:$PATH bash bench/build_codec_libs.sh --only=libjpeg-turbo,c-blosc2,libde265,dav1d,libavif,libheif,libaec,lerc,zfp,SZ3,pcodec,SPERR,brunsli'",
+    "bash -c 'PATH=$HOME/.cargo/bin:$PATH bash bench/build_codec_libs.sh --only=libjpeg-turbo,c-blosc2,libde265,dav1d,libavif,libheif,libaec,lerc,zfp,SZ3,pcodec,SPERR,brunsli,mozjpeg'",
     "bash bench/build_libjxl.sh",
 ]
 # Don't set OPENCODECS_*_PREFIX here — build_wheels.yml's
@@ -159,8 +159,11 @@ before-all = [
 # cache by bench/build_codec_libs.sh. brunsli vendors brotli as a
 # submodule so the brew brotli isn't required at link time.
 before-all = [
+    # mozjpeg removed from this brew install — the formula ships libjpeg
+    # only, not libturbojpeg, so the _mozjpeg probe couldn't find what it
+    # needed. Source-build via build_codec_libs.sh produces both libs.
     "brew install jpeg-xl libavif libheif webp libpng jpeg-turbo openjpeg zstd brotli c-blosc2 lz4 libdeflate libaec liblerc zfp rust cmake ninja",
-    "bash bench/build_codec_libs.sh --only=SZ3,pcodec,SPERR,brunsli",
+    "bash bench/build_codec_libs.sh --only=SZ3,pcodec,SPERR,brunsli,mozjpeg",
 ]
 # macos-latest is now macOS 15 (Sequoia) on arm64. Homebrew formulas are
 # compiled for 15.x, so any wheel target lower than 15 fails the delocate

{opencodecs-0.1.3 → opencodecs-0.1.5}/setup.py

@@ -638,12 +638,30 @@ def _maybe_build_mozjpeg_ext() -> list[Extension]:
     # by symbol absence alone. For generic system prefixes like /usr or
     # /usr/local we additionally require a ``mozjpeg/`` include subdir
     # so we don't misidentify vanilla libjpeg-turbo as MozJPEG.
-    candidates = [
+    # Keg-style per-user cache install from
+    # bench/build_codec_libs.sh::build_mozjpeg (Linux/macOS) and the
+    # cibuildwheel Windows install (under $OPENCODECS_CODEC_LIBS_PREFIX
+    # or $CONDA_PREFIX/Library). All "keg-style" — no mozjpeg/ include
+    # subdir needed because the prefix itself is mozjpeg-only.
+    candidates: list[tuple[Path, bool]] = [
+        (_OC_USER_CACHE / "mozjpeg", False),
         (Path("/opt/homebrew/opt/mozjpeg"), False),
         (Path("/usr/local/opt/mozjpeg"), False),
+    ]
+    _libs_prefix_env = os.environ.get("OPENCODECS_CODEC_LIBS_PREFIX")
+    if _libs_prefix_env:
+        _libs_prefix_path = Path(_libs_prefix_env)
+        candidates.append((_libs_prefix_path / "mozjpeg", False))
+        # Conda Library/ layout: $CONDA_PREFIX/Library/mozjpeg
+        candidates.append((_libs_prefix_path / "Library" / "mozjpeg", False))
+    _conda = os.environ.get("CONDA_PREFIX")
+    if _conda:
+        candidates.append((Path(_conda) / "mozjpeg", False))
+        candidates.append((Path(_conda) / "Library" / "mozjpeg", False))
+    candidates.extend([
         (Path("/usr"), True),
         (Path("/usr/local"), True),
-    ]
+    ])
     prefix = None
     lib_subdir = None  # "lib" or "lib/x86_64-linux-gnu" etc.
     lib_filename = None
@@ -653,24 +671,41 @@ def _maybe_build_mozjpeg_ext() -> list[Extension]:
         if not (c / "include" / "turbojpeg.h").exists():
             continue
         # Find the actual lib file. Linux multiarch ships under
-        # lib/<triple>/, plain /usr/local installs use lib/.
+        # lib/<triple>/, plain /usr/local installs use lib/, and
+        # AlmaLinux/RHEL (manylinux_2_28) puts 64-bit libs under lib64/
+        # by default — that's the GNU autoconf convention on those
+        # distros, and mozjpeg's CMake picks it up.
         lib_candidates = [
             ("lib", "libturbojpeg.dylib"),
             ("lib", "libturbojpeg.so"),
             ("lib", "libturbojpeg.so.0"),
+            ("lib64", "libturbojpeg.so"),
+            ("lib64", "libturbojpeg.so.0"),
             ("lib/x86_64-linux-gnu", "libturbojpeg.so"),
             ("lib/x86_64-linux-gnu", "libturbojpeg.so.0"),
             ("lib/aarch64-linux-gnu", "libturbojpeg.so"),
             ("lib/aarch64-linux-gnu", "libturbojpeg.so.0"),
+            # Windows MSVC build (mozjpeg's CMake produces turbojpeg.lib
+            # import library next to turbojpeg.dll in bin/).
+            ("lib", "turbojpeg.lib"),
         ]
         for subdir, name in lib_candidates:
             libpath = c / subdir / name
             if not libpath.exists():
                 continue
             # MozJPEG branches off libjpeg-turbo 1.x — it lacks the v3
-            # tj3* API. If we're already constrained to a mozjpeg subdir,
-            # accept any libturbojpeg under it. Otherwise probe symbols.
-            if require_mozjpeg_subdir:
+            # tj3* API. Three cases for accepting a candidate:
+            #   (a) require_mozjpeg_subdir=True (generic /usr or /usr/local
+            #       with a mozjpeg/ include subdir) — trust the layout.
+            #   (b) prefix path is named '.../mozjpeg' or '.../mozjpeg/'
+            #       (homebrew keg, our per-user cache build, conda env
+            #       subdir) — the dedicated dir name is the signal; skip
+            #       symbol probing. This is required on Windows where nm
+            #       isn't on PATH and on minimal Linux runners that don't
+            #       ship binutils.
+            #   (c) otherwise: probe libturbojpeg's symbol table with nm
+            #       to confirm it's a MozJPEG build (lacks tj3Compress8).
+            if require_mozjpeg_subdir or c.name == "mozjpeg":
                 prefix = c
                 lib_subdir = subdir
                 lib_filename = name
@@ -702,9 +737,18 @@ def _maybe_build_mozjpeg_ext() -> list[Extension]:
         ],
         library_dirs=[str(prefix / lib_subdir)],
         # Use absolute path on macOS to dodge the SDK-stub issue we
-        # hit with zlib-ng-compat.
+        # hit with zlib-ng-compat. On macOS we ALSO add the lib dir
+        # to LC_RPATH because mozjpeg's libturbojpeg has
+        # install_name=@rpath/libturbojpeg.0.dylib; without an rpath
+        # to a keg-only prefix like /opt/homebrew/opt/mozjpeg/lib,
+        # delocate can't resolve the LC_LOAD_DYLIB and the wheel
+        # repair fails with "@rpath/libturbojpeg.0.dylib not found".
         libraries=[],
-        extra_link_args=[str(prefix / lib_subdir / lib_filename)],
+        extra_link_args=(
+            [str(prefix / lib_subdir / lib_filename)]
+            + ([f"-Wl,-rpath,{prefix / lib_subdir}"]
+                if sys.platform == "darwin" else [])
+        ),
         define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
         language="c",
     )]
@@ -1081,6 +1125,36 @@ extensions = [
         extra_link_args=extra_link_args,
         language="c",
     ),
+    # libultrahdr (Ultra-HDR / ISO 21496-1). Links against system libuhdr.
+    # macOS: `brew install libultrahdr` -> /opt/homebrew/{include,lib}.
+    # Linux: build from https://github.com/google/libultrahdr.
+    # If the header/dylib aren't present, the Extension still appears in
+    # the wheel build plan -- the public opencodecs.uhdr module catches
+    # ImportError and substitutes a clear "install libultrahdr" stub.
+    Extension(
+        name="opencodecs.codecs._uhdr",
+        sources=["src/opencodecs/codecs/_uhdr.pyx"],
+        include_dirs=[
+            str(PKG_CODECS),
+            numpy.get_include(),
+            *_resolve_include_dirs("ultrahdr_api.h"),
+        ],
+        library_dirs=[],
+        libraries=["uhdr"],
+        define_macros=[
+            ("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION"),
+        ],
+        # Aggressive optimisation is critical for the gain-map kernel
+        # to auto-vectorise (NEON on Apple Silicon, AVX2 on x86). The
+        # polynomial log2 in _gain_map_kernel only beats numpy's
+        # vectorised log2 when the compiler turns it into SIMD.
+        extra_compile_args=[
+            "-O3",
+            "-ffast-math",  # fine for gain-map output (uint8, ~1% tolerance)
+            "-fno-math-errno",
+        ],
+        language="c",
+    ),
     # QOI: vendored single-header (3rdparty/qoi/qoi.h). Compile the impl
     # via QOI_IMPLEMENTATION; no external library needed.
     Extension(
@@ -1771,6 +1845,23 @@ extensions = [
         define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
         language="c",
     ),
+    # PLIO_1 decode for IRAF segmentation-mask tiles (ZCMPTYPE=
+    # 'PLIO_1'). Vendored cfitsio pliocomp.c (Doug Tody / NRAO,
+    # public-domain — see 3rdparty/cfitsio/License.txt).
+    Extension(
+        name="opencodecs.codecs._plio",
+        sources=[
+            "src/opencodecs/codecs/_plio.pyx",
+            "3rdparty/cfitsio/pliocomp.c",
+        ],
+        include_dirs=[
+            str(PKG_CODECS),
+            numpy.get_include(),
+            str(HERE / "3rdparty" / "cfitsio"),
+        ],
+        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
+        language="c",
+    ),
     # Radiance HDR (RGBE) — Bruce Walter / Greg Ward C library, vendored
     # as a single .c/.h pair. Public-domain origin (Greg Ward, LBL); the
     # vendored port carries the "USE AT YOUR OWN RISK" disclaimer in
@@ -1837,7 +1928,7 @@ _REQUIRED_HEADERS = {
     "opencodecs.codecs._snappy": ("snappy-c.h",),
     "opencodecs.codecs._pcodec": ("cpcodec.h",),
     "opencodecs.codecs._jpeg":   ("turbojpeg.h",),
-    "opencodecs.codecs._ultrahdr": ("ultrahdr_api.h",),
+    "opencodecs.codecs._uhdr":   ("ultrahdr_api.h",),
     "opencodecs.codecs._isal":   ("isa-l/igzip_lib.h",),
     "opencodecs.codecs._webp":   ("webp/encode.h",),
     "opencodecs.codecs._jpeg2k": ("openjpeg-2.5/openjpeg.h", "openjpeg-2.4/openjpeg.h"),