fix(m4): retain compact obstacle evidence
This commit is contained in:
DCCONSTRUCTIONS
@@ -0,0 +1,314 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import struct
|
||||
import subprocess
|
||||
import threading
|
||||
from contextlib import suppress
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
from .media import RecordedMediaEpoch, RecordedMediaInspector, RecordedMediaManifest
|
||||
from .models import SessionIntegrityError
|
||||
from .store import SessionStore
|
||||
|
||||
_MAX_KEYFRAME_DISTANCE = 120
|
||||
_FFMPEG_TIMEOUT_SECONDS = 15.0
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RecordedCameraFrame:
|
||||
payload: bytes
|
||||
media_type: str
|
||||
width: int
|
||||
height: int
|
||||
sha256: str
|
||||
|
||||
|
||||
class RecordedCameraFrameService:
|
||||
"""Decode one exact archived camera frame without preparing the full video.
|
||||
|
||||
Canonical camera archives contain one video sample per fMP4 fragment. The
|
||||
service validates the sealed manifest, walks back only to the preceding IDR
|
||||
fragment and gives that bounded GOP to ffmpeg. This keeps CAMERA review
|
||||
independent from the 4489-row VIDEO overlay and full-player preparation.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
store: SessionStore,
|
||||
inspector: RecordedMediaInspector,
|
||||
*,
|
||||
ffmpeg_path: Path,
|
||||
cache_root: Path,
|
||||
) -> None:
|
||||
resolved_ffmpeg = ffmpeg_path.expanduser().resolve(strict=True)
|
||||
if not resolved_ffmpeg.is_file() or not os.access(resolved_ffmpeg, os.X_OK):
|
||||
raise SessionIntegrityError("ffmpeg is unavailable for camera frame review")
|
||||
self._store = store
|
||||
self._inspector = inspector
|
||||
self._ffmpeg_path = resolved_ffmpeg
|
||||
self._cache_root = cache_root.expanduser().absolute()
|
||||
self._cache_root.mkdir(parents=True, exist_ok=True)
|
||||
if self._cache_root.is_symlink() or not self._cache_root.is_dir():
|
||||
raise SessionIntegrityError("camera frame cache root is invalid")
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def extract(
|
||||
self,
|
||||
session_id: str,
|
||||
frame_index: int,
|
||||
*,
|
||||
expected_source_name: str = "sensor.camera.right",
|
||||
) -> RecordedCameraFrame:
|
||||
if frame_index < 0:
|
||||
raise SessionIntegrityError("camera frame index is invalid")
|
||||
replay = self._store.prepare_replay(session_id, speed=1.0, loop=False)
|
||||
matches = tuple(
|
||||
artifact
|
||||
for artifact in self._store.list_recorded_media(session_id)
|
||||
if artifact.source_path.name == expected_source_name
|
||||
)
|
||||
if len(matches) != 1:
|
||||
raise SessionIntegrityError("recorded camera source is unavailable")
|
||||
artifact = matches[0]
|
||||
manifest = self._inspector.inspect(artifact, replay)
|
||||
epoch, sequence = _frame_location(manifest, frame_index)
|
||||
cache_key = hashlib.sha256(
|
||||
(
|
||||
f"{manifest.generation_sha256}\0{artifact.artifact_id}\0"
|
||||
f"{expected_source_name}\0{frame_index}\0jpeg-q2-v1"
|
||||
).encode()
|
||||
).hexdigest()
|
||||
cache_path = self._cache_root / f"{cache_key}.jpg"
|
||||
|
||||
with self._lock:
|
||||
cached = _read_cached_jpeg(cache_path)
|
||||
if cached is not None:
|
||||
return cached
|
||||
frame = self._decode(manifest, epoch, sequence)
|
||||
_publish_cached_jpeg(cache_path, frame.payload)
|
||||
return frame
|
||||
|
||||
def _decode(
|
||||
self,
|
||||
manifest: RecordedMediaManifest,
|
||||
epoch: RecordedMediaEpoch,
|
||||
sequence: int,
|
||||
) -> RecordedCameraFrame:
|
||||
target = self._inspector.get_segment(manifest, epoch.ordinal, sequence)
|
||||
fragments: list[bytes] = [target.payload]
|
||||
key_sequence = sequence
|
||||
while not _fragment_is_sync(fragments[0]):
|
||||
key_sequence -= 1
|
||||
if key_sequence < 1 or sequence - key_sequence > _MAX_KEYFRAME_DISTANCE:
|
||||
raise SessionIntegrityError("camera frame has no bounded sync fragment")
|
||||
previous = self._inspector.get_segment(
|
||||
manifest,
|
||||
epoch.ordinal,
|
||||
key_sequence,
|
||||
)
|
||||
fragments.insert(0, previous.payload)
|
||||
|
||||
init = self._inspector.get_init(manifest, epoch.ordinal)
|
||||
select_index = sequence - key_sequence
|
||||
try:
|
||||
completed = subprocess.run(
|
||||
[
|
||||
str(self._ffmpeg_path),
|
||||
"-hide_banner",
|
||||
"-loglevel",
|
||||
"error",
|
||||
"-f",
|
||||
"mp4",
|
||||
"-i",
|
||||
"pipe:0",
|
||||
"-vf",
|
||||
f"select=eq(n\\,{select_index})",
|
||||
"-fps_mode",
|
||||
"passthrough",
|
||||
"-frames:v",
|
||||
"1",
|
||||
"-f",
|
||||
"image2pipe",
|
||||
"-c:v",
|
||||
"mjpeg",
|
||||
"-q:v",
|
||||
"2",
|
||||
"pipe:1",
|
||||
],
|
||||
input=b"".join((init.payload, *fragments)),
|
||||
capture_output=True,
|
||||
timeout=_FFMPEG_TIMEOUT_SECONDS,
|
||||
check=False,
|
||||
)
|
||||
except (OSError, subprocess.TimeoutExpired) as exc:
|
||||
raise SessionIntegrityError("camera frame decoder failed") from exc
|
||||
if completed.returncode != 0:
|
||||
detail = completed.stderr.decode("utf-8", errors="replace").strip()[-500:]
|
||||
raise SessionIntegrityError(f"camera frame decoder rejected sealed media: {detail}")
|
||||
width, height = _jpeg_dimensions(completed.stdout)
|
||||
digest = hashlib.sha256(completed.stdout).hexdigest()
|
||||
return RecordedCameraFrame(
|
||||
payload=completed.stdout,
|
||||
media_type="image/jpeg",
|
||||
width=width,
|
||||
height=height,
|
||||
sha256=digest,
|
||||
)
|
||||
|
||||
|
||||
def _frame_location(
|
||||
manifest: RecordedMediaManifest,
|
||||
frame_index: int,
|
||||
) -> tuple[RecordedMediaEpoch, int]:
|
||||
remaining = frame_index
|
||||
for epoch in manifest.epochs:
|
||||
if remaining < len(epoch.segments):
|
||||
return epoch, remaining + 1
|
||||
remaining -= len(epoch.segments)
|
||||
raise SessionIntegrityError("camera frame is outside the recorded media manifest")
|
||||
|
||||
|
||||
def _fragment_is_sync(payload: bytes) -> bool:
|
||||
tfhd_default_flags: int | None = None
|
||||
sample_flags: int | None = None
|
||||
sample_count: int | None = None
|
||||
for box_type, body in _walk_boxes(payload):
|
||||
if box_type == b"tfhd":
|
||||
if len(body) < 8:
|
||||
raise SessionIntegrityError("camera fragment tfhd is truncated")
|
||||
flags = int.from_bytes(body[1:4], "big")
|
||||
offset = 8
|
||||
for mask, size in ((0x000001, 8), (0x000002, 4), (0x000008, 4), (0x000010, 4)):
|
||||
if flags & mask:
|
||||
offset += size
|
||||
if flags & 0x000020:
|
||||
if offset + 4 > len(body):
|
||||
raise SessionIntegrityError("camera fragment default flags are truncated")
|
||||
tfhd_default_flags = struct.unpack_from(">I", body, offset)[0]
|
||||
elif box_type == b"trun":
|
||||
if len(body) < 8:
|
||||
raise SessionIntegrityError("camera fragment trun is truncated")
|
||||
flags = int.from_bytes(body[1:4], "big")
|
||||
sample_count = struct.unpack_from(">I", body, 4)[0]
|
||||
if sample_count != 1:
|
||||
raise SessionIntegrityError("camera fragment must contain exactly one sample")
|
||||
offset = 8
|
||||
if flags & 0x000001:
|
||||
offset += 4
|
||||
if flags & 0x000004:
|
||||
if offset + 4 > len(body):
|
||||
raise SessionIntegrityError("camera fragment first flags are truncated")
|
||||
sample_flags = struct.unpack_from(">I", body, offset)[0]
|
||||
offset += 4
|
||||
per_sample_sizes = (
|
||||
(0x000100, 4),
|
||||
(0x000200, 4),
|
||||
(0x000400, 4),
|
||||
(0x000800, 4),
|
||||
)
|
||||
for mask, size in per_sample_sizes:
|
||||
if flags & mask:
|
||||
if offset + size > len(body):
|
||||
raise SessionIntegrityError("camera fragment sample data is truncated")
|
||||
if mask == 0x000400:
|
||||
sample_flags = struct.unpack_from(">I", body, offset)[0]
|
||||
offset += size
|
||||
if sample_count != 1:
|
||||
raise SessionIntegrityError("camera fragment has no unique video sample")
|
||||
effective_flags = sample_flags if sample_flags is not None else tfhd_default_flags
|
||||
if effective_flags is None:
|
||||
raise SessionIntegrityError("camera fragment sample flags are unavailable")
|
||||
return (effective_flags & 0x00010000) == 0
|
||||
|
||||
|
||||
def _walk_boxes(payload: bytes):
|
||||
containers = {b"moof", b"traf"}
|
||||
pending = [(0, len(payload))]
|
||||
boxes = 0
|
||||
while pending:
|
||||
start, end = pending.pop()
|
||||
offset = start
|
||||
while offset + 8 <= end:
|
||||
boxes += 1
|
||||
if boxes > 64:
|
||||
raise SessionIntegrityError("camera fragment box budget was exceeded")
|
||||
size = struct.unpack_from(">I", payload, offset)[0]
|
||||
box_type = payload[offset + 4 : offset + 8]
|
||||
header = 8
|
||||
if size == 1:
|
||||
if offset + 16 > end:
|
||||
raise SessionIntegrityError("camera fragment extended box is truncated")
|
||||
size = struct.unpack_from(">Q", payload, offset + 8)[0]
|
||||
header = 16
|
||||
elif size == 0:
|
||||
size = end - offset
|
||||
if size < header or offset + size > end:
|
||||
raise SessionIntegrityError("camera fragment box size is invalid")
|
||||
body_start = offset + header
|
||||
body_end = offset + size
|
||||
yield box_type, payload[body_start:body_end]
|
||||
if box_type in containers:
|
||||
pending.append((body_start, body_end))
|
||||
offset = body_end
|
||||
if offset != end:
|
||||
raise SessionIntegrityError("camera fragment box boundary is invalid")
|
||||
|
||||
|
||||
def _jpeg_dimensions(payload: bytes) -> tuple[int, int]:
|
||||
if len(payload) < 4 or payload[:2] != b"\xff\xd8" or payload[-2:] != b"\xff\xd9":
|
||||
raise SessionIntegrityError("camera frame decoder returned an invalid JPEG")
|
||||
offset = 2
|
||||
while offset + 4 <= len(payload):
|
||||
if payload[offset] != 0xFF:
|
||||
offset += 1
|
||||
continue
|
||||
marker = payload[offset + 1]
|
||||
offset += 2
|
||||
if marker in {0xD8, 0xD9} or 0xD0 <= marker <= 0xD7:
|
||||
continue
|
||||
if offset + 2 > len(payload):
|
||||
break
|
||||
length = struct.unpack_from(">H", payload, offset)[0]
|
||||
if length < 2 or offset + length > len(payload):
|
||||
break
|
||||
if marker in {0xC0, 0xC1, 0xC2} and length >= 7:
|
||||
height, width = struct.unpack_from(">HH", payload, offset + 3)
|
||||
if width > 0 and height > 0:
|
||||
return width, height
|
||||
offset += length
|
||||
raise SessionIntegrityError("camera frame JPEG dimensions are unavailable")
|
||||
|
||||
|
||||
def _read_cached_jpeg(path: Path) -> RecordedCameraFrame | None:
|
||||
try:
|
||||
if path.is_symlink() or not path.is_file():
|
||||
return None
|
||||
payload = path.read_bytes()
|
||||
width, height = _jpeg_dimensions(payload)
|
||||
except (OSError, SessionIntegrityError):
|
||||
return None
|
||||
return RecordedCameraFrame(
|
||||
payload=payload,
|
||||
media_type="image/jpeg",
|
||||
width=width,
|
||||
height=height,
|
||||
sha256=hashlib.sha256(payload).hexdigest(),
|
||||
)
|
||||
|
||||
|
||||
def _publish_cached_jpeg(path: Path, payload: bytes) -> None:
|
||||
temporary = path.parent / f".{path.name}.{os.getpid()}.{threading.get_ident()}.tmp"
|
||||
try:
|
||||
with temporary.open("xb") as stream:
|
||||
stream.write(payload)
|
||||
stream.flush()
|
||||
os.fsync(stream.fileno())
|
||||
os.replace(temporary, path)
|
||||
except OSError as exc:
|
||||
raise SessionIntegrityError("camera frame cache could not be published") from exc
|
||||
finally:
|
||||
with suppress(FileNotFoundError):
|
||||
temporary.unlink()
|
||||
Reference in New Issue
Block a user