spessasynth_core 1.1.2 → 1.1.4

package/src/soundfont/basic_soundfont/write_dls/wsmp.js

@@ -0,0 +1,78 @@
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeRIFFOddSize } from "../riff_chunk.js";
+
+const WSMP_SIZE = 20;
+
+/**
+ * @param sample {BasicSample}
+ * @param rootKey {number}
+ * @param tuning {number}
+ * @param attenuationCentibels {number} CENTIBELS, NO CORRECTION
+ * @param loopStart {number}
+ * @param loopEnd {number}
+ * @param loopingMode {number}
+ * @returns {IndexedByteArray}
+ */
+export function writeWavesample(
+    sample,
+    rootKey,
+    tuning,
+    attenuationCentibels,
+    loopStart,
+    loopEnd,
+    loopingMode)
+{
+    let loopCount = loopingMode === 0 ? 0 : 1;
+    const wsmpData = new IndexedByteArray(WSMP_SIZE + loopCount * 16);
+    writeDword(wsmpData, WSMP_SIZE); // cbSize
+    // usUnityNote (apply root pitch here)
+    writeWord(wsmpData, rootKey);
+    // sFineTune
+    writeWord(wsmpData, tuning);
+    
+    // gain correction, use InitialAttenuation, apply attenuation correction
+    const attenuationCb = attenuationCentibels * 0.4;
+    
+    // gain correction: Each unit of gain represents 1/655360 dB
+    const lGain = Math.floor(attenuationCb * -65536);
+    writeDword(wsmpData, lGain);
+    // fulOptions: has to be 2, according to all DLS files I have
+    writeDword(wsmpData, 2);
+    
+    const loopSize = loopEnd - loopStart;
+    let ulLoopType = 0;
+    switch (loopingMode)
+    {
+        default:
+        case 0:
+            // no loop
+            loopCount = 0;
+            break;
+        
+        case 1:
+            // loop
+            ulLoopType = 0;
+            loopCount = 1;
+            break;
+        
+        case 3:
+            // loop and release
+            ulLoopType = 1;
+            loopCount = 1;
+    }
+    
+    // cSampleLoops
+    writeDword(wsmpData, loopCount);
+    if (loopCount === 1)
+    {
+        writeDword(wsmpData, 16); // cbSize
+        writeDword(wsmpData, ulLoopType);
+        writeDword(wsmpData, loopStart);
+        writeDword(wsmpData, loopSize);
+    }
+    return writeRIFFOddSize(
+        "wsmp",
+        wsmpData
+    );
+}

package/src/soundfont/basic_soundfont/write_dls/wvpl.js

@@ -0,0 +1,32 @@
+import { writeDLSSample } from "./wave.js";
+import { writeRIFFOddSize } from "../riff_chunk.js";
+import { combineArrays } from "../../../utils/indexed_array.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {{data: IndexedByteArray, indexes: number[] }}
+ */
+export function writeWavePool()
+{
+    let currentIndex = 0;
+    const offsets = [];
+    /**
+     * @type {IndexedByteArray[]}
+     */
+    const samples = this.samples.map(s =>
+    {
+        const out = writeDLSSample(s);
+        offsets.push(currentIndex);
+        currentIndex += out.length;
+        return out;
+    });
+    return {
+        data: writeRIFFOddSize(
+            "wvpl",
+            combineArrays(samples),
+            false,
+            true
+        ),
+        indexes: offsets
+    };
+}

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

@@ -0,0 +1,39 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getIBAG()
+{
+    // write all ibag with their start indexes as they were changed in getIGEN() and getIMOD()
+    const ibagsize = this.instruments.reduce((sum, i) => i.instrumentZones.length * 4 + sum, 4);
+    const ibagdata = new IndexedByteArray(ibagsize);
+    let zoneID = 0;
+    let generatorIndex = 0;
+    let modulatorIndex = 0;
+    for (const inst of this.instruments)
+    {
+        inst.instrumentZoneIndex = zoneID;
+        for (const ibag of inst.instrumentZones)
+        {
+            ibag.zoneID = zoneID;
+            writeWord(ibagdata, generatorIndex);
+            writeWord(ibagdata, modulatorIndex);
+            generatorIndex += ibag.generators.length;
+            modulatorIndex += ibag.modulators.length;
+            zoneID++;
+        }
+    }
+    // write the terminal IBAG
+    writeWord(ibagdata, generatorIndex);
+    writeWord(ibagdata, modulatorIndex);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "ibag",
+        ibagdata.length,
+        ibagdata
+    ));
+}

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

@@ -0,0 +1,80 @@
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+import { Generator, generatorTypes } from "../generator.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getIGEN()
+{
+    // go through all instruments -> zones and write generators sequentially (add 4 for terminal)
+    let igensize = 4;
+    for (const inst of this.instruments)
+    {
+        igensize += inst.instrumentZones.reduce((sum, z) =>
+        {
+            // clear sample and range generators before determining the size
+            z.generators = z.generators.filter(g =>
+                g.generatorType !== generatorTypes.sampleID &&
+                g.generatorType !== generatorTypes.keyRange &&
+                g.generatorType !== generatorTypes.velRange
+            );
+            // add sample and ranges if necessary
+            // unshift vel then key (to make key first) and the instrument is last
+            if (z.velRange.max !== 127 || z.velRange.min !== 0)
+            {
+                z.generators.unshift(new Generator(
+                    generatorTypes.velRange,
+                    z.velRange.max << 8 | Math.max(z.velRange.min, 0),
+                    false
+                ));
+            }
+            if (z.keyRange.max !== 127 || z.keyRange.min !== 0)
+            {
+                z.generators.unshift(new Generator(
+                    generatorTypes.keyRange,
+                    z.keyRange.max << 8 | Math.max(z.keyRange.min, 0),
+                    false
+                ));
+            }
+            if (!z.isGlobal)
+            {
+                // write sample
+                z.generators.push(new Generator(
+                    generatorTypes.sampleID,
+                    this.samples.indexOf(z.sample),
+                    false
+                ));
+            }
+            return z.generators.length * 4 + sum;
+        }, 0);
+    }
+    const igendata = new IndexedByteArray(igensize);
+    let igenIndex = 0;
+    for (const instrument of this.instruments)
+    {
+        for (const instrumentZone of instrument.instrumentZones)
+        {
+            // set the start index here
+            instrumentZone.generatorZoneStartIndex = igenIndex;
+            for (const gen of instrumentZone.generators)
+            {
+                // name is deceptive, it works on negatives
+                writeWord(igendata, gen.generatorType);
+                writeWord(igendata, gen.generatorValue);
+                igenIndex++;
+            }
+        }
+    }
+    // terminal generator, is zero
+    writeDword(igendata, 0);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "igen",
+        igendata.length,
+        igendata
+    ));
+}

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

@@ -0,0 +1,46 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeLittleEndian, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getIMOD()
+{
+    // very similar to igen,
+    // go through all instruments -> zones and write modulators sequentially
+    let imodsize = 10;
+    for (const inst of this.instruments)
+    {
+        imodsize += inst.instrumentZones.reduce((sum, z) => z.modulators.length * 10 + sum, 0);
+    }
+    const imoddata = new IndexedByteArray(imodsize);
+    let imodIndex = 0;
+    for (const inst of this.instruments)
+    {
+        for (const ibag of inst.instrumentZones)
+        {
+            // set the start index here
+            ibag.modulatorZoneStartIndex = imodIndex;
+            for (const mod of ibag.modulators)
+            {
+                writeWord(imoddata, mod.sourceEnum);
+                writeWord(imoddata, mod.modulatorDestination);
+                writeWord(imoddata, mod.transformAmount);
+                writeWord(imoddata, mod.secondarySourceEnum);
+                writeWord(imoddata, mod.transformType);
+                imodIndex++;
+            }
+        }
+    }
+    
+    // terminal modulator, is zero
+    writeLittleEndian(imoddata, 0, 10);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "imod",
+        imoddata.length,
+        imoddata
+    ));
+}

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

@@ -0,0 +1,34 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
+import { writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getINST()
+{
+    const instsize = this.instruments.length * 22 + 22;
+    const instdata = new IndexedByteArray(instsize);
+    // the instrument start index is adjusted in ibag, write it here
+    let instrumentStart = 0;
+    let instrumentID = 0;
+    for (const inst of this.instruments)
+    {
+        writeStringAsBytes(instdata, inst.instrumentName, 20);
+        writeWord(instdata, instrumentStart);
+        instrumentStart += inst.instrumentZones.length;
+        inst.instrumentID = instrumentID;
+        instrumentID++;
+    }
+    // write EOI
+    writeStringAsBytes(instdata, "EOI", 20);
+    writeWord(instdata, instrumentStart);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "inst",
+        instdata.length,
+        instdata
+    ));
+}

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

@@ -0,0 +1,39 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getPBAG()
+{
+    // write all pbag with their start indexes as they were changed in getPGEN() and getPMOD()
+    const pbagsize = this.presets.reduce((sum, i) => i.presetZones.length * 4 + sum, 4);
+    const pbagdata = new IndexedByteArray(pbagsize);
+    let zoneID = 0;
+    let generatorIndex = 0;
+    let modulatorIndex = 0;
+    for (const preset of this.presets)
+    {
+        preset.presetZoneStartIndex = zoneID;
+        for (const pbag of preset.presetZones)
+        {
+            pbag.zoneID = zoneID;
+            writeWord(pbagdata, generatorIndex);
+            writeWord(pbagdata, modulatorIndex);
+            generatorIndex += pbag.generators.length;
+            modulatorIndex += pbag.modulators.length;
+            zoneID++;
+        }
+    }
+    // write the terminal PBAG
+    writeWord(pbagdata, generatorIndex);
+    writeWord(pbagdata, modulatorIndex);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "pbag",
+        pbagdata.length,
+        pbagdata
+    ));
+}

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

@@ -0,0 +1,82 @@
+import { writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+import { Generator, generatorTypes } from "../generator.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+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 = 4;
+    for (const preset of this.presets)
+    {
+        pgensize += preset.presetZones.reduce((size, z) =>
+        {
+            // clear instrument and range generators before determining the size
+            z.generators = z.generators.filter(g =>
+                g.generatorType !== generatorTypes.instrument &&
+                g.generatorType !== generatorTypes.keyRange &&
+                g.generatorType !== generatorTypes.velRange
+            );
+            // unshift vel then key and instrument is last
+            if (z.velRange.max !== 127 || z.velRange.min !== 0)
+            {
+                z.generators.unshift(new Generator(
+                    generatorTypes.velRange,
+                    z.velRange.max << 8 | Math.max(z.velRange.min, 0),
+                    false
+                ));
+            }
+            if (z.keyRange.max !== 127 || z.keyRange.min !== 0)
+            {
+                z.generators.unshift(new Generator(
+                    generatorTypes.keyRange,
+                    z.keyRange.max << 8 | Math.max(z.keyRange.min, 0),
+                    false
+                ));
+            }
+            if (!z.isGlobal)
+            {
+                // write the instrument
+                z.generators.push(new Generator(
+                    generatorTypes.instrument,
+                    this.instruments.indexOf(z.instrument),
+                    false
+                ));
+            }
+            return z.generators.length * 4 + size;
+        }, 0);
+    }
+    const pgendata = new IndexedByteArray(pgensize);
+    let pgenIndex = 0;
+    for (const preset of this.presets)
+    {
+        for (const presetZone of preset.presetZones)
+        {
+            // set the start index here
+            presetZone.generatorZoneStartIndex = pgenIndex;
+            // write generators
+            for (const gen of presetZone.generators)
+            {
+                // name is deceptive, it works on negatives
+                writeWord(pgendata, gen.generatorType);
+                writeWord(pgendata, gen.generatorValue);
+            }
+            pgenIndex += presetZone.generators.length;
+        }
+    }
+    // terminal generator, is zero
+    writeWord(pgendata, 0);
+    writeWord(pgendata, 0);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "pgen",
+        pgendata.length,
+        pgendata
+    ));
+}

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

@@ -0,0 +1,42 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getPHDR()
+{
+    const phdrsize = this.presets.length * 38 + 38;
+    const phdrdata = 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);
+        // 3 unused dword, spec says to keep em so we do
+        writeDword(phdrdata, preset.library);
+        writeDword(phdrdata, preset.genre);
+        writeDword(phdrdata, preset.morphology);
+        presetStart += preset.presetZones.length;
+    }
+    // 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
+    
+    return writeRIFFChunk(new RiffChunk(
+        "phdr",
+        phdrdata.length,
+        phdrdata
+    ));
+}

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

@@ -0,0 +1,46 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeLittleEndian, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function getPMOD()
+{
+    // very similar to imod,
+    // go through all presets -> zones and write modulators sequentially
+    let pmodsize = 10;
+    for (const preset of this.presets)
+    {
+        pmodsize += preset.presetZones.reduce((sum, z) => z.modulators.length * 10 + sum, 0);
+    }
+    const pmoddata = new IndexedByteArray(pmodsize);
+    let pmodIndex = 0;
+    for (const preset of this.presets)
+    {
+        for (const pbag of preset.presetZones)
+        {
+            // set the start index here
+            pbag.modulatorZoneStartIndex = pmodIndex;
+            for (const mod of pbag.modulators)
+            {
+                writeWord(pmoddata, mod.sourceEnum);
+                writeWord(pmoddata, mod.modulatorDestination);
+                writeWord(pmoddata, mod.transformAmount);
+                writeWord(pmoddata, mod.secondarySourceEnum);
+                writeWord(pmoddata, mod.transformType);
+                pmodIndex++;
+            }
+        }
+    }
+    
+    // terminal modulator, is zero
+    writeLittleEndian(pmoddata, 0, 10);
+    
+    return writeRIFFChunk(new RiffChunk(
+        "pmod",
+        pmoddata.length,
+        pmoddata
+    ));
+}

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

@@ -0,0 +1,80 @@
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @param smplStartOffsets {number[]}
+ * @param smplEndOffsets {number[]}
+ * @param compress {boolean}
+ * @param quality {number}
+ * @param vorbisFunc {EncodeVorbisFunction}
+ * @returns {IndexedByteArray}
+ */
+export function getSDTA(smplStartOffsets, smplEndOffsets, compress, quality, vorbisFunc)
+{
+    // write smpl: write int16 data of each sample linearly
+    // get size (calling getAudioData twice doesn't matter since it gets cached)
+    const sampleDatas = this.samples.map((s, i) =>
+    {
+        if (compress)
+        {
+            s.compressSample(quality, vorbisFunc);
+        }
+        const r = s.getRawData();
+        SpessaSynthInfo(
+            `%cEncoded sample %c${i}. ${s.sampleName}%c of %c${this.samples.length}%c. Compressed: %c${s.isCompressed}%c.`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            s.isCompressed ? consoleColors.recognized : consoleColors.unrecognized,
+            consoleColors.info
+        );
+        return r;
+    });
+    const smplSize = this.samples.reduce((total, s, i) =>
+    {
+        return total + sampleDatas[i].length + 46;
+    }, 0);
+    const smplData = new IndexedByteArray(smplSize);
+    // resample to int16 and write out
+    this.samples.forEach((sample, i) =>
+    {
+        const data = sampleDatas[i];
+        let startOffset;
+        let endOffset;
+        let jump = data.length;
+        if (sample.isCompressed)
+        {
+            // sf3 offset is in bytes
+            startOffset = smplData.currentIndex;
+            endOffset = startOffset + data.length;
+        }
+        else
+        {
+            // sf2 in sample data points
+            startOffset = smplData.currentIndex / 2;
+            endOffset = startOffset + data.length / 2;
+            jump += 46;
+        }
+        smplStartOffsets.push(startOffset);
+        smplData.set(data, smplData.currentIndex);
+        smplData.currentIndex += jump;
+        smplEndOffsets.push(endOffset);
+    });
+    
+    const smplChunk = writeRIFFChunk(new RiffChunk(
+        "smpl",
+        smplData.length,
+        smplData
+    ), new IndexedByteArray([115, 100, 116, 97])); // `sdta`
+    
+    return writeRIFFChunk(new RiffChunk(
+        "LIST",
+        smplChunk.length,
+        smplChunk
+    ));
+}

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

@@ -0,0 +1,55 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+
+/**
+ * @this {BasicSoundBank}
+ * @param smplStartOffsets {number[]}
+ * @param smplEndOffsets {number[]}
+ * @returns {IndexedByteArray}
+ */
+export function getSHDR(smplStartOffsets, smplEndOffsets)
+{
+    const sampleLength = 46;
+    const shdrData = new IndexedByteArray(sampleLength * (this.samples.length + 1)); // +1 because EOP
+    this.samples.forEach((sample, index) =>
+    {
+        // sample name
+        writeStringAsBytes(shdrData, sample.sampleName, 20);
+        // start offset
+        const dwStart = smplStartOffsets[index];
+        writeDword(shdrData, dwStart);
+        // end offset
+        const dwEnd = smplEndOffsets[index];
+        writeDword(shdrData, dwEnd);
+        // 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;
+        if (sample.isCompressed)
+        {
+            // https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format
+            loopStart -= dwStart;
+            loopEnd -= dwStart;
+        }
+        writeDword(shdrData, loopStart);
+        writeDword(shdrData, loopEnd);
+        // sample rate
+        writeDword(shdrData, sample.sampleRate);
+        // pitch and correction
+        shdrData[shdrData.currentIndex++] = sample.samplePitch;
+        shdrData[shdrData.currentIndex++] = sample.samplePitchCorrection;
+        // sample link
+        writeWord(shdrData, sample.sampleLink);
+        // sample type: write raw because we simply copy compressed samples
+        writeWord(shdrData, sample.sampleType);
+    });
+    
+    // write EOS and zero everything else
+    writeStringAsBytes(shdrData, "EOS", sampleLength);
+    return writeRIFFChunk(new RiffChunk(
+        "shdr",
+        shdrData.length,
+        shdrData
+    ));
+}