@yume-chan/scrcpy 0.0.24 → 1.1.0

package/src/options/1_16/options.ts

@@ -1,270 +0,0 @@
-import {
-    getUint16BigEndian,
-    getUint32BigEndian,
-} from "@yume-chan/no-data-view";
-import type {
-    PushReadableStreamController,
-    ReadableStream,
-} from "@yume-chan/stream-extra";
-import {
-    BufferedReadableStream,
-    PushReadableStream,
-    StructDeserializeStream,
-    TransformStream,
-} from "@yume-chan/stream-extra";
-import type { AsyncExactReadable, ValueOrPromise } from "@yume-chan/struct";
-import { decodeUtf8 } from "@yume-chan/struct";
-
-import type {
-    ScrcpyBackOrScreenOnControlMessage,
-    ScrcpyControlMessageType,
-    ScrcpyInjectTouchControlMessage,
-    ScrcpySetClipboardControlMessage,
-} from "../../control/index.js";
-import { AndroidKeyEventAction } from "../../control/index.js";
-import type {
-    ScrcpyMediaStreamPacket,
-    ScrcpyVideoStream,
-    ScrcpyVideoStreamMetadata,
-} from "../codec.js";
-import { ScrcpyVideoCodecId } from "../codec.js";
-import type { ScrcpyDisplay, ScrcpyEncoder } from "../types.js";
-import { ScrcpyOptions, toScrcpyOptionValue } from "../types.js";
-
-import { CodecOptions } from "./codec-options.js";
-import type { ScrcpyOptionsInit1_16 } from "./init.js";
-import { ScrcpyLogLevel1_16, ScrcpyVideoOrientation1_16 } from "./init.js";
-import {
-    SCRCPY_CONTROL_MESSAGE_TYPES_1_16,
-    SCRCPY_MEDIA_PACKET_FLAG_CONFIG,
-    ScrcpyBackOrScreenOnControlMessage1_16,
-    ScrcpyClipboardDeviceMessage,
-    ScrcpyInjectTouchControlMessage1_16,
-    ScrcpyMediaStreamRawPacket,
-    ScrcpySetClipboardControlMessage1_15,
-} from "./message.js";
-import type { ScrcpyScrollController } from "./scroll.js";
-import { ScrcpyScrollController1_16 } from "./scroll.js";
-
-export class ScrcpyOptions1_16 extends ScrcpyOptions<ScrcpyOptionsInit1_16> {
-    static readonly DEFAULTS = {
-        logLevel: ScrcpyLogLevel1_16.Debug,
-        maxSize: 0,
-        bitRate: 8_000_000,
-        maxFps: 0,
-        lockVideoOrientation: ScrcpyVideoOrientation1_16.Unlocked,
-        tunnelForward: false,
-        crop: undefined,
-        sendFrameMeta: true,
-        control: true,
-        displayId: 0,
-        showTouches: false,
-        stayAwake: false,
-        codecOptions: new CodecOptions(),
-    } as const satisfies Required<ScrcpyOptionsInit1_16>;
-
-    static readonly SERIALIZE_ORDER = [
-        "logLevel",
-        "maxSize",
-        "bitRate",
-        "maxFps",
-        "lockVideoOrientation",
-        "tunnelForward",
-        "crop",
-        "sendFrameMeta",
-        "control",
-        "displayId",
-        "showTouches",
-        "stayAwake",
-        "codecOptions",
-    ] as const satisfies readonly (keyof ScrcpyOptionsInit1_16)[];
-
-    static serialize<T>(options: T, order: readonly (keyof T)[]) {
-        return order.map((key) => toScrcpyOptionValue(options[key], "-"));
-    }
-
-    /**
-     * Parse a fixed-length, null-terminated string.
-     * @param stream The stream to read from
-     * @param maxLength The maximum length of the string, including the null terminator, in bytes
-     * @returns The parsed string, without the null terminator
-     */
-    static async parseCString(
-        stream: AsyncExactReadable,
-        maxLength: number,
-    ): Promise<string> {
-        const buffer = await stream.readExactly(maxLength);
-        // If null terminator is not found, `subarray(0, -1)` will remove the last byte
-        // But since it's a invalid case, it's fine
-        return decodeUtf8(buffer.subarray(0, buffer.indexOf(0)));
-    }
-
-    static async parseUint16BE(stream: AsyncExactReadable): Promise<number> {
-        const buffer = await stream.readExactly(2);
-        return getUint16BigEndian(buffer, 0);
-    }
-
-    static async parseUint32BE(stream: AsyncExactReadable): Promise<number> {
-        const buffer = await stream.readExactly(4);
-        return getUint32BigEndian(buffer, 0);
-    }
-
-    readonly defaults: Required<ScrcpyOptionsInit1_16> =
-        ScrcpyOptions1_16.DEFAULTS;
-
-    override get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
-        return SCRCPY_CONTROL_MESSAGE_TYPES_1_16;
-    }
-
-    #clipboardController!: PushReadableStreamController<string>;
-    #clipboard: ReadableStream<string>;
-    override get clipboard() {
-        return this.#clipboard;
-    }
-
-    constructor(init: ScrcpyOptionsInit1_16) {
-        super(undefined, init, ScrcpyOptions1_16.DEFAULTS);
-        this.#clipboard = new PushReadableStream<string>((controller) => {
-            this.#clipboardController = controller;
-        });
-    }
-
-    serialize(): string[] {
-        return ScrcpyOptions1_16.serialize(
-            this.value,
-            ScrcpyOptions1_16.SERIALIZE_ORDER,
-        );
-    }
-
-    override setListEncoders(): void {
-        throw new Error("Not supported");
-    }
-
-    override setListDisplays(): void {
-        // Set to an invalid value
-        // Server will print valid values before crashing
-        // (server will crash before opening sockets)
-        this.value.displayId = -1;
-    }
-
-    override parseEncoder(): ScrcpyEncoder | undefined {
-        throw new Error("Not supported");
-    }
-
-    override parseDisplay(line: string): ScrcpyDisplay | undefined {
-        const match = line.match(/^\s+scrcpy --display (\d+)$/);
-        if (match) {
-            return {
-                id: Number.parseInt(match[1]!, 10),
-            };
-        }
-        return undefined;
-    }
-
-    override parseVideoStreamMetadata(
-        stream: ReadableStream<Uint8Array>,
-    ): ValueOrPromise<ScrcpyVideoStream> {
-        return (async () => {
-            const buffered = new BufferedReadableStream(stream);
-            const metadata: ScrcpyVideoStreamMetadata = {
-                codec: ScrcpyVideoCodecId.H264,
-            };
-            metadata.deviceName = await ScrcpyOptions1_16.parseCString(
-                buffered,
-                64,
-            );
-            metadata.width = await ScrcpyOptions1_16.parseUint16BE(buffered);
-            metadata.height = await ScrcpyOptions1_16.parseUint16BE(buffered);
-            return { stream: buffered.release(), metadata };
-        })();
-    }
-
-    override parseAudioStreamMetadata(): never {
-        throw new Error("Not supported");
-    }
-
-    override async parseDeviceMessage(
-        id: number,
-        stream: AsyncExactReadable,
-    ): Promise<boolean> {
-        switch (id) {
-            case 0: {
-                const message =
-                    await ScrcpyClipboardDeviceMessage.deserialize(stream);
-                await this.#clipboardController.enqueue(message.content);
-                return true;
-            }
-            default:
-                return false;
-        }
-    }
-
-    override createMediaStreamTransformer(): TransformStream<
-        Uint8Array,
-        ScrcpyMediaStreamPacket
-    > {
-        // Optimized path for video frames only
-        if (!this.value.sendFrameMeta) {
-            return new TransformStream({
-                transform(chunk, controller) {
-                    controller.enqueue({
-                        type: "data",
-                        data: chunk,
-                    });
-                },
-            });
-        }
-
-        const deserializeStream = new StructDeserializeStream(
-            ScrcpyMediaStreamRawPacket,
-        );
-        return {
-            writable: deserializeStream.writable,
-            readable: deserializeStream.readable.pipeThrough(
-                new TransformStream({
-                    transform(packet, controller) {
-                        if (packet.pts === SCRCPY_MEDIA_PACKET_FLAG_CONFIG) {
-                            controller.enqueue({
-                                type: "configuration",
-                                data: packet.data,
-                            });
-                            return;
-                        }
-
-                        controller.enqueue({
-                            type: "data",
-                            pts: packet.pts,
-                            data: packet.data,
-                        });
-                    },
-                }),
-            ),
-        };
-    }
-
-    override serializeInjectTouchControlMessage(
-        message: ScrcpyInjectTouchControlMessage,
-    ): Uint8Array {
-        return ScrcpyInjectTouchControlMessage1_16.serialize(message);
-    }
-
-    override serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage,
-    ) {
-        if (message.action === AndroidKeyEventAction.Down) {
-            return ScrcpyBackOrScreenOnControlMessage1_16.serialize(message);
-        }
-
-        return undefined;
-    }
-
-    override serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage,
-    ): Uint8Array {
-        return ScrcpySetClipboardControlMessage1_15.serialize(message);
-    }
-
-    override createScrollController(): ScrcpyScrollController {
-        return new ScrcpyScrollController1_16();
-    }
-}

package/src/options/1_17.ts

@@ -1,60 +0,0 @@
-import type { ScrcpyOptionsInit1_16 } from "./1_16/index.js";
-import { ScrcpyOptions1_16 } from "./1_16/index.js";
-import type { ScrcpyEncoder } from "./types.js";
-import { ScrcpyOptions } from "./types.js";
-
-export interface ScrcpyOptionsInit1_17 extends ScrcpyOptionsInit1_16 {
-    encoderName?: string | undefined;
-}
-
-export class ScrcpyOptions1_17 extends ScrcpyOptions<ScrcpyOptionsInit1_17> {
-    static readonly DEFAULTS = {
-        ...ScrcpyOptions1_16.DEFAULTS,
-        encoderName: undefined,
-    } as const satisfies Required<ScrcpyOptionsInit1_17>;
-
-    static readonly SERIALIZE_ORDER = [
-        ...ScrcpyOptions1_16.SERIALIZE_ORDER,
-        "encoderName",
-    ] as const satisfies readonly (keyof ScrcpyOptionsInit1_17)[];
-
-    static parseEncoder(
-        line: string,
-        encoderNameRegex: RegExp,
-    ): ScrcpyEncoder | undefined {
-        const match = line.match(encoderNameRegex);
-        if (match) {
-            return { type: "video", name: match[1]! };
-        }
-        return undefined;
-    }
-
-    override get defaults(): Required<ScrcpyOptionsInit1_17> {
-        return ScrcpyOptions1_17.DEFAULTS;
-    }
-
-    constructor(init: ScrcpyOptionsInit1_17) {
-        super(ScrcpyOptions1_16, init, ScrcpyOptions1_17.DEFAULTS);
-    }
-
-    override serialize(): string[] {
-        return ScrcpyOptions1_16.serialize(
-            this.value,
-            ScrcpyOptions1_17.SERIALIZE_ORDER,
-        );
-    }
-
-    override setListEncoders() {
-        // Set to an invalid value
-        // Server will print valid values before crashing
-        // (server will crash after opening video and control sockets)
-        this.value.encoderName = "_";
-    }
-
-    override parseEncoder(line: string): ScrcpyEncoder | undefined {
-        return ScrcpyOptions1_17.parseEncoder(
-            line,
-            /^\s+scrcpy --encoder-name '([^']+)'$/,
-        );
-    }
-}

package/src/options/1_18.ts

@@ -1,104 +0,0 @@
-import Struct, { placeholder } from "@yume-chan/struct";
-
-import type {
-    AndroidKeyEventAction,
-    ScrcpyBackOrScreenOnControlMessage,
-} from "../control/index.js";
-import { ScrcpyControlMessageType } from "../control/index.js";
-
-import {
-    SCRCPY_CONTROL_MESSAGE_TYPES_1_16,
-    ScrcpyBackOrScreenOnControlMessage1_16,
-    ScrcpyOptions1_16,
-} from "./1_16/index.js";
-import type { ScrcpyOptionsInit1_17 } from "./1_17.js";
-import { ScrcpyOptions1_17 } from "./1_17.js";
-import type { ScrcpyEncoder } from "./types.js";
-import { ScrcpyOptions } from "./types.js";
-
-export enum ScrcpyLogLevel1_18 {
-    Verbose = "verbose",
-    Debug = "debug",
-    Info = "info",
-    Warn = "warn",
-    Error = "error",
-}
-
-export enum ScrcpyVideoOrientation1_18 {
-    Initial = -2,
-    Unlocked = -1,
-    Portrait = 0,
-    Landscape = 1,
-    PortraitFlipped = 2,
-    LandscapeFlipped = 3,
-}
-
-export interface ScrcpyOptionsInit1_18
-    extends Omit<ScrcpyOptionsInit1_17, "logLevel" | "lockVideoOrientation"> {
-    logLevel?: ScrcpyLogLevel1_18;
-
-    lockVideoOrientation?: ScrcpyVideoOrientation1_18;
-
-    powerOffOnClose?: boolean;
-}
-
-export const ScrcpyBackOrScreenOnControlMessage1_18 = new Struct()
-    .concat(ScrcpyBackOrScreenOnControlMessage1_16)
-    .uint8("action", placeholder<AndroidKeyEventAction>());
-
-export type ScrcpyBackOrScreenOnControlMessage1_18 =
-    (typeof ScrcpyBackOrScreenOnControlMessage1_18)["TInit"];
-
-export const SCRCPY_CONTROL_MESSAGE_TYPES_1_18 =
-    SCRCPY_CONTROL_MESSAGE_TYPES_1_16.slice();
-SCRCPY_CONTROL_MESSAGE_TYPES_1_18.splice(
-    6,
-    0,
-    ScrcpyControlMessageType.ExpandSettingPanel,
-);
-
-export class ScrcpyOptions1_18 extends ScrcpyOptions<ScrcpyOptionsInit1_18> {
-    static readonly DEFAULTS = {
-        ...ScrcpyOptions1_17.DEFAULTS,
-        logLevel: ScrcpyLogLevel1_18.Debug,
-        lockVideoOrientation: ScrcpyVideoOrientation1_18.Unlocked,
-        powerOffOnClose: false,
-    } as const satisfies Required<ScrcpyOptionsInit1_18>;
-
-    static readonly SERIALIZE_ORDER = [
-        ...ScrcpyOptions1_17.SERIALIZE_ORDER,
-        "powerOffOnClose",
-    ] as const satisfies readonly (keyof ScrcpyOptionsInit1_18)[];
-
-    override get defaults(): Required<ScrcpyOptionsInit1_18> {
-        return ScrcpyOptions1_18.DEFAULTS;
-    }
-
-    override get controlMessageTypes() {
-        return SCRCPY_CONTROL_MESSAGE_TYPES_1_18;
-    }
-
-    constructor(init: ScrcpyOptionsInit1_18) {
-        super(ScrcpyOptions1_17, init, ScrcpyOptions1_18.DEFAULTS);
-    }
-
-    override serialize(): string[] {
-        return ScrcpyOptions1_16.serialize(
-            this.value,
-            ScrcpyOptions1_18.SERIALIZE_ORDER,
-        );
-    }
-
-    override parseEncoder(line: string): ScrcpyEncoder | undefined {
-        return ScrcpyOptions1_17.parseEncoder(
-            line,
-            /^\s+scrcpy --encoder '([^']+)'$/,
-        );
-    }
-
-    override serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage,
-    ) {
-        return ScrcpyBackOrScreenOnControlMessage1_18.serialize(message);
-    }
-}

package/src/options/1_21.ts

@@ -1,112 +0,0 @@
-// cspell: ignore autosync
-
-import { PromiseResolver } from "@yume-chan/async";
-import type { AsyncExactReadable } from "@yume-chan/struct";
-import Struct, { placeholder } from "@yume-chan/struct";
-
-import type { ScrcpySetClipboardControlMessage } from "../control/index.js";
-
-import type { ScrcpyOptionsInit1_18 } from "./1_18.js";
-import { ScrcpyOptions1_18 } from "./1_18.js";
-import { ScrcpyOptions, toScrcpyOptionValue } from "./types.js";
-
-export const ScrcpyAckClipboardDeviceMessage = new Struct().uint64("sequence");
-
-export interface ScrcpyOptionsInit1_21 extends ScrcpyOptionsInit1_18 {
-    clipboardAutosync?: boolean;
-}
-
-function toSnakeCase(input: string): string {
-    return input.replace(/([A-Z])/g, "_$1").toLowerCase();
-}
-
-export const ScrcpySetClipboardControlMessage1_21 = new Struct()
-    .uint8("type")
-    .uint64("sequence")
-    .int8("paste", placeholder<boolean>())
-    .uint32("length")
-    .string("content", { lengthField: "length" });
-
-export type ScrcpySetClipboardControlMessage1_21 =
-    (typeof ScrcpySetClipboardControlMessage1_21)["TInit"];
-
-export class ScrcpyOptions1_21 extends ScrcpyOptions<ScrcpyOptionsInit1_21> {
-    static readonly DEFAULTS = {
-        ...ScrcpyOptions1_18.DEFAULTS,
-        clipboardAutosync: true,
-    } as const satisfies Required<ScrcpyOptionsInit1_21>;
-
-    static serialize<T extends object>(
-        options: T,
-        defaults: Required<T>,
-    ): string[] {
-        // 1.21 changed the format of arguments
-        const result: string[] = [];
-        for (const [key, value] of Object.entries(options)) {
-            const serializedValue = toScrcpyOptionValue(value, undefined);
-            if (!serializedValue) {
-                continue;
-            }
-
-            const defaultValue = toScrcpyOptionValue(
-                defaults[key as keyof T],
-                undefined,
-            );
-            if (serializedValue == defaultValue) {
-                continue;
-            }
-
-            result.push(`${toSnakeCase(key)}=${serializedValue}`);
-        }
-        return result;
-    }
-
-    override get defaults(): Required<ScrcpyOptionsInit1_21> {
-        return ScrcpyOptions1_21.DEFAULTS;
-    }
-
-    #clipboardAck = new Map<bigint, PromiseResolver<void>>();
-
-    constructor(init: ScrcpyOptionsInit1_21) {
-        super(ScrcpyOptions1_18, init, ScrcpyOptions1_21.DEFAULTS);
-    }
-
-    override async parseDeviceMessage(
-        id: number,
-        stream: AsyncExactReadable,
-    ): Promise<boolean> {
-        switch (id) {
-            case 1: {
-                const message =
-                    await ScrcpyAckClipboardDeviceMessage.deserialize(stream);
-                const resolver = this.#clipboardAck.get(message.sequence);
-                if (resolver) {
-                    resolver.resolve();
-                    this.#clipboardAck.delete(message.sequence);
-                }
-                return true;
-            }
-            default:
-                return await super.parseDeviceMessage(id, stream);
-        }
-    }
-
-    override serialize(): string[] {
-        return ScrcpyOptions1_21.serialize(this.value, this.defaults);
-    }
-
-    override serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage,
-    ): Uint8Array | [Uint8Array, Promise<void>] {
-        if (message.sequence === 0n) {
-            return ScrcpySetClipboardControlMessage1_21.serialize(message);
-        }
-
-        const resolver = new PromiseResolver<void>();
-        this.#clipboardAck.set(message.sequence, resolver);
-        return [
-            ScrcpySetClipboardControlMessage1_21.serialize(message),
-            resolver.promise,
-        ];
-    }
-}

package/src/options/1_22/index.ts

@@ -1,3 +0,0 @@
-export * from "./init.js";
-export * from "./options.js";
-export * from "./scroll.js";

package/src/options/1_22/options.ts

@@ -1,46 +0,0 @@
-import type { ReadableStream } from "@yume-chan/stream-extra";
-import type { ValueOrPromise } from "@yume-chan/struct";
-
-import type { ScrcpyScrollController } from "../1_16/index.js";
-import { ScrcpyOptions1_21 } from "../1_21.js";
-import type { ScrcpyVideoStream } from "../codec.js";
-import { ScrcpyVideoCodecId } from "../codec.js";
-import { ScrcpyOptions } from "../types.js";
-
-import type { ScrcpyOptionsInit1_22 } from "./init.js";
-import { ScrcpyScrollController1_22 } from "./scroll.js";
-
-export class ScrcpyOptions1_22 extends ScrcpyOptions<ScrcpyOptionsInit1_22> {
-    static readonly DEFAULTS = {
-        ...ScrcpyOptions1_21.DEFAULTS,
-        downsizeOnError: true,
-        sendDeviceMeta: true,
-        sendDummyByte: true,
-    } as const satisfies Required<ScrcpyOptionsInit1_22>;
-
-    override get defaults(): Required<ScrcpyOptionsInit1_22> {
-        return ScrcpyOptions1_22.DEFAULTS;
-    }
-
-    constructor(init: ScrcpyOptionsInit1_22) {
-        super(ScrcpyOptions1_21, init, ScrcpyOptions1_22.DEFAULTS);
-    }
-
-    override parseVideoStreamMetadata(
-        stream: ReadableStream<Uint8Array>,
-    ): ValueOrPromise<ScrcpyVideoStream> {
-        if (!this.value.sendDeviceMeta) {
-            return { stream, metadata: { codec: ScrcpyVideoCodecId.H264 } };
-        } else {
-            return super.parseVideoStreamMetadata(stream);
-        }
-    }
-
-    override serialize(): string[] {
-        return ScrcpyOptions1_21.serialize(this.value, this.defaults);
-    }
-
-    override createScrollController(): ScrcpyScrollController {
-        return new ScrcpyScrollController1_22();
-    }
-}

package/src/options/1_22/scroll.ts

@@ -1,26 +0,0 @@
-import Struct from "@yume-chan/struct";
-
-import {
-    ScrcpyInjectScrollControlMessage1_16,
-    ScrcpyScrollController1_16,
-} from "../1_16/index.js";
-
-export const ScrcpyInjectScrollControlMessage1_22 = new Struct()
-    .concat(ScrcpyInjectScrollControlMessage1_16)
-    .int32("buttons");
-
-export type ScrcpyInjectScrollControlMessage1_22 =
-    (typeof ScrcpyInjectScrollControlMessage1_22)["TInit"];
-
-export class ScrcpyScrollController1_22 extends ScrcpyScrollController1_16 {
-    override serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage1_22,
-    ): Uint8Array | undefined {
-        const processed = this.processMessage(message);
-        if (!processed) {
-            return undefined;
-        }
-
-        return ScrcpyInjectScrollControlMessage1_22.serialize(processed);
-    }
-}

package/src/options/1_23.ts

@@ -1,62 +0,0 @@
-import { TransformStream } from "@yume-chan/stream-extra";
-
-import { ScrcpyOptions1_21 } from "./1_21.js";
-import type { ScrcpyOptionsInit1_22 } from "./1_22/index.js";
-import { ScrcpyOptions1_22 } from "./1_22/index.js";
-import type { ScrcpyMediaStreamPacket } from "./codec.js";
-import { ScrcpyOptions } from "./types.js";
-
-export interface ScrcpyOptionsInit1_23 extends ScrcpyOptionsInit1_22 {
-    cleanup?: boolean;
-}
-
-const KEYFRAME_PTS = 1n << 62n;
-
-export class ScrcpyOptions1_23 extends ScrcpyOptions<ScrcpyOptionsInit1_23> {
-    static readonly DEFAULTS = {
-        ...ScrcpyOptions1_22.DEFAULTS,
-        cleanup: true,
-    } as const satisfies Required<ScrcpyOptionsInit1_23>;
-
-    override get defaults(): Required<ScrcpyOptionsInit1_23> {
-        return ScrcpyOptions1_23.DEFAULTS;
-    }
-
-    constructor(init: ScrcpyOptionsInit1_22) {
-        super(ScrcpyOptions1_22, init, ScrcpyOptions1_23.DEFAULTS);
-    }
-
-    override serialize(): string[] {
-        return ScrcpyOptions1_21.serialize(this.value, this.defaults);
-    }
-
-    override createMediaStreamTransformer(): TransformStream<
-        Uint8Array,
-        ScrcpyMediaStreamPacket
-    > {
-        const stream = super.createMediaStreamTransformer();
-        return {
-            writable: stream.writable,
-            readable: stream.readable.pipeThrough(
-                new TransformStream({
-                    transform(packet, controller): void {
-                        if (packet.type !== "data") {
-                            controller.enqueue(packet);
-                            return;
-                        }
-
-                        if (
-                            packet.pts !== undefined &&
-                            packet.pts & KEYFRAME_PTS
-                        ) {
-                            packet.keyframe = true;
-                            packet.pts &= ~KEYFRAME_PTS;
-                        }
-
-                        controller.enqueue(packet);
-                    },
-                }),
-            ),
-        };
-    }
-}