feat: Sync Points for alphaTex (#2131)

Author: Danielku15

src.compiler/csharp/CSharpAstTransformer.ts

@@ -3647,7 +3647,16 @@ export default class CSharpAstTransformer {
                     newObject.arguments.push(assignment);
                 } else if (ts.isShorthandPropertyAssignment(p)) {
                     assignment.label = p.name.getText();
-                    assignment.expression = this.visitExpression(assignment, p.objectAssignmentInitializer!)!;
+                    if(p.objectAssignmentInitializer) {
+                        assignment.expression = this.visitExpression(assignment, p.objectAssignmentInitializer)!;
+                    } else {
+                        assignment.expression = {
+                            nodeType: cs.SyntaxKind.Identifier,
+                            parent: assignment,
+                            tsNode: p.name,
+                            text: p.name.getText()
+                        } as cs.Identifier
+                    }
                     newObject.arguments.push(assignment);
                 } else if (ts.isSpreadAssignment(p)) {
                     this._context.addTsNodeDiagnostics(p, 'Spread operator not supported', ts.DiagnosticCategory.Error);

src/importer/AlphaTexImporter.ts

@@ -2,7 +2,7 @@ import { GeneralMidi } from '@src/midi/GeneralMidi';
 import { ScoreImporter } from '@src/importer/ScoreImporter';
 import { UnsupportedFormatError } from '@src/importer/UnsupportedFormatError';
 import { AccentuationType } from '@src/model/AccentuationType';
-import { Automation, AutomationType } from '@src/model/Automation';
+import { Automation, AutomationType, type FlatSyncPoint } from '@src/model/Automation';
 import { Bar, BarLineStyle, SustainPedalMarker, SustainPedalMarkerType } from '@src/model/Bar';
 import { Beat, BeatBeamingMode } from '@src/model/Beat';
 import { BendPoint } from '@src/model/BendPoint';
@@ -190,6 +190,7 @@ export class AlphaTexImporter extends ScoreImporter {
     private _articulationValueToIndex = new Map<number, number>();
 
     private _accidentalMode: AlphaTexAccidentalMode = AlphaTexAccidentalMode.Explicit;
+    private _syncPoints: FlatSyncPoint[] = [];
 
     public logErrors: boolean = false;
 
@@ -235,11 +236,18 @@ export class AlphaTexImporter extends ScoreImporter {
                 if (!anyMetaRead && !anyBarsRead) {
                     throw new UnsupportedFormatError('No alphaTex data found');
                 }
+
+                if (this._sy === AlphaTexSymbols.Dot) {
+                    this._sy = this.newSy();
+                    this.syncPoints();
+                }
             }
 
             ModelUtils.consolidate(this._score);
             this._score.finish(this.settings);
+            ModelUtils.trimEmptyBarsAtEnd(this._score);
             this._score.rebuildRepeatGroups();
+            this._score.applyFlatSyncPoints(this._syncPoints);
             for (const [track, lyrics] of this._lyrics) {
                 this._score.tracks[track].applyLyrics(lyrics);
             }
@@ -256,6 +264,55 @@ export class AlphaTexImporter extends ScoreImporter {
         }
     }
 
+    private syncPoints() {
+        while (this._sy !== AlphaTexSymbols.Eof) {
+            this.syncPoint();
+        }
+    }
+
+    private syncPoint() {
+        // \sync BarIndex Occurence MillisecondOffset
+        // \sync BarIndex Occurence MillisecondOffset RatioPosition
+
+        if (this._sy !== AlphaTexSymbols.MetaCommand || (this._syData as string) !== 'sync') {
+            this.error('syncPoint', AlphaTexSymbols.MetaCommand, true);
+        }
+
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarIndex', AlphaTexSymbols.Number, true);
+        }
+        const barIndex = this._syData as number;
+
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarOccurence', AlphaTexSymbols.Number, true);
+        }
+        const barOccurence = this._syData as number;
+
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarMillis', AlphaTexSymbols.Number, true);
+        }
+        const millisecondOffset = this._syData as number;
+
+        this._allowFloat = true;
+        this._sy = this.newSy();
+        this._allowFloat = false;
+        let barPosition = 0;
+        if (this._sy === AlphaTexSymbols.Number) {
+            barPosition = this._syData as number;
+            this._sy = this.newSy();
+        }
+
+        this._syncPoints.push({
+            barIndex,
+            barOccurence,
+            barPosition,
+            millisecondOffset
+        });
+    }
+
     private error(nonterm: string, expected: AlphaTexSymbols, wrongSymbol: boolean = true): void {
         let receivedSymbol: AlphaTexSymbols;
         let showSyData = false;

src/importer/ScoreLoader.ts

@@ -9,12 +9,26 @@ import type { Score } from '@src/model/Score';
 import { Settings } from '@src/Settings';
 
 import { Logger } from '@src/Logger';
+import { AlphaTexImporter } from '@src/importer/AlphaTexImporter';
 
 /**
  * The ScoreLoader enables you easy loading of Scores using all
  * available importers
  */
 export class ScoreLoader {
+    /**
+     * Loads the given alphaTex string.
+     * @param tex The alphaTex string.
+     * @param settings The settings to use for parsing.
+     * @returns The parsed {@see Score}.
+     */
+    public static loadAlphaTex(tex: string, settings?: Settings): Score {
+        const parser = new AlphaTexImporter();
+        parser.logErrors = true;
+        parser.initFromString(tex, settings ?? new Settings());
+        return parser.readScore();
+    }
+
     /**
      * Loads a score asynchronously from the given datasource
      * @param path the source path to load the binary file from

src/importer/_barrel.ts

@@ -1,3 +1,4 @@
 export { ScoreImporter } from '@src/importer/ScoreImporter';
 export { ScoreLoader } from '@src/importer/ScoreLoader';
 export { UnsupportedFormatError } from '@src/importer/UnsupportedFormatError';
+export { AlphaTexImporter } from '@src/importer/AlphaTexImporter';

src/model/Bar.ts

@@ -318,6 +318,31 @@ export class Bar {
         return this._isEmpty;
     }
 
+    /**
+     * Whether this bar has any changes applied which are not related to the voices in it.
+     * (e.g. new key signatures)
+     */
+    public get hasChanges(): boolean {
+        if (this.index === 0) {
+            return true;
+        }
+        const hasChangesToPrevious =
+            this.keySignature !== this.previousBar!.keySignature ||
+            this.keySignatureType !== this.previousBar!.keySignatureType ||
+            this.clef !== this.previousBar!.clef ||
+            this.clefOttava !== this.previousBar!.clefOttava;
+        if (hasChangesToPrevious) {
+            return true;
+        }
+
+        return (
+            this.simileMark !== SimileMark.None ||
+            this.sustainPedals.length > 0 ||
+            this.barLineLeft !== BarLineStyle.Automatic ||
+            this.barLineRight !== BarLineStyle.Automatic
+        );
+    }
+
     /**
      * Whether this bar is empty or has only rests.
      */

src/model/MasterBar.ts

@@ -44,6 +44,39 @@ export class MasterBar {
      */
     public index: number = 0;
 
+    /**
+     * Whether the masterbar is has any changes applied to it (e.g. tempo changes, time signature changes etc)
+     * The first bar is always considered changed due to initial setup of values. It does not consider
+     * elements like whether the tempo really changes to the previous bar.
+     */
+    public get hasChanges() {
+        if (this.index === 0) {
+            return false;
+        }
+
+        const hasChangesToPrevious =
+            this.timeSignatureCommon !== this.previousMasterBar!.timeSignatureCommon ||
+            this.timeSignatureNumerator !== this.previousMasterBar!.timeSignatureNumerator ||
+            this.timeSignatureDenominator !== this.previousMasterBar!.timeSignatureDenominator ||
+            this.tripletFeel !== this.previousMasterBar!.tripletFeel;
+        if (hasChangesToPrevious) {
+            return true;
+        }
+
+        return (
+            this.alternateEndings !== 0 ||
+            this.isRepeatStart ||
+            this.isRepeatEnd ||
+            this.isFreeTime ||
+            this.isSectionStart ||
+            this.tempoAutomations.length > 0 ||
+            this.syncPoints && this.syncPoints!.length > 0 ||
+            (this.fermata !== null && this.fermata!.size > 0) ||
+            (this.directions !== null && this.directions!.size > 0) ||
+            this.isAnacrusis
+        );
+    }
+
     /**
      * The key signature used on all bars.
      * @deprecated Use key signatures on bar level

src/model/ModelUtils.ts

@@ -411,16 +411,15 @@ export class ModelUtils {
                 const masterBar = score.masterBars[currentIndex];
 
                 let hasTempoChange = false;
-                for(const a of masterBar.tempoAutomations) {
-                    if(a.value !== tempo) {
+                for (const a of masterBar.tempoAutomations) {
+                    if (a.value !== tempo) {
                         hasTempoChange = true;
                     }
                     tempo = a.value;
                 }
 
                 // check if masterbar breaks multibar rests, it must be fully empty with no annotations
-                if (
-                    masterBar.alternateEndings ||
+                if (masterBar.alternateEndings ||
                     (masterBar.isRepeatStart && masterBar.index !== currentGroupStartIndex) ||
                     masterBar.isFreeTime ||
                     masterBar.isAnacrusis ||
@@ -632,4 +631,46 @@ export class ModelUtils {
             }
         }
     }
+
+    /**
+     * Trims any empty bars at the end of the song.
+     * @param score
+     */
+    public static trimEmptyBarsAtEnd(score: Score) {
+        while (score.masterBars.length > 1) {
+            const barIndex = score.masterBars.length - 1;
+            const masterBar = score.masterBars[barIndex];
+
+            if (masterBar.hasChanges) {
+                return;
+            }
+            
+            for (const track of score.tracks) {
+                for (const staff of track.staves) {
+                    if (barIndex < staff.bars.length) {
+                        const bar = staff.bars[barIndex];
+                        if (!bar.isEmpty || bar.hasChanges) {
+                            // found a non-empty bar, stop whole cleanup
+                            return;
+                        }
+                    }
+                }
+            }
+
+            // if we reach here, all found bars are empty, remove the bar
+            for (const track of score.tracks) {
+                for (const staff of track.staves) {
+                    if (barIndex < staff.bars.length) {
+                        const bar = staff.bars[barIndex];
+                        staff.bars.pop();
+                        // unlink
+                        bar.previousBar!.nextBar = null;
+                    }
+                }
+            }
+
+            score.masterBars.pop();
+            masterBar.previousMasterBar!.nextMasterBar = null;
+        }
+    }
 }

test/audio/MidiPlaybackController.test.ts

@@ -163,7 +163,7 @@ describe('MidiPlaybackControllerTest', () => {
         const tex: string = `
         \\tempo 175
         .
-        \\ro :1 r | \\ae 1 r | \\ae 2 \\rc 2 r | \\ro r | \\ae 1 r | \\ae (2 3 4) \\rc 4 r |       
+        \\ro :1 r | \\ae 1 r | \\ae 2 \\rc 2 r | \\ro r | \\ae 1 r | \\ae (2 3 4) \\rc 4 r | r
         `;
         const expectedBars: number[] = [0, 1, 0, 2, 3, 4, 3, 5, 3, 5, 3, 5, 6];
         testAlphaTexRepeat(tex, expectedBars, 50);

test/importer/AlphaTexImporter.test.ts

@@ -781,7 +781,7 @@ describe('AlphaTexImporterTest', () => {
             [KeySignature.B, KeySignatureType.Major],
             [KeySignature.FSharp, KeySignatureType.Minor]
         ];
-        
+
         for (let i = 0; i < expected.length; i++) {
             expect(bars[i].keySignature).to.equal(expected[i][0]);
             expect(bars[i].keySignatureType).to.equal(expected[i][1]);
@@ -881,7 +881,7 @@ describe('AlphaTexImporterTest', () => {
     });
 
     it('triplet-feel-multi-bar', () => {
-        const tex: string = '\\tf t16 | | | \\tf t8 | | | \\tf no | | ';
+        const tex: string = '\\tf t16 C4 | C4  | C4  | \\tf t8 C4 | C4 | C4 | \\tf no | C4  | C4 ';
         const score: Score = parseTex(tex);
         expect(score.masterBars[0].tripletFeel).to.equal(TripletFeel.Triplet16th);
         expect(score.masterBars[1].tripletFeel).to.equal(TripletFeel.Triplet16th);
@@ -1480,9 +1480,9 @@ describe('AlphaTexImporterTest', () => {
 
         expect(score.masterBars).to.have.length(2);
 
-        expect(score.tracks[0].staves[0].bars).to.have.length(2);
-        expect(score.tracks[0].staves[0].bars[0].voices).to.have.length(2);
-        expect(score.tracks[0].staves[0].bars[1].voices).to.have.length(2);
+        expect(score.tracks[0].staves[0].bars.length).to.equal(2);
+        expect(score.tracks[0].staves[0].bars[0].voices.length).to.equal(2);
+        expect(score.tracks[0].staves[0].bars[1].voices.length).to.equal(2);
     });
 
     it('multi-voice-simple-all-voices', () => {
@@ -1974,4 +1974,52 @@ describe('AlphaTexImporterTest', () => {
             `);
         expect(score).toMatchSnapshot();
     });
+
+    it('sync', () => {
+        const score = parseTex(`
+            \\tempo 90
+            .
+            3.4.4*4 | 3.4.4*4 |
+            \\ro 3.4.4*4 | 3.4.4*4 | \\rc 2 3.4.4*4 |
+            3.4.4*4 | 3.4.4*4
+            .
+            \\sync 0 0 0 
+            \\sync 0 0 1000 0.5
+            \\sync 1 0 2000
+            \\sync 3 0 3000
+            \\sync 3 1 4000
+            \\sync 6 1 5000
+            `);
+
+        // simplify snapshot
+        score.tracks = [];
+
+        expect(score).toMatchSnapshot();
+    });
+
+    it('sync-expect-dot', () => {
+        const score = parseTex(`
+            \\title "Prelude in D Minor"
+            \\artist "J.S. Bach (1685-1750)"
+            \\copyright "Public Domain"
+            \\tempo 80
+            .
+            \\ts 3 4
+            0.4.16 (3.2 -.4) (1.1 -.4) (5.1 -.4) 1.1 3.2 1.1 3.2 2.3.8 (3.2 3.4) |
+            (3.2 0.4).16 (3.2 -.4) (1.1 -.4) (5.1 -.4) 1.1 3.2 1.1 3.2 2.3.8 (3.2 3.4) | 
+            (3.2 0.4).16 (3.2 -.4) (3.1 -.4) (6.1 -.4) 3.1 3.2 3.1 3.2 3.3.8 (3.2 0.3) | 
+            (3.2 0.4).16 (3.2 -.4) (3.1 -.4) (6.1 -.4) 3.1 3.2 3.1 3.2 3.3.8 (3.2 0.3) |
+            .
+            \\sync 0 0 0
+            \\sync 0 0 1500 0.666
+            \\sync 1 0 4075 0.666
+            \\sync 2 0 6475 0.333
+            \\sync 3 0 10223 1
+        `);
+
+        // simplify snapshot
+        score.tracks = [];
+
+        expect(score).toMatchSnapshot();
+    });
 });