@lox-audioserver/node-slimproto 0.1.0

package/src/constants.ts

@@ -0,0 +1,7 @@
+export const SLIMPROTO_PORT = 3483;
+export const FALLBACK_CODECS = ['pcm', 'mp3'];
+
+export const FALLBACK_MODEL = 'Squeezebox';
+export const FALLLBACK_FIRMWARE = 'Unknown';
+export const FALLBACK_SAMPLE_RATE = 96000;
+export const HEARTBEAT_INTERVAL = 5;

package/src/discovery.ts

@@ -0,0 +1,121 @@
+import dgram from 'dgram';
+
+type OrderedMap = [string, string | null][];
+
+function parseTlvDiscoveryRequest(payload: Buffer): OrderedMap {
+  const data = payload.toString('utf-8', 1); // drop leading 'e'
+  const result: OrderedMap = [];
+  let idx = 0;
+  while (idx <= data.length - 5) {
+    const key = data.slice(idx, idx + 4);
+    const len = data.charCodeAt(idx + 4);
+    idx += 5;
+    const value = len > 0 ? data.slice(idx, idx + len) : null;
+    idx += len;
+    result.push([key, value]);
+  }
+  return result;
+}
+
+function buildTlvResponse(
+  requestData: OrderedMap,
+  opts: { name: string; ipAddress: string; cliPort?: number | null; cliPortJson?: number | null; uuid: string },
+): OrderedMap {
+  const response: OrderedMap = [];
+  for (const [key, val] of requestData) {
+    switch (key) {
+      case 'NAME':
+        response.push([key, opts.name]);
+        break;
+      case 'IPAD':
+        response.push([key, opts.ipAddress]);
+        break;
+      case 'JSON':
+        if (opts.cliPortJson != null) response.push([key, String(opts.cliPortJson)]);
+        break;
+      case 'CLIP':
+        if (opts.cliPort != null) response.push([key, String(opts.cliPort)]);
+        break;
+      case 'VERS':
+        response.push([key, '7.999.999']);
+        break;
+      case 'UUID':
+        response.push([key, opts.uuid]);
+        break;
+      default:
+        response.push([key, val]);
+    }
+  }
+  return response;
+}
+
+function encodeTlvResponse(responseData: OrderedMap): Buffer {
+  const parts: string[] = ['E']; // response prefix
+  for (const [key, value] of responseData) {
+    const val = value ?? '';
+    const truncated = val.length > 255 ? val.slice(0, 255) : val;
+    parts.push(key, String.fromCharCode(truncated.length), truncated);
+  }
+  return Buffer.from(parts.join(''), 'utf-8');
+}
+
+function encodeLegacyDiscovery(ipAddress: string): Buffer {
+  const hostname = ipAddress.slice(0, 16).padEnd(16, '\u0000');
+  const buf = Buffer.alloc(17);
+  buf.write('D', 0, 'ascii');
+  buf.write(hostname, 1, 'binary');
+  return buf;
+}
+
+export interface DiscoveryOptions {
+  ipAddress: string;
+  controlPort: number;
+  cliPort?: number | null;
+  cliPortJson?: number | null;
+  name?: string;
+  uuid?: string;
+}
+
+export function startDiscovery(opts: DiscoveryOptions): dgram.Socket {
+  const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+  const name = opts.name ?? 'Slimproto';
+  const uuid = opts.uuid ?? 'slimproto';
+
+  socket.on('listening', () => {
+    try {
+      socket.addMembership('239.255.255.250');
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.warn('Failed to join discovery multicast group', err);
+    }
+  });
+
+  socket.on('message', (msg, rinfo) => {
+    try {
+      if (msg.length === 0) return;
+      if (msg[0] === 0x65) {
+        const requestData = parseTlvDiscoveryRequest(msg);
+        const responseData = buildTlvResponse(requestData, {
+          name,
+          ipAddress: opts.ipAddress,
+          cliPort: opts.cliPort,
+          cliPortJson: opts.cliPortJson,
+          uuid,
+        });
+        const payload = encodeTlvResponse(responseData);
+        socket.send(payload, rinfo.port, rinfo.address);
+        return;
+      }
+      if (msg[0] === 0x64) {
+        const payload = encodeLegacyDiscovery(opts.ipAddress);
+        socket.send(payload, rinfo.port, rinfo.address);
+      }
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error('Error handling discovery message from', rinfo.address, err);
+    }
+  });
+
+  socket.bind(opts.controlPort, '0.0.0.0');
+  return socket;
+}

package/src/errors.ts

@@ -0,0 +1,6 @@
+export class UnsupportedContentType extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'UnsupportedContentType';
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './constants.js';
+export * from './models.js';
+export * from './util.js';
+export * from './volume.js';
+export * from './discovery.js';
+export * from './errors.js';
+export * from './client.js';
+export * from './server.js';

package/src/models.ts

@@ -0,0 +1,202 @@
+export enum EventType {
+  PLAYER_UPDATED = 'player_updated',
+  PLAYER_HEARTBEAT = 'player_heartbeat',
+  PLAYER_CONNECTED = 'player_connected',
+  PLAYER_DISCONNECTED = 'player_disconnected',
+  PLAYER_NAME_RECEIVED = 'player_name_received',
+  PLAYER_DISPLAY_RESOLUTION = 'player_display_resolution',
+  PLAYER_DECODER_READY = 'player_decoder_ready',
+  PLAYER_DECODER_ERROR = 'player_decoder_error',
+  PLAYER_OUTPUT_UNDERRUN = 'player_output_underrun',
+  PLAYER_BUFFER_READY = 'player_buffer_ready',
+  PLAYER_CLI_EVENT = 'player_cli_event',
+  PLAYER_BTN_EVENT = 'player_btn_event',
+  PLAYER_PRESETS_UPDATED = 'player_presets_updated',
+}
+
+export interface SlimEvent<T = unknown> {
+  type: EventType;
+  playerId: string;
+  data?: T;
+}
+
+export const DEVICE_TYPE: Record<number, string> = {
+  2: 'squeezebox',
+  3: 'softsqueeze',
+  4: 'squeezebox2',
+  5: 'transporter',
+  6: 'softsqueeze3',
+  7: 'receiver',
+  8: 'squeezeslave',
+  9: 'controller',
+  10: 'boom',
+  11: 'softboom',
+  12: 'squeezeplay',
+  100: 'squeezeesp32',
+};
+
+export enum PlayerState {
+  PLAYING = 'playing',
+  STOPPED = 'stopped',
+  PAUSED = 'paused',
+  BUFFERING = 'buffering',
+  BUFFER_READY = 'buffer_ready',
+}
+
+export enum TransitionType {
+  NONE = '0',
+  CROSSFADE = '1',
+  FADE_IN = '2',
+  FADE_OUT = '3',
+  FADE_IN_OUT = '4',
+}
+
+export enum VisualisationType {
+  NONE = 'none',
+  SPECTRUM_ANALYZER = 'spectrum_analyzer',
+  VU_METER_ANALOG = 'vu_meter_analog',
+  VU_METER_DIGITAL = 'vu_meter_digital',
+  WAVEFORM = 'waveform',
+}
+
+export enum RemoteCode {
+  SLEEP = 1988737095,
+  POWER = 1988706495,
+  REWIND = 1988739135,
+  PAUSE = 1988698335,
+  FORWARD = 1988730975,
+  ADD = 1988714655,
+  PLAY = 1988694255,
+  UP = 1988747295,
+  DOWN = 1988735055,
+  LEFT = 1988726895,
+  RIGHT = 1988743215,
+  VOLUME_UP = 1988722815,
+  VOLUME_DOWN = 1988690175,
+  NUM_1 = 1988751375,
+  NUM_2 = 1988692215,
+  NUM_3 = 1988724855,
+  NUM_4 = 1988708535,
+  NUM_5 = 1988741175,
+  NUM_6 = 1988700375,
+  NUM_7 = 1988733015,
+  NUM_8 = 1988716695,
+  NUM_9 = 1988749335,
+  NUM_0 = 1988728935,
+  FAVORITES = 1988696295,
+  SEARCH = 1988712615,
+  BROWSE = 1988718735,
+  SHUFFLE = 1988745255,
+  REPEAT = 1988704455,
+  NOW_PLAYING = 1988720775,
+  SIZE = 1988753415,
+  BRIGHTNESS = 1988691195,
+}
+
+export enum ButtonCode {
+  POWER = 65546,
+  PRESET_1 = 131104,
+  PRESET_2 = 131105,
+  PRESET_3 = 131106,
+  PRESET_4 = 131107,
+  PRESET_5 = 131108,
+  PRESET_6 = 131109,
+  BACK = 131085,
+  PLAY = 131090,
+  ADD = 131091,
+  UP = 131083,
+  OK = 131086,
+  REWIND = 131088,
+  PAUSE = 131095,
+  FORWARD = 131101,
+  VOLUME_DOWN = 131081,
+  POWER_RELEASE = 131082,
+}
+
+export const PCM_SAMPLE_SIZE: Record<number, Buffer> = {
+  8: Buffer.from('0'),
+  16: Buffer.from('1'),
+  20: Buffer.from('2'),
+  32: Buffer.from('3'),
+  24: Buffer.from('4'),
+  0: Buffer.from('?'),
+};
+
+export const PCM_SAMPLE_RATE: Record<number, Buffer> = {
+  11000: Buffer.from('0'),
+  22000: Buffer.from('1'),
+  44100: Buffer.from('3'),
+  48000: Buffer.from('4'),
+  8000: Buffer.from('5'),
+  12000: Buffer.from('6'),
+  16000: Buffer.from('7'),
+  24000: Buffer.from('8'),
+  88200: Buffer.from(':'),
+  96000: Buffer.from('9'),
+  176400: Buffer.from(';'),
+  192000: Buffer.from('<'),
+  352800: Buffer.from('='),
+  384000: Buffer.from('>'),
+  0: Buffer.from('?'),
+};
+
+export const CODEC_MAPPING: Record<string, string> = {
+  'audio/mp3': 'mp3',
+  'audio/mpeg': 'mp3',
+  'audio/flac': 'flc',
+  'audio/x-flac': 'flc',
+  'audio/wma': 'wma',
+  'audio/ogg': 'ogg',
+  'audio/oga': 'ogg',
+  'audio/aac': 'aac',
+  'audio/aacp': 'aac',
+  'audio/alac': 'alc',
+  'audio/wav': 'pcm',
+  'audio/x-wav': 'pcm',
+  'audio/dsf': 'dsf',
+  'audio/pcm,': 'pcm',
+};
+
+export const FORMAT_BYTE: Record<string, Buffer> = {
+  pcm: Buffer.from('p'),
+  mp3: Buffer.from('m'),
+  flc: Buffer.from('f'),
+  wma: Buffer.from('w'),
+  ogg: Buffer.from('o'),
+  aac: Buffer.from('a'),
+  alc: Buffer.from('l'),
+  dsf: Buffer.from('p'),
+  dff: Buffer.from('p'),
+  aif: Buffer.from('p'),
+};
+
+export const PLAYMODE_MAP: Record<PlayerState, string> = {
+  [PlayerState.STOPPED]: 'stop',
+  [PlayerState.PLAYING]: 'play',
+  [PlayerState.BUFFER_READY]: 'play',
+  [PlayerState.BUFFERING]: 'play',
+  [PlayerState.PAUSED]: 'pause',
+};
+
+export interface MediaMetadata {
+  item_id?: string;
+  artist?: string;
+  album?: string;
+  title?: string;
+  image_url?: string;
+  duration?: number;
+}
+
+export interface MediaDetails {
+  url: string;
+  mimeType?: string;
+  metadata?: MediaMetadata;
+  transition?: TransitionType;
+  transitionDuration?: number;
+}
+
+export interface Preset {
+  uri: string;
+  text: string;
+  icon: string;
+}

package/src/server.ts

@@ -0,0 +1,142 @@
+import { EventEmitter } from 'events';
+import net from 'net';
+import { startDiscovery } from './discovery.js';
+import { SLIMPROTO_PORT } from './constants.js';
+import { EventType, SlimEvent } from './models.js';
+import { getHostname, getIp } from './util.js';
+import { SlimClient } from './client.js';
+
+export interface SlimServerOptions {
+  cliPort?: number | null;
+  cliPortJson?: number | null;
+  ipAddress?: string | null;
+  name?: string | null;
+  controlPort?: number;
+}
+
+type Subscription = {
+  callback: (event: SlimEvent) => void | Promise<void>;
+  eventFilter: EventType[] | null;
+  playerFilter: string[] | null;
+};
+
+export class SlimServer extends EventEmitter {
+  readonly options: SlimServerOptions;
+
+  private server?: net.Server;
+  private discovery?: import('dgram').Socket;
+  private playersMap = new Map<string, SlimClient>();
+  private subscriptions: Subscription[] = [];
+
+  constructor(options: SlimServerOptions = {}) {
+    super();
+    this.options = options;
+  }
+
+  get players(): SlimClient[] {
+    return Array.from(this.playersMap.values());
+  }
+
+  getPlayer(playerId: string): SlimClient | undefined {
+    return this.playersMap.get(playerId);
+  }
+
+  async start(): Promise<void> {
+    const ipAddress = this.options.ipAddress ?? (await getIp());
+    const name = this.options.name ?? getHostname();
+    const controlPort = this.options.controlPort ?? SLIMPROTO_PORT;
+    this.server = net.createServer((socket) => this.registerPlayer(socket));
+    await new Promise<void>((resolve, reject) => {
+      this.server?.once('error', reject);
+      this.server?.listen(controlPort, '0.0.0.0', () => resolve());
+    });
+    this.discovery = startDiscovery({
+      ipAddress,
+      controlPort,
+      cliPort: this.options.cliPort ?? null,
+      cliPortJson: this.options.cliPortJson ?? null,
+      name,
+    });
+  }
+
+  async stop(): Promise<void> {
+    for (const client of this.playersMap.values()) {
+      client.disconnect();
+    }
+    this.playersMap.clear();
+    if (this.server) {
+      await new Promise<void>((resolve) => this.server?.close(() => resolve()));
+      this.server = undefined;
+    }
+    this.discovery?.close();
+    this.discovery = undefined;
+  }
+
+  subscribe(
+    cb: (event: SlimEvent) => void | Promise<void>,
+    eventFilter?: EventType | EventType[] | null,
+    playerFilter?: string | string[] | null,
+  ): () => void {
+    const eventList =
+      eventFilter == null ? null : Array.isArray(eventFilter) ? eventFilter : [eventFilter];
+    const playerList =
+      playerFilter == null ? null : Array.isArray(playerFilter) ? playerFilter : [playerFilter];
+    const subscription: Subscription = { callback: cb, eventFilter: eventList, playerFilter: playerList };
+    this.subscriptions.push(subscription);
+    return () => {
+      const idx = this.subscriptions.indexOf(subscription);
+      if (idx >= 0) this.subscriptions.splice(idx, 1);
+    };
+  }
+
+  private registerPlayer(socket: net.Socket): void {
+    const client = new SlimClient(socket, (player, eventType, data) => {
+      this.handleClientEvent(player, eventType, data);
+    });
+    socket.on('close', () => this.handleDisconnect(client));
+    socket.on('error', () => this.handleDisconnect(client));
+  }
+
+  private handleDisconnect(client: SlimClient): void {
+    if (client.playerId) {
+      this.playersMap.delete(client.playerId);
+    }
+  }
+
+  private handleClientEvent(player: SlimClient, eventType: EventType, data?: unknown): void {
+    const playerId = player.playerId;
+
+    if (eventType === EventType.PLAYER_CONNECTED) {
+      const existing = this.playersMap.get(playerId);
+      if (existing && existing.connected) {
+        player.disconnect();
+        return;
+      }
+      if (existing) {
+        existing.disconnect();
+      }
+      this.playersMap.set(playerId, player);
+    }
+
+    if (eventType === EventType.PLAYER_DISCONNECTED) {
+      if (playerId) {
+        this.playersMap.delete(playerId);
+      }
+    }
+
+    this.forwardEvent(playerId, eventType, data);
+  }
+
+  private forwardEvent(playerId: string, eventType: EventType, data?: unknown): void {
+    const event: SlimEvent = { type: eventType, playerId, data };
+    this.emit(eventType, event);
+    for (const sub of this.subscriptions) {
+      if (sub.playerFilter && playerId && !sub.playerFilter.includes(playerId)) continue;
+      if (sub.eventFilter && !sub.eventFilter.includes(eventType)) continue;
+      Promise.resolve(sub.callback(event)).catch((err) =>
+        // eslint-disable-next-line no-console
+        console.error('Error in subscriber', err),
+      );
+    }
+  }
+}

package/src/util.ts

@@ -0,0 +1,104 @@
+import dgram from 'dgram';
+import dns from 'dns/promises';
+import net from 'net';
+import os from 'os';
+import { FALLBACK_CODECS } from './constants.js';
+
+export async function getIp(): Promise<string> {
+  const socket = dgram.createSocket('udp4');
+  return new Promise((resolve) => {
+    socket.connect(1, '10.255.255.255', () => {
+      const address = socket.address();
+      socket.close();
+      if (typeof address === 'object') {
+        resolve(address.address);
+      } else {
+        resolve('127.0.0.1');
+      }
+    });
+    socket.on('error', () => {
+      socket.close();
+      resolve('127.0.0.1');
+    });
+  });
+}
+
+export function getHostname(): string {
+  return os.hostname();
+}
+
+export async function selectFreePort(rangeStart: number, rangeEnd: number): Promise<number> {
+  const isPortInUse = (port: number): Promise<boolean> =>
+    new Promise((resolve) => {
+      const tester = net.createServer();
+      tester.once('error', () => resolve(true));
+      tester.once('listening', () => tester.close(() => resolve(false)));
+      tester.listen(port, '0.0.0.0');
+    });
+
+  for (let port = rangeStart; port < rangeEnd; port += 1) {
+    // eslint-disable-next-line no-await-in-loop
+    const inUse = await isPortInUse(port);
+    if (!inUse) {
+      return port;
+    }
+  }
+  throw new Error('No free port available');
+}
+
+export function parseCapabilities(heloData: Buffer): Record<string, unknown> {
+  const params: Record<string, unknown> = {};
+  try {
+    const info = heloData.subarray(36).toString();
+    const pairs = info.replace(/,/g, '&').split('&');
+    for (const pair of pairs) {
+      if (!pair) continue;
+      const [key, value] = pair.split('=');
+      if (key) {
+        params[key] = value ?? '';
+      }
+    }
+    params.SupportedCodecs =
+      ['alc', 'aac', 'ogg', 'ogf', 'flc', 'aif', 'pcm', 'mp3'].filter((codec) => info.includes(codec)) ||
+      FALLBACK_CODECS;
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.error('Failed to parse capabilities', err);
+  }
+  return params;
+}
+
+export function parseHeaders(respData: Buffer): Record<string, string> {
+  const result: Record<string, string> = {};
+  const lines = respData.toString().split('\r\n').slice(1);
+  for (const line of lines) {
+    const [key, ...rest] = line.split(': ');
+    if (!key || rest.length === 0) continue;
+    result[key.toLowerCase()] = rest.join(': ');
+  }
+  return result;
+}
+
+export function parseStatus(respData: Buffer): { version: string; statusCode: number; statusText: string } {
+  const [statusLine] = respData.toString().split('\r\n');
+  if (!statusLine) {
+    return { version: 'HTTP/1.0', statusCode: 200, statusText: '' };
+  }
+  const [version, code, ...rest] = statusLine.split(' ');
+  return {
+    version,
+    statusCode: Number(code ?? 200),
+    statusText: rest.join(' '),
+  };
+}
+
+export async function lookupHost(host: string): Promise<string> {
+  const result = await dns.lookup(host);
+  return result.address;
+}
+
+export function ipToInt(ipAddress: string): number {
+  return ipAddress
+    .split('.')
+    .reduce((acc, octet) => (acc << 8) + Number(octet), 0) >>> 0;
+}

package/src/volume.ts

@@ -0,0 +1,64 @@
+export class SlimProtoVolume {
+  minimum = 0;
+  maximum = 100;
+  step = 1;
+
+  private static readonly oldMap: number[] = [
+    0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10, 11, 12, 13, 14, 15,
+    16, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 37,
+    38, 39, 40, 42, 43, 44, 46, 47, 48, 50, 51, 53, 54, 56, 57, 59, 60, 61, 63, 65,
+    66, 68, 69, 71, 72, 74, 75, 77, 79, 80, 82, 84, 85, 87, 89, 90, 92, 94, 96, 97,
+    99, 101, 103, 104, 106, 108, 110, 112, 113, 115, 117, 119, 121, 123, 125, 127,
+    128,
+  ];
+
+  private readonly totalVolumeRange = -50; // dB
+  private readonly stepPoint = -1;
+  private readonly stepFraction = 1;
+
+  volume = 50;
+
+  increment(): void {
+    this.volume = Math.min(this.volume + this.step, this.maximum);
+  }
+
+  decrement(): void {
+    this.volume = Math.max(this.volume - this.step, this.minimum);
+  }
+
+  oldGain(): number {
+    if (this.volume <= 0) return 0;
+    return SlimProtoVolume.oldMap[this.volume];
+  }
+
+  decibels(): number {
+    const stepDb = this.totalVolumeRange * this.stepFraction;
+    const maxVolumeDb = 0;
+    const slopeHigh = maxVolumeDb - stepDb / (100 - this.stepPoint);
+    const slopeLow = stepDb - this.totalVolumeRange / (this.stepPoint - 0.0);
+    const x2 = this.volume;
+    let m: number;
+    let x1: number;
+    let y1: number;
+    if (x2 > this.stepPoint) {
+      m = slopeHigh;
+      x1 = 100;
+      y1 = maxVolumeDb;
+    } else {
+      m = slopeLow;
+      x1 = 0;
+      y1 = this.totalVolumeRange;
+    }
+    return m * (x2 - x1) + y1;
+  }
+
+  newGain(): number {
+    if (this.volume <= 0) return 0;
+    const decibel = this.decibels();
+    const floatmult = 10 ** (decibel / 20.0);
+    if (decibel >= -30 && decibel <= 0) {
+      return Math.trunc(floatmult * (1 << 8) + 0.5) * (1 << 8);
+    }
+    return Math.trunc(floatmult * (1 << 16) + 0.5);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}