speechrecorderng 3.6.0 → 3.8.0

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

@@ -0,0 +1,1014 @@
+/**
+ * Created by klausj on 17.06.2017.
+ */
+import { Inject, Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpHeaders } from "@angular/common/http";
+import { ApiType, SPEECHRECORDER_CONFIG } from "../../spr.config";
+import { UUID } from "../../utils/utils";
+import { SprRecordingFile, RecordingFileUtils } from "../recording";
+import { ProjectService } from "../project/project.service";
+import { SessionService } from "../session/session.service";
+import { EMPTY, expand, map, Observable } from "rxjs";
+import { AudioBufferSource, AudioDataHolder } from "../../audio/audio_data_holder";
+import { ArrayAudioBuffer } from "../../audio/array_audio_buffer";
+import { IndexedDbAudioBuffer } from "../../audio/inddb_audio_buffer";
+import { BasicRecordingService } from "./basic_recording.service";
+import { AudioContextProvider } from "../../audio/context";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../spr.config";
+export class RecordingService extends BasicRecordingService {
+    // This seems to work
+    //public static readonly DEFAULT_CHUNKED_DOWNLOAD_SECONDS:number=4;
+    static { this.REC_API_CTX = 'recfile'; }
+    static { this.RECORDING_API_CTX = 'recordingfile'; }
+    constructor(http, config) {
+        super(http, config);
+        this.http = http;
+        this.config = config;
+        //private debugDelay:number=10000;
+        this.debugDelay = 0;
+    }
+    recordingFilesUrl() {
+        let recFilesUrl = this.apiEndPoint + RecordingService.RECORDING_API_CTX;
+        return recFilesUrl;
+    }
+    sessionRecordingFilesUrl(projectName, sessId) {
+        let encPrjName = encodeURIComponent(projectName);
+        let encSessId = encodeURIComponent(sessId);
+        let recFilesUrl = this.apiEndPoint + ProjectService.PROJECT_API_CTX + '/' + encPrjName + '/' +
+            SessionService.SESSION_API_CTX + '/' + encSessId + '/' + RecordingService.RECORDING_API_CTX;
+        return recFilesUrl;
+    }
+    // private sessionRecordingFilesUrl(projectName: string, sessId: string | number):URL{
+    //   let encPrjName=encodeURIComponent(projectName);
+    //   let encSessId=encodeURIComponent(sessId);
+    //
+    //   let recFilesUrlStr = this.apiEndPoint + ProjectService.PROJECT_API_CTX + '/' + encPrjName + '/' +
+    //     SessionService.SESSION_API_CTX + '/' + encSessId + '/' + RecordingService.RECORDING_API_CTX;
+    //   let recFilesUrl=new URL(recFilesUrlStr);
+    //   return recFilesUrl;
+    // }
+    sessionRecFilesUrl(projectName, sessId) {
+        let encPrjName = encodeURIComponent(projectName);
+        let encSessId = encodeURIComponent(sessId);
+        let recFilesUrl = this.apiEndPoint + ProjectService.PROJECT_API_CTX + '/' + encPrjName + '/' +
+            SessionService.SESSION_API_CTX + '/' + encSessId + '/' + RecordingService.REC_API_CTX;
+        return recFilesUrl;
+    }
+    sessionRecFilesReqUrl(projectName, sessId) {
+        let recFilesUrl = this.sessionRecFilesUrl(projectName, sessId);
+        if (this.config && this.config.apiType === ApiType.FILES) {
+            // for development and demo
+            // append UUID to make request URL unique to avoid localhost server caching
+            recFilesUrl = recFilesUrl + '.json?requestUUID=' + UUID.generate();
+        }
+        return recFilesUrl;
+    }
+    recordingFileDescrList(projectName, sessId) {
+        let recFilesReqUrl = this.sessionRecFilesReqUrl(projectName, sessId);
+        let wobs = this.http.get(recFilesReqUrl, { withCredentials: this.withCredentials });
+        return wobs;
+    }
+    recordingFileList(projectName, sessId) {
+        let recFilesReqUrl = this.sessionRecFilesReqUrl(projectName, sessId);
+        let wobs = this.http.get(recFilesReqUrl, { withCredentials: this.withCredentials });
+        return wobs;
+    }
+    sprRecordingFileList(projectName, sessId) {
+        let recFilesReqUrl = this.sessionRecFilesReqUrl(projectName, sessId);
+        let wobs = this.http.get(recFilesReqUrl, { withCredentials: this.withCredentials });
+        return wobs;
+    }
+    audioRequest(audioUrl) {
+        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();
+        }
+        let headers = new HttpHeaders();
+        headers = headers.set('Accept', 'audio/wav');
+        return this.http.get(audioUrl, {
+            headers: headers,
+            observe: 'response',
+            responseType: 'arraybuffer',
+            withCredentials: this.withCredentials
+        });
+    }
+    chunkAudioRequestToIndDb(persistentAudioStorageTarget, inddbAudioBuffer, baseAudioUrl, startFrame = 0, orgSampleRate, seconds) {
+        //let audioUrl=baseAudioUrl+'?startFrame='+startFrame+'&frameLength='+frameLength;
+        //let audioUrl=new URL(baseAudioUrl);
+        let frameLength = orgSampleRate * Math.round(seconds); // Important: multiple of original sample rate to prevent numeric rounding errors on resampling. 10 seconds is a good value for ind db storage.
+        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("chunkAudioRequestToIndDb: subscriber.closed: "+subscriber.closed);
+                        //console.debug("chunkAudioRequestToIndDb: Audio file bytes: "+resp.body.byteLength);
+                        AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                            //console.debug("chunkAudioRequestToIndDb: Decoded audio chunk frames for inddb: "+ab.length);
+                            if (!inddbAudioBuffer) {
+                                //console.debug("chunkAudioRequestToIndDb: Create inddb ab from chunk ab...");
+                                IndexedDbAudioBuffer.fromChunkAudioBuffer(persistentAudioStorageTarget, ab).subscribe({
+                                    next: (iab) => {
+                                        //console.debug("chunkAudioRequestToIndDb: Built inddb ab from chunk ab: "+iab);
+                                        inddbAudioBuffer = iab;
+                                        if (inddbAudioBuffer.frameLen < frameLength) {
+                                            //console.debug("chunkAudioRequestToIndDb: Built inddb ab from chunk ab: First chunk shorter tha frameLength ("+inddbAudioBuffer.frameLen+"<"+frameLength+"), assuming end of data, sealing inddb ab.");
+                                            inddbAudioBuffer.seal();
+                                        }
+                                        subscriber.next(iab);
+                                    },
+                                    complete: () => {
+                                        //console.debug("chunkAudioRequestToIndDb: Built inddb ab from chunk ab complete.");
+                                        subscriber.complete();
+                                    },
+                                    error: (err) => {
+                                        // iPad may throw QuotaExceededError here
+                                        console.error("chunkAudioRequestToIndDb: Built inddb ab from chunk ab error: " + err);
+                                        subscriber.error(err);
+                                    }
+                                });
+                            }
+                            else {
+                                //console.debug("chunkAudioRequestToIndDb: Append audio chunk to inddb ab...");
+                                inddbAudioBuffer.appendChunkAudioBuffer(ab).subscribe({
+                                    next: (iab) => {
+                                        // if(inddbAudioBuffer) {
+                                        //   console.debug("chunkAudioRequestToIndDb: Appended audio chunk to inddb audio buffer: "+inddbAudioBuffer);
+                                        // }else{
+                                        //   console.debug("chunkAudioRequestToIndDb: Append audio chunk returned null");
+                                        // }
+                                        subscriber.next(inddbAudioBuffer);
+                                    },
+                                    complete: () => {
+                                        subscriber.complete();
+                                    },
+                                    error: (err) => {
+                                        subscriber.error(err);
+                                    }
+                                });
+                            }
+                        }).catch(error => {
+                            console.error('chunkAudioRequestToIndDb: error: ' + error);
+                            //if(error instanceof HttpErrorResponse) {
+                            subscriber.error(error);
+                            //}
+                        });
+                    }
+                    else {
+                        const errMsg = 'chunkAudioRequestToIndDb: Fetching audio file: response has no body';
+                        console.error(errMsg);
+                        subscriber.error(new Error(errMsg));
+                    }
+                },
+                error: (error) => {
+                    console.error('chunkAudioRequestToIndDb: error: ' + error);
+                    subscriber.error(error);
+                    //subscriber.complete();
+                }
+            });
+        });
+        return obs;
+    }
+    chunkedAudioRequestToArrayBuffer(baseAudioUrl, orgSampleRate, seconds) {
+        let obs = new Observable(subscriber => {
+            let arrayAudioBuffer = null;
+            let startFrame = 0;
+            let frameLength = orgSampleRate * Math.round(seconds); // Important: multiple of original sample rate to prevent numeric rounding errors on resampling.
+            //console.debug("Chunk audio request startFrame 0");
+            let subscr = this.chunkAudioRequest(baseAudioUrl, startFrame, frameLength).pipe(expand(value => {
+                if (subscriber.closed) {
+                    subscr.unsubscribe();
+                }
+                if (value) {
+                    if (arrayAudioBuffer) {
+                        if (arrayAudioBuffer?.sealed()) {
+                            return EMPTY;
+                        }
+                        else {
+                            //let nextStartFrame=arrayAudioBuffer.frameLen + 1;
+                            // We cannot use the frame length of the array audio buffer to determine the next start frame because
+                            // AudioContext.decodeAudioData might change the sample rate of the original file. (E.g. Recordings from Mac/iOS with SR 44100 and listen to the on Windows platform will resmaple the audio data to 48000.)
+                            // Frame count then differs on client and server
+                            // Simply proceed in steps of frameLength
+                            // More advanced method would be to parse the WAV header to find out the rela frame length of the chunk audio file
+                            startFrame += frameLength;
+                            //console.debug("Next start frame: "+startFrame);
+                            //console.debug("chunkedAudioRequest: expand() subscriber.closed: "+subscriber.closed);
+                            return this.chunkAudioRequest(baseAudioUrl, startFrame, frameLength);
+                        }
+                    }
+                    else {
+                        return EMPTY;
+                    }
+                }
+                else {
+                    return EMPTY;
+                }
+            }), map(chDl => {
+                let ab = null;
+                if (chDl === null) {
+                    return null;
+                }
+                else {
+                    ab = chDl.decodedAudioBuffer;
+                }
+                if (ab) {
+                    if (arrayAudioBuffer) {
+                        arrayAudioBuffer.appendAudioBuffer(ab);
+                    }
+                    else {
+                        arrayAudioBuffer = ArrayAudioBuffer.fromAudioBuffer(ab, ab.length);
+                    }
+                    // Following code is wrong if original samplerate is less-then platform samplerate
+                    // E.g. Loading 44100Hz file on Safari
+                    // console.debug("Array ab seal?: "+ab.length+" < "+frameLength);
+                    // if (ab.length < frameLength) {
+                    //   arrayAudioBuffer.seal();
+                    //   console.debug("Array ab sealed.");
+                    // }
+                }
+                return arrayAudioBuffer;
+            })).subscribe({
+                next: (aab) => {
+                    //console.debug("chunkedAudioRequest: subscriber.closed: "+subscriber.closed);
+                    subscriber.next(aab);
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+                error: (err) => {
+                    if (err instanceof HttpErrorResponse) {
+                        if (err.status == 404) {
+                            if (arrayAudioBuffer) {
+                                arrayAudioBuffer.seal();
+                                subscriber.next(arrayAudioBuffer);
+                                subscriber.complete();
+                            }
+                            else {
+                                // Interpret not as an error, the file ist not recorded yet
+                                subscriber.next(null);
+                                subscriber.complete();
+                            }
+                            //   observer.complete()
+                        }
+                        else {
+                            // all other states are errors
+                            subscriber.error(err);
+                        }
+                    }
+                    else {
+                        subscriber.error(err);
+                    }
+                }
+            });
+        });
+        return obs;
+    }
+    chunkedInddbAudioRequest(persistentAudioStorageTarget, baseAudioUrl, orgSampleRate, seconds) {
+        let obs = new Observable(subscriber => {
+            let inddbAudioBuffer = null;
+            let startFrame = 0;
+            //let frameLength = DEFAULT_CHUNKED_DOWNLOAD_FRAMELENGTH;
+            let frameLength = orgSampleRate * Math.round(seconds);
+            //console.debug("chunkedInddbAudioRequest: Chunk audio request for inddb. startFrame: "+startFrame);
+            let subscr = this.chunkAudioRequestToIndDb(persistentAudioStorageTarget, null, baseAudioUrl, startFrame, orgSampleRate, seconds).pipe(expand(iab => {
+                // console.debug("chunkedInddbAudioRequest (pipe/expand): Got inddb ab: "+iab);
+                if (subscriber.closed) {
+                    subscr.unsubscribe();
+                }
+                if (iab) {
+                    inddbAudioBuffer = iab;
+                    //if (inddbAudioBuffer) {
+                    if (inddbAudioBuffer?.sealed()) {
+                        return EMPTY;
+                    }
+                    else {
+                        //let nextStartFrame=inddbAudioBuffer.frameLen + 1;
+                        // We cannot use the frame length of the array audio buffer to determine the next start frame because
+                        // AudioContext.decodeAudioData might change the sample rate of the original file. (E.g. Recordings from Mac/iOS with SR 44100 and listen to the on Windows platform will resmaple the audio data to 48000.)
+                        // Frame count then differs on client and server
+                        // Simply proceed in steps of frameLength
+                        // More advanced method would be to parse the WAV header to find out the real frame length of the chunk audio file
+                        startFrame += frameLength;
+                        //console.debug("Next start frame: "+startFrame);
+                        //console.debug("chunkedInddbAudioRequest: expand() subscriber.closed: "+subscriber.closed);
+                        return this.chunkAudioRequestToIndDb(persistentAudioStorageTarget, inddbAudioBuffer, baseAudioUrl, startFrame, orgSampleRate, seconds);
+                    }
+                    // } else {
+                    //   return EMPTY;
+                    // }
+                }
+                else {
+                    return EMPTY;
+                }
+            })).subscribe({
+                next: (aab) => {
+                    //console.debug("chunkedInddbAudioRequest: subscriber.closed: "+subscriber.closed);
+                    subscriber.next(aab);
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+                error: (err) => {
+                    if (err instanceof HttpErrorResponse) {
+                        if (err.status == 404) {
+                            //console.debug("chunkedInddbAudioRequest: Received HTTP 404 not found.");
+                            if (inddbAudioBuffer) {
+                                inddbAudioBuffer.seal();
+                                //console.debug("chunkedInddbAudioRequest: Sealed inddb audio buffer.");
+                                subscriber.next(inddbAudioBuffer);
+                                subscriber.complete();
+                            }
+                            else {
+                                // Interpret not as an error, the file ist not recorded yet
+                                //console.debug("chunkedInddbAudioRequest: Interpret HTTP 404 as not recorded yet.");
+                                subscriber.next(null);
+                                subscriber.complete();
+                            }
+                            //   observer.complete()
+                        }
+                        else {
+                            // all other states are (real) errors
+                            console.error("chunkedInddbAudioRequest: Error: " + err.message);
+                            subscriber.error(err);
+                        }
+                    }
+                    else {
+                        // all other errors are (real) errors
+                        console.error("chunkedInddbAudioRequest: Error: " + err);
+                        subscriber.error(err);
+                    }
+                }
+            });
+        });
+        return obs;
+    }
+    // private chunkedNetAudioRequest(aCtx:AudioContext,baseAudioUrl:string): Observable<NetAudioBuffer|null> {
+    //   let obs=new Observable<NetAudioBuffer|null>(subscriber => {
+    //     let inddbAudioBuffer: NetAudioBuffer | null = null;
+    //     let startFrame=0;
+    //     let frameLength = DEFAULT_CHUNKED_DOWNLOAD_FRAMELENGTH;
+    //     //console.debug("chunkedInddbAudioRequest: Chunk audio request for inddb. startFrame: "+startFrame);
+    //     let subscr=this.chunkAudioRequestToIndDb(aCtx,persistentAudioStorageTarget,null, baseAudioUrl, startFrame, frameLength).pipe(
+    //
+    //         expand(iab => {
+    //               // console.debug("chunkedInddbAudioRequest (pipe/expand): Got inddb ab: "+iab);
+    //               if(subscriber.closed){
+    //                 subscr.unsubscribe();
+    //               }
+    //               if (iab) {
+    //                 inddbAudioBuffer=iab;
+    //                 //if (inddbAudioBuffer) {
+    //                 if (inddbAudioBuffer?.sealed()) {
+    //                   return EMPTY;
+    //                 } else {
+    //                   //let nextStartFrame=inddbAudioBuffer.frameLen + 1;
+    //                   // We cannot use the frame length of the array audio buffer to determine the next start frame because
+    //                   // AudioContext.decodeAudioData might change the sample rate of the original file. (E.g. Recordings from Mac/iOS with SR 44100 and listen to the on Windows platform will resmaple the audio data to 48000.)
+    //                   // Frame count then differs on client and server
+    //
+    //                   // Simply proceed in steps of frameLength
+    //                   // More advanced method would be to parse the WAV header to find out the rela frame length of the chunk audio file
+    //                   startFrame+=frameLength;
+    //                   //console.debug("Next start frame: "+startFrame);
+    //                   //console.debug("chunkedInddbAudioRequest: expand() subscriber.closed: "+subscriber.closed);
+    //                   return this.chunkAudioRequestToIndDb(aCtx,persistentAudioStorageTarget,inddbAudioBuffer, baseAudioUrl, startFrame, frameLength);
+    //                 }
+    //                 // } else {
+    //                 //   return EMPTY;
+    //                 // }
+    //               }else{
+    //                 return EMPTY;
+    //               }
+    //             }
+    //         )
+    //     ).subscribe({
+    //       next: (aab)=>{
+    //         //console.debug("chunkedInddbAudioRequest: subscriber.closed: "+subscriber.closed);
+    //         subscriber.next(aab)
+    //       },
+    //       complete: ()=>{
+    //         subscriber.complete()
+    //       },
+    //       error: (err)=>{
+    //         if(err instanceof HttpErrorResponse){
+    //           if (err.status == 404) {
+    //             //console.debug("chunkedInddbAudioRequest: Received HTTP 404 not found.");
+    //             if(inddbAudioBuffer){
+    //               inddbAudioBuffer.seal();
+    //               //console.debug("chunkedInddbAudioRequest: Sealed inddb audio buffer.");
+    //               subscriber.next(inddbAudioBuffer);
+    //               subscriber.complete();
+    //             }else {
+    //               // Interpret not as an error, the file ist not recorded yet
+    //               //console.debug("chunkedInddbAudioRequest: Interpret HTTP 404 as not recorded yet.");
+    //               subscriber.next(null);
+    //               subscriber.complete();
+    //             }
+    //             //   observer.complete()
+    //           } else {
+    //             // all other states are (real) errors
+    //             console.error("chunkedInddbAudioRequest: Error: "+err.message);
+    //             subscriber.error(err);
+    //           }
+    //         }else {
+    //           // all other errors are (real) errors
+    //           console.error("chunkedInddbAudioRequest: Error: "+err);
+    //           subscriber.error(err);
+    //         }
+    //       }
+    //     });
+    //   });
+    //   return obs;
+    // }
+    audioFileUrlById(projectName, sessId, recFileId) {
+        let recFilesUrl = this.sessionRecordingFilesUrl(projectName, sessId);
+        let encRecFileId = encodeURIComponent(recFileId);
+        return recFilesUrl + '/' + encRecFileId;
+    }
+    fetchAudiofile(projectName, sessId, recFileId) {
+        let recUrl = this.audioFileUrlById(projectName, sessId, recFileId);
+        return this.audioRequest(recUrl);
+    }
+    audioFileUrl(projectName, recordingFile) {
+        let url = null;
+        let recFileId = recordingFile.recordingFileId;
+        if (!recFileId) {
+            recFileId = recordingFile.uuid;
+        }
+        if (recordingFile.session && recFileId) {
+            url = this.audioFileUrlById(projectName, recordingFile.session, recFileId);
+        }
+        return url;
+    }
+    audioFileUrlByUUID(projectName, session, uuid) {
+        let url = this.audioFileUrlById(projectName, session, uuid);
+        return url;
+    }
+    fetchSprAudiofile(projectName, sessId, itemcode, version) {
+        let recFilesUrl = this.sessionRecFilesUrl(projectName, sessId);
+        let encItemcode = encodeURIComponent(itemcode);
+        let recUrl = recFilesUrl + '/' + encItemcode + '/' + version;
+        return this.audioRequest(recUrl);
+    }
+    sprAudioFileUrlByItemcode(projectName, sessId, itemcode, version) {
+        let recFilesUrl = this.sessionRecFilesUrl(projectName, sessId);
+        let encItemcode = encodeURIComponent(itemcode);
+        let recUrl = recFilesUrl + '/' + encItemcode + '/' + version;
+        return recUrl;
+    }
+    sprAudioFileUrl(projectName, recordingFile) {
+        let url = null;
+        if (recordingFile.session) {
+            url = this.sprAudioFileUrlByItemcode(projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);
+        }
+        return url;
+    }
+    // private fetchSprAudiofileArrayBuffer(aCtx:AudioContext,projectName: string, sessId: string | number, itemcode: string,version:number): Observable<ArrayAudioBuffer|null>{
+    //   let recFilesUrl=this.sessionRecFilesUrl(projectName,sessId);
+    //   let encItemcode=encodeURIComponent(itemcode);
+    //   let recUrl = recFilesUrl + '/' + encItemcode +'/'+version;
+    //   return this.chunkedAudioRequest(aCtx,recUrl);
+    // }
+    // private fetchSprAudiofileInddbBuffer(aCtx:AudioContext, persistentAudioStorageTarget:PersistentAudioStorageTarget,projectName: string, sessId: string | number, itemcode: string,version:number): Observable<IndexedDbAudioBuffer|null>{
+    //   let recFilesUrlStr=this.sessionRecFilesUrl(projectName,sessId);
+    //   let encItemcode=encodeURIComponent(itemcode);
+    //   let recUrlStr = recFilesUrlStr + '/' + encItemcode +'/'+version;
+    //   //let recUrl=new URL(recUrlStr);
+    //   return this.chunkedInddbAudioRequest(aCtx,persistentAudioStorageTarget,recUrlStr);
+    // }
+    // private sprNetAudiofileBuffer(aCtx:AudioContext,projectName: string, sessId: string | number, itemcode: string,version:number): Observable<IndexedDbAudioBuffer|null>{
+    //   let recFilesUrlStr=this.sessionRecFilesUrl(projectName,sessId);
+    //   let encItemcode=encodeURIComponent(itemcode);
+    //   let recUrlStr = recFilesUrlStr + '/' + encItemcode +'/'+version;
+    //   //let recUrl=new URL(recUrlStr);
+    //   return this.chunkedInddbAudioRequest(aCtx,recUrlStr);
+    // }
+    fetchRecordingFileAudioBuffer(projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            let recFileId = recordingFile.recordingFileId;
+            if (!recFileId) {
+                recFileId = recordingFile.uuid;
+            }
+            if (recordingFile.session && recFileId) {
+                let obs = this.fetchAudiofile(projectName, recordingFile.session, recFileId);
+                obs.subscribe({
+                    next: resp => {
+                        // Do not use Promise version, which does not work with Safari 13 (13.0.5)
+                        if (resp.body) {
+                            AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                                observer.next(ab);
+                                observer.complete();
+                            }).catch(error => {
+                                observer.error(error);
+                                observer.complete();
+                            });
+                        }
+                        else {
+                            observer.error('Fetching audio file: response has no body');
+                        }
+                    }, error: (err) => {
+                        if (err instanceof HttpErrorResponse) {
+                            if (err.status == 404) {
+                                // Interpret not as an error, the file ist not recorded yet
+                                observer.next(null);
+                                observer.complete();
+                            }
+                            else {
+                                // all other states are errors
+                                observer.error(err);
+                                observer.complete();
+                            }
+                        }
+                        else {
+                            observer.error(err);
+                        }
+                    }
+                });
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchAndApplyRecordingFile(aCtx, projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            let recFileId = recordingFile.recordingFileId;
+            if (!recFileId) {
+                recFileId = recordingFile.uuid;
+            }
+            if (recordingFile.session && recFileId) {
+                let obs = this.fetchAudiofile(projectName, recordingFile.session, recFileId);
+                obs.subscribe({ next: resp => {
+                        //console.log("Fetched audio file. HTTP response status: "+resp.status+", type: "+resp.type+", byte length: "+ resp.body.byteLength);
+                        // Do not use Promise version, which does not work with Safari 13 (13.0.5)
+                        if (resp.body) {
+                            AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                                let abs = new AudioBufferSource(ab);
+                                let adh = new AudioDataHolder(abs);
+                                RecordingFileUtils.setAudioData(recordingFile, adh);
+                                if (this.debugDelay > 0) {
+                                    window.setTimeout(() => {
+                                        observer.next(recordingFile);
+                                        observer.complete();
+                                    }, this.debugDelay);
+                                }
+                                else {
+                                    observer.next(recordingFile);
+                                    observer.complete();
+                                }
+                            }).catch(error => {
+                                observer.error(error);
+                                observer.complete();
+                            });
+                        }
+                        else {
+                            observer.error('Fetching audio file: response has no body');
+                        }
+                    },
+                    error: (err) => {
+                        if (err instanceof HttpErrorResponse) {
+                            if (err.status == 404) {
+                                // Interpret not as an error, the file ist not recorded yet
+                                observer.next(null);
+                                observer.complete();
+                            }
+                            else {
+                                // all other states are errors
+                                observer.error(err);
+                                observer.complete();
+                            }
+                        }
+                        else {
+                            observer.error(err);
+                        }
+                    } });
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchSprRecordingFileAudioBuffer(projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let obs = this.fetchSprAudiofile(projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);
+                obs.subscribe({
+                    next: resp => {
+                        // Do not use Promise version, which does not work with Safari 13 (13.0.5)
+                        if (resp.body) {
+                            AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                                //RecordingFileUtils.setAudioData(recordingFile,new AudioDataHolder(ab,null));
+                                observer.next(ab);
+                                observer.complete();
+                            }).catch(error => {
+                                observer.error(error);
+                                observer.complete();
+                            });
+                        }
+                        else {
+                            observer.error('Fetching audio file: response has no body');
+                        }
+                    },
+                    error: (err) => {
+                        if (err instanceof HttpErrorResponse && err.status == 404) {
+                            // Interpret not as an error, the file ist not recorded yet
+                            observer.next(null);
+                            observer.complete();
+                        }
+                        else {
+                            // all other states are errors
+                            observer.error(err);
+                        }
+                    }
+                });
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchSprRecordingFileArrayAudioBuffer(projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let baseUrl = this.sprAudioFileUrl(projectName, recordingFile);
+                if (baseUrl) {
+                    if (recordingFile.samplerate) {
+                        let lengthInSeconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                        let obs = this.chunkedAudioRequestToArrayBuffer(baseUrl, recordingFile.samplerate, lengthInSeconds);
+                        //let obs = this.fetchSprAudiofileArrayBuffer(aCtx,projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);
+                        let subscr = obs.subscribe({
+                            next: aab => {
+                                //console.debug("fetchSprRecordingFileArrayAudioBuffer: observer.closed: "+observer.closed);
+                                if (observer.closed) {
+                                    subscr.unsubscribe();
+                                }
+                                observer.next(aab);
+                            },
+                            complete: () => {
+                                observer.complete();
+                            },
+                            error: (err) => {
+                                if (err instanceof HttpErrorResponse && err.status == 404) {
+                                    // Interpret not as an error, the file ist not recorded yet
+                                    observer.next(null);
+                                    observer.complete();
+                                }
+                                else {
+                                    // all other states are errors
+                                    observer.error(err);
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        observer.error(new Error('Unknown sample rate of recording file ID: ' + recordingFile.recordingFileId));
+                    }
+                }
+            }
+            else {
+                observer.error(new Error('Could not get session ID of recording file'));
+            }
+        });
+        return wobs;
+    }
+    fetchRecordingFileArrayAudioBuffer(projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let baseUrl = this.audioFileUrl(projectName, recordingFile);
+                if (baseUrl) {
+                    if (recordingFile.samplerate) {
+                        let lengthInSeconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                        let obs = this.chunkedAudioRequestToArrayBuffer(baseUrl, recordingFile.samplerate, lengthInSeconds);
+                        //let obs = this.fetchSprAudiofileArrayBuffer(aCtx,projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);
+                        let subscr = obs.subscribe({
+                            next: aab => {
+                                //console.debug("fetchSprRecordingFileArrayAudioBuffer: observer.closed: "+observer.closed);
+                                if (observer.closed) {
+                                    subscr.unsubscribe();
+                                }
+                                observer.next(aab);
+                            },
+                            complete: () => {
+                                observer.complete();
+                            },
+                            error: (err) => {
+                                if (err instanceof HttpErrorResponse && err.status == 404) {
+                                    // Interpret not as an error, the file ist not recorded yet
+                                    observer.next(null);
+                                    observer.complete();
+                                }
+                                else {
+                                    // all other states are errors
+                                    observer.error(err);
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        observer.error(new Error('Unknown sample rate of recording file ID: ' + recordingFile.recordingFileId));
+                    }
+                }
+            }
+            else {
+                observer.error(new Error('Could not get session ID of recording file'));
+            }
+        });
+        return wobs;
+    }
+    fetchSprRecordingFileIndDbAudioBuffer(persistentAudioStorageTarget, projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let baseUrl = this.sprAudioFileUrl(projectName, recordingFile);
+                if (baseUrl) {
+                    if (recordingFile.samplerate) {
+                        let lengthInSeconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                        let obs = this.chunkedInddbAudioRequest(persistentAudioStorageTarget, baseUrl, recordingFile.samplerate, lengthInSeconds);
+                        let subscr = obs.subscribe({
+                            next: aab => {
+                                //console.debug("fetchSprRecordingFileIndDbAudioBuffer: observer.closed: "+observer.closed);
+                                if (observer.closed) {
+                                    subscr.unsubscribe();
+                                }
+                                observer.next(aab);
+                            },
+                            complete: () => {
+                                observer.complete();
+                            },
+                            error: (err) => {
+                                if (err instanceof HttpErrorResponse && err.status == 404) {
+                                    // Interpret not as an error, the file ist not recorded yet
+                                    observer.next(null);
+                                    observer.complete();
+                                }
+                                else {
+                                    // all other errors are real errors
+                                    observer.error(err);
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        observer.error(new Error('Unknown sample rate of recording file ID: ' + recordingFile.recordingFileId));
+                    }
+                }
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchRecordingFileIndDbAudioBuffer(persistentAudioStorageTarget, projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let baseUrl = this.audioFileUrl(projectName, recordingFile);
+                if (baseUrl) {
+                    if (recordingFile.samplerate) {
+                        let lengthInSeconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                        let obs = this.chunkedInddbAudioRequest(persistentAudioStorageTarget, baseUrl, recordingFile.samplerate, lengthInSeconds);
+                        let subscr = obs.subscribe({
+                            next: aab => {
+                                //console.debug("fetchSprRecordingFileIndDbAudioBuffer: observer.closed: "+observer.closed);
+                                if (observer.closed) {
+                                    subscr.unsubscribe();
+                                }
+                                observer.next(aab);
+                            },
+                            complete: () => {
+                                observer.complete();
+                            },
+                            error: (err) => {
+                                if (err instanceof HttpErrorResponse && err.status == 404) {
+                                    // Interpret not as an error, the file ist not recorded yet
+                                    observer.next(null);
+                                    observer.complete();
+                                }
+                                else {
+                                    // all other errors are real errors
+                                    observer.error(err);
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        observer.error(new Error('Unknown sample rate of recording file ID: ' + recordingFile.recordingFileId));
+                    }
+                }
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchSprRecordingFileNetAudioBuffer(projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let baseUrl = this.sprAudioFileUrl(projectName, recordingFile);
+                if (baseUrl) {
+                    let seconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                    if (recordingFile.samplerate) {
+                        let obs = this.chunkAudioRequestToNetAudioBuffer(baseUrl, 0, recordingFile.samplerate, seconds, recordingFile.frames);
+                        let subscr = obs.subscribe({
+                            next: aab => {
+                                //console.debug("fetchSprRecordingFileIndDbAudioBuffer: observer.closed: "+observer.closed);
+                                if (observer.closed) {
+                                    subscr.unsubscribe();
+                                }
+                                else {
+                                    observer.next(aab);
+                                }
+                            },
+                            complete: () => {
+                                observer.complete();
+                            },
+                            error: (err) => {
+                                if (err instanceof HttpErrorResponse && err.status == 404) {
+                                    // Interpret not as an error, the file ist not recorded yet
+                                    observer.next(null);
+                                    observer.complete();
+                                }
+                                else {
+                                    // all other errors are real errors
+                                    observer.error(err);
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        observer.error(new Error('Unknown sample rate of recording file ID: ' + recordingFile.recordingFileId));
+                    }
+                }
+                else {
+                    observer.error();
+                }
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchRecordingFileNetAudioBuffer(projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let baseUrl = this.audioFileUrl(projectName, recordingFile);
+                if (baseUrl) {
+                    let seconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                    if (recordingFile.samplerate) {
+                        let obs = this.chunkAudioRequestToNetAudioBuffer(baseUrl, 0, recordingFile.samplerate, seconds, recordingFile.frames);
+                        let subscr = obs.subscribe({
+                            next: aab => {
+                                //console.debug("fetchSprRecordingFileIndDbAudioBuffer: observer.closed: "+observer.closed);
+                                if (observer.closed) {
+                                    subscr.unsubscribe();
+                                }
+                                else {
+                                    observer.next(aab);
+                                }
+                            },
+                            complete: () => {
+                                observer.complete();
+                            },
+                            error: (err) => {
+                                if (err instanceof HttpErrorResponse && err.status == 404) {
+                                    // Interpret not as an error, the file ist not recorded yet
+                                    observer.next(null);
+                                    observer.complete();
+                                }
+                                else {
+                                    // all other errors are real errors
+                                    observer.error(err);
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        observer.error(new Error('Unknown sample rate of recording file ID: ' + recordingFile.recordingFileId));
+                    }
+                }
+                else {
+                    observer.error();
+                }
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchAndApplySprRecordingFile(aCtx, projectName, recordingFile) {
+        let wobs = new Observable(observer => {
+            if (recordingFile.session) {
+                let obs = this.fetchSprAudiofile(projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);
+                obs.subscribe({
+                    next: resp => {
+                        //console.log("Fetched audio file. HTTP response status: "+resp.status+", type: "+resp.type+", byte length: "+ resp.body.byteLength);
+                        // Do not use Promise version, which does not work with Safari 13 (13.0.5)
+                        if (resp.body) {
+                            AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                                let abs = new AudioBufferSource(ab);
+                                RecordingFileUtils.setAudioData(recordingFile, new AudioDataHolder(abs));
+                                if (this.debugDelay > 0) {
+                                    window.setTimeout(() => {
+                                        observer.next(recordingFile);
+                                        observer.complete();
+                                    }, this.debugDelay);
+                                }
+                                else {
+                                    observer.next(recordingFile);
+                                    observer.complete();
+                                }
+                            }).catch(error => {
+                                observer.error(error);
+                                observer.complete();
+                            });
+                        }
+                        else {
+                            observer.error('Fetching audio file: response has no body');
+                        }
+                    },
+                    error: (err) => {
+                        if (err instanceof HttpErrorResponse && err.status == 404) {
+                            // Interpret not as an error, the file ist not recorded yet
+                            observer.next(null);
+                            observer.complete();
+                        }
+                        else {
+                            // all other states are errors
+                            observer.error(err);
+                        }
+                    }
+                });
+            }
+            else {
+                observer.error();
+            }
+        });
+        return wobs;
+    }
+    fetchRecordingFile(aCtx, projectName, sessId, itemcode, version) {
+        let wobs = new Observable(observer => {
+            let obs = this.fetchSprAudiofile(projectName, sessId, itemcode, version);
+            obs.subscribe({ next: resp => {
+                    if (resp.body) {
+                        AudioContextProvider.decodeAudioData(resp.body).then(ab => {
+                            let abs = new AudioBufferSource(ab);
+                            let adh = new AudioDataHolder(abs);
+                            let rf = new SprRecordingFile(sessId, itemcode, version, adh);
+                            if (this.debugDelay > 0) {
+                                window.setTimeout(() => {
+                                    observer.next(rf);
+                                    observer.complete();
+                                }, this.debugDelay);
+                            }
+                            else {
+                                observer.next(rf);
+                                observer.complete();
+                            }
+                        }).catch((reason) => { observer.error(reason); });
+                    }
+                    else {
+                        observer.error();
+                    }
+                },
+                error: (err) => {
+                    if (err instanceof HttpErrorResponse && err.status == 404) {
+                        // Interpret not as an error, the file ist not recorded yet
+                        observer.next(null);
+                        observer.complete();
+                    }
+                    else {
+                        // all other errors are real errors
+                        observer.error(err);
+                    }
+                }
+            });
+        });
+        return wobs;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: RecordingService, deps: [{ token: i1.HttpClient }, { token: SPEECHRECORDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: RecordingService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: RecordingService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.SpeechRecorderConfig, decorators: [{
+                    type: Inject,
+                    args: [SPEECHRECORDER_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recordings.service.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/speechrecorder/recordings/recordings.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Created by klausj on 17.06.2017.\r\n */\r\nimport {Inject, Injectable} from '@angular/core';\r\nimport {HttpClient, HttpErrorResponse, HttpHeaders, HttpResponse} from \"@angular/common/http\";\r\nimport {ApiType, SPEECHRECORDER_CONFIG, SpeechRecorderConfig} from \"../../spr.config\";\r\n\r\nimport {UUID} from \"../../utils/utils\";\r\nimport {SprRecordingFile, RecordingFileDescriptorImpl, RecordingFile, RecordingFileUtils} from \"../recording\";\r\nimport {ProjectService} from \"../project/project.service\";\r\nimport {SessionService} from \"../session/session.service\";\r\nimport {EMPTY, expand, map, Observable} from \"rxjs\";\r\nimport {AudioBufferSource, AudioDataHolder} from \"../../audio/audio_data_holder\";\r\nimport {ArrayAudioBuffer} from \"../../audio/array_audio_buffer\";\r\nimport {IndexedDbAudioBuffer, PersistentAudioStorageTarget} from \"../../audio/inddb_audio_buffer\";\r\nimport {NetAudioBuffer} from \"../../audio/net_audio_buffer\";\r\nimport {BasicRecordingService} from \"./basic_recording.service\";\r\nimport {AudioContextProvider} from \"../../audio/context\";\r\n\r\n@Injectable()\r\nexport class RecordingService extends BasicRecordingService{\r\n\r\n  // This seems to work\r\n  //public static readonly DEFAULT_CHUNKED_DOWNLOAD_SECONDS:number=4;\r\n\r\n  public static readonly REC_API_CTX = 'recfile'\r\n  public static readonly RECORDING_API_CTX='recordingfile'\r\n\r\n\r\n  //private debugDelay:number=10000;\r\n  private debugDelay:number=0;\r\n\r\n  constructor(protected http: HttpClient, @Inject(SPEECHRECORDER_CONFIG) protected config?: SpeechRecorderConfig) {\r\n    super(http, config);\r\n  }\r\n\r\n  private recordingFilesUrl():string{\r\n    let recFilesUrl = this.apiEndPoint  + RecordingService.RECORDING_API_CTX;\r\n    return recFilesUrl;\r\n  }\r\n\r\n  private sessionRecordingFilesUrl(projectName: string, sessId: string | number):string{\r\n    let encPrjName=encodeURIComponent(projectName);\r\n    let encSessId=encodeURIComponent(sessId);\r\n    let recFilesUrl = this.apiEndPoint + ProjectService.PROJECT_API_CTX + '/' + encPrjName + '/' +\r\n      SessionService.SESSION_API_CTX + '/' + encSessId + '/' + RecordingService.RECORDING_API_CTX;\r\n    return recFilesUrl;\r\n  }\r\n\r\n  // private sessionRecordingFilesUrl(projectName: string, sessId: string | number):URL{\r\n  //   let encPrjName=encodeURIComponent(projectName);\r\n  //   let encSessId=encodeURIComponent(sessId);\r\n  //\r\n  //   let recFilesUrlStr = this.apiEndPoint + ProjectService.PROJECT_API_CTX + '/' + encPrjName + '/' +\r\n  //     SessionService.SESSION_API_CTX + '/' + encSessId + '/' + RecordingService.RECORDING_API_CTX;\r\n  //   let recFilesUrl=new URL(recFilesUrlStr);\r\n  //   return recFilesUrl;\r\n  // }\r\n\r\n  private sessionRecFilesUrl(projectName: string, sessId: string | number):string{\r\n    let encPrjName=encodeURIComponent(projectName);\r\n    let encSessId=encodeURIComponent(sessId);\r\n    let recFilesUrl = this.apiEndPoint + ProjectService.PROJECT_API_CTX + '/' + encPrjName + '/' +\r\n        SessionService.SESSION_API_CTX + '/' + encSessId + '/' + RecordingService.REC_API_CTX;\r\n    return recFilesUrl;\r\n  }\r\n\r\n  private sessionRecFilesReqUrl(projectName: string, sessId: string | number):string{\r\n    let recFilesUrl=this.sessionRecFilesUrl(projectName,sessId);\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      recFilesUrl = recFilesUrl + '.json?requestUUID=' + UUID.generate();\r\n    }\r\n    return recFilesUrl;\r\n  }\r\n\r\n  recordingFileDescrList(projectName: string, sessId: string | number):Observable<Array<RecordingFileDescriptorImpl>> {\r\n    let recFilesReqUrl = this.sessionRecFilesReqUrl(projectName,sessId);\r\n    let wobs = this.http.get<Array<RecordingFileDescriptorImpl>>(recFilesReqUrl,{withCredentials:this.withCredentials});\r\n    return wobs;\r\n  }\r\n\r\n  recordingFileList(projectName: string, sessId: string | number):Observable<Array<RecordingFile>> {\r\n    let recFilesReqUrl = this.sessionRecFilesReqUrl(projectName,sessId);\r\n    let wobs = this.http.get<Array<RecordingFile>>(recFilesReqUrl,{withCredentials:this.withCredentials});\r\n    return wobs;\r\n  }\r\n\r\n  sprRecordingFileList(projectName: string, sessId: string | number):Observable<Array<SprRecordingFile>> {\r\n    let recFilesReqUrl = this.sessionRecFilesReqUrl(projectName,sessId);\r\n    let wobs = this.http.get<Array<SprRecordingFile>>(recFilesReqUrl,{withCredentials:this.withCredentials});\r\n    return wobs;\r\n  }\r\n\r\n  private audioRequest(audioUrl:string): Observable<HttpResponse<ArrayBuffer>> {\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    }\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\r\n\r\n\r\n\r\n  private chunkAudioRequestToIndDb(persistentAudioStorageTarget:PersistentAudioStorageTarget,inddbAudioBuffer:IndexedDbAudioBuffer|null,baseAudioUrl:string,startFrame:number=0,orgSampleRate: number,seconds:number): Observable<IndexedDbAudioBuffer|null> {\r\n    //let audioUrl=baseAudioUrl+'?startFrame='+startFrame+'&frameLength='+frameLength;\r\n    //let audioUrl=new URL(baseAudioUrl);\r\n    let frameLength=orgSampleRate * Math.round(seconds); // Important: multiple of original sample rate to prevent numeric rounding errors on resampling. 10 seconds is a good value for ind db storage.\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<IndexedDbAudioBuffer|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(\"chunkAudioRequestToIndDb: subscriber.closed: \"+subscriber.closed);\r\n            //console.debug(\"chunkAudioRequestToIndDb: Audio file bytes: \"+resp.body.byteLength);\r\n            AudioContextProvider.decodeAudioData(resp.body).then( ab => {\r\n                  //console.debug(\"chunkAudioRequestToIndDb: Decoded audio chunk frames for inddb: \"+ab.length);\r\n                  if (!inddbAudioBuffer) {\r\n                    //console.debug(\"chunkAudioRequestToIndDb: Create inddb ab from chunk ab...\");\r\n                    IndexedDbAudioBuffer.fromChunkAudioBuffer(persistentAudioStorageTarget, ab).subscribe({\r\n                      next: (iab) => {\r\n                        //console.debug(\"chunkAudioRequestToIndDb: Built inddb ab from chunk ab: \"+iab);\r\n                        inddbAudioBuffer = iab;\r\n                        if (inddbAudioBuffer.frameLen < frameLength) {\r\n                          //console.debug(\"chunkAudioRequestToIndDb: Built inddb ab from chunk ab: First chunk shorter tha frameLength (\"+inddbAudioBuffer.frameLen+\"<\"+frameLength+\"), assuming end of data, sealing inddb ab.\");\r\n                          inddbAudioBuffer.seal();\r\n                        }\r\n                        subscriber.next(iab);\r\n                      },\r\n                      complete: () => {\r\n                        //console.debug(\"chunkAudioRequestToIndDb: Built inddb ab from chunk ab complete.\");\r\n                        subscriber.complete();\r\n                      },\r\n                      error: (err) => {\r\n                        // iPad may throw QuotaExceededError here\r\n                        console.error(\"chunkAudioRequestToIndDb: Built inddb ab from chunk ab error: \" + err);\r\n                        subscriber.error(err);\r\n                      }\r\n                    })\r\n                  } else {\r\n                    //console.debug(\"chunkAudioRequestToIndDb: Append audio chunk to inddb ab...\");\r\n                    inddbAudioBuffer.appendChunkAudioBuffer(ab).subscribe({\r\n                      next: (iab) => {\r\n                        // if(inddbAudioBuffer) {\r\n                        //   console.debug(\"chunkAudioRequestToIndDb: Appended audio chunk to inddb audio buffer: \"+inddbAudioBuffer);\r\n                        // }else{\r\n                        //   console.debug(\"chunkAudioRequestToIndDb: Append audio chunk returned null\");\r\n                        // }\r\n                        subscriber.next(inddbAudioBuffer);\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                }).catch(error => {\r\n                  console.error('chunkAudioRequestToIndDb: error: ' + error);\r\n                  //if(error instanceof HttpErrorResponse) {\r\n                  subscriber.error(error);\r\n                  //}\r\n                })\r\n          } else {\r\n            const errMsg='chunkAudioRequestToIndDb: Fetching audio file: response has no body';\r\n            console.error(errMsg);\r\n            subscriber.error(new Error(errMsg));\r\n          }\r\n        },\r\n        error:(error) => {\r\n          console.error('chunkAudioRequestToIndDb: 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\r\n\r\n  private chunkedAudioRequestToArrayBuffer(baseAudioUrl:string,orgSampleRate:number,seconds:number): Observable<ArrayAudioBuffer|null> {\r\n    let obs=new Observable<ArrayAudioBuffer|null>(subscriber => {\r\n      let arrayAudioBuffer: ArrayAudioBuffer | null = null;\r\n      let startFrame=0;\r\n      let frameLength=orgSampleRate * Math.round(seconds); // Important: multiple of original sample rate to prevent numeric rounding errors on resampling.\r\n      //console.debug(\"Chunk audio request startFrame 0\");\r\n      let subscr=this.chunkAudioRequest(baseAudioUrl, startFrame, frameLength).pipe(\r\n\r\n        expand(value => {\r\n          if(subscriber.closed){\r\n            subscr.unsubscribe();\r\n          }\r\n            if (value) {\r\n              if (arrayAudioBuffer) {\r\n                if (arrayAudioBuffer?.sealed()) {\r\n                  return EMPTY;\r\n                } else {\r\n                  //let nextStartFrame=arrayAudioBuffer.frameLen + 1;\r\n                  // We cannot use the frame length of the array audio buffer to determine the next start frame because\r\n                  // AudioContext.decodeAudioData might change the sample rate of the original file. (E.g. Recordings from Mac/iOS with SR 44100 and listen to the on Windows platform will resmaple the audio data to 48000.)\r\n                  // Frame count then differs on client and server\r\n\r\n                  // Simply proceed in steps of frameLength\r\n                  // More advanced method would be to parse the WAV header to find out the rela frame length of the chunk audio file\r\n                  startFrame+=frameLength;\r\n                  //console.debug(\"Next start frame: \"+startFrame);\r\n                  //console.debug(\"chunkedAudioRequest: expand() subscriber.closed: \"+subscriber.closed);\r\n                  return this.chunkAudioRequest(baseAudioUrl, startFrame, frameLength);\r\n                }\r\n              } else {\r\n                return EMPTY;\r\n              }\r\n            }else{\r\n              return EMPTY;\r\n            }\r\n          }\r\n        ),\r\n      map(chDl => {\r\n        let ab:AudioBuffer|null=null;\r\n        if(chDl===null){\r\n          return null;\r\n        }else{\r\n          ab=chDl.decodedAudioBuffer;\r\n        }\r\n        if(ab) {\r\n          if (arrayAudioBuffer) {\r\n            arrayAudioBuffer.appendAudioBuffer(ab);\r\n          } else {\r\n            arrayAudioBuffer = ArrayAudioBuffer.fromAudioBuffer(ab, ab.length);\r\n          }\r\n          // Following code is wrong if original samplerate is less-then platform samplerate\r\n          // E.g. Loading 44100Hz file on Safari\r\n          // console.debug(\"Array ab seal?: \"+ab.length+\" < \"+frameLength);\r\n          // if (ab.length < frameLength) {\r\n          //   arrayAudioBuffer.seal();\r\n          //   console.debug(\"Array ab sealed.\");\r\n          // }\r\n        }\r\n        return arrayAudioBuffer;\r\n      })\r\n      ).subscribe({\r\n        next: (aab)=>{\r\n          //console.debug(\"chunkedAudioRequest: subscriber.closed: \"+subscriber.closed);\r\n          subscriber.next(aab)\r\n        },\r\n        complete: ()=>{\r\n          subscriber.complete()\r\n        },\r\n        error: (err)=>{\r\n          if(err instanceof HttpErrorResponse){\r\n            if (err.status == 404) {\r\n              if(arrayAudioBuffer){\r\n                arrayAudioBuffer.seal();\r\n                subscriber.next(arrayAudioBuffer);\r\n                subscriber.complete();\r\n              }else {\r\n                // Interpret not as an error, the file ist not recorded yet\r\n                subscriber.next(null);\r\n                subscriber.complete();\r\n              }\r\n            //   observer.complete()\r\n             } else {\r\n              // all other states are errors\r\n              subscriber.error(err);\r\n             }\r\n          }else{\r\n            subscriber.error(err);\r\n          }\r\n        }\r\n      });\r\n    });\r\n    return obs;\r\n  }\r\n\r\n  private chunkedInddbAudioRequest(persistentAudioStorageTarget:PersistentAudioStorageTarget,baseAudioUrl:string,orgSampleRate:number,seconds:number): Observable<IndexedDbAudioBuffer|null> {\r\n    let obs=new Observable<IndexedDbAudioBuffer|null>(subscriber => {\r\n      let inddbAudioBuffer: IndexedDbAudioBuffer | null = null;\r\n      let startFrame=0;\r\n      //let frameLength = DEFAULT_CHUNKED_DOWNLOAD_FRAMELENGTH;\r\n      let frameLength=orgSampleRate*Math.round(seconds);\r\n      //console.debug(\"chunkedInddbAudioRequest: Chunk audio request for inddb. startFrame: \"+startFrame);\r\n      let subscr=this.chunkAudioRequestToIndDb(persistentAudioStorageTarget,null, baseAudioUrl, startFrame,orgSampleRate,seconds).pipe(\r\n\r\n        expand(iab => {\r\n         // console.debug(\"chunkedInddbAudioRequest (pipe/expand): Got inddb ab: \"+iab);\r\n            if(subscriber.closed){\r\n              subscr.unsubscribe();\r\n            }\r\n            if (iab) {\r\n              inddbAudioBuffer=iab;\r\n              //if (inddbAudioBuffer) {\r\n                if (inddbAudioBuffer?.sealed()) {\r\n                  return EMPTY;\r\n                } else {\r\n                  //let nextStartFrame=inddbAudioBuffer.frameLen + 1;\r\n                  // We cannot use the frame length of the array audio buffer to determine the next start frame because\r\n                  // AudioContext.decodeAudioData might change the sample rate of the original file. (E.g. Recordings from Mac/iOS with SR 44100 and listen to the on Windows platform will resmaple the audio data to 48000.)\r\n                  // Frame count then differs on client and server\r\n\r\n                  // Simply proceed in steps of frameLength\r\n                  // More advanced method would be to parse the WAV header to find out the real frame length of the chunk audio file\r\n                  startFrame+=frameLength;\r\n                  //console.debug(\"Next start frame: \"+startFrame);\r\n                  //console.debug(\"chunkedInddbAudioRequest: expand() subscriber.closed: \"+subscriber.closed);\r\n                  return this.chunkAudioRequestToIndDb(persistentAudioStorageTarget,inddbAudioBuffer, baseAudioUrl, startFrame, orgSampleRate,seconds);\r\n                }\r\n              // } else {\r\n              //   return EMPTY;\r\n              // }\r\n            }else{\r\n              return EMPTY;\r\n            }\r\n          }\r\n        )\r\n      ).subscribe({\r\n        next: (aab)=>{\r\n          //console.debug(\"chunkedInddbAudioRequest: subscriber.closed: \"+subscriber.closed);\r\n          subscriber.next(aab)\r\n        },\r\n        complete: ()=>{\r\n          subscriber.complete()\r\n        },\r\n        error: (err)=>{\r\n          if(err instanceof HttpErrorResponse){\r\n            if (err.status == 404) {\r\n              //console.debug(\"chunkedInddbAudioRequest: Received HTTP 404 not found.\");\r\n              if(inddbAudioBuffer){\r\n                inddbAudioBuffer.seal();\r\n                //console.debug(\"chunkedInddbAudioRequest: Sealed inddb audio buffer.\");\r\n                subscriber.next(inddbAudioBuffer);\r\n                subscriber.complete();\r\n              }else {\r\n                // Interpret not as an error, the file ist not recorded yet\r\n                //console.debug(\"chunkedInddbAudioRequest: Interpret HTTP 404 as not recorded yet.\");\r\n                subscriber.next(null);\r\n                subscriber.complete();\r\n              }\r\n              //   observer.complete()\r\n            } else {\r\n              // all other states are (real) errors\r\n              console.error(\"chunkedInddbAudioRequest: Error: \"+err.message);\r\n              subscriber.error(err);\r\n            }\r\n          }else {\r\n            // all other errors are (real) errors\r\n            console.error(\"chunkedInddbAudioRequest: Error: \"+err);\r\n            subscriber.error(err);\r\n          }\r\n        }\r\n      });\r\n    });\r\n    return obs;\r\n  }\r\n\r\n\r\n  // private chunkedNetAudioRequest(aCtx:AudioContext,baseAudioUrl:string): Observable<NetAudioBuffer|null> {\r\n  //   let obs=new Observable<NetAudioBuffer|null>(subscriber => {\r\n  //     let inddbAudioBuffer: NetAudioBuffer | null = null;\r\n  //     let startFrame=0;\r\n  //     let frameLength = DEFAULT_CHUNKED_DOWNLOAD_FRAMELENGTH;\r\n  //     //console.debug(\"chunkedInddbAudioRequest: Chunk audio request for inddb. startFrame: \"+startFrame);\r\n  //     let subscr=this.chunkAudioRequestToIndDb(aCtx,persistentAudioStorageTarget,null, baseAudioUrl, startFrame, frameLength).pipe(\r\n  //\r\n  //         expand(iab => {\r\n  //               // console.debug(\"chunkedInddbAudioRequest (pipe/expand): Got inddb ab: \"+iab);\r\n  //               if(subscriber.closed){\r\n  //                 subscr.unsubscribe();\r\n  //               }\r\n  //               if (iab) {\r\n  //                 inddbAudioBuffer=iab;\r\n  //                 //if (inddbAudioBuffer) {\r\n  //                 if (inddbAudioBuffer?.sealed()) {\r\n  //                   return EMPTY;\r\n  //                 } else {\r\n  //                   //let nextStartFrame=inddbAudioBuffer.frameLen + 1;\r\n  //                   // We cannot use the frame length of the array audio buffer to determine the next start frame because\r\n  //                   // AudioContext.decodeAudioData might change the sample rate of the original file. (E.g. Recordings from Mac/iOS with SR 44100 and listen to the on Windows platform will resmaple the audio data to 48000.)\r\n  //                   // Frame count then differs on client and server\r\n  //\r\n  //                   // Simply proceed in steps of frameLength\r\n  //                   // More advanced method would be to parse the WAV header to find out the rela frame length of the chunk audio file\r\n  //                   startFrame+=frameLength;\r\n  //                   //console.debug(\"Next start frame: \"+startFrame);\r\n  //                   //console.debug(\"chunkedInddbAudioRequest: expand() subscriber.closed: \"+subscriber.closed);\r\n  //                   return this.chunkAudioRequestToIndDb(aCtx,persistentAudioStorageTarget,inddbAudioBuffer, baseAudioUrl, startFrame, frameLength);\r\n  //                 }\r\n  //                 // } else {\r\n  //                 //   return EMPTY;\r\n  //                 // }\r\n  //               }else{\r\n  //                 return EMPTY;\r\n  //               }\r\n  //             }\r\n  //         )\r\n  //     ).subscribe({\r\n  //       next: (aab)=>{\r\n  //         //console.debug(\"chunkedInddbAudioRequest: subscriber.closed: \"+subscriber.closed);\r\n  //         subscriber.next(aab)\r\n  //       },\r\n  //       complete: ()=>{\r\n  //         subscriber.complete()\r\n  //       },\r\n  //       error: (err)=>{\r\n  //         if(err instanceof HttpErrorResponse){\r\n  //           if (err.status == 404) {\r\n  //             //console.debug(\"chunkedInddbAudioRequest: Received HTTP 404 not found.\");\r\n  //             if(inddbAudioBuffer){\r\n  //               inddbAudioBuffer.seal();\r\n  //               //console.debug(\"chunkedInddbAudioRequest: Sealed inddb audio buffer.\");\r\n  //               subscriber.next(inddbAudioBuffer);\r\n  //               subscriber.complete();\r\n  //             }else {\r\n  //               // Interpret not as an error, the file ist not recorded yet\r\n  //               //console.debug(\"chunkedInddbAudioRequest: Interpret HTTP 404 as not recorded yet.\");\r\n  //               subscriber.next(null);\r\n  //               subscriber.complete();\r\n  //             }\r\n  //             //   observer.complete()\r\n  //           } else {\r\n  //             // all other states are (real) errors\r\n  //             console.error(\"chunkedInddbAudioRequest: Error: \"+err.message);\r\n  //             subscriber.error(err);\r\n  //           }\r\n  //         }else {\r\n  //           // all other errors are (real) errors\r\n  //           console.error(\"chunkedInddbAudioRequest: Error: \"+err);\r\n  //           subscriber.error(err);\r\n  //         }\r\n  //       }\r\n  //     });\r\n  //   });\r\n  //   return obs;\r\n  // }\r\n\r\n  audioFileUrlById(projectName: string, sessId: string | number, recFileId: string|number){\r\n    let recFilesUrl=this.sessionRecordingFilesUrl(projectName,sessId);\r\n    let encRecFileId=encodeURIComponent(recFileId);\r\n    return recFilesUrl + '/' + encRecFileId;\r\n  }\r\n\r\n  private fetchAudiofile(projectName: string, sessId: string | number, recFileId: string|number): Observable<HttpResponse<ArrayBuffer>> {\r\n    let recUrl = this.audioFileUrlById(projectName,sessId,recFileId);\r\n    return this.audioRequest(recUrl);\r\n  }\r\n\r\n  audioFileUrl(projectName: string, recordingFile:RecordingFile):string|null {\r\n    let url:string|null = null;\r\n    let recFileId = recordingFile.recordingFileId;\r\n    if (!recFileId) {\r\n      recFileId = recordingFile.uuid;\r\n    }\r\n    if (recordingFile.session && recFileId) {\r\n      url = this.audioFileUrlById(projectName, recordingFile.session, recFileId);\r\n    }\r\n    return url;\r\n  }\r\n\r\n  audioFileUrlByUUID(projectName: string, session:string|number,uuid:string):string|null {\r\n    let url = this.audioFileUrlById(projectName, session, uuid);\r\n    return url;\r\n  }\r\n\r\n  private fetchSprAudiofile(projectName: string, sessId: string | number, itemcode: string,version:number): Observable<HttpResponse<ArrayBuffer>> {\r\n    let recFilesUrl=this.sessionRecFilesUrl(projectName,sessId);\r\n    let encItemcode=encodeURIComponent(itemcode);\r\n    let recUrl = recFilesUrl + '/' + encItemcode +'/'+version;\r\n    return this.audioRequest(recUrl);\r\n  }\r\n\r\n  public sprAudioFileUrlByItemcode(projectName: string, sessId: string | number, itemcode: string,version:number){\r\n    let recFilesUrl=this.sessionRecFilesUrl(projectName,sessId);\r\n    let encItemcode=encodeURIComponent(itemcode);\r\n    let recUrl = recFilesUrl + '/' + encItemcode +'/'+version;\r\n    return recUrl;\r\n  }\r\n\r\n  sprAudioFileUrl(projectName: string, recordingFile:SprRecordingFile):string|null{\r\n    let url=null;\r\n    if(recordingFile.session) {\r\n      url = this.sprAudioFileUrlByItemcode(projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);\r\n    }\r\n    return url;\r\n  }\r\n\r\n\r\n\r\n  // private fetchSprAudiofileArrayBuffer(aCtx:AudioContext,projectName: string, sessId: string | number, itemcode: string,version:number): Observable<ArrayAudioBuffer|null>{\r\n  //   let recFilesUrl=this.sessionRecFilesUrl(projectName,sessId);\r\n  //   let encItemcode=encodeURIComponent(itemcode);\r\n  //   let recUrl = recFilesUrl + '/' + encItemcode +'/'+version;\r\n  //   return this.chunkedAudioRequest(aCtx,recUrl);\r\n  // }\r\n\r\n  // private fetchSprAudiofileInddbBuffer(aCtx:AudioContext, persistentAudioStorageTarget:PersistentAudioStorageTarget,projectName: string, sessId: string | number, itemcode: string,version:number): Observable<IndexedDbAudioBuffer|null>{\r\n  //   let recFilesUrlStr=this.sessionRecFilesUrl(projectName,sessId);\r\n  //   let encItemcode=encodeURIComponent(itemcode);\r\n  //   let recUrlStr = recFilesUrlStr + '/' + encItemcode +'/'+version;\r\n  //   //let recUrl=new URL(recUrlStr);\r\n  //   return this.chunkedInddbAudioRequest(aCtx,persistentAudioStorageTarget,recUrlStr);\r\n  // }\r\n\r\n  // private sprNetAudiofileBuffer(aCtx:AudioContext,projectName: string, sessId: string | number, itemcode: string,version:number): Observable<IndexedDbAudioBuffer|null>{\r\n  //   let recFilesUrlStr=this.sessionRecFilesUrl(projectName,sessId);\r\n  //   let encItemcode=encodeURIComponent(itemcode);\r\n  //   let recUrlStr = recFilesUrlStr + '/' + encItemcode +'/'+version;\r\n  //   //let recUrl=new URL(recUrlStr);\r\n  //   return this.chunkedInddbAudioRequest(aCtx,recUrlStr);\r\n  // }\r\n\r\n  fetchRecordingFileAudioBuffer(projectName: string, recordingFile:RecordingFile):Observable<AudioBuffer|null> {\r\n\r\n    let wobs = new Observable<AudioBuffer|null>(observer=>{\r\n      let recFileId=recordingFile.recordingFileId;\r\n      if(!recFileId){\r\n        recFileId=recordingFile.uuid;\r\n      }\r\n      if(recordingFile.session && recFileId) {\r\n\r\n        let obs = this.fetchAudiofile(projectName, recordingFile.session, recFileId);\r\n        obs.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                  AudioContextProvider.decodeAudioData(resp.body).then( ab => {\r\n                    observer.next(ab);\r\n                    observer.complete();\r\n                  }).catch( error => {\r\n                    observer.error(error);\r\n                    observer.complete();\r\n                  });\r\n                } else {\r\n                  observer.error('Fetching audio file: response has no body');\r\n                }\r\n              }, error: (err) => {\r\n                if (err instanceof HttpErrorResponse) {\r\n                  if (err.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                    observer.error(err);\r\n                    observer.complete();\r\n                  }\r\n                } else {\r\n                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchAndApplyRecordingFile(aCtx: AudioContext, projectName: string, recordingFile:RecordingFile):Observable<RecordingFile|null> {\r\n\r\n    let wobs = new Observable<RecordingFile|null>(observer=>{\r\n      let recFileId=recordingFile.recordingFileId;\r\n      if(!recFileId){\r\n        recFileId=recordingFile.uuid;\r\n      }\r\n      if(recordingFile.session && recFileId) {\r\n\r\n        let obs = this.fetchAudiofile(projectName, recordingFile.session, recFileId);\r\n        obs.subscribe(\r\n            {next:resp => {\r\n            //console.log(\"Fetched audio file. HTTP response status: \"+resp.status+\", type: \"+resp.type+\", byte length: \"+ resp.body.byteLength);\r\n\r\n            // Do not use Promise version, which does not work with Safari 13 (13.0.5)\r\n            if (resp.body) {\r\n              AudioContextProvider.decodeAudioData(resp.body).then(ab => {\r\n                let abs=new AudioBufferSource(ab);\r\n                let adh=new AudioDataHolder(abs);\r\n                RecordingFileUtils.setAudioData(recordingFile,adh);\r\n                if (this.debugDelay > 0) {\r\n                  window.setTimeout(() => {\r\n\r\n                    observer.next(recordingFile);\r\n                    observer.complete();\r\n                  }, this.debugDelay);\r\n                } else {\r\n                  observer.next(recordingFile);\r\n                  observer.complete();\r\n                }\r\n              }).catch(error => {\r\n                observer.error(error);\r\n                observer.complete();\r\n              });\r\n            } else {\r\n              observer.error('Fetching audio file: response has no body');\r\n            }\r\n          },\r\n          error:(err) => {\r\n          if(err instanceof HttpErrorResponse) {\r\n            if (err.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              observer.error(err);\r\n              observer.complete();\r\n            }\r\n          }else{\r\n            observer.error(err);\r\n          }\r\n          }});\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchSprRecordingFileAudioBuffer(projectName: string, recordingFile:SprRecordingFile):Observable<AudioBuffer|null> {\r\n\r\n    let wobs = new Observable<AudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let obs = this.fetchSprAudiofile(projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);\r\n        obs.subscribe({\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              AudioContextProvider.decodeAudioData(resp.body).then(ab => {\r\n                //RecordingFileUtils.setAudioData(recordingFile,new AudioDataHolder(ab,null));\r\n                observer.next(ab);\r\n                observer.complete();\r\n\r\n              }).catch(error => {\r\n                observer.error(error);\r\n                observer.complete();\r\n              });\r\n            } else {\r\n              observer.error('Fetching audio file: response has no body');\r\n            }\r\n          },\r\n          error: (err) => {\r\n            if (err instanceof HttpErrorResponse && err.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              observer.error(err);\r\n            }\r\n          }});\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n\r\n  fetchSprRecordingFileArrayAudioBuffer( projectName: string, recordingFile:SprRecordingFile):Observable<ArrayAudioBuffer|null> {\r\n    let wobs = new Observable<ArrayAudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let baseUrl=this.sprAudioFileUrl(projectName,recordingFile);\r\n        if(baseUrl) {\r\n          if(recordingFile.samplerate) {\r\n            let lengthInSeconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n            let obs = this.chunkedAudioRequestToArrayBuffer(baseUrl, recordingFile.samplerate, lengthInSeconds);\r\n\r\n            //let obs = this.fetchSprAudiofileArrayBuffer(aCtx,projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);\r\n            let subscr = obs.subscribe({\r\n              next: aab => {\r\n                //console.debug(\"fetchSprRecordingFileArrayAudioBuffer: observer.closed: \"+observer.closed);\r\n                if (observer.closed) {\r\n                  subscr.unsubscribe()\r\n                }\r\n                observer.next(aab)\r\n              },\r\n              complete: () => {\r\n                observer.complete();\r\n              },\r\n              error: (err) => {\r\n                if (err instanceof HttpErrorResponse && err.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                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n          }else{\r\n            observer.error(new Error('Unknown sample rate of recording file ID: '+recordingFile.recordingFileId));\r\n          }\r\n        }\r\n      }else{\r\n        observer.error(new Error('Could not get session ID of recording file'));\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchRecordingFileArrayAudioBuffer( projectName: string, recordingFile:RecordingFile):Observable<ArrayAudioBuffer|null> {\r\n    let wobs = new Observable<ArrayAudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let baseUrl=this.audioFileUrl(projectName,recordingFile);\r\n        if(baseUrl) {\r\n          if(recordingFile.samplerate) {\r\n            let lengthInSeconds = RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n            let obs = this.chunkedAudioRequestToArrayBuffer(baseUrl, recordingFile.samplerate, lengthInSeconds);\r\n\r\n            //let obs = this.fetchSprAudiofileArrayBuffer(aCtx,projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);\r\n            let subscr = obs.subscribe({\r\n              next: aab => {\r\n                //console.debug(\"fetchSprRecordingFileArrayAudioBuffer: observer.closed: \"+observer.closed);\r\n                if (observer.closed) {\r\n                  subscr.unsubscribe()\r\n                }\r\n                observer.next(aab)\r\n              },\r\n              complete: () => {\r\n                observer.complete();\r\n              },\r\n              error: (err) => {\r\n                if (err instanceof HttpErrorResponse && err.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                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n          }else{\r\n            observer.error(new Error('Unknown sample rate of recording file ID: '+recordingFile.recordingFileId));\r\n          }\r\n        }\r\n      }else{\r\n        observer.error(new Error('Could not get session ID of recording file'));\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchSprRecordingFileIndDbAudioBuffer(persistentAudioStorageTarget:PersistentAudioStorageTarget, projectName: string, recordingFile:SprRecordingFile):Observable<IndexedDbAudioBuffer|null> {\r\n    let wobs = new Observable<IndexedDbAudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let baseUrl=this.sprAudioFileUrl(projectName,recordingFile);\r\n        if(baseUrl) {\r\n          if(recordingFile.samplerate) {\r\n            let lengthInSeconds= RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n            let obs = this.chunkedInddbAudioRequest(persistentAudioStorageTarget,baseUrl,recordingFile.samplerate,lengthInSeconds);\r\n            let subscr = obs.subscribe({\r\n              next: aab => {\r\n                //console.debug(\"fetchSprRecordingFileIndDbAudioBuffer: observer.closed: \"+observer.closed);\r\n                if (observer.closed) {\r\n                  subscr.unsubscribe()\r\n                }\r\n                observer.next(aab)\r\n              },\r\n              complete: () => {\r\n                observer.complete();\r\n              },\r\n              error: (err) => {\r\n                if (err instanceof HttpErrorResponse && err.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 errors are real errors\r\n                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n          }else{\r\n            observer.error(new Error('Unknown sample rate of recording file ID: '+recordingFile.recordingFileId));\r\n          }\r\n        }\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchRecordingFileIndDbAudioBuffer(persistentAudioStorageTarget:PersistentAudioStorageTarget, projectName: string, recordingFile:RecordingFile):Observable<IndexedDbAudioBuffer|null> {\r\n    let wobs = new Observable<IndexedDbAudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let baseUrl=this.audioFileUrl(projectName,recordingFile);\r\n        if(baseUrl) {\r\n          if(recordingFile.samplerate) {\r\n            let lengthInSeconds= RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n            let obs = this.chunkedInddbAudioRequest(persistentAudioStorageTarget,baseUrl,recordingFile.samplerate,lengthInSeconds);\r\n            let subscr = obs.subscribe({\r\n              next: aab => {\r\n                //console.debug(\"fetchSprRecordingFileIndDbAudioBuffer: observer.closed: \"+observer.closed);\r\n                if (observer.closed) {\r\n                  subscr.unsubscribe()\r\n                }\r\n                observer.next(aab)\r\n              },\r\n              complete: () => {\r\n                observer.complete();\r\n              },\r\n              error: (err) => {\r\n                if (err instanceof HttpErrorResponse && err.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 errors are real errors\r\n                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n          }else{\r\n            observer.error(new Error('Unknown sample rate of recording file ID: '+recordingFile.recordingFileId));\r\n          }\r\n        }\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n\r\n  fetchSprRecordingFileNetAudioBuffer(projectName: string, recordingFile:SprRecordingFile):Observable<NetAudioBuffer|null> {\r\n    let wobs = new Observable<NetAudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let baseUrl=this.sprAudioFileUrl(projectName,recordingFile);\r\n        if(baseUrl) {\r\n          let seconds= RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n          if(recordingFile.samplerate) {\r\n            let obs = this.chunkAudioRequestToNetAudioBuffer(baseUrl, 0, recordingFile.samplerate,seconds, recordingFile.frames);\r\n            let subscr = obs.subscribe({\r\n              next: aab => {\r\n                //console.debug(\"fetchSprRecordingFileIndDbAudioBuffer: observer.closed: \"+observer.closed);\r\n                if (observer.closed) {\r\n                  subscr.unsubscribe();\r\n                }else {\r\n                  observer.next(aab)\r\n                }\r\n              },\r\n              complete: () => {\r\n                observer.complete();\r\n              },\r\n              error: (err) => {\r\n                if (err instanceof HttpErrorResponse && err.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 errors are real errors\r\n                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n          }else{\r\n            observer.error(new Error('Unknown sample rate of recording file ID: '+recordingFile.recordingFileId));\r\n          }\r\n        }else{\r\n          observer.error();\r\n        }\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchRecordingFileNetAudioBuffer(projectName: string, recordingFile:RecordingFile):Observable<NetAudioBuffer|null> {\r\n    let wobs = new Observable<NetAudioBuffer|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let baseUrl=this.audioFileUrl(projectName,recordingFile);\r\n        if(baseUrl) {\r\n          let seconds= RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n          if(recordingFile.samplerate) {\r\n            let obs = this.chunkAudioRequestToNetAudioBuffer(baseUrl, 0, recordingFile.samplerate,seconds, recordingFile.frames);\r\n            let subscr = obs.subscribe({\r\n              next: aab => {\r\n                //console.debug(\"fetchSprRecordingFileIndDbAudioBuffer: observer.closed: \"+observer.closed);\r\n                if (observer.closed) {\r\n                  subscr.unsubscribe();\r\n                }else {\r\n                  observer.next(aab)\r\n                }\r\n              },\r\n              complete: () => {\r\n                observer.complete();\r\n              },\r\n              error: (err) => {\r\n                if (err instanceof HttpErrorResponse && err.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 errors are real errors\r\n                  observer.error(err);\r\n                }\r\n              }\r\n            });\r\n          }else{\r\n            observer.error(new Error('Unknown sample rate of recording file ID: '+recordingFile.recordingFileId));\r\n          }\r\n        }else{\r\n          observer.error();\r\n        }\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n\r\n  fetchAndApplySprRecordingFile(aCtx: AudioContext, projectName: string, recordingFile:SprRecordingFile):Observable<SprRecordingFile|null> {\r\n\r\n    let wobs = new Observable<SprRecordingFile|null>(observer=>{\r\n      if(recordingFile.session) {\r\n        let obs = this.fetchSprAudiofile(projectName, recordingFile.session, recordingFile.itemCode, recordingFile.version);\r\n        obs.subscribe(\r\n            {\r\n              next: resp => {\r\n              //console.log(\"Fetched audio file. HTTP response status: \"+resp.status+\", type: \"+resp.type+\", byte length: \"+ resp.body.byteLength);\r\n\r\n              // Do not use Promise version, which does not work with Safari 13 (13.0.5)\r\n              if (resp.body) {\r\n                AudioContextProvider.decodeAudioData(resp.body).then(ab => {\r\n                  let abs=new AudioBufferSource(ab);\r\n                  RecordingFileUtils.setAudioData(recordingFile,new AudioDataHolder(abs));\r\n                  if (this.debugDelay > 0) {\r\n                    window.setTimeout(() => {\r\n\r\n                      observer.next(recordingFile);\r\n                      observer.complete();\r\n                    }, this.debugDelay);\r\n                  } else {\r\n                    observer.next(recordingFile);\r\n                    observer.complete();\r\n                  }\r\n                }).catch( error => {\r\n                  observer.error(error);\r\n                  observer.complete();\r\n                });\r\n              } else {\r\n                observer.error('Fetching audio file: response has no body');\r\n              }\r\n            },\r\n            error:(err) => {\r\n              if (err instanceof HttpErrorResponse && err.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                observer.error(err);\r\n              }\r\n            }});\r\n      }else{\r\n        observer.error();\r\n      }\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n\r\n  fetchRecordingFile(aCtx: AudioContext, projectName: string, sessId: string | number, itemcode: string,version:number):Observable<SprRecordingFile|null> {\r\n\r\n    let wobs = new Observable<SprRecordingFile | null>(observer=>{\r\n      let obs = this.fetchSprAudiofile(projectName, sessId, itemcode,version);\r\n\r\n\r\n      obs.subscribe(\r\n          {next:resp =>\r\n      {\r\n        if (resp.body) {\r\n          AudioContextProvider.decodeAudioData(resp.body).then( ab => {\r\n            let abs = new AudioBufferSource(ab);\r\n            let adh = new AudioDataHolder(abs);\r\n            let rf = new SprRecordingFile(sessId, itemcode, version, adh);\r\n            if (this.debugDelay > 0) {\r\n              window.setTimeout(() => {\r\n\r\n                observer.next(rf);\r\n                observer.complete();\r\n              }, this.debugDelay);\r\n            } else {\r\n              observer.next(rf);\r\n              observer.complete();\r\n            }\r\n          }).catch((reason)=>{observer.error(reason)});\r\n        } else {\r\n          observer.error();\r\n        }\r\n      }\r\n    ,\r\n     error: (err) => {\r\n        if (err instanceof HttpErrorResponse && err.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 errors are real errors\r\n          observer.error(err);\r\n        }\r\n      }\r\n    });\r\n    });\r\n\r\n    return wobs;\r\n  }\r\n}\r\n\r\n\r\n\r\n"]}