speechrecorderng 3.6.0 → 3.8.0

package/esm2022/lib/audio/capture/capture.mjs

@@ -0,0 +1,855 @@
+import { Browser, Platform, UserAgentBuilder } from "../../utils/ua-parser";
+import { AudioStorageType, Platform as CfgPlatform } from "../../speechrecorder/project/project";
+import { ArrayAudioBuffer } from "../array_audio_buffer";
+import { UUID } from "../../utils/utils";
+import { IndexedDbAudioBuffer } from "../inddb_audio_buffer";
+import { AudioContextProvider } from "../context";
+export const CHROME_ACTIVATE_ECHO_CANCELLATION_WITH_AGC = false;
+const DEBUG_TRACE_LEVEL = 0;
+// Dirty way to load this module
+// Copy content of interceptor_worklet.js to this string
+const awpStr = "class AudioCaptureInterceptorProcessor extends AudioWorkletProcessor{\n" +
+    "\n" +
+    "    BUFFER_QUANTUMS=64;\n" +
+    "    QUANTUM_FRAME_LEN=128;\n" +
+    "    BUFFER_FRAME_LEN=this.QUANTUM_FRAME_LEN*this.BUFFER_QUANTUMS;\n" +
+    "    buffer=null;\n" +
+    "    bufferPos=0;\n" +
+    "    bufferPosBytes=0;\n" +
+    "    constructor() {\n" +
+    "        super();\n" +
+    "\n" +
+    "    }\n" +
+    "\n" +
+    " process(\n" +
+    "      inputs,\n" +
+    "      outputs,\n" +
+    "      parameters\n" +
+    "  ){\n" +
+    "\n" +
+    "     let inputsCnt=inputs.length;\n" +
+    "     let channelCount=0;\n" +
+    "     let inputLen=0;\n" +
+    "     let inputLenBytes=0;\n" +
+    "     if(inputsCnt>0) {\n" +
+    "         let input0 = inputs[0];\n" +
+    "         channelCount = input0.length;\n" +
+    "         if (channelCount > 0) {\n" +
+    "             let input0ch0=input0[0];\n" +
+    "             inputLen=input0ch0.length;\n" +
+    "             inputLenBytes=input0ch0.buffer.length;\n" +
+    "         }\n" +
+    "     }\n" +
+    "     if (!this.buffer || this.buffer.length < channelCount) {\n" +
+    "         this.buffer = new Array(channelCount);\n" +
+    "         this.bufferPos = 0\n" +
+    "         for (let bch = 0; bch < channelCount; bch++) {\n" +
+    "             this.buffer[bch] = new Float32Array(this.BUFFER_FRAME_LEN);\n" +
+    "             this.bufferPos = 0;\n" +
+    "             this.bufferPosBytes=0;\n" +
+    "         }\n" +
+    "     }\n" +
+    "     let bufAvail = this.BUFFER_FRAME_LEN - this.bufferPos;\n" +
+    "     // check if buffer has to be transferred\n" +
+    "     if (inputLen > bufAvail) {\n" +
+    "         let ada=new Array(channelCount);\n" +
+    "         for (let ch = 0; ch < channelCount; ch++) {\n" +
+    "             ada[ch]=this.buffer[ch].buffer.slice(0);\n" +
+    "         }\n" +
+    "         this.port.postMessage({\n" +
+    "             data: ada,\n" +
+    "             chs: channelCount,\n" +
+    "             len: this.bufferPos\n" +
+    "         }, ada);\n" +
+    "         // buffer transferred, reset\n" +
+    "         this.bufferPos = 0;\n" +
+    "         this.bufferPosBytes=0;\n" +
+    "     }\n" +
+    "\n" +
+    "     for(let ii=0;ii<inputsCnt;ii++) {\n" +
+    "         for (let ch = 0; ch < channelCount; ch++) {\n" +
+    "             // Mute outputs\n" +
+    "             //outputs[ii][ch].fill(0);\n" +
+    "             let chSamples = inputs[ii][ch];\n" +
+    "             this.buffer[ch].set(chSamples,this.bufferPos);\n" +
+    "         }\n" +
+    "         this.bufferPos+=inputLen;\n" +
+    "         this.bufferPosBytes+=inputLenBytes;\n" +
+    "     }\n" +
+    "    \n" +
+    "     return true;\n" +
+    "  }\n" +
+    "}\n" +
+    "\n" +
+    "registerProcessor('capture-interceptor',AudioCaptureInterceptorProcessor);\n";
+export class AudioCapture {
+    get maxAutoNetMemStoreSamples() {
+        return this._maxAutoNetMemStoreSamples;
+    }
+    set maxAutoNetMemStoreSamples(value) {
+        this._maxAutoNetMemStoreSamples = value;
+    }
+    set recUUID(value) {
+        this._recUUID = value;
+    }
+    get recUUID() {
+        return this._recUUID;
+    }
+    get audioStorageType() {
+        return this._audioStorageType;
+    }
+    set audioStorageType(value) {
+        this._audioStorageType = value;
+    }
+    get persistentAudioStorageTarget() {
+        return this._persistentAudioStorageTarget;
+    }
+    set persistentAudioStorageTarget(value) {
+        this._persistentAudioStorageTarget = value;
+    }
+    get opened() {
+        return this._opened;
+    }
+    static { this.BUFFER_SIZE = 8192; }
+    static { this.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES = 2880000 * 5; } // Default 5 minute at 48kHz
+    static { this.captureInterceptorModuleRegistered = false; }
+    //private context:AudioContext|null=null;
+    constructor() {
+        this._maxAutoNetMemStoreSamples = AudioCapture.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES;
+        this.context = null;
+        this._recUUID = null;
+        this.agcStatus = null;
+        this.bufferingNode = null;
+        this.data = null;
+        this.audioOutStream = null;
+        this.disconnectStreams = true;
+        this._opened = false;
+        this.capturing = false;
+        this.framesRecorded = 0;
+        this._audioStorageType = AudioStorageType.MEM_ENTIRE;
+        this._persistentAudioStorageTarget = null;
+        this.persisted = true;
+        this.persistError = null;
+        this.inddbAudioBuffer = null;
+        this.n = navigator;
+    }
+    _audioContext() {
+        if (!this.context) {
+            this.context = AudioContextProvider.audioContextInstance();
+            if (this.context) {
+                this.context.addEventListener('statechange', () => {
+                    if (this.context && this.context.state !== 'running') {
+                        this.close();
+                    }
+                });
+            }
+        }
+        return this.context;
+    }
+    initData() {
+        if (!this._recUUID) {
+            this._recUUID = UUID.generate();
+        }
+        this.persistError = null;
+        //console.debug("Audio capture initialize storage for type: "+this._audioStorageType);
+        if (AudioStorageType.DB_CHUNKED === this._audioStorageType && this._persistentAudioStorageTarget && this._recUUID) {
+            //console.debug("Create indexed db audio buffer.");
+            this.inddbAudioBuffer = new IndexedDbAudioBuffer(this._persistentAudioStorageTarget, this.channelCount, this.currentSampleRate, AudioCapture.BUFFER_SIZE, 0, this._recUUID);
+        }
+        if (!(AudioStorageType.NET_CHUNKED === this._audioStorageType)) {
+            // Initialize audio data array except for net audio buffer mode
+            this.data = new Array();
+            for (let i = 0; i < this.channelCount; i++) {
+                this.data.push(new Array());
+            }
+        }
+        this.framesRecorded = 0;
+    }
+    listDevices() {
+        navigator.mediaDevices.enumerateDevices().then((l) => this.printDevices(l));
+    }
+    dummySession() {
+        // workaround to request permissions:
+        // Start a dummy session
+        let mediaStrCnstrs = { audio: { echoCancelation: false }
+        };
+        return navigator.mediaDevices.getUserMedia(mediaStrCnstrs);
+    }
+    stopAllSessionTracks(mediaStream) {
+        let ats = mediaStream.getTracks();
+        for (let atIdx = 0; atIdx < ats.length; atIdx++) {
+            //console.debug("Stop dummy session track: #" + atIdx)
+            ats[atIdx].stop();
+        }
+    }
+    deviceInfos(cb, retry = true, dummyStream) {
+        navigator.mediaDevices.enumerateDevices().then((l) => {
+            let labelsAvailable = false;
+            for (let i = 0; i < l.length; i++) {
+                let di = l[i];
+                if (di.label) {
+                    labelsAvailable = true;
+                }
+            }
+            if (!labelsAvailable) {
+                //console.debug("Media device enumeration: No labels.")
+                if (retry) {
+                    console.info("Starting dummy session to request audio permissions...");
+                    this.dummySession().then((s) => {
+                        // and stop it immediately
+                        if (s) {
+                            //console.debug("Got dummy session stream: " + s + " .")
+                        }
+                        else {
+                            //console.debug("No dummy stream")
+                        }
+                        // retry (only once)
+                        this.deviceInfos(cb, false, s);
+                    }, reason => {
+                        //console.debug("Dummy session rejected.")
+                        // TODO error callback
+                        cb(null);
+                    });
+                }
+                else {
+                    cb(null);
+                }
+            }
+            else {
+                // success
+                cb(l);
+            }
+            if (dummyStream) {
+                this.stopAllSessionTracks(dummyStream);
+            }
+        }, (reason) => {
+            //rejected
+            //console.debug("Media device enumeration rejected.")
+            if (retry) {
+                //console.debug("Starting dummy session to request audio permissions...")
+                this.dummySession().then((s) => {
+                    // and stop it immediately
+                    //console.debug("Dummy session.")
+                    if (s) {
+                        //console.debug("Got dummy session stream: " + s + " .")
+                    }
+                    else {
+                        //console.debug("No dummy stream")
+                    }
+                    // retry (only once)
+                    this.deviceInfos(cb, false, s);
+                }, reason => {
+                    //console.debug("Dummy session rejected.")
+                    // TODO error callback
+                    cb(null);
+                });
+            }
+            else {
+                cb(null);
+            }
+            if (dummyStream) {
+                this.stopAllSessionTracks(dummyStream);
+            }
+        });
+    }
+    printDevices(l) {
+        //let selDeviceId = '___dummy___';
+        for (let i = 0; i < l.length; i++) {
+            let di = l[i];
+            console.log("Audio device: Id: " + di.deviceId + " groupId: " + di.groupId + " label: " + di.label + " kind: " + di.kind);
+        }
+    }
+    addCaptureInterceptor() {
+        if (this.context) {
+            const awn = new AudioWorkletNode(this.context, 'capture-interceptor');
+            awn.onprocessorerror = (ev) => {
+                let msg = 'Unknwon error';
+                if (ev instanceof ErrorEvent) {
+                    msg = ev.message;
+                }
+                console.error("Capture audio worklet error: " + msg);
+                if (this.listener) {
+                    this.listener.error(msg);
+                }
+            };
+            let awnPt = awn.port;
+            if (awnPt) {
+                awnPt.onmessage = (ev) => {
+                    if (this.capturing) {
+                        let dt = ev.data;
+                        let chs = dt.chs;
+                        let adaLen = dt.data.length;
+                        if (DEBUG_TRACE_LEVEL > 8) {
+                            console.debug('Received data from worklet: ' + chs + ' ' + dt.len + ' Data chs: ' + adaLen);
+                        }
+                        let chunk = new Array(chs);
+                        const samples = this.framesRecorded * chs;
+                        if ((AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this.audioStorageType || AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this.audioStorageType) && this.data && samples > this._maxAutoNetMemStoreSamples) {
+                            this.data = null;
+                        }
+                        //console.debug("Data initialized: "+(this.data!=null));
+                        for (let ch = 0; ch < chs; ch++) {
+                            //console.debug("Data ch initialized: "+(this.data !=null && this.data[ch] !=null));
+                            if (ch < this.channelCount) {
+                                if (dt.data[ch]) {
+                                    let fa = new Float32Array(dt.data[ch]);
+                                    if (this.data && this.data[ch]) {
+                                        this.data[ch].push(fa);
+                                    }
+                                    chunk[ch] = fa;
+                                    // Use samples of channel 0 to count frames (samples)
+                                    if (ch == 0) {
+                                        this.framesRecorded += fa.length;
+                                    }
+                                }
+                            }
+                        }
+                        if (this.audioOutStream) {
+                            try {
+                                this.audioOutStream.write(chunk);
+                                // // Random test error:
+                                // if(Math.random()>0.98) {
+                                //   throw new Error('Test');
+                                // }
+                            }
+                            catch (err) {
+                                if (err instanceof Error) {
+                                    this.persistError = err;
+                                }
+                                else {
+                                    this.persistError = new Error('Error handling recorded audio data');
+                                }
+                                console.error("Capture error: " + err);
+                                try {
+                                    this.stop();
+                                }
+                                catch (err2) {
+                                    console.error("Capture next error (ignored): " + err2);
+                                }
+                                finally {
+                                    if (this.listener) {
+                                        let errExpl = '';
+                                        if (err instanceof DOMException) {
+                                            errExpl = ': ' + err.name + ': ' + err.message;
+                                        }
+                                        this.listener.error("Could not handle recorded audio data" + errExpl, "Please try to record again.");
+                                    }
+                                    else {
+                                        this.close();
+                                    }
+                                }
+                            }
+                        }
+                        if (AudioStorageType.DB_CHUNKED === this._audioStorageType && this._persistentAudioStorageTarget) {
+                            this.store();
+                        }
+                    }
+                };
+            }
+            // Tried to fix that Safari does not record the second channel
+            // Does not help
+            //awn.channelCount=this.channelCount;
+            //awn.channelCountMode='explicit';
+            //console.debug('Channel count explicitly set to '+this.channelCount);
+            this.bufferingNode = awn;
+            //this.bufferingNode.channelCount=this.channelCount;
+            this._opened = true;
+            if (this.listener) {
+                this.listener.opened();
+            }
+        }
+    }
+    open(channelCount, selDeviceId, autoGainControlConfigs, allowEchoCancellation) {
+        //console.debug("Capture open: ctx state: "+this.context.state);
+        this.context = this._audioContext();
+        if (!this.context) {
+            throw new Error("Could not get audio context!");
+        }
+        if (this.context.state === 'suspended') {
+            //console.debug("Capture open: Resume context");
+            this.context.resume().then(() => {
+                //console.debug("Capture open (ctx resumed): ctx state: "+this.context.state);
+                this._open(channelCount, selDeviceId, autoGainControlConfigs, allowEchoCancellation);
+            }).catch((err) => {
+                console.error(err.message);
+                throw err;
+            });
+        }
+        else if (this.context.state === 'closed') {
+            const msg = 'Error on start capture: The audio context is already closed.';
+            console.error(msg);
+            throw new Error(msg);
+        }
+        else {
+            this._open(channelCount, selDeviceId, autoGainControlConfigs, allowEchoCancellation);
+        }
+    }
+    _open(channelCount, selDeviceId, autoGainControlConfigs, allowEchoCancellation) {
+        this.channelCount = channelCount;
+        this.framesRecorded = 0;
+        this.context = this._audioContext();
+        if (!this.context) {
+            throw new Error("Could not get audio context!");
+        }
+        //var msc = new AudioStreamConstr();
+        // var msc={};
+        //msc.video = false;
+        //msc.audio = true;
+        // Chrome and Firefox stereo channels are identical !!
+        // And even worse: The data coming from the source is already preprocessed on FF and Chrome. It contains DSP artifacts!!
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=387737
+        // The workaround to set these constraints does _NOT_ help:
+        //var msc={audio: {echoCancellation: false,channelCount: 2, googAudioMirroring: false},video: false};
+        // Safari at least version 11: Support for media streams
+        // TODO test if input is unprocessed
+        let msc;
+        console.info('User agent: ' + navigator.userAgent);
+        let ua = UserAgentBuilder.userAgent();
+        // ua.components.forEach((c)=>{
+        //   console.info("UA_Comp: "+c.toString());
+        // })
+        let agcCfg = null;
+        let autoGainControl = false;
+        let chromeEchoCancellation = false;
+        if (autoGainControlConfigs) {
+            for (let agcc of autoGainControlConfigs) {
+                if (agcc.platform === CfgPlatform.Android && ua.detectedPlatform === Platform.Android) {
+                    agcCfg = agcc;
+                    break;
+                }
+                if (agcc.platform === CfgPlatform.Windows && ua.detectedPlatform === Platform.Windows) {
+                    agcCfg = agcc;
+                    break;
+                }
+            }
+            if (agcCfg) {
+                // TODO use EXACT/IDEAL constraint
+                autoGainControl = agcCfg.value;
+                if (CHROME_ACTIVATE_ECHO_CANCELLATION_WITH_AGC) {
+                    chromeEchoCancellation = agcCfg.value;
+                }
+                // TODO query real AGC status
+                this.agcStatus = agcCfg.value;
+            }
+            else {
+                this.agcStatus = false;
+            }
+        }
+        // default
+        msc = {
+            audio: {
+                deviceId: selDeviceId,
+                echoCancellation: false,
+                channelCount: channelCount,
+                autoGainControl: autoGainControl
+            },
+            video: false
+        };
+        if (ua.detectedBrowser === Browser.Edge) {
+            // Microsoft Edge sends unmodified audio
+            // The constraint can follow the specification
+            console.info("Setting media track constraints for Microsoft Edge.");
+            msc = {
+                audio: {
+                    deviceId: selDeviceId,
+                    echoCancellation: false,
+                    channelCount: channelCount,
+                    autoGainControl: autoGainControl
+                },
+                video: false
+            };
+        }
+        else if (ua.detectedBrowser === Browser.Chrome) {
+            // Google Chrome: we need to switch of each of the preprocessing units including the
+            console.info("Setting media track constraints for Google Chrome.");
+            // Chrome 60 -> 61 changed
+            // it works now without mandatory/optional sub-objects
+            // Requires at least Chrome 61
+            msc = {
+                audio: {
+                    deviceId: selDeviceId,
+                    channelCount: channelCount,
+                    echoCancellation: { exact: chromeEchoCancellation },
+                    autoGainControl: { exact: autoGainControl },
+                    sampleSize: { min: 16 },
+                },
+                video: false,
+            };
+        }
+        else if (ua.detectedBrowser === Browser.Firefox) {
+            console.info("Setting media track constraints for Mozilla Firefox.");
+            // Firefox
+            msc = {
+                audio: {
+                    deviceId: selDeviceId,
+                    channelCount: channelCount,
+                    echoCancellation: false,
+                    autoGainControl: autoGainControl,
+                    noiseSuppression: false
+                },
+                video: false,
+            };
+        }
+        else if (ua.detectedBrowser === Browser.Safari) {
+            console.info("Setting media track constraints for Safari browser.");
+            //console.info("Apply workaround for Safari: Avoid disconnect of streams.");
+            this.disconnectStreams = true;
+            msc = {
+                audio: {
+                    deviceId: selDeviceId,
+                    channelCount: channelCount,
+                    echoCancellation: allowEchoCancellation ? undefined : false
+                },
+                video: false,
+            };
+        }
+        else {
+            // TODO default constraints or error Browser not supported
+        }
+        console.debug("Audio capture, AGC: " + this.agcStatus);
+        let ump = navigator.mediaDevices.getUserMedia(msc);
+        ump.then((s) => {
+            if (this.context) {
+                this.stream = s;
+                let aTracks = s.getAudioTracks();
+                for (let i = 0; i < aTracks.length; i++) {
+                    let aTrack = aTracks[i];
+                    console.info("Track audio info: id: " + aTrack.id + " kind: " + aTrack.kind + " label: \"" + aTrack.label + "\"");
+                    let mtrSts = aTrack.getSettings();
+                    // Typescript lib.dom.ts MediaTrackSettings.channelCount is missing
+                    // https://github.com/mdn/browser-compat-data/blob/5493d8f937e05b2ddbd41b99f5bdfad4a1f2ed85/api/MediaTrackSettings.json
+                    //@ts-ignore
+                    console.info("Track audio settings: Ch cnt: " + mtrSts.channelCount + ", AGC: " + mtrSts.autoGainControl + ", Echo cancell.: " + mtrSts.echoCancellation);
+                    if (mtrSts.autoGainControl) {
+                        this.agcStatus = mtrSts.autoGainControl;
+                    }
+                    console.debug("Echo cancellation: " + mtrSts.echoCancellation);
+                }
+                let vTracks = s.getVideoTracks();
+                for (let i = 0; i < vTracks.length; i++) {
+                    let vTrack = vTracks[i];
+                    console.info("Track video info: id: " + vTrack.id + " kind: " + vTrack.kind + " label: " + vTrack.label);
+                }
+                this.mediaStream = this.context.createMediaStreamSource(s);
+                // stream channel count ( is always 2 !)
+                let streamChannelCount = this.mediaStream.channelCount;
+                console.info("Stream channel count: " + streamChannelCount);
+                // is not set!!
+                //this.currentSampleRate = this.mediaStream.sampleRate;
+                this.currentSampleRate = this.context.sampleRate;
+                console.info("Source audio node: channels: " + streamChannelCount + " samplerate: " + this.currentSampleRate);
+                if (this.audioOutStream) {
+                    this.audioOutStream.setFormat(this.channelCount, this.currentSampleRate);
+                }
+                // W3C  -> new name is createScriptProcessor
+                //
+                // Again deprecated, but AudioWorker not yet implemented in stable releases (June 2016)
+                // AudioWorker is now AudioWorkletProcessor ... (May 2017)
+                // Update 12-2020:
+                // The ScriptProcessorNode Interface - DEPRECATED
+                // Update 06-2021
+                //  AudioWorkletProcessor is here to stay. Web Audio API has now Recommendation status !
+                if (this.context.audioWorklet) {
+                    //const workletFileName = ('file-loader!./interceptor_worklet.js');
+                    //const workletFileName = 'http://localhost:4200/assets/interceptor_worklet.js';
+                    //console.log(awpStr);
+                    if (AudioCapture.captureInterceptorModuleRegistered) {
+                        // Required capture interceptor module already registered
+                        this.addCaptureInterceptor();
+                    }
+                    else {
+                        // Register capture interceptor module
+                        let audioWorkletModuleBlob = new Blob([awpStr], { type: 'text/javascript' });
+                        let audioWorkletModuleBlobUrl = window.URL.createObjectURL(audioWorkletModuleBlob);
+                        this.context.audioWorklet.addModule(audioWorkletModuleBlobUrl).then(() => {
+                            AudioCapture.captureInterceptorModuleRegistered = true;
+                            this.addCaptureInterceptor();
+                        }).catch((error) => {
+                            console.log('Could not add module ' + error);
+                        });
+                    }
+                }
+                else if (this.context.createScriptProcessor) {
+                    // The ScriptProcessorNode Interface - DEPRECATED Only as fallback
+                    // TODO should we use streamChannelCount or channelCount here ?
+                    let scriptProcessorNode = this.context.createScriptProcessor(AudioCapture.BUFFER_SIZE, streamChannelCount, streamChannelCount);
+                    this.bufferingNode = scriptProcessorNode;
+                    let c = 0;
+                    if (scriptProcessorNode.onaudioprocess) {
+                        scriptProcessorNode.onaudioprocess = (e) => {
+                            if (this.capturing) {
+                                let inBuffer = e.inputBuffer;
+                                // only process requested count of channels
+                                let currentBuffers = new Array(channelCount);
+                                for (let ch = 0; ch < channelCount; ch++) {
+                                    let chSamples = inBuffer.getChannelData(ch);
+                                    let chSamplesCopy = chSamples.slice(0);
+                                    currentBuffers[ch] = chSamplesCopy.slice(0);
+                                    if (this.data) {
+                                        this.data[ch].push(chSamplesCopy);
+                                    }
+                                    if (DEBUG_TRACE_LEVEL > 8) {
+                                        console.debug("Process " + chSamplesCopy.length + " samples.");
+                                    }
+                                    this.framesRecorded += chSamplesCopy.length;
+                                }
+                                c++;
+                                if (this.audioOutStream) {
+                                    this.audioOutStream.write(currentBuffers);
+                                }
+                            }
+                        };
+                        this._opened = true;
+                        if (this.listener) {
+                            this.listener.opened();
+                        }
+                    }
+                    else {
+                        this.listener.error('Browser does not support audio processing (ScriptProcessor.onaudioprocess method not found)!');
+                    }
+                }
+                else {
+                    this.listener.error('Browser does not support audio processing (neither AudioWorkletProcessor nor ScriptProcessor)!');
+                }
+            }
+        }, (e) => {
+            console.error(e + " Error name: " + e.name);
+            if (this.listener) {
+                if ('NotAllowedError' === e.name) {
+                    this.listener.error('Not allowed to use your microphone.', 'Please make sure that microphone access is allowed for this web page and reload the page.');
+                }
+                else if ('NotReadableError' === e.name) {
+                    this.listener.error('Could not read from your audio device.', 'Please make sure your audio device is working.');
+                }
+                else if ('OverconstrainedError' === e.name) {
+                    let eMsg = e.msg ? e.msg : 'Overconstrained media device request error.';
+                    this.listener.error(eMsg);
+                }
+                else {
+                    this.listener.error();
+                }
+            }
+        });
+    }
+    _start() {
+        if (this.context) {
+            this.initData();
+            if (this.audioOutStream) {
+                this.audioOutStream.nextStream();
+            }
+            this.capturing = true;
+            if (this.bufferingNode) {
+                this.mediaStream.connect(this.bufferingNode);
+                this.bufferingNode.connect(this.context.destination);
+            }
+            if (this.listener) {
+                this.listener.started();
+            }
+        }
+    }
+    start() {
+        if (this.context) {
+            const aSt = this.context.state;
+            if (aSt === 'running') {
+                this._start();
+            }
+            else {
+                console.debug("Capture start: audio context not running, state: " + aSt + ", resuming...");
+                this.context.resume().then(() => {
+                    console.debug("Capture start: audio context resumed, starting...");
+                    this._start();
+                });
+            }
+        }
+    }
+    stop() {
+        if (this.disconnectStreams && this.bufferingNode) {
+            this.mediaStream.disconnect(this.bufferingNode);
+            if (this.context) {
+                this.bufferingNode.disconnect(this.context.destination);
+            }
+        }
+        try {
+            if (this.audioOutStream) {
+                this.audioOutStream.flush();
+            }
+        }
+        catch (err) {
+            console.error("Could not flush capture stream.");
+            throw err;
+        }
+        finally {
+            this.capturing = false;
+            if (this.inddbAudioBuffer && this.persistError) {
+                // Delete invalid persistent audio data and hope that it will be completely uploaded to the server
+                this.inddbAudioBuffer.releaseAudioData();
+                this.inddbAudioBuffer = null;
+            }
+            if (this.listener && (this.persistError || this.persisted)) {
+                //console.debug("Stopped by stop() method call");
+                this.listener.stopped();
+            }
+        }
+    }
+    store() {
+        // if(this.db && this.recUUID){
+        //    let tr= this.db.transaction(SprDb.RECORDING_FILE_CHUNKS_OBJECT_STORE_NAME, 'readwrite');
+        //    let recFileObjStore = tr.objectStore(SprDb.RECORDING_FILE_CHUNKS_OBJECT_STORE_NAME);
+        //
+        //      try {
+        //        let ch0Data=this.data[0];
+        //        let dataChkCnt=ch0Data.length;
+        //          let pos = 0;
+        //          for (let chCkIdx = 0; chCkIdx < dataChkCnt; chCkIdx++) {
+        //            let bufLen=0;
+        //            for (let ch = 0; ch < this.channelCount; ch++) {
+        //              let chChk = this.data[ch][chCkIdx];
+        //              bufLen = chChk.length;
+        //              //let cacheId = uuid + '_' + ch + '_' + chCkIdx;
+        //              let chkDbId = [this.recUUID, this.indDbChkIdx + chCkIdx, ch];
+        //              let cr = recFileObjStore.add(chChk, chkDbId);
+        //              //console.debug("Added: "+ch+" "+(this.indDbChkIdx+chCkIdx));
+        //              cr.onsuccess=()=>{
+        //                //console.debug("Stored audio data to indexed db");
+        //              }
+        //              cr.onerror=()=>{
+        //                console.error("Error storing audio data to indexed db");
+        //              }
+        //            }
+        //            pos += bufLen;
+        //        }
+        //        this.indDbChkIdx+=dataChkCnt;
+        //
+        //        tr.onerror = (err) => {
+        //          console.error('Failed to cache audio data to indexed db: ' + err)
+        //        }
+        //        tr.oncomplete = () => {
+        //          //console.debug('Transferred capture audio data to indexed db, deleting original data from memory...');
+        //
+        //          /// Audio data saved to index db delete from in memory data array
+        //          for (let ch = 0; ch < this.channelCount; ch++) {
+        //           this.data[ch].splice(0);
+        //            //console.debug("Spliced/removed ch: "+ch);
+        //          }
+        //
+        //          this.persisted=true;
+        //          if(this.listener && !this.capturing){
+        //            //console.debug("Stopped by indexed db hook");
+        //            this.listener.stopped();
+        //          }
+        //        }
+        //        // Commit chunks
+        //        this.persisted=false;
+        //        tr.commit();
+        //      } catch (err) {
+        //        console.error('Transfer capture audio data error: '+err);
+        //      }
+        //    }
+        // if(!this.inddbAudioBuffer && this._persistentAudioStorageTarget && this.recUUID) {
+        //   this.inddbAudioBuffer = new IndexedDbAudioBuffer(this._persistentAudioStorageTarget, this.channelCount,this.currentSampleRate,AudioCapture.BUFFER_SIZE,0,this.recUUID)
+        // }
+        if (this.inddbAudioBuffer && this.data) {
+            // Try to append to
+            this.inddbAudioBuffer.appendRawAudioData(this.data).subscribe({
+                complete: () => {
+                    //console.debug('Transferred capture audio data to indexed db, deleting original data from memory...');
+                    /// Audio data saved to index db delete from in memory data array
+                    if (this.data) {
+                        for (let ch = 0; ch < this.channelCount; ch++) {
+                            this.data[ch].splice(0);
+                            //console.debug("Spliced/removed ch: "+ch);
+                        }
+                    }
+                    this.persisted = true;
+                    if (this.listener && !this.capturing) {
+                        //console.debug("Stopped by indexed db hook");
+                        this.listener.stopped();
+                    }
+                }, error: (err) => {
+                    // Only log the first error
+                    if (!this.persistError) {
+                        this.persistError = err;
+                        console.error("Error persisting audio data: " + err);
+                    }
+                }
+            });
+            this.persisted = false;
+        }
+    }
+    close() {
+        if (this.mediaStream) {
+            this.mediaStream.disconnect();
+        }
+        if (this.stream) {
+            const mts = this.stream.getTracks();
+            for (let i = 0; i < mts.length; i++) {
+                mts[i].stop();
+            }
+        }
+        this._opened = false;
+    }
+    audioBuffer() {
+        let ab = null;
+        if (this.context && this.data) {
+            let frameLen = 0;
+            let ch0Data = this.data[0];
+            for (let ch0Chk of ch0Data) {
+                frameLen += ch0Chk.length;
+            }
+            try {
+                ab = this.context.createBuffer(this.channelCount, frameLen, this.context.sampleRate);
+            }
+            catch (err) {
+                if (err instanceof DOMException) {
+                    if (err.name === 'NotSupportedError') {
+                        if (frameLen == 0) {
+                            // Empty buffers are not supported by Chromium
+                            // Create dummy buffer with one sample
+                            ab = this.context.createBuffer(this.channelCount, 1, this.context.sampleRate);
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                else if (err instanceof RangeError) {
+                    // Out of memory
+                    // TODO What to do ??
+                    throw err;
+                }
+                else {
+                    throw err;
+                }
+            }
+            for (let ch = 0; ch < this.channelCount; ch++) {
+                let chD = ab.getChannelData(ch);
+                let pos = 0;
+                for (let chChk of this.data[ch]) {
+                    let bufLen = chChk.length;
+                    chD.set(chChk, pos);
+                    pos += bufLen;
+                }
+            }
+        }
+        return ab;
+    }
+    audioBufferArray() {
+        let arrAb = null;
+        if (this.data) {
+            arrAb = new ArrayAudioBuffer(this.channelCount, this.currentSampleRate, this.data);
+        }
+        return arrAb;
+    }
+    inddbAudioBufferArray() {
+        if (this.persistError) {
+            return null;
+        }
+        else {
+            return this.inddbAudioBuffer;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capture.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/audio/capture/capture.ts"],"names":[],"mappings":"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","sourcesContent":["import {SequenceAudioFloat32OutStream} from \"../io/stream\";\r\nimport {Browser, Platform, UserAgentBuilder} from \"../../utils/ua-parser\";\r\n\r\nimport {AudioStorageType, AutoGainControlConfig, Platform as CfgPlatform} from \"../../speechrecorder/project/project\";\r\nimport {ArrayAudioBuffer} from \"../array_audio_buffer\";\r\nimport {UUID} from \"../../utils/utils\";\r\nimport {IndexedDbAudioBuffer, PersistentAudioStorageTarget} from \"../inddb_audio_buffer\";\r\nimport {AudioContextProvider} from \"../context\";\r\n\r\n\r\nexport const CHROME_ACTIVATE_ECHO_CANCELLATION_WITH_AGC=false;\r\n\r\nconst DEBUG_TRACE_LEVEL=0;\r\n\r\n// Dirty way to load this module\r\n// Copy content of interceptor_worklet.js to this string\r\nconst awpStr=\"class AudioCaptureInterceptorProcessor extends AudioWorkletProcessor{\\n\" +\r\n    \"\\n\" +\r\n    \"    BUFFER_QUANTUMS=64;\\n\" +\r\n    \"    QUANTUM_FRAME_LEN=128;\\n\" +\r\n    \"    BUFFER_FRAME_LEN=this.QUANTUM_FRAME_LEN*this.BUFFER_QUANTUMS;\\n\" +\r\n    \"    buffer=null;\\n\" +\r\n    \"    bufferPos=0;\\n\" +\r\n    \"    bufferPosBytes=0;\\n\" +\r\n    \"    constructor() {\\n\" +\r\n    \"        super();\\n\" +\r\n    \"\\n\" +\r\n    \"    }\\n\" +\r\n    \"\\n\" +\r\n    \" process(\\n\" +\r\n    \"      inputs,\\n\" +\r\n    \"      outputs,\\n\" +\r\n    \"      parameters\\n\" +\r\n    \"  ){\\n\" +\r\n    \"\\n\" +\r\n    \"     let inputsCnt=inputs.length;\\n\" +\r\n    \"     let channelCount=0;\\n\" +\r\n    \"     let inputLen=0;\\n\" +\r\n    \"     let inputLenBytes=0;\\n\" +\r\n    \"     if(inputsCnt>0) {\\n\" +\r\n    \"         let input0 = inputs[0];\\n\" +\r\n    \"         channelCount = input0.length;\\n\" +\r\n    \"         if (channelCount > 0) {\\n\" +\r\n    \"             let input0ch0=input0[0];\\n\" +\r\n    \"             inputLen=input0ch0.length;\\n\" +\r\n    \"             inputLenBytes=input0ch0.buffer.length;\\n\" +\r\n    \"         }\\n\" +\r\n    \"     }\\n\" +\r\n    \"     if (!this.buffer || this.buffer.length < channelCount) {\\n\" +\r\n    \"         this.buffer = new Array(channelCount);\\n\" +\r\n    \"         this.bufferPos = 0\\n\" +\r\n    \"         for (let bch = 0; bch < channelCount; bch++) {\\n\" +\r\n    \"             this.buffer[bch] = new Float32Array(this.BUFFER_FRAME_LEN);\\n\" +\r\n    \"             this.bufferPos = 0;\\n\" +\r\n    \"             this.bufferPosBytes=0;\\n\" +\r\n    \"         }\\n\" +\r\n    \"     }\\n\" +\r\n    \"     let bufAvail = this.BUFFER_FRAME_LEN - this.bufferPos;\\n\" +\r\n    \"     // check if buffer has to be transferred\\n\" +\r\n    \"     if (inputLen > bufAvail) {\\n\" +\r\n    \"         let ada=new Array(channelCount);\\n\" +\r\n    \"         for (let ch = 0; ch < channelCount; ch++) {\\n\" +\r\n    \"             ada[ch]=this.buffer[ch].buffer.slice(0);\\n\" +\r\n    \"         }\\n\" +\r\n    \"         this.port.postMessage({\\n\" +\r\n    \"             data: ada,\\n\" +\r\n    \"             chs: channelCount,\\n\" +\r\n    \"             len: this.bufferPos\\n\" +\r\n    \"         }, ada);\\n\" +\r\n    \"         // buffer transferred, reset\\n\" +\r\n    \"         this.bufferPos = 0;\\n\" +\r\n    \"         this.bufferPosBytes=0;\\n\" +\r\n    \"     }\\n\" +\r\n    \"\\n\" +\r\n    \"     for(let ii=0;ii<inputsCnt;ii++) {\\n\" +\r\n    \"         for (let ch = 0; ch < channelCount; ch++) {\\n\" +\r\n    \"             // Mute outputs\\n\" +\r\n    \"             //outputs[ii][ch].fill(0);\\n\" +\r\n    \"             let chSamples = inputs[ii][ch];\\n\" +\r\n    \"             this.buffer[ch].set(chSamples,this.bufferPos);\\n\" +\r\n    \"         }\\n\" +\r\n    \"         this.bufferPos+=inputLen;\\n\" +\r\n    \"         this.bufferPosBytes+=inputLenBytes;\\n\" +\r\n    \"     }\\n\" +\r\n    \"    \\n\" +\r\n    \"     return true;\\n\" +\r\n    \"  }\\n\" +\r\n    \"}\\n\" +\r\n    \"\\n\" +\r\n    \"registerProcessor('capture-interceptor',AudioCaptureInterceptorProcessor);\\n\";\r\n\r\n\r\n\r\n\r\nexport interface AudioCaptureListener {\r\n  opened(): void;\r\n\r\n  started(): void;\r\n\r\n  stopped(): void;\r\n\r\n  closed(): void;\r\n\r\n  error(msg?:string,advice?:string): void;\r\n}\r\n\r\nexport class AudioCapture {\r\n\r\n  get maxAutoNetMemStoreSamples(): number {\r\n    return this._maxAutoNetMemStoreSamples;\r\n  }\r\n\r\n  set maxAutoNetMemStoreSamples(value: number) {\r\n    this._maxAutoNetMemStoreSamples = value;\r\n  }\r\n  set recUUID(value: string|null) {\r\n    this._recUUID = value;\r\n  }\r\n  get recUUID(): string |null{\r\n    return this._recUUID;\r\n  }\r\n  get audioStorageType(): AudioStorageType {\r\n    return this._audioStorageType;\r\n  }\r\n\r\n  set audioStorageType(value: AudioStorageType) {\r\n    this._audioStorageType = value;\r\n  }\r\n  get persistentAudioStorageTarget(): PersistentAudioStorageTarget | null {\r\n    return this._persistentAudioStorageTarget;\r\n  }\r\n\r\n  set persistentAudioStorageTarget(value: PersistentAudioStorageTarget | null) {\r\n    this._persistentAudioStorageTarget = value;\r\n  }\r\n\r\n\r\n  get opened(): boolean {\r\n    return this._opened;\r\n  }\r\n\r\n  static BUFFER_SIZE: number = 8192;\r\n  private static readonly DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES:number=2880000*5; // Default 5 minute at 48kHz\r\n  private _maxAutoNetMemStoreSamples:number=AudioCapture.DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES;\r\n  private static captureInterceptorModuleRegistered=false;\r\n  context: AudioContext|null=null;\r\n  stream!: MediaStream;\r\n  channelCount!: number;\r\n  private _recUUID:string|null=null;\r\n  mediaStream: any;\r\n  agcStatus:boolean|null=null;\r\n  bufferingNode: AudioNode|null=null;\r\n  listener!: AudioCaptureListener;\r\n  data: Array<Array<Float32Array>>|null=null;\r\n  currentSampleRate!: number;\r\n  n: Navigator;\r\n  audioOutStream: SequenceAudioFloat32OutStream | null=null;\r\n  private disconnectStreams = true;\r\n  private _opened=false;\r\n  private capturing = false;\r\n\r\n  framesRecorded: number=0;\r\n\r\n  private _audioStorageType:AudioStorageType=AudioStorageType.MEM_ENTIRE;\r\n  private _persistentAudioStorageTarget:PersistentAudioStorageTarget|null=null;\r\n\r\n  private persisted=true;\r\n  private persistError:Error|null=null;\r\n  private inddbAudioBuffer:IndexedDbAudioBuffer|null=null;\r\n\r\n  //private context:AudioContext|null=null;\r\n\r\n  constructor() {\r\n    this.n = navigator;\r\n  }\r\n\r\n  private _audioContext():AudioContext|null{\r\n    if(!this.context){\r\n      this.context=AudioContextProvider.audioContextInstance();\r\n      if(this.context) {\r\n        this.context.addEventListener('statechange', () => {\r\n          if (this.context && this.context.state !== 'running') {\r\n            this.close();\r\n          }\r\n        });\r\n      }\r\n    }\r\n    return this.context;\r\n  }\r\n\r\n  private initData() {\r\n    if(!this._recUUID) {\r\n      this._recUUID = UUID.generate();\r\n    }\r\n    this.persistError=null;\r\n    //console.debug(\"Audio capture initialize storage for type: \"+this._audioStorageType);\r\n    if(AudioStorageType.DB_CHUNKED === this._audioStorageType && this._persistentAudioStorageTarget && this._recUUID) {\r\n      //console.debug(\"Create indexed db audio buffer.\");\r\n      this.inddbAudioBuffer = new IndexedDbAudioBuffer(this._persistentAudioStorageTarget, this.channelCount,this.currentSampleRate,AudioCapture.BUFFER_SIZE,0,this._recUUID)\r\n    }\r\n    if(!(AudioStorageType.NET_CHUNKED === this._audioStorageType)) {\r\n      // Initialize audio data array except for net audio buffer mode\r\n      this.data = new Array<Array<Float32Array>>();\r\n      for (let i = 0; i < this.channelCount; i++) {\r\n        this.data.push(new Array<Float32Array>());\r\n      }\r\n    }\r\n    this.framesRecorded = 0;\r\n  }\r\n\r\n  listDevices() {\r\n    navigator.mediaDevices.enumerateDevices().then((l: MediaDeviceInfo[]) => this.printDevices(l));\r\n  }\r\n\r\n  private dummySession():Promise<MediaStream>{\r\n    // workaround to request permissions:\r\n    // Start a dummy session\r\n    let mediaStrCnstrs = <MediaStreamConstraints>{audio:\r\n        {echoCancelation: false}\r\n    };\r\n    return navigator.mediaDevices.getUserMedia(mediaStrCnstrs);\r\n\r\n  }\r\n\r\n\r\n  private stopAllSessionTracks(mediaStream:MediaStream){\r\n      let ats = mediaStream.getTracks();\r\n      for (let atIdx = 0; atIdx < ats.length; atIdx++) {\r\n        //console.debug(\"Stop dummy session track: #\" + atIdx)\r\n        ats[atIdx].stop();\r\n      }\r\n  }\r\n\r\n  deviceInfos(cb: (deviceInfos: MediaDeviceInfo[] | null) => any, retry = true,dummyStream?:MediaStream) {\r\n\r\n    navigator.mediaDevices.enumerateDevices().then((l: MediaDeviceInfo[]) => {\r\n      let labelsAvailable = false;\r\n      for (let i = 0; i < l.length; i++) {\r\n        let di = l[i];\r\n        if (di.label) {\r\n          labelsAvailable = true;\r\n        }\r\n      }\r\n      if (!labelsAvailable) {\r\n        //console.debug(\"Media device enumeration: No labels.\")\r\n        if (retry) {\r\n            console.info(\"Starting dummy session to request audio permissions...\")\r\n\r\n            this.dummySession().then((s: MediaStream) => {\r\n            // and stop it immediately\r\n\r\n            if(s) {\r\n              //console.debug(\"Got dummy session stream: \" + s + \" .\")\r\n            }else{\r\n              //console.debug(\"No dummy stream\")\r\n            }\r\n            // retry (only once)\r\n            this.deviceInfos(cb, false,s);\r\n          },reason => {\r\n            //console.debug(\"Dummy session rejected.\")\r\n            // TODO error callback\r\n            cb(null);\r\n          });\r\n        } else {\r\n          cb(null);\r\n        }\r\n      } else {\r\n        // success\r\n        cb(l);\r\n      }\r\n      if(dummyStream){\r\n        this.stopAllSessionTracks(dummyStream);\r\n      }\r\n    },(reason)=> {\r\n      //rejected\r\n      //console.debug(\"Media device enumeration rejected.\")\r\n      if (retry) {\r\n        //console.debug(\"Starting dummy session to request audio permissions...\")\r\n        this.dummySession().then((s: MediaStream) => {\r\n          // and stop it immediately\r\n          //console.debug(\"Dummy session.\")\r\n          if(s) {\r\n            //console.debug(\"Got dummy session stream: \" + s + \" .\")\r\n          }else{\r\n            //console.debug(\"No dummy stream\")\r\n          }\r\n          // retry (only once)\r\n          this.deviceInfos(cb, false,s);\r\n        }, reason => {\r\n          //console.debug(\"Dummy session rejected.\")\r\n          // TODO error callback\r\n          cb(null);\r\n        });\r\n      } else {\r\n        cb(null);\r\n      }\r\n      if(dummyStream){\r\n        this.stopAllSessionTracks(dummyStream);\r\n      }\r\n    });\r\n\r\n\r\n\r\n  }\r\n\r\n\r\n  printDevices(l: MediaDeviceInfo[]): void {\r\n    //let selDeviceId = '___dummy___';\r\n    for (let i = 0; i < l.length; i++) {\r\n      let di = l[i];\r\n      console.log(\"Audio device: Id: \" + di.deviceId + \" groupId: \" + di.groupId + \" label: \" + di.label + \" kind: \" + di.kind);\r\n    }\r\n  }\r\n\r\n  addCaptureInterceptor() {\r\n    if (this.context) {\r\n\r\n    const awn = new AudioWorkletNode(this.context, 'capture-interceptor');\r\n    awn.onprocessorerror = (ev: Event) => {\r\n      let msg = 'Unknwon error';\r\n      if (ev instanceof ErrorEvent) {\r\n        msg = ev.message;\r\n      }\r\n      console.error(\"Capture audio worklet error: \" + msg);\r\n      if (this.listener) {\r\n        this.listener.error(msg);\r\n      }\r\n    }\r\n    let awnPt = awn.port;\r\n    if (awnPt) {\r\n      awnPt.onmessage = (ev: MessageEvent) => {\r\n        if (this.capturing) {\r\n          let dt = ev.data;\r\n          let chs = dt.chs;\r\n          let adaLen = dt.data.length;\r\n          if (DEBUG_TRACE_LEVEL > 8) {\r\n            console.debug('Received data from worklet: ' + chs + ' ' + dt.len + ' Data chs: ' + adaLen);\r\n          }\r\n          let chunk = new Array<Float32Array>(chs);\r\n          const samples = this.framesRecorded * chs;\r\n          if ((AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this.audioStorageType || AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this.audioStorageType) && this.data && samples > this._maxAutoNetMemStoreSamples) {\r\n            this.data = null;\r\n          }\r\n\r\n          //console.debug(\"Data initialized: \"+(this.data!=null));\r\n          for (let ch = 0; ch < chs; ch++) {\r\n            //console.debug(\"Data ch initialized: \"+(this.data !=null && this.data[ch] !=null));\r\n            if (ch < this.channelCount) {\r\n              if (dt.data[ch]) {\r\n                let fa = new Float32Array(dt.data[ch]);\r\n                if (this.data && this.data[ch]) {\r\n                  this.data[ch].push(fa);\r\n                }\r\n                chunk[ch] = fa;\r\n                // Use samples of channel 0 to count frames (samples)\r\n                if (ch == 0) {\r\n                  this.framesRecorded += fa.length;\r\n                }\r\n              }\r\n            }\r\n          }\r\n          if (this.audioOutStream) {\r\n            try {\r\n              this.audioOutStream.write(chunk);\r\n              // // Random test error:\r\n              // if(Math.random()>0.98) {\r\n              //   throw new Error('Test');\r\n              // }\r\n            } catch (err) {\r\n              if (err instanceof Error) {\r\n                this.persistError = err;\r\n              } else {\r\n                this.persistError = new Error('Error handling recorded audio data');\r\n              }\r\n\r\n              console.error(\"Capture error: \" + err);\r\n              try {\r\n                this.stop();\r\n              } catch (err2) {\r\n                console.error(\"Capture next error (ignored): \" + err2);\r\n              } finally {\r\n                if (this.listener) {\r\n                  let errExpl = '';\r\n                  if (err instanceof DOMException) {\r\n                    errExpl = ': ' + err.name + ': ' + err.message;\r\n                  }\r\n                  this.listener.error(\"Could not handle recorded audio data\" + errExpl, \"Please try to record again.\");\r\n                } else {\r\n                  this.close();\r\n                }\r\n              }\r\n            }\r\n          }\r\n          if (AudioStorageType.DB_CHUNKED === this._audioStorageType && this._persistentAudioStorageTarget) {\r\n            this.store();\r\n          }\r\n        }\r\n      };\r\n    }\r\n    // Tried to fix that Safari does not record the second channel\r\n    // Does not help\r\n    //awn.channelCount=this.channelCount;\r\n    //awn.channelCountMode='explicit';\r\n    //console.debug('Channel count explicitly set to '+this.channelCount);\r\n\r\n    this.bufferingNode = awn;\r\n    //this.bufferingNode.channelCount=this.channelCount;\r\n    this._opened = true;\r\n    if (this.listener) {\r\n      this.listener.opened();\r\n    }\r\n  }\r\n  }\r\n\r\n  open(channelCount: number, selDeviceId?: ConstrainDOMString|undefined,autoGainControlConfigs?:Array<AutoGainControlConfig>|null|undefined,allowEchoCancellation?:boolean){\r\n    //console.debug(\"Capture open: ctx state: \"+this.context.state);\r\n    this.context=this._audioContext();\r\n    if(!this.context){\r\n      throw new Error(\"Could not get audio context!\");\r\n    }\r\n    if(this.context.state==='suspended'){\r\n      //console.debug(\"Capture open: Resume context\");\r\n      this.context.resume().then(()=>{\r\n        //console.debug(\"Capture open (ctx resumed): ctx state: \"+this.context.state);\r\n        this._open(channelCount, selDeviceId, autoGainControlConfigs,allowEchoCancellation);\r\n      }).catch((err)=>{\r\n        console.error(err.message);\r\n        throw err;\r\n      })\r\n    }else if(this.context.state==='closed') {\r\n        const msg='Error on start capture: The audio context is already closed.';\r\n        console.error(msg);\r\n        throw new Error(msg);\r\n    }else {\r\n      this._open(channelCount, selDeviceId, autoGainControlConfigs,allowEchoCancellation);\r\n    }\r\n\r\n  }\r\n\r\n  _open(channelCount: number, selDeviceId?: ConstrainDOMString|undefined,autoGainControlConfigs?:Array<AutoGainControlConfig>|null|undefined,allowEchoCancellation?:boolean) {\r\n    this.channelCount = channelCount;\r\n    this.framesRecorded = 0;\r\n\r\n    this.context=this._audioContext();\r\n\r\n    if(!this.context){\r\n      throw new Error(\"Could not get audio context!\");\r\n    }\r\n\r\n    //var msc = new AudioStreamConstr();\r\n    // var msc={};\r\n    //msc.video = false;\r\n    //msc.audio = true;\r\n\r\n    // Chrome and Firefox stereo channels are identical !!\r\n    // And even worse: The data coming from the source is already preprocessed on FF and Chrome. It contains DSP artifacts!!\r\n\r\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=387737\r\n    // The workaround to set these constraints does _NOT_ help:\r\n    //var msc={audio: {echoCancellation: false,channelCount: 2, googAudioMirroring: false},video: false};\r\n\r\n    // Safari at least version 11: Support for media streams\r\n    // TODO test if input is unprocessed\r\n\r\n    let msc:MediaStreamConstraints;\r\n    console.info('User agent: '+navigator.userAgent);\r\n\r\n\r\n      let ua=UserAgentBuilder.userAgent();\r\n\r\n      // ua.components.forEach((c)=>{\r\n      //   console.info(\"UA_Comp: \"+c.toString());\r\n      // })\r\n\r\n     let agcCfg:AutoGainControlConfig|null=null;\r\n\r\n    let autoGainControl=false;\r\n    let chromeEchoCancellation=false;\r\n    if(autoGainControlConfigs){\r\n      for(let agcc of autoGainControlConfigs){\r\n        if(agcc.platform===CfgPlatform.Android && ua.detectedPlatform===Platform.Android){\r\n            agcCfg=agcc;\r\n            break;\r\n        }\r\n        if(agcc.platform===CfgPlatform.Windows && ua.detectedPlatform===Platform.Windows){\r\n          agcCfg=agcc;\r\n          break;\r\n        }\r\n      }\r\n      if(agcCfg){\r\n        // TODO use EXACT/IDEAL constraint\r\n        autoGainControl=agcCfg.value;\r\n        if(CHROME_ACTIVATE_ECHO_CANCELLATION_WITH_AGC){\r\n          chromeEchoCancellation=agcCfg.value;\r\n        }\r\n        // TODO query real AGC status\r\n        this.agcStatus=agcCfg.value;\r\n      }else{\r\n        this.agcStatus=false;\r\n      }\r\n    }\r\n\r\n    // default\r\n    msc = {\r\n      audio: {\r\n        deviceId: selDeviceId,\r\n        echoCancellation: false,\r\n        channelCount: channelCount,\r\n        autoGainControl: autoGainControl\r\n      },\r\n      video: false\r\n    };\r\n\r\n    if (ua.detectedBrowser===Browser.Edge) {\r\n\r\n      // Microsoft Edge sends unmodified audio\r\n      // The constraint can follow the specification\r\n      console.info(\"Setting media track constraints for Microsoft Edge.\");\r\n      msc = {\r\n        audio: {\r\n          deviceId: selDeviceId,\r\n          echoCancellation: false,\r\n          channelCount: channelCount,\r\n          autoGainControl: autoGainControl\r\n        },\r\n        video: false\r\n      };\r\n    } else if (ua.detectedBrowser===Browser.Chrome) {\r\n      // Google Chrome: we need to switch of each of the preprocessing units including the\r\n      console.info(\"Setting media track constraints for Google Chrome.\");\r\n\r\n      // Chrome 60 -> 61 changed\r\n      // it works now without mandatory/optional sub-objects\r\n\r\n\r\n      // Requires at least Chrome 61\r\n      msc = {\r\n        audio: {\r\n          deviceId: selDeviceId,\r\n          channelCount: channelCount,\r\n          echoCancellation: {exact:chromeEchoCancellation},\r\n          autoGainControl: {exact:autoGainControl},\r\n          sampleSize:{min: 16},\r\n        },\r\n        video: false,\r\n      }\r\n\r\n    } else if (ua.detectedBrowser===Browser.Firefox) {\r\n      console.info(\"Setting media track constraints for Mozilla Firefox.\");\r\n      // Firefox\r\n      msc = {\r\n        audio: {\r\n            deviceId: selDeviceId,\r\n            channelCount: channelCount,\r\n          echoCancellation: false,\r\n            autoGainControl: autoGainControl,\r\n          noiseSuppression: false\r\n        },\r\n        video: false,\r\n      }\r\n\r\n    } else if (ua.detectedBrowser===Browser.Safari) {\r\n      console.info(\"Setting media track constraints for Safari browser.\")\r\n      //console.info(\"Apply workaround for Safari: Avoid disconnect of streams.\");\r\n\r\n      this.disconnectStreams = true;\r\n\r\n      msc = {\r\n        audio: {\r\n          deviceId: selDeviceId,\r\n          channelCount: channelCount,\r\n          echoCancellation: allowEchoCancellation?undefined:false\r\n        },\r\n        video: false,\r\n      }\r\n\r\n    } else {\r\n\r\n      // TODO default constraints or error Browser not supported\r\n    }\r\n\r\n\r\n\r\n    console.debug(\"Audio capture, AGC: \"+this.agcStatus)\r\n\r\n    let ump = navigator.mediaDevices.getUserMedia(msc);\r\n    ump.then((s) => {\r\n\r\n      if (this.context) {\r\n      this.stream = s;\r\n\r\n      let aTracks = s.getAudioTracks();\r\n\r\n      for (let i = 0; i < aTracks.length; i++) {\r\n        let aTrack = aTracks[i];\r\n\r\n        console.info(\"Track audio info: id: \" + aTrack.id + \" kind: \" + aTrack.kind + \" label: \\\"\" + aTrack.label + \"\\\"\");\r\n        let mtrSts = aTrack.getSettings();\r\n\r\n        // Typescript lib.dom.ts MediaTrackSettings.channelCount is missing\r\n        // https://github.com/mdn/browser-compat-data/blob/5493d8f937e05b2ddbd41b99f5bdfad4a1f2ed85/api/MediaTrackSettings.json\r\n        //@ts-ignore\r\n        console.info(\"Track audio settings: Ch cnt: \" + mtrSts.channelCount + \", AGC: \" + mtrSts.autoGainControl + \", Echo cancell.: \" + mtrSts.echoCancellation);\r\n        if (mtrSts.autoGainControl) {\r\n          this.agcStatus = mtrSts.autoGainControl;\r\n        }\r\n\r\n        console.debug(\"Echo cancellation: \"+mtrSts.echoCancellation);\r\n\r\n      }\r\n\r\n      let vTracks = s.getVideoTracks();\r\n      for (let i = 0; i < vTracks.length; i++) {\r\n        let vTrack = vTracks[i];\r\n        console.info(\"Track video info: id: \" + vTrack.id + \" kind: \" + vTrack.kind + \" label: \" + vTrack.label);\r\n      }\r\n      this.mediaStream = this.context.createMediaStreamSource(s);\r\n      // stream channel count ( is always 2 !)\r\n      let streamChannelCount: number = this.mediaStream.channelCount;\r\n      console.info(\"Stream channel count: \" + streamChannelCount);\r\n      // is not set!!\r\n      //this.currentSampleRate = this.mediaStream.sampleRate;\r\n      this.currentSampleRate = this.context.sampleRate;\r\n      console.info(\"Source audio node: channels: \" + streamChannelCount + \" samplerate: \" + this.currentSampleRate);\r\n      if (this.audioOutStream) {\r\n        this.audioOutStream.setFormat(this.channelCount, this.currentSampleRate);\r\n      }\r\n      // W3C  -> new name is createScriptProcessor\r\n      //\r\n      // Again deprecated, but AudioWorker not yet implemented in stable releases (June 2016)\r\n      // AudioWorker is now AudioWorkletProcessor ... (May 2017)\r\n\r\n      // Update 12-2020:\r\n      // The ScriptProcessorNode Interface - DEPRECATED\r\n\r\n      // Update 06-2021\r\n      //  AudioWorkletProcessor is here to stay. Web Audio API has now Recommendation status !\r\n\r\n      if (this.context.audioWorklet) {\r\n        //const workletFileName = ('file-loader!./interceptor_worklet.js');\r\n        //const workletFileName = 'http://localhost:4200/assets/interceptor_worklet.js';\r\n        //console.log(awpStr);\r\n        if (AudioCapture.captureInterceptorModuleRegistered) {\r\n          // Required capture interceptor module already registered\r\n          this.addCaptureInterceptor();\r\n        } else {\r\n\r\n          // Register capture interceptor module\r\n          let audioWorkletModuleBlob = new Blob([awpStr], {type: 'text/javascript'});\r\n\r\n          let audioWorkletModuleBlobUrl = window.URL.createObjectURL(audioWorkletModuleBlob);\r\n\r\n          this.context.audioWorklet.addModule(audioWorkletModuleBlobUrl).then(() => {\r\n                AudioCapture.captureInterceptorModuleRegistered = true;\r\n                this.addCaptureInterceptor();\r\n              }\r\n          ).catch((error: any) => {\r\n            console.log('Could not add module ' + error);\r\n          });\r\n        }\r\n      } else if (this.context.createScriptProcessor) {\r\n        // The ScriptProcessorNode Interface - DEPRECATED Only as fallback\r\n        // TODO should we use streamChannelCount or channelCount here ?\r\n        let scriptProcessorNode = this.context.createScriptProcessor(AudioCapture.BUFFER_SIZE, streamChannelCount, streamChannelCount);\r\n        this.bufferingNode = scriptProcessorNode;\r\n        let c = 0;\r\n        if (scriptProcessorNode.onaudioprocess) {\r\n          scriptProcessorNode.onaudioprocess = (e: AudioProcessingEvent) => {\r\n\r\n            if (this.capturing) {\r\n              let inBuffer = e.inputBuffer;\r\n              // only process requested count of channels\r\n              let currentBuffers = new Array<Float32Array>(channelCount);\r\n              for (let ch: number = 0; ch < channelCount; ch++) {\r\n                let chSamples = inBuffer.getChannelData(ch);\r\n                let chSamplesCopy = chSamples.slice(0);\r\n                currentBuffers[ch] = chSamplesCopy.slice(0);\r\n                if (this.data) {\r\n                  this.data[ch].push(chSamplesCopy);\r\n                }\r\n                if (DEBUG_TRACE_LEVEL > 8) {\r\n                  console.debug(\"Process \" + chSamplesCopy.length + \" samples.\");\r\n                }\r\n                this.framesRecorded += chSamplesCopy.length;\r\n              }\r\n              c++;\r\n              if (this.audioOutStream) {\r\n                this.audioOutStream.write(currentBuffers);\r\n              }\r\n            }\r\n          };\r\n          this._opened = true;\r\n          if (this.listener) {\r\n            this.listener.opened();\r\n          }\r\n        } else {\r\n          this.listener.error('Browser does not support audio processing (ScriptProcessor.onaudioprocess method not found)!');\r\n        }\r\n      } else {\r\n        this.listener.error('Browser does not support audio processing (neither AudioWorkletProcessor nor ScriptProcessor)!');\r\n      }\r\n    }\r\n        }, (e) => {\r\n          console.error(e + \" Error name: \" +e.name);\r\n          if (this.listener) {\r\n            if('NotAllowedError' === e.name){\r\n              this.listener.error('Not allowed to use your microphone.','Please make sure that microphone access is allowed for this web page and reload the page.');\r\n            }else if('NotReadableError' === e.name){\r\n              this.listener.error('Could not read from your audio device.','Please make sure your audio device is working.');\r\n            }else if('OverconstrainedError' === e.name){\r\n              let eMsg=e.msg?e.msg:'Overconstrained media device request error.';\r\n              this.listener.error(eMsg);\r\n            } else {\r\n              this.listener.error();\r\n            }\r\n          }\r\n        }\r\n    )\r\n  }\r\n\r\n  private _start(){\r\n    if(this.context) {\r\n      this.initData();\r\n      if (this.audioOutStream) {\r\n        this.audioOutStream.nextStream()\r\n      }\r\n      this.capturing = true;\r\n      if (this.bufferingNode) {\r\n        this.mediaStream.connect(this.bufferingNode);\r\n        this.bufferingNode.connect(this.context.destination);\r\n      }\r\n      if (this.listener) {\r\n        this.listener.started();\r\n      }\r\n    }\r\n  }\r\n\r\n  start() {\r\n    if(this.context) {\r\n      const aSt = this.context.state;\r\n      if (aSt === 'running') {\r\n        this._start();\r\n      } else {\r\n        console.debug(\"Capture start: audio context not running, state: \" + aSt + \", resuming...\");\r\n        this.context.resume().then(() => {\r\n          console.debug(\"Capture start: audio context resumed, starting...\");\r\n          this._start();\r\n        })\r\n      }\r\n    }\r\n  }\r\n\r\n  stop() {\r\n\r\n    if (this.disconnectStreams && this.bufferingNode) {\r\n      this.mediaStream.disconnect(this.bufferingNode);\r\n      if(this.context) {\r\n        this.bufferingNode.disconnect(this.context.destination);\r\n      }\r\n    }\r\n\r\n    try {\r\n      if (this.audioOutStream) {\r\n        this.audioOutStream.flush();\r\n      }\r\n    }catch(err){\r\n      console.error(\"Could not flush capture stream.\");\r\n     throw err;\r\n    }finally {\r\n      this.capturing = false;\r\n      if (this.inddbAudioBuffer && this.persistError) {\r\n        // Delete invalid persistent audio data and hope that it will be completely uploaded to the server\r\n        this.inddbAudioBuffer.releaseAudioData();\r\n        this.inddbAudioBuffer = null;\r\n      }\r\n      if (this.listener && (this.persistError || this.persisted)) {\r\n        //console.debug(\"Stopped by stop() method call\");\r\n        this.listener.stopped();\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  store(){\r\n   // if(this.db && this.recUUID){\r\n   //    let tr= this.db.transaction(SprDb.RECORDING_FILE_CHUNKS_OBJECT_STORE_NAME, 'readwrite');\r\n   //    let recFileObjStore = tr.objectStore(SprDb.RECORDING_FILE_CHUNKS_OBJECT_STORE_NAME);\r\n   //\r\n   //      try {\r\n   //        let ch0Data=this.data[0];\r\n   //        let dataChkCnt=ch0Data.length;\r\n   //          let pos = 0;\r\n   //          for (let chCkIdx = 0; chCkIdx < dataChkCnt; chCkIdx++) {\r\n   //            let bufLen=0;\r\n   //            for (let ch = 0; ch < this.channelCount; ch++) {\r\n   //              let chChk = this.data[ch][chCkIdx];\r\n   //              bufLen = chChk.length;\r\n   //              //let cacheId = uuid + '_' + ch + '_' + chCkIdx;\r\n   //              let chkDbId = [this.recUUID, this.indDbChkIdx + chCkIdx, ch];\r\n   //              let cr = recFileObjStore.add(chChk, chkDbId);\r\n   //              //console.debug(\"Added: \"+ch+\" \"+(this.indDbChkIdx+chCkIdx));\r\n   //              cr.onsuccess=()=>{\r\n   //                //console.debug(\"Stored audio data to indexed db\");\r\n   //              }\r\n   //              cr.onerror=()=>{\r\n   //                console.error(\"Error storing audio data to indexed db\");\r\n   //              }\r\n   //            }\r\n   //            pos += bufLen;\r\n   //        }\r\n   //        this.indDbChkIdx+=dataChkCnt;\r\n   //\r\n   //        tr.onerror = (err) => {\r\n   //          console.error('Failed to cache audio data to indexed db: ' + err)\r\n   //        }\r\n   //        tr.oncomplete = () => {\r\n   //          //console.debug('Transferred capture audio data to indexed db, deleting original data from memory...');\r\n   //\r\n   //          /// Audio data saved to index db delete from in memory data array\r\n   //          for (let ch = 0; ch < this.channelCount; ch++) {\r\n   //           this.data[ch].splice(0);\r\n   //            //console.debug(\"Spliced/removed ch: \"+ch);\r\n   //          }\r\n   //\r\n   //          this.persisted=true;\r\n   //          if(this.listener && !this.capturing){\r\n   //            //console.debug(\"Stopped by indexed db hook\");\r\n   //            this.listener.stopped();\r\n   //          }\r\n   //        }\r\n   //        // Commit chunks\r\n   //        this.persisted=false;\r\n   //        tr.commit();\r\n   //      } catch (err) {\r\n   //        console.error('Transfer capture audio data error: '+err);\r\n   //      }\r\n   //    }\r\n\r\n    // if(!this.inddbAudioBuffer && this._persistentAudioStorageTarget && this.recUUID) {\r\n    //   this.inddbAudioBuffer = new IndexedDbAudioBuffer(this._persistentAudioStorageTarget, this.channelCount,this.currentSampleRate,AudioCapture.BUFFER_SIZE,0,this.recUUID)\r\n    // }\r\n    if(this.inddbAudioBuffer && this.data){\r\n\r\n      // Try to append to\r\n      this.inddbAudioBuffer.appendRawAudioData(this.data).subscribe({\r\n        complete: () => {\r\n          //console.debug('Transferred capture audio data to indexed db, deleting original data from memory...');\r\n\r\n          /// Audio data saved to index db delete from in memory data array\r\n          if(this.data) {\r\n            for (let ch = 0; ch < this.channelCount; ch++) {\r\n              this.data[ch].splice(0);\r\n              //console.debug(\"Spliced/removed ch: \"+ch);\r\n            }\r\n          }\r\n          this.persisted = true;\r\n          if (this.listener && !this.capturing) {\r\n            //console.debug(\"Stopped by indexed db hook\");\r\n            this.listener.stopped();\r\n          }\r\n        },error:(err)=>{\r\n          // Only log the first error\r\n          if(!this.persistError) {\r\n            this.persistError = err;\r\n            console.error(\"Error persisting audio data: \" + err);\r\n          }\r\n        }\r\n      });\r\n      this.persisted=false;\r\n    }\r\n  }\r\n\r\n\r\n  close() {\r\n    if(this.mediaStream) {\r\n      this.mediaStream.disconnect();\r\n    }\r\n    if (this.stream) {\r\n      const mts = this.stream.getTracks();\r\n      for (let i = 0; i < mts.length; i++) {\r\n        mts[i].stop();\r\n      }\r\n    }\r\n    this._opened=false;\r\n  }\r\n\r\n  audioBuffer(): AudioBuffer |null{\r\n    let ab: AudioBuffer|null=null;\r\n    if(this.context && this.data) {\r\n      let frameLen: number = 0;\r\n\r\n      let ch0Data = this.data[0];\r\n\r\n      for (let ch0Chk of ch0Data) {\r\n        frameLen += ch0Chk.length;\r\n      }\r\n\r\n      try {\r\n        ab = this.context.createBuffer(this.channelCount, frameLen, this.context.sampleRate);\r\n      } catch (err) {\r\n        if (err instanceof DOMException) {\r\n          if (err.name === 'NotSupportedError') {\r\n            if (frameLen == 0) {\r\n              // Empty buffers are not supported by Chromium\r\n              // Create dummy buffer with one sample\r\n              ab = this.context.createBuffer(this.channelCount, 1, this.context.sampleRate);\r\n            } else {\r\n              throw err;\r\n            }\r\n          } else {\r\n            throw err;\r\n          }\r\n        } else if (err instanceof RangeError) {\r\n          // Out of memory\r\n          // TODO What to do ??\r\n          throw err;\r\n        } else {\r\n          throw err;\r\n        }\r\n      }\r\n      for (let ch = 0; ch < this.channelCount; ch++) {\r\n        let chD = ab.getChannelData(ch);\r\n        let pos = 0;\r\n        for (let chChk of this.data[ch]) {\r\n          let bufLen = chChk.length;\r\n          chD.set(chChk, pos);\r\n          pos += bufLen;\r\n        }\r\n      }\r\n    }\r\n    return ab;\r\n  }\r\n\r\n  audioBufferArray():ArrayAudioBuffer|null{\r\n      let arrAb:ArrayAudioBuffer|null=null;\r\n      if(this.data) {\r\n        arrAb=new ArrayAudioBuffer(this.channelCount, this.currentSampleRate, this.data);\r\n      }\r\n      return arrAb;\r\n  }\r\n\r\n  inddbAudioBufferArray():IndexedDbAudioBuffer|null{\r\n    if(this.persistError){\r\n      return null;\r\n    }else {\r\n      return this.inddbAudioBuffer;\r\n    }\r\n  }\r\n\r\n\r\n}\r\n\r\n"]}