opencodecs 0.6.0__tar.gz → 0.7.1__tar.gz

{opencodecs-0.6.0 → opencodecs-0.7.1}/CHANGES.rst

@@ -10,6 +10,127 @@ 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.7.1 (unreleased)
+------------------
+
+Every encoder is now tested against a decoder that is not ours.
+``tests/test_foreign_readers.py`` encodes with each of the 46 codecs that can
+encode and decodes with the format's own library where it has a Python
+binding (zstandard, lz4, brotli, python-blosc2, cramjam, lerc, zfpy, pcodec,
+qoi, pillow-heif, the standard library), imagecodecs, and format readers
+(tifffile, mrcfile, nibabel, pydicom, numcodecs, numpy); it also opens the
+files every writer produces (TIFF with each compression, pyramids, NDTiff,
+OME-Zarr, MRC, NIfTI, RGBE, JPEG XL animation, CZI pyramids). A codec that
+gains an encoder without a case fails the suite. CI installs these readers.
+It found:
+
+- Fix: the JPEG XL encoder refused ``level``, so ``TiffWriter`` and the NDTiff
+  writer raised for JPEG XL with ``compression_level``, which their
+  documentation promised to pass through. ``level`` now means what it means
+  in ``imagecodecs.jpegxl_encode``: 100 or below is lossy at that quality,
+  above 100 lossless. Passing both ``level`` and ``quality`` raises.
+- Fix: OME-Zarr stores written with ``compressor="blosc2"`` opened only in
+  opencodecs. No zarr specification defines Blosc2; the one numcodecs plugin
+  for it, ocf-blosc2 (Open Climate Fix), registers the id ``blosc2`` with
+  the parameters ``cname`` and ``clevel``, where the writer recorded
+  ``level``, which that plugin refuses. v2 stores now record ``cname`` and
+  ``clevel``, and v3 stores name the codec ``numcodecs.blosc2``, as zarr
+  names a numcodecs codec. With ocf-blosc2 installed, zarr opens both and
+  reads the pixels exactly. The chunks themselves are unchanged, and stores
+  written the old way still read here.
+- Fix: on Windows, which has no ``os.preadv``, the CZI reader maps the file,
+  and ``close()`` left the closed mapping in place: the next call raised the
+  mapping's ``ValueError: mmap closed or invalid`` instead of the reader's
+  own closed-reader ``CziError``. Two tests encoded the positional-read path
+  as universal (the payload index is kept on every path; a stored stack is
+  one copy out of the mapping on one worker there) and now assert each
+  path's own behavior.
+
+- Fix: a CZI this library wrote with default metadata could not be opened by
+  libCZI, so not by czicompress and not by ZEN. ``CziWriter``'s default
+  metadata was a bare ``<Metadata/>``, and libCZI requires the document to be
+  rooted at ``ImageDocument``; it refuses anything else outright with
+  ``Root-node "ImageDocument" not found``. Every round-trip test in this
+  suite passed because every one of them read the file back with our own
+  reader, which accepts it. Metadata lacking the root is now wrapped in one,
+  so a caller writing a new file cannot produce an unopenable one.
+  ``czi_recompress`` passes ``metadata_as_is=True``: it promises the source's
+  metadata is carried across unchanged, and rewriting it there would break
+  that promise, while silently "fixing" a source libCZI could not open either
+  is a surprise rather than a service. Its output is then exactly as openable
+  as its input.
+- ``tests/test_czi_foreign_readers.py`` never uses opencodecs to read. It
+  writes with opencodecs and opens with pylibCZIrw (libCZI itself, so what
+  ZEN and czicompress see), czifile (an independent implementation) and
+  aicspylibczi, skipping any reader that is absent rather than passing
+  silently. It covers all three compressions, a foreign decoder reading
+  pixels back exactly, both metadata regressions, a recompressed real file,
+  and 481 JPEG XR sub-blocks carried across. Its header records what to
+  assume when one fails: the writer is wrong, not the reader, because all
+  three open ZEN files and we are the new participant in a format we did not
+  define.
+- ``tests/_czi_fixture.py`` takes the same default. That serializer is an
+  independent reimplementation of the layout, and
+  ``test_file_bytes_match_the_fixture_serializer`` compares the writer's bytes
+  against it, so the two have to agree on the default; it is written as a
+  literal on both sides rather than imported, because importing would make
+  them agree by construction and hollow the test out. Fixture files are also
+  the sources for the ``czi_recompress`` tests, so that corpus now produces
+  files libCZI accepts.
+- Documented why the ZSTDHDR zstd level is 3 and not a parameter. Measured end
+  to end on a 503 MB uncompressed CZI, against ZEISS czicompress at 0.87 s and
+  319.9 MB on the same file: level 3 gives 0.24 s and 318.3 MB, level 6 gives
+  0.92 s and 315.3 MB, level 9 gives 1.38 s and 314.4 MB. The encode cost
+  transfers almost 1:1 into wall clock because this path is encode-bound
+  rather than I/O-bound, so 32 workers hide none of it, and level 6 is already
+  slower than the tool it replaces. About 1% of size for 4 to 6x the time is
+  not a trade worth a default. The hi-lo byte-plane shuffle is where the gain
+  actually is, and it is already on: on real microscopy pixels it takes the
+  ratio from 0.537 to 0.485 while being faster than raw zstd, 923 against
+  199 MB/s.
+
+0.7.0 (2026-10-03)
+------------------
+
+``czi_recompress`` takes ``recompress_when``, a predicate over the reader's
+``CziSubBlockEntry``. Sub-blocks it accepts are decoded and re-encoded as
+before; sub-blocks it rejects are carried across BYTE FOR BYTE, keeping their
+original compression. The default stays ``None``, which re-encodes everything,
+so existing callers are unaffected. The returned summary gains
+``recompressed`` and ``carried`` counts.
+
+This exists because a sub-block's compression is not a detail to be
+normalized away. Re-encoding one that is already compressed is wasted work,
+and re-encoding a LOSSY one is destructive: the pixels are decoded from a
+lossy encoding and written back losslessly, so the file grows and the
+artifacts become permanent. Measured on a 505 MB Axioscan slide scan of 481
+JPEG XR sub-blocks:
+
+====================================  ========  ==========  ============
+strategy                              time      output      vs source
+====================================  ========  ==========  ============
+carry JPEG XR across (predicate)      0.36 s    489 MB      0.97x
+re-encode everything (no predicate)   12.6 s    1309 MB     2.59x
+====================================  ========  ==========  ============
+
+So the predicate is not a speed knob. Without it that file more than doubles
+in size, takes 33x longer, and loses the option of ever recovering the
+original encoding. This is what ZEISS's ``czicompress`` expresses with
+``--strategy``, and the three strategies map directly::
+
+    uncompressed        lambda e: e.compression == 0
+    uncompressed+zstd   lambda e: e.compression in (0, 5, 6)
+    all                 None
+
+Supporting this needed a writer that can emit a sub-block it cannot itself
+produce. ``_build_subblock`` gained ``encoded=``, which writes the payload
+exactly as given and records the compression code as-is, with no encode step
+and no look at the pixels. That is the only path by which a JPEG XR sub-block
+can reach a file this writer wrote, and it is why carrying one across cannot
+alter it. Verification is refused on that path: nothing was encoded, so there
+is nothing to check. ``verify=True`` therefore applies only to the sub-blocks
+that were re-encoded.
+
 0.6.0 (2026-10-03)
 ------------------
 

{opencodecs-0.6.0/src/opencodecs.egg-info → opencodecs-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencodecs
-Version: 0.6.0
+Version: 0.7.1
 Summary: Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)
 Author: Kevin Cutler
 License-Expression: BSD-3-Clause
@@ -39,6 +39,18 @@ Requires-Dist: nd2; extra == "reference"
 Requires-Dist: readlif; extra == "reference"
 Requires-Dist: oiffile; extra == "reference"
 Requires-Dist: blosc2; extra == "reference"
+Requires-Dist: zstandard; extra == "reference"
+Requires-Dist: lz4; extra == "reference"
+Requires-Dist: brotli; extra == "reference"
+Requires-Dist: cramjam; extra == "reference"
+Requires-Dist: lerc; extra == "reference"
+Requires-Dist: zfpy; extra == "reference"
+Requires-Dist: pcodec; extra == "reference"
+Requires-Dist: ocf-blosc2; extra == "reference"
+Requires-Dist: qoi; extra == "reference"
+Requires-Dist: pillow-heif; extra == "reference"
+Requires-Dist: pylibCZIrw; extra == "reference"
+Requires-Dist: aicspylibczi; extra == "reference"
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{opencodecs-0.6.0 → opencodecs-0.7.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencodecs"
-version = "0.6.0"
+version = "0.7.1"
 description = "Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -54,7 +54,21 @@ reference = [
     "nd2",            # ND2
     "readlif",        # LIF
     "oiffile",        # OIB
-    "blosc2",         # MRCZ
+    "blosc2",         # MRCZ, and Blosc2 / B2ND streams
+    # The libraries' own bindings, which test_foreign_readers.py decodes
+    # our streams with alongside imagecodecs.
+    "zstandard",      # zstd
+    "lz4",            # LZ4 frame
+    "brotli",         # Brotli
+    "cramjam",        # Snappy raw and framed
+    "lerc",           # LERC
+    "zfpy",           # ZFP
+    "pcodec",         # pcodec
+    "ocf-blosc2",     # Blosc2 in zarr (no zarr spec defines it)
+    "qoi",            # QOI
+    "pillow-heif",    # HEIF, libheif's decoder
+    "pylibCZIrw",     # CZI through libCZI
+    "aicspylibczi",   # CZI, the Allen Institute's libCZI binding
 ]
 test = [
     "pytest>=8",

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/__init__.py

@@ -349,4 +349,4 @@ __all__ = [
     "czi_recompress", "subblock_dims",
 ]
 
-__version__ = "0.6.0"
+__version__ = "0.7.1"

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/_czi_reader.py

@@ -813,6 +813,10 @@ class CziReader(Reader):
         finally:
             os.close(self._fd)
             self._owns_fd = False
+            # As on the positional-read path: a closed reader has no
+            # buffer, so the next call raises the reader's own "closed"
+            # error, not the mapping's "mmap closed or invalid".
+            self._mmap = None
 
     @classmethod
     def from_http(

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/_czi_writer.py

@@ -70,10 +70,67 @@ _CMP_NAME_TO_CODE = {
 }
 
 
+#: libCZI refuses metadata that is not rooted at ``ImageDocument``, with
+#: ``Root-node "ImageDocument" not found``. That means czicompress and ZEN
+#: cannot open the file at all -- not a degraded read, no read. The writer's
+#: old default was a bare ``<Metadata/>``, which opencodecs' own reader
+#: accepts, so every round-trip test passed while the files were unreadable
+#: by every other CZI tool. Found 2026-10-04 when czicompress rejected a file
+#: this writer had just produced.
+#:
+#: So metadata lacking the root is WRAPPED in one, and a caller writing a NEW
+#: file cannot produce an unopenable one by accident or on purpose.
+#:
+#: ``metadata_as_is=True`` opts out, and exactly one caller needs it:
+#: ``czi_recompress``, which promises the source's metadata is carried across
+#: UNCHANGED. Rewriting it there would break that promise, and silently
+#: "fixing" a source that libCZI could not open either is a surprise, not a
+#: service -- the output is then exactly as openable as the input, which is
+#: what faithful means.
+_DEFAULT_METADATA = b"<ImageDocument><Metadata/></ImageDocument>"
+
+
+def _ensure_image_document(xml: bytes) -> bytes:
+    """Return ``xml`` rooted at ImageDocument, wrapping it if it is not."""
+    head = xml.lstrip()
+    decl = b""
+    if head.startswith(b"<?xml"):
+        end = head.find(b"?>")
+        if end != -1:
+            decl, head = head[:end + 2], head[end + 2:].lstrip()
+    if head.startswith(b"<ImageDocument>") or head.startswith(b"<ImageDocument "):
+        return xml
+    return decl + b"<ImageDocument>" + head + b"</ImageDocument>"
+
+
 class CziWriterError(RuntimeError):
     """Raised on writer state-machine violations."""
 
 
+class _CarriedSubBlock:
+    """A sub-block copied across unchanged, not re-encoded.
+
+    Carries the encoded payload and the compression code it was written
+    with, plus a zero-filled array of the right shape and dtype so the
+    existing header path can read shape/dtype without the pixels ever being
+    decoded. ``np.empty`` would do, but zeros make an accidental use of
+    these pixels obvious rather than random.
+    """
+
+    __slots__ = ("payload", "compression", "dims", "pyramid_type",
+                 "shape_array", "logical_shape", "pixel_type")
+
+    def __init__(self, payload, *, compression, dims, pyramid_type,
+                 shape_array, logical_shape, pixel_type):
+        self.payload = payload
+        self.compression = compression
+        self.pixel_type = pixel_type
+        self.dims = dims
+        self.pyramid_type = pyramid_type
+        self.shape_array = shape_array
+        self.logical_shape = logical_shape
+
+
 class CziCancelled(CziWriterError):
     """Raised when a caller's ``should_continue`` stops a rewrite.
 
@@ -239,6 +296,27 @@ def _zstdhdr_encode(pixel_bytes, itemsize: int, hilo: bool, *, scratch=None):
     before this returns, and verification later reads the encoded payload
     and the caller's own pixel snapshot rather than this buffer, so the
     next frame may reuse it.
+
+    WHY LEVEL 3, AND WHY IT IS NOT A PARAMETER
+    Measured end to end through this pipeline on a 503 MB uncompressed CZI
+    (2026-10-04), against ZEISS czicompress at 0.87 s / 319.9 MB on the same
+    file:
+
+        level 3   0.24 s   318.3 MB     beats czicompress on size AND speed
+        level 6   0.92 s   315.3 MB     0.93% smaller, 3.91x slower
+        level 9   1.38 s   314.4 MB     1.23% smaller, 5.83x slower
+
+    The encode cost transfers almost 1:1 into wall clock, because this path is
+    encode-bound rather than I/O-bound: there is no I/O to hide it behind, even
+    with 32 workers. So a higher level buys about 1% of size for 4-6x the time,
+    and level 6 is already slower than the tool we replaced. Level 3 is the
+    only setting that wins on both axes.
+
+    The hi-lo shuffle, by contrast, is free and large: on real microscopy
+    pixels it took the ratio from 0.537 to 0.485 (9.7% smaller) while being
+    FASTER than raw zstd, 923 MB/s against 199 MB/s, because shuffled byte
+    planes are far more compressible. That is where the gain is, and it is
+    already on by default.
     """
     from .codecs._zstd import encode as zstd_encode
     if hilo and itemsize > 1:
@@ -339,6 +417,7 @@ def _build_subblock(
     dims: tuple | None = None,
     verification_input: list | None = None,
     scratch=None,
+    encoded: object | None = None,
 ) -> tuple[_SubBlockSegment, dict]:
     """Build one ZISRAWSUBBLOCK segment as parts.
 
@@ -351,7 +430,21 @@ def _build_subblock(
     check runs after this returns while the producer may already be
     refilling ``array``. Without it nothing here outlives the call, so the
     array's own buffer feeds the compressor or becomes the raw payload.
+
+    With ``encoded`` the payload is written exactly as given and
+    ``compression_code`` is recorded as-is, with no encode step and no look
+    at the pixels. That is how a sub-block is carried across unchanged, and
+    it is the only path that can emit a compression this writer cannot
+    produce (JPEG XR, for instance). ``array`` is then used only for its
+    shape and dtype, so a zero-filled array of the right shape is enough.
+    Verification is not available on this path: there is nothing to check,
+    because nothing was encoded.
     """
+    if encoded is not None and verification_input is not None:
+        raise CziWriterError(
+            "czi: verification_input cannot be combined with encoded; a "
+            "carried-across sub-block is not re-encoded, so there is "
+            "nothing to verify")
     h, w = array.shape[:2]
     logical_h, logical_w = logical_shape
     start_y, start_x = location
@@ -390,7 +483,10 @@ def _build_subblock(
         pixels = memoryview(contiguous).cast("B")
         keep = contiguous
     itemsize = array.dtype.itemsize
-    if compression_code == 0:
+    if encoded is not None:
+        data = encoded
+        keep = encoded
+    elif compression_code == 0:
         data = pixels
     elif compression_code == 5:
         from .codecs._zstd import encode as zstd_encode
@@ -477,15 +573,22 @@ class _CziStreamWriter(Writer):
     """Shared sub-block sink with optional bounded pixel verification."""
 
     def __init__(self, path: str | Path, *, compression: str = "none",
-                 hilo: bool = True, metadata_xml: bytes | str = b"<Metadata/>",
-                 verify: bool = False, background_encode: bool = False):
+                 hilo: bool = True, metadata_xml: bytes | str | None = None,
+                 verify: bool = False, background_encode: bool = False,
+                 metadata_as_is: bool = False):
         if compression not in _CMP_NAME_TO_CODE:
             raise CziWriterError(f"unknown compression {compression!r}")
         self._path = Path(path)
         self._cmp_code = _CMP_NAME_TO_CODE[compression]
         self._hilo = bool(hilo)
-        xml = metadata_xml.encode("utf-8") if isinstance(metadata_xml, str) else metadata_xml
-        self._metadata_segment = _build_metadata_segment(xml)
+        if metadata_xml is None:
+            xml = _DEFAULT_METADATA
+        elif isinstance(metadata_xml, str):
+            xml = metadata_xml.encode("utf-8")
+        else:
+            xml = metadata_xml
+        self._metadata_segment = _build_metadata_segment(
+            xml if metadata_as_is else _ensure_image_document(xml))
         self._header_size = (32 + 88 + 31) // 32 * 32
         self._position = self._header_size + len(self._metadata_segment)
         self._entries: list[dict] = []
@@ -687,6 +790,17 @@ class _CziStreamWriter(Writer):
             workers = resolve_workers(None, 1 << 30, output_bytes=None, max_workers=8)
         workers = max(1, int(workers))
 
+        def item_bytes(item):
+            """Cost of one snapshotted item, for batching and reservation.
+
+            A carried sub-block has no array: its cost is the encoded payload
+            it already owns. Both batching sites go through here so they
+            cannot disagree about what an item weighs.
+            """
+            if isinstance(item, _CarriedSubBlock):
+                return len(item.payload)
+            return item[0].nbytes
+
         def snapshot(frame):
             """Own the frame's pixels before the producer can touch them.
 
@@ -695,6 +809,10 @@ class _CziStreamWriter(Writer):
             it is a down-scaled level. Those forms are what make a faithful
             re-encode possible on this path as well as on ``write_frame``.
             """
+            if isinstance(frame, _CarriedSubBlock):
+                # Nothing to snapshot: the payload is already bytes we own,
+                # and the pixels are never looked at.
+                return frame
             dims = override_pyramid = None
             if isinstance(frame, tuple):
                 if len(frame) == 2:
@@ -728,7 +846,7 @@ class _CziStreamWriter(Writer):
             batch, batch_bytes = [], 0
             for frame in frames:
                 item = snapshot(frame)
-                n = item[0].nbytes
+                n = item_bytes(item)
                 if batch and batch_bytes + n > batch_limit:
                     yield batch
                     batch, batch_bytes = [], 0
@@ -738,7 +856,7 @@ class _CziStreamWriter(Writer):
                 yield batch
 
         def size(batch):
-            n = sum(item[0].nbytes for item in batch)
+            n = sum(item_bytes(item) for item in batch)
             # Snapshot + encoded output (bounded by the input for these
             # codecs) + decoded verification result and comparison scratch.
             return 2 * n + (verification_reservation(n) if verify else 0)
@@ -746,7 +864,19 @@ class _CziStreamWriter(Writer):
         def encode(batch):
             out = []
             scratch = _worker_scratch()
-            for pixels, logical_shape, pyramid_type, dims in batch:
+            for item in batch:
+                if isinstance(item, _CarriedSubBlock):
+                    segment, entry = _build_subblock(
+                        item.shape_array,
+                        pixel_type=item.pixel_type,
+                        compression_code=item.compression, hilo=self._hilo,
+                        file_position=0, logical_shape=item.logical_shape,
+                        pyramid_type=item.pyramid_type, dims=item.dims,
+                        verification_input=None, scratch=None,
+                        encoded=item.payload)
+                    out.append((segment, entry))
+                    continue
+                pixels, logical_shape, pyramid_type, dims = item
                 captured = [] if verify else None
                 segment, entry = _build_subblock(
                     pixels, pixel_type=_DTYPE_TO_PIXELTYPE[pixels.dtype],
@@ -992,7 +1122,8 @@ __all__ = ["CziWriter", "CziPyramidWriter", "CziWriterError"]
 def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
                workers=None, verify: bool = False,
                background_encode: bool = False,
-               should_continue=None) -> dict:
+               should_continue=None,
+               recompress_when=None) -> dict:
     """Rewrite a CZI with different compression, keeping the container.
 
     Every sub-block keeps its dimension coordinates, its scene and mosaic
@@ -1016,8 +1147,30 @@ def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
     know which. Encodes already dispatched still finish, so cancellation
     takes effect within roughly ``workers`` sub-blocks rather than instantly.
 
-    Returns a summary dict: sub-block count, input and output sizes, and the
-    compression that was applied.
+    ``recompress_when`` is an optional predicate over the reader's
+    ``CziSubBlockEntry``. Sub-blocks it accepts are decoded and re-encoded;
+    sub-blocks it rejects are carried across BYTE FOR BYTE, keeping their
+    original compression. Default ``None`` re-encodes everything, which is
+    what earlier versions did.
+
+    This is what makes the selective strategies of ZEISS's ``czicompress``
+    expressible, and the reason they exist: re-encoding an already-compressed
+    sub-block is at best wasted work, and for a lossy one it is destructive.
+    A JPEG XR sub-block decoded and re-encoded as lossless zstdhdr grows,
+    and bakes the lossy artifacts in permanently. Carrying it across cannot
+    do that.
+
+        uncompressed only   lambda e: e.compression == 0
+        uncompressed+zstd   lambda e: e.compression in (0, 5, 6)
+        everything          None
+
+    ``verify=True`` applies only to the sub-blocks that were re-encoded; a
+    carried-across payload is unchanged by definition, so there is nothing
+    to check.
+
+    Returns a summary dict: sub-block count, input and output sizes, the
+    compression that was applied, and how many sub-blocks were re-encoded
+    versus carried across.
     """
     import os
 
@@ -1027,7 +1180,9 @@ def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
         n = len(reader.entries)
         if not n:
             raise CziWriterError(f"czi: {src} has no sub-blocks to recompress")
-        metadata = reader.metadata_bytes or b"<Metadata/>"
+        metadata = reader.metadata_bytes or _DEFAULT_METADATA
+
+        counts = {"recompressed": 0, "carried": 0}
 
         def frames():
             # One sub-block at a time: a slide scan does not fit in memory,
@@ -1038,12 +1193,36 @@ def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
                         f"czi: recompress of {src} cancelled after "
                         f"{i} of {n} sub-blocks")
                 entry = reader.entries[i]
-                yield reader[i], subblock_dims(entry), entry.pyramid_type
+                if recompress_when is None or recompress_when(entry):
+                    counts["recompressed"] += 1
+                    yield reader[i], subblock_dims(entry), entry.pyramid_type
+                else:
+                    # Carried across: the encoded bytes are copied straight
+                    # from the source and the original compression is kept,
+                    # so the pixels are never decoded and cannot change.
+                    counts["carried"] += 1
+                    d = subblock_dims(entry)
+                    axes = {name.rstrip(b"\x00"): (size, stored)
+                            for name, _start, size, _co, stored in d}
+                    log_h, st_h = axes[b"Y"]
+                    log_w, st_w = axes[b"X"]
+                    with reader._payload(entry) as view:
+                        # Copy: the reader hands back a buffer it reuses, so
+                        # a borrowed view would be overwritten by the next
+                        # sub-block before the writer emits this one.
+                        payload = bytes(view)
+                    yield _CarriedSubBlock(
+                        payload, compression=entry.compression,
+                        dims=d, pyramid_type=entry.pyramid_type,
+                        shape_array=np.zeros((st_h, st_w), entry.dtype),
+                        logical_shape=(log_h, log_w),
+                        pixel_type=entry.pixel_type)
 
         try:
             with CziWriter(str(dst), compression=compression, hilo=hilo,
                            metadata_xml=metadata, verify=verify,
-                           background_encode=background_encode) as writer:
+                           background_encode=background_encode,
+                           metadata_as_is=True) as writer:
                 writer.write_many(frames(), workers=workers, copy_frames=False)
         except BaseException:
             # An interrupted rewrite must not leave a file behind. A CZI
@@ -1061,4 +1240,6 @@ def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
         "src_bytes": os.path.getsize(src),
         "dst_bytes": os.path.getsize(dst),
         "compression": compression,
+        "recompressed": counts["recompressed"],
+        "carried": counts["carried"],
     }

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/_jxl_codec.py

@@ -139,6 +139,22 @@ class JpegXLReader(Reader):
         self._inner.close()
 
 
+def jxl_level_as_quality(opts: dict) -> dict:
+    """imagecodecs.jpegxl_encode's ``level`` is a quality: 100 or below is
+    lossy at that quality, above 100 lossless. The encoder's ``quality``
+    has exactly that meaning, so ``level`` is passed as ``quality``.
+    Writers that take one compression level for every codec (TIFF,
+    NDTiff) reach JPEG XL through this too."""
+    if opts.get("level") is None:
+        opts.pop("level", None)
+        return opts
+    if opts.get("quality") is not None:
+        raise TypeError("jxl: pass level or quality, not both")
+    opts = dict(opts)
+    opts["quality"] = opts.pop("level")
+    return opts
+
+
 class JpegXLCodec(Codec):
     """Native JPEG XL codec (libjxl 0.11).
 
@@ -176,7 +192,7 @@ class JpegXLCodec(Codec):
         return _jxl_check_signature(head)
 
     def encode(self, arr: np.ndarray, *, dest=None, **opts) -> bytes | None:
-        return _jxl_encode(arr, dest=dest, **opts)
+        return _jxl_encode(arr, dest=dest, **jxl_level_as_quality(opts))
 
     def decode(self, src: Any, **opts) -> np.ndarray:
         """Decode a JXL codestream.

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/_omezarr.py

@@ -496,7 +496,10 @@ def _run_decoder(name: str, cfg: dict, data: bytes) -> bytes:
             _DECODER_CACHE["blosc2"] = fn
         if fn:
             return fn(data)
-    if name == "blosc2":
+    if name in ("blosc2", "numcodecs.blosc2"):
+        # "numcodecs.blosc2" is ocf-blosc2's v3 name, which our writer
+        # uses; plain "blosc2" is the v2 id, and what v3 stores this
+        # package wrote before 0.7.0 carry.
         fn = _DECODER_CACHE.get("blosc2")
         if not fn:
             from .codecs._blosc2 import decode as _b_decode

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/_omezarr_writer.py

@@ -53,7 +53,10 @@ _CODEC_NAME_MAP = {
     "none":   (None, None),
     "raw":    (None, None),
     "zstd":   ("zstd", "zstd"),
-    "blosc2": ("blosc2", "blosc2"),     # blosc2 wire format (v2 + v3)
+    # No zarr specification defines Blosc2. These are the names ocf-blosc2,
+    # the one numcodecs plugin for it, registers: "blosc2" for v2, and
+    # "numcodecs.blosc2" for v3, which is how zarr names a numcodecs codec.
+    "blosc2": ("blosc2", "numcodecs.blosc2"),
     "gzip":   ("gzip", "gzip"),
     "blosc":  ("blosc", None),          # v2-only (no v3 spec)
 }
@@ -68,6 +71,16 @@ class OmeZarrWriterError(RuntimeError):
 # ---------------------------------------------------------------------------
 
 
+def _blosc2_config(level: int | None, v3: bool = False) -> dict:
+    """The parameters ocf-blosc2's Blosc2(cname, clevel) takes, so zarr with
+    that plugin installed opens the store. cname names the inner codec;
+    _encode_chunk compresses with zstd, blosc2's default, and ocf-blosc2
+    reads "zstd" as that. (Before 0.7.0 the writer recorded "level", which
+    no reader but opencodecs accepted; those stores still read here.)"""
+    config = {"cname": "zstd", "clevel": level if level is not None else 5}
+    return config if v3 else {"id": "blosc2", **config}
+
+
 def _encode_chunk(raw: bytes, codec: str, level: int | None) -> bytes:
     """Compress one chunk's bytes."""
     if codec in (None, "none", "raw"):
@@ -309,8 +322,7 @@ def _write_v2(
         metadata["compressor"] = {"id": "zstd",
                                   "level": level if level is not None else 3}
     elif compressor == "blosc2":
-        metadata["compressor"] = {"id": "blosc2",
-                                  "level": level if level is not None else 5}
+        metadata["compressor"] = _blosc2_config(level)
     elif compressor == "gzip":
         metadata["compressor"] = {"id": "gzip",
                                   "level": level if level is not None else 6}
@@ -375,8 +387,8 @@ def _write_v3(
         })
     elif compressor == "blosc2":
         codecs.append({
-            "name": "blosc2",
-            "configuration": {"clevel": level if level is not None else 5},
+            "name": "numcodecs.blosc2",
+            "configuration": _blosc2_config(level, v3=True),
         })
     elif compressor == "gzip":
         codecs.append({
@@ -460,8 +472,8 @@ def _v3_codecs_for_shard_inner(
         })
     elif compressor == "blosc2":
         codecs.append({
-            "name": "blosc2",
-            "configuration": {"clevel": level if level is not None else 5},
+            "name": "numcodecs.blosc2",
+            "configuration": _blosc2_config(level, v3=True),
         })
     elif compressor == "gzip":
         codecs.append({

{opencodecs-0.6.0 → opencodecs-0.7.1}/src/opencodecs/core/segment_compression.py

@@ -254,6 +254,9 @@ def encode_segment(data, codec: str | int, *, level: int | None = None,
         kw["level"] = level
     if code == JPEG2000:
         kw.setdefault("planar", False)
+    if code == JXL:
+        from .._jxl_codec import jxl_level_as_quality
+        kw = jxl_level_as_quality(kw)
     if code in (ZSTD, JPEG2000, JXL):
         from .pipeline import native_workers, in_worker
         # Zstandard counts background workers: zero means inline serial.
@@ -292,6 +295,9 @@ def bind_segment_encoder(codec: str | int, *, level=None, owned_output=False,
         options.setdefault("level", level)
     if code == JPEG2000:
         options.setdefault("planar", False)
+    if code == JXL:
+        from .._jxl_codec import jxl_level_as_quality
+        options = jxl_level_as_quality(options)
     eager = partial(fn, **options)
     if code not in (ZSTD, JPEG2000, JXL):
         return eager