@yume-chan/scrcpy-decoder-webcodecs 2.5.3 → 3.0.0-beta.0

package/src/video/utils/video-decoder-stream.ts

@@ -0,0 +1,406 @@
+import { EventEmitter, StickyEventEmitter } from "@yume-chan/event";
+import type { ScrcpyVideoDecoderPerformanceCounterInterface } from "@yume-chan/scrcpy-decoder-shared";
+import { ScrcpyVideoDecoderPerformanceCounter } from "@yume-chan/scrcpy-decoder-shared";
+import { concatBuffers, TransformStream } from "@yume-chan/stream-extra";
+
+import type { CodecTransformStream } from "../codec/type.js";
+
+type State =
+    | {
+          type: "unconfigured";
+      }
+    | {
+          type: "configured";
+          /**
+           * The native decoder.
+           *
+           * `transform`, `flush` and `cancel` callbacks don't need to
+           * check `#decoder.state` for "closed".
+           *
+           * Decoder can enter "closed" state by either:
+           *   - Encounter a decoding error: this triggers `controller.error`,
+           *     so no more transformer callbacks will be called.
+           *   - Calling `close` manually: this only happens in `flush` and `cancel`,
+           *     so no more transformer callbacks will be called.
+           */
+          decoder: VideoDecoder;
+          /** Saved configuration for use when resetting/re-creating the decoder. */
+          config: CodecTransformStream.Config;
+      }
+    | {
+          type: "decoding";
+          decoder: VideoDecoder;
+          /** Saved configuration for use when resetting/re-creating the decoder. */
+          config: CodecTransformStream.Config;
+          /** Saved frames since last keyframe for use when re-creating the decoder */
+          frames: CodecTransformStream.VideoChunk[];
+      }
+    | {
+          type: "reclaimed";
+          /** Saved configuration for use when re-creating the decoder. */
+          config: CodecTransformStream.Config;
+          /** Saved frames since last keyframe for use when re-creating the decoder */
+          frames: CodecTransformStream.VideoChunk[] | undefined;
+      };
+
+function decodeFirstKeyFrame(
+    decoder: VideoDecoder,
+    config: CodecTransformStream.Config,
+    chunk: CodecTransformStream.VideoChunk,
+) {
+    decoder.decode(
+        new EncodedVideoChunk({
+            type: "key",
+            timestamp: chunk.timestamp,
+            // `lib.dom.d.ts` doesn't allow `duration` to be undefined.
+            duration: chunk.duration!,
+            data: config.raw
+                ? concatBuffers([config.raw, chunk.data])
+                : chunk.data,
+        }),
+    );
+}
+
+function decodeFrame(
+    decoder: VideoDecoder,
+    chunk: CodecTransformStream.VideoChunk,
+) {
+    decoder.decode(
+        new EncodedVideoChunk({
+            type: chunk.type,
+            timestamp: chunk.timestamp,
+            // `lib.dom.d.ts` doesn't allow `duration` to be undefined.
+            duration: chunk.duration!,
+            data: chunk.data,
+        }),
+    );
+}
+
+export class VideoDecoderStream
+    extends TransformStream<
+        CodecTransformStream.Config | CodecTransformStream.VideoChunk,
+        VideoFrame
+    >
+    implements ScrcpyVideoDecoderPerformanceCounterInterface
+{
+    #controller!: TransformStreamDefaultController<VideoFrame>;
+
+    #state: State = { type: "unconfigured" };
+
+    #hardwareAcceleration = new StickyEventEmitter<
+        Exclude<CodecTransformStream.Config["hardwareAcceleration"], undefined>
+    >({
+        initialValue: "no-preference",
+        equals: (a, b) => a === b,
+    });
+    get hardwareAcceleration() {
+        return this.#hardwareAcceleration.value;
+    }
+    get onHardwareAccelerationChange() {
+        return this.#hardwareAcceleration.event;
+    }
+
+    /**
+     * Gets the number of frames waiting to be decoded.
+     */
+    get decodeQueueSize() {
+        if ("decoder" in this.#state) {
+            return this.#state.decoder.decodeQueueSize;
+        }
+
+        return 0;
+    }
+
+    #onDequeue = new EventEmitter<undefined>();
+    /**
+     * Gets an event when a frame is dequeued (either decoded or discarded).
+     */
+    get onDequeue() {
+        return this.#onDequeue.event;
+    }
+
+    #counter = new ScrcpyVideoDecoderPerformanceCounter();
+    /**
+     * Gets the number of frames decoded by the decoder.
+     */
+    get framesDecoded() {
+        return this.#counter.framesDecoded;
+    }
+    /**
+     * Gets the number of frames skipped by the decoder.
+     */
+    get framesSkippedDecoding() {
+        return this.#counter.framesSkippedDecoding;
+    }
+    /**
+     * Gets the number of times the decoder has been reset to catch up new keyframes.
+     */
+    get decoderResetCount() {
+        return this.#counter.decoderResetCount;
+    }
+
+    #abortController = new AbortController();
+    #skipFramesBefore = -1;
+
+    constructor() {
+        let controller!: TransformStreamDefaultController<VideoFrame>;
+
+        super({
+            start: (controller_) => {
+                // WARN: can't use `this` here
+                controller = controller_;
+            },
+            transform: async (chunk) => {
+                if ("codec" in chunk) {
+                    this.#hardwareAcceleration.fire(
+                        chunk.hardwareAcceleration ?? "no-preference",
+                    );
+                    // Validate the config by creating decoder right away
+                    switch (this.#state.type) {
+                        case "unconfigured":
+                        case "reclaimed":
+                            this.#state = {
+                                type: "configured",
+                                decoder: this.#createDecoder(chunk),
+                                config: chunk,
+                            };
+                            break;
+                        // @ts-expect-error: intentional case fallthrough
+                        case "decoding":
+                            await this.#state.decoder.flush();
+                        // fallthrough
+                        case "configured":
+                            // Reuse the existing decoder.
+                            // `decoder` is definitely in "configured" state,
+                            // otherwise the stream is in error state
+                            // and no `transform` callbacks will be called.
+                            this.#state.decoder.configure(chunk);
+                            this.#state = {
+                                type: "configured",
+                                decoder: this.#state.decoder,
+                                config: chunk,
+                            };
+                            break;
+                    }
+                    return;
+                }
+
+                this.#handleVideoChunk(chunk);
+            },
+            flush: async () => {
+                // only call `flush` when `decoder.state` is "configured".
+                if (
+                    "decoder" in this.#state &&
+                    this.#state.decoder.state === "configured"
+                ) {
+                    // This also delays closing `readable` and `writable` streams
+                    // (if they are not in error state) until all frames are decoded.
+                    await this.#state.decoder.flush();
+                }
+                this.#dispose();
+            },
+            cancel: () => {
+                // Immediately close the decoder on stream cancel/error
+                this.#dispose();
+            },
+        });
+
+        this.#controller = controller;
+    }
+
+    #handleVideoChunk(chunk: CodecTransformStream.VideoChunk) {
+        switch (this.#state.type) {
+            case "unconfigured":
+                throw new Error("Decoder not configured");
+            case "configured": {
+                if (chunk.type === "delta") {
+                    throw new Error("Expect a keyframe but got a delta frame");
+                }
+
+                decodeFirstKeyFrame(
+                    this.#state.decoder,
+                    this.#state.config,
+                    chunk,
+                );
+
+                this.#state = {
+                    type: "decoding",
+                    decoder: this.#state.decoder,
+                    config: this.#state.config,
+                    frames: [chunk],
+                };
+                break;
+            }
+            case "decoding":
+                if (chunk.type === "key") {
+                    this.#state.frames.length = 0;
+                }
+                this.#state.frames.push(chunk);
+
+                decodeFrame(this.#state.decoder, chunk);
+                break;
+            case "reclaimed": {
+                const decoder = this.#createDecoder(this.#state.config);
+
+                if (chunk.type === "key") {
+                    decodeFirstKeyFrame(decoder, this.#state.config, chunk);
+
+                    this.#state = {
+                        type: "decoding",
+                        decoder: decoder,
+                        config: this.#state.config,
+                        frames: [chunk],
+                    };
+                    return;
+                }
+
+                if (!this.#state.frames) {
+                    // Reclaimed when configured but no frames have been decoded yet,
+                    // so a keyframe is required to start decoding.
+                    throw new Error("Expect a keyframe but got a delta frame");
+                }
+
+                decodeFirstKeyFrame(
+                    decoder,
+                    this.#state.config,
+                    this.#state.frames[0]!,
+                );
+
+                // `chunk`s must have monotonic timestamps, so we can skip all frames before `chunk`.
+                this.#skipFramesBefore = chunk.timestamp;
+                this.#state.frames.push(chunk);
+
+                for (const frame of this.#state.frames.slice(1)) {
+                    decodeFrame(decoder, frame);
+                }
+
+                this.#state = {
+                    type: "decoding",
+                    decoder: decoder,
+                    config: this.#state.config,
+                    frames: this.#state.frames,
+                };
+
+                break;
+            }
+        }
+    }
+
+    #createDecoder(config: CodecTransformStream.Config) {
+        const decoder = new VideoDecoder({
+            output: (frame) => {
+                if (frame.timestamp < this.#skipFramesBefore) {
+                    frame.close();
+                    return;
+                }
+
+                this.#counter.increaseFramesDecoded();
+                try {
+                    this.#controller.enqueue(frame);
+                } catch {
+                    // `controller` is closed
+                    frame.close();
+                }
+            },
+            error: (error) => {
+                if (error.name === "QuotaExceededError") {
+                    // Chrome reclaims inactive `VideoDecoder`'s after 90 seconds
+                    // (for example due to pausing decoding when the document is hidden).
+                    // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/modules/webcodecs/reclaimable_codec.cc;l=181;drc=aba14550ed0b4620deb59e7c5f551cbde8970fb3
+                    // Reset states, it will be recreated in next `transform` call.
+                    switch (this.#state.type) {
+                        case "unconfigured":
+                        case "reclaimed":
+                            // Don't throw, report errors to stream
+                            this.#controller.error(
+                                new Error(
+                                    "Unexpected state when reclaiming decoder",
+                                ),
+                            );
+                            this.#dispose();
+                            return;
+                        case "configured":
+                            // Unlike `transform` callback,
+                            // this doesn't re-create the decoder immediately,
+                            // because the config has already been validated,
+                            // and since browser reclaims the decoder to save hardware resources,
+                            // we don't want to undo that by creating a new decoder immediately.
+                            this.#state = {
+                                type: "reclaimed",
+                                config,
+                                frames: undefined,
+                            };
+                            break;
+                        case "decoding":
+                            this.#state = {
+                                type: "reclaimed",
+                                config,
+                                frames: this.#state.frames,
+                            };
+                            break;
+                    }
+                    return;
+                }
+
+                // Maybe the decoder is hardware accelerated but the hardware has an issue,
+                // retry with software decoder.
+                if (
+                    error.name === "EncodingError" &&
+                    this.#state.type === "decoding" &&
+                    config.hardwareAcceleration !== "prefer-software"
+                ) {
+                    try {
+                        config.hardwareAcceleration = "prefer-software";
+                        this.#hardwareAcceleration.fire("prefer-software");
+                        const decoder = this.#createDecoder(config);
+
+                        // Replay frames with rendering skipping
+                        this.#skipFramesBefore =
+                            this.#state.frames.at(-1)!.timestamp;
+                        decodeFirstKeyFrame(
+                            decoder,
+                            config,
+                            this.#state.frames[0]!,
+                        );
+                        for (const frame of this.#state.frames.slice(1)) {
+                            decodeFrame(decoder, frame);
+                        }
+
+                        // Update state
+                        this.#state.decoder = decoder;
+                        return;
+                    } catch {
+                        // ignore, report original error to stream
+                    }
+                }
+
+                // Propagate other decoder errors to stream.
+                this.#controller.error(error);
+                this.#dispose();
+            },
+        });
+
+        decoder.addEventListener(
+            "dequeue",
+            () => this.#onDequeue.fire(undefined),
+            { signal: this.#abortController.signal },
+        );
+
+        decoder.configure(config);
+
+        return decoder;
+    }
+
+    #dispose() {
+        this.#abortController.abort();
+        this.#onDequeue.dispose();
+
+        if (
+            "decoder" in this.#state &&
+            this.#state.decoder.state !== "closed"
+        ) {
+            this.#state.decoder.close();
+        }
+        this.#state = { type: "unconfigured" };
+    }
+}

package/tsconfig.build.json

@@ -7,18 +7,4 @@
         ],
         "types": []
     },
-    "references": [
-        {
-            "path": "../no-data-view/tsconfig.build.json"
-        },
-        {
-            "path": "../scrcpy-decoder-tinyh264/tsconfig.build.json"
-        },
-        {
-            "path": "../scrcpy/tsconfig.build.json"
-        },
-        {
-            "path": "../stream-extra/tsconfig.build.json"
-        }
-    ]
 }

package/CHANGELOG.md

@@ -1,140 +0,0 @@
-# Change Log - @yume-chan/scrcpy-decoder-webcodecs
-
-## 2.5.0
-
-### Minor Changes
-
-- 5ec8923: Expose `VideoDecoder.prototype.configure`'s `hardwareAcceleration` option
-
-## 2.1.0
-
-### Patch Changes
-
-- Updated dependencies [40a60ca]
-    - @yume-chan/stream-extra@2.1.0
-    - @yume-chan/scrcpy@2.1.0
-    - @yume-chan/scrcpy-decoder-tinyh264@2.1.0
-
-## 2.0.1
-
-### Patch Changes
-
-- @yume-chan/scrcpy@2.0.1
-- @yume-chan/stream-extra@2.0.1
-- @yume-chan/scrcpy-decoder-tinyh264@2.0.1
-
-## 2.0.0
-
-### Patch Changes
-
-- Updated dependencies [fe06652]
-- Updated dependencies [05c01ad]
-- Updated dependencies [02f5bd5]
-- Updated dependencies
-    - @yume-chan/scrcpy@2.0.0
-    - @yume-chan/event@2.0.0
-    - @yume-chan/no-data-view@2.0.0
-    - @yume-chan/scrcpy-decoder-tinyh264@2.0.0
-    - @yume-chan/stream-extra@2.0.0
-
-## 1.1.0
-
-### Minor Changes
-
-- fba7533: Rename `XXXWebCodecsDecoderRenderer` to `XXXVideoFrameRenderer`
-
-### Patch Changes
-
-- Updated dependencies [6140ebc]
-- Updated dependencies [6140ebc]
-- Updated dependencies [6140ebc]
-- Updated dependencies [8c5b3c2]
-- Updated dependencies [7f2a09c]
-- Updated dependencies [cb44b63]
-    - @yume-chan/scrcpy@1.1.0
-    - @yume-chan/scrcpy-decoder-tinyh264@1.1.0
-
-## 1.0.1
-
-### Patch Changes
-
-- 53688d3: Use PNPM workspace and Changesets to manage the monorepo.
-
-    Because Changesets doesn't support alpha versions (`0.x.x`), this version is `1.0.0`. Future versions will follow SemVer rules, for example, breaking API changes will introduce a new major version.
-
-- db8466f: Fix H.265 rendering in Microsoft Edge
-- 8e4c1ef: Add a renderer based on Insertable Stream API
-- db8466f: Add a `snapshot` method to convert the last rendered frame into PNG
-- Updated dependencies [53688d3]
-- Updated dependencies [db8466f]
-- Updated dependencies [db8466f]
-- Updated dependencies [ea5002b]
-- Updated dependencies [ea5002b]
-- Updated dependencies [db8466f]
-    - @yume-chan/scrcpy-decoder-tinyh264@1.0.1
-    - @yume-chan/no-data-view@1.0.1
-    - @yume-chan/stream-extra@1.0.1
-    - @yume-chan/scrcpy@1.0.1
-    - @yume-chan/event@1.0.1
-
-This log was last generated on Tue, 18 Jun 2024 02:49:43 GMT and should not be manually modified.
-
-## 0.0.24
-
-Tue, 18 Jun 2024 02:49:43 GMT
-
-### Updates
-
-- Support decoding AV1
-- Add `enableCapture` option to `WebCodecsVideoDecoder` which allows `renderer.readPixels` and `renderer.toDataURL` to work. The performance will be slightly affected when enabled.
-
-## 0.0.23
-
-Thu, 21 Mar 2024 03:15:10 GMT
-
-### Updates
-
-- Add `sizeChanged` event
-- Add WebGL and Bitmap based video renderers, which are 1.5 to 3 times faster on Android devices
-
-## 0.0.22
-
-Wed, 13 Dec 2023 05:57:27 GMT
-
-_Version update only_
-
-## 0.0.21
-
-Fri, 25 Aug 2023 14:05:18 GMT
-
-_Version update only_
-
-## 0.0.20
-
-Mon, 05 Jun 2023 02:51:41 GMT
-
-### Updates
-
-- Add support for decoding H.265 on supported browsers (Chrome works, Microsoft Edge with HEVC Video Extension from Microsoft Store doesn't decode H.265 correctly).
-
-## 0.0.19
-
-Sun, 09 Apr 2023 05:55:33 GMT
-
-_Version update only_
-
-## 0.0.18
-
-Wed, 25 Jan 2023 21:33:49 GMT
-
-### Updates
-
-- Change to not use vertical sync to minimize latency
-
-## 0.0.17
-
-Tue, 18 Oct 2022 09:32:30 GMT
-
-### Updates
-
-- Separated from `@yume-chan/scrcpy` for simpler dependency management.

package/esm/video/codec/utils.d.ts

@@ -1,4 +0,0 @@
-export declare function hexDigits(value: number): string;
-export declare function hexTwoDigits(value: number): string;
-export declare function decimalTwoDigits(value: number): string;
-//# sourceMappingURL=utils.d.ts.map

package/esm/video/codec/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/video/codec/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,UAEtC;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,UAEzC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,UAE7C"}

package/esm/video/codec/utils.js

@@ -1,10 +0,0 @@
-export function hexDigits(value) {
-    return value.toString(16).toUpperCase();
-}
-export function hexTwoDigits(value) {
-    return value.toString(16).toUpperCase().padStart(2, "0");
-}
-export function decimalTwoDigits(value) {
-    return value.toString(10).padStart(2, "0");
-}
-//# sourceMappingURL=utils.js.map

package/esm/video/codec/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/video/codec/utils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAC,KAAa;IACnC,OAAO,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,OAAO,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC1C,OAAO,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC/C,CAAC"}

package/esm/video/snapshot.d.ts

@@ -1,6 +0,0 @@
-export declare class VideoFrameCapturer {
-    #private;
-    constructor();
-    capture(frame: VideoFrame): Promise<Blob>;
-}
-//# sourceMappingURL=snapshot.d.ts.map

package/esm/video/snapshot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/video/snapshot.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAkB;;;IAiBrB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAuBlD"}

package/esm/video/snapshot.js

@@ -1,41 +0,0 @@
-export class VideoFrameCapturer {
-    #canvas;
-    #context;
-    constructor() {
-        if (typeof OffscreenCanvas !== "undefined") {
-            this.#canvas = new OffscreenCanvas(1, 1);
-        }
-        else {
-            this.#canvas = document.createElement("canvas");
-            this.#canvas.width = 1;
-            this.#canvas.height = 1;
-        }
-        this.#context = this.#canvas.getContext("bitmaprenderer", {
-            alpha: false,
-        });
-    }
-    async capture(frame) {
-        this.#canvas.width = frame.displayWidth;
-        this.#canvas.height = frame.displayHeight;
-        const bitmap = await createImageBitmap(frame);
-        this.#context.transferFromImageBitmap(bitmap);
-        if (this.#canvas instanceof OffscreenCanvas) {
-            return await this.#canvas.convertToBlob({
-                type: "image/png",
-            });
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                this.#canvas.toBlob((blob) => {
-                    if (!blob) {
-                        reject(new Error("Failed to convert canvas to blob"));
-                    }
-                    else {
-                        resolve(blob);
-                    }
-                }, "image/png");
-            });
-        }
-    }
-}
-//# sourceMappingURL=snapshot.js.map

package/esm/video/snapshot.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../src/video/snapshot.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,kBAAkB;IAC3B,OAAO,CAAsC;IAC7C,QAAQ,CAA8B;IAEtC;QACI,IAAI,OAAO,eAAe,KAAK,WAAW,EAAE,CAAC;YACzC,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAChD,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;YACvB,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,gBAAgB,EAAE;YACtD,KAAK,EAAE,KAAK;SACf,CAAE,CAAC;IACR,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,KAAiB;QAC3B,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC;QAE1C,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;QAE9C,IAAI,IAAI,CAAC,OAAO,YAAY,eAAe,EAAE,CAAC;YAC1C,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;gBACpC,IAAI,EAAE,WAAW;aACpB,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBAClC,IAAI,CAAC,OAA6B,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;oBAChD,IAAI,CAAC,IAAI,EAAE,CAAC;wBACR,MAAM,CAAC,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC,CAAC;oBAC1D,CAAC;yBAAM,CAAC;wBACJ,OAAO,CAAC,IAAI,CAAC,CAAC;oBAClB,CAAC;gBACL,CAAC,EAAE,WAAW,CAAC,CAAC;YACpB,CAAC,CAAC,CAAC;QACP,CAAC;IACL,CAAC;CACJ"}

package/src/video/codec/utils.ts

@@ -1,11 +0,0 @@
-export function hexDigits(value: number) {
-    return value.toString(16).toUpperCase();
-}
-
-export function hexTwoDigits(value: number) {
-    return value.toString(16).toUpperCase().padStart(2, "0");
-}
-
-export function decimalTwoDigits(value: number) {
-    return value.toString(10).padStart(2, "0");
-}