@luxonis/depthai-viewer-common 3.7.4 → 3.7.6

package/dist/visualizer/messaging/deserialization/video/rgbd-to-pointcloud.js

@@ -0,0 +1,651 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+import { releaseProxy, transfer, wrap } from "comlink";
+import { Profile } from "../../../protobuf.generated/EncodedFrame.js";
+import { Type } from "../../../protobuf.generated/ImgFrame.js";
+import { constructKeyForTopicRenderMetrics, globalDecodeMetricsManager, globalInputEventMetricsManager, globalRenderMetricsManager, } from "../../../utils/metrics-manager.js";
+import { parseMessage } from "../../parse-utils.js";
+import { VisualizerNumericType } from "../../schema-constants.js";
+import { uint8ArrayToUint16Array } from "../pointcloud/utils.js";
+import { deserializeDepthFrame } from "./depth.js";
+import { convertNv12ToI420, deserializeEncodedFrameH264 } from "./h264.js";
+import { deserializeEncodedFrameH265 } from "./h265.js";
+import { deserializeMJPEGFrame } from "./mjpeg.js";
+const RGBD_POINTCLOUD_WORKER_COUNT = 6;
+const RGBD_POINTCLOUD_WORKER_TIMEOUT_MS = 15_000;
+const RGBD_POINTCLOUD_SCHEDULE_DELAY_MS = 0;
+const ENABLE_RGBD_GPU_BATCHING = true;
+const RGBD_GPU_BATCH_SIZE = 2;
+const RGBD_GPU_BATCH_FLUSH_DELAY_MS = 8;
+const RGBD_POINTCLOUD_IDLE_CLEANUP_MS = 30_000;
+let cachedRGBDHasGPU;
+let rgbdHasGPUPromise;
+let rgbdPointCloudWorkers;
+let rgbdPointCloudWorkerIndex = 0;
+let rgbdPointCloudIdleCleanupTimeoutId;
+const rgbdIntrinsicsByTopic = new Map();
+const pendingRGBDBatches = new Map();
+function collectArrayBuffers(arrays) {
+    const buffers = [];
+    for (let index = 0; index < arrays.length; index++) {
+        const array = arrays[index];
+        if (array) {
+            buffers.push(array.buffer);
+        }
+    }
+    return buffers;
+}
+function ensureEvenByteLength(data) {
+    if (data.length % 2 === 0) {
+        return data;
+    }
+    const padded = new Uint8Array(data.length + 1);
+    padded.set(data);
+    return padded;
+}
+function ensureRGBDGPUSupportDetection() {
+    if (cachedRGBDHasGPU != undefined || rgbdHasGPUPromise) {
+        return;
+    }
+    rgbdHasGPUPromise = (async () => {
+        if (typeof navigator.gpu === "undefined") {
+            cachedRGBDHasGPU = false;
+            return false;
+        }
+        try {
+            const adapter = await navigator.gpu.requestAdapter();
+            cachedRGBDHasGPU = adapter != undefined;
+            return cachedRGBDHasGPU;
+        }
+        catch {
+            cachedRGBDHasGPU = false;
+            return false;
+        }
+        finally {
+            rgbdHasGPUPromise = undefined;
+        }
+    })();
+}
+function getRGBDGPUSupport() {
+    ensureRGBDGPUSupportDetection();
+    return cachedRGBDHasGPU ?? false;
+}
+function ensureRGBDPointCloudWorkers() {
+    if (!rgbdPointCloudWorkers) {
+        rgbdPointCloudWorkers = Array.from({ length: RGBD_POINTCLOUD_WORKER_COUNT }, () => {
+            return createRGBDPointCloudWorkerSlot();
+        });
+    }
+    return rgbdPointCloudWorkers;
+}
+function createRGBDPointCloudWorkerSlot() {
+    const worker = new Worker(new URL("../pointcloud/pointcloudFromDepth.worker.js", import.meta.url), {
+        type: "module",
+    });
+    const remote = wrap(worker);
+    return {
+        worker,
+        remote,
+        activeJobs: 0,
+        dispose: () => {
+            remote[releaseProxy]();
+            worker.terminate();
+        },
+    };
+}
+function clearRGBDPointCloudIdleCleanupTimeout() {
+    if (rgbdPointCloudIdleCleanupTimeoutId != undefined) {
+        clearTimeout(rgbdPointCloudIdleCleanupTimeoutId);
+        rgbdPointCloudIdleCleanupTimeoutId = undefined;
+    }
+}
+function hasActiveRGBDPointCloudWork() {
+    const hasActiveJobs = rgbdPointCloudWorkers?.some((slot) => slot.activeJobs > 0) ?? false;
+    return hasActiveJobs || pendingRGBDBatches.size > 0;
+}
+function disposeRGBDPointCloudWorkers() {
+    clearRGBDPointCloudIdleCleanupTimeout();
+    for (const batch of pendingRGBDBatches.values()) {
+        clearRGBDBatchFlush(batch);
+    }
+    pendingRGBDBatches.clear();
+    rgbdIntrinsicsByTopic.clear();
+    if (rgbdPointCloudWorkers) {
+        for (const slot of rgbdPointCloudWorkers) {
+            slot.dispose();
+        }
+        rgbdPointCloudWorkers = undefined;
+    }
+    rgbdPointCloudWorkerIndex = 0;
+}
+function scheduleRGBDPointCloudWorkersCleanup() {
+    clearRGBDPointCloudIdleCleanupTimeout();
+    rgbdPointCloudIdleCleanupTimeoutId = setTimeout(() => {
+        if (hasActiveRGBDPointCloudWork()) {
+            scheduleRGBDPointCloudWorkersCleanup();
+            return;
+        }
+        disposeRGBDPointCloudWorkers();
+    }, RGBD_POINTCLOUD_IDLE_CLEANUP_MS);
+}
+function markRGBDPointCloudWorkersActive() {
+    scheduleRGBDPointCloudWorkersCleanup();
+}
+function replaceRGBDPointCloudWorker(index) {
+    const slots = ensureRGBDPointCloudWorkers();
+    const currentSlot = slots[index];
+    currentSlot?.dispose();
+    const replacementSlot = createRGBDPointCloudWorkerSlot();
+    slots[index] = replacementSlot;
+    markRGBDPointCloudWorkersActive();
+    return replacementSlot;
+}
+function tryAcquireRGBDPointCloudWorkerSlot() {
+    const ensuredSlots = ensureRGBDPointCloudWorkers();
+    markRGBDPointCloudWorkersActive();
+    for (let offset = 0; offset < ensuredSlots.length; offset++) {
+        const index = (rgbdPointCloudWorkerIndex + offset) % ensuredSlots.length;
+        const slot = ensuredSlots[index];
+        if (!slot || slot.activeJobs > 0) {
+            continue;
+        }
+        slot.activeJobs = 1;
+        rgbdPointCloudWorkerIndex = (index + 1) % ensuredSlots.length;
+        return { slot, index };
+    }
+    return undefined;
+}
+function repackYuv420pToI420(imageFrame, width, height) {
+    const specs = imageFrame.fb ?? imageFrame.sourceFb;
+    const source = ensureEvenByteLength(imageFrame.data);
+    const yStride = specs?.stride || width;
+    const uvWidth = Math.ceil(width / 2);
+    const uvHeight = Math.ceil(height / 2);
+    const uvStride = yStride > width ? Math.floor(yStride / 2) : uvWidth;
+    const yPlaneSize = width * height;
+    const uvPlaneSize = uvWidth * uvHeight;
+    const uOffset = specs?.p1Offset || yStride * height;
+    const vOffset = specs?.p2Offset || uOffset + uvStride * uvHeight;
+    const i420 = new Uint8Array(yPlaneSize + 2 * uvPlaneSize);
+    for (let row = 0; row < height; row++) {
+        const srcOffset = row * yStride;
+        const dstOffset = row * width;
+        i420.set(source.subarray(srcOffset, srcOffset + width), dstOffset);
+    }
+    for (let row = 0; row < uvHeight; row++) {
+        const srcUOffset = uOffset + row * uvStride;
+        const srcVOffset = vOffset + row * uvStride;
+        const dstOffset = row * uvWidth;
+        i420.set(source.subarray(srcUOffset, srcUOffset + uvWidth), yPlaneSize + dstOffset);
+        i420.set(source.subarray(srcVOffset, srcVOffset + uvWidth), yPlaneSize + uvPlaneSize + dstOffset);
+    }
+    return i420;
+}
+function getRGBDIntrinsics(topic, message, depthWidth, depthHeight, fallbackIntrinsics) {
+    const resolvedIntrinsics = resolveRGBDIntrinsicsFromMessage(message, depthWidth, depthHeight);
+    if (resolvedIntrinsics) {
+        rgbdIntrinsicsByTopic.set(topic, resolvedIntrinsics);
+        return resolvedIntrinsics;
+    }
+    const cachedIntrinsics = rgbdIntrinsicsByTopic.get(topic);
+    if (cachedIntrinsics) {
+        return cachedIntrinsics;
+    }
+    if (hasValidIntrinsics(fallbackIntrinsics)) {
+        return normalizePointCloudIntrinsics(fallbackIntrinsics, depthWidth, depthHeight);
+    }
+    return undefined;
+}
+function hasValidIntrinsics(intrinsics) {
+    const right = intrinsics?.right;
+    return Boolean(right &&
+        Number.isFinite(right.focalLenght?.x) &&
+        Number.isFinite(right.focalLenght?.y) &&
+        Number.isFinite(right.principalPoint?.x) &&
+        Number.isFinite(right.principalPoint?.y));
+}
+function normalizePointCloudIntrinsics(intrinsics, width, height) {
+    const normalizeCamera = (camera) => {
+        let fx = camera.focalLenght.x;
+        let fy = camera.focalLenght.y;
+        let cx = camera.principalPoint.x;
+        let cy = camera.principalPoint.y;
+        if (cx > 0 && cx <= 1 && cy > 0 && cy <= 1) {
+            cx *= width;
+            cy *= height;
+            if (fx > 0 && fx <= 1) {
+                fx *= width;
+            }
+            if (fy > 0 && fy <= 1) {
+                fy *= height;
+            }
+        }
+        else if (cx > width * 0.75 || cy > height * 0.75) {
+            const scaleX = width / (cx * 2);
+            const scaleY = height / (cy * 2);
+            fx *= scaleX;
+            fy *= scaleY;
+            cx *= scaleX;
+            cy *= scaleY;
+        }
+        return {
+            focalLenght: { x: fx, y: fy },
+            principalPoint: { x: cx, y: cy },
+        };
+    };
+    return {
+        left: normalizeCamera(intrinsics.left),
+        right: normalizeCamera(intrinsics.right),
+    };
+}
+function toMatrix3x3(matrix) {
+    const rows = matrix?.arrays;
+    if (!rows || rows.length < 3) {
+        return undefined;
+    }
+    const normalizedRows = rows
+        .slice(0, 3)
+        .map((row) => row?.values.slice(0, 3).map((value) => value ?? 0));
+    if (normalizedRows.some((row) => !row || row.length < 3)) {
+        return undefined;
+    }
+    return normalizedRows;
+}
+function extractIntrinsicsFromTransformation(transformation, targetWidth, targetHeight) {
+    const sourceIntrinsicMatrix = toMatrix3x3(transformation?.sourceIntrinsicMatrix);
+    if (!sourceIntrinsicMatrix) {
+        return undefined;
+    }
+    const fx = sourceIntrinsicMatrix[0][0];
+    const fy = sourceIntrinsicMatrix[1][1];
+    const cx = sourceIntrinsicMatrix[0][2];
+    const cy = sourceIntrinsicMatrix[1][2];
+    if (![fx, fy, cx, cy].every((value) => Number.isFinite(value))) {
+        return undefined;
+    }
+    const sourceWidth = transformation?.srcWidth || transformation?.width || targetWidth;
+    const sourceHeight = transformation?.srcHeight || transformation?.height || targetHeight;
+    const scaleX = sourceWidth > 0 ? targetWidth / sourceWidth : 1;
+    const scaleY = sourceHeight > 0 ? targetHeight / sourceHeight : 1;
+    return {
+        left: {
+            focalLenght: { x: fx * scaleX, y: fy * scaleY },
+            principalPoint: { x: cx * scaleX, y: cy * scaleY },
+        },
+        right: {
+            focalLenght: { x: fx * scaleX, y: fy * scaleY },
+            principalPoint: { x: cx * scaleX, y: cy * scaleY },
+        },
+    };
+}
+function resolveRGBDIntrinsicsFromMessage(message, depthWidth, depthHeight) {
+    return (extractIntrinsicsFromTransformation(message.depthImgFrame?.transformation, depthWidth, depthHeight) ??
+        extractIntrinsicsFromTransformation(message.depthEncodedFrame?.transformation, depthWidth, depthHeight) ??
+        extractIntrinsicsFromTransformation(message.colorImgFrame?.transformation, depthWidth, depthHeight) ??
+        extractIntrinsicsFromTransformation(message.colorEncodedFrame?.transformation, depthWidth, depthHeight));
+}
+async function extractEncodedColorFrame(encodedFrame, topicDecoders, topic) {
+    const decoderTopic = `${topic}::rgbd-color-extract`;
+    const decodeFrame = async () => await new Promise((resolve, reject) => {
+        const callback = (event) => {
+            resolve(event.message);
+        };
+        const rejectDecode = (error) => {
+            reject(error);
+        };
+        const args = {
+            topic: decoderTopic,
+            message: encodedFrame,
+            callback,
+        };
+        if (encodedFrame.profile === Profile.AVC) {
+            void deserializeEncodedFrameH264({
+                ...args,
+                topicDecoders,
+                onError: rejectDecode,
+                outputMode: "i420",
+            }).catch(rejectDecode);
+        }
+        else if (encodedFrame.profile === Profile.JPEG) {
+            void deserializeMJPEGFrame({
+                ...args,
+                outputMode: "i420",
+            }).catch(rejectDecode);
+        }
+        else if (encodedFrame.profile === Profile.HEVC) {
+            void deserializeEncodedFrameH265({
+                ...args,
+                topicDecoders,
+                onError: rejectDecode,
+                outputMode: "i420",
+            }).catch(rejectDecode);
+        }
+        else {
+            reject(new Error(`Unsupported RGBD color profile ${Profile[encodedFrame.profile] ?? encodedFrame.profile}`));
+        }
+    });
+    const decoded = await decodeFrame();
+    return {
+        data: ensureEvenByteLength(decoded.data),
+        width: decoded.width,
+        height: decoded.height,
+    };
+}
+function extractColorFrame(encodedFrame, imageFrame, topicDecoders, topic) {
+    if (encodedFrame) {
+        return extractEncodedColorFrame(encodedFrame, topicDecoders, topic);
+    }
+    if (imageFrame) {
+        const { width, height, type } = parseMessage(imageFrame);
+        const specs = imageFrame.fb ?? imageFrame.sourceFb;
+        if (type === Type.NV12) {
+            const stride = specs?.stride || width;
+            const uvOffset = specs?.p1Offset || stride * height;
+            return Promise.resolve({
+                data: convertNv12ToI420(ensureEvenByteLength(imageFrame.data), width, height, stride, stride, 0, uvOffset),
+                width,
+                height,
+            });
+        }
+        if (type === Type.YUV420p) {
+            return Promise.resolve({
+                data: repackYuv420pToI420(imageFrame, width, height),
+                width,
+                height,
+            });
+        }
+        return Promise.reject(new Error(`Unsupported RGBD color ImgFrame type ${Type[type]}`));
+    }
+    return Promise.resolve({
+        data: new Uint8Array(),
+        width: 0,
+        height: 0,
+    });
+}
+function extractDepthFrame(encodedFrame, imageFrame) {
+    if (encodedFrame) {
+        return ensureEvenByteLength(encodedFrame.data);
+    }
+    if (imageFrame) {
+        return ensureEvenByteLength(imageFrame.data);
+    }
+    return new Uint8Array();
+}
+function parseDimensions(message) {
+    const obj = {
+        depthWidth: 0,
+        depthHeight: 0,
+    };
+    if (message.depthEncodedFrame) {
+        const { width, height } = message.depthEncodedFrame ?? { width: 1920, height: 1200 };
+        obj.depthWidth = width;
+        obj.depthHeight = height;
+    }
+    else if (message.depthImgFrame) {
+        const { width, height } = parseMessage(message.depthImgFrame);
+        obj.depthWidth = width;
+        obj.depthHeight = height;
+    }
+    return obj;
+}
+function emitRGBDDepthPreview(topic, message, maxStereoDepth, callback, onError) {
+    if (!message.depthImgFrame) {
+        return;
+    }
+    const depthFrameForPreview = {
+        ...message.depthImgFrame,
+        data: message.depthImgFrame.data.slice(),
+    };
+    void deserializeDepthFrame({
+        topic,
+        message: depthFrameForPreview,
+        callback,
+        maxStereoDepth: maxStereoDepth / 1000,
+    }).catch(onError);
+}
+function emitRGBDPointCloud(frame, pointCloudData) {
+    const foxgloveMessage = {
+        timestamp: frame.timestamp ?? frame.receiveTime,
+        frame_id: `pointcloud-${frame.topic}-frame`,
+        point_stride: 16,
+        pose: {
+            position: { x: 0, y: 0, z: 0 },
+            orientation: { x: 0, y: 0, z: 1, w: 0 },
+        },
+        width: frame.depthWidth,
+        height: frame.depthHeight,
+        fields: [
+            { name: "x", offset: 0, type: VisualizerNumericType.FLOAT32 },
+            { name: "y", offset: 4, type: VisualizerNumericType.FLOAT32 },
+            { name: "z", offset: 8, type: VisualizerNumericType.FLOAT32 },
+            { name: "red", offset: 12, type: VisualizerNumericType.UINT8 },
+            { name: "green", offset: 13, type: VisualizerNumericType.UINT8 },
+            { name: "blue", offset: 14, type: VisualizerNumericType.UINT8 },
+            { name: "alpha", offset: 15, type: VisualizerNumericType.UINT8 },
+        ],
+        data: pointCloudData,
+    };
+    frame.callback({
+        topic: frame.topic,
+        receiveTime: frame.receiveTime,
+        message: foxgloveMessage,
+        sizeInBytes: pointCloudData.byteLength,
+        schemaName: "foxglove.PointCloud.Colored",
+    });
+}
+function getRGBDBatchSignature(frame) {
+    const intrinsics = frame.rgbdIntrinsics.right;
+    return [
+        frame.depthWidth,
+        frame.depthHeight,
+        frame.colorFrame.width,
+        frame.colorFrame.height,
+        intrinsics.focalLenght.x,
+        intrinsics.focalLenght.y,
+        intrinsics.principalPoint.x,
+        intrinsics.principalPoint.y,
+        frame.maxStereoDepth,
+        frame.hasGPU,
+    ].join(":");
+}
+function clearRGBDBatchFlush(batch) {
+    if (batch.flushTimeoutId != undefined) {
+        clearTimeout(batch.flushTimeoutId);
+        batch.flushTimeoutId = undefined;
+    }
+}
+export function resetRGBDPointCloudTopic(topic) {
+    const pendingBatch = pendingRGBDBatches.get(topic);
+    if (pendingBatch) {
+        clearRGBDBatchFlush(pendingBatch);
+        pendingRGBDBatches.delete(topic);
+    }
+    rgbdIntrinsicsByTopic.delete(topic);
+}
+async function processRGBDPointCloudBatchOnWorker(workerSlot, workerIndex, frames) {
+    const firstFrame = frames[0];
+    if (!firstFrame) {
+        workerSlot.activeJobs = Math.max(0, workerSlot.activeJobs - 1);
+        return;
+    }
+    const intrinsics = firstFrame.rgbdIntrinsics.right;
+    let timeoutId;
+    try {
+        const pointClouds = await Promise.race([
+            workerSlot.remote.depthToPointcloudGPU(transfer(frames.map((frame) => frame.depthFrame), collectArrayBuffers(frames.map((frame) => frame.depthFrame))), firstFrame.depthWidth, firstFrame.depthHeight, intrinsics.focalLenght.x, intrinsics.focalLenght.y, intrinsics.principalPoint.x, intrinsics.principalPoint.y, transfer(frames.map((frame) => frame.colorFrame.data), collectArrayBuffers(frames.map((frame) => frame.colorFrame.data))), firstFrame.colorFrame.width, firstFrame.colorFrame.height, firstFrame.maxStereoDepth, { hasGPU: firstFrame.hasGPU }),
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new Error(`RGBD pointcloud worker ${workerIndex} timed out after ${RGBD_POINTCLOUD_WORKER_TIMEOUT_MS}ms for topic ${firstFrame.topic} ` +
+                        `(batch=${frames.length}, depth=${firstFrame.depthWidth}x${firstFrame.depthHeight}, color=${firstFrame.colorFrame.width}x${firstFrame.colorFrame.height}, hasGPU=${firstFrame.hasGPU})`));
+                }, RGBD_POINTCLOUD_WORKER_TIMEOUT_MS);
+            }),
+        ]);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (pointClouds.length !== frames.length) {
+            throw new Error(`RGBD pointcloud worker returned ${pointClouds.length} frames for batch size ${frames.length}`);
+        }
+        for (let index = 0; index < frames.length; index++) {
+            const frame = frames[index];
+            const pointCloud = pointClouds[index];
+            if (!frame || !pointCloud) {
+                continue;
+            }
+            emitRGBDPointCloud(frame, pointCloud);
+        }
+    }
+    catch (error) {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (error instanceof Error && error.message.includes("timed out")) {
+            replaceRGBDPointCloudWorker(workerIndex);
+            console.error(error);
+        }
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        for (const frame of frames) {
+            frame.onError(normalizedError);
+        }
+    }
+    finally {
+        workerSlot.activeJobs = Math.max(0, workerSlot.activeJobs - 1);
+        markRGBDPointCloudWorkersActive();
+    }
+}
+async function processRGBDPointCloudOnWorker(workerSlot, workerIndex, frame) {
+    const intrinsics = frame.rgbdIntrinsics.right;
+    let timeoutId;
+    try {
+        const pointClouds = await Promise.race([
+            workerSlot.remote.depthToPointcloudGPU(transfer([frame.depthFrame], [frame.depthFrame.buffer]), frame.depthWidth, frame.depthHeight, intrinsics.focalLenght.x, intrinsics.focalLenght.y, intrinsics.principalPoint.x, intrinsics.principalPoint.y, transfer([frame.colorFrame.data], [frame.colorFrame.data.buffer]), frame.colorFrame.width, frame.colorFrame.height, frame.maxStereoDepth, { hasGPU: frame.hasGPU }),
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new Error(`RGBD pointcloud worker ${workerIndex} timed out after ${RGBD_POINTCLOUD_WORKER_TIMEOUT_MS}ms for topic ${frame.topic} ` +
+                        `(depth=${frame.depthWidth}x${frame.depthHeight}, color=${frame.colorFrame.width}x${frame.colorFrame.height}, hasGPU=${frame.hasGPU})`));
+                }, RGBD_POINTCLOUD_WORKER_TIMEOUT_MS);
+            }),
+        ]);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (pointClouds.length !== 1 || !pointClouds[0]) {
+            throw new Error(`RGBD pointcloud worker returned ${pointClouds.length} frames for single-frame request`);
+        }
+        emitRGBDPointCloud(frame, pointClouds[0]);
+    }
+    catch (error) {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (error instanceof Error && error.message.includes("timed out")) {
+            replaceRGBDPointCloudWorker(workerIndex);
+            console.error(error);
+        }
+        frame.onError(error instanceof Error ? error : new Error(String(error)));
+    }
+    finally {
+        workerSlot.activeJobs = Math.max(0, workerSlot.activeJobs - 1);
+        markRGBDPointCloudWorkersActive();
+    }
+}
+function flushRGBDPointCloudBatch(topic) {
+    const batch = pendingRGBDBatches.get(topic);
+    if (!batch || batch.frames.length === 0) {
+        pendingRGBDBatches.delete(topic);
+        return;
+    }
+    clearRGBDBatchFlush(batch);
+    pendingRGBDBatches.delete(topic);
+    const reservedWorkerSelection = tryAcquireRGBDPointCloudWorkerSlot();
+    if (!reservedWorkerSelection) {
+        console.warn(`[RGBD] Dropping pointcloud frame for topic ${topic}: all RGBD pointcloud workers are busy.`);
+        return;
+    }
+    void processRGBDPointCloudBatchOnWorker(reservedWorkerSelection.slot, reservedWorkerSelection.index, batch.frames);
+}
+function enqueueRGBDPointCloudFrame(frame) {
+    if (!ENABLE_RGBD_GPU_BATCHING || !frame.hasGPU) {
+        const reservedWorkerSelection = tryAcquireRGBDPointCloudWorkerSlot();
+        if (!reservedWorkerSelection) {
+            console.warn(`[RGBD] Dropping pointcloud frame for topic ${frame.topic}: all RGBD pointcloud workers are busy.`);
+            return;
+        }
+        globalRenderMetricsManager.ensureTopic(constructKeyForTopicRenderMetrics("renderPointCloudFrame", "Point Cloud"));
+        globalInputEventMetricsManager.registerEvent(constructKeyForTopicRenderMetrics("incomingPointCloudFrame", "Point Cloud"));
+        globalDecodeMetricsManager.registerEvent("Point Cloud");
+        void processRGBDPointCloudOnWorker(reservedWorkerSelection.slot, reservedWorkerSelection.index, frame);
+        return;
+    }
+    const existingBatch = pendingRGBDBatches.get(frame.topic);
+    if (existingBatch &&
+        existingBatch.frames.length > 0 &&
+        getRGBDBatchSignature(existingBatch.frames[0]) !== getRGBDBatchSignature(frame)) {
+        flushRGBDPointCloudBatch(frame.topic);
+    }
+    const batch = pendingRGBDBatches.get(frame.topic) ?? { frames: [] };
+    batch.frames.push(frame);
+    pendingRGBDBatches.set(frame.topic, batch);
+    if (batch.frames.length >= RGBD_GPU_BATCH_SIZE) {
+        flushRGBDPointCloudBatch(frame.topic);
+        return;
+    }
+    clearRGBDBatchFlush(batch);
+    batch.flushTimeoutId = setTimeout(() => {
+        flushRGBDPointCloudBatch(frame.topic);
+    }, RGBD_GPU_BATCH_FLUSH_DELAY_MS);
+}
+export async function deserializeRGBDFrameToPointCloud({ topic, topicDecoders, cameraIntrinsics, maxStereoDepth, message, callback, onError, }) {
+    markRGBDPointCloudWorkersActive();
+    emitRGBDDepthPreview(topic, message, maxStereoDepth, callback, onError);
+    setTimeout(() => {
+        void processScheduledRGBDPointCloud({
+            topic,
+            topicDecoders,
+            cameraIntrinsics,
+            maxStereoDepth,
+            message,
+            callback,
+            onError,
+        });
+    }, RGBD_POINTCLOUD_SCHEDULE_DELAY_MS);
+}
+async function processScheduledRGBDPointCloud({ topic, topicDecoders, cameraIntrinsics, maxStereoDepth, message, callback, onError, }) {
+    const { receiveTime } = parseMessage(message);
+    const { depthWidth, depthHeight } = parseDimensions(message);
+    const rgbdIntrinsics = getRGBDIntrinsics(topic, message, depthWidth, depthHeight, cameraIntrinsics);
+    if (!rgbdIntrinsics) {
+        onError(new Error(`Cannot generate RGBD point cloud for topic "${topic}": missing camera intrinsics.`));
+        return;
+    }
+    const hasGPU = getRGBDGPUSupport();
+    try {
+        const colorFrame = await extractColorFrame(message.colorEncodedFrame, message.colorImgFrame, topicDecoders, topic);
+        const uint8DepthFrames = extractDepthFrame(message.depthEncodedFrame, message.depthImgFrame);
+        const depthFrame = uint8ArrayToUint16Array(uint8DepthFrames);
+        const pendingFrame = {
+            topic,
+            receiveTime,
+            timestamp: message.tsDevice,
+            depthWidth,
+            depthHeight,
+            rgbdIntrinsics,
+            colorFrame,
+            depthFrame,
+            maxStereoDepth,
+            hasGPU,
+            callback,
+            onError,
+        };
+        enqueueRGBDPointCloudFrame(pendingFrame);
+    }
+    catch (error) {
+        onError(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+//# sourceMappingURL=rgbd-to-pointcloud.js.map