@lox-audioserver/node-airplay-sender 0.4.0

package/dist/esm/core/atvAuthenticator.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const elliptic = require('elliptic');
+const crypto_1 = __importDefault(require("crypto"));
+const ed = __importStar(require("@noble/ed25519"));
+const util_1 = require("../utils/util");
+// ...
+// Note: All functions expect parameters to be hex strings.
+function pair_setup_aes_key(K) {
+    return crypto_1.default.createHash('sha512')
+        .update('Pair-Setup-AES-Key')
+        .update((0, util_1.hexString2ArrayBuffer)(K))
+        .digest('hex')
+        .substring(0, 32);
+}
+function pair_setup_aes_iv(K) {
+    let ab = crypto_1.default.createHash('sha512')
+        .update('Pair-Setup-AES-IV')
+        .update((0, util_1.hexString2ArrayBuffer)(K))
+        .digest();
+    ab = ab.slice(0, 16);
+    ab[ab.length - 1] += 0x01;
+    return (0, util_1.buf2hex)(ab);
+}
+function pair_verify_aes_key(shared) {
+    return (0, util_1.buf2hex)(crypto_1.default.createHash('sha512')
+        .update('Pair-Verify-AES-Key')
+        .update((0, util_1.hexString2ArrayBuffer)(shared))
+        .digest()
+        .slice(0, 16));
+}
+function pair_verify_aes_iv(shared) {
+    return (0, util_1.buf2hex)(crypto_1.default.createHash('sha512')
+        .update('Pair-Verify-AES-IV')
+        .update((0, util_1.hexString2ArrayBuffer)(shared))
+        .digest()
+        .slice(0, 16));
+}
+// ...
+// Public.
+function a_pub(a) {
+    return elliptic.utils.toHex(new elliptic.eddsa('ed25519').keyFromSecret(a).getPublic());
+}
+function confirm(a, K) {
+    const key = pair_setup_aes_key(K);
+    const iv = pair_setup_aes_iv(K);
+    const cipher = crypto_1.default.createCipheriv('aes-128-gcm', (0, util_1.hexString2ArrayBuffer)(key), (0, util_1.hexString2ArrayBuffer)(iv));
+    const encrypted = Buffer.concat([
+        cipher.update((0, util_1.hexString2ArrayBuffer)(a_pub(a))),
+        cipher.final(),
+    ]);
+    return {
+        epk: encrypted.toString('hex'),
+        authTag: (0, util_1.buf2hex)(cipher.getAuthTag()),
+    };
+}
+function verifier(a) {
+    const privateKey = Buffer.from(ed.utils.randomPrivateKey());
+    const publicKey = Buffer.from(ed.curve25519.scalarMultBase(privateKey));
+    const v_pri = (0, util_1.buf2hex)(privateKey);
+    const v_pub = (0, util_1.buf2hex)(publicKey);
+    const header = Buffer.from([0x01, 0x00, 0x00, 0x00]);
+    const a_pub_buf = Buffer.from(a_pub(a), 'hex');
+    return {
+        verifierBody: Buffer.concat([header, publicKey, a_pub_buf], header.byteLength + publicKey.byteLength + a_pub_buf.byteLength),
+        v_pri,
+        v_pub
+    };
+}
+function shared(v_pri, atv_pub) {
+    return (0, util_1.buf2hex)(Buffer.from(ed.curve25519.scalarMult((0, util_1.hexString2ArrayBuffer)(v_pri), (0, util_1.hexString2ArrayBuffer)(atv_pub))));
+}
+function signed(a, v_pub, atv_pub) {
+    const key = new elliptic.eddsa('ed25519').keyFromSecret(a);
+    return key.sign(v_pub + atv_pub).toHex();
+}
+function signature(shared, atv_data, signed) {
+    const cipher = crypto_1.default.createCipheriv('aes-128-ctr', (0, util_1.hexString2ArrayBuffer)(pair_verify_aes_key(shared)), (0, util_1.hexString2ArrayBuffer)(pair_verify_aes_iv(shared)));
+    // discard the result of encrypting atv_data.
+    cipher.update((0, util_1.hexString2ArrayBuffer)(atv_data));
+    const encrypted = Buffer.concat([
+        cipher.update(Buffer.from(signed, 'hex')),
+        cipher.final(),
+    ]);
+    return encrypted.toString('hex');
+}
+exports.default = {
+    pair_setup_aes_key,
+    pair_setup_aes_iv,
+    pair_verify_aes_key,
+    pair_verify_aes_iv,
+    a_pub,
+    confirm,
+    verifier,
+    shared,
+    signed,
+    signature,
+};

package/dist/esm/core/audioOut.js

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const config_1 = __importDefault(require("../utils/config"));
+const numUtil_1 = require("../utils/numUtil");
+const ntp_1 = __importStar(require("../utils/ntp"));
+const SEQ_NUM_WRAP = Math.pow(2, 16);
+const FRAC_PER_SEC = 0x1_0000_0000;
+/**
+ * Generates RTP timestamps and sequence, pulling PCM/ALAC packets from a circular buffer.
+ * Emits `packet` events for devices and sync requests (`need_sync`) at intervals.
+ */
+class AudioOut extends node_events_1.EventEmitter {
+    lastSeq = -1;
+    lastWireSeq = 0;
+    hasAirTunes = false;
+    rtpTimeRef = 0;
+    startTimeMs;
+    startTimeNtp;
+    latencyFrames = 0;
+    latencyApplied = false;
+    seqOffset = 0;
+    tsOffset = 0;
+    syncOffsetFrames = 0;
+    deviceMagic = 0;
+    packetCount = 0;
+    octetCount = 0;
+    frameDurationMs = (config_1.default.frames_per_packet / config_1.default.sampling_rate) * 1000;
+    muteUntilMs = 0;
+    /**
+     * Begin pulling from the buffer and emitting packets at the configured cadence.
+     * @param devices Device manager for sync events.
+     * @param circularBuffer PCM/ALAC buffer.
+     * @param startTimeMs Optional unix ms to align playback.
+     * @param startTimeNtp Optional NTP uint64 (sec<<32|frac) to align playback.
+     */
+    init(devices, circularBuffer, startTimeMs, startTimeNtp, deviceMagic, underrunMuteMs) {
+        this.startTimeMs =
+            typeof startTimeMs === 'number' && Number.isFinite(startTimeMs)
+                ? startTimeMs
+                : undefined;
+        this.startTimeNtp = startTimeNtp;
+        this.seqOffset = Math.floor(Math.random() * SEQ_NUM_WRAP);
+        this.tsOffset = Math.floor(Math.random() * 0xffffffff);
+        this.syncOffsetFrames = this.tsOffset / config_1.default.frames_per_packet;
+        this.deviceMagic = typeof deviceMagic === 'number' ? deviceMagic : config_1.default.device_magic;
+        if (typeof underrunMuteMs === 'number') {
+            config_1.default.underrun_mute_ms = underrunMuteMs;
+        }
+        circularBuffer.on('underrun', () => this.handleUnderrun());
+        const monoNow = node_perf_hooks_1.performance.now();
+        const wallToMonoOffset = Date.now() - monoNow;
+        if (typeof this.startTimeNtp === 'bigint' || typeof this.startTimeNtp === 'number') {
+            const { sec, frac } = (0, ntp_1.parseNtpTimestamp)(this.startTimeNtp);
+            const unixMs = (sec - config_1.default.ntp_epoch) * 1000 + Math.floor((frac * 1000) / FRAC_PER_SEC);
+            const nowMs = config_1.default.use_monotonic_clock ? monoNow : Date.now();
+            const delta = unixMs - nowMs;
+            // If target is too close/past, clamp to now.
+            this.rtpTimeRef = delta > -config_1.default.stream_latency ? unixMs - wallToMonoOffset : nowMs;
+        }
+        else if (this.startTimeMs !== undefined) {
+            const nowMs = config_1.default.use_monotonic_clock ? monoNow : Date.now();
+            const delta = this.startTimeMs - nowMs;
+            this.rtpTimeRef = delta > -config_1.default.stream_latency ? this.startTimeMs - wallToMonoOffset : nowMs;
+        }
+        else if (config_1.default.use_monotonic_clock) {
+            this.rtpTimeRef = monoNow;
+        }
+        else {
+            this.rtpTimeRef = Date.now();
+        }
+        devices.on('airtunes_devices', (hasAirTunes) => {
+            this.hasAirTunes = hasAirTunes;
+        });
+        devices.on('need_sync', () => {
+            this.emit('need_sync', { seq: this.lastWireSeq, tsOffsetFrames: this.syncOffsetFrames });
+        });
+        const syncEvery = config_1.default.sync_period && config_1.default.sync_period > 0
+            ? config_1.default.sync_period
+            : Math.max(1, Math.round(config_1.default.sampling_rate / config_1.default.frames_per_packet));
+        const sendPacket = (seq) => {
+            const wireSeq = (this.seqOffset + seq) % SEQ_NUM_WRAP;
+            const packet = circularBuffer.readPacket();
+            packet.seq = wireSeq;
+            packet.timestamp = (0, numUtil_1.low32)(this.tsOffset + wireSeq * config_1.default.frames_per_packet + 2 * config_1.default.sampling_rate);
+            this.packetCount += 1;
+            this.octetCount += packet.pcm.length;
+            if (this.hasAirTunes && seq % syncEvery === 0) {
+                this.emit('need_sync', {
+                    seq: wireSeq,
+                    tsOffsetFrames: this.syncOffsetFrames,
+                    rtcp: {
+                        rtpTimestamp: packet.timestamp,
+                        ntp: ntp_1.default.timestamp(),
+                        packetCount: this.packetCount,
+                        octetCount: this.octetCount,
+                        xr: { ntp: ntp_1.default.timestamp() },
+                    },
+                });
+                const nowMs = config_1.default.use_monotonic_clock ? node_perf_hooks_1.performance.now() : Date.now();
+                const expectedTimeMs = this.rtpTimeRef +
+                    (((seq + this.syncOffsetFrames) * config_1.default.frames_per_packet) / config_1.default.sampling_rate) * 1000;
+                const deltaMs = nowMs - expectedTimeMs;
+                this.emit('metrics', { type: 'sync', seq: wireSeq, deltaMs, latencyFrames: this.latencyFrames });
+            }
+            this.emit('packet', packet);
+            if (this.muteUntilMs > 0) {
+                const nowMsSend = config_1.default.use_monotonic_clock ? node_perf_hooks_1.performance.now() : Date.now();
+                if (nowMsSend < this.muteUntilMs) {
+                    packet.pcm.fill(0);
+                }
+                else {
+                    this.muteUntilMs = 0;
+                }
+            }
+            packet.release();
+            this.lastWireSeq = wireSeq;
+        };
+        const syncAudio = () => {
+            const nowMs = config_1.default.use_monotonic_clock ? node_perf_hooks_1.performance.now() : Date.now();
+            const elapsed = nowMs - this.rtpTimeRef;
+            if (elapsed < 0) {
+                setTimeout(syncAudio, Math.min(config_1.default.stream_latency, Math.abs(elapsed)));
+                return;
+            }
+            let currentSeq = Math.floor((elapsed * config_1.default.sampling_rate) / (config_1.default.frames_per_packet * 1000));
+            // If we're lagging behind significantly, jump forward to avoid long hitches.
+            if (config_1.default.jump_forward_enabled) {
+                const expectedTimeMs = this.rtpTimeRef + currentSeq * this.frameDurationMs;
+                const deltaMs = nowMs - expectedTimeMs;
+                if (deltaMs > config_1.default.jump_forward_threshold_ms) {
+                    const jumpSeq = Math.ceil((config_1.default.jump_forward_lead_ms * config_1.default.sampling_rate) /
+                        (config_1.default.frames_per_packet * 1000));
+                    const newSeq = currentSeq + jumpSeq;
+                    this.rtpTimeRef = nowMs - newSeq * this.frameDurationMs;
+                    this.lastSeq = newSeq - 1;
+                    currentSeq = newSeq;
+                }
+            }
+            for (let i = this.lastSeq + 1; i <= currentSeq; i += 1) {
+                sendPacket(i);
+            }
+            this.lastSeq = currentSeq;
+            setTimeout(syncAudio, config_1.default.stream_latency);
+        };
+        // If a future start is scheduled, defer until then; otherwise start immediately.
+        const nowMs = config_1.default.use_monotonic_clock ? node_perf_hooks_1.performance.now() : Date.now();
+        const delayMs = Math.max(0, this.rtpTimeRef - nowMs);
+        if (delayMs > 0) {
+            setTimeout(syncAudio, delayMs);
+        }
+        else {
+            syncAudio();
+        }
+    }
+    /**
+     * Apply latency (in audio frames) when aligning start time.
+     */
+    setLatencyFrames(latencyFrames) {
+        if (!Number.isFinite(latencyFrames) || latencyFrames <= 0) {
+            return;
+        }
+        this.latencyFrames = latencyFrames;
+        if ((this.startTimeMs === undefined && this.startTimeNtp === undefined) || this.latencyApplied) {
+            return;
+        }
+        const latencyMs = (this.latencyFrames / config_1.default.sampling_rate) * 1000;
+        this.rtpTimeRef -= latencyMs;
+        this.latencyApplied = true;
+    }
+    handleUnderrun() {
+        const nowMs = config_1.default.use_monotonic_clock ? node_perf_hooks_1.performance.now() : Date.now();
+        const currentSeq = Math.max(0, this.lastSeq);
+        const currentFrames = currentSeq * config_1.default.frames_per_packet;
+        const offsetMs = (currentFrames / config_1.default.sampling_rate) * 1000;
+        this.rtpTimeRef = nowMs - offsetMs;
+        if (config_1.default.underrun_mute_ms > 0) {
+            this.muteUntilMs = nowMs + config_1.default.underrun_mute_ms;
+        }
+        this.emit('underrun');
+    }
+}
+exports.default = AudioOut;