tensorcodec 0.1.0__tar.gz → 0.1.1__tar.gz

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorcodec
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
@@ -24,42 +24,63 @@ Project-URL: Repository, https://github.com/MilkClouds/tensorcodec
 
 # TensorCodec
 
+[![CI](https://github.com/MilkClouds/tensorcodec/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/MilkClouds/tensorcodec/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/tensorcodec)](https://pypi.org/project/tensorcodec/)
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue)](https://pypi.org/project/tensorcodec/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue)](LICENSE)
+
 **TorchCodec-style video and audio decoding, without PyTorch.**
 
-- Use the CPU decoder API and playback rules of **TorchCodec 0.17.0**.
-- Get **NumPy arrays** instead of `torch.Tensor`.
-- Install **NumPy + TensorCodec**. No Torch, PyAV, or FFmpeg CLI at runtime.
+- Use the CPU decoder API and playback rules of TorchCodec 0.17.0.
+- Get NumPy arrays instead of `torch.Tensor`.
+- Install NumPy + TensorCodec. No Torch, PyAV, or FFmpeg CLI at runtime.
 
 The goal is predictable frame selection, timestamps and audio ranges with a small
 runtime dependency set. This is a **CPU decoding subset**, not the entire
 TorchCodec package. It does not promise a speedup over PyAV or TorchCodec.
 
-## What is available?
-
-| Capability | TorchCodec 0.17.0 | TensorCodec 0.1.0 |
-| --- | --- | --- |
-| Python runtime dependency | PyTorch | NumPy |
-| Output arrays | `torch.Tensor` | `numpy.ndarray`; array interface + DLPack |
-| Video index/slice/batch access | Supported | Supported |
-| Playback time/range access | Supported | Supported |
-| CFR, VFR, offset PTS, B-frames | Supported | Tested |
-| Request ordering and duplicates | Preserved | Preserved |
-| Exact / approximate seeking | Supported | Supported; exact is the default |
-| NCHW / NHWC RGB | Supported | Supported |
-| uint8 / float32 video | Supported | Supported for SDR |
-| FPS sampling, custom frame mappings | Supported | Supported |
-| Audio ranges, resampling, channel mixing | Supported | Supported; float32 output |
-| Paths, URLs, bytes, seekable file objects | Supported | Supported |
-| Encoded tensor input | `torch.Tensor` | 1-D uint8 NumPy arrays |
-| CUDA decoding | Supported | **Not implemented** |
-| Decoder transforms | Supported | **Not implemented** |
-| HDR inputs / display rotation | Supported | **Rejected explicitly** |
-| Other modules, including samplers/encoders | Available | **Outside the initial scope** |
+## Scope compared with TorchCodec
+
+TorchCodec includes decoders, encoders, sampling and transforms.
+
+Legend for both tables: ✓ supported · △ limited support · — unavailable.
+
+| Module family | Component | TorchCodec 0.17.0 | TensorCodec 0.1.1 |
+| --- | --- | :---: | --- |
+| Decoders | Video · `VideoDecoder` | ✓ | △ CPU, SDR |
+| | Audio · `AudioDecoder` | ✓ | △ CPU |
+| | Images | ✓ | — |
+| Encoders | Video / audio / JPEG / PNG | ✓ | — |
+| Samplers | Clip sampling | ✓ | — |
+| Transforms | Decoder transforms | ✓ | — |
+
+FPS-based decoder queries are available; clip samplers are not implemented.
+
+### Decoder compatibility
+
+| Area | Capability | TorchCodec 0.17.0 | TensorCodec 0.1.1 |
+| --- | --- | :---: | --- |
+| Video · selection | Index / slice / batch | ✓ | ✓ |
+| | Playback time / range | ✓ | ✓ |
+| | Order / duplicates preserved | ✓ | ✓ |
+| | Exact / approximate seek | ✓ | ✓ Default: exact |
+| | FPS queries / custom frame mappings | ✓ | ✓ |
+| Video · formats | CFR / VFR / offset PTS / B-frames | ✓ | ✓ Tested |
+| | NCHW / NHWC RGB | ✓ | ✓ |
+| | uint8 / float32 | ✓ | △ SDR |
+| | HDR transfer / display rotation | ✓ | — Explicit rejection |
+| Audio | Ranges / resampling / channel mixing | ✓ | ✓ float32 |
+| Input / output | Paths / URLs / bytes / seekable files | ✓ | ✓ |
+| | Encoded array input | `torch.Tensor` | 1-D uint8 NumPy arrays |
+| | Decoded arrays | `torch.Tensor` | `numpy.ndarray` + array interface / DLPack |
+| Execution | CPU | ✓ | ✓ |
+| | CUDA | ✓ | — |
+| | Python runtime dependency | PyTorch | NumPy |
 
 ### Compatibility means
 
 - Match the supported CPU API's frame selection, ordering, timing and metadata.
-- Check behavior independently **and** against pinned TorchCodec 0.17.0.
+- Check behavior independently and against pinned TorchCodec 0.17.0.
 - Allow color-conversion rounding: at most 1 uint8 unit or 1/65535 for float32
   in the tested cases. Do not claim identical pixels across every FFmpeg build.
 - Accept empty index lists, including the case affected by the reference's
@@ -69,9 +90,13 @@ Details and the tested scope: [compatibility contract](docs/compatibility.md).
 
 ### Current limits
 
-- Binary wheels: **Linux x86_64, glibc 2.28+, CPython 3.10+**.
-- No macOS or Windows wheels yet; free-threaded Python is not a release target.
+- Binary wheels: **Linux x86_64 / ARM64 (aarch64), glibc 2.17+, CPython 3.10+**.
+- A compatible NumPy wheel is also required. On older glibc, the installer may
+  select an older NumPy; newer Python versions may require a newer glibc.
+- No macOS, Windows or musl/Alpine wheels yet; free-threaded Python is not a release target.
 - Exact video seeking scans packet timestamps when opening the decoder.
+- Seeking trusts container keyframe flags; incorrect flags can corrupt decoded
+  frames. Corrected frame mappings or a repaired input are needed in that case.
 - Audio range queries currently decode from the beginning; late ranges can be
   expensive.
 - NumPy return types require caller changes where code expects Torch tensors.
@@ -80,18 +105,13 @@ Details and the tested scope: [compatibility contract](docs/compatibility.md).
 ## Install
 
 ```sh
-python -m pip install tensorcodec
+uv pip install tensorcodec
 ```
 
+Use an existing virtual environment, or create one with `uv venv` first.
 Linux wheels bundle shared FFmpeg libraries. Source builds need Rust, libclang
 and FFmpeg 7 development headers/libraries.
 
-Before the first PyPI upload, install a local wheel:
-
-```sh
-python -m pip install dist/tensorcodec-*.whl
-```
-
 ## Use
 
 ```python
@@ -124,17 +144,15 @@ A batch crosses the Python/Rust boundary once. Native decoding releases the GIL.
 ## Development and verification
 
 ```sh
-# Requires Rust, Clang/libclang, pkg-config and FFmpeg 7 development libraries.
-python -m venv .venv
-. .venv/bin/activate
-python -m pip install numpy pytest ruff 'maturin>=1.8,<2'
-maturin develop --locked
-
-# Reference dependencies are for tests only.
-python -m pip install torch==2.14.1 torchcodec==0.17.0 \
-  --index-url https://download.pytorch.org/whl/cpu
-pytest tests/test_video_contract.py tests/test_audio_contract.py --backend torchcodec
-pytest --compare
+# Requires uv, Rust, Clang/libclang, pkg-config and FFmpeg 7 development libraries.
+# Build the editable package and install development + pinned CPU oracle groups.
+uv sync --group dev --group oracle
+
+uv run --group oracle pytest tests/test_video_contract.py tests/test_audio_contract.py --backend torchcodec
+uv run --group oracle pytest --compare
+
+# Rebuild after changing Rust code.
+uv run --group oracle maturin develop --locked --uv
 ```
 
 Tests generate fixtures with FFmpeg/ffprobe and Python's `wave` module.

tensorcodec-0.1.1/README.md

@@ -0,0 +1,142 @@
+# TensorCodec
+
+[![CI](https://github.com/MilkClouds/tensorcodec/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/MilkClouds/tensorcodec/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/tensorcodec)](https://pypi.org/project/tensorcodec/)
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue)](https://pypi.org/project/tensorcodec/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue)](LICENSE)
+
+**TorchCodec-style video and audio decoding, without PyTorch.**
+
+- Use the CPU decoder API and playback rules of TorchCodec 0.17.0.
+- Get NumPy arrays instead of `torch.Tensor`.
+- Install NumPy + TensorCodec. No Torch, PyAV, or FFmpeg CLI at runtime.
+
+The goal is predictable frame selection, timestamps and audio ranges with a small
+runtime dependency set. This is a **CPU decoding subset**, not the entire
+TorchCodec package. It does not promise a speedup over PyAV or TorchCodec.
+
+## Scope compared with TorchCodec
+
+TorchCodec includes decoders, encoders, sampling and transforms.
+
+Legend for both tables: ✓ supported · △ limited support · — unavailable.
+
+| Module family | Component | TorchCodec 0.17.0 | TensorCodec 0.1.1 |
+| --- | --- | :---: | --- |
+| Decoders | Video · `VideoDecoder` | ✓ | △ CPU, SDR |
+| | Audio · `AudioDecoder` | ✓ | △ CPU |
+| | Images | ✓ | — |
+| Encoders | Video / audio / JPEG / PNG | ✓ | — |
+| Samplers | Clip sampling | ✓ | — |
+| Transforms | Decoder transforms | ✓ | — |
+
+FPS-based decoder queries are available; clip samplers are not implemented.
+
+### Decoder compatibility
+
+| Area | Capability | TorchCodec 0.17.0 | TensorCodec 0.1.1 |
+| --- | --- | :---: | --- |
+| Video · selection | Index / slice / batch | ✓ | ✓ |
+| | Playback time / range | ✓ | ✓ |
+| | Order / duplicates preserved | ✓ | ✓ |
+| | Exact / approximate seek | ✓ | ✓ Default: exact |
+| | FPS queries / custom frame mappings | ✓ | ✓ |
+| Video · formats | CFR / VFR / offset PTS / B-frames | ✓ | ✓ Tested |
+| | NCHW / NHWC RGB | ✓ | ✓ |
+| | uint8 / float32 | ✓ | △ SDR |
+| | HDR transfer / display rotation | ✓ | — Explicit rejection |
+| Audio | Ranges / resampling / channel mixing | ✓ | ✓ float32 |
+| Input / output | Paths / URLs / bytes / seekable files | ✓ | ✓ |
+| | Encoded array input | `torch.Tensor` | 1-D uint8 NumPy arrays |
+| | Decoded arrays | `torch.Tensor` | `numpy.ndarray` + array interface / DLPack |
+| Execution | CPU | ✓ | ✓ |
+| | CUDA | ✓ | — |
+| | Python runtime dependency | PyTorch | NumPy |
+
+### Compatibility means
+
+- Match the supported CPU API's frame selection, ordering, timing and metadata.
+- Check behavior independently and against pinned TorchCodec 0.17.0.
+- Allow color-conversion rounding: at most 1 uint8 unit or 1/65535 for float32
+  in the tested cases. Do not claim identical pixels across every FFmpeg build.
+- Accept empty index lists, including the case affected by the reference's
+  empty-list dtype inference bug.
+
+Details and the tested scope: [compatibility contract](docs/compatibility.md).
+
+### Current limits
+
+- Binary wheels: **Linux x86_64 / ARM64 (aarch64), glibc 2.17+, CPython 3.10+**.
+- A compatible NumPy wheel is also required. On older glibc, the installer may
+  select an older NumPy; newer Python versions may require a newer glibc.
+- No macOS, Windows or musl/Alpine wheels yet; free-threaded Python is not a release target.
+- Exact video seeking scans packet timestamps when opening the decoder.
+- Seeking trusts container keyframe flags; incorrect flags can corrupt decoded
+  frames. Corrected frame mappings or a repaired input are needed in that case.
+- Audio range queries currently decode from the beginning; late ranges can be
+  expensive.
+- NumPy return types require caller changes where code expects Torch tensors.
+- Historical avdec benchmarks are not TensorCodec performance results.
+
+## Install
+
+```sh
+uv pip install tensorcodec
+```
+
+Use an existing virtual environment, or create one with `uv venv` first.
+Linux wheels bundle shared FFmpeg libraries. Source builds need Rust, libclang
+and FFmpeg 7 development headers/libraries.
+
+## Use
+
+```python
+from tensorcodec.decoders import VideoDecoder, AudioDecoder
+
+with VideoDecoder("video.mp4") as video:
+    frame = video.get_frame_played_at(1.25)  # frame playing at this time
+    print(frame.data.shape)                 # CHW NumPy array
+    batch = video.get_frames_at([4, 0, 4])   # order and duplicates preserved
+    clip = video.get_frames_played_in_range(0, 1, fps=8)
+
+with AudioDecoder("audio.wav", sample_rate=16000, num_channels=1) as audio:
+    samples = audio.get_samples_played_in_range(0, 1)
+    print(samples.data.shape)               # channels × samples, float32
+```
+
+Decoded arrays keep their storage after the decoder closes. Input file objects
+remain caller-owned.
+
+## Implementation
+
+| Layer | Responsibility |
+| --- | --- |
+| Python | Public API, frame/time selection, validation, result objects |
+| Rust + PyO3 | FFmpeg handles, seeking/decoding, color conversion, resampling |
+| FFmpeg | Codec and container implementations |
+
+A batch crosses the Python/Rust boundary once. Native decoding releases the GIL.
+
+## Development and verification
+
+```sh
+# Requires uv, Rust, Clang/libclang, pkg-config and FFmpeg 7 development libraries.
+# Build the editable package and install development + pinned CPU oracle groups.
+uv sync --group dev --group oracle
+
+uv run --group oracle pytest tests/test_video_contract.py tests/test_audio_contract.py --backend torchcodec
+uv run --group oracle pytest --compare
+
+# Rebuild after changing Rust code.
+uv run --group oracle maturin develop --locked --uv
+```
+
+Tests generate fixtures with FFmpeg/ffprobe and Python's `wave` module.
+`--compare` requires the exact oracle version; otherwise differential tests skip.
+The old avdec decoder and tests are never executed.
+
+- [Playback rules](docs/playback_semantics.md)
+- [Release builds and PyPI publishing](docs/releasing.md)
+- [Native dependency licenses and source/build notices](licenses/README.md)
+
+TensorCodec's own code is MIT licensed.

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/docs/releasing.md

@@ -1,7 +1,8 @@
 # Publishing TensorCodec
 
-Release version: `0.1.0`. Distribution and import name: `tensorcodec`.
-The first binary release targets Linux x86_64, glibc 2.28+, CPython 3.10+.
+Release version: `0.1.1`. Distribution and import name: `tensorcodec`.
+Binary wheels target Linux x86_64 and ARM64 (aarch64), glibc 2.17+, CPython 3.10+.
+NumPy must also provide a compatible wheel for the selected Python/glibc pair.
 The wheel bundles shared FFmpeg 7.1.5 and OpenSSL 3.5.9 LTS; its only Python
 runtime dependency is NumPy. macOS/Windows wheels are not yet provided.
 
@@ -26,7 +27,7 @@ settings instead. Do not put an API token in the repository or chat.
 
 ## Release
 
-Run the **Publish to PyPI** workflow on `main`. It builds the portable Linux wheel
+Run the **Publish to PyPI** workflow on `main`. It builds the portable Linux wheels
 and source distribution, checks package metadata, validates the pinned oracle
 and compares playback before uploading through PyPI Trusted Publishing. It uses
 the existing GitHub `pypi` environment. Publication fails if authorization is
@@ -38,13 +39,14 @@ gh workflow run publish.yml --repo MilkClouds/tensorcodec --ref main
 
 For a build and full validation without uploading, pass `--field publish=false`.
 
-Check the workflow and https://pypi.org/project/tensorcodec/0.1.0/ before reporting
-success. Verify a fresh `pip install tensorcodec==0.1.0` and a decode without
-Torch/PyAV. Update the version before subsequent releases; PyPI versions cannot
-be overwritten.
+Check the workflow and https://pypi.org/project/tensorcodec/0.1.1/ before reporting
+success. Verify a fresh `uv pip install tensorcodec==0.1.1` and a decode without
+Torch/PyAV on both architectures. Update the version before subsequent releases;
+PyPI versions cannot be overwritten.
 
 The local Linux build is reproducible using `scripts/build_linux_wheel.sh` inside
-`quay.io/pypa/manylinux_2_28_x86_64` with Rust, maturin, libclang, NASM and Perl.
+`quay.io/pypa/manylinux2014_x86_64` or
+`quay.io/pypa/manylinux2014_aarch64` with Rust, maturin, libclang, NASM and Perl.
 Both native source archives are version- and checksum-pinned. Their licensing
 and source links are recorded in `licenses/README.md`.
 
@@ -53,8 +55,12 @@ and source links are recorded in `licenses/README.md`.
 - Ordinary CI uses prebuilt conda-forge FFmpeg 7.1.1 through Pixi, including its
   headers and shared libraries. It builds only the TensorCodec extension.
 - PyPI wheels use the smaller LGPL FFmpeg 7.1.5 build plus OpenSSL 3.5.9.
-  Their native prefix is cached by the build-script checksums. This preserves the
-  wheel's codec set, dependency size and licensing rather than bundling the full
+  Their native prefix is cached by architecture, glibc baseline and build-script
+  checksums. This preserves the wheel's codec set, dependency size and licensing rather than bundling the full
   conda-forge dependency graph.
+- Release validation installs each repaired wheel on glibc 2.17 with Python 3.10
+  and 3.13 and decodes video/audio without Torch, PyAV or a system FFmpeg. Python
+  3.10 also checks the minimum NumPy line (1.26.4). Native
+  x86_64 and ARM64 runners also run the full pinned playback oracle comparison.
 - Release validation still tests the installed repaired wheel. The fixture CLI
   can be FFmpeg 6 or 7; fixtures explicitly remove auxiliary sentinel packets.

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/native/Cargo.lock

@@ -455,7 +455,7 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tensorcodec-native"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "ffmpeg-sys-next",
  "numpy",

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tensorcodec-native"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 license = "MIT"
 

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/native/src/ffmpeg.rs

@@ -26,7 +26,7 @@ fn check(code: i32, operation: &str) -> Result<()> {
     if code >= 0 {
         return Ok(());
     }
-    let mut text = [0i8; 256];
+    let mut text: [std::ffi::c_char; 256] = [0; 256];
     unsafe {
         av::av_strerror(code, text.as_mut_ptr(), text.len());
     }

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tensorcodec"
-version = "0.1.0"
+version = "0.1.1"
 description = "NumPy audio/video decoding with TorchCodec-compatible playback semantics"
 readme = "README.md"
 license = "MIT"
@@ -46,7 +46,7 @@ include = [
 testpaths = ["tests"]
 
 [tool.ruff]
-line-length = 110
+line-length = 119
 target-version = "py310"
 
 [tool.uv.sources]

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/scripts/build_linux_wheel.sh

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
-# Run inside manylinux_2_28 with Rust, maturin, libclang, NASM and Perl installed.
+# Run inside manylinux2014 with Rust, maturin, libclang, NASM and Perl installed.
 set -euo pipefail
+export BINDGEN_EXTRA_CLANG_ARGS="-I$(gcc -print-file-name=include)${BINDGEN_EXTRA_CLANG_ARGS:+ $BINDGEN_EXTRA_CLANG_ARGS}"
 build_prefix="${TENSORCODEC_NATIVE_PREFIX:-/opt/tensorcodec}"
 scripts/build_openssl.sh "$build_prefix/openssl"
 export PKG_CONFIG_PATH="$build_prefix/openssl/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"
@@ -8,4 +9,4 @@ export LD_LIBRARY_PATH="$build_prefix/openssl/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY
 scripts/build_ffmpeg.sh "$build_prefix/ffmpeg"
 export FFMPEG_DIR="$build_prefix/ffmpeg"
 export LD_LIBRARY_PATH="$FFMPEG_DIR/lib:$LD_LIBRARY_PATH"
-maturin build --release --locked --auditwheel repair --compatibility manylinux_2_28 --out dist
+maturin build --release --locked --auditwheel repair --compatibility manylinux2014 --out dist

tensorcodec-0.1.1/scripts/build_nasm.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Build-only assembler; manylinux2014's system NASM is too old for FFmpeg 7.
+set -euo pipefail
+prefix="${1:?usage: build_nasm.sh ABSOLUTE_INSTALL_PREFIX}"
+version=2.16.03
+build_root="$(mktemp -d)"
+curl -fsSL "https://www.nasm.us/pub/nasm/releasebuilds/${version}/nasm-${version}.tar.xz" -o "$build_root/nasm.tar.xz"
+echo "1412a1c760bbd05db026b6c0d1657affd6631cd0a63cddb6f73cc6d4aa616148  $build_root/nasm.tar.xz" | sha256sum --check
+tar -xf "$build_root/nasm.tar.xz" -C "$build_root"
+cd "$build_root/nasm-${version}"
+./configure --prefix="$prefix"
+make -j "${TENSORCODEC_BUILD_JOBS:-4}"
+make install

tensorcodec-0.1.1/scripts/check_wheel_runtime.py

@@ -0,0 +1,75 @@
+"""Generate portable fixtures, then decode them in a clean wheel runtime."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import platform
+import subprocess
+import wave
+from pathlib import Path
+
+
+def generate(root: Path):
+    import numpy as np
+
+    root.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [
+            "ffmpeg",
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc2=size=64x48:rate=10:duration=1",
+            "-c:v",
+            "libx264",
+            "-g",
+            "10",
+            "-bf",
+            "2",
+            str(root / "video.mp4"),
+        ],
+        check=True,
+    )
+    samples = np.stack([np.arange(8000) % 1000, -(np.arange(8000) % 1000)], axis=1).astype("<i2")
+    with wave.open(str(root / "audio.wav"), "wb") as audio:
+        audio.setparams((2, 2, 8000, 8000, "NONE", "not compressed"))
+        audio.writeframes(samples.tobytes())
+
+
+def check(root: Path):
+    import numpy as np
+
+    from tensorcodec.decoders import AudioDecoder, VideoDecoder
+
+    assert all(importlib.util.find_spec(name) is None for name in ("torch", "torchcodec", "av"))
+    with VideoDecoder(root / "video.mp4") as decoder:
+        assert len(decoder) == 10
+        frames = decoder.get_frames_at([7, 0, 7])
+        assert frames.data.shape == (3, 3, 48, 64)
+        assert frames.data.dtype == np.uint8
+        np.testing.assert_allclose(frames.pts_seconds, [0.7, 0.0, 0.7])
+        np.testing.assert_array_equal(frames.data[0], frames.data[2])
+        played = decoder.get_frame_played_at(0.75)
+        np.testing.assert_array_equal(played.data, frames.data[0])
+    assert frames.data.max() > frames.data.min()
+    with AudioDecoder(root / "audio.wav") as decoder:
+        audio = decoder.get_samples_played_in_range(0.125, 0.25)
+        assert audio.data.shape == (2, 1000)
+        assert audio.data.dtype == np.float32
+        expected = np.arange(1000, dtype=np.float32) / 32768
+        np.testing.assert_allclose(audio.data[0], expected, atol=1e-7)
+        np.testing.assert_allclose(audio.data[1], -expected, atol=1e-7)
+    print(f"Wheel decoding passed: Python {platform.python_version()}, {platform.machine()}, {platform.libc_ver()}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=("generate", "check"))
+    parser.add_argument("fixtures", type=Path)
+    args = parser.parse_args()
+    {"generate": generate, "check": check}[args.command](args.fixtures)

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/src/tensorcodec/__init__.py

@@ -3,5 +3,5 @@
 from tensorcodec import decoders
 from tensorcodec._frame import AudioSamples, Frame, FrameBatch
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __all__ = ["AudioSamples", "Frame", "FrameBatch", "decoders"]

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/src/tensorcodec/decoders/_decoder.py

@@ -241,9 +241,7 @@ class VideoDecoder(_Decoder):
             )
             if self._order == "NCHW":
                 data = data.transpose(0, 3, 1, 2)
-            return FrameBatch(
-                data, np.asarray(pts, dtype=np.float64), np.asarray(durations, dtype=np.float64)
-            )
+            return FrameBatch(data, np.asarray(pts, dtype=np.float64), np.asarray(durations, dtype=np.float64))
 
     def get_frame_at(self, index):
         batch = self.get_frames_at([index])
@@ -275,9 +273,7 @@ class VideoDecoder(_Decoder):
             raise RuntimeError("timestamp is outside the stream")
         if self._mappings is not None:
             return np.searchsorted(self._pts, values, side="right") - 1
-        return np.floor((values - self.metadata.begin_stream_seconds) * self.metadata.average_fps).astype(
-            np.int64
-        )
+        return np.floor((values - self.metadata.begin_stream_seconds) * self.metadata.average_fps).astype(np.int64)
 
     def get_frames_played_at(self, seconds):
         with self._lock:
@@ -312,12 +308,8 @@ class VideoDecoder(_Decoder):
                 start = int(np.searchsorted(self._pts, start_seconds, side="right") - 1)
                 stop = int(np.searchsorted(self._pts, stop_seconds, side="left"))
             else:
-                start = math.floor(
-                    (start_seconds - self.metadata.begin_stream_seconds) * self.metadata.average_fps
-                )
-                stop = math.ceil(
-                    (stop_seconds - self.metadata.begin_stream_seconds) * self.metadata.average_fps
-                )
+                start = math.floor((start_seconds - self.metadata.begin_stream_seconds) * self.metadata.average_fps)
+                stop = math.ceil((stop_seconds - self.metadata.begin_stream_seconds) * self.metadata.average_fps)
             return self.get_frames_in_range(start, stop)
 
     def get_all_frames(self, fps=None):
@@ -365,8 +357,7 @@ class AudioDecoder(_Decoder):
         with self._lock:
             self._check_open()
             if not math.isfinite(start_seconds) or (
-                stop_seconds is not None
-                and (not math.isfinite(stop_seconds) or not start_seconds <= stop_seconds)
+                stop_seconds is not None and (not math.isfinite(stop_seconds) or not start_seconds <= stop_seconds)
             ):
                 raise ValueError("invalid audio time range")
             data, first_pts = self._native.decode_audio(self._rate, self._channels, stop_seconds)

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/tests/test_differential.py

@@ -9,9 +9,7 @@ from tests.conftest import as_numpy, index_input, time_input
 def compare_batch(actual, expected):
     assert actual.data.shape == expected.data.shape
     np.testing.assert_allclose(actual.pts_seconds, as_numpy(expected.pts_seconds), atol=1e-12, rtol=0)
-    np.testing.assert_allclose(
-        actual.duration_seconds, as_numpy(expected.duration_seconds), atol=1e-12, rtol=0
-    )
+    np.testing.assert_allclose(actual.duration_seconds, as_numpy(expected.duration_seconds), atol=1e-12, rtol=0)
     # Identical FFmpeg conversion settings should match; allow one rounding unit, not 20.
     np.testing.assert_allclose(actual.data, as_numpy(expected.data), atol=1, rtol=0)
 
@@ -40,9 +38,7 @@ def test_video_differential(backend, oracle, video):
     for indices in [[11, 0, 5, 5, 2], [], list(range(12))]:
         compare_batch(actual.get_frames_at(indices), expected.get_frames_at(index_input(oracle, indices)))
     times = ((video.pts[:-1] + video.pts[1:]) / 2).tolist()[::-1]
-    compare_batch(
-        actual.get_frames_played_at(times), expected.get_frames_played_at(time_input(oracle, times))
-    )
+    compare_batch(actual.get_frames_played_at(times), expected.get_frames_played_at(time_input(oracle, times)))
     compare_batch(
         actual.get_frames_played_in_range(float(video.pts[1]), float(video.pts[8])),
         expected.get_frames_played_in_range(float(video.pts[1]), float(video.pts[8])),
@@ -73,9 +69,7 @@ def test_color_conversion_differential(backend, oracle, color_video, dtype):
     # Exact pixel conversion when both backends link the same FFmpeg version.
     for indices in ([11, 3, 3, 0], [4, 1, 9], [0, 11]):
         left, right = actual.get_frames_at(indices), expected.get_frames_at(indices)
-        np.testing.assert_allclose(
-            left.data, as_numpy(right.data), atol=1 if dtype == "uint8" else 1 / 65535, rtol=0
-        )
+        np.testing.assert_allclose(left.data, as_numpy(right.data), atol=1 if dtype == "uint8" else 1 / 65535, rtol=0)
         np.testing.assert_allclose(left.pts_seconds, as_numpy(right.pts_seconds), atol=1e-12, rtol=0)
     for field in ("color_space", "color_primaries", "color_transfer_characteristic", "pixel_format"):
         assert getattr(actual.metadata, field) == getattr(expected.metadata, field)

{tensorcodec-0.1.0 → tensorcodec-0.1.1}/tests/test_video_contract.py

@@ -115,9 +115,7 @@ def test_encoded_sources(backend, videos, kind):
     assert_batch(backend.VideoDecoder(source).get_frames_at([11, 0, 4]), case, [11, 0, 4])
 
 
-@pytest.mark.parametrize(
-    "kwargs", [{"dimension_order": "CHWN"}, {"seek_mode": "wrong"}, {"num_ffmpeg_threads": None}]
-)
+@pytest.mark.parametrize("kwargs", [{"dimension_order": "CHWN"}, {"seek_mode": "wrong"}, {"num_ffmpeg_threads": None}])
 def test_invalid_constructor_arguments(backend, videos, kwargs):
     with pytest.raises(ValueError):
         backend.VideoDecoder(videos["cfr"].path, **kwargs)

tensorcodec-0.1.0/README.md

@@ -1,124 +0,0 @@
-# TensorCodec
-
-**TorchCodec-style video and audio decoding, without PyTorch.**
-
-- Use the CPU decoder API and playback rules of **TorchCodec 0.17.0**.
-- Get **NumPy arrays** instead of `torch.Tensor`.
-- Install **NumPy + TensorCodec**. No Torch, PyAV, or FFmpeg CLI at runtime.
-
-The goal is predictable frame selection, timestamps and audio ranges with a small
-runtime dependency set. This is a **CPU decoding subset**, not the entire
-TorchCodec package. It does not promise a speedup over PyAV or TorchCodec.
-
-## What is available?
-
-| Capability | TorchCodec 0.17.0 | TensorCodec 0.1.0 |
-| --- | --- | --- |
-| Python runtime dependency | PyTorch | NumPy |
-| Output arrays | `torch.Tensor` | `numpy.ndarray`; array interface + DLPack |
-| Video index/slice/batch access | Supported | Supported |
-| Playback time/range access | Supported | Supported |
-| CFR, VFR, offset PTS, B-frames | Supported | Tested |
-| Request ordering and duplicates | Preserved | Preserved |
-| Exact / approximate seeking | Supported | Supported; exact is the default |
-| NCHW / NHWC RGB | Supported | Supported |
-| uint8 / float32 video | Supported | Supported for SDR |
-| FPS sampling, custom frame mappings | Supported | Supported |
-| Audio ranges, resampling, channel mixing | Supported | Supported; float32 output |
-| Paths, URLs, bytes, seekable file objects | Supported | Supported |
-| Encoded tensor input | `torch.Tensor` | 1-D uint8 NumPy arrays |
-| CUDA decoding | Supported | **Not implemented** |
-| Decoder transforms | Supported | **Not implemented** |
-| HDR inputs / display rotation | Supported | **Rejected explicitly** |
-| Other modules, including samplers/encoders | Available | **Outside the initial scope** |
-
-### Compatibility means
-
-- Match the supported CPU API's frame selection, ordering, timing and metadata.
-- Check behavior independently **and** against pinned TorchCodec 0.17.0.
-- Allow color-conversion rounding: at most 1 uint8 unit or 1/65535 for float32
-  in the tested cases. Do not claim identical pixels across every FFmpeg build.
-- Accept empty index lists, including the case affected by the reference's
-  empty-list dtype inference bug.
-
-Details and the tested scope: [compatibility contract](docs/compatibility.md).
-
-### Current limits
-
-- Binary wheels: **Linux x86_64, glibc 2.28+, CPython 3.10+**.
-- No macOS or Windows wheels yet; free-threaded Python is not a release target.
-- Exact video seeking scans packet timestamps when opening the decoder.
-- Audio range queries currently decode from the beginning; late ranges can be
-  expensive.
-- NumPy return types require caller changes where code expects Torch tensors.
-- Historical avdec benchmarks are not TensorCodec performance results.
-
-## Install
-
-```sh
-python -m pip install tensorcodec
-```
-
-Linux wheels bundle shared FFmpeg libraries. Source builds need Rust, libclang
-and FFmpeg 7 development headers/libraries.
-
-Before the first PyPI upload, install a local wheel:
-
-```sh
-python -m pip install dist/tensorcodec-*.whl
-```
-
-## Use
-
-```python
-from tensorcodec.decoders import VideoDecoder, AudioDecoder
-
-with VideoDecoder("video.mp4") as video:
-    frame = video.get_frame_played_at(1.25)  # frame playing at this time
-    print(frame.data.shape)                 # CHW NumPy array
-    batch = video.get_frames_at([4, 0, 4])   # order and duplicates preserved
-    clip = video.get_frames_played_in_range(0, 1, fps=8)
-
-with AudioDecoder("audio.wav", sample_rate=16000, num_channels=1) as audio:
-    samples = audio.get_samples_played_in_range(0, 1)
-    print(samples.data.shape)               # channels × samples, float32
-```
-
-Decoded arrays keep their storage after the decoder closes. Input file objects
-remain caller-owned.
-
-## Implementation
-
-| Layer | Responsibility |
-| --- | --- |
-| Python | Public API, frame/time selection, validation, result objects |
-| Rust + PyO3 | FFmpeg handles, seeking/decoding, color conversion, resampling |
-| FFmpeg | Codec and container implementations |
-
-A batch crosses the Python/Rust boundary once. Native decoding releases the GIL.
-
-## Development and verification
-
-```sh
-# Requires Rust, Clang/libclang, pkg-config and FFmpeg 7 development libraries.
-python -m venv .venv
-. .venv/bin/activate
-python -m pip install numpy pytest ruff 'maturin>=1.8,<2'
-maturin develop --locked
-
-# Reference dependencies are for tests only.
-python -m pip install torch==2.14.1 torchcodec==0.17.0 \
-  --index-url https://download.pytorch.org/whl/cpu
-pytest tests/test_video_contract.py tests/test_audio_contract.py --backend torchcodec
-pytest --compare
-```
-
-Tests generate fixtures with FFmpeg/ffprobe and Python's `wave` module.
-`--compare` requires the exact oracle version; otherwise differential tests skip.
-The old avdec decoder and tests are never executed.
-
-- [Playback rules](docs/playback_semantics.md)
-- [Release builds and PyPI publishing](docs/releasing.md)
-- [Native dependency licenses and source/build notices](licenses/README.md)
-
-TensorCodec's own code is MIT licensed.