speechrecorderng 3.0.0 → 3.3.0

package/lib/audio/array_audio_buffer.d.ts

@@ -1,15 +1,31 @@
-export declare class ArrayAudioBuffer {
+import { BasicAudioSource, RandomAccessAudioStream } from "./audio_data_holder";
+import { AsyncFloat32ArrayInputStream, Float32ArrayInputStream } from "../io/stream";
+import { Observable } from "rxjs";
+export declare class ArrayAudioBuffer extends BasicAudioSource {
     private _channelCount;
     private _sampleRate;
     private _data;
     private _chunkCount;
     private _frameLen;
+    private _duration;
+    private _sealed;
     constructor(_channelCount: number, _sampleRate: number, _data: Array<Array<Float32Array>>);
+    private updateFrameLen;
+    seal(): void;
+    sealed(): boolean;
     static fromAudioBuffer(audioBuffer: AudioBuffer, chunkFrameSize?: number): ArrayAudioBuffer;
+    appendAudioBuffer(audioBuffer: AudioBuffer): void;
     get channelCount(): number;
     frames(framePos: number, frameLen: number, bufs: Float32Array[]): number;
     get sampleRate(): number;
     get frameLen(): number;
     get chunkCount(): number;
     get data(): Array<Array<Float32Array>>;
+    asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    audioInputStream(): Float32ArrayInputStream | null;
+    get duration(): number;
+    get numberOfChannels(): number;
+    releaseAudioData(): Observable<void>;
+    sampleCounts(): number;
+    randomAccessAudioStream(): RandomAccessAudioStream;
 }

package/lib/audio/array_audio_buffer_random_access_stream.d.ts

@@ -0,0 +1,9 @@
+import { ArrayAudioBuffer } from "./array_audio_buffer";
+import { RandomAccessAudioStream } from "./audio_data_holder";
+import { Observable } from "rxjs";
+export declare class ArrayAudioBufferRandomAccessStream implements RandomAccessAudioStream {
+    private _arrayBuffer;
+    constructor(_arrayBuffer: ArrayAudioBuffer);
+    close(): void;
+    framesObs(framePos: number, frameLen: number, bufs: Float32Array[]): Observable<number>;
+}

package/lib/audio/audio_data_holder.d.ts

@@ -1,23 +1,78 @@
-import { ArrayAudioBuffer } from "./array_audio_buffer";
-import { Float32ArrayInputStream } from "../io/stream";
+import { AsyncFloat32ArrayInputStream, Float32ArrayInputStream } from "../io/stream";
+import { Observable } from "rxjs";
+export interface AudioSource {
+    get duration(): number;
+    get sampleRate(): number;
+    get numberOfChannels(): number;
+    get frameLen(): number;
+    sampleCounts(): number;
+    audioInputStream(): Float32ArrayInputStream | null;
+    asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    randomAccessAudioStream(): RandomAccessAudioStream;
+    releaseAudioData(): Observable<void>;
+    addOnReadyListener(onReady: (() => void) | null): void;
+    removeOnReadyListener(onReady: (() => void) | null): void;
+    ready(): void;
+}
+export declare abstract class BasicAudioSource implements AudioSource {
+    protected _ready: boolean;
+    protected onReadyListeners: Array<(() => void)>;
+    addOnReadyListener(onReady: (() => void)): void;
+    removeOnReadyListener(onReady: (() => void)): void;
+    ready(): void;
+    abstract asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    abstract audioInputStream(): Float32ArrayInputStream | null;
+    abstract get duration(): number;
+    abstract get frameLen(): number;
+    abstract get numberOfChannels(): number;
+    abstract randomAccessAudioStream(): RandomAccessAudioStream;
+    abstract releaseAudioData(): Observable<void>;
+    abstract sampleCounts(): number;
+    abstract get sampleRate(): number;
+}
+export declare class AudioBufferSource extends BasicAudioSource {
+    private _audioBuffer;
+    private readonly _duration;
+    constructor(_audioBuffer: AudioBuffer);
+    get audioBuffer(): AudioBuffer;
+    get duration(): number;
+    get sampleRate(): number;
+    get numberOfChannels(): number;
+    get frameLen(): number;
+    sampleCounts(): number;
+    audioInputStream(): Float32ArrayInputStream | null;
+    asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    releaseAudioData(): Observable<void>;
+    randomAccessAudioStream(): RandomAccessAudioStream;
+}
+export interface RandomAccessAudioStream {
+    framesObs(framePos: number, frameLen: number, bufs: Float32Array[]): Observable<number>;
+    close(): void;
+}
 export declare class AudioDataHolder {
-    private _buffer;
-    private _arrayBuffer;
+    private _audioSource;
+    get audioSource(): AudioSource | null;
     get duration(): number;
-    private _numberOfChannels;
-    private _sampleRate;
-    private _frameLen;
-    private _duration;
-    private static readonly ONE_OF_MUST_BE_SET_ERR_MSG;
-    constructor(_buffer: AudioBuffer | null, _arrayBuffer?: ArrayAudioBuffer | null);
+    private readonly _numberOfChannels;
+    private readonly _sampleRate;
+    private readonly _frameLen;
+    private readonly _duration;
+    constructor(_audioSource: AudioSource | null);
+    addOnReadyListener(onReady: (() => void) | null): void;
     get sampleRate(): number;
     get numberOfChannels(): number;
     get frameLen(): number;
     sampleCounts(): number;
-    frames(framePos: number, frameLen: number, bufs: Float32Array[]): number;
-    audioInputStream(): Float32ArrayInputStream;
-    get buffer(): AudioBuffer | null;
-    get arrayBuffer(): ArrayAudioBuffer | null;
+    randomAccessAudioStream(): RandomAccessAudioStream;
+    audioInputStream(): Float32ArrayInputStream | null;
+    asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    releaseAudioData(): Observable<void>;
+}
+export declare class RandomAccessAudioBufferStream implements RandomAccessAudioStream {
+    private _buffer;
+    constructor(_buffer: AudioBuffer);
+    close(): void;
+    framesObs(framePos: number, frameLen: number, bufs: Float32Array[]): Observable<number>;
 }
 export declare class AudioBufferInputStream implements Float32ArrayInputStream {
     private audioBuffer;

package/lib/audio/audio_display.d.ts

@@ -34,5 +34,5 @@ export declare class AudioDisplay implements OnInit, AfterViewInit {
     set playFramePosition(playFramePosition: number);
     error(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AudioDisplay, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplay, "app-audiodisplay", never, { "playStartAction": "playStartAction"; "playStopAction": "playStopAction"; "playSelectionAction": "playSelectionAction"; "autoPlayOnSelectToggleAction": "autoPlayOnSelectToggleAction"; "audioData": "audioData"; "audioClip": "audioClip"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplay, "app-audiodisplay", never, { "playStartAction": "playStartAction"; "playStopAction": "playStopAction"; "playSelectionAction": "playSelectionAction"; "autoPlayOnSelectToggleAction": "autoPlayOnSelectToggleAction"; "audioData": "audioData"; "audioClip": "audioClip"; }, {}, never, never, false>;
 }

package/lib/audio/audio_player.d.ts

@@ -1,11 +1,11 @@
-import { ChangeDetectorRef, AfterViewInit, AfterContentInit, OnInit, AfterContentChecked, AfterViewChecked, ElementRef } from '@angular/core';
+import { ChangeDetectorRef, AfterViewInit, OnInit, ElementRef } from '@angular/core';
 import { AudioClip } from './persistor';
 import { AudioPlayer, AudioPlayerListener, AudioPlayerEvent } from './playback/player';
 import { ActivatedRoute } from "@angular/router";
 import { Action } from "../action/action";
 import { AudioDataHolder } from "./audio_data_holder";
 import * as i0 from "@angular/core";
-export declare class AudioDisplayPlayer implements AudioPlayerListener, OnInit, AfterContentInit, AfterContentChecked, AfterViewInit, AfterViewChecked {
+export declare class AudioDisplayPlayer implements AudioPlayerListener, OnInit, AfterViewInit {
     protected route: ActivatedRoute;
     protected ref: ChangeDetectorRef;
     protected eRef: ElementRef;
@@ -29,11 +29,7 @@ export declare class AudioDisplayPlayer implements AudioPlayerListener, OnInit,
     private audioDisplayScrollPane;
     constructor(route: ActivatedRoute, ref: ChangeDetectorRef, eRef: ElementRef);
     ngOnInit(): void;
-    ngAfterContentInit(): void;
-    ngAfterContentChecked(): void;
     ngAfterViewInit(): void;
-    ngAfterViewChecked(): void;
-    init(): void;
     layout(): void;
     get audioUrl(): string | null;
     set audioUrl(value: string | null);
@@ -48,5 +44,5 @@ export declare class AudioDisplayPlayer implements AudioPlayerListener, OnInit,
     audioPlayerUpdate(e: AudioPlayerEvent): void;
     error(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AudioDisplayPlayer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplayPlayer, "app-audiodisplayplayer", never, { "playStartAction": "playStartAction"; "playStopAction": "playStopAction"; "playSelectionAction": "playSelectionAction"; "autoPlayOnSelectToggleAction": "autoPlayOnSelectToggleAction"; "audioData": "audioData"; "audioClip": "audioClip"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplayPlayer, "app-audiodisplayplayer", never, { "playStartAction": "playStartAction"; "playStopAction": "playStopAction"; "playSelectionAction": "playSelectionAction"; "autoPlayOnSelectToggleAction": "autoPlayOnSelectToggleAction"; "audioData": "audioData"; "audioClip": "audioClip"; }, {}, never, never, false>;
 }

package/lib/audio/capture/capture.d.ts

@@ -1,6 +1,7 @@
 import { SequenceAudioFloat32OutStream } from "../io/stream";
-import { AutoGainControlConfig } from "../../speechrecorder/project/project";
+import { AudioStorageType, AutoGainControlConfig } from "../../speechrecorder/project/project";
 import { ArrayAudioBuffer } from "../array_audio_buffer";
+import { IndexedDbAudioBuffer, PersistentAudioStorageTarget } from "../inddb_audio_buffer";
 export declare const CHROME_ACTIVATE_ECHO_CANCELLATION_WITH_AGC = false;
 export interface AudioCaptureListener {
     opened(): void;
@@ -10,16 +11,27 @@ export interface AudioCaptureListener {
     error(msg?: string, advice?: string): void;
 }
 export declare class AudioCapture {
+    get maxAutoNetMemStoreSamples(): number;
+    set maxAutoNetMemStoreSamples(value: number);
+    set recUUID(value: string | null);
+    get recUUID(): string | null;
+    get audioStorageType(): AudioStorageType;
+    set audioStorageType(value: AudioStorageType);
+    get persistentAudioStorageTarget(): PersistentAudioStorageTarget | null;
+    set persistentAudioStorageTarget(value: PersistentAudioStorageTarget | null);
     get opened(): boolean;
     static BUFFER_SIZE: number;
+    private static readonly DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES;
+    private _maxAutoNetMemStoreSamples;
     context: AudioContext;
     stream: MediaStream;
     channelCount: number;
+    private _recUUID;
     mediaStream: any;
     agcStatus: boolean | null;
     bufferingNode: AudioNode | null;
     listener: AudioCaptureListener;
-    data: Array<Array<Float32Array>>;
+    data: Array<Array<Float32Array>> | null;
     currentSampleRate: number;
     n: Navigator;
     audioOutStream: SequenceAudioFloat32OutStream | null;
@@ -27,6 +39,11 @@ export declare class AudioCapture {
     private _opened;
     private capturing;
     framesRecorded: number;
+    private _audioStorageType;
+    private _persistentAudioStorageTarget;
+    private persisted;
+    private persistError;
+    private inddbAudioBuffer;
     constructor(context: AudioContext);
     private initData;
     listDevices(): void;
@@ -36,9 +53,12 @@ export declare class AudioCapture {
     printDevices(l: MediaDeviceInfo[]): void;
     open(channelCount: number, selDeviceId?: ConstrainDOMString | undefined, autoGainControlConfigs?: Array<AutoGainControlConfig> | null | undefined): void;
     _open(channelCount: number, selDeviceId?: ConstrainDOMString | undefined, autoGainControlConfigs?: Array<AutoGainControlConfig> | null | undefined): void;
+    private _start;
     start(): void;
     stop(): void;
+    store(): void;
     close(): void;
-    audioBuffer(): AudioBuffer;
-    audioBufferArray(): ArrayAudioBuffer;
+    audioBuffer(): AudioBuffer | null;
+    audioBufferArray(): ArrayAudioBuffer | null;
+    inddbAudioBufferArray(): IndexedDbAudioBuffer | null;
 }

package/lib/audio/dsp/level_measure.d.ts

@@ -1,5 +1,6 @@
 import { SequenceAudioFloat32OutStream } from "../io/stream";
 import { AudioDataHolder } from "../audio_data_holder";
+import { Observable } from "rxjs";
 export declare const MIN_DB_LEVEL = -40;
 export declare class LevelInfo {
     readonly channelCount: number;
@@ -29,32 +30,10 @@ export interface LevelListener {
     streamFinished(): void;
     reset(): void;
 }
-export interface PeakLevelListener {
-    update(peakLevel: number): void;
-}
-export interface PeakLevelListener {
-    update(levelInfo: LevelInfo, peakLevelInfo: LevelInfo): void;
-    streamFinished(): void;
-    reset(): void;
-}
-export declare class PeakLevelInterceptor implements LevelListener {
-    private levelListener?;
-    get peakDbLvl(): number;
-    get channelCount(): number;
-    set channelCount(value: number);
-    private _channelCount;
-    private _peakDbLvl;
-    constructor(levelListener?: LevelListener | undefined);
-    update(levelInfo: LevelInfo, peakLevelInfo: LevelInfo): void;
-    streamFinished(): void;
-    reset(): void;
-}
 export declare class LevelMeasure {
     private readonly workerURL;
-    private worker;
     constructor();
-    calcBufferLevelInfos(audioDataHolder: AudioDataHolder, bufferTimeLength: number): Promise<LevelInfos>;
-    private terminateWorker;
+    calcBufferLevelInfos(audioDataHolder: AudioDataHolder, bufferTimeLength: number): Observable<LevelInfos>;
     workerFunction(): void;
 }
 export declare class StreamLevelMeasure implements SequenceAudioFloat32OutStream {

package/lib/audio/impl/wavformat.d.ts

@@ -1,5 +1,5 @@
 export declare class WavFileFormat {
-    static RIFF_KEY: string;
-    static WAV_KEY: string;
-    static PCM: number;
+    static readonly RIFF_KEY: string;
+    static readonly WAV_KEY: string;
+    static readonly PCM: number;
 }

package/lib/audio/impl/wavreader.d.ts

@@ -0,0 +1,16 @@
+import { PCMAudioFormat } from '../format';
+export declare class WavReader {
+    private br;
+    private format;
+    private totalLength;
+    private dataChunkLength;
+    constructor(data: ArrayBuffer);
+    private readHeader;
+    readFormat(): PCMAudioFormat | null;
+    private _frameLength;
+    frameLength(): number | null;
+    read(): AudioBuffer | null;
+    private navigateToChunk;
+    private parseFmtChunk;
+    private readData;
+}

package/lib/audio/impl/wavwriter.d.ts

@@ -1,9 +1,6 @@
 export declare class WavWriter {
-    static PCM: number;
-    static DEFAULT_SAMPLE_SIZE_BYTES: number;
+    static readonly DEFAULT_SAMPLE_SIZE_BYTES: number;
     private bw;
-    private format;
-    private dataLength;
     private workerURL;
     constructor();
     workerFunction(): void;

package/lib/audio/inddb_audio_buffer.d.ts

@@ -0,0 +1,68 @@
+import { Observable } from "rxjs";
+import { AsyncFloat32ArrayInputStream, Float32ArrayInputStream } from "../io/stream";
+import { AudioSource, BasicAudioSource, RandomAccessAudioStream } from "./audio_data_holder";
+export declare class PersistentAudioStorageTarget {
+    private _indexedDb;
+    private _storeName;
+    get indexedDb(): IDBDatabase;
+    get storeName(): string;
+    constructor(_indexedDb: IDBDatabase, _storeName: string);
+    transaction(mode?: IDBTransactionMode): IDBTransaction;
+    objectStore(mode?: IDBTransactionMode): IDBObjectStore;
+    deleteAll(): Observable<void>;
+}
+export declare class IndexedDbAudioBuffer extends BasicAudioSource implements AudioSource {
+    private _persistentAudioStorageTarget;
+    private _channelCount;
+    private _sampleRate;
+    private _chunkFrameLen;
+    private _frameLen;
+    private _uuid;
+    get chunkFrameLen(): number;
+    get persistentAudioStorageTarget(): PersistentAudioStorageTarget;
+    get uuid(): string;
+    private _chunkCount;
+    private indDbChkIdx;
+    private _sealed;
+    private _storeError;
+    constructor(_persistentAudioStorageTarget: PersistentAudioStorageTarget, _channelCount: number, _sampleRate: number, _chunkFrameLen: number, _frameLen: number, _uuid: string);
+    get channelCount(): number;
+    sealed(): boolean;
+    seal(): void;
+    private deleteChunk;
+    private deleteAllBufs;
+    get sampleRate(): number;
+    get frameLen(): number;
+    get chunkCount(): number;
+    appendRawAudioData(data: Array<Array<Float32Array>>): Observable<void>;
+    static fromChunkAudioBuffer(persistentAudioStorageTarget: PersistentAudioStorageTarget, audioBuffer: AudioBuffer): Observable<IndexedDbAudioBuffer>;
+    appendChunkAudioBuffer(audioBuffer: AudioBuffer): Observable<void>;
+    releaseAudioData(): Observable<void>;
+    toString(): string;
+    asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    audioInputStream(): Float32ArrayInputStream | null;
+    get duration(): number;
+    get numberOfChannels(): number;
+    sampleCounts(): number;
+    randomAccessAudioStream(): RandomAccessAudioStream;
+}
+export declare class IndexedDbRandomAccessStream implements RandomAccessAudioStream {
+    private _inddbAb;
+    private _currCi;
+    private _ccCache;
+    constructor(_inddbAb: IndexedDbAudioBuffer);
+    private chunk;
+    private _fillBufs;
+    private fillBufs;
+    framesObs(framePos: number, frameLen: number, bufs: Float32Array[]): Observable<number>;
+    close(): void;
+}
+export declare class IndexedDbAudioInputStream implements AsyncFloat32ArrayInputStream {
+    private inddbAb;
+    private framePos;
+    private inddbAbStr;
+    constructor(inddbAb: IndexedDbAudioBuffer);
+    close(): void;
+    readObs(buffers: Array<Float32Array>): Observable<number>;
+    skipFrames(n: number): void;
+}

package/lib/audio/net_audio_buffer.d.ts

@@ -0,0 +1,59 @@
+import { Observable } from "rxjs";
+import { AsyncFloat32ArrayInputStream, Float32ArrayInputStream } from "../io/stream";
+import { AudioSource, BasicAudioSource, RandomAccessAudioStream } from "./audio_data_holder";
+import { BasicRecordingService } from "../speechrecorder/recordings/basic_recording.service";
+export declare class NetAudioBuffer extends BasicAudioSource implements AudioSource {
+    protected _audioContext: AudioContext;
+    private _recFileService;
+    private _baseUrl;
+    private _channelCount;
+    private _sampleRate;
+    private _chunkFrameLen;
+    private _frameLen;
+    private _uuid;
+    private _orgFetchChunkFrameLen;
+    get orgFetchChunkFrameLen(): number;
+    get recFileService(): BasicRecordingService;
+    get audioContext(): AudioContext;
+    get baseUrl(): string;
+    get chunkFrameLen(): number;
+    get uuid(): string | null;
+    private _chunkCount;
+    private _sealed;
+    constructor(_audioContext: AudioContext, _recFileService: BasicRecordingService, _baseUrl: string, _channelCount: number, _sampleRate: number, _chunkFrameLen: number, _frameLen: number, _uuid?: string | null, _orgFetchChunkFrameLen?: number);
+    get channelCount(): number;
+    sealed(): boolean;
+    seal(): void;
+    get sampleRate(): number;
+    get frameLen(): number;
+    get chunkCount(): number;
+    releaseAudioData(): Observable<void>;
+    toString(): string;
+    static fromChunkAudioBuffer(aCtx: AudioContext, recordingsService: BasicRecordingService, baseUrl: string, ab: AudioBuffer, frameLen: number, orgFetchChunkFrameLen?: number): NetAudioBuffer;
+    asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+    audioInputStream(): Float32ArrayInputStream | null;
+    get duration(): number;
+    get numberOfChannels(): number;
+    sampleCounts(): number;
+    randomAccessAudioStream(): RandomAccessAudioStream;
+}
+export declare class NetRandomAccessAudioStream implements RandomAccessAudioStream {
+    private _netAb;
+    private _currCi;
+    private _ccCache;
+    constructor(_netAb: NetAudioBuffer);
+    private chunk;
+    private _fillBufs;
+    private fillBufs;
+    framesObs(framePos: number, frameLen: number, bufs: Float32Array[]): Observable<number>;
+    close(): void;
+}
+export declare class NetAudioInputStream implements AsyncFloat32ArrayInputStream {
+    private netAb;
+    private framePos;
+    private netAbStr;
+    constructor(netAb: NetAudioBuffer);
+    close(): void;
+    readObs(buffers: Array<Float32Array>): Observable<number>;
+    skipFrames(n: number): void;
+}

package/lib/audio/persistor.d.ts

@@ -14,16 +14,10 @@ export declare class AudioClip {
     addSelectionObserver(selectionObserver: (audioClip: AudioClip) => void, init?: boolean): void;
     removeSelectionObserver(selectionObserver: (audioClip: AudioClip) => void): void;
 }
-export interface Reader {
-    read(data: Blob): AudioClip;
-}
-export interface Writer {
-    write(audioData: AudioClip): Blob;
-}
 export declare class Selection {
-    private _sampleRate;
-    private _startFrame;
-    private _endFrame;
+    private readonly _sampleRate;
+    private readonly _startFrame;
+    private readonly _endFrame;
     constructor(sampleRate: number, startFrame: number, endFrame: number);
     get sampleRate(): number;
     get endFrame(): number;

package/lib/audio/playback/array_audio_buffer_source_node.d.ts

@@ -1,14 +1,12 @@
 import { ArrayAudioBuffer } from "../array_audio_buffer";
-export declare class ArrayAudioBufferSourceNode extends AudioWorkletNode {
-    static readonly QUANTUM_FRAME_LEN = 128;
-    static readonly DEFAULT_BUFFER_FILL_SECONDS = 10;
+import { AudioSourceNode } from "./audio_source_node";
+export declare class ArrayAudioBufferSourceNode extends AudioSourceNode {
     private _bufferFillSeconds;
     private bufferFillFrames;
     private _arrayAudioBuffer;
     private _audioInputStream;
     private _aisBufs;
     private filledFrames;
-    onended: (() => void) | null;
     constructor(context: AudioContext);
     private fillBuffer;
     get arrayAudioBuffer(): ArrayAudioBuffer | null;
@@ -18,7 +16,3 @@ export declare class ArrayAudioBufferSourceNode extends AudioWorkletNode {
     start(when?: number | undefined, offset?: number | undefined, duration?: number | undefined): void;
     stop(): void;
 }
-export declare class AudioSourceWorkletModuleLoader {
-    private static moduleLoaded;
-    static loadModule(context: AudioContext): Promise<void>;
-}

package/lib/audio/playback/audio_source_node.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class AudioSourceNode extends AudioWorkletNode {
+    static readonly DEFAULT_BUFFER_FILL_SECONDS = 10;
+    static readonly DEFAULT_STREAM_READ_FRAME_LEN = 1024;
+    static readonly QUANTUM_FRAME_LEN = 128;
+    protected _playStartTime: number | null;
+    abstract start(when?: number | undefined, offset?: number | undefined, duration?: number | undefined): void;
+    abstract stop(): void;
+    get playPositionTime(): number | null;
+    onended: (() => void) | null;
+}

package/lib/audio/playback/audio_source_worklet_module_loader.d.ts

@@ -0,0 +1,4 @@
+export declare class AudioSourceWorkletModuleLoader {
+    private static moduleLoaded;
+    static loadModule(context: AudioContext): Promise<void>;
+}

package/lib/audio/playback/inddb_audio_buffer_source_node.d.ts

@@ -0,0 +1,21 @@
+import { IndexedDbAudioBuffer } from "../inddb_audio_buffer";
+import { AudioSourceNode } from "./audio_source_node";
+export declare class IndexedDbAudioBufferSourceNode extends AudioSourceNode {
+    private _bufferFillSeconds;
+    private bufferFillFrames;
+    private _streamReadFrameLen;
+    private _inddbAudioBuffer;
+    private _audioInputStream;
+    private _aisBufs;
+    private _active;
+    private _endOfStream;
+    private filledFrames;
+    constructor(context: AudioContext);
+    private fillBufferObs;
+    get inddbAudioBuffer(): IndexedDbAudioBuffer | null;
+    set inddbAudioBuffer(value: IndexedDbAudioBuffer | null);
+    get bufferFillSeconds(): number;
+    set bufferFillSeconds(value: number);
+    start(when?: number | undefined, offset?: number | undefined, duration?: number | undefined): void;
+    stop(): void;
+}

package/lib/audio/playback/net_audio_buffer_source_node.d.ts

@@ -0,0 +1,27 @@
+import { AudioSourceNode } from "./audio_source_node";
+import { NetAudioBuffer } from "../net_audio_buffer";
+export declare class NetAudioBufferSourceNode extends AudioSourceNode {
+    private _bufferFillSeconds;
+    private bufferFillFrames;
+    private _streamReadFrameLen;
+    private _netAudioBuffer;
+    private _audioInputStream;
+    private _aisBufs;
+    private _active;
+    private stalled;
+    private _endOfStream;
+    private readDataSubscription;
+    private filledFrames;
+    private stalledStartTime;
+    private stalledTime;
+    private stopEndTime;
+    constructor(context: AudioContext);
+    private fillBufferObs;
+    get netAudioBuffer(): NetAudioBuffer | null;
+    set netAudioBuffer(value: NetAudioBuffer | null);
+    get bufferFillSeconds(): number;
+    set bufferFillSeconds(value: number);
+    start(when?: number | undefined, offset?: number | undefined, duration?: number | undefined): void;
+    stop(): void;
+    get playPositionTime(): number | null;
+}

package/lib/audio/playback/player.d.ts

@@ -1,18 +1,19 @@
 import { Action } from '../../action/action';
 import { AudioClip } from '../persistor';
-import { ArrayAudioBuffer } from "../array_audio_buffer";
-import { ArrayAudioBufferSourceNode } from "./array_audio_buffer_source_node";
+import { AudioSourceNode } from "./audio_source_node";
+import { AudioSource } from "../audio_data_holder";
 export declare enum EventType {
     CLOSED = 0,
     READY = 1,
     STARTED = 2,
     POS_UPDATE = 3,
     STOPPED = 4,
-    ENDED = 5
+    ENDED = 5,
+    ERROR = 6
 }
 export declare class AudioPlayerEvent {
-    private _type;
-    private _timePosition;
+    private readonly _type;
+    private readonly _timePosition;
     constructor(type: EventType, timePosition?: number);
     get type(): EventType;
     get timePosition(): number | undefined;
@@ -24,18 +25,18 @@ export declare class AudioPlayer {
     get autoPlayOnSelectToggleAction(): Action<boolean>;
     static DEFAULT_BUFSIZE: number;
     private running;
-    private _startAction;
-    private _startSelectionAction;
-    private _autoPlayOnSelectToggleAction;
-    private _stopAction;
+    private readonly _startAction;
+    private readonly _startSelectionAction;
+    private readonly _autoPlayOnSelectToggleAction;
+    private readonly _stopAction;
     bufSize: number;
     context: AudioContext;
+    ready: boolean;
     listener: AudioPlayerListener;
     _audioClip: AudioClip | null;
-    _audioBuffer: AudioBuffer | null;
-    _arrayAudioBuffer: ArrayAudioBuffer | null;
+    private _audioSource;
     sourceBufferNode: AudioBufferSourceNode | null;
-    sourceAudioWorkletNode: ArrayAudioBufferSourceNode | null;
+    sourceAudioWorkletNode: AudioSourceNode | null;
     buffPos: number;
     private zeroBufCnt;
     n: any;
@@ -47,12 +48,14 @@ export declare class AudioPlayer {
     get startSelectionAction(): Action<void>;
     get stopAction(): Action<void>;
     set audioClip(audioClip: AudioClip | null);
-    set audioBuffer(audioBuffer: AudioBuffer | null);
-    get audioBuffer(): AudioBuffer | null;
-    set arrayAudioBuffer(arrayAudioBuffer: ArrayAudioBuffer | null);
-    get arrayAudioBuffer(): ArrayAudioBuffer | null;
+    get audioSource(): AudioSource | null;
+    set audioSource(value: AudioSource | null);
+    private _loadSourceWorkletAndInitStart;
+    private _startAudioSourceWorkletNode;
     start(): void;
+    updateStartActions(): void;
     startSelectionDisabled(): boolean;
+    private _start;
     startSelected(): void;
     stop(): void;
     onended(): void;