@camera.ui/server 0.0.1

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

@@ -0,0 +1,922 @@
+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
+
+import nats
+from camera_ui_types import DecoderFormat, FrameData, FrameMetadata, ImageOptions
+from image_utils import process_image_threaded
+from nats.aio.client import Client as NatsConnection
+from nats.aio.msg import Msg
+from nats.aio.subscription import Subscription
+from nats.errors import NoRespondersError, TimeoutError
+from plugins.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.packer import pack, unpack
+from utilities.task import TaskSet
+
+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,
+}
+
+PIX_FMT: Literal["yuv420p", "rgb24"] = "yuv420p"
+
+
+class FrameWorkerChild:
+    def __init__(self):
+        self.camera_id = config["cameraId"]
+        self.camera_name = config["cameraName"]
+        self.ffmpeg_path = config["ffmpegPath"]
+
+        self.logger = PluginLogger("Frame Worker", config["disableTimestamps"])
+        self.logger.debug_enabled = config["logLevel"] == "debug" or config["logLevel"] == "trace"
+        self.logger.trace_enabled = config["logLevel"] == "trace"
+
+        self.subject = f"{config['frameWorkerId']}.frameWorkerChild"
+        self.ipc_subject = f"{config['frameWorkerId']}.frameWorker"
+        self.image_subject = f"{config['cameraId']}.frameGenerator"
+        self.signaling_subject = f"{config['cameraId']}.frameGenerator.signaling"
+        self.frame_subject = f"{config['cameraId']}.frameReceiver"
+
+        self.publisher: Optional[NatsConnection] = None
+        self.signaling_publisher: Optional[NatsConnection] = None
+        self.image_publisher: Optional[NatsConnection] = None
+        self.frame_publisher: Optional[NatsConnection] = None
+
+        self.subscriber: Optional[Subscription] = None
+        self.image_subscriber: Optional[Subscription] = None
+        self.signal_subscriber: Optional[Subscription] = None
+
+        self.max_diff_frame = 3
+        self.restart_delay = 5
+        self.stopped = False
+        self.closed = False
+        self.restarting = False
+        self.clients: dict[str, FrameWorkerClient] = {}
+        self.tasks: TaskSet = TaskSet(f"{self.camera_name} 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
+
+    @property
+    def log_prefix(self) -> str:
+        return f"{self.camera_name}:"
+
+    @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()
+
+        async def ignore_cb(e: Optional[Any] = None):
+            pass
+
+        self.publisher = await nats.connect(
+            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
+            name=self.subject,
+            user=config["auth"]["user"],
+            password=config["auth"]["password"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        self.image_publisher = await nats.connect(
+            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
+            name=self.image_subject,
+            user=config["auth"]["user"],
+            password=config["auth"]["password"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        self.frame_publisher = await nats.connect(
+            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
+            name=self.frame_subject,
+            user=config["auth"]["user"],
+            password=config["auth"]["password"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        self.signaling_publisher = await nats.connect(
+            servers=[endpoint for endpoint in config["proxyEndpoints"] if endpoint.startswith("nats://")],
+            name=self.signaling_subject,
+            user=config["auth"]["user"],
+            password=config["auth"]["password"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        self.subscriber = await self.publisher.subscribe(subject=self.subject)
+        self.image_subscriber = await self.image_publisher.subscribe(subject=self.image_subject)
+        self.signal_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
+
+        await asyncio.gather(
+            self.send("started"),
+            self.listen_to_ipc_messages(),
+            self.listen_to_signaling_messages(),
+            self.listen_to_prebuffered_image_messages(),
+        )
+
+        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
+            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.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:
+        if self.ffmpeg_process:
+            return
+
+        # 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:
+            ffmpeg_process = cast(Optional[asyncio.subprocess.Process], self.ffmpeg_process)
+            if ffmpeg_process and ffmpeg_process.returncode is None:
+                ffmpeg_process.kill()
+            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(config['resolution']))},fps=fps={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.ffmpeg_path, 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:
+            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:
+                await self.start()
+
+            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()
+            restart_timeout = None
+
+            def is_closed() -> bool:
+                return (
+                    self.stopped
+                    or self.closed
+                    or not self.frame_publisher
+                    or self.frame_publisher.is_closed
+                    or not self.ffmpeg_process
+                    or not self.ffmpeg_process.stdout
+                    or self.ffmpeg_process.returncode is not None
+                )
+
+            def restart_watchdog():
+                nonlocal restart_timeout
+                if restart_timeout:
+                    restart_timeout.cancel()
+                restart_timeout = asyncio.get_event_loop().call_later(
+                    3, lambda: asyncio.create_task(restart_ffmpeg())
+                )
+
+            async def restart_ffmpeg():
+                if not self.stopped and not self.closed and not self.restarting:
+                    self.logger.error(
+                        f"{self.log_prefix} FFmpeg process is not producing frames, restarting..."
+                    )
+                    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"]),
+                    )
+
+                    if is_closed():
+                        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, pack(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
+        except asyncio.CancelledError:
+            pass
+
+    async def handle_ffmpeg_close(self) -> None:
+        try:
+            if self.ffmpeg_process:
+                code = await self.ffmpeg_process.wait()
+                self.ffmpeg_process = None
+
+                await self.reset()
+
+                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)"
+                    )
+
+                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 = 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,
+        }
+
+        msg = await self.publisher.request(
+            self.ipc_subject,
+            pack(worker_message),
+            timeout=30,
+        )
+
+        response: MainToWorkerResponse = unpack(msg.data)
+
+        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)}")
+
+        await self.send("updateClient", {"pluginId": client.plugin_id, "requestIds": client.request_ids})
+
+        if len(self.clients) == 1:
+            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:
+            await self.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, pack(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.camera_id, 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:
+                ping_message: PingMessage = {"type": "ping", "requestId": request_id}
+
+                # self.logger.trace(f"{self.log_prefix} Sending ping to {camera_id}:{plugin_id}")
+
+                msg = await self.signaling_publisher.request(
+                    ping_target_subject,
+                    pack(ping_message),
+                    timeout=ping_timeout,
+                )
+
+                ping_response: PongMessage = unpack(msg.data)
+
+                if not request_id_exists():
+                    break
+
+                if ping_response["type"] != "pong":
+                    raise Exception("Invalid response to ping")
+
+                # self.logger.trace(f"{self.log_prefix} Received pong from {camera_id}:{plugin_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 {camera_id}:{plugin_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 listen_to_ipc_messages(self) -> None:
+        if not self.subscriber:
+            raise Exception("Subscriber not initialized")
+
+        async for msg in self.subscriber.messages:
+            try:
+                if self.closed:
+                    break
+
+                if len(msg.data) == 0:
+                    continue
+
+                self.tasks.add(self.respond_on_ipc_message(msg))
+            except Exception as e:
+                if not self.closed:
+                    self.logger.error(f"{self.log_prefix} Error while processing IPC message:", e)
+                else:
+                    break
+
+    async def listen_to_signaling_messages(self) -> None:
+        if not self.signal_subscriber:
+            raise Exception("Subscriber not initialized")
+
+        async for msg in self.signal_subscriber.messages:
+            try:
+                if self.closed:
+                    break
+
+                if len(msg.data) == 0:
+                    continue
+
+                self.tasks.add(self.respond_on_signaling_message(msg))
+            except Exception as e:
+                if not self.closed:
+                    self.logger.error(f"{self.log_prefix} Error while processing signaling message:", e)
+                else:
+                    break
+
+    async def listen_to_prebuffered_image_messages(self) -> None:
+        if not self.image_subscriber:
+            raise Exception("Subscriber not initialized")
+
+        async for msg in self.image_subscriber.messages:
+            try:
+                if self.closed:
+                    break
+
+                if len(msg.data) == 0:
+                    continue
+
+                self.tasks.add(self.respond_on_prebuffered_image_message(msg))
+            except Exception as e:
+                if not self.closed:
+                    self.logger.error(f"{self.log_prefix} Error while processing image message:", e)
+                else:
+                    break
+
+    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.camera_name = 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(processed_image)
+                return
+
+            await msg.respond(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 / 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 / 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(), debug=True)