@yume-chan/scrcpy 0.0.24 → 1.1.0

package/src/1_25/options.ts

@@ -0,0 +1,154 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+import type {
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} from "../base/index.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    EncoderRegex,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    setListDisplays,
+    setListEncoders,
+} from "./impl/index.js";
+
+export class ScrcpyOptions1_25 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly version: string;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    constructor(init: Init, version = "1.25") {
+        this.value = { ...Defaults, ...init };
+        this.version = version;
+
+        if (this.value.control && this.value.clipboardAutosync) {
+            this.#clipboard = new ClipboardStream();
+            this.#ackClipboardHandler = new AckClipboardHandler();
+        }
+    }
+
+    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, EncoderRegex);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(this.value, stream);
+    }
+
+    async parseDeviceMessage(
+        id: number,
+        stream: AsyncExactReadable,
+    ): Promise<void> {
+        if (await this.#clipboard?.parse(id, stream)) {
+            return;
+        }
+
+        if (await this.#ackClipboardHandler?.parse(id, stream)) {
+            return;
+        }
+
+        throw new Error("Unknown device message");
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        if (e) {
+            this.#clipboard?.error(e);
+            this.#ackClipboardHandler?.error(e);
+        } else {
+            this.#clipboard?.close();
+            this.#ackClipboardHandler?.close();
+        }
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyMediaStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        return this.#ackClipboardHandler!.serializeSetClipboardControlMessage(
+            message,
+        );
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        return createScrollController();
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions1_25 {
+    export type Init = Init_;
+}

package/src/2_0/impl/defaults.ts

@@ -0,0 +1,25 @@
+import { omit } from "../../utils/index.js";
+
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        ...omit(PrevImpl.Defaults, "bitRate", "codecOptions", "encoderName"),
+        scid: undefined,
+
+        videoCodec: "h264",
+        videoBitRate: 8000000,
+        videoCodecOptions: undefined,
+        videoEncoder: undefined,
+
+        audio: true,
+        audioCodec: "opus",
+        audioBitRate: 128000,
+        audioCodecOptions: undefined,
+        audioEncoder: undefined,
+
+        listEncoders: false,
+        listDisplays: false,
+        sendCodecMeta: true,
+    }) as const satisfies Required<Init>)();

package/src/2_0/impl/index.ts

@@ -0,0 +1,13 @@
+export * from "../../1_25/impl/index.js";
+export { Defaults } from "./defaults.js";
+export { InstanceId, type Init } from "./init.js";
+export {
+    InjectTouchControlMessage,
+    serializeInjectTouchControlMessage,
+} from "./inject-touch.js";
+export * from "./parse-audio-stream-metadata.js";
+export { parseDisplay } from "./parse-display.js";
+export { parseEncoder } from "./parse-encoder.js";
+export { parseVideoStreamMetadata } from "./parse-video-stream-metadata.js";
+export { setListDisplays } from "./set-list-display.js";
+export { setListEncoders } from "./set-list-encoder.js";

package/src/2_0/impl/init.ts

@@ -0,0 +1,45 @@
+import type { ScrcpyOptionValue } from "../../base/index.js";
+
+import type { PrevImpl } from "./prev.js";
+
+export class InstanceId implements ScrcpyOptionValue {
+    static readonly NONE = /* #__PURE__ */ new InstanceId(-1);
+
+    static random(): InstanceId {
+        // A random 31-bit unsigned integer
+        return new InstanceId((Math.random() * 0x80000000) | 0);
+    }
+
+    value: number;
+
+    constructor(value: number) {
+        this.value = value;
+    }
+
+    toOptionValue(): string | undefined {
+        if (this.value < 0) {
+            return undefined;
+        }
+        return this.value.toString(16);
+    }
+}
+
+export interface Init
+    extends Omit<PrevImpl.Init, "bitRate" | "codecOptions" | "encoderName"> {
+    scid?: InstanceId | string | undefined;
+
+    videoCodec?: "h264" | "h265" | "av1";
+    videoBitRate?: number;
+    videoCodecOptions?: PrevImpl.CodecOptions | string | undefined;
+    videoEncoder?: string | undefined;
+
+    audio?: boolean;
+    audioCodec?: "raw" | "opus" | "aac";
+    audioBitRate?: number;
+    audioCodecOptions?: PrevImpl.CodecOptions | string | undefined;
+    audioEncoder?: string | undefined;
+
+    listEncoders?: boolean;
+    listDisplays?: boolean;
+    sendCodecMeta?: boolean;
+}

package/src/2_0/impl/inject-touch.ts

@@ -0,0 +1,35 @@
+import type { StructInit } from "@yume-chan/struct";
+import { struct, u16, u32, u64, u8 } from "@yume-chan/struct";
+
+import type { AndroidMotionEventAction } from "../../android/motion-event.js";
+import { ScrcpyControlMessageType } from "../../base/control-message-type.js";
+import type { ScrcpyInjectTouchControlMessage } from "../../latest.js";
+
+import { PrevImpl } from "./prev.js";
+
+export const InjectTouchControlMessage = /* #__PURE__ */ (() =>
+    struct(
+        {
+            type: u8(ScrcpyControlMessageType.InjectTouch),
+            action: u8<AndroidMotionEventAction>(),
+            pointerId: u64,
+            pointerX: u32,
+            pointerY: u32,
+            screenWidth: u16,
+            screenHeight: u16,
+            pressure: PrevImpl.UnsignedFloat,
+            actionButton: u32,
+            buttons: u32,
+        },
+        { littleEndian: false },
+    ))();
+
+export type InjectTouchControlMessage = StructInit<
+    typeof InjectTouchControlMessage
+>;
+
+export function serializeInjectTouchControlMessage(
+    message: ScrcpyInjectTouchControlMessage,
+): Uint8Array {
+    return InjectTouchControlMessage.serialize(message);
+}

package/src/2_0/impl/parse-audio-stream-metadata.ts

@@ -0,0 +1,99 @@
+import { getUint32BigEndian } from "@yume-chan/no-data-view";
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import {
+    BufferedReadableStream,
+    PushReadableStream,
+} from "@yume-chan/stream-extra";
+
+import type { Init } from "../../2_3/impl/init.js";
+import type { ScrcpyAudioStreamMetadata } from "../../base/index.js";
+import { ScrcpyAudioCodec } from "../../base/index.js";
+
+export async function parseAudioStreamMetadata(
+    stream: ReadableStream<Uint8Array>,
+    options: Pick<Required<Init>, "sendCodecMeta" | "audioCodec">,
+): Promise<ScrcpyAudioStreamMetadata> {
+    const buffered = new BufferedReadableStream(stream);
+
+    const buffer = await buffered.readExactly(4);
+    // Treat it as a 32-bit number for simpler comparisons
+    const codecMetadataValue = getUint32BigEndian(buffer, 0);
+    // Server will send `0x00_00_00_00` and `0x00_00_00_01` even if `sendCodecMeta` is false
+    switch (codecMetadataValue) {
+        case 0x00_00_00_00:
+            return {
+                type: "disabled",
+            };
+        case 0x00_00_00_01:
+            return {
+                type: "errored",
+            };
+    }
+
+    if (options.sendCodecMeta) {
+        let codec: ScrcpyAudioCodec;
+        switch (codecMetadataValue) {
+            case ScrcpyAudioCodec.Raw.metadataValue:
+                codec = ScrcpyAudioCodec.Raw;
+                break;
+            case ScrcpyAudioCodec.Opus.metadataValue:
+                codec = ScrcpyAudioCodec.Opus;
+                break;
+            case ScrcpyAudioCodec.Aac.metadataValue:
+                codec = ScrcpyAudioCodec.Aac;
+                break;
+            case ScrcpyAudioCodec.Flac.metadataValue:
+                codec = ScrcpyAudioCodec.Flac;
+                break;
+            default:
+                throw new Error(
+                    `Unknown audio codec metadata value: ${codecMetadataValue}`,
+                );
+        }
+        return {
+            type: "success",
+            codec,
+            stream: buffered.release(),
+        };
+    }
+
+    // Infer codec from `audioCodec` option
+    let codec: ScrcpyAudioCodec;
+    switch (options.audioCodec as string) {
+        case "raw":
+            codec = ScrcpyAudioCodec.Raw;
+            break;
+        case "opus":
+            codec = ScrcpyAudioCodec.Opus;
+            break;
+        case "aac":
+            codec = ScrcpyAudioCodec.Aac;
+            break;
+        case "flac":
+            codec = ScrcpyAudioCodec.Flac;
+            break;
+        default:
+            throw new Error(
+                `Unknown audio codec metadata value: ${codecMetadataValue}`,
+            );
+    }
+
+    return {
+        type: "success",
+        codec,
+        stream: new PushReadableStream<Uint8Array>(async (controller) => {
+            // Put the first 4 bytes back
+            await controller.enqueue(buffer);
+
+            const stream = buffered.release();
+            const reader = stream.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                await controller.enqueue(value);
+            }
+        }),
+    };
+}

package/src/2_0/impl/parse-display.ts

@@ -0,0 +1,17 @@
+import type { ScrcpyDisplay } from "../../base/index.js";
+
+export function parseDisplay(line: string): ScrcpyDisplay | undefined {
+    // The client-side option name is `--display`
+    // but the server-side option name is always `display_id`
+    const match = line.match(/^\s+--display=(\d+)\s+\(([^)]+)\)$/);
+    if (match) {
+        const display: ScrcpyDisplay = {
+            id: Number.parseInt(match[1]!, 10),
+        };
+        if (match[2] !== "size unknown") {
+            display.resolution = match[2]!;
+        }
+        return display;
+    }
+    return undefined;
+}

package/src/2_0/impl/parse-encoder.ts

@@ -0,0 +1,15 @@
+import type { ScrcpyEncoder } from "../../base/index.js";
+
+const EncoderRegex =
+    /^\s+--(video|audio)-codec=(\S+)\s+--\1-encoder='([^']+)'$/;
+
+export function parseEncoder(line: string): ScrcpyEncoder | undefined {
+    const match = line.match(EncoderRegex);
+    return match
+        ? {
+              type: match[1]! as "video" | "audio",
+              name: match[3]!,
+              codec: match[2]!,
+          }
+        : undefined;
+}

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

@@ -0,0 +1,72 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import { BufferedReadableStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyVideoStream } from "../../base/video.js";
+import { ScrcpyVideoCodecId } from "../../base/video.js";
+
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+function toCodecId(codec: string): ScrcpyVideoCodecId {
+    switch (codec) {
+        case "h264":
+            return ScrcpyVideoCodecId.H264;
+        case "h265":
+            return ScrcpyVideoCodecId.H265;
+        case "av1":
+            return ScrcpyVideoCodecId.AV1;
+        default:
+            throw new Error(`Unknown video codec: ${codec}`);
+    }
+}
+
+async function parseAsync(
+    options: Pick<
+        Required<Init>,
+        "sendDeviceMeta" | "sendCodecMeta" | "videoCodec"
+    >,
+    stream: ReadableStream<Uint8Array>,
+) {
+    const buffered = new BufferedReadableStream(stream);
+
+    // `sendDeviceMeta` now only contains device name,
+    // can't use `super.parseVideoStreamMetadata` here
+    let deviceName: string | undefined;
+    if (options.sendDeviceMeta) {
+        deviceName = await PrevImpl.readString(buffered, 64);
+    }
+
+    let codec: ScrcpyVideoCodecId;
+    let width: number | undefined;
+    let height: number | undefined;
+    if (options.sendCodecMeta) {
+        codec = (await PrevImpl.readU32(buffered)) as ScrcpyVideoCodecId;
+        width = await PrevImpl.readU32(buffered);
+        height = await PrevImpl.readU32(buffered);
+    } else {
+        codec = toCodecId(options.videoCodec);
+    }
+
+    return {
+        stream: buffered.release(),
+        metadata: { deviceName, codec, width, height },
+    };
+}
+
+export function parseVideoStreamMetadata(
+    options: Pick<
+        Required<Init>,
+        "sendDeviceMeta" | "sendCodecMeta" | "videoCodec"
+    >,
+    stream: ReadableStream<Uint8Array>,
+): MaybePromiseLike<ScrcpyVideoStream> {
+    if (!options.sendDeviceMeta && !options.sendCodecMeta) {
+        return {
+            stream,
+            metadata: { codec: toCodecId(options.videoCodec) },
+        };
+    }
+
+    return parseAsync(options, stream);
+}

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

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

package/src/2_0/impl/set-list-display.ts

@@ -0,0 +1,5 @@
+import type { Init } from "./init.js";
+
+export function setListDisplays(options: Pick<Init, "listDisplays">): void {
+    options.listDisplays = true;
+}

package/src/2_0/impl/set-list-encoder.ts

@@ -0,0 +1,5 @@
+import type { Init } from "./init.js";
+
+export function setListEncoders(options: Pick<Init, "listEncoders">): void {
+    options.listEncoders = true;
+}

package/src/2_0/index.ts

@@ -0,0 +1,2 @@
+export * as ScrcpyOptions2_0Impl from "./impl/index.js";
+export * from "./options.js";

package/src/2_0/options.ts

@@ -0,0 +1,161 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+import type {
+    ScrcpyAudioStreamMetadata,
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} from "../base/index.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    setListDisplays,
+    setListEncoders,
+} from "./impl/index.js";
+
+export class ScrcpyOptions2_0 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly version: string;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    constructor(init: Init, version = "2.0") {
+        this.value = { ...Defaults, ...init };
+        this.version = version;
+
+        if (this.value.control && this.value.clipboardAutosync) {
+            this.#clipboard = new ClipboardStream();
+            this.#ackClipboardHandler = new AckClipboardHandler();
+        }
+    }
+
+    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(this.value, stream);
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(stream, this.value);
+    }
+
+    async parseDeviceMessage(
+        id: number,
+        stream: AsyncExactReadable,
+    ): Promise<void> {
+        if (await this.#clipboard?.parse(id, stream)) {
+            return;
+        }
+
+        if (await this.#ackClipboardHandler?.parse(id, stream)) {
+            return;
+        }
+
+        throw new Error("Unknown device message");
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        if (e) {
+            this.#clipboard?.error(e);
+            this.#ackClipboardHandler?.error(e);
+        } else {
+            this.#clipboard?.close();
+            this.#ackClipboardHandler?.close();
+        }
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyMediaStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        return this.#ackClipboardHandler!.serializeSetClipboardControlMessage(
+            message,
+        );
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        return createScrollController();
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions2_0 {
+    export type Init = Init_;
+}

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

@@ -0,0 +1,9 @@
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        ...PrevImpl.Defaults,
+        video: true,
+        audioSource: "output",
+    }) as const satisfies Required<Init>)();

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

@@ -0,0 +1,3 @@
+export * from "../../2_0/impl/index.js";
+export { Defaults } from "./defaults.js";
+export type { Init } from "./init.js";

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

@@ -0,0 +1,6 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends PrevImpl.Init {
+    video?: boolean;
+    audioSource?: "output" | "mic";
+}

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

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