rhythia-api 242.0.0 → 243.0.0

package/utils/star-calc/sspmParser.ts

@@ -1,3 +1,5 @@
+import { Buffer } from "buffer";
+
 type DataTypeID =
   | 0x00
   | 0x01
@@ -13,6 +15,22 @@ type DataTypeID =
   | 0x0b
   | 0x0c;
 
+const enum DataType {
+  End = 0x00,
+  Byte = 0x01,
+  UInt16 = 0x02,
+  UInt32 = 0x03,
+  UInt64 = 0x04,
+  Float = 0x05,
+  Double = 0x06,
+  Position = 0x07,
+  Buffer = 0x08,
+  String = 0x09,
+  LongBuffer = 0x0a,
+  LongString = 0x0b,
+  Array = 0x0c,
+}
+
 interface Header {
   signature: Buffer;
   version: number;
@@ -70,33 +88,66 @@ interface MarkerDefinition {
 interface Marker {
   position: number;
   type: number;
-  data: Buffer;
+  data: any;
 }
 
 export class SSPMParser {
+  private static readonly SIGNATURE = 0x6d2b5353;
   private buffer: Buffer;
-  private offset: number = 0;
+  private offset = 0;
 
   constructor(buffer: Buffer) {
     this.buffer = buffer;
   }
 
   private checkBounds(length: number): void {
-    if (this.offset + length > this.buffer.length) {
+    if (length < 0 || this.offset + length > this.buffer.length) {
       throw new RangeError(
-        `Attempt to read beyond buffer length: Offset=${this.offset}, Length=${length}, Buffer Length=${this.buffer.length}`
+        `Attempt to read beyond buffer length: offset=${this.offset}, length=${length}, bufferLength=${this.buffer.length}`
       );
     }
   }
 
-  private log(message: string): void {
-    // console.log(`[Offset: ${this.offset}] ${message}`);
+  private seek(position: number): void {
+    if (
+      !Number.isInteger(position) ||
+      position < 0 ||
+      position > this.buffer.length
+    ) {
+      throw new RangeError(`Invalid seek position: ${position}`);
+    }
+    this.offset = position;
+  }
+
+  private skip(length: number): void {
+    this.checkBounds(length);
+    this.offset += length;
+  }
+
+  private log(_message: string): void {}
+
+  private readUInt8(): number {
+    this.checkBounds(1);
+    return this.buffer.readUInt8(this.offset++);
+  }
+
+  private readInt32(): number {
+    this.checkBounds(4);
+    const value = this.buffer.readInt32LE(this.offset);
+    this.offset += 4;
+    return value;
   }
 
   private readUInt16(): number {
     this.checkBounds(2);
     const value = this.buffer.readUInt16LE(this.offset);
-    this.log(`Read UInt16: ${value}`);
+    this.offset += 2;
+    return value;
+  }
+
+  private readInt16(): number {
+    this.checkBounds(2);
+    const value = this.buffer.readInt16LE(this.offset);
     this.offset += 2;
     return value;
   }
@@ -104,39 +155,55 @@ export class SSPMParser {
   private readUInt32(): number {
     this.checkBounds(4);
     const value = this.buffer.readUInt32LE(this.offset);
-    this.log(`Read UInt32: ${value}`);
     this.offset += 4;
     return value;
   }
 
+  private readUInt64BigInt(): bigint {
+    this.checkBounds(8);
+    const value = this.buffer.readBigUInt64LE(this.offset);
+    this.offset += 8;
+    return value;
+  }
+
   private readUInt64(): number {
+    const value = this.readUInt64BigInt();
+    const asNumber = Number(value);
+
+    if (!Number.isSafeInteger(asNumber)) {
+      throw new RangeError(`OutOfRange: ${value.toString()}`);
+    }
+
+    return asNumber;
+  }
+
+  private readFloat32(): number {
+    this.checkBounds(4);
+    const value = this.buffer.readFloatLE(this.offset);
+    this.offset += 4;
+    return value;
+  }
+
+  private readFloat64(): number {
     this.checkBounds(8);
-    const low = this.buffer.readUInt32LE(this.offset);
-    const high = this.buffer.readUInt32LE(this.offset + 4);
+    const value = this.buffer.readDoubleLE(this.offset);
     this.offset += 8;
-    const value = low + high * 2 ** 32;
-    this.log(`Read UInt64: ${value} (Low: ${low}, High: ${high})`);
     return value;
   }
 
   private readBytes(length: number): Buffer {
     this.checkBounds(length);
-    const value = this.buffer.slice(this.offset, this.offset + length);
-    this.log(`Read ${length} bytes`);
+    const value = this.buffer.subarray(this.offset, this.offset + length);
     this.offset += length;
     return value;
   }
 
-  private readString(): string {
-    const length = this.readUInt16();
-    this.checkBounds(length);
-    const value = this.readBytes(length).toString("utf-8");
-    this.log(`Read String of length ${length}: ${value}`);
-    return value;
+  private readString(longString = false): string {
+    const length = longString ? this.readUInt32() : this.readUInt16();
+    return this.readBytes(length).toString("utf8");
   }
 
   private readStringList(count: number): string[] {
-    console.log("[DANGER] Reading String List");
     const list: string[] = [];
     for (let i = 0; i < count; i++) {
       list.push(this.readString());
@@ -144,77 +211,129 @@ export class SSPMParser {
     return list;
   }
 
-  private readMarkerField(typeID: DataTypeID): any {
+  private readPosition(): { x: number; y: number; type: "int" | "quantum" } {
+    const type = this.readUInt8();
+
+    if (type === 0x00) {
+      return {
+        x: this.readUInt8(),
+        y: this.readUInt8(),
+        type: "int",
+      };
+    }
+
+    if (type === 0x01) {
+      return {
+        x: this.readFloat32(),
+        y: this.readFloat32(),
+        type: "quantum",
+      };
+    }
+
+    throw new Error(`Invalid position type: ${type}`);
+  }
+
+  private readTypedValue(typeID: DataTypeID): any {
     switch (typeID) {
-      case 0x01: // 1 byte integer
-        this.checkBounds(1);
-        const int8 = this.buffer.readInt8(this.offset++);
-        this.log(`Read Int8: ${int8}`);
-        return int8;
-      case 0x02: // 2 byte uint
+      case DataType.End:
+        return null;
+      case DataType.Byte:
+        return this.readUInt8();
+      case DataType.UInt16:
         return this.readUInt16();
-      case 0x03: // 4 byte uint
+      case DataType.UInt32:
         return this.readUInt32();
-      case 0x04: // 8 byte uint
+      case DataType.UInt64:
         return this.readUInt64();
-      case 0x05: // 4 byte float
-        this.checkBounds(4);
-        const floatVal32 = this.buffer.readFloatLE(this.offset);
-        this.log(`Read Float32: ${floatVal32}`);
-        this.offset += 4;
-        return floatVal32;
-      case 0x06: // 8 byte float
-        this.checkBounds(8);
-        const floatVal64 = this.buffer.readDoubleLE(this.offset);
-        this.log(`Read Float64: ${floatVal64}`);
-        this.offset += 8;
-        return floatVal64;
-      case 0x07: // position type
-        const isQuantum = this.buffer.readUInt8(this.offset++);
-        let posData;
-        if (isQuantum === 0x00) {
-          this.checkBounds(2);
-          const posX = this.buffer.readUInt8(this.offset++);
-          const posY = this.buffer.readUInt8(this.offset++);
-          this.log(`Read Position Int: x=${posX}, y=${posY}`);
-          posData = { x: posX, y: posY, type: "int" };
-        } else {
-          this.checkBounds(8);
-          const posX = this.buffer.readFloatLE(this.offset);
-          this.offset += 4;
-          const posY = this.buffer.readFloatLE(this.offset);
-          this.offset += 4;
-          this.log(`Read Position Quantum: x=${posX}, y=${posY}`);
-          posData = { x: posX, y: posY, type: "quantum" };
+      case DataType.Float:
+        return this.readFloat32();
+      case DataType.Double:
+        return this.readFloat64();
+      case DataType.Position:
+        return this.readPosition();
+      case DataType.Buffer: {
+        const length = this.readUInt16();
+        return this.readBytes(length);
+      }
+      case DataType.String:
+        return this.readString(false);
+      case DataType.LongBuffer: {
+        const length = this.readUInt32();
+        return this.readBytes(length);
+      }
+      case DataType.LongString:
+        return this.readString(true);
+      case DataType.Array:
+        throw new Error("Array type must be handled separately.");
+      default:
+        throw new Error(`Unknown data type: ${typeID}`);
+    }
+  }
+
+  private skipTypedValue(typeID: DataTypeID): void {
+    switch (typeID) {
+      case DataType.End:
+        return;
+      case DataType.Byte:
+        this.skip(1);
+        return;
+      case DataType.UInt16:
+        this.skip(2);
+        return;
+      case DataType.UInt32:
+        this.skip(4);
+        return;
+      case DataType.UInt64:
+        this.skip(8);
+        return;
+      case DataType.Float:
+        this.skip(4);
+        return;
+      case DataType.Double:
+        this.skip(8);
+        return;
+      case DataType.Position: {
+        const posType = this.readUInt8();
+        if (posType === 0x00) {
+          this.skip(2);
+          return;
         }
-        return posData;
-      case 0x08: // buffer
-      case 0x09: // string
-        const length16 = this.readUInt16();
-        this.checkBounds(length16);
-        const value = this.readBytes(length16).toString("utf-8");
-        this.log(`Read Buffer/String of length ${length16}`);
-        return value;
-      case 0x0a: // long buffer
-      case 0x0b: // long string
-        const length32 = this.readUInt32();
-        this.log(`Reading Buffer/String of length ${length32}`);
-        this.checkBounds(length32);
-        const longValue = this.readBytes(length32).toString("utf-8");
-        this.log(`Read Long Buffer/String of length ${length32}`);
-        return longValue;
-      case 0x00: // end type, should not appear here
+        if (posType === 0x01) {
+          this.skip(8);
+          return;
+        }
+        throw new Error(`Invalid position type while skipping: ${posType}`);
+      }
+      case DataType.Buffer:
+      case DataType.String:
+        this.skip(this.readUInt16());
+        return;
+      case DataType.LongBuffer:
+      case DataType.LongString:
+        this.skip(this.readUInt32());
+        return;
+      case DataType.Array:
+        throw new Error("Array is not allowed in markers.");
       default:
-        throw new Error("Unexpected DataTypeID in marker definition.");
+        throw new Error(`Unknown data type while skipping: ${typeID}`);
     }
   }
 
-  private readMarkerData(typeIDs: DataTypeID[]): any {
-    const dataObject: any = {};
-    for (const [index, typeID] of typeIDs.entries()) {
-      dataObject[`field${index}`] = this.readMarkerField(typeID);
+  private readCustomValue(type: DataTypeID, arrayType?: DataTypeID): any {
+    if (type === DataType.Array) {
+      if (arrayType == null) {
+        throw new Error("Array custom field missing array element type.");
+      }
+
+      const count = this.readUInt32();
+      const values: any[] = [];
+      for (let i = 0; i < count; i++) {
+        values.push(this.readTypedValue(arrayType));
+      }
+      return values;
     }
-    return dataObject;
+
+    return this.readTypedValue(type);
   }
 
   parse(): {
@@ -228,30 +347,33 @@ export class SSPMParser {
     markerDefinitions: MarkerDefinition[];
     markers: Marker[];
   } {
-    // Header
     const header: Header = {
       signature: this.readBytes(4),
-      version: this.readUInt16(),
+      version: this.readInt16(),
       reserved: this.readBytes(4),
     };
-    if (header.version == 1) {
-      throw "Can't parse";
+
+    const signatureValue = header.signature.readInt32LE(0);
+    if (signatureValue !== SSPMParser.SIGNATURE) {
+      throw new Error("Invalid SSPM signature.");
+    }
+
+    if (header.version !== 2) {
+      throw new Error(`Invalid SSPM version: ${header.version}`);
     }
 
-    // Static Metadata
     const metadata: StaticMetadata = {
       sha1: this.readBytes(20),
       lastMarkerPos: this.readUInt32(),
       noteCount: this.readUInt32(),
       markerCount: this.readUInt32(),
-      difficulty: this.buffer.readUInt8(this.offset++),
+      difficulty: this.readUInt8(),
       rating: this.readUInt16(),
-      hasAudio: this.buffer.readUInt8(this.offset++) === 1,
-      hasCover: this.buffer.readUInt8(this.offset++) === 1,
-      requiresMod: this.buffer.readUInt8(this.offset++) === 1,
+      hasAudio: this.readUInt8() === 0x01,
+      hasCover: this.readUInt8() === 0x01,
+      requiresMod: this.readUInt8() === 0x01,
     };
 
-    // Pointers
     const pointers: Pointers = {
       customDataOffset: this.readUInt64(),
       customDataLength: this.readUInt64(),
@@ -265,19 +387,6 @@ export class SSPMParser {
       markerLength: this.readUInt64(),
     };
 
-    // Log derived pointer values
-    this.log(`customDataOffset: ${pointers.customDataOffset}`);
-    this.log(`customDataLength: ${pointers.customDataLength}`);
-    this.log(`audioOffset: ${pointers.audioOffset}`);
-    this.log(`audioLength: ${pointers.audioLength}`);
-    this.log(`coverOffset: ${pointers.coverOffset}`);
-    this.log(`coverLength: ${pointers.coverLength}`);
-    this.log(`markerDefinitionsOffset: ${pointers.markerDefinitionsOffset}`);
-    this.log(`markerDefinitionsLength: ${pointers.markerDefinitionsLength}`);
-    this.log(`markerOffset: ${pointers.markerOffset}`);
-    this.log(`markerLength: ${pointers.markerLength}`);
-
-    // Strings
     const strings: Strings = {
       mapID: this.readString(),
       mapName: this.readString(),
@@ -285,89 +394,114 @@ export class SSPMParser {
       mappers: this.readStringList(this.readUInt16()),
     };
 
-    let customData: CustomData = { fields: [] };
-    try {
-      if (pointers.customDataOffset && pointers.customDataLength) {
-        this.log(
-          `Reading Custom Data, Offset: ${pointers.customDataOffset}, Length: ${pointers.customDataLength}`
-        );
-        this.offset = Number(pointers.customDataOffset);
-        const fieldCount = this.readUInt16();
-        this.log(`Fields: ${fieldCount.toString()}`);
-        for (let i = 0; i < fieldCount; i++) {
-          const id = this.readString();
-          const type = this.buffer.readUInt8(this.offset++) as DataTypeID;
-          let arrayType: DataTypeID | undefined;
-          if (type === 0x0c) {
-            arrayType = this.buffer.readUInt8(this.offset++) as DataTypeID;
-          }
-          const length = this.readUInt32();
-          // this.checkBounds(length);
-          const value = this.readBytes(length);
-          customData.fields.push({ id, type, arrayType, value });
+    const customData: CustomData = { fields: [] };
+
+    if (pointers.customDataOffset !== 0) {
+      this.seek(pointers.customDataOffset);
+
+      const fieldCount = this.readUInt16();
+      for (let i = 0; i < fieldCount; i++) {
+        const id = this.readString();
+        const type = this.readUInt8() as DataTypeID;
+
+        let arrayType: DataTypeID | undefined;
+        if (type === DataType.Array) {
+          arrayType = this.readUInt8() as DataTypeID;
         }
+
+        const value = this.readCustomValue(type, arrayType);
+        customData.fields.push({ id, type, arrayType, value });
       }
-    } catch (error) {}
+    }
 
     let audio: Buffer | undefined;
     if (
       metadata.hasAudio &&
-      pointers.audioOffset != 0 &&
-      pointers.audioLength != 0
+      pointers.audioOffset !== 0 &&
+      pointers.audioLength !== 0
     ) {
-      this.log(
-        `Reading Audio Data, Offset: ${pointers.audioOffset}, Length: ${pointers.audioLength}`
-      );
-      this.offset = Number(pointers.audioOffset);
-      this.checkBounds(Number(pointers.audioLength));
-      audio = this.readBytes(Number(pointers.audioLength));
+      this.seek(pointers.audioOffset);
+      audio = this.readBytes(pointers.audioLength);
     }
 
     let cover: Buffer | undefined;
     if (
       metadata.hasCover &&
-      pointers.coverOffset != 0 &&
-      pointers.coverLength != 0
+      pointers.coverOffset !== 0 &&
+      pointers.coverLength !== 0
     ) {
-      this.log(
-        `Reading Cover Data, Offset: ${pointers.coverOffset}, Length: ${pointers.coverLength}`
-      );
-      this.offset = Number(pointers.coverOffset);
-      this.checkBounds(Number(pointers.coverLength));
-      cover = this.readBytes(Number(pointers.coverLength));
+      this.seek(pointers.coverOffset);
+      cover = this.readBytes(pointers.coverLength);
     }
 
-    // Marker Definitions
-    this.log(
-      `Reading Marker Definitions, Offset: ${pointers.markerDefinitionsOffset}, Length: ${pointers.markerDefinitionsLength}`
-    );
-    this.offset = Number(pointers.markerDefinitionsOffset);
-    const markerDefCount = this.buffer.readUInt8(this.offset++);
+    if (pointers.markerDefinitionsOffset === 0) {
+      throw new Error("Missing marker definitions offset.");
+    }
+
+    this.seek(pointers.markerDefinitionsOffset);
+
+    const markerDefCount = this.readUInt8();
     const markerDefinitions: MarkerDefinition[] = [];
+
     for (let i = 0; i < markerDefCount; i++) {
       const id = this.readString();
-      const valueCount = this.buffer.readUInt8(this.offset++);
+      const valueCount = this.readUInt8();
+
       const values: DataTypeID[] = [];
       for (let j = 0; j < valueCount; j++) {
-        values.push(this.buffer.readUInt8(this.offset++) as DataTypeID);
+        values.push(this.readUInt8() as DataTypeID);
+      }
+
+      const terminator = this.readUInt8();
+      if (terminator !== 0x00) {
+        throw new Error(
+          `Invalid marker definition terminator for "${id}": expected 0x00, got 0x${terminator.toString(16)}`
+        );
       }
+
       markerDefinitions.push({ id, values });
     }
 
-    // Markers
-    this.log(
-      `Reading Markers, Offset: ${pointers.markerOffset}, Length: ${pointers.markerLength}`
-    );
-    this.offset = Number(pointers.markerOffset);
-    const endOffset = this.offset + Number(pointers.markerLength);
+    this.seek(pointers.markerOffset);
 
     const markers: Marker[] = [];
+    const noteDefIndex = markerDefinitions.findIndex(
+      (d) => d.id === "ssp_note"
+    );
+    const effectiveNoteDefIndex = noteDefIndex >= 0 ? noteDefIndex : 0;
 
-    while (this.offset < endOffset) {
+    for (let i = 0; i < metadata.markerCount; i++) {
       const position = this.readUInt32();
-      const type = this.buffer.readUInt8(this.offset++);
-      const def = markerDefinitions.find((d) => d.id === "ssp_note"); // Adjust as needed for other marker types
-      const data = def ? this.readMarkerData(def.values) : {};
+      const type = this.readUInt8();
+
+      if (type >= markerDefinitions.length) {
+        throw new Error(`Invalid marker type index: ${type}`);
+      }
+
+      const def = markerDefinitions[type];
+      const isNote = type === effectiveNoteDefIndex;
+
+      const data: Record<string, any> = {};
+      let firstNotePositionCaptured = false;
+
+      for (let fieldIndex = 0; fieldIndex < def.values.length; fieldIndex++) {
+        const valueType = def.values[fieldIndex];
+
+        if (
+          isNote &&
+          valueType === DataType.Position &&
+          !firstNotePositionCaptured
+        ) {
+          const pos = this.readPosition();
+          data[`field${fieldIndex}`] = pos;
+          data.position = pos;
+          firstNotePositionCaptured = true;
+          continue;
+        }
+
+        data[`field${fieldIndex}`] = this.readTypedValue(valueType);
+      }
+
       markers.push({ position, type, data });
     }