@yume-chan/scrcpy 3.0.0-beta.0 → 3.0.0-beta.1

package/src/4_0/index.ts

@@ -0,0 +1,226 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyAudioStreamMetadata } from "../base/audio.js";
+import { ScrcpyDeviceMessageParsers } from "../base/device-message.js";
+import type { ScrcpyDisplay } from "../base/display.js";
+import type { ScrcpyEncoder } from "../base/encoder.js";
+import type { ScrcpyVideoStreamPacket } from "../base/media.js";
+import type {
+    MapBoolean,
+    ScrcpyOptions,
+    ScrcpyOptionsListEncoders,
+} from "../base/options.js";
+import type { ScrcpyScrollController } from "../base/scroll-controller.js";
+import type { ScrcpyVideoStream } from "../base/video.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import type { ComputeOptionTypes, Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    computeOptionValues,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoCodecOption,
+    parseVideoStreamMetadata,
+    parseVideoStreamMetadataAsync,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeSetClipboardControlMessage,
+    serializeSetDisplayPowerControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+
+export class ScrcpyOptions4_0<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ComputeOptionTypes<TInit, typeof Defaults>>,
+        ScrcpyOptionsListEncoders
+{
+    static readonly Defaults = Defaults;
+
+    readonly value: ComputeOptionTypes<TInit, typeof Defaults>;
+
+    get controlMessageTypes(): typeof ControlMessageTypes {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput(): MapBoolean<
+        this["value"]["control"],
+        ReadableStream<ScrcpyUHidOutputDeviceMessage>,
+        undefined
+    > {
+        return this.#uHidOutput as never;
+    }
+
+    #deviceMessageParsers = new ScrcpyDeviceMessageParsers();
+    get deviceMessageParsers() {
+        return this.#deviceMessageParsers;
+    }
+
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+            }
+
+            this.#ackClipboardHandler = this.#deviceMessageParsers.add(
+                new AckClipboardHandler(),
+            );
+
+            this.#uHidOutput = this.#deviceMessageParsers.add(
+                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(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendStreamMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendStreamMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetClipboardControlMessage(
+            message,
+            this.#ackClipboardHandler,
+        );
+    }
+
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetDisplayPowerControlMessage(message);
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return createScrollController();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions4_0 {
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
+}

package/src/4_1/impl/control-message-types.ts

@@ -0,0 +1,28 @@
+import type { ScrcpyControlMessageTypeMap } from "../../base/index.js";
+import { ScrcpyControlMessageType } from "../../base/index.js";
+
+export const ControlMessageTypes = {
+    [ScrcpyControlMessageType.InjectKeyCode]: 0,
+    [ScrcpyControlMessageType.InjectText]: 1,
+    [ScrcpyControlMessageType.InjectTouch]: 2,
+    [ScrcpyControlMessageType.InjectScroll]: 3,
+    [ScrcpyControlMessageType.BackOrScreenOn]: 4,
+    [ScrcpyControlMessageType.ExpandNotificationPanel]: 5,
+    [ScrcpyControlMessageType.ExpandSettingPanel]: 6,
+    [ScrcpyControlMessageType.CollapseNotificationPanel]: 7,
+    [ScrcpyControlMessageType.GetClipboard]: 8,
+    [ScrcpyControlMessageType.SetClipboard]: 9,
+    [ScrcpyControlMessageType.SetDisplayPower]: 10,
+    [ScrcpyControlMessageType.RotateDevice]: 11,
+    [ScrcpyControlMessageType.UHidCreate]: 12,
+    [ScrcpyControlMessageType.UHidInput]: 13,
+    [ScrcpyControlMessageType.UHidDestroy]: 14,
+    [ScrcpyControlMessageType.OpenHardKeyboardSettings]: 15,
+    [ScrcpyControlMessageType.StartApp]: 16,
+    [ScrcpyControlMessageType.ResetVideo]: 17,
+    [ScrcpyControlMessageType.CameraSetTorch]: 18,
+    [ScrcpyControlMessageType.CameraZoomIn]: 19,
+    [ScrcpyControlMessageType.CameraZoomOut]: 20,
+    [ScrcpyControlMessageType.ResizeDisplay]: 21,
+    [ScrcpyControlMessageType.ScanFile]: 22,
+} as const satisfies ScrcpyControlMessageTypeMap;

package/src/4_1/impl/defaults.ts

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

package/src/4_1/impl/index.ts

@@ -0,0 +1,6 @@
+export * from "../../4_0/impl/index.js";
+
+export { ControlMessageTypes } from "./control-message-types.js";
+export { Defaults } from "./defaults.js";
+export type { Init } from "./init.js";
+export { parseVideoCodecOption } from "./parse-video-stream-metadata.js";

package/src/4_1/impl/init.ts

@@ -0,0 +1,7 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends Omit<PrevImpl.Init, "videoCodec"> {
+    videoCodec: PrevImpl.Init["videoCodec"] | "vp8" | "vp9";
+
+    ignoreVideoEncoderConstraints?: boolean | undefined;
+}

package/src/4_1/impl/parse-video-stream-metadata.ts

@@ -0,0 +1,23 @@
+import { ScrcpyVideoCodecId } from "../../video/index.js";
+
+import type { Init } from "./init.js";
+
+export function parseVideoCodecOption(
+    codec: Exclude<Init["videoCodec"], undefined>,
+): ScrcpyVideoCodecId {
+    switch (codec) {
+        case "h264":
+            return ScrcpyVideoCodecId.H264;
+        case "h265":
+            return ScrcpyVideoCodecId.H265;
+        case "av1":
+            return ScrcpyVideoCodecId.Av1;
+        case "vp8":
+            return ScrcpyVideoCodecId.Vp8;
+        case "vp9":
+            return ScrcpyVideoCodecId.Vp9;
+        default:
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            throw new Error(`Unknown video codec: ${codec}`);
+    }
+}

package/src/4_1/impl/prev.ts

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

package/src/4_1/index.ts

@@ -0,0 +1,226 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyAudioStreamMetadata } from "../base/audio.js";
+import { ScrcpyDeviceMessageParsers } from "../base/device-message.js";
+import type { ScrcpyDisplay } from "../base/display.js";
+import type { ScrcpyEncoder } from "../base/encoder.js";
+import type { ScrcpyVideoStreamPacket } from "../base/media.js";
+import type {
+    MapBoolean,
+    ScrcpyOptions,
+    ScrcpyOptionsListEncoders,
+} from "../base/options.js";
+import type { ScrcpyScrollController } from "../base/scroll-controller.js";
+import type { ScrcpyVideoStream } from "../base/video.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import type { ComputeOptionTypes, Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    computeOptionValues,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoCodecOption,
+    parseVideoStreamMetadata,
+    parseVideoStreamMetadataAsync,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeSetClipboardControlMessage,
+    serializeSetDisplayPowerControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+
+export class ScrcpyOptions4_1<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ComputeOptionTypes<TInit, typeof Defaults>>,
+        ScrcpyOptionsListEncoders
+{
+    static readonly Defaults = Defaults;
+
+    readonly value: ComputeOptionTypes<TInit, typeof Defaults>;
+
+    get controlMessageTypes(): typeof ControlMessageTypes {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput(): MapBoolean<
+        this["value"]["control"],
+        ReadableStream<ScrcpyUHidOutputDeviceMessage>,
+        undefined
+    > {
+        return this.#uHidOutput as never;
+    }
+
+    #deviceMessageParsers = new ScrcpyDeviceMessageParsers();
+    get deviceMessageParsers() {
+        return this.#deviceMessageParsers;
+    }
+
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+            }
+
+            this.#ackClipboardHandler = this.#deviceMessageParsers.add(
+                new AckClipboardHandler(),
+            );
+
+            this.#uHidOutput = this.#deviceMessageParsers.add(
+                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(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendStreamMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendStreamMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetClipboardControlMessage(
+            message,
+            this.#ackClipboardHandler,
+        );
+    }
+
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetDisplayPowerControlMessage(message);
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return createScrollController();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions4_1 {
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
+}

package/src/base/control-message-type-value.ts

@@ -16,3 +16,8 @@ export const UHidDestroy = 14;
 export const OpenHardKeyboardSettings = 15;
 export const StartApp = 16;
 export const ResetVideo = 17;
+export const CameraSetTorch = 18;
+export const CameraZoomIn = 19;
+export const CameraZoomOut = 20;
+export const ResizeDisplay = 21;
+export const ScanFile = 22;

package/src/base/media.ts

@@ -10,6 +10,15 @@ export interface ScrcpyMediaStreamDataPacket {
     data: Uint8Array;
 }
 
-export type ScrcpyMediaStreamPacket =
-    | ScrcpyMediaStreamConfigurationPacket
-    | ScrcpyMediaStreamDataPacket;
+export interface ScrcpyVideoStreamSessionPacket {
+    type: "session";
+    isClientResize: boolean;
+    width: number;
+    height: number;
+}
+
+export type ScrcpyAudioStreamPacket =
+    ScrcpyMediaStreamConfigurationPacket | ScrcpyMediaStreamDataPacket;
+
+export type ScrcpyVideoStreamPacket =
+    ScrcpyAudioStreamPacket | ScrcpyVideoStreamSessionPacket;

package/src/base/options.ts

@@ -5,6 +5,7 @@ import type {
     ScrcpyBackOrScreenOnControlMessage,
     ScrcpyInjectTouchControlMessage,
     ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
     ScrcpyUHidCreateControlMessage,
     ScrcpyUHidOutputDeviceMessage,
 } from "../latest.js";
@@ -14,7 +15,7 @@ import type { ScrcpyControlMessageType } from "./control-message-type.js";
 import type { ScrcpyDeviceMessageParsers } from "./device-message.js";
 import type { ScrcpyDisplay } from "./display.js";
 import type { ScrcpyEncoder } from "./encoder.js";
-import type { ScrcpyMediaStreamPacket } from "./media.js";
+import type { ScrcpyVideoStreamPacket } from "./media.js";
 import type { ScrcpyScrollController } from "./scroll-controller.js";
 import type { ScrcpyVideoStream } from "./video.js";
 
@@ -22,16 +23,21 @@ export type ScrcpyControlMessageTypeMap = Partial<
     Record<ScrcpyControlMessageType, number>
 >;
 
+// Distributive Conditional Types
+// (https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types)
+export type MapBoolean<T extends boolean, TTrue, TFalse> = T extends true
+    ? TTrue
+    : TFalse;
+
 export interface ScrcpyOptions<T extends object> {
     get controlMessageTypes(): ScrcpyControlMessageTypeMap;
 
-    value: Required<T>;
+    value: T;
 
     readonly clipboard?: ReadableStream<string> | undefined;
 
     readonly uHidOutput?:
-        | ReadableStream<ScrcpyUHidOutputDeviceMessage>
-        | undefined;
+        ReadableStream<ScrcpyUHidOutputDeviceMessage> | undefined;
 
     readonly deviceMessageParsers: ScrcpyDeviceMessageParsers;
 
@@ -51,7 +57,7 @@ export interface ScrcpyOptions<T extends object> {
 
     createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyMediaStreamPacket
+        ScrcpyVideoStreamPacket
     >;
 
     serializeInjectTouchControlMessage(
@@ -66,6 +72,10 @@ export interface ScrcpyOptions<T extends object> {
         message: ScrcpySetClipboardControlMessage,
     ): Uint8Array | [Uint8Array, Promise<void>];
 
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array;
+
     createScrollController(): ScrcpyScrollController;
 
     serializeUHidCreateControlMessage?(

package/src/base/video.ts

@@ -1,5 +1,7 @@
 import type { ReadableStream } from "@yume-chan/stream-extra";
 
+import type { ScrcpyVideoCodecId } from "../video/index.js";
+
 export interface ScrcpyVideoStream {
     readonly stream: ReadableStream<Uint8Array>;
     readonly metadata: ScrcpyVideoStreamMetadata;
@@ -11,22 +13,3 @@ export interface ScrcpyVideoStreamMetadata {
     height?: number | undefined;
     codec: ScrcpyVideoCodecId;
 }
-
-export const ScrcpyVideoCodecId = {
-    H264: 0x68_32_36_34,
-    H265: 0x68_32_36_35,
-    AV1: 0x00_61_76_31,
-} as const;
-
-export type ScrcpyVideoCodecId =
-    (typeof ScrcpyVideoCodecId)[keyof typeof ScrcpyVideoCodecId];
-
-export const ScrcpyVideoCodecNameMap = /* #__PURE__ */ (() => {
-    const result = new Map<number, string>();
-    for (const key in ScrcpyVideoCodecId) {
-        const value =
-            ScrcpyVideoCodecId[key as keyof typeof ScrcpyVideoCodecId];
-        result.set(value, key);
-    }
-    return result;
-})();

package/src/control/boolean.ts

@@ -0,0 +1,9 @@
+import type { StructInit } from "@yume-chan/struct";
+import { struct, u8 } from "@yume-chan/struct";
+
+export const BooleanControlMessage = struct(
+    { type: u8, value: u8<boolean>() },
+    { littleEndian: false },
+);
+
+export type BooleanControlMessage = StructInit<typeof BooleanControlMessage>;

package/src/control/index.ts

@@ -1,6 +1,7 @@
+export * from "./boolean.js";
 export * from "./empty.js";
 export * from "./inject-key-code.js";
 export * from "./inject-text.js";
+export * from "./resize-display.js";
 export * from "./serializer.js";
-export * from "./set-screen-power-mode.js";
 export * from "./writer.js";

package/src/control/resize-display.ts

@@ -0,0 +1,16 @@
+import type { StructInit } from "@yume-chan/struct";
+import { struct, u16, u8 } from "@yume-chan/struct";
+
+export const ScrcpyResizeDisplayControlMessage = struct(
+    {
+        // value of `type` can change between versions
+        type: u8,
+        width: u16,
+        height: u16,
+    },
+    { littleEndian: false },
+);
+
+export type ScrcpyResizeDisplayControlMessage = StructInit<
+    typeof ScrcpyResizeDisplayControlMessage
+>;