stagelinq 1.0.0

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "stagelinq",
+	"version": "1.0.0",
+	"description": "Typescript library to connect to Denon StageLinq devices",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"start": "node dist/cli/index.js",
+		"build": "tsc --build tsconfig.json",
+		"watch": "tsc --build tsconfig.json -w"
+	},
+	"author": "Chris Le (TRIODE)",
+	"license": "GNU GPLv3",
+	"main": "index.ts",
+	"dependencies": {
+		"better-sqlite3": "^7.5.0",
+		"console-stamp": "^3.0.3",
+		"file-type": "^16.5.3",
+		"ip": "^1.1.5",
+		"minimist": "^1.2.5",
+		"promise-socket": "^7.0.0"
+	},
+	"devDependencies": {
+		"@types/assert": "^1.5.5",
+		"@types/better-sqlite3": "^7.4.0",
+		"@types/ip": "^1.1.0",
+		"@types/minimist": "^1.2.2",
+		"@types/node": "^16.4.0",
+		"prettier": "^2.5.1",
+		"typescript": "^4.6.2"
+	}
+}

package/services/FileTransfer.ts

@@ -0,0 +1,298 @@
+import { DOWNLOAD_TIMEOUT } from '../types';
+import { Logger } from '../LogEmitter';
+import { ReadContext } from '../utils/ReadContext';
+import { Service } from './Service';
+import { sleep } from '../utils/sleep';
+import { strict as assert } from 'assert';
+import { WriteContext } from '../utils/WriteContext';
+import type { ServiceMessage, Source } from '../types';
+
+const MAGIC_MARKER = 'fltx';
+export const CHUNK_SIZE = 4096;
+
+// FIXME: Strongly type this for all possible messages?
+type FileTransferData = any;
+
+enum MessageId {
+  TimeCode = 0x0,
+  FileStat = 0x1,
+  EndOfMessage = 0x2,
+  SourceLocations = 0x3,
+  FileTransferId = 0x4,
+  FileTransferChunk = 0x5,
+  Unknown0 = 0x8,
+}
+
+interface FileTransferProgress {
+  sizeLeft: number;
+  total: number;
+  bytesDownloaded: number;
+  percentComplete: number;
+}
+
+export declare interface FileTransfer {
+  on(event: 'fileTransferProgress', listener: (progress: FileTransferProgress) => void): this;
+}
+
+export class FileTransfer extends Service<FileTransferData> {
+  private receivedFile: WriteContext = null;
+
+  async init() {}
+
+  protected parseData(p_ctx: ReadContext): ServiceMessage<FileTransferData> {
+    const check = p_ctx.getString(4);
+    assert(check === MAGIC_MARKER);
+    const code = p_ctx.readUInt32();
+
+    // If first 4 bytes are non-zero, a timecode is sent
+    if (code > 0) {
+      assert(p_ctx.sizeLeft() === 8);
+      const id = p_ctx.readUInt32();
+      assert(id === 0x07d2);
+      assert(p_ctx.readUInt32() === 0);
+      return {
+        id: MessageId.TimeCode,
+        message: {
+          timecode: code,
+        },
+      };
+    }
+
+    // Else
+    const messageId: MessageId = p_ctx.readUInt32();
+    switch (messageId) {
+      case MessageId.SourceLocations: {
+        const sources: string[] = [];
+        const sourceCount = p_ctx.readUInt32();
+        for (let i = 0; i < sourceCount; ++i) {
+          // We get a location
+          const location = p_ctx.readNetworkStringUTF16();
+          sources.push(location);
+        }
+        // Final three bytes should be 0x1 0x1 0x1
+        assert(p_ctx.readUInt8() === 0x1);
+        assert(p_ctx.readUInt8() === 0x1);
+        assert(p_ctx.readUInt8() === 0x1);
+        assert(p_ctx.isEOF());
+        return {
+          id: messageId,
+          message: {
+            sources: sources,
+          },
+        };
+      }
+
+      case MessageId.FileStat: {
+        assert(p_ctx.sizeLeft() === 53);
+        // Last 4 bytes (FAT32) indicate size of file
+        p_ctx.seek(49);
+        const size = p_ctx.readUInt32();
+        return {
+          id: messageId,
+          message: {
+            size: size,
+          },
+        };
+      }
+
+      case MessageId.EndOfMessage: {
+        // End of result indication?
+        return {
+          id: messageId,
+          message: null,
+        };
+      }
+
+      case MessageId.FileTransferId: {
+        assert(p_ctx.sizeLeft() === 12);
+        assert(p_ctx.readUInt32() === 0x0);
+        const filesize = p_ctx.readUInt32();
+        const id = p_ctx.readUInt32();
+
+        return {
+          id: messageId,
+          message: {
+            size: filesize,
+            txid: id,
+          },
+        };
+      }
+
+      case MessageId.FileTransferChunk: {
+        assert(p_ctx.readUInt32() === 0x0);
+        const offset = p_ctx.readUInt32();
+        const chunksize = p_ctx.readUInt32();
+        assert(chunksize === p_ctx.sizeLeft());
+        assert(p_ctx.sizeLeft() <= CHUNK_SIZE);
+
+        return {
+          id: messageId,
+          message: {
+            data: p_ctx.readRemainingAsNewBuffer(),
+            offset: offset,
+            size: chunksize,
+          },
+        };
+      }
+
+      case MessageId.Unknown0: {
+        return {
+          id: messageId,
+          message: null,
+        };
+      }
+
+      default:
+        {
+          assert.fail(`File Transfer Unhandled message id '${messageId}'`);
+        }
+        break;
+    }
+  }
+
+  protected messageHandler(p_data: ServiceMessage<FileTransferData>): void {
+    if (p_data.id === MessageId.FileTransferChunk && this.receivedFile) {
+      assert(this.receivedFile.sizeLeft() >= p_data.message.size);
+      this.receivedFile.write(p_data.message.data);
+    } else {
+      // Logger.log(p_data);
+    }
+  }
+
+  async getFile(p_location: string): Promise<Uint8Array> {
+    assert(this.receivedFile === null);
+
+    await this.requestFileTransferId(p_location);
+    const txinfo = await this.waitForMessage(MessageId.FileTransferId);
+
+    if (txinfo) {
+      this.receivedFile = new WriteContext({ size: txinfo.size });
+
+      const totalChunks = Math.ceil(txinfo.size / CHUNK_SIZE);
+
+      await this.requestChunkRange(txinfo.txid, 0, totalChunks - 1);
+
+      try {
+        await new Promise(async (resolve, reject) => {
+          setTimeout(() => {
+            reject(new Error(`Failed to download '${p_location}'`));
+          }, DOWNLOAD_TIMEOUT);
+
+          while (this.receivedFile.isEOF() === false) {
+            const total = parseInt(txinfo.size);
+            const bytesDownloaded = total - this.receivedFile.sizeLeft();
+            const percentComplete = (bytesDownloaded / total) * 100;
+            this.emit('fileTransferProgress', {
+              sizeLeft: this.receivedFile.sizeLeft(),
+              total: txinfo.size,
+              bytesDownloaded: bytesDownloaded,
+              percentComplete: percentComplete
+            })
+            Logger.debug(`Reading ${p_location} progressComplete=${Math.ceil(percentComplete)}% ${bytesDownloaded}/${total}`);
+            await sleep(200);
+          }
+          Logger.debug(`Download complete.`);
+          resolve(true);
+        });
+      } catch (err) {
+        const msg = `Could not read database from ${p_location}: ${err.message}`
+        Logger.error(msg);
+        throw new Error(msg);
+      }
+
+      Logger.debug(`Signaling transfer complete.`);
+      await this.signalTransferComplete();
+    }
+
+    const buf = this.receivedFile ? this.receivedFile.getBuffer() : null;
+    this.receivedFile = null;
+    return buf;
+  }
+
+  async getSources(): Promise<Source[]> {
+    const result: Source[] = [];
+
+    await this.requestSources();
+    const message = await this.waitForMessage(MessageId.SourceLocations);
+    if (message) {
+      for (const source of message.sources) {
+        //try to retrieve V2.x Database2/m.db first. If file doesn't exist or 0 size, retrieve V1.x /m.db
+        const databases = [`/${source}/Engine Library/Database2/m.db`, `/${source}/Engine Library/m.db`];
+        for (const database of databases) {
+          await this.requestStat(database);
+          const fstatMessage = await this.waitForMessage(MessageId.FileStat);
+          if (fstatMessage.size > 0) {
+            result.push({
+              name: source,
+              database: {
+                location: database,
+                size: fstatMessage.size,
+              },
+            });
+            break;
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  ///////////////////////////////////////////////////////////////////////////
+  // Private methods
+
+  private async requestStat(p_filepath: string): Promise<void> {
+    // 0x7d1: seems to request some sort of fstat on a file
+    const ctx = new WriteContext();
+    ctx.writeFixedSizedString(MAGIC_MARKER);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(0x7d1);
+    ctx.writeNetworkStringUTF16(p_filepath);
+    await this.writeWithLength(ctx);
+  }
+
+  private async requestSources(): Promise<void> {
+    // 0x7d2: Request available sources
+    const ctx = new WriteContext();
+    ctx.writeFixedSizedString(MAGIC_MARKER);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(0x7d2); // Database query
+    ctx.writeUInt32(0x0);
+    await this.writeWithLength(ctx);
+  }
+
+  private async requestFileTransferId(p_filepath: string): Promise<void> {
+    // 0x7d4: Request transfer id?
+    const ctx = new WriteContext();
+    ctx.writeFixedSizedString(MAGIC_MARKER);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(0x7d4);
+    ctx.writeNetworkStringUTF16(p_filepath);
+    ctx.writeUInt32(0x0); // Not sure why we need 0x0 here
+    await this.writeWithLength(ctx);
+  }
+
+  private async requestChunkRange(p_txid: number, p_chunkStartId: number, p_chunkEndId: number): Promise<void> {
+    // 0x7d5: seems to be the code to request chunk range
+    const ctx = new WriteContext();
+    ctx.writeFixedSizedString(MAGIC_MARKER);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(0x7d5);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(p_txid); // I assume this is the transferid
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(p_chunkStartId);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(p_chunkEndId);
+    await this.writeWithLength(ctx);
+  }
+
+  private async signalTransferComplete(): Promise<void> {
+    // 0x7d6: seems to be the code to signal transfer completed
+    const ctx = new WriteContext();
+    ctx.writeFixedSizedString(MAGIC_MARKER);
+    ctx.writeUInt32(0x0);
+    ctx.writeUInt32(0x7d6);
+    await this.writeWithLength(ctx);
+  }
+}

package/services/Service.ts

@@ -0,0 +1,144 @@
+//import { hex } from '../utils/hex';
+import { EventEmitter } from 'events';
+import { Logger } from '../LogEmitter';
+import { MessageId, MESSAGE_TIMEOUT, Tokens } from '../types';
+import { NetworkDevice } from '../network/NetworkDevice';
+import { ReadContext } from '../utils/ReadContext';
+import { strict as assert } from 'assert';
+import { WriteContext } from '../utils/WriteContext';
+import * as tcp from '../utils/tcp';
+import type { ServiceMessage } from '../types';
+
+export abstract class Service<T> extends EventEmitter {
+	private address: string;
+	private port: number;
+	public readonly name: string;
+	protected controller: NetworkDevice;
+	protected connection: tcp.Connection = null;
+
+	constructor(p_address: string, p_port: number, p_controller: NetworkDevice) {
+		super();
+		this.address = p_address;
+		this.port = p_port;
+		this.name = this.constructor.name;
+		this.controller = p_controller;
+	}
+
+	async connect(): Promise<void> {
+		assert(!this.connection);
+		this.connection = await tcp.connect(this.address, this.port);
+		let queue: Buffer = null;
+
+		this.connection.socket.on('data', (p_data: Buffer) => {
+			let buffer: Buffer = null;
+			if (queue && queue.length > 0) {
+				buffer = Buffer.concat([queue, p_data]);
+			} else {
+				buffer = p_data;
+			}
+
+			// FIXME: Clean up this arraybuffer confusion mess
+			const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+			const ctx = new ReadContext(arrayBuffer, false);
+			queue = null;
+
+			try {
+				while (ctx.isEOF() === false) {
+					if (ctx.sizeLeft() < 4) {
+						queue = ctx.readRemainingAsNewBuffer();
+						break;
+					}
+
+					const length = ctx.readUInt32();
+					if (length <= ctx.sizeLeft()) {
+						const message = ctx.read(length);
+						// Use slice to get an actual copy of the message instead of working on the shared underlying ArrayBuffer
+						const data = message.buffer.slice(message.byteOffset, message.byteOffset + length);
+						// Logger.info("RECV", length);
+						//hex(message);
+						const parsedData = this.parseData(new ReadContext(data, false));
+
+						// Forward parsed data to message handler
+						this.messageHandler(parsedData);
+						this.emit('message', parsedData);
+					} else {
+						ctx.seek(-4); // Rewind 4 bytes to include the length again
+						queue = ctx.readRemainingAsNewBuffer();
+						break;
+					}
+				}
+			} catch (err) {
+				// FIXME: Rethrow based on the severity?
+				Logger.error(err);
+			}
+		});
+
+		// FIXME: Is this required for all Services?
+		const ctx = new WriteContext();
+		ctx.writeUInt32(MessageId.ServicesAnnouncement);
+		ctx.write(Tokens.SoundSwitch);
+		ctx.writeNetworkStringUTF16(this.name);
+		ctx.writeUInt16(this.connection.socket.localPort); // FIXME: In the Go code this is the local TCP port, but 0 or any other 16 bit value seems to work fine as well
+		await this.write(ctx);
+
+		await this.init();
+
+		Logger.debug(`Connected to service '${this.name}' at port ${this.port}`);
+	}
+
+	disconnect() {
+		assert(this.connection);
+		try {
+			this.connection.destroy();
+		} catch (e) {
+			Logger.error('Error disconnecting', e);
+		} finally {
+			this.connection = null;
+		}
+	}
+
+	async waitForMessage(p_messageId: number): Promise<T> {
+		return await new Promise((resolve, reject) => {
+			const listener = (p_message: ServiceMessage<T>) => {
+				if (p_message.id === p_messageId) {
+					this.removeListener('message', listener);
+					resolve(p_message.message);
+				}
+			};
+			this.addListener('message', listener);
+			setTimeout(() => {
+				reject(new Error(`Failed to receive message '${p_messageId}' on time`));
+			}, MESSAGE_TIMEOUT);
+		});
+	}
+
+	async write(p_ctx: WriteContext) {
+		assert(p_ctx.isLittleEndian() === false);
+		assert(this.connection);
+		const buf = p_ctx.getBuffer();
+		// Logger.info("SEND");
+		//hex(buf);
+		const written = await this.connection.write(buf);
+		assert(written === buf.byteLength);
+		return written;
+	}
+
+	async writeWithLength(p_ctx: WriteContext) {
+		assert(p_ctx.isLittleEndian() === false);
+		assert(this.connection);
+		const newCtx = new WriteContext({ size: p_ctx.tell() + 4, autoGrow: false });
+		newCtx.writeUInt32(p_ctx.tell());
+		newCtx.write(p_ctx.getBuffer());
+		assert(newCtx.isEOF());
+		return await this.write(newCtx);
+	}
+
+	// FIXME: Cannot use abstract because of async; is there another way to get this?
+	protected async init() {
+		assert.fail('Implement this');
+	}
+
+	protected abstract parseData(p_ctx: ReadContext): ServiceMessage<T>;
+
+	protected abstract messageHandler(p_data: ServiceMessage<T>): void;
+}

package/services/StateMap.ts

@@ -0,0 +1,170 @@
+import { strict as assert } from 'assert';
+import { StageLinqValue } from '../types';
+import { ReadContext } from '../utils/ReadContext';
+import { WriteContext } from '../utils/WriteContext';
+import { Service } from './Service';
+import type { ServiceMessage } from '../types';
+// import { Logger } from '../LogEmitter';
+
+export const States = [
+  // Mixer
+  StageLinqValue.MixerCH1faderPosition,
+  StageLinqValue.MixerCH2faderPosition,
+  StageLinqValue.MixerCrossfaderPosition,
+
+  // Decks
+  StageLinqValue.EngineDeck1Play,
+  StageLinqValue.EngineDeck1PlayState,
+  StageLinqValue.EngineDeck1PlayStatePath,
+  StageLinqValue.EngineDeck1TrackArtistName,
+  StageLinqValue.EngineDeck1TrackTrackNetworkPath,
+  StageLinqValue.EngineDeck1TrackSongLoaded,
+  StageLinqValue.EngineDeck1TrackSongName,
+  StageLinqValue.EngineDeck1TrackTrackData,
+  StageLinqValue.EngineDeck1TrackTrackName,
+  StageLinqValue.EngineDeck1CurrentBPM,
+  StageLinqValue.EngineDeck1ExternalMixerVolume,
+
+  StageLinqValue.EngineDeck2Play,
+  StageLinqValue.EngineDeck2PlayState,
+  StageLinqValue.EngineDeck2PlayStatePath,
+  StageLinqValue.EngineDeck2TrackArtistName,
+  StageLinqValue.EngineDeck2TrackTrackNetworkPath,
+  StageLinqValue.EngineDeck2TrackSongLoaded,
+  StageLinqValue.EngineDeck2TrackSongName,
+  StageLinqValue.EngineDeck2TrackTrackData,
+  StageLinqValue.EngineDeck2TrackTrackName,
+  StageLinqValue.EngineDeck2CurrentBPM,
+  StageLinqValue.EngineDeck2ExternalMixerVolume,
+
+  StageLinqValue.EngineDeck3Play,
+  StageLinqValue.EngineDeck3PlayState,
+  StageLinqValue.EngineDeck3PlayStatePath,
+  StageLinqValue.EngineDeck3TrackArtistName,
+  StageLinqValue.EngineDeck3TrackTrackNetworkPath,
+  StageLinqValue.EngineDeck3TrackSongLoaded,
+  StageLinqValue.EngineDeck3TrackSongName,
+  StageLinqValue.EngineDeck3TrackTrackData,
+  StageLinqValue.EngineDeck3TrackTrackName,
+  StageLinqValue.EngineDeck3CurrentBPM,
+  StageLinqValue.EngineDeck3ExternalMixerVolume,
+
+  StageLinqValue.EngineDeck4Play,
+  StageLinqValue.EngineDeck4PlayState,
+  StageLinqValue.EngineDeck4PlayStatePath,
+  StageLinqValue.EngineDeck4TrackArtistName,
+  StageLinqValue.EngineDeck4TrackTrackNetworkPath,
+  StageLinqValue.EngineDeck4TrackSongLoaded,
+  StageLinqValue.EngineDeck4TrackSongName,
+  StageLinqValue.EngineDeck4TrackTrackData,
+  StageLinqValue.EngineDeck4TrackTrackName,
+  StageLinqValue.EngineDeck4CurrentBPM,
+  StageLinqValue.EngineDeck4ExternalMixerVolume,
+
+  StageLinqValue.ClientPreferencesLayerA,
+  StageLinqValue.ClientPreferencesPlayer,
+  StageLinqValue.ClientPreferencesPlayerJogColorA,
+  StageLinqValue.ClientPreferencesPlayerJogColorB,
+  StageLinqValue.EngineDeck1DeckIsMaster,
+  StageLinqValue.EngineDeck2DeckIsMaster,
+  StageLinqValue.EngineMasterMasterTempo,
+  StageLinqValue.EngineSyncNetworkMasterStatus,
+  StageLinqValue.MixerChannelAssignment1,
+  StageLinqValue.MixerChannelAssignment2,
+  StageLinqValue.MixerChannelAssignment3,
+  StageLinqValue.MixerChannelAssignment4,
+  StageLinqValue.MixerNumberOfChannels,
+
+];
+
+const MAGIC_MARKER = 'smaa';
+// FIXME: Is this thing really an interval?
+const MAGIC_MARKER_INTERVAL = 0x000007d2;
+const MAGIC_MARKER_JSON = 0x00000000;
+
+export interface StateData {
+  name: string;
+  json?: {
+    type: number;
+    string?: string;
+    value?: number;
+  };
+  interval?: number;
+}
+
+export class StateMap extends Service<StateData> {
+  async init() {
+    for (const state of States) {
+      await this.subscribeState(state, 0);
+    }
+  }
+
+  protected parseData(p_ctx: ReadContext): ServiceMessage<StateData> {
+    const marker = p_ctx.getString(4);
+    assert(marker === MAGIC_MARKER);
+
+    const type = p_ctx.readUInt32();
+    switch (type) {
+      case MAGIC_MARKER_JSON: {
+        const name = p_ctx.readNetworkStringUTF16();
+        const json = JSON.parse(p_ctx.readNetworkStringUTF16());
+        return {
+          id: MAGIC_MARKER_JSON,
+          message: {
+            name: name,
+            json: json,
+          },
+        };
+      }
+
+      case MAGIC_MARKER_INTERVAL: {
+        const name = p_ctx.readNetworkStringUTF16();
+        const interval = p_ctx.readInt32();
+        return {
+          id: MAGIC_MARKER_INTERVAL,
+          message: {
+            name: name,
+            interval: interval,
+          },
+        };
+      }
+
+      default:
+        break;
+    }
+    assert.fail(`Unhandled type ${type}`);
+    return null;
+  }
+
+  protected messageHandler(_: ServiceMessage<StateData>): void {
+    // Logger.debug(
+    //   `${p_data.message.name} => ${
+    //     p_data.message.json ? JSON.stringify(p_data.message.json) : p_data.message.interval
+    //   }`
+    // );
+  }
+
+  private async subscribeState(p_state: string, p_interval: number) {
+    // Logger.log(`Subscribe to state '${p_state}'`);
+    const getMessage = function (): Buffer {
+      const ctx = new WriteContext();
+      ctx.writeFixedSizedString(MAGIC_MARKER);
+      ctx.writeUInt32(MAGIC_MARKER_INTERVAL);
+      ctx.writeNetworkStringUTF16(p_state);
+      ctx.writeUInt32(p_interval);
+      return ctx.getBuffer();
+    };
+
+    const message = getMessage();
+    {
+      const ctx = new WriteContext();
+      ctx.writeUInt32(message.length);
+      const written = await this.connection.write(ctx.getBuffer());
+      assert(written === 4);
+    }
+    {
+      const written = await this.connection.write(message);
+      assert(written === message.length);
+    }
+  }
+}

package/services/index.ts

@@ -0,0 +1,3 @@
+export * from './FileTransfer';
+export * from './Service';
+export * from './StateMap';

package/stagelinq.code-workspace

@@ -0,0 +1,16 @@
+{
+	"folders": [
+		{
+			"path": "."
+		},
+		{
+			"path": "../stagelinq-pcap"
+		},
+		{
+			"path": "../go-stagelinq"
+		}
+	],
+	"settings": {
+		"task.allowAutomaticTasks": "on"
+	}
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"target": "es2020",
+		"module": "commonjs",
+		"outDir": "dist",
+		"sourceMap": true,
+		"allowJs": false,
+		"alwaysStrict": true,
+		"noImplicitAny": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true
+	}
+}