@mega-yfue/eufy-sdk 0.5.0-beta.33 → 0.5.0-beta.35

package/dist/index.js

@@ -17119,32 +17119,35 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Frames are packed back to back, so a frame header can itself be cut by a datagram boundary. The start
    * of a header left at the end of a datagram is carried into the next one rather than discarded; dropping
    * it would lose that frame and every frame after it until a datagram happened to begin on a header.
+   * Payload fragments retain their original slices and are copied once, when the complete frame is delivered.
    */
   reassemble(dataType, datagramBody) {
     const pending = this.pendingByDataType.get(dataType);
-    let body = pending ? Buffer.concat([pending.buf, datagramBody]) : datagramBody;
-    const carryHeader = pending?.header;
     this.pendingByDataType.delete(dataType);
-    if (carryHeader) {
-      if (body.length < carryHeader.bytesToRead) {
-        this.pendingByDataType.set(dataType, { header: carryHeader, buf: body });
+    let body = pending && !pending.header ? Buffer.concat([...pending.chunks, datagramBody]) : datagramBody;
+    if (pending?.header) {
+      const taken = Math.min(pending.header.bytesToRead - pending.byteLength, body.length);
+      pending.chunks.push(body.subarray(0, taken));
+      pending.byteLength += taken;
+      body = body.subarray(taken);
+      if (pending.byteLength < pending.header.bytesToRead) {
+        this.pendingByDataType.set(dataType, pending);
         return;
       }
-      this.handleFrame(carryHeader, body.subarray(0, carryHeader.bytesToRead), dataType);
-      body = body.subarray(carryHeader.bytesToRead);
+      this.handleFrame(pending.header, Buffer.concat(pending.chunks, pending.byteLength), dataType);
     }
     while (body.length >= P2P_DATA_HEADER_BYTES && body.subarray(0, 4).toString() === MAGIC_WORD) {
       const header = parseDataFrameHeader(body);
       const payload = body.subarray(P2P_DATA_HEADER_BYTES);
       if (payload.length < header.bytesToRead) {
-        this.pendingByDataType.set(dataType, { header, buf: payload });
+        this.pendingByDataType.set(dataType, { header, chunks: [payload], byteLength: payload.length });
         return;
       }
       this.handleFrame(header, payload.subarray(0, header.bytesToRead), dataType);
       body = body.subarray(P2P_DATA_HEADER_BYTES + header.bytesToRead);
     }
     if (body.length > 0 && body.length < P2P_DATA_HEADER_BYTES && MAGIC_WORD.startsWith(body.subarray(0, 4).toString())) {
-      this.pendingByDataType.set(dataType, { buf: body });
+      this.pendingByDataType.set(dataType, { chunks: [body], byteLength: body.length });
     }
   }
   /**
@@ -20419,7 +20422,8 @@ var Fmp4Muxer = class {
   fragTicks = 0;
   // ticks accumulated in the open fragment
   samples = [];
-  lastVideoTimestampMs;
+  /** Ticks from the first video sample's start to the newest sample's end, at its provisional duration. */
+  videoTicks = 0;
   audioRequested;
   audioCodec;
   /** Decoder config of an AAC-ELD track, taken from its frames; absent for AAC-LC, whose `esds` config is fixed. */
@@ -20443,6 +20447,10 @@ var Fmp4Muxer = class {
    * Push one access unit. Returns any completed segments: the `init` on the first keyframe, and/or a
    * media fragment when this frame closed the open one. Returns `undefined` if nothing is emitted yet
    * (e.g. delta frames before the first keyframe).
+   *
+   * A sample lasts until the next frame's `timestampMs`, measured from the first keyframe's, so the video
+   * timeline follows the arrival clock; a frame that shares the previous one's timestamp leaves that
+   * sample one tick long, and the next frame's duration absorbs the difference.
    */
   push(frame, timestampMs = now()) {
     if (frame.codec === "av1")
@@ -20461,15 +20469,14 @@ var Fmp4Muxer = class {
       this.height = declared?.height ?? frame.height;
       this.firstVideoTimestampMs = timestampMs;
     }
-    if (this.lastVideoTimestampMs !== void 0 && this.samples.length) {
-      const measured = Math.round((timestampMs - this.lastVideoTimestampMs) * (TIMESCALE / 1e3));
-      if (measured > 0) {
-        const previous = this.samples[this.samples.length - 1];
-        this.fragTicks += measured - previous.duration;
-        previous.duration = measured;
-      }
+    if (this.firstVideoTimestampMs !== void 0 && this.samples.length) {
+      const previous = this.samples[this.samples.length - 1];
+      const arrival = Math.round((timestampMs - this.firstVideoTimestampMs) * (TIMESCALE / 1e3));
+      const duration = Math.max(1, arrival - (this.videoTicks - previous.duration));
+      this.fragTicks += duration - previous.duration;
+      this.videoTicks += duration - previous.duration;
+      previous.duration = duration;
     }
-    this.lastVideoTimestampMs = timestampMs;
     let fragment;
     if (frame.keyframe && this.samples.length > 0 && this.fragTicks >= this.fragmentTicks) {
       if (!this.initSent) {
@@ -20481,6 +20488,7 @@ var Fmp4Muxer = class {
     }
     this.samples.push({ data: annexbToAvcc(frame.data), duration: this.firstDuration, keyframe: frame.keyframe });
     this.fragTicks += this.firstDuration;
+    this.videoTicks += this.firstDuration;
     if (!this.initSent && (!this.audioRequested || this.audioCodec || this.audioDisabled)) {
       init = this.buildInit();
       this.initSent = true;