@luxonis/depthai-viewer-common 3.7.4 → 3.7.6

package/dist/visualizer/messaging/deserialization/video/h264.js

@@ -0,0 +1,634 @@
+// 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 * as Comlink from "comlink";
+import { FrameType } from "../../../protobuf.generated/EncodedFrame.js";
+import { ensureWebCodecsSupported } from "../../../utils/compatibility.js";
+import { DecoderRuntimeError } from "../../../utils/error.js";
+import { Logger } from "../../../utils/logger.js";
+import { fromMicros } from "../../../utils/time.js";
+import { parseMessage } from "../../parse-utils.js";
+import { recordDecoderRecovery, recordQueuedOutputReplacement, recordStreamBackpressure, recordStreamIngress, recordStreamOutput, } from "../../stream-diagnostics.js";
+const logger = Logger.getLogger();
+// Keep the WebCodecs backlog shallow so live streams do not bunch decoded frames into
+// bursty catch-up delivery on the worker or main thread.
+const MAX_DECODE_QUEUE_SIZE = 3;
+const DECODE_OUTPUT_STALL_TIMEOUT_MS = 5_000;
+const KEYFRAME_DECODE_TIMEOUT_MS = 2_500;
+const EMPTY_FRAME_DATA = new Uint8Array(0);
+export function getDecodedFrameTransferables(payload) {
+    const transferables = [];
+    if (payload.data.buffer.byteLength > 0) {
+        transferables.push(payload.data.buffer);
+    }
+    if (payload.renderableBitmap) {
+        transferables.push(payload.renderableBitmap);
+    }
+    return transferables;
+}
+function configureDecoder(decoder) {
+    decoder.configure({
+        codec: "avc1.42001E",
+        optimizeForLatency: true,
+    });
+}
+function closeDecoder(decoder) {
+    if (!decoder) {
+        return;
+    }
+    if (decoder.state === "closed") {
+        return;
+    }
+    try {
+        decoder.close();
+    }
+    catch (error) {
+        logger.warn("Failed to close H264 decoder cleanly.", error);
+    }
+}
+function clearTopicDecoderState(decoderInfo) {
+    decoderInfo.queuedOutputFrame?.close();
+    decoderInfo.queuedOutputFrame = undefined;
+    decoderInfo.timing.clear();
+    decoderInfo.ingressPerfTimes.clear();
+    decoderInfo.transformations.clear();
+    decoderInfo.outputModes.clear();
+    decoderInfo.pendingCallbacks.clear();
+    decoderInfo.droppedFrames = 0;
+    decoderInfo.processingOutput = false;
+}
+function enterAwaitingKeyframe(topic, topicDecoders, reason) {
+    const decoderInfo = topicDecoders.get(topic);
+    if (!decoderInfo || decoderInfo.recovery.state === "awaiting-keyframe") {
+        return;
+    }
+    decoderInfo.decoderGeneration += 1;
+    closeDecoder(decoderInfo.decoder);
+    clearTopicDecoderState(decoderInfo);
+    decoderInfo.recovery = { state: "awaiting-keyframe", enteredAt: performance.now(), reason };
+    recordDecoderRecovery({
+        topic,
+        codec: "h264",
+        event: "entered",
+        reason,
+        generation: decoderInfo.decoderGeneration,
+    });
+}
+function closeTopicDecoder(topic, topicDecoders) {
+    const decoderInfo = topicDecoders.get(topic);
+    closeDecoder(decoderInfo?.decoder);
+    if (decoderInfo) {
+        clearTopicDecoderState(decoderInfo);
+    }
+}
+function isIgnorableInitialDecodeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("A key frame is required after configure() or flush()");
+}
+function getEncodedVideoChunkType(message) {
+    if ("profile" in message) {
+        switch (message.type) {
+            case FrameType.P:
+            case FrameType.B:
+                return "delta";
+            default:
+                return "key";
+        }
+    }
+    return "key";
+}
+function discardDecodedFrameMetadata(decoderInfo, timestamp) {
+    decoderInfo.timing.delete(timestamp);
+    decoderInfo.ingressPerfTimes.delete(timestamp);
+    decoderInfo.transformations.delete(timestamp);
+    decoderInfo.outputModes.delete(timestamp);
+    decoderInfo.pendingCallbacks.delete(timestamp);
+}
+async function processDecodedVideoFrame(topic, initialFrame, topicDecoders, generation) {
+    const decoderInfo = topicDecoders.get(topic);
+    if (!decoderInfo || decoderInfo.decoderGeneration !== generation) {
+        initialFrame.close();
+        return;
+    }
+    decoderInfo.processingOutput = true;
+    let currentFrame = initialFrame;
+    try {
+        while (currentFrame) {
+            const activeDecoderInfo = topicDecoders.get(topic);
+            if (!activeDecoderInfo || activeDecoderInfo.decoderGeneration !== generation) {
+                currentFrame.close();
+                return;
+            }
+            const outputMode = activeDecoderInfo.outputModes.get(currentFrame.timestamp) ?? "native";
+            const payload = await copyVideoFrameToPayload(currentFrame, outputMode, activeDecoderInfo.copyScratchBuffers);
+            if (topicDecoders.get(topic)?.decoderGeneration !== generation) {
+                payload.renderableBitmap?.close();
+                return;
+            }
+            const receiveTime = activeDecoderInfo.timing.get(currentFrame.timestamp) ?? fromMicros(currentFrame.timestamp);
+            const ingressPerfTime = activeDecoderInfo?.ingressPerfTimes.get(currentFrame.timestamp);
+            const transformation = activeDecoderInfo?.transformations.get(currentFrame.timestamp);
+            const callback = activeDecoderInfo?.pendingCallbacks.get(currentFrame.timestamp) ??
+                activeDecoderInfo?.callback;
+            activeDecoderInfo?.timing.delete(currentFrame.timestamp);
+            activeDecoderInfo?.ingressPerfTimes.delete(currentFrame.timestamp);
+            activeDecoderInfo?.transformations.delete(currentFrame.timestamp);
+            activeDecoderInfo?.outputModes.delete(currentFrame.timestamp);
+            activeDecoderInfo?.pendingCallbacks.delete(currentFrame.timestamp);
+            const foxgloveMessage = {
+                timestamp: receiveTime,
+                frame_id: `h264-${topic}-frame`,
+                width: payload.width,
+                height: payload.height,
+                data: payload.data,
+                encoding: payload.encoding,
+                step: payload.step,
+                stride: payload.stride,
+                planeStride: payload.planeStride,
+                renderableBitmap: payload.renderableBitmap,
+            };
+            const event = {
+                topic,
+                receiveTime,
+                message: foxgloveMessage,
+                sizeInBytes: payload.sizeInBytes,
+                schemaName: "foxglove.RawImage",
+                depthaiTransformation: transformation,
+            };
+            const transferables = getDecodedFrameTransferables(payload);
+            if (activeDecoderInfo) {
+                activeDecoderInfo.lastDecodedFrameAt = performance.now();
+            }
+            recordStreamOutput({
+                topic,
+                codec: "h264",
+                queueDepth: activeDecoderInfo?.decoder.decodeQueueSize ?? 0,
+                deliveryLatencyMs: ingressPerfTime != undefined ? performance.now() - ingressPerfTime : 0,
+            });
+            callback?.(transferables.length > 0 ? Comlink.transfer(event, transferables) : event);
+            currentFrame.close();
+            const nextFrame = activeDecoderInfo?.queuedOutputFrame;
+            if (activeDecoderInfo) {
+                activeDecoderInfo.queuedOutputFrame = undefined;
+            }
+            currentFrame = nextFrame;
+        }
+    }
+    catch (error) {
+        currentFrame?.close();
+        closeTopicDecoder(topic, topicDecoders);
+        decoderInfo.onError(new DecoderRuntimeError(topic, error instanceof Error ? error.message : "Failed to process decoded H.264 frame."));
+    }
+    finally {
+        const activeDecoderInfo = topicDecoders.get(topic);
+        if (activeDecoderInfo) {
+            activeDecoderInfo.processingOutput = false;
+        }
+    }
+}
+export function packedToI420(packed, width, height, stride, format, cropLeft = 0, cropTop = 0, out = new Uint8Array(width * height + ((width * height) >> 2) * 2)) {
+    if ((width & 1) !== 0 || (height & 1) !== 0) {
+        throw new Error("I420 requires even width and height.");
+    }
+    const ySize = width * height;
+    const uvSize = (width * height) >> 2;
+    const Y = out.subarray(0, ySize);
+    const U = out.subarray(ySize, ySize + uvSize);
+    const V = out.subarray(ySize + uvSize);
+    const isRgbLayout = format === "RGBX" || format === "RGBA";
+    const clamp8 = (x) => (x < 0 ? 0 : x > 255 ? 255 : x | 0);
+    for (let y = 0; y < height; y += 2) {
+        const row0 = (y + cropTop) * stride;
+        const row1 = (y + cropTop + 1) * stride;
+        for (let x = 0; x < width; x += 2) {
+            const srcX = x + cropLeft;
+            const p00 = row0 + srcX * 4;
+            const p01 = row0 + (srcX + 1) * 4;
+            const p10 = row1 + srcX * 4;
+            const p11 = row1 + (srcX + 1) * 4;
+            const R00 = packed[p00 + (isRgbLayout ? 0 : 2)];
+            const G00 = packed[p00 + 1];
+            const B00 = packed[p00 + (isRgbLayout ? 2 : 0)];
+            const R01 = packed[p01 + (isRgbLayout ? 0 : 2)];
+            const G01 = packed[p01 + 1];
+            const B01 = packed[p01 + (isRgbLayout ? 2 : 0)];
+            const R10 = packed[p10 + (isRgbLayout ? 0 : 2)];
+            const G10 = packed[p10 + 1];
+            const B10 = packed[p10 + (isRgbLayout ? 2 : 0)];
+            const R11 = packed[p11 + (isRgbLayout ? 0 : 2)];
+            const G11 = packed[p11 + 1];
+            const B11 = packed[p11 + (isRgbLayout ? 2 : 0)];
+            const Y00 = (77 * R00 + 150 * G00 + 29 * B00 + 128) >> 8;
+            const Y01 = (77 * R01 + 150 * G01 + 29 * B01 + 128) >> 8;
+            const Y10 = (77 * R10 + 150 * G10 + 29 * B10 + 128) >> 8;
+            const Y11 = (77 * R11 + 150 * G11 + 29 * B11 + 128) >> 8;
+            const yRow0 = y * width + x;
+            const yRow1 = (y + 1) * width + x;
+            Y[yRow0 + 0] = Y00;
+            Y[yRow0 + 1] = Y01;
+            Y[yRow1 + 0] = Y10;
+            Y[yRow1 + 1] = Y11;
+            const Ravg = (R00 + R01 + R10 + R11) >> 2;
+            const Gavg = (G00 + G01 + G10 + G11) >> 2;
+            const Bavg = (B00 + B01 + B10 + B11) >> 2;
+            const Uval = clamp8(((-43 * Ravg - 85 * Gavg + 128 * Bavg) >> 8) + 128);
+            const Vval = clamp8(((128 * Ravg - 107 * Gavg - 21 * Bavg) >> 8) + 128);
+            const uvCol = x >> 1;
+            const uvRow = y >> 1;
+            const uvW = width >> 1;
+            const uvPos = uvRow * uvW + uvCol;
+            U[uvPos] = Uval;
+            V[uvPos] = Vval;
+        }
+    }
+    return out;
+}
+export function convertNv12ToI420(nv12Buffer, width, height, yStride, uvStride, yOffset = 0, uvOffset = yStride * height, cropLeft = 0, cropTop = 0, i420Buffer = new Uint8Array(width * height + ((width * height) >> 2) * 2)) {
+    const ySize = width * height;
+    const uvSize = ySize / 4;
+    for (let row = 0; row < height; row++) {
+        const srcOffset = yOffset + (row + cropTop) * yStride + cropLeft;
+        const dstOffset = row * width;
+        i420Buffer.set(nv12Buffer.subarray(srcOffset, srcOffset + width), dstOffset);
+    }
+    const uPlaneOffset = ySize;
+    const vPlaneOffset = ySize + uvSize;
+    const uvHeight = height / 2;
+    const uvWidth = width / 2;
+    const uvCropLeft = cropLeft >> 1;
+    const uvCropTop = cropTop >> 1;
+    for (let row = 0; row < uvHeight; row++) {
+        for (let col = 0; col < uvWidth; col++) {
+            const srcIndex = uvOffset + (row + uvCropTop) * uvStride + (col + uvCropLeft) * 2;
+            const dstIndex = row * uvWidth + col;
+            i420Buffer[uPlaneOffset + dstIndex] = nv12Buffer[srcIndex] ?? 0; // U
+            i420Buffer[vPlaneOffset + dstIndex] = nv12Buffer[srcIndex + 1] ?? 0; // V
+        }
+    }
+    return i420Buffer;
+}
+export function repackI420(source, width, height, yLayout, uLayout, vLayout, cropLeft = 0, cropTop = 0, out = new Uint8Array(width * height + ((width * height) >> 2) * 2)) {
+    const ySize = width * height;
+    const uvWidth = width >> 1;
+    const uvHeight = height >> 1;
+    const uvSize = uvWidth * uvHeight;
+    const uvCropLeft = cropLeft >> 1;
+    const uvCropTop = cropTop >> 1;
+    for (let row = 0; row < height; row++) {
+        const srcOffset = yLayout.offset + (row + cropTop) * yLayout.stride + cropLeft;
+        out.set(source.subarray(srcOffset, srcOffset + width), row * width);
+    }
+    for (let row = 0; row < uvHeight; row++) {
+        const uSrcOffset = uLayout.offset + (row + uvCropTop) * uLayout.stride + uvCropLeft;
+        const vSrcOffset = vLayout.offset + (row + uvCropTop) * vLayout.stride + uvCropLeft;
+        const dstOffset = row * uvWidth;
+        out.set(source.subarray(uSrcOffset, uSrcOffset + uvWidth), ySize + dstOffset);
+        out.set(source.subarray(vSrcOffset, vSrcOffset + uvWidth), ySize + uvSize + dstOffset);
+    }
+    return out;
+}
+function ensureScratchBuffer(scratchBuffers, key, size) {
+    const existing = scratchBuffers?.[key];
+    if (existing && existing.byteLength >= size) {
+        return existing;
+    }
+    const nextBuffer = new Uint8Array(size);
+    if (scratchBuffers) {
+        scratchBuffers[key] = nextBuffer;
+    }
+    return nextBuffer;
+}
+export async function copyVideoFrameToI420(frame, _logPrefix, scratchBuffers) {
+    const visibleRect = frame.visibleRect;
+    const frameWidth = visibleRect?.width ?? frame.codedWidth;
+    const frameHeight = visibleRect?.height ?? frame.codedHeight;
+    const cropLeft = visibleRect?.x ?? 0;
+    const cropTop = visibleRect?.y ?? 0;
+    const finalBuffer = new Uint8Array(frameWidth * frameHeight + ((frameWidth * frameHeight) >> 2) * 2);
+    switch (frame.format) {
+        case "I420": {
+            const i420Buffer = ensureScratchBuffer(scratchBuffers, "i420CopyBuffer", frame.allocationSize());
+            const layouts = await frame.copyTo(i420Buffer);
+            const [yLayout, uLayout, vLayout] = layouts;
+            if (yLayout != undefined && uLayout != undefined && vLayout != undefined) {
+                repackI420(i420Buffer, frameWidth, frameHeight, yLayout, uLayout, vLayout, cropLeft, cropTop, finalBuffer);
+            }
+            else {
+                finalBuffer.set(i420Buffer.subarray(0, finalBuffer.byteLength));
+            }
+            break;
+        }
+        case "NV12": {
+            const nv12Buffer = ensureScratchBuffer(scratchBuffers, "nv12CopyBuffer", frame.allocationSize());
+            const layouts = await frame.copyTo(nv12Buffer);
+            const [yLayout, uvLayout] = layouts;
+            convertNv12ToI420(nv12Buffer, frameWidth, frameHeight, yLayout?.stride ?? frame.codedWidth, uvLayout?.stride ?? frame.codedWidth, yLayout?.offset ?? 0, uvLayout?.offset ?? (yLayout?.stride ?? frame.codedWidth) * frame.codedHeight, cropLeft, cropTop, finalBuffer);
+            break;
+        }
+        case "RGBX":
+        case "RGBA":
+        case "BGRX":
+        case "BGRA": {
+            const packedBuffer = ensureScratchBuffer(scratchBuffers, "packedCopyBuffer", frame.allocationSize());
+            const [layout] = await frame.copyTo(packedBuffer);
+            packedToI420(packedBuffer, frameWidth, frameHeight, layout?.stride ?? frame.codedWidth * 4, frame.format, cropLeft, cropTop, finalBuffer);
+            break;
+        }
+        default:
+            break;
+    }
+    return {
+        data: finalBuffer,
+        width: frameWidth,
+        height: frameHeight,
+    };
+}
+async function copyVideoFrameToRenderablePayload(frame) {
+    const visibleRect = frame.visibleRect;
+    const frameWidth = visibleRect?.width ?? frame.codedWidth;
+    const frameHeight = visibleRect?.height ?? frame.codedHeight;
+    const cropLeft = visibleRect?.x ?? 0;
+    const cropTop = visibleRect?.y ?? 0;
+    return {
+        data: EMPTY_FRAME_DATA,
+        width: frameWidth,
+        height: frameHeight,
+        encoding: frame.format === "NV12" && cropLeft === 0 && cropTop === 0 ? "nv12" : "yuv420p",
+        step: frameWidth,
+        sizeInBytes: frame.allocationSize(),
+        renderableBitmap: await createImageBitmap(frame),
+    };
+}
+async function copyVideoFrameToNv12Payload(frame) {
+    const visibleRect = frame.visibleRect;
+    const frameWidth = visibleRect?.width ?? frame.codedWidth;
+    const frameHeight = visibleRect?.height ?? frame.codedHeight;
+    const cropLeft = visibleRect?.x ?? 0;
+    const cropTop = visibleRect?.y ?? 0;
+    if (frame.format !== "NV12" || cropLeft !== 0 || cropTop !== 0) {
+        return undefined;
+    }
+    const destination = new Uint8Array(frame.allocationSize());
+    const layouts = await frame.copyTo(destination);
+    const yPlaneLayout = layouts[0];
+    const uvPlaneLayout = layouts[1];
+    return {
+        data: destination,
+        width: frameWidth,
+        height: frameHeight,
+        encoding: "nv12",
+        step: yPlaneLayout?.stride ?? frameWidth,
+        sizeInBytes: destination.byteLength,
+        stride: yPlaneLayout?.stride ?? frameWidth,
+        planeStride: uvPlaneLayout?.offset ?? null,
+    };
+}
+async function copyVideoFrameToPayload(frame, outputMode, scratchBuffers) {
+    if (outputMode === "i420") {
+        return {
+            ...(await copyVideoFrameToI420(frame, "H264", scratchBuffers)),
+            encoding: "yuv420p",
+            step: frame.visibleRect?.width ?? frame.codedWidth,
+            sizeInBytes: frame.allocationSize(),
+        };
+    }
+    try {
+        return await copyVideoFrameToRenderablePayload(frame);
+    }
+    catch (error) {
+        logger.warn("Falling back to planar payload for H264 frame.", error);
+    }
+    try {
+        const nv12Payload = await copyVideoFrameToNv12Payload(frame);
+        if (nv12Payload) {
+            return nv12Payload;
+        }
+        return {
+            ...(await copyVideoFrameToI420(frame, "H264", scratchBuffers)),
+            encoding: "yuv420p",
+            step: frame.visibleRect?.width ?? frame.codedWidth,
+            sizeInBytes: frame.allocationSize(),
+        };
+    }
+    catch (error) {
+        logger.warn("Falling back to I420 payload for H264 frame.", error);
+        return {
+            ...(await copyVideoFrameToI420(frame, "H264", scratchBuffers)),
+            encoding: "yuv420p",
+            step: frame.visibleRect?.width ?? frame.codedWidth,
+            sizeInBytes: frame.allocationSize(),
+        };
+    }
+}
+function createVideoDecoder({ topic, topicDecoders }) {
+    const generation = topicDecoders.get(topic)?.decoderGeneration ?? 0;
+    let hasProducedFrame = false;
+    return new VideoDecoder({
+        output: (frame) => {
+            hasProducedFrame = true;
+            const decoderInfo = topicDecoders.get(topic);
+            if (!decoderInfo || decoderInfo.decoderGeneration !== generation) {
+                frame.close();
+                return;
+            }
+            if (decoderInfo.recovery.state === "verifying-keyframe") {
+                const recoveryElapsedMs = performance.now() - decoderInfo.recovery.enteredAt;
+                decoderInfo.recovery = { state: "synchronized", enteredAt: performance.now() };
+                decoderInfo.lastDecodedFrameAt = performance.now();
+                recordDecoderRecovery({
+                    topic,
+                    codec: "h264",
+                    event: "succeeded",
+                    generation,
+                    elapsedMs: recoveryElapsedMs,
+                });
+            }
+            if (decoderInfo.processingOutput) {
+                if (decoderInfo.queuedOutputFrame) {
+                    discardDecodedFrameMetadata(decoderInfo, decoderInfo.queuedOutputFrame.timestamp);
+                    decoderInfo.queuedOutputFrame.close();
+                    recordQueuedOutputReplacement(topic, "h264");
+                }
+                decoderInfo.queuedOutputFrame = frame;
+                return;
+            }
+            void processDecodedVideoFrame(topic, frame, topicDecoders, generation);
+        },
+        error: (error) => {
+            const decoderInfo = topicDecoders.get(topic);
+            if (!decoderInfo || decoderInfo.decoderGeneration !== generation) {
+                return;
+            }
+            if (!hasProducedFrame && isIgnorableInitialDecodeError(error)) {
+                logger.warn(`H264 decoder requires a keyframe for topic ${topic}: ${error.message}`);
+            }
+            else {
+                logger.error(error);
+            }
+            const wasVerifying = decoderInfo.recovery.state === "verifying-keyframe";
+            enterAwaitingKeyframe(topic, topicDecoders, wasVerifying ? "keyframe-decode-failure" : "decoder-error");
+            if (wasVerifying) {
+                recordDecoderRecovery({
+                    topic,
+                    codec: "h264",
+                    event: "keyframe-decode-failure",
+                    generation,
+                });
+            }
+        },
+    });
+}
+export function getDecoderRecoveryStatus(topic, topicDecoders) {
+    const decoderInfo = topicDecoders.get(topic);
+    if (!decoderInfo) {
+        return undefined;
+    }
+    return {
+        recoveryState: decoderInfo.recovery.state,
+        lastDecodedFrameAt: decoderInfo.lastDecodedFrameAt,
+        lastReceivedKeyframeAt: decoderInfo.lastReceivedKeyframeAt,
+        recoveryElapsedMs: decoderInfo.recovery.state === "synchronized"
+            ? undefined
+            : performance.now() - decoderInfo.recovery.enteredAt,
+    };
+}
+export async function deserializeEncodedFrameH264({ topic, message, topicDecoders, callback, onError, outputMode = "native", }) {
+    const { receiveTime } = parseMessage(message);
+    const supported = ensureWebCodecsSupported("VideoDecoder");
+    if (!supported) {
+        return;
+    }
+    let decoderInfo = topicDecoders.get(topic);
+    if (!decoderInfo) {
+        decoderInfo = {
+            decoder: undefined,
+            timing: new Map(),
+            ingressPerfTimes: new Map(),
+            transformations: new Map(),
+            outputModes: new Map(),
+            pendingCallbacks: new Map(),
+            callback,
+            onError,
+            droppedFrames: 0,
+            processingOutput: false,
+            copyScratchBuffers: {},
+            decoderGeneration: 0,
+            recovery: { state: "awaiting-keyframe", enteredAt: performance.now(), reason: "initial" },
+        };
+        topicDecoders.set(topic, decoderInfo);
+        decoderInfo.decoder = createVideoDecoder({ topic, topicDecoders });
+    }
+    decoderInfo.callback = callback;
+    decoderInfo.onError = onError;
+    const frameType = getEncodedVideoChunkType(message);
+    const now = performance.now();
+    decoderInfo.lastEncodedIngressAt = now;
+    if (frameType === "key") {
+        decoderInfo.lastReceivedKeyframeAt = now;
+    }
+    recordStreamIngress({
+        topic,
+        codec: "h264",
+        payloadBytes: message.data.byteLength,
+        queueDepth: decoderInfo.decoder.decodeQueueSize,
+        transferMode: "ArrayBuffer",
+        frameType,
+    });
+    if (decoderInfo.recovery.state === "synchronized" &&
+        decoderInfo.lastDecodedFrameAt != undefined &&
+        now - decoderInfo.lastDecodedFrameAt >= DECODE_OUTPUT_STALL_TIMEOUT_MS) {
+        enterAwaitingKeyframe(topic, topicDecoders, "decoded-output-stall");
+    }
+    if (decoderInfo.recovery.state === "verifying-keyframe" &&
+        now - decoderInfo.recovery.keyframeAt >= KEYFRAME_DECODE_TIMEOUT_MS) {
+        // A received keyframe is not proof of recovery. If it produces no decoder output,
+        // abandon this attempt so a later periodic keyframe can be tried.
+        enterAwaitingKeyframe(topic, topicDecoders, "keyframe-output-timeout");
+    }
+    if (decoderInfo.recovery.state === "awaiting-keyframe" ||
+        (decoderInfo.recovery.state === "verifying-keyframe" && frameType === "key")) {
+        if (frameType === "delta") {
+            recordDecoderRecovery({
+                topic,
+                codec: "h264",
+                event: "delta-dropped",
+                generation: decoderInfo.decoderGeneration,
+            });
+            return;
+        }
+        closeDecoder(decoderInfo.decoder);
+        decoderInfo.decoderGeneration += 1;
+        const decoder = createVideoDecoder({ topic, topicDecoders });
+        try {
+            configureDecoder(decoder);
+        }
+        catch (_error) {
+            closeDecoder(decoder);
+            decoderInfo.recovery = {
+                state: "awaiting-keyframe",
+                enteredAt: now,
+                reason: "keyframe-decode-failure",
+            };
+            recordDecoderRecovery({
+                topic,
+                codec: "h264",
+                event: "keyframe-decode-failure",
+                generation: decoderInfo.decoderGeneration,
+            });
+            return;
+        }
+        decoderInfo.decoder = decoder;
+        clearTopicDecoderState(decoderInfo);
+        decoderInfo.recovery = { state: "verifying-keyframe", enteredAt: now, keyframeAt: now };
+    }
+    else if (decoderInfo.recovery.state === "verifying-keyframe") {
+        recordDecoderRecovery({
+            topic,
+            codec: "h264",
+            event: "delta-dropped",
+            generation: decoderInfo.decoderGeneration,
+        });
+        return;
+    }
+    const queueDepth = decoderInfo.decoder.decodeQueueSize;
+    if (queueDepth >= MAX_DECODE_QUEUE_SIZE) {
+        decoderInfo.droppedFrames += 1;
+        recordStreamBackpressure({
+            topic,
+            codec: "h264",
+            queueDepth,
+            frameType: getEncodedVideoChunkType(message),
+        });
+    }
+    else {
+        decoderInfo.droppedFrames = 0;
+    }
+    const microTimestamp = receiveTime.sec * 1_000_000 + Math.floor(receiveTime.nsec / 1_000);
+    decoderInfo.timing.set(microTimestamp, receiveTime);
+    decoderInfo.ingressPerfTimes.set(microTimestamp, performance.now());
+    decoderInfo.transformations.set(microTimestamp, message.transformation);
+    decoderInfo.outputModes.set(microTimestamp, outputMode);
+    decoderInfo.pendingCallbacks.set(microTimestamp, callback);
+    const frame = {
+        type: getEncodedVideoChunkType(message),
+        data: message.data,
+        timestamp: microTimestamp,
+    };
+    try {
+        const chunk = new EncodedVideoChunk(frame);
+        decoderInfo.decoder.decode(chunk);
+    }
+    catch (error) {
+        const wasVerifying = decoderInfo.recovery.state === "verifying-keyframe";
+        enterAwaitingKeyframe(topic, topicDecoders, isIgnorableInitialDecodeError(error) ? "keyframe-required" : "decode-error");
+        if (wasVerifying) {
+            recordDecoderRecovery({
+                topic,
+                codec: "h264",
+                event: "keyframe-decode-failure",
+                generation: decoderInfo.decoderGeneration,
+            });
+        }
+    }
+}
+//# sourceMappingURL=h264.js.map