mcap-codec-support 0.2.0__tar.gz → 0.5.0__tar.gz

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mcap-codec-support
-Version: 0.2.0
+Version: 0.5.0
 Summary: Reusable MCAP encoder and decoder factories for robotics codecs
 Keywords: mcap,robotics,factories,video,pointcloud
 Author: Marko Bausch
@@ -17,14 +17,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Typing :: Typed
+Requires-Dist: small-mcap
 Requires-Dist: typing-extensions>=4.15.0
-Requires-Dist: mcap-codec-support[ros2,video,pointcloud,image,draco] ; extra == 'all'
+Requires-Dist: mcap-codec-support[ros2,video,pointcloud,draco] ; extra == 'all'
 Requires-Dist: dracopy>=1.7.0 ; extra == 'draco'
 Requires-Dist: mcap-ros2-support-fast ; extra == 'draco'
 Requires-Dist: numpy>=1.24.0 ; extra == 'draco'
 Requires-Dist: pointcloud2 ; extra == 'draco'
-Requires-Dist: mcap-codec-support[video] ; extra == 'image'
-Requires-Dist: imagecodecs>=2024.1.1 ; extra == 'image'
 Requires-Dist: mcap-ros2-support-fast ; extra == 'pointcloud'
 Requires-Dist: pureini ; extra == 'pointcloud'
 Requires-Dist: numpy>=1.24.0 ; extra == 'pointcloud'
@@ -32,13 +31,13 @@ Requires-Dist: pointcloud2 ; extra == 'pointcloud'
 Requires-Dist: mcap-ros2-support-fast ; extra == 'ros2'
 Requires-Dist: av>=12.0.0 ; extra == 'video'
 Requires-Dist: numpy>=1.24.0 ; extra == 'video'
+Requires-Dist: pillow>=10.0 ; extra == 'video'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/mrkbac/robotic-tools
 Project-URL: Issues, https://github.com/mrkbac/robotic-tools/issues
 Project-URL: Repository, https://github.com/mrkbac/robotic-tools
 Provides-Extra: all
 Provides-Extra: draco
-Provides-Extra: image
 Provides-Extra: pointcloud
 Provides-Extra: ros2
 Provides-Extra: video

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcap-codec-support"
-version = "0.2.0"
+version = "0.5.0"
 description = "Reusable MCAP encoder and decoder factories for robotics codecs"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,6 +22,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
+    "small-mcap",
     "typing-extensions>=4.15.0",
 ]
 
@@ -32,10 +33,9 @@ Issues = "https://github.com/mrkbac/robotic-tools/issues"
 
 [project.optional-dependencies]
 ros2 = ["mcap-ros2-support-fast"]
-video = ["av>=12.0.0", "numpy>=1.24.0"]
+video = ["av>=12.0.0", "numpy>=1.24.0", "pillow>=10.0"]
 pointcloud = ["mcap-ros2-support-fast", "pureini", "numpy>=1.24.0", "pointcloud2"]
-image = ["mcap-codec-support[video]", "imagecodecs>=2024.1.1"]
-all = ["mcap-codec-support[ros2,video,pointcloud,image,draco]"]
+all = ["mcap-codec-support[ros2,video,pointcloud,draco]"]
 draco = [
     "dracopy>=1.7.0",
     "mcap-ros2-support-fast",

mcap_codec_support-0.5.0/src/mcap_codec_support/_messages.py

@@ -0,0 +1,15 @@
+"""Shared TypedDict shapes for decoded ROS messages."""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class Stamp(TypedDict):
+    sec: int
+    nanosec: int
+
+
+class Header(TypedDict):
+    stamp: Stamp
+    frame_id: str

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/_protocols.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Protocol
 
 if TYPE_CHECKING:
-    import numpy as np
     from av import VideoFrame
     from small_mcap import DecodedMessage
 
@@ -18,6 +17,7 @@ class RawImageMessage(Protocol):
     width: int
     height: int
     encoding: str
+    step: int
     data: bytes
 
 
@@ -78,17 +78,3 @@ class VideoCompressionBackend(Protocol):
     ) -> VideoEncoderProtocol: ...
 
     def get_pix_fmt(self, topic: str) -> str | None: ...
-
-
-class VideoFileStrategy(Protocol):
-    """Strategy contract used by the lazy MP4 file writer."""
-
-    config: EncoderConfig
-
-    def write_compressed(self, data: bytes, log_time_ns: int) -> None: ...
-
-    def write_raw(self, data: bytes, log_time_ns: int) -> None: ...
-
-    def write_rgb(self, rgb: np.ndarray, log_time_ns: int) -> None: ...
-
-    def close(self) -> int: ...

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/pointcloud/__init__.py

@@ -13,6 +13,7 @@ from mcap_codec_support.pointcloud.factories import (
     CompressedPointCloudDecompressFactory,
     Pointcloud2DecoderFactory,
     PointCloudDecompressFactory,
+    is_compressed_codec_available,
 )
 from mcap_codec_support.pointcloud.schemas import (
     CLOUDINI_COMPRESSED_POINTCLOUD2,
@@ -42,4 +43,5 @@ __all__ = [
     "Pointcloud2DecoderFactory",
     "build_compressed_pointcloud2_message",
     "build_foxglove_compressed_pointcloud_message",
+    "is_compressed_codec_available",
 ]

mcap_codec_support-0.5.0/src/mcap_codec_support/pointcloud/_messages.py

@@ -0,0 +1,28 @@
+"""Pointcloud-specific TypedDict shapes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    from pointcloud2 import PointFieldDict
+
+    from mcap_codec_support._messages import Header
+
+
+class Pointcloud2Dict(TypedDict):
+    """Dict shape mirroring ``sensor_msgs/PointCloud2``.
+
+    Compatible with ``pointcloud2.read_points`` once wrapped in a
+    ``SimpleNamespace``.
+    """
+
+    header: Header
+    height: int
+    width: int
+    fields: list[PointFieldDict]
+    is_bigendian: bool
+    point_step: int
+    row_step: int
+    data: bytes
+    is_dense: bool

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/pointcloud/compression.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any, Protocol
 if TYPE_CHECKING:
     import numpy as np
     import numpy.typing as npt
-    from pointcloud2.messages import Pointcloud2Msg, PointFieldMsg
+    from pointcloud2 import Pointcloud2Msg, PointFieldMsg
     from pureini import CompressionOption, EncodingInfo, EncodingOptions
 
 DRACO_MAX_QUANTIZATION_BITS = 30

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/pointcloud/factories.py

@@ -21,11 +21,11 @@ if TYPE_CHECKING:
 
     import numpy as np
     from pointcloud2 import HeaderMsg, PointFieldDict, PointFieldMsg
-    from pointcloud2.messages import Stamp
     from pureini import PointcloudDecoder
     from small_mcap import Schema
 
-    from mcap_codec_support._messages import Header, Pointcloud2Dict
+    from mcap_codec_support._messages import Header, Stamp
+    from mcap_codec_support.pointcloud._messages import Pointcloud2Dict
 
 
 class _RosCompressedPointcloud2Msg(Protocol):
@@ -43,10 +43,15 @@ class _RosCompressedPointcloud2Msg(Protocol):
     compressed_data: bytes
 
 
+class _StampMsg(Protocol):
+    sec: int
+    nanosec: int
+
+
 class _FoxgloveCompressedPointcloudMsg(Protocol):
     """foxglove_msgs/msg/CompressedPointCloud — flattened header."""
 
-    timestamp: Stamp
+    timestamp: _StampMsg
     frame_id: str
     format: str | bytes
     data: bytes
@@ -58,6 +63,21 @@ _COMPRESSED_POINTCLOUD_SCHEMAS = {
 }
 
 
+def is_compressed_codec_available() -> bool:
+    """True if any compressed point-cloud codec backend (cloudini or draco) is importable."""
+    try:
+        import pureini  # noqa: F401, PLC0415
+    except ImportError:
+        pass
+    else:
+        return True
+    try:
+        import DracoPy  # noqa: F401, PLC0415
+    except ImportError:
+        return False
+    return True
+
+
 def _pointcloud_dict_to_array(cloud_dict: Pointcloud2Dict) -> np.ndarray:
     from pointcloud2 import read_points  # noqa: PLC0415
 
@@ -75,17 +95,20 @@ def _as_bytes(payload: bytes | bytearray | memoryview) -> bytes:
     return payload if isinstance(payload, bytes) else bytes(payload)
 
 
+def _stamp_from_msg(stamp: _StampMsg) -> Stamp:
+    return {"sec": stamp.sec, "nanosec": stamp.nanosec}
+
+
 def _header_from_ros_msg(msg: _RosCompressedPointcloud2Msg) -> Header:
-    stamp = msg.header.stamp
     return {
-        "stamp": {"sec": stamp.sec, "nanosec": stamp.nanosec},
+        "stamp": _stamp_from_msg(msg.header.stamp),
         "frame_id": msg.header.frame_id,
     }
 
 
 def _header_from_foxglove_msg(msg: _FoxgloveCompressedPointcloudMsg) -> Header:
     return {
-        "stamp": {"sec": msg.timestamp.sec, "nanosec": msg.timestamp.nanosec},
+        "stamp": _stamp_from_msg(msg.timestamp),
         "frame_id": msg.frame_id,
     }
 

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/video/__init__.py

@@ -17,10 +17,6 @@ from mcap_codec_support.video.compression import (
     prefetch_image_decodes,
 )
 from mcap_codec_support.video.factories import VideoDecompressFactory
-from mcap_codec_support.video.file_writer import (
-    VideoFileWriterSession,
-    create_video_file_writer,
-)
 from mcap_codec_support.video.schemas import (
     COMPRESSED_IMAGE,
     COMPRESSED_VIDEO_SCHEMA,
@@ -44,10 +40,8 @@ __all__ = [
     "VideoCompressionBackend",
     "VideoDecompressFactory",
     "VideoEncoderError",
-    "VideoFileWriterSession",
     "calculate_downscale_dimensions",
     "create_video_compression_backend",
-    "create_video_file_writer",
     "encode_raw_image_to_jpeg",
     "get_software_encoder",
     "prefetch_image_decodes",

mcap_codec_support-0.5.0/src/mcap_codec_support/video/_messages.py

@@ -0,0 +1,28 @@
+"""Video-specific TypedDict shapes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    from mcap_codec_support._messages import Header
+
+
+class CompressedImageDict(TypedDict):
+    """Dict shape mirroring ``sensor_msgs/CompressedImage``."""
+
+    header: Header
+    format: str
+    data: bytes
+
+
+class ImageDict(TypedDict):
+    """Dict shape mirroring ``sensor_msgs/Image`` for raw RGB frames."""
+
+    header: Header
+    height: int
+    width: int
+    encoding: str
+    is_bigendian: int
+    step: int
+    data: bytes

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/video/common.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable
 
     import numpy as np
+    from PIL.Image import Image as PILImage
 
     from mcap_codec_support._protocols import RawImageMessage
 
@@ -209,6 +210,34 @@ def raw_image_to_array(message: RawImageMessage) -> np.ndarray:
     raise VideoEncoderError(f"Unsupported image encoding: {message.encoding}")
 
 
+def raw_image_to_pil(message: RawImageMessage) -> PILImage:
+    """Convert a ROS Image message to a PIL ``Image`` (RGB)."""
+    try:
+        from PIL import Image  # noqa: PLC0415
+    except ImportError as exc:
+        raise VideoEncoderError(
+            "Pillow is required for raw image decoding. "
+            "Install with: uv add 'mcap-codec-support[video]'"
+        ) from exc
+
+    if not message.data:
+        raise VideoEncoderError("Image has no data")
+
+    width = message.width
+    height = message.height
+    encoding = str(message.encoding).lower()
+    data = bytes(message.data)
+
+    if encoding in {"rgb", "rgb8"}:
+        return Image.frombytes("RGB", (width, height), data)
+    if encoding in {"bgr", "bgr8"}:
+        return Image.frombytes("RGB", (width, height), data, "raw", "BGR")
+    if encoding in {"mono", "mono8", "8uc1"}:
+        return Image.frombytes("L", (width, height), data).convert("RGB")
+
+    raise VideoEncoderError(f"Unsupported image encoding: {message.encoding}")
+
+
 # ---------------------------------------------------------------------------
 # Encoder resolution
 # ---------------------------------------------------------------------------

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/video/compression.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import io
 from collections import deque
 from typing import TYPE_CHECKING, Any
 
@@ -13,16 +14,28 @@ from mcap_codec_support.video.common import (
     VideoEncoderError,
     calculate_downscale_dimensions,
     raw_image_to_array,
+    raw_image_to_pil,
 )
 from mcap_codec_support.video.schemas import COMPRESSED_SCHEMAS
 
+try:
+    from PIL.Image import Resampling as _Resampling
+
+    _PIL_BILINEAR = _Resampling.BILINEAR
+except ImportError:
+    _PIL_BILINEAR = None  # ``raw_image_to_pil`` raises if Pillow is missing.
+
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator
     from concurrent.futures import Future, ThreadPoolExecutor
 
     from small_mcap import DecodedMessage
 
-    from mcap_codec_support._protocols import VideoCompressionBackend, VideoDecompressorProtocol
+    from mcap_codec_support._protocols import (
+        RawImageMessage,
+        VideoCompressionBackend,
+        VideoDecompressorProtocol,
+    )
 
 
 class _PyAVCompressionBackend:
@@ -62,9 +75,12 @@ class _PyAVCompressionBackend:
         codec_name: str,
         quality: int,
         *,
-        input_pix_fmt: str | None = None,  # noqa: ARG002
-        scale: tuple[int, int] | None = None,  # noqa: ARG002
+        input_pix_fmt: str | None = None,
+        scale: tuple[int, int] | None = None,
     ) -> Any:
+        # PyAV reformats input frames per-frame inside VideoEncoder.encode, so
+        # the protocol's pix-fmt / scale knobs are FFmpeg-CLI-only.
+        del input_pix_fmt, scale
         from mcap_codec_support.video.pyav import VideoEncoder  # noqa: PLC0415
 
         return VideoEncoder(
@@ -190,30 +206,12 @@ def prefetch_image_decodes(
         yield buffer.popleft()
 
 
-def _encode_rgb_array_to_jpeg(rgb_array: Any, quality: int) -> bytes:
-    try:
-        import imagecodecs  # noqa: PLC0415
-    except ImportError as exc:
-        raise VideoEncoderError(
-            "imagecodecs is required for JPEG image encoding. "
-            "Install with: uv add 'mcap-codec-support[image]'"
-        ) from exc
-    return bytes(imagecodecs.jpeg_encode(rgb_array, level=quality))
-
-
-def _resize_rgb_array(rgb_array: Any, width: int, height: int) -> Any:
-    import av  # noqa: PLC0415
-
-    frame = av.VideoFrame.from_ndarray(rgb_array, format="rgb24")
-    return frame.reformat(width=width, height=height, format="rgb24").to_ndarray(format="rgb24")
-
-
 def encode_raw_image_to_jpeg(
-    decoded_message: Any, *, jpeg_quality: int, scale: int | None
+    decoded_message: RawImageMessage, *, jpeg_quality: int, scale: int | None
 ) -> tuple[bytes, int, int]:
-    """Encode a raw ROS Image message to JPEG using imagecodecs for final encode."""
-    rgb_array = raw_image_to_array(decoded_message)
-    src_h, src_w = rgb_array.shape[:2]
+    """Encode a raw ROS Image message to JPEG using Pillow."""
+    image = raw_image_to_pil(decoded_message)
+    src_w, src_h = image.size
     if scale is not None:
         target_w, target_h = calculate_downscale_dimensions(src_w, src_h, scale)
     else:
@@ -225,9 +223,11 @@ def encode_raw_image_to_jpeg(
         raise VideoEncoderError(f"Source frame too small ({target_w}x{target_h}) for JPEG encoding")
 
     if target_w != src_w or target_h != src_h:
-        rgb_array = _resize_rgb_array(rgb_array, target_w, target_h)
+        image = image.resize((target_w, target_h), _PIL_BILINEAR)
 
-    return _encode_rgb_array_to_jpeg(rgb_array, jpeg_quality), target_w, target_h
+    buf = io.BytesIO()
+    image.save(buf, format="JPEG", quality=jpeg_quality)
+    return buf.getvalue(), target_w, target_h
 
 
 def decode_compressed_image_to_rgb_array(data: bytes) -> Any:

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/video/factories.py

@@ -16,8 +16,9 @@ if TYPE_CHECKING:
 
     from small_mcap import Channel, Schema
 
-    from mcap_codec_support._messages import CompressedImageDict, Header, ImageDict
+    from mcap_codec_support._messages import Header
     from mcap_codec_support._protocols import VideoDecompressorProtocol
+    from mcap_codec_support.video._messages import CompressedImageDict, ImageDict
     from mcap_codec_support.video.common import DecompressedFrame
 
 

{mcap_codec_support-0.2.0 → mcap_codec_support-0.5.0}/src/mcap_codec_support/video/ffmpeg.py

@@ -6,7 +6,6 @@ All ``ffmpeg`` / ``ffprobe`` subprocess usage is confined to this module.
 
 from __future__ import annotations
 
-import contextlib
 import os
 import shutil
 import subprocess
@@ -790,155 +789,3 @@ class FFmpegVideoDecompressor:
                 self._process.wait(timeout=2)
         except Exception:  # noqa: BLE001, S110
             pass
-
-
-# ---------------------------------------------------------------------------
-# FFmpegMp4Encoder — raw RGB frames in via stdin, MP4 file out
-# ---------------------------------------------------------------------------
-
-
-class FFmpegMp4Encoder:
-    """Encode a stream of raw RGB frames to an MP4 file via ffmpeg subprocess.
-
-    Sibling of :class:`FFmpegVideoEncoder`, which emits raw Annex B bitstream
-    to stdout for in-MCAP ``CompressedVideo`` messages. This class instead
-    asks ffmpeg to mux into MP4 and write to disk directly — what the
-    ``video`` exporter wants when the user picks ``--mode ffmpeg-cli``.
-    """
-
-    def __init__(
-        self,
-        output_path: os.PathLike[str] | str,
-        *,
-        width: int,
-        height: int,
-        codec_name: str,
-        quality: int = 28,
-        target_fps: float = 30.0,
-        gop_size: int = 60,
-        input_pix_fmt: str | None = "rgb24",
-    ) -> None:
-        ffmpeg = _require_ffmpeg()
-
-        # Even dimensions required by yuv420p / common encoders.
-        width -= width % 2
-        height -= height % 2
-        if width < 2 or height < 2:
-            raise VideoEncoderError(f"Source frame too small ({width}x{height}) for video encoding")
-
-        if not check_encoder_cli(codec_name):
-            raise VideoEncoderError(
-                f"ffmpeg CLI does not support encoder {codec_name!r}. "
-                "Install a fuller ffmpeg build or pick a different --encoder backend."
-            )
-
-        options, bit_rate = build_encoder_options(codec_name, quality, width, height)
-        fps_int = max(round(target_fps), 1)
-
-        cmd: list[str] = [ffmpeg, "-hide_banner", "-loglevel", "error", "-y"]
-        if input_pix_fmt is None:
-            cmd.extend(["-f", "image2pipe", "-r", str(fps_int), "-i", "pipe:0"])
-        else:
-            cmd.extend(
-                [
-                    "-f",
-                    "rawvideo",
-                    "-pix_fmt",
-                    input_pix_fmt,
-                    "-s",
-                    f"{width}x{height}",
-                    "-r",
-                    str(fps_int),
-                    "-i",
-                    "pipe:0",
-                ]
-            )
-
-        if input_pix_fmt is None:
-            cmd.extend(["-vf", f"scale={width}:{height}"])
-
-        cmd.extend(
-            [
-                "-c:v",
-                codec_name,
-                "-pix_fmt",
-                "yuv420p",
-                "-g",
-                str(gop_size),
-                "-bf",
-                "0",
-            ]
-        )
-        if bit_rate is not None:
-            cmd.extend(["-b:v", str(bit_rate)])
-        for key, value in options.items():
-            cmd.extend([f"-{key}", value])
-
-        cmd.extend(["-movflags", "+faststart", "-f", "mp4", str(output_path)])
-
-        self._cmd = cmd
-        self.output_path = output_path
-        self.config = EncoderConfig(width=width, height=height, codec_name=codec_name)
-        self._stderr_lines: list[str] = []
-        self._frames_fed = 0
-
-        self._process = subprocess.Popen(  # noqa: S603 — args list, not shell
-            cmd,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.PIPE,
-        )
-
-        self._stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
-        self._stderr_thread.start()
-
-    def _read_stderr(self) -> None:
-        if self._process.stderr is None:
-            return
-        for raw in iter(self._process.stderr.readline, b""):
-            line = raw.decode("utf-8", errors="replace").rstrip()
-            if line:
-                self._stderr_lines.append(line)
-        self._process.stderr.close()
-
-    def write_frame(self, frame_bytes: bytes) -> None:
-        """Write one input frame to ffmpeg stdin."""
-        if self._process.stdin is None or self._process.stdin.closed:
-            raise VideoEncoderError("ffmpeg process stdin is closed")
-        try:
-            self._process.stdin.write(frame_bytes)
-        except BrokenPipeError as exc:
-            stderr_tail = "\n".join(self._stderr_lines[-5:])
-            raise VideoEncoderError(f"ffmpeg subprocess exited mid-stream:\n{stderr_tail}") from exc
-        self._frames_fed += 1
-
-    @property
-    def frames_fed(self) -> int:
-        return self._frames_fed
-
-    def close(self) -> None:
-        if self._process.poll() is not None and self._process.stdin is None:
-            return
-        if self._process.stdin and not self._process.stdin.closed:
-            with contextlib.suppress(BrokenPipeError):
-                self._process.stdin.close()
-        try:
-            self._process.wait(timeout=30)
-        except subprocess.TimeoutExpired:
-            self._process.kill()
-            self._process.wait(timeout=5)
-            raise VideoEncoderError("ffmpeg subprocess did not exit cleanly; killed") from None
-        self._stderr_thread.join(timeout=5)
-        if self._process.returncode != 0:
-            stderr_tail = "\n".join(self._stderr_lines[-10:])
-            raise VideoEncoderError(
-                f"ffmpeg exited with code {self._process.returncode}:\n{stderr_tail}"
-            )
-
-    def __del__(self) -> None:
-        try:
-            if self._process and self._process.poll() is None:
-                self._process.kill()
-                self._process.wait(timeout=2)
-        except Exception:  # noqa: BLE001, S110
-            pass

mcap_codec_support-0.2.0/src/mcap_codec_support/_messages.py

@@ -1,56 +0,0 @@
-"""Shared TypedDict shapes for decoded ROS messages."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, TypedDict
-
-if TYPE_CHECKING:
-    from pointcloud2 import PointFieldDict
-
-
-class Stamp(TypedDict):
-    sec: int
-    nanosec: int
-
-
-class Header(TypedDict):
-    stamp: Stamp
-    frame_id: str
-
-
-class Pointcloud2Dict(TypedDict):
-    """Dict shape mirroring ``sensor_msgs/PointCloud2``.
-
-    Compatible with ``pointcloud2.read_points`` once wrapped in a
-    ``SimpleNamespace``.
-    """
-
-    header: Header
-    height: int
-    width: int
-    fields: list[PointFieldDict]
-    is_bigendian: bool
-    point_step: int
-    row_step: int
-    data: bytes
-    is_dense: bool
-
-
-class CompressedImageDict(TypedDict):
-    """Dict shape mirroring ``sensor_msgs/CompressedImage``."""
-
-    header: Header
-    format: str
-    data: bytes
-
-
-class ImageDict(TypedDict):
-    """Dict shape mirroring ``sensor_msgs/Image`` for raw RGB frames."""
-
-    header: Header
-    height: int
-    width: int
-    encoding: str
-    is_bigendian: int
-    step: int
-    data: bytes

mcap_codec_support-0.2.0/src/mcap_codec_support/video/file_writer.py

@@ -1,411 +0,0 @@
-"""Lazy MP4 writer helpers for decoded image messages."""
-
-from __future__ import annotations
-
-from fractions import Fraction
-from typing import TYPE_CHECKING, Any, cast
-
-from mcap_codec_support.video.common import (
-    EncoderBackend,
-    EncoderConfig,
-    EncoderMode,
-    VideoCodec,
-    VideoEncoderError,
-    get_encoder_options,
-    raw_image_to_array,
-    resolve_encoder_for_backend,
-)
-from mcap_codec_support.video.compression import decode_compressed_image_to_rgb_array
-from mcap_codec_support.video.schemas import COMPRESSED_SCHEMAS, IMAGE_SCHEMAS, RAW_SCHEMAS
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from pathlib import Path
-
-    from mcap_codec_support._protocols import VideoFileStrategy
-
-
-_TARGET_BITRATE_BY_QUALITY: tuple[tuple[int, int], ...] = (
-    (20, 10_000_000),
-    (25, 5_000_000),
-    (10**6, 2_000_000),
-)
-
-
-def _bitrate_for(quality: int) -> int:
-    for threshold, bitrate in _TARGET_BITRATE_BY_QUALITY:
-        if quality <= threshold:
-            return bitrate
-    return _TARGET_BITRATE_BY_QUALITY[-1][1]
-
-
-_RAW_BYTES_PER_PIXEL: dict[str, int] = {
-    "rgb": 3,
-    "rgb8": 3,
-    "bgr": 3,
-    "bgr8": 3,
-    "mono": 1,
-    "mono8": 1,
-    "8uc1": 1,
-}
-
-
-def _pack_raw_image_bytes(decoded: Any, *, width: int, height: int) -> bytes:
-    """Pack raw ROS Image bytes to the exact frame size expected by ffmpeg."""
-    encoding = str(decoded.encoding).lower()
-    bytes_per_pixel = _RAW_BYTES_PER_PIXEL.get(encoding)
-    if bytes_per_pixel is None:
-        raise VideoEncoderError(f"Unsupported image encoding: {decoded.encoding}")
-
-    src_width = int(decoded.width)
-    src_height = int(decoded.height)
-    if width > src_width or height > src_height:
-        raise VideoEncoderError(
-            f"Cannot pack {src_width}x{src_height} frame as larger {width}x{height}"
-        )
-
-    src_row_bytes = src_width * bytes_per_pixel
-    dst_row_bytes = width * bytes_per_pixel
-    step = int(decoded.step)
-    if step < src_row_bytes:
-        raise VideoEncoderError(f"Image step {step} is smaller than row size {src_row_bytes}")
-
-    data = bytes(decoded.data)
-    required = step * src_height
-    if len(data) < required:
-        raise VideoEncoderError(f"Image data has {len(data)} bytes, expected at least {required}")
-
-    if width == src_width and height == src_height and step == dst_row_bytes:
-        return data
-
-    packed = bytearray(dst_row_bytes * height)
-    offset = 0
-    for row in range(height):
-        start = row * step
-        end = start + dst_row_bytes
-        packed[offset : offset + dst_row_bytes] = data[start:end]
-        offset += dst_row_bytes
-    return bytes(packed)
-
-
-class _PyAVMp4Strategy:
-    """In-process PyAV MP4 writer."""
-
-    def __init__(
-        self,
-        path: Path,
-        *,
-        codec: VideoCodec,
-        encoder_backend: EncoderBackend,
-        quality: int,
-        width: int,
-        height: int,
-    ) -> None:
-        import av  # noqa: PLC0415
-        import av.error  # noqa: PLC0415
-
-        from mcap_codec_support.video.pyav import resolve_encoder_for_backend  # noqa: PLC0415
-
-        self.path = path
-        self._codec = codec
-        self._quality = quality
-        self._encoder_name = resolve_encoder_for_backend(codec.value, encoder_backend.value)
-        self._first_timestamp_ns: int | None = None
-        self._last_pts = -1
-        self._frame_count = 0
-        self.config = EncoderConfig(width=width, height=height, codec_name=self._encoder_name)
-
-        container = av.open(str(path), "w", format=None, options={"movflags": "faststart"})
-        try:
-            stream = cast("Any", container.add_stream(codec_name=self._encoder_name))
-        except (av.error.FFmpegError, ValueError) as exc:
-            container.close()
-            raise VideoEncoderError(
-                f"Failed to create video stream with encoder '{self._encoder_name}': {exc}"
-            ) from exc
-
-        stream.width = width
-        stream.height = height
-        stream.pix_fmt = "yuv420p"
-        stream.time_base = Fraction(1, 1_000_000)
-        stream.codec_context.time_base = Fraction(1, 1_000_000)
-        stream.codec_context.framerate = Fraction(30, 1)
-        stream.codec_context.gop_size = 60
-        stream.codec_context.bit_rate = _bitrate_for(quality)
-
-        options = get_encoder_options(codec, self._encoder_name)
-        if any(s in self._encoder_name for s in ("libx264", "libx265", "videotoolbox")):
-            options["bf"] = "0"
-        stream.codec_context.options = options
-
-        self._container = container
-        self._stream = stream
-
-    def write_compressed(self, data: bytes, log_time_ns: int) -> None:
-        self.write_rgb(decode_compressed_image_to_rgb_array(data), log_time_ns)
-
-    def write_raw(self, data: bytes, log_time_ns: int) -> None:
-        del data, log_time_ns
-        raise VideoEncoderError("PyAV MP4 writer needs decoded RGB for raw frames")
-
-    def write_rgb(self, rgb: Any, log_time_ns: int) -> None:
-        import av  # noqa: PLC0415
-        import av.error  # noqa: PLC0415
-
-        if self._first_timestamp_ns is None:
-            self._first_timestamp_ns = log_time_ns
-
-        try:
-            frame = av.VideoFrame.from_ndarray(rgb, format="rgb24").reformat(format="yuv420p")
-        except (av.error.FFmpegError, ValueError) as exc:
-            raise VideoEncoderError(f"Frame conversion failed: {exc}") from exc
-
-        current_pts = (log_time_ns - self._first_timestamp_ns) // 1000
-        if current_pts <= self._last_pts:
-            current_pts = self._last_pts + 1
-        frame.pts = current_pts
-        self._last_pts = current_pts
-
-        try:
-            for packet in self._stream.encode(frame):
-                self._container.mux(packet)
-        except (av.error.FFmpegError, ValueError) as exc:
-            raise VideoEncoderError(
-                f"PyAV encoding failed at frame {self._frame_count}: {exc}"
-            ) from exc
-        self._frame_count += 1
-
-    def close(self) -> int:
-        for packet in self._stream.encode(None):
-            self._container.mux(packet)
-        self._container.close()
-        return self._frame_count
-
-
-class _FfmpegMp4Strategy:
-    """ffmpeg-subprocess MP4 writer."""
-
-    def __init__(
-        self,
-        path: Path,
-        *,
-        codec: VideoCodec,
-        encoder_backend: EncoderBackend,
-        quality: int,
-        width: int,
-        height: int,
-        input_pix_fmt: str | None,
-    ) -> None:
-        from mcap_codec_support.video.ffmpeg import (  # noqa: PLC0415
-            FFmpegMp4Encoder,
-            check_encoder_cli,
-        )
-
-        encoder_name = resolve_encoder_for_backend(
-            codec.value, encoder_backend.value, test_fn=check_encoder_cli
-        )
-        self._encoder = FFmpegMp4Encoder(
-            path,
-            width=width,
-            height=height,
-            codec_name=encoder_name,
-            quality=quality,
-            input_pix_fmt=input_pix_fmt,
-        )
-        self.config = self._encoder.config
-
-    def write_compressed(self, data: bytes, log_time_ns: int) -> None:
-        del log_time_ns
-        self._encoder.write_frame(data)
-
-    def write_raw(self, data: bytes, log_time_ns: int) -> None:
-        del log_time_ns
-        self._encoder.write_frame(data)
-
-    def write_rgb(self, rgb: Any, log_time_ns: int) -> None:
-        del log_time_ns
-        self._encoder.write_frame(rgb.tobytes())
-
-    def close(self) -> int:
-        frames = self._encoder.frames_fed
-        self._encoder.close()
-        return frames
-
-
-class VideoFileWriterSession:
-    """Lazy per-topic MP4 writer with unified backend selection."""
-
-    def __init__(
-        self,
-        path: Path,
-        *,
-        codec: VideoCodec,
-        encoder_backend: EncoderBackend,
-        quality: int,
-        mode: EncoderMode,
-        on_fallback: Callable[[str], None] | None = None,
-    ) -> None:
-        self.path = path
-        self._codec = codec
-        self._encoder_backend = encoder_backend
-        self._quality = quality
-        self._mode = mode
-        self._on_fallback = on_fallback
-        self._strategy: VideoFileStrategy | None = None
-        self._input_kind: str | None = None
-
-    def write_message(self, decoded: Any, schema_name: str, log_time_ns: int) -> None:
-        if schema_name not in IMAGE_SCHEMAS:
-            raise VideoEncoderError(f"Unexpected image schema {schema_name!r}")
-
-        if schema_name in COMPRESSED_SCHEMAS:
-            data = bytes(decoded.data)
-            first_rgb = self._ensure_open_for_compressed(data)
-            assert self._strategy is not None
-            if self._input_kind == "pyav":
-                rgb = (
-                    first_rgb
-                    if first_rgb is not None
-                    else decode_compressed_image_to_rgb_array(data)
-                )
-                self._strategy.write_rgb(rgb, log_time_ns)
-            else:
-                self._strategy.write_compressed(data, log_time_ns)
-            return
-
-        if schema_name in RAW_SCHEMAS:
-            first_rgb = self._ensure_open_for_raw(decoded)
-            assert self._strategy is not None
-            if self._input_kind == "pyav":
-                rgb = first_rgb if first_rgb is not None else raw_image_to_array(decoded)
-                self._strategy.write_rgb(rgb, log_time_ns)
-            else:
-                data = _pack_raw_image_bytes(
-                    decoded,
-                    width=self._strategy.config.width,
-                    height=self._strategy.config.height,
-                )
-                self._strategy.write_raw(data, log_time_ns)
-            return
-
-        raise VideoEncoderError(f"Unexpected image schema {schema_name!r}")
-
-    def _ensure_open_for_compressed(self, data: bytes) -> Any | None:
-        return self._open_with_fallback(
-            decode_pyav=lambda: decode_compressed_image_to_rgb_array(data),
-            open_ffmpeg=lambda: self._open_ffmpeg_compressed(data),
-        )
-
-    def _ensure_open_for_raw(self, decoded: Any) -> Any | None:
-        return self._open_with_fallback(
-            decode_pyav=lambda: raw_image_to_array(decoded),
-            open_ffmpeg=lambda: self._open_ffmpeg_raw(decoded),
-        )
-
-    def _open_with_fallback(
-        self,
-        *,
-        decode_pyav: Callable[[], Any],
-        open_ffmpeg: Callable[[], None],
-    ) -> Any | None:
-        if self._strategy is not None:
-            return None
-
-        if self._mode is EncoderMode.FFMPEG_CLI:
-            open_ffmpeg()
-            return None
-
-        try:
-            rgb = decode_pyav()
-            height, width = rgb.shape[:2]
-            self._open_pyav(width, height)
-        except (ImportError, VideoEncoderError) as exc:
-            if self._mode is EncoderMode.PYAV:
-                raise
-            if self._on_fallback is not None:
-                self._on_fallback(
-                    f"PyAV failed to open encoder ({exc}); falling back to ffmpeg-cli."
-                )
-            open_ffmpeg()
-            return None
-        return rgb
-
-    def _open_pyav(self, width: int, height: int) -> None:
-        width, height = _even_dimensions(width, height)
-        self._strategy = _PyAVMp4Strategy(
-            self.path,
-            codec=self._codec,
-            encoder_backend=self._encoder_backend,
-            quality=self._quality,
-            width=width,
-            height=height,
-        )
-        self._input_kind = "pyav"
-
-    def _open_ffmpeg_compressed(self, data: bytes) -> None:
-        from mcap_codec_support.video.ffmpeg import probe_image_dimensions  # noqa: PLC0415
-
-        width, height = probe_image_dimensions(data)
-        width, height = _even_dimensions(width, height)
-        self._strategy = _FfmpegMp4Strategy(
-            self.path,
-            codec=self._codec,
-            encoder_backend=self._encoder_backend,
-            quality=self._quality,
-            width=width,
-            height=height,
-            input_pix_fmt=None,
-        )
-        self._input_kind = "ffmpeg"
-
-    def _open_ffmpeg_raw(self, decoded: Any) -> None:
-        from mcap_codec_support.video.ffmpeg import ROS_ENCODING_TO_PIX_FMT  # noqa: PLC0415
-
-        encoding = str(decoded.encoding).lower()
-        pix_fmt = ROS_ENCODING_TO_PIX_FMT.get(encoding)
-        if not pix_fmt:
-            raise VideoEncoderError(f"Unsupported image encoding: {decoded.encoding}")
-        width, height = _even_dimensions(decoded.width, decoded.height)
-        self._strategy = _FfmpegMp4Strategy(
-            self.path,
-            codec=self._codec,
-            encoder_backend=self._encoder_backend,
-            quality=self._quality,
-            width=width,
-            height=height,
-            input_pix_fmt=pix_fmt,
-        )
-        self._input_kind = "ffmpeg"
-
-    def close(self) -> int:
-        if self._strategy is None:
-            return 0
-        return self._strategy.close()
-
-
-def _even_dimensions(width: int, height: int) -> tuple[int, int]:
-    width -= width % 2
-    height -= height % 2
-    if width < 2 or height < 2:
-        raise VideoEncoderError(f"Source frame too small ({width}x{height}) for video encoding")
-    return width, height
-
-
-def create_video_file_writer(
-    path: Path,
-    *,
-    codec: VideoCodec,
-    encoder_backend: EncoderBackend,
-    quality: int,
-    mode: EncoderMode,
-    on_fallback: Callable[[str], None] | None = None,
-) -> VideoFileWriterSession:
-    """Create a lazy MP4 writer session."""
-    return VideoFileWriterSession(
-        path,
-        codec=codec,
-        encoder_backend=encoder_backend,
-        quality=quality,
-        mode=mode,
-        on_fallback=on_fallback,
-    )