c# - Csharp 回声消除 Speex

Question

我想使用 naudio 通过网络与 csharp 进行语音对话。然而，回声正在发生。我使用 libspeexdsp.dll 来避免回声，但回声仍在继续，几乎没用。我想知道我在哪里做错了。我的声音回到我身边。我计算了任何延迟。我想知道我是否应该考虑 speex 数据的其他替代方案。

   class EchoFilter {
    [DllImport("libspeexdsp", EntryPoint = "speex_echo_state_init", CallingConvention = CallingConvention.Cdecl)]
    static extern IntPtr speex_echo_state_init(int frame_size, int filter_length);

    [DllImport("libspeexdsp", EntryPoint = "speex_echo_cancellation", CallingConvention = CallingConvention.Cdecl)]
    static extern void speex_echo_cancellation(IntPtr state, short[] inputFrame, short[] echoFrame, short[] outputFrame);

    [DllImport("libspeexdsp", EntryPoint = "speex_echo_ctl", CallingConvention = CallingConvention.Cdecl)]
    public static extern int speex_echo_ctl(IntPtr st, int id, ref int sampleRate);

    [DllImport("libspeexdsp", EntryPoint = "speex_preprocess_state_init", CallingConvention = CallingConvention.Cdecl)]
    static extern IntPtr speex_preprocess_state_init(int frame_size, int sampleRate);

    [DllImport("libspeexdsp", EntryPoint = "speex_preprocess_ctl", CallingConvention = CallingConvention.Cdecl)]
    public static extern int speex_preprocess_ctl(IntPtr state, int id, IntPtr val);

    [DllImport("libspeexdsp", EntryPoint = "speex_preprocess_run", CallingConvention = CallingConvention.Cdecl)]
    public static extern int speex_preprocess_run(IntPtr st, short[] outputFrame);

    [DllImport("libspeexdsp", EntryPoint = "speex_preprocess_state_destroy", CallingConvention = CallingConvention.Cdecl)]
    public static extern void speex_preprocess_state_destroy(IntPtr st);

    [DllImport("libspeexdsp", EntryPoint = "speex_echo_state_destroy", CallingConvention = CallingConvention.Cdecl)]
    static extern void speex_echo_state_destroy(IntPtr state);

    IntPtr st;
    IntPtr den;

    int SPEEX_ECHO_SET_SAMPLING_RATE = 24;
    int SPEEX_PREPROCESS_SET_ECHO_STATE = 24;

    /// <param name="frameSize">frameSize is the amount of data (in samples) you want to process at once.</param>
    /// <param name="filterLength">filterLength is the length (in samples) of the echo cancelling filter you want to use (also known as tail length).</param>
    public EchoFilter(int frameSize, int filterLength, int sampleRate) {
        st = speex_echo_state_init(frameSize, filterLength);
        den = speex_preprocess_state_init(frameSize, sampleRate);
        speex_echo_ctl(st, SPEEX_ECHO_SET_SAMPLING_RATE, ref sampleRate);
        speex_preprocess_ctl(den, SPEEX_PREPROCESS_SET_ECHO_STATE, st);
    }

    /// <summary>
    /// Method for echo cancellation
    /// </summary>
    /// <param name="inputFrame">Frame obtained from local microphone (Signal that contains echo)</param>
    /// <param name="echoFrame">Frame obtained from remote source (Source of echo)</param>
    /// <param name="outputFrame">Filtered output</param>
    public void Filter(short[] inputFrame, short[] echoFrame, short[] outputFrame) {
        speex_echo_cancellation(st, inputFrame, echoFrame, outputFrame);
        speex_preprocess_run(den, outputFrame);
    }

    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    void Dispose(bool disposing) {
        if (st != IntPtr.Zero) {
            speex_echo_state_destroy(st);
            st = IntPtr.Zero;
        }

        if (den != IntPtr.Zero) {
            speex_preprocess_state_destroy(den);
            den = IntPtr.Zero;
        }
    }
    ~EchoFilter() {
        Dispose(false);
    }
}

class IMicrophone : IMMNotificationClient {
    MMDeviceEnumerator deviceEnum;
    ComboBox cbbDeviceList;

    int bufferMilliseconds = 20;
    WaveIn waveIn = null;
    BufferedWaveProvider bufferedWaveProvider;

    WaveFormat waveFormat = null;
    EventHandler<WaveInEventArgs> dataAvailable;

    public MMDevice defaultSpeaker = null;
    public MMDevice defaultMicrophone = null;


    public bool noDevice() {
        return WaveIn.DeviceCount == 0 ? true : false;
    }

    public EchoFilter filterSpeex = null;
    Queue<byte[]> playedQueue = new Queue<byte[]>();

    public IMicrophone() {
        deviceEnum = new MMDeviceEnumerator();
        deviceEnum.RegisterEndpointNotificationCallback(this);

        waveFormat = new WaveFormat(ISetting.MIC_SAMPLE_RATE, 1);

        TimeSpan frameSizeTime = TimeSpan.FromMilliseconds(bufferMilliseconds);
        int frameSize = (int)Math.Ceiling(frameSizeTime.TotalSeconds * waveFormat.SampleRate);
        int filterLength = frameSize * 25;

        filterSpeex = new EchoFilter(frameSize, filterLength, ISetting.MIC_SAMPLE_RATE);
    }

    public void echoCancellation(byte[] buffer, Action<byte[]> completed) {
        short[] bufferOut = new short[buffer.Length / 2];

        lock (playedQueue) {
            if (playedQueue.Count == 0) {
                completed(buffer);
            } else {
                filterSpeex.Filter(BytesToShorts(buffer), BytesToShorts(playedQueue.First()), bufferOut);
                completed(ShortsToBytes(bufferOut));
            }
        }
    }

    public void load(ComboBox cbbDeviceList, EventHandler<WaveInEventArgs> dataAvailable) {
        defaultSpeaker = deviceEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
        defaultMicrophone = deviceEnum.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Multimedia);

        this.cbbDeviceList = cbbDeviceList;
        this.dataAvailable = dataAvailable;

        List<WaveInCapabilities> waveIns = new List<WaveInCapabilities>();
        for (int i = 0; i < WaveIn.DeviceCount; i++) {
            cbbDeviceList.Items.Add(WaveIn.GetCapabilities(i).ProductName);
        }

        if (WaveIn.DeviceCount > 0) {
            cbbDeviceList.SelectedIndex = 0;
        }

        setMicrophoneMasterVolumeLevel(80);
    }

    public void addSamples(AudioInfo audioInfo) {
        if (!ISetting.ipAddress.Equals(audioInfo.ip)) {
            lock (playedQueue) {
                playedQueue.Enqueue(audioInfo.buffer);
                bufferedWaveProvider.AddSamples(audioInfo.buffer, 0, audioInfo.buffer.Length);
            }
        }
    }

    public void connect() {
        stop();
        if (WaveIn.DeviceCount > 0) {
            waveIn = new WaveIn();
            waveIn.DeviceNumber = cbbDeviceList.SelectedIndex;
            waveIn.DataAvailable += new EventHandler<WaveInEventArgs>(dataAvailable);
            waveIn.WaveFormat = waveFormat;
            waveIn.BufferMilliseconds = bufferMilliseconds; // Biriktirme MS
            start();

            // Mic Play
            WaveOut waveOut = new WaveOut();
            bufferedWaveProvider = new BufferedWaveProvider(waveFormat) { DiscardOnBufferOverflow = true };
            waveOut.DesiredLatency = 100;
            waveOut.Volume = 1.0f;
            waveOut.Init(bufferedWaveProvider);
            waveOut.Play();
        }
    }

    public void start() {
        waveIn.StartRecording();
    }

    public void stop() {
        if (waveIn != null) {
            waveIn.Dispose();
            waveIn = null;
        }
    }

   
}


[Serializable]
class AudioInfo {
    public string ip;
    public byte[] buffer;

    public AudioInfo(string ip, byte[] buffer) {
        this.ip = ip;
        this.buffer = buffer;
    }
}} 

void wave_DataAvailable(object sender, WaveInEventArgs e) {
        microphone.echoCancellation(e.Buffer, (bufferOut) => {
            if (MYInfo.info.isSpeaker && MYInfo.info.startedMic) {
                byte[] bytesStream = Helper.serializeToStream(new AudioInfo(ISetting.ipAddress, bufferOut));
                foreach (UserInfo userInfo in UsersInfo.infos) { // SADECE SERVER   
                    ITCP.sendDataAsync(userInfo.ipAddress, ISetting.PORT_MIC, bytesStream);
                }
            }
        });
    }

    private void micStartListening(IAsyncResult ar) {
        ITCP.getListenData(listenerMic, ar, micStartListening, (buffer) => {
            AudioInfo audioInfo = (AudioInfo)Helper.desserialize(buffer);
            microphone.addSamples(audioInfo);

            if (MYInfo.info.isServer) {
                foreach (UserInfo userInfo in UsersInfo.infos.Where(info => info.isClient && !info.ipAddress.Equals(audioInfo.ip))) {
                    //ITCP.sendDataAsync(userInfo.ipAddress, ISetting.PORT_MIC, buffer);
                }
            }
        });
    }

标签： c#voipnaudiospeexecho-cancellation