vspackrgb 1.0.0__cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl

vspackrgb/__init__.py

@@ -0,0 +1,7 @@
+"""RGB packing for VapourSynth frames."""
+
+from __future__ import annotations
+
+from .helpers import packrgb
+
+__all__ = ["packrgb"]

vspackrgb/cython.pyi

@@ -0,0 +1,22 @@
+import ctypes
+
+def pack_bgra_8bit(
+    b_data: ctypes.Array[ctypes.c_uint8],
+    g_data: ctypes.Array[ctypes.c_uint8],
+    r_data: ctypes.Array[ctypes.c_uint8],
+    width: int,
+    height: int,
+    src_stride: int,
+    dest_ptr: int,
+    dest_stride: int,
+) -> None: ...
+def pack_rgb30_10bit(
+    r_data: ctypes.Array[ctypes.c_uint16],
+    g_data: ctypes.Array[ctypes.c_uint16],
+    b_data: ctypes.Array[ctypes.c_uint16],
+    width: int,
+    height: int,
+    samples_per_row: int,
+    dest_ptr: int,
+    dest_stride: int,
+) -> None: ...

vspackrgb/helpers.py

@@ -0,0 +1,149 @@
+"""VapourSynth frame packing helpers."""
+
+import ctypes
+from collections.abc import Callable
+from typing import Literal, Protocol, overload
+
+import vapoursynth as vs
+
+from . import cython, numpy, python
+
+
+def packrgb(clip: vs.VideoNode, backend: Literal["cython", "numpy", "python"] = "cython") -> vs.VideoNode:
+    """
+    Pack a planar RGB clip into a display-ready format.
+
+    Converts RGB24 to interleaved BGRA (32-bit) or RGB30 to packed RGB30 (10-bit per channel) format,
+    stored in a GRAY32 clip
+
+    Args:
+        clip: Input clip in RGB24 or RGB30 format.
+        backend: Packing backend ("cython", "numpy", "python"). "python" is *very* slow.
+
+    Returns:
+        GRAY32 clip with packed pixel data.
+
+    Raises:
+        ValueError: If format or backend is unsupported or resolution is variable.
+    """
+    if 0 in [clip.width, clip.height]:
+        raise ValueError("Variable resolution clips are not supported")
+
+    match clip.format.id, backend:
+        case (vs.RGB24, "cython"):
+            pack_fn = _make_pack_frame_8bit(cython.pack_bgra_8bit)
+        case (vs.RGB24, "numpy"):
+            pack_fn = _make_pack_frame_8bit(numpy.pack_bgra_8bit)
+        case (vs.RGB24, "python"):
+            pack_fn = _make_pack_frame_8bit(python.pack_bgra_8bit)
+        case (vs.RGB30, "cython"):
+            pack_fn = _make_pack_frame_10bit(cython.pack_rgb30_10bit)
+        case (vs.RGB30, "numpy"):
+            pack_fn = _make_pack_frame_10bit(numpy.pack_rgb30_10bit)
+        case (vs.RGB30, "python"):
+            pack_fn = _make_pack_frame_10bit(python.pack_rgb30_10bit)
+        case _:
+            raise ValueError("Unsupported input format or backend")
+
+    blank = clip.std.BlankClip(format=vs.GRAY32, keep=True)
+
+    return vs.core.std.ModifyFrame(blank, [clip, blank], pack_fn)
+
+
+class _ModifyFrameFunction(Protocol):
+    def __call__(self, *, n: int, f: list[vs.VideoFrame]) -> vs.VideoFrame: ...
+
+
+def _make_pack_frame_8bit(pack_bgra_8bit: Callable[..., None]) -> _ModifyFrameFunction:
+    def _pack_frame(n: int, f: list[vs.VideoFrame]) -> vs.VideoFrame:
+        frame_src, frame_dst = f[0], f[1].copy()
+
+        width, height = frame_src.width, frame_src.height
+        src_stride = frame_src.get_stride(0)
+        dst_stride = frame_dst.get_stride(0)
+        dst_ptr = frame_dst.get_write_ptr(0).value
+
+        if dst_ptr is None:
+            raise ValueError("Destination frame pointer is NULL")
+
+        b_plane = get_plane_buffer(frame_src, 2)
+        g_plane = get_plane_buffer(frame_src, 1)
+        r_plane = get_plane_buffer(frame_src, 0)
+
+        pack_bgra_8bit(b_plane, g_plane, r_plane, width, height, src_stride, dst_ptr, dst_stride)
+
+        return frame_dst
+
+    return _pack_frame
+
+
+def _make_pack_frame_10bit(pack_rgb30_10bit: Callable[..., None]) -> _ModifyFrameFunction:
+    def _pack_frame(n: int, f: list[vs.VideoFrame]) -> vs.VideoFrame:
+        frame_src, frame_dst = f[0], f[1].copy()
+
+        width, height = frame_src.width, frame_src.height
+        src_stride = frame_src.get_stride(0)
+        samples_per_row = src_stride // 2
+        dst_stride = frame_dst.get_stride(0)
+        dst_ptr = frame_dst.get_write_ptr(0).value
+
+        if dst_ptr is None:
+            raise ValueError("Destination frame pointer is NULL")
+
+        r_plane = get_plane_buffer(frame_src, 0, bytes_per_sample=2)
+        g_plane = get_plane_buffer(frame_src, 1, bytes_per_sample=2)
+        b_plane = get_plane_buffer(frame_src, 2, bytes_per_sample=2)
+
+        pack_rgb30_10bit(r_plane, g_plane, b_plane, width, height, samples_per_row, dst_ptr, dst_stride)
+
+        return frame_dst
+
+    return _pack_frame
+
+
+@overload
+def get_plane_buffer(
+    frame: vs.VideoFrame, plane: int, bytes_per_sample: Literal[1] = 1
+) -> ctypes.Array[ctypes.c_uint8]: ...
+
+
+@overload
+def get_plane_buffer(
+    frame: vs.VideoFrame, plane: int, bytes_per_sample: Literal[2]
+) -> ctypes.Array[ctypes.c_uint16]: ...
+
+
+def get_plane_buffer(
+    frame: vs.VideoFrame, plane: int, bytes_per_sample: int = 1
+) -> ctypes.Array[ctypes.c_uint8] | ctypes.Array[ctypes.c_uint16]:
+    """
+    Get a ctypes array from a VideoFrame plane.
+
+    Args:
+        frame: VideoFrame to read from.
+        plane: Plane index (0=R, 1=G, 2=B for RGB).
+        bytes_per_sample: 1 for 8-bit, 2 for 10/16-bit.
+
+    Returns:
+        ctypes array of the plane's pixel data.
+
+    Raises:
+        ValueError: If pointer is NULL or bytes_per_sample invalid.
+    """
+    stride = frame.get_stride(plane)
+    height = frame.height
+    ptr = frame.get_read_ptr(plane)
+
+    if (ptr_val := ptr.value) is None:
+        raise ValueError(f"Plane {plane} pointer is NULL")
+
+    buf_size = stride * height
+
+    if bytes_per_sample == 1:
+        c_buffer = (ctypes.c_uint8 * buf_size).from_address(ptr_val)
+    elif bytes_per_sample == 2:
+        c_buffer = (ctypes.c_uint16 * (buf_size // 2)).from_address(ptr_val)
+    else:
+        raise ValueError(f"Unsupported bytes_per_sample: {bytes_per_sample}")
+
+    return c_buffer

vspackrgb/numpy.py

@@ -0,0 +1,70 @@
+"""NumPy-accelerated RGB packing functions."""
+
+import ctypes
+
+
+def pack_bgra_8bit(
+    b_data: ctypes.Array[ctypes.c_uint8],
+    g_data: ctypes.Array[ctypes.c_uint8],
+    r_data: ctypes.Array[ctypes.c_uint8],
+    width: int,
+    height: int,
+    src_stride: int,
+    dest_ptr: int,
+    dest_stride: int,
+) -> None:
+    """Pack planar 8-bit RGB to interleaved BGRA, writing to dest buffer."""
+    import numpy as np
+
+    b_arr = np.frombuffer(b_data, dtype=np.uint8).reshape((height, src_stride))[:, :width]
+    g_arr = np.frombuffer(g_data, dtype=np.uint8).reshape((height, src_stride))[:, :width]
+    r_arr = np.frombuffer(r_data, dtype=np.uint8).reshape((height, src_stride))[:, :width]
+
+    bgra = np.empty((height, width, 4), dtype=np.uint8)
+    bgra[:, :, 0] = b_arr
+    bgra[:, :, 1] = g_arr
+    bgra[:, :, 2] = r_arr
+    bgra[:, :, 3] = 255  # Full alpha
+
+    out = (ctypes.c_uint8 * (dest_stride * height)).from_address(dest_ptr)
+    out_arr = np.frombuffer(out, dtype=np.uint8).reshape((height, dest_stride))
+
+    row_bytes = width * 4
+    out_arr[:, :row_bytes] = bgra.reshape((height, row_bytes))
+
+
+def pack_rgb30_10bit(
+    r_data: ctypes.Array[ctypes.c_uint16],
+    g_data: ctypes.Array[ctypes.c_uint16],
+    b_data: ctypes.Array[ctypes.c_uint16],
+    width: int,
+    height: int,
+    samples_per_row: int,
+    dest_ptr: int,
+    dest_stride: int,
+) -> None:
+    """Pack planar 10-bit RGB to RGB30 (0xC0RRGGBB), writing to dest buffer."""
+    import numpy as np
+
+    r_arr = np.frombuffer(r_data, dtype=np.uint16).reshape((height, samples_per_row))[:, :width]
+    g_arr = np.frombuffer(g_data, dtype=np.uint16).reshape((height, samples_per_row))[:, :width]
+    b_arr = np.frombuffer(b_data, dtype=np.uint16).reshape((height, samples_per_row))[:, :width]
+
+    dest_samples_per_row = dest_stride // 4
+    out = (ctypes.c_uint32 * (dest_samples_per_row * height)).from_address(dest_ptr)
+    out_arr = np.frombuffer(out, dtype=np.uint32).reshape((height, dest_samples_per_row))
+    out_view = out_arr[:, :width]
+
+    # Pack into RGB30: high 2 bits = 0b11 (alpha), R(10) | G(10) | B(10)
+    temp = np.empty((height, width), dtype=np.uint32)
+
+    # R << 20 into temp, then add alpha mask
+    np.left_shift(r_arr, 20, out=temp, dtype=np.uint32)
+    temp |= 0xC0000000
+
+    # G << 10, add to temp
+    np.left_shift(g_arr, 10, out=out_view, dtype=np.uint32)
+    temp |= out_view
+
+    # B (just cast) and final OR into output
+    np.add(temp, b_arr, out=out_view, dtype=np.uint32)

vspackrgb/python.py

@@ -0,0 +1,53 @@
+"""Pure Python RGB packing (reference only, too slow for real-time)."""
+
+import ctypes
+
+
+def pack_bgra_8bit(
+    b_data: ctypes.Array[ctypes.c_uint8],
+    g_data: ctypes.Array[ctypes.c_uint8],
+    r_data: ctypes.Array[ctypes.c_uint8],
+    width: int,
+    height: int,
+    src_stride: int,
+    dest_ptr: int,
+    dest_stride: int,
+) -> None:
+    """Pack planar 8-bit RGB to interleaved BGRA, writing to dest buffer."""
+    out = (ctypes.c_uint8 * (dest_stride * height)).from_address(dest_ptr)
+
+    for y in range(height):
+        src_row = y * src_stride
+        dst_row = y * dest_stride
+
+        for x in range(width):
+            dst_offset = dst_row + x * 4
+            out[dst_offset + 0] = b_data[src_row + x]
+            out[dst_offset + 1] = g_data[src_row + x]
+            out[dst_offset + 2] = r_data[src_row + x]
+            out[dst_offset + 3] = 255
+
+
+def pack_rgb30_10bit(
+    r_data: ctypes.Array[ctypes.c_uint16],
+    g_data: ctypes.Array[ctypes.c_uint16],
+    b_data: ctypes.Array[ctypes.c_uint16],
+    width: int,
+    height: int,
+    samples_per_row: int,
+    dest_ptr: int,
+    dest_stride: int,
+) -> None:
+    """Pack planar 10-bit RGB to RGB30 (0xC0RRGGBB), writing to dest buffer."""
+    out = (ctypes.c_uint32 * ((dest_stride // 4) * height)).from_address(dest_ptr)
+    dest_samples_per_row = dest_stride // 4
+
+    for y in range(height):
+        src_row = y * samples_per_row
+        dst_row = y * dest_samples_per_row
+
+        for x in range(width):
+            r = r_data[src_row + x]
+            g = g_data[src_row + x]
+            b = b_data[src_row + x]
+            out[dst_row + x] = 0xC0000000 | (r << 20) | (g << 10) | b

vspackrgb-1.0.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: vspackrgb
+Version: 1.0.0
+Summary: RGB packing for VapourSynth frames
+Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/vs-view/tree/main/src/vspackrgb
+Project-URL: Bug Tracker, https://github.com/Jaded-Encoding-Thaumaturgy/vs-view/issues
+Project-URL: Contact, https://discord.gg/XTpc6Fa9eB
+License: MIT License
+        
+        Copyright (c) 2026 Jaded Encoding Thaumaturgy
+        
+        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.
+License-File: LICENSE
+Keywords: aarch64,arm,arm64,cython,packing,rgb,vapoursynth
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: vapoursynth
+Provides-Extra: numpy
+Requires-Dist: numpy>=2.0.0; extra == 'numpy'
+Description-Content-Type: text/markdown
+
+# vspackrgb
+
+RGB packing for VapourSynth frames.
+
+Converts planar RGB VapourSynth clips into display-ready packed formats:
+
+- **RGB24 → BGRA** (8-bit interleaved)
+- **RGB30 → RGB30** (10-bit packed, 2-bit alpha)
+
+Output is stored in a GRAY32 clip.
+
+## Benchmarks
+
+### Blank clip with `keep=True`
+
+```
+             RGB24 Packing (1920x1080)
+┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
+┃ Backend            ┃ Frames ┃    Time ┃     FPS ┃
+┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
+│ vszip.PackRGB      │   6000 │  2.186s │ 2745.14 │
+│ libp2p.Pack        │   6000 │  2.867s │ 2092.89 │
+│ akarin.Expr        │   6000 │  2.802s │ 2141.23 │
+│ vspackrgb (cython) │   6000 │  8.998s │  666.84 │
+│ vspackrgb (numpy)  │   6000 │ 20.182s │  297.30 │
+│ vspackrgb (python) │     30 │ 13.706s │    2.19 │
+└────────────────────┴────────┴─────────┴─────────┘
+
+             RGB30 Packing (1920x1080)
+┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
+┃ Backend            ┃ Frames ┃    Time ┃     FPS ┃
+┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
+│ vszip.PackRGB      │   6000 │  2.842s │ 2111.21 │
+│ libp2p.Pack        │   6000 │  2.817s │ 2129.78 │
+│ akarin.Expr        │   6000 │  2.866s │ 2093.62 │
+│ vspackrgb (cython) │   6000 │  8.750s │  685.72 │
+│ vspackrgb (numpy)  │   6000 │ 30.640s │  195.83 │
+│ vspackrgb (python) │     30 │ 11.968s │    2.51 │
+└────────────────────┴────────┴─────────┴─────────┘
+```
+
+### Real world scenario
+
+```
+            RGB24 Packing (1920x1080)
+┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┳━━━━━━━━┓
+┃ Backend            ┃ Frames ┃    Time ┃    FPS ┃
+┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━╇━━━━━━━━┩
+│ vszip.PackRGB      │   6000 │  8.623s │ 695.79 │
+│ libp2p.Pack        │   6000 │  9.450s │ 634.93 │
+│ akarin.Expr        │   6000 │  9.395s │ 638.65 │
+│ vspackrgb (cython) │   6000 │ 12.231s │ 490.57 │
+│ vspackrgb (numpy)  │   6000 │ 23.421s │ 256.18 │
+│ vspackrgb (python) │     30 │ 13.840s │   2.17 │
+└────────────────────┴────────┴─────────┴────────┘
+
+            RGB30 Packing (1920x1080)
+┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┳━━━━━━━━┓
+┃ Backend            ┃ Frames ┃    Time ┃    FPS ┃
+┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━╇━━━━━━━━┩
+│ vszip.PackRGB      │   6000 │ 10.623s │ 564.79 │
+│ libp2p.Pack        │   6000 │ 10.874s │ 551.77 │
+│ akarin.Expr        │   6000 │ 10.655s │ 563.13 │
+│ vspackrgb (cython) │   6000 │ 13.503s │ 444.35 │
+│ vspackrgb (numpy)  │   6000 │ 36.062s │ 166.38 │
+│ vspackrgb (python) │     30 │ 12.055s │   2.49 │
+└────────────────────┴────────┴─────────┴────────┘
+
+```

vspackrgb-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+vspackrgb/__init__.py,sha256=wfzPuwYQr1jStRk896mp8u6TgrSprAnsas78wXLXRkM,131
+vspackrgb/cython.cpython-314-x86_64-linux-gnu.so,sha256=HHxEBkBkKA2Pk-qE3_cvM06ojh0EFSgKv9z__sY9d1Q,1571056
+vspackrgb/cython.pyi,sha256=NrJkV9M1SfJ5QWjQtIPsNNLxUz2hP7QFt2YddBqB198,537
+vspackrgb/helpers.py,sha256=XSUtzMrclKS3vjN7iR42_mtntqzC3UHFc2gOpOpuDUU,4984
+vspackrgb/numpy.py,sha256=lJjYNhFiY8ibgneygW-gsZC_R5hU-3-qSrqdG1gCaqk,2485
+vspackrgb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vspackrgb/python.py,sha256=Sj7thHtXX69biSarMawtPqYqqh0m8ZU-lgn3hJ00QEI,1653
+vspackrgb-1.0.0.dist-info/METADATA,sha256=wgAgNH5Qt3d_dsmssBr_2LJp0G2B4ifM8nFkKM2O1hw,6314
+vspackrgb-1.0.0.dist-info/WHEEL,sha256=nEHiLHY71DlJuQytFfdiSsqM8nj_w2dKX7OfeVPo0ho,187
+vspackrgb-1.0.0.dist-info/RECORD,,
+vspackrgb-1.0.0.dist-info/licenses/LICENSE,sha256=Am5mgDbqE74Pmbmv59-OsvKODDcWpkVPUdaXhhj5CdI,1083

vspackrgb-1.0.0.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_17_x86_64
+Tag: cp314-cp314-manylinux2014_x86_64
+Tag: cp314-cp314-manylinux_2_28_x86_64
+

vspackrgb-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jaded Encoding Thaumaturgy
+
+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.