@yume-chan/scrcpy 0.0.19 → 0.0.21

package/src/options/1_16/options.ts

@@ -1,329 +1,216 @@
+import type { ReadableStream } from "@yume-chan/stream-extra";
 import {
+    BufferedReadableStream,
     StructDeserializeStream,
     TransformStream,
 } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
+import type { AsyncExactReadable, ValueOrPromise } from "@yume-chan/struct";
+import { NumberFieldType, decodeUtf8 } from "@yume-chan/struct";
 
 import type {
     ScrcpyBackOrScreenOnControlMessage,
-    ScrcpySetClipboardControlMessage,
-} from "../../control/index.js";
-import {
-    AndroidKeyEventAction,
     ScrcpyControlMessageType,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
 } from "../../control/index.js";
-import type { ScrcpyOptions, ScrcpyVideoStreamPacket } from "../types.js";
+import { AndroidKeyEventAction } from "../../control/index.js";
+import type {
+    ScrcpyMediaStreamPacket,
+    ScrcpyVideoStream,
+    ScrcpyVideoStreamMetadata,
+} from "../codec.js";
+import { ScrcpyVideoCodecId } from "../codec.js";
+import type { ScrcpyDisplay, ScrcpyEncoder, ScrcpyOptions } from "../types.js";
 import { toScrcpyOptionValue } from "../types.js";
 
 import { CodecOptions } from "./codec-options.js";
+import type { ScrcpyOptionsInit1_16 } from "./init.js";
+import { ScrcpyLogLevel1_16, ScrcpyVideoOrientation1_16 } from "./init.js";
 import {
-    parseH264Configuration,
-    parseSequenceParameterSet,
-    removeH264Emulation,
-} from "./h264-configuration.js";
+    SCRCPY_CONTROL_MESSAGE_TYPES_1_16,
+    SCRCPY_MEDIA_PACKET_FLAG_CONFIG,
+    ScrcpyBackOrScreenOnControlMessage1_16,
+    ScrcpyInjectTouchControlMessage1_16,
+    ScrcpyMediaStreamRawPacket,
+    ScrcpySetClipboardControlMessage1_15,
+} from "./message.js";
 import type { ScrcpyScrollController } from "./scroll.js";
 import { ScrcpyScrollController1_16 } from "./scroll.js";
 
-export enum ScrcpyLogLevel {
-    Verbose = "verbose",
-    Debug = "debug",
-    Info = "info",
-    Warn = "warn",
-    Error = "error",
-}
-
-export enum ScrcpyVideoOrientation {
-    Initial = -2,
-    Unlocked = -1,
-    Portrait = 0,
-    Landscape = 1,
-    PortraitFlipped = 2,
-    LandscapeFlipped = 3,
-}
-
-export interface ScrcpyOptionsInit1_16 {
-    logLevel: ScrcpyLogLevel;
-
-    /**
-     * The maximum value of both width and height.
-     */
-    maxSize: number;
-
-    bitRate: number;
-
-    /**
-     * 0 for unlimited.
-     *
-     * @default 0
-     */
-    maxFps: number;
-
-    /**
-     * The orientation of the video stream.
-     *
-     * It will not keep the device screen in specific orientation,
-     * only the captured video will in this orientation.
-     */
-    lockVideoOrientation: ScrcpyVideoOrientation;
-
-    /**
-     * Use ADB forward tunnel instead of reverse tunnel.
-     *
-     * This option is mainly used for working around the bug that on Android <9,
-     * ADB daemon can't create reverse tunnels if connected wirelessly (ADB over WiFi).
-     *
-     * When using `AdbScrcpyClient`, it can detect this situation and enable this option automatically.
-     */
-    tunnelForward: boolean;
-
-    crop: string;
-
-    /**
-     * Send PTS so that the client may record properly
-     *
-     * Note: When `sendFrameMeta: false` is specified,
-     * `onChangeEncoding` event won't fire and `onVideoData` event doesn't
-     * merge sps/pps frame and first video frame. Which means you can't use
-     * the shipped decoders to render the video
-     * (You can still record the stream into a file).
-     *
-     * @default true
-     */
-    sendFrameMeta: boolean;
-
-    /**
-     * @default true
-     */
-    control: boolean;
-
-    displayId: number;
-
-    showTouches: boolean;
-
-    stayAwake: boolean;
-
-    codecOptions: CodecOptions;
+export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
+    static readonly DEFAULTS = {
+        logLevel: ScrcpyLogLevel1_16.Debug,
+        maxSize: 0,
+        bitRate: 8_000_000,
+        maxFps: 0,
+        lockVideoOrientation: ScrcpyVideoOrientation1_16.Unlocked,
+        tunnelForward: false,
+        crop: undefined,
+        sendFrameMeta: true,
+        control: true,
+        displayId: 0,
+        showTouches: false,
+        stayAwake: false,
+        codecOptions: new CodecOptions(),
+    } as const satisfies Required<ScrcpyOptionsInit1_16>;
+
+    static readonly SERIALIZE_ORDER = [
+        "logLevel",
+        "maxSize",
+        "bitRate",
+        "maxFps",
+        "lockVideoOrientation",
+        "tunnelForward",
+        "crop",
+        "sendFrameMeta",
+        "control",
+        "displayId",
+        "showTouches",
+        "stayAwake",
+        "codecOptions",
+    ] as const satisfies readonly (keyof ScrcpyOptionsInit1_16)[];
+
+    static serialize<T>(options: T, order: readonly (keyof T)[]) {
+        return order.map((key) => toScrcpyOptionValue(options[key], "-"));
+    }
 
-    encoderName: string;
-}
+    static async parseCString(
+        stream: AsyncExactReadable,
+        maxLength: number,
+    ): Promise<string> {
+        let result = decodeUtf8(await stream.readExactly(maxLength));
+        result = result.substring(0, result.indexOf("\0"));
+        return result;
+    }
 
-export const VideoPacket = new Struct()
-    .uint64("pts")
-    .uint32("size")
-    .uint8Array("data", { lengthField: "size" });
+    static async parseUint16BE(stream: AsyncExactReadable): Promise<number> {
+        const buffer = await stream.readExactly(NumberFieldType.Uint16.size);
+        return NumberFieldType.Uint16.deserialize(buffer, false);
+    }
 
-export const NO_PTS = BigInt(1) << BigInt(63);
+    static async parseUint32BE(stream: AsyncExactReadable): Promise<number> {
+        const buffer = await stream.readExactly(NumberFieldType.Uint32.size);
+        return NumberFieldType.Uint32.deserialize(buffer, false);
+    }
 
-export const ScrcpyBackOrScreenOnControlMessage1_16 = new Struct().uint8(
-    "type",
-    ScrcpyControlMessageType.BackOrScreenOn as const
-);
+    value: Required<ScrcpyOptionsInit1_16>;
 
-export const ScrcpySetClipboardControlMessage1_15 = new Struct()
-    .uint8("type", ScrcpyControlMessageType.SetClipboard as const)
-    .uint32("length")
-    .string("content", { lengthField: "length" });
+    readonly defaults: Required<ScrcpyOptionsInit1_16> =
+        ScrcpyOptions1_16.DEFAULTS;
 
-export type ScrcpySetClipboardControlMessage1_15 =
-    (typeof ScrcpySetClipboardControlMessage1_15)["TInit"];
+    readonly controlMessageTypes: readonly ScrcpyControlMessageType[] =
+        SCRCPY_CONTROL_MESSAGE_TYPES_1_16;
 
-export class ScrcpyOptions1_16<
-    T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16
-> implements ScrcpyOptions<T>
-{
-    public value: Partial<T>;
+    constructor(init: ScrcpyOptionsInit1_16) {
+        this.value = { ...ScrcpyOptions1_16.DEFAULTS, ...init };
+    }
 
-    public constructor(value: Partial<ScrcpyOptionsInit1_16>) {
-        if (
-            new.target === ScrcpyOptions1_16 &&
-            value.logLevel === ScrcpyLogLevel.Verbose
-        ) {
-            value.logLevel = ScrcpyLogLevel.Debug;
-        }
+    serialize(): string[] {
+        return ScrcpyOptions1_16.serialize(
+            this.value,
+            ScrcpyOptions1_16.SERIALIZE_ORDER,
+        );
+    }
 
-        if (
-            new.target === ScrcpyOptions1_16 &&
-            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial
-        ) {
-            value.lockVideoOrientation = ScrcpyVideoOrientation.Unlocked;
-        }
+    setListEncoders(): void {
+        throw new Error("Not supported");
+    }
 
-        this.value = value as Partial<T>;
+    setListDisplays(): void {
+        // Set to an invalid value
+        // Server will print valid values before crashing
+        // (server will crash before opening sockets)
+        this.value.displayId = -1;
     }
 
-    protected getArgumentOrder(): (keyof T)[] {
-        return [
-            "logLevel",
-            "maxSize",
-            "bitRate",
-            "maxFps",
-            "lockVideoOrientation",
-            "tunnelForward",
-            "crop",
-            "sendFrameMeta",
-            "control",
-            "displayId",
-            "showTouches",
-            "stayAwake",
-            "codecOptions",
-            "encoderName",
-        ];
+    parseEncoder(): ScrcpyEncoder | undefined {
+        throw new Error("Not supported");
     }
 
-    public getDefaultValue(): T {
-        return {
-            logLevel: ScrcpyLogLevel.Debug,
-            maxSize: 0,
-            bitRate: 8_000_000,
-            maxFps: 0,
-            lockVideoOrientation: ScrcpyVideoOrientation.Unlocked,
-            tunnelForward: false,
-            crop: "-",
-            sendFrameMeta: true,
-            control: true,
-            displayId: 0,
-            showTouches: false,
-            stayAwake: false,
-            codecOptions: new CodecOptions({}),
-            encoderName: "-",
-        } as T;
+    parseDisplay(line: string): ScrcpyDisplay | undefined {
+        const displayIdRegex = /\s+scrcpy --display (\d+)/;
+        const match = line.match(displayIdRegex);
+        if (match) {
+            return {
+                id: Number.parseInt(match[1]!, 10),
+            };
+        }
+        return undefined;
     }
 
-    public formatServerArguments(): string[] {
-        const defaults = this.getDefaultValue();
-        return this.getArgumentOrder().map((key) =>
-            toScrcpyOptionValue(this.value[key] || defaults[key], "-")
-        );
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): ValueOrPromise<ScrcpyVideoStream> {
+        return (async () => {
+            const buffered = new BufferedReadableStream(stream);
+            const metadata: ScrcpyVideoStreamMetadata = {
+                codec: ScrcpyVideoCodecId.H264,
+            };
+            metadata.deviceName = await ScrcpyOptions1_16.parseCString(
+                buffered,
+                64,
+            );
+            metadata.width = await ScrcpyOptions1_16.parseUint16BE(buffered);
+            metadata.height = await ScrcpyOptions1_16.parseUint16BE(buffered);
+            return { stream: buffered.release(), metadata };
+        })();
     }
 
-    public getOutputEncoderNameRegex(): RegExp {
-        return /\s+scrcpy --encoder-name '(.*?)'/;
+    parseAudioStreamMetadata(): never {
+        throw new Error("Not supported");
     }
 
-    public createVideoStreamTransformer(): TransformStream<
+    createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyVideoStreamPacket
+        ScrcpyMediaStreamPacket
     > {
         // Optimized path for video frames only
-        if (this.value.sendFrameMeta === false) {
+        if (!this.value.sendFrameMeta) {
             return new TransformStream({
                 transform(chunk, controller) {
                     controller.enqueue({
-                        type: "frame",
+                        type: "data",
                         data: chunk,
                     });
                 },
             });
         }
 
-        let header: Uint8Array | undefined;
-
-        const deserializeStream = new StructDeserializeStream(VideoPacket);
+        const deserializeStream = new StructDeserializeStream(
+            ScrcpyMediaStreamRawPacket,
+        );
         return {
             writable: deserializeStream.writable,
             readable: deserializeStream.readable.pipeThrough(
                 new TransformStream({
                     transform(packet, controller) {
-                        if (packet.pts === NO_PTS) {
-                            const {
-                                sequenceParameterSet,
-                                pictureParameterSet,
-                            } = parseH264Configuration(packet.data);
-
-                            const {
-                                profile_idc: profileIndex,
-                                constraint_set: constraintSet,
-                                level_idc: levelIndex,
-                                pic_width_in_mbs_minus1,
-                                pic_height_in_map_units_minus1,
-                                frame_mbs_only_flag,
-                                frame_crop_left_offset,
-                                frame_crop_right_offset,
-                                frame_crop_top_offset,
-                                frame_crop_bottom_offset,
-                            } = parseSequenceParameterSet(
-                                removeH264Emulation(sequenceParameterSet)
-                            );
-
-                            const encodedWidth =
-                                (pic_width_in_mbs_minus1 + 1) * 16;
-                            const encodedHeight =
-                                (pic_height_in_map_units_minus1 + 1) *
-                                (2 - frame_mbs_only_flag) *
-                                16;
-                            const cropLeft = frame_crop_left_offset * 2;
-                            const cropRight = frame_crop_right_offset * 2;
-                            const cropTop = frame_crop_top_offset * 2;
-                            const cropBottom = frame_crop_bottom_offset * 2;
-
-                            const croppedWidth =
-                                encodedWidth - cropLeft - cropRight;
-                            const croppedHeight =
-                                encodedHeight - cropTop - cropBottom;
-
-                            header = packet.data;
+                        if (packet.pts === SCRCPY_MEDIA_PACKET_FLAG_CONFIG) {
                             controller.enqueue({
                                 type: "configuration",
-                                pictureParameterSet,
-                                sequenceParameterSet,
-                                data: {
-                                    profileIndex,
-                                    constraintSet,
-                                    levelIndex,
-                                    encodedWidth,
-                                    encodedHeight,
-                                    cropLeft,
-                                    cropRight,
-                                    cropTop,
-                                    cropBottom,
-                                    croppedWidth,
-                                    croppedHeight,
-                                },
+                                data: packet.data,
                             });
                             return;
                         }
 
-                        let frameData: Uint8Array;
-                        if (header) {
-                            frameData = new Uint8Array(
-                                header.byteLength + packet.data.byteLength
-                            );
-                            frameData.set(header);
-                            frameData.set(packet.data, header.byteLength);
-                            header = undefined;
-                        } else {
-                            frameData = packet.data;
-                        }
-
                         controller.enqueue({
-                            type: "frame",
+                            type: "data",
                             pts: packet.pts,
-                            data: frameData,
+                            data: packet.data,
                         });
                     },
-                })
+                }),
             ),
         };
     }
 
-    public getControlMessageTypes(): ScrcpyControlMessageType[] {
-        return [
-            /*  0 */ ScrcpyControlMessageType.InjectKeyCode,
-            /*  1 */ ScrcpyControlMessageType.InjectText,
-            /*  2 */ ScrcpyControlMessageType.InjectTouch,
-            /*  3 */ ScrcpyControlMessageType.InjectScroll,
-            /*  4 */ ScrcpyControlMessageType.BackOrScreenOn,
-            /*  5 */ ScrcpyControlMessageType.ExpandNotificationPanel,
-            /*  6 */ ScrcpyControlMessageType.CollapseNotificationPanel,
-            /*  7 */ ScrcpyControlMessageType.GetClipboard,
-            /*  8 */ ScrcpyControlMessageType.SetClipboard,
-            /*  9 */ ScrcpyControlMessageType.SetScreenPowerMode,
-            /* 10 */ ScrcpyControlMessageType.RotateDevice,
-        ];
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        return ScrcpyInjectTouchControlMessage1_16.serialize(message);
     }
 
-    public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
     ) {
         if (message.action === AndroidKeyEventAction.Down) {
             return ScrcpyBackOrScreenOnControlMessage1_16.serialize(message);
@@ -332,13 +219,13 @@ export class ScrcpyOptions1_16<
         return undefined;
     }
 
-    public serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
     ): Uint8Array {
         return ScrcpySetClipboardControlMessage1_15.serialize(message);
     }
 
-    public getScrollController(): ScrcpyScrollController {
+    createScrollController(): ScrcpyScrollController {
         return new ScrcpyScrollController1_16();
     }
 }

package/src/options/1_16/scroll.ts

@@ -1,16 +1,15 @@
 import Struct from "@yume-chan/struct";
 
 import type { ScrcpyInjectScrollControlMessage } from "../../control/index.js";
-import { ScrcpyControlMessageType } from "../../control/index.js";
 
 export interface ScrcpyScrollController {
     serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage
+        message: ScrcpyInjectScrollControlMessage,
     ): Uint8Array | undefined;
 }
 
 export const ScrcpyInjectScrollControlMessage1_16 = new Struct()
-    .uint8("type", ScrcpyControlMessageType.InjectScroll as const)
+    .uint8("type")
     .uint32("pointerX")
     .uint32("pointerY")
     .uint16("screenWidth")
@@ -25,31 +24,31 @@ export const ScrcpyInjectScrollControlMessage1_16 = new Struct()
  * reaches 1 or -1.
  */
 export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
-    private accumulatedX = 0;
-    private accumulatedY = 0;
+    #accumulatedX = 0;
+    #accumulatedY = 0;
 
     protected processMessage(
-        message: ScrcpyInjectScrollControlMessage
+        message: ScrcpyInjectScrollControlMessage,
     ): ScrcpyInjectScrollControlMessage | undefined {
-        this.accumulatedX += message.scrollX;
-        this.accumulatedY += message.scrollY;
+        this.#accumulatedX += message.scrollX;
+        this.#accumulatedY += message.scrollY;
 
         let scrollX = 0;
         let scrollY = 0;
-        if (this.accumulatedX >= 1) {
+        if (this.#accumulatedX >= 1) {
             scrollX = 1;
-            this.accumulatedX = 0;
-        } else if (this.accumulatedX <= -1) {
+            this.#accumulatedX = 0;
+        } else if (this.#accumulatedX <= -1) {
             scrollX = -1;
-            this.accumulatedX = 0;
+            this.#accumulatedX = 0;
         }
 
-        if (this.accumulatedY >= 1) {
+        if (this.#accumulatedY >= 1) {
             scrollY = 1;
-            this.accumulatedY = 0;
-        } else if (this.accumulatedY <= -1) {
+            this.#accumulatedY = 0;
+        } else if (this.#accumulatedY <= -1) {
             scrollY = -1;
-            this.accumulatedY = 0;
+            this.#accumulatedY = 0;
         }
 
         if (scrollX === 0 && scrollY === 0) {
@@ -61,8 +60,8 @@ export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
         return message;
     }
 
-    public serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage
+    serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage,
     ): Uint8Array | undefined {
         const processed = this.processMessage(message);
         if (!processed) {

package/src/options/1_17.ts

@@ -0,0 +1,66 @@
+import type { ScrcpyOptionsInit1_16 } from "./1_16/index.js";
+import { ScrcpyOptions1_16 } from "./1_16/index.js";
+import type { ScrcpyEncoder } from "./types.js";
+import { ScrcpyOptionsBase } from "./types.js";
+
+export interface ScrcpyOptionsInit1_17 extends ScrcpyOptionsInit1_16 {
+    encoderName?: string | undefined;
+}
+
+export class ScrcpyOptions1_17 extends ScrcpyOptionsBase<
+    ScrcpyOptionsInit1_17,
+    ScrcpyOptions1_16
+> {
+    static readonly DEFAULTS = {
+        ...ScrcpyOptions1_16.DEFAULTS,
+        encoderName: undefined,
+    } as const satisfies Required<ScrcpyOptionsInit1_17>;
+
+    static readonly SERIALIZE_ORDER = [
+        ...ScrcpyOptions1_16.SERIALIZE_ORDER,
+        "encoderName",
+    ] as const satisfies readonly (keyof ScrcpyOptionsInit1_17)[];
+
+    static parseEncoder(
+        line: string,
+        encoderNameRegex: RegExp,
+    ): ScrcpyEncoder | undefined {
+        const match = line.match(encoderNameRegex);
+        if (match) {
+            return { type: "video", name: match[1]! };
+        }
+        return undefined;
+    }
+
+    override get defaults(): Required<ScrcpyOptionsInit1_17> {
+        return ScrcpyOptions1_17.DEFAULTS;
+    }
+
+    constructor(init: ScrcpyOptionsInit1_17) {
+        super(new ScrcpyOptions1_16(init), {
+            ...ScrcpyOptions1_17.DEFAULTS,
+            ...init,
+        });
+    }
+
+    override serialize(): string[] {
+        return ScrcpyOptions1_16.serialize(
+            this.value,
+            ScrcpyOptions1_17.SERIALIZE_ORDER,
+        );
+    }
+
+    override setListEncoders() {
+        // Set to an invalid value
+        // Server will print valid values before crashing
+        // (server will crash after opening video and control sockets)
+        this.value.encoderName = "_";
+    }
+
+    override parseEncoder(line: string): ScrcpyEncoder | undefined {
+        return ScrcpyOptions1_17.parseEncoder(
+            line,
+            /\s+scrcpy --encoder-name '(.*?)'/,
+        );
+    }
+}