@yume-chan/scrcpy 0.0.23 → 1.0.0

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

@@ -0,0 +1,14 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends PrevImpl.Init {
+    videoSource?: "display" | "camera";
+    cameraId?: string | undefined;
+    cameraSize?: string | undefined;
+    cameraFacing?: "front" | "back" | "external" | undefined;
+    cameraAr?: string | undefined;
+    cameraFps?: number | undefined;
+    cameraHighSpeed?: boolean;
+
+    listCameras?: boolean;
+    listCameraSizes?: boolean;
+}

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

@@ -0,0 +1,15 @@
+import type { ScrcpyDisplay } from "../../base/index.js";
+
+export function parseDisplay(line: string): ScrcpyDisplay | undefined {
+    const match = line.match(/^\s+--display-id=(\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_2/impl/prev.ts

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

package/src/2_2/index.ts

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

package/src/2_2/options.ts

@@ -0,0 +1,162 @@
+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_2 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;
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.videoSource === "camera") {
+            this.value.control = false;
+        }
+
+        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_2 {
+    export type Init = Init_;
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends Omit<PrevImpl.Init, "audioCodec"> {
+    audioCodec?: PrevImpl.Init["audioCodec"] | "flac";
+}

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

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

package/src/2_3/index.ts

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

package/src/2_3/options.ts

@@ -0,0 +1,162 @@
+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_3 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;
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.videoSource === "camera") {
+            this.value.control = false;
+        }
+
+        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_3 {
+    export type Init = Init_;
+}

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

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

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

@@ -0,0 +1,4 @@
+export * from "../../2_3/impl/index.js";
+export { ControlMessageTypes } from "./control-message-types.js";
+export * from "./serialize-uhid-create.js";
+export * from "./uhid-output-stream.js";

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

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

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

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

package/src/2_4/impl/uhid-output-stream.ts

@@ -0,0 +1,51 @@
+import type { PushReadableStreamController } from "@yume-chan/stream-extra";
+import { PushReadableStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable, StructValue } from "@yume-chan/struct";
+import { buffer, struct, u16 } from "@yume-chan/struct";
+
+import type { ScrcpyDeviceMessageParser } from "../../base/index.js";
+
+export const UHidOutputDeviceMessage = struct(
+    {
+        id: u16,
+        data: buffer(u16),
+    },
+    { littleEndian: false },
+);
+
+export type UHidOutputDeviceMessage = StructValue<
+    typeof UHidOutputDeviceMessage
+>;
+
+export class UHidOutputStream
+    extends PushReadableStream<UHidOutputDeviceMessage>
+    implements ScrcpyDeviceMessageParser
+{
+    #controller: PushReadableStreamController<UHidOutputDeviceMessage>;
+
+    constructor() {
+        let controller!: PushReadableStreamController<UHidOutputDeviceMessage>;
+        super((controller_) => {
+            controller = controller_;
+        });
+        this.#controller = controller;
+    }
+
+    async parse(id: number, stream: AsyncExactReadable): Promise<boolean> {
+        if (id !== 2) {
+            return false;
+        }
+
+        const message = await UHidOutputDeviceMessage.deserialize(stream);
+        await this.#controller.enqueue(message);
+        return true;
+    }
+
+    close() {
+        this.#controller.close();
+    }
+
+    error(e?: unknown) {
+        this.#controller.error(e);
+    }
+}

package/src/2_4/index.ts

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

package/src/2_4/options.ts

@@ -0,0 +1,189 @@
+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_4 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.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;
+        }
+
+        if (await this.#uHidOutput?.parse(id, stream)) {
+            return;
+        }
+
+        throw new Error("Unknown device message");
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        if (e) {
+            this.#clipboard?.error(e);
+            this.#ackClipboardHandler?.error(e);
+            this.#uHidOutput?.error(e);
+        } else {
+            this.#clipboard?.close();
+            this.#ackClipboardHandler?.close();
+            this.#uHidOutput?.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_4 {
+    export type Init = Init_;
+}

package/src/2_5.ts

@@ -0,0 +1,4 @@
+export {
+    ScrcpyOptions2_4 as ScrcpyOptions2_5,
+    ScrcpyOptions2_4Impl as ScrcpyOptions2_5Impl,
+} from "./2_4/index.js";

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

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

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

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