@yume-chan/scrcpy 0.0.23 → 0.0.24

package/src/options/2_0.ts

@@ -1,10 +1,11 @@
+import { getUint32BigEndian } from "@yume-chan/no-data-view";
 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 Struct, { placeholder } from "@yume-chan/struct";
 
 import type {
     AndroidMotionEventAction,
@@ -13,8 +14,8 @@ import type {
 
 import {
     CodecOptions,
-    ScrcpyFloatToUint16FieldDefinition,
     ScrcpyOptions1_16,
+    ScrcpyUnsignedFloatFieldDefinition,
 } from "./1_16/index.js";
 import { ScrcpyOptions1_21 } from "./1_21.js";
 import type { ScrcpyOptionsInit1_24 } from "./1_24.js";
@@ -27,7 +28,7 @@ import type {
     ScrcpyEncoder,
     ScrcpyOptionValue,
 } from "./types.js";
-import { ScrcpyOptionsBase } from "./types.js";
+import { ScrcpyOptions } from "./types.js";
 
 export const ScrcpyInjectTouchControlMessage2_0 = new Struct()
     .uint8("type")
@@ -37,7 +38,7 @@ export const ScrcpyInjectTouchControlMessage2_0 = new Struct()
     .uint32("pointerY")
     .uint16("screenWidth")
     .uint16("screenHeight")
-    .field("pressure", ScrcpyFloatToUint16FieldDefinition)
+    .field("pressure", ScrcpyUnsignedFloatFieldDefinition)
     .uint32("actionButton")
     .uint32("buttons");
 
@@ -76,20 +77,20 @@ export interface ScrcpyOptionsInit2_0
     videoCodec?: "h264" | "h265" | "av1";
     videoBitRate?: number;
     videoCodecOptions?: CodecOptions;
-    videoEncoder?: string;
+    videoEncoder?: string | undefined;
 
     audio?: boolean;
-    audioCodec?: "opus" | "aac" | "raw";
+    audioCodec?: "raw" | "opus" | "aac";
     audioBitRate?: number;
     audioCodecOptions?: CodecOptions;
-    audioEncoder?: string;
+    audioEncoder?: string | undefined;
 
     listEncoders?: boolean;
     listDisplays?: boolean;
     sendCodecMeta?: boolean;
 }
 
-function omit<T extends object, K extends keyof T>(
+export function omit<T extends object, K extends keyof T>(
     obj: T,
     keys: K[],
 ): Omit<T, K> {
@@ -102,10 +103,59 @@ function omit<T extends object, K extends keyof T>(
     return result as Omit<T, K>;
 }
 
-export class ScrcpyOptions2_0 extends ScrcpyOptionsBase<
-    ScrcpyOptionsInit2_0,
-    ScrcpyOptions1_25
-> {
+export class ScrcpyOptions2_0 extends ScrcpyOptions<ScrcpyOptionsInit2_0> {
+    static async parseAudioMetadata(
+        stream: ReadableStream<Uint8Array>,
+        sendCodecMeta: boolean,
+        mapMetadata: (value: number) => ScrcpyAudioCodec,
+        getOptionCodec: () => ScrcpyAudioCodec,
+    ): Promise<ScrcpyAudioStreamMetadata> {
+        const buffered = new BufferedReadableStream(stream);
+
+        const buffer = await buffered.readExactly(4);
+        // Treat it as a 32-bit number for simpler comparisons
+        const codecMetadataValue = getUint32BigEndian(buffer, 0);
+        // 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 (sendCodecMeta) {
+            return {
+                type: "success",
+                codec: mapMetadata(codecMetadataValue),
+                stream: buffered.release(),
+            };
+        }
+
+        return {
+            type: "success",
+            // Infer codec from `audioCodec` option
+            codec: getOptionCodec(),
+            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);
+                }
+            }),
+        };
+    }
+
     static readonly DEFAULTS = {
         ...omit(ScrcpyOptions1_24.DEFAULTS, [
             "bitRate",
@@ -117,13 +167,13 @@ export class ScrcpyOptions2_0 extends ScrcpyOptionsBase<
         videoCodec: "h264",
         videoBitRate: 8000000,
         videoCodecOptions: new CodecOptions(),
-        videoEncoder: "",
+        videoEncoder: undefined,
 
         audio: true,
         audioCodec: "opus",
         audioBitRate: 128000,
         audioCodecOptions: new CodecOptions(),
-        audioEncoder: "",
+        audioEncoder: undefined,
 
         listEncoders: false,
         listDisplays: false,
@@ -135,10 +185,7 @@ export class ScrcpyOptions2_0 extends ScrcpyOptionsBase<
     }
 
     constructor(init: ScrcpyOptionsInit2_0) {
-        super(new ScrcpyOptions1_25(init), {
-            ...ScrcpyOptions2_0.DEFAULTS,
-            ...init,
-        });
+        super(ScrcpyOptions1_25, init, ScrcpyOptions2_0.DEFAULTS);
     }
 
     override serialize(): string[] {
@@ -254,86 +301,34 @@ export class ScrcpyOptions2_0 extends ScrcpyOptionsBase<
     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) {
+        return ScrcpyOptions2_0.parseAudioMetadata(
+            stream,
+            this.value.sendCodecMeta,
+            (value) => {
+                switch (value) {
+                    case ScrcpyAudioCodec.RAW.metadataValue:
+                        return ScrcpyAudioCodec.RAW;
                     case ScrcpyAudioCodec.OPUS.metadataValue:
-                        codec = ScrcpyAudioCodec.OPUS;
-                        break;
+                        return ScrcpyAudioCodec.OPUS;
                     case ScrcpyAudioCodec.AAC.metadataValue:
-                        codec = ScrcpyAudioCodec.AAC;
-                        break;
-                    case ScrcpyAudioCodec.RAW.metadataValue:
-                        codec = ScrcpyAudioCodec.RAW;
-                        break;
+                        return ScrcpyAudioCodec.AAC;
                     default:
                         throw new Error(
-                            `Unknown audio codec metadata value: ${codecMetadataValue}`,
+                            `Unknown audio codec metadata value: ${value}`,
                         );
                 }
-                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);
-                        }
-                    },
-                ),
-            };
-        })();
+            },
+            () => {
+                switch (this.value.audioCodec) {
+                    case "raw":
+                        return ScrcpyAudioCodec.RAW;
+                    case "opus":
+                        return ScrcpyAudioCodec.OPUS;
+                    case "aac":
+                        return ScrcpyAudioCodec.AAC;
+                }
+            },
+        );
     }
 
     override serializeInjectTouchControlMessage(

package/src/options/2_1.ts

@@ -1,17 +1,14 @@
 import { ScrcpyOptions1_21 } from "./1_21.js";
 import type { ScrcpyOptionsInit2_0 } from "./2_0.js";
 import { ScrcpyOptions2_0 } from "./2_0.js";
-import { ScrcpyOptionsBase } from "./types.js";
+import { ScrcpyOptions } from "./types.js";
 
 export interface ScrcpyOptionsInit2_1 extends ScrcpyOptionsInit2_0 {
     video?: boolean;
     audioSource?: "output" | "mic";
 }
 
-export class ScrcpyOptions2_1 extends ScrcpyOptionsBase<
-    ScrcpyOptionsInit2_1,
-    ScrcpyOptions2_0
-> {
+export class ScrcpyOptions2_1 extends ScrcpyOptions<ScrcpyOptionsInit2_1> {
     static readonly DEFAULTS = {
         ...ScrcpyOptions2_0.DEFAULTS,
         video: true,
@@ -23,10 +20,7 @@ export class ScrcpyOptions2_1 extends ScrcpyOptionsBase<
     }
 
     constructor(init: ScrcpyOptionsInit2_1) {
-        super(new ScrcpyOptions2_0(init), {
-            ...ScrcpyOptions2_1.DEFAULTS,
-            ...init,
-        });
+        super(ScrcpyOptions2_0, init, ScrcpyOptions2_1.DEFAULTS);
     }
 
     override serialize(): string[] {

package/src/options/2_2.ts

@@ -2,7 +2,7 @@ import { ScrcpyOptions1_21 } from "./1_21.js";
 import type { ScrcpyOptionsInit2_1 } from "./2_1.js";
 import { ScrcpyOptions2_1 } from "./2_1.js";
 import type { ScrcpyDisplay } from "./types.js";
-import { ScrcpyOptionsBase } from "./types.js";
+import { ScrcpyOptions } from "./types.js";
 
 export interface ScrcpyOptionsInit2_2
     extends Omit<ScrcpyOptionsInit2_1, "display"> {
@@ -19,10 +19,7 @@ export interface ScrcpyOptionsInit2_2
     listCameraSizes?: boolean;
 }
 
-export class ScrcpyOptions2_2 extends ScrcpyOptionsBase<
-    ScrcpyOptionsInit2_2,
-    ScrcpyOptions2_1
-> {
+export class ScrcpyOptions2_2 extends ScrcpyOptions<ScrcpyOptionsInit2_2> {
     static readonly DEFAULTS = {
         ...ScrcpyOptions2_1.DEFAULTS,
         videoSource: "display",
@@ -42,10 +39,7 @@ export class ScrcpyOptions2_2 extends ScrcpyOptionsBase<
     }
 
     constructor(init: ScrcpyOptionsInit2_2) {
-        super(new ScrcpyOptions2_1(init), {
-            ...ScrcpyOptions2_2.DEFAULTS,
-            ...init,
-        });
+        super(ScrcpyOptions2_1, init, ScrcpyOptions2_2.DEFAULTS);
     }
 
     override parseDisplay(line: string): ScrcpyDisplay | undefined {

package/src/options/2_3.ts

@@ -0,0 +1,70 @@
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
+
+import { ScrcpyOptions1_21 } from "./1_21.js";
+import { ScrcpyOptions2_0 } from "./2_0.js";
+import type { ScrcpyOptionsInit2_2 } from "./2_2.js";
+import { ScrcpyOptions2_2 } from "./2_2.js";
+import type { ScrcpyAudioStreamMetadata } from "./codec.js";
+import { ScrcpyAudioCodec } from "./codec.js";
+import { ScrcpyOptions } from "./types.js";
+
+export interface ScrcpyOptionsInit2_3
+    extends Omit<ScrcpyOptionsInit2_2, "audioCodec"> {
+    audioCodec?: "raw" | "opus" | "aac" | "flac";
+}
+
+export class ScrcpyOptions2_3 extends ScrcpyOptions<ScrcpyOptionsInit2_3> {
+    static readonly DEFAULTS = {
+        ...ScrcpyOptions2_2.DEFAULTS,
+    } as const satisfies Required<ScrcpyOptionsInit2_3>;
+
+    override get defaults(): Required<ScrcpyOptionsInit2_3> {
+        return ScrcpyOptions2_3.DEFAULTS;
+    }
+
+    constructor(init: ScrcpyOptionsInit2_3) {
+        super(ScrcpyOptions2_2, init, ScrcpyOptions2_3.DEFAULTS);
+    }
+
+    override serialize(): string[] {
+        return ScrcpyOptions1_21.serialize(this.value, this.defaults);
+    }
+
+    override parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): ValueOrPromise<ScrcpyAudioStreamMetadata> {
+        return ScrcpyOptions2_0.parseAudioMetadata(
+            stream,
+            this.value.sendCodecMeta,
+            (value) => {
+                switch (value) {
+                    case ScrcpyAudioCodec.RAW.metadataValue:
+                        return ScrcpyAudioCodec.RAW;
+                    case ScrcpyAudioCodec.OPUS.metadataValue:
+                        return ScrcpyAudioCodec.OPUS;
+                    case ScrcpyAudioCodec.AAC.metadataValue:
+                        return ScrcpyAudioCodec.AAC;
+                    case ScrcpyAudioCodec.FLAC.metadataValue:
+                        return ScrcpyAudioCodec.FLAC;
+                    default:
+                        throw new Error(
+                            `Unknown audio codec metadata value: ${value}`,
+                        );
+                }
+            },
+            () => {
+                switch (this.value.audioCodec) {
+                    case "raw":
+                        return ScrcpyAudioCodec.RAW;
+                    case "opus":
+                        return ScrcpyAudioCodec.OPUS;
+                    case "aac":
+                        return ScrcpyAudioCodec.AAC;
+                    case "flac":
+                        return ScrcpyAudioCodec.FLAC;
+                }
+            },
+        );
+    }
+}

package/src/options/codec.ts

@@ -33,6 +33,12 @@ export class ScrcpyAudioCodec implements ScrcpyOptionValue {
         "audio/aac",
         "mp4a.66",
     );
+    static readonly FLAC = new ScrcpyAudioCodec(
+        "flac",
+        0x66_6c_61_63,
+        "audio/flac",
+        "flac",
+    );
     static readonly RAW = new ScrcpyAudioCodec(
         "raw",
         0x00_72_61_77,

package/src/options/index.ts

@@ -9,6 +9,7 @@ export * from "./1_25/index.js";
 export * from "./2_0.js";
 export * from "./2_1.js";
 export * from "./2_2.js";
+export * from "./2_3.js";
 export * from "./codec.js";
 export * from "./latest.js";
 export * from "./types.js";

package/src/options/latest.ts

@@ -1,6 +1,6 @@
 import { ScrcpyLogLevel1_18, ScrcpyVideoOrientation1_18 } from "./1_18.js";
-import type { ScrcpyOptionsInit2_2 } from "./2_2.js";
-import { ScrcpyOptions2_2 } from "./2_2.js";
+import type { ScrcpyOptionsInit2_3 } from "./2_3.js";
+import { ScrcpyOptions2_3 } from "./2_3.js";
 
 export const ScrcpyLogLevel = ScrcpyLogLevel1_18;
 export type ScrcpyLogLevel = ScrcpyLogLevel1_18;
@@ -8,5 +8,5 @@ export type ScrcpyLogLevel = ScrcpyLogLevel1_18;
 export const ScrcpyVideoOrientation = ScrcpyVideoOrientation1_18;
 export type ScrcpyVideoOrientation = ScrcpyVideoOrientation1_18;
 
-export type ScrcpyOptionsInitLatest = ScrcpyOptionsInit2_2;
-export class ScrcpyOptionsLatest extends ScrcpyOptions2_2 {}
+export type ScrcpyOptionsInitLatest = ScrcpyOptionsInit2_3;
+export class ScrcpyOptionsLatest extends ScrcpyOptions2_3 {}