spessasynth_core 3.27.8 → 4.0.1

package/src/midi/midi_tools/used_keys_loaded.js

@@ -1,256 +0,0 @@
-import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../utils/loggin.js";
-import { consoleColors } from "../../utils/other.js";
-import { messageTypes, midiControllers } from "../midi_message.js";
-import { DEFAULT_PERCUSSION } from "../../synthetizer/synth_constants.js";
-import { chooseBank, isSystemXG, parseBankSelect } from "../../utils/xg_hacks.js";
-import { isGSDrumsOn, isXGOn } from "../../utils/sysex_detector.js";
-import { SoundFontManager } from "../../synthetizer/audio_engine/engine_components/soundfont_manager.js";
-
-/**
- * Gets the used programs and keys for this MIDI file with a given sound bank
- * @this {BasicMIDI}
- * @param soundfont {SoundFontManager|BasicSoundBank} - the sound bank
- * @returns {Record<string, Set<string>>} Record<bank:program, Set<key-velocity>>
- */
-export function getUsedProgramsAndKeys(soundfont)
-{
-    const mid = this;
-    SpessaSynthGroupCollapsed(
-        "%cSearching for all used programs and keys...",
-        consoleColors.info
-    );
-    // Find every bank:program combo and every key:velocity for each. Make sure to care about ports and drums
-    const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur : max);
-    /**
-     * @type {{program: number, bank: number, bankLSB: number, drums: boolean, string: string, actualBank: number}[]}
-     */
-    const channelPresets = [];
-    for (let i = 0; i < channelsAmount; i++)
-    {
-        const bank = i % 16 === DEFAULT_PERCUSSION ? 128 : 0;
-        channelPresets.push({
-            program: 0,
-            bank: bank,
-            bankLSB: 0,
-            actualBank: bank,
-            drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
-            string: `${bank}:0`
-        });
-    }
-    
-    // check for xg
-    let system = "gs";
-    
-    function updateString(ch)
-    {
-        const bank = chooseBank(ch.bank, ch.bankLSB, ch.drums, isSystemXG(system));
-        // check if this exists in the soundfont
-        let existsBank, existsProgram;
-        if (soundfont instanceof SoundFontManager)
-        {
-            /**
-             * @type {{preset: BasicPreset, bankOffset: number}}
-             */
-            let exists = soundfont.getPreset(bank, ch.program, isSystemXG(system));
-            existsBank = exists.preset.bank + exists.bankOffset;
-            existsProgram = exists.preset.program;
-        }
-        else
-        {
-            /**
-             * @type {BasicPreset}
-             */
-            let exists = soundfont.getPreset(bank, ch.program, isSystemXG(system));
-            existsBank = exists.bank;
-            existsProgram = exists.program;
-        }
-        ch.actualBank = existsBank;
-        ch.program = existsProgram;
-        ch.string = ch.actualBank + ":" + ch.program;
-        if (!usedProgramsAndKeys[ch.string])
-        {
-            SpessaSynthInfo(
-                `%cDetected a new preset: %c${ch.string}`,
-                consoleColors.info,
-                consoleColors.recognized
-            );
-            usedProgramsAndKeys[ch.string] = new Set();
-        }
-    }
-    
-    /**
-     * find all programs used and key-velocity combos in them
-     * bank:program each has a set of midiNote-velocity
-     * @type {Record<string, Set<string>>}
-     */
-    const usedProgramsAndKeys = {};
-    
-    /**
-     * indexes for tracks
-     * @type {number[]}
-     */
-    const eventIndexes = Array(mid.tracks.length).fill(0);
-    let remainingTracks = mid.tracks.length;
-    
-    function findFirstEventIndex()
-    {
-        let index = 0;
-        let ticks = Infinity;
-        mid.tracks.forEach((track, i) =>
-        {
-            if (eventIndexes[i] >= track.length)
-            {
-                return;
-            }
-            if (track[eventIndexes[i]].ticks < ticks)
-            {
-                index = i;
-                ticks = track[eventIndexes[i]].ticks;
-            }
-        });
-        return index;
-    }
-    
-    const ports = mid.midiPorts.slice();
-    // initialize
-    channelPresets.forEach(c =>
-    {
-        updateString(c);
-    });
-    while (remainingTracks > 0)
-    {
-        let trackNum = findFirstEventIndex();
-        const track = mid.tracks[trackNum];
-        if (eventIndexes[trackNum] >= track.length)
-        {
-            remainingTracks--;
-            continue;
-        }
-        const event = track[eventIndexes[trackNum]];
-        eventIndexes[trackNum]++;
-        
-        if (event.messageStatusByte === messageTypes.midiPort)
-        {
-            ports[trackNum] = event.messageData[0];
-            continue;
-        }
-        const status = event.messageStatusByte & 0xF0;
-        if (
-            status !== messageTypes.noteOn &&
-            status !== messageTypes.controllerChange &&
-            status !== messageTypes.programChange &&
-            status !== messageTypes.systemExclusive
-        )
-        {
-            continue;
-        }
-        const channel = (event.messageStatusByte & 0xF) + mid.midiPortChannelOffsets[ports[trackNum]] || 0;
-        let ch = channelPresets[channel];
-        switch (status)
-        {
-            case messageTypes.programChange:
-                ch.program = event.messageData[0];
-                updateString(ch);
-                break;
-            
-            case messageTypes.controllerChange:
-                const isLSB = event.messageData[0] === midiControllers.lsbForControl0BankSelect;
-                if (event.messageData[0] !== midiControllers.bankSelect && !isLSB)
-                {
-                    // we only care about bank select
-                    continue;
-                }
-                if (system === "gs" && ch.drums)
-                {
-                    // gs drums get changed via sysex, ignore here
-                    continue;
-                }
-                const bank = event.messageData[1];
-                if (isLSB)
-                {
-                    ch.bankLSB = bank;
-                }
-                else
-                {
-                    ch.bank = bank;
-                }
-                // interpret the bank
-                const intepretation = parseBankSelect(
-                    ch.bank,
-                    bank,
-                    system,
-                    isLSB,
-                    ch.drums,
-                    channel
-                );
-                switch (intepretation.drumsStatus)
-                {
-                    case 0:
-                        // no change
-                        break;
-                    
-                    case 1:
-                        // drums changed to off
-                        // drum change is a program change
-                        ch.drums = false;
-                        updateString(ch);
-                        break;
-                    
-                    case 2:
-                        // drums changed to on
-                        // drum change is a program change
-                        ch.drums = true;
-                        updateString(ch);
-                        break;
-                }
-                // do not update the data, bank change doesn't change the preset
-                break;
-            
-            case messageTypes.noteOn:
-                if (event.messageData[1] === 0)
-                {
-                    // that's a note off
-                    continue;
-                }
-                usedProgramsAndKeys[ch.string].add(`${event.messageData[0]}-${event.messageData[1]}`);
-                break;
-            
-            case messageTypes.systemExclusive:
-                // check for drum sysex
-                if (!isGSDrumsOn(event))
-                {
-                    // check for XG
-                    if (isXGOn(event))
-                    {
-                        system = "xg";
-                        SpessaSynthInfo(
-                            "%cXG on detected!",
-                            consoleColors.recognized
-                        );
-                    }
-                    continue;
-                }
-                const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][event.messageData[5] & 0x0F] + mid.midiPortChannelOffsets[ports[trackNum]];
-                const isDrum = !!(event.messageData[7] > 0 && event.messageData[5] >> 4);
-                ch = channelPresets[sysexChannel];
-                ch.drums = isDrum;
-                updateString(ch);
-                break;
-            
-        }
-    }
-    for (const key of Object.keys(usedProgramsAndKeys))
-    {
-        if (usedProgramsAndKeys[key].size === 0)
-        {
-            SpessaSynthInfo(
-                `%cDetected change but no keys for %c${key}`,
-                consoleColors.info,
-                consoleColors.value
-            );
-            delete usedProgramsAndKeys[key];
-        }
-    }
-    SpessaSynthGroupEnd();
-    return usedProgramsAndKeys;
-}

package/src/midi/xmf_loader.js

@@ -1,454 +0,0 @@
-import { readBytesAsString } from "../utils/byte_functions/string.js";
-import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.js";
-import { consoleColors } from "../utils/other.js";
-import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
-import { readVariableLengthQuantity } from "../utils/byte_functions/variable_length_quantity.js";
-import { RMIDINFOChunks } from "./midi_tools/rmidi_writer.js";
-import { inflateSync } from "../externals/fflate/fflate.min.js";
-import { IndexedByteArray } from "../utils/indexed_array.js";
-
-/**
- * @enum {number}
- */
-const metadataTypes = {
-    XMFFileType: 0,
-    nodeName: 1,
-    nodeIDNumber: 2,
-    resourceFormat: 3,
-    filenameOnDisk: 4,
-    filenameExtensionOnDisk: 5,
-    macOSFileTypeAndCreator: 6,
-    mimeType: 7,
-    title: 8,
-    copyrightNotice: 9,
-    comment: 10,
-    autoStart: 11,                 // Node Name of the FileNode containing the SMF image to autostart when the XMF file loads
-    preload: 12,                   // Used to preload specific SMF and DLS file images.
-    contentDescription: 13,        // RP-42a (https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp42.pdf)
-    ID3Metadata: 14                // RP-47 (https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp47.pdf)
-};
-
-/**
- * @enum {number}
- */
-const referenceTypeIds = {
-    inLineResource: 1,
-    inFileResource: 2,
-    inFileNode: 3,
-    externalFile: 4,
-    externalXMF: 5,
-    XMFFileURIandNodeID: 6
-};
-
-/**
- * @enum {number}
- */
-const resourceFormatIDs = {
-    StandardMIDIFile: 0,
-    StandardMIDIFileType1: 1,
-    DLS1: 2,
-    DLS2: 3,
-    DLS22: 4,
-    mobileDLS: 5
-};
-
-/**
- * @enum {number}
- */
-const formatTypeIDs = {
-    standard: 0,
-    MMA: 1,
-    registered: 2,
-    nonRegistered: 3
-};
-
-
-/**
- * @enum {number}
- */
-const unpackerIDs = {
-    none: 0,
-    MMAUnpacker: 1,
-    registered: 2,
-    nonRegistered: 3
-};
-
-class XMFNode
-{
-    /**
-     * @type {number}
-     */
-    length;
-    /**
-     * 0 means it's a file node
-     * @type {number}
-     */
-    itemCount;
-    /**
-     * @type {number}
-     */
-    metadataLength;
-    
-    /**
-     * @type {Record<string, any>}
-     */
-    metadata = {};
-    
-    /**
-     * @type {IndexedByteArray}
-     */
-    nodeData;
-    
-    /**
-     * @type {XMFNode[]}
-     */
-    innerNodes = [];
-    
-    packedContent = false;
-    
-    nodeUnpackers = [];
-    
-    
-    /**
-     * @type {"StandardMIDIFile"|
-     * "StandardMIDIFileType1"|
-     * "DLS1"|
-     * "DLS2"|
-     * "DLS22"|
-     * "mobileDLS"|
-     * "unknown"|"folder"}
-     */
-    resourceFormat = "unknown";
-    
-    /**
-     * @param binaryData {IndexedByteArray}
-     */
-    constructor(binaryData)
-    {
-        let nodeStartIndex = binaryData.currentIndex;
-        this.length = readVariableLengthQuantity(binaryData);
-        this.itemCount = readVariableLengthQuantity(binaryData);
-        // header length
-        const headerLength = readVariableLengthQuantity(binaryData);
-        const readBytes = binaryData.currentIndex - nodeStartIndex;
-        
-        const remainingHeader = headerLength - readBytes;
-        const headerData = binaryData.slice(
-            binaryData.currentIndex,
-            binaryData.currentIndex + remainingHeader
-        );
-        binaryData.currentIndex += remainingHeader;
-        
-        this.metadataLength = readVariableLengthQuantity(headerData);
-        
-        const metadataChunk = headerData.slice(
-            headerData.currentIndex,
-            headerData.currentIndex + this.metadataLength
-        );
-        headerData.currentIndex += this.metadataLength;
-        
-        /**
-         * @type {metadataTypes|string|number}
-         */
-        let fieldSpecifier;
-        let key;
-        while (metadataChunk.currentIndex < metadataChunk.length)
-        {
-            const firstSpecifierByte = metadataChunk[metadataChunk.currentIndex];
-            if (firstSpecifierByte === 0)
-            {
-                metadataChunk.currentIndex++;
-                fieldSpecifier = readVariableLengthQuantity(metadataChunk);
-                if (Object.values(metadataTypes).indexOf(fieldSpecifier) === -1)
-                {
-                    SpessaSynthWarn(`Unknown field specifier: ${fieldSpecifier}`);
-                    key = `unknown_${fieldSpecifier}`;
-                }
-                else
-                {
-                    key = Object.keys(metadataTypes).find(k => metadataTypes[k] === fieldSpecifier);
-                }
-            }
-            else
-            {
-                // this is the length of string
-                const stringLength = readVariableLengthQuantity(metadataChunk);
-                fieldSpecifier = readBytesAsString(metadataChunk, stringLength);
-                key = fieldSpecifier;
-            }
-            
-            const numberOfVersions = readVariableLengthQuantity(metadataChunk);
-            if (numberOfVersions === 0)
-            {
-                const dataLength = readVariableLengthQuantity(metadataChunk);
-                const contentsChunk = metadataChunk.slice(
-                    metadataChunk.currentIndex,
-                    metadataChunk.currentIndex + dataLength
-                );
-                metadataChunk.currentIndex += dataLength;
-                const formatID = readVariableLengthQuantity(contentsChunk);
-                // text only
-                if (formatID < 4)
-                {
-                    this.metadata[key] = readBytesAsString(contentsChunk, dataLength - 1);
-                }
-                else
-                {
-                    this.metadata[key] = contentsChunk.slice(contentsChunk.currentIndex);
-                }
-            }
-            else
-            {
-                // throw new Error ("International content is not supported.");
-                // Skip the number of versions
-                SpessaSynthWarn(`International content: ${numberOfVersions}`);
-                // Length in bytes
-                // Skip the whole thing!
-                metadataChunk.currentIndex += readVariableLengthQuantity(metadataChunk);
-            }
-        }
-        
-        const unpackersStart = headerData.currentIndex;
-        const unpackersLength = readVariableLengthQuantity(headerData);
-        const unpackersData = headerData.slice(headerData.currentIndex, unpackersStart + unpackersLength);
-        headerData.currentIndex = unpackersStart + unpackersLength;
-        if (unpackersLength > 0)
-        {
-            this.packedContent = true;
-            while (unpackersData.currentIndex < unpackersLength)
-            {
-                const unpacker = {};
-                unpacker.id = readVariableLengthQuantity(unpackersData);
-                switch (unpacker.id)
-                {
-                    case unpackerIDs.nonRegistered:
-                    case unpackerIDs.registered:
-                        SpessaSynthGroupEnd();
-                        throw new Error(`Unsupported unpacker ID: ${unpacker.id}`);
-                    
-                    default:
-                        SpessaSynthGroupEnd();
-                        throw new Error(`Unknown unpacker ID: ${unpacker.id}`);
-                    
-                    case unpackerIDs.none:
-                        unpacker.standardID = readVariableLengthQuantity(unpackersData);
-                        break;
-                    
-                    case unpackerIDs.MMAUnpacker:
-                        let manufacturerID = unpackersData[unpackersData.currentIndex++];
-                        // one or three byte form, depending on if the first byte is zero
-                        if (manufacturerID === 0)
-                        {
-                            manufacturerID <<= 8;
-                            manufacturerID |= unpackersData[unpackersData.currentIndex++];
-                            manufacturerID <<= 8;
-                            manufacturerID |= unpackersData[unpackersData.currentIndex++];
-                        }
-                        const manufacturerInternalID = readVariableLengthQuantity(unpackersData);
-                        unpacker.manufacturerID = manufacturerID;
-                        unpacker.manufacturerInternalID = manufacturerInternalID;
-                        break;
-                }
-                unpacker.decodedSize = readVariableLengthQuantity(unpackersData);
-                this.nodeUnpackers.push(unpacker);
-            }
-        }
-        binaryData.currentIndex = nodeStartIndex + headerLength;
-        /**
-         * @type {referenceTypeIds|number}
-         */
-        this.referenceTypeID = readVariableLengthQuantity(binaryData);
-        this.nodeData = binaryData.slice(binaryData.currentIndex, nodeStartIndex + this.length);
-        binaryData.currentIndex = nodeStartIndex + this.length;
-        switch (this.referenceTypeID)
-        {
-            case referenceTypeIds.inLineResource:
-                break;
-            
-            case referenceTypeIds.externalXMF:
-            case referenceTypeIds.inFileNode:
-            case referenceTypeIds.XMFFileURIandNodeID:
-            case referenceTypeIds.externalFile:
-            case referenceTypeIds.inFileResource:
-                SpessaSynthGroupEnd();
-                throw new Error(`Unsupported reference type: ${this.referenceTypeID}`);
-            
-            default:
-                SpessaSynthGroupEnd();
-                throw new Error(`Unknown reference type: ${this.referenceTypeID}`);
-        }
-        
-        // read the data
-        if (this.isFile)
-        {
-            if (this.packedContent)
-            {
-                const compressed = this.nodeData.slice(2, this.nodeData.length);
-                SpessaSynthInfo(
-                    `%cPacked content. Attemting to deflate. Target size: %c${this.nodeUnpackers[0].decodedSize}`,
-                    consoleColors.warn,
-                    consoleColors.value
-                );
-                try
-                {
-                    this.nodeData = new IndexedByteArray(inflateSync(compressed).buffer);
-                }
-                catch (e)
-                {
-                    SpessaSynthGroupEnd();
-                    throw new Error(`Error unpacking XMF file contents: ${e.message}.`);
-                }
-            }
-            /**
-             * interpret the content
-             * @type {number[]}
-             */
-            const resourceFormat = this.metadata["resourceFormat"];
-            if (resourceFormat === undefined)
-            {
-                SpessaSynthWarn("No resource format for this file node!");
-            }
-            else
-            {
-                const formatTypeID = resourceFormat[0];
-                if (formatTypeID !== formatTypeIDs.standard)
-                {
-                    SpessaSynthWarn(`Non-standard formatTypeID: ${resourceFormat}`);
-                    this.resourceFormat = resourceFormat.toString();
-                }
-                const resourceFormatID = resourceFormat[1];
-                if (Object.values(resourceFormatIDs).indexOf(resourceFormatID) === -1)
-                {
-                    SpessaSynthWarn(`Unrecognized resource format: ${resourceFormatID}`);
-                }
-                else
-                {
-                    this.resourceFormat = Object.keys(resourceFormatIDs)
-                        .find(k => resourceFormatIDs[k] === resourceFormatID);
-                }
-            }
-        }
-        else
-        {
-            // folder node
-            this.resourceFormat = "folder";
-            while (this.nodeData.currentIndex < this.nodeData.length)
-            {
-                const nodeStartIndex = this.nodeData.currentIndex;
-                const nodeLength = readVariableLengthQuantity(this.nodeData);
-                const nodeData = this.nodeData.slice(nodeStartIndex, nodeStartIndex + nodeLength);
-                this.nodeData.currentIndex = nodeStartIndex + nodeLength;
-                this.innerNodes.push(new XMFNode(nodeData));
-            }
-        }
-    }
-    
-    get isFile()
-    {
-        return this.itemCount === 0;
-    }
-}
-
-/**
- * @param midi {BasicMIDI}
- * @param binaryData {IndexedByteArray}
- * @returns {IndexedByteArray} the file byte array
- */
-export function loadXMF(midi, binaryData)
-{
-    midi.bankOffset = 0;
-    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/xmf-v1a.pdf
-    // https://wiki.multimedia.cx/index.php?title=Extensible_Music_Format_(XMF)
-    const sanityCheck = readBytesAsString(binaryData, 4);
-    if (sanityCheck !== "XMF_")
-    {
-        SpessaSynthGroupEnd();
-        throw new SyntaxError(`Invalid XMF Header! Expected "_XMF", got "${sanityCheck}"`);
-    }
-    
-    SpessaSynthGroup("%cParsing XMF file...", consoleColors.info);
-    const version = readBytesAsString(binaryData, 4);
-    SpessaSynthInfo(
-        `%cXMF version: %c${version}`,
-        consoleColors.info, consoleColors.recognized
-    );
-    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp43.pdf
-    // version 2.00 has additional bytes
-    if (version === "2.00")
-    {
-        const fileTypeId = readBytesAsUintBigEndian(binaryData, 4);
-        const fileTypeRevisionId = readBytesAsUintBigEndian(binaryData, 4);
-        SpessaSynthInfo(
-            `%cFile Type ID: %c${fileTypeId}%c, File Type Revision ID: %c${fileTypeRevisionId}`,
-            consoleColors.info,
-            consoleColors.recognized,
-            consoleColors.info,
-            consoleColors.recognized
-        );
-    }
-    
-    // file length
-    readVariableLengthQuantity(binaryData);
-    
-    const metadataTableLength = readVariableLengthQuantity(binaryData);
-    // skip metadata
-    binaryData.currentIndex += metadataTableLength;
-    
-    // skip to tree root
-    binaryData.currentIndex = readVariableLengthQuantity(binaryData);
-    const rootNode = new XMFNode(binaryData);
-    /**
-     * @type {IndexedByteArray}
-     */
-    let midiArray;
-    /**
-     * find the stuff we care about
-     * @param node {XMFNode}
-     */
-    const searchNode = node =>
-    {
-        const checkMeta = (xmf, rmid) =>
-        {
-            if (node.metadata[xmf] !== undefined && typeof node.metadata[xmf] === "string")
-            {
-                midi.RMIDInfo[rmid] = node.metadata[xmf];
-            }
-        };
-        // meta
-        checkMeta("nodeName", RMIDINFOChunks.name);
-        checkMeta("title", RMIDINFOChunks.name);
-        checkMeta("copyrightNotice", RMIDINFOChunks.copyright);
-        checkMeta("comment", RMIDINFOChunks.comment);
-        if (node.isFile)
-        {
-            switch (node.resourceFormat)
-            {
-                default:
-                    return;
-                case "DLS1":
-                case "DLS2":
-                case "DLS22":
-                case "mobileDLS":
-                    SpessaSynthInfo("%cFound embedded DLS!", consoleColors.recognized);
-                    midi.embeddedSoundFont = node.nodeData.buffer;
-                    break;
-                
-                case "StandardMIDIFile":
-                case "StandardMIDIFileType1":
-                    SpessaSynthInfo("%cFound embedded MIDI!", consoleColors.recognized);
-                    midiArray = node.nodeData;
-                    break;
-            }
-        }
-        else
-        {
-            for (const n of node.innerNodes)
-            {
-                searchNode(n);
-            }
-        }
-    };
-    searchNode(rootNode);
-    SpessaSynthGroupEnd();
-    return midiArray;
-}