@yume-chan/scrcpy 0.0.19 → 0.0.21

package/src/codec/index.ts

@@ -0,0 +1,4 @@
+export * from "./av1.js";
+export * from "./h264.js";
+export * from "./h265.js";
+export * from "./nalu.js";

package/src/codec/nalu.ts

@@ -0,0 +1,391 @@
+/**
+ * Split NAL units from an H.264/H.265 Annex B stream.
+ *
+ * The input is not modified.
+ * The returned NAL units are views of the input (no memory allocation nor copy),
+ * and still contains emulation prevention bytes.
+ *
+ * This methods returns a generator, so it can be stopped immediately
+ * after the interested NAL unit is found.
+ */
+export function* annexBSplitNalu(buffer: Uint8Array): Generator<Uint8Array> {
+    // -1 means we haven't found the first start code
+    let start = -1;
+    // How many `0x00`s in a row we have counted
+    let zeroCount = 0;
+    let inEmulation = false;
+
+    for (let i = 0; i < buffer.length; i += 1) {
+        const byte = buffer[i]!;
+
+        if (inEmulation) {
+            if (byte > 0x03) {
+                // `0x00000304` or larger are invalid
+                throw new Error("Invalid data");
+            }
+
+            inEmulation = false;
+            continue;
+        }
+
+        if (byte === 0x00) {
+            zeroCount += 1;
+            continue;
+        }
+
+        const prevZeroCount = zeroCount;
+        zeroCount = 0;
+
+        if (start === -1) {
+            // 0x000001 is the start code
+            // But it can be preceded by any number of zeros
+            // So 2 is the minimal
+            if (prevZeroCount >= 2 && byte === 0x01) {
+                // Found start of first NAL unit
+                start = i + 1;
+                continue;
+            }
+
+            // Not begin with start code
+            throw new Error("Invalid data");
+        }
+
+        if (prevZeroCount < 2) {
+            // zero or one `0x00`s are acceptable
+            continue;
+        }
+
+        if (byte === 0x01) {
+            // Found another NAL unit
+            yield buffer.subarray(start, i - prevZeroCount);
+
+            start = i + 1;
+            continue;
+        }
+
+        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;
+                break;
+            default:
+                // `0x000004` or larger are as-is
+                break;
+        }
+    }
+
+    if (inEmulation) {
+        throw new Error("Invalid data");
+    }
+
+    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;
+    readonly #byteLength: number;
+    readonly #stopBitIndex: number;
+
+    #zeroCount = 0;
+    #bytePosition = -1;
+    #bitPosition = -1;
+    #byte = 0;
+
+    get byteLength() {
+        return this.#byteLength;
+    }
+
+    get stopBitIndex() {
+        return this.#stopBitIndex;
+    }
+
+    get bytePosition() {
+        return this.#bytePosition;
+    }
+
+    get bitPosition() {
+        return this.#bitPosition;
+    }
+
+    get ended() {
+        return (
+            this.#bytePosition === this.#byteLength &&
+            this.#bitPosition === this.#stopBitIndex
+        );
+    }
+
+    constructor(nalu: Uint8Array) {
+        this.#nalu = nalu;
+
+        for (let i = nalu.length - 1; i >= 0; i -= 1) {
+            if (this.#nalu[i] === 0) {
+                continue;
+            }
+
+            const byte = nalu[i]!;
+            for (let j = 0; j < 8; j += 1) {
+                if (((byte >> j) & 1) === 1) {
+                    this.#byteLength = i;
+                    this.#stopBitIndex = j;
+                    this.#readByte();
+                    return;
+                }
+            }
+        }
+
+        throw new Error("Stop bit not found");
+    }
+
+    #readByte() {
+        this.#byte = this.#nalu[this.#bytePosition]!;
+        if (this.#zeroCount === 2 && this.#byte === 3) {
+            this.#zeroCount = 0;
+            this.#bytePosition += 1;
+            this.#readByte();
+            return;
+        }
+
+        if (this.#byte === 0) {
+            this.#zeroCount += 1;
+        } else {
+            this.#zeroCount = 0;
+        }
+    }
+
+    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;
+        return value;
+    }
+
+    read(length: number): number {
+        if (length > 32) {
+            throw new Error("Read length too large");
+        }
+
+        let result = 0;
+        for (let i = 0; i < length; i += 1) {
+            result = (result << 1) | this.next();
+        }
+        return result;
+    }
+
+    skip(length: number) {
+        for (let i = 0; i < length; i += 1) {
+            this.next();
+        }
+    }
+
+    decodeExponentialGolombNumber(): number {
+        let length = 0;
+        while (this.next() === 0) {
+            length += 1;
+        }
+        if (length === 0) {
+            return 0;
+        }
+        return ((1 << length) | this.read(length)) - 1;
+    }
+
+    #save() {
+        return {
+            zeroCount: this.#zeroCount,
+            bytePosition: this.#bytePosition,
+            bitPosition: this.#bitPosition,
+            byte: this.#byte,
+        };
+    }
+
+    #restore(state: {
+        zeroCount: number;
+        bytePosition: number;
+        bitPosition: number;
+        byte: number;
+    }) {
+        this.#zeroCount = state.zeroCount;
+        this.#bytePosition = state.bytePosition;
+        this.#bitPosition = state.bitPosition;
+        this.#byte = state.byte;
+    }
+
+    peek(length: number) {
+        const state = this.#save();
+        const result = this.read(length);
+        this.#restore(state);
+        return result;
+    }
+
+    readBytes(length: number): Uint8Array {
+        const result = new Uint8Array(length);
+        for (let i = 0; i < length; i += 1) {
+            result[i] = this.read(8);
+        }
+        return result;
+    }
+
+    peekBytes(length: number): Uint8Array {
+        const state = this.#save();
+        const result = this.readBytes(length);
+        this.#restore(state);
+        return result;
+    }
+}

package/src/control/back-or-screen-on.ts

@@ -1,4 +1,4 @@
-import type { ScrcpyBackOrScreenOnControlMessage1_18 } from "../index.js";
+import type { ScrcpyBackOrScreenOnControlMessage1_18 } from "../options/index.js";
 
 export type ScrcpyBackOrScreenOnControlMessage =
     ScrcpyBackOrScreenOnControlMessage1_18;

package/{esm/control/simple.js → src/control/basic.ts}

@@ -1,3 +1,3 @@
-import { Struct } from "@yume-chan/struct";
-export const BasicControlMessage = new Struct().uint8("type");
-//# sourceMappingURL=simple.js.map
+import { Struct } from "@yume-chan/struct";
+
+export const BasicControlMessage = new Struct().uint8("type");

package/src/control/hover-helper.ts

@@ -15,34 +15,33 @@ import { ScrcpyControlMessageType } from "./type.js";
  * so Scrcpy server can remove the previously hovering pointer.
  */
 export class ScrcpyHoverHelper {
-    // AFAIK, only mouse and pen can have hover state
-    // and you can't have two mouses or pens.
-    // So remember the last hovering pointer is enough.
-    private lastHoverMessage: ScrcpyInjectTouchControlMessage | undefined;
+    // There can be only one hovering pointer (either mouse or pen,
+    // touch can have multiple pointers but no hovering state).
+    #lastHoverMessage: ScrcpyInjectTouchControlMessage | undefined;
 
-    public process(
-        message: Omit<ScrcpyInjectTouchControlMessage, "type">
+    process(
+        message: Omit<ScrcpyInjectTouchControlMessage, "type">,
     ): ScrcpyInjectTouchControlMessage[] {
         const result: ScrcpyInjectTouchControlMessage[] = [];
 
         // A different pointer appeared,
         // Cancel previously hovering pointer so Scrcpy server can free up the pointer ID.
         if (
-            this.lastHoverMessage &&
-            this.lastHoverMessage.pointerId !== message.pointerId
+            this.#lastHoverMessage &&
+            this.#lastHoverMessage.pointerId !== message.pointerId
         ) {
             // TODO: Inject MotionEvent.ACTION_HOVER_EXIT
             // From testing, it seems no App cares about this event.
             result.push({
-                ...this.lastHoverMessage,
+                ...this.#lastHoverMessage,
                 action: AndroidMotionEventAction.Up,
             });
-            this.lastHoverMessage = undefined;
+            this.#lastHoverMessage = undefined;
         }
 
         if (message.action === AndroidMotionEventAction.HoverMove) {
             // TODO: Inject MotionEvent.ACTION_HOVER_ENTER
-            this.lastHoverMessage = message as ScrcpyInjectTouchControlMessage;
+            this.#lastHoverMessage = message as ScrcpyInjectTouchControlMessage;
         }
 
         (message as ScrcpyInjectTouchControlMessage).type =

package/src/control/index.ts

@@ -1,4 +1,5 @@
 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";
@@ -9,3 +10,4 @@ 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-keycode.ts

@@ -1,7 +1,5 @@
 import Struct, { placeholder } from "@yume-chan/struct";
 
-import { ScrcpyControlMessageType } from "./type.js";
-
 export enum AndroidKeyEventAction {
     Down = 0,
     Up = 1,
@@ -207,7 +205,7 @@ export enum AndroidKeyCode {
 }
 
 export const ScrcpyInjectKeyCodeControlMessage = new Struct()
-    .uint8("type", ScrcpyControlMessageType.InjectKeyCode as const)
+    .uint8("type")
     .uint8("action", placeholder<AndroidKeyEventAction>())
     .uint32("keyCode")
     .uint32("repeat")

package/src/control/inject-text.ts

@@ -1,9 +1,7 @@
 import Struct from "@yume-chan/struct";
 
-import { ScrcpyControlMessageType } from "./type.js";
-
 export const ScrcpyInjectTextControlMessage = new Struct()
-    .uint8("type", ScrcpyControlMessageType.InjectText as const)
+    .uint8("type")
     .uint32("length")
     .string("text", { lengthField: "length" });
 

package/src/control/inject-touch.ts

@@ -1,10 +1,4 @@
-import Struct, {
-    NumberFieldDefinition,
-    NumberFieldType,
-    placeholder,
-} from "@yume-chan/struct";
-
-import { ScrcpyControlMessageType } from "./type.js";
+import type { ScrcpyInjectTouchControlMessage2_0 } from "../options/index.js";
 
 // https://developer.android.com/reference/android/view/MotionEvent#constants_1
 export enum AndroidMotionEventAction {
@@ -23,56 +17,23 @@ export enum AndroidMotionEventAction {
     ButtonRelease,
 }
 
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace ScrcpyPointerId {
-    export const Mouse = BigInt(-1);
-    export const Finger = BigInt(-2);
-    export const VirtualMouse = BigInt(-3);
-    export const VirtualFinger = BigInt(-4);
+export enum AndroidMotionEventButton {
+    Primary = 0x01,
+    Secondary = 0x02,
+    Tertiary = 0x04,
+    Back = 0x08,
+    Forward = 0x10,
+    StylusPrimary = 0x20,
+    StylusSecondary = 0x40,
 }
 
-export function clamp(value: number, min: number, max: number): number {
-    if (value < min) {
-        return min;
-    }
-
-    if (value > max) {
-        return max;
-    }
-
-    return value;
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace ScrcpyPointerId {
+    export const Mouse = -1n;
+    export const Finger = -2n;
+    export const VirtualMouse = -3n;
+    export const VirtualFinger = -4n;
 }
 
-export const ScrcpyFloatToUint16NumberType: NumberFieldType = {
-    size: 2,
-    signed: false,
-    deserialize(array, littleEndian) {
-        const value = NumberFieldType.Uint16.deserialize(array, littleEndian);
-        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/server/src/main/java/com/genymobile/scrcpy/Binary.java#L22
-        return value === 0xffff ? 1 : value / 0x10000;
-    },
-    serialize(dataView, offset, value, 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;
-        NumberFieldType.Uint16.serialize(dataView, offset, value, littleEndian);
-    },
-};
-
-const ScrcpyFloatToUint16FieldDefinition = new NumberFieldDefinition(
-    ScrcpyFloatToUint16NumberType
-);
-
-export const ScrcpyInjectTouchControlMessage = new Struct()
-    .uint8("type", ScrcpyControlMessageType.InjectTouch as const)
-    .uint8("action", placeholder<AndroidMotionEventAction>())
-    .uint64("pointerId")
-    .uint32("pointerX")
-    .uint32("pointerY")
-    .uint16("screenWidth")
-    .uint16("screenHeight")
-    .field("pressure", ScrcpyFloatToUint16FieldDefinition)
-    .uint32("buttons");
-
 export type ScrcpyInjectTouchControlMessage =
-    (typeof ScrcpyInjectTouchControlMessage)["TInit"];
+    ScrcpyInjectTouchControlMessage2_0;

package/src/control/rotate-device.ts

@@ -1,11 +1,6 @@
-import Struct from "@yume-chan/struct";
+import { BasicControlMessage } from "./basic.js";
 
-import { ScrcpyControlMessageType } from "./type.js";
-
-export const ScrcpyRotateDeviceControlMessage = new Struct().uint8(
-    "type",
-    ScrcpyControlMessageType.RotateDevice as const
-);
+export const ScrcpyRotateDeviceControlMessage = BasicControlMessage;
 
 export type ScrcpyRotateDeviceControlMessage =
     (typeof ScrcpyRotateDeviceControlMessage)["TInit"];