@homebridge-plugins/homebridge-eufy-security 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/media/live-stream.js

@@ -1,4 +1,4 @@
-import { LiveStreamStartError } from '@mega-yfue/eufy-sdk';
+import { LiveStreamStartError, StationKeyUnavailableError, StationUnreachableError } from '@mega-yfue/eufy-sdk';
 import { createSocket } from 'node:dgram';
 import { execFile, spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
@@ -34,7 +34,18 @@ function canCode(running, announced) {
  */
 const MAX_SOURCE_INPUT_REPLACEMENTS = 3;
 const INITIAL_RTCP_GRACE_MS = 15_000;
-const SOURCE_ACQUISITION_DEADLINE_MS = 10_000;
+/**
+ * The longest a session waits for the SDK to hand over a source, after which it cancels the acquisition.
+ *
+ * Reaching a station is inside this wait: an unconnected station is reconnected within it, and a HomeBase
+ * resolves its session before it can start one. The bound is therefore above what reaching a station costs and
+ * below both {@link SOURCE_START_BACKSTOP_MS} and the window a started request is owed an outcome within, so
+ * the acquisition is what this expiry reports.
+ *
+ * Expiry cancels the acquisition. A station serves one media channel, and an uncancelled acquisition holds it
+ * until the SDK's own wait elapses, which refuses every camera behind that station meanwhile.
+ */
+const SOURCE_ACQUISITION_DEADLINE_MS = 25_000;
 const RETURN_AUDIO_BIND_GRACE_MS = 250;
 /**
  * Backstop for a started media session that never produces adapted output. The SDK source owns the
@@ -44,6 +55,20 @@ const RETURN_AUDIO_BIND_GRACE_MS = 250;
  * reports nothing at all.
  */
 export const SOURCE_START_BACKSTOP_MS = 30_000;
+/**
+ * How far the RTP sequence space is advanced for each adaptation a session sends on, in packets.
+ *
+ * One session keeps one SSRC and one SRTP key across a replaced adaptation, and the SRTP packet index is built
+ * from the sequence number — so a replacement that started where FFmpeg would have, at a random base, is read
+ * by the controller as replay half the time and its packets are discarded under a key that still
+ * authenticates. Nothing reports it: the controller goes on acknowledging what it received before, so RTCP
+ * liveness holds while the picture never advances again.
+ *
+ * Advancing instead of restarting keeps the index monotonic. The step is well under half the sequence space,
+ * which is what keeps the receiver's own index estimate correct across the wrap it eventually crosses; a gap
+ * this size reads as loss, which a controller already tolerates.
+ */
+const OUTPUT_SEQUENCE_STEP = 4_096;
 const SOURCE_ACQUISITION_TIMEOUT = Symbol('source-acquisition-timeout');
 /**
  * The bounded reason one SDK source failure reports.
@@ -55,8 +80,11 @@ const SOURCE_ACQUISITION_TIMEOUT = Symbol('source-acquisition-timeout');
  * from a transport that failed.
  */
 function sourceFailure(error) {
-    if (error instanceof Error && error.name === 'StationBusyError') {
-        return 'station-busy';
+    if (error instanceof StationUnreachableError) {
+        return 'station-unreachable';
+    }
+    if (error instanceof StationKeyUnavailableError) {
+        return 'station-key-unavailable';
     }
     return error instanceof LiveStreamStartError && error.stage === 'audio-only' ? 'source-audio-only' : 'source-error';
 }
@@ -152,6 +180,10 @@ export async function resolveFfmpegIdentity(path, source, probe = probeFfmpegVer
     const version = await probe(path).catch(() => undefined);
     return { path, source, ...(version === undefined ? {} : { version }) };
 }
+/** The `libx264` constant rate factor a live adaptation codes at when the negotiated bit rate is ignored. */
+const CONSTANT_QUALITY_CRF = 23;
+/** The live video packet size an administrator can choose for networks that drop the negotiated one. */
+export const SMALL_VIDEO_PACKET_SIZE = 1128;
 /** Adapts separate SDK elementary streams into independently failing HomeKit SRTP outputs. */
 export class FfmpegLiveMedia {
     executable;
@@ -159,12 +191,18 @@ export class FfmpegLiveMedia {
     createProcess;
     reservePort;
     createReturnAudioProcess;
-    constructor(executable, adaptationDiagnostics, createProcess = spawnLiveMediaProcess, reservePort = reserveMediaPort, createReturnAudioProcess = spawnReturnAudioProcess) {
+    maxVideoPacketSize;
+    copyVideo;
+    constantQuality;
+    constructor(executable, adaptationDiagnostics, createProcess = spawnLiveMediaProcess, reservePort = reserveMediaPort, createReturnAudioProcess = spawnReturnAudioProcess, maxVideoPacketSize = Number.POSITIVE_INFINITY, copyVideo = false, constantQuality = false) {
         this.executable = executable;
         this.adaptationDiagnostics = adaptationDiagnostics;
         this.createProcess = createProcess;
         this.reservePort = reservePort;
         this.createReturnAudioProcess = createReturnAudioProcess;
+        this.maxVideoPacketSize = maxVideoPacketSize;
+        this.copyVideo = copyVideo;
+        this.constantQuality = constantQuality;
     }
     /**
      * Reserves the negotiated output ports so `SetupEndpoints` can be answered with them, and returns a
@@ -175,6 +213,9 @@ export class FfmpegLiveMedia {
     async prepare(transport) {
         const videoPort = await this.reservePort(transport.addressVersion);
         const targetAddress = transport.addressVersion === 'ipv6' ? `[${transport.targetAddress}]` : transport.targetAddress;
+        const maxVideoPacketSize = this.maxVideoPacketSize;
+        const copyVideo = this.copyVideo;
+        const constantQuality = this.constantQuality;
         let audioPort;
         try {
             audioPort = transport.audio ? await this.reservePort(transport.addressVersion) : undefined;
@@ -184,6 +225,13 @@ export class FfmpegLiveMedia {
             throw error;
         }
         let source;
+        /**
+         * Cancels the source acquisition in flight, and is held for exactly as long as one is.
+         *
+         * The station's one media channel is held for the whole of an uncancelled acquisition, so a session that
+         * ends during one cancels it rather than leaving it to the SDK's own wait.
+         */
+        let acquiring;
         let videoProcess;
         let audioProcess;
         let returnAudioProcess;
@@ -194,7 +242,6 @@ export class FfmpegLiveMedia {
         let negotiated;
         let stopped = false;
         let receivedVideoKeyframe = false;
-        let reconfigurationPending = false;
         /**
          * The coded configuration the source last announced, and the one the running adaptation was opened for.
          *
@@ -213,6 +260,13 @@ export class FfmpegLiveMedia {
         let videoStartBackstop;
         let videoFailed = false;
         let rtcpObserved = false;
+        /** How many receiver reports this session was acknowledged by, and when the last one arrived. */
+        /** Why the video adaptation now running was started, which the record reporting it carries. */
+        let videoCause = 'first';
+        /** Where the next adaptation this session sends on starts its RTP sequence, advanced for every one. */
+        let videoSequence = 0;
+        let rtcpReports = 0;
+        let lastRtcpAt;
         let streaming = false;
         const stoppingProcesses = new WeakSet();
         const congested = new Set();
@@ -320,33 +374,43 @@ export class FfmpegLiveMedia {
                 return;
             }
             stopped = true;
+            acquiring?.abort(new Error('live media session stopped'));
             clearTimeout(rtcpDeadline);
             clearTimeout(initialRtcpGrace);
             clearTimeout(videoStartBackstop);
             stopTalkback();
             stopProcess(videoProcess);
             stopProcess(audioProcess);
-            if (source) {
-                source.stop();
-                transport.onSessionReleased?.();
+            source?.stop();
+            if (negotiated) {
+                transport.onSessionReleased?.(videoFailed ? 'failed' : 'requested', {
+                    reports: rtcpReports,
+                    ...(lastRtcpAt === undefined ? {} : { sinceLastReportMs: Date.now() - lastRtcpAt }),
+                }, ...(source === undefined ? ['sdk-source-acquisition'] : []));
             }
             videoPort.close();
             audioPort?.close();
         };
-        const failVideo = (reason) => {
+        const failVideo = (reason, error) => {
             if (stopped || videoFailed) {
                 return;
             }
             videoFailed = true;
             stop();
+            const warmUp = error instanceof LiveStreamStartError;
             const stage = reason === 'source-acquisition-timeout' || source === undefined
                 ? 'sdk-source-acquisition'
                 : reason === 'rtcp-timeout'
                     ? 'controller-rtcp'
-                    : !receivedVideoKeyframe
+                    : warmUp || !receivedVideoKeyframe
                         ? 'first-source-keyframe'
                         : 'first-adapted-output';
-            transport.onSessionOutcome?.({ outcome: 'failed', reason, stage });
+            transport.onSessionOutcome?.({
+                outcome: 'failed',
+                reason,
+                stage,
+                ...(warmUp ? { sourceStage: error.stage, sourceReason: error.reason } : {}),
+            });
             transport.onVideoFailure?.();
         };
         /**
@@ -357,6 +421,8 @@ export class FfmpegLiveMedia {
          */
         const resetRtcpDeadline = () => {
             rtcpObserved = true;
+            rtcpReports += 1;
+            lastRtcpAt = Date.now();
             clearTimeout(initialRtcpGrace);
             clearTimeout(rtcpDeadline);
             if (!streaming) {
@@ -371,13 +437,9 @@ export class FfmpegLiveMedia {
          * Adaptation reached the negotiated output, so the session is bounded from here by RTCP liveness
          * rather than by the start backstop. The initial grace is armed from this point because media may
          * legitimately start well after the session does.
-         *
-         * A selection HomeKit has already replaced does not discharge the deadline for its replacement, however
-         * much it keeps reporting: FFmpeg reports progress on a timer whether or not new media reaches it, so
-         * only the adaptation that carries the current selection can say that selection is being served.
          */
-        const observeAdaptationProgress = (reporter) => {
-            if (stopped || (reconfigurationPending && reporter === videoProcess)) {
+        const observeAdaptationProgress = () => {
+            if (stopped) {
                 return;
             }
             clearTimeout(videoStartBackstop);
@@ -406,13 +468,12 @@ export class FfmpegLiveMedia {
          * Writes one source access unit to the adaptation that is entitled to code it.
          *
          * A source configuration the running adaptation was not opened for cannot be coded by it at all, so those
-         * frames wait for the keyframe that lets a replacement start. A reconfigured HomeKit selection changes
-         * only the output, so the current process keeps coding and keeps the previous selection on the wire until
-         * that same keyframe arrives; a controller reconfigures precisely when it is unhappy with what it
-         * receives, and the source is then often the very thing not producing keyframes.
+         * frames wait for the keyframe that lets a replacement start.
          *
          * Source-driven replacement is bounded by {@link MAX_SOURCE_INPUT_REPLACEMENTS}, past which the session
-         * fails rather than spawn again. A controller-driven one is not: the controller bounds how often it asks.
+         * fails rather than spawn again. It is the only replacement a session makes: a source that changes what it
+         * delivers cannot be coded by the running process at all, whereas a controller's renegotiated selection is
+         * a request this session declines in favour of the one it started on.
          */
         const writeVideo = (frame) => {
             if (stopped || !negotiated || !videoConfig) {
@@ -428,29 +489,28 @@ export class FfmpegLiveMedia {
             if (videoProcess && inputChanged && !frame.keyframe) {
                 return;
             }
-            if (videoProcess && frame.keyframe && (inputChanged || reconfigurationPending)) {
-                if (inputChanged) {
-                    sourceInputReplacements += 1;
-                }
+            if (videoProcess && frame.keyframe && inputChanged) {
+                sourceInputReplacements += 1;
                 if (sourceInputReplacements > MAX_SOURCE_INPUT_REPLACEMENTS) {
                     failVideo('source-input-unstable');
                     return;
                 }
-                reconfigurationPending = false;
+                videoCause = 'source-configuration';
                 stopProcess(videoProcess);
                 videoProcess = undefined;
             }
             if (!videoProcess) {
                 adaptationConfig = videoConfig;
-                const child = this.createProcess(this.executable, videoArguments(videoConfig, negotiated.video, targetAddress, transport.video));
+                videoSequence = (videoSequence + OUTPUT_SEQUENCE_STEP) & 0xffff;
+                const child = this.createProcess(this.executable, videoArguments(videoConfig, negotiated.video, targetAddress, transport.video, videoSequence, copyVideo, constantQuality));
                 videoProcess = child;
-                adaptationDiagnostics?.report({ role: 'live-video', event: 'started' });
+                adaptationDiagnostics?.report({ role: 'live-video', event: 'started', cause: videoCause });
                 const stderr = new AdaptationStderr();
                 let producedOutput = false;
                 child.stderr.on('data', (chunk) => {
                     if (stderr.observe(chunk).some((line) => line.startsWith('progress='))) {
                         producedOutput = true;
-                        observeAdaptationProgress(child);
+                        observeAdaptationProgress();
                     }
                 });
                 child.stdin.on('error', () => {
@@ -485,6 +545,9 @@ export class FfmpegLiveMedia {
                 audioInputCodec = frame.codec;
                 const child = this.createProcess(this.executable, audioArguments(frame, negotiated.audio, targetAddress, transport.audio));
                 audioProcess = child;
+                if (frame.config) {
+                    writeToAdaptation(child.stdin, Buffer.concat([FLV_FILE_HEADER, flvAacTag(0, frame.config)]));
+                }
                 adaptationDiagnostics?.report({ role: 'live-audio', event: 'started' });
                 const stderr = new AdaptationStderr();
                 let producedOutput = false;
@@ -535,7 +598,7 @@ export class FfmpegLiveMedia {
                 writeAudio(frame);
                 return;
             }
-            writeToAdaptation(audioProcess.stdin, frame.data);
+            writeToAdaptation(audioProcess.stdin, frame.config ? flvAacTag(1, frame.data) : frame.data);
         };
         /**
          * Write one decoded return-audio chunk through the SDK writable that owns ADTS frame recovery,
@@ -668,7 +731,9 @@ export class FfmpegLiveMedia {
                         return;
                     }
                     reportAdaptation('return-audio', producedOutput ? 'exited-while-streaming' : 'exited-before-output', stderr, code, signal);
-                    failTalkback('adaptation-failed');
+                    failTalkback(stderr.tail().some((line) => line.includes('Error during demuxing: Operation timed out'))
+                        ? 'no-controller-audio'
+                        : 'adaptation-failed');
                 });
                 child.stdin.end(returnAudioSdp(audioPort.port, selection, transport.audio, transport.addressVersion));
                 await delay(RETURN_AUDIO_BIND_GRACE_MS);
@@ -684,12 +749,14 @@ export class FfmpegLiveMedia {
                 if (stopped) {
                     throw new Error('live media session is already stopped');
                 }
-                negotiated = selection;
+                negotiated = { ...selection, video: { ...selection.video, mtu: Math.min(selection.video.mtu, maxVideoPacketSize) } };
                 const returnAudioReady = startReturnAudio(camera, selection.audio);
                 let sourcePromise;
                 let acquisitionDeadline;
+                const acquisition = new AbortController();
+                acquiring = acquisition;
                 try {
-                    sourcePromise = camera.live();
+                    sourcePromise = camera.live({ signal: acquisition.signal });
                     void sourcePromise.then((lateSource) => {
                         if (stopped && source !== lateSource) {
                             lateSource.stop();
@@ -704,11 +771,13 @@ export class FfmpegLiveMedia {
                     ]);
                 }
                 catch (error) {
-                    failVideo(error === SOURCE_ACQUISITION_TIMEOUT ? 'source-acquisition-timeout' : sourceFailure(error));
+                    acquisition.abort(new Error('live media source acquisition was cancelled'));
+                    failVideo(error === SOURCE_ACQUISITION_TIMEOUT ? 'source-acquisition-timeout' : sourceFailure(error), error);
                     throw error === SOURCE_ACQUISITION_TIMEOUT ? new Error('live media source acquisition timed out') : error;
                 }
                 finally {
                     clearTimeout(acquisitionDeadline);
+                    acquiring = undefined;
                 }
                 if (stopped) {
                     source.stop();
@@ -724,43 +793,25 @@ export class FfmpegLiveMedia {
                         notice.extend();
                     }
                 });
-                source.on('error', (error) => failVideo(sourceFailure(error)));
+                source.on('error', (error) => failVideo(sourceFailure(error), error));
                 source.on('stop', () => failVideo('source-stopped'));
                 await returnAudioReady;
             },
-            /**
-             * Acknowledges a reconfigured selection and applies it at the next source keyframe.
-             *
-             * Nothing is torn down here: the current adaptation keeps the previous selection on the wire until the
-             * replacement has a keyframe to start from. The deferral is still bounded, because a session that never
-             * applies the selection HomeKit asked for must end and be renegotiated rather than silently serve the
-             * old one forever.
-             */
-            reconfigure(video) {
-                if (!negotiated) {
-                    return;
-                }
-                negotiated = { ...negotiated, video };
-                reconfigurationPending = videoProcess !== undefined;
-                clearTimeout(videoStartBackstop);
-                videoStartBackstop = setTimeout(() => failVideo('no-video-within-backstop'), SOURCE_START_BACKSTOP_MS);
-                videoStartBackstop.unref?.();
-            },
             stop,
         };
     }
 }
 /**
- * Options every adapted elementary stream applies to its own input.
+ * Options every adapted input applies to itself: a piped elementary stream, or audio framed as FLV.
  *
- * A piped elementary stream carries no container, so FFmpeg's initial stream analysis is the only thing
- * standing between the first written access unit and the first coded frame. The caller already declares the
- * format, so that analysis has nothing left to discover and is bounded to its minimum; leaving it at the
+ * FFmpeg's initial stream analysis is the only thing standing between the first written access unit and the
+ * first coded frame. The caller already declares the format, and an FLV input states its decoder config in its
+ * first tag, so that analysis has nothing left to discover and is bounded to its minimum; leaving it at the
  * default delays first output by seconds and scales that delay with the source keyframe interval.
  *
- * Every such input is read on one clock: when its media arrived. A pipe carries no timeline of its own, so
- * arrival is the only timeline there is, and two adapted streams of one session can be presented together
- * only while both are read on it.
+ * Every such input is read on one clock: when its media arrived. An elementary stream carries no timeline of its
+ * own and the FLV tags this plugin writes carry none either, so arrival is the only timeline there is, and two
+ * adapted streams of one session can be presented together only while both are read on it.
  *
  * Nothing asks FFmpeg to discard or reinterpret what it read. Discarding the analysed packets throws away the
  * leading keyframe the caller waited for, and a raw A-law demuxer stops emitting timestamps entirely, so both
@@ -787,12 +838,21 @@ function commonArguments(inputFormat, inputOptions = []) {
         'pipe:0',
     ];
 }
-function outputArguments(targetAddress, target, payloadType, ssrc, packetSize) {
+/**
+ * The RTP output one adaptation sends on: the controller's endpoint, the identity the session negotiated for
+ * it, and where its sequence numbering starts.
+ *
+ * `sequence` is stated wherever a session may send on more than one adaptation, because the identity and the
+ * SRTP key outlive the process: see {@link OUTPUT_SEQUENCE_STEP} for what a restarted numbering costs. An
+ * output no replacement can follow omits it and keeps FFmpeg's own base.
+ */
+function outputArguments(targetAddress, target, payloadType, ssrc, packetSize, sequence) {
     return [
         '-payload_type',
         String(payloadType),
         '-ssrc',
         String(ssrc),
+        ...(sequence === undefined ? [] : ['-seq', String(sequence)]),
         '-f',
         'rtp',
         '-srtp_out_suite',
@@ -811,11 +871,19 @@ function outputArguments(targetAddress, target, payloadType, ssrc, packetSize) {
  * every frame it was given.
  *
  * A negotiated frame rate is a CEILING, not a cadence, so the rate is bounded rather than pinned. Pinning it
- * makes the encoder duplicate frames the source never sent, and each duplicate costs a full encode and a share
- * of the negotiated bit rate for a picture carrying nothing new. Measured on a 1600x1200 doorbell delivering
- * about 15 fps against a 30 fps selection: 264 of 267 emitted frames were duplicates and the adaptation ran at
- * 0.32x real time, so it fell further behind every second and the session died on its backstop with nothing
- * watchable reaching the controller.
+ * with `-r` makes the encoder interpolate a cadence a bare Annex-B pipe never states, which collapses a session
+ * onto one instant.
+ *
+ * The output is constant-rate, which fills a gap in arrival with a duplicate of the last picture rather than
+ * carrying the gap. A duplicate costs a full encode and a share of the negotiated bit rate for a frame carrying
+ * nothing new, and a source over this transport gaps as its normal case: measured on the bundled encoder against
+ * a 15 fps arrival stalled 1.5 seconds after every second of media, a constant rate emitted 266 frames of which
+ * 146 were duplicates, against 120 frames and none when the arrival timestamps were passed through, at the same
+ * 0.90x real time either way. What the duplicates buy is a dense presentation timeline: a controller shown the
+ * gaps instead displays a picture that visibly jumps at every one of them.
+ *
+ * `-fpsmax` states that ceiling for a constant-rate output only, and FFmpeg refuses it beside any other
+ * frame-rate mode, so the two cannot be combined.
  *
  * A negotiated selection states no refresh cadence, so the keyframe interval is plugin policy: `-g` and
  * `-keyint_min` are the negotiated rate doubled and scene-cut detection is off, which is a refresh every two
@@ -834,9 +902,29 @@ function outputArguments(targetAddress, target, payloadType, ssrc, packetSize) {
  * coded stream can carry a negotiated Main or High profile; `ultrafast` drops CABAC and codes Constrained
  * Baseline whatever `-profile:v` asks for. `-tune zerolatency` pins the same `sliced_threads`, `bframes`
  * and `rc_lookahead` at either preset, so this costs computation rather than frame delay.
+ *
+ * `copy` sends an H.264 source as the camera coded it, with no encoder in the process. Nothing above then holds:
+ * the geometry, frame rate, bit rate, profile and keyframe interval are the camera's own, not the negotiated
+ * selection. Only the RTP output is the negotiated one. An H.265 source is transcoded either way.
+ *
+ * `constantQuality` codes at {@link CONSTANT_QUALITY_CRF} with no rate control, so the negotiated bit rate is not
+ * honoured: the output spends what the picture needs. A controller asks 299 kbps for 720p and does not raise it
+ * during a session, which the ceiling above codes as a blurred, then blocky, picture.
  */
-function videoArguments(input, selection, targetAddress, target) {
+function videoArguments(input, selection, targetAddress, target, sequence, copy = false, constantQuality = false) {
+    if (copy && input.codec === 'h264') {
+        return [
+            ...commonArguments('h264'),
+            '-an',
+            '-c:v',
+            'copy',
+            ...outputArguments(targetAddress, target, selection.payloadType, selection.ssrc, selection.mtu, sequence),
+        ];
+    }
     const budget = videoBudgetInsideCeiling(selection);
+    const rate = constantQuality
+        ? ['-crf', String(CONSTANT_QUALITY_CRF)]
+        : ['-b:v', `${budget}k`, '-maxrate', `${budget}k`, '-bufsize', `${budget}k`];
     return [
         ...commonArguments(input.codec === 'h265' ? 'hevc' : input.codec),
         '-an',
@@ -862,22 +950,51 @@ function videoArguments(input, selection, targetAddress, target) {
         String(selection.fps * 2),
         '-sc_threshold',
         '0',
-        '-b:v',
-        `${budget}k`,
-        '-maxrate',
-        `${budget}k`,
-        '-bufsize',
-        `${budget}k`,
-        ...outputArguments(targetAddress, target, selection.payloadType, selection.ssrc, selection.mtu),
+        ...rate,
+        ...outputArguments(targetAddress, target, selection.payloadType, selection.ssrc, selection.mtu, sequence),
     ];
 }
+/** FLV signature, version 1, the audio-only flag, header size 9, and the zero size of the tag before the first. */
+const FLV_FILE_HEADER = Buffer.from([0x46, 0x4c, 0x56, 0x01, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00]);
 /**
- * Adapts one source audio elementary stream to the negotiated AAC-ELD output.
+ * One FLV audio tag of an AAC elementary stream and its trailing size. The body is the AAC sound flags 0xaf, the AAC
+ * packet type (0 for the AudioSpecificConfig, 1 for one access unit) and `payload` unchanged. The sound flags fix the
+ * 44 kHz, 16-bit, stereo values the format requires; an AAC decoder takes the real parameters from the
+ * AudioSpecificConfig. The timestamp, its extension and the stream id are zero: the stream carries no timeline of its
+ * own, because its reader stamps every tag with the instant it arrived.
+ */
+function flvAacTag(packetType, payload) {
+    const header = Buffer.alloc(13);
+    header[0] = 8;
+    header.writeUIntBE(payload.length + 2, 1, 3);
+    header[11] = 0xaf;
+    header[12] = packetType;
+    const previousTagSize = Buffer.alloc(4);
+    previousTagSize.writeUInt32BE(13 + payload.length);
+    return Buffer.concat([header, payload, previousTagSize]);
+}
+/**
+ * The FFmpeg input format and input options for one source audio stream.
  *
- * The SDK reports no sample rate or channel count, because a station sends neither; 16 kHz mono is the
- * assumption every Eufy client applies. Raw A-law carries nothing at all and must be told that assumption,
- * while an ADTS input states its own rate in every frame header and rejects the option outright, which fails
- * the process before it reads a byte.
+ * A stream whose decoder config travels apart from its access units is framed as FLV, which states that config
+ * once ahead of them, and is decoded by `libfdk_aac`, which decodes AAC-ELD in the config the SDK declares. Outside
+ * such a config the SDK reports no sample rate or channel count, because a station sends neither;
+ * 16 kHz mono is the assumption every Eufy client applies. Raw A-law carries nothing at all and must be told that
+ * assumption, while an ADTS input states its own rate in every frame header and rejects the option outright, which
+ * fails the process before it reads a byte.
+ */
+function audioInput(frame) {
+    if (frame.config) {
+        return ['flv', ['-c:a', 'libfdk_aac']];
+    }
+    if (frame.codec === 'g711a') {
+        return ['alaw', ['-ar', '16k', '-ac', '1']];
+    }
+    return ['aac', []];
+}
+/**
+ * Adapts one source audio elementary stream to the negotiated AAC-ELD output, reading it as {@link audioInput}
+ * describes.
  *
  * Asynchronous resampling is what makes this output honour the arrival clock its input is read on. An encoder
  * advances its output timeline by the samples in each coded frame it is handed, whatever timestamp arrived
@@ -890,13 +1007,12 @@ function videoArguments(input, selection, targetAddress, target) {
  * accident of the filter: a live view owes its controller the newest audio, and audio which is already
  * seconds stale by the time it arrives cannot be presented beside a picture timestamped on arrival.
  *
- * `libfdk_aac` selects its transport from the requested output framing, and AAC-ELD cannot be carried in
+ * The `libfdk_aac` encoder selects its transport from the requested output framing, and AAC-ELD cannot be carried in
  * ADTS, so without an explicit global header the encoder refuses to initialise at all.
  */
 function audioArguments(frame, selection, targetAddress, target) {
-    const rawAlaw = frame.codec === 'g711a';
     return [
-        ...commonArguments(rawAlaw ? 'alaw' : 'aac', rawAlaw ? ['-ar', '16k', '-ac', '1'] : []),
+        ...commonArguments(...audioInput(frame)),
         '-vn',
         '-c:a',
         'libfdk_aac',