@yume-chan/scrcpy 0.0.19 → 0.0.20

package/src/options/2_0.ts

@@ -0,0 +1,342 @@
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import {
+    BufferedReadableStream,
+    PushReadableStream,
+} from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import Struct, { NumberFieldType, placeholder } from "@yume-chan/struct";
+
+import type {
+    AndroidMotionEventAction,
+    ScrcpyInjectTouchControlMessage,
+} from "../control/index.js";
+
+import {
+    CodecOptions,
+    ScrcpyFloatToUint16FieldDefinition,
+    ScrcpyOptions1_16,
+} from "./1_16/index.js";
+import { ScrcpyOptions1_21 } from "./1_21.js";
+import type { ScrcpyOptionsInit1_24 } from "./1_24.js";
+import { ScrcpyOptions1_24 } from "./1_24.js";
+import { ScrcpyOptions1_25 } from "./1_25/index.js";
+import type { ScrcpyAudioStreamMetadata, ScrcpyVideoStream } from "./codec.js";
+import { ScrcpyAudioCodec, ScrcpyVideoCodecId } from "./codec.js";
+import type {
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyOptionValue,
+} from "./types.js";
+import { ScrcpyOptionsBase } from "./types.js";
+
+export const ScrcpyInjectTouchControlMessage2_0 = new Struct()
+    .uint8("type")
+    .uint8("action", placeholder<AndroidMotionEventAction>())
+    .uint64("pointerId")
+    .uint32("pointerX")
+    .uint32("pointerY")
+    .uint16("screenWidth")
+    .uint16("screenHeight")
+    .field("pressure", ScrcpyFloatToUint16FieldDefinition)
+    .uint32("actionButton")
+    .uint32("buttons");
+
+export type ScrcpyInjectTouchControlMessage2_0 =
+    (typeof ScrcpyInjectTouchControlMessage2_0)["TInit"];
+
+export class ScrcpyInstanceId implements ScrcpyOptionValue {
+    public static readonly NONE = new ScrcpyInstanceId(-1);
+
+    public static random(): ScrcpyInstanceId {
+        // A random 31-bit unsigned integer
+        return new ScrcpyInstanceId((Math.random() * 0x80000000) | 0);
+    }
+
+    public value: number;
+
+    public constructor(value: number) {
+        this.value = value;
+    }
+
+    public toOptionValue(): string | undefined {
+        if (this.value < 0) {
+            return undefined;
+        }
+        return this.value.toString(16);
+    }
+}
+
+export interface ScrcpyOptionsInit2_0
+    extends Omit<
+        ScrcpyOptionsInit1_24,
+        "bitRate" | "codecOptions" | "encoderName"
+    > {
+    scid?: ScrcpyInstanceId;
+
+    videoCodec?: "h264" | "h265" | "av1";
+    videoBitRate?: number;
+    videoCodecOptions?: CodecOptions;
+    videoEncoder?: string;
+
+    audio?: boolean;
+    audioCodec?: "opus" | "aac" | "raw";
+    audioBitRate?: number;
+    audioCodecOptions?: CodecOptions;
+    audioEncoder?: string;
+
+    listEncoders?: boolean;
+    listDisplays?: boolean;
+    sendCodecMeta?: boolean;
+}
+
+function omit<T extends object, K extends keyof T>(
+    obj: T,
+    keys: K[]
+): Omit<T, K> {
+    const result: Record<PropertyKey, unknown> = {};
+    for (const key in obj) {
+        if (!keys.includes(key as keyof T as K)) {
+            result[key] = obj[key];
+        }
+    }
+    return result as Omit<T, K>;
+}
+
+export class ScrcpyOptions2_0 extends ScrcpyOptionsBase<
+    ScrcpyOptionsInit2_0,
+    ScrcpyOptions1_25
+> {
+    public static readonly DEFAULTS = {
+        ...omit(ScrcpyOptions1_24.DEFAULTS, [
+            "bitRate",
+            "codecOptions",
+            "encoderName",
+        ]),
+        scid: ScrcpyInstanceId.NONE,
+
+        videoCodec: "h264",
+        videoBitRate: 8000000,
+        videoCodecOptions: new CodecOptions(),
+        videoEncoder: "",
+
+        audio: true,
+        audioCodec: "opus",
+        audioBitRate: 128000,
+        audioCodecOptions: new CodecOptions(),
+        audioEncoder: "",
+
+        listEncoders: false,
+        listDisplays: false,
+        sendCodecMeta: true,
+    } as const satisfies Required<ScrcpyOptionsInit2_0>;
+
+    public override get defaults(): Required<ScrcpyOptionsInit2_0> {
+        return ScrcpyOptions2_0.DEFAULTS;
+    }
+
+    public constructor(init: ScrcpyOptionsInit2_0) {
+        super(new ScrcpyOptions1_25(init), {
+            ...ScrcpyOptions2_0.DEFAULTS,
+            ...init,
+        });
+    }
+
+    public override serialize(): string[] {
+        return ScrcpyOptions1_21.serialize(this.value, this.defaults);
+    }
+
+    public override setListEncoders(): void {
+        this.value.listEncoders = true;
+    }
+
+    public override setListDisplays(): void {
+        this.value.listDisplays = true;
+    }
+
+    public override parseEncoder(line: string): ScrcpyEncoder | undefined {
+        let match = line.match(
+            /\s+--video-codec=(.*)\s+--video-encoder='(.*)'/
+        );
+        if (match) {
+            return {
+                type: "video",
+                codec: match[1]!,
+                name: match[2]!,
+            };
+        }
+
+        match = line.match(/\s+--audio-codec=(.*)\s+--audio-encoder='(.*)'/);
+        if (match) {
+            return {
+                type: "audio",
+                codec: match[1]!,
+                name: match[2]!,
+            };
+        }
+
+        return undefined;
+    }
+
+    public override parseDisplay(line: string): ScrcpyDisplay | undefined {
+        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;
+    }
+
+    public override parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>
+    ): ValueOrPromise<ScrcpyVideoStream> {
+        const { sendDeviceMeta, sendCodecMeta } = this.value;
+        if (!sendDeviceMeta && !sendCodecMeta) {
+            let codec: ScrcpyVideoCodecId;
+            switch (this.value.videoCodec) {
+                case "h264":
+                    codec = ScrcpyVideoCodecId.H264;
+                    break;
+                case "h265":
+                    codec = ScrcpyVideoCodecId.H265;
+                    break;
+                case "av1":
+                    codec = ScrcpyVideoCodecId.AV1;
+                    break;
+            }
+            return { stream, metadata: { codec } };
+        }
+
+        return (async () => {
+            const buffered = new BufferedReadableStream(stream);
+
+            // `sendDeviceMeta` now only contains device name,
+            // can't use `super.parseVideoStreamMetadata` here
+            let deviceName: string | undefined;
+            if (sendDeviceMeta) {
+                deviceName = await ScrcpyOptions1_16.parseCString(buffered, 64);
+            }
+
+            let codec: ScrcpyVideoCodecId;
+            let width: number | undefined;
+            let height: number | undefined;
+            if (sendCodecMeta) {
+                codec = await ScrcpyOptions1_16.parseUint32BE(buffered);
+                width = await ScrcpyOptions1_16.parseUint32BE(buffered);
+                height = await ScrcpyOptions1_16.parseUint32BE(buffered);
+            } else {
+                switch (this.value.videoCodec) {
+                    case "h264":
+                        codec = ScrcpyVideoCodecId.H264;
+                        break;
+                    case "h265":
+                        codec = ScrcpyVideoCodecId.H265;
+                        break;
+                    case "av1":
+                        codec = ScrcpyVideoCodecId.AV1;
+                        break;
+                }
+            }
+
+            return {
+                stream: buffered.release(),
+                metadata: { deviceName, codec, width, height },
+            };
+        })();
+    }
+
+    public override parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>
+    ): ValueOrPromise<ScrcpyAudioStreamMetadata> {
+        return (async (): Promise<ScrcpyAudioStreamMetadata> => {
+            const buffered = new BufferedReadableStream(stream);
+            const buffer = await buffered.readExactly(
+                NumberFieldType.Uint32.size
+            );
+
+            const codecMetadataValue = NumberFieldType.Uint32.deserialize(
+                buffer,
+                false
+            );
+            // 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 (this.value.sendCodecMeta) {
+                let codec: ScrcpyAudioCodec;
+                switch (codecMetadataValue) {
+                    case ScrcpyAudioCodec.OPUS.metadataValue:
+                        codec = ScrcpyAudioCodec.OPUS;
+                        break;
+                    case ScrcpyAudioCodec.AAC.metadataValue:
+                        codec = ScrcpyAudioCodec.AAC;
+                        break;
+                    case ScrcpyAudioCodec.RAW.metadataValue:
+                        codec = ScrcpyAudioCodec.RAW;
+                        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 (this.value.audioCodec) {
+                case "opus":
+                    codec = ScrcpyAudioCodec.OPUS;
+                    break;
+                case "aac":
+                    codec = ScrcpyAudioCodec.AAC;
+                    break;
+                case "raw":
+                    codec = ScrcpyAudioCodec.RAW;
+                    break;
+            }
+            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);
+                        }
+                    }
+                ),
+            };
+        })();
+    }
+
+    public override serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage
+    ): Uint8Array {
+        return ScrcpyInjectTouchControlMessage2_0.serialize(message);
+    }
+}

package/src/options/codec.ts

@@ -0,0 +1,98 @@
+import type { ReadableStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyOptionValue } from "./types.js";
+
+export enum ScrcpyVideoCodecId {
+    H264 = 0x68_32_36_34,
+    H265 = 0x68_32_36_35,
+    AV1 = 0x00_61_76_31,
+}
+
+export interface ScrcpyVideoStreamMetadata {
+    deviceName?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    codec: ScrcpyVideoCodecId;
+}
+
+export interface ScrcpyVideoStream {
+    readonly stream: ReadableStream<Uint8Array>;
+    readonly metadata: ScrcpyVideoStreamMetadata;
+}
+
+export class ScrcpyAudioCodec implements ScrcpyOptionValue {
+    public static readonly OPUS = new ScrcpyAudioCodec(
+        "opus",
+        0x6f_70_75_73,
+        "audio/opus",
+        "opus"
+    );
+    public static readonly AAC = new ScrcpyAudioCodec(
+        "aac",
+        0x00_61_61_63,
+        "audio/aac",
+        "mp4a.66"
+    );
+    public static readonly RAW = new ScrcpyAudioCodec(
+        "raw",
+        0x00_72_61_77,
+        "audio/raw",
+        "1"
+    );
+
+    public readonly optionValue: string;
+    public readonly metadataValue: number;
+    public readonly mimeType: string;
+    public readonly webCodecId: string;
+
+    public constructor(
+        optionValue: string,
+        metadataValue: number,
+        mimeType: string,
+        webCodecId: string
+    ) {
+        this.optionValue = optionValue;
+        this.metadataValue = metadataValue;
+        this.mimeType = mimeType;
+        this.webCodecId = webCodecId;
+    }
+
+    public toOptionValue(): string {
+        return this.optionValue;
+    }
+}
+
+export interface ScrcpyAudioStreamDisabledMetadata {
+    readonly type: "disabled";
+}
+
+export interface ScrcpyAudioStreamErroredMetadata {
+    readonly type: "errored";
+}
+
+export interface ScrcpyAudioStreamSuccessMetadata {
+    readonly type: "success";
+    readonly codec: ScrcpyAudioCodec;
+    readonly stream: ReadableStream<Uint8Array>;
+}
+
+export type ScrcpyAudioStreamMetadata =
+    | ScrcpyAudioStreamDisabledMetadata
+    | ScrcpyAudioStreamErroredMetadata
+    | ScrcpyAudioStreamSuccessMetadata;
+
+export interface ScrcpyMediaStreamConfigurationPacket {
+    type: "configuration";
+    data: Uint8Array;
+}
+
+export interface ScrcpyMediaStreamDataPacket {
+    type: "data";
+    keyframe?: boolean;
+    pts?: bigint;
+    data: Uint8Array;
+}
+
+export type ScrcpyMediaStreamPacket =
+    | ScrcpyMediaStreamConfigurationPacket
+    | ScrcpyMediaStreamDataPacket;

package/src/options/index.ts

@@ -1,8 +1,12 @@
 export * from "./1_16/index.js";
+export * from "./1_17.js";
 export * from "./1_18.js";
 export * from "./1_21.js";
 export * from "./1_22/index.js";
 export * from "./1_23.js";
 export * from "./1_24.js";
 export * from "./1_25/index.js";
+export * from "./2_0.js";
+export * from "./codec.js";
+export * from "./latest.js";
 export * from "./types.js";

package/src/options/latest.ts

@@ -0,0 +1,14 @@
+import { ScrcpyLogLevel1_18, ScrcpyVideoOrientation1_18 } from "./1_18.js";
+import type { ScrcpyOptionsInit2_0 } from "./2_0.js";
+import { ScrcpyOptions2_0 } from "./2_0.js";
+
+export const ScrcpyLogLevel = ScrcpyLogLevel1_18;
+export type ScrcpyLogLevel = ScrcpyLogLevel1_18;
+
+export const ScrcpyVideoOrientation = ScrcpyVideoOrientation1_18;
+export type ScrcpyVideoOrientation = ScrcpyVideoOrientation1_18;
+
+export type ScrcpyOptionsInitLatest = ScrcpyOptionsInit2_0;
+export class ScrcpyOptionsLatest extends ScrcpyOptions2_0 {}
+
+export const ScrcpyLatestVersion = "2.0";

package/src/options/types.ts

@@ -1,12 +1,19 @@
-import type { TransformStream } from "@yume-chan/stream-extra";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type {
     ScrcpyBackOrScreenOnControlMessage,
     ScrcpyControlMessageType,
+    ScrcpyInjectTouchControlMessage,
     ScrcpySetClipboardControlMessage,
 } from "../control/index.js";
 
 import type { ScrcpyScrollController } from "./1_16/scroll.js";
+import type {
+    ScrcpyAudioStreamMetadata,
+    ScrcpyMediaStreamPacket,
+    ScrcpyVideoStream,
+} from "./codec.js";
 
 export const DEFAULT_SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";
 
@@ -38,65 +45,168 @@ export function toScrcpyOptionValue<T>(value: unknown, empty: T): string | T {
     return String(value);
 }
 
-export interface H264Configuration {
-    profileIndex: number;
-    constraintSet: number;
-    levelIndex: number;
+export interface ScrcpyEncoder {
+    type: "video" | "audio";
+    codec?: string;
+    name: string;
+}
 
-    encodedWidth: number;
-    encodedHeight: number;
+export interface ScrcpyDisplay {
+    id: number;
+    resolution?: string;
+}
 
-    cropLeft: number;
-    cropRight: number;
+export interface ScrcpyOptions<T extends object> {
+    readonly defaults: Required<T>;
+
+    readonly controlMessageTypes: readonly ScrcpyControlMessageType[];
+
+    readonly value: Required<T>;
+
+    serialize(): string[];
+
+    /**
+     * Set the essential options to let Scrcpy server print out available encoders.
+     */
+    setListEncoders(): void;
+
+    /**
+     * Set the essential options to let Scrcpy server print out available displays.
+     */
+    setListDisplays(): void;
+
+    /**
+     * Parse encoder information from Scrcpy server output
+     * @param line One line of Scrcpy server output
+     */
+    parseEncoder(line: string): ScrcpyEncoder | undefined;
+
+    /**
+     * Parse display information from Scrcpy server output
+     * @param line One line of Scrcpy server output
+     */
+    parseDisplay(line: string): ScrcpyDisplay | undefined;
+
+    /**
+     * Parse the device metadata from video stream according to the current version and options.
+     * @param stream The video stream.
+     * @returns
+     * A tuple of the video stream and the metadata.
+     *
+     * The returned video stream may be different from the input stream, and should be used for further processing.
+     */
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>
+    ): ValueOrPromise<ScrcpyVideoStream>;
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>
+    ): ValueOrPromise<ScrcpyAudioStreamMetadata>;
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyMediaStreamPacket
+    >;
 
-    cropTop: number;
-    cropBottom: number;
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage
+    ): Uint8Array;
 
-    croppedWidth: number;
-    croppedHeight: number;
-}
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage
+    ): Uint8Array | undefined;
 
-export interface ScrcpyVideoStreamConfigurationPacket {
-    type: "configuration";
-    sequenceParameterSet: Uint8Array;
-    pictureParameterSet: Uint8Array;
-    data: H264Configuration;
-}
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage
+    ): Uint8Array;
 
-export interface ScrcpyVideoStreamFramePacket {
-    type: "frame";
-    keyframe?: boolean;
-    pts?: bigint;
-    data: Uint8Array;
+    createScrollController(): ScrcpyScrollController;
 }
 
-export type ScrcpyVideoStreamPacket =
-    | ScrcpyVideoStreamConfigurationPacket
-    | ScrcpyVideoStreamFramePacket;
+export abstract class ScrcpyOptionsBase<
+    T extends object,
+    B extends ScrcpyOptions<object>
+> implements ScrcpyOptions<T>
+{
+    protected _base: B;
 
-export interface ScrcpyOptions<T extends object> {
-    value: Partial<T>;
+    public abstract get defaults(): Required<T>;
 
-    getDefaultValue(): T;
+    public get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return this._base.controlMessageTypes;
+    }
+
+    public readonly value: Required<T>;
 
-    formatServerArguments(): string[];
+    public constructor(base: B, value: Required<T>) {
+        this._base = base;
+        this.value = value;
+    }
 
-    getOutputEncoderNameRegex(): RegExp;
+    public abstract serialize(): string[];
+
+    public setListEncoders(): void {
+        this._base.setListEncoders();
+    }
 
-    createVideoStreamTransformer(): TransformStream<
+    public setListDisplays(): void {
+        this._base.setListDisplays();
+    }
+
+    public parseEncoder(line: string): ScrcpyEncoder | undefined {
+        return this._base.parseEncoder(line);
+    }
+
+    public parseDisplay(line: string): ScrcpyDisplay | undefined {
+        return this._base.parseDisplay(line);
+    }
+
+    /**
+     * Parse the device metadata from video stream according to the current version and options.
+     * @param stream The video stream.
+     * @returns
+     * A tuple of the video stream and the metadata.
+     *
+     * The returned video stream may be different from the input stream, and should be used for further processing.
+     */
+    public parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>
+    ): ValueOrPromise<ScrcpyVideoStream> {
+        return this._base.parseVideoStreamMetadata(stream);
+    }
+
+    public parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>
+    ): ValueOrPromise<ScrcpyAudioStreamMetadata> {
+        return this._base.parseAudioStreamMetadata(stream);
+    }
+
+    public createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyVideoStreamPacket
-    >;
+        ScrcpyMediaStreamPacket
+    > {
+        return this._base.createMediaStreamTransformer();
+    }
 
-    getControlMessageTypes(): ScrcpyControlMessageType[];
+    public serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage
+    ): Uint8Array {
+        return this._base.serializeInjectTouchControlMessage(message);
+    }
 
-    serializeBackOrScreenOnControlMessage(
+    public serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnControlMessage
-    ): Uint8Array | undefined;
+    ): Uint8Array | undefined {
+        return this._base.serializeBackOrScreenOnControlMessage(message);
+    }
 
-    serializeSetClipboardControlMessage(
+    public serializeSetClipboardControlMessage(
         message: ScrcpySetClipboardControlMessage
-    ): Uint8Array;
+    ): Uint8Array {
+        return this._base.serializeSetClipboardControlMessage(message);
+    }
 
-    getScrollController(): ScrcpyScrollController;
+    public createScrollController(): ScrcpyScrollController {
+        return this._base.createScrollController();
+    }
 }