tensorcodec 0.1.2__tar.gz → 0.1.3__tar.gz

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: tensorcodec
-Version: 0.1.2
+Version: 0.1.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Multimedia :: Video
@@ -48,7 +49,7 @@ CPU video/audio decoding with TorchCodec-style APIs and NumPy output.
   ranges are checked against TorchCodec 0.17.0 and independently generated media.
 - **Efficient batch decoding.** Rust/PyO3 bindings to FFmpeg process frame batches
   in a single native call, avoiding per-frame Python calls.
-- **Lightweight installation.** Linux wheels are 10.2–10.4 MiB (v0.1.1), including
+- **Lightweight installation.** Linux wheels are 10.2–10.4 MiB (v0.1.2), including
   FFmpeg shared libraries. NumPy is the only Python dependency.
 
 ## Quick start
@@ -78,7 +79,7 @@ Arrays keep their storage after the decoder closes. Paths, URLs, encoded bytes,
 
 ## Features
 
-TensorCodec 0.1.2 relative to TorchCodec 0.17.0.
+TensorCodec 0.1.3 relative to TorchCodec 0.17.0.
 ✓ supported · △ partial support · — not implemented.
 
 | Component | TensorCodec | TorchCodec 0.17.0 |
@@ -105,6 +106,7 @@ FPS-based frame queries are supported; clip samplers are a separate API.
 | NCHW / NHWC RGB output | ✓ | ✓ |
 | uint8 / float32 / automatic dtype | ✓ SDR and high-bit-depth video | ✓ |
 | uint16 RGB output | ✓ Full-range RGB48 | — |
+| Native grayscale/depth and packed RGB(A) | ✓ Values preserved | — |
 | PQ / HLG decoding | ✓ Transfer-encoded RGB | ✓ |
 | Right-angle display rotation | ✓ | ✓ |
 | Audio ranges / resampling / channel mixing | ✓ float32 | ✓ |
@@ -118,6 +120,11 @@ float32 above 8 bits, or `output_dtype="uint16"` for full-range 16-bit RGB.
 HDR output retains PQ/HLG encoding without SDR tone mapping. Rotation is applied
 automatically, and metadata dimensions match the output.
 
+For unmodified samples, use `VideoDecoder(path, output_format="native")`.
+Supported formats: `gray`, `gray12le`, `gray16le/be`, `rgb24`, `rgba`.
+Native output preserves channel count, integer values and pixel coordinates;
+`expected_pixel_format` optionally asserts the source format.
+
 ## Package size
 
 <!-- wheel-size:start -->
@@ -153,8 +160,8 @@ See the [compatibility contract](docs/compatibility.md) and
 
 - **Wheels:** Linux x86_64 and ARM64 (aarch64), glibc 2.17+, CPython 3.10+.
   NumPy must also provide a compatible wheel; newer Python versions may require
-  a newer glibc. macOS, Windows, musl/Alpine and free-threaded Python wheels are
-  not release targets yet.
+  a newer glibc. macOS 14+ wheels support ARM64 and x86_64. Windows, musl/Alpine
+  and free-threaded Python wheels are not provided.
 - **Exact seeking:** scans packet timestamps when opening the decoder. Incorrect
   container keyframe flags can produce corrupt frames; repaired input or corrected
   frame mappings are needed in that case.
@@ -174,6 +181,8 @@ Source builds require Rust, Clang/libclang, pkg-config and FFmpeg 7 development
 headers/libraries. Python handles API and playback selection; Rust + PyO3 handles
 FFmpeg. Native decoding releases the GIL, allowing separate decoder instances to
 run concurrently across Python threads. Calls on the same instance are serialized.
+The default is one FFmpeg thread per decoder; use independent workers for concurrent
+windows and tune the total thread count to avoid oversubscription.
 
 ```sh
 uv sync --group dev --group oracle

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/README.md

@@ -24,7 +24,7 @@ CPU video/audio decoding with TorchCodec-style APIs and NumPy output.
   ranges are checked against TorchCodec 0.17.0 and independently generated media.
 - **Efficient batch decoding.** Rust/PyO3 bindings to FFmpeg process frame batches
   in a single native call, avoiding per-frame Python calls.
-- **Lightweight installation.** Linux wheels are 10.2–10.4 MiB (v0.1.1), including
+- **Lightweight installation.** Linux wheels are 10.2–10.4 MiB (v0.1.2), including
   FFmpeg shared libraries. NumPy is the only Python dependency.
 
 ## Quick start
@@ -54,7 +54,7 @@ Arrays keep their storage after the decoder closes. Paths, URLs, encoded bytes,
 
 ## Features
 
-TensorCodec 0.1.2 relative to TorchCodec 0.17.0.
+TensorCodec 0.1.3 relative to TorchCodec 0.17.0.
 ✓ supported · △ partial support · — not implemented.
 
 | Component | TensorCodec | TorchCodec 0.17.0 |
@@ -81,6 +81,7 @@ FPS-based frame queries are supported; clip samplers are a separate API.
 | NCHW / NHWC RGB output | ✓ | ✓ |
 | uint8 / float32 / automatic dtype | ✓ SDR and high-bit-depth video | ✓ |
 | uint16 RGB output | ✓ Full-range RGB48 | — |
+| Native grayscale/depth and packed RGB(A) | ✓ Values preserved | — |
 | PQ / HLG decoding | ✓ Transfer-encoded RGB | ✓ |
 | Right-angle display rotation | ✓ | ✓ |
 | Audio ranges / resampling / channel mixing | ✓ float32 | ✓ |
@@ -94,6 +95,11 @@ float32 above 8 bits, or `output_dtype="uint16"` for full-range 16-bit RGB.
 HDR output retains PQ/HLG encoding without SDR tone mapping. Rotation is applied
 automatically, and metadata dimensions match the output.
 
+For unmodified samples, use `VideoDecoder(path, output_format="native")`.
+Supported formats: `gray`, `gray12le`, `gray16le/be`, `rgb24`, `rgba`.
+Native output preserves channel count, integer values and pixel coordinates;
+`expected_pixel_format` optionally asserts the source format.
+
 ## Package size
 
 <!-- wheel-size:start -->
@@ -129,8 +135,8 @@ See the [compatibility contract](docs/compatibility.md) and
 
 - **Wheels:** Linux x86_64 and ARM64 (aarch64), glibc 2.17+, CPython 3.10+.
   NumPy must also provide a compatible wheel; newer Python versions may require
-  a newer glibc. macOS, Windows, musl/Alpine and free-threaded Python wheels are
-  not release targets yet.
+  a newer glibc. macOS 14+ wheels support ARM64 and x86_64. Windows, musl/Alpine
+  and free-threaded Python wheels are not provided.
 - **Exact seeking:** scans packet timestamps when opening the decoder. Incorrect
   container keyframe flags can produce corrupt frames; repaired input or corrected
   frame mappings are needed in that case.
@@ -150,6 +156,8 @@ Source builds require Rust, Clang/libclang, pkg-config and FFmpeg 7 development
 headers/libraries. Python handles API and playback selection; Rust + PyO3 handles
 FFmpeg. Native decoding releases the GIL, allowing separate decoder instances to
 run concurrently across Python threads. Calls on the same instance are serialized.
+The default is one FFmpeg thread per decoder; use independent workers for concurrent
+windows and tune the total thread count to avoid oversubscription.
 
 ```sh
 uv sync --group dev --group oracle

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/docs/compatibility.md

@@ -66,3 +66,18 @@ TensorCodec extensions. Right-angle display rotations are applied automatically;
 metadata dimensions describe the rotated output. Reflected and non-right-angle
 display matrices remain unsupported. Color metadata and pixel aspect ratio
 describe the source; HDR output is not linear light or sRGB.
+
+## Native video output
+
+`output_format="native"` bypasses color conversion and display transforms for
+`gray`, `gray12le`, `gray16le`, `gray16be`, `rgb24` and `rgba`. NCHW/NHWC keeps
+1, 3 or 4 channels. Output uses host-endian uint8/uint16 without range scaling;
+`output_dtype` may be omitted, `"auto"`, or the matching integer dtype.
+`expected_pixel_format` asserts the source layout. Unsupported formats, dtype
+conversions and changes of pixel format or dimensions fail explicitly.
+
+Frame/FrameBatch `pixel_format` records the native source format and survives
+indexing and FPS resampling. RGB results retain their existing behavior. Native
+mode preserves encoded pixel coordinates, including inputs with display matrices.
+Playback selection follows the same TorchCodec contract as RGB, including the
+frame overlapping a range's start; it does not copy PyAV's legacy PTS-only range rule.

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/docs/package_size.md

@@ -51,7 +51,7 @@ download; candidate builds never update it.
 To reproduce or recover a documentation update after publication:
 
 ```sh
-uv run --no-project python scripts/update_size_comparison.py --version 0.1.2
+uv run --no-project python scripts/update_size_comparison.py --version 0.1.3
 ```
 
 Review and commit `README.md` and `packaging/size-baseline.json` together. The script

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/docs/releasing.md

@@ -1,10 +1,11 @@
 # Publishing TensorCodec
 
-Release version: `0.1.2`. Distribution and import name: `tensorcodec`.
+Release version: `0.1.3`. 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.
+runtime dependency is NumPy. macOS 14+ ARM64/x86_64 wheels bundle the same minimal
+runtime. Windows wheels are not provided.
 
 ## Trusted publisher configuration
 
@@ -24,7 +25,7 @@ is needed. Repository visibility does not need to change for a release.
 
 ## Release
 
-Run the **Publish to PyPI** workflow on `main`. It builds the portable Linux wheels
+Run the **Publish to PyPI** workflow on `main`. It builds the portable Linux/macOS 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
@@ -36,8 +37,8 @@ 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.2/ before reporting
-success. Verify a fresh `uv pip install tensorcodec==0.1.2` and a decode without
+Check the workflow and https://pypi.org/project/tensorcodec/0.1.3/ before reporting
+success. Verify a fresh `uv pip install tensorcodec==0.1.3` and a decode without
 Torch/PyAV on both architectures. Update the version before subsequent releases;
 PyPI versions cannot be overwritten.
 

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/docs/system_ffmpeg.md

@@ -37,7 +37,7 @@ test -f "$FFMPEG_DIR/include/libavcodec/avcodec.h"
 test -f "$FFMPEG_DIR/lib/libavcodec.so.61"
 
 uv venv
-uv pip install --no-binary tensorcodec 'tensorcodec==0.1.2'
+uv pip install --no-binary tensorcodec 'tensorcodec==0.1.3'
 ```
 
 The version/build constraint avoids silently selecting an incompatible FFmpeg
@@ -75,3 +75,11 @@ The native extension build and playback contracts run against prebuilt FFmpeg
 no external FFmpeg library installation. Configuration-specific outputs can differ
 within the color-conversion tolerances described in the
 [compatibility contract](compatibility.md).
+
+## macOS wheels
+
+Since 0.1.3, macOS 14+ wheels support Apple Silicon and Intel, bundling
+FFmpeg/OpenSSL with `delocate`. CI tests
+the installed wheels and clean Python 3.10/3.13 environments. Developers can run
+`scripts/build_macos_wheel.sh` with Rust, Xcode tools, NASM, pkg-config, coreutils,
+maturin and delocate installed in their build environment.

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/licenses/README.md

@@ -1,6 +1,6 @@
 # Bundled native libraries
 
-TensorCodec's own code is MIT licensed. Linux wheels bundle shared FFmpeg
+TensorCodec's own code is MIT licensed. Linux and macOS wheels bundle shared FFmpeg
 7.1.5 libraries, built without GPL codec libraries using
 `scripts/build_ffmpeg.sh`. This configuration is LGPL-3.0-or-later. Its notices
 and both the LGPLv3 and incorporated GPLv3 texts are included here. The exact
@@ -8,9 +8,11 @@ upstream source is https://ffmpeg.org/releases/ffmpeg-7.1.5.tar.xz; the build
 script records the configuration. FFmpeg libraries remain dynamically linked
 and can be rebuilt/replaced with an ABI-compatible build.
 
-Portable Linux release wheels also bundle shared OpenSSL 3.5.9 LTS, licensed
+Release wheels also bundle shared OpenSSL 3.5.9 LTS, licensed
 under Apache-2.0. Its exact source is
 https://github.com/openssl/openssl/releases/download/openssl-3.5.9/openssl-3.5.9.tar.gz;
 `scripts/build_openssl.sh` records the checksum and build configuration.
 System-library builds can additionally depend on Zstandard; its notices are
 retained here. Inspect repaired wheels when changing the native build.
+
+PNG/Deflate decoding uses the platform zlib library.

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/native/Cargo.lock

@@ -455,9 +455,10 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tensorcodec-native"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "ffmpeg-sys-next",
+ "libc",
  "numpy",
  "pyo3",
 ]

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tensorcodec-native"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 license = "MIT"
 
@@ -9,6 +9,7 @@ name = "_native"
 crate-type = ["cdylib"]
 
 [dependencies]
+libc = "0.2"
 pyo3 = { version = "0.23", features = ["abi3-py310"] }
 numpy = "0.23"
 ffmpeg-sys-next = { version = "7.1", default-features = false, features = ["avcodec", "avformat", "swscale", "swresample"] }

{tensorcodec-0.1.2 → tensorcodec-0.1.3}/native/src/ffmpeg.rs

@@ -64,7 +64,7 @@ enum Reader {
 }
 unsafe extern "C" fn read_memory(opaque: *mut c_void, buffer: *mut u8, size: i32) -> i32 {
     if size <= 0 {
-        return -22;
+        return av::AVERROR(libc::EINVAL);
     }
     let reader = &mut *(opaque as *mut Reader);
     let input = match reader {
@@ -121,13 +121,13 @@ unsafe extern "C" fn seek_memory(opaque: *mut c_void, offset: i64, whence: i32)
         0 => 0,
         1 => input.position as i64,
         2 => input.data.len() as i64,
-        _ => return -22,
+        _ => return i64::from(av::AVERROR(libc::EINVAL)),
     };
     let Some(position) = base.checked_add(offset) else {
-        return -22;
+        return i64::from(av::AVERROR(libc::EINVAL));
     };
     if position < 0 || position > input.data.len() as i64 {
-        return -22;
+        return i64::from(av::AVERROR(libc::EINVAL));
     }
     input.position = position as usize;
     position
@@ -146,6 +146,7 @@ pub struct Decoder {
     index: i32,
     time_base: av::AVRational,
     audio: bool,
+    video_layout: (i32, i32, av::AVPixelFormat),
     draining: bool,
 }
 // SAFETY: all pointers are uniquely owned. PyO3's mutable borrow plus the Python
@@ -194,6 +195,7 @@ impl Decoder {
             index: 0,
             time_base: av::AVRational { num: 0, den: 1 },
             audio,
+            video_layout: (0, 0, av::AVPixelFormat::AV_PIX_FMT_NONE),
             draining: false,
         };
         unsafe {
@@ -276,6 +278,13 @@ impl Decoder {
             if (*params).codec_type != media_type {
                 return Err(Error("stream has the wrong media type".into(), true));
             }
+            if !audio {
+                this.video_layout = (
+                    (*params).width,
+                    (*params).height,
+                    std::mem::transmute::<i32, av::AVPixelFormat>((*params).format),
+                );
+            }
             this.time_base = (*stream).time_base;
             if this.time_base.den <= 0 || this.time_base.num <= 0 {
                 return Err(failure("invalid stream time base"));
@@ -336,7 +345,11 @@ impl Decoder {
         Ok(())
     }
 
-    pub fn metadata<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+    pub fn metadata<'py>(
+        &self,
+        py: Python<'py>,
+        apply_rotation: bool,
+    ) -> PyResult<Bound<'py, PyDict>> {
         let data = PyDict::new(py);
         unsafe {
             let stream = &*self.stream();
@@ -448,7 +461,8 @@ impl Decoder {
                     params.nb_coded_side_data,
                     av::AVPacketSideDataType::AV_PKT_DATA_DISPLAYMATRIX,
                 );
-                let rotation = if !side_data.is_null() && (*side_data).size >= 36 {
+                let rotation = if apply_rotation && !side_data.is_null() && (*side_data).size >= 36
+                {
                     let matrix = (*side_data).data as *const i32;
                     let determinant = *matrix as f64 * *matrix.add(4) as f64
                         - *matrix.add(1) as f64 * *matrix.add(3) as f64;
@@ -513,7 +527,7 @@ impl Decoder {
                 if code == av::AVERROR_EOF {
                     return Ok(false);
                 }
-                if code != -11 {
+                if code != av::AVERROR(libc::EAGAIN) {
                     check(code, "receive decoded frame")?;
                 }
                 if self.draining {
@@ -567,12 +581,31 @@ impl Decoder {
         if self.audio {
             return Err(failure("cannot decode video from audio stream"));
         }
+        let native = matches!(dtype, OutputDtype::Native);
+        let (width, height, source_format) = self.video_layout;
+        let (channels, dtype, big_endian) = if native {
+            use av::AVPixelFormat::*;
+            match source_format {
+                AV_PIX_FMT_GRAY8 => (1, OutputDtype::U8, false),
+                AV_PIX_FMT_GRAY12LE | AV_PIX_FMT_GRAY16LE => (1, OutputDtype::U16, false),
+                AV_PIX_FMT_GRAY16BE => (1, OutputDtype::U16, true),
+                AV_PIX_FMT_RGB24 => (3, OutputDtype::U8, false),
+                AV_PIX_FMT_RGBA => (4, OutputDtype::U8, false),
+                _ => {
+                    return Err(Error(
+                        "native output does not support this pixel format".into(),
+                        true,
+                    ))
+                }
+            }
+        } else {
+            (3, dtype, false)
+        };
         let high_depth = !matches!(dtype, OutputDtype::U8);
-        let width = unsafe { (*self.codec).width } as usize;
-        let height = unsafe { (*self.codec).height } as usize;
+        let (width, height) = (width as usize, height as usize);
         let count = width
             .checked_mul(height)
-            .and_then(|n| n.checked_mul(3))
+            .and_then(|n| n.checked_mul(channels))
             .ok_or_else(|| failure("frame is too large"))?;
         let total = count
             .checked_mul(targets.len())
@@ -627,106 +660,119 @@ impl Decoder {
                         return Err(failure("dynamic frame dimensions are unsupported"));
                     }
                     let input_format: av::AVPixelFormat = std::mem::transmute(frame.format);
-                    let output_format = if high_depth {
-                        av::AVPixelFormat::AV_PIX_FMT_RGB48LE
+                    let output_frame = if native {
+                        if input_format != source_format {
+                            return Err(Error("pixel format changed within stream".into(), true));
+                        }
+                        frame
                     } else {
-                        av::AVPixelFormat::AV_PIX_FMT_RGB24
-                    };
-                    let config = (
-                        frame.width,
-                        frame.height,
-                        input_format as i32,
-                        output_format as i32,
-                    );
-                    if self.scale_config != Some(config) {
-                        av::sws_freeContext(self.scale);
-                        self.scale = av::sws_getContext(
+                        let output_format = if high_depth {
+                            av::AVPixelFormat::AV_PIX_FMT_RGB48LE
+                        } else {
+                            av::AVPixelFormat::AV_PIX_FMT_RGB24
+                        };
+                        let config = (
                             frame.width,
                             frame.height,
-                            input_format,
-                            frame.width,
-                            frame.height,
-                            output_format,
-                            0,
-                            ptr::null_mut(),
-                            ptr::null_mut(),
-                            ptr::null(),
+                            input_format as i32,
+                            output_format as i32,
                         );
-                        self.scale_config = Some(config);
-                    }
-                    if self.scale.is_null() {
-                        return Err(failure("cannot initialize color conversion"));
-                    }
-                    let mut inverse = ptr::null_mut();
-                    let mut table = ptr::null_mut();
-                    let (
-                        mut source_range,
-                        mut destination_range,
-                        mut brightness,
-                        mut contrast,
-                        mut saturation,
-                    ) = (0, 0, 0, 0, 0);
-                    check(
-                        av::sws_getColorspaceDetails(
-                            self.scale,
-                            &mut inverse,
-                            &mut source_range,
-                            &mut table,
-                            &mut destination_range,
-                            &mut brightness,
-                            &mut contrast,
-                            &mut saturation,
-                        ),
-                        "read color conversion settings",
-                    )?;
-                    if frame.color_range != av::AVColorRange::AVCOL_RANGE_UNSPECIFIED {
-                        source_range =
-                            i32::from(frame.color_range == av::AVColorRange::AVCOL_RANGE_JPEG);
-                    }
-                    let coefficients = av::sws_getCoefficients(frame.colorspace as i32);
-                    check(
-                        av::sws_setColorspaceDetails(
-                            self.scale,
-                            coefficients,
-                            source_range,
-                            coefficients,
-                            destination_range,
-                            brightness,
-                            contrast,
-                            saturation,
-                        ),
-                        "configure color conversion",
-                    )?;
-                    if (*self.rgb_frame).width != frame.width
-                        || (*self.rgb_frame).height != frame.height
-                        || (*self.rgb_frame).format != output_format as i32
-                    {
-                        av::av_frame_unref(self.rgb_frame);
-                        (*self.rgb_frame).width = frame.width;
-                        (*self.rgb_frame).height = frame.height;
-                        (*self.rgb_frame).format = output_format as i32;
+                        if self.scale_config != Some(config) {
+                            av::sws_freeContext(self.scale);
+                            self.scale = av::sws_getContext(
+                                frame.width,
+                                frame.height,
+                                input_format,
+                                frame.width,
+                                frame.height,
+                                output_format,
+                                0,
+                                ptr::null_mut(),
+                                ptr::null_mut(),
+                                ptr::null(),
+                            );
+                            self.scale_config = Some(config);
+                        }
+                        if self.scale.is_null() {
+                            return Err(failure("cannot initialize color conversion"));
+                        }
+                        let mut inverse = ptr::null_mut();
+                        let mut table = ptr::null_mut();
+                        let (
+                            mut source_range,
+                            mut destination_range,
+                            mut brightness,
+                            mut contrast,
+                            mut saturation,
+                        ) = (0, 0, 0, 0, 0);
                         check(
-                            av::av_frame_get_buffer(self.rgb_frame, 32),
-                            "allocate RGB frame",
+                            av::sws_getColorspaceDetails(
+                                self.scale,
+                                &mut inverse,
+                                &mut source_range,
+                                &mut table,
+                                &mut destination_range,
+                                &mut brightness,
+                                &mut contrast,
+                                &mut saturation,
+                            ),
+                            "read color conversion settings",
                         )?;
+                        if frame.color_range != av::AVColorRange::AVCOL_RANGE_UNSPECIFIED {
+                            source_range =
+                                i32::from(frame.color_range == av::AVColorRange::AVCOL_RANGE_JPEG);
+                        }
+                        let coefficients = av::sws_getCoefficients(frame.colorspace as i32);
+                        check(
+                            av::sws_setColorspaceDetails(
+                                self.scale,
+                                coefficients,
+                                source_range,
+                                coefficients,
+                                destination_range,
+                                brightness,
+                                contrast,
+                                saturation,
+                            ),
+                            "configure color conversion",
+                        )?;
+                        if (*self.rgb_frame).width != frame.width
+                            || (*self.rgb_frame).height != frame.height
+                            || (*self.rgb_frame).format != output_format as i32
+                        {
+                            av::av_frame_unref(self.rgb_frame);
+                            (*self.rgb_frame).width = frame.width;
+                            (*self.rgb_frame).height = frame.height;
+                            (*self.rgb_frame).format = output_format as i32;
+                            check(
+                                av::av_frame_get_buffer(self.rgb_frame, 32),
+                                "allocate RGB frame",
+                            )?;
+                        }
+                        let rows = av::sws_scale(
+                            self.scale,
+                            frame.data.as_ptr() as *const *const u8,
+                            frame.linesize.as_ptr(),
+                            0,
+                            frame.height,
+                            (*self.rgb_frame).data.as_ptr(),
+                            (*self.rgb_frame).linesize.as_ptr(),
+                        );
+                        if rows != frame.height {
+                            return Err(failure("color conversion failed"));
+                        }
+                        &*self.rgb_frame
+                    };
+                    let row_bytes = width * channels * if high_depth { 2 } else { 1 };
+                    if output_frame.data[0].is_null()
+                        || (output_frame.linesize[0].unsigned_abs() as usize) < row_bytes
+                    {
+                        return Err(failure("invalid decoded frame stride"));
                     }
-                    let rows = av::sws_scale(
-                        self.scale,
-                        frame.data.as_ptr() as *const *const u8,
-                        frame.linesize.as_ptr(),
-                        0,
-                        frame.height,
-                        (*self.rgb_frame).data.as_ptr(),
-                        (*self.rgb_frame).linesize.as_ptr(),
-                    );
-                    if rows != frame.height {
-                        return Err(failure("color conversion failed"));
-                    }
-                    let row_bytes = width * 3 * if high_depth { 2 } else { 1 };
                     for row in 0..height {
                         ptr::copy_nonoverlapping(
-                            (*self.rgb_frame).data[0]
-                                .add(row * (*self.rgb_frame).linesize[0] as usize),
+                            output_frame.data[0]
+                                .offset(row as isize * output_frame.linesize[0] as isize),
                             pixels.as_mut_ptr().add(first * stride + row * row_bytes),
                             row_bytes,
                         );
@@ -760,10 +806,17 @@ impl Decoder {
                     .as_chunks::<2>()
                     .0
                     .iter()
-                    .map(|p| u16::from_le_bytes(*p))
+                    .map(|p| {
+                        if big_endian {
+                            u16::from_be_bytes(*p)
+                        } else {
+                            u16::from_le_bytes(*p)
+                        }
+                    })
                     .collect(),
             ),
             OutputDtype::U8 => Pixels::U8(pixels),
+            OutputDtype::Native => unreachable!(),
         };
         Ok(Video {
             pixels,
@@ -771,6 +824,7 @@ impl Decoder {
             durations,
             width,
             height,
+            channels,
         })
     }
 
@@ -881,6 +935,7 @@ pub enum Pixels {
     F32(Vec<f32>),
 }
 pub enum OutputDtype {
+    Native,
     U8,
     U16,
     F32,
@@ -891,6 +946,7 @@ pub struct Video {
     pub durations: Vec<f64>,
     pub width: usize,
     pub height: usize,
+    pub channels: usize,
 }
 pub struct Audio {
     pub data: Vec<f32>,