@coderline/alphatab-monaco 1.7.0-alpha.1626

package/dist/types/alphatab/src/synth/ISynthOutput.d.ts

@@ -0,0 +1,90 @@
+import type { IEventEmitter, IEventEmitterOfT } from "./../EventEmitter";
+/**
+ * Represents a output device on which the synth can send the audio to.
+ * @public
+ */
+export interface ISynthOutputDevice {
+    /**
+     * The ID to uniquely identify the device.
+     */
+    readonly deviceId: string;
+    /**
+     * A string describing the device.
+     */
+    readonly label: string;
+    /**
+     * Gets a value indicating whether the device is the default output device.
+     */
+    readonly isDefault: boolean;
+}
+/**
+ * This is the base interface for output devices which can
+ * request and playback audio samples.
+ * @public
+ */
+export interface ISynthOutput {
+    /**
+     * Gets the sample rate required by the output.
+     */
+    readonly sampleRate: number;
+    /**
+     * Called when the output should be opened.
+     */
+    open(bufferTimeInMilliseconds: number): void;
+    /**
+     * Called when the output should start the playback.
+     */
+    play(): void;
+    /**
+     * Requests the output to destroy itself.
+     */
+    destroy(): void;
+    /**
+     * Called when the output should stop the playback.
+     */
+    pause(): void;
+    /**
+     * Called when samples have been synthesized and should be added to the playback buffer.
+     * @param samples
+     */
+    addSamples(samples: Float32Array): void;
+    /**
+     * Called when the samples in the output buffer should be reset. This is neeed for instance when seeking to another position.
+     */
+    resetSamples(): void;
+    /**
+     * Activates the output component.
+     */
+    activate(): void;
+    /**
+     * Fired when the output has been successfully opened and is ready to play samples.
+     */
+    readonly ready: IEventEmitter;
+    /**
+     * Fired when a certain number of samples have been played.
+     */
+    readonly samplesPlayed: IEventEmitterOfT<number>;
+    /**
+     * Fired when the output needs more samples to be played.
+     */
+    readonly sampleRequest: IEventEmitter;
+    /**
+     * Loads and lists the available output devices. Will request permissions if needed.
+     * @async
+     */
+    enumerateOutputDevices(): Promise<ISynthOutputDevice[]>;
+    /**
+     * Changes the output device which should be used for playing the audio.
+     * @async
+     * @param device The output device to use, or null to switch to the default device.
+     */
+    setOutputDevice(device: ISynthOutputDevice | null): Promise<void>;
+    /**
+     * The currently configured output device if changed via {@link setOutputDevice}.
+     * @async
+     * @returns The custom configured output device which was set via {@link setOutputDevice} or `null`
+     * if the default outputDevice is used.
+     * The output device might change dynamically if devices are connected/disconnected (e.g. bluetooth headset).
+     */
+    getOutputDevice(): Promise<ISynthOutputDevice | null>;
+}

package/dist/types/alphatab/src/synth/MidiEventsPlayedEventArgs.d.ts

@@ -0,0 +1,16 @@
+import type { MidiEvent } from "./../midi/MidiEvent";
+/**
+ * Represents the info when the synthesizer played certain midi events.
+ * @public
+ */
+export declare class MidiEventsPlayedEventArgs {
+    /**
+     * Gets the events which were played.
+     */
+    readonly events: MidiEvent[];
+    /**
+     * Initializes a new instance of the {@link MidiEventsPlayedEventArgs} class.
+     * @param events The events which were played.
+     */
+    constructor(events: MidiEvent[]);
+}

package/dist/types/alphatab/src/synth/MidiFileSequencer.d.ts

@@ -0,0 +1,98 @@
+import type { MidiFile } from "./../midi/MidiFile";
+import type { PlaybackRange } from "./PlaybackRange";
+import { SynthEvent } from "./synthesis/SynthEvent";
+import type { IAudioSampleSynthesizer } from "./IAudioSampleSynthesizer";
+import { BackingTrackSyncPoint } from "./IAlphaSynth";
+/**
+ * @internal
+ */
+export declare class MidiFileSequencerTempoChange {
+    bpm: number;
+    ticks: number;
+    time: number;
+    constructor(bpm: number, ticks: number, time: number);
+}
+/**
+ * @internal
+ */
+declare class MidiSequencerState {
+    tempoChanges: MidiFileSequencerTempoChange[];
+    tempoChangeIndex: number;
+    syncPoints: BackingTrackSyncPoint[];
+    firstProgramEventPerChannel: Map<number, SynthEvent>;
+    firstTimeSignatureNumerator: number;
+    firstTimeSignatureDenominator: number;
+    synthData: SynthEvent[];
+    division: number;
+    eventIndex: number;
+    currentTime: number;
+    syncPointIndex: number;
+    playbackRange: PlaybackRange | null;
+    playbackRangeStartTime: number;
+    playbackRangeEndTime: number;
+    endTick: number;
+    endTime: number;
+    currentTempo: number;
+    syncPointTempo: number;
+}
+/**
+ * This sequencer dispatches midi events to the synthesizer based on the current
+ * synthesize position. The sequencer does not consider the playback speed.
+ * @internal
+ */
+export declare class MidiFileSequencer {
+    private _synthesizer;
+    private _currentState;
+    private _mainState;
+    private _oneTimeState;
+    private _countInState;
+    get isPlayingMain(): boolean;
+    get isPlayingOneTimeMidi(): boolean;
+    get isPlayingCountIn(): boolean;
+    constructor(synthesizer: IAudioSampleSynthesizer);
+    get mainPlaybackRange(): PlaybackRange | null;
+    set mainPlaybackRange(value: PlaybackRange | null);
+    isLooping: boolean;
+    get currentTime(): number;
+    /**
+     * Gets the duration of the song in ticks.
+     */
+    get currentEndTick(): number;
+    get currentEndTime(): number;
+    get currentTempo(): number;
+    get modifiedTempo(): number;
+    get syncPointTempo(): number;
+    get currentSyncPoints(): BackingTrackSyncPoint[];
+    /**
+     * Gets or sets the playback speed.
+     */
+    playbackSpeed: number;
+    mainSeek(timePosition: number): void;
+    private _mainSilentProcess;
+    loadOneTimeMidi(midiFile: MidiFile): void;
+    instrumentPrograms: Set<number>;
+    percussionKeys: Set<number>;
+    loadMidi(midiFile: MidiFile): void;
+    createStateFromFile(midiFile: MidiFile): MidiSequencerState;
+    fillMidiEventQueue(): boolean;
+    fillMidiEventQueueToEndTime(endTime: number): boolean;
+    private _fillMidiEventQueueLimited;
+    mainTickPositionToTimePosition(tickPosition: number): number;
+    mainUpdateSyncPoints(syncPoints: BackingTrackSyncPoint[]): void;
+    currentTimePositionToTickPosition(timePosition: number): number;
+    currentUpdateCurrentTempo(timePosition: number): void;
+    private _updateCurrentTempo;
+    currentUpdateSyncPoints(timePosition: number): void;
+    private _updateSyncPoints;
+    mainTimePositionFromBackingTrack(timePosition: number, backingTrackLength: number): number;
+    mainTimePositionToBackingTrack(timePosition: number, backingTrackLength: number): number;
+    private _tickPositionToTimePositionWithSpeed;
+    private get _internalEndTime();
+    get isFinished(): boolean;
+    stop(): void;
+    resetOneTimeMidi(): void;
+    resetCountIn(): void;
+    startCountIn(): void;
+    generateCountInMidi(): void;
+}
+export {};

package/dist/types/alphatab/src/synth/PlaybackRange.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents a range of the song that should be played.
+ * @public
+ */
+export declare class PlaybackRange {
+    /**
+     * The position in midi ticks from where the song should start.
+     */
+    startTick: number;
+    /**
+     * The position in midi ticks to where the song should be played.
+     */
+    endTick: number;
+}

package/dist/types/alphatab/src/synth/PlaybackRangeChangedEventArgs.d.ts

@@ -0,0 +1,16 @@
+import type { PlaybackRange } from "./PlaybackRange";
+/**
+ * Represents the info when the playback range changed.
+ * @public
+ */
+export declare class PlaybackRangeChangedEventArgs {
+    /**
+     * The new playback range.
+     */
+    readonly playbackRange: PlaybackRange | null;
+    /**
+     * Initializes a new instance of the {@link PlaybackRangeChangedEventArgs} class.
+     * @param range The range.
+     */
+    constructor(playbackRange: PlaybackRange | null);
+}

package/dist/types/alphatab/src/synth/PlayerState.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lists the different states of the player
+ * @public
+ */
+export declare enum PlayerState {
+    /**
+     * Player is paused
+     */
+    Paused = 0,
+    /**
+     * Player is playing
+     */
+    Playing = 1
+}

package/dist/types/alphatab/src/synth/PlayerStateChangedEventArgs.d.ts

@@ -0,0 +1,21 @@
+import type { PlayerState } from "./PlayerState";
+/**
+ * Represents the info when the player state changes.
+ * @public
+ */
+export declare class PlayerStateChangedEventArgs {
+    /**
+     * The new state of the player.
+     */
+    readonly state: PlayerState;
+    /**
+     * Gets a value indicating whether the playback was stopped or only paused.
+     * @returns true if the playback was stopped, false if the playback was started or paused
+     */
+    readonly stopped: boolean;
+    /**
+     * Initializes a new instance of the {@link PlayerStateChangedEventArgs} class.
+     * @param state The state.
+     */
+    constructor(state: PlayerState, stopped: boolean);
+}

package/dist/types/alphatab/src/synth/PositionChangedEventArgs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Represents the info when the time in the synthesizer changes.
+ * @public
+ */
+export declare class PositionChangedEventArgs {
+    /**
+     * The current time position within the song in milliseconds.
+     */
+    readonly currentTime: number;
+    /**
+     * The total length of the song in milliseconds.
+     */
+    readonly endTime: number;
+    /**
+     * The current time position within the song in midi ticks.
+     */
+    readonly currentTick: number;
+    /**
+     * The total length of the song in midi ticks.
+     */
+    readonly endTick: number;
+    /**
+     * Whether the position changed because of time seeking.
+     * @since 1.2.0
+     */
+    isSeek: boolean;
+    /**
+     * The original tempo in which alphaTab internally would be playing right now.
+     */
+    originalTempo: number;
+    /**
+     * The modified tempo in which the actual playback is happening (e.g. due to playback speed or external audio synchronization)
+     */
+    modifiedTempo: number;
+    /**
+     * Initializes a new instance of the {@link PositionChangedEventArgs} class.
+     * @param currentTime The current time.
+     * @param endTime The end time.
+     * @param currentTick The current tick.
+     * @param endTick The end tick.
+     * @param isSeek Whether the time was seeked.
+     */
+    constructor(currentTime: number, endTime: number, currentTick: number, endTick: number, isSeek: boolean, originalTempo: number, modifiedTempo: number);
+}

package/dist/types/alphatab/src/synth/SynthConstants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @internal
+ */
+export declare class SynthConstants {
+    static readonly DefaultChannelCount: number;
+    static readonly MetronomeChannel: number;
+    static readonly MetronomeKey: number;
+    static readonly AudioChannels: number;
+    static readonly MinVolume: number;
+    static readonly MinProgram: number;
+    static readonly MaxProgram: number;
+    static readonly MinPlaybackSpeed: number;
+    static readonly MaxPlaybackSpeed: number;
+    static readonly PercussionChannel: number;
+    static readonly PercussionBank: number;
+    /**
+     * The Midi Pitch bend message is a 15-bit value
+     */
+    static readonly MaxPitchWheel: number;
+    /**
+     * The Midi 2.0 Pitch bend message is a 32-bit value
+     */
+    static readonly MaxPitchWheel20: number;
+    /**
+     * The pitch wheel value for no pitch change at all.
+     */
+    static readonly DefaultPitchWheel: number;
+    static readonly MicroBufferCount: number;
+    static readonly MicroBufferSize: number;
+}

package/dist/types/alphatab/src/synth/SynthHelper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ */
+export declare class SynthHelper {
+    static timecents2Secs(timecents: number): number;
+    static decibelsToGain(db: number): number;
+    static gainToDecibels(gain: number): number;
+    static cents2Hertz(cents: number): number;
+}

package/dist/types/alphatab/src/synth/_barrel.d.ts

@@ -0,0 +1,19 @@
+export { AlphaSynthBase, AlphaSynth, type IAlphaSynthAudioExporter } from "./AlphaSynth";
+export { CircularSampleBuffer } from "./ds/CircularSampleBuffer";
+export { PlaybackRange } from "./PlaybackRange";
+export type { ISynthOutput, ISynthOutputDevice } from "./ISynthOutput";
+export type { IBackingTrackSynthOutput } from "./BackingTrackPlayer";
+export { type IAlphaSynth, BackingTrackSyncPoint } from "./IAlphaSynth";
+export { PlayerState } from "./PlayerState";
+export { PlayerStateChangedEventArgs } from "./PlayerStateChangedEventArgs";
+export { PlaybackRangeChangedEventArgs } from "./PlaybackRangeChangedEventArgs";
+export { PositionChangedEventArgs } from "./PositionChangedEventArgs";
+export { MidiEventsPlayedEventArgs } from "./MidiEventsPlayedEventArgs";
+export { ActiveBeatsChangedEventArgs } from "./ActiveBeatsChangedEventArgs";
+export { AlphaSynthWebWorkerApi } from "./../platform/javascript/AlphaSynthWebWorkerApi";
+export { AlphaSynthWebAudioOutputBase } from "./../platform/javascript/AlphaSynthWebAudioOutputBase";
+export { AlphaSynthScriptProcessorOutput } from "./../platform/javascript/AlphaSynthScriptProcessorOutput";
+export { AlphaSynthAudioWorkletOutput } from "./../platform/javascript/AlphaSynthAudioWorkletOutput";
+export type { IAudioElementBackingTrackSynthOutput } from "./../platform/javascript/AudioElementBackingTrackSynthOutput";
+export type { IExternalMediaHandler, IExternalMediaSynthOutput } from "./ExternalMediaPlayer";
+export { type IAudioExporter, type IAudioExporterWorker, AudioExportChunk, AudioExportOptions } from "./IAudioExporter";

package/dist/types/alphatab/src/synth/ds/CircularSampleBuffer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Represents a fixed size circular sample buffer that can be written to and read from.
+ * @internal
+ */
+export declare class CircularSampleBuffer {
+    private _buffer;
+    private _writePosition;
+    private _readPosition;
+    /**
+     * Gets the number of samples written to the buffer.
+     */
+    count: number;
+    /**
+     * Initializes a new instance of the {@link CircularSampleBuffer} class.
+     * @param size The size.
+     */
+    constructor(size: number);
+    /**
+     * Clears all samples written to this buffer.
+     */
+    clear(): void;
+    /**
+     * Writes the given samples to this buffer.
+     * @param data The sample array to read from.
+     * @param offset
+     * @param count
+     * @returns
+     */
+    write(data: Float32Array, offset: number, count: number): number;
+    /**
+     * Reads the requested amount of samples from the buffer.
+     * @param data The sample array to store the read elements.
+     * @param offset The offset within the destination buffer to put the items at.
+     * @param count The number of items to read from this buffer.
+     * @returns The number of items actually read from the buffer.
+     */
+    read(data: Float32Array, offset: number, count: number): number;
+}

package/dist/types/alphatab/src/synth/ds/Queue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @internal
+ */
+export declare class Queue<T extends object> {
+    private _head?;
+    private _tail?;
+    get isEmpty(): boolean;
+    clear(): void;
+    enqueue(item: T): void;
+    enqueueFront(item: T): void;
+    peek(): T | undefined;
+    dequeue(): T | undefined;
+}

package/dist/types/alphatab/src/synth/soundfont/Hydra.d.ts

@@ -0,0 +1,133 @@
+import type { IReadable } from "./../../io/IReadable";
+/**
+ * @internal
+ */
+export declare class Hydra {
+    phdrs: HydraPhdr[];
+    pbags: HydraPbag[];
+    pmods: HydraPmod[];
+    pgens: HydraPgen[];
+    insts: HydraInst[];
+    ibags: HydraIbag[];
+    imods: HydraImod[];
+    igens: HydraIgen[];
+    sHdrs: HydraShdr[];
+    sampleData: Uint8Array;
+    private _sampleCache;
+    decodeSamples(startByte: number, endByte: number, decompressVorbis: boolean): Float32Array;
+    load(readable: IReadable): void;
+}
+/**
+ * @internal
+ */
+export declare class HydraIbag {
+    static readonly SizeInFile: number;
+    instGenNdx: number;
+    instModNdx: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraImod {
+    static readonly SizeInFile: number;
+    modSrcOper: number;
+    modDestOper: number;
+    modAmount: number;
+    modAmtSrcOper: number;
+    modTransOper: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraIgen {
+    static readonly SizeInFile: number;
+    genOper: number;
+    genAmount: HydraGenAmount;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraInst {
+    static readonly SizeInFile: number;
+    instName: string;
+    instBagNdx: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraPbag {
+    static readonly SizeInFile: number;
+    genNdx: number;
+    modNdx: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraPgen {
+    static readonly SizeInFile: number;
+    static readonly GenInstrument: number;
+    static readonly GenKeyRange: number;
+    static readonly GenVelRange: number;
+    static readonly GenSampleId: number;
+    genOper: number;
+    genAmount: HydraGenAmount;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraPhdr {
+    static readonly SizeInFile: number;
+    presetName: string;
+    preset: number;
+    bank: number;
+    presetBagNdx: number;
+    library: number;
+    genre: number;
+    morphology: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraPmod {
+    static readonly SizeInFile: number;
+    modSrcOper: number;
+    modDestOper: number;
+    modAmount: number;
+    modAmtSrcOper: number;
+    modTransOper: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraShdr {
+    static readonly SizeInFile: number;
+    sampleName: string;
+    start: number;
+    end: number;
+    startLoop: number;
+    endLoop: number;
+    sampleRate: number;
+    originalPitch: number;
+    pitchCorrection: number;
+    sampleLink: number;
+    sampleType: number;
+    constructor(reader: IReadable);
+}
+/**
+ * @internal
+ */
+export declare class HydraGenAmount {
+    wordAmount: number;
+    get shortAmount(): number;
+    get lowByteAmount(): number;
+    get highByteAmount(): number;
+    constructor(reader: IReadable);
+}

package/dist/types/alphatab/src/synth/soundfont/RiffChunk.d.ts

@@ -0,0 +1,10 @@
+import type { IReadable } from "./../../io/IReadable";
+/**
+ * @internal
+ */
+export declare class RiffChunk {
+    static readonly HeaderSize: number;
+    id: string;
+    size: number;
+    static load(parent: RiffChunk | null, chunk: RiffChunk, stream: IReadable): boolean;
+}

package/dist/types/alphatab/src/synth/synthesis/Channel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @internal
+ */
+export declare class Channel {
+    presetIndex: number;
+    bank: number;
+    pitchWheel: number;
+    perNotePitchWheel: Map<number, number>;
+    midiPan: number;
+    midiVolume: number;
+    midiExpression: number;
+    midiRpn: number;
+    midiData: number;
+    panOffset: number;
+    gainDb: number;
+    pitchRange: number;
+    tuning: number;
+    mixVolume: number;
+    mute: boolean;
+    solo: boolean;
+}

package/dist/types/alphatab/src/synth/synthesis/Channels.d.ts

@@ -0,0 +1,11 @@
+import type { Channel } from "./Channel";
+import type { TinySoundFont } from "./TinySoundFont";
+import type { Voice } from "./Voice";
+/**
+ * @internal
+ */
+export declare class Channels {
+    activeChannel: number;
+    channelList: Channel[];
+    setupVoice(tinySoundFont: TinySoundFont, voice: Voice): void;
+}

package/dist/types/alphatab/src/synth/synthesis/Envelope.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @internal
+ */
+export declare class Envelope {
+    delay: number;
+    attack: number;
+    hold: number;
+    decay: number;
+    sustain: number;
+    release: number;
+    keynumToHold: number;
+    keynumToDecay: number;
+    constructor(other?: Envelope);
+    clear(): void;
+    envToSecs(sustainIsGain: boolean): void;
+}

package/dist/types/alphatab/src/synth/synthesis/LoopMode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export declare enum LoopMode {
+    None = 0,
+    Continuous = 1,
+    Sustain = 2
+}

package/dist/types/alphatab/src/synth/synthesis/OutputMode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Supported output modes by the render methods
+ * @internal
+ */
+export declare enum OutputMode {
+    /**
+     * Two channels with single left/right samples one after another
+     */
+    StereoInterleaved = 0,
+    /**
+     * Two channels with all samples for the left channel first then right
+     */
+    StereoUnweaved = 1,
+    /**
+     * A single channel (stereo instruments are mixed into center)
+     */
+    Mono = 2
+}

package/dist/types/alphatab/src/synth/synthesis/Preset.d.ts

@@ -0,0 +1,10 @@
+import type { Region } from "./Region";
+/**
+ * @internal
+ */
+export declare class Preset {
+    name: string;
+    presetNumber: number;
+    bank: number;
+    regions: Region[] | null;
+}