@coderline/alphatab 1.6.0-alpha.1426 → 1.6.0-alpha.1430

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1426 (develop, build 1426)
+ * alphaTab v1.6.0-alpha.1430 (develop, build 1430)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -1418,13 +1418,7 @@
              */
             this.barOccurence = 0;
             /**
-             * The modified tempo at which the cursor should move (aka. the tempo played within the external audio track).
-             * This information is used together with normal tempo changes to calculate how much faster/slower the
-             * cursor playback is performed to align with the audio track.
-             */
-            this.modifiedTempo = 0;
-            /**
-             * The uadio offset marking the position within the audio track in milliseconds.
+             * The audio offset marking the position within the audio track in milliseconds.
              * This information is used to regularly sync (or on seeking) to match a given external audio time axis with the internal time axis.
              */
             this.millisecondOffset = 0;
@@ -5849,7 +5843,6 @@
         static clone(original) {
             const clone = new SyncPointData();
             clone.barOccurence = original.barOccurence;
-            clone.modifiedTempo = original.modifiedTempo;
             clone.millisecondOffset = original.millisecondOffset;
             return clone;
         }
@@ -7305,6 +7298,59 @@
                 this.tracks[i].finish(settings, sharedDataBag);
             }
         }
+        /**
+         * Applies the given list of {@link FlatSyncPoint} to this song.
+         * @param syncPoints The list of sync points to apply.
+         * @since 1.6.0
+         */
+        applyFlatSyncPoints(syncPoints) {
+            for (const b of this.masterBars) {
+                b.syncPoints = undefined;
+            }
+            for (const syncPoint of syncPoints) {
+                const automation = new Automation();
+                automation.ratioPosition = Math.min(1, Math.max(0, syncPoint.barPosition));
+                automation.type = AutomationType.SyncPoint;
+                automation.syncPointValue = new SyncPointData();
+                automation.syncPointValue.millisecondOffset = syncPoint.millisecondOffset;
+                automation.syncPointValue.barOccurence = syncPoint.barOccurence;
+                if (syncPoint.barIndex < this.masterBars.length) {
+                    this.masterBars[syncPoint.barIndex].addSyncPoint(automation);
+                }
+            }
+            for (const b of this.masterBars) {
+                if (b.syncPoints) {
+                    b.syncPoints.sort((a, b) => {
+                        const occurence = a.syncPointValue.barOccurence - b.syncPointValue.barOccurence;
+                        if (occurence !== 0) {
+                            return occurence;
+                        }
+                        return a.ratioPosition - b.ratioPosition;
+                    });
+                }
+            }
+        }
+        /**
+         * Exports all sync points in this song to a {@link FlatSyncPoint} list.
+         * @since 1.6.0
+         */
+        exportFlatSyncPoints() {
+            const syncPoints = [];
+            for (const masterBar of this.masterBars) {
+                const masterBarSyncPoints = masterBar.syncPoints;
+                if (masterBarSyncPoints) {
+                    for (const syncPoint of masterBarSyncPoints) {
+                        syncPoints.push({
+                            barIndex: masterBar.index,
+                            barOccurence: syncPoint.syncPointValue.barOccurence,
+                            barPosition: syncPoint.ratioPosition,
+                            millisecondOffset: syncPoint.syncPointValue.millisecondOffset
+                        });
+                    }
+                }
+            }
+            return syncPoints;
+        }
     }
 
     /**
@@ -13613,6 +13659,7 @@
         XmlNodeType[XmlNodeType["CDATA"] = 3] = "CDATA";
         XmlNodeType[XmlNodeType["Document"] = 4] = "Document";
         XmlNodeType[XmlNodeType["DocumentType"] = 5] = "DocumentType";
+        XmlNodeType[XmlNodeType["Comment"] = 6] = "Comment";
     })(XmlNodeType || (XmlNodeType = {}));
     class XmlNode {
         constructor() {
@@ -14189,7 +14236,7 @@
                             this.indent();
                             for (const child of xml.childNodes) {
                                 // skip text nodes in case of multiple children
-                                if (child.nodeType === XmlNodeType.Element) {
+                                if (child.nodeType === XmlNodeType.Element || child.nodeType === XmlNodeType.Comment) {
                                     this.writeNode(child);
                                 }
                             }
@@ -14220,6 +14267,9 @@
                 case XmlNodeType.DocumentType:
                     this.write(`<!DOCTYPE ${xml.value}>`);
                     break;
+                case XmlNodeType.Comment:
+                    this.write(`<!-- ${xml.value} -->`);
+                    break;
             }
         }
         unindend() {
@@ -14661,9 +14711,6 @@
                                     case 'BarOccurrence':
                                         syncPointValue.barOccurence = GpifParser.parseIntSafe(vc.innerText, 0);
                                         break;
-                                    case 'ModifiedTempo':
-                                        syncPointValue.modifiedTempo = GpifParser.parseFloatSafe(vc.innerText, 0);
-                                        break;
                                     case 'FrameOffset':
                                         const frameOffset = GpifParser.parseFloatSafe(vc.innerText, 0);
                                         syncPointValue.millisecondOffset = (frameOffset / GpifParser.SampleRate) * 1000;
@@ -16816,7 +16863,7 @@
      * Internal Range: 1 per quarter note
      */
     GpifParser.BendPointValueFactor = 1 / 25.0;
-    // test have shown that Guitar Pro seem to always work with 44100hz for the frame offsets,
+    // tests have shown that Guitar Pro seem to always work with 44100hz for the frame offsets,
     // they are NOT using the sample rate of the input file. 
     // Downsampling a 44100hz ogg to 8000hz and using it in as audio track resulted in the same frame offset when placing sync points.
     GpifParser.SampleRate = 44100;
@@ -22286,6 +22333,61 @@
         }
     }
 
+    /**
+     * Rerpresents a point to sync the alphaTab time axis with an external backing track.
+     */
+    class BackingTrackSyncPoint {
+        constructor() {
+            /**
+             * The index of the masterbar to which this sync point belongs to.
+             * @remarks
+             * This property is purely informative for external use like in editors.
+             * It has no impact to the synchronization itself.
+             */
+            this.masterBarIndex = 0;
+            /**
+             * The occurence of the masterbar to which this sync point belongs to. The occurence
+             * is 0-based and increases with every repeated play of a masterbar (e.g. on repeats or jumps).
+             * @remarks
+             * This property is purely informative for external use like in editors.
+             * It has no impact to the synchronization itself.
+             */
+            this.masterBarOccurence = 0;
+            /**
+             * The BPM the synthesizer has at the exact tick position of this sync point.
+             */
+            this.synthBpm = 0;
+            /**
+             * The millisecond time position of the synthesizer when this sync point is reached.
+             */
+            this.synthTime = 0;
+            /**
+             * The midi tick position of the synthesizer when this sync point is reached.
+             */
+            this.synthTick = 0;
+            /**
+             * The millisecond time in the external media marking the synchronization point.
+             */
+            this.syncTime = 0;
+            /**
+             * The BPM the song will have virtually after this sync point to align the external media time axis
+             * with the one from the synthesizer.
+             */
+            this.syncBpm = 0;
+        }
+        /**
+         * Updates the synchronization BPM that will apply after this sync point.
+         * @param nextSyncPointSynthTime The synthesizer time of the next sync point after this one.
+         * @param nextSyncPointSyncTime The synchronization time of the next sync point after this one.
+         */
+        updateSyncBpm(nextSyncPointSynthTime, nextSyncPointSyncTime) {
+            const synthDuration = nextSyncPointSynthTime - this.synthTime;
+            const syncedDuration = nextSyncPointSyncTime - this.syncTime;
+            const modifiedTempo = (synthDuration / syncedDuration) * this.synthBpm;
+            this.syncBpm = modifiedTempo;
+        }
+    }
+
     class MidiFileSequencerTempoChange {
         constructor(bpm, ticks, time) {
             this.bpm = bpm;
@@ -22293,14 +22395,6 @@
             this.time = time;
         }
     }
-    class BackingTrackSyncPointWithTime {
-        constructor(tick, time, modifiedTempo, millisecondOffset) {
-            this.alphaTabTick = tick;
-            this.alphaTabTime = time;
-            this.modifiedTempo = modifiedTempo;
-            this.millisecondOffset = millisecondOffset;
-        }
-    }
     class MidiSequencerState {
         constructor() {
             this.tempoChanges = [];
@@ -22404,7 +22498,7 @@
                 this._mainState.currentTempo = this._mainState.tempoChanges[0].bpm;
                 this._mainState.modifiedTempo =
                     this._mainState.syncPoints.length > 0
-                        ? this._mainState.syncPoints[0].modifiedTempo
+                        ? this._mainState.syncPoints[0].syncBpm
                         : this._mainState.currentTempo;
                 if (this.isPlayingMain) {
                     const metronomeVolume = this._synthesizer.metronomeVolume;
@@ -22575,7 +22669,7 @@
         }
         mainUpdateSyncPoints(syncPoints) {
             const state = this._mainState;
-            syncPoints.sort((a, b) => a.tick - b.tick); // just in case
+            syncPoints.sort((a, b) => a.synthTick - b.synthTick); // just in case
             state.syncPoints = [];
             if (syncPoints.length >= 0) {
                 let bpm = 120;
@@ -22585,6 +22679,8 @@
                 for (let i = 0; i < syncPoints.length; i++) {
                     const p = syncPoints[i];
                     let deltaTick = 0;
+                    // TODO: merge interpolation into MidiFileGenerator where we already play through
+                    // the time axis.
                     // remember state from previous sync point (or start). to handle linear interpolation
                     let previousModifiedTempo;
                     let previousMillisecondOffset;
@@ -22596,9 +22692,9 @@
                     }
                     else {
                         const previousSyncPoint = syncPoints[i - 1];
-                        previousModifiedTempo = previousSyncPoint.data.modifiedTempo;
-                        previousMillisecondOffset = previousSyncPoint.data.millisecondOffset;
-                        previousTick = previousSyncPoint.tick;
+                        previousModifiedTempo = previousSyncPoint.syncBpm;
+                        previousMillisecondOffset = previousSyncPoint.syncTime;
+                        previousTick = previousSyncPoint.synthTick;
                     }
                     // process time until sync point
                     // here it gets a bit tricky. if we have tempo changes on the synthesizer time axis (inbetween two sync points)
@@ -22606,25 +22702,31 @@
                     // otherwise the linear interpolation later in the lookup will fail.
                     // goal is to have always a linear increase between two points, no matter if the time axis is sliced by tempo changes or sync points
                     while (tempoChangeIndex < state.tempoChanges.length &&
-                        state.tempoChanges[tempoChangeIndex].ticks <= p.tick) {
+                        state.tempoChanges[tempoChangeIndex].ticks <= p.synthTick) {
                         deltaTick = state.tempoChanges[tempoChangeIndex].ticks - absTick;
                         if (deltaTick > 0) {
                             absTick += deltaTick;
                             absTime += deltaTick * (60000.0 / (bpm * state.division));
-                            const millisPerTick = (p.data.millisecondOffset - previousMillisecondOffset) / (p.tick - previousTick);
+                            const millisPerTick = (p.syncTime - previousMillisecondOffset) / (p.synthTick - previousTick);
                             const interpolatedMillisecondOffset = (absTick - previousTick) * millisPerTick + previousMillisecondOffset;
-                            state.syncPoints.push(new BackingTrackSyncPointWithTime(absTick, absTime, previousModifiedTempo, interpolatedMillisecondOffset));
+                            const syncPoint = new BackingTrackSyncPoint();
+                            syncPoint.synthTick = absTick;
+                            syncPoint.synthBpm = bpm;
+                            syncPoint.synthTime = absTime;
+                            syncPoint.syncTime = interpolatedMillisecondOffset;
+                            syncPoint.syncBpm = previousModifiedTempo;
                         }
                         bpm = state.tempoChanges[tempoChangeIndex].bpm;
                         tempoChangeIndex++;
                     }
-                    deltaTick = p.tick - absTick;
+                    deltaTick = p.synthTick - absTick;
                     absTick += deltaTick;
                     absTime += deltaTick * (60000.0 / (bpm * state.division));
-                    state.syncPoints.push(new BackingTrackSyncPointWithTime(p.tick, absTime, p.data.modifiedTempo, p.data.millisecondOffset));
+                    state.syncPoints.push(p);
                 }
             }
             state.syncPointIndex = 0;
+            state.modifiedTempo = state.syncPoints.length > 0 ? state.syncPoints[0].syncBpm : state.currentTempo;
         }
         currentTimePositionToTickPosition(timePosition) {
             const state = this._currentState;
@@ -22657,16 +22759,15 @@
             const syncPoints = state.syncPoints;
             if (syncPoints.length > 0) {
                 let syncPointIndex = Math.min(state.syncPointIndex, syncPoints.length - 1);
-                if (timePosition < syncPoints[syncPointIndex].millisecondOffset) {
+                if (timePosition < syncPoints[syncPointIndex].syncTime) {
                     syncPointIndex = 0;
                 }
-                while (syncPointIndex + 1 < syncPoints.length &&
-                    syncPoints[syncPointIndex + 1].millisecondOffset <= timePosition) {
+                while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].syncTime <= timePosition) {
                     syncPointIndex++;
                 }
                 if (syncPointIndex !== state.syncPointIndex) {
                     state.syncPointIndex = syncPointIndex;
-                    state.modifiedTempo = syncPoints[syncPointIndex].modifiedTempo;
+                    state.modifiedTempo = syncPoints[syncPointIndex].syncBpm;
                 }
             }
             else {
@@ -22682,18 +22783,18 @@
             this.updateSyncPoints(this._mainState, timePosition);
             const syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
             const currentSyncPoint = syncPoints[syncPointIndex];
-            const timeDiff = timePosition - currentSyncPoint.millisecondOffset;
+            const timeDiff = timePosition - currentSyncPoint.syncTime;
             let alphaTabTimeDiff;
             if (syncPointIndex + 1 < syncPoints.length) {
                 const nextSyncPoint = syncPoints[syncPointIndex + 1];
-                const relativeTimeDiff = timeDiff / (nextSyncPoint.millisecondOffset - currentSyncPoint.millisecondOffset);
-                alphaTabTimeDiff = (nextSyncPoint.alphaTabTime - currentSyncPoint.alphaTabTime) * relativeTimeDiff;
+                const relativeTimeDiff = timeDiff / (nextSyncPoint.syncTime - currentSyncPoint.syncTime);
+                alphaTabTimeDiff = (nextSyncPoint.synthTime - currentSyncPoint.synthTime) * relativeTimeDiff;
             }
             else {
-                const relativeTimeDiff = timeDiff / (backingTrackLength - currentSyncPoint.millisecondOffset);
-                alphaTabTimeDiff = (mainState.endTime - currentSyncPoint.alphaTabTime) * relativeTimeDiff;
+                const relativeTimeDiff = timeDiff / (backingTrackLength - currentSyncPoint.syncTime);
+                alphaTabTimeDiff = (mainState.endTime - currentSyncPoint.synthTime) * relativeTimeDiff;
             }
-            return (currentSyncPoint.alphaTabTime + alphaTabTimeDiff) / this.playbackSpeed;
+            return (currentSyncPoint.synthTime + alphaTabTimeDiff) / this.playbackSpeed;
         }
         mainTimePositionToBackingTrack(timePosition, backingTrackLength) {
             const mainState = this._mainState;
@@ -22703,27 +22804,27 @@
             }
             timePosition *= this.playbackSpeed;
             let syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
-            if (timePosition < syncPoints[syncPointIndex].alphaTabTime) {
+            if (timePosition < syncPoints[syncPointIndex].synthTime) {
                 syncPointIndex = 0;
             }
-            while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].alphaTabTime <= timePosition) {
+            while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].synthTime <= timePosition) {
                 syncPointIndex++;
             }
             // NOTE: this logic heavily relies on the interpolation done in mainUpdateSyncPoints
             // we ensure that we have a linear increase between two points
             const currentSyncPoint = syncPoints[syncPointIndex];
-            const alphaTabTimeDiff = timePosition - currentSyncPoint.alphaTabTime;
+            const alphaTabTimeDiff = timePosition - currentSyncPoint.synthTime;
             let backingTrackPos;
             if (syncPointIndex + 1 < syncPoints.length) {
                 const nextSyncPoint = syncPoints[syncPointIndex + 1];
-                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (nextSyncPoint.alphaTabTime - currentSyncPoint.alphaTabTime);
-                const backingTrackDiff = nextSyncPoint.millisecondOffset - currentSyncPoint.millisecondOffset;
-                backingTrackPos = currentSyncPoint.millisecondOffset + backingTrackDiff * relativeAlphaTabTimeDiff;
+                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (nextSyncPoint.synthTime - currentSyncPoint.synthTime);
+                const backingTrackDiff = nextSyncPoint.syncTime - currentSyncPoint.syncTime;
+                backingTrackPos = currentSyncPoint.syncTime + backingTrackDiff * relativeAlphaTabTimeDiff;
             }
             else {
-                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (mainState.endTime - currentSyncPoint.alphaTabTime);
-                const frameDiff = backingTrackLength - currentSyncPoint.millisecondOffset;
-                backingTrackPos = currentSyncPoint.millisecondOffset + frameDiff * relativeAlphaTabTimeDiff;
+                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (mainState.endTime - currentSyncPoint.synthTime);
+                const frameDiff = backingTrackLength - currentSyncPoint.syncTime;
+                backingTrackPos = currentSyncPoint.syncTime + frameDiff * relativeAlphaTabTimeDiff;
             }
             return backingTrackPos;
         }
@@ -30995,7 +31096,6 @@
             }
             const o = new Map();
             o.set("baroccurence", obj.barOccurence);
-            o.set("modifiedtempo", obj.modifiedTempo);
             o.set("millisecondoffset", obj.millisecondOffset);
             return o;
         }
@@ -31004,9 +31104,6 @@
                 case "baroccurence":
                     obj.barOccurence = v;
                     return true;
-                case "modifiedtempo":
-                    obj.modifiedTempo = v;
-                    return true;
                 case "millisecondoffset":
                     obj.millisecondOffset = v;
                     return true;
@@ -35769,17 +35866,6 @@
         }
     }
 
-    /**
-     * Rerpresents a point to sync the alphaTab time axis with an external backing track.
-     */
-    class BackingTrackSyncPoint {
-        constructor(tick, data) {
-            this.tick = 0;
-            this.tick = tick;
-            this.data = data;
-        }
-    }
-
     class MidiNoteDuration {
         constructor() {
             this.noteOnly = 0;
@@ -35800,6 +35886,14 @@
             this.brushInfos = [];
         }
     }
+    class PlayThroughContext {
+        constructor() {
+            this.synthTick = 0;
+            this.synthTime = 0;
+            this.currentTempo = 0;
+            this.automationToSyncPoint = new Map();
+        }
+    }
     /**
      * This generator creates a midi file using a score.
      */
@@ -35926,9 +36020,22 @@
             });
             return syncPoints;
         }
+        /**
+         * @internal
+         */
+        static buildModifiedTempoLookup(score) {
+            const syncPoints = [];
+            const context = MidiFileGenerator.playThroughSong(score, syncPoints, (_masterBar, _previousMasterBar, _currentTick, _currentTempo, _barOccurence) => {
+            }, (_barIndex, _currentTick, _currentTempo) => {
+            }, _endTick => {
+            });
+            return context.automationToSyncPoint;
+        }
         static playThroughSong(score, syncPoints, generateMasterBar, generateTracks, finish) {
             const controller = new MidiPlaybackController(score);
-            let currentTempo = score.tempo;
+            const playContext = new PlayThroughContext();
+            playContext.currentTempo = score.tempo;
+            playContext.syncPoints = syncPoints;
             let previousMasterBar = null;
             // store the previous played bar for repeats
             const barOccurence = new Map();
@@ -35941,23 +36048,11 @@
                     let occurence = barOccurence.has(index) ? barOccurence.get(index) : -1;
                     occurence++;
                     barOccurence.set(index, occurence);
-                    generateMasterBar(bar, previousMasterBar, currentTick, currentTempo, occurence);
-                    const barSyncPoints = bar.syncPoints;
-                    if (barSyncPoints) {
-                        for (const syncPoint of barSyncPoints) {
-                            if (syncPoint.syncPointValue.barOccurence === occurence) {
-                                const tick = currentTick + bar.calculateDuration() * syncPoint.ratioPosition;
-                                syncPoints.push(new BackingTrackSyncPoint(tick, syncPoint.syncPointValue));
-                            }
-                        }
-                    }
-                    if (bar.tempoAutomations.length > 0) {
-                        currentTempo = bar.tempoAutomations[0].value;
-                    }
-                    generateTracks(index, currentTick, currentTempo);
-                    if (bar.tempoAutomations.length > 0) {
-                        currentTempo = bar.tempoAutomations[bar.tempoAutomations.length - 1].value;
-                    }
+                    generateMasterBar(bar, previousMasterBar, currentTick, playContext.currentTempo, occurence);
+                    const trackTempo = bar.tempoAutomations.length > 0 ? bar.tempoAutomations[0].value : playContext.currentTempo;
+                    generateTracks(index, currentTick, trackTempo);
+                    playContext.synthTick = currentTick;
+                    MidiFileGenerator.processBarTime(bar, occurence, playContext);
                 }
                 controller.moveNext();
                 previousMasterBar = bar;
@@ -35968,21 +36063,119 @@
             // but where it ends according to the BPM and the remaining ticks.
             if (syncPoints.length > 0) {
                 const lastSyncPoint = syncPoints[syncPoints.length - 1];
-                const remainingTicks = controller.currentTick - lastSyncPoint.tick;
+                const remainingTicks = controller.currentTick - lastSyncPoint.synthTick;
                 if (remainingTicks > 0) {
-                    const syncPointData = new SyncPointData();
-                    // last occurence of the last bar
-                    syncPointData.barOccurence = barOccurence.get(score.masterBars.length - 1);
-                    // same tempo as last point
-                    syncPointData.modifiedTempo = lastSyncPoint.data.modifiedTempo;
-                    // interpolated end from last syncPoint
-                    syncPointData.millisecondOffset =
-                        lastSyncPoint.data.millisecondOffset +
-                            MidiUtils.ticksToMillis(remainingTicks, syncPointData.modifiedTempo);
-                    syncPoints.push(new BackingTrackSyncPoint(controller.currentTick, syncPointData));
+                    const backingTrackSyncPoint = new BackingTrackSyncPoint();
+                    backingTrackSyncPoint.masterBarIndex = previousMasterBar.index;
+                    backingTrackSyncPoint.masterBarOccurence = barOccurence.get(previousMasterBar.index) - 1;
+                    backingTrackSyncPoint.synthTick = controller.currentTick;
+                    backingTrackSyncPoint.synthBpm = playContext.currentTempo;
+                    // we need to assume some BPM for the last interpolated point.
+                    // if we have more than just a start point, we keep the BPM before the last manual sync point
+                    // otherwise we have no customized sync BPM known and keep the synthesizer one.
+                    backingTrackSyncPoint.syncBpm =
+                        syncPoints.length > 1 ? syncPoints[syncPoints.length - 2].syncBpm : lastSyncPoint.synthBpm;
+                    backingTrackSyncPoint.synthTime =
+                        lastSyncPoint.synthTime + MidiUtils.ticksToMillis(remainingTicks, lastSyncPoint.synthBpm);
+                    backingTrackSyncPoint.syncTime =
+                        lastSyncPoint.syncTime + MidiUtils.ticksToMillis(remainingTicks, backingTrackSyncPoint.syncBpm);
+                    // update the previous sync point according to the new time
+                    lastSyncPoint.updateSyncBpm(backingTrackSyncPoint.synthTime, backingTrackSyncPoint.syncTime);
+                    syncPoints.push(backingTrackSyncPoint);
                 }
             }
             finish(controller.currentTick);
+            return playContext;
+        }
+        static processBarTime(bar, occurence, context) {
+            const duration = bar.calculateDuration();
+            const barSyncPoints = bar.syncPoints;
+            const barStartTick = context.synthTick;
+            if (barSyncPoints) {
+                MidiFileGenerator.processBarTimeWithSyncPoints(bar, occurence, context);
+            }
+            else {
+                MidiFileGenerator.processBarTimeNoSyncPoints(bar, context);
+            }
+            // don't forget the part after the last tempo change
+            const endTick = barStartTick + duration;
+            const tickOffset = endTick - context.synthTick;
+            if (tickOffset > 0) {
+                context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+                context.synthTick = endTick;
+            }
+        }
+        static processBarTimeWithSyncPoints(bar, occurence, context) {
+            const barStartTick = context.synthTick;
+            const duration = bar.calculateDuration();
+            let tempoChangeIndex = 0;
+            let tickOffset;
+            for (const syncPoint of bar.syncPoints) {
+                if (syncPoint.syncPointValue.barOccurence !== occurence) {
+                    continue;
+                }
+                const syncPointTick = barStartTick + syncPoint.ratioPosition * duration;
+                // first process all tempo changes until this sync point
+                while (tempoChangeIndex < bar.tempoAutomations.length &&
+                    bar.tempoAutomations[tempoChangeIndex].ratioPosition <= syncPoint.ratioPosition) {
+                    const tempoChange = bar.tempoAutomations[tempoChangeIndex];
+                    const absoluteTick = barStartTick + tempoChange.ratioPosition * duration;
+                    tickOffset = absoluteTick - context.synthTick;
+                    if (tickOffset > 0) {
+                        context.synthTick = absoluteTick;
+                        context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+                    }
+                    context.currentTempo = tempoChange.value;
+                    tempoChangeIndex++;
+                }
+                // process time until sync point
+                tickOffset = syncPointTick - context.synthTick;
+                if (tickOffset > 0) {
+                    context.synthTick = syncPointTick;
+                    context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+                }
+                // update the previous sync point according to the new time
+                if (context.syncPoints.length > 0) {
+                    context.syncPoints[context.syncPoints.length - 1].updateSyncBpm(context.synthTime, syncPoint.syncPointValue.millisecondOffset);
+                }
+                // create the new sync point
+                const backingTrackSyncPoint = new BackingTrackSyncPoint();
+                backingTrackSyncPoint.masterBarIndex = bar.index;
+                backingTrackSyncPoint.masterBarOccurence = occurence;
+                backingTrackSyncPoint.synthTick = syncPointTick;
+                backingTrackSyncPoint.synthBpm = context.currentTempo;
+                backingTrackSyncPoint.synthTime = context.synthTime;
+                backingTrackSyncPoint.syncTime = syncPoint.syncPointValue.millisecondOffset;
+                backingTrackSyncPoint.syncBpm = 0 /* calculated by next sync point */;
+                context.syncPoints.push(backingTrackSyncPoint);
+                context.automationToSyncPoint.set(syncPoint, backingTrackSyncPoint);
+            }
+            // process remaining tempo changes after all sync points
+            while (tempoChangeIndex < bar.tempoAutomations.length) {
+                const tempoChange = bar.tempoAutomations[tempoChangeIndex];
+                const absoluteTick = barStartTick + tempoChange.ratioPosition * duration;
+                tickOffset = absoluteTick - context.synthTick;
+                if (tickOffset > 0) {
+                    context.synthTick = absoluteTick;
+                    context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+                }
+                context.currentTempo = tempoChange.value;
+                tempoChangeIndex++;
+            }
+        }
+        static processBarTimeNoSyncPoints(bar, context) {
+            // walk through the tempo changes
+            const barStartTick = context.synthTick;
+            const duration = bar.calculateDuration();
+            for (const changes of bar.tempoAutomations) {
+                const absoluteTick = barStartTick + changes.ratioPosition * duration;
+                const tickOffset = absoluteTick - context.synthTick;
+                if (tickOffset > 0) {
+                    context.synthTick = absoluteTick;
+                    context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+                }
+                context.currentTempo = changes.value;
+            }
         }
         static toChannelShort(data) {
             const value = Math.max(-32768, Math.min(32767, data * 8 - 1));
@@ -38486,6 +38679,7 @@
                     value.playbackSpeed = this._playbackSpeed;
                     value.isLooping = this._isLooping;
                     value.midiEventsPlayedFilter = this._midiEventsPlayedFilter;
+                    this.ready.trigger();
                 }
                 else {
                     newUnregister.push(value.ready.on(() => {
@@ -43846,6 +44040,9 @@
             const audioElement = document.createElement('audio');
             audioElement.style.display = 'none';
             document.body.appendChild(audioElement);
+            audioElement.addEventListener('seeked', () => {
+                this.updatePosition();
+            });
             audioElement.addEventListener('timeupdate', () => {
                 this.updatePosition();
             });
@@ -60941,9 +61138,9 @@
             print(`build date: ${VersionInfo.date}`);
         }
     }
-    VersionInfo.version = '1.6.0-alpha.1426';
-    VersionInfo.date = '2025-05-27T02:07:22.361Z';
-    VersionInfo.commit = '6f8b50015eb3eaebd605045bc9f5aaf6fbf2882d';
+    VersionInfo.version = '1.6.0-alpha.1430';
+    VersionInfo.date = '2025-05-29T22:21:21.689Z';
+    VersionInfo.commit = '98a4c2bec8d71f2645008118d3b77fb40973e7fe';
 
     /**
      * A factory for custom layout engines.
@@ -61856,18 +62053,24 @@
         writeDom(parent, score) {
             const gpif = parent.addElement('GPIF');
             // just some values at the time this was implemented,
-            gpif.addElement('GPVersion').innerText = '7';
+            gpif.addElement('GPVersion').innerText = '8.1.3';
             const gpRevision = gpif.addElement('GPRevision');
-            gpRevision.innerText = '7';
-            gpRevision.attributes.set('required', '12021');
-            gpRevision.attributes.set('recommended', '12023');
-            gpRevision.innerText = '12025';
-            gpif.addElement('Encoding').addElement('EncodingDescription').innerText = 'GP7';
+            gpRevision.attributes.set('required', '12024');
+            gpRevision.attributes.set('recommended', '13000');
+            gpRevision.innerText = '13007';
+            const encoding = gpif.addElement('Encoding');
+            encoding.addElement('EncodingDescription').innerText = 'GP8';
+            const alphaTabComment = new XmlNode();
+            alphaTabComment.nodeType = XmlNodeType.Comment;
+            alphaTabComment.value = `Written by alphaTab ${VersionInfo.version} (${VersionInfo.commit})`;
+            encoding.addChild(alphaTabComment);
             this.writeScoreNode(gpif, score);
             this.writeMasterTrackNode(gpif, score);
+            this.writeBackingTrackNode(gpif, score);
             this.writeAudioTracksNode(gpif, score);
             this.writeTracksNode(gpif, score);
             this.writeMasterBarsNode(gpif, score);
+            this.writeAssets(gpif, score);
             const bars = gpif.addElement('Bars');
             const voices = gpif.addElement('Voices');
             const beats = gpif.addElement('Beats');
@@ -61890,6 +62093,42 @@
                 }
             }
         }
+        writeAssets(parent, score) {
+            if (!score.backingTrack?.rawAudioFile) {
+                return;
+            }
+            const assets = parent.addElement('Assets');
+            const asset = assets.addElement('Asset');
+            asset.attributes.set('id', this.backingTrackAssetId);
+            this.backingTrackAssetFileName = 'Content/Assets/backing-track';
+            asset.addElement('EmbeddedFilePath').setCData(this.backingTrackAssetFileName);
+        }
+        writeBackingTrackNode(parent, score) {
+            if (!score.backingTrack?.rawAudioFile) {
+                return;
+            }
+            const backingTrackNode = parent.addElement('BackingTrack');
+            const backingTrackAssetId = '0';
+            this.backingTrackAssetId = backingTrackAssetId;
+            backingTrackNode.addElement('IconId').innerText = '21';
+            backingTrackNode.addElement('Color').innerText = '0 0 0';
+            backingTrackNode.addElement('Name').setCData('Audio Track');
+            backingTrackNode.addElement('ShortName').setCData('a.track');
+            backingTrackNode.addElement('PlaybackState').innerText = 'Default';
+            backingTrackNode.addElement('Enabled').innerText = 'true';
+            backingTrackNode.addElement('Source').innerText = 'Local';
+            backingTrackNode.addElement('AssetId').innerText = backingTrackAssetId;
+            const channelStrip = backingTrackNode.addElement('ChannelStrip');
+            channelStrip.addElement('Parameters').innerText =
+                '0.500000 0.500000 0.500000 0.500000 0.500000 0.500000 0.500000 0.500000 0.500000 0.000000 0.500000 0.500000 0.800000 0.500000 0.500000 0.500000';
+            channelStrip.addElement('YouTubeVideoUrl').innerText = '';
+            channelStrip.addElement('Filter').innerText = '6';
+            channelStrip.addElement('FramesPerPixel').innerText = '400';
+            const framePadding = this.backingTrackFramePadding !== undefined ? this.backingTrackFramePadding : 0;
+            backingTrackNode.addElement('FramePadding').innerText = `${framePadding}`;
+            backingTrackNode.addElement('Semitones').innerText = '0';
+            backingTrackNode.addElement('Cents').innerText = '0';
+        }
         writeNoteNode(parent, note) {
             const noteNode = parent.addElement('Note');
             noteNode.attributes.set('id', note.id.toString());
@@ -62546,6 +62785,12 @@
                     initialTempoAutomation.addElement('Text').innerText = score.tempoLabel;
                 }
             }
+            const initialSyncPoint = score.masterBars[0].syncPoints
+                ? score.masterBars[0].syncPoints.find(p => p.ratioPosition === 0 && p.syncPointValue.barOccurence === 0)
+                : undefined;
+            const millisecondPadding = initialSyncPoint ? initialSyncPoint.syncPointValue.millisecondOffset : 0;
+            this.backingTrackFramePadding = (-1 * ((millisecondPadding / 1000) * GpifWriter.SampleRate)) | 0;
+            const modifiedTempoLookup = new Lazy(() => MidiFileGenerator.buildModifiedTempoLookup(score));
             for (const mb of score.masterBars) {
                 for (const automation of mb.tempoAutomations) {
                     const tempoAutomation = automations.addElement('Automation');
@@ -62559,6 +62804,25 @@
                         tempoAutomation.addElement('Text').innerText = automation.text;
                     }
                 }
+                if (mb.syncPoints) {
+                    for (const syncPoint of mb.syncPoints) {
+                        const syncPointAutomation = automations.addElement('Automation');
+                        syncPointAutomation.addElement('Type').innerText = 'SyncPoint';
+                        syncPointAutomation.addElement('Linear').innerText = 'false';
+                        syncPointAutomation.addElement('Bar').innerText = mb.index.toString();
+                        syncPointAutomation.addElement('Position').innerText = syncPoint.ratioPosition.toString();
+                        syncPointAutomation.addElement('Visible').innerText = 'true';
+                        const value = syncPointAutomation.addElement('Value');
+                        value.addElement('BarIndex').innerText = mb.index.toString();
+                        value.addElement('BarOccurrence').innerText = syncPoint.syncPointValue.barOccurence.toString();
+                        value.addElement('ModifiedTempo').innerText = modifiedTempoLookup.value.get(syncPoint).syncBpm.toString();
+                        value.addElement('OriginalTempo').innerText = score.tempo.toString();
+                        const frameOffset = (((syncPoint.syncPointValue.millisecondOffset - millisecondPadding) / 1000) *
+                            GpifWriter.SampleRate) |
+                            0;
+                        value.addElement('FrameOffset').innerText = frameOffset.toString();
+                    }
+                }
             }
         }
         writeAudioTracksNode(parent, score) {
@@ -63209,6 +63473,10 @@
             voiceNode.addElement('Beats').innerText = voice.beats.map(v => v.id).join(' ');
         }
     }
+    // tests have shown that Guitar Pro seem to always work with 44100hz for the frame offsets,
+    // they are NOT using the sample rate of the input file.
+    // Downsampling a 44100hz ogg to 8000hz and using it in as audio track resulted in the same frame offset when placing sync points.
+    GpifWriter.SampleRate = 44100;
     GpifWriter.MidiProgramInfoLookup = new Map([
         [0, new GpifMidiProgramInfo(GpifIconIds.Piano, 'Acoustic Piano')],
         [1, new GpifMidiProgramInfo(GpifIconIds.Piano, 'Acoustic Piano')],
@@ -64946,11 +65214,11 @@
     }
 
     /**
-     * This ScoreExporter can write Guitar Pro 7 (gp) files.
+     * This ScoreExporter can write Guitar Pro 7+ (gp) files.
      */
     class Gp7Exporter extends ScoreExporter {
         get name() {
-            return 'Guitar Pro 7';
+            return 'Guitar Pro 7-8';
         }
         writeScore(score) {
             Logger.debug(this.name, 'Writing data entries');
@@ -64967,6 +65235,9 @@
             fileSystem.writeEntry(new ZipEntry('Content/PartConfiguration', partConfiguration));
             fileSystem.writeEntry(new ZipEntry('Content/LayoutConfiguration', layoutConfiguration));
             fileSystem.writeEntry(new ZipEntry('Content/score.gpif', IOHelper.stringToBytes(gpifXml)));
+            if (gpifWriter.backingTrackAssetFileName) {
+                fileSystem.writeEntry(new ZipEntry(gpifWriter.backingTrackAssetFileName, score.backingTrack.rawAudioFile));
+            }
             fileSystem.end();
         }
     }