tserato 0.1.0 → 0.1.10

package/src/builder.ts

@@ -0,0 +1,198 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { BaseEncoder } from './encoders/baseEncoder';
+import { Crate } from './model/crate';
+import { Track } from './model/track';
+import { seratoEncode, seratoDecode, concatBytes, intToBytes, latin1Encode } from './util';
+
+export const DEFAULT_SERATO_FOLDER = path.join(
+  process.env.HOME ?? process.cwd(),
+  'Music',
+  '_Serato_'
+);
+
+export class Builder {
+  private _encoder?: BaseEncoder;
+  constructor(encoder?: BaseEncoder) { this._encoder = encoder; }
+
+  private static *_resolvePath(root: Crate): Generator<[Crate, string]> {
+    let pathStr = '';
+    const stack: Array<[Crate, string]> = [[root, pathStr]];
+    while (stack.length) {
+      const [crate, p] = stack.pop() as [Crate, string];
+      let newPath = p + `${crate.name}%%`;
+      const children = crate.children;
+      for (const child of children.values()) {
+        stack.push([child, newPath]);
+      }
+      yield [crate, newPath.replace(/%%$/, '') + '.crate'];
+    }
+  }
+
+  private static *_parseCrateNames(filepath: string): Generator<string> {
+    const parts = path.basename(filepath).split('%%');
+    for (const p of parts) yield p.replace('.crate', '');
+  }
+
+  private *_buildCrateFilepath(crate: Crate, seratoFolder: string): Generator<[Crate, string]> {
+    const subcrateFolder = path.join(seratoFolder, 'SubCrates');
+    if (!fs.existsSync(subcrateFolder)) fs.mkdirSync(subcrateFolder, { recursive: true });
+    for (const [c, p] of Builder._resolvePath(crate)) {
+      yield [c, path.join(subcrateFolder, p)];
+    }
+  }
+
+  parseCratesFromRootPath(subcratePath: string): Map<string, Crate> {
+    // map from top-level crate name to crate
+    const topLevelCrateMap = new Map<string, Crate>();
+
+    for (const entry of fs.readdirSync(subcratePath, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith("crate")) {
+        continue;
+      }
+
+      const fullPath = path.join(subcratePath, entry.name);
+      const crate = this._buildCratesFromFilepath(fullPath, topLevelCrateMap);
+
+      if (!topLevelCrateMap.has(crate.name)) {
+        topLevelCrateMap.set(crate.name, crate);
+      }
+    }
+
+    return topLevelCrateMap;
+  }
+
+  private _buildCratesFromFilepath(
+    filepath: string,
+    topLevelCrateMap: Map<string, Crate>,
+  ): Crate {
+    const crateNames = Array.from(Builder._parseCrateNames(filepath));
+    if (crateNames.length === 0) {
+      throw new Error(`No crates parsed from ${filepath}`);
+    }
+
+    const tracks: Track[] = [];
+    for (const p of this._parseCrateTracks(filepath)) {
+      console.log('make track from path ', p, 'from file path ', filepath)
+      tracks.push(Track.fromPath(p));
+    }
+
+    let root = topLevelCrateMap.get(crateNames[0]);
+    if (!root) {
+      root = new Crate(crateNames[0]);
+    }
+
+    let current = root;
+
+    for (const crateName of crateNames.slice(1)) {
+      let nextCrate = current.children.get(crateName);
+      if (!nextCrate) {
+        nextCrate = new Crate(crateName);
+        current.children.set(crateName, nextCrate);
+      }
+      current = nextCrate;
+    }
+
+    for (const track of tracks) {
+      current.addTrack(track);
+    }
+
+    return root;
+  }
+
+
+  private *_parseCrateTracks(filepath: string): Generator<string> {
+    let buffer = fs.readFileSync(filepath);
+    const OTRK = Buffer.from("otrk", "utf8");
+    const PTRK = Buffer.from("ptrk", "utf8");
+    while (buffer.length > 0) {
+      const otrkIdx = buffer.indexOf(OTRK);
+      if (otrkIdx < 0) break;
+
+      const ptrkIdx = buffer.indexOf(PTRK);
+      if (ptrkIdx < 0) break;
+
+      const ptrkSection = buffer.slice(ptrkIdx);
+
+      const trackNameLength = ptrkSection.readUInt32BE(4);
+      const trackNameEncoded = ptrkSection.slice(
+        8,
+        8 + trackNameLength,
+      );
+
+      let filePath = seratoDecode(trackNameEncoded);
+
+      if (!filePath.startsWith("/")) {
+        filePath = "/" + filePath;
+      }
+
+      yield filePath;
+
+      buffer = buffer.slice(ptrkIdx + 8 + trackNameLength);
+    }
+  }
+
+  private _construct(crate: Crate): Uint8Array {
+    // ----- HEADER -----
+    let header = concatBytes([
+      latin1Encode("vrsn"),
+      intToBytes(0, 1),
+      intToBytes(0, 1),
+      seratoEncode("81.0"),
+      seratoEncode("/Serato ScratchLive Crate"),
+    ]);
+
+    // ----- DEFAULT COLUMNS -----
+    const DEFAULT_COLUMNS = ["track", "artist", "album", "length"];
+
+    const parts: Uint8Array[] = [];
+    for (const column of DEFAULT_COLUMNS) {
+      parts.push(latin1Encode("ovct"));
+      parts.push(intToBytes(column.length * 2 + 18, 4));
+
+      parts.push(latin1Encode("tvcn"));
+      parts.push(intToBytes(column.length * 2, 4));
+      parts.push(seratoEncode(column));
+
+      parts.push(latin1Encode("tvcw"));
+      parts.push(intToBytes(2, 4));
+      parts.push(latin1Encode("0"));
+      parts.push(latin1Encode("0"));
+
+    }
+    const columnSection = concatBytes(parts);
+
+    // ----- PLAYLIST SECTION -----
+
+    const playlistParts: Uint8Array[] = [];
+    for (const track of crate.tracks) {
+      if (this._encoder) {
+        this._encoder.write(track);
+      }
+      const absoluteTrackPath = path.resolve(track.path);
+
+      const otrkSize = intToBytes(absoluteTrackPath.length * 2 + 8, 4);
+      const ptrkSize = intToBytes(absoluteTrackPath.length * 2, 4);
+
+      playlistParts.push(latin1Encode("otrk"));
+      playlistParts.push(otrkSize);
+      playlistParts.push(latin1Encode("ptrk"));
+      playlistParts.push(ptrkSize);
+      playlistParts.push(seratoEncode(absoluteTrackPath));
+    }
+    const playlistSection = concatBytes(playlistParts);
+
+    // ----- FINAL CONTENTS -----
+    const contents = concatBytes([header, columnSection, playlistSection]);
+    return contents;
+  }
+
+
+  save(root: Crate, savePath: string = DEFAULT_SERATO_FOLDER, overwrite = false): void {
+    for (const [crate, filepath] of this._buildCrateFilepath(root, savePath)) {
+      if (fs.existsSync(filepath) && !overwrite) continue;
+      const buffer = this._construct(crate);
+      fs.writeFileSync(filepath, buffer);
+    }
+  }
+}

package/src/encoders/baseEncoder.ts

@@ -0,0 +1,8 @@
+import { Track } from '../model/track';
+
+export abstract class BaseEncoder {
+  abstract get tagName(): string;
+  abstract get tagVersion(): Buffer;
+  abstract get markersName(): string;
+  abstract write(track: Track): void;
+}

package/src/encoders/serato_tags.ts

@@ -0,0 +1,4 @@
+export const SERATO_MARKERS_V2 = 'Serato Markers2';
+export const SERATO_OVERVIEW = 'Serato Overview';
+export const SERATO_MARKERS_V1 = 'Serato Markers_';
+export const SERATO_ANALYSIS = 'Serato Analysis';

package/src/encoders/utils.ts

@@ -0,0 +1,21 @@
+export function encode(data: Buffer): Buffer {
+  const a = data.readUInt8(0);
+  const b = data.readUInt8(1);
+  const c = data.readUInt8(2);
+  const z = c & 0x7F;
+  const y = ((c >> 7) | (b << 1)) & 0x7F;
+  const x = ((b >> 6) | (a << 2)) & 0x7F;
+  const w = a >> 5;
+  return Buffer.from([w, x, y, z]);
+}
+
+export function decode(data: Buffer): Buffer {
+  const w = data.readUInt8(0);
+  const x = data.readUInt8(1);
+  const y = data.readUInt8(2);
+  const z = data.readUInt8(3);
+  const c = (z & 0x7F) | ((y & 0x01) << 7);
+  const b = ((y & 0x7F) >> 1) | ((x & 0x03) << 6);
+  const a = ((x & 0x7F) >> 2) | ((w & 0x07) << 5);
+  return Buffer.from([a, b, c]);
+}

package/src/encoders/v2/v2Mp3Encoder.ts

@@ -0,0 +1,230 @@
+import { HotCue } from '../../../src/model/hotCue';
+import { HotCueType } from '../../model/hotCueType';
+import { Track } from '../../model/track';
+import { BaseEncoder } from '../baseEncoder';
+import { SERATO_MARKERS_V2 } from '../serato_tags';
+import MP3Tag from 'mp3tag.js'
+import { splitString } from '../../util';
+
+const fs = require('fs')
+
+/**
+ * Replacement for Python's BytesIO
+ */
+class BufferReader {
+  private offset = 0;
+  constructor(private buffer: Buffer) {}
+
+  read(n: number): Buffer {
+    const chunk = this.buffer.slice(this.offset, this.offset + n);
+    this.offset += n;
+    return chunk;
+  }
+
+  readUInt8(): number {
+    const value = this.buffer.readUInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+
+  readUInt32BE(): number {
+    const value = this.buffer.readUInt32BE(this.offset);
+    this.offset += 4;
+    return value;
+  }
+}
+
+export class V2Mp3Encoder extends BaseEncoder {
+
+  get tagName(): string {
+    return SERATO_MARKERS_V2;
+  }
+
+  get tagVersion(): Buffer {
+    return Buffer.from([0x01, 0x01]);
+  }
+
+  get markersName(): string {
+    return "Serato Markers2";
+  }
+
+  write(track: Track): void {
+    const payload = this._encode(track);
+    this._write(track, payload);
+  }
+
+  readCues(track: Track): HotCue[] {
+
+    // Read the buffer of an audio file
+    const buffer = fs.readFileSync(track.path.toString())
+    
+    // Now, pass it to MP3Tag
+    const mp3tag = new MP3Tag(buffer, true)
+    
+    mp3tag.read()
+    
+    const geob = mp3tag.tags.v2?.GEOB
+
+    if (!geob) {
+      return [];
+    }
+
+    const data = Buffer.from(geob[0].object);
+    return Array.from(this._decode(data));
+  }
+
+  private *_decode(data: Buffer): IterableIterator<HotCue> {
+    const fp = new BufferReader(data);
+
+    // Expect version 0x01, 0x01
+    const a = fp.readUInt8();
+    const b = fp.readUInt8();
+    if (a !== 0x01 || b !== 0x01) {
+      throw new Error("Invalid Serato markers header");
+    }
+
+    const payload = fp.read(data.length - 2);
+    let processed = this._removeNullPadding(payload);
+    processed = this._padEncodedData(processed);
+
+    const decoded = Buffer.from(processed.toString(), "base64");
+    const fp2 = new BufferReader(decoded);
+
+    const a2 = fp2.readUInt8();
+    const b2 = fp2.readUInt8();
+    if (a2 !== 0x01 || b2 !== 0x01) {
+      throw new Error("Invalid decoded header");
+    }
+
+    while (true) {
+      const entryName = this._getEntryName(fp2);
+      if (entryName.length === 0) {
+        break;
+      }
+
+      const structLength = fp2.readUInt32BE();
+      if (structLength <= 0) throw new Error("Invalid struct length");
+
+      const entryData = fp2.read(structLength);
+
+      switch (entryName) {
+        case "COLOR":
+          // not yet implemented
+          continue;
+        case "CUE":
+          yield HotCue.fromBytes(entryData, HotCueType.CUE);
+          continue
+        case "LOOP":
+          yield HotCue.fromBytes(entryData, HotCueType.LOOP);
+          continue
+        case "BPMLOCK":
+          // not yet implemented
+          continue;
+      }
+    }
+  }
+
+  private _removeNullPadding(payload: Buffer): Buffer {
+    const nullIndex = payload.indexOf(0x00);
+    return nullIndex >= 0 ? payload.slice(0, nullIndex) : payload;
+  }
+
+  private _getEntryName(fp: BufferReader): string {
+    const bytes: number[] = [];
+    while (true) {
+      const byte = fp.read(1)[0];
+      if (byte === 0x00) break;
+      bytes.push(byte);
+    }
+    return Buffer.from(bytes).toString("utf-8");
+  }
+
+  private _padEncodedData(data: Buffer): Buffer {
+    const len = data.length;
+    let padding: Buffer;
+    if (len % 4 === 1) {
+      padding = Buffer.from("A==");
+    } else {
+      padding = Buffer.from("=".repeat((-len % 4 + 4) % 4));
+    }
+    return Buffer.concat([data, padding]);
+  }
+
+  private _write(track: Track, payload: Buffer): void {
+    // Read the buffer of an audio file
+    const buffer = fs.readFileSync(track.path.toString())
+    
+    const mp3tag = new MP3Tag(buffer, true)
+    
+    mp3tag.read()
+    
+    // Write the ID3v2 tags.
+    // See https://mp3tag.js.org/docs/frames.html for the list of supported ID3v2 frames
+    
+    const object = Array.from(payload)
+    mp3tag.tags.v2!.GEOB = [
+      {
+        format: 'application/octet-stream',
+        filename: "",
+        object: object,
+        description: this.markersName,
+      }
+    ]
+    
+    // Save the tags
+    mp3tag.save({id3v2: {encoding: "latin1"}})
+    
+    // Handle error if there's any
+    if (mp3tag.error !== '') throw new Error(mp3tag.error)
+    
+    // Read the new buffer again
+    mp3tag.read()
+    
+    // Write the new buffer to file
+    fs.writeFileSync(track.path.toString(), mp3tag.buffer)
+  }
+
+  private _encode(track: Track): Buffer {
+    let payload = Buffer.alloc(0);
+    for (const cue of track.hotCues) {
+      payload = Buffer.concat([payload, cue.toV2Bytes()]);
+    }
+    for (const cue of track.cueLoops) {
+      payload = Buffer.concat([payload, cue.toV2Bytes()]);
+    }
+    return this._pad(payload);
+  }
+
+  private _pad(payload: Buffer, entriesCount?: number): Buffer {
+    // prepend tag version
+    payload = Buffer.concat([this.tagVersion, payload]);
+
+    payload = this._removeEncodedDataPad(Buffer.from(payload.toString("base64")));
+    payload = this._padPayload(splitString(payload));
+    payload = this._enrichPayload(payload, entriesCount);
+
+    return payload;
+  }
+
+  private _removeEncodedDataPad(data: Buffer): Buffer {
+    return Buffer.from(data.toString().replace(/=/g, "A"));
+  }
+
+  private _padPayload(payload: Buffer): Buffer {
+    const length = payload.length;
+    if (length < 468) {
+      return Buffer.concat([payload, Buffer.alloc(468 - length)]);
+    }
+    return Buffer.concat([payload, Buffer.alloc(982 - length), Buffer.from([0x00])]);
+  }
+
+  private _enrichPayload(payload: Buffer, entriesCount?: number): Buffer {
+    let header = this.tagVersion;
+    if (entriesCount !== undefined) {
+      const buf = Buffer.alloc(4);
+      buf.writeUInt32BE(entriesCount, 0);
+      header = Buffer.concat([header, buf]);
+    }
+    return Buffer.concat([header, payload]);
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { Builder, DEFAULT_SERATO_FOLDER } from './builder';
+export { V2Mp3Encoder } from './encoders/v2/v2Mp3Encoder';
+export { Crate } from './model/crate';
+export { Track } from './model/track';
+export { HotCue } from './model/hotCue';
+export { HotCueType } from './model/hotCueType';

package/src/model/crate.ts

@@ -0,0 +1,55 @@
+import { Track } from './track';
+import { sanitizeFilename, DuplicateTrackError } from '../util';
+
+export class Crate {
+  private _children: Map<string, Crate>;
+  readonly name: string;
+  private _tracks: Set<Track>;
+
+  constructor(name: string, children?: Map<string, Crate>) {
+    this._children = children ?? new Map();
+    this.name = sanitizeFilename(name);
+    this._tracks = new Set();
+  }
+
+  get children(): Map<string, Crate> {
+    return this._children;
+  }
+
+  get tracks(): Set<Track> {
+    return this._tracks;
+  }
+
+  addTrack(track: Track): void {
+    if (this._tracks.has(track)) {
+      throw new DuplicateTrackError(`track ${track} is already in the crate ${this.name}`);
+    }
+    this._tracks.add(track);
+  }
+
+  toString(): string {
+    return `Crate<${this.name}>`;
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return this.toString();
+  }
+
+  equals(other: Crate): boolean {
+    if (this.name !== other.name) return false;
+    if (this._tracks.size !== other._tracks.size) return false;
+
+    for (const [name, child] of this.children) {
+      const otherChild = other.children.get(name);
+      if (!otherChild) {
+        return false;
+      }
+      if (!child.equals(otherChild)) {
+        return false;
+      }
+    }
+
+    return true;
+
+  }
+}