@yume-chan/scrcpy 2.3.0 → 3.0.0-beta.1

package/src/4_0/impl/media-stream-transformer.ts

@@ -0,0 +1,58 @@
+import {
+    getUint32BigEndian,
+    getUint64BigEndian,
+} from "@yume-chan/no-data-view";
+import {
+    BufferedTransformStream,
+    TransformStream,
+} from "@yume-chan/stream-extra";
+
+import type { ScrcpyVideoStreamPacket } from "../../base/index.js";
+
+import type { Init } from "./init.js";
+
+export function createMediaStreamTransformer(
+    options: Pick<Init, "sendFrameMeta">,
+): TransformStream<Uint8Array, ScrcpyVideoStreamPacket> {
+    // Quick path for raw stream without frame meta
+    if (!options.sendFrameMeta) {
+        return new TransformStream({
+            transform(chunk, controller) {
+                controller.enqueue({
+                    type: "data",
+                    data: chunk,
+                });
+            },
+        });
+    }
+
+    return new BufferedTransformStream<ScrcpyVideoStreamPacket>(
+        async (buffered) => {
+            const header = await buffered.readExactly(12);
+            if (header[0]! & 0x80) {
+                return {
+                    type: "session",
+                    isClientResize: !!(header[0]! & 1),
+                    width: getUint32BigEndian(header, 4),
+                    height: getUint32BigEndian(header, 8),
+                };
+            }
+
+            if (header[0]! & 0x40) {
+                return {
+                    type: "configuration",
+                    data: await buffered.readExactly(
+                        getUint32BigEndian(header, 8),
+                    ),
+                };
+            }
+
+            return {
+                type: "data",
+                keyframe: !!(header[0]! & 0x20),
+                pts: getUint64BigEndian(header, 0) & 0x1fffffffffffffffn,
+                data: await buffered.readExactly(getUint32BigEndian(header, 8)),
+            };
+        },
+    );
+}

package/src/4_0/impl/parse-video-stream-metadata.ts

@@ -0,0 +1,34 @@
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import { BufferedReadableStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyVideoStream } from "../../base/video.js";
+import type { ScrcpyVideoCodecId } from "../../video/index.js";
+
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export async function parseVideoStreamMetadataAsync(
+    stream: ReadableStream<Uint8Array>,
+    sendDeviceMeta: Exclude<Init["sendDeviceMeta"], undefined>,
+    sendStreamMeta: Exclude<Init["sendStreamMeta"], undefined>,
+    fallbackCodec: ScrcpyVideoCodecId,
+): Promise<ScrcpyVideoStream> {
+    const buffered = new BufferedReadableStream(stream);
+
+    let deviceName: string | undefined;
+    if (sendDeviceMeta) {
+        deviceName = await PrevImpl.readString(buffered, 64);
+    }
+
+    let codec: ScrcpyVideoCodecId;
+    if (sendStreamMeta) {
+        codec = (await PrevImpl.readU32(buffered)) as ScrcpyVideoCodecId;
+    } else {
+        codec = fallbackCodec;
+    }
+
+    return {
+        stream: buffered.release(),
+        metadata: { deviceName, codec },
+    };
+}

package/src/4_0/impl/prev.ts

@@ -0,0 +1 @@
+export * as PrevImpl from "../../3_3_1/impl/index.js";

package/src/4_0/index.ts

@@ -0,0 +1,226 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyAudioStreamMetadata } from "../base/audio.js";
+import { ScrcpyDeviceMessageParsers } from "../base/device-message.js";
+import type { ScrcpyDisplay } from "../base/display.js";
+import type { ScrcpyEncoder } from "../base/encoder.js";
+import type { ScrcpyVideoStreamPacket } from "../base/media.js";
+import type {
+    MapBoolean,
+    ScrcpyOptions,
+    ScrcpyOptionsListEncoders,
+} from "../base/options.js";
+import type { ScrcpyScrollController } from "../base/scroll-controller.js";
+import type { ScrcpyVideoStream } from "../base/video.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import type { ComputeOptionTypes, Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    computeOptionValues,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoCodecOption,
+    parseVideoStreamMetadata,
+    parseVideoStreamMetadataAsync,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeSetClipboardControlMessage,
+    serializeSetDisplayPowerControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+
+export class ScrcpyOptions4_0<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ComputeOptionTypes<TInit, typeof Defaults>>,
+        ScrcpyOptionsListEncoders
+{
+    static readonly Defaults = Defaults;
+
+    readonly value: ComputeOptionTypes<TInit, typeof Defaults>;
+
+    get controlMessageTypes(): typeof ControlMessageTypes {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput(): MapBoolean<
+        this["value"]["control"],
+        ReadableStream<ScrcpyUHidOutputDeviceMessage>,
+        undefined
+    > {
+        return this.#uHidOutput as never;
+    }
+
+    #deviceMessageParsers = new ScrcpyDeviceMessageParsers();
+    get deviceMessageParsers() {
+        return this.#deviceMessageParsers;
+    }
+
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+            }
+
+            this.#ackClipboardHandler = this.#deviceMessageParsers.add(
+                new AckClipboardHandler(),
+            );
+
+            this.#uHidOutput = this.#deviceMessageParsers.add(
+                new UHidOutputStream(),
+            );
+        }
+    }
+
+    serialize(): string[] {
+        return serialize(this.value, Defaults);
+    }
+
+    setListDisplays(): void {
+        setListDisplays(this.value);
+    }
+
+    parseDisplay(line: string): ScrcpyDisplay | undefined {
+        return parseDisplay(line);
+    }
+
+    setListEncoders() {
+        setListEncoders(this.value);
+    }
+
+    parseEncoder(line: string): ScrcpyEncoder | undefined {
+        return parseEncoder(line);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendStreamMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendStreamMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetClipboardControlMessage(
+            message,
+            this.#ackClipboardHandler,
+        );
+    }
+
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetDisplayPowerControlMessage(message);
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return createScrollController();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions4_0 {
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
+}

package/src/4_1/impl/control-message-types.ts

@@ -0,0 +1,28 @@
+import type { ScrcpyControlMessageTypeMap } from "../../base/index.js";
+import { ScrcpyControlMessageType } from "../../base/index.js";
+
+export const ControlMessageTypes = {
+    [ScrcpyControlMessageType.InjectKeyCode]: 0,
+    [ScrcpyControlMessageType.InjectText]: 1,
+    [ScrcpyControlMessageType.InjectTouch]: 2,
+    [ScrcpyControlMessageType.InjectScroll]: 3,
+    [ScrcpyControlMessageType.BackOrScreenOn]: 4,
+    [ScrcpyControlMessageType.ExpandNotificationPanel]: 5,
+    [ScrcpyControlMessageType.ExpandSettingPanel]: 6,
+    [ScrcpyControlMessageType.CollapseNotificationPanel]: 7,
+    [ScrcpyControlMessageType.GetClipboard]: 8,
+    [ScrcpyControlMessageType.SetClipboard]: 9,
+    [ScrcpyControlMessageType.SetDisplayPower]: 10,
+    [ScrcpyControlMessageType.RotateDevice]: 11,
+    [ScrcpyControlMessageType.UHidCreate]: 12,
+    [ScrcpyControlMessageType.UHidInput]: 13,
+    [ScrcpyControlMessageType.UHidDestroy]: 14,
+    [ScrcpyControlMessageType.OpenHardKeyboardSettings]: 15,
+    [ScrcpyControlMessageType.StartApp]: 16,
+    [ScrcpyControlMessageType.ResetVideo]: 17,
+    [ScrcpyControlMessageType.CameraSetTorch]: 18,
+    [ScrcpyControlMessageType.CameraZoomIn]: 19,
+    [ScrcpyControlMessageType.CameraZoomOut]: 20,
+    [ScrcpyControlMessageType.ResizeDisplay]: 21,
+    [ScrcpyControlMessageType.ScanFile]: 22,
+} as const satisfies ScrcpyControlMessageTypeMap;

package/src/4_1/impl/defaults.ts

@@ -0,0 +1,8 @@
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = {
+    ...PrevImpl.Defaults,
+
+    ignoreVideoEncoderConstraints: false,
+} as const satisfies Required<Init>;

package/src/4_1/impl/index.ts

@@ -0,0 +1,6 @@
+export * from "../../4_0/impl/index.js";
+
+export { ControlMessageTypes } from "./control-message-types.js";
+export { Defaults } from "./defaults.js";
+export type { Init } from "./init.js";
+export { parseVideoCodecOption } from "./parse-video-stream-metadata.js";

package/src/4_1/impl/init.ts

@@ -0,0 +1,7 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends Omit<PrevImpl.Init, "videoCodec"> {
+    videoCodec: PrevImpl.Init["videoCodec"] | "vp8" | "vp9";
+
+    ignoreVideoEncoderConstraints?: boolean | undefined;
+}

package/src/4_1/impl/parse-video-stream-metadata.ts

@@ -0,0 +1,23 @@
+import { ScrcpyVideoCodecId } from "../../video/index.js";
+
+import type { Init } from "./init.js";
+
+export function parseVideoCodecOption(
+    codec: Exclude<Init["videoCodec"], undefined>,
+): ScrcpyVideoCodecId {
+    switch (codec) {
+        case "h264":
+            return ScrcpyVideoCodecId.H264;
+        case "h265":
+            return ScrcpyVideoCodecId.H265;
+        case "av1":
+            return ScrcpyVideoCodecId.Av1;
+        case "vp8":
+            return ScrcpyVideoCodecId.Vp8;
+        case "vp9":
+            return ScrcpyVideoCodecId.Vp9;
+        default:
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            throw new Error(`Unknown video codec: ${codec}`);
+    }
+}

package/src/4_1/impl/prev.ts

@@ -0,0 +1 @@
+export * as PrevImpl from "../../4_0/impl/index.js";

package/src/4_1/index.ts

@@ -0,0 +1,226 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyAudioStreamMetadata } from "../base/audio.js";
+import { ScrcpyDeviceMessageParsers } from "../base/device-message.js";
+import type { ScrcpyDisplay } from "../base/display.js";
+import type { ScrcpyEncoder } from "../base/encoder.js";
+import type { ScrcpyVideoStreamPacket } from "../base/media.js";
+import type {
+    MapBoolean,
+    ScrcpyOptions,
+    ScrcpyOptionsListEncoders,
+} from "../base/options.js";
+import type { ScrcpyScrollController } from "../base/scroll-controller.js";
+import type { ScrcpyVideoStream } from "../base/video.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import type { ComputeOptionTypes, Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    computeOptionValues,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoCodecOption,
+    parseVideoStreamMetadata,
+    parseVideoStreamMetadataAsync,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeSetClipboardControlMessage,
+    serializeSetDisplayPowerControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+
+export class ScrcpyOptions4_1<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ComputeOptionTypes<TInit, typeof Defaults>>,
+        ScrcpyOptionsListEncoders
+{
+    static readonly Defaults = Defaults;
+
+    readonly value: ComputeOptionTypes<TInit, typeof Defaults>;
+
+    get controlMessageTypes(): typeof ControlMessageTypes {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput(): MapBoolean<
+        this["value"]["control"],
+        ReadableStream<ScrcpyUHidOutputDeviceMessage>,
+        undefined
+    > {
+        return this.#uHidOutput as never;
+    }
+
+    #deviceMessageParsers = new ScrcpyDeviceMessageParsers();
+    get deviceMessageParsers() {
+        return this.#deviceMessageParsers;
+    }
+
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+            }
+
+            this.#ackClipboardHandler = this.#deviceMessageParsers.add(
+                new AckClipboardHandler(),
+            );
+
+            this.#uHidOutput = this.#deviceMessageParsers.add(
+                new UHidOutputStream(),
+            );
+        }
+    }
+
+    serialize(): string[] {
+        return serialize(this.value, Defaults);
+    }
+
+    setListDisplays(): void {
+        setListDisplays(this.value);
+    }
+
+    parseDisplay(line: string): ScrcpyDisplay | undefined {
+        return parseDisplay(line);
+    }
+
+    setListEncoders() {
+        setListEncoders(this.value);
+    }
+
+    parseEncoder(line: string): ScrcpyEncoder | undefined {
+        return parseEncoder(line);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendStreamMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendStreamMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetClipboardControlMessage(
+            message,
+            this.#ackClipboardHandler,
+        );
+    }
+
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetDisplayPowerControlMessage(message);
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return createScrollController();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions4_1 {
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
+}