@yume-chan/scrcpy 0.0.23 → 1.0.0

package/src/1_23/impl/defaults.ts

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

package/src/1_23/impl/index.ts

@@ -0,0 +1,7 @@
+export * from "../../1_22/impl/index.js";
+export { Defaults } from "./defaults.js";
+export type { Init } from "./init.js";
+export {
+    PtsKeyframe,
+    createMediaStreamTransformer,
+} from "./media-stream-transformer.js";

package/src/1_23/impl/init.ts

@@ -0,0 +1,5 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends PrevImpl.Init {
+    cleanup?: boolean;
+}

package/src/1_23/impl/media-stream-transformer.ts

@@ -0,0 +1,64 @@
+import {
+    StructDeserializeStream,
+    TransformStream,
+} from "@yume-chan/stream-extra";
+
+import type { ScrcpyMediaStreamPacket } from "../../base/index.js";
+
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const PtsKeyframe = 1n << 62n;
+
+export function createMediaStreamTransformer(
+    options: Pick<Init, "sendFrameMeta">,
+): TransformStream<Uint8Array, ScrcpyMediaStreamPacket> {
+    // Optimized path for video frames only
+    if (!options.sendFrameMeta) {
+        return new TransformStream({
+            transform(chunk, controller) {
+                controller.enqueue({
+                    type: "data",
+                    data: chunk,
+                });
+            },
+        });
+    }
+
+    const deserializeStream = new StructDeserializeStream(
+        PrevImpl.MediaStreamRawPacket,
+    );
+    return {
+        writable: deserializeStream.writable,
+        readable: deserializeStream.readable.pipeThrough(
+            new TransformStream({
+                transform(packet, controller) {
+                    if (packet.pts === PrevImpl.PtsConfig) {
+                        controller.enqueue({
+                            type: "configuration",
+                            data: packet.data,
+                        });
+                        return;
+                    }
+
+                    if (packet.pts & PtsKeyframe) {
+                        controller.enqueue({
+                            type: "data",
+                            keyframe: true,
+                            pts: packet.pts & ~PtsKeyframe,
+                            data: packet.data,
+                        });
+                        return;
+                    }
+
+                    controller.enqueue({
+                        type: "data",
+                        keyframe: false,
+                        pts: packet.pts,
+                        data: packet.data,
+                    });
+                },
+            }),
+        ),
+    };
+}

package/src/1_23/impl/prev.ts

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

package/src/1_23/index.ts

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

package/src/1_23/options.ts

@@ -0,0 +1,151 @@
+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_23 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.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_23 {
+    export type Init = Init_;
+}

package/src/1_24/impl/defaults.ts

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

package/src/1_24/impl/index.ts

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

package/src/1_24/impl/init.ts

@@ -0,0 +1,5 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends PrevImpl.Init {
+    powerOn?: boolean;
+}

package/src/1_24/impl/prev.ts

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

package/src/1_24/index.ts

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

package/src/1_24/options.ts

@@ -0,0 +1,151 @@
+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_24 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.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_24 {
+    export type Init = Init_;
+}

package/src/1_25/impl/index.ts

@@ -0,0 +1,6 @@
+export * from "../../1_24/impl/index.js";
+export {
+    InjectScrollControlMessage,
+    ScrollController,
+    SignedFloat,
+} from "./scroll-controller.js";

package/src/1_25/impl/prev.ts

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

package/src/1_25/impl/scroll-controller.ts

@@ -0,0 +1,51 @@
+import { getInt16, setInt16 } from "@yume-chan/no-data-view";
+import type { Field, StructInit } from "@yume-chan/struct";
+import { bipedal, struct, u16, u32, u8 } from "@yume-chan/struct";
+
+import { ScrcpyControlMessageType } from "../../base/index.js";
+import type { ScrcpyScrollController } from "../../base/index.js";
+import type { ScrcpyInjectScrollControlMessage } from "../../latest.js";
+import { clamp } from "../../utils/index.js";
+
+export const SignedFloat: Field<number, never, never> = {
+    size: 2,
+    serialize(value, { buffer, index, littleEndian }) {
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/app/src/util/binary.h#L51
+        value = clamp(value, -1, 1);
+        value = value === 1 ? 0x7fff : value * 0x8000;
+        setInt16(buffer, index, value, littleEndian);
+    },
+    deserialize: bipedal(function* (then, { reader, littleEndian }) {
+        const data = yield* then(reader.readExactly(2));
+        const value = getInt16(data, 0, littleEndian);
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/server/src/main/java/com/genymobile/scrcpy/Binary.java#L34
+        return value === 0x7fff ? 1 : value / 0x8000;
+    }),
+};
+
+export const InjectScrollControlMessage = /* #__PURE__ */ (() =>
+    struct(
+        {
+            type: u8(ScrcpyControlMessageType.InjectScroll),
+            pointerX: u32,
+            pointerY: u32,
+            screenWidth: u16,
+            screenHeight: u16,
+            scrollX: SignedFloat,
+            scrollY: SignedFloat,
+            buttons: u32,
+        },
+        { littleEndian: false },
+    ))();
+
+export type InjectScrollControlMessage = StructInit<
+    typeof InjectScrollControlMessage
+>;
+
+export class ScrollController implements ScrcpyScrollController {
+    serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage,
+    ): Uint8Array | undefined {
+        return InjectScrollControlMessage.serialize(message);
+    }
+}

package/src/1_25/index.ts

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

package/src/1_25/options.ts

@@ -0,0 +1,151 @@
+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 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.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,26 @@
+import { omit } from "../../utils/index.js";
+
+import type { Init } from "./init.js";
+import { InstanceId } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        ...omit(PrevImpl.Defaults, "bitRate", "codecOptions", "encoderName"),
+        scid: InstanceId.NONE,
+
+        videoCodec: "h264",
+        videoBitRate: 8000000,
+        videoCodecOptions: PrevImpl.CodecOptions.Empty,
+        videoEncoder: undefined,
+
+        audio: true,
+        audioCodec: "opus",
+        audioBitRate: 128000,
+        audioCodecOptions: PrevImpl.CodecOptions.Empty,
+        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";