spessasynth_core 3.26.27 → 3.26.29

package/src/soundfont/basic_soundfont/write_sf2/pgen.js

@@ -7,17 +7,17 @@ import { generatorTypes } from "../generator_types.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getPGEN()
 {
     // almost identical to igen, except the correct instrument instead of sample gen
     // goes through all preset zones and writes generators sequentially (add 4 for terminal)
-    let pgensize = GEN_BYTE_SIZE;
+    let pgenSize = GEN_BYTE_SIZE;
     for (const preset of this.presets)
     {
-        pgensize += preset.globalZone.generators.length * GEN_BYTE_SIZE;
-        pgensize += preset.presetZones.reduce((size, z) =>
+        pgenSize += preset.globalZone.generators.length * GEN_BYTE_SIZE;
+        pgenSize += preset.presetZones.reduce((size, z) =>
         {
             // clear instrument and range generators before determining the size
             z.generators = z.generators.filter(g =>
@@ -51,7 +51,7 @@ export function getPGEN()
             return z.generators.length * GEN_BYTE_SIZE + size;
         }, 0);
     }
-    const pgendata = new IndexedByteArray(pgensize);
+    const pgenData = new IndexedByteArray(pgenSize);
     
     /**
      * @param z {BasicZone}
@@ -61,8 +61,8 @@ export function getPGEN()
         for (const gen of z.generators)
         {
             // name is deceptive, it works on negatives
-            writeWord(pgendata, gen.generatorType);
-            writeWord(pgendata, gen.generatorValue);
+            writeWord(pgenData, gen.generatorType);
+            writeWord(pgenData, gen.generatorValue);
         }
     };
     for (const preset of this.presets)
@@ -75,11 +75,25 @@ export function getPGEN()
         }
     }
     // terminal generator, is zero
-    writeDword(pgendata, 0);
+    writeDword(pgenData, 0);
     
-    return writeRIFFChunk(new RiffChunk(
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xpgenData = new IndexedByteArray(GEN_BYTE_SIZE);
+    writeDword(xpgenData, 0);
+    
+    const pgen = writeRIFFChunk(new RiffChunk(
+        "pgen",
+        pgenData.length,
+        pgenData
+    ));
+    const xpgen = writeRIFFChunk(new RiffChunk(
         "pgen",
-        pgendata.length,
-        pgendata
+        xpgenData.length,
+        xpgenData
     ));
+    return {
+        pdta: pgen,
+        xdta: xpgen,
+        highestIndex: 0 // not applicable
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/phdr.js

@@ -7,38 +7,63 @@ const PHDR_SIZE = 38;
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getPHDR()
 {
-    const phdrsize = this.presets.length * PHDR_SIZE + PHDR_SIZE;
-    const phdrdata = new IndexedByteArray(phdrsize);
+    const phdrSize = this.presets.length * PHDR_SIZE + PHDR_SIZE;
+    const phdrData = new IndexedByteArray(phdrSize);
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xphdrData = new IndexedByteArray(phdrSize);
     // the preset start is adjusted in pbag, this is only for the terminal preset index
     let presetStart = 0;
     for (const preset of this.presets)
     {
-        writeStringAsBytes(phdrdata, preset.presetName, 20);
-        writeWord(phdrdata, preset.program);
-        writeWord(phdrdata, preset.bank);
-        writeWord(phdrdata, presetStart);
+        writeStringAsBytes(phdrData, preset.presetName.substring(0, 20), 20);
+        writeStringAsBytes(xphdrData, preset.presetName.substring(20), 20);
+        
+        writeWord(phdrData, preset.program);
+        writeWord(phdrData, preset.bank);
+        writeWord(phdrData, presetStart & 0xFFFF);
+        
+        xphdrData.currentIndex += 4;
+        writeWord(xphdrData, presetStart >> 16);
+        
         // 3 unused dword, spec says to keep em so we do
-        writeDword(phdrdata, preset.library);
-        writeDword(phdrdata, preset.genre);
-        writeDword(phdrdata, preset.morphology);
+        writeDword(phdrData, preset.library);
+        writeDword(phdrData, preset.genre);
+        writeDword(phdrData, preset.morphology);
+        
+        xphdrData.currentIndex += 12;
+        
         presetStart += preset.presetZones.length + 1; // global
     }
     // write EOP
-    writeStringAsBytes(phdrdata, "EOP", 20);
-    writeWord(phdrdata, 0); // program
-    writeWord(phdrdata, 0); // bank
-    writeWord(phdrdata, presetStart);
-    writeDword(phdrdata, 0); // library
-    writeDword(phdrdata, 0); // genre
-    writeDword(phdrdata, 0); // morphology
+    writeStringAsBytes(phdrData, "EOP", 20);
+    phdrData.currentIndex += 4; // program, bank
+    writeWord(phdrData, presetStart & 0xFFFF);
+    phdrData.currentIndex += 12;// library, genre, morphology
     
-    return writeRIFFChunk(new RiffChunk(
+    writeStringAsBytes(xphdrData, "EOP", 20);
+    xphdrData.currentIndex += 4; // program, bank
+    writeWord(xphdrData, presetStart >> 16);
+    xphdrData.currentIndex += 12;// library, genre, morphology
+    
+    const phdr = writeRIFFChunk(new RiffChunk(
         "phdr",
-        phdrdata.length,
-        phdrdata
+        phdrData.length,
+        phdrData
     ));
+    
+    const xphdr = writeRIFFChunk(new RiffChunk(
+        "phdr",
+        xphdrData.length,
+        xphdrData
+    ));
+    
+    return {
+        pdta: phdr,
+        xdta: xphdr,
+        highestIndex: presetStart
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/pmod.js

@@ -5,19 +5,19 @@ import { MOD_BYTE_SIZE } from "../modulator.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getPMOD()
 {
     // very similar to imod,
     // go through all presets -> zones and write modulators sequentially
-    let pmodsize = MOD_BYTE_SIZE;
+    let pmodSize = MOD_BYTE_SIZE;
     for (const preset of this.presets)
     {
-        pmodsize += preset.globalZone.modulators.length * MOD_BYTE_SIZE;
-        pmodsize += preset.presetZones.reduce((sum, z) => z.modulators.length * MOD_BYTE_SIZE + sum, 0);
+        pmodSize += preset.globalZone.modulators.length * MOD_BYTE_SIZE;
+        pmodSize += preset.presetZones.reduce((sum, z) => z.modulators.length * MOD_BYTE_SIZE + sum, 0);
     }
-    const pmoddata = new IndexedByteArray(pmodsize);
+    const pmodData = new IndexedByteArray(pmodSize);
     
     /**
      * @param z {BasicZone}
@@ -26,11 +26,11 @@ export function getPMOD()
     {
         for (const mod of z.modulators)
         {
-            writeWord(pmoddata, mod.getSourceEnum());
-            writeWord(pmoddata, mod.modulatorDestination);
-            writeWord(pmoddata, mod.transformAmount);
-            writeWord(pmoddata, mod.getSecSrcEnum());
-            writeWord(pmoddata, mod.transformType);
+            writeWord(pmodData, mod.getSourceEnum());
+            writeWord(pmodData, mod.modulatorDestination);
+            writeWord(pmodData, mod.transformAmount);
+            writeWord(pmodData, mod.getSecSrcEnum());
+            writeWord(pmodData, mod.transformType);
         }
     };
     
@@ -46,11 +46,25 @@ export function getPMOD()
     }
     
     // terminal modulator, is zero
-    writeLittleEndian(pmoddata, 0, MOD_BYTE_SIZE);
+    writeLittleEndian(pmodData, 0, MOD_BYTE_SIZE);
     
-    return writeRIFFChunk(new RiffChunk(
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xpmodData = new IndexedByteArray(MOD_BYTE_SIZE);
+    writeLittleEndian(xpmodData, 0, MOD_BYTE_SIZE);
+    
+    const pmod = writeRIFFChunk(new RiffChunk(
+        "pmod",
+        pmodData.length,
+        pmodData
+    ));
+    const xpmod = writeRIFFChunk(new RiffChunk(
         "pmod",
-        pmoddata.length,
-        pmoddata
+        xpmodData.length,
+        xpmodData
     ));
+    return {
+        pdta: pmod,
+        xdta: xpmod,
+        highestIndex: 0 // not applicable
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/shdr.js

@@ -8,22 +8,29 @@ import { SF3_BIT_FLIT } from "../../read_sf2/samples.js";
  * @this {BasicSoundBank}
  * @param smplStartOffsets {number[]}
  * @param smplEndOffsets {number[]}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getSHDR(smplStartOffsets, smplEndOffsets)
 {
     const sampleLength = 46;
-    const shdrData = new IndexedByteArray(sampleLength * (this.samples.length + 1)); // +1 because EOP
+    const shdrSize = sampleLength * (this.samples.length + 1); // +1 because EOP
+    const shdrData = new IndexedByteArray(shdrSize);
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xshdrData = new IndexedByteArray(shdrSize);
+    let maxSampleLink = 0;
     this.samples.forEach((sample, index) =>
     {
         // sample name
-        writeStringAsBytes(shdrData, sample.sampleName, 20);
+        writeStringAsBytes(shdrData, sample.sampleName.substring(0, 20), 20);
+        writeStringAsBytes(xshdrData, sample.sampleName.substring(20), 20);
         // start offset
         const dwStart = smplStartOffsets[index];
         writeDword(shdrData, dwStart);
+        xshdrData.currentIndex += 4;
         // end offset
         const dwEnd = smplEndOffsets[index];
         writeDword(shdrData, dwEnd);
+        xshdrData.currentIndex += 4;
         // loop is stored as relative in sample points, change it to absolute sample points here
         let loopStart = sample.sampleLoopStartIndex + dwStart;
         let loopEnd = sample.sampleLoopEndIndex + dwStart;
@@ -40,9 +47,13 @@ export function getSHDR(smplStartOffsets, smplEndOffsets)
         // pitch and correction
         shdrData[shdrData.currentIndex++] = sample.samplePitch;
         shdrData[shdrData.currentIndex++] = sample.samplePitchCorrection;
+        // skip all those for xshdr
+        xshdrData.currentIndex += 14;
         // sample link
         const sampleLinkIndex = this.samples.indexOf(sample.linkedSample);
-        writeWord(shdrData, Math.max(0, sampleLinkIndex));
+        writeWord(shdrData, Math.max(0, sampleLinkIndex) & 0xFFFF);
+        writeWord(xshdrData, Math.max(0, sampleLinkIndex) >> 16);
+        maxSampleLink = Math.max(maxSampleLink, sampleLinkIndex);
         // sample type: add byte if compressed
         let type = sample.sampleType;
         if (sample.isCompressed)
@@ -50,13 +61,25 @@ export function getSHDR(smplStartOffsets, smplEndOffsets)
             type |= SF3_BIT_FLIT;
         }
         writeWord(shdrData, type);
+        xshdrData.currentIndex += 2;
     });
     
     // write EOS and zero everything else
     writeStringAsBytes(shdrData, "EOS", sampleLength);
-    return writeRIFFChunk(new RiffChunk(
+    writeStringAsBytes(xshdrData, "EOS", sampleLength);
+    const shdr = writeRIFFChunk(new RiffChunk(
         "shdr",
         shdrData.length,
         shdrData
     ));
+    const xshdr = writeRIFFChunk(new RiffChunk(
+        "shdr",
+        xshdrData.length,
+        xshdrData
+    ));
+    return {
+        pdta: shdr,
+        xdta: xshdr,
+        highestIndex: maxSampleLink
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/write.js

@@ -24,6 +24,16 @@ import { fillWithDefaults } from "../../../utils/fill_with_defaults.js";
  * the encode vorbis function. Can be undefined if not compressed.
  * @property {boolean|undefined} writeDefaultModulators - if the DMOD chunk should be written.
  * Recommended.
+ * @property {boolean|undefined} writeExtendedLimits - if the xdta chunk should be written to allow virtually infinite parameters.
+ * Recommended.
+ */
+
+
+/**
+ * @typedef {Object} ReturnedExtendedSf2Chunks
+ * @property {IndexedByteArray} pdta - the pdta part of the chunk
+ * @property {IndexedByteArray} xdta - the xdta (https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md) part of the chunk
+ * @property {number} highestIndex - the highest index written (0 if not applicable). Used for determining whether the xdta chunk is necessary.
  */
 
 /**
@@ -33,7 +43,8 @@ const DEFAULT_WRITE_OPTIONS = {
     compress: false,
     compressionQuality: 0.5,
     compressionFunction: undefined,
-    writeDefaultModulators: true
+    writeDefaultModulators: true,
+    writeExtendedLimits: true
 };
 
 /**
@@ -146,7 +157,6 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
             )));
         }
     }
-    const infoChunk = writeRIFFOddSize("INFO", combineArrays(infoArrays), false, true);
     
     SpessaSynthInfo(
         "%cWriting SDTA...",
@@ -213,24 +223,53 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
         consoleColors.info
     );
     const phdrChunk = getPHDR.call(this);
+    /**
+     * @type {ReturnedExtendedSf2Chunks[]}
+     */
+    const chunks = [phdrChunk, pbagChunk, pmodChunk, pgenChunk, instChunk, ibagChunk, imodChunk, igenChunk, shdrChunk];
     // combine in the sfspec order
-    const pdtadata = combineArrays([
+    const pdtaData = combineArrays([
         new IndexedByteArray([112, 100, 116, 97]), // "pdta"
-        phdrChunk,
-        pbagChunk,
-        pmodChunk,
-        pgenChunk,
-        instChunk,
-        ibagChunk,
-        imodChunk,
-        igenChunk,
-        shdrChunk
+        ...chunks.map(c => c.pdta)
     ]);
     const pdtaChunk = writeRIFFChunk(new RiffChunk(
         "LIST",
-        pdtadata.length,
-        pdtadata
+        pdtaData.length,
+        pdtaData
     ));
+    const maxIndex = Math.max(
+        ...chunks.map(c => c.highestIndex)
+    );
+    
+    const writeXdta = options.writeExtendedLimits && (
+        maxIndex > 0xFFF
+        || this.presets.some(p => p.presetName.length > 20)
+        || this.instruments.some(i => i.instrumentName.length > 20)
+        || this.samples.some(s => s.sampleName.length > 20)
+    );
+    
+    if (writeXdta)
+    {
+        SpessaSynthInfo(
+            `%cWriting the xdta chunk! Max index: %c${maxIndex}`,
+            consoleColors.info,
+            consoleColors.value
+        );
+        // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+        const xpdtaData = combineArrays([
+            new IndexedByteArray([120, 100, 116, 97]), // "xdta"
+            ...chunks.map(c => c.xdta)
+        ]);
+        
+        const xpdtaChunk = writeRIFFChunk(new RiffChunk(
+            "LIST",
+            xpdtaData.length,
+            xpdtaData
+        ));
+        infoArrays.push(xpdtaChunk);
+    }
+    
+    const infoChunk = writeRIFFOddSize("INFO", combineArrays(infoArrays), false, true);
     SpessaSynthInfo(
         "%cWriting the output file...",
         consoleColors.info

package/src/soundfont/dls/dls_sample.js

@@ -1,4 +1,116 @@
 import { BasicSample, sampleTypes } from "../basic_soundfont/basic_sample.js";
+import { SpessaSynthWarn } from "../../utils/loggin.js";
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+import { IndexedByteArray } from "../../utils/indexed_array.js";
+
+const W_FORMAT_TAG = {
+    PCM: 0x01,
+    ALAW: 0x6
+};
+
+
+/**
+ * @param data {IndexedByteArray}
+ * @param bytesPerSample {number}
+ * @returns {Float32Array}
+ */
+function readPCM(data, bytesPerSample)
+{
+    const maxSampleValue = Math.pow(2, bytesPerSample * 8 - 1); // Max value for the sample
+    const maxUnsigned = Math.pow(2, bytesPerSample * 8);
+    
+    let normalizationFactor;
+    let isUnsigned = false;
+    
+    if (bytesPerSample === 1)
+    {
+        normalizationFactor = 255; // For 8-bit normalize from 0-255
+        isUnsigned = true;
+    }
+    else
+    {
+        normalizationFactor = maxSampleValue; // For 16-bit normalize from -32,768 to 32,767
+    }
+    const sampleLength = data.length / bytesPerSample;
+    const sampleData = new Float32Array(sampleLength);
+    if (bytesPerSample === 2)
+    {
+        // special optimized case for s16 (most common)
+        const s16 = new Int16Array(data.buffer);
+        for (let i = 0; i < s16.length; i++)
+        {
+            sampleData[i] = s16[i] / 32768;
+        }
+    }
+    else
+    {
+        for (let i = 0; i < sampleData.length; i++)
+        {
+            // read
+            let sample = readLittleEndian(data, bytesPerSample);
+            // turn into signed
+            if (isUnsigned)
+            {
+                // normalize unsigned 8-bit sample
+                sampleData[i] = (sample / normalizationFactor) - 0.5;
+            }
+            else
+            {
+                // normalize signed sample
+                if (sample >= maxSampleValue)
+                {
+                    sample -= maxUnsigned;
+                }
+                sampleData[i] = sample / normalizationFactor;
+            }
+        }
+    }
+    return sampleData;
+}
+
+/**
+ * @param data {IndexedByteArray}
+ * @param bytesPerSample {number}
+ * @returns {Float32Array}
+ */
+function readALAW(data, bytesPerSample)
+{
+    const sampleLength = data / bytesPerSample;
+    const sampleData = new Float32Array(sampleLength);
+    for (let i = 0; i < sampleData.length; i++)
+    {
+        // read
+        const input = readLittleEndian(data, bytesPerSample);
+        
+        // https://en.wikipedia.org/wiki/G.711#A-law
+        // re-toggle toggled bits
+        let sample = input ^ 0x55;
+        
+        // remove sign bit
+        sample &= 0x7F;
+        
+        // extract exponent
+        let exponent = sample >> 4;
+        // extract mantissa
+        let mantissa = sample & 0xF;
+        if (exponent > 0)
+        {
+            mantissa += 16; // add leading '1', if exponent > 0
+        }
+        
+        mantissa = (mantissa << 4) + 0x8;
+        if (exponent > 1)
+        {
+            mantissa = mantissa << (exponent - 1);
+        }
+        
+        const s16sample = input > 127 ? mantissa : -mantissa;
+        
+        // convert to float
+        sampleData[i] = s16sample / 32678;
+    }
+    return sampleData;
+}
 
 export class DLSSample extends BasicSample
 {
@@ -12,6 +124,22 @@ export class DLSSample extends BasicSample
      */
     sampleData;
     
+    /**
+     * @type {number}
+     */
+    wFormatTag;
+    
+    /**
+     * @type {number}
+     */
+    bytesPerSample;
+    
+    /**
+     * Sample's raw data before decoding it, for faster writing
+     * @type {IndexedByteArray}
+     */
+    rawData;
+    
     /**
      * @param name {string}
      * @param rate {number}
@@ -19,8 +147,10 @@ export class DLSSample extends BasicSample
      * @param pitchCorrection {number}
      * @param loopStart {number} sample data points
      * @param loopEnd {number} sample data points
-     * @param data {Float32Array}
      * @param sampleDbAttenuation {number} in db
+     * @param dataChunk {RiffChunk}
+     * @param wFormatTag {number}
+     * @param bytesPerSample {number}
      */
     constructor(
         name,
@@ -29,8 +159,10 @@ export class DLSSample extends BasicSample
         pitchCorrection,
         loopStart,
         loopEnd,
-        data,
-        sampleDbAttenuation
+        sampleDbAttenuation,
+        dataChunk,
+        wFormatTag,
+        bytesPerSample
     )
     {
         super(
@@ -42,12 +174,42 @@ export class DLSSample extends BasicSample
             loopStart,
             loopEnd
         );
-        this.setAudioData(data);
         this.sampleDbAttenuation = sampleDbAttenuation;
+        /**
+         * @type {IndexedByteArray}
+         */
+        this.rawData = dataChunk.chunkData;
+        this.wFormatTag = wFormatTag;
+        this.bytesPerSample = bytesPerSample;
     }
     
     getAudioData()
     {
+        if (!(this.rawData instanceof Uint8Array))
+        {
+            return new Float32Array(0);
+        }
+        if (!this.sampleData)
+        {
+            let sampleData;
+            switch (this.wFormatTag)
+            {
+                default:
+                    SpessaSynthWarn(`Failed to decode sample. Unknown wFormatTag: ${this.wFormatTag}`);
+                    sampleData = new Float32Array(this.rawData.length / this.bytesPerSample);
+                    break;
+                
+                case W_FORMAT_TAG.PCM:
+                    sampleData = readPCM(this.rawData, this.bytesPerSample);
+                    break;
+                
+                case W_FORMAT_TAG.ALAW:
+                    sampleData = readALAW(this.rawData, this.bytesPerSample);
+                    break;
+                
+            }
+            this.setAudioData(sampleData);
+        }
         return this.sampleData;
     }
     
@@ -59,24 +221,23 @@ export class DLSSample extends BasicSample
         super.setAudioData(audioData);
     }
     
-    getRawData()
+    getRawData(allowVorbis = true)
     {
-        if (this.isCompressed)
+        if (this.dataOverriden)
+        {
+            return this.encodeS16LE();
+        }
+        else
         {
-            if (!this.compressedData)
+            if (this.compressedData && allowVorbis)
+            {
+                return this.compressedData;
+            }
+            if (this.wFormatTag === W_FORMAT_TAG.PCM && this.bytesPerSample === 2)
             {
-                throw new Error("Compressed but no data?? This shouldn't happen!!");
+                return this.rawData;
             }
-            return this.compressedData;
+            return this.encodeS16LE();
         }
-        return super.getRawData();
-        // const uint8 = new Uint8Array(this.sampleData.length * 2);
-        // for (let i = 0; i < this.sampleData.length; i++)
-        // {
-        //     const sample = Math.floor(this.sampleData[i] * 32768);
-        //     uint8[i * 2] = sample & 0xFF; // lower byte
-        //     uint8[i * 2 + 1] = (sample >> 8) & 0xFF; // upper byte
-        // }
-        // return uint8;
     }
 }