spessasynth_lib 3.11.1 → 3.12.0

package/@types/midi_parser/rmidi_writer.d.ts

@@ -1,16 +1,33 @@
 /**
- *
+ * @typedef {Object} RMIDMetadata
+ * @property {string|undefined} name - the name of the file
+ * @property {string|undefined} engineer - the engineer who worked on the file
+ * @property {string|undefined} artist - the artist
+ * @property {string|undefined} album - the album
+ * @property {string|undefined} genre - the genre of the song
+ * @property {ArrayBuffer|undefined} picture - the image for the file (album cover)
+ * @property {string|undefined} comment - the coment of the file
+ * @property {string|undefined} creationDate - the creation date of the file
+ * @property {string|undefined} copyright - the copyright of the file
+ */
+/**
+ * Writes an RMIDI file
  * @param soundfontBinary {Uint8Array}
  * @param mid {MIDI}
  * @param soundfont {SoundFont2}
  * @param bankOffset {number} the bank offset for RMIDI
  * @param encoding {string} the encoding of the RMIDI info chunk
+ * @param metadata {RMIDMetadata} the metadata of the file. Optional. If provided, the encoding is forced to utf-8/
  * @returns {IndexedByteArray}
  */
-export function writeRMIDI(soundfontBinary: Uint8Array, mid: MIDI, soundfont: SoundFont2, bankOffset?: number, encoding?: string): IndexedByteArray;
+export function writeRMIDI(soundfontBinary: Uint8Array, mid: MIDI, soundfont: SoundFont2, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata): IndexedByteArray;
 export type RMIDINFOChunks = string;
 export namespace RMIDINFOChunks {
     let name: string;
+    let album: string;
+    let artist: string;
+    let genre: string;
+    let picture: string;
     let copyright: string;
     let creationDate: string;
     let comment: string;
@@ -19,4 +36,42 @@ export namespace RMIDINFOChunks {
     let encoding: string;
     let bankOffset: string;
 }
+export type RMIDMetadata = {
+    /**
+     * - the name of the file
+     */
+    name: string | undefined;
+    /**
+     * - the engineer who worked on the file
+     */
+    engineer: string | undefined;
+    /**
+     * - the artist
+     */
+    artist: string | undefined;
+    /**
+     * - the album
+     */
+    album: string | undefined;
+    /**
+     * - the genre of the song
+     */
+    genre: string | undefined;
+    /**
+     * - the image for the file (album cover)
+     */
+    picture: ArrayBuffer | undefined;
+    /**
+     * - the coment of the file
+     */
+    comment: string | undefined;
+    /**
+     * - the creation date of the file
+     */
+    creationDate: string | undefined;
+    /**
+     * - the copyright of the file
+     */
+    copyright: string | undefined;
+};
 import { IndexedByteArray } from '../utils/indexed_array.js';

package/@types/soundfont/read/riff_chunk.d.ts

@@ -11,6 +11,12 @@ export function readRIFFChunk(dataArray: IndexedByteArray, readData?: boolean, f
  * @returns {IndexedByteArray}
  */
 export function writeRIFFChunk(chunk: RiffChunk, prepend?: IndexedByteArray): IndexedByteArray;
+/**
+ * @param header {string}
+ * @param data {Uint8Array}
+ * @returns {IndexedByteArray}
+ */
+export function writeRIFFOddSize(header: string, data: Uint8Array): IndexedByteArray;
 /**
  * riff_chunk.js
  * reads a riff read and stores it as a class

package/@types/utils/buffer_to_wav.d.ts

@@ -1,3 +1,9 @@
+/**
+ * @typedef {Object} WaveMetadata
+ * @property {string} title - the song's title
+ * @property {string} album - the song's album
+ * @property {string} genre - the song's genre
+ */
 /**
  *
  * @param audioBuffer {AudioBuffer}
@@ -6,3 +12,17 @@
  * @returns {Blob}
  */
 export function audioBufferToWav(audioBuffer: AudioBuffer, normalizeAudio?: boolean, channelOffset?: number): Blob;
+export type WaveMetadata = {
+    /**
+     * - the song's title
+     */
+    title: string;
+    /**
+     * - the song's album
+     */
+    album: string;
+    /**
+     * - the song's genre
+     */
+    genre: string;
+};

package/midi_parser/midi_loader.js

@@ -47,6 +47,7 @@ class MIDI{
          * @type {string}
          */
         this.copyright = "";
+        let copyrightDetected = false;
 
         /**
          * The MIDI name
@@ -55,6 +56,7 @@ class MIDI{
         this.midiName = "";
 
         this.rawMidiName = new Uint8Array(0);
+        let nameDetected = false;
 
         const initialString = readBytesAsString(binaryData, 4);
         binaryData.currentIndex -= 4;
@@ -106,12 +108,14 @@ class MIDI{
                         }
                         if(this.RMIDInfo['ICOP'])
                         {
-                            this.copyright += readBytesAsString(this.RMIDInfo['ICOP'], this.RMIDInfo['ICOP'].length);
+                            copyrightDetected = true;
+                            this.copyright = readBytesAsString(this.RMIDInfo['ICOP'], this.RMIDInfo['ICOP'].length);
                         }
                         if(this.RMIDInfo['INAM'])
                         {
                             this.rawMidiName = this.RMIDInfo[RMIDINFOChunks.name];
-                            this.midiName = readBytesAsString(this.rawMidiName,  this.rawMidiName.length);
+                            this.midiName = readBytesAsString(this.rawMidiName, this.rawMidiName.length, undefined, false);
+                            nameDetected = true;
                         }
                         this.bankOffset = 1; // defaults to 1
                         if(this.RMIDInfo[RMIDINFOChunks.bankOffset])
@@ -346,7 +350,10 @@ class MIDI{
                                 break;
 
                             case messageTypes.copyright:
-                                this.copyright += readBytesAsString(eventData, eventData.length) + "\n";
+                                if(!copyrightDetected)
+                                {
+                                    this.copyright += readBytesAsString(eventData, eventData.length, undefined, false) + "\n";
+                                }
                                 break;
 
                             case messageTypes.lyric:
@@ -432,8 +439,10 @@ class MIDI{
             loopStart = this.firstNoteOn;
             loopEnd = this.lastVoiceEventTick;
         }
-        else {
-            if (loopStart === null) {
+        else
+        {
+            if (loopStart === null)
+            {
                 loopStart = this.firstNoteOn;
             }
 
@@ -470,7 +479,7 @@ class MIDI{
         this.loop = {start: loopStart, end: loopEnd};
 
         // midi name
-        if(this.midiName.length < 1)
+        if(!nameDetected)
         {
             if (this.tracks.length > 1)
             {
@@ -479,7 +488,7 @@ class MIDI{
                     this.tracks[0].find(
                     message => message.messageStatusByte >= messageTypes.noteOn
                         &&
-                        message.messageStatusByte < messageTypes.systemExclusive
+                        message.messageStatusByte < messageTypes.polyPressure
                     ) === undefined
                 )
                 {

package/midi_parser/rmidi_writer.js

@@ -1,6 +1,6 @@
 import { combineArrays, IndexedByteArray } from '../utils/indexed_array.js'
 import { writeMIDIFile } from './midi_writer.js'
-import { RiffChunk, writeRIFFChunk } from '../soundfont/read/riff_chunk.js'
+import { writeRIFFOddSize } from '../soundfont/read/riff_chunk.js'
 import { getStringBytes } from '../utils/byte_functions/string.js'
 import { messageTypes, midiControllers, MidiMessage } from './midi_message.js'
 import { DEFAULT_PERCUSSION } from '../synthetizer/synthetizer.js'
@@ -8,14 +8,17 @@ import { getGsOn } from './midi_editor.js'
 import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.js'
 import { consoleColors } from '../utils/other.js'
 import { writeLittleEndian } from '../utils/byte_functions/little_endian.js'
-
 /**
  * @enum {string}
  */
 export const RMIDINFOChunks = {
     name: "INAM",
+    album: "IPRD",
+    artist: "IART",
+    genre: "IGNR",
+    picture: "IPIC",
     copyright: "ICOP",
-    creationDate: "ICRT",
+    creationDate: "ICRD",
     comment: "ICMT",
     engineer: "IENG",
     software: "ISFT",
@@ -23,16 +26,33 @@ export const RMIDINFOChunks = {
     bankOffset: "DBNK"
 }
 
+const FORCED_ENCODING = "utf-8";
+const DEFAULT_COPYRIGHT = "Created by SpessaSynth";
+
 /**
- *
+ * @typedef {Object} RMIDMetadata
+ * @property {string|undefined} name - the name of the file
+ * @property {string|undefined} engineer - the engineer who worked on the file
+ * @property {string|undefined} artist - the artist
+ * @property {string|undefined} album - the album
+ * @property {string|undefined} genre - the genre of the song
+ * @property {ArrayBuffer|undefined} picture - the image for the file (album cover)
+ * @property {string|undefined} comment - the coment of the file
+ * @property {string|undefined} creationDate - the creation date of the file
+ * @property {string|undefined} copyright - the copyright of the file
+ */
+
+/**
+ * Writes an RMIDI file
  * @param soundfontBinary {Uint8Array}
  * @param mid {MIDI}
  * @param soundfont {SoundFont2}
  * @param bankOffset {number} the bank offset for RMIDI
  * @param encoding {string} the encoding of the RMIDI info chunk
+ * @param metadata {RMIDMetadata} the metadata of the file. Optional. If provided, the encoding is forced to utf-8/
  * @returns {IndexedByteArray}
  */
-export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, encoding = "Shift_JIS")
+export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, encoding = "Shift_JIS", metadata = {})
 {
     SpessaSynthGroup("%cWriting the RMIDI File...", consoleColors.info);
     SpessaSynthInfo(`%cConfiguration: Bank offset: %c${bankOffset}%c, encoding: %c${encoding}`,
@@ -156,7 +176,7 @@ export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, enco
                 // check if this preset exists for program and bank
                 const realBank = lastBankChanges[chNum]?.messageData[1] - mid.bankOffset; // make sure to take the previous bank offset into account
                 const bank = drums[chNum] ? 128 : realBank;
-                if(bank === undefined)
+                if(lastBankChanges[chNum] === undefined)
                 {
                     return;
                 }
@@ -259,81 +279,136 @@ export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, enco
     const newMid = new IndexedByteArray(writeMIDIFile(mid).buffer);
 
     // infodata for RMID
-    const today = new Date().toLocaleString();
+    /**
+     * @type {Uint8Array[]}
+     */
+    const infoContent = [getStringBytes("INFO")];
+    const encoder = new TextEncoder();
+
+    // name
+    if(metadata.name !== undefined)
+    {
+
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.name, encoder.encode(metadata.name))
+        );
+        encoding = FORCED_ENCODING;
+    }
+    else
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.name, mid.rawMidiName)
+        );
+    }
+    // creation date
+    if(metadata.creationDate !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.creationDate, encoder.encode(metadata.creationDate))
+        );
+    }
+    else
+    {
+        const today = new Date().toLocaleString(undefined, {
+        weekday: "long",
+        year: 'numeric',
+        month: "long",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric"
+    });
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.creationDate, getStringBytes(today))
+        );
+    }
+    // comment
+    if(metadata.comment !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.comment, encoder.encode(metadata.comment))
+        );
+    }
+    // engineer
+    if(metadata.engineer !== undefined)
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.engineer, encoder.encode(metadata.engineer))
+        )
+    }
+    // album
+    if(metadata.album !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.album, encoder.encode(metadata.album))
+        );
+    }
+    // artist
+    if(metadata.artist !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.artist, encoder.encode(metadata.artist))
+        );
+    }
+    // genre
+    if(metadata.genre !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.genre, encoder.encode(metadata.genre))
+        );
+    }
+    // picture
+    if(metadata.picture !== undefined)
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.picture, new Uint8Array(metadata.picture))
+        );
+    }
+    // copyright
+    if(metadata.copyright !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.copyright, encoder.encode(metadata.copyright))
+        );
+    }
+    else
+    {
+        // use midi copyright if possible
+        const copyright = mid.copyright.length > 0 ? mid.copyright : DEFAULT_COPYRIGHT;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.copyright, getStringBytes(copyright))
+        );
+    }
+
+    // bank offset
     const DBNK = new IndexedByteArray(2);
     writeLittleEndian(DBNK, bankOffset, 2);
-    const ICOP = mid.copyright.length > 0 ? getStringBytes(mid.copyright) : getStringBytes("Created by SpessaSynth");
-    const infodata = combineArrays([
-        // icop: copyright
-        writeRIFFChunk(
-            new RiffChunk(
-                RMIDINFOChunks.copyright,
-                ICOP.length,
-                ICOP
-            ),
-            new IndexedByteArray([73, 78, 70, 79]) // "INFO"
-        ),
-        // inam: name
-        writeRIFFChunk(
-            new RiffChunk(
-                RMIDINFOChunks.name,
-                mid.rawMidiName.length,
-                new IndexedByteArray(mid.rawMidiName.buffer)
-            ),
-        ),
-        // icrd: creation date
-        writeRIFFChunk(
-            new RiffChunk(
-                RMIDINFOChunks.creationDate,
-                today.length,
-                getStringBytes(today)
-            )
-        ),
-        // isft: software used
-        writeRIFFChunk(
-            new RiffChunk(
-                RMIDINFOChunks.software,
-                11,
-                getStringBytes("SpessaSynth"),
-            )
-        ),
-        // ienc: encoding for the info chunk
-        writeRIFFChunk(
-            new RiffChunk(
-                RMIDINFOChunks.encoding,
-                encoding.length,
-                getStringBytes(encoding)
-            )
-        ),
-        // dbnk: bank offset
-        writeRIFFChunk(
-            new RiffChunk(
-                RMIDINFOChunks.bankOffset,
-                2,
-                DBNK
-            )
-        )
-    ]);
+    infoContent.push(writeRIFFOddSize(RMIDINFOChunks.bankOffset, DBNK));
+    // encoding
+    infoContent.push(writeRIFFOddSize(RMIDINFOChunks.encoding, getStringBytes(encoding)));
+    const infodata = combineArrays(infoContent);
 
     const rmiddata = combineArrays([
-        new Uint8Array([82, 77, 73, 68]), // "RMID"
-        writeRIFFChunk(new RiffChunk(
+        getStringBytes("RMID"),
+        writeRIFFOddSize(
             "data",
-            newMid.length, // "data", size, midi binary
             newMid
-        )),
-        writeRIFFChunk(new RiffChunk(
+        ),
+        writeRIFFOddSize(
             "LIST",
-            infodata.length,
             infodata
-        )),
+        ),
         soundfontBinary
     ]);
     SpessaSynthInfo("%cFinished!", consoleColors.info)
     SpessaSynthGroupEnd();
-    return writeRIFFChunk(new RiffChunk(
+    return writeRIFFOddSize(
         "RIFF",
-        rmiddata.length,
         rmiddata
-    ));
+    );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.11.1",
+  "version": "3.12.0",
   "description": "No compromise MIDI and SoundFont2 Synthesizer library",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/soundfont/read/riff_chunk.js

@@ -47,7 +47,10 @@ export function readRIFFChunk(dataArray, readData = true, forceShift = false) {
 
     if(size % 2 !== 0)
     {
-        dataArray.currentIndex++;
+        if(dataArray[dataArray.currentIndex] === 0)
+        {
+            dataArray.currentIndex++;
+        }
     }
 
     return new RiffChunk(header, size, chunkData)
@@ -83,4 +86,23 @@ export function writeRIFFChunk(chunk, prepend = undefined)
     // write data
     array.set(chunk.chunkData, array.currentIndex);
     return array;
+}
+
+/**
+ * @param header {string}
+ * @param data {Uint8Array}
+ * @returns {IndexedByteArray}
+ */
+export function writeRIFFOddSize(header, data)
+{
+    let finalSize = 8 + data.length;
+    if(finalSize % 2 !== 0)
+    {
+        finalSize++;
+    }
+    const outArray = new IndexedByteArray(finalSize);
+    writeStringAsBytes(outArray, header);
+    writeDword(outArray, data.length);
+    outArray.set(data, 8);
+    return outArray;
 }