supervision 0.2.0-next.0 → 0.2.0-next.2

package/dist/mask-preparation.worker.js

@@ -426,7 +426,6 @@
         const height = width === maskWidth
             ? maskHeight
             : Math.max(1, Math.round((width * maskHeight) / maskWidth));
-        const strokeScale = width / maskWidth;
         const scaledAxes = width === maskWidth
             ? undefined
             : createScaledMaskAxes({ height, maskHeight, maskWidth, width });
@@ -437,18 +436,17 @@
         let hasStroke = false;
         let maxStrokeWidth = 0;
         for (const instruction of instructions) {
-            const detectionMaskId = instruction.detectionIndex + 1;
-            if (detectionMaskId <= 0 ||
-                detectionMaskId >= MAX_ID_MASK_PALETTE_ENTRIES) {
+            const detectionMaskId = resolveIdMaskPaletteId(instruction.detectionIndex);
+            if (detectionMaskId === undefined) {
                 return undefined;
             }
-            writePaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);
+            writeIdMaskPaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);
             if (instruction.stroke && instruction.stroke.width > 0) {
-                const strokeWidth = Math.min(resolveStrokeTexels(instruction.stroke.width, strokeScale), MAX_ID_MASK_STROKE_WIDTH);
+                const strokeWidth = resolveIdMaskStrokeTexels(instruction.stroke.width, maskWidth, width);
                 hasStroke = true;
                 strokeWidths[detectionMaskId] = strokeWidth;
                 maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);
-                writePaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);
+                writeIdMaskPaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);
             }
             if (scaledAxes) {
                 writeScaledMaskRuns(data, scaledAxes, instruction.mask, detectionMaskId);
@@ -463,6 +461,7 @@
             hasStroke,
             height,
             maxStrokeWidth,
+            sourceWidth: maskWidth,
             strokePalette,
             strokeWidths,
             width,
@@ -545,10 +544,14 @@
      * A stroke is measured in texels of the raster it is drawn on, so a coarser
      * raster measures it in coarser texels. A stroke of a texel or more keeps at
      * least one, the thinnest line the shader can draw; a narrower one keeps its
-     * own width, which the shader draws as an inner boundary at any scale.
+     * own width, which the shader draws as an inner boundary at any scale. The
+     * ceiling is the widest neighbourhood the shaders scan, so a wider stroke would
+     * be drawn at the ceiling anyway and every layer drawing the same annotation
+     * has to arrive at the same width.
      */
-    function resolveStrokeTexels(strokeWidth, scale) {
-        return Math.max(strokeWidth * scale, Math.min(strokeWidth, 1));
+    function resolveIdMaskStrokeTexels(strokeWidth, maskWidth, rasterWidth) {
+        const scale = maskWidth > 0 ? rasterWidth / maskWidth : 1;
+        return Math.min(Math.max(strokeWidth * scale, Math.min(strokeWidth, 1)), MAX_ID_MASK_STROKE_WIDTH);
     }
     function createScaledMaskAxes(frame) {
         return {
@@ -565,8 +568,19 @@
         }
         return map;
     }
-    function writePaletteEntry(palette, id, color, alpha) {
-        const offset = id * 4;
+    /**
+     * The palette slot a detection index names, or undefined when the palette has
+     * no slot for it. Slot zero is the background, so the ids start at one and the
+     * last detection the palette can name sits one index below the last slot.
+     */
+    function resolveIdMaskPaletteId(detectionIndex) {
+        const detectionMaskId = detectionIndex + 1;
+        return detectionMaskId > 0 && detectionMaskId < MAX_ID_MASK_PALETTE_ENTRIES
+            ? detectionMaskId
+            : undefined;
+    }
+    function writeIdMaskPaletteEntry(palette, detectionMaskId, color, alpha) {
+        const offset = detectionMaskId * 4;
         palette[offset] = ((color >> 16) & 0xff) / 255;
         palette[offset + 1] = ((color >> 8) & 0xff) / 255;
         palette[offset + 2] = (color & 0xff) / 255;
@@ -606,7 +620,7 @@
      */
     var MediaErrorKind;
     (function (MediaErrorKind) {
-        /** The media could not be opened or read at all. */
+        /** The media could not be opened or read, or was refused before any read. */
         MediaErrorKind["Unreadable"] = "unreadable";
         /** The container or codec is not supported by this platform. */
         MediaErrorKind["UnsupportedFormat"] = "unsupportedFormat";
@@ -640,8 +654,8 @@
      * A source the renderer pulls samples from can be held between any two frames,
      * because the renderer decides when each one is drawn. A source that presents
      * its own frames owns the playhead, so holding it means stopping the producer
-     * and starting it again, which the detection gate does and the
-     * render-preparation gate does not.
+     * and starting it again, and a gate that stops one has to bound its own wait
+     * or a producer nothing answers for never runs again.
      */
     var PlaybackGateReach;
     (function (PlaybackGateReach) {
@@ -652,8 +666,6 @@
          * missing, until they arrive or the gate's own wait bound gives up on them.
          */
         PlaybackGateReach["EveryFrame"] = "everyFrame";
-        /** Playback waits to begin; frames after that are not held. */
-        PlaybackGateReach["StartOfPlayback"] = "startOfPlayback";
     })(PlaybackGateReach || (PlaybackGateReach = {}));
 
     /**
@@ -707,7 +719,23 @@
         MediaSessionActivityKind["Error"] = "error";
         MediaSessionActivityKind["MediaNormalizing"] = "mediaNormalizing";
         MediaSessionActivityKind["MediaOpening"] = "mediaOpening";
+        /**
+         * The picture is waiting on media the source has not handed over yet, which
+         * is the bytes and their decode rather than anything downstream of them.
+         * `PlaybackBuffering` is what a transport reports once it has already
+         * stopped; this is reported from the read itself, including the reads a seek
+         * makes while the transport still reads as paused.
+         */
+        MediaSessionActivityKind["MediaSourceReading"] = "mediaSourceReading";
         MediaSessionActivityKind["PlaybackBuffering"] = "playbackBuffering";
+        /**
+         * The render-preparation gate held the picture for artifacts that never
+         * arrived and let it go. Nothing is blocked: the frames reaching the screen
+         * are the ones whose artifacts were given up on. What is waited on is
+         * preparation finishing another frame, which is what lets the gate hold the
+         * picture again; `RenderPreparing` covers the holds that are running.
+         */
+        MediaSessionActivityKind["RenderPreparationAbandoned"] = "renderPreparationAbandoned";
         MediaSessionActivityKind["RenderPreparing"] = "renderPreparing";
     })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));
     /**
@@ -791,18 +819,33 @@
             return undefined;
         }
     }
+    /**
+     * Whether the palette has a slot for every detection this frame masks. An id
+     * names a detection by its index in the frame, so one masked detection past the
+     * last slot leaves the whole frame without an id raster however few masks it
+     * carries.
+     */
+    function canIdMaskPaletteNameFrame(instructions) {
+        return instructions.every((instruction) => instruction.visible === false ||
+            resolveIdMaskPaletteId(instruction.detectionIndex) !== undefined);
+    }
     function createIdMaskPlane(instructions, maxRasterWidth) {
+        // The plane carries the ids a failed cook could not. A frame the palette
+        // cannot name has none to carry, and cooking it again reaches the same
+        // refusal after rasterizing every mask a second time.
+        if (!canIdMaskPaletteNameFrame(instructions)) {
+            return undefined;
+        }
         const frame = createIdMaskRasterFrame(instructions, maxRasterWidth);
         return frame
             ? { data: frame.data, height: frame.height, width: frame.width }
             : undefined;
     }
     function compositeInstruction(rgba, canvasWidth, instruction) {
-        const decodedMask = decodeCompressedRleMask(instruction.mask);
         const fill = resolveRgbaColor(instruction.color, instruction.alpha);
-        compositeMaskFill(rgba, canvasWidth, decodedMask, fill);
-        if (instruction.stroke) {
-            compositeMaskStroke(rgba, canvasWidth, decodedMask, instruction.stroke);
+        const bounds = compositeMaskFill(rgba, canvasWidth, instruction.mask, fill);
+        if (instruction.stroke && bounds) {
+            compositeMaskStroke(rgba, canvasWidth, decodeCompressedRleMask(instruction.mask), bounds, instruction.stroke);
         }
     }
     function materializeMaskInstructions(instructions) {
@@ -822,25 +865,59 @@
             };
         });
     }
-    function compositeMaskFill(rgba, canvasWidth, decodedMask, fill) {
-        for (let y = 0; y < decodedMask.height; y += 1) {
-            for (let x = 0; x < decodedMask.width; x += 1) {
-                const maskOffset = y * decodedMask.width + x;
-                if (!decodedMask.data[maskOffset]) {
-                    continue;
+    /**
+     * Compressed RLE counts runs down each column in turn, so a foreground run is
+     * a contiguous walk down one column that wraps into the next.
+     */
+    function compositeMaskFill(rgba, canvasWidth, mask, fill) {
+        const counts = decodeCompressedRleCounts(mask.counts);
+        const maskWidth = mask.width;
+        const maskHeight = mask.height;
+        const maskArea = maskWidth * maskHeight;
+        let maskOffset = 0;
+        let minX = maskWidth;
+        let minY = maskHeight;
+        let maxX = -1;
+        let maxY = -1;
+        for (let index = 0; index < counts.length; index += 1) {
+            const runLength = counts[index] ?? 0;
+            if (index % 2 === 0 || runLength <= 0) {
+                maskOffset += runLength;
+                continue;
+            }
+            let columnX = Math.floor(maskOffset / maskHeight);
+            let columnY = maskOffset - columnX * maskHeight;
+            for (let step = 0; step < runLength; step += 1) {
+                // A run can outlast the columns the mask has; the pixel it then names
+                // is wherever that column-major offset lands when read back row-major.
+                const rowMajorOffset = columnY * maskWidth + columnX;
+                if (rowMajorOffset < maskArea) {
+                    const x = rowMajorOffset % maskWidth;
+                    const y = (rowMajorOffset - x) / maskWidth;
+                    writePixel(rgba, canvasWidth, x, y, fill);
+                    minX = Math.min(minX, x);
+                    minY = Math.min(minY, y);
+                    maxX = Math.max(maxX, x);
+                    maxY = Math.max(maxY, y);
+                }
+                columnY += 1;
+                if (columnY === maskHeight) {
+                    columnY = 0;
+                    columnX += 1;
                 }
-                writePixel(rgba, canvasWidth, x, y, fill);
             }
+            maskOffset += runLength;
         }
+        return maxX < minX || maxY < minY ? undefined : { maxX, maxY, minX, minY };
     }
-    function compositeMaskStroke(rgba, canvasWidth, decodedMask, stroke) {
+    function compositeMaskStroke(rgba, canvasWidth, decodedMask, bounds, stroke) {
         const width = Math.round(stroke.width);
         if (width <= 0) {
             return;
         }
         const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);
-        for (let y = 0; y < decodedMask.height; y += 1) {
-            for (let x = 0; x < decodedMask.width; x += 1) {
+        for (let y = bounds.minY; y <= bounds.maxY; y += 1) {
+            for (let x = bounds.minX; x <= bounds.maxX; x += 1) {
                 if (!isMaskPixel(decodedMask, x, y) ||
                     !isBoundaryPixel(decodedMask, x, y)) {
                     continue;
@@ -946,6 +1023,7 @@
                     raster: idMaskFrame.data,
                     regionMaskCoverage,
                     requestId: message.requestId,
+                    sourceWidth: idMaskFrame.sourceWidth,
                     strokePalette: idMaskFrame.strokePalette,
                     strokeWidths: idMaskFrame.strokeWidths,
                     type: MaskPreparationWorkerMessageType.Complete,