speechrecorderng 2.21.4 → 2.22.0

package/esm2020/lib/audio/capture/capture.mjs

@@ -0,0 +1,547 @@
+import { Browser, Platform, UserAgentBuilder } from "../../utils/ua-parser";
+import { Platform as CfgPlatform } from "../../speechrecorder/project/project";
+export const CHROME_ACTIVATE_ECHO_CANCELLATION_WITH_AGC = false;
+const DEBUG_TRACE_LEVEL = 0;
+const ENABLE_AUDIO_WORKLET = true;
+// Super 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 {
+    constructor(context) {
+        this.agcStatus = null;
+        this.bufferingNode = null;
+        this.audioOutStream = null;
+        this.disconnectStreams = true;
+        this._opened = false;
+        this.capturing = false;
+        this.framesRecorded = 0;
+        this.context = context;
+        this.n = navigator;
+    }
+    get opened() {
+        return this._opened;
+    }
+    initData() {
+        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);
+        }
+    }
+    open(channelCount, selDeviceId, autoGainControlConfigs) {
+        this.context.resume().then(() => {
+            this._open(channelCount, selDeviceId, autoGainControlConfigs);
+        });
+    }
+    _open(channelCount, selDeviceId, autoGainControlConfigs) {
+        this.channelCount = channelCount;
+        this.framesRecorded = 0;
+        //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 = false;
+            msc = {
+                audio: {
+                    deviceId: selDeviceId,
+                    channelCount: channelCount,
+                    echoCancellation: 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) => {
+            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;
+                }
+            }
+            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 (ENABLE_AUDIO_WORKLET && this.context.audioWorklet) {
+                //const workletFileName = ('file-loader!./interceptor_worklet.js');
+                //const workletFileName = 'http://localhost:4200/assets/interceptor_worklet.js';
+                //console.log(awpStr);
+                let audioWorkletModuleBlob = new Blob([awpStr], { type: 'text/javascript' });
+                let audioWorkletModuleBlobUrl = window.URL.createObjectURL(audioWorkletModuleBlob);
+                this.context.audioWorklet.addModule(audioWorkletModuleBlobUrl).then(() => {
+                    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 chunkLen = adaLen / chs;
+                                let chunkLen = adaLen;
+                                let chunk = new Array(chs);
+                                for (let ch = 0; ch < chs; ch++) {
+                                    if (this.data && this.data[ch]) {
+                                        let adaPos = ch * chunkLen;
+                                        if (dt.data[ch]) {
+                                            let fa = new Float32Array(dt.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;
+                                            }
+                                        }
+                                        else {
+                                            if (DEBUG_TRACE_LEVEL > 8) {
+                                                console.debug('Channel ' + ch + ' data not set!!');
+                                            }
+                                        }
+                                    }
+                                }
+                                if (this.audioOutStream) {
+                                    this.audioOutStream.write(chunk);
+                                }
+                            }
+                        };
+                    }
+                    this.bufferingNode = awn;
+                    this._opened = true;
+                    if (this.listener) {
+                        this.listener.opened();
+                    }
+                }).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;
+                            let duration = inBuffer.duration;
+                            // 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);
+                                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() {
+        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();
+        }
+    }
+    stop() {
+        if (this.disconnectStreams && this.bufferingNode) {
+            this.mediaStream.disconnect(this.bufferingNode);
+            this.bufferingNode.disconnect(this.context.destination);
+        }
+        if (this.audioOutStream) {
+            this.audioOutStream.flush();
+        }
+        this.capturing = false;
+        if (this.listener) {
+            this.listener.stopped();
+        }
+    }
+    close() {
+        this.mediaStream.disconnect();
+        if (this.stream) {
+            //this.stream.stop();
+            //'MediaStream.stop()' is deprecated and will be removed in M47, around November 2015. Please use 'MediaStream.active' instead.
+            //this.stream.active=false;
+            var mts = this.stream.getTracks();
+            for (var i = 0; i < mts.length; i++) {
+                mts[i].stop();
+            }
+        }
+        this._opened = false;
+    }
+    audioBuffer() {
+        var frameLen = 0;
+        var ch0Data = this.data[0];
+        for (var ch0Chk of ch0Data) {
+            frameLen += ch0Chk.length;
+        }
+        var ab = this.context.createBuffer(this.channelCount, frameLen, this.context.sampleRate);
+        for (var ch = 0; ch < this.channelCount; ch++) {
+            var chD = ab.getChannelData(ch);
+            var pos = 0;
+            for (var chChk of this.data[ch]) {
+                var bufLen = chChk.length;
+                chD.set(chChk, pos);
+                pos += bufLen;
+            }
+        }
+        return ab;
+    }
+}
+AudioCapture.BUFFER_SIZE = 8192;
+//# 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 {AutoGainControlConfig, Platform as CfgPlatform} from \"../../speechrecorder/project/project\";\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\nconst ENABLE_AUDIO_WORKLET=true;\r\n\r\n// Super 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  get opened(): boolean {\r\n    return this._opened;\r\n  }\r\n\r\n  static BUFFER_SIZE: number = 8192;\r\n  context: AudioContext;\r\n  stream!: MediaStream;\r\n  channelCount!: number;\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>>;\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  constructor(context: AudioContext) {\r\n    this.context = context;\r\n    this.n = navigator;\r\n  }\r\n\r\n  private initData() {\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    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\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  open(channelCount: number, selDeviceId?: ConstrainDOMString|undefined,autoGainControlConfigs?:Array<AutoGainControlConfig>|null|undefined){\r\n      this.context.resume().then(()=>{\r\n        this._open(channelCount,selDeviceId,autoGainControlConfigs);\r\n      })\r\n  }\r\n\r\n  _open(channelCount: number, selDeviceId?: ConstrainDOMString|undefined,autoGainControlConfigs?:Array<AutoGainControlConfig>|null|undefined) {\r\n    this.channelCount = channelCount;\r\n    this.framesRecorded = 0;\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 = false;\r\n      msc = {\r\n        audio: {\r\n          deviceId: selDeviceId,\r\n          channelCount: channelCount,\r\n          echoCancellation: 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\r\n    let ump = navigator.mediaDevices.getUserMedia(msc);\r\n    ump.then((s) => {\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\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(ENABLE_AUDIO_WORKLET && 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            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                  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<any>) => {\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 chunkLen = adaLen / chs;\r\n                        let chunkLen = adaLen;\r\n                        let chunk = new Array<Float32Array>(chs);\r\n                        for (let ch = 0; ch < chs; ch++) {\r\n                          if (this.data && this.data[ch]) {\r\n                            let adaPos = ch * chunkLen;\r\n                            if(dt.data[ch]) {\r\n                              let fa = new Float32Array(dt.data[ch]);\r\n                              this.data[ch].push(fa);\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                            }else{\r\n                              if(DEBUG_TRACE_LEVEL>8) {\r\n                                console.debug('Channel '+ch+' data not set!!');\r\n                              }\r\n                            }\r\n                          }\r\n                        }\r\n                        if (this.audioOutStream) {\r\n                          this.audioOutStream.write(chunk);\r\n                        }\r\n                      }\r\n                    };\r\n                  }\r\n                  this.bufferingNode = awn;\r\n                  this._opened = true;\r\n                  if (this.listener) {\r\n                    this.listener.opened();\r\n                  }\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                  let duration = inBuffer.duration;\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                    this.data[ch].push(chSamplesCopy);\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        }, (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  start() {\r\n\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  stop() {\r\n\r\n    if (this.disconnectStreams && this.bufferingNode) {\r\n      this.mediaStream.disconnect(this.bufferingNode);\r\n      this.bufferingNode.disconnect(this.context.destination);\r\n    }\r\n\r\n    if (this.audioOutStream) {\r\n      this.audioOutStream.flush();\r\n    }\r\n    this.capturing = false;\r\n    if (this.listener) {\r\n      this.listener.stopped();\r\n    }\r\n  }\r\n\r\n\r\n  close() {\r\n    this.mediaStream.disconnect();\r\n    if (this.stream) {\r\n      //this.stream.stop();\r\n      //'MediaStream.stop()' is deprecated and will be removed in M47, around November 2015. Please use 'MediaStream.active' instead.\r\n      //this.stream.active=false;\r\n      var mts = this.stream.getTracks();\r\n      for (var 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 {\r\n    var frameLen: number = 0;\r\n    var ch0Data = this.data[0];\r\n\r\n    for (var ch0Chk of ch0Data) {\r\n      frameLen += ch0Chk.length;\r\n    }\r\n    var ab = this.context.createBuffer(this.channelCount, frameLen, this.context.sampleRate);\r\n    for (var ch = 0; ch < this.channelCount; ch++) {\r\n\r\n      var chD = ab.getChannelData(ch);\r\n      var pos = 0;\r\n      for (var chChk of this.data[ch]) {\r\n        var bufLen = chChk.length;\r\n        chD.set(chChk, pos);\r\n        pos += bufLen;\r\n      }\r\n    }\r\n    return ab;\r\n  }\r\n}\r\n\r\n"]}