speechrecorderng 3.0.0 → 3.3.0

package/esm2020/lib/audio/playback/inddb_audio_buffer_source_node.mjs

@@ -0,0 +1,167 @@
+import { AsyncEditFloat32ArrayInputStream } from "../../io/stream";
+import { IndexedDbAudioInputStream } from "../inddb_audio_buffer";
+import { ArrayAudioBufferSourceNode } from "./array_audio_buffer_source_node";
+import { EMPTY, expand, Observable } from "rxjs";
+import { AudioSourceNode } from "./audio_source_node";
+export class IndexedDbAudioBufferSourceNode extends AudioSourceNode {
+    constructor(context) {
+        super(context, 'audio-source-worklet');
+        this._bufferFillSeconds = AudioSourceNode.DEFAULT_BUFFER_FILL_SECONDS;
+        this.bufferFillFrames = 0;
+        this._streamReadFrameLen = AudioSourceNode.DEFAULT_STREAM_READ_FRAME_LEN * 8; // Much overhead fetching small buffers from indexed db, use larger buffer (8192).
+        this._inddbAudioBuffer = null;
+        this._audioInputStream = null;
+        this._aisBufs = null;
+        this._active = false;
+        this._endOfStream = false;
+        this.filledFrames = 0;
+        this.channelCountMode = 'explicit';
+        this.port.onmessage = (msgEv) => {
+            if (msgEv.data) {
+                let evType = msgEv.data.eventType;
+                if (evType) {
+                    if ('bufferNotification' === evType) {
+                        this.filledFrames = msgEv.data.filledFrames;
+                        if (!this._endOfStream) {
+                            this.fillBufferObs().subscribe();
+                        }
+                    }
+                    else if ('ended' === evType) {
+                        //console.debug("Inddb audio source ended playback.");
+                        let drainTime = 0;
+                        if (this._inddbAudioBuffer?.sampleRate) {
+                            drainTime = ArrayAudioBufferSourceNode.QUANTUM_FRAME_LEN / this._inddbAudioBuffer.sampleRate;
+                        }
+                        //let dstAny:any=this.context.destination;
+                        //console.debug('Destination node tail-time: '+dstAny['tail-time']);
+                        window.setTimeout(() => {
+                            this.onended?.call(this);
+                        }, drainTime * 1000);
+                    }
+                }
+            }
+        };
+    }
+    fillBufferObs(frameOffset) {
+        let obs = new Observable(subscriber => {
+            if (frameOffset) {
+                subscriber.error(new Error("Starting playback from position not equal zero not supported yet."));
+            }
+            else {
+                let filled = this.filledFrames;
+                let bufLen = 0;
+                if (this._audioInputStream && this._aisBufs) {
+                    this._audioInputStream.readObs(this._aisBufs).pipe(expand((read) => {
+                        if (read && this._aisBufs) {
+                            let trBuffers = new Array(this.channelCount);
+                            for (let ch = 0; ch < this.channelCount; ch++) {
+                                let adCh = this._aisBufs[ch];
+                                let adChCopy = new Float32Array(read);
+                                bufLen = adChCopy.length;
+                                if (read === adCh.length) {
+                                    adChCopy.set(adCh);
+                                }
+                                else {
+                                    // Note: slice() does not work here, since it returns a shallow copy.
+                                    for (let i = 0; i < read; i++) {
+                                        adChCopy[i] = adCh[i];
+                                    }
+                                }
+                                trBuffers[ch] = adChCopy.buffer;
+                            }
+                            this.port.postMessage({
+                                cmd: 'data',
+                                chs: this.channelCount,
+                                audioData: trBuffers
+                            }, trBuffers);
+                            filled += read;
+                            //console.debug("IndexedDbAudioBufferSourceNode::fillBufferObs: Sent "+read+" frames to audio source worklet. Filled: "+filled+", to fill: "+this.bufferFillFrames);
+                            if (this._audioInputStream && filled < this.bufferFillFrames) {
+                                //console.debug("IndexedDbAudioBufferSourceNode::fillBufferObs: Next inddb audio input stream readObs");
+                                return this._audioInputStream.readObs(this._aisBufs);
+                            }
+                            else {
+                                //console.debug("Return EMPTY");
+                                return EMPTY;
+                            }
+                        }
+                        else {
+                            //console.debug("IndexedDbAudioBufferSourceNode::fillBufferObs: Return EMPTY (read: "+read+")");
+                            this._endOfStream = true;
+                            this.port.postMessage({
+                                cmd: 'endOfStream'
+                            });
+                            return EMPTY;
+                        }
+                    })).subscribe(subscriber);
+                }
+            }
+        });
+        return obs;
+    }
+    get inddbAudioBuffer() {
+        return this._inddbAudioBuffer;
+    }
+    set inddbAudioBuffer(value) {
+        this._inddbAudioBuffer = value;
+        if (this._inddbAudioBuffer?.channelCount) {
+            this.channelCount = this._inddbAudioBuffer?.channelCount;
+            this.bufferFillFrames = this._inddbAudioBuffer.sampleRate * this._bufferFillSeconds;
+        }
+    }
+    get bufferFillSeconds() {
+        return this._bufferFillSeconds;
+    }
+    set bufferFillSeconds(value) {
+        this._bufferFillSeconds = value;
+    }
+    start(when, offset, duration) {
+        if (when) {
+            throw Error("when parameter currently not supported by IndexedDbAudioBufferSourceNode class");
+        }
+        if (this._inddbAudioBuffer) {
+            let arrAis = new IndexedDbAudioInputStream(this._inddbAudioBuffer);
+            if (offset === undefined && duration === undefined) {
+                this._audioInputStream = arrAis;
+            }
+            else {
+                let offsetFrames = 0;
+                let durationFrames = undefined;
+                if (offset !== undefined) {
+                    offsetFrames = Math.floor(offset * this._inddbAudioBuffer.sampleRate);
+                }
+                if (duration !== undefined) {
+                    durationFrames = Math.floor(duration * this._inddbAudioBuffer.sampleRate);
+                }
+                //console.debug("Create AsyncEditFloat32ArrayInputStream: offsetFrames:"+offsetFrames+", durationFrames:"+durationFrames);
+                this._audioInputStream = new AsyncEditFloat32ArrayInputStream(arrAis, offsetFrames, durationFrames);
+            }
+            let chs = this._inddbAudioBuffer.channelCount;
+            this._aisBufs = new Array(chs);
+            for (let ch = 0; ch < chs; ch++) {
+                this._aisBufs[ch] = new Float32Array(this._streamReadFrameLen);
+            }
+            this.fillBufferObs().subscribe({
+                complete: () => {
+                    //console.debug("IndexedDbAudioBufferSourceNode::start: Async play buffer fill completed. Sending start command to audio worklet.");
+                    if (this._active) {
+                        this.port.postMessage({ cmd: 'start' });
+                        if (offset) {
+                            this._playStartTime = this.context.currentTime - offset;
+                        }
+                        else {
+                            this._playStartTime = this.context.currentTime;
+                        }
+                    }
+                }
+            });
+            this._active = true;
+        }
+    }
+    stop() {
+        this._active = false;
+        this.port.postMessage({ cmd: 'stop' });
+        this.onended?.call(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inddb_audio_buffer_source_node.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/audio/playback/inddb_audio_buffer_source_node.ts"],"names":[],"mappings":"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","sourcesContent":["import {AsyncEditFloat32ArrayInputStream, AsyncFloat32ArrayInputStream} from \"../../io/stream\";\r\nimport {IndexedDbAudioBuffer, IndexedDbAudioInputStream} from \"../inddb_audio_buffer\";\r\nimport {ArrayAudioBufferSourceNode} from \"./array_audio_buffer_source_node\";\r\nimport {EMPTY, expand, map, Observable} from \"rxjs\";\r\nimport {AudioSourceNode} from \"./audio_source_node\";\r\n\r\nexport class IndexedDbAudioBufferSourceNode extends AudioSourceNode {\r\n\r\n  private _bufferFillSeconds = AudioSourceNode.DEFAULT_BUFFER_FILL_SECONDS;\r\n  private bufferFillFrames = 0;\r\n  private _streamReadFrameLen=AudioSourceNode.DEFAULT_STREAM_READ_FRAME_LEN * 8;  // Much overhead fetching small buffers from indexed db, use larger buffer (8192).\r\n  private _inddbAudioBuffer:IndexedDbAudioBuffer|null=null;\r\n  private _audioInputStream:AsyncFloat32ArrayInputStream|null=null;\r\n  private _aisBufs:Float32Array[]|null=null;\r\n  private _active=false;\r\n  private _endOfStream=false;\r\n  private filledFrames = 0;\r\n\r\n  constructor(context: AudioContext) {\r\n\r\n    super(context, 'audio-source-worklet');\r\n    this.channelCountMode = 'explicit';\r\n    this.port.onmessage = (msgEv: MessageEvent) => {\r\n      if (msgEv.data) {\r\n        let evType = msgEv.data.eventType;\r\n        if (evType) {\r\n          if ('bufferNotification' === evType) {\r\n            this.filledFrames = msgEv.data.filledFrames;\r\n            if(!this._endOfStream) {\r\n              this.fillBufferObs().subscribe();\r\n            }\r\n          } else if ('ended' === evType) {\r\n            //console.debug(\"Inddb audio source ended playback.\");\r\n            let drainTime = 0;\r\n            if (this._inddbAudioBuffer?.sampleRate) {\r\n              drainTime = ArrayAudioBufferSourceNode.QUANTUM_FRAME_LEN / this._inddbAudioBuffer.sampleRate;\r\n            }\r\n            //let dstAny:any=this.context.destination;\r\n            //console.debug('Destination node tail-time: '+dstAny['tail-time']);\r\n            window.setTimeout(() => {\r\n              this.onended?.call(this);\r\n            }, drainTime * 1000);\r\n\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private fillBufferObs(frameOffset?:number):Observable<number|null> {\r\n\r\n      let obs = new Observable<number | null>(subscriber => {\r\n        if(frameOffset){\r\n          subscriber.error(new Error(\"Starting playback from position not equal zero not supported yet.\"));\r\n        }else {\r\n          let filled = this.filledFrames;\r\n          let bufLen = 0;\r\n          if (this._audioInputStream && this._aisBufs) {\r\n            this._audioInputStream.readObs(this._aisBufs).pipe(\r\n              expand((read) => {\r\n                  if (read && this._aisBufs) {\r\n                    let trBuffers = new Array<any>(this.channelCount);\r\n                    for (let ch = 0; ch < this.channelCount; ch++) {\r\n                      let adCh = this._aisBufs[ch];\r\n                      let adChCopy = new Float32Array(read);\r\n                      bufLen = adChCopy.length;\r\n                      if(read===adCh.length) {\r\n                        adChCopy.set(adCh);\r\n                      }else{\r\n                        // Note: slice() does not work here, since it returns a shallow copy.\r\n                        for(let i=0;i<read;i++){\r\n                          adChCopy[i]=adCh[i];\r\n                        }\r\n                      }\r\n                      trBuffers[ch] = adChCopy.buffer;\r\n                    }\r\n                    this.port.postMessage({\r\n                      cmd: 'data',\r\n                      chs: this.channelCount,\r\n                      audioData: trBuffers\r\n                    }, trBuffers);\r\n                    filled += read;\r\n                    //console.debug(\"IndexedDbAudioBufferSourceNode::fillBufferObs: Sent \"+read+\" frames to audio source worklet. Filled: \"+filled+\", to fill: \"+this.bufferFillFrames);\r\n                    if (this._audioInputStream && filled < this.bufferFillFrames) {\r\n                      //console.debug(\"IndexedDbAudioBufferSourceNode::fillBufferObs: Next inddb audio input stream readObs\");\r\n                      return this._audioInputStream.readObs(this._aisBufs);\r\n                    } else {\r\n                      //console.debug(\"Return EMPTY\");\r\n                      return EMPTY;\r\n                    }\r\n                  } else {\r\n                    //console.debug(\"IndexedDbAudioBufferSourceNode::fillBufferObs: Return EMPTY (read: \"+read+\")\");\r\n                    this._endOfStream=true;\r\n                    this.port.postMessage({\r\n                      cmd: 'endOfStream'\r\n                    });\r\n                    return EMPTY;\r\n                  }\r\n                }\r\n              )\r\n            ).subscribe(subscriber);\r\n          }\r\n        }\r\n      });\r\n      return obs;\r\n  }\r\n\r\n\r\n  get inddbAudioBuffer(): IndexedDbAudioBuffer | null {\r\n    return this._inddbAudioBuffer\r\n  }\r\n\r\n  set inddbAudioBuffer(value: IndexedDbAudioBuffer | null) {\r\n    this._inddbAudioBuffer = value;\r\n    if (this._inddbAudioBuffer?.channelCount) {\r\n      this.channelCount = this._inddbAudioBuffer?.channelCount;\r\n      this.bufferFillFrames = this._inddbAudioBuffer.sampleRate * this._bufferFillSeconds;\r\n    }\r\n  }\r\n\r\n  get bufferFillSeconds(): number {\r\n    return this._bufferFillSeconds;\r\n  }\r\n\r\n  set bufferFillSeconds(value: number) {\r\n    this._bufferFillSeconds = value;\r\n  }\r\n\r\n  start(when?: number | undefined,offset?: number | undefined,duration?: number | undefined): void {\r\n    if (when) {\r\n      throw Error(\"when parameter currently not supported by IndexedDbAudioBufferSourceNode class\")\r\n    }\r\n\r\n    if (this._inddbAudioBuffer) {\r\n      let arrAis=new IndexedDbAudioInputStream(this._inddbAudioBuffer);\r\n      if(offset===undefined && duration===undefined){\r\n        this._audioInputStream = arrAis;\r\n      }else{\r\n        let offsetFrames=0;\r\n        let durationFrames=undefined;\r\n        if(offset!==undefined) {\r\n          offsetFrames=Math.floor(offset * this._inddbAudioBuffer.sampleRate);\r\n        }\r\n        if(duration!==undefined){\r\n          durationFrames=Math.floor(duration * this._inddbAudioBuffer.sampleRate);\r\n        }\r\n        //console.debug(\"Create AsyncEditFloat32ArrayInputStream: offsetFrames:\"+offsetFrames+\", durationFrames:\"+durationFrames);\r\n        this._audioInputStream=new AsyncEditFloat32ArrayInputStream(arrAis,offsetFrames,durationFrames);\r\n      }\r\n\r\n      let chs=this._inddbAudioBuffer.channelCount;\r\n      this._aisBufs=new Array<Float32Array>(chs);\r\n      for(let ch=0;ch<chs;ch++){\r\n        this._aisBufs[ch]=new Float32Array(this._streamReadFrameLen);\r\n      }\r\n\r\n      this.fillBufferObs().subscribe({\r\n        complete: ()=>{\r\n          //console.debug(\"IndexedDbAudioBufferSourceNode::start: Async play buffer fill completed. Sending start command to audio worklet.\");\r\n          if(this._active) {\r\n            this.port.postMessage({cmd: 'start'});\r\n            if (offset) {\r\n              this._playStartTime = this.context.currentTime - offset;\r\n            } else {\r\n              this._playStartTime = this.context.currentTime;\r\n            }\r\n          }\r\n        }\r\n      })\r\n    this._active=true;\r\n    }\r\n  }\r\n\r\n  stop() {\r\n    this._active=false;\r\n    this.port.postMessage({cmd: 'stop'});\r\n    this.onended?.call(this);\r\n  }\r\n\r\n}\r\n\r\n"]}

package/esm2020/lib/audio/playback/net_audio_buffer_source_node.mjs

@@ -0,0 +1,218 @@
+import { AsyncEditFloat32ArrayInputStream } from "../../io/stream";
+import { ArrayAudioBufferSourceNode } from "./array_audio_buffer_source_node";
+import { EMPTY, expand, Observable } from "rxjs";
+import { AudioSourceNode } from "./audio_source_node";
+import { NetAudioInputStream } from "../net_audio_buffer";
+export class NetAudioBufferSourceNode extends AudioSourceNode {
+    constructor(context) {
+        super(context, 'audio-source-worklet');
+        this._bufferFillSeconds = AudioSourceNode.DEFAULT_BUFFER_FILL_SECONDS;
+        this.bufferFillFrames = 0;
+        this._streamReadFrameLen = AudioSourceNode.DEFAULT_STREAM_READ_FRAME_LEN * 8; // Much overhead fetching small buffers from indexed db, use larger buffer (8192).
+        this._netAudioBuffer = null;
+        this._audioInputStream = null;
+        this._aisBufs = null;
+        this._active = false;
+        this.stalled = false;
+        this._endOfStream = false;
+        this.readDataSubscription = null;
+        this.filledFrames = 0;
+        this.stalledStartTime = null;
+        this.stalledTime = 0;
+        this.stopEndTime = null;
+        this.channelCountMode = 'explicit';
+        this.port.onmessage = (msgEv) => {
+            if (msgEv.data) {
+                let evType = msgEv.data.eventType;
+                if (evType) {
+                    if ('bufferNotification' === evType) {
+                        this.filledFrames = msgEv.data.filledFrames;
+                        //console.debug("IndexedDbAudioBufferSourceNode: Buffer notification: filled frames: " + this.filledFrames);
+                        if (!this._endOfStream) {
+                            this.fillBufferObs().subscribe();
+                        }
+                    }
+                    else if ('ended' === evType) {
+                        //console.debug("Inddb audio source ended playback.");
+                        let drainTime = 0;
+                        if (this._netAudioBuffer?.sampleRate) {
+                            drainTime = ArrayAudioBufferSourceNode.QUANTUM_FRAME_LEN / this._netAudioBuffer.sampleRate;
+                        }
+                        //let dstAny:any=this.context.destination;
+                        //console.debug('Destination node tail-time: '+dstAny['tail-time']);
+                        window.setTimeout(() => {
+                            this.stopEndTime = this.context.currentTime;
+                            this._active = false;
+                            this.onended?.call(this);
+                        }, drainTime * 1000);
+                    }
+                    else if ('stalled' === evType) {
+                        console.debug('Playback stalled...');
+                        this.stalled = true;
+                        this.stalledStartTime = this.context.currentTime;
+                    }
+                    else if ('resumed' === evType) {
+                        console.debug('Playback resumed after stall.');
+                        this.stalled = false;
+                        if (this.stalledStartTime != null) {
+                            this.stalledTime += this.context.currentTime - this.stalledStartTime;
+                            this.stalledStartTime = null;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    fillBufferObs(frameOffset) {
+        return new Observable(subscriber => {
+            if (frameOffset) {
+                subscriber.error(new Error("Starting playback from position not equal zero not supported yet."));
+            }
+            else {
+                let filled = this.filledFrames;
+                let bufLen = 0;
+                if (this._audioInputStream && this._aisBufs && (this.readDataSubscription == null || this.readDataSubscription?.closed)) {
+                    this.readDataSubscription = this._audioInputStream.readObs(this._aisBufs).pipe(expand((read) => {
+                        if (read && this._aisBufs) {
+                            let trBuffers = new Array(this.channelCount);
+                            for (let ch = 0; ch < this.channelCount; ch++) {
+                                let adCh = this._aisBufs[ch];
+                                let adChCopy = new Float32Array(read);
+                                bufLen = adChCopy.length;
+                                if (read === adCh.length) {
+                                    adChCopy.set(adCh);
+                                }
+                                else {
+                                    // Note: slice() does not work here, since it returns a shallow copy.
+                                    for (let i = 0; i < read; i++) {
+                                        adChCopy[i] = adCh[i];
+                                    }
+                                }
+                                trBuffers[ch] = adChCopy.buffer;
+                            }
+                            this.port.postMessage({
+                                cmd: 'data',
+                                chs: this.channelCount,
+                                audioData: trBuffers
+                            }, trBuffers);
+                            filled += read;
+                            //console.debug("IndexedDbAudioBufferSourceNode::fillBufferObs: Sent "+read+" frames to audio source worklet. Filled: "+filled+", to fill: "+this.bufferFillFrames);
+                            if (this._audioInputStream && filled < this.bufferFillFrames) {
+                                //console.debug("IndexedDbAudioBufferSourceNode::fillBufferObs: Next inddb audio input stream readObs");
+                                return this._audioInputStream.readObs(this._aisBufs);
+                            }
+                            else {
+                                if (this.stalled) {
+                                    this.port.postMessage({
+                                        cmd: 'continue'
+                                    });
+                                }
+                                return EMPTY;
+                            }
+                        }
+                        else {
+                            //console.debug("IndexedDbAudioBufferSourceNode::fillBufferObs: Return EMPTY (read: "+read+")");
+                            this._endOfStream = true;
+                            this.port.postMessage({
+                                cmd: 'endOfStream'
+                            });
+                            return EMPTY;
+                        }
+                    })).subscribe(subscriber);
+                }
+            }
+        });
+    }
+    get netAudioBuffer() {
+        return this._netAudioBuffer;
+    }
+    set netAudioBuffer(value) {
+        this._netAudioBuffer = value;
+        if (this._netAudioBuffer?.channelCount) {
+            this.channelCount = this._netAudioBuffer?.channelCount;
+            this.bufferFillFrames = this._netAudioBuffer.sampleRate * this._bufferFillSeconds;
+        }
+    }
+    get bufferFillSeconds() {
+        return this._bufferFillSeconds;
+    }
+    set bufferFillSeconds(value) {
+        this._bufferFillSeconds = value;
+    }
+    start(when, offset, duration) {
+        if (when) {
+            throw Error("when parameter currently not supported by IndexedDbAudioBufferSourceNode class");
+        }
+        this._playStartTime = null;
+        this.stopEndTime = null;
+        this.stalledTime = 0;
+        this.stalledStartTime = null;
+        if (this._netAudioBuffer) {
+            let arrAis = new NetAudioInputStream(this._netAudioBuffer);
+            if (offset === undefined && duration === undefined) {
+                this._audioInputStream = arrAis;
+            }
+            else {
+                let offsetFrames = 0;
+                let durationFrames = undefined;
+                if (offset !== undefined) {
+                    offsetFrames = Math.floor(offset * this._netAudioBuffer.sampleRate);
+                }
+                if (duration !== undefined) {
+                    durationFrames = Math.floor(duration * this._netAudioBuffer.sampleRate);
+                }
+                //console.error("Playback selection not supported yet!");
+                this._audioInputStream = new AsyncEditFloat32ArrayInputStream(arrAis, offsetFrames, durationFrames);
+            }
+            let chs = this._netAudioBuffer.channelCount;
+            this._aisBufs = new Array(chs);
+            for (let ch = 0; ch < chs; ch++) {
+                this._aisBufs[ch] = new Float32Array(this._streamReadFrameLen);
+            }
+            this.fillBufferObs().subscribe({
+                complete: () => {
+                    //console.debug("IndexedDbAudioBufferSourceNode::start: Async play buffer fill completed. Sending start command to audio worklet.");
+                    if (this._active) {
+                        this.port.postMessage({ cmd: 'start' });
+                        if (offset) {
+                            this._playStartTime = this.context.currentTime - offset;
+                        }
+                        else {
+                            this._playStartTime = this.context.currentTime;
+                        }
+                    }
+                }
+            });
+            this._active = true;
+        }
+    }
+    stop() {
+        this._active = false;
+        this.port.postMessage({ cmd: 'stop' });
+        this.onended?.call(this);
+    }
+    get playPositionTime() {
+        let ppt = null;
+        if (this._playStartTime !== null) {
+            if (this._active) {
+                if (this.stalledStartTime == null) {
+                    ppt = this.context.currentTime - this._playStartTime - this.stalledTime;
+                }
+                else {
+                    ppt = this.stalledStartTime - this._playStartTime - this.stalledTime;
+                }
+            }
+            else {
+                if (this.stopEndTime != null) {
+                    // if(this._netAudioBuffer?.frameLen !=null && this._netAudioBuffer.sampleRate) {
+                    //   ppt = this._netAudioBuffer?.frameLen / this._netAudioBuffer?.sampleRate;
+                    // }else{
+                    ppt = this.stopEndTime - this._playStartTime - this.stalledTime;
+                    //}
+                }
+            }
+        }
+        return ppt;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"net_audio_buffer_source_node.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/audio/playback/net_audio_buffer_source_node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gCAAgC,EAA+B,MAAM,iBAAiB,CAAC;AAC/F,OAAO,EAAC,0BAA0B,EAAC,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAe,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAiB,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAExE,MAAM,OAAO,wBAAyB,SAAQ,eAAe;IAmB3D,YAAY,OAAqB;QAE/B,KAAK,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC;QAnBjC,uBAAkB,GAAG,eAAe,CAAC,2BAA2B,CAAC;QACjE,qBAAgB,GAAG,CAAC,CAAC;QACrB,wBAAmB,GAAC,eAAe,CAAC,6BAA6B,GAAG,CAAC,CAAC,CAAE,kFAAkF;QAC1J,oBAAe,GAAqB,IAAI,CAAC;QACzC,sBAAiB,GAAmC,IAAI,CAAC;QACzD,aAAQ,GAAqB,IAAI,CAAC;QAClC,YAAO,GAAC,KAAK,CAAC;QACd,YAAO,GAAC,KAAK,CAAC;QACd,iBAAY,GAAC,KAAK,CAAC;QACnB,yBAAoB,GAAmB,IAAI,CAAC;QAC5C,iBAAY,GAAG,CAAC,CAAC;QAEjB,qBAAgB,GAAa,IAAI,CAAC;QAClC,gBAAW,GAAQ,CAAC,CAAC;QAErB,gBAAW,GAAa,IAAI,CAAC;QAKnC,IAAI,CAAC,gBAAgB,GAAG,UAAU,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,KAAmB,EAAE,EAAE;YAC5C,IAAI,KAAK,CAAC,IAAI,EAAE;gBACd,IAAI,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;gBAClC,IAAI,MAAM,EAAE;oBACV,IAAI,oBAAoB,KAAK,MAAM,EAAE;wBACnC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC;wBAC5C,4GAA4G;wBAC5G,IAAG,CAAC,IAAI,CAAC,YAAY,EAAE;4BACrB,IAAI,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,CAAC;yBAClC;qBACF;yBAAM,IAAI,OAAO,KAAK,MAAM,EAAE;wBAC7B,sDAAsD;wBACtD,IAAI,SAAS,GAAG,CAAC,CAAC;wBAClB,IAAI,IAAI,CAAC,eAAe,EAAE,UAAU,EAAE;4BACpC,SAAS,GAAG,0BAA0B,CAAC,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC;yBAC5F;wBACD,0CAA0C;wBAC1C,oEAAoE;wBACpE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;4BACrB,IAAI,CAAC,WAAW,GAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;4BAC1C,IAAI,CAAC,OAAO,GAAC,KAAK,CAAC;4BACnB,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;wBAC3B,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,CAAC;qBAEtB;yBAAK,IAAI,SAAS,KAAK,MAAM,EAAE;wBAC9B,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;wBACrC,IAAI,CAAC,OAAO,GAAC,IAAI,CAAC;wBAClB,IAAI,CAAC,gBAAgB,GAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;qBAChD;yBAAK,IAAI,SAAS,KAAK,MAAM,EAAE;wBAC9B,OAAO,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC;wBAC/C,IAAI,CAAC,OAAO,GAAC,KAAK,CAAC;wBACnB,IAAG,IAAI,CAAC,gBAAgB,IAAE,IAAI,EAAE;4BAC9B,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC;4BACrE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;yBAC9B;qBACF;iBACF;aACF;QACH,CAAC,CAAA;IACH,CAAC;IAEO,aAAa,CAAC,WAAmB;QAErC,OAAO,IAAI,UAAU,CAAgB,UAAU,CAAC,EAAE;YAChD,IAAG,WAAW,EAAC;gBACb,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC,CAAC;aAClG;iBAAK;gBACJ,IAAI,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;gBAC/B,IAAI,MAAM,GAAG,CAAC,CAAC;gBACf,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,oBAAoB,IAAE,IAAI,IAAI,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,EAAE;oBACrH,IAAI,CAAC,oBAAoB,GAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC1E,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;wBACZ,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;4BACzB,IAAI,SAAS,GAAG,IAAI,KAAK,CAAM,IAAI,CAAC,YAAY,CAAC,CAAC;4BAClD,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,EAAE,EAAE,EAAE;gCAC7C,IAAI,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;gCAC7B,IAAI,QAAQ,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;gCACtC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;gCACzB,IAAG,IAAI,KAAG,IAAI,CAAC,MAAM,EAAE;oCACrB,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;iCACpB;qCAAI;oCACH,qEAAqE;oCACrE,KAAI,IAAI,CAAC,GAAC,CAAC,EAAC,CAAC,GAAC,IAAI,EAAC,CAAC,EAAE,EAAC;wCACrB,QAAQ,CAAC,CAAC,CAAC,GAAC,IAAI,CAAC,CAAC,CAAC,CAAC;qCACrB;iCACF;gCACD,SAAS,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC;6BACjC;4BACD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;gCACpB,GAAG,EAAE,MAAM;gCACX,GAAG,EAAE,IAAI,CAAC,YAAY;gCACtB,SAAS,EAAE,SAAS;6BACrB,EAAE,SAAS,CAAC,CAAC;4BACd,MAAM,IAAI,IAAI,CAAC;4BACf,oKAAoK;4BACpK,IAAI,IAAI,CAAC,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE;gCAC5D,wGAAwG;gCACxG,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;6BACtD;iCAAM;gCACL,IAAG,IAAI,CAAC,OAAO,EAAC;oCACd,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;wCACpB,GAAG,EAAE,UAAU;qCAChB,CAAC,CAAC;iCAEJ;gCACD,OAAO,KAAK,CAAC;6BACd;yBACF;6BAAM;4BACL,gGAAgG;4BAChG,IAAI,CAAC,YAAY,GAAC,IAAI,CAAC;4BACvB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;gCACpB,GAAG,EAAE,aAAa;6BACnB,CAAC,CAAC;4BACH,OAAO,KAAK,CAAC;yBACd;oBACH,CAAC,CACF,CACF,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;iBACzB;aACF;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAGD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAA;IAC7B,CAAC;IAED,IAAI,cAAc,CAAC,KAA4B;QAC7C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC7B,IAAI,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE;YACtC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,YAAY,CAAC;YACvD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC;SACnF;IACH,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED,IAAI,iBAAiB,CAAC,KAAa;QACjC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IAED,KAAK,CAAC,IAAyB,EAAC,MAA2B,EAAC,QAA6B;QACvF,IAAI,IAAI,EAAE;YACR,MAAM,KAAK,CAAC,gFAAgF,CAAC,CAAA;SAC9F;QACD,IAAI,CAAC,cAAc,GAAC,IAAI,CAAC;QACzB,IAAI,CAAC,WAAW,GAAC,IAAI,CAAC;QACtB,IAAI,CAAC,WAAW,GAAC,CAAC,CAAC;QACnB,IAAI,CAAC,gBAAgB,GAAC,IAAI,CAAC;QAE3B,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,MAAM,GAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACzD,IAAG,MAAM,KAAG,SAAS,IAAI,QAAQ,KAAG,SAAS,EAAC;gBAC5C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC;aACjC;iBAAI;gBACH,IAAI,YAAY,GAAC,CAAC,CAAC;gBACnB,IAAI,cAAc,GAAC,SAAS,CAAC;gBAC7B,IAAG,MAAM,KAAG,SAAS,EAAE;oBACrB,YAAY,GAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;iBACnE;gBACD,IAAG,QAAQ,KAAG,SAAS,EAAC;oBACtB,cAAc,GAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;iBACvE;gBACD,yDAAyD;gBACzD,IAAI,CAAC,iBAAiB,GAAC,IAAI,gCAAgC,CAAC,MAAM,EAAC,YAAY,EAAC,cAAc,CAAC,CAAC;aACjG;YAED,IAAI,GAAG,GAAC,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC;YAC1C,IAAI,CAAC,QAAQ,GAAC,IAAI,KAAK,CAAe,GAAG,CAAC,CAAC;YAC3C,KAAI,IAAI,EAAE,GAAC,CAAC,EAAC,EAAE,GAAC,GAAG,EAAC,EAAE,EAAE,EAAC;gBACvB,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAC,IAAI,YAAY,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;aAC9D;YAED,IAAI,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC;gBAC7B,QAAQ,EAAE,GAAE,EAAE;oBACZ,oIAAoI;oBACpI,IAAG,IAAI,CAAC,OAAO,EAAE;wBACf,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAC,GAAG,EAAE,OAAO,EAAC,CAAC,CAAC;wBACtC,IAAG,MAAM,EAAE;4BACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC;yBACzD;6BAAI;4BACH,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;yBAChD;qBACF;gBACH,CAAC;aACF,CAAC,CAAA;YACF,IAAI,CAAC,OAAO,GAAC,IAAI,CAAC;SAEnB;IACH,CAAC;IAED,IAAI;QACF,IAAI,CAAC,OAAO,GAAC,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAC,GAAG,EAAE,MAAM,EAAC,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,IAAI,gBAAgB;QAClB,IAAI,GAAG,GAAa,IAAI,CAAC;QACzB,IAAG,IAAI,CAAC,cAAc,KAAG,IAAI,EAAE;YAC7B,IAAG,IAAI,CAAC,OAAO,EAAE;gBACf,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,EAAE;oBACjC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC;iBACzE;qBAAM;oBACL,GAAG,GAAG,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC;iBACtE;aACF;iBAAI;gBACH,IAAG,IAAI,CAAC,WAAW,IAAE,IAAI,EAAC;oBACxB,iFAAiF;oBACjF,6EAA6E;oBAC7E,SAAS;oBACP,GAAG,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC;oBAClE,GAAG;iBACJ;aACF;SACF;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CAEF","sourcesContent":["import {AsyncEditFloat32ArrayInputStream, AsyncFloat32ArrayInputStream} from \"../../io/stream\";\r\nimport {ArrayAudioBufferSourceNode} from \"./array_audio_buffer_source_node\";\r\nimport {EMPTY, expand, Observable, Subscription} from \"rxjs\";\r\nimport {AudioSourceNode} from \"./audio_source_node\";\r\nimport {NetAudioBuffer, NetAudioInputStream} from \"../net_audio_buffer\";\r\n\r\nexport class NetAudioBufferSourceNode extends AudioSourceNode {\r\n\r\n  private _bufferFillSeconds = AudioSourceNode.DEFAULT_BUFFER_FILL_SECONDS;\r\n  private bufferFillFrames = 0;\r\n  private _streamReadFrameLen=AudioSourceNode.DEFAULT_STREAM_READ_FRAME_LEN * 8;  // Much overhead fetching small buffers from indexed db, use larger buffer (8192).\r\n  private _netAudioBuffer:NetAudioBuffer|null=null;\r\n  private _audioInputStream:AsyncFloat32ArrayInputStream|null=null;\r\n  private _aisBufs:Float32Array[]|null=null;\r\n  private _active=false;\r\n  private stalled=false;\r\n  private _endOfStream=false;\r\n  private readDataSubscription:Subscription|null=null;\r\n  private filledFrames = 0;\r\n\r\n  private stalledStartTime:number|null=null;\r\n  private stalledTime:number=0;\r\n\r\n  private stopEndTime:number|null=null;\r\n\r\n  constructor(context: AudioContext) {\r\n\r\n    super(context, 'audio-source-worklet');\r\n    this.channelCountMode = 'explicit';\r\n    this.port.onmessage = (msgEv: MessageEvent) => {\r\n      if (msgEv.data) {\r\n        let evType = msgEv.data.eventType;\r\n        if (evType) {\r\n          if ('bufferNotification' === evType) {\r\n            this.filledFrames = msgEv.data.filledFrames;\r\n            //console.debug(\"IndexedDbAudioBufferSourceNode: Buffer notification: filled frames: \" + this.filledFrames);\r\n            if(!this._endOfStream) {\r\n              this.fillBufferObs().subscribe();\r\n            }\r\n          } else if ('ended' === evType) {\r\n            //console.debug(\"Inddb audio source ended playback.\");\r\n            let drainTime = 0;\r\n            if (this._netAudioBuffer?.sampleRate) {\r\n              drainTime = ArrayAudioBufferSourceNode.QUANTUM_FRAME_LEN / this._netAudioBuffer.sampleRate;\r\n            }\r\n            //let dstAny:any=this.context.destination;\r\n            //console.debug('Destination node tail-time: '+dstAny['tail-time']);\r\n            window.setTimeout(() => {\r\n              this.stopEndTime=this.context.currentTime;\r\n              this._active=false;\r\n              this.onended?.call(this);\r\n            }, drainTime * 1000);\r\n\r\n          }else if ('stalled' === evType) {\r\n            console.debug('Playback stalled...');\r\n            this.stalled=true;\r\n            this.stalledStartTime=this.context.currentTime;\r\n          }else if ('resumed' === evType) {\r\n            console.debug('Playback resumed after stall.');\r\n            this.stalled=false;\r\n            if(this.stalledStartTime!=null) {\r\n              this.stalledTime += this.context.currentTime - this.stalledStartTime;\r\n              this.stalledStartTime = null;\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private fillBufferObs(frameOffset?:number):Observable<number|null> {\r\n\r\n      return new Observable<number | null>(subscriber => {\r\n        if(frameOffset){\r\n          subscriber.error(new Error(\"Starting playback from position not equal zero not supported yet.\"));\r\n        }else {\r\n          let filled = this.filledFrames;\r\n          let bufLen = 0;\r\n          if (this._audioInputStream && this._aisBufs && (this.readDataSubscription==null || this.readDataSubscription?.closed)) {\r\n            this.readDataSubscription=this._audioInputStream.readObs(this._aisBufs).pipe(\r\n              expand((read) => {\r\n                  if (read && this._aisBufs) {\r\n                    let trBuffers = new Array<any>(this.channelCount);\r\n                    for (let ch = 0; ch < this.channelCount; ch++) {\r\n                      let adCh = this._aisBufs[ch];\r\n                      let adChCopy = new Float32Array(read);\r\n                      bufLen = adChCopy.length;\r\n                      if(read===adCh.length) {\r\n                        adChCopy.set(adCh);\r\n                      }else{\r\n                        // Note: slice() does not work here, since it returns a shallow copy.\r\n                        for(let i=0;i<read;i++){\r\n                          adChCopy[i]=adCh[i];\r\n                        }\r\n                      }\r\n                      trBuffers[ch] = adChCopy.buffer;\r\n                    }\r\n                    this.port.postMessage({\r\n                      cmd: 'data',\r\n                      chs: this.channelCount,\r\n                      audioData: trBuffers\r\n                    }, trBuffers);\r\n                    filled += read;\r\n                    //console.debug(\"IndexedDbAudioBufferSourceNode::fillBufferObs: Sent \"+read+\" frames to audio source worklet. Filled: \"+filled+\", to fill: \"+this.bufferFillFrames);\r\n                    if (this._audioInputStream && filled < this.bufferFillFrames) {\r\n                      //console.debug(\"IndexedDbAudioBufferSourceNode::fillBufferObs: Next inddb audio input stream readObs\");\r\n                      return this._audioInputStream.readObs(this._aisBufs);\r\n                    } else {\r\n                      if(this.stalled){\r\n                        this.port.postMessage({\r\n                          cmd: 'continue'\r\n                        });\r\n\r\n                      }\r\n                      return EMPTY;\r\n                    }\r\n                  } else {\r\n                    //console.debug(\"IndexedDbAudioBufferSourceNode::fillBufferObs: Return EMPTY (read: \"+read+\")\");\r\n                    this._endOfStream=true;\r\n                    this.port.postMessage({\r\n                      cmd: 'endOfStream'\r\n                    });\r\n                    return EMPTY;\r\n                  }\r\n                }\r\n              )\r\n            ).subscribe(subscriber);\r\n          }\r\n        }\r\n      });\r\n  }\r\n\r\n\r\n  get netAudioBuffer(): NetAudioBuffer | null {\r\n    return this._netAudioBuffer\r\n  }\r\n\r\n  set netAudioBuffer(value: NetAudioBuffer | null) {\r\n    this._netAudioBuffer = value;\r\n    if (this._netAudioBuffer?.channelCount) {\r\n      this.channelCount = this._netAudioBuffer?.channelCount;\r\n      this.bufferFillFrames = this._netAudioBuffer.sampleRate * this._bufferFillSeconds;\r\n    }\r\n  }\r\n\r\n  get bufferFillSeconds(): number {\r\n    return this._bufferFillSeconds;\r\n  }\r\n\r\n  set bufferFillSeconds(value: number) {\r\n    this._bufferFillSeconds = value;\r\n  }\r\n\r\n  start(when?: number | undefined,offset?: number | undefined,duration?: number | undefined): void {\r\n    if (when) {\r\n      throw Error(\"when parameter currently not supported by IndexedDbAudioBufferSourceNode class\")\r\n    }\r\n    this._playStartTime=null;\r\n    this.stopEndTime=null;\r\n    this.stalledTime=0;\r\n    this.stalledStartTime=null;\r\n\r\n    if (this._netAudioBuffer) {\r\n      let arrAis=new NetAudioInputStream(this._netAudioBuffer);\r\n      if(offset===undefined && duration===undefined){\r\n        this._audioInputStream = arrAis;\r\n      }else{\r\n        let offsetFrames=0;\r\n        let durationFrames=undefined;\r\n        if(offset!==undefined) {\r\n          offsetFrames=Math.floor(offset * this._netAudioBuffer.sampleRate);\r\n        }\r\n        if(duration!==undefined){\r\n          durationFrames=Math.floor(duration * this._netAudioBuffer.sampleRate);\r\n        }\r\n        //console.error(\"Playback selection not supported yet!\");\r\n        this._audioInputStream=new AsyncEditFloat32ArrayInputStream(arrAis,offsetFrames,durationFrames);\r\n      }\r\n\r\n      let chs=this._netAudioBuffer.channelCount;\r\n      this._aisBufs=new Array<Float32Array>(chs);\r\n      for(let ch=0;ch<chs;ch++){\r\n        this._aisBufs[ch]=new Float32Array(this._streamReadFrameLen);\r\n      }\r\n\r\n      this.fillBufferObs().subscribe({\r\n        complete: ()=>{\r\n          //console.debug(\"IndexedDbAudioBufferSourceNode::start: Async play buffer fill completed. Sending start command to audio worklet.\");\r\n          if(this._active) {\r\n            this.port.postMessage({cmd: 'start'});\r\n            if(offset) {\r\n              this._playStartTime = this.context.currentTime - offset;\r\n            }else{\r\n              this._playStartTime = this.context.currentTime;\r\n            }\r\n          }\r\n        }\r\n      })\r\n      this._active=true;\r\n\r\n    }\r\n  }\r\n\r\n  stop() {\r\n    this._active=false;\r\n    this.port.postMessage({cmd: 'stop'});\r\n    this.onended?.call(this);\r\n  }\r\n\r\n  get playPositionTime():number|null {\r\n    let ppt:number|null=null;\r\n    if(this._playStartTime!==null) {\r\n      if(this._active) {\r\n        if (this.stalledStartTime == null) {\r\n          ppt = this.context.currentTime - this._playStartTime - this.stalledTime;\r\n        } else {\r\n          ppt = this.stalledStartTime - this._playStartTime - this.stalledTime;\r\n        }\r\n      }else{\r\n        if(this.stopEndTime!=null){\r\n          // if(this._netAudioBuffer?.frameLen !=null && this._netAudioBuffer.sampleRate) {\r\n          //   ppt = this._netAudioBuffer?.frameLen / this._netAudioBuffer?.sampleRate;\r\n          // }else{\r\n            ppt = this.stopEndTime - this._playStartTime - this.stalledTime;\r\n          //}\r\n        }\r\n      }\r\n    }\r\n    return ppt;\r\n  }\r\n\r\n}\r\n\r\n"]}