speechrecorderng 3.6.0 → 3.8.0

package/esm2022/lib/audio/inddb_audio_buffer.mjs

@@ -0,0 +1,508 @@
+import { Observable } from "rxjs";
+import { UUID } from "../utils/utils";
+import { BasicAudioSource } from "./audio_data_holder";
+export class PersistentAudioStorageTarget {
+    get indexedDb() {
+        return this._indexedDb;
+    }
+    get storeName() {
+        return this._storeName;
+    }
+    constructor(_indexedDb, _storeName) {
+        this._indexedDb = _indexedDb;
+        this._storeName = _storeName;
+    }
+    transaction(mode) {
+        return this._indexedDb.transaction(this.storeName, mode);
+    }
+    objectStore(mode) {
+        let tr = this.transaction(mode);
+        return tr.objectStore(this._storeName);
+    }
+    deleteAll() {
+        return new Observable(subscriber => {
+            let os = this.objectStore('readwrite');
+            let clearReq = os.clear();
+            clearReq.onsuccess = () => {
+                console.debug("Cleared audio storage object store.");
+                os.transaction.commit();
+            };
+            clearReq.onerror = () => {
+                os.transaction.abort();
+                console.error("Could not clear object store: " + clearReq.error);
+            };
+            os.transaction.oncomplete = () => {
+                console.debug("Transaction complete: Clear audio storage object store.");
+                subscriber.complete();
+            };
+            os.transaction.onerror = (err) => {
+                subscriber.error(err);
+            };
+        });
+    }
+}
+export class IndexedDbAudioBuffer extends BasicAudioSource {
+    get chunkFrameLen() {
+        return this._chunkFrameLen;
+    }
+    get persistentAudioStorageTarget() {
+        return this._persistentAudioStorageTarget;
+    }
+    get uuid() {
+        return this._uuid;
+    }
+    constructor(_persistentAudioStorageTarget, _channelCount, _sampleRate, _chunkFrameLen, _frameLen, _uuid) {
+        super();
+        this._persistentAudioStorageTarget = _persistentAudioStorageTarget;
+        this._channelCount = _channelCount;
+        this._sampleRate = _sampleRate;
+        this._chunkFrameLen = _chunkFrameLen;
+        this._frameLen = _frameLen;
+        this._uuid = _uuid;
+        this._chunkCount = 0;
+        this.indDbChkIdx = 0;
+        this._sealed = false;
+        this._storeError = null;
+        this.ready();
+    }
+    get channelCount() {
+        return this._channelCount;
+    }
+    sealed() {
+        return this._sealed;
+    }
+    seal() {
+        this._sealed = true;
+    }
+    deleteChunk(os, ci, cb, errCb) {
+        // Build bounds for channels
+        let lIdx = [this._uuid, ci, 0];
+        let hIdx = [this._uuid, ci, this._channelCount];
+        let chsKr = IDBKeyRange.bound(lIdx, hIdx);
+        let exRq = os.getAllKeys(chsKr);
+        exRq.onsuccess = () => {
+            let cc = exRq.result;
+            if (cc && cc.length > 0) {
+                let rq = os.delete(chsKr);
+                rq.onerror = (errEv) => {
+                    errCb(new Error(errEv.toString()));
+                };
+                os.transaction.oncomplete = () => {
+                    cb(cc);
+                };
+                os.transaction.commit();
+            }
+        };
+        exRq.onerror = (errEv) => {
+            errCb(new Error(errEv.toString()));
+        };
+    }
+    deleteAllBufs(os, ci, cbEnd, cbErr) {
+        //console.debug('IndexedDbAudioBuffer::fillBufs: framePos:'+framePos+', frameLen: '+frameLen+', filled: '+filled+', srcFramePos: '+srcFramePos+',ci: '+ci+', ccPos: '+ccPos);
+        this.deleteChunk(os, ci, (ccKeys) => {
+            if (ccKeys && ccKeys.length > 0) {
+                //console.debug('IndexedDbAudioBuffer::fillBufs frameLen: '+frameLen);
+                ci++;
+                this.deleteAllBufs(os, ci, cbEnd, cbErr);
+            }
+            else {
+                //console.debug('IndexedDbAudioBuffer::fillBufs (chunk not found) call: cbend '+filled);
+                cbEnd();
+            }
+        }, (err) => {
+            cbErr(err);
+        });
+    }
+    get sampleRate() {
+        return this._sampleRate;
+    }
+    get frameLen() {
+        return this._frameLen;
+    }
+    get chunkCount() {
+        return this._chunkCount;
+    }
+    appendRawAudioData(data) {
+        return new Observable(subscriber => {
+            if (this._persistentAudioStorageTarget && this._uuid) {
+                let tr = this._persistentAudioStorageTarget.indexedDb.transaction(this._persistentAudioStorageTarget.storeName, 'readwrite');
+                let recFileObjStore = tr.objectStore(this._persistentAudioStorageTarget.storeName);
+                try {
+                    let ch0Data = data[0];
+                    let dataChkCnt = ch0Data.length;
+                    let pos = 0;
+                    for (let chCkIdx = 0; chCkIdx < dataChkCnt; chCkIdx++) {
+                        let bufLen = 0;
+                        for (let ch = 0; ch < this.channelCount; ch++) {
+                            let chChk = data[ch][chCkIdx];
+                            bufLen = chChk.length;
+                            //let cacheId = uuid + '_' + ch + '_' + chCkIdx;
+                            let chkDbId = [this._uuid, this.indDbChkIdx + chCkIdx, ch];
+                            let cr = recFileObjStore.add(chChk, chkDbId);
+                            //console.debug("Added: "+ch+" "+(this.indDbChkIdx+chCkIdx));
+                            cr.onsuccess = () => {
+                                //console.debug("Stored audio data to indexed db");
+                                // if(chCkIdx>= dataChkCnt-1 && ch>=this.channelCount-1){
+                                //   tr.commit();
+                                // }
+                            };
+                            cr.onerror = () => {
+                                if (!this._storeError) {
+                                    // Only log the first error
+                                    console.error("Error storing audio data of " + chChk.byteLength + " bytes to indexed db: " + cr.error);
+                                }
+                            };
+                        }
+                        pos += bufLen;
+                        this._frameLen += bufLen;
+                    }
+                    this.indDbChkIdx += dataChkCnt;
+                    tr.onerror = (ev) => {
+                        if (!this._storeError) {
+                            // Only log the first error
+                            console.error("Failed to store audio data to indexed db, transaction error: " + tr.error);
+                            this._storeError = tr.error;
+                        }
+                        subscriber.error(tr.error);
+                    };
+                    tr.onabort = (ev) => {
+                        // If Chrome reaches quota it aborts the transaction
+                        if (!this._storeError) {
+                            // Only log the first error
+                            console.error("Failed to store audio data to indexed db, transaction aborted: " + tr.error);
+                            this._storeError = tr.error;
+                        }
+                        subscriber.error(tr.error);
+                    };
+                    tr.oncomplete = (ev) => {
+                        subscriber.complete();
+                    };
+                    tr.commit();
+                }
+                catch (err) {
+                    subscriber.error(new Error('Transfer audio data error: ' + err));
+                }
+            }
+        });
+    }
+    static fromChunkAudioBuffer(persistentAudioStorageTarget, audioBuffer) {
+        return new Observable(subscriber => {
+            let chs = audioBuffer.numberOfChannels;
+            let sr = audioBuffer.sampleRate;
+            let chkFrameLength = audioBuffer.length;
+            let iab = new IndexedDbAudioBuffer(persistentAudioStorageTarget, chs, sr, chkFrameLength, 0, UUID.generate());
+            iab.appendChunkAudioBuffer(audioBuffer).subscribe({
+                next: () => {
+                    subscriber.next(iab);
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+                error: (err) => {
+                    subscriber.error(err);
+                }
+            });
+        });
+    }
+    appendChunkAudioBuffer(audioBuffer) {
+        if (this._sealed) {
+            throw new Error('Cannot append audio buffer to already sealed audio buffer.');
+        }
+        let chs = audioBuffer.numberOfChannels;
+        if (this._channelCount !== chs) {
+            throw new Error('Cannot append audio buffer with ' + chs + ' channels to this array audio buffer with ' + this._channelCount + ' channels. Number of channels must match.');
+        }
+        let sr = audioBuffer.sampleRate;
+        if (sr !== this._sampleRate) {
+            throw new Error('Cannot append audio buffer with samplerate ' + sr + ' to this array audio buffer with samplerate ' + this._sampleRate + '. Samplerates must match.');
+        }
+        let abFl = audioBuffer.length;
+        if (abFl > this._chunkFrameLen) {
+            throw new Error('Cannot append audio buffer with frame length ' + abFl + ' to this array audio buffer with chunk frame length ' + this._chunkFrameLen + '. Chunk length must be equal or less if last chunk.');
+        }
+        return new Observable(subscriber => {
+            if (this._persistentAudioStorageTarget && this._uuid) {
+                let tr = this._persistentAudioStorageTarget.transaction('readwrite');
+                let recFileObjStore = tr.objectStore(this._persistentAudioStorageTarget.storeName);
+                try {
+                    for (let ch = 0; ch < this.channelCount; ch++) {
+                        let chChk = audioBuffer.getChannelData(ch);
+                        let chkDbId = [this._uuid, this.indDbChkIdx++, ch];
+                        try {
+                            let cr = recFileObjStore.add(chChk, chkDbId);
+                            cr.onsuccess = (ev) => { };
+                            cr.onerror = (ev) => {
+                                // iPad may throw QuotaExceededError here
+                                // iPad asks for more storage and if denied, the error is thrown here
+                                if (!this._storeError) {
+                                    // Only log the first error
+                                    console.error("Error storing audio data of " + chChk.byteLength + " bytes to indexed db: " + cr.error);
+                                }
+                                //subscriber.error(cr.error);
+                            };
+                        }
+                        catch (err1) {
+                            if (!this._storeError) {
+                                console.error("Error adding audio data to indexed db store: " + err1);
+                                this._storeError = (err1 instanceof Error) ? err1 : new Error(err1);
+                            }
+                            subscriber.error(err1);
+                        }
+                    }
+                    this._frameLen += abFl;
+                    tr.onerror = (ev) => {
+                        if (!this._storeError) {
+                            // Only log the first error
+                            console.error("Failed to store audio data to indexed db, transaction error: " + tr.error);
+                            this._storeError = tr.error;
+                        }
+                        subscriber.error(tr.error);
+                    };
+                    tr.onabort = (ev) => {
+                        // If Chrome reaches quota it aborts the transaction
+                        if (!this._storeError) {
+                            // Only log the first error
+                            console.error("Failed to store audio data to indexed db, transaction aborted: " + tr.error);
+                            this._storeError = tr.error;
+                        }
+                        subscriber.error(tr.error);
+                    };
+                    tr.oncomplete = (ev) => {
+                        //console.debug("Transaction complete");
+                        if (abFl < this._chunkFrameLen) {
+                            // last chunk
+                            this.seal();
+                        }
+                        subscriber.next();
+                        subscriber.complete();
+                    };
+                    tr.commit();
+                }
+                catch (err) {
+                    console.error('Catched error: ' + err);
+                    subscriber.error(new Error('Transfer audio data error: ' + err));
+                }
+            }
+        });
+    }
+    releaseAudioData() {
+        return new Observable((subscriber) => {
+            let os = this._persistentAudioStorageTarget.objectStore('readwrite');
+            this.deleteAllBufs(os, 0, () => {
+                subscriber.next();
+                subscriber.complete();
+            }, (err) => {
+                subscriber.error(err);
+            });
+        });
+    }
+    toString() {
+        return "Indexed db audio buffer. Channels: " + this.channelCount + ", sample rate: " + this.sampleRate + ", chunk frame length: " + this._chunkFrameLen + ", number of chunks: " + this.chunkCount + ", frame length: " + this.frameLen + ", sealed: " + this.sealed();
+    }
+    asyncAudioInputStream() {
+        return new IndexedDbAudioInputStream(this);
+    }
+    audioInputStream() {
+        // Synchronous stream not supported
+        return null;
+    }
+    get duration() {
+        return this._chunkFrameLen / this._sampleRate;
+    }
+    get numberOfChannels() {
+        return this._channelCount;
+    }
+    sampleCounts() {
+        return this._channelCount * this._frameLen;
+    }
+    randomAccessAudioStream() {
+        return new IndexedDbRandomAccessStream(this);
+    }
+}
+export class IndexedDbRandomAccessStream {
+    constructor(_inddbAb) {
+        this._inddbAb = _inddbAb;
+        this._currCi = 0;
+        this._ccCache = null;
+    }
+    chunk(os, ci, cb, errCb) {
+        // Build bounds for channels
+        let lIdx = [this._inddbAb.uuid, ci, 0];
+        let hIdx = [this._inddbAb.uuid, ci, this._inddbAb.channelCount];
+        let chsKr = IDBKeyRange.bound(lIdx, hIdx);
+        let rq = os.getAll(chsKr);
+        rq.onsuccess = () => {
+            let cc = rq.result;
+            let cc0;
+            let ccChs = cc.length;
+            if (ccChs == 0) {
+                cb(null);
+                return;
+            }
+            if (ccChs !== this._inddbAb.channelCount) {
+                errCb(new Error('Number of channels of inddb data (' + ccChs + ') does not match number of channels (' + this._inddbAb.channelCount + ')'));
+                return;
+            }
+            if (cc.length > 0) {
+                cc0 = cc[0];
+            }
+            let arrBuf = new Array();
+            let ccLen = cc0.length;
+            for (let ch = 0; ch < ccChs; ch++) {
+                let chArr = new Float32Array(ccLen);
+                for (let si = 0; si < ccLen; si++) {
+                    chArr[si] = cc[ch][si];
+                }
+                arrBuf.push(chArr);
+            }
+            cb(arrBuf);
+        };
+        rq.onerror = (errEv) => {
+            errCb(new Error(errEv.toString()));
+        };
+    }
+    _fillBufs(ccBufs, trgState, srcState) {
+        let ccBufsChs = ccBufs.length;
+        if (ccBufsChs > 0) {
+            let ccBuf0 = ccBufs[0];
+            let ccBufsLen = ccBuf0.length;
+            //console.debug('IndexedDbAudioBuffer::fillBufs framePos: '+framePos+', srcFramePos: '+srcFramePos+', ccBufsLen: '+ccBufsLen);
+            if (trgState.framePos >= srcState.srcFramePos + ccBufsLen) {
+                // target frame position is ahead, seek to next source buffer
+                //console.debug('IndexedDbAudioBuffer::fillBufs seek to next inddb buffer');
+                this._ccCache = null;
+                srcState.ci++;
+                srcState.ccPos = 0;
+                srcState.srcFramePos += ccBufsLen;
+            }
+            else {
+                // Assuming target frame pos is inside current source buffer
+                srcState.ccPos = trgState.framePos - srcState.srcFramePos;
+                let ccAvail = ccBufsLen - srcState.ccPos;
+                let toCopy = ccBufsLen;
+                if (toCopy > ccAvail) {
+                    toCopy = ccAvail;
+                }
+                if (toCopy > trgState.frameLen) {
+                    toCopy = trgState.frameLen;
+                }
+                for (let ch = 0; ch < ccBufsChs; ch++) {
+                    for (let si = 0; si < toCopy; si++) {
+                        trgState.trgBufs[ch][trgState.filled + si] = ccBufs[ch][srcState.ccPos + si];
+                    }
+                }
+                trgState.filled += toCopy;
+                trgState.frameLen -= toCopy;
+                trgState.framePos += toCopy;
+                srcState.ccPos += toCopy;
+                if (srcState.ccPos >= ccBufsLen) {
+                    // Invalidate cache
+                    this._ccCache = null;
+                    srcState.ci++;
+                    this._currCi = srcState.ci;
+                    srcState.ccPos = 0;
+                    srcState.srcFramePos += ccBufsLen;
+                }
+            }
+        }
+    }
+    fillBufs(os, trgState, srcState, cb, cbEnd, cbErr) {
+        //console.debug('IndexedDbAudioBuffer::fillBufs: framePos:'+trgState.framePos+', frameLen: '+trgState.frameLen+', filled: '+trgState.filled+', srcFramePos: '+srcState.srcFramePos+',ci: '+srcState.ci+', ccPos: '+srcState.ccPos);
+        if (this._ccCache) {
+            this._fillBufs(this._ccCache, trgState, srcState);
+            //console.debug('IndexedDbAudioBuffer::fillBufs frameLen: '+trgState.frameLen);
+            if (trgState.frameLen === 0) {
+                //console.debug('IndexedDbAudioBuffer::fillBufs (framelen==0) call: cbend '+trgState.filled);
+                cbEnd(trgState.filled);
+            }
+            else {
+                this.fillBufs(os, trgState, srcState, cb, cbEnd, cbErr);
+            }
+        }
+        else {
+            this.chunk(os, srcState.ci, (ccBufs) => {
+                if (ccBufs) {
+                    this._currCi = srcState.ci;
+                    this._ccCache = ccBufs;
+                    this._fillBufs(ccBufs, trgState, srcState);
+                    //console.debug('IndexedDbAudioBuffer::fillBufs frameLen: '+trgState.frameLen);
+                    if (trgState.frameLen === 0) {
+                        //console.debug('IndexedDbAudioBuffer::fillBufs (framelen==0) call: cbend '+trgState.filled);
+                        cbEnd(trgState.filled);
+                    }
+                    else {
+                        this.fillBufs(os, trgState, srcState, cb, cbEnd, cbErr);
+                    }
+                }
+                else {
+                    //console.debug('IndexedDbAudioBuffer::fillBufs (chunk not found) call: cbend '+trgState.filled);
+                    cbEnd(trgState.filled);
+                }
+            }, (err) => {
+                cbErr(err);
+            });
+        }
+    }
+    framesObs(framePos, frameLen, bufs) {
+        return new Observable((subscriber) => {
+            let tr = this._inddbAb.persistentAudioStorageTarget.transaction();
+            let os = tr.objectStore(this._inddbAb.persistentAudioStorageTarget.storeName);
+            // Positioning
+            let newCi = Math.floor(framePos / this._inddbAb.chunkFrameLen);
+            if (newCi !== this._currCi) {
+                this._currCi = newCi;
+                this._ccCache = null;
+            }
+            let srcFramePos = newCi * this._inddbAb.chunkFrameLen;
+            let trgState = { framePos: framePos, frameLen: frameLen, trgBufs: bufs, filled: 0 };
+            let srcState = { srcFramePos: srcFramePos, ci: newCi, ccPos: 0, ccFilled: 0 };
+            this.fillBufs(os, trgState, srcState, (val) => { }, (filled) => {
+                subscriber.next(filled);
+                subscriber.complete();
+            }, err => {
+                subscriber.error(err);
+            });
+        });
+    }
+    close() {
+        this._currCi = 0;
+        this._ccCache = null;
+    }
+}
+export class IndexedDbAudioInputStream {
+    constructor(inddbAb) {
+        this.inddbAb = inddbAb;
+        this.framePos = 0;
+        this.inddbAbStr = new IndexedDbRandomAccessStream(inddbAb);
+    }
+    close() {
+        this.inddbAbStr.close();
+    }
+    readObs(buffers) {
+        return new Observable(subscr => {
+            if (buffers && buffers.length > 0) {
+                let fl = buffers[0].length;
+                this.inddbAbStr.framesObs(this.framePos, fl, buffers).subscribe({
+                    next: (read) => {
+                        this.framePos += read;
+                        subscr.next(read);
+                    },
+                    complete: () => {
+                        subscr.complete();
+                    },
+                    error: (err) => {
+                        subscr.error(err);
+                    }
+                });
+            }
+            else {
+                subscr.next(0);
+                subscr.complete();
+            }
+        });
+    }
+    skipFrames(n) {
+        this.framePos += n;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inddb_audio_buffer.js","sourceRoot":"","sources":["../../../../../projects/speechrecorderng/src/lib/audio/inddb_audio_buffer.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable} from \"rxjs\";\r\nimport {AsyncFloat32ArrayInputStream, Float32ArrayInputStream} from \"../io/stream\";\r\nimport {UUID} from \"../utils/utils\";\r\nimport {AudioSource, BasicAudioSource, RandomAccessAudioStream} from \"./audio_data_holder\";\r\n\r\nexport class PersistentAudioStorageTarget{\r\n  get indexedDb(): IDBDatabase {\r\n    return this._indexedDb;\r\n  }\r\n\r\n  get storeName(): string {\r\n    return this._storeName;\r\n  }\r\n  constructor(private _indexedDb:IDBDatabase,private _storeName:string) {\r\n  }\r\n\r\n  transaction(mode?:IDBTransactionMode):IDBTransaction{\r\n    return this._indexedDb.transaction(this.storeName, mode);\r\n  }\r\n\r\n  objectStore(mode?:IDBTransactionMode ){\r\n    let tr=this.transaction(mode);\r\n    return tr.objectStore(this._storeName);\r\n  }\r\n\r\n  deleteAll():Observable<void>{\r\n    return new Observable<void>(subscriber => {\r\n      let os = this.objectStore('readwrite');\r\n      let clearReq=os.clear();\r\n      clearReq.onsuccess=()=>{\r\n        console.debug(\"Cleared audio storage object store.\");\r\n        os.transaction.commit();\r\n      }\r\n      clearReq.onerror=()=>{\r\n        os.transaction.abort();\r\n        console.error(\"Could not clear object store: \"+clearReq.error);\r\n      }\r\n      os.transaction.oncomplete = () => {\r\n        console.debug(\"Transaction complete: Clear audio storage object store.\");\r\n          subscriber.complete();\r\n      }\r\n      os.transaction.onerror = (err) => {\r\n          subscriber.error(err);\r\n      }\r\n    });\r\n  }\r\n\r\n}\r\n\r\nexport class IndexedDbAudioBuffer extends BasicAudioSource implements AudioSource{\r\n  get chunkFrameLen(): number {\r\n    return this._chunkFrameLen;\r\n  }\r\n  get persistentAudioStorageTarget(): PersistentAudioStorageTarget {\r\n    return this._persistentAudioStorageTarget;\r\n  }\r\n  get uuid(): string {\r\n    return this._uuid;\r\n  }\r\n\r\n\r\n  private _chunkCount=0;\r\n  private indDbChkIdx: number=0;\r\n  private _sealed=false;\r\n  private _storeError:Error|null=null;\r\n\r\n\r\n  constructor(private _persistentAudioStorageTarget:PersistentAudioStorageTarget,private _channelCount: number, private _sampleRate: number,private _chunkFrameLen:number,private _frameLen:number, private _uuid:string) {\r\n    super();\r\n    this.ready();\r\n  }\r\n\r\n  get channelCount(): number {\r\n    return this._channelCount;\r\n  }\r\n\r\n  sealed(): boolean {\r\n    return this._sealed;\r\n  }\r\n\r\n  seal():void{\r\n    this._sealed=true;\r\n  }\r\n\r\n  private deleteChunk(os:IDBObjectStore,ci:number,cb:(keys:IDBValidKey[])=>void,errCb:(err:Error)=>void){\r\n\r\n    // Build bounds for channels\r\n    let lIdx=[this._uuid,ci,0];\r\n    let hIdx=[this._uuid,ci,this._channelCount];\r\n    let chsKr=IDBKeyRange.bound(lIdx,hIdx);\r\n\r\n    let exRq=os.getAllKeys(chsKr);\r\n\r\n    exRq.onsuccess=()=>{\r\n      let cc=exRq.result;\r\n      if(cc && cc.length>0) {\r\n        let rq = os.delete(chsKr);\r\n        rq.onerror=(errEv)=>{\r\n          errCb(new Error(errEv.toString()));\r\n        }\r\n        os.transaction.oncomplete=()=>{\r\n          cb(cc);\r\n        }\r\n        os.transaction.commit();\r\n      }\r\n    }\r\n    exRq.onerror=(errEv)=>{\r\n      errCb(new Error(errEv.toString()));\r\n    }\r\n\r\n  }\r\n\r\n  private deleteAllBufs(os:IDBObjectStore,ci:number,cbEnd:()=>void,cbErr:(err:Error)=>void){\r\n    //console.debug('IndexedDbAudioBuffer::fillBufs: framePos:'+framePos+', frameLen: '+frameLen+', filled: '+filled+', srcFramePos: '+srcFramePos+',ci: '+ci+', ccPos: '+ccPos);\r\n    this.deleteChunk(os,ci,(ccKeys)=>{\r\n      if(ccKeys && ccKeys.length>0){\r\n        //console.debug('IndexedDbAudioBuffer::fillBufs frameLen: '+frameLen);\r\n        ci++;\r\n        this.deleteAllBufs(os,ci,cbEnd, cbErr);\r\n      }else{\r\n        //console.debug('IndexedDbAudioBuffer::fillBufs (chunk not found) call: cbend '+filled);\r\n        cbEnd();\r\n      }\r\n    },(err)=>{\r\n      cbErr(err);\r\n    });\r\n\r\n  }\r\n\r\n  get sampleRate(): number {\r\n    return this._sampleRate;\r\n  }\r\n\r\n  get frameLen(): number {\r\n    return this._frameLen;\r\n  }\r\n\r\n  get chunkCount(): number {\r\n    return this._chunkCount;\r\n  }\r\n\r\n  appendRawAudioData(data:Array<Array<Float32Array>>):Observable<void>{\r\n\r\n  return new Observable<void>(subscriber => {\r\n\r\n    if (this._persistentAudioStorageTarget && this._uuid) {\r\n      let tr = this._persistentAudioStorageTarget.indexedDb.transaction(this._persistentAudioStorageTarget.storeName, 'readwrite');\r\n      let recFileObjStore = tr.objectStore(this._persistentAudioStorageTarget.storeName);\r\n\r\n      try {\r\n        let ch0Data = data[0];\r\n        let dataChkCnt = ch0Data.length;\r\n        let pos = 0;\r\n        for (let chCkIdx = 0; chCkIdx < dataChkCnt; chCkIdx++) {\r\n          let bufLen = 0;\r\n          for (let ch = 0; ch < this.channelCount; ch++) {\r\n            let chChk = data[ch][chCkIdx];\r\n            bufLen = chChk.length;\r\n            //let cacheId = uuid + '_' + ch + '_' + chCkIdx;\r\n            let chkDbId = [this._uuid, this.indDbChkIdx + chCkIdx, ch];\r\n            let cr = recFileObjStore.add(chChk, chkDbId);\r\n            //console.debug(\"Added: \"+ch+\" \"+(this.indDbChkIdx+chCkIdx));\r\n            cr.onsuccess = () => {\r\n              //console.debug(\"Stored audio data to indexed db\");\r\n              // if(chCkIdx>= dataChkCnt-1 && ch>=this.channelCount-1){\r\n              //   tr.commit();\r\n              // }\r\n            }\r\n            cr.onerror = () => {\r\n              if(!this._storeError) {\r\n                // Only log the first error\r\n                console.error(\"Error storing audio data of \" + chChk.byteLength + \" bytes to indexed db: \" + cr.error);\r\n              }\r\n            }\r\n          }\r\n          pos += bufLen;\r\n          this._frameLen+=bufLen;\r\n        }\r\n        this.indDbChkIdx += dataChkCnt;\r\n\r\n        tr.onerror = (ev) => {\r\n          if(!this._storeError) {\r\n            // Only log the first error\r\n            console.error(\"Failed to store audio data to indexed db, transaction error: \"+tr.error);\r\n            this._storeError = tr.error;\r\n          }\r\n          subscriber.error(tr.error);\r\n        }\r\n        tr.onabort=(ev)=>{\r\n          // If Chrome reaches quota it aborts the transaction\r\n          if(!this._storeError) {\r\n            // Only log the first error\r\n            console.error(\"Failed to store audio data to indexed db, transaction aborted: \"+tr.error);\r\n            this._storeError = tr.error;\r\n          }\r\n          subscriber.error(tr.error);\r\n        }\r\n        tr.oncomplete = (ev) => {\r\n          subscriber.complete();\r\n        }\r\n        tr.commit();\r\n      } catch (err) {\r\n        subscriber.error(new Error('Transfer audio data error: ' + err));\r\n      }\r\n    }\r\n  });\r\n  }\r\n\r\n  static fromChunkAudioBuffer(persistentAudioStorageTarget:PersistentAudioStorageTarget ,audioBuffer:AudioBuffer):Observable<IndexedDbAudioBuffer>{\r\n\r\n    return new Observable<IndexedDbAudioBuffer>(subscriber => {\r\n      let chs = audioBuffer.numberOfChannels;\r\n      let sr = audioBuffer.sampleRate;\r\n      let chkFrameLength = audioBuffer.length;\r\n\r\n      let iab = new IndexedDbAudioBuffer(persistentAudioStorageTarget, chs, sr, chkFrameLength, 0, UUID.generate());\r\n      iab.appendChunkAudioBuffer(audioBuffer).subscribe(\r\n        {\r\n          next: ()=>{\r\n            subscriber.next(iab);\r\n          },\r\n          complete: () => {\r\n            subscriber.complete();\r\n          },\r\n          error: (err)=>{\r\n            subscriber.error(err);\r\n          }\r\n        }\r\n      )\r\n    });\r\n  }\r\n\r\n  appendChunkAudioBuffer(audioBuffer:AudioBuffer){\r\n    if(this._sealed){\r\n      throw new Error('Cannot append audio buffer to already sealed audio buffer.');\r\n    }\r\n    let chs=audioBuffer.numberOfChannels;\r\n    if(this._channelCount!== chs){\r\n      throw new Error('Cannot append audio buffer with '+chs+' channels to this array audio buffer with '+this._channelCount+' channels. Number of channels must match.');\r\n    }\r\n    let sr=audioBuffer.sampleRate;\r\n    if(sr!==this._sampleRate){\r\n      throw new Error('Cannot append audio buffer with samplerate '+sr+' to this array audio buffer with samplerate '+this._sampleRate+'. Samplerates must match.');\r\n    }\r\n\r\n    let abFl=audioBuffer.length;\r\n    if(abFl>this._chunkFrameLen){\r\n      throw new Error('Cannot append audio buffer with frame length '+abFl+' to this array audio buffer with chunk frame length '+this._chunkFrameLen+'. Chunk length must be equal or less if last chunk.');\r\n    }\r\n    return new Observable<void>(subscriber => {\r\n      if (this._persistentAudioStorageTarget && this._uuid) {\r\n        let tr = this._persistentAudioStorageTarget.transaction('readwrite');\r\n        let recFileObjStore = tr.objectStore(this._persistentAudioStorageTarget.storeName);\r\n        try {\r\n\r\n            for (let ch = 0; ch < this.channelCount; ch++) {\r\n              let chChk = audioBuffer.getChannelData(ch);\r\n              let chkDbId = [this._uuid, this.indDbChkIdx++, ch];\r\n              try {\r\n                let cr = recFileObjStore.add(chChk, chkDbId);\r\n                cr.onsuccess = (ev) => {}\r\n                cr.onerror = (ev) => {\r\n                  // iPad may throw QuotaExceededError here\r\n                  // iPad asks for more storage and if denied, the error is thrown here\r\n                  if(!this._storeError) {\r\n                    // Only log the first error\r\n                    console.error(\"Error storing audio data of \" + chChk.byteLength + \" bytes to indexed db: \" + cr.error);\r\n                  }\r\n                  //subscriber.error(cr.error);\r\n                }\r\n              }catch(err1:any){\r\n                if(!this._storeError) {\r\n                  console.error(\"Error adding audio data to indexed db store: \" + err1);\r\n                  this._storeError=(err1 instanceof Error)?err1:new Error(err1);\r\n                }\r\n                subscriber.error(err1);\r\n              }\r\n            }\r\n            this._frameLen+=abFl;\r\n\r\n          tr.onerror = (ev) => {\r\n            if(!this._storeError) {\r\n              // Only log the first error\r\n              console.error(\"Failed to store audio data to indexed db, transaction error: \"+tr.error);\r\n              this._storeError = tr.error;\r\n            }\r\n            subscriber.error(tr.error);\r\n          }\r\n          tr.onabort=(ev)=>{\r\n            // If Chrome reaches quota it aborts the transaction\r\n            if(!this._storeError) {\r\n              // Only log the first error\r\n              console.error(\"Failed to store audio data to indexed db, transaction aborted: \"+tr.error);\r\n              this._storeError = tr.error;\r\n            }\r\n            subscriber.error(tr.error);\r\n          }\r\n          tr.oncomplete = (ev) => {\r\n            //console.debug(\"Transaction complete\");\r\n            if(abFl<this._chunkFrameLen){\r\n              // last chunk\r\n              this.seal();\r\n            }\r\n            subscriber.next();\r\n            subscriber.complete();\r\n          }\r\n          tr.commit();\r\n        } catch (err) {\r\n          console.error('Catched error: '+err);\r\n          subscriber.error(new Error('Transfer audio data error: ' + err));\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  releaseAudioData():Observable<void>{\r\n    return new Observable<void>((subscriber)=>{\r\n      let os=this._persistentAudioStorageTarget.objectStore('readwrite');\r\n      this.deleteAllBufs(os,0,()=>{\r\n        subscriber.next();\r\n        subscriber.complete();\r\n      },(err)=>{\r\n        subscriber.error(err);\r\n      })\r\n    });\r\n  }\r\n\r\n  toString():string{\r\n    return \"Indexed db audio buffer. Channels: \"+this.channelCount+\", sample rate: \"+this.sampleRate+\", chunk frame length: \"+this._chunkFrameLen+\", number of chunks: \"+this.chunkCount+\", frame length: \"+this.frameLen+\", sealed: \"+this.sealed();\r\n  }\r\n\r\n  asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null {\r\n    return new IndexedDbAudioInputStream(this);\r\n  }\r\n\r\n  audioInputStream(): Float32ArrayInputStream | null {\r\n    // Synchronous stream not supported\r\n    return null;\r\n  }\r\n\r\n  get duration(): number {\r\n    return this._chunkFrameLen/this._sampleRate;\r\n  }\r\n\r\n  get numberOfChannels(): number {\r\n    return this._channelCount;\r\n  }\r\n\r\n  sampleCounts(): number {\r\n    return this._channelCount*this._frameLen;\r\n  }\r\n\r\n  randomAccessAudioStream(): RandomAccessAudioStream {\r\n    return new IndexedDbRandomAccessStream(this);\r\n  }\r\n\r\n}\r\n\r\n\r\nexport class IndexedDbRandomAccessStream implements RandomAccessAudioStream{\r\n\r\n  private _currCi=0;\r\n  private _ccCache:Float32Array[]|null=null;\r\n\r\n  constructor(private _inddbAb:IndexedDbAudioBuffer) {\r\n  }\r\n\r\n  private chunk(os:IDBObjectStore,ci:number,cb:(bufs:Array<Float32Array>|null)=>void,errCb:(err:Error)=>void){\r\n\r\n    // Build bounds for channels\r\n    let lIdx=[this._inddbAb.uuid,ci,0];\r\n    let hIdx=[this._inddbAb.uuid,ci,this._inddbAb.channelCount];\r\n    let chsKr=IDBKeyRange.bound(lIdx,hIdx);\r\n\r\n    let rq=os.getAll(chsKr);\r\n\r\n    rq.onsuccess=()=>{\r\n      let cc=rq.result;\r\n      let cc0;\r\n      let ccChs=cc.length;\r\n      if(ccChs==0){\r\n        cb(null);\r\n        return;\r\n      }\r\n      if(ccChs!==this._inddbAb.channelCount){\r\n        errCb(new Error('Number of channels of inddb data ('+ccChs+') does not match number of channels ('+this._inddbAb.channelCount+')'));\r\n        return;\r\n                 }\r\n      if(cc.length>0){\r\n        cc0=cc[0];\r\n      }\r\n      let arrBuf=new Array<Float32Array>();\r\n      let ccLen=cc0.length;\r\n      for(let ch=0;ch<ccChs;ch++){\r\n        let chArr=new Float32Array(ccLen);\r\n        for(let si=0;si<ccLen;si++){\r\n          chArr[si]=cc[ch][si];\r\n        }\r\n        arrBuf.push(chArr);\r\n      }\r\n      cb(arrBuf);\r\n    }\r\n    rq.onerror=(errEv)=>{\r\n      errCb(new Error(errEv.toString()));\r\n    }\r\n\r\n  }\r\n\r\n  private _fillBufs(ccBufs:Float32Array[],trgState:{framePos:number,frameLen:number,trgBufs:Float32Array[],filled:number},srcState:{srcFramePos:number,ci:number,ccPos:number}){\r\n    let ccBufsChs=ccBufs.length;\r\n    if(ccBufsChs>0) {\r\n      let ccBuf0 = ccBufs[0];\r\n      let ccBufsLen = ccBuf0.length;\r\n\r\n      //console.debug('IndexedDbAudioBuffer::fillBufs framePos: '+framePos+', srcFramePos: '+srcFramePos+', ccBufsLen: '+ccBufsLen);\r\n      if (trgState.framePos >= srcState.srcFramePos + ccBufsLen) {\r\n        // target frame position is ahead, seek to next source buffer\r\n        //console.debug('IndexedDbAudioBuffer::fillBufs seek to next inddb buffer');\r\n        this._ccCache=null;\r\n        srcState.ci++;\r\n        srcState.ccPos=0;\r\n        srcState.srcFramePos+=ccBufsLen;\r\n      } else {\r\n        // Assuming target frame pos is inside current source buffer\r\n        srcState.ccPos=trgState.framePos-srcState.srcFramePos;\r\n        let ccAvail = ccBufsLen - srcState.ccPos;\r\n        let toCopy = ccBufsLen;\r\n\r\n        if (toCopy > ccAvail) {\r\n          toCopy = ccAvail;\r\n        }\r\n        if (toCopy > trgState.frameLen) {\r\n          toCopy = trgState.frameLen;\r\n        }\r\n        for (let ch = 0; ch < ccBufsChs; ch++) {\r\n          for (let si = 0; si < toCopy; si++) {\r\n            trgState.trgBufs[ch][trgState.filled+si] = ccBufs[ch][srcState.ccPos+si];\r\n          }\r\n        }\r\n        trgState.filled += toCopy;\r\n        trgState.frameLen -= toCopy;\r\n        trgState.framePos += toCopy;\r\n        srcState.ccPos += toCopy;\r\n        if (srcState.ccPos >= ccBufsLen) {\r\n          // Invalidate cache\r\n          this._ccCache=null;\r\n          srcState.ci++;\r\n          this._currCi=srcState.ci;\r\n          srcState.ccPos = 0;\r\n          srcState.srcFramePos+=ccBufsLen;\r\n        }\r\n      }\r\n    }\r\n\r\n  }\r\n\r\n  private fillBufs(os:IDBObjectStore,trgState:{framePos:number,frameLen:number,trgBufs:Float32Array[],filled:number},srcState:{srcFramePos:number,ci:number,ccPos:number,ccFilled:number},cb:(filled:number)=>void,cbEnd:(filled:number)=>void,cbErr:(err:Error)=>void){\r\n    //console.debug('IndexedDbAudioBuffer::fillBufs: framePos:'+trgState.framePos+', frameLen: '+trgState.frameLen+', filled: '+trgState.filled+', srcFramePos: '+srcState.srcFramePos+',ci: '+srcState.ci+', ccPos: '+srcState.ccPos);\r\n    if(this._ccCache){\r\n      this._fillBufs(this._ccCache,trgState,srcState);\r\n      //console.debug('IndexedDbAudioBuffer::fillBufs frameLen: '+trgState.frameLen);\r\n      if(trgState.frameLen===0){\r\n        //console.debug('IndexedDbAudioBuffer::fillBufs (framelen==0) call: cbend '+trgState.filled);\r\n        cbEnd(trgState.filled);\r\n      }else {\r\n        this.fillBufs(os, trgState, srcState, cb, cbEnd, cbErr);\r\n      }\r\n    }else {\r\n      this.chunk(os, srcState.ci, (ccBufs) => {\r\n        if (ccBufs) {\r\n          this._currCi = srcState.ci;\r\n          this._ccCache = ccBufs;\r\n\r\n          this._fillBufs(ccBufs, trgState, srcState);\r\n          //console.debug('IndexedDbAudioBuffer::fillBufs frameLen: '+trgState.frameLen);\r\n          if (trgState.frameLen === 0) {\r\n            //console.debug('IndexedDbAudioBuffer::fillBufs (framelen==0) call: cbend '+trgState.filled);\r\n            cbEnd(trgState.filled);\r\n          } else {\r\n            this.fillBufs(os,trgState, srcState, cb, cbEnd, cbErr);\r\n          }\r\n        } else {\r\n          //console.debug('IndexedDbAudioBuffer::fillBufs (chunk not found) call: cbend '+trgState.filled);\r\n          cbEnd(trgState.filled);\r\n        }\r\n      }, (err) => {\r\n        cbErr(err);\r\n      });\r\n    }\r\n  }\r\n\r\n\r\n  framesObs(framePos:number,frameLen:number,bufs:Float32Array[]):Observable<number>{\r\n    return new Observable<number>((subscriber)=>{\r\n      let tr=this._inddbAb.persistentAudioStorageTarget.transaction();\r\n      let os=tr.objectStore(this._inddbAb.persistentAudioStorageTarget.storeName);\r\n      // Positioning\r\n      let newCi=Math.floor(framePos/this._inddbAb.chunkFrameLen);\r\n      if(newCi!==this._currCi){\r\n        this._currCi=newCi;\r\n        this._ccCache=null;\r\n      }\r\n      let srcFramePos=newCi*this._inddbAb.chunkFrameLen;\r\n      let trgState={framePos:framePos,frameLen:frameLen,trgBufs:bufs,filled:0};\r\n      let srcState={srcFramePos:srcFramePos,ci:newCi,ccPos:0,ccFilled:0};\r\n      this.fillBufs(os,trgState,srcState,(val)=>{},(filled:number)=>{\r\n        subscriber.next(filled);\r\n        subscriber.complete();\r\n      },err => {\r\n        subscriber.error(err);\r\n      })\r\n    });\r\n  }\r\n\r\n  close(): void {\r\n    this._currCi=0;\r\n    this._ccCache=null;\r\n  }\r\n}\r\n\r\nexport class IndexedDbAudioInputStream implements AsyncFloat32ArrayInputStream{\r\n\r\n  private framePos:number=0;\r\n  private inddbAbStr:IndexedDbRandomAccessStream;\r\n  constructor(private inddbAb:IndexedDbAudioBuffer) {\r\n      this.inddbAbStr=new IndexedDbRandomAccessStream(inddbAb);\r\n  }\r\n\r\n  close(): void {\r\n    this.inddbAbStr.close();\r\n  }\r\n\r\n  readObs(buffers: Array<Float32Array>): Observable<number> {\r\n    return new Observable<number>(subscr=> {\r\n      if (buffers && buffers.length > 0) {\r\n        let fl = buffers[0].length;\r\n        this.inddbAbStr.framesObs(this.framePos, fl, buffers).subscribe({\r\n          next: (read) => {\r\n            this.framePos += read;\r\n            subscr.next(read);\r\n          },\r\n          complete: () => {\r\n            subscr.complete();\r\n          },\r\n          error: (err) => {\r\n            subscr.error(err);\r\n          }\r\n        })\r\n      }else{\r\n        subscr.next(0);\r\n        subscr.complete();\r\n      }\r\n    });\r\n  }\r\n\r\n  skipFrames(n: number):void {\r\n    this.framePos+=n;\r\n  }\r\n\r\n}\r\n"]}