speechrecorderng 3.0.0 → 3.3.0

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

@@ -0,0 +1,213 @@
+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";
+export class ChunkDownload {
+    constructor(_orgPCMAudioFormat, _orgFrameLength, _decodedAudioBuffer) {
+        this._orgPCMAudioFormat = _orgPCMAudioFormat;
+        this._orgFrameLength = _orgFrameLength;
+        this._decodedAudioBuffer = _decodedAudioBuffer;
+    }
+    get orgPCMAudioFormat() {
+        return this._orgPCMAudioFormat;
+    }
+    get orgFrameLength() {
+        return this._orgFrameLength;
+    }
+    get decodedAudioBuffer() {
+        return this._decodedAudioBuffer;
+    }
+}
+let BasicRecordingService = class BasicRecordingService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        this._maxAutoNetMemStoreSamples = BasicRecordingService.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(aCtx, 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(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) {
+                        aCtx.decodeAudioData(resp.body, ab => {
+                            //console.debug("Decoded audio chunk frames: "+ab.length);
+                            let chDl = new ChunkDownload(pcmFmt, orgFl, ab);
+                            observer.next(chDl);
+                            observer.complete();
+                        }, 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) => {
+                // all other states are errors
+                //const errMsg='Fetching audio file HTTP error: '+error;
+                //console.error(errMsg);
+                observer.error(error);
+                //observer.complete();
+            });
+        });
+        return obs;
+    }
+    chunkAudioRequestToNetAudioBuffer(aCtx, 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);
+                        aCtx.decodeAudioData(resp.body, 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(aCtx, 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();
+                            }
+                        }, 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;
+    }
+};
+// iPad 9th generation, iOS 15.7.1, sometimes:
+// Failed to load resource: WebKit hat einen internen Fehler festgestellt
+// Firefox on Windows crashes
+BasicRecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS = 10;
+BasicRecordingService.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES = 2880000 * 5; // Default 5 minutes one channel at 48kHz
+BasicRecordingService = __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\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    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(aCtx:AudioContext,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(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                            aCtx.decodeAudioData(resp.body, 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                                }\r\n                                , 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                },\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        return obs;\r\n    }\r\n\r\n\r\n    protected chunkAudioRequestToNetAudioBuffer(aCtx: AudioContext, 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                        aCtx.decodeAudioData(resp.body, 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(aCtx, 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                            }\r\n                            , 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"]}