pyst2110 0.9.1__tar.gz

pyst2110-0.9.1/.gitignore

@@ -0,0 +1,15 @@
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+build/
+dist/
+*.egg-info/
+
+# Tooling caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# Agent worktrees
+.claude/worktrees/

pyst2110-0.9.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fuse Technical Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyst2110-0.9.1/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.5
+Name: pyst2110
+Version: 0.9.1
+Summary: SMPTE ST 2110 protocol: RTP and RFC 4175 headers, geometry, SDP
+Project-URL: Repository, https://github.com/Fuse-Technical-Group/pyst2110
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Video
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: numpy>=2
+Description-Content-Type: text/markdown
+
+# pyst2110
+
+SMPTE ST 2110 protocol for Python: RTP and RFC 4175 headers read and
+written, frame boundaries, sequence-loss accounting, pgroup geometry, and
+SDP.
+
+> [REQUIREMENTS.md](REQUIREMENTS.md) — the problem.
+> [SPEC.md](SPEC.md) — the design and its rationale.
+> [ROADMAP.md](ROADMAP.md) — what is not built yet.
+
+| Layer | Owns |
+| --- | --- |
+| A transport binding (a NIC binding, a socket, a capture file) | Moving bytes |
+| **pyst2110** | RTP + RFC 4175 headers, geometry, SDP, ST 2110-21 timing |
+| The consuming runtime | Pixels — packing, unpacking, colour |
+
+The layer between a transport and a raster: it says what packet headers
+mean and where their payloads belong, and never moves a pixel itself.
+numpy is the only runtime dependency — no vendor SDK, no transport
+binding, no NIC and no licence, so it runs anywhere CI does.
+
+## Install
+
+A git dependency pinned by tag. Publication to PyPI waits for a consumer
+depending on a released version (§road:pypi):
+
+```bash
+uv add "pyst2110 @ git+https://github.com/Fuse-Technical-Group/pyst2110@v0.2.0"
+```
+
+## Usage
+
+```python
+from pyst2110 import parse_sdp, parse_video_format
+
+offer = open("flow.sdp").read()
+flow = parse_sdp(offer)          # destination address, port, source filter
+video = parse_video_format(offer)  # width, height, rate, sampling, depth
+```
+
+Parsing is vectorized over whole chunks: every function takes a
+two-dimensional `uint8` array, one row per packet, and returns one array
+per field — the shape a header-data-split receiver already hands out.
+
+Header fields are reported as the wire declared them, this being a parse
+and not a filter. A packet is free to name a row outside the image, so
+`fits_raster` masks the descriptors that name a place inside the flow's
+raster and a consumer places only those:
+
+```python
+fits = fits_raster(video, payload.line, payload.offset_samples)
+starts = raster_offset(video, payload.line[fits], payload.offset_samples[fits])
+```
+
+Sending is the same shape in reverse. A frame's headers are built once
+for a format and payload size, then stamped per frame with the only two
+fields that move — the sequence numbers and the media timestamp:
+
+```python
+from pyst2110 import FrameHeaders, choose_payload_size, format_sdp, max_payload_size
+
+payload_size = choose_payload_size(video, max_payload_size(video))
+frame = FrameHeaders(video, payload_size, ssrc=0x1234ABCD)
+for index in range(frames):
+    headers = frame.stamp(index)   # (packets, 20) uint8, one row per packet
+    ...                            # send each header with frame.frame_offset_octets
+offer = format_sdp(flow, video, session_name="my sender")  # what was sent
+```
+
+The offer carries the media type parameters ST 2110-20 section 7.2 and
+ST 2110-21 section 8.1 require of a sender. `TP` describes the pacing,
+which is the transport's and not this library's, so `sender_type=` is
+the caller's to set — it defaults to `2110TPN`. A multicast `flow` names
+its sender or passes `any_source=True`; see §spec:sdp for why that is a
+choice rather than a default.
+
+An ST 2022-7 redundant pair is one offer and not two. `format_dup_sdp`
+writes RFC 7104's grouping — a session-level `a=group:DUP` over two
+`m=video` blocks, each with its own address and sender — and
+`parse_dup_sdp` reads both legs back, in the order the group names them:
+
+```python
+from pyst2110 import format_dup_sdp, parse_dup_sdp
+
+offer = format_dup_sdp(red, blue, video, session_name="my sender")
+first, second = parse_dup_sdp(offer)
+```
+
+A document whose `DUP` tags and media blocks disagree is refused rather
+than read as a single-leg offer, and `parse_sdp` refuses a grouped offer
+for the same reason: a sender that emitted one leg where two were meant
+sends unprotected essence and reports success.
+
+`session_name` defaults to the single space RFC 4566 section 5.3 prescribes
+for a session with no meaningful name — and at least one transmit SDK refuses
+it, so name the session where a sender will read the offer back. NVIDIA
+Rivermax reports `'x=<token>' format not found` and fails stream creation,
+accepting the same document once it is named.
+
+`frame_offset_octets` says which octets of the frame buffer each packet
+carries. Moving them is the consumer's, as on the receive side.
+
+`stamp` hands back the same array every time, restamped in place — that
+is what keeps the loop above from allocating a frame of headers per
+frame. So `headers` is only valid until the next `stamp`: a caller
+queueing two frames at once copies the first.
+
+## API
+
+Everything is re-exported from the top-level package, and the
+docstrings there are the authority; `help(pyst2110)` is the index.
+
+Both paths are built: SDP parsing and emit — the single-leg offer and the
+ST 2022-7 pair — the RFC 3550 header parse, format geometry, sequence and
+frame tracking, RFC 4175 payload descriptors, the transmit header block,
+the ST 2022-7 reconstruction of one flow from two legs, and the ST 2110-21
+timing model — read schedules, sender limits, and the two leaky buckets
+that judge a capture's emission instants. What is not built is listed in
+[ROADMAP.md](ROADMAP.md).
+
+## Development
+
+```bash
+uv sync
+bash tools/ci.sh
+```
+
+`tools/ci.sh` is the gate CI runs — ruff, mypy, pytest.
+
+## License
+
+MIT — see [LICENSE](LICENSE). The standards this implements are public and
+an implementation of them should be too.

pyst2110-0.9.1/README.md

@@ -0,0 +1,133 @@
+# pyst2110
+
+SMPTE ST 2110 protocol for Python: RTP and RFC 4175 headers read and
+written, frame boundaries, sequence-loss accounting, pgroup geometry, and
+SDP.
+
+> [REQUIREMENTS.md](REQUIREMENTS.md) — the problem.
+> [SPEC.md](SPEC.md) — the design and its rationale.
+> [ROADMAP.md](ROADMAP.md) — what is not built yet.
+
+| Layer | Owns |
+| --- | --- |
+| A transport binding (a NIC binding, a socket, a capture file) | Moving bytes |
+| **pyst2110** | RTP + RFC 4175 headers, geometry, SDP, ST 2110-21 timing |
+| The consuming runtime | Pixels — packing, unpacking, colour |
+
+The layer between a transport and a raster: it says what packet headers
+mean and where their payloads belong, and never moves a pixel itself.
+numpy is the only runtime dependency — no vendor SDK, no transport
+binding, no NIC and no licence, so it runs anywhere CI does.
+
+## Install
+
+A git dependency pinned by tag. Publication to PyPI waits for a consumer
+depending on a released version (§road:pypi):
+
+```bash
+uv add "pyst2110 @ git+https://github.com/Fuse-Technical-Group/pyst2110@v0.2.0"
+```
+
+## Usage
+
+```python
+from pyst2110 import parse_sdp, parse_video_format
+
+offer = open("flow.sdp").read()
+flow = parse_sdp(offer)          # destination address, port, source filter
+video = parse_video_format(offer)  # width, height, rate, sampling, depth
+```
+
+Parsing is vectorized over whole chunks: every function takes a
+two-dimensional `uint8` array, one row per packet, and returns one array
+per field — the shape a header-data-split receiver already hands out.
+
+Header fields are reported as the wire declared them, this being a parse
+and not a filter. A packet is free to name a row outside the image, so
+`fits_raster` masks the descriptors that name a place inside the flow's
+raster and a consumer places only those:
+
+```python
+fits = fits_raster(video, payload.line, payload.offset_samples)
+starts = raster_offset(video, payload.line[fits], payload.offset_samples[fits])
+```
+
+Sending is the same shape in reverse. A frame's headers are built once
+for a format and payload size, then stamped per frame with the only two
+fields that move — the sequence numbers and the media timestamp:
+
+```python
+from pyst2110 import FrameHeaders, choose_payload_size, format_sdp, max_payload_size
+
+payload_size = choose_payload_size(video, max_payload_size(video))
+frame = FrameHeaders(video, payload_size, ssrc=0x1234ABCD)
+for index in range(frames):
+    headers = frame.stamp(index)   # (packets, 20) uint8, one row per packet
+    ...                            # send each header with frame.frame_offset_octets
+offer = format_sdp(flow, video, session_name="my sender")  # what was sent
+```
+
+The offer carries the media type parameters ST 2110-20 section 7.2 and
+ST 2110-21 section 8.1 require of a sender. `TP` describes the pacing,
+which is the transport's and not this library's, so `sender_type=` is
+the caller's to set — it defaults to `2110TPN`. A multicast `flow` names
+its sender or passes `any_source=True`; see §spec:sdp for why that is a
+choice rather than a default.
+
+An ST 2022-7 redundant pair is one offer and not two. `format_dup_sdp`
+writes RFC 7104's grouping — a session-level `a=group:DUP` over two
+`m=video` blocks, each with its own address and sender — and
+`parse_dup_sdp` reads both legs back, in the order the group names them:
+
+```python
+from pyst2110 import format_dup_sdp, parse_dup_sdp
+
+offer = format_dup_sdp(red, blue, video, session_name="my sender")
+first, second = parse_dup_sdp(offer)
+```
+
+A document whose `DUP` tags and media blocks disagree is refused rather
+than read as a single-leg offer, and `parse_sdp` refuses a grouped offer
+for the same reason: a sender that emitted one leg where two were meant
+sends unprotected essence and reports success.
+
+`session_name` defaults to the single space RFC 4566 section 5.3 prescribes
+for a session with no meaningful name — and at least one transmit SDK refuses
+it, so name the session where a sender will read the offer back. NVIDIA
+Rivermax reports `'x=<token>' format not found` and fails stream creation,
+accepting the same document once it is named.
+
+`frame_offset_octets` says which octets of the frame buffer each packet
+carries. Moving them is the consumer's, as on the receive side.
+
+`stamp` hands back the same array every time, restamped in place — that
+is what keeps the loop above from allocating a frame of headers per
+frame. So `headers` is only valid until the next `stamp`: a caller
+queueing two frames at once copies the first.
+
+## API
+
+Everything is re-exported from the top-level package, and the
+docstrings there are the authority; `help(pyst2110)` is the index.
+
+Both paths are built: SDP parsing and emit — the single-leg offer and the
+ST 2022-7 pair — the RFC 3550 header parse, format geometry, sequence and
+frame tracking, RFC 4175 payload descriptors, the transmit header block,
+the ST 2022-7 reconstruction of one flow from two legs, and the ST 2110-21
+timing model — read schedules, sender limits, and the two leaky buckets
+that judge a capture's emission instants. What is not built is listed in
+[ROADMAP.md](ROADMAP.md).
+
+## Development
+
+```bash
+uv sync
+bash tools/ci.sh
+```
+
+`tools/ci.sh` is the gate CI runs — ruff, mypy, pytest.
+
+## License
+
+MIT — see [LICENSE](LICENSE). The standards this implements are public and
+an implementation of them should be too.

pyst2110-0.9.1/pyproject.toml

@@ -0,0 +1,94 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyst2110"
+# Derived from the git tag, never authored here. A static version is one a
+# release has to remember to rewrite, and this one's releases did not: every
+# tag from v0.4.0 to v0.7.1 shipped `0.0.0`, so `importlib.metadata.version`
+# told a consumer nothing about which parse it had loaded, and a consumer had
+# to probe for a capability instead. See [tool.hatch.version].
+dynamic = ["version"]
+description = "SMPTE ST 2110 protocol: RTP and RFC 4175 headers, geometry, SDP"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Video",
+    "Typing :: Typed",
+]
+# The only runtime dependency, and the interface itself: every parse takes
+# and returns numpy arrays (SPEC §spec:interface-shape). No transport
+# binding and no SDK appears here, by design (§spec:scope-boundary).
+dependencies = ["numpy>=2"]
+
+[project.urls]
+Repository = "https://github.com/Fuse-Technical-Group/pyst2110"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    # Pinned, not floored: a newer ruff than CI runs is precisely the
+    # disagreement a pin exists to prevent.
+    "ruff==0.15.9",
+    # py.typed promises downstream consumers type information; this checks it.
+    "mypy>=1.13",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyst2110"]
+
+# An allowlist, because hatchling's default sdist is every tracked file. That
+# would publish the two vendored Vale binaries under .cache/ — 40 MB each —
+# and the governance documents, none of which a PyPI consumer builds from.
+# The tests ride along so the sdist can check itself.
+[tool.hatch.build.targets.sdist]
+include = ["/src/pyst2110", "/tests", "/README.md", "/LICENSE"]
+
+[tool.pytest.ini_options]
+# No markers and no deselection: nothing here needs a NIC, a licence or an
+# SDK, so the default selection is the whole suite (SPEC §spec:testing).
+testpaths = ["tests"]
+# A fixture is a conforming offer unless its test says otherwise: a tolerated
+# gap in one is an error here, and a test that means it catches the warning
+# (SPEC §spec:sdp).
+filterwarnings = ["error::pyst2110.sdp.SdpConformanceWarning"]
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.ruff]
+target-version = "py312"
+line-length = 88
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "F",   # pyflakes
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "I",   # isort
+    "N",   # pep8-naming
+    "UP",  # pyupgrade
+    "A",   # flake8-builtins
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "PT",  # flake8-pytest-style
+    "RET", # flake8-return
+    "SIM", # flake8-simplify
+    "S",   # bandit
+    "RUF", # ruff-specific
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]  # assert is what pytest is made of
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+files = ["src/pyst2110"]

pyst2110-0.9.1/src/pyst2110/__init__.py

@@ -0,0 +1,113 @@
+"""SMPTE ST 2110 protocol: RTP and RFC 4175 headers, geometry, SDP.
+
+The layer between a transport and a raster. A NIC binding, a socket or a
+capture file supplies packets; this says what their headers mean and where
+their payloads belong; the consumer moves the pixels (SPEC
+§spec:scope-boundary).
+
+Nothing here needs a NIC, a licence or a vendor SDK.
+"""
+
+from pyst2110.framing import FrameTracker as FrameTracker
+from pyst2110.framing import SequenceTracker as SequenceTracker
+from pyst2110.framing import frame_boundaries as frame_boundaries
+from pyst2110.framing import frame_starts as frame_starts
+from pyst2110.geometry import byte_offset as byte_offset
+from pyst2110.geometry import choose_payload_size as choose_payload_size
+from pyst2110.geometry import fits_raster as fits_raster
+from pyst2110.geometry import line_bytes as line_bytes
+from pyst2110.geometry import packets_per_frame as packets_per_frame
+from pyst2110.geometry import packets_per_line as packets_per_line
+from pyst2110.geometry import pgroup as pgroup
+from pyst2110.geometry import raster_offset as raster_offset
+from pyst2110.geometry import rows_per_field as rows_per_field
+from pyst2110.geometry import sample_offset as sample_offset
+from pyst2110.payload import PayloadHeaders as PayloadHeaders
+from pyst2110.payload import parse_payload_headers as parse_payload_headers
+from pyst2110.redundancy import LegPair as LegPair
+from pyst2110.redundancy import reconstruct as reconstruct
+from pyst2110.rtp import FIXED_HEADER_SIZE as FIXED_HEADER_SIZE
+from pyst2110.rtp import RtpHeaders as RtpHeaders
+from pyst2110.rtp import parse_rtp as parse_rtp
+from pyst2110.sdp import RTP_CLOCK_RATE as RTP_CLOCK_RATE
+from pyst2110.sdp import SENDER_TYPE_NARROW as SENDER_TYPE_NARROW
+from pyst2110.sdp import SENDER_TYPE_NARROW_LINEAR as SENDER_TYPE_NARROW_LINEAR
+from pyst2110.sdp import SENDER_TYPE_WIDE as SENDER_TYPE_WIDE
+from pyst2110.sdp import SENDER_TYPES as SENDER_TYPES
+from pyst2110.sdp import STANDARD_UDP_SIZE_LIMIT as STANDARD_UDP_SIZE_LIMIT
+from pyst2110.sdp import SdpConformanceWarning as SdpConformanceWarning
+from pyst2110.sdp import SdpFlow as SdpFlow
+from pyst2110.sdp import SdpVideo as SdpVideo
+from pyst2110.sdp import format_dup_sdp as format_dup_sdp
+from pyst2110.sdp import format_sdp as format_sdp
+from pyst2110.sdp import parse_dup_sdp as parse_dup_sdp
+from pyst2110.sdp import parse_sdp as parse_sdp
+from pyst2110.sdp import parse_video_format as parse_video_format
+from pyst2110.timing import Limits as Limits
+from pyst2110.timing import Measurement as Measurement
+from pyst2110.timing import Schedule as Schedule
+from pyst2110.timing import Vrx as Vrx
+from pyst2110.timing import c_inst as c_inst
+from pyst2110.timing import measure as measure
+from pyst2110.timing import read_schedule as read_schedule
+from pyst2110.timing import read_times as read_times
+from pyst2110.timing import sender_limits as sender_limits
+from pyst2110.timing import video_datum as video_datum
+from pyst2110.timing import vrx as vrx
+from pyst2110.transmit import PACKET_HEADER_SIZE as PACKET_HEADER_SIZE
+from pyst2110.transmit import UDP_HEADER_SIZE as UDP_HEADER_SIZE
+from pyst2110.transmit import FrameHeaders as FrameHeaders
+from pyst2110.transmit import max_payload_size as max_payload_size
+
+__all__ = [
+    "FIXED_HEADER_SIZE",
+    "PACKET_HEADER_SIZE",
+    "RTP_CLOCK_RATE",
+    "SENDER_TYPES",
+    "SENDER_TYPE_NARROW",
+    "SENDER_TYPE_NARROW_LINEAR",
+    "SENDER_TYPE_WIDE",
+    "STANDARD_UDP_SIZE_LIMIT",
+    "UDP_HEADER_SIZE",
+    "FrameHeaders",
+    "FrameTracker",
+    "LegPair",
+    "Limits",
+    "Measurement",
+    "PayloadHeaders",
+    "RtpHeaders",
+    "Schedule",
+    "SdpConformanceWarning",
+    "SdpFlow",
+    "SdpVideo",
+    "SequenceTracker",
+    "Vrx",
+    "byte_offset",
+    "c_inst",
+    "choose_payload_size",
+    "fits_raster",
+    "format_dup_sdp",
+    "format_sdp",
+    "frame_boundaries",
+    "frame_starts",
+    "line_bytes",
+    "max_payload_size",
+    "measure",
+    "packets_per_frame",
+    "packets_per_line",
+    "parse_dup_sdp",
+    "parse_payload_headers",
+    "parse_rtp",
+    "parse_sdp",
+    "parse_video_format",
+    "pgroup",
+    "raster_offset",
+    "read_schedule",
+    "read_times",
+    "reconstruct",
+    "rows_per_field",
+    "sample_offset",
+    "sender_limits",
+    "video_datum",
+    "vrx",
+]

pyst2110-0.9.1/src/pyst2110/_chunk.py

@@ -0,0 +1,146 @@
+"""Shape checks and per-packet reads shared by the header parses.
+
+Internal. Both parses take the same thing — a ``(packets, stride)`` uint8 view
+(SPEC §spec:interface-shape) — and both need to read a big-endian field at an
+offset that differs per packet, because CSRCs, a header extension and the
+RFC 4175 continuation bit all move what follows them.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike, DTypeLike, NDArray
+
+_U16_SIZE = 2
+_U32_SIZE = 4
+
+
+def per_packet(
+    values: ArrayLike,
+    noun: str,
+    count: int | None = None,
+    plural: str = "",
+    dtype: DTypeLike = np.int64,
+) -> NDArray[Any]:
+    """One ``noun`` per packet, coerced — or a ValueError naming the field.
+
+    Every array crossing this interface is packet-aligned
+    (§spec:interface-shape), so every one of them is checked the same way.
+    Pass ``count`` where the packet count is already known, which reports both
+    numbers; without it the check is that the input is one-dimensional at all,
+    which is what catches a ``(packets, stride)`` view passed by mistake.
+
+    ``plural`` names ``noun`` in the plural where adding an *s* does not.
+    """
+    array = np.asarray(values, dtype=dtype)
+    if count is None:
+        if array.ndim != 1:
+            raise ValueError(f"expected one {noun} per packet, got shape {array.shape}")
+    elif array.shape != (count,):
+        raise ValueError(
+            f"expected one {noun} per packet: {count} packets, "
+            f"{array.size} {plural or noun + 's'}"
+        )
+    return array
+
+
+def validate(packets: NDArray[np.uint8], minimum: int) -> None:
+    """Reject anything that is not a byte chunk of at least ``minimum`` columns."""
+    if packets.ndim != 2:
+        raise ValueError(
+            f"expected a (packets, stride) byte view, got shape {packets.shape}"
+        )
+    if packets.dtype != np.uint8:
+        raise ValueError(
+            f"expected a uint8 byte view, got dtype {packets.dtype}; a wider "
+            "dtype would misalign every field"
+        )
+    if packets.shape[1] < minimum:
+        raise ValueError(
+            f"expected at least {minimum} columns, got shape {packets.shape}"
+        )
+
+
+def limits(
+    packets: NDArray[np.uint8], sizes: NDArray[np.integer[Any]] | None
+) -> NDArray[np.int64]:
+    """Each packet's usable length: its reported size, or the stride if unstated.
+
+    A receiver writes at most the stride and reports the true size separately,
+    so the columns past a packet still hold whatever the buffer held before
+    (§spec:interface-shape). Deriving a field's position from those would read
+    the previous frame's packet.
+    """
+    count, stride = packets.shape
+    if sizes is None:
+        return np.full(count, stride, dtype=np.int64)
+    bounds: NDArray[np.int64] = per_packet(sizes, "size", count=count)
+    return np.clip(bounds, 0, stride)
+
+
+def read_u16(
+    packets: NDArray[np.uint8],
+    offsets: NDArray[np.int64],
+    bounds: NDArray[np.int64],
+    rows: NDArray[np.int64] | None = None,
+) -> tuple[NDArray[np.int64], NDArray[np.bool_]]:
+    """A big-endian 16-bit field read at a per-packet offset.
+
+    Returns the values and a mask of which reads landed inside their packet.
+    A read that does not fit is clamped to a valid index and its value zeroed
+    rather than raising: one malformed packet in a chunk of thousands is a
+    packet to account for, not a reason to drop the chunk.
+
+    ``rows`` is the packet index the gather reads down, ``arange(count)``
+    where a caller does not pass one. A caller reading several fields of the
+    same chunk passes it once rather than paying an allocation per field:
+    :func:`pyst2110.payload.parse_payload_headers` reads nine, and at a
+    thousand chunks a second that is nine arange allocations per chunk on the
+    frame path.
+    """
+    inside = (offsets >= 0) & (offsets + _U16_SIZE <= bounds)
+    index = np.where(inside, offsets, 0).clip(0, packets.shape[1] - _U16_SIZE)
+    if rows is None:
+        rows = np.arange(packets.shape[0])
+    high = packets[rows, index].astype(np.int64)
+    low = packets[rows, index + 1].astype(np.int64)
+    return np.where(inside, (high << 8) | low, 0).astype(np.int64), inside
+
+
+def u16_view(packets: NDArray[np.uint8]) -> NDArray[np.uint16] | None:
+    """The whole chunk as big-endian 16-bit words, or ``None`` if it cannot be.
+
+    Reinterpreting the buffer is what turns a header field into a column
+    slice, and a column slice is what the conforming fast path is made of
+    (§spec:conforming-fast-path). It needs the rows contiguous and an even
+    number of octets in each; a caller handing over an odd stride, or a
+    sub-block sliced out of a wider buffer, gets ``None`` and the general path
+    rather than an exception. Both are legitimate chunks — they are simply not
+    ones a column slice can read.
+    """
+    if packets.shape[1] % _U16_SIZE != 0 or not packets.flags["C_CONTIGUOUS"]:
+        return None
+    view: NDArray[np.uint16] = packets.view(">u2")
+    return view
+
+
+def u32_view(packets: NDArray[np.uint8]) -> NDArray[np.uint32] | None:
+    """The whole chunk as big-endian 32-bit words, or ``None`` if it cannot be.
+
+    The same reinterpretation :func:`u16_view` makes, one width up, for the
+    fields that are thirty-two bits on the wire — the RTP timestamp and the
+    SSRC. Reading one as two sixteen-bit columns joined in place costs a
+    widen, a shift and an or over the chunk; reading it as one column costs a
+    strided copy and nothing else.
+
+    A stricter guard than the sixteen-bit one, and it has to be: a stride that
+    is a multiple of two but not of four reinterprets to a shape numpy
+    refuses, so it takes the sixteen-bit path instead. The chunk's own base is
+    numpy's to align.
+    """
+    if packets.shape[1] % _U32_SIZE != 0 or not packets.flags["C_CONTIGUOUS"]:
+        return None
+    view: NDArray[np.uint32] = packets.view(">u4")
+    return view