@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/dist/server/src/decoder/python/image_utils.py

@@ -0,0 +1,196 @@
+from typing import Any, Literal, Union
+
+import numpy as np
+from PIL import Image
+
+from _camera_ui_tools.camera_ui_common import to_thread
+from _camera_ui_tools.camera_ui_types import (
+    DecoderFormat,
+    ImageCrop,
+    ImageFormat,
+    ImageOptions,
+    ImageResize,
+)
+
+_YUV2RGB_MATRIX = np.array([[1.0, 0.0, 1.402], [1.0, -0.344136, -0.714136], [1.0, 1.772, 0.0]]).T
+
+
+async def process_image_threaded(
+    image_data: bytes,
+    input_width: int,
+    input_height: int,
+    input_format: Union[DecoderFormat, Literal["rgba"], Literal["gray"]],
+    options: ImageOptions,
+) -> bytes:
+    return await to_thread(
+        lambda: process_image(image_data, input_width, input_height, input_format, options)
+    )
+
+
+def process_image(
+    image_data: bytes,
+    input_width: int,
+    input_height: int,
+    input_format: Union[DecoderFormat, Literal["rgba"], Literal["gray"]],
+    options: ImageOptions,
+) -> bytes:
+    image: Union[Image.Image, None] = None
+
+    crop = options.get("crop", None)
+    resize = options.get("resize", None)
+    format = options.get("format", None)
+
+    if format and format["to"] == "gray":
+        if input_format == "yuv420p":
+            gray = yuv420_to_gray(image_data, input_width, input_height)
+            image = Image.fromarray(gray)
+        elif input_format == "nv12":
+            gray = nv12_to_gray(image_data, input_width, input_height)
+            image = Image.fromarray(gray)
+        elif input_format == "rgb24":
+            image = Image.frombytes("RGB", (input_width, input_height), image_data).convert("L")
+        elif input_format == "rgba":
+            image = Image.frombytes("RGBA", (input_width, input_height), image_data).convert("L")
+        else:
+            image = Image.frombytes("L", (input_width, input_height), image_data)
+
+        format = None
+    elif format and format["to"] == "rgba":
+        if input_format == "yuv420p":
+            rgba = yuv420_to_rgba(image_data, input_width, input_height)
+            image = Image.fromarray(rgba)
+        elif input_format == "nv12":
+            rgba = nv12_to_rgba(image_data, input_width, input_height)
+            image = Image.fromarray(rgba)
+        elif input_format == "rgb24":
+            image = Image.frombytes("RGB", (input_width, input_height), image_data).convert("RGBA")
+        elif input_format == "gray":
+            image = Image.frombytes("L", (input_width, input_height), image_data).convert("RGBA")
+        else:
+            image = Image.frombytes("RGBA", (input_width, input_height), image_data)
+
+        format = None
+    else:
+        if input_format == "yuv420p":
+            rgb = yuv420_to_rgb(image_data, input_width, input_height)
+            image = Image.fromarray(rgb)
+        elif input_format == "nv12":
+            rgb = nv12_to_rgb(image_data, input_width, input_height)
+            image = Image.fromarray(rgb)
+        elif input_format == "rgb24":
+            image = Image.frombytes("RGB", (input_width, input_height), image_data)
+        elif input_format == "gray":
+            image = Image.frombytes("L", (input_width, input_height), image_data)
+        else:
+            image = Image.frombytes("RGBA", (input_width, input_height), image_data)
+
+    if crop:
+        image = crop_image(image, crop)
+        input_width = crop["width"]
+        input_height = crop["height"]
+
+    if resize:
+        image = resize_image(image, input_width, input_height, resize)
+        input_width = resize["width"]
+        input_height = resize["height"]
+
+    if format:
+        image = format_image(image, format)
+
+    return image.tobytes()
+
+
+def crop_image(image: Image.Image, crop: ImageCrop) -> Image.Image:
+    crop_box = (
+        int(crop["left"]),
+        int(crop["top"]),
+        int(crop["left"] + crop["width"]),
+        int(crop["top"] + crop["height"]),
+    )
+
+    return image.crop(crop_box)
+
+
+def resize_image(image: Image.Image, input_width: int, input_height: int, resize: ImageResize) -> Image.Image:
+    width = resize["width"]
+    height = resize["height"]
+
+    if width and height and (width != input_width or height != input_height):
+        image = image.resize((int(width), int(height)), resample=Image.Resampling.BILINEAR)
+
+    return image
+
+
+def format_image(image: Image.Image, format: ImageFormat) -> Image.Image:
+    if format["to"] == "rgba":
+        image = image.convert("RGBA")
+    elif format["to"] == "gray":
+        image = image.convert("L")
+
+    return image
+
+
+def yuv420_to_rgb(yuv_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    frame_size = width * height
+    uv_size = frame_size // 4
+
+    raw_data = np.frombuffer(yuv_bytes, dtype=np.uint8)
+
+    y = raw_data[:frame_size].reshape((height, width)).astype(np.float32) - 16.0
+    u = (
+        raw_data[frame_size : frame_size + uv_size].reshape((height // 2, width // 2)).astype(np.float32)
+        - 128.0
+    )
+    v = raw_data[frame_size + uv_size :].reshape((height // 2, width // 2)).astype(np.float32) - 128.0
+
+    u = u.repeat(2, axis=0).repeat(2, axis=1)
+    v = v.repeat(2, axis=0).repeat(2, axis=1)
+
+    r = y + 1.402 * v
+    g = y - 0.344136 * u - 0.714136 * v
+    b = y + 1.772 * u
+
+    rgb = np.stack((r, g, b), axis=-1)
+    return np.clip(rgb, 0, 255).astype(np.uint8)
+
+
+def yuv420_to_rgba(yuv_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    rgb = yuv420_to_rgb(yuv_bytes, width, height)
+    alpha = np.full((height, width, 1), 255, dtype=np.uint8)
+    rgba = np.concatenate((rgb, alpha), axis=-1)
+    return rgba
+
+
+def yuv420_to_gray(yuv_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    frame_size = width * height
+    raw_data = np.frombuffer(yuv_bytes, dtype=np.uint8)
+    return raw_data[:frame_size].reshape((height, width)).astype(np.uint8)
+
+
+def nv12_to_gray(nv12_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    frame_size = width * height
+    raw_data = np.frombuffer(nv12_bytes, dtype=np.uint8)
+    return raw_data[:frame_size].reshape((height, width))
+
+
+def nv12_to_rgb(nv12_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    frame_size = width * height
+
+    raw_data = np.frombuffer(nv12_bytes, dtype=np.uint8)
+    y = raw_data[:frame_size].reshape((height, width)).astype(np.float32) - 16.0
+    uv_plane = raw_data[frame_size:].reshape((height // 2, width)).astype(np.float32) - 128.0
+
+    u = uv_plane[:, 0::2].repeat(2, axis=0).repeat(2, axis=1)
+    v = uv_plane[:, 1::2].repeat(2, axis=0).repeat(2, axis=1)
+
+    yuv = np.stack((y, u, v), axis=-1)
+
+    rgb = np.dot(yuv, _YUV2RGB_MATRIX)
+
+    return np.clip(rgb, 0, 255).astype(np.uint8)
+
+
+def nv12_to_rgba(nv12_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    rgb = nv12_to_rgb(nv12_bytes, width, height)
+    alpha = np.full((height, width, 1), 255, dtype=np.uint8)
+    return np.concatenate((rgb, alpha), axis=-1)

package/dist/server/src/decoder/python/pool.py

@@ -0,0 +1,45 @@
+import weakref
+
+
+class FramePool:
+    def __init__(self, frame_size: int, max_pool_size: int = 4):
+        self._frame_size = frame_size
+        self._max_pool_size = max_pool_size
+        self._pool: list[memoryview] = []
+        self._in_use: dict[int, weakref.ref[memoryview]] = {}
+
+        # Initial pool filling
+        for _ in range(max_pool_size):
+            self._pool.append(memoryview(bytearray(frame_size)))
+
+    def get(self) -> memoryview:
+        self._cleanup_expired_refs()
+        frame = self._pool.pop() if self._pool else memoryview(bytearray(self._frame_size))
+        frame_id = id(frame)
+
+        def callback(ref: weakref.ref[memoryview]) -> None:
+            return self._on_frame_collected(frame_id)
+
+        self._in_use[frame_id] = weakref.ref(frame, callback)
+
+        return frame
+
+    def release(self, frame: memoryview) -> None:
+        if frame.nbytes != self._frame_size:
+            return  # Ignore invalid frames
+
+        frame_id = id(frame)
+        if frame_id in self._in_use:
+            del self._in_use[frame_id]
+
+            if len(self._pool) < self._max_pool_size:
+                self._pool.append(frame)
+
+    def _cleanup_expired_refs(self) -> None:
+        expired = [frame_id for frame_id, ref in self._in_use.items() if ref() is None]
+        for frame_id in expired:
+            del self._in_use[frame_id]
+
+    def _on_frame_collected(self, frame_id: int) -> None:
+        if frame_id in self._in_use:
+            del self._in_use[frame_id]

package/dist/server/src/decoder/python/typings.py

@@ -0,0 +1,57 @@
+from collections.abc import AsyncGenerator
+from typing import Any, Optional, Protocol, Union, runtime_checkable
+
+from typing_extensions import Literal, TypedDict
+
+from _camera_ui_tools.camera_ui_types import (
+    CameraFrameWorkerDecoder,
+    CameraFrameWorkerResolution,
+    DecoderFormat,
+    FrameBuffer,
+    FrameData,
+    ImageOptions,
+)
+
+
+class AuthConfig(TypedDict):
+    user: str
+    password: str
+
+
+PixelFormat = Literal["yuv420p", "rgb24", "nv12"]
+
+
+class BaseFrameWorkerConfig(TypedDict):
+    cameraId: str
+    cameraName: str
+    cameraSource: str
+    ffmpegPath: str
+    auth: AuthConfig
+    proxyEndpoints: list[str]
+    fps: int
+    resolution: CameraFrameWorkerResolution
+    decoder: CameraFrameWorkerDecoder
+
+
+class WorkerToMainMessage(TypedDict):
+    message: Literal["started"]
+    data: dict[str, Any]
+
+
+@runtime_checkable
+class FrameWorkerInterface(Protocol):
+    def generateFrames(self, options: Optional[ImageOptions] = None) -> AsyncGenerator[FrameData, None]: ...
+    async def processFrame(
+        self,
+        frame: Union[bytes, bytearray],
+        width: int,
+        height: int,
+        format: Union[DecoderFormat, Literal["rgba", "gray"]],
+        options: ImageOptions,
+    ) -> FrameBuffer: ...
+    async def getPrebufferedFrame(
+        self,
+        timestamp: int,
+        options: Optional[ImageOptions] = None,
+        max_difference: Optional[int] = 100,
+    ) -> Optional[FrameData]: ...

package/dist/server/src/decoder/python/utils.py

@@ -0,0 +1,70 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass
+class TCPConnectionDetails:
+    server: asyncio.Server
+    server_url: str
+    server_address: str
+    server_port: int
+    connection_promise: asyncio.Future[tuple[asyncio.StreamReader, asyncio.StreamWriter]]
+
+    def terminate(self) -> None:
+        self.server.close()
+
+
+async def create_single_connection_server(
+    bind_address: str = "127.0.0.1", config: Optional[dict[str, Any]] = None, wait_duration: float = 30.0
+) -> TCPConnectionDetails:
+    if not config:
+        config = {}
+
+    if not bind_address or bind_address == "0.0.0.0":
+        bind_address = "127.0.0.1"
+
+    connection_future: asyncio.Future[tuple[asyncio.StreamReader, asyncio.StreamWriter]] = asyncio.Future()
+
+    async def client_connected(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        if not connection_future.done():
+            connection_future.set_result((reader, writer))
+
+    server = await asyncio.start_server(
+        client_connected,
+        host=bind_address,
+        port=0,
+        **config,
+    )
+
+    server_port = 0
+    for sock in server.sockets:
+        _, server_port = sock.getsockname()
+        break
+
+    if server_port == 0:
+        raise RuntimeError("Konnte keinen Server-Port zuweisen")
+
+    def on_timeout() -> None:
+        if not connection_future.done():
+            connection_future.set_exception(
+                TimeoutError(f"Verbindungs-Timeout nach {wait_duration} Sekunden")
+            )
+            server.close()
+
+    timeout_handle = asyncio.get_running_loop().call_later(wait_duration, on_timeout)
+
+    def cancel_timeout(future: asyncio.Future[tuple[asyncio.StreamReader, asyncio.StreamWriter]]) -> None:
+        timeout_handle.cancel()
+        if future.exception() and server.is_serving():
+            server.close()
+
+    connection_future.add_done_callback(cancel_timeout)
+
+    return TCPConnectionDetails(
+        server=server,
+        server_url=f"tcp://{bind_address}:{server_port}",
+        server_address=bind_address,
+        server_port=server_port,
+        connection_promise=connection_future,
+    )

package/dist/server/src/decoder/types.d.ts

@@ -0,0 +1,23 @@
+import type { AuthConfig } from '@camera.ui/rpc-common';
+import type { CameraFrameWorkerDecoder, CameraFrameWorkerResolution, DecoderFormat, FrameBuffer, FrameData, ImageOptions } from '@camera.ui/types';
+export type PixelFormat = 'yuv420p' | 'rgb24' | 'nv12';
+export interface BaseFrameWorkerConfig {
+    cameraId: string;
+    cameraName: string;
+    cameraSource: string;
+    ffmpegPath: string;
+    auth: AuthConfig;
+    proxyEndpoints: string[];
+    fps: number;
+    resolution: CameraFrameWorkerResolution;
+    decoder: CameraFrameWorkerDecoder;
+}
+export interface WorkerToMainMessage {
+    message: 'started';
+    data: Record<string, any>;
+}
+export interface FrameWorkerInterface {
+    generateFrames(options?: ImageOptions): AsyncGenerator<FrameData>;
+    processFrame(frame: Buffer | Uint8Array, width: number, height: number, format: DecoderFormat | 'rgba' | 'gray', options: ImageOptions): Promise<FrameBuffer>;
+    getPrebufferedFrame(timestamp: number, options?: ImageOptions, maxDifference?: number): Promise<FrameData | undefined>;
+}

package/dist/server/src/decoder/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/decoder/types.ts"],"names":[],"mappings":""}

package/dist/server/src/decoder/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Server, ServerOpts, Socket } from 'node:net';
+export interface TCPConnectionDetails {
+    server: Server;
+    terminate: () => void;
+    serverUrl: string;
+    serverAddress: string;
+    serverPort: number;
+    connectionPromise: Promise<Socket>;
+}
+export declare function bindRandomPort(server: Server, bindAddress: string): Promise<number>;
+export declare function createSingleConnectionServer(bindAddress: string, config?: ServerOpts & {
+    secure?: boolean;
+}, waitDuration?: number): Promise<TCPConnectionDetails>;

package/dist/server/src/decoder/utils.js

@@ -0,0 +1,45 @@
+import { createServer } from 'node:net';
+import { createServer as createTLSServer } from 'node:tls';
+export async function bindRandomPort(server, bindAddress) {
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, bindAddress || '127.0.0.1', () => {
+            server.removeListener('error', reject);
+            const addressInfo = server.address();
+            resolve(addressInfo.port);
+        });
+    });
+}
+export async function createSingleConnectionServer(bindAddress, config, waitDuration = 30000) {
+    const server = config?.secure ? createTLSServer(config) : createServer(config);
+    const serverPort = await bindRandomPort(server, bindAddress);
+    let terminate = () => { };
+    const connectionPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Connection timed out'));
+        }, waitDuration);
+        terminate = () => {
+            clearTimeout(timeout);
+            server.close();
+        };
+        server.once('connection', (clientSocket) => {
+            terminate();
+            resolve(clientSocket);
+        });
+    });
+    connectionPromise.catch(() => { });
+    let serverAddress = bindAddress;
+    if (!serverAddress || serverAddress === '0.0.0.0') {
+        serverAddress = '127.0.0.1';
+    }
+    return {
+        server,
+        terminate,
+        serverUrl: `tcp://${serverAddress}:${serverPort}`,
+        serverAddress,
+        serverPort,
+        connectionPromise,
+    };
+}
+//# sourceMappingURL=utils.js.map

package/dist/server/src/decoder/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/decoder/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,YAAY,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC;AAa3D,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAAc,EAAE,WAAmB;IACtE,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC7C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAE7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,IAAI,WAAW,EAAE,GAAG,EAAE;YAChD,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YACvC,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,EAAiB,CAAC;YACpD,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAAC,WAAmB,EAAE,MAA0C,EAAE,YAAY,GAAG,KAAK;IACtI,MAAM,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC/E,MAAM,UAAU,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAE7D,IAAI,SAAS,GAAe,GAAG,EAAE,GAAE,CAAC,CAAC;IACrC,MAAM,iBAAiB,GAAG,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAChE,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;YAC9B,MAAM,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC,CAAC;QAC5C,CAAC,EAAE,YAAY,CAAC,CAAC;QAEjB,SAAS,GAAG,GAAG,EAAE;YACf,YAAY,CAAC,OAAO,CAAC,CAAC;YACtB,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,CAAC;QAEF,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,YAAY,EAAE,EAAE;YACzC,SAAS,EAAE,CAAC;YACZ,OAAO,CAAC,YAAY,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,iBAAiB,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAElC,IAAI,aAAa,GAAG,WAAW,CAAC;IAChC,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QAClD,aAAa,GAAG,WAAW,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,MAAM;QACN,SAAS;QACT,SAAS,EAAE,SAAS,aAAa,IAAI,UAAU,EAAE;QACjD,aAAa;QACb,UAAU;QACV,iBAAiB;KAClB,CAAC;AACJ,CAAC"}

package/dist/server/src/decoder/wasm/build/decoder.d.ts

@@ -0,0 +1,43 @@
+declare namespace __AdaptedExports {
+  /** Exported memory */
+  export const memory: WebAssembly.Memory;
+  // Exported runtime interface
+  export function __new(size: number, id: number): number;
+  export function __pin(ptr: number): number;
+  export function __unpin(ptr: number): void;
+  export function __collect(): void;
+  export const __rtti_base: number;
+  /**
+   * assembly/index/processImage
+   * @param inputFrame `~lib/typedarray/Uint8Array`
+   * @param inputWidth `i32`
+   * @param inputHeight `i32`
+   * @param format `i32`
+   * @param cropTop `i32`
+   * @param cropLeft `i32`
+   * @param cropWidth `i32`
+   * @param cropHeight `i32`
+   * @param resizeWidth `i32`
+   * @param resizeHeight `i32`
+   * @param blurRadius `i32`
+   * @param inputFormat `i32`
+   * @param reconvertYUV `i32`
+   * @returns `~lib/typedarray/Uint8Array`
+   */
+  export function processImage(inputFrame: Uint8Array, inputWidth: number, inputHeight: number, format: number, cropTop: number, cropLeft: number, cropWidth: number, cropHeight: number, resizeWidth: number, resizeHeight: number, blurRadius: number, inputFormat: number, reconvertYUV: number): Uint8Array;
+  /** assembly/index/Uint8Array_ID */
+  export const Uint8Array_ID: {
+    /** @type `u32` */
+    get value(): number
+  };
+  /**
+   * assembly/console/log
+   * @param s `~lib/string/String`
+   */
+  export function log(s: string): void;
+}
+/** Instantiates the compiled WebAssembly module with the given imports. */
+export declare function instantiate(module: WebAssembly.Module, imports: {
+  env: unknown,
+  console: unknown,
+}): Promise<typeof __AdaptedExports>;

package/dist/server/src/decoder/wasm/build/decoder.js

@@ -0,0 +1,108 @@
+export async function instantiate(module, imports = {}) {
+  const __module0 = imports.console;
+  const adaptedImports = {
+    env: Object.assign(Object.create(globalThis), imports.env || {}, {
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+    }),
+    console: Object.assign(Object.create(__module0), {
+      log(s) {
+        // assembly/console/log(~lib/string/String) => void
+        s = __liftString(s >>> 0);
+        __module0.log(s);
+      },
+    }),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    processImage(inputFrame, inputWidth, inputHeight, format, cropTop, cropLeft, cropWidth, cropHeight, resizeWidth, resizeHeight, blurRadius, inputFormat, reconvertYUV) {
+      // assembly/index/processImage(~lib/typedarray/Uint8Array, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) => ~lib/typedarray/Uint8Array
+      inputFrame = __lowerTypedArray(Uint8Array, 7, 0, inputFrame) || __notnull();
+      return __liftTypedArray(Uint8Array, exports.processImage(inputFrame, inputWidth, inputHeight, format, cropTop, cropLeft, cropWidth, cropHeight, resizeWidth, resizeHeight, blurRadius, inputFormat, reconvertYUV) >>> 0);
+    },
+    Uint8Array_ID: {
+      // assembly/index/Uint8Array_ID: u32
+      valueOf() { return this.value; },
+      get value() {
+        return exports.Uint8Array_ID.value >>> 0;
+      }
+    },
+    log(s) {
+      // assembly/console/log(~lib/string/String) => void
+      s = __lowerString(s) || __notnull();
+      exports.log(s);
+    },
+  }, exports);
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __lowerString(value) {
+    if (value == null) return 0;
+    const
+      length = value.length,
+      pointer = exports.__new(length << 1, 2) >>> 0,
+      memoryU16 = new Uint16Array(memory.buffer);
+    for (let i = 0; i < length; ++i) memoryU16[(pointer >>> 1) + i] = value.charCodeAt(i);
+    return pointer;
+  }
+  function __liftTypedArray(constructor, pointer) {
+    if (!pointer) return null;
+    return new constructor(
+      memory.buffer,
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
+    ).slice();
+  }
+  function __lowerTypedArray(constructor, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    new constructor(memory.buffer, buffer, length).set(values);
+    exports.__unpin(buffer);
+    return header;
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  return adaptedExports;
+}

package/dist/server/src/decoder/worker.d.ts

@@ -0,0 +1 @@
+export {};