@basmilius/apple-raop 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Bas Milius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/const.d.ts

@@ -0,0 +1,8 @@
+import { type MediaMetadata } from "./types";
+export declare const MAX_PACKETS_COMPENSATE = 3;
+export declare const PACKET_BACKLOG_SIZE = 1e3;
+export declare const SLOW_WARNING_THRESHOLD = 5;
+export declare const FRAMES_PER_PACKET = 352;
+export declare const MISSING_METADATA: MediaMetadata;
+export declare const EMPTY_METADATA: MediaMetadata;
+export declare const SUPPORTED_ENCRYPTIONS: unknown;

package/dist/controlClient.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "node:events";
+import { PacketFifo } from "./packets";
+import type { StreamContext } from "./types";
+export default class ControlClient extends EventEmitter {
+	#private;
+	constructor(context: StreamContext, packetBacklog: PacketFifo);
+	get port(): number;
+	bind(localIp: string, port: number): Promise<void>;
+	close(): void;
+	start(remoteAddr: string): void;
+	stop(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./packets";
+export * from "./utils";
+export { default as ControlClient } from "./controlClient";
+export { default as RtspClient } from "./rtspClient";
+export { default as Statistics } from "./statistics";
+export { default as StreamClient } from "./streamClient";
+export { RaopClient, type StreamOptions } from "./raop";

package/dist/index.js

@@ -0,0 +1,1034 @@
+// src/types.ts
+var EncryptionType;
+((EncryptionType2) => {
+  EncryptionType2[EncryptionType2["Unknown"] = 0] = "Unknown";
+  EncryptionType2[EncryptionType2["Unencrypted"] = 1] = "Unencrypted";
+  EncryptionType2[EncryptionType2["MFiSAP"] = 2] = "MFiSAP";
+})(EncryptionType ||= {});
+var MetadataType;
+((MetadataType2) => {
+  MetadataType2[MetadataType2["NotSupported"] = 0] = "NotSupported";
+  MetadataType2[MetadataType2["Text"] = 1] = "Text";
+  MetadataType2[MetadataType2["Artwork"] = 2] = "Artwork";
+  MetadataType2[MetadataType2["Progress"] = 4] = "Progress";
+})(MetadataType ||= {});
+// src/packets.ts
+class PacketFifo {
+  #maxSize;
+  #packets = new Map;
+  #order = [];
+  constructor(maxSize) {
+    this.#maxSize = maxSize;
+  }
+  get(seqno) {
+    return this.#packets.get(seqno);
+  }
+  set(seqno, packet) {
+    if (this.#packets.has(seqno)) {
+      return;
+    }
+    this.#packets.set(seqno, packet);
+    this.#order.push(seqno);
+    while (this.#order.length > this.#maxSize) {
+      const oldest = this.#order.shift();
+      if (oldest !== undefined) {
+        this.#packets.delete(oldest);
+      }
+    }
+  }
+  has(seqno) {
+    return this.#packets.has(seqno);
+  }
+  clear() {
+    this.#packets.clear();
+    this.#order.length = 0;
+  }
+}
+var AudioPacketHeader = {
+  encode(header, payloadType, seqno, timestamp, ssrc) {
+    const packet = Buffer.alloc(12);
+    packet.writeUInt8(header, 0);
+    packet.writeUInt8(payloadType, 1);
+    packet.writeUInt16BE(seqno, 2);
+    packet.writeUInt32BE(timestamp, 4);
+    packet.writeUInt32BE(ssrc, 8);
+    return packet;
+  }
+};
+var SyncPacket = {
+  encode(header, payloadType, seqno, rtpTimestamp, ntpSec, ntpFrac, rtpTimestampNow) {
+    const packet = Buffer.alloc(20);
+    packet.writeUInt8(header, 0);
+    packet.writeUInt8(payloadType, 1);
+    packet.writeUInt16BE(seqno, 2);
+    packet.writeUInt32BE(rtpTimestamp, 4);
+    packet.writeUInt32BE(ntpSec, 8);
+    packet.writeUInt32BE(ntpFrac, 12);
+    packet.writeUInt32BE(rtpTimestampNow, 16);
+    return packet;
+  }
+};
+function decodeRetransmitRequest(data) {
+  return {
+    lostSeqno: data.readUInt16BE(4),
+    lostPackets: data.readUInt16BE(6)
+  };
+}
+// src/utils.ts
+function pctToDbfs(volume) {
+  if (volume <= 0)
+    return -144;
+  if (volume >= 100)
+    return 0;
+  return 20 * Math.log10(volume / 100);
+}
+function getEncryptionTypes(properties) {
+  const et = properties.get("et");
+  if (!et)
+    return 0 /* Unknown */;
+  let types = 0 /* Unknown */;
+  for (const t of et.split(",")) {
+    const num = parseInt(t.trim(), 10);
+    if (num === 0)
+      types |= 1 /* Unencrypted */;
+    if (num === 1)
+      types |= 2 /* MFiSAP */;
+  }
+  return types;
+}
+function getMetadataTypes(properties) {
+  const md = properties.get("md");
+  if (!md)
+    return 0 /* NotSupported */;
+  let types = 0 /* NotSupported */;
+  for (const t of md.split(",")) {
+    const num = parseInt(t.trim(), 10);
+    if (num === 0)
+      types |= 1 /* Text */;
+    if (num === 1)
+      types |= 2 /* Artwork */;
+    if (num === 2)
+      types |= 4 /* Progress */;
+  }
+  return types;
+}
+function getAudioProperties(properties) {
+  const sr = parseInt(properties.get("sr") ?? "44100", 10);
+  const ch = parseInt(properties.get("ch") ?? "2", 10);
+  const ss = parseInt(properties.get("ss") ?? "16", 10);
+  return [sr, ch, ss / 8];
+}
+// src/controlClient.ts
+import { createSocket } from "node:dgram";
+import { EventEmitter } from "node:events";
+import { NTP } from "@basmilius/apple-encoding";
+function ntpFromTs(timestamp, sampleRate) {
+  const seconds = Math.floor(timestamp / sampleRate);
+  const fraction = timestamp % sampleRate * 4294967295 / sampleRate;
+  return BigInt(seconds) << 32n | BigInt(Math.floor(fraction));
+}
+
+class ControlClient extends EventEmitter {
+  #transport;
+  #context;
+  #packetBacklog;
+  #syncTask;
+  #abortController;
+  #localPort;
+  constructor(context, packetBacklog) {
+    super();
+    this.#context = context;
+    this.#packetBacklog = packetBacklog;
+  }
+  get port() {
+    return this.#localPort ?? 0;
+  }
+  async bind(localIp, port) {
+    return new Promise((resolve, reject) => {
+      this.#transport = createSocket("udp4");
+      this.#transport.on("error", (err) => {
+        console.error("Control connection error:", err);
+        reject(err);
+      });
+      this.#transport.on("message", (data, rinfo) => {
+        this.#onMessage(data, rinfo);
+      });
+      this.#transport.on("listening", () => {
+        const address = this.#transport.address();
+        this.#localPort = address.port;
+        resolve();
+      });
+      this.#transport.bind(port, localIp);
+    });
+  }
+  close() {
+    this.stop();
+    if (this.#transport) {
+      this.#transport.close();
+      this.#transport = undefined;
+    }
+  }
+  start(remoteAddr) {
+    if (this.#syncTask) {
+      throw new Error("Already running");
+    }
+    this.#abortController = new AbortController;
+    this.#startSyncTask(remoteAddr, this.#context.controlPort);
+  }
+  stop() {
+    if (this.#abortController) {
+      this.#abortController.abort();
+      this.#abortController = undefined;
+    }
+    if (this.#syncTask) {
+      clearInterval(this.#syncTask);
+      this.#syncTask = undefined;
+    }
+  }
+  #startSyncTask(addr, port) {
+    let firstPacket = true;
+    const sendSync = () => {
+      if (!this.#transport)
+        return;
+      const currentTime = ntpFromTs(this.#context.headTs, this.#context.sampleRate);
+      const [currentSec, currentFrac] = NTP.parts(currentTime);
+      const packet = SyncPacket.encode(firstPacket ? 144 : 128, 212, 7, this.#context.headTs - this.#context.latency, currentSec, currentFrac, this.#context.headTs);
+      firstPacket = false;
+      this.#transport.send(packet, port, addr);
+    };
+    sendSync();
+    this.#syncTask = setInterval(sendSync, 1000);
+  }
+  #onMessage(data, rinfo) {
+    const actualType = data[1] & 127;
+    if (actualType === 85) {
+      this.#retransmitLostPackets(decodeRetransmitRequest(data), rinfo);
+    } else {
+      console.debug("Received unhandled control data from", rinfo, data);
+    }
+  }
+  #retransmitLostPackets(request, addr) {
+    for (let i = 0;i < request.lostPackets; i++) {
+      const seqno = request.lostSeqno + i;
+      if (this.#packetBacklog.has(seqno)) {
+        const packet = this.#packetBacklog.get(seqno);
+        const originalSeqno = packet.subarray(2, 4);
+        const resp = Buffer.concat([Buffer.from([128, 214]), originalSeqno, packet]);
+        if (this.#transport) {
+          this.#transport.send(resp, addr.port, addr.address);
+        }
+      } else {
+        console.debug(`Packet ${seqno} not in backlog`);
+      }
+    }
+  }
+}
+// src/rtspClient.ts
+import { createHash } from "node:crypto";
+import { generateActiveRemoteId, generateDacpId, generateSessionId } from "@basmilius/apple-airplay";
+import { Connection, HTTP_TIMEOUT } from "@basmilius/apple-common";
+import { DAAP, Plist, RTSP } from "@basmilius/apple-encoding";
+var USER_AGENT = "AirPlay/550.10";
+var FRAMES_PER_PACKET = 352;
+var AUTH_SETUP_UNENCRYPTED = Buffer.from([1]);
+var CURVE25519_PUB_KEY = Buffer.from([
+  89,
+  2,
+  237,
+  233,
+  13,
+  78,
+  242,
+  189,
+  76,
+  182,
+  138,
+  99,
+  48,
+  3,
+  130,
+  7,
+  169,
+  77,
+  189,
+  80,
+  216,
+  170,
+  70,
+  91,
+  93,
+  140,
+  1,
+  42,
+  12,
+  126,
+  29,
+  78
+]);
+function getDigestPayload(method, uri, info) {
+  const ha1 = createHash("md5").update(`${info.username}:${info.realm}:${info.password}`).digest("hex");
+  const ha2 = createHash("md5").update(`${method}:${uri}`).digest("hex");
+  const response = createHash("md5").update(`${ha1}:${info.nonce}:${ha2}`).digest("hex");
+  return `Digest username="${info.username}", realm="${info.realm}", nonce="${info.nonce}", uri="${uri}", response="${response}"`;
+}
+function generateRandomSessionId() {
+  return Math.floor(Math.random() * 4294967295);
+}
+function buildAnnouncePayload(options) {
+  return [
+    "v=0",
+    `o=iTunes ${options.sessionId} 0 IN IP4 ${options.localIp}`,
+    "s=iTunes",
+    `c=IN IP4 ${options.remoteIp}`,
+    "t=0 0",
+    "m=audio 0 RTP/AVP 96",
+    `a=rtpmap:96 L16/${options.sampleRate}/${options.channels}`,
+    `a=fmtp:96 ${FRAMES_PER_PACKET} 0 ${options.bitsPerChannel} 40 10 14 ${options.channels} 255 0 0 ${options.sampleRate}`
+  ].join(`\r
+`) + `\r
+`;
+}
+
+class RtspClient extends Connection {
+  get activeRemoteId() {
+    return this.#activeRemoteId;
+  }
+  get dacpId() {
+    return this.#dacpId;
+  }
+  get rtspSessionId() {
+    return this.#rtspSessionId;
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  get uri() {
+    return `rtsp://${this.connection.localIp}/${this.#sessionId}`;
+  }
+  get connection() {
+    return {
+      localIp: this.#localIp,
+      remoteIp: this.address
+    };
+  }
+  #activeRemoteId;
+  #dacpId;
+  #rtspSessionId;
+  #sessionId;
+  #localIp = "0.0.0.0";
+  #buffer = Buffer.alloc(0);
+  #cseq = 0;
+  #digestInfo;
+  #requests = new Map;
+  constructor(context, address, port) {
+    super(context, address, port);
+    this.#activeRemoteId = generateActiveRemoteId();
+    this.#dacpId = generateDacpId();
+    this.#rtspSessionId = generateSessionId();
+    this.#sessionId = generateRandomSessionId();
+    this.on("close", this.#onClose.bind(this));
+    this.on("data", this.#onData.bind(this));
+    this.on("error", this.#onError.bind(this));
+    this.on("timeout", this.#onTimeout.bind(this));
+    this.on("connect", this.#onConnect.bind(this));
+  }
+  async info() {
+    try {
+      const response = await this.#exchange("GET", "/info", {
+        allowError: true
+      });
+      if (response.ok) {
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.length > 0) {
+          try {
+            return Plist.parse(buffer.buffer);
+          } catch {
+            return {};
+          }
+        }
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  async authSetup() {
+    const body = Buffer.concat([AUTH_SETUP_UNENCRYPTED, CURVE25519_PUB_KEY]);
+    await this.#exchange("POST", "/auth-setup", {
+      contentType: "application/octet-stream",
+      body,
+      protocol: "HTTP/1.1"
+    });
+  }
+  async announce(bytesPerChannel, channels, sampleRate, password) {
+    const body = buildAnnouncePayload({
+      sessionId: this.#sessionId,
+      localIp: this.connection.localIp,
+      remoteIp: this.connection.remoteIp,
+      bitsPerChannel: 8 * bytesPerChannel,
+      channels,
+      sampleRate
+    });
+    let response = await this.#exchange("ANNOUNCE", undefined, {
+      contentType: "application/sdp",
+      body,
+      allowError: !!password
+    });
+    if (response.status === 401 && password) {
+      const wwwAuthenticate = response.headers.get("www-authenticate");
+      if (wwwAuthenticate) {
+        const parts = wwwAuthenticate.split('"');
+        if (parts.length >= 5) {
+          this.#digestInfo = {
+            username: "pyatv",
+            realm: parts[1],
+            password,
+            nonce: parts[3]
+          };
+          response = await this.#exchange("ANNOUNCE", undefined, {
+            contentType: "application/sdp",
+            body
+          });
+        }
+      }
+    }
+    return response;
+  }
+  async setup(headers, body) {
+    return await this.#exchange("SETUP", undefined, { headers, body });
+  }
+  async record(headers) {
+    await this.#exchange("RECORD", undefined, { headers });
+  }
+  async flush(options) {
+    await this.#exchange("FLUSH", undefined, { headers: options.headers });
+  }
+  async setParameter(name, value) {
+    await this.#exchange("SET_PARAMETER", undefined, {
+      contentType: "text/parameters",
+      body: `${name}: ${value}`
+    });
+  }
+  async setMetadata(session, rtpseq, rtptime, metadata) {
+    const daapData = DAAP.encodeTrackMetadata({
+      title: metadata.title,
+      artist: metadata.artist,
+      album: metadata.album,
+      duration: metadata.duration
+    });
+    await this.#exchange("SET_PARAMETER", undefined, {
+      contentType: "application/x-dmap-tagged",
+      headers: {
+        Session: session,
+        "RTP-Info": `seq=${rtpseq};rtptime=${rtptime}`
+      },
+      body: daapData
+    });
+  }
+  async setArtwork(session, rtpseq, rtptime, artwork) {
+    let contentType = "image/jpeg";
+    if (artwork[0] === 137 && artwork[1] === 80) {
+      contentType = "image/png";
+    }
+    await this.#exchange("SET_PARAMETER", undefined, {
+      contentType,
+      headers: {
+        Session: session,
+        "RTP-Info": `seq=${rtpseq};rtptime=${rtptime}`
+      },
+      body: artwork
+    });
+  }
+  async feedback(allowError = false) {
+    return await this.#exchange("POST", "/feedback", { allowError });
+  }
+  async teardown(session) {
+    await this.#exchange("TEARDOWN", undefined, {
+      headers: { Session: session }
+    });
+  }
+  async#exchange(method, uri, options = {}) {
+    const {
+      contentType,
+      headers: extraHeaders = {},
+      allowError = false,
+      protocol = "RTSP/1.0",
+      timeout = HTTP_TIMEOUT
+    } = options;
+    let { body } = options;
+    const cseq = this.#cseq++;
+    const targetUri = uri ?? this.uri;
+    const headers = {
+      CSeq: cseq,
+      "DACP-ID": this.#dacpId,
+      "Active-Remote": this.#activeRemoteId,
+      "Client-Instance": this.#dacpId,
+      "User-Agent": USER_AGENT
+    };
+    if (this.#digestInfo) {
+      headers["Authorization"] = getDigestPayload(method, targetUri, this.#digestInfo);
+    }
+    Object.assign(headers, extraHeaders);
+    if (body && typeof body === "object" && !Buffer.isBuffer(body)) {
+      headers["Content-Type"] = "application/x-apple-binary-plist";
+      body = Buffer.from(Plist.serialize(body));
+    } else if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    let bodyBuffer;
+    if (body) {
+      bodyBuffer = typeof body === "string" ? Buffer.from(body) : body;
+      headers["Content-Length"] = bodyBuffer.length;
+    } else {
+      headers["Content-Length"] = 0;
+    }
+    const headerLines = [
+      `${method} ${targetUri} ${protocol}`,
+      ...Object.entries(headers).map(([k, v]) => `${k}: ${v}`),
+      "",
+      ""
+    ].join(`\r
+`);
+    const data = bodyBuffer ? Buffer.concat([Buffer.from(headerLines), bodyBuffer]) : Buffer.from(headerLines);
+    this.context.logger.net("[rtsp]", method, targetUri, `cseq=${cseq}`);
+    return new Promise((resolve, reject) => {
+      this.#requests.set(cseq, { resolve, reject });
+      const timer = setTimeout(() => {
+        this.#requests.delete(cseq);
+        reject(new Error(`No response to CSeq ${cseq} (${targetUri})`));
+      }, timeout);
+      this.write(data).catch((err) => {
+        clearTimeout(timer);
+        this.#requests.delete(cseq);
+        reject(err);
+      });
+      const originalResolve = resolve;
+      this.#requests.set(cseq, {
+        resolve: (response) => {
+          clearTimeout(timer);
+          if (!allowError && !response.ok) {
+            reject(new Error(`RTSP error: ${response.status} ${response.statusText}`));
+          } else {
+            originalResolve(response);
+          }
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+  }
+  #onConnect() {
+    this.#localIp = "0.0.0.0";
+  }
+  #onClose() {
+    this.#buffer = Buffer.alloc(0);
+    for (const [cseq, { reject }] of this.#requests) {
+      reject(new Error("Connection closed"));
+      this.#requests.delete(cseq);
+    }
+    this.context.logger.net("[rtsp]", "#onClose()");
+  }
+  #onData(data) {
+    try {
+      this.#buffer = Buffer.concat([this.#buffer, data]);
+      while (this.#buffer.byteLength > 0) {
+        const result = RTSP.makeResponse(this.#buffer);
+        if (result === null) {
+          return;
+        }
+        this.#buffer = this.#buffer.subarray(result.responseLength);
+        const cseqHeader = result.response.headers.get("CSeq");
+        const cseq = cseqHeader ? parseInt(cseqHeader, 10) : -1;
+        if (this.#requests.has(cseq)) {
+          const { resolve } = this.#requests.get(cseq);
+          this.#requests.delete(cseq);
+          resolve(result.response);
+        } else {
+          this.context.logger.warn("[rtsp]", `Unexpected response for CSeq ${cseq}`);
+        }
+      }
+    } catch (err) {
+      this.context.logger.error("[rtsp]", "#onData()", err);
+      this.emit("error", err);
+    }
+  }
+  #onError(err) {
+    for (const [cseq, { reject }] of this.#requests) {
+      reject(err);
+      this.#requests.delete(cseq);
+    }
+    this.context.logger.error("[rtsp]", "#onError()", err);
+  }
+  #onTimeout() {
+    const err = new Error("Connection timed out");
+    for (const [cseq, { reject }] of this.#requests) {
+      reject(err);
+      this.#requests.delete(cseq);
+    }
+    this.context.logger.net("[rtsp]", "#onTimeout()");
+  }
+}
+// src/statistics.ts
+class Statistics {
+  sampleRate;
+  startTimeNs;
+  intervalTime;
+  totalFrames = 0;
+  intervalFrames = 0;
+  constructor(sampleRate) {
+    this.sampleRate = sampleRate;
+    this.startTimeNs = process.hrtime.bigint();
+    this.intervalTime = performance.now();
+  }
+  get expectedFrameCount() {
+    const elapsedNs = Number(process.hrtime.bigint() - this.startTimeNs);
+    return Math.floor(elapsedNs / (1e9 / this.sampleRate));
+  }
+  get framesBehind() {
+    return this.expectedFrameCount - this.totalFrames;
+  }
+  get intervalCompleted() {
+    return this.intervalFrames >= this.sampleRate;
+  }
+  tick(sentFrames) {
+    this.totalFrames += sentFrames;
+    this.intervalFrames += sentFrames;
+  }
+  newInterval() {
+    const endTime = performance.now();
+    const diff = (endTime - this.intervalTime) / 1000;
+    this.intervalTime = endTime;
+    const frames = this.intervalFrames;
+    this.intervalFrames = 0;
+    return [diff, frames];
+  }
+}
+// src/streamClient.ts
+import { createSocket as createSocket2 } from "node:dgram";
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { waitFor } from "@basmilius/apple-common";
+
+// src/const.ts
+var MAX_PACKETS_COMPENSATE = 3;
+var PACKET_BACKLOG_SIZE = 1000;
+var SLOW_WARNING_THRESHOLD = 5;
+var FRAMES_PER_PACKET2 = 352;
+var MISSING_METADATA = {
+  title: "Streaming with apple-raop",
+  artist: "apple-raop",
+  album: "AirPlay",
+  duration: 0
+};
+var EMPTY_METADATA = {
+  title: "",
+  artist: "",
+  album: "",
+  duration: 0
+};
+var SUPPORTED_ENCRYPTIONS = 1 /* Unencrypted */ | 2 /* MFiSAP */;
+
+// src/streamClient.ts
+class StreamClient extends EventEmitter2 {
+  get info() {
+    return this.#info;
+  }
+  get playbackInfo() {
+    return {
+      metadata: this.#isMetadataEmpty(this.#metadata) ? MISSING_METADATA : this.#metadata,
+      position: this.#streamContext.position
+    };
+  }
+  get #requiresAuthSetup() {
+    const modelName = this.#properties.get("am") ?? "";
+    return (this.#encryptionTypes & 2 /* MFiSAP */) !== 0 && modelName.startsWith("AirPort");
+  }
+  #context;
+  #rtsp;
+  #streamContext;
+  #settings;
+  #protocol;
+  #packetBacklog;
+  #timingServer;
+  #controlClient;
+  #encryptionTypes = 0 /* Unknown */;
+  #metadataTypes = 0 /* NotSupported */;
+  #metadata = EMPTY_METADATA;
+  #info = {};
+  #properties = new Map;
+  #isPlaying = false;
+  constructor(context, rtsp, streamContext, protocol, settings, timingServer) {
+    super();
+    this.#context = context;
+    this.#rtsp = rtsp;
+    this.#streamContext = streamContext;
+    this.#protocol = protocol;
+    this.#settings = settings;
+    this.#packetBacklog = new PacketFifo(PACKET_BACKLOG_SIZE);
+    this.#timingServer = timingServer;
+  }
+  close() {
+    this.#protocol.teardown();
+    this.#controlClient?.close();
+  }
+  async initialize(properties) {
+    this.#properties = properties;
+    this.#encryptionTypes = getEncryptionTypes(properties);
+    this.#metadataTypes = getMetadataTypes(properties);
+    this.#context.logger.info(`Initializing RTSP with encryption=${this.#encryptionTypes}, metadata=${this.#metadataTypes}`);
+    const intersection = this.#encryptionTypes & SUPPORTED_ENCRYPTIONS;
+    if (!intersection || intersection === 0 /* Unknown */) {
+      this.#context.logger.debug("No supported encryption type, continuing anyway");
+    }
+    this.#updateOutputProperties(properties);
+    this.#controlClient = new ControlClient(this.#streamContext, this.#packetBacklog);
+    await this.#controlClient.bind(this.#rtsp.connection.localIp, this.#settings.protocols.raop.controlPort);
+    this.#context.logger.debug(`Local ports: control=${this.#controlClient.port}, timing=${this.#timingServer.port}`);
+    const info = await this.#rtsp.info();
+    Object.assign(this.#info, info);
+    this.#context.logger.debug("Updated info parameters to:", this.#info);
+    if (this.#requiresAuthSetup) {
+      await this.#rtsp.authSetup();
+    }
+    await this.#protocol.setup(this.#timingServer.port, this.#controlClient.port);
+  }
+  stop() {
+    this.#context.logger.debug("Stopping audio playback");
+    this.#isPlaying = false;
+  }
+  async setVolume(volume) {
+    await this.#rtsp.setParameter("volume", String(volume));
+    this.#streamContext.volume = volume;
+  }
+  async sendAudio(source, metadata = EMPTY_METADATA, volume) {
+    if (!this.#controlClient) {
+      throw new Error("Not initialized");
+    }
+    this.#streamContext.reset();
+    let transport;
+    try {
+      transport = createSocket2("udp4");
+      await new Promise((resolve) => {
+        transport.connect(this.#streamContext.serverPort, this.#rtsp.connection.remoteIp, resolve);
+      });
+      this.#controlClient.start(this.#rtsp.connection.remoteIp);
+      if ((this.#metadataTypes & 4 /* Progress */) !== 0) {
+        const start = this.#streamContext.rtptime;
+        const now = this.#streamContext.rtptime;
+        const end = start + source.duration * this.#streamContext.sampleRate;
+        await this.#rtsp.setParameter("progress", `${start}/${now}/${end}`);
+      }
+      this.#metadata = metadata;
+      if ((this.#metadataTypes & 1 /* Text */) !== 0) {
+        this.#context.logger.debug("Playing with metadata:", this.playbackInfo.metadata);
+        await this.#rtsp.setMetadata(this.#streamContext.rtspSession, this.#streamContext.rtpseq, this.#streamContext.rtptime, this.playbackInfo.metadata);
+      }
+      if ((this.#metadataTypes & 2 /* Artwork */) !== 0 && metadata.artwork) {
+        this.#context.logger.debug(`Sending ${metadata.artwork.length} bytes artwork`);
+        await this.#rtsp.setArtwork(this.#streamContext.rtspSession, this.#streamContext.rtpseq, this.#streamContext.rtptime, metadata.artwork);
+      }
+      await this.#protocol.startFeedback();
+      this.emit("playing", this.playbackInfo);
+      await this.#rtsp.record({
+        Range: "npt=0-",
+        Session: this.#streamContext.rtspSession,
+        "RTP-Info": `seq=${this.#streamContext.rtpseq};rtptime=${this.#streamContext.rtptime}`
+      });
+      await this.#rtsp.flush({
+        headers: {
+          Range: "npt=0-",
+          Session: this.#streamContext.rtspSession,
+          "RTP-Info": `seq=${this.#streamContext.rtpseq};rtptime=${this.#streamContext.rtptime}`
+        }
+      });
+      if (volume !== undefined) {
+        await this.setVolume(pctToDbfs(volume));
+      }
+      await this.#streamData(source, transport);
+    } catch (err) {
+      this.#context.logger.error("An error occurred during streaming.", err);
+      throw new Error(`An error occurred during streaming: ${err}`);
+    } finally {
+      this.#packetBacklog.clear();
+      if (transport) {
+        await this.#rtsp.teardown(this.#streamContext.rtspSession);
+        transport.close();
+      }
+      this.#protocol.teardown();
+      this.close();
+      this.emit("stopped");
+    }
+  }
+  async#streamData(source, transport) {
+    const stats = new Statistics(this.#streamContext.sampleRate);
+    const initialTime = performance.now();
+    let prevSlowSeqno = null;
+    let numberSlowSeqno = 0;
+    this.#isPlaying = true;
+    while (this.#isPlaying) {
+      const currentSeqno = this.#streamContext.rtpseq - 1;
+      const numSent = await this.#sendPacket(source, stats.totalFrames === 0, transport);
+      if (numSent === 0) {
+        break;
+      }
+      stats.tick(numSent);
+      const framesBehind = stats.framesBehind;
+      if (framesBehind >= FRAMES_PER_PACKET2) {
+        const maxPackets = Math.min(Math.floor(framesBehind / FRAMES_PER_PACKET2), MAX_PACKETS_COMPENSATE);
+        this.#context.logger.debug(`Compensating with ${maxPackets} packets (${framesBehind} frames behind)`);
+        const [sentFrames, hasMorePackets] = await this.#sendNumberOfPackets(source, transport, maxPackets);
+        stats.tick(sentFrames);
+        if (!hasMorePackets) {
+          break;
+        }
+      }
+      if (stats.intervalCompleted) {
+        const [intervalTime, intervalFrames] = stats.newInterval();
+        this.#context.logger.debug(`Sent ${intervalFrames} frames in ${intervalTime.toFixed(3)}s (current frames: ${stats.totalFrames}, expected: ${stats.expectedFrameCount})`);
+      }
+      const absTimeStream = stats.totalFrames / this.#streamContext.sampleRate;
+      const relToStart = (performance.now() - initialTime) / 1000;
+      const diff = absTimeStream - relToStart;
+      if (diff > 0) {
+        numberSlowSeqno = 0;
+        await waitFor(diff * 1000);
+      } else {
+        if (prevSlowSeqno === currentSeqno - 1) {
+          numberSlowSeqno++;
+        }
+        if (numberSlowSeqno >= SLOW_WARNING_THRESHOLD) {
+          this.#context.logger.warn(`Too slow to keep up for seqno ${currentSeqno} (${absTimeStream.toFixed(3)} vs ${relToStart.toFixed(3)} => ${diff.toFixed(3)})`);
+        } else {
+          this.#context.logger.debug(`Too slow to keep up for seqno ${currentSeqno} (${absTimeStream.toFixed(3)} vs ${relToStart.toFixed(3)} => ${diff.toFixed(3)})`);
+        }
+        prevSlowSeqno = currentSeqno;
+      }
+    }
+    const elapsedNs = Number(process.hrtime.bigint() - stats.startTimeNs);
+    this.#context.logger.debug(`Audio finished sending in ${(elapsedNs / 1e9).toFixed(3)}s`);
+  }
+  async#sendPacket(source, firstPacket, transport) {
+    if (this.#streamContext.paddingSent >= this.#streamContext.latency) {
+      return 0;
+    }
+    let frames = await source.readFrames(FRAMES_PER_PACKET2);
+    if (!frames) {
+      frames = Buffer.alloc(this.#streamContext.packetSize);
+      this.#streamContext.paddingSent += Math.floor(frames.length / this.#streamContext.frameSize);
+    } else if (frames.length !== this.#streamContext.packetSize) {
+      const padded = Buffer.alloc(this.#streamContext.packetSize);
+      frames.copy(padded);
+      frames = padded;
+    }
+    const header = AudioPacketHeader.encode(128, firstPacket ? 224 : 96, this.#streamContext.rtpseq, this.#streamContext.headTs, this.#rtsp.sessionId);
+    const [rtpseq, packet] = await this.#protocol.sendAudioPacket(transport, header, frames);
+    this.#packetBacklog.set(rtpseq, packet);
+    this.#streamContext.rtpseq = (this.#streamContext.rtpseq + 1) % 2 ** 16;
+    this.#streamContext.headTs += Math.floor(frames.length / this.#streamContext.frameSize);
+    return Math.floor(frames.length / this.#streamContext.frameSize);
+  }
+  async#sendNumberOfPackets(source, transport, count) {
+    let totalFrames = 0;
+    for (let i = 0;i < count; i++) {
+      const sent = await this.#sendPacket(source, false, transport);
+      totalFrames += sent;
+      if (sent === 0) {
+        return [totalFrames, false];
+      }
+    }
+    return [totalFrames, true];
+  }
+  #isMetadataEmpty(metadata) {
+    return metadata.title === "" && metadata.artist === "" && metadata.album === "" && metadata.duration === 0;
+  }
+  #updateOutputProperties(properties) {
+    const [sampleRate, channels, bytesPerChannel] = getAudioProperties(properties);
+    this.#streamContext.sampleRate = sampleRate;
+    this.#streamContext.channels = channels;
+    this.#streamContext.bytesPerChannel = bytesPerChannel;
+    this.#context.logger.debug(`Update play settings to ${sampleRate}/${channels}/${bytesPerChannel * 8}bit`);
+  }
+}
+// src/raop.ts
+import { EventEmitter as EventEmitter3 } from "node:events";
+import { Context, Discovery } from "@basmilius/apple-common";
+var SAMPLE_RATE = 44100;
+var CHANNELS = 2;
+var BYTES_PER_CHANNEL = 2;
+var FRAMES_PER_PACKET3 = 352;
+
+class RaopClient extends EventEmitter3 {
+  get context() {
+    return this.#context;
+  }
+  get deviceId() {
+    return this.#discoveryResult.id;
+  }
+  get address() {
+    return this.#discoveryResult.address;
+  }
+  get modelName() {
+    return this.#discoveryResult.modelName;
+  }
+  get info() {
+    return this.#streamClient.info;
+  }
+  #context;
+  #rtsp;
+  #streamClient;
+  #discoveryResult;
+  constructor(context, rtsp, streamClient, discoveryResult) {
+    super();
+    this.#context = context;
+    this.#rtsp = rtsp;
+    this.#streamClient = streamClient;
+    this.#discoveryResult = discoveryResult;
+    this.#streamClient.on("playing", (info) => this.emit("playing", info));
+    this.#streamClient.on("stopped", () => this.emit("stopped"));
+  }
+  async stream(source, options = {}) {
+    await source.start();
+    try {
+      await this.#streamClient.sendAudio(source, options.metadata, options.volume);
+    } finally {
+      await source.stop();
+    }
+  }
+  stop() {
+    this.#streamClient.stop();
+  }
+  async setVolume(volume) {
+    await this.#streamClient.setVolume(volume);
+  }
+  async close() {
+    this.#streamClient.close();
+    await this.#rtsp.disconnect();
+  }
+  static async create(discoveryResult, timingServer) {
+    const context = new Context(discoveryResult.id);
+    const rtsp = new RtspClient(context, discoveryResult.address, discoveryResult.service.port);
+    await rtsp.connect();
+    const streamContext = createStreamContext();
+    streamContext.rtspSession = rtsp.rtspSessionId;
+    const protocol = new RaopStreamProtocol(rtsp, streamContext);
+    const settings = {
+      protocols: {
+        raop: {
+          controlPort: 0,
+          timingPort: 0
+        }
+      }
+    };
+    const streamClient = new StreamClient(context, rtsp, streamContext, protocol, settings, timingServer);
+    const properties = new Map(Object.entries(discoveryResult.txt));
+    await streamClient.initialize(properties);
+    return new RaopClient(context, rtsp, streamClient, discoveryResult);
+  }
+  static async discover(deviceId, timingServer) {
+    const discovery = Discovery.raop();
+    const result = await discovery.findUntil(deviceId);
+    return RaopClient.create(result, timingServer);
+  }
+}
+
+class RaopStreamProtocol {
+  #rtsp;
+  #streamContext;
+  #feedbackInterval;
+  constructor(rtsp, streamContext) {
+    this.#rtsp = rtsp;
+    this.#streamContext = streamContext;
+  }
+  async setup(timingPort, controlPort) {
+    await this.#rtsp.announce(this.#streamContext.bytesPerChannel, this.#streamContext.channels, this.#streamContext.sampleRate);
+    const transport = [
+      "RTP/AVP/UDP",
+      "unicast",
+      "interleaved=0-1",
+      "mode=record",
+      `control_port=${controlPort}`,
+      `timing_port=${timingPort}`
+    ].filter(Boolean).join(";");
+    const response = await this.#rtsp.setup({
+      Transport: transport
+    });
+    const transportHeader = response.headers.get("Transport");
+    if (!transportHeader) {
+      return;
+    }
+    const serverPortMatch = transportHeader.match(/server_port=(\d+)/);
+    if (serverPortMatch) {
+      this.#streamContext.serverPort = parseInt(serverPortMatch[1], 10);
+    }
+    const controlPortMatch = transportHeader.match(/control_port=(\d+)/);
+    if (controlPortMatch) {
+      this.#streamContext.controlPort = parseInt(controlPortMatch[1], 10);
+    }
+  }
+  async startFeedback() {
+    this.#feedbackInterval = setInterval(async () => {
+      try {
+        await this.#rtsp.feedback(true);
+      } catch {}
+    }, 2000);
+  }
+  async sendAudioPacket(transport, header, audio) {
+    const packet = Buffer.concat([header, audio]);
+    const seqno = header.readUInt16BE(2);
+    await new Promise((resolve, reject) => {
+      transport.send(packet, (err) => err ? reject(err) : resolve());
+    });
+    return [seqno, packet];
+  }
+  teardown() {
+    if (!this.#feedbackInterval) {
+      return;
+    }
+    clearInterval(this.#feedbackInterval);
+    this.#feedbackInterval = undefined;
+  }
+}
+function createStreamContext() {
+  return {
+    sampleRate: SAMPLE_RATE,
+    channels: CHANNELS,
+    bytesPerChannel: BYTES_PER_CHANNEL,
+    rtpseq: Math.floor(Math.random() * 65536),
+    rtptime: Math.floor(Math.random() * 4294967295),
+    headTs: 0,
+    latency: Math.floor(SAMPLE_RATE * 2),
+    serverPort: 0,
+    controlPort: 0,
+    rtspSession: "",
+    volume: -20,
+    position: 0,
+    packetSize: FRAMES_PER_PACKET3 * CHANNELS * BYTES_PER_CHANNEL,
+    frameSize: CHANNELS * BYTES_PER_CHANNEL,
+    paddingSent: 0,
+    reset() {
+      this.rtpseq = Math.floor(Math.random() * 65536);
+      this.rtptime = Math.floor(Math.random() * 4294967295);
+      this.headTs = this.rtptime;
+      this.paddingSent = 0;
+      this.position = 0;
+    }
+  };
+}
+export {
+  pctToDbfs,
+  getMetadataTypes,
+  getEncryptionTypes,
+  getAudioProperties,
+  decodeRetransmitRequest,
+  SyncPacket,
+  StreamClient,
+  Statistics,
+  RtspClient,
+  RaopClient,
+  PacketFifo,
+  MetadataType,
+  EncryptionType,
+  ControlClient,
+  AudioPacketHeader
+};

package/dist/packets.d.ts

@@ -0,0 +1,19 @@
+export declare class PacketFifo {
+	#private;
+	constructor(maxSize: number);
+	get(seqno: number): Buffer | undefined;
+	set(seqno: number, packet: Buffer): void;
+	has(seqno: number): boolean;
+	clear(): void;
+}
+export declare const AudioPacketHeader: {
+	encode(header: number, payloadType: number, seqno: number, timestamp: number, ssrc: number): Buffer;
+};
+export declare const SyncPacket: {
+	encode(header: number, payloadType: number, seqno: number, rtpTimestamp: number, ntpSec: number, ntpFrac: number, rtpTimestampNow: number): Buffer;
+};
+export type RetransmitRequest = {
+	readonly lostSeqno: number;
+	readonly lostPackets: number;
+};
+export declare function decodeRetransmitRequest(data: Buffer): RetransmitRequest;

package/dist/raop.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "node:events";
+import { type AudioSource, Context, type DiscoveryResult, TimingServer } from "@basmilius/apple-common";
+import type { MediaMetadata, PlaybackInfo } from "./types";
+export type EventMap = {
+	readonly playing: [playbackInfo: PlaybackInfo];
+	readonly stopped: [];
+};
+export type StreamOptions = {
+	readonly metadata?: MediaMetadata;
+	readonly volume?: number;
+};
+export declare class RaopClient extends EventEmitter<EventMap> {
+	#private;
+	get context(): Context;
+	get deviceId(): string;
+	get address(): string;
+	get modelName(): string;
+	get info(): Record<string, unknown>;
+	private constructor();
+	stream(source: AudioSource, options?: StreamOptions): Promise<void>;
+	stop(): void;
+	setVolume(volume: number): Promise<void>;
+	close(): Promise<void>;
+	static create(discoveryResult: DiscoveryResult, timingServer: TimingServer): Promise<RaopClient>;
+	static discover(deviceId: string, timingServer: TimingServer): Promise<RaopClient>;
+}

package/dist/rtspClient.d.ts

@@ -0,0 +1,28 @@
+import { Connection, type Context } from "@basmilius/apple-common";
+import type { MediaMetadata } from "./types";
+export default class RtspClient extends Connection<{}> {
+	#private;
+	get activeRemoteId(): string;
+	get dacpId(): string;
+	get rtspSessionId(): string;
+	get sessionId(): number;
+	get uri(): string;
+	get connection(): {
+		localIp: string;
+		remoteIp: string;
+	};
+	constructor(context: Context, address: string, port: number);
+	info(): Promise<Record<string, unknown>>;
+	authSetup(): Promise<void>;
+	announce(bytesPerChannel: number, channels: number, sampleRate: number, password?: string): Promise<Response>;
+	setup(headers?: Record<string, string>, body?: Buffer | string | Record<string, unknown>): Promise<Response>;
+	record(headers?: Record<string, string>): Promise<void>;
+	flush(options: {
+		headers: Record<string, string>;
+	}): Promise<void>;
+	setParameter(name: string, value: string): Promise<void>;
+	setMetadata(session: string, rtpseq: number, rtptime: number, metadata: MediaMetadata): Promise<void>;
+	setArtwork(session: string, rtpseq: number, rtptime: number, artwork: Buffer): Promise<void>;
+	feedback(allowError?: boolean): Promise<Response>;
+	teardown(session: string): Promise<void>;
+}

package/dist/statistics.d.ts

@@ -0,0 +1,13 @@
+export default class Statistics {
+	readonly sampleRate: number;
+	readonly startTimeNs: bigint;
+	intervalTime: number;
+	totalFrames: number;
+	intervalFrames: number;
+	constructor(sampleRate: number);
+	get expectedFrameCount(): number;
+	get framesBehind(): number;
+	get intervalCompleted(): boolean;
+	tick(sentFrames: number): void;
+	newInterval(): [number, number];
+}

package/dist/streamClient.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from "node:events";
+import { type AudioSource, type Context, type TimingServer } from "@basmilius/apple-common";
+import { type MediaMetadata, type PlaybackInfo, type Settings, type StreamContext, type StreamProtocol } from "./types";
+import RtspClient from "./rtspClient";
+export type EventMap = {
+	readonly playing: [playbackInfo: PlaybackInfo];
+	readonly stopped: [];
+};
+export default class StreamClient extends EventEmitter<EventMap> {
+	#private;
+	get info(): Record<string, unknown>;
+	get playbackInfo(): PlaybackInfo;
+	constructor(context: Context, rtsp: RtspClient, streamContext: StreamContext, protocol: StreamProtocol, settings: Settings, timingServer: TimingServer);
+	close(): void;
+	initialize(properties: Map<string, string>): Promise<void>;
+	stop(): void;
+	setVolume(volume: number): Promise<void>;
+	sendAudio(source: AudioSource, metadata?: MediaMetadata, volume?: number): Promise<void>;
+}

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+import type { Socket as UdpSocket } from 'node:dgram';
+
+export type MediaMetadata = {
+    readonly title: string;
+    readonly artist: string;
+    readonly album: string;
+    readonly duration: number;
+    readonly artwork?: Buffer;
+}
+
+export type PlaybackInfo = {
+    readonly metadata: MediaMetadata;
+    readonly position: number;
+}
+
+export type StreamContext = {
+    sampleRate: number;
+    channels: number;
+    bytesPerChannel: number;
+    rtpseq: number;
+    rtptime: number;
+    headTs: number;
+    latency: number;
+    serverPort: number;
+    controlPort: number;
+    rtspSession: string;
+    volume: number;
+    position: number;
+    packetSize: number;
+    frameSize: number;
+    paddingSent: number;
+
+    reset(): void;
+}
+
+export interface StreamProtocol {
+    setup(timingPort: number, controlPort: number): Promise<void>;
+    startFeedback(): Promise<void>;
+    sendAudioPacket(transport: UdpSocket, header: Buffer, audio: Buffer): Promise<[number, Buffer]>;
+    teardown(): void;
+}
+
+export interface Settings {
+    protocols: {
+        raop: {
+            controlPort: number;
+            timingPort: number;
+        };
+    };
+}
+
+export enum EncryptionType {
+    Unknown = 0,
+    Unencrypted = 1 << 0,
+    MFiSAP = 1 << 1
+}
+
+export enum MetadataType {
+    NotSupported = 0,
+    Text = 1 << 0,
+    Artwork = 1 << 1,
+    Progress = 1 << 2
+}
+
+export interface RaopListener {
+    playing(playbackInfo: PlaybackInfo): void;
+    stopped(): void;
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import { EncryptionType, MetadataType } from "./types";
+export declare function pctToDbfs(volume: number): number;
+export declare function getEncryptionTypes(properties: Map<string, string>): EncryptionType;
+export declare function getMetadataTypes(properties: Map<string, string>): MetadataType;
+export declare function getAudioProperties(properties: Map<string, string>): [number, number, number];

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@basmilius/apple-raop",
+    "description": "Implementation of Apple's RAOP protocol in Node.js.",
+    "version": "0.6.0",
+    "type": "module",
+    "license": "MIT",
+    "author": {
+        "name": "Bas Milius",
+        "email": "bas@mili.us",
+        "url": "https://bas.dev"
+    },
+    "keywords": [
+        "apple",
+        "raop",
+        "airplay",
+        "tv",
+        "apple tv",
+        "homekit"
+    ],
+    "files": [
+        "dist",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "scripts": {
+        "build": "tsc && bun -b build.ts",
+        "watch:test": "bun --watch test.ts"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "typings": "./dist/index.d.ts",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "dependencies": {
+        "@basmilius/apple-airplay": "0.6.0",
+        "@basmilius/apple-common": "0.6.0",
+        "@basmilius/apple-encoding": "0.6.0",
+        "@basmilius/apple-encryption": "0.6.0"
+    },
+    "devDependencies": {
+        "@basmilius/tools": "^2.23.0",
+        "@types/bun": "^1.3.8"
+    }
+}