@ylink-sdk/mobile-web 0.1.6 → 0.1.9-beta.1

package/dist/e30037b8/native-audio-worker.global.js

@@ -0,0 +1,1583 @@
+(function () {
+    'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function pipeline(middleware) {
+        return (context, next) => {
+            // last called middleware
+            let index = -1;
+            const run = (i) => __awaiter(this, void 0, void 0, function* () {
+                if (i <= index) {
+                     console.warn('next() called multiple times');
+                    return;
+                }
+                index = i;
+                let callback = middleware[i];
+                if (i === middleware.length)
+                    callback = next;
+                if (!callback)
+                    return;
+                if (callback.length > 1) {
+                    return callback(context, dispatch);
+                }
+                yield callback(context, dispatch);
+                return dispatch();
+            });
+            const dispatch = () => run(index + 1);
+            return dispatch();
+        };
+    }
+
+    class MojoReceiver {
+        constructor(channel, pipe) {
+            this.middleware = [];
+            this.pipe = pipe || Math.random().toString(36).slice(3);
+            this.channel = channel;
+        }
+        get valid() {
+            return this.channel.has(this.pipe);
+        }
+        implement(key, invoke) {
+            const m = (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+                const { method, params, status, required, attached = {} } = ctx.data;
+                if (key !== method) {
+                    return next();
+                }
+                let handled = false;
+                const transfer = [];
+                const reAttached = {};
+                const done = (payload) => {
+                    if (handled) {
+                         console.warn(`receiver[${this}] - ${method} reply multiple times`);
+                        return;
+                    }
+                    handled = true;
+                    this.channel.send(Object.assign(Object.assign(Object.assign({}, ctx.data), { 
+                        // override params as it may contains un-cloned object
+                        params: undefined, 
+                        // override attached as it may contains un-cloned object
+                        attached: reAttached }), payload), transfer);
+                };
+                const reply = {
+                    transfer: (...args) => {
+                        if (required) {
+                            transfer.push(...args);
+                        }
+                        return reply;
+                    },
+                    resolve: (value) => {
+                        if (!required) {
+                            handled = true;
+                            return;
+                        }
+                        done({ resolve: value, status: status + 1 });
+                    },
+                    reject: (reason) => {
+                        if (!required) {
+                            handled = true;
+                            return;
+                        }
+                        done({ status: status - 1, reject: reason });
+                    },
+                    // attached
+                    set: (key, val) => {
+                        if (required) {
+                            reAttached[key] = val;
+                        }
+                        return reply;
+                    },
+                    get: (key) => attached[key],
+                };
+                try {
+                    const timestamp = Date.now();
+                    yield invoke(reply, params, ctx.ports);
+                    if (true) {
+                        const delta = Date.now() - timestamp;
+                        if (delta > 100) {
+                            console.log(`receiver[${this}] - ${method}() took ${delta}ms`);
+                        }
+                    }
+                }
+                catch (error) {
+                     console.warn(error);
+                    if (!handled) {
+                        reply.reject(`${error}`);
+                    }
+                }
+                ctx.data.touched = true;
+                if (!handled) {
+                    yield next();
+                }
+            });
+            this.middleware.unshift(m);
+            const unload = () => {
+                const index = this.middleware.findIndex((v) => v === m);
+                if (~index) {
+                    this.middleware.splice(index, 1);
+                }
+            };
+            return unload;
+        }
+        reject(msg = '') {
+            this.channel.reject(this, msg);
+        }
+        as() {
+            return this;
+        }
+        callback() {
+            return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+                const { pipe, status } = ctx.data;
+                if (pipe !== this.pipe) {
+                    return next();
+                }
+                if (status) {
+                    return next();
+                }
+                return pipeline(this.middleware)(ctx, next);
+            });
+        }
+        toString() {
+            return `${this.pipe}`;
+        }
+    }
+
+    class MojoRemote {
+        constructor(channel, pipe) {
+            this.sequence = 0;
+            this.pendings = new Map();
+            this.pipe = pipe || Math.random().toString(36).slice(3);
+            this.channel = channel;
+            this.accepted = defer();
+        }
+        get ready() {
+            return this.accepted.promise;
+        }
+        get valid() {
+            return this.channel.has(this.pipe);
+        }
+        make(key) {
+            const transfer = [];
+            const attached = {};
+            const ready = (params) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.ready;
+                }
+                catch (error) {
+                     console.warn(`remote[${this}] - ${key}(${params}) failed with '${error}'`);
+                    throw error;
+                }
+            });
+            const send = (params, required) => {
+                this.channel.send({
+                    pipe: this.pipe,
+                    sequence: ++this.sequence,
+                    timestamp: Date.now(),
+                    method: key,
+                    status: 0,
+                    params,
+                    required,
+                    attached,
+                }, transfer);
+            };
+            const invoke = {
+                transfer: (...args) => {
+                    transfer.push(...args);
+                    return invoke;
+                },
+                post: (...params) => __awaiter(this, void 0, void 0, function* () {
+                    yield ready(params);
+                    send(params);
+                }),
+                invoke: (...params) => __awaiter(this, void 0, void 0, function* () {
+                    yield ready(params);
+                    send(params, true);
+                    const d = defer();
+                    this.pendings.set(this.sequence, d);
+                    return d.promise;
+                }),
+                // attached
+                set: (key, val) => {
+                    attached[key] = val;
+                    return invoke;
+                },
+                get: (key) => attached[key],
+            };
+            return invoke;
+        }
+        break(msg = '') {
+            this.channel.break(this, msg);
+            this.pendings.forEach((p) => p.reject('broken'));
+            this.pendings.clear();
+            this.accepted.reject('broken');
+            // eslint-disable-next-line prefer-promise-reject-errors
+            this.accepted.promise = Promise.reject('broken');
+            // handle uncaught promise
+            this.accepted.promise.catch(NOOP);
+        }
+        callback() {
+            return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+                const { pipe, sequence, timestamp, method, status, reject, resolve } = ctx.data;
+                if (pipe !== this.pipe) {
+                    return next();
+                }
+                if (!status) {
+                    return next();
+                }
+                const d = this.pendings.get(sequence);
+                if (!d) {
+                     console.log(`remote[${this}] - receive unknown ${method} reply`);
+                    return;
+                }
+                if (status < 0) {
+                    d.reject(reject);
+                }
+                else {
+                    d.resolve(resolve);
+                }
+                this.pendings.delete(sequence);
+                {
+                    const delta = Date.now() - timestamp;
+                    if (delta > 100) {
+                        console.log(`remote[${this}] - ${method}() took ${delta}ms`);
+                    }
+                }
+            });
+        }
+        toString() {
+            return `${this.pipe}`;
+        }
+    }
+    function defer() {
+        const until = {};
+        until.promise = new Promise((resolve, reject) => {
+            until.resolve = resolve;
+            until.reject = reject;
+        });
+        // handle uncaught promise
+        until.promise.catch(NOOP);
+        if ( typeof setTimeout !== 'undefined') {
+            setTimeout(() => until.reject('timeout'), 10000);
+        }
+        return until;
+    }
+    const NOOP = () => {
+        // nothing
+    };
+
+    class MojoChannel {
+        // fix me
+        // incompatible onmessage ev type
+        constructor(transport) {
+            this.remotes = new Map();
+            this.receivers = new Map();
+            this.pendingReceivers = new Set();
+            const previous = transport.onmessage;
+            this.transport = transport;
+            this.transport.onmessage = (ev) => {
+                const { data, ports = [] } = ev;
+                if (isString(data)) {
+                    if (/^mojo/.test(data)) {
+                        const [, pipe] = data.split(':');
+                        const receiver = this.receivers.get(`${pipe}`);
+                        if (receiver) {
+                            this.send(`accept:${receiver}`);
+                            this.oninvitation && this.oninvitation(pipe, receiver);
+                            receiver.onready && receiver.onready();
+                            return;
+                        }
+                        this.pendingReceivers.add(pipe);
+                        this.oninvitation && this.oninvitation(pipe);
+                        if (this.pendingReceivers.has(pipe)) {
+                            previous && previous.call(this.transport, ev);
+                        }
+                        return;
+                    }
+                    if (/^accept/.test(data)) {
+                        const [, pipe] = data.split(':');
+                        const remote = this.remotes.get(pipe);
+                        if (!remote) {
+                             console.log(`unknown accept:\n${data}`);
+                            return;
+                        }
+                        remote.accepted.resolve();
+                        remote.onaccept && remote.onaccept();
+                        return;
+                    }
+                    if (/^reject/.test(data)) {
+                        const [, pipe, msg = 'rejected'] = data.split(':');
+                        const remote = this.remotes.get(pipe);
+                        if (!remote) {
+                             console.log(`unknown reject:\n${data}`);
+                            return;
+                        }
+                        this.remotes.delete(pipe);
+                        remote.accepted.reject(msg);
+                        remote.onreject && remote.onreject(msg);
+                        return;
+                    }
+                    if (/^break/.test(data)) {
+                        const [, pipe, msg = 'breaked'] = data.split(':');
+                        if (this.pendingReceivers.has(pipe)) {
+                            this.pendingReceivers.delete(pipe);
+                            return;
+                        }
+                        const receiver = this.receivers.get(pipe);
+                        if (!receiver) {
+                             console.log(`unknown break:\n${data}`);
+                            return;
+                        }
+                        this.receivers.delete(pipe);
+                        receiver.onbreak && receiver.onbreak(msg);
+                        return;
+                    }
+                    if (previous) {
+                        previous.call(this.transport, ev);
+                        return;
+                    }
+                     console.log(`unknown invitation:\n${data}`);
+                    return;
+                }
+                const ctx = { data, ports };
+                pipeline([
+                    ...Array.from(this.remotes.values()).map((p) => p.callback()),
+                    ...Array.from(this.receivers.values()).map((p) => p.callback()),
+                ])(ctx, () => {
+                    if (previous) {
+                        previous.call(this.transport, ev);
+                        return;
+                    }
+                    if (data.touched) {
+                        
+                            console.log(`unhandled method: ${data.pipe}::${data.method}\n` +
+                                `forget to call resolve() or reject() in method implement?`);
+                        return;
+                    }
+                     console.log('unknown message', data);
+                });
+            };
+        }
+        fork() {
+            return new MojoChannel(this.transport);
+        }
+        has(pipe) {
+            return this.remotes.has(pipe) || this.receivers.has(pipe);
+        }
+        close() {
+            this.remotes.forEach((v) => v.break());
+            this.remotes.clear();
+            this.receivers.forEach((v) => v.reject());
+            this.receivers.clear();
+            this.transport.onmessage = null;
+            this.transport = null;
+        }
+        send(msg, transfer) {
+            this.transport.postMessage(msg, transfer);
+        }
+        reject(receiver, msg = '') {
+            this.send(`reject:${receiver}:${msg}`);
+            this.receivers.delete(`${receiver}`);
+        }
+        break(remote, msg = '') {
+            if (!this.remotes.has(`${remote}`))
+                return;
+            this.send(`break:${remote}:${msg}`);
+            this.remotes.delete(`${remote}`);
+        }
+        remote(pipe) {
+            const remote = new MojoRemote(this, pipe && `${pipe}`);
+            this.remotes.set(`${remote}`, remote);
+            this.send(`mojo:${remote}`);
+            return remote;
+        }
+        receiver(pipe) {
+            if (pipe && this.receivers.has(`${pipe}`)) {
+                 console.log(`duplicate pipe: ${pipe}`);
+            }
+            const receiver = new MojoReceiver(this, pipe && `${pipe}`);
+            this.receivers.set(`${receiver}`, receiver);
+            if (this.pendingReceivers.has(`${receiver}`)) {
+                this.send(`accept:${receiver}`);
+                this.pendingReceivers.delete(`${receiver}`);
+                receiver.onready && receiver.onready();
+            }
+            return receiver;
+        }
+    }
+    const isString = (val) => typeof val === 'string';
+
+    class AudioFrameBuffer {
+        constructor(builder) {
+            const { length, numberOfChannels: channels = 1, sampleRate } = builder;
+            let { data } = builder;
+            this.length = length;
+            this.numberOfChannels = channels;
+            this.sampleRate = sampleRate;
+            this.duration = length / sampleRate;
+            if (!data || !data.length || !data[0].length) {
+                // AudioBuffer do not store data as a planar sequence
+                data = [...Array(channels)].map(() => new Float32Array(length));
+            }
+            if (data.length < channels) {
+                 console.warn(`invalid buffer channels ${channels} vs ${data.length}`);
+            }
+            if (data[0].length < length) {
+                 console.warn(`invalid buffer length ${length} vs ${data[0].length}`);
+            }
+            this.data = data;
+        }
+        // CopyFrom
+        static From(buffer) {
+            const { sampleRate, numberOfChannels, length } = buffer;
+            const data = [...Array(numberOfChannels).keys()].map((ch) => buffer.getChannelData(ch).slice());
+            return new AudioFrameBuffer({ length, numberOfChannels, sampleRate, data });
+        }
+        static Copy(dst, src) {
+            const { numberOfChannels: channels } = dst;
+            const { numberOfChannels: available } = src;
+            for (let ch = 0; ch < channels; ch++) {
+                dst.copyToChannel(src.getChannelData(Math.min(ch, available - 1)), ch);
+            }
+        }
+        static Clip(buffer, begin, end) {
+            const { sampleRate, numberOfChannels } = buffer;
+            const data = AudioFrameBuffer.Data(buffer, begin, end);
+            const { length } = data[0];
+            return new AudioFrameBuffer({ length, numberOfChannels, sampleRate, data });
+        }
+        static Data(buffer, begin, end) {
+            return [...Array(buffer.numberOfChannels)].map((_, ch) => buffer.getChannelData(ch).subarray(begin, end));
+        }
+        static Builder(buffer) {
+            const { length, numberOfChannels, sampleRate } = buffer;
+            const data = AudioFrameBuffer.Data(buffer);
+            return {
+                length,
+                numberOfChannels,
+                sampleRate,
+                data,
+            };
+        }
+        copyFromChannel(destination, channel = 0, bufferOffset = 0) {
+            if (channel >= this.numberOfChannels) {
+                 console.warn('invalid channel');
+                return;
+            }
+            const data = this.getChannelData(channel);
+            if (bufferOffset >= data.length) {
+                 console.warn('invalid offset');
+                return;
+            }
+            const source = data.subarray(bufferOffset);
+            destination.set(source.subarray(0, Math.min(source.length, destination.length)));
+        }
+        copyToChannel(source, channel = 0, bufferOffset = 0) {
+            if (channel >= this.numberOfChannels) {
+                 console.warn('invalid channel');
+                return;
+            }
+            const data = this.getChannelData(channel);
+            if (bufferOffset >= this.length) {
+                 console.warn('invalid offset');
+                return;
+            }
+            const length = Math.min(this.length - bufferOffset, source.length);
+            const clipped = source.subarray(0, length);
+            data.set(clipped, bufferOffset);
+        }
+        getChannelData(channel) {
+            return this.data[channel];
+        }
+    }
+
+    // export const enum SpeechType {
+    var VADActivity;
+    (function (VADActivity) {
+        VADActivity[VADActivity["kVadActive"] = 0] = "kVadActive";
+        VADActivity[VADActivity["kVadPassive"] = 1] = "kVadPassive";
+        VADActivity[VADActivity["kVadUnknown"] = 2] = "kVadUnknown";
+    })(VADActivity || (VADActivity = {}));
+    // export const enum SpeechType {
+    var SpeechType;
+    (function (SpeechType) {
+        SpeechType[SpeechType["kNormalSpeech"] = 0] = "kNormalSpeech";
+        SpeechType[SpeechType["kPLC"] = 1] = "kPLC";
+        SpeechType[SpeechType["kCNG"] = 2] = "kCNG";
+        SpeechType[SpeechType["kPLCCNG"] = 3] = "kPLCCNG";
+        SpeechType[SpeechType["kCodecPLC"] = 4] = "kCodecPLC";
+        SpeechType[SpeechType["kUndefined"] = 5] = "kUndefined";
+    })(SpeechType || (SpeechType = {}));
+    class AudioFrame {
+        constructor(builder) {
+            this.buffer = builder.buffer;
+            this.timestamp = builder.timestamp;
+            this.elapsedTimeMs = builder.elapsedTimeMs;
+            this.ntpTimeMs = builder.ntpTimeMs;
+            this.vad = builder.vad || VADActivity.kVadUnknown;
+            this.speech = builder.speech || SpeechType.kUndefined;
+        }
+        get sampleRate() {
+            return this.buffer.sampleRate;
+        }
+        get samples() {
+            return this.buffer.length;
+        }
+        get channels() {
+            return this.buffer.numberOfChannels;
+        }
+        get duration() {
+            return this.buffer.duration;
+        }
+    }
+
+    function CopyAudioFrame(output, outputOffset = 0, input, inputOffset = 0, length = input.length) {
+        const { numberOfChannels: channels } = output;
+        const { numberOfChannels: available } = input;
+        for (let channel = 0; channel < channels; channel++) {
+            const source = input
+                .getChannelData(Math.min(channel, available - 1))
+                .subarray(inputOffset, inputOffset + length);
+            output.copyToChannel(source, channel, outputOffset);
+        }
+    }
+    function InterleaveT(buffer, factory, map = (val) => val) {
+        const channels = buffer.length;
+        const length = channels * buffer[0].length;
+        const output = factory(length);
+        for (let channel = 0; channel < channels; channel++) {
+            const data = buffer[channel];
+            for (let index = 0; index < data.length; index++) {
+                output[index * channels + channel] = map(data[index]);
+            }
+        }
+        return output;
+    }
+    function PlanarT(buffer, channels, factory, map = (val) => val) {
+        const output = [];
+        const length = buffer.length / channels;
+        for (let channel = 0; channel < channels; channel++) {
+            output[channel] = factory(length, channel);
+        }
+        for (let index = 0; index < buffer.length; index++) {
+            const channel = index % channels;
+            const data = output[channel];
+            data[Math.floor(index / channels)] = map(buffer[index]);
+        }
+        return output;
+    }
+    const DeInterleaveT = PlanarT;
+    function Float32ToInt16(val) {
+        return Math.min(Math.max((val * 0x7fff) | 0, -0x8000), 0x7fff);
+    }
+    function Int16ToFloat32(val) {
+        return val >= 0x8000 ? -(0x10000 - val) / 0x8000 : val / 0x7fff;
+    }
+
+    function makeAudioReshaper(wanted, callback, factory) {
+        let pending;
+        let offset = 0;
+        return (input) => {
+            const { samples, channels, sampleRate } = input;
+            let current = 0;
+            while (current < samples) {
+                const needed = wanted - offset;
+                const available = samples - current;
+                const total = Math.min(available, needed);
+                if (!needed) {
+                    callback(pending);
+                    pending = null;
+                }
+                if (!pending) {
+                    pending = factory
+                        ? factory(wanted)
+                        : new AudioFrame({
+                            buffer: new AudioFrameBuffer({
+                                length: wanted,
+                                numberOfChannels: channels,
+                                sampleRate,
+                            }),
+                        });
+                    offset = 0;
+                }
+                CopyAudioFrame(pending.buffer, offset, input.buffer, current, total);
+                current += total;
+                offset += total;
+            }
+        };
+    }
+
+    class AudioFrameQueue {
+        constructor() {
+            this.queue = [];
+            // total audio samples
+            this.total = 0;
+            // audio samples offset
+            this.offset = 0;
+        }
+        get length() {
+            return this.total;
+        }
+        clear() {
+            this.queue.length = 0;
+            this.total = 0;
+            this.offset = 0;
+        }
+        shift() {
+            if (!this.total)
+                return;
+            const frame = this.queue[0];
+            const available = frame.samples - this.offset;
+            if (this.offset) {
+                 console.log('maybe unexpected samples');
+            }
+            return this.pull(available);
+        }
+        push(frame) {
+            const input = (frame) => {
+                this.queue.push(frame);
+                this.total += frame.samples;
+            };
+            if (!this.onpush) {
+                input(frame);
+                return;
+            }
+            const { samples, callback, factory, reshape = false } = this.onpush;
+            let { reshaper } = this.onpush;
+            if (reshape) {
+                if (!reshaper) {
+                    reshaper = makeAudioReshaper(samples, input, factory);
+                    this.onpush.reshaper = reshaper;
+                }
+                // reshape & input
+                reshaper(frame);
+            }
+            else {
+                input(frame);
+            }
+            while (this.total - this.offset >= samples) {
+                callback(reshape ? this.shift() : this.pull(samples, factory && factory(samples)));
+            }
+        }
+        pull(wanted, output) {
+            if (wanted <= 0) {
+                 wanted < 0 && console.warn(`invalid samples: ${wanted}`);
+                return;
+            }
+            if (this.onpull) {
+                const { samples, callback, eager } = this.onpull;
+                while (this.total < Math.max(samples, wanted) * (eager ? 2 : 1)) {
+                    const frame = callback(this.total, wanted);
+                    if (!frame) {
+                        break;
+                    }
+                    this.queue.push(frame);
+                    this.total += frame.samples;
+                }
+            }
+            if (this.total < wanted) {
+                 console.warn('audio frame drained');
+                return;
+            }
+            let current = 0;
+            let { offset } = this;
+            while (current < wanted) {
+                const frame = this.queue.shift();
+                const available = frame.samples - offset;
+                const needed = wanted - current;
+                const length = Math.min(available, needed);
+                if (!available) {
+                    continue;
+                }
+                // clip buffer w/o copy
+                if (!output && !current && available >= needed) {
+                    const buffer = AudioFrameBuffer.Clip(frame.buffer, offset, offset + needed);
+                    output = new AudioFrame({ buffer });
+                    if (available > needed) {
+                        offset += length;
+                        this.queue.unshift(frame);
+                    }
+                    else {
+                        offset = 0;
+                    }
+                    break;
+                }
+                // copy needed or available
+                if (!output) {
+                    const buffer = new AudioFrameBuffer({
+                        length: wanted,
+                        numberOfChannels: frame.channels,
+                        sampleRate: frame.sampleRate,
+                    });
+                    output = new AudioFrame({ buffer });
+                }
+                if (output.samples < wanted) {
+                     console.warn('invalid frame buffer length');
+                }
+                CopyAudioFrame(output.buffer, current, frame.buffer, offset, length);
+                current += length;
+                if (available > needed) {
+                    offset += length;
+                    this.queue.unshift(frame);
+                    break;
+                }
+                offset = 0;
+                if (this.onpull) {
+                    // optional chaining
+                    // this.onpull.drain?.(frame);
+                    const { drain } = this.onpull;
+                    drain && drain(frame);
+                }
+            }
+            this.total -= wanted;
+            this.offset = offset;
+            return output;
+        }
+    }
+
+    /// <reference types="emscripten" />
+    const DEFAULT_HEAP_TYPE = 'HEAPU8';
+    function createMemoryAllocator(native, type) {
+        return (length) => {
+            const { BYTES_PER_ELEMENT } = native[type || DEFAULT_HEAP_TYPE];
+            const bytes = length * BYTES_PER_ELEMENT;
+            const pointer = native._malloc(bytes);
+            const tuple = () => [pointer, bytes];
+            // malloc() might cause wasm memory growth, which will detach 'heap' buffer
+            const view = (normalize = true) => {
+                const v = native[type || DEFAULT_HEAP_TYPE].subarray(pointer / BYTES_PER_ELEMENT, pointer + length);
+                if (normalize && typeof v.constructor !== 'undefined') {
+                    return new v.constructor(v.buffer, v.byteOffset, length);
+                }
+                 console.log('unnormalized array view has unexpected length');
+                return v;
+            };
+            const free = () => native._free(pointer);
+            return {
+                BYTES_PER_ELEMENT,
+                pointer,
+                length,
+                bytes,
+                tuple,
+                view,
+                free,
+            };
+        };
+    }
+    function createMemoryViewer(native, type) {
+        return (begin, length, normalize = true) => {
+            const heap = native[type || DEFAULT_HEAP_TYPE];
+            const { BYTES_PER_ELEMENT } = heap;
+            const view = heap.subarray(begin / BYTES_PER_ELEMENT, begin + length);
+            if (normalize && typeof view.constructor !== 'undefined') {
+                return new view.constructor(view.buffer, view.byteOffset, length);
+            }
+             console.log('unnormalized array view has unexpected length');
+            return view;
+        };
+    }
+
+    function open(name, store) {
+        const request = indexedDB.open(name);
+        request.onupgradeneeded = () => request.result.createObjectStore(store);
+        const promise = make(request);
+        return (mode, callback) => promise.then((db) => callback(db.transaction(store, mode).objectStore(store)));
+    }
+    const LAZY_INSTANCE = (factory) => {
+        let instance;
+        return (...args) => {
+            if (!instance) {
+                instance = factory();
+            }
+            return instance(...args);
+        };
+    };
+    const LAZY_GLOBAL_STORE = LAZY_INSTANCE(() => open('LINE-UI', 'key-value'));
+    function get(key, store = LAZY_GLOBAL_STORE) {
+        return store('readonly', (store) => make(store.get(key)));
+    }
+    function clear(store = LAZY_GLOBAL_STORE) {
+        return store('readwrite', (store) => {
+            store.clear();
+            return make(store.transaction);
+        });
+    }
+    function make(request) {
+        return new Promise((resolve, reject) => {
+            // @ts-ignore - file size hacks
+            request.oncomplete = request.onsuccess = () => resolve(request.result);
+            // @ts-ignore - file size hacks
+            request.onabort = request.onerror = () => reject(request.error);
+        });
+    }
+
+    /// <reference types="emscripten" />
+    var IPVPEvents;
+    (function (IPVPEvents) {
+        IPVPEvents[IPVPEvents["kRTPDead"] = 1] = "kRTPDead";
+        IPVPEvents[IPVPEvents["kGainCtrl"] = 2] = "kGainCtrl";
+        IPVPEvents[IPVPEvents["kCSRCChange"] = 3] = "kCSRCChange";
+        IPVPEvents[IPVPEvents["kCCIDChange"] = 4] = "kCCIDChange";
+        IPVPEvents[IPVPEvents["kMicFramingDelay"] = 5] = "kMicFramingDelay";
+        IPVPEvents[IPVPEvents["kSpkFramengDelay"] = 6] = "kSpkFramengDelay";
+        IPVPEvents[IPVPEvents["kRTPViolate"] = 7] = "kRTPViolate";
+        IPVPEvents[IPVPEvents["kSignalBreak"] = 8] = "kSignalBreak";
+    })(IPVPEvents || (IPVPEvents = {}));
+    var IPVPConfigAEC;
+    (function (IPVPConfigAEC) {
+        IPVPConfigAEC[IPVPConfigAEC["kOff"] = 0] = "kOff";
+        IPVPConfigAEC[IPVPConfigAEC["kNormal"] = 1] = "kNormal";
+        IPVPConfigAEC[IPVPConfigAEC["kEnhance"] = 2] = "kEnhance";
+    })(IPVPConfigAEC || (IPVPConfigAEC = {}));
+    var IPVPConfigANS;
+    (function (IPVPConfigANS) {
+        IPVPConfigANS[IPVPConfigANS["kOff"] = 0] = "kOff";
+        IPVPConfigANS[IPVPConfigANS["kLow"] = 1] = "kLow";
+        IPVPConfigANS[IPVPConfigANS["kMiddle"] = 2] = "kMiddle";
+        IPVPConfigANS[IPVPConfigANS["kHigh"] = 3] = "kHigh";
+    })(IPVPConfigANS || (IPVPConfigANS = {}));
+    var IPVPConfigAGCMode;
+    (function (IPVPConfigAGCMode) {
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kAdaptiveDigital"] = 1] = "kAdaptiveDigital";
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kAdaptiveAnalog"] = 2] = "kAdaptiveAnalog";
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kFixedDigital"] = 4] = "kFixedDigital";
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kUnchanged"] = 8] = "kUnchanged";
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kCustomTable"] = 16] = "kCustomTable";
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kDigitalAgcAdj"] = 32] = "kDigitalAgcAdj";
+        IPVPConfigAGCMode[IPVPConfigAGCMode["kVadThresholdAdj"] = 64] = "kVadThresholdAdj";
+    })(IPVPConfigAGCMode || (IPVPConfigAGCMode = {}));
+    var IPVPDataType;
+    (function (IPVPDataType) {
+        IPVPDataType[IPVPDataType["kInvalid"] = -1] = "kInvalid";
+        IPVPDataType[IPVPDataType["kSpeech"] = 0] = "kSpeech";
+        IPVPDataType[IPVPDataType["kPCM"] = 1] = "kPCM";
+        IPVPDataType[IPVPDataType["kRTP"] = 2] = "kRTP";
+        IPVPDataType[IPVPDataType["kRTCP"] = 3] = "kRTCP";
+        IPVPDataType[IPVPDataType["kRFC2833"] = 4] = "kRFC2833";
+        IPVPDataType[IPVPDataType["kCNG"] = 5] = "kCNG";
+        IPVPDataType[IPVPDataType["kAVS"] = 6] = "kAVS";
+        IPVPDataType[IPVPDataType["kRED"] = 7] = "kRED";
+        IPVPDataType[IPVPDataType["kVQM"] = 8] = "kVQM";
+        IPVPDataType[IPVPDataType["kSDES"] = 9] = "kSDES";
+        IPVPDataType[IPVPDataType["kFEC"] = 10] = "kFEC";
+    })(IPVPDataType || (IPVPDataType = {}));
+    var IPVPTalkFlag;
+    (function (IPVPTalkFlag) {
+        IPVPTalkFlag[IPVPTalkFlag["kInactive"] = 0] = "kInactive";
+        IPVPTalkFlag[IPVPTalkFlag["kRecvOnly"] = 1] = "kRecvOnly";
+        IPVPTalkFlag[IPVPTalkFlag["kSendOnly"] = 2] = "kSendOnly";
+        IPVPTalkFlag[IPVPTalkFlag["kSendRecv"] = 3] = "kSendRecv";
+        IPVPTalkFlag[IPVPTalkFlag["kSendEvnt"] = 4] = "kSendEvnt";
+        IPVPTalkFlag[IPVPTalkFlag["kPaging"] = 8] = "kPaging";
+        IPVPTalkFlag[IPVPTalkFlag["kMax"] = 15] = "kMax";
+    })(IPVPTalkFlag || (IPVPTalkFlag = {}));
+    var IPVPSRTPCryptoExtern;
+    (function (IPVPSRTPCryptoExtern) {
+        IPVPSRTPCryptoExtern[IPVPSRTPCryptoExtern["kUnencryRTP"] = 1] = "kUnencryRTP";
+        IPVPSRTPCryptoExtern[IPVPSRTPCryptoExtern["kUnencryRTCP"] = 2] = "kUnencryRTCP";
+        IPVPSRTPCryptoExtern[IPVPSRTPCryptoExtern["kUnautoRTP"] = 4] = "kUnautoRTP";
+    })(IPVPSRTPCryptoExtern || (IPVPSRTPCryptoExtern = {}));
+    var IPVPCodecOpts;
+    (function (IPVPCodecOpts) {
+        IPVPCodecOpts[IPVPCodecOpts["kAmrWbIO"] = 1] = "kAmrWbIO";
+        IPVPCodecOpts[IPVPCodecOpts["kHFOnly"] = 2] = "kHFOnly";
+        IPVPCodecOpts[IPVPCodecOpts["kDTXSend"] = 4] = "kDTXSend";
+        IPVPCodecOpts[IPVPCodecOpts["kDTXRecv"] = 8] = "kDTXRecv";
+        IPVPCodecOpts[IPVPCodecOpts["kStero"] = 16] = "kStero";
+        IPVPCodecOpts[IPVPCodecOpts["kInbandFEC"] = 32] = "kInbandFEC";
+        IPVPCodecOpts[IPVPCodecOpts["kUseYLRTX"] = 64] = "kUseYLRTX";
+    })(IPVPCodecOpts || (IPVPCodecOpts = {}));
+    var IPVPFECFormat;
+    (function (IPVPFECFormat) {
+        IPVPFECFormat[IPVPFECFormat["kURL"] = 0] = "kURL";
+        IPVPFECFormat[IPVPFECFormat["kFLEX"] = 1] = "kFLEX";
+    })(IPVPFECFormat || (IPVPFECFormat = {}));
+    var IPVPGainDir;
+    (function (IPVPGainDir) {
+        IPVPGainDir[IPVPGainDir["kNone"] = 0] = "kNone";
+        IPVPGainDir[IPVPGainDir["kRecv"] = 1] = "kRecv";
+        IPVPGainDir[IPVPGainDir["kSend"] = 2] = "kSend";
+    })(IPVPGainDir || (IPVPGainDir = {}));
+    var IPVPFlowDir;
+    (function (IPVPFlowDir) {
+        IPVPFlowDir[IPVPFlowDir["kNone"] = 0] = "kNone";
+        IPVPFlowDir[IPVPFlowDir["kLocal"] = 1] = "kLocal";
+        IPVPFlowDir[IPVPFlowDir["kNet"] = 2] = "kNet";
+        IPVPFlowDir[IPVPFlowDir["kMix"] = 4] = "kMix";
+        IPVPFlowDir[IPVPFlowDir["kAll"] = 3] = "kAll";
+    })(IPVPFlowDir || (IPVPFlowDir = {}));
+
+    let native;
+    let alloc;
+    let alloc16;
+    let view;
+    let view32;
+    let loglevel = 1;
+    let callid; // aka encoder id
+    const decoders = [];
+    const decoderGains = [-1, -1];
+    function hasDecoder(ccid) {
+        return decoders.findIndex((v) => v && v.has(ccid));
+    }
+    function addDecoder(ccid, track) {
+        if (!decoders[track]) {
+            decoders[track] = new Set();
+        }
+        decoders[track].add(ccid);
+    }
+    function removeDecoder(ccid) {
+        let channel = -1;
+        decoders.forEach((v, i) => {
+            if (!v)
+                return;
+            if (v.has(ccid)) {
+                channel = i;
+            }
+            v.delete(ccid);
+        });
+        return channel;
+    }
+    function moveDecoder(ccid, track) {
+        removeDecoder(ccid);
+        addDecoder(ccid, track);
+    }
+    function decoderList(from = 0, to) {
+        return decoders.slice(from, to).reduce((p, v) => p.concat(Array.from(v)), []);
+    }
+    function isMainTrack(track) {
+        return track < 11;
+    }
+    function trackType(track) {
+        return isMainTrack(track) ? 0 /* kMain */ : 1 /* kOther */;
+    }
+    let eventR;
+    let memory;
+    let inputBuffer;
+    let outputBuffer;
+    let refBuffer;
+    let push;
+    let push_ref;
+    let pull;
+    let drop;
+    let vtuner_reply;
+    const isWechatWorker = typeof worker !== 'undefined';
+    if (isWechatWorker) {
+        worker.onMessage((data) => {
+            worker.onmessage && worker.onmessage({ data });
+        });
+    }
+    const cleanup = [];
+    // eslint-disable-next-line no-restricted-globals
+    const channel = new MojoChannel(isWechatWorker ? worker : self);
+    const engine = channel.receiver('audio-engine-host');
+    engine.implement('init', (reply, [url, transportPR, eventPR, verbose = false]) => __awaiter(void 0, void 0, void 0, function* () {
+        let factory;
+        let wasmUrl;
+        if (isWechatWorker) {
+            const trailingSlash = (v) => (!v || v.endsWith('/') ? v : `${v}/`);
+            const filename = (path) => path.substring(path.lastIndexOf('/') + 1);
+            const [scriptUrl, wasmDir = ''] = url.split('?');
+            const scriptName = filename(scriptUrl);
+            factory = require(scriptUrl);
+            wasmUrl = trailingSlash(wasmDir) + scriptName.replace(/\.js$/, '.wasm');
+        }
+        else {
+            importScripts(url);
+            factory = LIBIPVP;
+            wasmUrl = url.replace(/\.js$/, '.wasm');
+        }
+        const wasmBinary = isWechatWorker
+            ? wasmUrl
+            : yield get(wasmUrl).catch(() => null);
+        // should clear cache if init failed
+        native = yield factory({ wasmBinary }).catch((error) => {
+            clear();
+            throw error;
+        });
+        alloc = createMemoryAllocator(native);
+        alloc16 = createMemoryAllocator(native, 'HEAPU16');
+        view = createMemoryViewer(native);
+        view32 = createMemoryViewer(native, 'HEAPU32');
+         console.log(`IPVP: ${native.ipvp_get_version()} - ${native.ipvp_get_build()}`);
+        eventR = channel.remote(eventPR);
+        const transportR = channel.remote(transportPR);
+        cleanup.unshift(() => {
+            transportR.break();
+            eventR.break();
+            eventR = null;
+        });
+        native.ipvp_init((level, msg) => {
+            if (verbose || (level <= loglevel && true)) {
+                console.log(msg);
+            }
+        }, (event, wparam, lparam, data, length) => {
+            if (event === IPVPEvents.kRTPDead) {
+                if (hasDecoder(wparam)) {
+                    native.ipvp_decode_stop(wparam);
+                    const channel = removeDecoder(wparam);
+                    eventR && eventR.make('decodestop').post(wparam, channel);
+                }
+                return;
+            }
+            if (event === IPVPEvents.kGainCtrl) {
+                 console.log(`gain control: ${lparam}db`);
+                return;
+            }
+            if (event === IPVPEvents.kCSRCChange) {
+                const speaking = [];
+                if (data && lparam) {
+                    // [int32_t, int32_t][]
+                    speaking.push(...view32(data, lparam).filter((_, index) => index % 2 === 0));
+                }
+                eventR.make('speaking').post(callid, speaking);
+                maybeUpdateDecodeGain(speaking);
+                return;
+            }
+            if (event === IPVPEvents.kCCIDChange) {
+                const speaking = [];
+                if (data && lparam) {
+                    speaking.push(...view32(data, lparam));
+                }
+                eventR.make('focusing').post(callid, speaking);
+                return;
+            }
+             console.log(`ipvp event: ${IPVPEvents[event]}`);
+        }, (callid, data, length) => {
+            const memory = new Uint8Array(view(data, length));
+            transportR.make('send').transfer(memory.buffer).post(callid, memory);
+        }, (data, length) => {
+            vtuner_reply && vtuner_reply(data, length);
+        });
+        // native.ipvp_config_jitter(1, 0, 0, 60);
+        reply.resolve();
+    }));
+    engine.implement('exit', (reply) => {
+        cleanup.forEach((v) => v());
+        cleanup.length = 0;
+        native.ipvp_exit();
+        reply.resolve();
+    });
+    engine.implement('debug', (reply, [level]) => {
+        loglevel = level;
+        reply.resolve();
+    });
+    engine.implement('mos', (reply, [lossrate, rtt, realtime = false]) => {
+        // range[0, 100] to range[0, 10]
+        reply.resolve(native.ipvp_mos(lossrate, rtt, realtime) / 10);
+    });
+    engine.implement('aec', (reply, [level]) => {
+         console.log(`IPVP AEC: ${level}`);
+        native.ipvp_config_aec(level);
+        reply.resolve();
+    });
+    engine.implement('agc', (reply, [enable]) => {
+         console.log(`IPVP AGC: ${enable}`);
+        native.ipvp_config_agc(enable);
+        reply.resolve();
+    });
+    engine.implement('ans', (reply, [ans, tns = ans]) => {
+         console.log(`IPVP ANS: ${ans}, ${tns}`);
+        native.ipvp_config_ans(tns, ans);
+        reply.resolve();
+    });
+    engine.implement('mute', (reply, [enable]) => {
+         console.log(`IPVP mute: ${enable}`);
+        native.ipvp_set_mute(Number(enable));
+        reply.resolve();
+    });
+    engine.implement('bypass', (reply, [enable]) => {
+        if (enable) {
+            native.ipvp_config_aec(IPVPConfigAEC.kOff);
+            native.ipvp_config_ans(IPVPConfigANS.kOff, IPVPConfigANS.kOff);
+            native.ipvp_set_bypass(1);
+        }
+        else {
+            native.ipvp_config_aec(IPVPConfigAEC.kNormal);
+            native.ipvp_config_ans(IPVPConfigANS.kLow, IPVPConfigANS.kLow);
+            native.ipvp_set_bypass(0);
+        }
+        reply.resolve();
+    });
+    engine.implement('dtmf', (reply, [tones]) => {
+        native.ipvp_dtmf_send(callid, tones, IPVPFlowDir.kNet);
+        reply.resolve();
+    });
+    engine.implement('sendstats', (reply) => {
+        reply.resolve(native.ipvp_get_astats_tx(callid));
+    });
+    engine.implement('recvstats', (reply, [ccid]) => {
+        if (ccid !== -1) {
+            reply.resolve(native.ipvp_get_astats_rx(ccid));
+            return;
+        }
+        reply.resolve(decoderList().map((id) => native.ipvp_get_astats_rx(id)));
+        // const counts = decoders.size;
+        // const stats = Array.from(decoders)
+        //   .map((id) => native.ipvp_get_astats_rx(id))
+        //   .reduce((stats, val, index) => {
+        //     if (!index) {
+        //       val.mos_conver /= counts;
+        //       val.mos_listen /= counts;
+        //       val.mos_network /= counts;
+        //       return val;
+        //     }
+        //     stats.mos_conver += val.mos_conver / counts;
+        //     stats.mos_listen += val.mos_listen / counts;
+        //     stats.mos_network += val.mos_network / counts;
+        //     return stats;
+        //   }, {} as IPVPAudioStatsRX);
+        // reply.resolve(stats);
+    });
+    engine.implement('bandwidth', (reply) => {
+        reply.resolve(native.ipvp_get_bandwidth());
+    });
+    engine.implement('jitter', (reply) => {
+        reply.resolve(native.ipvp_get_jitter(callid));
+    });
+    engine.implement('sendstatsadv', (reply) => {
+        reply.resolve(native.ipvp_get_astats_tx_advance(callid));
+    });
+    engine.implement('recvstatsadv', (reply, [ccid]) => {
+        if (ccid !== -1) {
+            reply.resolve(native.ipvp_get_astats_rx_advance(ccid));
+            return;
+        }
+        reply.resolve(decoderList().map((id) => native.ipvp_get_astats_rx_advance(id)));
+    });
+    engine.implement('report', (reply) => {
+        reply.resolve(native.ipvp_get_astats_report());
+    });
+    engine.implement('micschedule', (reply) => {
+        reply.resolve(native.ipvp_get_mic_schedule());
+    });
+    engine.implement('spkschedule', (reply) => {
+        reply.resolve(native.ipvp_get_spk_schedule());
+    });
+    engine.implement('process', (reply, [builder]) => {
+        if (!push) {
+             console.log('unexpected - process before setup');
+            reply.reject();
+            return;
+        }
+        push(builder);
+        const output = pull(builder.length);
+        if (!output) {
+            reply.resolve();
+            return;
+        }
+        reply.transfer(...output.data.map((d) => d.buffer)).resolve(output);
+    });
+    engine.implement('processdelay', (reply, [samples]) => {
+        if (!drop) {
+             console.log('unexpected - processdelay before setup');
+            reply.reject();
+            return;
+        }
+        drop(samples);
+        reply.resolve();
+    });
+    engine.implement('push', (reply, [builder]) => {
+        if (!push) {
+             console.log('unexpected - process before setup');
+            reply.reject();
+            return;
+        }
+        push(builder);
+        reply.resolve();
+    });
+    engine.implement('pushref', (reply, [builder]) => {
+        if (!push_ref) {
+             console.log('unexpected - process before setup');
+            reply.reject();
+            return;
+        }
+        push_ref(builder);
+        reply.resolve();
+    });
+    engine.implement('pull', (reply, [samples]) => {
+        const output = pull(samples);
+        if (!output) {
+            reply.resolve();
+            return;
+        }
+        reply.transfer(...output.data.map((d) => d.buffer)).resolve(output);
+    });
+    engine.implement('pulldelay', (reply, [samples]) => {
+        if (!drop) {
+             console.log('unexpected - processdelay before setup');
+            reply.reject();
+            return;
+        }
+        drop(samples);
+        reply.resolve();
+    });
+    engine.implement('receive', (reply, [ccid, data, track = 0]) => {
+        if (hasDecoder(ccid) === -1) {
+            // CHECK RTP EXT - M bit
+            // if (!(data[17] & 0x40)) {
+            // }
+            // CHECK RTP EXT - energy
+            if (!data[18] && !data[19]) {
+                reply.resolve();
+                return;
+            }
+            const result = native.ipvp_decode_start(ccid, ccid);
+            if (result !== 0) {
+                 console.log(`audio decoder failed: ${result}`);
+            }
+            if (result > 0) {
+                 console.log(`trying to release audio decoder: ${result}`);
+                const track = removeDecoder(result);
+                native.ipvp_decode_stop(result);
+                native.ipvp_decode_start(ccid, ccid);
+                eventR && eventR.make('decodestop').post(result, track);
+            }
+            addDecoder(ccid, track);
+            eventR && eventR.make('decodestart').post(ccid, track);
+            // gain override
+            const gain = decoderGains[trackType(track)];
+            if (gain >= 0) {
+                native.ipvp_decode_gain([[ccid, gain]]);
+                eventR && eventR.make('gainchange').post(gain, track);
+            }
+        }
+        else if (!decoders[track] || !decoders[track].has(ccid)) {
+            moveDecoder(ccid, track);
+            // gain override
+            const gain = decoderGains[trackType(track)];
+            if (gain >= 0) {
+                native.ipvp_decode_gain([[ccid, gain]]);
+                eventR && eventR.make('gainchange').post(gain, track);
+            }
+            else {
+                const gain = isMainTrack(track) && CURRENT_SUPPRESSION ? 20 : 100;
+                native.ipvp_decode_gain([[ccid, gain]]);
+                eventR && eventR.make('gainchange').post(gain, track);
+            }
+            maybeUpdateDecodeGain();
+        }
+        const memory = alloc(data.length);
+        memory.view().set(data);
+        native.ipvp_net_data(ccid, memory.pointer, memory.bytes, IPVPDataType.kRTP);
+        memory.free();
+        reply.resolve();
+    });
+    engine.implement('setup', (reply, [ccid, samplerate, type = 3 /* kSendRecv */], [port]) => {
+        callid = ccid;
+        if (type & 1 /* kSendOnly */) {
+            native.ipvp_encode_start(ccid, ccid);
+            cleanup.unshift(() => native.ipvp_encode_stop(ccid));
+        }
+        if (type & 2 /* kRecvOnly */) {
+            cleanup.unshift(() => decoderList().forEach((id) => native.ipvp_decode_stop(id)));
+        }
+        const channels = 1;
+        const samples = samplerate / 100;
+        memory = alloc16(samples * channels);
+        inputBuffer = new AudioFrameQueue();
+        outputBuffer = new AudioFrameQueue();
+        refBuffer = new AudioFrameQueue();
+        cleanup.unshift(() => memory.free());
+         console.log(`config - channel: ${channels}, samplerate: ${samplerate}`);
+        native.ipvp_dev_config(samplerate, channels);
+        inputBuffer.onpush = {
+            samples,
+            callback: (frame) => {
+                const { buffer } = frame;
+                // always use first channel
+                const data = [...Array(1)].map((_, ch) => buffer.getChannelData(ch));
+                InterleaveT(data, () => memory.view(), Float32ToInt16);
+                native.ipvp_mic_framing(memory.pointer, memory.bytes);
+            },
+        };
+        refBuffer.onpush = {
+            samples,
+            callback: (frame) => {
+                const { buffer } = frame;
+                // always use first channel
+                const data = [...Array(1)].map((_, ch) => buffer.getChannelData(ch));
+                InterleaveT(data, () => memory.view(), Float32ToInt16);
+                native.ipvp_ref_framing(memory.pointer, memory.bytes);
+            },
+        };
+        outputBuffer.onpull = {
+            samples,
+            callback: () => {
+                native.ipvp_spk_framing(memory.pointer, memory.bytes);
+                const data = DeInterleaveT(memory.view(), channels, (samples) => new Float32Array(samples), Int16ToFloat32);
+                const buffer = new AudioFrameBuffer({
+                    length: samples,
+                    numberOfChannels: channels,
+                    sampleRate: samplerate,
+                    data,
+                });
+                const frame = new AudioFrame({ buffer });
+                // ref
+                if (is(3 /* kSendRecv */)) {
+                    native.ipvp_ref_framing(memory.pointer, memory.bytes);
+                }
+                return frame;
+            },
+        };
+        const is = (val) => !(type ^ val);
+        push = (builder) => {
+            if (is(2 /* kRecvOnly */)) {
+                 console.log('push auido buffer but engine is recv only');
+                return;
+            }
+            const buffer = new AudioFrameBuffer(builder);
+            const frame = new AudioFrame({ buffer });
+            inputBuffer.push(frame);
+        };
+        push_ref = (builder) => {
+            if (is(2 /* kRecvOnly */)) {
+                 console.log('push ref auido buffer but engine is recv only');
+                return;
+            }
+            const buffer = new AudioFrameBuffer(builder);
+            const frame = new AudioFrame({ buffer });
+            refBuffer.push(frame);
+        };
+        pull = (wanted) => {
+            if (is(1 /* kSendOnly */)) {
+                 console.log('pull auido buffer but engine is send only');
+                return;
+            }
+            // true && checkSamples(wanted, samplerate);
+            const frame = outputBuffer.pull(wanted);
+            if (!frame)
+                return;
+            return AudioFrameBuffer.Builder(frame.buffer);
+        };
+        let dropRequests = 0;
+        drop = () => {
+            if (is(1 /* kSendOnly */)) {
+                 console.log('drop audio buffer but engine is send only');
+                return;
+            }
+            dropRequests++;
+        };
+        if (port) {
+            const channel = new MojoChannel(port);
+            // processor api
+            const processor = channel.receiver('worklet-audio-processor-host');
+            processor.implement('process', (reply, [builder]) => {
+                push(builder);
+                let wanted = builder.length;
+                if (dropRequests > 0) {
+                    dropRequests--;
+                    wanted -= samples;
+                }
+                const output = pull(wanted);
+                if (!output) {
+                    reply.resolve();
+                    return;
+                }
+                reply.transfer(...output.data.map((d) => d.buffer)).resolve(output);
+            });
+            processor.implement('processdelay', (reply, [samples]) => {
+                drop(samples);
+                reply.resolve();
+            });
+            // source|sink api
+            const source = channel.receiver('worklet-audio-source-host');
+            source.implement('onpush', (reply, [builder]) => {
+                push(builder);
+                reply.resolve();
+            });
+            source.implement('onref', (reply, [builder]) => {
+                push_ref(builder);
+                reply.resolve();
+            });
+            const sink = channel.receiver('worklet-audio-sink-host');
+            sink.implement('onpull', (reply, [wanted]) => {
+                const output = pull(wanted);
+                if (!output) {
+                    reply.resolve();
+                    return;
+                }
+                reply.transfer(...output.data.map((d) => d.buffer)).resolve(output);
+            });
+            sink.implement('ondelay', (reply, [samples]) => {
+                drop(samples);
+                reply.resolve();
+            });
+            cleanup.unshift(() => {
+                channel.close();
+                port.close();
+            });
+        }
+        reply.resolve();
+    });
+    engine.implement('trackgain', (reply, [gain = -1, track = 0]) => {
+        const type = trackType(track);
+        decoderGains[trackType(track)] = gain;
+        if (gain >= 0) {
+            const decoders = type === 0 /* kMain */ ? decoderList(0, 10) : decoderList(11);
+            native.ipvp_decode_gain(decoders.map((ccid) => [ccid, gain]));
+            eventR && eventR.make('gainchange').post(gain, track);
+            if (type === 0 /* kMain */) {
+                debouncedUpdateDecodeGain.cancel();
+            }
+        }
+        reply.resolve();
+    });
+    engine.implement('fec', (reply, [lossrate]) => {
+        native.ipvp_config_fec(callid, lossrate);
+        reply.resolve();
+    });
+    engine.implement('dumpstats', (reply) => {
+        native.ipvp_debug_dump_stat();
+        reply.resolve();
+    });
+    engine.implement('dumpparam', (reply) => {
+        native.ipvp_debug_dump_param();
+        reply.resolve();
+    });
+    engine.implement('dumptalk', (reply) => {
+        native.ipvp_debug_dump_talk();
+        reply.resolve();
+    });
+    {
+        engine.implement('vtuner', (reply, [host = 'localhost:8090', port = Math.random() * 10000 + 1080]) => {
+            /* eslint-disable no-restricted-globals */
+            const { hostname, protocol } = self.location;
+            const scheme = hostname === 'localhost' ? 'ws:' : protocol.replace('http', 'ws');
+            const ws = new WebSocket(`${scheme}//${host}/?port=${port.toFixed(0)}`);
+            ws.binaryType = 'arraybuffer';
+             console.log(`vtuner: ${port.toFixed(0)}`);
+            let close;
+            ws.onopen = () => {
+                ws.onmessage = ({ data }) => {
+                    if (typeof data !== 'string') {
+                        memory.view().set(new Uint8Array(data));
+                        native.ipvp_debug_vtuner_send(memory.pointer, data.byteLength);
+                    }
+                    else {
+                         console.log(`unknown message:\n\n${data}\n`);
+                    }
+                };
+                native.ipvp_debug_vtuner_enable(1);
+                const memory = alloc(512 * 1024);
+                vtuner_reply = (data, length) => {
+                    ws.send(view(data, length));
+                };
+                close = () => {
+                     console.log('closing vtuner...');
+                    native.ipvp_debug_vtuner_enable(0);
+                    memory.free();
+                    ws.close();
+                };
+                cleanup.unshift(() => {
+                    close && close();
+                    close = null;
+                });
+            };
+            ws.onclose = () => {
+                close && close();
+                close = null;
+            };
+            reply.resolve();
+        });
+    }
+    const DEFAULT_DELAYED_UPDATE_TIME = 5000;
+    let LAST_SPEAKING = [];
+    let CURRENT_SUPPRESSION = false;
+    function maybeUpdateDecodeGain(speaking = LAST_SPEAKING) {
+        LAST_SPEAKING = speaking;
+        let gain = decoderGains[0 /* kMain */];
+        if (gain >= 0)
+            return;
+        const specialDecoders = decoderList(11);
+        const normalDecoders = decoderList(0, 10);
+        const shouldSuppression = specialDecoders.some((v) => speaking.includes(v));
+        // if has channel > 10
+        // all ssrc in channel below 10 set to 20%
+        if (shouldSuppression) {
+            const DEFAULT_SUPPRESSION_GAIN = 20;
+            gain = DEFAULT_SUPPRESSION_GAIN;
+            debouncedUpdateDecodeGain.cancel();
+            updateDecodeGain(normalDecoders, gain);
+        }
+        // if no channel > 10
+        // all ssrc in channel below 10 set to 100%
+        else {
+            const DEFAULT_GAIN = 100;
+            gain = DEFAULT_GAIN;
+            debouncedUpdateDecodeGain(normalDecoders, gain);
+        }
+    }
+    function updateDecodeGain(decoders, gain) {
+        native.ipvp_decode_gain(decoders.map((ccid) => [ccid, gain]));
+        eventR && eventR.make('gainchange').post(gain, 0 /* kMain */);
+        CURRENT_SUPPRESSION = gain !== 100;
+    }
+    const debouncedUpdateDecodeGain = debounce(updateDecodeGain, DEFAULT_DELAYED_UPDATE_TIME);
+    function debounce(fn, delay) {
+        let timer;
+        function delegate(...args) {
+            clearTimeout(timer);
+            // @ts-ignore
+            timer = setTimeout(() => fn.call(this, ...args), delay);
+        }
+        delegate.cancel = () => clearTimeout(timer);
+        return delegate;
+    }
+     setupBusyDetector();
+    // simple cpu overload detection
+    function setupBusyDetector() {
+        let last = Date.now();
+        let detectTimer;
+        const detectInterval = 1000;
+        const factor = 1.1;
+        const detect = () => {
+            const now = Date.now();
+            const delta = now - last;
+            const tester = detectInterval * factor;
+            if (delta > tester) {
+                console.log(`busy:\n` +
+                    `delta: ${delta}\n` +
+                    `factor: ${factor}\n` +
+                    `interval: ${detectInterval}\n` +
+                    `delay: ${delta - detectInterval}\n`);
+            }
+            last = now;
+            detectTimer = setTimeout(detect, detectInterval);
+        };
+        detect();
+        return () => clearTimeout(detectTimer);
+    }
+    // const checkSamples = (samples: number, sampleRate: number) => {
+    //   const period = sampleRate / 100;
+    //   const diff = samples % period;
+    //   const upside = samples - diff + period;
+    //   const downside = samples - diff;
+    //   if (diff) {
+    //     true &&
+    //       console.log(`invalid samples: ${samples} -> ${upside} or ${downside}`);
+    //   }
+    // };
+
+}());