lox-airplay-sender 0.1.0

package/dist/core/deviceAirtunes.js

@@ -0,0 +1,501 @@
+"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_dgram_1 = __importDefault(require("node:dgram"));
+const node_events_1 = require("node:events");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const config_1 = __importDefault(require("../utils/config"));
+const nu = __importStar(require("../utils/numUtil"));
+const rtsp_1 = __importDefault(require("./rtsp"));
+const udpServers_1 = __importDefault(require("./udpServers"));
+const alac_1 = require("../utils/alac");
+/**
+ * AirTunes (RAOP/AirPlay) device session.
+ * Handles RTSP control, UDP audio transport, optional ALAC encoding, and authentication hints.
+ */
+const RTP_HEADER_SIZE = 12;
+function formatLogArg(value) {
+    if (Buffer.isBuffer(value)) {
+        return `<buffer len=${value.length}>`;
+    }
+    if (value instanceof Uint8Array) {
+        return `<uint8 len=${value.length}>`;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function logLine(ctx, ...args) {
+    if (!args.length) {
+        return;
+    }
+    if (ctx?.log) {
+        const formatted = args.map(formatLogArg).join(' ');
+        ctx.log('debug', formatted);
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(...args);
+}
+class BufferWithNames {
+    size;
+    buffer = [];
+    constructor(size) {
+        this.size = size;
+    }
+    add(name, item) {
+        while (this.buffer.length > this.size) {
+            this.buffer.shift();
+        }
+        this.buffer.push([name, item]);
+    }
+    getLatestNamed(name) {
+        for (let i = this.buffer.length - 1; i >= 0; i -= 1) {
+            if (this.buffer[i][0] === name) {
+                return this.buffer[i][1];
+            }
+        }
+        return undefined;
+    }
+}
+/**
+ * Construct a RAOP/AirPlay device handler.
+ * Accepts discovery TXT/flags and wires RTSP handshake to UDP audio.
+ */
+function AirTunesDevice(host, audioOut, options, mode = 0, txt = '') {
+    node_events_1.EventEmitter.call(this);
+    if (!host) {
+        throw new Error('host is mandatory');
+    }
+    this.audioPacketHistory = new BufferWithNames(100);
+    this.udpServers = new udpServers_1.default();
+    this.audioOut = audioOut;
+    this.type = 'airtunes';
+    this.options = options;
+    this.log = options?.log;
+    this.logLine = (...args) => logLine(this, ...args);
+    this.host = host;
+    this.port = Number(options?.port ?? 5000);
+    this.key = this.host + ':' + this.port;
+    this.mode = mode; // Homepods with or without passcode
+    // if (options.password != null && compatMode === true) {
+    //   this.mode = 1; // Airport / Shairport passcode mode
+    // this.mode = 2 // MFi mode
+    // }
+    this.forceAlac = options.forceAlac ?? true;
+    // this.skipAutoVolume = options.skipAutoVolume ?? false
+    this.statusflags = [];
+    this.alacEncoding = options?.alacEncoding ?? true;
+    this.inputCodec = options?.inputCodec ?? 'pcm';
+    this.airplay2 = options?.airplay2 ?? false;
+    this.txt = Array.isArray(txt) ? txt : txt ? [String(txt)] : [];
+    this.borkedshp = false;
+    if (this.airplay2 && this.mode === 0) {
+        this.mode = 2;
+    }
+    // console.debug('airplay txt', this.txt, 'port', this.port);
+    let a = this.txt.filter((u) => String(u).startsWith('et='));
+    if ((a[0] ?? '').includes('4')) {
+        this.mode = 2;
+    }
+    let b = this.txt.filter((u) => String(u).startsWith('cn='));
+    if (!this.forceAlac) {
+        if ((b[0] ?? '').includes('0')) {
+            this.alacEncoding = false;
+        }
+    }
+    let c = this.txt.filter((u) => String(u).startsWith('sf='));
+    this.statusflags = c[0] ? parseInt(c[0].substring(3)).toString(2).split('') : [];
+    if (c.length == 0) {
+        c = this.txt.filter((u) => String(u).startsWith('flags='));
+        this.statusflags = c[0] ? parseInt(c[0].substring(6)).toString(2).split('') : [];
+    }
+    this.needPassword = false;
+    this.needPin = false;
+    this.transient = false;
+    let d = this.txt.filter((u) => String(u).startsWith('features='));
+    if (d.length === 0)
+        d = this.txt.filter((u) => String(u).startsWith('ft='));
+    const features_set = d.length > 0 ? d[0].substring(d[0].indexOf('=') + 1).split(',') : [];
+    this.features = [
+        ...(features_set.length > 0 ? parseInt(features_set[0], 10).toString(2).split('') : []),
+        ...(features_set.length > 1 ? parseInt(features_set[1], 10).toString(2).split('') : []),
+    ];
+    if (this.features.length > 0) {
+        this.transient = (this.features[this.features.length - 1 - 48] == '1');
+    }
+    if (this.statusflags.length) {
+        let PasswordRequired = (this.statusflags[this.statusflags.length - 1 - 7] == '1');
+        let PinRequired = (this.statusflags[this.statusflags.length - 1 - 3] == '1');
+        let OneTimePairingRequired = (this.statusflags[this.statusflags.length - 1 - 9] == '1');
+        // console.debug('needPss', PasswordRequired, PinRequired, OneTimePairingRequired);
+        this.needPassword = PasswordRequired;
+        this.needPin = (PinRequired || OneTimePairingRequired);
+        this.transient = !(PasswordRequired || PinRequired || OneTimePairingRequired);
+    }
+    if (this.airplay2 && this.statusflags.length === 0 && !this.needPassword && !this.needPin) {
+        this.transient = true;
+    }
+    // console.debug('transient', this.transient);
+    // detect old shairports with broken text
+    let oldver1 = this.txt.filter((u) => String(u).startsWith('sm='));
+    let oldver2 = this.txt.filter((u) => String(u).startsWith('sv='));
+    if ((b[0] ?? '') === 'cn=0,1' && (a[0] ?? '') === 'et=0,1' && (oldver1[0] ?? '') === 'sm=false' && (oldver2[0] ?? '') === 'sv=false' && this.statusflags.length === 0) {
+        // console.debug('borked shairport found');
+        this.alacEncoding = true;
+        this.borkedshp = true;
+    }
+    let k = this.txt.filter((u) => String(u).startsWith('am='));
+    if ((k[0] ?? '').includes('AppleTV3,1') || (k[0] ?? '').includes('AirReceiver3,1') || (k[0] ?? '').includes('AirRecever3,1') || (k[0] ?? '').includes('Shairport')) {
+        this.alacEncoding = true;
+        this.airplay2 = false;
+    }
+    k = this.txt.filter((u) => String(u).startsWith('rmodel='));
+    if ((k[0] ?? '').includes('AppleTV3,1') || (k[0] ?? '').includes('AirReceiver3,1') || (k[0] ?? '').includes('AirRecever3,1') || (k[0] ?? '').includes('Shairport')) {
+        this.alacEncoding = true;
+        this.airplay2 = false;
+    }
+    let manufacturer = this.txt.filter((u) => String(u).startsWith('manufacturer='));
+    if ((manufacturer[0] ?? '').includes('Sonos')) {
+        this.mode = 2;
+        this.needPin = true;
+    }
+    // console.debug('needPin', this.needPin);
+    // console.debug('mode-atv', this.mode);
+    // console.debug('alacEncoding', this.alacEncoding);
+    try {
+        this.rtsp = new rtsp_1.default.Client(options.volume || 50, options.password || null, audioOut, {
+            mode: this.mode,
+            txt: this.txt,
+            alacEncoding: this.alacEncoding,
+            needPassword: this.needPassword,
+            airplay2: this.airplay2,
+            needPin: this.needPin,
+            debug: options.debug,
+            transient: this.transient,
+            borkedshp: this.borkedshp,
+            log: this.log,
+        });
+    }
+    catch (e) {
+        this.logLine?.('rtsp error', e);
+    }
+    this.audioCallback = null;
+    this.encoder = [];
+    this.credentials = null;
+    // this.func = `
+    // const {Worker, isMainThread, parentPort, workerData} = require('node:worker_threads');
+    // var { WebSocketServer } = require('ws');
+    // const wss = new WebSocketServer({ port: 8980 });
+    //  wss.on('connection', function connection(ws) {
+    //    ws.on('message', function message(data) {
+    //      parentPort.postMessage({message: data});
+    //    });
+    //    parentPort.on("message", data => {
+    //      console.log("ass");
+    //      ws.send(data);
+    //    });
+    //  });`;
+    // this.worker = new Worker(func, {eval: true});
+}
+Object.setPrototypeOf(AirTunesDevice.prototype, node_events_1.EventEmitter.prototype);
+AirTunesDevice.prototype.start = function () {
+    var self = this;
+    this.audioSocket = node_dgram_1.default.createSocket('udp4');
+    // Wait until timing and control ports are chosen. We need them in RTSP handshake.
+    this.udpServers.on('ports', function (err) {
+        if (err) {
+            self.logLine?.(err.code);
+            self.status = 'stopped';
+            self.emit('status', 'stopped');
+            self.logLine?.('port issues');
+            self.emit('error', 'udp_ports', err.code);
+            return;
+        }
+        self.doHandshake();
+    });
+    this.udpServers.bind(this.host);
+};
+AirTunesDevice.prototype.doHandshake = function () {
+    var self = this;
+    try {
+        if (this.rtsp == null) {
+            try {
+                this.rtsp = new rtsp_1.default.Client(this.options.volume || 30, this.options.password || null, this.audioOut, {
+                    mode: this.mode,
+                    txt: this.txt,
+                    alacEncoding: this.alacEncoding,
+                    needPassword: this.needPassword,
+                    airplay2: this.airplay2,
+                    needPin: this.needPin,
+                    debug: true,
+                    transient: this.transient,
+                    borkedshp: this.borkedshp,
+                    log: this.log,
+                });
+            }
+            catch (e) {
+                self.logLine?.(e);
+            }
+        }
+        if (!this.rtsp) {
+            return;
+        }
+        this.rtsp.on('config', function (setup) {
+            self.audioLatency = setup.audioLatency;
+            self.requireEncryption = setup.requireEncryption;
+            self.serverPort = setup.server_port;
+            self.controlPort = setup.control_port;
+            self.timingPort = setup.timing_port;
+            self.credentials = setup.credentials;
+            try {
+                self.audioOut?.setLatencyFrames?.(self.audioLatency);
+            }
+            catch {
+                /* ignore */
+            }
+        });
+        this.rtsp.on('ready', function () {
+            self.relayAudio();
+        });
+        this.rtsp.on('need_password', function () {
+            self.emit('status', 'need_password');
+        });
+        this.rtsp.on('pair_failed', function () {
+            self.emit('status', 'pair_failed');
+        });
+        this.rtsp.on('pair_success', function () {
+            self.emit('status', 'pair_success');
+        });
+        this.rtsp.on('end', function (err) {
+            self.logLine?.(err);
+            self.cleanup();
+            if (err !== 'stopped')
+                self.emit(err);
+        });
+    }
+    catch (e) {
+        self.logLine?.(e);
+    }
+    // console.log(this.udpServers, this.host,this.port)
+    if (!this.rtsp) {
+        return;
+    }
+    this.rtsp.startHandshake(this.udpServers, this.host, this.port);
+};
+AirTunesDevice.prototype.relayAudio = function () {
+    var self = this;
+    this.status = 'ready';
+    this.emit('status', 'ready');
+    this.audioCallback = function (packet) {
+        var airTunes = makeAirTunesPacket(packet, self.encoder, self.requireEncryption, self.alacEncoding, self.credentials, self.inputCodec);
+        // if (self.credentials) {
+        //   airTunes = self.credentials.encrypt(airTunes)
+        // }
+        if (self.audioSocket == null) {
+            self.audioSocket = node_dgram_1.default.createSocket('udp4');
+        }
+        self.audioSocket.send(airTunes, 0, airTunes.length, self.serverPort, self.host);
+    };
+    //   this.sendAirTunesPacket = function(airTunes) {
+    //     try{
+    //     if(self.audioSocket == null){
+    //       self.audioSocket = dgram.createSocket('udp4');
+    //     }
+    //     self.audioSocket.send(
+    //       airTunes, 0, airTunes.length,
+    //       self.serverPort, self.host
+    //     );} catch(e){
+    //       console.log('send error',e)
+    //     }
+    //   };
+    //   this.audioCallback = function(packet) {
+    //     var airTunes = makeAirTunesPacket(packet, self.encoder, self.requireEncryption, self.alacEncoding, self.credentials);
+    //     try{
+    //     self.sendAirTunesPacket(airTunes);
+    //     self.audioPacketHistory.add(packet.seq, airTunes); // If we need to resend it
+    //     } catch(e){}
+    //   };
+    //   this.udpServers.on('resendRequested', function (missedSeq, count) {
+    //     try{
+    //     for (var i = 0; i < count; i++) {
+    //     airTunes = self.audioPacketHistory.getLatestNamed(missedSeq + i);
+    //     if (airTunes != null)
+    //     self.sendAirTunesPacket(airTunes);}}
+    //     catch (_){}
+    //   });
+    this.audioOut.on('packet', this.audioCallback);
+};
+AirTunesDevice.prototype.onSyncNeeded = function (seq) {
+    this.udpServers.sendControlSync(seq, this);
+    //if ( this.airplay2)this.rtsp.sendControlSync(seq, this, this.rtsp);
+};
+AirTunesDevice.prototype.cleanup = function () {
+    this.audioSocket = null;
+    this.audioPacketHistory = null;
+    this.status = 'stopped';
+    this.emit('status', 'stopped');
+    // console.debug('stop');
+    if (this.audioCallback) {
+        this.audioOut.removeListener('packet', this.audioCallback);
+        this.audioCallback = null;
+    }
+    this.udpServers.close();
+    this.removeAllListeners();
+    this.rtsp = null;
+};
+AirTunesDevice.prototype.reportStatus = function () {
+    this.emit('status', this.status);
+};
+AirTunesDevice.prototype.stop = function (cb) {
+    try {
+        if (!this.rtsp)
+            return;
+        this.rtsp.once('end', function () {
+            if (cb)
+                cb();
+        });
+        // console.debug('teardown');
+        this.rtsp.teardown();
+    }
+    catch (_) { }
+};
+AirTunesDevice.prototype.setVolume = function (volume, callback) {
+    if (!this.rtsp)
+        return;
+    this.rtsp.setVolume(volume, callback);
+};
+AirTunesDevice.prototype.setTrackInfo = function (name, artist, album, callback) {
+    if (!this.rtsp)
+        return;
+    this.rtsp.setTrackInfo(name, artist, album, callback);
+};
+AirTunesDevice.prototype.setProgress = function (progress, duration, callback) {
+    if (!this.rtsp)
+        return;
+    this.rtsp.setProgress(progress, duration, callback);
+};
+AirTunesDevice.prototype.setArtwork = function (art, contentType, callback) {
+    if (!this.rtsp)
+        return;
+    this.rtsp.setArtwork(art, contentType, callback);
+};
+AirTunesDevice.prototype.setPasscode = function (password) {
+    if (!this.rtsp)
+        return;
+    this.rtsp.setPasscode(password);
+};
+AirTunesDevice.prototype.requireEncryption = function () {
+    return Boolean(this.requireEncryption);
+};
+exports.default = AirTunesDevice;
+function makeAirTunesPacket(packet, encoder, requireEncryption, alacEncoding = true, credentials = null, inputCodec = 'pcm') {
+    const useAlacInput = inputCodec === 'alac';
+    var alac = useAlacInput
+        ? packet.pcm
+        : (alacEncoding || credentials)
+            ? (0, alac_1.encodePcmToAlac)(packet.pcm)
+            : pcmParse(packet.pcm);
+    var airTunes = Buffer.alloc(alac.length + RTP_HEADER_SIZE);
+    var header = makeRTPHeader(packet);
+    if (requireEncryption) {
+        alac = encryptAES(alac, alac.length);
+    }
+    if (credentials) {
+        let pcm = credentials.encryptAudio(alac, header.slice(4, 12), packet.seq);
+        let airplay = Buffer.alloc(RTP_HEADER_SIZE + pcm.length);
+        header.copy(airplay);
+        pcm.copy(airplay, RTP_HEADER_SIZE);
+        return airplay;
+        // console.log(alac.length)
+    }
+    else {
+        header.copy(airTunes);
+        alac.copy(airTunes, RTP_HEADER_SIZE);
+        return airTunes;
+    }
+}
+function pcmParse(pcmData) {
+    let dst = new Uint8Array(352 * 4);
+    let src = pcmData;
+    let a = 0;
+    let b = 0;
+    let size;
+    for (size = 0; size < 352; size++) {
+        dst[a++] = src[b + 1];
+        dst[a++] = src[b++];
+        b++;
+        dst[a++] = src[b + 1];
+        dst[a++] = src[b++];
+        b++;
+    }
+    return Buffer.from(dst);
+}
+function encryptAES(alacData, alacSize) {
+    let result = Buffer.concat([]);
+    const isv = Buffer.from([0x78, 0xf4, 0x41, 0x2c, 0x8d, 0x17, 0x37, 0x90, 0x2b, 0x15, 0xa6, 0xb3, 0xee, 0x77, 0x0d, 0x67]);
+    const aes_key = Buffer.from([0x14, 0x49, 0x7d, 0xcc, 0x98, 0xe1, 0x37, 0xa8, 0x55, 0xc1, 0x45, 0x5a, 0x6b, 0xc0, 0xc9, 0x79]);
+    let remainder = alacData.length % 16;
+    let end_of_encoded_data = alacData.length - remainder;
+    let cipher = node_crypto_1.default.createCipheriv('aes-128-cbc', aes_key, isv);
+    cipher.setAutoPadding(false);
+    let i = 0;
+    let l = end_of_encoded_data - 16;
+    for (i = 0, l = end_of_encoded_data - 16; i <= l; i += 16) {
+        let chunk = cipher.update(alacData.slice(i, i + 16));
+        result = Buffer.concat([result, chunk]);
+    }
+    return Buffer.concat([result, alacData.slice(end_of_encoded_data)]);
+}
+function makeRTPHeader(packet) {
+    var header = Buffer.alloc(RTP_HEADER_SIZE);
+    if (packet.seq === 0)
+        header.writeUInt16BE(0x80e0, 0);
+    else
+        header.writeUInt16BE(0x8060, 0);
+    header.writeUInt16BE(nu.low16(packet.seq), 2);
+    header.writeUInt32BE(packet.timestamp, 4);
+    header.writeUInt32BE(config_1.default.device_magic, 8);
+    return header;
+}

package/dist/core/devices.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter } from 'node:events';
+type DeviceStatus = 'connecting' | 'ready' | 'playing' | 'stopped' | 'error' | string;
+type AirTunesDeviceInstance = any;
+type DevicesEmitter = EventEmitter & {
+    emit(event: 'status', key: string, status: DeviceStatus, desc: string): boolean;
+    emit(event: 'airtunes_devices', hasAirTunes: boolean): boolean;
+    emit(event: 'need_sync'): boolean;
+};
+/**
+ * Tracks and controls all connected AirPlay/RAOP devices.
+ * Responsible for lifecycle, fan-out of state, and sync signaling.
+ */
+export default class Devices extends EventEmitter implements DevicesEmitter {
+    private readonly audioOut;
+    private readonly devices;
+    private hasAirTunes;
+    constructor(audioOut: EventEmitter);
+    /** Wire device sync events from AudioOut into individual devices. */
+    init(): void;
+    /** Iterate over live devices. */
+    private forEach;
+    /**
+     * 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: string, host: string | null, options: any, mode?: number, txt?: string[] | string): AirTunesDeviceInstance;
+    /** Adjust volume on one device. */
+    setVolume(key: string, volume: number, callback?: (err?: unknown) => void): void;
+    /** Push playback position to one or all devices. */
+    setProgress(key: string, progress: number, duration: number, callback?: (err?: unknown) => void): void;
+    /**
+     * Update track info on one or all devices.
+     */
+    setTrackInfo(key: string, name: string, artist?: string, album?: string, callback?: (err?: unknown) => void): void;
+    /** Update artwork on one or all devices. */
+    setArtwork(key: string, art: Buffer, contentType?: string, callback?: (err?: unknown) => void): void;
+    /** Provide a passcode to a specific device. */
+    setPasscode(key: string, passcode: string): void;
+    /** Stop one device. */
+    stop(key: string): void;
+    /** Stop every device in parallel. */
+    stopAll(allCb?: (err?: unknown) => void): void;
+    /** Track whether any active device is RAOP to drive sync signals. */
+    private checkAirTunesDevices;
+}
+export {};