| """Lossless media I/O, bounded by one frame; no resizing or automatic rotation.""" |
| import hashlib |
| import io |
| import json |
| import subprocess |
| import time |
| from fractions import Fraction |
| from pathlib import Path |
|
|
| import av |
| import numpy as np |
| from PIL import Image |
|
|
|
|
| def rgb(path): |
| with Image.open(path) as im: |
| if im.mode not in ('RGB', 'L', 'P', 'RGBA'): |
| raise ValueError(f'Unsupported source bit depth/mode {im.mode}: {path}') |
| if (im.mode == 'RGBA' or 'transparency' in im.info) and im.convert('RGBA').getextrema()[3] != (255, 255): |
| raise ValueError(f'Nonopaque source alpha cannot silently be discarded: {path}') |
| with av.open(str(path)) as c: |
| frames = list(c.decode(video=0)) |
| if len(frames) != 1 or any(x.bits > 8 for x in frames[0].format.components): |
| raise ValueError(f'Expected one 8-bit image: {path}') |
| return frames[0].to_ndarray(format='rgb24') |
|
|
|
|
| def mask(path): |
| with Image.open(path) as im: |
| a = np.asarray(im) |
| if a.ndim != 2 or not np.isin(a, np.arange(9)).all(): |
| raise ValueError(f'Unexpected EgoHOS label palette/values: {path}') |
| |
| return np.where(a == 0, 9, a).astype(np.uint16) |
|
|
|
|
| def decode(path, labels=False): |
| with av.open(str(path)) as c: |
| for frame in c.decode(video=0): |
| yield frame.to_ndarray(format='gray16le' if labels else 'rgb24') |
|
|
|
|
| def verify(path, sources, loader, labels=False): |
| start = time.monotonic() |
| it = iter(sources) |
| hashes = [] |
| for frame in decode(path, labels): |
| source = next(it, None) |
| if source is None: |
| raise ValueError(f'Extra video frame in {path}') |
| original = loader(source) |
| if not np.array_equal(original, frame): |
| raise ValueError(f'Lossless round-trip mismatch at frame {len(hashes)}: {path}') |
| hashes.append(hashlib.sha256(frame.tobytes()).hexdigest()) |
| if next(it, None) is not None or not hashes: |
| raise ValueError(f'Missing video frames: {path}') |
| return {'frames': len(hashes), 'all_decoded_frames_exact': True, |
| 'ordered_decoded_sha256': hashes, 'decode_verify_seconds': time.monotonic() - start} |
|
|
|
|
| def encode_ffmpeg(paths, target, loader, size, encoder, labels=False): |
| pix = 'gray16le' if labels else 'rgb24' |
| options = ['-c:v', 'ffv1', '-level', '3', '-pix_fmt', pix if labels else 'bgr0'] |
| if encoder == 'libx264rgb': |
| options = ['-c:v', 'libx264rgb', '-crf', '0', '-preset', 'medium', '-g', '64', '-pix_fmt', 'rgb24'] |
| command = ['ffmpeg', '-hide_banner', '-loglevel', 'error', '-y', '-f', 'rawvideo', |
| '-pixel_format', pix, '-video_size', f'{size[0]}x{size[1]}', '-framerate', '1', |
| '-i', 'pipe:0', '-an', *options, str(target)] |
| |
| with target.with_suffix('.log').open('wb') as log: |
| p = subprocess.Popen(command, stdin=subprocess.PIPE, stderr=log) |
| try: |
| for path in paths: |
| a = loader(path) |
| if list(a.shape[1::-1]) != size: |
| raise ValueError(f'Changing image size: {path}') |
| p.stdin.write(a.astype('<u2' if labels else 'u1', copy=False).tobytes()) |
| p.stdin.close() |
| if p.wait() != 0: |
| raise RuntimeError(target.with_suffix('.log').read_text()) |
| except BaseException: |
| p.kill() |
| p.wait() |
| raise |
| target.with_suffix('.log').unlink() |
| return command |
|
|
|
|
| def encode_copy(paths, target): |
| with av.open(str(paths[0])) as src, av.open(str(target), 'w', format='matroska') as dst: |
| stream = dst.add_stream_from_template(src.streams.video[0]) |
| stream.time_base = Fraction(1, 1000) |
| for i, path in enumerate(paths): |
| packet = av.Packet(Path(path).read_bytes()) |
| packet.stream = stream |
| packet.pts = packet.dts = i * 1000 |
| packet.duration = 1000 |
| packet.time_base = Fraction(1, 1000) |
| dst.mux(packet) |
| with av.open(str(target)) as c: |
| actual = [hashlib.sha256(bytes(p)).hexdigest() for p in c.demux(video=0) if p.size] |
| expected = [hashlib.sha256(Path(p).read_bytes()).hexdigest() for p in paths] |
| if actual != expected: |
| raise ValueError('JPEG packets changed during remux') |
| return {'all_jpeg_packets_exact': True, 'packet_count': len(actual), 'ordered_packet_sha256': actual} |
|
|
|
|
| def encode(paths, target, labels=False): |
| target.parent.mkdir(parents=True, exist_ok=True) |
| loader = mask if labels else rgb |
| size = list(loader(paths[0]).shape[1::-1]) |
| candidates, failed = [], [] |
| choices = ['ffv1'] if labels else ['ffv1', 'libx264rgb'] |
| if not labels and all(Path(p).suffix.lower() in ('.jpg', '.jpeg') for p in paths): |
| choices.insert(0, 'copy') |
| for encoder in choices: |
| path = target.with_name(target.stem + '.' + encoder + '.mkv') |
| start = time.monotonic() |
| try: |
| extra = encode_copy(paths, path) if encoder == 'copy' else {'command': encode_ffmpeg(paths, path, loader, size, encoder, labels)} |
| elapsed = time.monotonic() - start |
| proof = verify(path, paths, loader, labels) |
| candidates.append({'encoder': encoder, 'path': path, 'bytes': path.stat().st_size, |
| 'encode_seconds': elapsed, **proof, **extra}) |
| if encoder == 'copy': |
| break |
| except (ValueError, RuntimeError, av.FFmpegError) as e: |
| failed.append({'encoder': encoder, 'error': str(e)}) |
| path.unlink(missing_ok=True) |
| if not candidates: |
| raise RuntimeError(f'No exact lossless encoder candidate: {failed}') |
| chosen = min(candidates, key=lambda x: x['bytes']) |
| chosen['path'].replace(target) |
| for c in candidates: |
| c['path'].unlink(missing_ok=True) |
| c.pop('path') |
| with av.open(str(target)) as container: |
| s = container.streams.video[0] |
| actual = {'codec': s.codec_context.name, 'pixel_format': s.codec_context.format.name, |
| 'encoded_size': [s.width, s.height]} |
| enc = chosen['encoder'] |
| profile = ('mkv/uint16_ffv1/v1' if labels else {'copy': 'mkv/mjpeg_copy/v1', |
| 'ffv1': 'mkv/ffv1_rgb/v1', 'libx264rgb': 'mkv/h264_rgb_lossless/v1'}[enc]) |
| storage = {'profile': profile, **actual, 'storage_fps': 1, 'timebase_role': 'index_only', |
| 'source_lossy': False if labels else (True if all(Path(p).suffix.lower() in ('.jpg', '.jpeg') for p in paths) else 'unknown'), |
| 'decoder': {'name': 'PyAV', 'version': av.__version__, |
| 'libraries': {k: list(v) for k, v in av.library_versions.items()}, |
| 'output': 'gray16le' if labels else 'rgb24', 'rotation': 'none', |
| 'color_interpretation': 'libswscale source metadata/defaults; identical source/target decoder', |
| 'source_color_space': 'unknown'}, |
| 'encoder_parameters': {'name': enc, 'stream_copy': enc == 'copy', |
| 'ffmpeg_version': subprocess.check_output(['ffmpeg', '-version'], text=True).splitlines()[0], |
| 'crf': 0 if enc == 'libx264rgb' else None, 'gop': 64 if enc == 'libx264rgb' else None}} |
| return storage, {'selected': enc, 'candidates': candidates, 'failed_candidates': failed, |
| 'pixel_coverage': 'ALL frames, count and order', 'random_access': 'sequential decode from beginning'} |
|
|
