camera.ui3 0.0.30-alpha.0 → 0.0.30-alpha.3

package/dist/server/src/polyglot/python/decoder/child.py

@@ -1,882 +0,0 @@
-import asyncio
-import os
-import random
-import re
-import signal
-import string
-import traceback
-from contextlib import suppress
-from datetime import datetime
-from typing import Any, Literal, Optional, Union, cast
-
-from camera_ui_types import DecoderFormat, FrameData, FrameMetadata, ImageOptions
-from image_utils import process_image_threaded
-from nats.aio.msg import Msg
-from nats.errors import NoRespondersError, TimeoutError
-from plugins.plugin_logger import PluginLogger
-from plugins.typings import ProcessPrebufferedImageRequest
-from typings import (
-    BaseFrameWorkerConfig,
-    FfmpegArgs,
-    FfmpegArgsResponse,
-    FrameWorkerClient,
-    MainToWorkerMessage,
-    MainToWorkerResponse,
-    PingMessage,
-    PongMessage,
-    PrebufferContainer,
-    RecoveredClient,
-    SignalingRequest,
-    SignalingResponse,
-    WorkerMessage,
-    WorkerToMainMessage,
-    WorkerToMainResponse,
-)
-from utilities.connection import ProxyConnection
-from utilities.packer import pack, unpack
-from utilities.subscriptions import ProxySubscription
-from utilities.task import TaskSet
-
-PIX_FMT: Literal["yuv420p", "rgb24"] = "yuv420p"
-
-
-class FrameWorkerChild:
-    def __init__(self):
-        self.config: BaseFrameWorkerConfig = {
-            "frameWorkerId": os.environ["FRAME_WORKER_ID"],
-            "cameraId": os.environ["CAMERA_ID"],
-            "cameraName": os.environ["CAMERA_NAME"],
-            "ffmpegPath": os.environ["FFMPEG_PATH"],
-            "logLevel": os.environ.get("LOGGER_LEVEL") or "debug",
-            "disableTimestamps": os.environ.get("LOGGER_DISABLE_TIMESTAMPS") == "true",
-            "auth": {
-                "user": os.environ["PROXY_USER"],
-                "password": os.environ["PROXY_PASSWORD"],
-            },
-            "proxyEndpoints": [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")],
-            "fps": int(os.environ["FPS"]) if "FPS" in os.environ else 10,
-            "resolution": int(os.environ["RESOLUTION"]) if "RESOLUTION" in os.environ else 640,
-        }
-
-        del os.environ["FRAME_WORKER_ID"]
-        del os.environ["CAMERA_ID"]
-        del os.environ["CAMERA_NAME"]
-        del os.environ["FFMPEG_PATH"]
-        del os.environ["PROXY_USER"]
-        del os.environ["PROXY_PASSWORD"]
-        del os.environ["PROXY_ENDPOINTS"]
-        del os.environ["FPS"]
-        del os.environ["RESOLUTION"]
-
-        self.logger = PluginLogger("Frame Worker", self.config["disableTimestamps"])
-        self.logger.debug_enabled = self.config["logLevel"] == "debug" or self.config["logLevel"] == "trace"
-        self.logger.trace_enabled = self.config["logLevel"] == "trace"
-
-        self.subject = f"{self.config['frameWorkerId']}.frameWorkerChild"
-        self.ipc_subject = f"{self.config['frameWorkerId']}.frameWorker"
-        self.image_subject = f"{self.config['cameraId']}.frameGenerator"
-        self.signaling_subject = f"{self.config['cameraId']}.frameGenerator.signaling"
-        self.frame_subject = f"{self.config['cameraId']}.frameReceiver"
-
-        self.publisher: Optional[ProxyConnection] = None
-        self.signaling_publisher: Optional[ProxyConnection] = None
-        self.image_publisher: Optional[ProxyConnection] = None
-        self.frame_publisher: Optional[ProxyConnection] = None
-
-        self.subscriber: Optional[ProxySubscription] = None
-        self.image_subscriber: Optional[ProxySubscription] = None
-        self.signal_subscriber: Optional[ProxySubscription] = None
-
-        self.clients: dict[str, FrameWorkerClient] = {}
-        self.tasks: TaskSet = TaskSet(f"{self.config['cameraName']} FrameWorkerChild")
-
-        self.prebuffer_full = False
-        self.prebuffer_duration = 7
-        self.prebuffer_container: list[PrebufferContainer] = []
-
-        self.shutdown_event = asyncio.Event()
-        self.loop = asyncio.get_event_loop()
-
-        self._metadata: Optional[FrameMetadata] = None
-        self.metadata_event = asyncio.Event()
-        self.ffmpeg_process = None
-
-        self.stderr_task: Optional[asyncio.Task[None]] = None
-        self.stdout_task: Optional[asyncio.Task[None]] = None
-        self.close_task: Optional[asyncio.Task[None]] = None
-
-        self.stopped = False
-        self.closed = False
-        self.restarting = False
-
-        self.max_diff_frame = 3
-        self.restart_delay = 5
-
-        self.restart_timeout: Optional[asyncio.TimerHandle] = None
-        self.restart_watchdog_delay = 5
-
-        self.close_timeout: Optional[asyncio.TimerHandle] = None
-        self.close_delay = 5
-
-    @property
-    def log_prefix(self) -> str:
-        return f"{self.config['cameraName']}:"
-
-    @property
-    async def metadata(self) -> FrameMetadata:
-        if not self._metadata:
-            await self.metadata_event.wait()
-
-        return cast(FrameMetadata, self._metadata)
-
-    async def listen(self) -> None:
-        self.setup_signal_handlers()
-
-        servers = [endpoint for endpoint in self.config["proxyEndpoints"] if endpoint.startswith("nats://")]
-
-        self.publisher = ProxyConnection(self.subject, servers, self.config["auth"])
-        await self.publisher.connect()
-
-        self.image_publisher = ProxyConnection(self.image_subject, servers, self.config["auth"])
-        await self.image_publisher.connect()
-
-        self.frame_publisher = ProxyConnection(self.frame_subject, servers, self.config["auth"])
-        await self.frame_publisher.connect()
-
-        self.signaling_publisher = ProxyConnection(self.signaling_subject, servers, self.config["auth"])
-        await self.signaling_publisher.connect()
-
-        self.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.subscriber.on("message", self.on_worker_message)
-
-        self.image_subscriber = await self.image_publisher.subscribe(subject=self.image_subject)
-        self.image_subscriber.on("message", self.on_image_request)
-
-        self.signal_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
-        self.signal_subscriber.on("message", self.on_signaling_message)
-
-        await self.send("started")
-        await self.shutdown_event.wait()
-
-    async def close(self) -> None:
-        self.closed = True
-        # await self.stop()
-
-        with suppress(Exception):
-            if self.publisher:
-                await self.publisher.close()
-
-            if self.image_publisher:
-                await self.image_publisher.close()
-
-            if self.signaling_publisher:
-                await self.signaling_publisher.close()
-
-            if self.frame_publisher:
-                await self.frame_publisher.close()
-
-        self.shutdown_event.set()
-
-    async def start(self) -> None:
-        try:
-            self.closed = False
-            self.restarting = False
-            self.stopped = False
-
-            if self.close_timeout:
-                self.close_timeout.cancel()
-                self.close_timeout = None
-
-            await self.start_video_session()
-        except Exception as e:
-            self.logger.error(f"{self.log_prefix} An error occurred while starting frame session:", e)
-            await self.restart_ffmpeg()
-
-    async def stop(self) -> None:
-        self.stopped = True
-        await self.disconnect_all_clients()
-        await self.reset()
-
-    async def reset(self) -> None:
-        self.reset_prebuffer()
-        self.reset_metadata()
-        await self.reset_video_session()
-
-    def reset_prebuffer(self) -> None:
-        self.prebuffer_full = False
-        self.prebuffer_container = []
-
-    def reset_metadata(self) -> None:
-        self.metadata_event.clear()
-        self._metadata = None
-
-    async def reset_video_session(self) -> None:
-        if self.close_timeout:
-            self.close_timeout.cancel()
-            self.close_timeout = None
-
-        if self.restart_timeout:
-            self.restart_timeout.cancel()
-            self.restart_timeout = None
-
-        if self.stderr_task:
-            self.stderr_task.cancel()
-            self.stderr_task = None
-
-        if self.stdout_task:
-            self.stdout_task.cancel()
-            self.stdout_task = None
-
-        if self.close_task:
-            self.close_task.cancel()
-            self.close_task = None
-
-        if self.ffmpeg_process:
-            self.logger.debug(f"{self.log_prefix} Stopping FFmpeg process...")
-            self.ffmpeg_process.kill()
-            await self.ffmpeg_process.wait()
-            self.ffmpeg_process = None
-
-    async def start_video_session(self) -> None:
-        self.reset_prebuffer()
-        await self.reset_video_session()
-
-        # await self.reset()
-        self.stopped = False
-
-        try:
-            self.tasks.add(self.spawn_ffmpeg())
-            await asyncio.wait_for(self.metadata_event.wait(), timeout=15)
-            self.logger.debug(f"{self.log_prefix} Frame session started")
-        except asyncio.TimeoutError:
-            raise Exception("FFmpeg process timed out") from None
-
-    def build_ffmpeg_args(self, ffmpeg_path: str, camera_source: str, ffmpeg_args: FfmpegArgs) -> list[str]:
-        return [
-            ffmpeg_path,
-            "-hide_banner",
-            # "-vsync",
-            # "0",
-            "-hwaccel",
-            ffmpeg_args["hwaccel"],
-            *ffmpeg_args["hwaccelArgs"],
-            "-fflags",
-            "nobuffer",
-            "-flags",
-            "low_delay",
-            "-analyzeduration",
-            "0",
-            "-probesize",
-            "500000",
-            "-reorder_queue_size",
-            "0",
-            "-user_agent",
-            "camera.ui/decoder",
-            "-rtsp_transport",
-            "tcp",
-            "-i",
-            camera_source,
-            "-threads",
-            ffmpeg_args["threads"],
-            "-vf",
-            f"showinfo=checksum=0,{ffmpeg_args['hwaccelFilter'].replace('640', str(self.config['resolution']))},fps=fps={self.config['fps']}",
-            "-an",
-            "-dn",
-            "-sn",
-            "-vcodec",
-            "rawvideo",
-            "-f",
-            "rawvideo",
-            "-pix_fmt",
-            PIX_FMT,
-            "-",
-        ]
-
-    async def spawn_ffmpeg(self) -> None:
-        response = cast(Union[FfmpegArgsResponse, None], await self.send("getFFmpegArgs"))
-
-        if not response:
-            raise Exception("Error getting FFmpeg args from main process")
-
-        args = self.build_ffmpeg_args(
-            self.config["ffmpegPath"], response["cameraSource"], response["ffmpegArgs"]
-        )
-
-        self.logger.debug(f"{self.log_prefix} Starting FFmpeg process: {' '.join(args)}")
-
-        self.ffmpeg_process = await asyncio.create_subprocess_exec(
-            *args,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            limit=10**8,
-        )
-
-        self.stderr_task = self.tasks.add(self.handle_ffmpeg_stderr())
-        self.stdout_task = self.tasks.add(self.handle_ffmpeg_stdout())
-        self.close_task = self.tasks.add(self.handle_ffmpeg_close())
-
-    async def restart_ffmpeg(self) -> None:
-        if not self.stopped and not self.closed and not self.restarting and len(self.clients) > 0:
-            self.restarting = True
-
-            self.logger.log(f"{self.log_prefix} Restarting FFmpeg process in {self.restart_delay} seconds...")
-
-            with suppress(asyncio.TimeoutError):
-                await asyncio.wait_for(asyncio.sleep(self.restart_delay), timeout=self.restart_delay)
-
-            if not self.stopped and not self.closed and len(self.clients) > 0:
-                await self.start()
-            else:
-                self.restarting = False
-
-    async def handle_ffmpeg_stderr(self) -> None:
-        try:
-
-            def is_closed() -> bool:
-                return (
-                    self.stopped
-                    or self.closed
-                    or not self.ffmpeg_process
-                    or not self.ffmpeg_process.stderr
-                    or self.ffmpeg_process.returncode is not None
-                )
-
-            while not is_closed():
-                try:
-                    line = await self.ffmpeg_process.stderr.readline()  # type: ignore
-
-                    if is_closed():
-                        break
-
-                    if not line or len(line) == 0:
-                        continue
-
-                    line = line.decode("utf-8").strip()
-                    metadata = self.parse_frame_info(line)
-
-                    if metadata:
-                        self.logger.debug(f"{self.log_prefix} Metadata:", metadata)
-                        self._metadata = metadata
-                        self.metadata_event.set()
-                        break
-
-                except Exception as e:
-                    self.logger.error(
-                        f"{self.log_prefix} An error occurred while reading ffmpeg stderr:",
-                        e,
-                    )
-
-                    break
-        except asyncio.CancelledError:
-            pass
-
-    async def handle_ffmpeg_stdout(self) -> None:
-        try:
-            metadata = (await self.metadata).copy()
-            warned = False
-
-            def is_closed() -> bool:
-                return (
-                    self.stopped
-                    or self.closed
-                    or not self.frame_publisher
-                    or not self.ffmpeg_process
-                    or not self.ffmpeg_process.stdout
-                    or self.ffmpeg_process.returncode is not None
-                )
-
-            def reset_restart_watchdog():
-                if self.restart_timeout:
-                    self.restart_timeout.cancel()
-                self.restart_timeout = None
-
-            def restart_watchdog():
-                reset_restart_watchdog()
-                self.restart_timeout = asyncio.get_event_loop().call_later(
-                    self.restart_watchdog_delay,
-                    lambda: asyncio.create_task(restart_ffmpeg(), name="FrameWorker Restart FFmpeg"),
-                )
-
-            async def restart_ffmpeg():
-                if not self.stopped and not self.closed and not self.restarting:
-                    message = "FFmpeg process is not producing frames, terminating..."
-
-                    nonlocal warned
-                    if warned is False:
-                        self.logger.debug(f"{self.log_prefix} {message}")
-                        warned = True
-                    else:
-                        self.logger.error(f"{self.log_prefix} {message}")
-
-                    await self.reset()
-                    await self.restart_ffmpeg()
-
-            while not is_closed():
-                try:
-                    restart_watchdog()
-
-                    frame = await self.ffmpeg_process.stdout.readexactly(  # type: ignore
-                        int(metadata["frameSize"]),
-                    )
-
-                    warned = False
-
-                    if is_closed():
-                        reset_restart_watchdog()
-                        break
-
-                    frame_id = self.generate_id()
-                    now = int(datetime.now().timestamp() * 1000)
-
-                    self.prebuffer_container.append(
-                        {
-                            "frame_id": frame_id,
-                            "time": now,
-                            "frame": frame,
-                        }
-                    )
-
-                    if (
-                        len(self.prebuffer_container) > 0
-                        and now - self.prebuffer_container[0]["time"] >= (self.prebuffer_duration * 1000)
-                        and not self.prebuffer_full
-                    ):
-                        self.logger.debug(f"{self.log_prefix} Prebuffer is full")
-                        self.prebuffer_full = True
-
-                    while len(self.prebuffer_container) > 0 and self.prebuffer_container[0]["time"] < now - (
-                        self.prebuffer_duration * 1000
-                    ):
-                        self.prebuffer_container.pop(0)
-
-                    if self.prebuffer_full:
-                        frame_data: FrameData = {"frameId": frame_id, "timestamp": now}
-
-                        await self.frame_publisher.publish(self.frame_subject, frame_data)  # type: ignore
-
-                except asyncio.IncompleteReadError as e:
-                    if not is_closed() and not self.restarting:
-                        self.logger.error(f"{self.log_prefix} Incomplete read error:", e)
-                        await asyncio.sleep(0.1)
-
-                except Exception as e:
-                    if not is_closed() and not self.restarting:
-                        self.logger.error(
-                            f"{self.log_prefix} An error occurred while reading ffmpeg stdout:",
-                            e,
-                        )
-                    break
-                finally:
-                    reset_restart_watchdog()
-        except asyncio.CancelledError:
-            pass
-
-    async def handle_ffmpeg_close(self) -> None:
-        try:
-            if self.ffmpeg_process:
-                code = await self.ffmpeg_process.wait()
-
-                if code != 0 and code != -9 or not self.stopped:
-                    self.logger.error(
-                        self.log_prefix,
-                        f"FFmpeg process has exited with code {code} (unexpected)",
-                    )
-                else:
-                    self.logger.debug(
-                        f"{self.log_prefix} FFmpeg process has exited with code {code} (expected)"
-                    )
-
-                self.ffmpeg_process = None
-
-                await self.reset()
-                await self.restart_ffmpeg()
-        except asyncio.CancelledError:
-            pass
-
-    def parse_frame_info(self, stderr: str) -> Optional[FrameMetadata]:
-        patterns = {
-            "s": r"s:\s*(\d+x\d+)",
-        }
-
-        matches: dict[str, str] = {}
-
-        for key, pattern in patterns.items():
-            match = re.search(pattern, stderr)
-            if match:
-                matches[key] = match.group(1)
-
-        if "s" not in matches:
-            return None
-
-        width, height = map(int, matches["s"].split("x"))
-        new_width = self.config["resolution"]
-        new_height = round((new_width * height) / width)
-        format: DecoderFormat = "yuv" if PIX_FMT == "yuv420p" else "rgb"
-        bytes_per_pixel = 1.5 if format == "yuv" else 3
-        frame_size = new_width * new_height * bytes_per_pixel
-
-        metadata: FrameMetadata = {
-            "format": format,
-            "frameSize": frame_size,
-            "width": new_width,
-            "height": new_height,
-            "origHeight": height,
-            "origWidth": width,
-        }
-
-        return metadata
-
-    async def send(
-        self,
-        message: WorkerMessage,
-        data: Optional[dict[str, Any]] = None,
-    ) -> Union[dict[str, Any], None]:
-        if self.publisher is None:
-            raise Exception("Publisher not initialized")
-
-        if data is None:
-            data = {}
-
-        worker_message: WorkerToMainMessage = {
-            "message": message,
-            "data": data,
-        }
-
-        response: MainToWorkerResponse = await self.publisher.request(
-            self.ipc_subject, worker_message, timeout=30
-        )
-
-        return response.get("response")
-
-    async def add_client(self, plugin_id: str, request_id: str) -> None:
-        if not self.clients.get(plugin_id):
-            self.clients[plugin_id] = FrameWorkerClient(plugin_id, [request_id])
-
-        client = self.clients[plugin_id]
-
-        if request_id not in client.request_ids:
-            client.request_ids.append(request_id)
-
-        self.logger.trace(f"{self.log_prefix} New client {self.client_identifier(plugin_id, request_id)}")
-
-        if self.close_timeout:
-            self.close_timeout.cancel()
-            self.close_timeout = None
-
-        await self.send("updateClient", {"pluginId": client.plugin_id, "requestIds": client.request_ids})
-
-        if len(self.clients) > 0 and self.ffmpeg_process is None and not self.restarting:
-            await self.start()
-
-    async def remove_client(self, plugin_id: str, request_id: str) -> None:
-        client = self.clients[plugin_id]
-
-        if not client or request_id not in client.request_ids:
-            return
-
-        self.logger.trace(
-            f"{self.log_prefix} Removing client {self.client_identifier(plugin_id, request_id)}"
-        )
-
-        if request_id in client.request_ids:
-            client.request_ids.remove(request_id)
-
-        if len(client.request_ids) == 0:
-            del self.clients[plugin_id]
-            await self.send("removeClient", {"pluginId": client.plugin_id, "requestIds": client.request_ids})
-        else:
-            await self.send("updateClient", {"pluginId": client.plugin_id, "requestIds": client.request_ids})
-
-        if len(self.clients) == 0:
-            if self.close_timeout:
-                self.close_timeout.cancel()
-
-            self.close_timeout = asyncio.get_event_loop().call_later(
-                self.close_delay, lambda: asyncio.create_task(self.stop(), name="FrameWorker Stop")
-            )
-
-    async def recover_clients(self, clients: list[RecoveredClient]) -> None:
-        for client in clients:
-            for request_id in client["requestIds"]:
-                self.logger.trace(
-                    f"{self.log_prefix} Recovering client {self.client_identifier(client['pluginId'], request_id)}"
-                )
-
-            self.clients[client["pluginId"]] = FrameWorkerClient(client["pluginId"], client["requestIds"])
-
-        if len(self.clients) > 0:
-            await self.start()
-
-    async def disconnect_client(self, camera_id: str, plugin_id: str, request_id: str) -> None:
-        client = self.clients.get(plugin_id)
-
-        if not self.signaling_publisher or not client or request_id not in client.request_ids:
-            return
-
-        ping_target_subject = f"{plugin_id}.camera.{camera_id}.signaling"
-
-        response: SignalingResponse = {"type": "disconnect", "requestId": request_id}
-
-        await self.signaling_publisher.publish(ping_target_subject, response)
-        await self.remove_client(plugin_id, request_id)
-
-    async def disconnect_all_clients(self) -> None:
-        for client in self.clients.values():
-            for request_id in client.request_ids:
-                await self.disconnect_client(self.config["cameraId"], client.plugin_id, request_id)
-
-    async def handle_connect_message(self, message: SignalingRequest) -> None:
-        await self.add_client(message["pluginId"], message["requestId"])
-        self.tasks.add(self.start_ping_pong(message["cameraId"], message["pluginId"], message["requestId"]))
-
-    async def handle_disconnect_message(self, message: SignalingRequest) -> None:
-        await self.remove_client(message["pluginId"], message["requestId"])
-
-    async def handle_metadata_message(self, msg: Msg, message: SignalingRequest) -> None:
-        metadata = (await self.metadata).copy()
-
-        response: SignalingResponse = {
-            "type": "metadata",
-            "requestId": message["requestId"],
-            "metadata": metadata,
-        }
-
-        await msg.respond(pack(response))
-
-    async def start_ping_pong(self, camera_id: str, plugin_id: str, request_id: str) -> None:
-        ping_target_subject = f"{plugin_id}.camera.{camera_id}.signaling"
-        ping_interval = 3
-        ping_timeout = 2
-
-        def request_id_exists() -> bool:
-            return self.clients.get(plugin_id, False) and request_id in self.clients[plugin_id].request_ids
-
-        while self.signaling_publisher and request_id_exists():
-            try:
-                message: PingMessage = {"type": "ping", "requestId": request_id}
-
-                # self.logger.trace(f"{self.log_prefix} Sending ping to {self.client_identifier(plugin_id, request_id)}")
-
-                response: PongMessage = await self.signaling_publisher.request(
-                    ping_target_subject,
-                    message,
-                    timeout=ping_timeout,
-                )
-
-                if not request_id_exists():
-                    break
-
-                if response["type"] != "pong":
-                    raise Exception("Invalid response to ping")
-
-                # self.logger.trace(f"{self.log_prefix} Received pong from {self.client_identifier(plugin_id, request_id)}")
-
-                await asyncio.sleep(ping_interval)
-            except (Exception, NoRespondersError, TimeoutError) as e:
-                if request_id_exists():
-                    if isinstance(e, (NoRespondersError, TimeoutError)):
-                        # self.logger.trace(f"{self.log_prefix} Ping/Pong timeout for {self.client_identifier(plugin_id, request_id)}")
-                        await self.remove_client(plugin_id, request_id)
-                    else:
-                        self.logger.error(f"{self.log_prefix} Error during ping/pong:", e)
-
-                break
-
-    async def on_worker_message(self, msg: Msg) -> None:
-        if self.closed:
-            return
-
-        self.tasks.add(self.respond_on_ipc_message(msg))
-
-    async def on_signaling_message(self, msg: Msg) -> None:
-        if self.closed:
-            return
-
-        self.tasks.add(self.respond_on_signaling_message(msg))
-
-    async def on_image_request(self, msg: Msg) -> None:
-        if self.closed:
-            return
-
-        self.tasks.add(self.respond_on_prebuffered_image_message(msg))
-
-    async def respond_on_ipc_message(self, msg: Msg) -> None:
-        try:
-            main_message: MainToWorkerMessage = unpack(msg.data)
-            response: WorkerToMainResponse = {}
-            message = main_message["message"]
-
-            if message == "setCameraName":
-                self.config["cameraName"] = main_message["data"]["cameraName"]
-            elif message == "recoverClients":
-                await self.recover_clients(main_message["data"]["clients"])
-
-            await msg.respond(pack(response))
-        except Exception as e:
-            self.logger.error(f"{self.log_prefix} Error while processing IPC respond:", e)
-
-    async def respond_on_signaling_message(self, msg: Msg) -> None:
-        try:
-            message: SignalingRequest = unpack(msg.data)
-
-            if message["type"] == "connect":
-                await self.handle_connect_message(message)
-            elif message["type"] == "disconnect":
-                await self.handle_disconnect_message(message)
-            elif message["type"] == "metadata":
-                await self.handle_metadata_message(msg, message)
-        except Exception as e:
-            self.logger.error(f"{self.log_prefix} Error while processing signaling respond:", e)
-
-    async def respond_on_prebuffered_image_message(self, msg: Msg) -> None:
-        try:
-            message: ProcessPrebufferedImageRequest = unpack(msg.data)
-            metadata = message["metadata"]
-            frame_data = message["frameData"]
-            options = message["options"]
-            prebuffer_duration = message["prebufferDuration"]
-            width = metadata["width"]
-            height = metadata["height"]
-            format = metadata["format"]
-
-            target_frame = self.find_target_frame(frame_data, prebuffer_duration)
-
-            if not target_frame:
-                self.log_frame_not_found()
-            else:
-                processed_image = await self.process_frame(
-                    target_frame["frame"], width, height, format, options
-                )
-                await msg.respond(pack(processed_image))
-                return
-
-            await msg.respond(pack(b""))
-        except Exception as e:
-            self.logger.error(f"{self.log_prefix} Error while processing image respond:", e)
-
-    def find_target_frame(
-        self, frame_data: FrameData, prebuffer_duration: int
-    ) -> Optional[PrebufferContainer]:
-        target_index = next(
-            (
-                i
-                for i, frame in enumerate(self.prebuffer_container)
-                if frame["frame_id"] == frame_data["frameId"]
-            ),
-            -1,
-        )
-
-        if target_index == -1:
-            return self.find_nearest_frame(frame_data)
-
-        if prebuffer_duration > 0:
-            target_time = self.prebuffer_container[target_index]["time"] - prebuffer_duration * 1000
-            result = self.find_nearest_frame_by_time(target_time)
-            if result is not None:
-                return result
-
-        return self.prebuffer_container[target_index]
-
-    def find_nearest_frame(self, frame_data: FrameData) -> Optional[PrebufferContainer]:
-        max_time_diff = self.max_diff_frame * (1000 / self.config["fps"])
-
-        nearest_frame = None
-        min_time_diff = float("inf")
-
-        for frame in self.prebuffer_container:
-            current_time_diff = abs(frame["time"] - frame_data["timestamp"])
-
-            if current_time_diff <= max_time_diff and (
-                nearest_frame is None or current_time_diff < min_time_diff
-            ):
-                nearest_frame = frame
-                min_time_diff = current_time_diff
-
-        return nearest_frame
-
-    def find_nearest_frame_by_time(self, target_time: float) -> Optional[PrebufferContainer]:
-        max_time_diff = (self.max_diff_frame / self.config["fps"]) * 1000
-        nearest_frame = None
-        min_diff = float("inf")
-
-        for frame in self.prebuffer_container:
-            if frame["time"] <= target_time:
-                time_diff = abs(frame["time"] - target_time)
-                if time_diff <= max_time_diff and time_diff < min_diff:
-                    nearest_frame = frame
-                    min_diff = time_diff
-
-        return nearest_frame
-
-    async def process_frame(
-        self,
-        frame: bytes,
-        width: int,
-        height: int,
-        format: Union[DecoderFormat, Literal["rgba", "gray"]],
-        options: ImageOptions,
-    ) -> bytes:
-        return await process_image_threaded(
-            frame,
-            width,
-            height,
-            format,
-            options,
-        )
-
-    def log_frame_not_found(self):
-        if len(self.prebuffer_container) > 0:
-            self.logger.warn(f"{self.log_prefix} Frame not found in prebuffer")
-        else:
-            self.logger.warn(f"{self.log_prefix} Prebuffer is empty! FFmpeg is not producing frames?")
-
-    def client_identifier(self, plugin_id: str, request_id: str) -> str:
-        return f"{plugin_id}:{request_id}"
-
-    def generate_id(self, length: int = 9) -> str:
-        characters = string.ascii_letters + string.digits
-        return "".join(random.choice(characters) for _ in range(length))
-
-    def setup_signal_handlers(self) -> None:
-        loop = asyncio.get_running_loop()
-        loop.set_exception_handler(self.handle_exception)
-
-        for signame in ("SIGINT", "SIGTERM"):
-            loop.add_signal_handler(
-                getattr(signal, signame),
-                lambda signame=signame: self.gracefully_close(signame, getattr(signal, signame)),
-            )
-
-    def gracefully_close(self, signame: str, reason: Any = "unknown") -> None:
-        if self.stopped:
-            return
-
-        self.logger.debug(
-            f"{self.log_prefix} Frame Worker is gracefully closing from signal='{signame}' reason='{reason}'..."
-        )
-
-        self.tasks.add(self.close())
-        self.shutdown_event.set()
-
-    def handle_exception(self, loop: asyncio.AbstractEventLoop, context: Any) -> None:
-        print(f"{self.log_prefix} Exception context:", context)
-        traceback.print_exc()
-
-        msg = context.get("message", "Unknown error")
-        exception = context.get("exception")
-
-        if exception:
-            tb_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))  # type: ignore
-
-            self.logger.error(f"{self.log_prefix} Caught exception: {msg}\n{tb_str}")
-        else:
-            self.logger.error(f"{self.log_prefix} Caught exception: {msg}")
-
-        if loop.is_running():
-            self.gracefully_close("uncaughtException", msg)
-
-
-if __name__ == "__main__":
-    worker = FrameWorkerChild()
-    asyncio.run(worker.listen())
-    # asyncio.run(worker.listen(), debug=True)