speechrecorderng 3.6.0 → 3.8.0

package/esm2022/lib/speechrecorder/project/project.service.mjs

@@ -0,0 +1,64 @@
+/**
+ * Created by klausj on 17.06.2017.
+ */
+import { Inject, Injectable } from '@angular/core';
+import { ApiType, SPEECHRECORDER_CONFIG } from "../../spr.config";
+import { UUID } from "../../utils/utils";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/common";
+import * as i3 from "../../spr.config";
+export class ProjectService {
+    static { this.PROJECT_API_CTX = 'project'; }
+    constructor(http, platformLocation, config) {
+        this.http = http;
+        this.platformLocation = platformLocation;
+        this.config = config;
+        this.withCredentials = false;
+        console.log("Base Href: " + platformLocation.getBaseHrefFromDOM());
+        let apiEndPoint = '';
+        if (config && config.apiEndPoint) {
+            apiEndPoint = config.apiEndPoint;
+        }
+        if (apiEndPoint !== '') {
+            apiEndPoint = apiEndPoint + '/';
+        }
+        if (config != null && config.withCredentials != null) {
+            this.withCredentials = config.withCredentials;
+        }
+        this.projectCtxUrl = apiEndPoint + ProjectService.PROJECT_API_CTX;
+    }
+    appendRequestUUIDForDevelopmentServer(url) {
+        let resUrl = url;
+        if (this.config && this.config.apiType === ApiType.FILES) {
+            // for development and demo
+            // append UUID to make request URL unique to avoid localhost server caching
+            resUrl = resUrl + '.json?requestUUID=' + UUID.generate();
+        }
+        return resUrl;
+    }
+    projectUrl(id) {
+        let encPrjId = encodeURIComponent(id);
+        return this.appendRequestUUIDForDevelopmentServer(this.projectCtxUrl + '/' + encPrjId);
+    }
+    projectResourceUrl(projectId, relResourcePath) {
+        let encPrjId = encodeURIComponent(projectId);
+        // Use encodeURI here since the relatice resource path from recording scripts is already a URI
+        // encodeURIComponent function would encode the slashes and fetching the resource would fail
+        let encRelResPath = encodeURI(relResourcePath);
+        return this.projectCtxUrl + '/' + encPrjId + '/' + encRelResPath;
+    }
+    projectObservable(id) {
+        let prjUrl = this.projectUrl(id);
+        return this.http.get(prjUrl, { withCredentials: this.withCredentials });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: ProjectService, deps: [{ token: i1.HttpClient }, { token: i2.PlatformLocation }, { token: SPEECHRECORDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: ProjectService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: ProjectService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.PlatformLocation }, { type: i3.SpeechRecorderConfig, decorators: [{
+                    type: Inject,
+                    args: [SPEECHRECORDER_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/speechrecorder/recording.mjs

@@ -1,124 +1,124 @@
-import { UUID } from '../utils/utils';
-export class RecordingFileDescriptorImpl {
-    constructor() { }
-}
-export class RecordingFile {
-    constructor(uuid, sessionId, audioDataHolder) {
-        this.recordingFileId = null;
-        this.uuid = null;
-        this.serverPersisted = false;
-        this.date = null;
-        this._dateAsDateObj = null;
-        this.startedDate = null;
-        this._startedAsDateObj = null;
-        this.audioDataHolder = null;
-        this.session = null;
-        this.channels = null;
-        this.frames = null;
-        this.samplerate = null;
-        this.timeLength = null;
-        this.editSampleRate = null;
-        this.editStartFrame = null;
-        this.editEndFrame = null;
-        this.session = sessionId;
-        this.audioDataHolder = audioDataHolder;
-        if (audioDataHolder) {
-            this.frames = audioDataHolder.frameLen;
-            this.timeLength = audioDataHolder.duration;
-        }
-        this.uuid = uuid;
-    }
-    filenameString() {
-        let fns = '';
-        if (this.session) {
-            fns += this.session;
-            fns += '_';
-        }
-        fns += this.uuid;
-        return fns;
-    }
-    equals(otherRecordingFile) {
-        if (otherRecordingFile !== null) {
-            if (otherRecordingFile === this) {
-                return true;
-            }
-            if (otherRecordingFile.uuid === this.uuid) {
-                return true;
-            }
-        }
-        return false;
-    }
-    toString() {
-        return 'Recording file: UUID: ' + this.uuid + ', session: ' + this.session;
-    }
-}
-export class SprRecordingFile extends RecordingFile {
-    constructor(sessionId, itemcode, version, audioDataHolder) {
-        super(UUID.generate(), sessionId, audioDataHolder);
-        this.session = sessionId;
-        this.itemCode = itemcode;
-        this.version = version;
-    }
-    recordingFileDone() {
-        return (this.serverPersisted === true) || (this.audioDataHolder != null);
-    }
-    filenameString() {
-        let fns = '';
-        if (this.session) {
-            fns += this.session;
-            fns += '_';
-        }
-        if (this.itemCode) {
-            fns += this.itemCode;
-            fns += '_';
-        }
-        fns += this.uuid;
-        return fns;
-    }
-    toString() {
-        return 'Recording file: UUID: ' + this.uuid + ', session: ' + this.session + ', itemcode: ' + this.itemCode + ', version: ' + this.version + ', UUID: ' + this.uuid;
-    }
-}
-export class RecordingFileUtils {
-    static equals(recordinFile, otherRecordingFile) {
-        if (recordinFile && otherRecordingFile) {
-            if (otherRecordingFile === recordinFile) {
-                return true;
-            }
-            if (otherRecordingFile.uuid === recordinFile.uuid) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static setAudioData(rf, audioDataHolder) {
-        rf.audioDataHolder = audioDataHolder;
-        if (audioDataHolder) {
-            if (rf.samplerate == null) {
-                rf.samplerate = audioDataHolder.sampleRate;
-            }
-            if (rf.frames == null) {
-                rf.frames = audioDataHolder.frameLen;
-            }
-            rf.timeLength = audioDataHolder.duration;
-        }
-    }
-    static sampleCount(rf) {
-        if (rf.audioDataHolder) {
-            return rf.audioDataHolder.sampleCounts();
-        }
-        else {
-            return 0;
-        }
-    }
-    static expireAudioData(rf) {
-        let expiredSamples = 0;
-        if (rf && rf.audioDataHolder) {
-            expiredSamples = rf.audioDataHolder.sampleCounts();
-            rf.audioDataHolder.releaseAudioData();
-            rf.audioDataHolder = null;
-        }
-        return expiredSamples;
-    }
-}
+import { UUID } from '../utils/utils';
+export class RecordingFileDescriptorImpl {
+    constructor() { }
+}
+export class RecordingFile {
+    constructor(uuid, sessionId, audioDataHolder) {
+        this.recordingFileId = null;
+        this.uuid = null;
+        this.serverPersisted = false;
+        this.date = null;
+        this._dateAsDateObj = null;
+        this.startedDate = null;
+        this._startedAsDateObj = null;
+        this.audioDataHolder = null;
+        this.session = null;
+        this.channels = null;
+        this.frames = null;
+        this.samplerate = null;
+        this.timeLength = null;
+        this.editSampleRate = null;
+        this.editStartFrame = null;
+        this.editEndFrame = null;
+        this.session = sessionId;
+        this.audioDataHolder = audioDataHolder;
+        if (audioDataHolder) {
+            this.frames = audioDataHolder.frameLen;
+            this.timeLength = audioDataHolder.duration;
+        }
+        this.uuid = uuid;
+    }
+    filenameString() {
+        let fns = '';
+        if (this.session) {
+            fns += this.session;
+            fns += '_';
+        }
+        fns += this.uuid;
+        return fns;
+    }
+    equals(otherRecordingFile) {
+        if (otherRecordingFile !== null) {
+            if (otherRecordingFile === this) {
+                return true;
+            }
+            if (otherRecordingFile.uuid === this.uuid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    toString() {
+        return 'Recording file: UUID: ' + this.uuid + ', session: ' + this.session;
+    }
+}
+export class SprRecordingFile extends RecordingFile {
+    constructor(sessionId, itemcode, version, audioDataHolder) {
+        super(UUID.generate(), sessionId, audioDataHolder);
+        this.session = sessionId;
+        this.itemCode = itemcode;
+        this.version = version;
+    }
+    recordingFileDone() {
+        return (this.serverPersisted === true) || (this.audioDataHolder != null);
+    }
+    filenameString() {
+        let fns = '';
+        if (this.session) {
+            fns += this.session;
+            fns += '_';
+        }
+        if (this.itemCode) {
+            fns += this.itemCode;
+            fns += '_';
+        }
+        fns += this.uuid;
+        return fns;
+    }
+    toString() {
+        return 'Recording file: UUID: ' + this.uuid + ', session: ' + this.session + ', itemcode: ' + this.itemCode + ', version: ' + this.version + ', UUID: ' + this.uuid;
+    }
+}
+export class RecordingFileUtils {
+    static equals(recordinFile, otherRecordingFile) {
+        if (recordinFile && otherRecordingFile) {
+            if (otherRecordingFile === recordinFile) {
+                return true;
+            }
+            if (otherRecordingFile.uuid === recordinFile.uuid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static setAudioData(rf, audioDataHolder) {
+        rf.audioDataHolder = audioDataHolder;
+        if (audioDataHolder) {
+            if (rf.samplerate == null) {
+                rf.samplerate = audioDataHolder.sampleRate;
+            }
+            if (rf.frames == null) {
+                rf.frames = audioDataHolder.frameLen;
+            }
+            rf.timeLength = audioDataHolder.duration;
+        }
+    }
+    static sampleCount(rf) {
+        if (rf.audioDataHolder) {
+            return rf.audioDataHolder.sampleCounts();
+        }
+        else {
+            return 0;
+        }
+    }
+    static expireAudioData(rf) {
+        let expiredSamples = 0;
+        if (rf && rf.audioDataHolder) {
+            expiredSamples = rf.audioDataHolder.sampleCounts();
+            rf.audioDataHolder.releaseAudioData();
+            rf.audioDataHolder = null;
+        }
+        return expiredSamples;
+    }
+}
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recording.js","sourceRoot":"","sources":["../../../../../projects/speechrecorderng/src/lib/speechrecorder/recording.ts"],"names":[],"mappings":"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","sourcesContent":["import { UUID } from '../utils/utils'\r\nimport {PromptItem} from \"./script/script\";\r\nimport {AudioDataHolder} from \"../audio/audio_data_holder\";\r\n\r\n// TODO I think the interface/class structure needs some refactoring\r\n// The question in general is how to fetch an object of a class (with member methods)\r\n// https://stackoverflow.com/questions/50452431/angular-6-httpclient-return-instance-of-class\r\n// Angular HTTPClient seems to simply\r\n// https://stackoverflow.com/questions/47499324/angular-5-models-httpclient-type-casting\r\n\r\nexport interface RecordingFileDescriptor {\r\n  recording:PromptItem;\r\n  version:number;\r\n}\r\n\r\nexport class RecordingFileDescriptorImpl {\r\n  recording!:PromptItem;\r\n  version!:number;\r\n  frames?:number;\r\n  samplerate?:number;\r\n  channels?: number;\r\n  constructor() {}\r\n}\r\n\r\nexport class RecordingFile {\r\n  recordingFileId: string | number | null= null;\r\n  uuid:string|null=null;\r\n  serverPersisted=false;\r\n  date: string|null=null;\r\n  _dateAsDateObj:Date|null=null;\r\n  startedDate: string|null=null;\r\n  _startedAsDateObj?:Date|null=null;\r\n  audioDataHolder:AudioDataHolder|null=null;\r\n  session:string|number|null=null;\r\n  channels:number|null=null;\r\n  frames:number|null=null;\r\n  samplerate:number|null=null;\r\n  timeLength:number|null=null;\r\n  editSampleRate:number|null=null;\r\n  editStartFrame:number|null=null\r\n  editEndFrame:number|null=null\r\n\r\n  constructor(uuid:string,sessionId:string|number,audioDataHolder:AudioDataHolder|null) {\r\n    this.session=sessionId;\r\n    this.audioDataHolder=audioDataHolder\r\n    if(audioDataHolder){\r\n      this.frames=audioDataHolder.frameLen;\r\n      this.timeLength=audioDataHolder.duration;\r\n    }\r\n    this.uuid=uuid;\r\n  }\r\n\r\n  filenameString():string{\r\n    let fns:string='';\r\n    if(this.session){\r\n      fns+=this.session;\r\n      fns+='_';\r\n    }\r\n    fns+=this.uuid;\r\n    return fns;\r\n  }\r\n\r\n  equals(otherRecordingFile:RecordingFile|null):boolean{\r\n    if(otherRecordingFile!==null) {\r\n      if (otherRecordingFile === this) {\r\n        return true;\r\n      }\r\n      if (otherRecordingFile.uuid === this.uuid) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  toString():string{\r\n    return 'Recording file: UUID: '+this.uuid+', session: '+this.session;\r\n  }\r\n\r\n}\r\n\r\n    export class SprRecordingFile extends RecordingFile implements  RecordingFileDescriptor{\r\n\r\n      itemCode:string;\r\n\r\n      recording!:PromptItem;\r\n      version!:number;\r\n\r\n      constructor(sessionId:string|number,itemcode:string,version:number,audioDataHolder:AudioDataHolder|null) {\r\n          super(UUID.generate(),sessionId,audioDataHolder);\r\n          this.session=sessionId;\r\n          this.itemCode=itemcode;\r\n          this.version=version;\r\n      }\r\n\r\n      recordingFileDone():boolean{\r\n        return (this.serverPersisted===true) || (this.audioDataHolder!=null);\r\n      }\r\n\r\n      filenameString():string{\r\n        let fns:string='';\r\n        if(this.session){\r\n            fns+=this.session;\r\n            fns+='_';\r\n        }\r\n        if(this.itemCode){\r\n          fns+=this.itemCode;\r\n          fns+='_';\r\n        }\r\n        fns+=this.uuid;\r\n        return fns;\r\n      }\r\n\r\n      toString():string{\r\n        return 'Recording file: UUID: '+this.uuid+', session: '+this.session+', itemcode: '+this.itemCode+', version: '+this.version+', UUID: '+this.uuid;\r\n      }\r\n\r\n    }\r\n\r\n    export class RecordingFileUtils{\r\n\r\n      static equals(recordinFile:RecordingFile|null,otherRecordingFile:RecordingFile|null):boolean{\r\n        if(recordinFile && otherRecordingFile){\r\n          if (otherRecordingFile === recordinFile) {\r\n            return true;\r\n          }\r\n          if (otherRecordingFile.uuid === recordinFile.uuid) {\r\n            return true;\r\n          }\r\n        }\r\n        return false;\r\n      }\r\n\r\n      static setAudioData(rf:RecordingFile,audioDataHolder:AudioDataHolder|null){\r\n          rf.audioDataHolder=audioDataHolder;\r\n          if(audioDataHolder) {\r\n            if(rf.samplerate==null){\r\n              rf.samplerate=audioDataHolder.sampleRate;\r\n            }\r\n            if(rf.frames==null) {\r\n              rf.frames = audioDataHolder.frameLen;\r\n            }\r\n            rf.timeLength=audioDataHolder.duration;\r\n          }\r\n      }\r\n\r\n      static sampleCount(rf:RecordingFile):number{\r\n        if(rf.audioDataHolder){\r\n          return rf.audioDataHolder.sampleCounts();\r\n        }else{\r\n          return 0;\r\n        }\r\n      }\r\n      static expireAudioData(rf:RecordingFile):number{\r\n        let expiredSamples=0;\r\n        if(rf && rf.audioDataHolder){\r\n          expiredSamples=rf.audioDataHolder.sampleCounts();\r\n          rf.audioDataHolder.releaseAudioData()\r\n          rf.audioDataHolder=null;\r\n        }\r\n        return expiredSamples;\r\n      }\r\n\r\n    }\r\n"]}

package/esm2022/lib/speechrecorder/recordings/basic_recording.service.mjs

@@ -0,0 +1,218 @@
+var BasicRecordingService_1;
+import { __decorate, __param } from "tslib";
+import { HttpHeaders } from "@angular/common/http";
+import { Inject } from "@angular/core";
+import { ApiType, SPEECHRECORDER_CONFIG } from "../../spr.config";
+import { Observable } from "rxjs";
+import { NetAudioBuffer } from "../../audio/net_audio_buffer";
+import { UUID } from "../../utils/utils";
+import { WavReader } from "../../audio/impl/wavreader";
+import { AudioContextProvider } from "../../audio/context";
+export class ChunkDownload {
+    get orgPCMAudioFormat() {
+        return this._orgPCMAudioFormat;
+    }
+    get orgFrameLength() {
+        return this._orgFrameLength;
+    }
+    get decodedAudioBuffer() {
+        return this._decodedAudioBuffer;
+    }
+    constructor(_orgPCMAudioFormat, _orgFrameLength, _decodedAudioBuffer) {
+        this._orgPCMAudioFormat = _orgPCMAudioFormat;
+        this._orgFrameLength = _orgFrameLength;
+        this._decodedAudioBuffer = _decodedAudioBuffer;
+    }
+}
+let BasicRecordingService = class BasicRecordingService {
+    static { BasicRecordingService_1 = this; }
+    // iPad 9th generation, iOS 15.7.1, sometimes:
+    // Failed to load resource: WebKit hat einen internen Fehler festgestellt
+    // Firefox on Windows crashes
+    static { this.DEFAULT_CHUNKED_DOWNLOAD_SECONDS = 10; }
+    static { this.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES = 2880000 * 5; } // Default 5 minutes one channel at 48kHz
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        this._maxAutoNetMemStoreSamples = BasicRecordingService_1.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES;
+        this.withCredentials = false;
+        this.apiEndPoint = '';
+        if (config && config.apiEndPoint) {
+            this.apiEndPoint = config.apiEndPoint;
+        }
+        if (this.apiEndPoint !== '') {
+            this.apiEndPoint = this.apiEndPoint + '/';
+        }
+        if (config != null && config.withCredentials != null) {
+            this.withCredentials = config.withCredentials;
+        }
+    }
+    audioRequestByURL(audioBaseUrl, audioURLSearchParams) {
+        let audioUrl = audioBaseUrl;
+        if (this.config && this.config.apiType === ApiType.FILES) {
+            // for development and demo
+            audioUrl = audioUrl + '.wav';
+            // append UUID to make request URL unique to avoid localhost server caching
+            audioURLSearchParams.set('requestUUID', UUID.generate());
+            //audioUrl = audioUrl + '.wav?requestUUID=' + UUID.generate();
+        }
+        audioUrl = audioUrl + '?' + audioURLSearchParams.toString();
+        let headers = new HttpHeaders();
+        headers = headers.set('Accept', 'audio/wav');
+        return this.http.get(audioUrl, {
+            headers: headers,
+            observe: 'response',
+            responseType: 'arraybuffer',
+            withCredentials: this.withCredentials
+        });
+    }
+    chunkAudioRequest(baseAudioUrl, startFrame = 0, frameLength) {
+        let ausps = new URLSearchParams();
+        ausps.set('startFrame', startFrame.toString());
+        ausps.set('frameLength', frameLength.toString());
+        if (this.config && this.config.apiType === ApiType.FILES) {
+            // for development and demo
+            // append UUID to make request URL unique to avoid localhost server caching
+            //audioUrl = audioUrl + '.wav?requestUUID=' + UUID.generate();
+            ausps.set('requestUUID', UUID.generate());
+        }
+        let obs = new Observable(observer => {
+            this.audioRequestByURL(baseAudioUrl, ausps).subscribe({
+                next: resp => {
+                    // Do not use Promise version, which does not work with Safari 13 (13.0.5)
+                    if (resp.body) {
+                        //console.debug("chunkAudioRequest: observer.closed: "+observer.closed);
+                        //console.debug("Audio file bytes: "+resp.body.byteLength);
+                        // Check original audio format
+                        let wr = new WavReader(resp.body);
+                        const pcmFmt = wr.readFormat();
+                        const orgFl = wr.frameLength();
+                        // if(pcmFmt){
+                        //   console.debug("Original WAVE format of download chunk: "+pcmFmt);
+                        // }else{
+                        //   console.error("Could not read WAVE format of original download chunk!");
+                        // }
+                        // if(orgFl){
+                        //   console.debug("Original frame length of download chunk: "+orgFl);
+                        // }else{
+                        //   console.error("Could not read WAVE format of original download chunk!");
+                        // }
+                        if (pcmFmt && orgFl) {
+                            AudioContextProvider.decodeAudioData(resp.body).then((ab) => {
+                                //console.debug("Decoded audio chunk frames: "+ab.length);
+                                let chDl = new ChunkDownload(pcmFmt, orgFl, ab);
+                                observer.next(chDl);
+                                observer.complete();
+                            }).catch(error => {
+                                //if(error instanceof HttpErrorResponse) {
+                                // if (error.status == 404) {
+                                //   // Interpret not as an error, the file ist not recorded yet
+                                //   observer.next(null);
+                                //   observer.complete()
+                                // } else {
+                                //   // all other states are errors
+                                console.error("Recordings service chunkAudioRequest error decoding audio data: " + error.name + ": " + error.message);
+                                observer.error(error);
+                                // }
+                                // }
+                            });
+                        }
+                        else {
+                            const errMsg = 'Could not parse audio header for format and/or frame length of download.';
+                            console.error(errMsg);
+                            observer.error(errMsg);
+                        }
+                    }
+                    else {
+                        const errMsg = 'Fetching audio file: response has no body';
+                        console.error(errMsg);
+                        observer.error(errMsg);
+                    }
+                }, error: (error) => {
+                    // all other states are errors
+                    //const errMsg='Fetching audio file HTTP error: '+error;
+                    //console.error(errMsg);
+                    observer.error(error);
+                    //observer.complete();
+                }
+            });
+        });
+        return obs;
+    }
+    chunkAudioRequestToNetAudioBuffer(baseAudioUrl, startFrame = 0, orgSampleRate, seconds, frames) {
+        //let audioUrl=baseAudioUrl+'?startFrame='+startFrame+'&frameLength='+frameLength;
+        //let audioUrl=new URL(baseAudioUrl);
+        // if(orgSampleRate!=null && frameLength%orgSampleRate>0){
+        //   const errMsg='frameLength must be equal or multiple of original samplerate.';
+        //   console.error(errMsg+' ('+frameLength+'%'+orgSampleRate+'=='+(frameLength%orgSampleRate)+')');
+        //   throw Error(errMsg)
+        // }
+        let frameLength = orgSampleRate * Math.round(seconds);
+        let ausps = new URLSearchParams();
+        ausps.set('startFrame', startFrame.toString());
+        ausps.set('frameLength', frameLength.toString());
+        if (this.config && this.config.apiType === ApiType.FILES) {
+            // for development and demo
+            // append UUID to make request URL unique to avoid localhost server caching
+            //audioUrl = audioUrl + '.wav?requestUUID=' + UUID.generate();
+            ausps.set('requestUUID', UUID.generate());
+        }
+        let obs = new Observable(subscriber => {
+            this.audioRequestByURL(baseAudioUrl, ausps).subscribe({ next: (resp) => {
+                    // Do not use Promise version, which does not work with Safari 13 (13.0.5)
+                    if (resp.body) {
+                        //console.debug("chunkAudioRequestTonetAb: subscriber.closed: "+subscriber.closed);
+                        //console.debug("chunkAudioRequestTonetAb: Audio file bytes: "+resp.body.byteLength);
+                        AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                            //console.debug("chunkAudioRequestTonetAb: Decoded audio chunk frames for netAb: "+ab.length);
+                            //console.debug("chunkAudioRequestTonetAb: Create netAb ab from chunk ab...");
+                            if (frames === null) {
+                                subscriber.error(new Error('Could not get frame length from recording file object'));
+                            }
+                            else {
+                                let fl = frames;
+                                if (ab.sampleRate !== orgSampleRate) {
+                                    if (orgSampleRate && frames) {
+                                        fl = Math.round(ab.sampleRate * frames / orgSampleRate);
+                                        //console.debug("Platform sr: "+ab.sampleRate+", file sr: "+orgSampleRate+", decoded/org frame length: "+fl+"/"+frames+", ab.length: "+ab.length);
+                                    }
+                                }
+                                let nab = NetAudioBuffer.fromChunkAudioBuffer(this, baseAudioUrl, ab, fl, frameLength);
+                                //let rp=new ReadyProvider();
+                                //nab.readyProvider=rp;
+                                //rp.ready();
+                                nab.ready();
+                                if (nab.frameLen < frameLength) {
+                                    //console.debug("chunkAudioRequestTonetAb: Built netAb ab from chunk ab: First chunk shorter tha frameLength ("+netAbAudioBuffer.frameLen+"<"+frameLength+"), assuming end of data, sealing netAb ab.");
+                                    nab.seal();
+                                }
+                                subscriber.next(nab);
+                                subscriber.complete();
+                            }
+                        }).catch(error => {
+                            console.error('chunkAudioRequestToNetAb: error: ' + error);
+                            //if(error instanceof HttpErrorResponse) {
+                            subscriber.error(error);
+                            //}
+                        });
+                    }
+                    else {
+                        console.error('chunkAudioRequestToNetAb: Fetching audio file: response has no body');
+                        subscriber.error('chunkAudioRequestToNetAb: Fetching audio file: response has no body');
+                    }
+                },
+                error: (error) => {
+                    console.error('chunkAudioRequestToNetAb: error: ' + error);
+                    subscriber.error(error);
+                    //subscriber.complete();
+                }
+            });
+        });
+        return obs;
+    }
+};
+BasicRecordingService = BasicRecordingService_1 = __decorate([
+    __param(1, Inject(SPEECHRECORDER_CONFIG))
+], BasicRecordingService);
+export { BasicRecordingService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"basic_recording.service.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/speechrecorder/recordings/basic_recording.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpClient, HttpHeaders, HttpResponse} from \"@angular/common/http\";\r\nimport {Inject} from \"@angular/core\";\r\nimport {ApiType, SPEECHRECORDER_CONFIG, SpeechRecorderConfig} from \"../../spr.config\";\r\nimport {Observable} from \"rxjs\";\r\nimport {NetAudioBuffer} from \"../../audio/net_audio_buffer\";\r\nimport {UUID} from \"../../utils/utils\";\r\nimport {WavReader} from \"../../audio/impl/wavreader\";\r\nimport {PCMAudioFormat} from \"../../audio/format\";\r\nimport {AudioContextProvider} from \"../../audio/context\";\r\n\r\nexport class ChunkDownload{\r\n  get orgPCMAudioFormat(): PCMAudioFormat {\r\n    return this._orgPCMAudioFormat;\r\n  }\r\n\r\n  get orgFrameLength(): number {\r\n    return this._orgFrameLength;\r\n  }\r\n\r\n  get decodedAudioBuffer(): AudioBuffer {\r\n    return this._decodedAudioBuffer;\r\n  }\r\n  constructor(private _orgPCMAudioFormat:PCMAudioFormat,private _orgFrameLength:number,private _decodedAudioBuffer:AudioBuffer){}\r\n}\r\n\r\nexport class BasicRecordingService{\r\n  // iPad 9th generation, iOS 15.7.1, sometimes:\r\n  // Failed to load resource: WebKit hat einen internen Fehler festgestellt\r\n  // Firefox on Windows crashes\r\n  public static readonly DEFAULT_CHUNKED_DOWNLOAD_SECONDS:number=10;\r\n  public static readonly DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES:number=2880000*5; // Default 5 minutes one channel at 48kHz\r\n  protected _maxAutoNetMemStoreSamples:number=BasicRecordingService.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES;\r\n    protected apiEndPoint: string;\r\n    protected withCredentials: boolean = false;\r\n\r\n    constructor(protected http: HttpClient, @Inject(SPEECHRECORDER_CONFIG) protected config?: SpeechRecorderConfig) {\r\n        this.apiEndPoint = ''\r\n\r\n        if (config && config.apiEndPoint) {\r\n            this.apiEndPoint = config.apiEndPoint;\r\n        }\r\n        if (this.apiEndPoint !== '') {\r\n            this.apiEndPoint = this.apiEndPoint + '/'\r\n        }\r\n        if (config != null && config.withCredentials != null) {\r\n            this.withCredentials = config.withCredentials;\r\n        }\r\n    }\r\n\r\n    protected audioRequestByURL(audioBaseUrl:string,audioURLSearchParams:URLSearchParams): Observable<HttpResponse<ArrayBuffer>> {\r\n        let audioUrl=audioBaseUrl;\r\n        if (this.config && this.config.apiType === ApiType.FILES) {\r\n            // for development and demo\r\n            audioUrl=audioUrl+'.wav';\r\n            // append UUID to make request URL unique to avoid localhost server caching\r\n            audioURLSearchParams.set('requestUUID',UUID.generate());\r\n            //audioUrl = audioUrl + '.wav?requestUUID=' + UUID.generate();\r\n        }\r\n\r\n        audioUrl=audioUrl+'?'+audioURLSearchParams.toString();\r\n\r\n        let headers = new HttpHeaders();\r\n        headers = headers.set('Accept', 'audio/wav');\r\n        return this.http.get(audioUrl, {\r\n            headers: headers,\r\n            observe: 'response',\r\n            responseType: 'arraybuffer',\r\n            withCredentials: this.withCredentials\r\n        });\r\n\r\n    }\r\n\r\n    public chunkAudioRequest(baseAudioUrl:string,startFrame:number=0,frameLength:number): Observable<ChunkDownload|null> {\r\n\r\n        let ausps=new URLSearchParams();\r\n        ausps.set('startFrame',startFrame.toString());\r\n        ausps.set('frameLength',frameLength.toString());\r\n        if (this.config && this.config.apiType === ApiType.FILES) {\r\n            // for development and demo\r\n            // append UUID to make request URL unique to avoid localhost server caching\r\n            //audioUrl = audioUrl + '.wav?requestUUID=' + UUID.generate();\r\n            ausps.set('requestUUID',UUID.generate());\r\n        }\r\n\r\n        let obs=new Observable<ChunkDownload|null>(observer=> {\r\n            this.audioRequestByURL(baseAudioUrl,ausps).subscribe(\r\n                {\r\n                    next: resp => {\r\n                        // Do not use Promise version, which does not work with Safari 13 (13.0.5)\r\n                        if (resp.body) {\r\n                            //console.debug(\"chunkAudioRequest: observer.closed: \"+observer.closed);\r\n                            //console.debug(\"Audio file bytes: \"+resp.body.byteLength);\r\n\r\n                            // Check original audio format\r\n                            let wr = new WavReader(resp.body);\r\n                            const pcmFmt = wr.readFormat();\r\n                            const orgFl = wr.frameLength();\r\n                            // if(pcmFmt){\r\n                            //   console.debug(\"Original WAVE format of download chunk: \"+pcmFmt);\r\n                            // }else{\r\n                            //   console.error(\"Could not read WAVE format of original download chunk!\");\r\n                            // }\r\n                            // if(orgFl){\r\n                            //   console.debug(\"Original frame length of download chunk: \"+orgFl);\r\n                            // }else{\r\n                            //   console.error(\"Could not read WAVE format of original download chunk!\");\r\n                            // }\r\n\r\n                            if (pcmFmt && orgFl) {\r\n                              AudioContextProvider.decodeAudioData(resp.body).then((ab)=>{\r\n                                      //console.debug(\"Decoded audio chunk frames: \"+ab.length);\r\n                                      let chDl = new ChunkDownload(pcmFmt, orgFl, ab);\r\n                                      observer.next(chDl);\r\n                                      observer.complete();\r\n                                    }).catch(error => {\r\n                                      //if(error instanceof HttpErrorResponse) {\r\n                                      // if (error.status == 404) {\r\n                                      //   // Interpret not as an error, the file ist not recorded yet\r\n                                      //   observer.next(null);\r\n                                      //   observer.complete()\r\n                                      // } else {\r\n                                      //   // all other states are errors\r\n                                      console.error(\"Recordings service chunkAudioRequest error decoding audio data: \" + error.name + \": \" + error.message);\r\n                                      observer.error(error);\r\n                                      // }\r\n                                      // }\r\n                                    });\r\n                            } else {\r\n                                const errMsg = 'Could not parse audio header for format and/or frame length of download.';\r\n                                console.error(errMsg);\r\n                                observer.error(errMsg);\r\n                            }\r\n                        } else {\r\n                            const errMsg = 'Fetching audio file: response has no body';\r\n                            console.error(errMsg);\r\n                            observer.error(errMsg);\r\n                        }\r\n                    }, error:\r\n                        (error) => {\r\n                            // all other states are errors\r\n                            //const errMsg='Fetching audio file HTTP error: '+error;\r\n                            //console.error(errMsg);\r\n                            observer.error(error);\r\n                            //observer.complete();\r\n\r\n                        }\r\n                });\r\n        });\r\n        return obs;\r\n    }\r\n\r\n\r\n    protected chunkAudioRequestToNetAudioBuffer(baseAudioUrl: string, startFrame: number = 0, orgSampleRate: number, seconds:number,frames: number | null): Observable<NetAudioBuffer | null> {\r\n        //let audioUrl=baseAudioUrl+'?startFrame='+startFrame+'&frameLength='+frameLength;\r\n        //let audioUrl=new URL(baseAudioUrl);\r\n        // if(orgSampleRate!=null && frameLength%orgSampleRate>0){\r\n        //   const errMsg='frameLength must be equal or multiple of original samplerate.';\r\n        //   console.error(errMsg+' ('+frameLength+'%'+orgSampleRate+'=='+(frameLength%orgSampleRate)+')');\r\n        //   throw Error(errMsg)\r\n        // }\r\n        let frameLength:number=orgSampleRate*Math.round(seconds);\r\n        let ausps=new URLSearchParams();\r\n        ausps.set('startFrame',startFrame.toString());\r\n        ausps.set('frameLength',frameLength.toString());\r\n        if (this.config && this.config.apiType === ApiType.FILES) {\r\n            // for development and demo\r\n            // append UUID to make request URL unique to avoid localhost server caching\r\n            //audioUrl = audioUrl + '.wav?requestUUID=' + UUID.generate();\r\n            ausps.set('requestUUID',UUID.generate());\r\n        }\r\n        let obs=new Observable<NetAudioBuffer|null>(subscriber=> {\r\n            this.audioRequestByURL(baseAudioUrl,ausps).subscribe({next:(resp) => {\r\n                    // Do not use Promise version, which does not work with Safari 13 (13.0.5)\r\n                    if (resp.body) {\r\n                        //console.debug(\"chunkAudioRequestTonetAb: subscriber.closed: \"+subscriber.closed);\r\n                        //console.debug(\"chunkAudioRequestTonetAb: Audio file bytes: \"+resp.body.byteLength);\r\n                        AudioContextProvider.decodeAudioData(resp.body).then(ab => {\r\n                                //console.debug(\"chunkAudioRequestTonetAb: Decoded audio chunk frames for netAb: \"+ab.length);\r\n                                //console.debug(\"chunkAudioRequestTonetAb: Create netAb ab from chunk ab...\");\r\n                                if(frames===null){\r\n                                    subscriber.error(new Error('Could not get frame length from recording file object'));\r\n                                }else {\r\n                                    let fl = frames;\r\n                                    if (ab.sampleRate !== orgSampleRate) {\r\n                                        if (orgSampleRate && frames) {\r\n                                            fl = Math.round(ab.sampleRate * frames / orgSampleRate);\r\n                                            //console.debug(\"Platform sr: \"+ab.sampleRate+\", file sr: \"+orgSampleRate+\", decoded/org frame length: \"+fl+\"/\"+frames+\", ab.length: \"+ab.length);\r\n                                        }\r\n                                    }\r\n\r\n                                    let nab = NetAudioBuffer.fromChunkAudioBuffer(this,baseAudioUrl, ab, fl,frameLength);\r\n                                    //let rp=new ReadyProvider();\r\n                                    //nab.readyProvider=rp;\r\n                                    //rp.ready();\r\n                                    nab.ready();\r\n                                    if (nab.frameLen < frameLength) {\r\n                                        //console.debug(\"chunkAudioRequestTonetAb: Built netAb ab from chunk ab: First chunk shorter tha frameLength (\"+netAbAudioBuffer.frameLen+\"<\"+frameLength+\"), assuming end of data, sealing netAb ab.\");\r\n                                        nab.seal();\r\n                                    }\r\n                                    subscriber.next(nab);\r\n\r\n                                    subscriber.complete();\r\n                                }\r\n                            }).catch(error => {\r\n                                console.error('chunkAudioRequestToNetAb: error: '+error);\r\n                                //if(error instanceof HttpErrorResponse) {\r\n                                subscriber.error(error);\r\n                                //}\r\n                            })\r\n                    } else {\r\n                        console.error('chunkAudioRequestToNetAb: Fetching audio file: response has no body');\r\n                        subscriber.error('chunkAudioRequestToNetAb: Fetching audio file: response has no body');\r\n                    }\r\n                },\r\n                error:(error) => {\r\n                    console.error('chunkAudioRequestToNetAb: error: '+error);\r\n                    subscriber.error(error);\r\n                    //subscriber.complete();\r\n                }\r\n            });\r\n        });\r\n        return obs;\r\n    }\r\n\r\n}\r\n"]}