feat: Add option to create fresh sync points (#2161)

Author: Danielku15

src/midi/MidiFileGenerator.ts

@@ -64,6 +64,7 @@ class PlayThroughContext {
     public currentTempo: number = 0;
     public automationToSyncPoint: Map<Automation, BackingTrackSyncPoint> = new Map<Automation, BackingTrackSyncPoint>();
     public syncPoints!: BackingTrackSyncPoint[];
+    public createNewSyncPoints: boolean = false;
 }
 
 /**
@@ -133,6 +134,7 @@ export class MidiFileGenerator {
         MidiFileGenerator.playThroughSong(
             this._score,
             this.syncPoints,
+            false,
             (bar, previousMasterBar, currentTick, currentTempo, occurence) => {
                 this.generateMasterBar(bar, previousMasterBar, currentTick, currentTempo, occurence);
             },
@@ -219,14 +221,16 @@ export class MidiFileGenerator {
      * It correctly handles repeats and places sync points accoridng to their absolute midi tick when they
      * need to be considered for synchronization.
      * @param score The song for which to regenerate the sync points.
+     * @param createNew Whether a new set of sync points should be generated for the sync (start, stop and tempo changes).
      * @returns The generated sync points for usage in the backing track playback.
      */
-    public static generateSyncPoints(score: Score): BackingTrackSyncPoint[] {
+    public static generateSyncPoints(score: Score, createNew: boolean = false): BackingTrackSyncPoint[] {
         const syncPoints: BackingTrackSyncPoint[] = [];
 
         MidiFileGenerator.playThroughSong(
             score,
             syncPoints,
+            createNew,
             (_masterBar, _previousMasterBar, _currentTick, _currentTempo, _barOccurence) => {
                 // no generation
             },
@@ -250,6 +254,7 @@ export class MidiFileGenerator {
         const context = MidiFileGenerator.playThroughSong(
             score,
             syncPoints,
+            false,
             (_masterBar, _previousMasterBar, _currentTick, _currentTempo, _barOccurence) => {
                 // no generation
             },
@@ -267,6 +272,7 @@ export class MidiFileGenerator {
     private static playThroughSong(
         score: Score,
         syncPoints: BackingTrackSyncPoint[],
+        createNewSyncPoints: boolean,
         generateMasterBar: (
             masterBar: MasterBar,
             previousMasterBar: MasterBar | null,
@@ -282,6 +288,7 @@ export class MidiFileGenerator {
         const playContext = new PlayThroughContext();
         playContext.currentTempo = score.tempo;
         playContext.syncPoints = syncPoints;
+        playContext.createNewSyncPoints = createNewSyncPoints;
         let previousMasterBar: MasterBar | null = null;
 
         // store the previous played bar for repeats
@@ -328,16 +335,24 @@ export class MidiFileGenerator {
                 // 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;
+                if (playContext.createNewSyncPoints) {
+                    backingTrackSyncPoint.syncBpm = lastSyncPoint.synthBpm;
+                    backingTrackSyncPoint.synthBpm = lastSyncPoint.synthBpm;
+                } else if (syncPoints.length === 1) {
+                    backingTrackSyncPoint.syncBpm = lastSyncPoint.synthBpm;
+                } else {
+                    backingTrackSyncPoint.syncBpm = syncPoints[syncPoints.length - 2].syncBpm;
+                }
 
                 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);
+                if (!playContext.createNewSyncPoints) {
+                    lastSyncPoint.updateSyncBpm(backingTrackSyncPoint.synthTime, backingTrackSyncPoint.syncTime);
+                }
 
                 syncPoints.push(backingTrackSyncPoint);
             }
@@ -352,7 +367,9 @@ export class MidiFileGenerator {
         const duration = bar.calculateDuration();
         const barSyncPoints = bar.syncPoints;
         const barStartTick = context.synthTick;
-        if (barSyncPoints) {
+        if (context.createNewSyncPoints) {
+            MidiFileGenerator.processBarTimeWithNewSyncPoints(bar, occurence, context);
+        } else if (barSyncPoints) {
             MidiFileGenerator.processBarTimeWithSyncPoints(bar, occurence, context);
         } else {
             MidiFileGenerator.processBarTimeNoSyncPoints(bar, context);
@@ -367,6 +384,51 @@ export class MidiFileGenerator {
         }
     }
 
+    private static processBarTimeWithNewSyncPoints(bar: MasterBar, occurence: number, context: PlayThroughContext) {
+        // start marker
+        const barStartTick = context.synthTick;
+        if (bar.index === 0 && occurence === 0) {
+            context.currentTempo = bar.score.tempo;
+
+            const backingTrackSyncPoint = new BackingTrackSyncPoint();
+            backingTrackSyncPoint.masterBarIndex = bar.index;
+            backingTrackSyncPoint.masterBarOccurence = occurence;
+            backingTrackSyncPoint.synthTick = barStartTick;
+            backingTrackSyncPoint.synthBpm = context.currentTempo;
+            backingTrackSyncPoint.synthTime = context.synthTime;
+            backingTrackSyncPoint.syncBpm = context.currentTempo;
+            backingTrackSyncPoint.syncTime = context.synthTime;
+
+            context.syncPoints.push(backingTrackSyncPoint);
+        }
+
+        // walk tempo changes and create points
+        const duration = bar.calculateDuration();
+        for (const change of bar.tempoAutomations) {
+            const absoluteTick = barStartTick + change.ratioPosition * duration;
+            const tickOffset = absoluteTick - context.synthTick;
+            if (tickOffset > 0) {
+                context.synthTick = absoluteTick;
+                context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+            }
+
+            if (change.value !== context.currentTempo) {
+                context.currentTempo = change.value;
+
+                const backingTrackSyncPoint = new BackingTrackSyncPoint();
+                backingTrackSyncPoint.masterBarIndex = bar.index;
+                backingTrackSyncPoint.masterBarOccurence = occurence;
+                backingTrackSyncPoint.synthTick = absoluteTick;
+                backingTrackSyncPoint.synthBpm = context.currentTempo;
+                backingTrackSyncPoint.synthTime = context.synthTime;
+                backingTrackSyncPoint.syncBpm = context.currentTempo;
+                backingTrackSyncPoint.syncTime = context.synthTime;
+
+                context.syncPoints.push(backingTrackSyncPoint);
+            }
+        }
+    }
+
     private static processBarTimeWithSyncPoints(bar: MasterBar, occurence: number, context: PlayThroughContext) {
         const barStartTick = context.synthTick;
         const duration = bar.calculateDuration();

test/audio/SyncPoint.test.ts

@@ -124,6 +124,19 @@ describe('SyncPointTests', () => {
         }
     });
 
+    it('sync-point-generation-new', async () => {
+        const score = await syncPointTestScore();
+
+        const update = MidiFileGenerator.generateSyncPoints(score, true);
+        expect(
+            update.map(
+                p =>
+                    `${p.masterBarIndex},${p.masterBarOccurence},${p.synthBpm},${p.syncBpm},${p.synthTime},${p.syncTime}`
+            )
+        ).toMatchSnapshot();
+
+    });
+
     it('modified-tempo-lookup', async () => {
         const score = await syncPointTestScore();
 

test/audio/__snapshots__/SyncPoint.test.ts.snap

@@ -403,6 +403,15 @@ Array [
 ]
 `;
 
+exports[`SyncPointTests sync-point-generation-new 1`] = `
+Array [
+  "0,0,120,120,0,0",
+  "4,0,60,60,8000,8000",
+  "8,0,80,80,24000,24000",
+  "11,0,80,80,48000,48000",
+]
+`;
+
 exports[`SyncPointTests sync-point-update 1`] = `
 Array [
   "0,0,120,120,0,0",