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

package/src/2_0/impl/parse-audio-stream-metadata.ts

@@ -9,9 +9,39 @@ import type { Init } from "../../2_3/impl/init.js";
 import type { ScrcpyAudioStreamMetadata } from "../../base/index.js";
 import { ScrcpyAudioCodec } from "../../base/index.js";
 
+export function parseAudioMetadataCodec(codec: number): ScrcpyAudioCodec {
+    switch (codec) {
+        case ScrcpyAudioCodec.Raw.metadataValue:
+            return ScrcpyAudioCodec.Raw;
+        case ScrcpyAudioCodec.Opus.metadataValue:
+            return ScrcpyAudioCodec.Opus;
+        case ScrcpyAudioCodec.Aac.metadataValue:
+            return ScrcpyAudioCodec.Aac;
+        default:
+            throw new Error(`Unknown audio codec metadata value: ${codec}`);
+    }
+}
+
+export function parseAudioCodecOption(
+    audioCodec: Exclude<Init["audioCodec"], undefined>,
+): ScrcpyAudioCodec {
+    switch (audioCodec) {
+        case "raw":
+            return ScrcpyAudioCodec.Raw;
+        case "opus":
+            return ScrcpyAudioCodec.Opus;
+        case "aac":
+            return ScrcpyAudioCodec.Aac;
+        default:
+            throw new Error(`Unknown audio codec: ${audioCodec}`);
+    }
+}
+
 export async function parseAudioStreamMetadata(
     stream: ReadableStream<Uint8Array>,
-    options: Pick<Required<Init<boolean>>, "sendCodecMeta" | "audioCodec">,
+    sendCodecMeta: Exclude<Init["sendCodecMeta"], undefined>,
+    parseMetadataCodec: (codec: number) => ScrcpyAudioCodec,
+    fallbackCodec: ScrcpyAudioCodec,
 ): Promise<ScrcpyAudioStreamMetadata> {
     const buffered = new BufferedReadableStream(stream);
 
@@ -30,69 +60,25 @@ export async function parseAudioStreamMetadata(
             };
     }
 
-    if (options.sendCodecMeta) {
-        let codec: ScrcpyAudioCodec;
-        switch (codecMetadataValue) {
-            case ScrcpyAudioCodec.Raw.metadataValue:
-                codec = ScrcpyAudioCodec.Raw;
-                break;
-            case ScrcpyAudioCodec.Opus.metadataValue:
-                codec = ScrcpyAudioCodec.Opus;
-                break;
-            case ScrcpyAudioCodec.Aac.metadataValue:
-                codec = ScrcpyAudioCodec.Aac;
-                break;
-            case ScrcpyAudioCodec.Flac.metadataValue:
-                codec = ScrcpyAudioCodec.Flac;
-                break;
-            default:
-                throw new Error(
-                    `Unknown audio codec metadata value: ${codecMetadataValue}`,
-                );
-        }
+    if (sendCodecMeta) {
         return {
             type: "success",
-            codec,
+            codec: parseMetadataCodec(codecMetadataValue),
             stream: buffered.release(),
         };
     }
 
-    // Infer codec from `audioCodec` option
-    let codec: ScrcpyAudioCodec;
-    switch (options.audioCodec as string) {
-        case "raw":
-            codec = ScrcpyAudioCodec.Raw;
-            break;
-        case "opus":
-            codec = ScrcpyAudioCodec.Opus;
-            break;
-        case "aac":
-            codec = ScrcpyAudioCodec.Aac;
-            break;
-        case "flac":
-            codec = ScrcpyAudioCodec.Flac;
-            break;
-        default:
-            throw new Error(
-                `Unknown audio codec metadata value: ${codecMetadataValue}`,
-            );
-    }
-
     return {
         type: "success",
-        codec,
+        codec: fallbackCodec,
         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);
+
+            for await (const chunk of stream) {
+                await controller.enqueue(chunk);
             }
         }),
     };

package/src/2_0/impl/parse-video-stream-metadata.ts

@@ -2,50 +2,52 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { ReadableStream } from "@yume-chan/stream-extra";
 import { BufferedReadableStream } from "@yume-chan/stream-extra";
 
-import type { ScrcpyVideoStream } from "../../base/video.js";
-import { ScrcpyVideoCodecId } from "../../base/video.js";
+import type { ScrcpyVideoStream } from "../../base/index.js";
+import { ScrcpyVideoCodecId } from "../../video/index.js";
 
 import type { Init } from "./init.js";
 import { PrevImpl } from "./prev.js";
 
-function toCodecId(codec: string): ScrcpyVideoCodecId {
+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;
+            return ScrcpyVideoCodecId.Av1;
         default:
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             throw new Error(`Unknown video codec: ${codec}`);
     }
 }
 
-async function parseAsync(
-    options: Pick<
-        Required<Init>,
-        "sendDeviceMeta" | "sendCodecMeta" | "videoCodec"
-    >,
+export async function parseVideoStreamMetadataAsync(
     stream: ReadableStream<Uint8Array>,
-) {
+    sendDeviceMeta: Exclude<Init["sendDeviceMeta"], undefined>,
+    sendCodecMeta: Exclude<Init["sendCodecMeta"], undefined>,
+    fallbackCodec: ScrcpyVideoCodecId,
+): Promise<ScrcpyVideoStream> {
     const buffered = new BufferedReadableStream(stream);
 
     // `sendDeviceMeta` now only contains device name,
-    // can't use `super.parseVideoStreamMetadata` here
+    // can't use `PrevImpl.parseVideoStreamMetadata` here
     let deviceName: string | undefined;
-    if (options.sendDeviceMeta) {
+    if (sendDeviceMeta) {
         deviceName = await PrevImpl.readString(buffered, 64);
     }
 
     let codec: ScrcpyVideoCodecId;
     let width: number | undefined;
     let height: number | undefined;
-    if (options.sendCodecMeta) {
+    if (sendCodecMeta) {
         codec = (await PrevImpl.readU32(buffered)) as ScrcpyVideoCodecId;
         width = await PrevImpl.readU32(buffered);
         height = await PrevImpl.readU32(buffered);
     } else {
-        codec = toCodecId(options.videoCodec);
+        codec = fallbackCodec;
     }
 
     return {
@@ -54,19 +56,20 @@ async function parseAsync(
     };
 }
 
+// eslint-disable-next-line @typescript-eslint/max-params
 export function parseVideoStreamMetadata(
-    options: Pick<
-        Required<Init>,
-        "sendDeviceMeta" | "sendCodecMeta" | "videoCodec"
-    >,
     stream: ReadableStream<Uint8Array>,
+    sendDeviceMeta: Exclude<Init["sendDeviceMeta"], undefined>,
+    sendCodecMeta: Exclude<Init["sendCodecMeta"], undefined>,
+    fallbackCodec: ScrcpyVideoCodecId,
+    parseAsync: typeof parseVideoStreamMetadataAsync,
 ): MaybePromiseLike<ScrcpyVideoStream> {
-    if (!options.sendDeviceMeta && !options.sendCodecMeta) {
+    if (!sendDeviceMeta && !sendCodecMeta) {
         return {
             stream,
-            metadata: { codec: toCodecId(options.videoCodec) },
+            metadata: { codec: fallbackCodec },
         };
     }
 
-    return parseAsync(options, stream);
+    return parseAsync(stream, sendDeviceMeta, sendCodecMeta, fallbackCodec);
 }

package/src/2_0/options.ts

@@ -2,56 +2,70 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
 
 import type {
+    MapBoolean,
     ScrcpyAudioStreamMetadata,
-    ScrcpyControlMessageType,
     ScrcpyDisplay,
     ScrcpyEncoder,
-    ScrcpyMediaStreamPacket,
     ScrcpyOptions,
     ScrcpyOptionsListEncoders,
     ScrcpyScrollController,
     ScrcpyVideoStream,
+    ScrcpyVideoStreamPacket,
 } from "../base/index.js";
 import { ScrcpyDeviceMessageParsers } from "../base/index.js";
 import type {
     ScrcpyBackOrScreenOnControlMessage,
     ScrcpyInjectTouchControlMessage,
     ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
 } from "../latest.js";
 
-import type { Init } from "./impl/index.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,
     setListDisplays,
     setListEncoders,
 } from "./impl/index.js";
 
-export class ScrcpyOptions2_0
-    implements ScrcpyOptions<Init>, ScrcpyOptionsListEncoders
+export class ScrcpyOptions2_0<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ScrcpyOptions2_0.Value<TInit>>,
+        ScrcpyOptionsListEncoders
 {
     static readonly Defaults = Defaults;
 
-    readonly value: Required<Init>;
+    readonly value: ScrcpyOptions2_0.Value<TInit>;
 
-    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+    get controlMessageTypes(): typeof ControlMessageTypes {
         return ControlMessageTypes;
     }
 
     #clipboard: ClipboardStream | undefined;
-    get clipboard(): ReadableStream<string> | undefined {
-        return this.#clipboard;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
     }
 
     #ackClipboardHandler: AckClipboardHandler | undefined;
@@ -61,13 +75,15 @@ export class ScrcpyOptions2_0
         return this.#deviceMessageParsers;
     }
 
-    constructor(init: Init) {
-        this.value = { ...Defaults, ...init };
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
 
-        if (this.value.control && this.value.clipboardAutosync) {
-            this.#clipboard = this.#deviceMessageParsers.add(
-                new ClipboardStream(),
-            );
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+            }
 
             this.#ackClipboardHandler = this.#deviceMessageParsers.add(
                 new AckClipboardHandler(),
@@ -98,18 +114,29 @@ export class ScrcpyOptions2_0
     parseVideoStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyVideoStream> {
-        return parseVideoStreamMetadata(this.value, stream);
+        return parseVideoStreamMetadata(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendCodecMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
     }
 
     parseAudioStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
-        return parseAudioStreamMetadata(stream, this.value);
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendCodecMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
     }
 
     createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyMediaStreamPacket
+        ScrcpyVideoStreamPacket
     > {
         return createMediaStreamTransformer(this.value);
     }
@@ -117,24 +144,46 @@ export class ScrcpyOptions2_0
     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>] {
-        return this.#ackClipboardHandler!.serializeSetClipboardControlMessage(
+        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();
     }
 }
@@ -143,4 +192,9 @@ type Init_ = Init;
 
 export namespace ScrcpyOptions2_0 {
     export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
 }

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

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

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

@@ -1,6 +1,6 @@
 import type { PrevImpl } from "./prev.js";
 
-export interface Init<TVideo extends boolean> extends PrevImpl.Init {
-    video?: TVideo;
-    audioSource?: "output" | "mic";
+export interface Init extends PrevImpl.Init {
+    video?: boolean | undefined;
+    audioSource?: "output" | "mic" | undefined;
 }

package/src/2_1/options.ts

@@ -2,56 +2,70 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
 
 import type {
+    MapBoolean,
     ScrcpyAudioStreamMetadata,
-    ScrcpyControlMessageType,
     ScrcpyDisplay,
     ScrcpyEncoder,
-    ScrcpyMediaStreamPacket,
     ScrcpyOptions,
     ScrcpyOptionsListEncoders,
     ScrcpyScrollController,
     ScrcpyVideoStream,
+    ScrcpyVideoStreamPacket,
 } from "../base/index.js";
 import { ScrcpyDeviceMessageParsers } from "../base/index.js";
 import type {
     ScrcpyBackOrScreenOnControlMessage,
     ScrcpyInjectTouchControlMessage,
     ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
 } from "../latest.js";
 
-import type { Init } from "./impl/index.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,
     setListDisplays,
     setListEncoders,
 } from "./impl/index.js";
 
-export class ScrcpyOptions2_1<TVideo extends boolean>
-    implements ScrcpyOptions<Init<TVideo>>, ScrcpyOptionsListEncoders
+export class ScrcpyOptions2_1<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ScrcpyOptions2_1.Value<TInit>>,
+        ScrcpyOptionsListEncoders
 {
     static readonly Defaults = Defaults;
 
-    readonly value: Required<Init<TVideo>>;
+    readonly value: ScrcpyOptions2_1.Value<TInit>;
 
-    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+    get controlMessageTypes(): typeof ControlMessageTypes {
         return ControlMessageTypes;
     }
 
     #clipboard: ClipboardStream | undefined;
-    get clipboard(): ReadableStream<string> | undefined {
-        return this.#clipboard;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
     }
 
     #ackClipboardHandler: AckClipboardHandler | undefined;
@@ -61,13 +75,15 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
         return this.#deviceMessageParsers;
     }
 
-    constructor(init: Init<TVideo>) {
-        this.value = { ...Defaults, ...init } as never;
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
 
-        if (this.value.control && this.value.clipboardAutosync) {
-            this.#clipboard = this.#deviceMessageParsers.add(
-                new ClipboardStream(),
-            );
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+            }
 
             this.#ackClipboardHandler = this.#deviceMessageParsers.add(
                 new AckClipboardHandler(),
@@ -76,7 +92,7 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
     }
 
     serialize(): string[] {
-        return serialize<Init<boolean>>(this.value, Defaults);
+        return serialize(this.value, Defaults);
     }
 
     setListDisplays(): void {
@@ -98,18 +114,29 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
     parseVideoStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyVideoStream> {
-        return parseVideoStreamMetadata(this.value, stream);
+        return parseVideoStreamMetadata(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendCodecMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
     }
 
     parseAudioStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
-        return parseAudioStreamMetadata(stream, this.value);
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendCodecMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
     }
 
     createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyMediaStreamPacket
+        ScrcpyVideoStreamPacket
     > {
         return createMediaStreamTransformer(this.value);
     }
@@ -117,30 +144,57 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
     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>] {
-        return this.#ackClipboardHandler!.serializeSetClipboardControlMessage(
+        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();
     }
 }
 
-type Init_<TVideo extends boolean> = Init<TVideo>;
+type Init_ = Init;
 
 export namespace ScrcpyOptions2_1 {
-    export type Init<TVideo extends boolean = boolean> = Init_<TVideo>;
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
 }

package/src/2_1_1.ts

@@ -1,14 +1 @@
-import { ScrcpyOptions2_1 } from "./2_1/index.js";
-
-export class ScrcpyOptions2_1_1<
-    TVideo extends boolean,
-> extends ScrcpyOptions2_1<TVideo> {
-    constructor(init: ScrcpyOptions2_1.Init<TVideo>) {
-        super(init);
-    }
-}
-
-export namespace ScrcpyOptions2_1_1 {
-    export type Init<TVideo extends boolean = boolean> =
-        ScrcpyOptions2_1.Init<TVideo>;
-}
+export { ScrcpyOptions2_1 as ScrcpyOptions2_1_1 } from "./2_1/index.js";