@lox-audioserver/node-airplay-sender 0.4.0

package/dist/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;

package/dist/core/deviceAirtunes.d.ts

@@ -0,0 +1,76 @@
+import dgram from 'node:dgram';
+import { EventEmitter } from 'node:events';
+import UDPServers from './udpServers';
+type AnyObject = Record<string, unknown>;
+type RTSPClient = {
+    on: (event: string, cb: (...args: any[]) => void) => void;
+    once: (event: string, cb: (...args: any[]) => void) => void;
+    startHandshake: (udpServers: any, host: string, port: number) => void;
+    teardown: () => void;
+    setVolume: (volume: number, callback?: (err?: unknown) => void) => void;
+    setTrackInfo: (name: string, artist?: string, album?: string, callback?: (err?: unknown) => void) => void;
+    setProgress: (progress: number, duration: number, callback?: (err?: unknown) => void) => void;
+    setArtwork: (art: Buffer, contentType?: string, callback?: (err?: unknown) => void) => void;
+    setPasscode: (password: string) => void;
+};
+type Packet = {
+    seq: number;
+    pcm: Buffer;
+    timestamp: number;
+};
+type LogFn = (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown) => void;
+declare class BufferWithNames {
+    private readonly size;
+    private readonly buffer;
+    constructor(size: number);
+    add(name: string | number, item: any): void;
+    getLatestNamed(name: string | number): any;
+}
+type AirTunesDeviceInstance = EventEmitter & {
+    audioPacketHistory: BufferWithNames | null;
+    udpServers: UDPServers;
+    audioOut: EventEmitter;
+    type: string;
+    deviceMagic: number;
+    options: AnyObject;
+    host: string;
+    port: number;
+    key: string;
+    mode: number;
+    forceAlac: boolean;
+    statusflags: string[];
+    alacEncoding: boolean;
+    inputCodec: 'pcm' | 'alac';
+    airplay2: boolean;
+    txt: string[];
+    borkedshp: boolean;
+    needPassword: boolean;
+    needPin: boolean;
+    transient: boolean;
+    features: string[];
+    rtsp: RTSPClient | null;
+    audioCallback: ((packet: Packet) => void) | null;
+    encoder: any[];
+    credentials: any;
+    audioSocket: dgram.Socket | null;
+    status: string;
+    serverPort: number;
+    controlPort: number;
+    timingPort: number;
+    audioLatency: number;
+    requireEncryption: boolean;
+    log?: LogFn;
+    logLine?: (...args: any[]) => void;
+    doHandshake: () => void;
+    relayAudio: () => void;
+    cleanup: () => void;
+    onUnderrun?: () => void;
+    audioNonce: number;
+    packetsSent: number;
+};
+/**
+ * Construct a RAOP/AirPlay device handler.
+ * Accepts discovery TXT/flags and wires RTSP handshake to UDP audio.
+ */
+declare function AirTunesDevice(this: AirTunesDeviceInstance, host: string | null, audioOut: EventEmitter, options: AnyObject, mode?: number, txt?: string[] | string): void;
+export default AirTunesDevice;