spessasynth_lib 0.0.1

package/package/soundfont/write/igen.js

@@ -0,0 +1,75 @@
+import { writeDword, writeWord } from '../../utils/byte_functions/little_endian.js'
+import { IndexedByteArray } from '../../utils/indexed_array.js'
+import { RiffChunk, writeRIFFChunk } from '../read/riff_chunk.js'
+import { generatorTypes } from '../read/generators.js'
+
+/**
+ * @this {SoundFont2}
+ * @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 derermining 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 needed
+            // unshift vel then key ( to make key first)     and instrument is last
+            if(z.velRange.max !== 127 || z.velRange.min !== 0)
+            {
+                z.generators.unshift({
+                    generatorType: generatorTypes.velRange,
+                    generatorValue: z.velRange.max << 8 | z.velRange.min
+                });
+            }
+            if(z.keyRange.max !== 127 || z.keyRange.min !== 0)
+            {
+                z.generators.unshift({
+                    generatorType: generatorTypes.keyRange,
+                    generatorValue: z.keyRange.max << 8 | z.keyRange.min
+                });
+            }
+            if(!z.isGlobal)
+            {
+                // write sample
+                z.generators.push({
+                    generatorType: generatorTypes.sampleID,
+                    generatorValue: this.samples.indexOf(z.sample)
+                });
+            }
+            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/package/soundfont/write/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 '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @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.modulatorSource);
+                writeWord(imoddata, mod.modulatorDestination);
+                writeWord(imoddata, mod.transformAmount);
+                writeWord(imoddata, mod.modulationSecondarySrc);
+                writeWord(imoddata, mod.transformType);
+                imodIndex++;
+            }
+        }
+    }
+
+    // terminal modulator, is zero
+    writeLittleEndian(imoddata, 0, 10);
+
+    return writeRIFFChunk(new RiffChunk(
+        "imod",
+        imoddata.length,
+        imoddata
+    ));
+}

package/package/soundfont/write/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 '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @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, simply 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/package/soundfont/write/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 '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @returns {IndexedByteArray}
+ */
+export function getPBAG()
+{
+    // write all pbags 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/package/soundfont/write/pgen.js

@@ -0,0 +1,77 @@
+import { writeWord } from '../../utils/byte_functions/little_endian.js'
+import { IndexedByteArray } from '../../utils/indexed_array.js'
+import { RiffChunk, writeRIFFChunk } from '../read/riff_chunk.js'
+import { generatorTypes } from '../read/generators.js'
+
+/**
+ * @this {SoundFont2}
+ * @returns {IndexedByteArray}
+ */
+export function getPGEN()
+{
+    // almost identical to igen, except correct instrument instead of sample gen
+    // go through all preset zones and write 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 derermining 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({
+                    generatorType: generatorTypes.velRange,
+                    generatorValue: z.velRange.max << 8 | z.velRange.min
+                });
+            }
+            if(z.keyRange.max !== 127 || z.keyRange.min !== 0)
+            {
+                z.generators.unshift({
+                    generatorType: generatorTypes.keyRange,
+                    generatorValue: z.keyRange.max << 8 | z.keyRange.min
+                });
+            }
+            if(!z.isGlobal)
+            {
+                // write instrument
+                z.generators.push({
+                    generatorType: generatorTypes.instrument,
+                    generatorValue: this.instruments.indexOf(z.instrument)
+                });
+            }
+            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/package/soundfont/write/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 '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @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 dwords, 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/package/soundfont/write/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 '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @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.modulatorSource);
+                writeWord(pmoddata, mod.modulatorDestination);
+                writeWord(pmoddata, mod.transformAmount);
+                writeWord(pmoddata, mod.modulationSecondarySrc);
+                writeWord(pmoddata, mod.transformType);
+                pmodIndex++;
+            }
+        }
+    }
+
+    // terminal modulator, is zero
+    writeLittleEndian(pmoddata, 0, 10);
+
+    return writeRIFFChunk(new RiffChunk(
+        "pmod",
+        pmoddata.length,
+        pmoddata
+    ));
+}

package/package/soundfont/write/sdta.js

@@ -0,0 +1,72 @@
+import { RiffChunk, writeRIFFChunk } from '../read/riff_chunk.js'
+import { IndexedByteArray } from '../../utils/indexed_array.js'
+import { SpessaSynthInfo } from '../../utils/loggin.js'
+import { consoleColors } from '../../utils/other.js'
+
+/**
+ * @this {SoundFont2}
+ * @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}`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized);
+        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/package/soundfont/write/shdr.js

@@ -0,0 +1,54 @@
+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 '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @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 / 2 + dwStart;
+        let loopEnd = sample.sampleLoopEndIndex / 2 + 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
+    ));
+}

package/package/soundfont/write/soundfont_trimmer.js

@@ -0,0 +1,169 @@
+import { consoleColors } from '../../utils/other.js'
+import {
+    SpessaSynthGroup,
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+} from '../../utils/loggin.js'
+import { getUsedProgramsAndKeys } from '../../midi_parser/used_keys_loaded.js'
+
+/**
+ * @param soundfont {SoundFont2}
+ * @param mid {MIDI}
+ * @returns {Uint8Array}
+ */
+export function trimSoundfont(soundfont, mid)
+{
+    /**
+     * @param instrument {Instrument}
+     * @param combos {{key: number, velocity: number}[]}
+     * @returns {number}
+     */
+    function trimInstrumentZones(instrument, combos)
+    {
+        let trimmedIZones = 0;
+        for (let iZoneIndex = 0; iZoneIndex < instrument.instrumentZones.length; iZoneIndex++)
+        {
+            const iZone = instrument.instrumentZones[iZoneIndex];
+            if(iZone.isGlobal)
+            {
+                continue;
+            }
+            const iKeyRange = iZone.keyRange;
+            const iVelRange = iZone.velRange;
+            let isIZoneUsed = false;
+            for(const iCombo of combos)
+            {
+                if(
+                    (iCombo.key >= iKeyRange.min && iCombo.key <= iKeyRange.max) &&
+                    (iCombo.velocity >= iVelRange.min && iCombo.velocity <= iVelRange.max)
+                )
+                {
+                    isIZoneUsed = true;
+                    break;
+                }
+            }
+            if(!isIZoneUsed)
+            {
+                SpessaSynthInfo(`%c${iZone.sample.sampleName} %cremoved from %c${instrument.instrumentName}%c. Use count: %c${iZone.useCount - 1}`,
+                    consoleColors.recognized,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info,
+                    consoleColors.recognized);
+                if(instrument.safeDeleteZone(iZoneIndex))
+                {
+                    trimmedIZones++;
+                    iZoneIndex--;
+                    SpessaSynthInfo(`%c${iZone.sample.sampleName} %cdeleted`,
+                        consoleColors.recognized,
+                        consoleColors.info)
+                }
+                if(iZone.sample.useCount < 1)
+                {
+                    soundfont.deleteSample(iZone.sample);
+                }
+            }
+
+        }
+        return trimmedIZones;
+    }
+
+    SpessaSynthGroup("%cTrimming soundfont...",
+        consoleColors.info);
+    const usedProgramsAndKeys = getUsedProgramsAndKeys(mid, soundfont);
+
+    SpessaSynthGroupCollapsed("%cModifying soundfont...",
+        consoleColors.info);
+    SpessaSynthInfo("Detected keys for midi:", usedProgramsAndKeys);
+    // modify the soundfont to only include programs and samples that are used
+    for (let presetIndex = 0; presetIndex < soundfont.presets.length; presetIndex++)
+    {
+        const p = soundfont.presets[presetIndex];
+        const string = p.bank + ":" + p.program;
+        const used = usedProgramsAndKeys[string];
+        if(used === undefined)
+        {
+            SpessaSynthInfo(`%cDeleting preset %c${p.presetName}%c and its zones`,
+                consoleColors.info,
+                consoleColors.recognized,
+                consoleColors.info
+            );
+            soundfont.deletePreset(p);
+            presetIndex--;
+        }
+        else
+        {
+            const combos = [...used].map(s => {
+                const split = s.split("-");
+                return {
+                    key: parseInt(split[0]),
+                    velocity: parseInt(split[1])
+                }
+            });
+            SpessaSynthGroupCollapsed(`%cTrimming %c${p.presetName}`,
+                consoleColors.info,
+                consoleColors.recognized);
+            SpessaSynthInfo(`Keys for ${p.presetName}:`, combos)
+            let trimmedZones = 0;
+            // clean the preset to only use zones that are used
+            for (let zoneIndex = 0; zoneIndex < p.presetZones.length; zoneIndex++)
+            {
+                const zone = p.presetZones[zoneIndex];
+                if(zone.isGlobal)
+                {
+                    continue;
+                }
+                const keyRange = zone.keyRange;
+                const velRange = zone.velRange;
+                // check if any of the combos matches the zone
+                let isZoneUsed = false;
+                for(const combo of combos)
+                {
+                    if(
+                        (combo.key >= keyRange.min && combo.key <= keyRange.max) &&
+                        (combo.velocity >= velRange.min && combo.velocity <= velRange.max)
+                    )
+                    {
+                        // zone is used, trim the instrument zones
+                        isZoneUsed = true;
+                        const trimmedIZones = trimInstrumentZones(zone.instrument, combos);
+                        SpessaSynthInfo(`%cTrimmed off %c${trimmedIZones}%c zones from %c${zone.instrument.instrumentName}`,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info,
+                            consoleColors.recognized
+                        );
+                        break;
+                    }
+                }
+                if(!isZoneUsed)
+                {
+                    trimmedZones++;
+                    p.deleteZone(zoneIndex);
+                    if(zone.instrument.useCount < 1)
+                    {
+                        soundfont.deleteInstrument(zone.instrument);
+                    }
+                    zoneIndex--;
+                }
+            }
+            SpessaSynthInfo(`%cTrimmed off %c${trimmedZones}%c zones from %c${p.presetName}`,
+                consoleColors.info,
+                consoleColors.recognized,
+                consoleColors.info,
+                consoleColors.recognized
+            );
+            SpessaSynthGroupEnd();
+        }
+    }
+    soundfont.removeUnusedElements();
+
+    soundfont.soundFontInfo['ICMT'] = `NOTE: This soundfont was trimmed by SpessaSynth to only contain presets used in "${mid.midiName}"\n\n`
+        + soundfont.soundFontInfo['ICMT'];
+
+    SpessaSynthInfo("%cSoundfont modified!",
+        consoleColors.recognized)
+    SpessaSynthGroupEnd();
+    SpessaSynthGroupEnd();
+}