Function testAudioExport

packages/alphatab/test/audio/AlphaSynth.test.ts:145–232

(
        score: Score,
        fileName: string,
        prepareOptions: (options: AudioExportOptions) => void
    )

    });

    async function testAudioExport(
        score: Score,
        fileName: string,
        prepareOptions: (options: AudioExportOptions) => void
    ) {
        // add a fake sync point to get time range (if there are not already sync points)
        const syncPoints = score.exportFlatSyncPoints();
        if (syncPoints.length === 0) {
            score.applyFlatSyncPoints([
                {
                    barIndex: 0,
                    barOccurence: 0,
                    barPosition: 0,
                    millisecondOffset: 0
                }
            ]);
        }

        const soundFont = await TestPlatform.loadFile('test-data/audio/default.sf2');
        const synth = new AlphaSynth(new TestOutput(), 500);

        const midi: MidiFile = new MidiFile();
        const generator: MidiFileGenerator = new MidiFileGenerator(
            score,
            new Settings(),
            new AlphaSynthMidiFileHandler(midi)
        );
        generator.applyTranspositionPitches = false;
        generator.generate();

        const exportOptions = new AudioExportOptions();
        exportOptions.masterVolume = 1;
        exportOptions.metronomeVolume = 0;
        exportOptions.sampleRate = 44100;
        exportOptions.soundFonts = [soundFont];
        prepareOptions(exportOptions);

        const exporter = synth.exportAudio(exportOptions, midi, generator.syncPoints, generator.transpositionPitches);

        let generated: Float32Array = new Float32Array(
            exportOptions.sampleRate *
                (generator.syncPoints[generator.syncPoints.length - 1].syncTime / 1000) *
                SynthConstants.AudioChannels
        );

        let totalSamples = 0;
        while (true) {
            const chunk = exporter.render(300);
            if (chunk === undefined) {
                break;
            }

            const neededSize = totalSamples + chunk.samples.length;
            if (generated.length < neededSize) {
                const needed = neededSize - generated.length;
                const newBuffer = new Float32Array(generated.length + needed);
                newBuffer.set(generated, 0);
                generated = newBuffer;