@mega-yfue/eufy-sdk 0.6.0-beta.30 → 0.6.0-beta.31

package/dist/core/contracts.d.ts

@@ -153,8 +153,9 @@ export declare class DeviceChannelUnresolvedError extends Error {
 /**
  * Why {@link MediaProvider.downloadRecording} returned no recording.
  *
- * - `invalid-recording` — the recording name is not one the station could hold.
- * - `key-unavailable` — the key the recording was stored under could not be obtained.
+ * - `invalid-recording` — the recording name is not one the camera's station could hold.
+ * - `key-unavailable` — the station stores the recording sealed and the key it was sealed under could not be
+ *   obtained.
  * - `no-data` — the station sent nothing within the wait.
  * - `incomplete` — the transfer ended before the station's finish frame.
  * - `undecodable` — data arrived but no video frame could be decoded from it.
@@ -170,10 +171,10 @@ export declare class RecordingDownloadError extends Error {
 /**
  * A recording downloaded from the station, as elementary streams.
  *
- * `video` is Annex-B H.264 in decode order, `audio` AAC-LC 16 kHz mono in ADTS framing (absent when the
- * recording carried none that could be decoded). `frames` counts the distinct video sequences emitted.
- * `missingFrames` counts gaps between received sequences and received sequences that yielded no usable
- * picture, including at either end. `durationMs` spans the first to the last emitted picture by the
+ * `video` is Annex-B H.264 or H.265 in decode order, `audio` AAC-LC 16 kHz mono in ADTS framing (absent
+ * when the recording carried none that could be decoded). `frames` counts the distinct video sequences
+ * emitted. `missingFrames` counts gaps between received sequences and received sequences that yielded no
+ * usable picture, including at either end. `durationMs` spans the first to the last emitted picture by the
  * camera's own timestamps; `fps` is derived from those stamps.
  */
 export interface RecordingDownload {
@@ -884,9 +885,11 @@ export interface MediaProvider {
         encoder?: AacEncoder;
     } & SharedSourceHints): Promise<TalkbackHandle>;
     /**
-     * Download one recording the camera's station stored, identified by the recording name and cipher id of
-     * the event. One download runs at a time per station. Rejects with {@link RecordingDownloadError}.
-     * Optional, and absent on a camera whose station's recording download is unverified.
+     * Download one recording the camera's station stored. `recording` names it: the file name the station stores
+     * it under, without the folder or the extension. `cipherId` is the cipher the station names for it, and is not
+     * read on a station that stores its recordings in the clear. One download runs at a time per station. Rejects with
+     * {@link RecordingDownloadError}. Optional, and absent on a camera whose station's recording download is
+     * unverified.
      */
     downloadRecording?(opts: {
         recording: string;

package/dist/index.js

@@ -18951,15 +18951,19 @@ var VideoFrameDecoder = class {
 var STATION_CHUNK_BYTES = 64e3;
 var AccessUnitAssembler = class {
   onDropped;
+  chunkBytes;
   open;
   droppedUnits = 0;
   /**
    * @param onDropped called for each incomplete unit discarded, with what had arrived, how many frames it
    * arrived in, and how many this assembler has dropped in total — a running count, so no caller keeps
    * its own.
+   * @param chunkBytes the payload size the station fills a frame to before continuing a unit in the next. A
+   * unit is held while its latest frame declares exactly this. {@link STATION_CHUNK_BYTES} when omitted.
    */
-  constructor(onDropped) {
+  constructor(onDropped, chunkBytes = STATION_CHUNK_BYTES) {
     this.onDropped = onDropped;
+    this.chunkBytes = chunkBytes;
   }
   /**
    * Feed one raw `CMD_VIDEO_FRAME` payload; returns the access units it completed — none while a unit is
@@ -18978,7 +18982,7 @@ var AccessUnitAssembler = class {
       this.discard();
       return [];
     }
-    const full = header.payloadLength === STATION_CHUNK_BYTES;
+    const full = header.payloadLength === this.chunkBytes;
     const open2 = this.open;
     if (open2 && sameUnit(open2.header, header) && !beginsAccessUnit(body)) {
       open2.chunks.push(body);
@@ -19992,16 +19996,31 @@ function annexbToJpeg(annexb, spawn2) {
 var RECORDING_DATA_TYPE = 3;
 var VIDEO_HEADER_LEN2 = 22;
 var AUDIO_CODEC_AAC_LC = 0;
-var FINISH_CHANNEL = 0;
 var FIRST_FRAME_WAIT_MS = 2e4;
 var IDLE_END_MS = 15e3;
 var DEFAULT_TRANSFER_MS = 12e4;
 var MAX_TRANSFER_BYTES = 32 * 1024 * 1024;
+function cameraFolder(channel) {
+  if (!Number.isInteger(channel) || channel < 0 || channel > 99)
+    return void 0;
+  return `Camera${String(channel).padStart(2, "0")}`;
+}
 function homeBase2RecordingPath(channel, recording) {
-  if (!/^(?:h265_)?\d{14}$/.test(recording) || !Number.isInteger(channel) || channel < 0 || channel > 99)
+  const folder = cameraFolder(channel);
+  if (!folder || !/^(?:h265_)?\d{14}$/.test(recording))
+    return void 0;
+  return `/media/mmcblk0p1/${folder}/${recording}.dat`;
+}
+function homeBase3RecordingPath(channel, recording) {
+  const folder = cameraFolder(channel);
+  if (!folder || !/^\d{14}$/.test(recording))
     return void 0;
-  return `/media/mmcblk0p1/Camera${String(channel).padStart(2, "0")}/${recording}.dat`;
+  return `/zx/emmcdata/${folder}/${recording.slice(0, 6)}/${recording}/${recording}.zxvideo`;
 }
+var RECORDING_STATIONS = /* @__PURE__ */ new Map([
+  ["T8010", { path: homeBase2RecordingPath, sealed: true, finishChannel: 0, chunkBytes: STATION_CHUNK_BYTES }],
+  ["T8030", { path: homeBase3RecordingPath, sealed: false, finishChannel: STATION_CHANNEL3, chunkBytes: 4e5 }]
+]);
 function receiveRecording(session, request) {
   let resolveFrames;
   let rejectFrames;
@@ -20045,7 +20064,7 @@ function receiveRecording(session, request) {
   };
   const onData = (frame) => {
     if (frame.commandId === CommandType.CMD_DOWNLOAD_FINISH) {
-      if (frame.channel !== request.channel && frame.channel !== FINISH_CHANNEL)
+      if (frame.channel !== request.channel && frame.channel !== request.finishChannel)
         return;
       if (draining)
         incomplete(draining);
@@ -20102,12 +20121,17 @@ function receiveRecording(session, request) {
   }
   return { frames, drained };
 }
-function decodeRecording(frames, eccPrivateKeyHex) {
-  const eccPrivateKey = Buffer.from(eccPrivateKeyHex, "hex");
-  if (eccPrivateKey.length !== 32)
+function clearVideoPayload(raw, header) {
+  const end = VIDEO_HEADER_LEN2 + header.payloadLength;
+  return raw.length >= end ? raw.subarray(VIDEO_HEADER_LEN2, end) : void 0;
+}
+function decodeRecording(frames, station, eccPrivateKeyHex) {
+  const eccPrivateKey = station.sealed ? Buffer.from(eccPrivateKeyHex ?? "", "hex") : void 0;
+  if (eccPrivateKey && eccPrivateKey.length !== 32) {
     throw new RecordingDownloadError("undecodable", "the cipher key is not a P-256 key");
-  const decoder = new VideoFrameDecoder(eccPrivateKey);
-  const assembler = new AccessUnitAssembler();
+  }
+  const decoder = eccPrivateKey && new VideoFrameDecoder(eccPrivateKey);
+  const assembler = new AccessUnitAssembler(void 0, station.chunkBytes);
   const video = [];
   const audio = [];
   const numbers = /* @__PURE__ */ new Set();
@@ -20120,7 +20144,7 @@ function decodeRecording(frames, eccPrivateKeyHex) {
       if (!header)
         continue;
       receivedNumbers.add(header.sequence);
-      const units = assembler.push(raw, (payload) => header.keyframe ? decoder.decodeFrame(payload)?.h264 : payload.length >= VIDEO_HEADER_LEN2 + header.payloadLength ? payload.subarray(VIDEO_HEADER_LEN2, VIDEO_HEADER_LEN2 + header.payloadLength) : void 0);
+      const units = assembler.push(raw, (payload) => decoder && header.keyframe ? decoder.decodeFrame(payload)?.h264 : clearVideoPayload(payload, header));
       for (const unit of units) {
         video.push(unit.data);
         numbers.add(header.sequence);
@@ -20129,10 +20153,10 @@ function decodeRecording(frames, eccPrivateKeyHex) {
         lastStamp = stamp;
       }
     } else if (commandId === CommandType.CMD_AUDIO_FRAME) {
-      const mediaKey = decoder.currentMediaKey;
-      if (!mediaKey || raw[5] !== AUDIO_CODEC_AAC_LC)
+      if (raw[5] !== AUDIO_CODEC_AAC_LC)
         continue;
-      const aac = openSealedAudio(raw, mediaKey);
+      const mediaKey = decoder?.currentMediaKey;
+      const aac = decoder ? mediaKey && openSealedAudio(raw, mediaKey) : raw.subarray(AUDIO_HEADER_LEN);
       if (aac?.length)
         audio.push(aac);
     }
@@ -22864,7 +22888,8 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * start has no level-1 form for.
    */
   mediaProviderFor(sn) {
-    const recordings = this.downloadsRecordings(sn) ? { downloadRecording: (opts) => this.downloadRecording(sn, opts) } : {};
+    const station = this.recordingStationFor(sn);
+    const recordings = station ? { downloadRecording: (opts) => this.downloadRecording(sn, station, opts) } : {};
     return {
       ...recordings,
       snapshotLive: async (opts) => {
@@ -22906,29 +22931,32 @@ var P2PCommandRouter = class _P2PCommandRouter {
     };
   }
   /**
-   * Whether `sn` is a camera attached to a HomeBase 2 (T8010), the one station whose recording path layout
-   * and frame formats are confirmed.
+   * The {@link RecordingStation} of the station `sn` is attached to, when `sn` is a camera attached to a
+   * station with an entry in {@link RECORDING_STATIONS}. A standalone device, or a camera on any other
+   * station, answers `undefined`.
    */
-  downloadsRecordings(sn) {
+  recordingStationFor(sn) {
     const dev = this.recordFor(sn);
     if (!dev)
-      return false;
+      return void 0;
     const parentSn = stationOf(dev);
-    return parentSn !== sn && this.recordFor(parentSn)?.model === "T8010";
+    if (parentSn === sn)
+      return void 0;
+    return RECORDING_STATIONS.get(this.recordFor(parentSn)?.model ?? "");
   }
   /**
-   * Download one recording a HomeBase 2 holds for an attached camera, then decode it
-   * ({@link decodeRecording}). Downloads queue per station: the station streams one recording at a time
-   * on the camera's channel, so a download starts only once the previous one has drained
-   * ({@link RecordingTransfer.drained}), even when that one's caller already has its answer. An abort
-   * while waiting rejects without sending anything; an abort mid-transfer rejects at once and the station's
-   * turn is held until the transfer drains.
+   * Download one recording `station` holds for the attached camera `sn`, then decode it
+   * ({@link decodeRecording}). `station` is the entry {@link mediaProviderFor} bound. Downloads queue per
+   * station: the station streams one recording at a time on the camera's channel, so a download starts only
+   * once the previous one has drained ({@link RecordingTransfer.drained}), even when that one's caller already
+   * has its answer. An abort while waiting rejects without sending anything; an abort mid-transfer rejects at
+   * once and the station's turn is held until the transfer drains.
    */
-  async downloadRecording(sn, opts) {
+  async downloadRecording(sn, station, opts) {
     opts.signal?.throwIfAborted();
     const parentSn = this.stationKeyOf(sn);
     const previous = this.recordingDownloads.get(parentSn) ?? Promise.resolve();
-    const started = this.waitTurn(previous, opts.signal).then(() => this.startRecordingDownload(sn, opts));
+    const started = this.waitTurn(previous, opts.signal).then(() => this.startRecordingDownload(sn, station, opts));
     const turn = Promise.allSettled([previous, started.then((t) => t.drained)]).then(() => {
       if (this.recordingDownloads.get(parentSn) === turn)
         this.recordingDownloads.delete(parentSn);
@@ -22942,25 +22970,32 @@ var P2PCommandRouter = class _P2PCommandRouter {
   }
   /**
    * Start one recording download, once the station's previous download has drained: the decoded recording,
-   * and when the station is done sending it.
+   * and when the station is done sending it. The path is `station.path(channel, opts.recording)`, and a name
+   * it refuses rejects `invalid-recording` before anything is sent. On a sealed station the cipher's ECC key
+   * is looked up, and its absence rejects `key-unavailable` before anything is sent. A station in the clear
+   * reads no cipher, and `opts.cipherId` is not read.
    */
-  async startRecordingDownload(sn, opts) {
+  async startRecordingDownload(sn, station, opts) {
     const { session, parentSn, channel, accountId } = await this.resolveSession(sn, { signal: opts.signal });
-    const path = homeBase2RecordingPath(channel, opts.recording);
+    const path = station.path(channel, opts.recording);
     if (!path)
       throw new RecordingDownloadError("invalid-recording", `no recording named ${opts.recording}`);
-    const eccKey = (await this.cipherKeysFor(session, opts.cipherId, accountId, parentSn))?.ecc;
-    if (!eccKey) {
+    const eccKey = station.sealed ? (await this.cipherKeysFor(session, opts.cipherId, accountId, parentSn))?.ecc : void 0;
+    if (station.sealed && !eccKey) {
       throw new RecordingDownloadError("key-unavailable", `cipher ${opts.cipherId} could not be obtained`);
     }
     const transfer = receiveRecording(session, {
       path,
       accountId,
       channel,
+      finishChannel: station.finishChannel,
       timeoutMs: opts.timeoutMs,
       signal: opts.signal
     });
-    return { recording: transfer.frames.then((frames) => decodeRecording(frames, eccKey)), drained: transfer.drained };
+    return {
+      recording: transfer.frames.then((frames) => decodeRecording(frames, station, eccKey)),
+      drained: transfer.drained
+    };
   }
   /**
    * Open a {@link Talkback} on a device's camera channel.