@yume-chan/scrcpy 0.0.23 → 1.0.0

package/src/codec/h264.ts

@@ -5,40 +5,40 @@
 import { NaluSodbBitReader, annexBSplitNalu } from "./nalu.js";
 
 // From https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
-export enum AndroidAvcProfile {
-    Baseline = 1 << 0,
-    Main = 1 << 1,
-    Extended = 1 << 2,
-    High = 1 << 3,
-    High10 = 1 << 4,
-    High422 = 1 << 5,
-    High444 = 1 << 6,
-    ConstrainedBaseline = 1 << 16,
-    ConstrainedHigh = 1 << 19,
-}
-
-export enum AndroidAvcLevel {
-    Level1 = 1 << 0,
-    Level1b = 1 << 1,
-    Level11 = 1 << 2,
-    Level12 = 1 << 3,
-    Level13 = 1 << 4,
-    Level2 = 1 << 5,
-    Level21 = 1 << 6,
-    Level22 = 1 << 7,
-    Level3 = 1 << 8,
-    Level31 = 1 << 9,
-    Level32 = 1 << 10,
-    Level4 = 1 << 11,
-    Level41 = 1 << 12,
-    Level42 = 1 << 13,
-    Level5 = 1 << 14,
-    Level51 = 1 << 15,
-    Level52 = 1 << 16,
-    Level6 = 1 << 17,
-    Level61 = 1 << 18,
-    Level62 = 1 << 19,
-}
+export const AndroidAvcProfile = {
+    Baseline: 1 << 0,
+    Main: 1 << 1,
+    Extended: 1 << 2,
+    High: 1 << 3,
+    High10: 1 << 4,
+    High422: 1 << 5,
+    High444: 1 << 6,
+    ConstrainedBaseline: 1 << 16,
+    ConstrainedHigh: 1 << 19,
+};
+
+export const AndroidAvcLevel = {
+    Level1: 1 << 0,
+    Level1b: 1 << 1,
+    Level11: 1 << 2,
+    Level12: 1 << 3,
+    Level13: 1 << 4,
+    Level2: 1 << 5,
+    Level21: 1 << 6,
+    Level22: 1 << 7,
+    Level3: 1 << 8,
+    Level31: 1 << 9,
+    Level32: 1 << 10,
+    Level4: 1 << 11,
+    Level41: 1 << 12,
+    Level42: 1 << 13,
+    Level5: 1 << 14,
+    Level51: 1 << 15,
+    Level52: 1 << 16,
+    Level6: 1 << 17,
+    Level61: 1 << 18,
+    Level62: 1 << 19,
+};
 
 // H.264 has two standards: ITU-T H.264 and ISO/IEC 14496-10
 // they have the same content, and refer themselves as "H.264".

package/src/codec/h265.ts

@@ -20,42 +20,42 @@
 
 import { NaluSodbBitReader, annexBSplitNalu } from "./nalu.js";
 
-export enum AndroidHevcProfile {
-    Main = 1 << 0,
-    Main10 = 1 << 1,
-    MainStill = 1 << 2,
-    Main10Hdr10 = 1 << 12,
-    Main10Hdr10Plus = 1 << 13,
-}
-
-export enum AndroidHevcLevel {
-    MainTierLevel1 = 1 << 0,
-    HighTierLevel1 = 1 << 1,
-    MainTierLevel2 = 1 << 2,
-    HighTierLevel2 = 1 << 3,
-    MainTierLevel21 = 1 << 4,
-    HighTierLevel21 = 1 << 5,
-    MainTierLevel3 = 1 << 6,
-    HighTierLevel3 = 1 << 7,
-    MainTierLevel31 = 1 << 8,
-    HighTierLevel31 = 1 << 9,
-    MainTierLevel4 = 1 << 10,
-    HighTierLevel4 = 1 << 11,
-    MainTierLevel41 = 1 << 12,
-    HighTierLevel41 = 1 << 13,
-    MainTierLevel5 = 1 << 14,
-    HighTierLevel5 = 1 << 15,
-    MainTierLevel51 = 1 << 16,
-    HighTierLevel51 = 1 << 17,
-    MainTierLevel52 = 1 << 18,
-    HighTierLevel52 = 1 << 19,
-    MainTierLevel6 = 1 << 20,
-    HighTierLevel6 = 1 << 21,
-    MainTierLevel61 = 1 << 22,
-    HighTierLevel61 = 1 << 23,
-    MainTierLevel62 = 1 << 24,
-    HighTierLevel62 = 1 << 25,
-}
+export const AndroidHevcProfile = {
+    Main: 1 << 0,
+    Main10: 1 << 1,
+    MainStill: 1 << 2,
+    Main10Hdr10: 1 << 12,
+    Main10Hdr10Plus: 1 << 13,
+};
+
+export const AndroidHevcLevel = {
+    MainTierLevel1: 1 << 0,
+    HighTierLevel1: 1 << 1,
+    MainTierLevel2: 1 << 2,
+    HighTierLevel2: 1 << 3,
+    MainTierLevel21: 1 << 4,
+    HighTierLevel21: 1 << 5,
+    MainTierLevel3: 1 << 6,
+    HighTierLevel3: 1 << 7,
+    MainTierLevel31: 1 << 8,
+    HighTierLevel31: 1 << 9,
+    MainTierLevel4: 1 << 10,
+    HighTierLevel4: 1 << 11,
+    MainTierLevel41: 1 << 12,
+    HighTierLevel41: 1 << 13,
+    MainTierLevel5: 1 << 14,
+    HighTierLevel5: 1 << 15,
+    MainTierLevel51: 1 << 16,
+    HighTierLevel51: 1 << 17,
+    MainTierLevel52: 1 << 18,
+    HighTierLevel52: 1 << 19,
+    MainTierLevel6: 1 << 20,
+    HighTierLevel6: 1 << 21,
+    MainTierLevel61: 1 << 22,
+    HighTierLevel61: 1 << 23,
+    MainTierLevel62: 1 << 24,
+    HighTierLevel62: 1 << 25,
+};
 
 /**
  * 6.2 Source, decoded and output picture formats

package/src/codec/nalu.ts

@@ -91,153 +91,17 @@ export function* annexBSplitNalu(buffer: Uint8Array): Generator<Uint8Array> {
     yield buffer.subarray(start, buffer.length);
 }
 
-/**
- * Remove emulation prevention bytes from a H.264/H.265 NAL Unit.
- *
- * The input is not modified.
- * If the input doesn't contain any emulation prevention bytes,
- * the input is returned as-is.
- * Otherwise, a new `Uint8Array` is created and returned.
- */
-export function naluRemoveEmulation(buffer: Uint8Array) {
-    // output will be created when first emulation prevention byte is found
-    let output: Uint8Array | undefined;
-    let outputOffset = 0;
-
-    let zeroCount = 0;
-    let inEmulation = false;
-
-    let i = 0;
-    scan: for (; i < buffer.length; i += 1) {
-        const byte = buffer[i]!;
-
-        if (byte === 0x00) {
-            zeroCount += 1;
-            continue;
-        }
-
-        // Current byte is not zero
-        const prevZeroCount = zeroCount;
-        zeroCount = 0;
-
-        if (prevZeroCount < 2) {
-            // zero or one `0x00`s are acceptable
-            continue;
-        }
-
-        if (byte === 0x01) {
-            // Unexpected start code
-            throw new Error("Invalid data");
-        }
-
-        if (prevZeroCount > 2) {
-            // Too much `0x00`s
-            throw new Error("Invalid data");
-        }
-
-        switch (byte) {
-            case 0x02:
-                // Didn't find why, but 7.4.1 NAL unit semantics forbids `0x000002` appearing in NAL units
-                throw new Error("Invalid data");
-            case 0x03:
-                // `0x000003` is the "emulation_prevention_three_byte"
-                // `0x00000300`, `0x00000301`, `0x00000302` and `0x00000303` represent
-                // `0x000000`, `0x000001`, `0x000002` and `0x000003` respectively
-                inEmulation = true;
-
-                // Create output and copy the data before the emulation prevention byte
-                // Output size is unknown, so we use the input size as an upper bound
-                output = new Uint8Array(buffer.length - 1);
-                output.set(buffer.subarray(0, i));
-                outputOffset = i;
-                i += 1;
-                break scan;
-            default:
-                // `0x000004` or larger are as-is
-                break;
-        }
-    }
-
-    if (!output) {
-        return buffer;
-    }
-
-    // Continue at the byte after the emulation prevention byte
-    for (; i < buffer.length; i += 1) {
-        const byte = buffer[i]!;
-
-        output[outputOffset] = byte;
-        outputOffset += 1;
-
-        if (inEmulation) {
-            if (byte > 0x03) {
-                // `0x00000304` or larger are invalid
-                throw new Error("Invalid data");
-            }
-
-            // `00000300000300` results in `0000000000` (both `0x03` are removed)
-            // which means the `0x00` after `0x03` also counts
-            if (byte === 0x00) {
-                zeroCount += 1;
-            }
-
-            inEmulation = false;
-            continue;
-        }
-
-        if (byte === 0x00) {
-            zeroCount += 1;
-            continue;
-        }
-
-        const prevZeroCount = zeroCount;
-        zeroCount = 0;
-
-        if (prevZeroCount < 2) {
-            // zero or one `0x00`s are acceptable
-            continue;
-        }
-
-        if (byte === 0x01) {
-            // Unexpected start code
-            throw new Error("Invalid data");
-        }
-
-        if (prevZeroCount > 2) {
-            // Too much `0x00`s
-            throw new Error("Invalid data");
-        }
-
-        switch (byte) {
-            case 0x02:
-                // Didn't find why, but 7.4.1 NAL unit semantics forbids `0x000002` appearing in NAL units
-                throw new Error("Invalid data");
-            case 0x03:
-                // `0x000003` is the "emulation_prevention_three_byte"
-                // `0x00000300`, `0x00000301`, `0x00000302` and `0x00000303` represent
-                // `0x000000`, `0x000001`, `0x000002` and `0x000003` respectively
-                inEmulation = true;
-
-                // Remove the emulation prevention byte
-                outputOffset -= 1;
-                break;
-            default:
-                // `0x000004` or larger are as-is
-                break;
-        }
-    }
-
-    return output.subarray(0, outputOffset);
-}
-
 export class NaluSodbBitReader {
     readonly #nalu: Uint8Array;
+    // logical length is `#byteLength * 8 + (7 - #stopBitIndex)`
     readonly #byteLength: number;
     readonly #stopBitIndex: number;
 
     #zeroCount = 0;
-    #bytePosition = -1;
-    #bitPosition = -1;
+
+    // logical position is `#bytePosition * 8 + (7 - #bitPosition)`
+    #bytePosition = 0;
+    #bitPosition = 7;
     #byte = 0;
 
     get byteLength() {
@@ -258,14 +122,15 @@ export class NaluSodbBitReader {
 
     get ended() {
         return (
-            this.#bytePosition === this.#byteLength &&
-            this.#bitPosition === this.#stopBitIndex
+            this.#bytePosition >= this.#byteLength &&
+            this.#bitPosition <= this.#stopBitIndex
         );
     }
 
     constructor(nalu: Uint8Array) {
         this.#nalu = nalu;
 
+        // Search for the last bit being `1`, also known as the stop bit
         for (let i = nalu.length - 1; i >= 0; i -= 1) {
             if (this.#nalu[i] === 0) {
                 continue;
@@ -276,7 +141,7 @@ export class NaluSodbBitReader {
                 if (((byte >> j) & 1) === 1) {
                     this.#byteLength = i;
                     this.#stopBitIndex = j;
-                    this.#readByte();
+                    this.#loadByte();
                     return;
                 }
             }
@@ -285,15 +150,22 @@ export class NaluSodbBitReader {
         throw new Error("Stop bit not found");
     }
 
-    #readByte() {
+    #loadByte() {
         this.#byte = this.#nalu[this.#bytePosition]!;
+
+        // If the current sequence is `0x000003`, skip to the next byte.
+        // `annexBSplitNalu` had validated the input, so skip the check here
         if (this.#zeroCount === 2 && this.#byte === 3) {
             this.#zeroCount = 0;
             this.#bytePosition += 1;
-            this.#readByte();
+            // Call `#loadByte` again, because if the next byte is `0x00`,
+            // it need to be counted in `#zeroCount` as well.
+            this.#loadByte();
             return;
         }
 
+        // `0x00000301` becomes `0x000001`, so only the `0x03` byte needs to be skipped
+        // All `0x00` bytes are returned as-is
         if (this.#byte === 0) {
             this.#zeroCount += 1;
         } else {
@@ -302,18 +174,19 @@ export class NaluSodbBitReader {
     }
 
     next() {
-        if (this.#bitPosition === -1) {
-            this.#bitPosition = 7;
-            this.#bytePosition += 1;
-            this.#readByte();
-        }
-
         if (this.ended) {
             throw new Error("Bit index out of bounds");
         }
 
         const value = (this.#byte >> this.#bitPosition) & 1;
+
         this.#bitPosition -= 1;
+        if (this.#bitPosition < 0) {
+            this.#bytePosition += 1;
+            this.#bitPosition = 7;
+            this.#loadByte();
+        }
+
         return value;
     }
 
@@ -329,10 +202,50 @@ export class NaluSodbBitReader {
         return result;
     }
 
+    /**
+     * Throws an error if the current position is invalid for `skip`.
+     *
+     * Usually it will throw if `ended` is `true`,
+     * except when the bit position is at the stop bit,
+     * in which case `ended` will be `true`, but it won't throw.
+     * `skip` can skip all remaining bits, and stop at the end position.
+     * The next `next` call will throw since there is no more bits to read.
+     */
+    #checkSkipPosition() {
+        if (
+            this.#bytePosition >= this.#byteLength &&
+            this.#bitPosition < this.#stopBitIndex
+        ) {
+            throw new Error("Bit index out of bounds");
+        }
+    }
+
     skip(length: number) {
-        for (let i = 0; i < length; i += 1) {
-            this.next();
+        if (length <= this.#bitPosition + 1) {
+            this.#bitPosition -= length;
+            this.#checkSkipPosition();
+            return;
+        }
+
+        // Because of emulation prevention bytes,
+        // we don't know how many bits are left in the NAL,
+        // nor how many bits should be skipped.
+        // So we need to check each byte.
+
+        length -= this.#bitPosition + 1;
+        this.#bytePosition += 1;
+        this.#bitPosition = 7;
+        this.#loadByte();
+        this.#checkSkipPosition();
+
+        for (; length >= 8; length -= 8) {
+            this.#bytePosition += 1;
+            this.#loadByte();
+            this.#checkSkipPosition();
         }
+
+        this.#bitPosition = 7 - length;
+        this.#checkSkipPosition();
     }
 
     decodeExponentialGolombNumber(): number {

package/src/control/empty.ts

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

package/src/control/index.ts

@@ -1,13 +1,7 @@
-export * from "./back-or-screen-on.js";
-export * from "./basic.js";
-export * from "./hover-helper.js";
-export * from "./inject-keycode.js";
-export * from "./inject-scroll.js";
+export * from "./empty.js";
+export * from "./inject-key-code.js";
 export * from "./inject-text.js";
-export * from "./inject-touch.js";
-export * from "./rotate-device.js";
+export * from "./message-type-map.js";
 export * from "./serializer.js";
-export * from "./set-clipboard.js";
 export * from "./set-screen-power-mode.js";
-export * from "./type.js";
 export * from "./writer.js";

package/src/control/inject-key-code.ts

@@ -0,0 +1,25 @@
+import type { StructInit } from "@yume-chan/struct";
+import { struct, u32, u8 } from "@yume-chan/struct";
+
+import type {
+    AndroidKeyCode,
+    AndroidKeyEventAction,
+    AndroidKeyEventMeta,
+} from "../android/index.js";
+import { ScrcpyControlMessageType } from "../base/index.js";
+
+export const ScrcpyInjectKeyCodeControlMessage = /* #__PURE__ */ (() =>
+    struct(
+        {
+            type: u8(ScrcpyControlMessageType.InjectKeyCode),
+            action: u8<AndroidKeyEventAction>(),
+            keyCode: u32<AndroidKeyCode>(),
+            repeat: u32,
+            metaState: u32<AndroidKeyEventMeta>(),
+        },
+        { littleEndian: false },
+    ))();
+
+export type ScrcpyInjectKeyCodeControlMessage = StructInit<
+    typeof ScrcpyInjectKeyCodeControlMessage
+>;

package/src/control/inject-text.ts

@@ -1,9 +1,11 @@
-import Struct from "@yume-chan/struct";
+import type { StructInit } from "@yume-chan/struct";
+import { string, struct, u32, u8 } from "@yume-chan/struct";
 
-export const ScrcpyInjectTextControlMessage = new Struct()
-    .uint8("type")
-    .uint32("length")
-    .string("text", { lengthField: "length" });
+export const ScrcpyInjectTextControlMessage = struct(
+    { type: u8, text: string(u32) },
+    { littleEndian: false },
+);
 
-export type ScrcpyInjectTextControlMessage =
-    (typeof ScrcpyInjectTextControlMessage)["TInit"];
+export type ScrcpyInjectTextControlMessage = StructInit<
+    typeof ScrcpyInjectTextControlMessage
+>;

package/src/control/message-type-map.ts

@@ -0,0 +1,30 @@
+import type { ScrcpyControlMessageType, ScrcpyOptions } from "../base/index.js";
+
+/**
+ * Scrcpy control message types have different values between versions.
+ *
+ * This class provides a way to get the actual value for a given type.
+ */
+export class ScrcpyControlMessageTypeMap {
+    #types: readonly ScrcpyControlMessageType[];
+
+    constructor(options: ScrcpyOptions<object>) {
+        this.#types = options.controlMessageTypes;
+    }
+
+    get(type: ScrcpyControlMessageType): number {
+        const value = this.#types.indexOf(type);
+        if (value === -1) {
+            throw new TypeError("Invalid or unsupported control message type");
+        }
+        return value;
+    }
+
+    fillMessageType<T extends { type: ScrcpyControlMessageType }>(
+        message: Omit<T, "type">,
+        type: T["type"],
+    ): T {
+        (message as T).type = this.get(type) as ScrcpyControlMessageType;
+        return message as T;
+    }
+}