@coderline/alphatab 1.3.0-alpha.849 → 1.3.0-alpha.856

package/dist/alphaTab.mjs

@@ -1,5 +1,5 @@
 /**
- * alphaTab v1.3.0-alpha.849 (develop, build 849)
+ * alphaTab v1.3.0-alpha.856 (develop, build 856)
  * 
  * Copyright © 2023, Daniel Kuschny and Contributors, All rights reserved.
  * 
@@ -2023,6 +2023,7 @@ class Note {
         this.maxBendPoint = null;
         /**
          * Gets or sets the fret on which this note is played on the instrument.
+         * 0 is the nut.
          */
         this.fret = -1;
         /**
@@ -2370,28 +2371,43 @@ class Note {
         return 0;
     }
     get realValue() {
-        let realValue = this.realValueWithoutHarmonic;
-        if (this.isStringed) {
-            if (this.harmonicType === HarmonicType.Natural) {
-                realValue = this.harmonicPitch + this.stringTuning - this.beat.voice.bar.staff.transpositionPitch;
-            }
-            else {
-                realValue += this.harmonicPitch;
-            }
-        }
-        return realValue;
+        return this.calculateRealValue(true, true);
     }
     get realValueWithoutHarmonic() {
-        if (this.isPercussion) {
-            return this.percussionArticulation;
-        }
-        if (this.isStringed) {
-            return this.fret + this.stringTuning - this.beat.voice.bar.staff.transpositionPitch;
+        return this.calculateRealValue(true, false);
+    }
+    /**
+     * Calculates the real note value of this note as midi key respecting the given options.
+     * @param applyTranspositionPitch Whether or not to apply the transposition pitch of the current staff.
+     * @param applyHarmonic Whether or not to apply harmonic pitches to the note.
+     * @returns The calculated note value as midi key.
+     */
+    calculateRealValue(applyTranspositionPitch, applyHarmonic) {
+        const transpositionPitch = applyTranspositionPitch ? this.beat.voice.bar.staff.transpositionPitch : 0;
+        if (applyHarmonic) {
+            let realValue = this.calculateRealValue(applyTranspositionPitch, false);
+            if (this.isStringed) {
+                if (this.harmonicType === HarmonicType.Natural) {
+                    realValue = this.harmonicPitch + this.stringTuning - transpositionPitch;
+                }
+                else {
+                    realValue += this.harmonicPitch;
+                }
+            }
+            return realValue;
         }
-        if (this.isPiano) {
-            return this.octave * 12 + this.tone - this.beat.voice.bar.staff.transpositionPitch;
+        else {
+            if (this.isPercussion) {
+                return this.percussionArticulation;
+            }
+            if (this.isStringed) {
+                return this.fret + this.stringTuning - transpositionPitch;
+            }
+            if (this.isPiano) {
+                return this.octave * 12 + this.tone - transpositionPitch;
+            }
+            return 0;
         }
-        return 0;
     }
     get harmonicPitch() {
         if (this.harmonicType === HarmonicType.None || !this.isStringed) {
@@ -13317,6 +13333,7 @@ class MusicXmlImporter extends ScoreImporter {
                 this.ensureVoices(bar);
             }
         }
+        let chordsByIdForTrack = new Map();
         if (masterBar) {
             let attributesParsed = false;
             for (let c of element.childNodes) {
@@ -13338,7 +13355,7 @@ class MusicXmlImporter extends ScoreImporter {
                             }
                             break;
                         case 'harmony':
-                            this.parseHarmony(c, track);
+                            this.parseHarmony(c, track, chordsByIdForTrack);
                             break;
                         case 'sound':
                             // TODO
@@ -13478,127 +13495,23 @@ class MusicXmlImporter extends ScoreImporter {
             staff.tuning[staff.tuning.length - line] = tuning;
         }
     }
-    parseHarmony(element, track) {
-        let rootStep = null;
-        let rootAlter = '';
-        // let kind: string | null = null;
-        // let kindText: string | null = null;
-        for (let c of element.childNodes) {
-            if (c.nodeType === XmlNodeType.Element) {
-                switch (c.localName) {
+    parseHarmony(element, track, chordsByIdForTrack) {
+        let chord = new Chord();
+        for (let childNode of element.childNodes) {
+            if (childNode.nodeType === XmlNodeType.Element) {
+                switch (childNode.localName) {
                     case 'root':
-                        for (let rootChild of c.childNodes) {
-                            if (rootChild.nodeType === XmlNodeType.Element) {
-                                switch (rootChild.localName) {
-                                    case 'root-step':
-                                        rootStep = rootChild.innerText;
-                                        break;
-                                    case 'root-alter':
-                                        switch (parseInt(c.innerText)) {
-                                            case -2:
-                                                rootAlter = ' bb';
-                                                break;
-                                            case -1:
-                                                rootAlter = ' b';
-                                                break;
-                                            case 0:
-                                                rootAlter = '';
-                                                break;
-                                            case 1:
-                                                rootAlter = ' #';
-                                                break;
-                                            case 2:
-                                                rootAlter = ' ##';
-                                                break;
-                                        }
-                                        break;
-                                }
-                            }
-                        }
+                        chord.name = this.parseHarmonyRoot(childNode);
+                        break;
+                    case 'kind':
+                        chord.name = chord.name + this.parseHarmonyKind(childNode);
+                        break;
+                    case 'frame':
+                        this.parseHarmonyFrame(childNode, chord);
                         break;
                 }
             }
         }
-        let chord = new Chord();
-        chord.name = rootStep + rootAlter;
-        // TODO: find proper names for the rest
-        // switch (kind)
-        // {
-        //    // triads
-        //    case "major":
-        //        break;
-        //    case "minor":
-        //        chord.Name += "m";
-        //        break;
-        //    // Sevenths
-        //    case "augmented":
-        //        break;
-        //    case "diminished":
-        //        break;
-        //    case "dominant":
-        //        break;
-        //    case "major-seventh":
-        //        chord.Name += "7M";
-        //        break;
-        //    case "minor-seventh":
-        //        chord.Name += "m7";
-        //        break;
-        //    case "diminished-seventh":
-        //        break;
-        //    case "augmented-seventh":
-        //        break;
-        //    case "half-diminished":
-        //        break;
-        //    case "major-minor":
-        //        break;
-        //    // Sixths
-        //    case "major-sixth":
-        //        break;
-        //    case "minor-sixth":
-        //        break;
-        //    // Ninths
-        //    case "dominant-ninth":
-        //        break;
-        //    case "major-ninth":
-        //        break;
-        //    case "minor-ninth":
-        //        break;
-        //    // 11ths
-        //    case "dominant-11th":
-        //        break;
-        //    case "major-11th":
-        //        break;
-        //    case "minor-11th":
-        //        break;
-        //    // 13ths
-        //    case "dominant-13th":
-        //        break;
-        //    case "major-13th":
-        //        break;
-        //    case "minor-13th":
-        //        break;
-        //    // Suspended
-        //    case "suspended-second":
-        //        break;
-        //    case "suspended-fourth":
-        //        break;
-        //    // Functional sixths
-        //    case "Neapolitan":
-        //        break;
-        //    case "Italian":
-        //        break;
-        //    case "French":
-        //        break;
-        //    case "German":
-        //        break;
-        //    // Other
-        //    case "pedal":
-        //        break;
-        //    case "power":
-        //        break;
-        //    case "Tristan":
-        //        break;
-        // }
         // var degree = element.GetElementsByTagName("degree");
         // if (degree.Length > 0)
         // {
@@ -13615,9 +13528,199 @@ class MusicXmlImporter extends ScoreImporter {
         //    }
         // }
         this._currentChord = ModelUtils.newGuid();
+        const chordKey = chord.uniqueId;
+        if (chordsByIdForTrack.has(chordKey)) {
+            // check if the chord is already present
+            chord.showDiagram = false;
+        }
         for (let staff of track.staves) {
             staff.addChord(this._currentChord, chord);
         }
+        chordsByIdForTrack.set(chordKey, chord);
+    }
+    parseHarmonyRoot(xmlNode) {
+        let rootStep = '';
+        let rootAlter = '';
+        for (let rootChild of xmlNode.childNodes) {
+            if (rootChild.nodeType === XmlNodeType.Element) {
+                switch (rootChild.localName) {
+                    case 'root-step':
+                        rootStep = rootChild.innerText;
+                        break;
+                    case 'root-alter':
+                        switch (parseInt(xmlNode.innerText)) {
+                            case -2:
+                                rootAlter = 'bb';
+                                break;
+                            case -1:
+                                rootAlter = 'b';
+                                break;
+                            case 0:
+                                rootAlter = '';
+                                break;
+                            case 1:
+                                rootAlter = '#';
+                                break;
+                            case 2:
+                                rootAlter = '##';
+                                break;
+                        }
+                        break;
+                }
+            }
+        }
+        return rootStep + rootAlter;
+    }
+    parseHarmonyKind(xmlNode) {
+        const kindText = xmlNode.getAttribute('text');
+        let resultKind = '';
+        if (kindText) {
+            // the abbreviation is already provided
+            resultKind = kindText;
+        }
+        else {
+            const kindContent = xmlNode.innerText;
+            switch (kindContent) {
+                // triads
+                case 'major':
+                    resultKind = '';
+                    break;
+                case 'minor':
+                    resultKind = 'm';
+                    break;
+                // Sevenths
+                case 'augmented':
+                    resultKind = '+';
+                    break;
+                case 'diminished':
+                    resultKind = '\u25CB';
+                    break;
+                case 'dominant':
+                    resultKind = '7';
+                    break;
+                case 'major-seventh':
+                    resultKind = '7M';
+                    break;
+                case 'minor-seventh':
+                    resultKind = 'm7';
+                    break;
+                case 'diminished-seventh':
+                    resultKind = '\u25CB7';
+                    break;
+                case 'augmented-seventh':
+                    resultKind = '+7';
+                    break;
+                case 'half-diminished':
+                    resultKind = '\u2349';
+                    break;
+                case 'major-minor':
+                    resultKind = 'mMaj';
+                    break;
+                // Sixths
+                case 'major-sixth':
+                    resultKind = 'maj6';
+                    break;
+                case 'minor-sixth':
+                    resultKind = 'm6';
+                    break;
+                // Ninths
+                case 'dominant-ninth':
+                    resultKind = '9';
+                    break;
+                case 'major-ninth':
+                    resultKind = 'maj9';
+                    break;
+                case 'minor-ninth':
+                    resultKind = 'm9';
+                    break;
+                // 11ths
+                case 'dominant-11th':
+                    resultKind = '11';
+                    break;
+                case 'major-11th':
+                    resultKind = 'maj11';
+                    break;
+                case 'minor-11th':
+                    resultKind = 'm11';
+                    break;
+                // 13ths
+                case 'dominant-13th':
+                    resultKind = '13';
+                    break;
+                case 'major-13th':
+                    resultKind = 'maj13';
+                    break;
+                case 'minor-13th':
+                    resultKind = 'm13';
+                    break;
+                // Suspended
+                case 'suspended-second':
+                    resultKind = 'sus2';
+                    break;
+                case 'suspended-fourth':
+                    resultKind = 'sus4';
+                    break;
+                // TODO: find proper names for the rest
+                // Functional sixths
+                // case "Neapolitan":
+                //     break;
+                // case "Italian":
+                //     break;
+                // case "French":
+                //     break;
+                // case "German":
+                //     break;
+                // // Other
+                // case "pedal":
+                //     break;
+                // case "power":
+                //     break;
+                // case "Tristan":
+                //     break;
+            }
+        }
+        return resultKind;
+    }
+    parseHarmonyFrame(xmlNode, chord) {
+        for (let frameChild of xmlNode.childNodes) {
+            if (frameChild.nodeType === XmlNodeType.Element) {
+                switch (frameChild.localName) {
+                    case 'frame-strings':
+                        const stringsCount = parseInt(frameChild.innerText);
+                        chord.strings = new Array(stringsCount);
+                        for (let i = 0; i < stringsCount; i++) {
+                            // set strings unplayed as default
+                            chord.strings[i] = -1;
+                        }
+                        break;
+                    case 'first-fret':
+                        chord.firstFret = parseInt(frameChild.innerText);
+                        break;
+                    case 'frame-note':
+                        let stringNo = null;
+                        let fretNo = null;
+                        for (let noteChild of frameChild.childNodes) {
+                            switch (noteChild.localName) {
+                                case 'string':
+                                    stringNo = parseInt(noteChild.innerText);
+                                    break;
+                                case 'fret':
+                                    fretNo = parseInt(noteChild.innerText);
+                                    if (stringNo && fretNo >= 0) {
+                                        chord.strings[stringNo - 1] = fretNo;
+                                    }
+                                    break;
+                                case 'barre':
+                                    if (stringNo && fretNo && noteChild.getAttribute('type') === 'start') {
+                                        chord.barreFrets.push(fretNo);
+                                    }
+                                    break;
+                            }
+                        }
+                        break;
+                }
+            }
+        }
     }
     parseBarline(element, masterBar) {
         for (let c of element.childNodes) {
@@ -13884,9 +13987,9 @@ class MusicXmlImporter extends ScoreImporter {
                         if (!slurNumber) {
                             slurNumber = '1';
                         }
-                        // slur numbers are unique in the way that they have the same ID across 
-                        // staffs/tracks etc. as long they represent the logically same slur. 
-                        // but in our case it must be globally unique to link the correct notes. 
+                        // slur numbers are unique in the way that they have the same ID across
+                        // staffs/tracks etc. as long they represent the logically same slur.
+                        // but in our case it must be globally unique to link the correct notes.
                         // adding the staff ID should be enough to achieve this
                         slurNumber = beat.voice.bar.staff.index + '_' + slurNumber;
                         switch (c.getAttribute('type')) {
@@ -18922,6 +19025,14 @@ class MidiFileGenerator {
          * at a given midi tick position.
          */
         this.tickLookup = new MidiTickLookup();
+        /**
+         * Gets or sets whether transposition pitches should be applied to the individual midi events or not.
+         */
+        this.applyTranspositionPitches = true;
+        /**
+         * Gets the transposition pitches for the individual midi channels.
+         */
+        this.transpositionPitches = new Map();
         this._currentTripletFeel = null;
         this.vibratoResolution = 16;
         this._score = score;
@@ -18933,6 +19044,7 @@ class MidiFileGenerator {
      * Starts the generation of the midi file.
      */
     generate() {
+        this.transpositionPitches.clear();
         // initialize tracks
         for (const track of this._score.tracks) {
             this.generateTrack(track);
@@ -18978,7 +19090,22 @@ class MidiFileGenerator {
             this._programsPerChannel.set(channel, program);
         }
     }
+    static buildTranspositionPitches(score, settings) {
+        const transpositionPitches = new Map();
+        for (const track of score.tracks) {
+            const transpositionPitch = track.index < settings.notation.transpositionPitches.length
+                ? settings.notation.transpositionPitches[track.index]
+                : 0;
+            transpositionPitches.set(track.playbackInfo.primaryChannel, transpositionPitch);
+            transpositionPitches.set(track.playbackInfo.secondaryChannel, transpositionPitch);
+        }
+        return transpositionPitches;
+    }
     generateChannel(track, channel, playbackInfo) {
+        const transpositionPitch = track.index < this._settings.notation.transpositionPitches.length
+            ? this._settings.notation.transpositionPitches[track.index]
+            : 0;
+        this.transpositionPitches.set(channel, transpositionPitch);
         let volume = MidiFileGenerator.toChannelShort(playbackInfo.volume);
         let balance = MidiFileGenerator.toChannelShort(playbackInfo.balance);
         this._handler.addControlChange(track.index, 0, channel, ControllerType.VolumeCoarse, volume);
@@ -19198,7 +19325,7 @@ class MidiFileGenerator {
     generateNote(note, beatStart, beatDuration, brushInfo) {
         const track = note.beat.voice.bar.staff.track;
         const staff = note.beat.voice.bar.staff;
-        let noteKey = note.realValue;
+        let noteKey = note.calculateRealValue(this.applyTranspositionPitches, true);
         if (note.isPercussion) {
             const articulation = PercussionMapper.getArticulation(note);
             if (articulation) {
@@ -19476,7 +19603,7 @@ class MidiFileGenerator {
             case SlideOutType.Shift:
                 playedBendPoints.push(new BendPoint(shiftSlideDurationOffset, 0));
                 // normal note values are in 1/2 tones, bends are in 1/4 tones
-                const dy = (note.slideTarget.realValue - note.realValue) * 2;
+                const dy = (note.slideTarget.calculateRealValue(this.applyTranspositionPitches, true) - note.calculateRealValue(this.applyTranspositionPitches, true)) * 2;
                 playedBendPoints.push(new BendPoint(BendPoint.MaxPosition, dy));
                 break;
             case SlideOutType.OutDown:
@@ -20015,6 +20142,7 @@ class TinySoundFont {
         this._mutedChannels = new Map();
         this._soloChannels = new Map();
         this._isAnySolo = false;
+        this._transpositionPitches = new Map();
         this.currentTempo = 0;
         this.timeSignatureNumerator = 0;
         this.timeSignatureDenominator = 0;
@@ -20076,8 +20204,30 @@ class TinySoundFont {
     resetChannelStates() {
         this._mutedChannels = new Map();
         this._soloChannels = new Map();
+        this.applyTranspositionPitches(new Map());
         this._isAnySolo = false;
     }
+    applyTranspositionPitches(transpositionPitches) {
+        // dynamically adjust actively playing voices to the new pitch they have. 
+        // we are not updating the used preset and regions though. 
+        const previousTransposePitches = this._transpositionPitches;
+        for (const voice of this._voices) {
+            if (voice.playingChannel >= 0 && voice.playingChannel !== 9 /*percussion*/) {
+                let pitchDifference = 0;
+                if (previousTransposePitches.has(voice.playingChannel)) {
+                    pitchDifference -= previousTransposePitches.get(voice.playingChannel);
+                }
+                if (transpositionPitches.has(voice.playingChannel)) {
+                    pitchDifference += transpositionPitches.get(voice.playingChannel);
+                }
+                voice.playingKey += pitchDifference;
+                if (this._channels) {
+                    voice.updatePitchRatio(this._channels.channelList[voice.playingChannel], this.outSampleRate);
+                }
+            }
+        }
+        this._transpositionPitches = transpositionPitches;
+    }
     dispatchEvent(synthEvent) {
         this._midiEventQueue.enqueue(synthEvent);
     }
@@ -20492,6 +20642,9 @@ class TinySoundFont {
         if (!this._channels || channel > this._channels.channelList.length) {
             return;
         }
+        if (this._transpositionPitches.has(channel)) {
+            key += this._transpositionPitches.get(channel);
+        }
         this._channels.activeChannel = channel;
         this.noteOn(this._channels.channelList[channel].presetIndex, key, vel);
     }
@@ -20501,6 +20654,9 @@ class TinySoundFont {
      * @param key note value between 0 and 127 (60 being middle C)
      */
     channelNoteOff(channel, key) {
+        if (this._transpositionPitches.has(channel)) {
+            key += this._transpositionPitches.get(channel);
+        }
         const matches = [];
         let matchFirst = null;
         let matchLast = null;
@@ -20689,6 +20845,9 @@ class TinySoundFont {
      * @param pitchWheel pitch wheel position 0 to 16383 (default 8192 unpitched)
      */
     channelSetPerNotePitchWheel(channel, key, pitchWheel) {
+        if (this._transpositionPitches.has(channel)) {
+            key += this._transpositionPitches.get(channel);
+        }
         const c = this.channelInit(channel);
         if (c.perNotePitchWheel.has(key) && c.perNotePitchWheel.get(key) === pitchWheel) {
             return;
@@ -21486,6 +21645,9 @@ class AlphaSynth {
             this.midiLoadFailed.trigger(e);
         }
     }
+    applyTranspositionPitches(transpositionPitches) {
+        this._synthesizer.applyTranspositionPitches(transpositionPitches);
+    }
     setChannelMute(channel, mute) {
         this._synthesizer.channelSetMute(channel, mute);
     }
@@ -23174,6 +23336,9 @@ class AlphaSynthWebWorker {
                     cmd: 'alphaSynth.destroyed'
                 });
                 break;
+            case 'alphaSynth.applyTranspositionPitches':
+                this._player.applyTranspositionPitches(new Map(JSON.parse(data.transpositionPitches)));
+                break;
         }
     }
     onPositionChanged(e) {
@@ -24963,6 +25128,7 @@ class AlphaTabApiBase {
      * Applies any changes that were done to the settings object and informs the {@link renderer} about any new values to consider.
      */
     updateSettings() {
+        var _a;
         const score = this.score;
         if (score) {
             ModelUtils.applyPitchOffsets(this.settings, score);
@@ -24971,6 +25137,9 @@ class AlphaTabApiBase {
         // enable/disable player if needed
         if (this.settings.player.enablePlayer) {
             this.setupPlayer();
+            if (score) {
+                (_a = this.player) === null || _a === void 0 ? void 0 : _a.applyTranspositionPitches(MidiFileGenerator.buildTranspositionPitches(score, this.settings));
+            }
         }
         else {
             this.destroyPlayer();
@@ -25341,10 +25510,13 @@ class AlphaTabApiBase {
         let midiFile = new MidiFile();
         let handler = new AlphaSynthMidiFileHandler(midiFile);
         let generator = new MidiFileGenerator(this.score, this.settings, handler);
+        // we pass the transposition pitches separately to alphaSynth.
+        generator.applyTranspositionPitches = false;
         generator.generate();
         this._tickCache = generator.tickLookup;
         this.onMidiLoad(midiFile);
         this.player.loadMidiFile(midiFile);
+        this.player.applyTranspositionPitches(generator.transpositionPitches);
     }
     /**
      * Changes the volume of the given tracks.
@@ -27018,6 +27190,12 @@ class AlphaSynthWebWorkerApi {
             midi: JsonConverter.midiFileToJsObject(midi)
         });
     }
+    applyTranspositionPitches(transpositionPitches) {
+        this._synth.postMessage({
+            cmd: 'alphaSynth.applyTranspositionPitches',
+            transpositionPitches: JSON.stringify(Array.from(transpositionPitches.entries()))
+        });
+    }
     setChannelMute(channel, mute) {
         this._synth.postMessage({
             cmd: 'alphaSynth.setChannelMute',
@@ -42315,8 +42493,8 @@ class CoreSettings {
 // </auto-generated>
 class VersionInfo {
 }
-VersionInfo.version = '1.3.0-alpha.849';
-VersionInfo.date = '2023-12-05T01:25:45.378Z';
+VersionInfo.version = '1.3.0-alpha.856';
+VersionInfo.date = '2023-12-12T01:25:35.593Z';
 
 var index$5 = /*#__PURE__*/Object.freeze({
     __proto__: null,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coderline/alphatab",
-    "version": "1.3.0-alpha.849",
+    "version": "1.3.0-alpha.856",
     "description": "alphaTab is a music notation and guitar tablature rendering library",
     "keywords": [
         "guitar",
@@ -80,7 +80,7 @@
         "rollup-plugin-dts": "^6.1.0",
         "rollup-plugin-license": "^3.2.0",
         "terser": "^5.24.0",
-        "tsx": "^3.14.0",
+        "tsx": "^4.6.2",
         "typescript": "^5.2.2"
     },
     "files": [