streamo 0.2.0__py3-none-any.whl

streamo/composition.py

@@ -0,0 +1,156 @@
+from .config import Streamo
+from .providers import FfmpegDestination, FfmpegOutput, ingest_output
+
+LOCAL_DISPLAY_URL = 'udp://127.0.0.1:23000?pkt_size=1316'
+
+
+def ffmpeg_command(
+    config: Streamo,
+    *,
+    output: FfmpegOutput | None = None,
+    image_pipe: int | None = None,
+    preview: bool = False,
+) -> list[str]:
+    encoding = config.streaming_service.encoding
+    command = [
+        'ffmpeg',
+        '-hide_banner',
+        '-loglevel',
+        'warning',
+        '-nostats',
+        '-progress',
+        'pipe:2',
+        '-f',
+        'f32le',
+        '-ar',
+        str(config.sample_rate),
+        '-ac',
+        '2',
+        '-i',
+        'pipe:0',
+    ]
+    if encoding.video is not None:
+        assert config.video is not None
+        command.extend(
+            [
+                '-re',
+                '-stream_loop',
+                '-1',
+                '-i',
+                config.video.as_posix(),
+            ]
+        )
+    if encoding.video is not None and config.live_overlays:
+        if image_pipe is None:
+            raise ValueError('overlay pipe is required when live_overlays is enabled')
+        command.extend(
+            [
+                '-f',
+                'rawvideo',
+                '-pixel_format',
+                'rgba',
+                '-video_size',
+                encoding.video.resolution,
+                '-framerate',
+                str(config.overlay_frame_rate),
+                '-i',
+                f'pipe:{image_pipe}',
+                '-filter_complex',
+                overlay_filter(config),
+                '-map',
+                '[video]',
+            ]
+        )
+    elif encoding.video is not None:
+        command.extend(['-map', '1:v:0'])
+    command.extend(['-map', '0:a:0'])
+    if encoding.video is not None:
+        command.extend(
+            [
+                '-c:v',
+                VIDEO_CODECS[encoding.video.codec],
+                '-b:v',
+                str(encoding.video.bitrate),
+                '-pix_fmt',
+                encoding.video.pixel_format,
+                '-r',
+                str(encoding.video.frame_rate),
+                '-s',
+                encoding.video.resolution,
+                '-g',
+                str(
+                    round(encoding.video.frame_rate * encoding.video.keyframe_interval)
+                ),
+            ]
+        )
+        if encoding.video.codec in {'h264', 'hevc'}:
+            command.extend(['-preset', 'veryfast'])
+        if encoding.video.codec == 'h264':
+            command.extend(['-tune', 'animation'])
+    command.extend(
+        [
+            '-c:a',
+            AUDIO_CODECS[encoding.audio.codec],
+            '-b:a',
+            str(encoding.audio.bitrate),
+            '-ar',
+            str(encoding.audio.sample_rate),
+            '-ac',
+            str(encoding.audio.channels),
+        ]
+    )
+    if preview:
+        command.extend(['-f', 'nut', 'pipe:1'])
+    else:
+        command.extend(
+            (
+                output
+                if output is not None
+                else local_display_output(
+                    config, ingest_output(config.streaming_service)
+                )
+            ).arguments
+        )
+    return command
+
+
+def local_display_output(config: Streamo, output: FfmpegOutput | None) -> FfmpegOutput:
+    output = output or ingest_output(config.streaming_service)
+    if not config.local_display or config.streaming_service.encoding.video is None:
+        return output
+    return output.model_copy(
+        update={
+            'destinations': [
+                *output.destinations,
+                FfmpegDestination(
+                    muxer='mpegts', url=LOCAL_DISPLAY_URL, secret_url=False
+                ),
+            ]
+        }
+    )
+
+
+def overlay_filter(config: Streamo) -> str:
+    encoding = config.streaming_service.encoding.video
+    assert encoding is not None
+    width, height = encoding.resolution.lower().split('x')
+    return (
+        f'[1:v]scale={width}:{height},fps={encoding.frame_rate},format=yuv420p[base];'
+        '[2:v]setpts=PTS-STARTPTS[live];'
+        '[base][live]overlay=0:0:eof_action=pass[video]'
+    )
+
+
+AUDIO_CODECS = {
+    'aac': 'aac',
+    'mp3': 'libmp3lame',
+    'opus': 'libopus',
+    'vorbis': 'libvorbis',
+}
+
+
+VIDEO_CODECS = {
+    'h264': 'libx264',
+    'hevc': 'libx265',
+    'av1': 'libaom-av1',
+}

streamo/config.py

@@ -0,0 +1,308 @@
+import threading
+import time
+from math import isfinite
+from pathlib import Path
+from typing import TYPE_CHECKING, Self
+
+from PIL import Image
+from pydantic import ConfigDict, Field, PrivateAttr, field_validator, model_validator
+from reccy.configuration import units
+from reccy.protocol import ipc, rpc
+from reccy.reccy import Reccy, ReccyStatus
+from reccy.services.spec import load
+
+from .closing import DEFAULT_CREDITS, ClosingCredits, ClosingSequence
+from .image_feed import ImageFeed, ImageFeedPoller
+from .images import image_paths
+from .provider_config import StreamingServiceConfiguration, pixel_resolution
+from .providers import GenericServiceAdapter, adapter_for
+from .runtime import HealthWarnings, RuntimeState
+
+STREAMO_SERVICE = load(Path(__file__).with_name('service.toml'))
+
+if TYPE_CHECKING:
+    from .control import ControlController
+
+
+class Streamo(Reccy, frozen=True):
+    name = 'streamo'
+    service_spec = STREAMO_SERVICE
+    status_model = ReccyStatus
+    rpc_enabled = True
+
+    device_name: str
+    channel: int = Field(
+        description='First channel of the stereo input pair, numbered from 1.'
+    )
+    streaming_service: StreamingServiceConfiguration
+    video: Path | None = None
+    title_card: Path | None = None
+    closing_credits: ClosingCredits | None = None
+    closing_state_path: Path = Field(
+        default_factory=lambda: Path.home() / '.local/state/streamo/closing.json'
+    )
+
+    sample_rate: units.WholeHertz = 48_000
+    overlay_resolution: str = '640x360'
+    overlay_frame_rate: units.WholeFramesPerSecond = 10
+    title_interval: units.Seconds = 180.0
+    title_duration: units.Seconds = 8.0
+    title_fade: units.Seconds = 2.0
+    local_display: bool = True
+    live_overlays: bool = Field(
+        default=True,
+        description='Enable titles, photos and slate. Requires a restart to change.',
+    )
+    recover_publish: bool = False
+    health_warnings: HealthWarnings = Field(default_factory=HealthWarnings)
+    image_dir: list[Path] = Field(default_factory=lambda: [Path('images')])
+    image_dir_weights: str | list[int] | None = None
+    image_approval_required: bool = False
+    image_feed: ImageFeed | None = None
+    current_session_image_weight: int = 3
+    image_interval: units.Seconds = 0.0
+    image_duration: units.Seconds = 8.0
+    image_fade: units.Seconds = 2.0
+    _controller: 'ControlController | None' = PrivateAttr(default=None)
+
+    def run(self, *, preview: bool = False) -> int:
+        from . import control, streamer
+
+        self.validate_media()
+        service_adapter = (
+            GenericServiceAdapter(self.streaming_service)
+            if preview
+            else adapter_for(self.streaming_service)
+        )
+        controller = control.ControlController(
+            state=RuntimeState(self.health_warnings),
+            image_dir=self.incoming_image_dir,
+            service=None if preview else service_adapter,
+            closing=ClosingSequence(
+                self.resolved_closing_credits, self.closing_state_path
+            ),
+        )
+        controller.state.configure_service(service_adapter)
+        if preview:
+            controller.state.capabilities = []
+        object.__setattr__(self, '_controller', controller)
+        image_feed_poller = (
+            None
+            if self.image_feed is None
+            or not self.live_overlays
+            or self.streaming_service.encoding.video is None
+            else ImageFeedPoller(self.image_feed, self.incoming_image_dir)
+        )
+        initial_image_paths = {
+            p
+            for d in [*self.image_dir, self.incoming_image_dir]
+            for p in image_paths(d)
+        }
+        self.start()
+        try:
+            if image_feed_poller is not None:
+                image_feed_poller.start()
+            returncode = streamer.stream(
+                self,
+                controller,
+                service_adapter,
+                initial_image_paths=initial_image_paths,
+                preview=preview,
+            )
+            if returncode:
+                self.publish_error(f'ffmpeg exited with {returncode}')
+            if controller.closing is not None and (
+                controller.closing.snapshot()['state'] == 'completed'
+            ):
+                while not streamer.should_stop(controller):
+                    time.sleep(0.1)
+            return returncode
+        finally:
+            if image_feed_poller is not None:
+                image_feed_poller.stop()
+            self.close()
+
+    def validate_media(self) -> None:
+        if self.streaming_service.encoding.video is not None:
+            if self.video is None or not self.video.is_file():
+                raise ValueError(f'Video file is unavailable: {self.video}')
+            with self.video.open('rb'):
+                pass
+        if self.live_overlays and self.title_card is not None:
+            with Image.open(self.title_card) as image:
+                image.load()
+        if self.resolved_closing_credits is not None:
+            from .overlays import render_text
+
+            width, height = (int(v) for v in self.overlay_resolution.split('x'))
+            for page in self.resolved_closing_credits.pages:
+                if page.image is not None:
+                    with Image.open(page.image) as image:
+                        image.load()
+                else:
+                    assert page.text is not None
+                    render_text(page.text, (width, height))
+
+    @field_validator('overlay_resolution')
+    @classmethod
+    def validate_resolution(cls, value: str) -> str:
+        width, height = pixel_resolution(value)
+        if width > 1920 or height > 1080:
+            raise ValueError('overlay_resolution must not exceed 1920x1080')
+        return f'{width}x{height}'
+
+    def rpc_response(
+        self, request: rpc.Request, cancelled: threading.Event
+    ) -> rpc.Result:
+        if cancelled.is_set():
+            return ipc.Error(type='error', message='request was cancelled')
+        if request.command == 'preflight':
+            from .preflight import check
+
+            if request.params:
+                return ipc.Error(
+                    type='error',
+                    message=(
+                        'RPC preflight accepts no parameters; '
+                        'use the CLI for explicit probes'
+                    ),
+                )
+            return check(self).model_dump(mode='json')
+        if self._controller is None:
+            return ipc.Error(type='error', message='streamO is not running')
+        return self._controller.handle_request(request)
+
+    @field_validator('channel', 'sample_rate', 'overlay_frame_rate')
+    @classmethod
+    def validate_positive(cls, value: int) -> int:
+        if value <= 0:
+            raise ValueError('must be positive')
+        return value
+
+    @model_validator(mode='after')
+    def validate_resource_limits(self) -> Self:
+        if self.sample_rate > 192_000:
+            raise ValueError('sample_rate must not exceed 192000')
+        if self.overlay_frame_rate > 60:
+            raise ValueError('overlay_frame_rate must not exceed 60')
+        return self
+
+    @field_validator('current_session_image_weight')
+    @classmethod
+    def validate_nonnegative_weight(cls, value: int) -> int:
+        if not isfinite(value) or value < 0:
+            raise ValueError('must not be negative')
+        return value
+
+    @model_validator(mode='after')
+    def validate_image_dirs(self) -> Self:
+        if not self.image_dir:
+            raise ValueError('image_dir must contain at least one directory')
+        if len(set(self.image_dir)) != len(self.image_dir):
+            raise ValueError('image_dir entries must be distinct')
+        if self.incoming_image_dir.resolve() in {p.resolve() for p in self.image_dir}:
+            raise ValueError('image_dir must not include the incoming image inbox')
+        if self.image_dir_weights is not None:
+            weights = parse_image_dir_weights(self.image_dir_weights)
+            if not weights:
+                raise ValueError('image_dir_weights must contain at least one weight')
+            if len(weights) > len(self.image_dir):
+                raise ValueError('image_dir_weights must not exceed image_dir')
+            if any(w <= 0 for w in weights):
+                raise ValueError('image_dir_weights must be positive')
+        return self
+
+    @property
+    def primary_image_dir(self) -> Path:
+        return self.image_dir[0]
+
+    @property
+    def incoming_image_dir(self) -> Path:
+        return self.primary_image_dir / 'incoming'
+
+    @property
+    def resolved_image_dir_weights(self) -> list[int]:
+        if self.image_dir_weights is None:
+            return list(range(len(self.image_dir), 0, -1))
+        weights = parse_image_dir_weights(self.image_dir_weights)
+        return weights + [weights[-1]] * (len(self.image_dir) - len(weights))
+
+    @field_validator(
+        'title_interval',
+        'title_duration',
+        'title_fade',
+        'image_interval',
+        'image_duration',
+        'image_fade',
+    )
+    @classmethod
+    def validate_nonnegative_time(cls, value: float) -> float:
+        if not isfinite(value) or value < 0:
+            raise ValueError('must be finite and nonnegative')
+        return value
+
+    @model_validator(mode='after')
+    def validate_title_card(self) -> Self:
+        if not self.live_overlays:
+            return self
+        if self.title_card is not None and not self.title_card.is_file():
+            raise ValueError(f'{self.title_card} does not exist')
+        if self.title_interval <= 0:
+            raise ValueError('title_interval must be positive')
+        if self.title_duration <= 0:
+            raise ValueError('title_duration must be positive')
+        if self.title_duration >= self.title_interval:
+            raise ValueError('title_duration must be shorter than title_interval')
+        if self.title_fade * 2 > self.title_duration:
+            raise ValueError('title_fade must fit within title_duration')
+        return self
+
+    @model_validator(mode='after')
+    def validate_image_overlay(self) -> Self:
+        if self.image_interval == 0:
+            if self.image_feed is not None:
+                raise ValueError('image_interval must be positive with an image feed')
+            return self
+        if self.image_duration <= 0:
+            raise ValueError('image_duration must be positive')
+        if self.image_duration >= self.image_interval:
+            raise ValueError('image_duration must be shorter than image_interval')
+        if self.image_fade * 2 > self.image_duration:
+            raise ValueError('image_fade must fit within image_duration')
+        return self
+
+    @model_validator(mode='after')
+    def validate_video(self) -> Self:
+        if self.streaming_service.encoding.video is not None and self.video is None:
+            raise ValueError('video is required for video streaming')
+        if self.closing_credits is not None and (
+            self.streaming_service.encoding.video is None or not self.live_overlays
+        ):
+            raise ValueError('closing_credits requires video and live_overlays')
+        return self
+
+    @property
+    def required_channels(self) -> int:
+        return self.channel + 1
+
+    @property
+    def resolved_closing_credits(self) -> ClosingCredits | None:
+        if self.streaming_service.encoding.video is None or not self.live_overlays:
+            return None
+        return self.closing_credits or DEFAULT_CREDITS
+
+    model_config = ConfigDict(hide_input_in_errors=True, extra='forbid')
+
+
+def parse_image_dir_weights(value: str | list[int]) -> list[int]:
+    if isinstance(value, list):
+        return value
+    try:
+        weights = [int(part.strip()) for part in value.split(',')]
+    except ValueError as error:
+        raise ValueError(
+            'image_dir_weights must be comma-separated integers'
+        ) from error
+    if not weights or any(not part.strip() for part in value.split(',')):
+        raise ValueError('image_dir_weights must be comma-separated integers')
+    return weights