lox-airplay-sender 0.1.0

package/dist/core/devices.js

@@ -0,0 +1,209 @@
+"use strict";
+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 async_1 = __importDefault(require("async"));
+const deviceAirtunes_1 = __importDefault(require("./deviceAirtunes"));
+/**
+ * Tracks and controls all connected AirPlay/RAOP devices.
+ * Responsible for lifecycle, fan-out of state, and sync signaling.
+ */
+class Devices extends node_events_1.EventEmitter {
+    audioOut;
+    devices = {};
+    hasAirTunes = false;
+    constructor(audioOut) {
+        super();
+        this.audioOut = audioOut;
+    }
+    /** Wire device sync events from AudioOut into individual devices. */
+    init() {
+        this.audioOut.on('need_sync', (seq) => {
+            this.forEach((dev) => {
+                try {
+                    if (dev.onSyncNeeded && dev.controlPort) {
+                        dev.onSyncNeeded(seq);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            });
+        });
+    }
+    /** Iterate over live devices. */
+    forEach(it) {
+        for (const key of Object.keys(this.devices)) {
+            it(this.devices[key], key);
+        }
+    }
+    /**
+     * Add (or reuse) a device and start playback.
+     * @param type Device type (airtunes/coreaudio).
+     * @param host Target host/IP.
+     * @param options Transport options (volume/password/etc).
+     * @param mode RAOP mode (0 default, 2 for AirPlay 2).
+     * @param txt TXT records advertised by the device.
+     */
+    add(type, host, options, mode = 0, txt = '') {
+        this.emit('status', host ?? 'unknown', 'connecting', '');
+        const dev = new deviceAirtunes_1.default(host, this.audioOut, options, mode, txt);
+        const previousDev = this.devices[dev.key];
+        if (previousDev) {
+            previousDev.reportStatus();
+            return previousDev;
+        }
+        this.devices[dev.key] = dev;
+        dev.on('status', (status) => {
+            if (status === 'error' || status === 'stopped') {
+                delete this.devices[dev.key];
+                this.checkAirTunesDevices();
+            }
+            if (this.hasAirTunes && status === 'playing') {
+                this.emit('need_sync');
+            }
+            this.emit('status', dev.key, status, '');
+        });
+        dev.start();
+        this.checkAirTunesDevices();
+        return dev;
+    }
+    /** Adjust volume on one device. */
+    setVolume(key, volume, callback) {
+        const dev = this.devices[key];
+        if (!dev) {
+            this.emit('status', key, 'error', 'not_found');
+            return;
+        }
+        dev.setVolume(volume, callback);
+    }
+    /** Push playback position to one or all devices. */
+    setProgress(key, progress, duration, callback) {
+        try {
+            if (key === 'all') {
+                for (const device of Object.keys(this.devices)) {
+                    try {
+                        this.devices[device].setProgress(progress, duration, callback);
+                    }
+                    catch (err) {
+                        if (err?.name === 'TypeError') {
+                            delete this.devices[device];
+                        }
+                    }
+                }
+                return;
+            }
+            const dev = this.devices[key];
+            if (!dev) {
+                this.emit('status', key, 'error', 'not_found');
+                return;
+            }
+            dev.setProgress(progress, duration, callback);
+        }
+        catch {
+            // ignore
+        }
+    }
+    /**
+     * Update track info on one or all devices.
+     */
+    setTrackInfo(key, name, artist, album, callback) {
+        try {
+            if (key === 'all') {
+                for (const device of Object.keys(this.devices)) {
+                    try {
+                        this.devices[device].setTrackInfo(name, artist, album, callback);
+                    }
+                    catch (err) {
+                        if (err?.name === 'TypeError') {
+                            delete this.devices[device];
+                        }
+                    }
+                }
+                return;
+            }
+            const dev = this.devices[key];
+            if (!dev) {
+                this.emit('status', key, 'error', 'not_found');
+                return;
+            }
+            dev.setTrackInfo(name, artist, album, callback);
+        }
+        catch {
+            // ignore
+        }
+    }
+    /** Update artwork on one or all devices. */
+    setArtwork(key, art, contentType, callback) {
+        try {
+            if (key === 'all') {
+                for (const device of Object.keys(this.devices)) {
+                    try {
+                        this.devices[device].setArtwork(art, contentType, callback);
+                    }
+                    catch (err) {
+                        if (err?.name === 'TypeError') {
+                            delete this.devices[device];
+                        }
+                    }
+                }
+                return;
+            }
+            const dev = this.devices[key];
+            if (!dev) {
+                this.emit('status', key, 'error', 'not_found');
+                return;
+            }
+            dev.setArtwork(art, contentType, callback);
+        }
+        catch {
+            // ignore
+        }
+    }
+    /** Provide a passcode to a specific device. */
+    setPasscode(key, passcode) {
+        const dev = this.devices[key];
+        if (!dev) {
+            this.emit('status', key, 'error', 'not_found');
+            return;
+        }
+        dev.setPasscode(passcode);
+    }
+    /** Stop one device. */
+    stop(key) {
+        const dev = this.devices[key];
+        if (!dev) {
+            this.emit('status', key, 'error', 'not_found');
+            return;
+        }
+        dev.stop();
+        delete this.devices[key];
+    }
+    /** Stop every device in parallel. */
+    stopAll(allCb) {
+        const devices = Object.values(this.devices);
+        async_1.default.each(devices, (dev, callback) => {
+            dev.stop(callback);
+        }, (err) => {
+            if (allCb) {
+                allCb(err);
+            }
+        });
+    }
+    /** Track whether any active device is RAOP to drive sync signals. */
+    checkAirTunesDevices() {
+        let hasAirTunes = false;
+        this.forEach((dev) => {
+            if (dev.type === 'airtunes') {
+                hasAirTunes = true;
+            }
+        });
+        if (hasAirTunes !== this.hasAirTunes) {
+            this.hasAirTunes = hasAirTunes;
+            this.emit('airtunes_devices', hasAirTunes);
+        }
+    }
+}
+exports.default = Devices;

package/dist/core/index.d.ts

@@ -0,0 +1,47 @@
+import { Duplex } from 'node:stream';
+import Devices from './devices';
+/**
+ * High-level RAOP/AirPlay sender that wires together devices, buffering, and output.
+ * Acts as a Duplex stream: write PCM/ALAC chunks, listen to status events.
+ */
+declare class AirTunes extends Duplex {
+    readonly devices: Devices;
+    private readonly circularBuffer;
+    /**
+     * @param options.packetSize Override packet size; defaults to config.
+     * @param options.startTimeMs Optional unix ms to align playback start.
+     */
+    constructor(options?: {
+        packetSize?: number;
+        startTimeMs?: number;
+    });
+    /** Register an AirTunes (RAOP) device and start streaming to it. */
+    add(host: string, options: Record<string, unknown>, mode?: number, txt?: string[] | string): any;
+    /** Register a CoreAudio output (legacy shim). */
+    addCoreAudio(options: Record<string, unknown>): unknown;
+    /** Stop every device and release resources. */
+    stopAll(cb?: () => void): void;
+    /** Stop a single device by key. */
+    stop(deviceKey: string): void;
+    /** Adjust volume for a device. */
+    setVolume(deviceKey: string, volume: number, callback?: (err?: unknown) => void): void;
+    /**
+     * Push playback position (seconds) to a device.
+     */
+    setProgress(deviceKey: string, progress: number, duration: number, callback?: (err?: unknown) => void): void;
+    /**
+     * Update track title/artist/album on a device.
+     */
+    setTrackInfo(deviceKey: string, name: string, artist?: string, album?: string, callback?: (err?: unknown) => void): void;
+    /** Reset the circular buffer state. */
+    reset(): void;
+    /** Send artwork to a device. */
+    setArtwork(deviceKey: string, art: Buffer, contentType?: string, callback?: (err?: unknown) => void): void;
+    /** Write PCM/ALAC frames into the buffer. */
+    write(data: Buffer): boolean;
+    /** Provide a passcode to a device requiring auth. */
+    setPasscode(deviceKey: string, passcode: string): void;
+    /** Close the writable side and stop buffering. */
+    end(chunk?: any, encoding?: any, cb?: any): this;
+}
+export default AirTunes;

package/dist/core/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const devices_1 = __importDefault(require("./devices"));
+const config_1 = __importDefault(require("../utils/config"));
+const circularBuffer_1 = __importDefault(require("../utils/circularBuffer"));
+const audioOut_1 = __importDefault(require("./audioOut"));
+/**
+ * High-level RAOP/AirPlay sender that wires together devices, buffering, and output.
+ * Acts as a Duplex stream: write PCM/ALAC chunks, listen to status events.
+ */
+class AirTunes extends node_stream_1.Duplex {
+    devices;
+    circularBuffer;
+    /**
+     * @param options.packetSize Override packet size; defaults to config.
+     * @param options.startTimeMs Optional unix ms to align playback start.
+     */
+    constructor(options = {}) {
+        super({ readableObjectMode: false, writableObjectMode: false });
+        const audioOut = new audioOut_1.default();
+        this.devices = new devices_1.default(audioOut);
+        this.devices.init();
+        this.devices.on('status', (key, status, desc) => {
+            this.emit('device', key, status, desc);
+        });
+        const packetSize = options.packetSize ?? config_1.default.packet_size;
+        this.circularBuffer = new circularBuffer_1.default(config_1.default.packets_in_buffer, packetSize);
+        this.circularBuffer.on('status', (status) => {
+            this.emit('buffer', status);
+        });
+        audioOut.init(this.devices, this.circularBuffer, options.startTimeMs);
+        this.circularBuffer.on('drain', () => {
+            this.emit('drain');
+        });
+        this.circularBuffer.on('error', (err) => {
+            this.emit('error', err);
+        });
+    }
+    /** Register an AirTunes (RAOP) device and start streaming to it. */
+    add(host, options, mode = 0, txt = '') {
+        return this.devices.add('airtunes', host, options, mode, txt);
+    }
+    /** Register a CoreAudio output (legacy shim). */
+    addCoreAudio(options) {
+        return this.devices.add('coreaudio', null, options);
+    }
+    /** Stop every device and release resources. */
+    stopAll(cb) {
+        this.devices.stopAll(cb);
+    }
+    /** Stop a single device by key. */
+    stop(deviceKey) {
+        this.devices.stop(deviceKey);
+    }
+    /** Adjust volume for a device. */
+    setVolume(deviceKey, volume, callback) {
+        this.devices.setVolume(deviceKey, volume, callback);
+    }
+    /**
+     * Push playback position (seconds) to a device.
+     */
+    setProgress(deviceKey, progress, duration, callback) {
+        this.devices.setProgress(deviceKey, progress, duration, callback);
+    }
+    /**
+     * Update track title/artist/album on a device.
+     */
+    setTrackInfo(deviceKey, name, artist, album, callback) {
+        this.devices.setTrackInfo(deviceKey, name, artist, album, callback);
+    }
+    /** Reset the circular buffer state. */
+    reset() {
+        this.circularBuffer.reset();
+    }
+    /** Send artwork to a device. */
+    setArtwork(deviceKey, art, contentType, callback) {
+        this.devices.setArtwork(deviceKey, art, contentType, callback);
+    }
+    /** Write PCM/ALAC frames into the buffer. */
+    write(data) {
+        return this.circularBuffer.write(data);
+    }
+    /** Provide a passcode to a device requiring auth. */
+    setPasscode(deviceKey, passcode) {
+        this.devices.setPasscode(deviceKey, passcode);
+    }
+    /** Close the writable side and stop buffering. */
+    end(chunk, encoding, cb) {
+        this.circularBuffer.end();
+        return super.end(chunk, encoding, cb);
+    }
+}
+exports.default = AirTunes;

package/dist/core/rtsp.d.ts

@@ -0,0 +1,12 @@
+type AnyObject = Record<string, any>;
+type LogFn = (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown) => void;
+type ClientInstance = AnyObject & {
+    log?: LogFn;
+    logLine?: (...args: any[]) => void;
+};
+declare function Client(this: ClientInstance, volume: number, password: string | null, audioOut: any, options: AnyObject): void;
+export { Client };
+declare const _default: {
+    Client: typeof Client;
+};
+export default _default;