@yume-chan/scrcpy 0.0.23 → 1.0.0

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

@@ -0,0 +1,6 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends Omit<PrevImpl.Init, "audioSource"> {
+    audioSource?: PrevImpl.Init["audioSource"] | "playback";
+    audioDup?: boolean;
+}

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

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

package/src/2_6/index.ts

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

package/src/2_6/options.ts

@@ -0,0 +1,187 @@
+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,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+import type { Init } from "./impl/index.js";
+
+export class ScrcpyOptions2_6 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput():
+        | ReadableStream<ScrcpyUHidOutputDeviceMessage>
+        | undefined {
+        return this.#uHidOutput;
+    }
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.videoSource === "camera") {
+            this.value.control = false;
+        }
+
+        if (this.value.audioDup) {
+            this.value.audioSource = "playback";
+        }
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = new ClipboardStream();
+                this.#ackClipboardHandler = new AckClipboardHandler();
+            }
+
+            this.#uHidOutput = 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(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();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions2_6 {
+    export type Init = Init_;
+}

package/src/2_7/impl/control-message-types.ts

@@ -0,0 +1,10 @@
+import { ScrcpyControlMessageType } from "../../base/index.js";
+
+import { PrevImpl } from "./prev.js";
+
+export const ControlMessageTypes: readonly ScrcpyControlMessageType[] =
+    /* #__PURE__ */ (() => {
+        const result = PrevImpl.ControlMessageTypes.slice();
+        result.splice(14, 0, ScrcpyControlMessageType.UHidDestroy);
+        return result;
+    })();

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

@@ -0,0 +1,6 @@
+export * from "../../2_6/impl/index.js";
+export { ControlMessageTypes } from "./control-message-types.js";
+export {
+    serializeUHidCreateControlMessage,
+    UHidCreateControlMessage,
+} from "./serialize-uhid-create.js";

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

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

package/src/2_7/impl/serialize-uhid-create.ts

@@ -0,0 +1,26 @@
+import type { StructInit } from "@yume-chan/struct";
+import { buffer, string, struct, u16, u8 } from "@yume-chan/struct";
+
+import { ScrcpyControlMessageType } from "../../base/control-message-type.js";
+import type { ScrcpyUHidCreateControlMessage } from "../../latest.js";
+
+export const UHidCreateControlMessage = /* #__PURE__ */ (() =>
+    struct(
+        {
+            type: u8(ScrcpyControlMessageType.UHidCreate),
+            id: u16,
+            name: string(u8),
+            data: buffer(u16),
+        },
+        { littleEndian: false },
+    ))();
+
+export type UHidCreateControlMessage = StructInit<
+    typeof UHidCreateControlMessage
+>;
+
+export function serializeUHidCreateControlMessage(
+    message: ScrcpyUHidCreateControlMessage,
+) {
+    return UHidCreateControlMessage.serialize(message);
+}

package/src/2_7/index.ts

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

package/src/2_7/options.ts

@@ -0,0 +1,187 @@
+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,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+
+export class ScrcpyOptions2_7 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput():
+        | ReadableStream<ScrcpyUHidOutputDeviceMessage>
+        | undefined {
+        return this.#uHidOutput;
+    }
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.videoSource === "camera") {
+            this.value.control = false;
+        }
+
+        if (this.value.audioDup) {
+            this.value.audioSource = "playback";
+        }
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = new ClipboardStream();
+                this.#ackClipboardHandler = new AckClipboardHandler();
+            }
+
+            this.#uHidOutput = 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(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();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions2_7 {
+    export type Init = Init_;
+}

package/src/3_0/impl/control-message-types.ts

@@ -0,0 +1,10 @@
+import { ScrcpyControlMessageType } from "../../base/index.js";
+
+import { PrevImpl } from "./prev.js";
+
+export const ControlMessageTypes: readonly ScrcpyControlMessageType[] =
+    /* #__PURE__ */ (() => [
+        ...PrevImpl.ControlMessageTypes,
+        ScrcpyControlMessageType.StartApp,
+        ScrcpyControlMessageType.ResetVideo,
+    ])();

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

@@ -0,0 +1,16 @@
+import { omit } from "../../utils/index.js";
+
+import type { Init } from "./init.js";
+import { CaptureOrientation } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        ...omit(PrevImpl.Defaults, "lockVideoOrientation"),
+        captureOrientation: CaptureOrientation.Unlocked,
+        angle: 0,
+        screenOffTimeout: undefined,
+        listApps: false,
+        newDisplay: undefined,
+        vdSystemDecorations: true,
+    }) as const satisfies Required<Init>)();

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

@@ -0,0 +1,11 @@
+export * from "../../2_7/impl/index.js";
+export { ControlMessageTypes } from "./control-message-types.js";
+export { Defaults } from "./defaults.js";
+export {
+    CaptureOrientation,
+    LockOrientation,
+    NewDisplay,
+    Orientation,
+} from "./init.js";
+export type { Init } from "./init.js";
+export { parseEncoder } from "./parse-encoder.js";

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

@@ -0,0 +1,121 @@
+import type { ScrcpyOptionValue } from "../../base/option-value.js";
+
+import type { PrevImpl } from "./prev.js";
+
+export const LockOrientation = {
+    Unlocked: 0,
+    LockedInitial: 1,
+    LockedValue: 2,
+} as const;
+
+export type LockOrientation =
+    (typeof LockOrientation)[keyof typeof LockOrientation];
+
+export const Orientation = {
+    Orient0: 0,
+    Orient90: 90,
+    Orient180: 180,
+    Orient270: 270,
+} as const;
+
+export type Orientation = (typeof Orientation)[keyof typeof Orientation];
+
+export class CaptureOrientation implements ScrcpyOptionValue {
+    static Unlocked = /* #__PURE__ */ (() =>
+        new CaptureOrientation(
+            LockOrientation.Unlocked,
+            Orientation.Orient0,
+            false,
+        ))();
+
+    lock: LockOrientation;
+    orientation: Orientation;
+    flip: boolean;
+
+    constructor(lock: LockOrientation, orientation: Orientation, flip = false) {
+        this.lock = lock;
+        this.orientation = orientation;
+        this.flip = flip;
+    }
+
+    toOptionValue(): string | undefined {
+        if (
+            this.lock === LockOrientation.Unlocked &&
+            this.orientation === Orientation.Orient0 &&
+            !this.flip
+        ) {
+            return undefined;
+        }
+
+        if (this.lock === LockOrientation.LockedInitial) {
+            return "@";
+        }
+
+        return (
+            (this.lock === LockOrientation.LockedValue ? "@" : "") +
+            (this.flip ? "flip" : "") +
+            this.orientation
+        );
+    }
+}
+
+export class NewDisplay implements ScrcpyOptionValue {
+    static Default = /* #__PURE__ */ new NewDisplay();
+
+    width?: number | undefined;
+    height?: number | undefined;
+    dpi?: number | undefined;
+
+    constructor();
+    constructor(width: number, height: number);
+    constructor(dpi: number);
+    constructor(width: number, height: number, dpi: number);
+    constructor(a?: number, b?: number, c?: number) {
+        if (a === undefined) {
+            return;
+        }
+
+        if (b === undefined) {
+            this.dpi = a;
+            return;
+        }
+
+        this.width = a;
+        this.height = b;
+        this.dpi = c;
+    }
+
+    toOptionValue() {
+        if (
+            this.width === undefined &&
+            this.height === undefined &&
+            this.dpi === undefined
+        ) {
+            return "";
+        }
+
+        if (this.width === undefined) {
+            return `/${this.dpi}`;
+        }
+
+        if (this.dpi === undefined) {
+            return `${this.width}x${this.height}`;
+        }
+
+        return `${this.width}x${this.height}/${this.dpi}`;
+    }
+}
+
+export interface Init extends Omit<PrevImpl.Init, "lockVideoOrientation"> {
+    captureOrientation?: CaptureOrientation;
+    angle?: number;
+    screenOffTimeout?: number | undefined;
+
+    listApps?: boolean;
+
+    // `display_id` and `new_display` can't be specified at the same time
+    // but `serialize` method will exclude options that are same as the default value
+    // so `displayId: 0` will be ignored
+    newDisplay?: NewDisplay | undefined;
+    vdSystemDecorations?: boolean;
+}

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

@@ -0,0 +1,31 @@
+import type { ScrcpyEncoder } from "../../base/index.js";
+
+const EncoderRegex =
+    /^\s+--(video|audio)-codec=(\S+)\s+--\1-encoder=(\S+)(?:\s*\((sw|hw|hybrid)\))?(?:\s*\[vendor\])?(?:\s*\(alias for (\S+)\))?$/;
+
+function toHardwareType(value: string): ScrcpyEncoder["hardwareType"] {
+    switch (value) {
+        case "sw":
+            return "software";
+        case "hw":
+            return "hardware";
+        case "hybrid":
+            return "hybrid";
+        default:
+            throw new Error(`Unknown hardware type: ${value}`);
+    }
+}
+
+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]!,
+              hardwareType: match[4] ? toHardwareType(match[4]) : undefined,
+              vendor: !!match[5],
+              aliasFor: match[6],
+          }
+        : undefined;
+}

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

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

package/src/3_0/index.ts

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