scrypted-kasa 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "scrypted-kasa",
-   "version": "1.3.0",
+   "version": "1.3.1",
    "description": "TP-Link Kasa plugin for Scrypted — cameras (video, two-way audio, spotlight, siren, status LED), plugs/outlets, wall switches, dimmers, and smart bulbs (on/off, brightness, color, color temperature).",
    "author": "Sergey Vilgelm <sergey@vilgelm.com>",
    "license": "MIT",

package/src/camera/intercom.ts

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import { ClientRequest } from 'http';
 import https from 'https';
+import net from 'net';
 import { PassThrough } from 'stream';
 
 export const KASA_TALK_PORT = 18443;
@@ -77,6 +78,21 @@ export class KasaTalkSession {
 
         this.request = req;
 
+        // Disable Nagle on the underlying TCP socket as soon as it's available. Each 20 ms
+        // audio part we write is small (~230 B) and fewer than the segment size, so Nagle
+        // would coalesce parts waiting for an ACK or for the 200 ms deadline — adding
+        // user-perceptible chunkiness on top of the inherent network round-trip. The talk
+        // session is a constant low-rate stream, exactly the workload Nagle hurts.
+        //
+        // Cover both timings: the default https.Agent pools connections and may assign a
+        // pooled socket synchronously inside https.request(), in which case `'socket'`
+        // already fired by the time we get here and our once-listener would never run.
+        // Check `req.socket` immediately, and otherwise register a once-listener for the
+        // fresh-connection path.
+        const setSocketNoDelay = (socket: net.Socket) => socket.setNoDelay(true);
+        if (req.socket) setSocketNoDelay(req.socket as net.Socket);
+        else req.once('socket', setSocketNoDelay);
+
         req.on('error', e => {
             // Suppress when the close came first (deliberate teardown via close()): ending
             // the body mid-flight makes the in-flight HTTPS request emit "socket hang up"
@@ -127,12 +143,19 @@ export class KasaTalkSession {
 
     private writePart(contentType: string, body: Buffer): boolean {
         if (this.closed) return true;
-        const header = `--${TALK_BOUNDARY}\r\nContent-Length: ${body.length}\r\nContent-Type: ${contentType}\r\n\r\n`;
-        // Only the last write's return value matters for backpressure — if any of these
-        // fills the buffer, Node will emit `drain` after the buffer empties.
-        this.body.write(header);
-        if (body.length) this.body.write(body);
-        return this.body.write('\r\n');
+        const header = Buffer.from(
+            `--${TALK_BOUNDARY}\r\nContent-Length: ${body.length}\r\nContent-Type: ${contentType}\r\n\r\n`,
+        );
+        // Concat header + body + CRLF into one write. Three separate writes would each
+        // become its own chunked-encoding chunk on the HTTP body and (worse) its own TLS
+        // record + TCP segment. Cameras and Node's HTTP/TLS stack both prefer one part
+        // arriving as one segment — fewer per-packet ACKs and no risk of the camera
+        // partially parsing a part header before the body lands.
+        const trailer = Buffer.from('\r\n');
+        const out = body.length
+            ? Buffer.concat([header, body, trailer], header.length + body.length + trailer.length)
+            : Buffer.concat([header, trailer], header.length + trailer.length);
+        return this.body.write(out);
     }
 
     close(): void {

package/src/main.ts

@@ -502,16 +502,56 @@ class KasaCamera extends ScryptedDeviceBase implements VideoCamera, Settings, In
         // -loglevel error + -nostats: without these, ffmpeg emits a `size= time= bitrate=`
         // progress line every ~0.5 s during the talkback session. On long talks that's a
         // steady stream of stderr → string allocations + log I/O for no diagnostic value.
+        //
+        // Low-latency knobs (without these, talkback lagged ~10 s — the symptom was hearing
+        // your own voice through the camera speaker only after releasing Push-to-Talk):
+        //   -fflags +nobuffer  : skip libavformat's input prebuffer (typically 1-2 s on SDP/SRTP).
+        //   -fflags +flush_packets, -flush_packets 1
+        //                      : flush the AVIO output buffer after every encoded packet
+        //                        instead of when the 32 KB buffer fills (~4 s of 8 kHz mulaw).
+        //                        The two forms cover both global flags and the output-muxer
+        //                        explicit option; cheap belt-and-suspenders.
+        //   -flags low_delay   : codec-level low-delay decode/encode flag.
+        //   -probesize 32, -analyzeduration 0
+        //                      : skip the auto-detect probe phase, which would otherwise
+        //                        wait for ~5 s of audio to estimate stream parameters
+        //                        before producing the first output sample.
+        //   -rtsp_transport tcp, -reorder_queue_size 0   (RTSP-only, conditional)
+        //                      : force TCP-interleaved RTP and zero the demuxer's
+        //                        out-of-order reordering window. Only emitted when the
+        //                        input URL is RTSP; for non-RTSP inputs ffmpeg would just
+        //                        warn "Option not found" but the conditional keeps the arg
+        //                        list honest about which demuxer each option targets.
+        //   -max_delay 0       : zero libavformat's max-delay setting. General — applies
+        //                        to several demuxers, including RTSP/RTP — so safe to pass
+        //                        unconditionally.
+        //   -af aresample=async=0:min_hard_comp=0
+        //                      : disable async resampling. ffmpeg auto-inserts aresample
+        //                        when input/output sample rates differ (Opus 24 kHz →
+        //                        mulaw 8 kHz); async=0 keeps it operating on tiny frames
+        //                        without the multi-second resync window async=1 introduces.
+        const inputArgs = ffmpegInput.inputArguments || [];
+        const isRtspInput = inputArgs.some(a => typeof a === 'string' && a.startsWith('rtsp://'));
         // prettier-ignore
         const args = [
             '-hide_banner',
             '-loglevel', 'error',
             '-nostats',
-            ...(ffmpegInput.inputArguments || []),
+            '-fflags', '+nobuffer+flush_packets',
+            '-flags', 'low_delay',
+            '-probesize', '32',
+            '-analyzeduration', '0',
+            '-max_delay', '0',
+            ...(isRtspInput ? ['-rtsp_transport', 'tcp', '-reorder_queue_size', '0'] : []),
+            '-thread_queue_size', '1',
+            '-use_wallclock_as_timestamps', '1',
+            ...inputArgs,
             '-vn', '-sn', '-dn',
+            '-af', 'aresample=async=0:min_hard_comp=0',
             '-f', 'mulaw',
             '-ar', '8000',
             '-ac', '1',
+            '-flush_packets', '1',
             'pipe:1',
         ];
         const cp = child_process.spawn(ffmpegPath, args);