@yume-chan/scrcpy 0.0.24 → 1.0.0

package/esm/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./clamp.js";
+export * from "./constants.js";
+export * from "./omit.js";
+export * from "./wrapper.js";
+//# sourceMappingURL=index.js.map

package/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/esm/utils/omit.d.ts

@@ -0,0 +1,2 @@
+export declare function omit<T extends Record<string, unknown>, K extends (keyof T)[]>(value: T, ...keys: K): T;
+//# sourceMappingURL=omit.d.ts.map

package/esm/utils/omit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../src/utils/omit.ts"],"names":[],"mappings":"AACA,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,EACzE,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,CAAC,GACX,CAAC,CAMH"}

package/esm/utils/omit.js

@@ -0,0 +1,5 @@
+/* #__NO_SIDE_EFFECTS__ */
+export function omit(value, ...keys) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !keys.includes(key)));
+}
+//# sourceMappingURL=omit.js.map

package/esm/utils/omit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.js","sourceRoot":"","sources":["../../src/utils/omit.ts"],"names":[],"mappings":"AAAA,0BAA0B;AAC1B,MAAM,UAAU,IAAI,CAChB,KAAQ,EACR,GAAG,IAAO;IAEV,OAAO,MAAM,CAAC,WAAW,CACrB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CACxB,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAgB,CAAC,CAC9C,CACK,CAAC;AACf,CAAC"}

package/esm/utils/wrapper.d.ts

@@ -0,0 +1,37 @@
+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 } from "../base/audio.js";
+import type { ScrcpyEncoder } from "../base/encoder.js";
+import type { ScrcpyMediaStreamPacket } from "../base/media.js";
+import type { ScrcpyOptions } from "../base/options.js";
+import type { ScrcpyScrollController } from "../base/scroll-controller.js";
+import type { ScrcpyVideoStream } from "../base/video.js";
+import type { ScrcpyBackOrScreenOnControlMessage, ScrcpyInjectTouchControlMessage, ScrcpySetClipboardControlMessage, ScrcpyUHidCreateControlMessage } from "../latest.js";
+export declare class ScrcpyOptionsWrapper<T extends object> implements ScrcpyOptions<T> {
+    #private;
+    get controlMessageTypes(): readonly import("../index.js").ScrcpyControlMessageType[];
+    get value(): Required<T>;
+    get clipboard(): ReadableStream<string> | undefined;
+    get uHidOutput(): ReadableStream<import("@yume-chan/struct").FieldsType<{
+        id: import("@yume-chan/struct").NumberField<number>;
+        data: import("@yume-chan/struct").Field<Uint8Array<ArrayBufferLike>, never, never>;
+    }>> | undefined;
+    constructor(options: ScrcpyOptions<T>);
+    serialize(): string[];
+    setListDisplays(): void;
+    parseDisplay(line: string): import("../index.js").ScrcpyDisplay | undefined;
+    setListEncoders(): void;
+    parseEncoder(line: string): ScrcpyEncoder | undefined;
+    parseVideoStreamMetadata(stream: ReadableStream<Uint8Array>): MaybePromiseLike<ScrcpyVideoStream>;
+    parseAudioStreamMetadata(stream: ReadableStream<Uint8Array>): MaybePromiseLike<ScrcpyAudioStreamMetadata>;
+    parseDeviceMessage(id: number, stream: AsyncExactReadable): Promise<void>;
+    endDeviceMessageStream(e?: unknown): void;
+    createMediaStreamTransformer(): TransformStream<Uint8Array, ScrcpyMediaStreamPacket>;
+    serializeInjectTouchControlMessage(message: ScrcpyInjectTouchControlMessage): Uint8Array;
+    serializeBackOrScreenOnControlMessage(message: ScrcpyBackOrScreenOnControlMessage): Uint8Array | undefined;
+    serializeSetClipboardControlMessage(message: ScrcpySetClipboardControlMessage): Uint8Array | [Uint8Array, Promise<void>];
+    createScrollController(): ScrcpyScrollController;
+    serializeUHidCreateControlMessage(message: ScrcpyUHidCreateControlMessage): Uint8Array;
+}
+//# sourceMappingURL=wrapper.d.ts.map

package/esm/utils/wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EACR,kCAAkC,EAClC,+BAA+B,EAC/B,gCAAgC,EAChC,8BAA8B,EACjC,MAAM,cAAc,CAAC;AAEtB,qBAAa,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAC9C,YAAW,aAAa,CAAC,CAAC,CAAC;;IAI3B,IAAI,mBAAmB,8DAEtB;IAED,IAAI,KAAK,gBAER;IAED,IAAI,SAAS,uCAEZ;IAED,IAAI,UAAU;;;oBAEb;gBAEW,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;IAIrC,SAAS,IAAI,MAAM,EAAE;IAIrB,eAAe;IAIf,YAAY,CAAC,IAAI,EAAE,MAAM;IAIzB,eAAe,IAAI,IAAI;IAOvB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAOrD,wBAAwB,CACpB,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACnC,gBAAgB,CAAC,iBAAiB,CAAC;IAItC,wBAAwB,CACpB,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACnC,gBAAgB,CAAC,yBAAyB,CAAC;IAO9C,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzE,sBAAsB,CAAC,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI;IAIzC,4BAA4B,IAAI,eAAe,CAC3C,UAAU,EACV,uBAAuB,CAC1B;IAID,kCAAkC,CAC9B,OAAO,EAAE,+BAA+B,GACzC,UAAU;IAIb,qCAAqC,CACjC,OAAO,EAAE,kCAAkC,GAC5C,UAAU,GAAG,SAAS;IAIzB,mCAAmC,CAC/B,OAAO,EAAE,gCAAgC,GAC1C,UAAU,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAI3C,sBAAsB,IAAI,sBAAsB;IAIhD,iCAAiC,CAC7B,OAAO,EAAE,8BAA8B,GACxC,UAAU;CAQhB"}

package/esm/utils/wrapper.js

@@ -0,0 +1,76 @@
+export class ScrcpyOptionsWrapper {
+    #base;
+    get controlMessageTypes() {
+        return this.#base.controlMessageTypes;
+    }
+    get value() {
+        return this.#base.value;
+    }
+    get clipboard() {
+        return this.#base.clipboard;
+    }
+    get uHidOutput() {
+        return this.#base.uHidOutput;
+    }
+    constructor(options) {
+        this.#base = options;
+    }
+    serialize() {
+        return this.#base.serialize();
+    }
+    setListDisplays() {
+        this.#base.setListDisplays();
+    }
+    parseDisplay(line) {
+        return this.#base.parseDisplay(line);
+    }
+    setListEncoders() {
+        if (!this.#base.setListEncoders) {
+            throw new Error("setListEncoders is not implemented");
+        }
+        this.#base.setListEncoders();
+    }
+    parseEncoder(line) {
+        if (!this.#base.parseEncoder) {
+            throw new Error("parseEncoder is not implemented");
+        }
+        return this.#base.parseEncoder(line);
+    }
+    parseVideoStreamMetadata(stream) {
+        return this.#base.parseVideoStreamMetadata(stream);
+    }
+    parseAudioStreamMetadata(stream) {
+        if (!this.#base.parseAudioStreamMetadata) {
+            throw new Error("parseAudioStreamMetadata is not implemented");
+        }
+        return this.#base.parseAudioStreamMetadata(stream);
+    }
+    parseDeviceMessage(id, stream) {
+        return this.#base.parseDeviceMessage(id, stream);
+    }
+    endDeviceMessageStream(e) {
+        this.#base.endDeviceMessageStream(e);
+    }
+    createMediaStreamTransformer() {
+        return this.#base.createMediaStreamTransformer();
+    }
+    serializeInjectTouchControlMessage(message) {
+        return this.#base.serializeInjectTouchControlMessage(message);
+    }
+    serializeBackOrScreenOnControlMessage(message) {
+        return this.#base.serializeBackOrScreenOnControlMessage(message);
+    }
+    serializeSetClipboardControlMessage(message) {
+        return this.#base.serializeSetClipboardControlMessage(message);
+    }
+    createScrollController() {
+        return this.#base.createScrollController();
+    }
+    serializeUHidCreateControlMessage(message) {
+        if (!this.#base.serializeUHidCreateControlMessage) {
+            throw new Error("serializeUHidCreateControlMessage is not implemented");
+        }
+        return this.#base.serializeUHidCreateControlMessage(message);
+    }
+}
+//# sourceMappingURL=wrapper.js.map

package/esm/utils/wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/utils/wrapper.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yume-chan/scrcpy",
-  "version": "0.0.24",
-  "description": "TypeScript implementation of Scrcpy.",
+  "version": "1.0.0",
+  "description": "TypeScript implementation of Scrcpy client.",
   "keywords": [
     "adb",
     "android-phone",
@@ -25,26 +25,24 @@
   "type": "module",
   "main": "esm/index.js",
   "types": "esm/index.d.ts",
+  "sideEffects": false,
   "dependencies": {
-    "@yume-chan/async": "^2.2.0",
-    "@yume-chan/no-data-view": "^0.0.24",
-    "@yume-chan/stream-extra": "^0.0.24",
-    "@yume-chan/struct": "^0.0.24"
+    "@yume-chan/async": "^4.0.2",
+    "@yume-chan/struct": "^1.0.0",
+    "@yume-chan/no-data-view": "^1.0.0",
+    "@yume-chan/stream-extra": "^1.0.0"
   },
   "devDependencies": {
-    "@jest/globals": "^30.0.0-alpha.4",
+    "@types/node": "^22.10.0",
+    "prettier": "^3.4.1",
+    "typescript": "^5.7.2",
     "@yume-chan/eslint-config": "^1.0.0",
-    "@yume-chan/tsconfig": "^1.0.0",
-    "cross-env": "^7.0.3",
-    "jest": "^30.0.0-alpha.4",
-    "prettier": "^3.3.2",
-    "ts-jest": "^29.1.4",
-    "typescript": "^5.4.5"
+    "@yume-chan/test-runner": "^1.0.0",
+    "@yume-chan/tsconfig": "^1.0.0"
   },
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
-    "build:watch": "tsc -b tsconfig.build.json",
-    "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules --no-warnings\" TS_JEST_DISABLE_VER_CHECKER=true jest --coverage",
-    "lint": "run-eslint && prettier src/**/*.ts --write --tab-width 4"
+    "lint": "run-eslint && prettier src/**/*.ts --write --tab-width 4",
+    "test": "run-test"
   }
 }

package/src/1_15/impl/back-or-screen-on.ts

@@ -0,0 +1,21 @@
+import type { StructInit } from "@yume-chan/struct";
+
+import { AndroidKeyEventAction } from "../../android/index.js";
+import { EmptyControlMessage } from "../../control/index.js";
+import type { ScrcpyBackOrScreenOnControlMessage } from "../../latest.js";
+
+export const BackOrScreenOnControlMessage = EmptyControlMessage;
+
+export type BackOrScreenOnControlMessage = StructInit<
+    typeof BackOrScreenOnControlMessage
+>;
+
+export function serializeBackOrScreenOnControlMessage(
+    message: ScrcpyBackOrScreenOnControlMessage,
+) {
+    if (message.action === AndroidKeyEventAction.Down) {
+        return BackOrScreenOnControlMessage.serialize(message);
+    }
+
+    return undefined;
+}

package/src/1_15/impl/clipboard-stream.ts

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

package/src/1_15/impl/control-message-types.ts

@@ -0,0 +1,16 @@
+import { ScrcpyControlMessageType } from "../../base/index.js";
+
+export const ControlMessageTypes: readonly ScrcpyControlMessageType[] =
+    /* #__PURE__ */ (() => [
+        /*  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.SetDisplayPower,
+        /* 10 */ ScrcpyControlMessageType.RotateDevice,
+    ])();

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

@@ -0,0 +1,19 @@
+import type { Init } from "./init.js";
+import { CodecOptions, VideoOrientation } from "./init.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        logLevel: "debug",
+        maxSize: 0,
+        bitRate: 8_000_000,
+        maxFps: 0,
+        lockVideoOrientation: VideoOrientation.Unlocked,
+        tunnelForward: false,
+        crop: undefined,
+        sendFrameMeta: true,
+        control: true,
+        displayId: 0,
+        showTouches: false,
+        stayAwake: false,
+        codecOptions: CodecOptions.Empty,
+    }) as const satisfies Required<Init>)();

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

@@ -0,0 +1,14 @@
+export * from "./back-or-screen-on.js";
+export * from "./clipboard-stream.js";
+export * from "./control-message-types.js";
+export * from "./defaults.js";
+export * from "./init.js";
+export * from "./inject-touch.js";
+export * from "./media-stream-transformer.js";
+export * from "./parse-display.js";
+export * from "./parse-video-stream-metadata.js";
+export * from "./scroll-controller.js";
+export * from "./serialize-order.js";
+export * from "./serialize.js";
+export * from "./set-clipboard.js";
+export * from "./set-list-display.js";

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

@@ -0,0 +1,154 @@
+import type { ScrcpyOptionValue } from "../../base/index.js";
+
+export const VideoOrientation = {
+    Unlocked: -1,
+    Portrait: 0,
+    Landscape: 1,
+    PortraitFlipped: 2,
+    LandscapeFlipped: 3,
+} as const;
+
+export type VideoOrientation =
+    (typeof VideoOrientation)[keyof typeof VideoOrientation];
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+/**
+ * If the option you need is not in this type,
+ * please file an issue on GitHub.
+ */
+export interface CodecOptionsInit {
+    profile?: number | undefined;
+    level?: number | undefined;
+
+    iFrameInterval?: number | undefined;
+    maxBframes?: number | undefined;
+    repeatPreviousFrameAfter?: number | undefined;
+    maxPtsGapToEncoder?: number | undefined;
+    intraRefreshPeriod?: number | undefined;
+}
+
+function toDashCase(input: string) {
+    return input.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+
+const CodecOptionTypes: Partial<
+    Record<keyof CodecOptionsInit, "long" | "float" | "string">
+> = {
+    repeatPreviousFrameAfter: "long",
+    maxPtsGapToEncoder: "long",
+};
+
+export class CodecOptions implements ScrcpyOptionValue {
+    static Empty = /* #__PURE__ */ new CodecOptions();
+
+    options: CodecOptionsInit;
+
+    constructor(options: CodecOptionsInit = {}) {
+        for (const [key, value] of Object.entries(options)) {
+            if (value === undefined) {
+                continue;
+            }
+
+            if (typeof value !== "number") {
+                throw new Error(
+                    `Invalid option value for ${key}: ${String(value)}`,
+                );
+            }
+        }
+
+        this.options = options;
+    }
+
+    toOptionValue(): string | undefined {
+        const entries = Object.entries(this.options).filter(
+            ([, value]) => value !== undefined,
+        );
+
+        if (entries.length === 0) {
+            return undefined;
+        }
+
+        return entries
+            .map(([key, value]) => {
+                let result = toDashCase(key);
+
+                const type = CodecOptionTypes[key as keyof CodecOptionsInit];
+                if (type) {
+                    result += `:${type}`;
+                }
+
+                result += `=${value}`;
+                return result;
+            })
+            .join(",");
+    }
+}
+
+export namespace CodecOptions {
+    export type Init = CodecOptionsInit;
+}
+
+export interface Init {
+    logLevel?: LogLevel;
+
+    /**
+     * 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?: VideoOrientation;
+
+    /**
+     * 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 | undefined;
+
+    /**
+     * Send PTS so that the client may record properly
+     *
+     * Note: When `sendFrameMeta: false` is specified,
+     * the video stream will not contain `configuration` typed packets,
+     * which means it can't be decoded by the companion decoders.
+     * It's still possible to record the stream into a file,
+     * or to decode it with a more tolerant decoder like FFMpeg.
+     *
+     * @default true
+     */
+    sendFrameMeta?: boolean;
+
+    /**
+     * @default true
+     */
+    control?: boolean;
+
+    displayId?: number;
+
+    showTouches?: boolean;
+
+    stayAwake?: boolean;
+
+    codecOptions?: CodecOptions;
+}

package/src/1_15/impl/inject-touch.ts

@@ -0,0 +1,55 @@
+import { getUint16, setUint16 } from "@yume-chan/no-data-view";
+import type { Field, StructInit } from "@yume-chan/struct";
+import { bipedal, struct, u16, u32, u64, u8 } from "@yume-chan/struct";
+
+import type { AndroidMotionEventAction } from "../../android/index.js";
+import type { ScrcpyInjectTouchControlMessage } from "../../latest.js";
+import { clamp } from "../../utils/index.js";
+
+export const UnsignedFloat: 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 ? 0xffff : value * 0x10000;
+        setUint16(buffer, index, value, littleEndian);
+    },
+    deserialize: bipedal(function* (then, { reader, littleEndian }) {
+        const data = yield* then(reader.readExactly(2));
+        const value = getUint16(data, 0, littleEndian);
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/server/src/main/java/com/genymobile/scrcpy/Binary.java#L22
+        return value === 0xffff ? 1 : value / 0x10000;
+    }),
+};
+
+export const PointerId = {
+    Mouse: -1n,
+    Finger: -2n,
+    VirtualMouse: -3n,
+    VirtualFinger: -4n,
+} as const;
+
+export const InjectTouchControlMessage = struct(
+    {
+        type: u8,
+        action: u8<AndroidMotionEventAction>(),
+        pointerId: u64,
+        pointerX: u32,
+        pointerY: u32,
+        screenWidth: u16,
+        screenHeight: u16,
+        pressure: UnsignedFloat,
+        buttons: u32,
+    },
+    { littleEndian: false },
+);
+
+export type InjectTouchControlMessage = StructInit<
+    typeof InjectTouchControlMessage
+>;
+
+export function serializeInjectTouchControlMessage(
+    message: ScrcpyInjectTouchControlMessage,
+): Uint8Array {
+    return InjectTouchControlMessage.serialize(message);
+}

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

@@ -0,0 +1,56 @@
+import {
+    StructDeserializeStream,
+    TransformStream,
+} from "@yume-chan/stream-extra";
+import { buffer, struct, u32, u64 } from "@yume-chan/struct";
+
+import type { ScrcpyMediaStreamPacket } from "../../base/index.js";
+
+import type { Init } from "./init.js";
+
+export const MediaStreamRawPacket = struct(
+    { pts: u64, data: buffer(u32) },
+    { littleEndian: false },
+);
+
+export const PtsConfig = 1n << 63n;
+
+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(MediaStreamRawPacket);
+    return {
+        writable: deserializeStream.writable,
+        readable: deserializeStream.readable.pipeThrough(
+            new TransformStream({
+                transform(packet, controller) {
+                    if (packet.pts === PtsConfig) {
+                        controller.enqueue({
+                            type: "configuration",
+                            data: packet.data,
+                        });
+                        return;
+                    }
+
+                    controller.enqueue({
+                        type: "data",
+                        pts: packet.pts,
+                        data: packet.data,
+                    });
+                },
+            }),
+        ),
+    };
+}

package/src/1_15/impl/parse-display.ts

@@ -0,0 +1,11 @@
+import type { ScrcpyDisplay } from "../../base/index.js";
+
+export function parseDisplay(line: string): ScrcpyDisplay | undefined {
+    const match = line.match(/^\s+scrcpy --display (\d+)$/);
+    if (match) {
+        return {
+            id: Number.parseInt(match[1]!, 10),
+        };
+    }
+    return undefined;
+}

package/src/1_15/impl/parse-video-stream-metadata.ts

@@ -0,0 +1,53 @@
+import {
+    getUint16BigEndian,
+    getUint32BigEndian,
+} from "@yume-chan/no-data-view";
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import { BufferedReadableStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+import { decodeUtf8 } from "@yume-chan/struct";
+
+import type {
+    ScrcpyVideoStream,
+    ScrcpyVideoStreamMetadata,
+} from "../../base/index.js";
+import { ScrcpyVideoCodecId } from "../../base/index.js";
+
+/**
+ * Parse a fixed-length, null-terminated string.
+ * @param stream The stream to read from
+ * @param maxLength The maximum length of the string, including the null terminator, in bytes
+ * @returns The parsed string, without the null terminator
+ */
+export async function readString(
+    stream: AsyncExactReadable,
+    maxLength: number,
+): Promise<string> {
+    const buffer = await stream.readExactly(maxLength);
+    // If null terminator is not found, `subarray(0, -1)` will remove the last byte
+    // But since it's a invalid case, it's fine
+    return decodeUtf8(buffer.subarray(0, buffer.indexOf(0)));
+}
+
+export async function readU16(stream: AsyncExactReadable): Promise<number> {
+    const buffer = await stream.readExactly(2);
+    return getUint16BigEndian(buffer, 0);
+}
+
+export async function readU32(stream: AsyncExactReadable): Promise<number> {
+    const buffer = await stream.readExactly(4);
+    return getUint32BigEndian(buffer, 0);
+}
+
+export async function parseVideoStreamMetadata(
+    stream: ReadableStream<Uint8Array>,
+): Promise<ScrcpyVideoStream> {
+    const buffered = new BufferedReadableStream(stream);
+    const metadata: ScrcpyVideoStreamMetadata = {
+        codec: ScrcpyVideoCodecId.H264,
+    };
+    metadata.deviceName = await readString(buffered, 64);
+    metadata.width = await readU16(buffered);
+    metadata.height = await readU16(buffered);
+    return { stream: buffered.release(), metadata };
+}