camera.ui3 0.0.30-alpha.0

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

@@ -0,0 +1,882 @@
+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)