audiocool

WebRtc/Speex AEC matlab代码分析

自适应回声消除算法

欢迎留言交流

AEC算法早期用在Voip，电话这些场景中，自从智能设备诞生后，智能语音设备也要消除自身的音源，这些音源包括音乐或者TTS机器合成声音。

本文基于开源算法阐述AEC的原理和实现，基于WebRTC和speex两种算法，文末会附上两种算法的matlab实现。

回声消除原理

回声消除的基本原理是使用一个自适应滤波器对未知的回声信道: ω 进行参数辨识，根据扬声器信号与产生的多路回声的相关性为基础，建立远端信号模型，模拟回声路径，通过自适应算法调整，使其冲击响应和真实回声路径相逼近。然后将麦克风接收到的信号减去估计值，即可实现回声消除功能。
echo=x∗ω 1.1
d=s+echo 1.2
y^=x∗ω^ 1.3
e=d−y^ 1.4
式中 ω 是回声通道的时域冲击响应函数，x是远端语音；echo是所得回声；s是近端说话人语音，d为麦克风采集到的信号， y^ 是对回声信号的估计值，e为误差。
为了消除较长时间的回声，需要FIR滤波器的阶数较高，时域计算法，有两个问题，一个是实时性较差，一个是计算量大。为了在实时性/计算量以及可以消除的回声时长之间找到使这三个最优的算法，采用了频谱分块自适应滤波算法。
这里用到了很多信号处理算法，为了让算法理解起来容易些，简单罗列涉及到的算法：

FFT/IFFT
循环卷积和线性卷积的关系;重叠保留法
功率谱密度
互相关
NLMS自适应算法

NLMS权重调整

关于NLMS，可以下载http://download.csdn.net/detail/shichaog/9832657

下面直接开始WebRTC的matlab梳理，由于matlab代码和webRTC的c++代码命名几乎一致。所以c++的实现就一笔带过。
首先解释几个名词：

RERL-residual_echo_return_loss
ERL-echo return loss
ERLE echo return loss enhancement
NLP non-linear processing

首先matlab读入远端和近端信号。

%near is micphone captured signal
fid=fopen('near.pcm', 'rb'); % Load far end
ssin=fread(fid,inf,'float32');
fclose(fid);
%far is speaker played music
fid=fopen('far.pcm', 'rb'); % Load fnear end
rrin=fread(fid,inf,'float32');
fclose(fid);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8

然后对一些变量赋初值

fs=16000;
NLPon=1; % NLP on
M = 16; % Number of partitions
N = 64; % Partition length
L = M*N; % Filter length
VADtd=48;
alp = 0.15; % Power estimation factor 
alc = 0.1; % Coherence estimation factor
step = 0.1875;%0.1875; % Downward step size
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9

上述初始化中，M=16和最新的WebRTC代码并不一致，且最新的WebRTC中支持aec3最新一代算法。

len=length(ssin);
NN=len;
Nb=floor(NN/N)-M;
for kk=1:Nb
    pos = N * (kk-1) + start;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5

可以看出Nb是麦克风采集到的数据块数-16（分区数），这是因为第一次输入了16块，所以这里减掉了16。pos是每一次添加一块时的地址指针。

    %far is speaker played music
    xk = rrin(pos:pos+N-1);
    %near is micphone captured signal
    dk = ssin(pos:pos+N-1);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4

xk和dk是读取到的64个点，这里是时域信号。

功率计算

    %----------------------- far end signal process
    xx = [xo;xk];
    xo = xk;
    tmp = fft(xx);
    XX = tmp(1:N+1);

    dd = [do;dk]; % Overlap
    do = dk;
    tmp = fft(dd); % Frequency domain
    DD = tmp(1:N+1);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10

将xk和上一次的数据结合在一起，做FFT变换，由于两次组合在一起，那么得到的应该是N=128点，这里可以知道得到的谱分辨率是 n∗fs/N , fs 前面设置过了，是16k，则得到的每一个bin的频谱分辨率是16000/128=125Hz。这里XX和DD取了前65个点，这是因为N点FFT变换后频谱是关于N/2对称的，对称的原因是奈奎斯特采样定理，如果 fs=16000Hz ,那么要求采样到的信号的截止频率必然小于等于 fs/2=8000Hz ,对于实信号，N/2~N,实际上表示的是 −fs/2 ~ 0 之间的频率。第一个点是直流分量，所以取65个点。和上一帧64个点信号合并在一起的另一个原因是使用重叠保（overlap-save）留法将循环卷积变成线性卷积，这里做的FFT变换，就是为了减少时域里做卷积的计算量的。
计算远端信号功率谱

    % ------------------------far end Power estimation
    pn0 = (1 - alp) * pn0 + alp * real(XX.* conj(XX));
    pn = pn0;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

平滑功率谱，上一次的功率谱占85%（alp=0.15），后面的频域共轭相乘等于功率是有帕斯瓦尔定理支撑的。pn0是65*1的矩阵。

滤波

 XFm(:,1) = XX;
   
   
   
   
    
    
    
    1

首先将远端信号频谱赋给XFm，XFm是65*16的矩阵，16就是前面初始化的M值，这里将XX给第一列，其2~16列对应的是之前的输入频谱。

    for mm=0:(M-1)
        m=mm+1;
        YFb(:,m) = XFm(:,m) .* WFb(:,m);
    end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4

YFb，WFb以及XFm都是65*16的矩阵，WFb是自适应滤波器的频谱表示，XFm是原始的speaker数据，上式的意义对应于插图中的 y^ 的频域值，变换到时域后就可以得到 y 的估计值 y^ .

    yfk = sum(YFb,2);
    tmp = [yfk ; flipud(conj(yfk(2:N)))];
    ykt = real(ifft(tmp));
    ykfb = ykt(end-N+1:end);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4

首先yfk是65*1的矩阵，sum求和就是将估计的频谱按行求和，也就是yfk包含了最近16个块的远端频谱估计信息，这样，只要近端麦克采集到的信号里有这16个块包含的远端信号，那么就可以消掉，从这里也可以看出来，容许的延迟差在16*64/16=64ms，也就是说，如果麦克风采集到的speaker信号滞后speaker播放超过64ms，那么这种情况是无法消掉的，当然，延迟差越小越好。
flipud(conj(yfk(2:N))是因为前面计算频谱时利用奈奎斯特定理，也即实数的FFT结果按N/2对称，所以这里为了得到正确的ifft变换结果，先把频谱不全到 fs .
ykfb就是 y^ .后面再看WFb是如何跟新。

误差估计

   ekfb = dk - ykfb;
   
   
   
   
    
    
    
    1

dk是麦克风采集到的信号，ykfb是 y^ ,这样得到的是误差信号，理想情况下，那么得到的误差信号就是需要的人声信号，而完全滤除掉了speaker信号（远端信号）。

    erfb(pos:pos+N-1) = ekfb;
    tmp = fft([zm;ekfb]); % FD version for cancelling part (overlap-save)
    Ek = tmp(1:N+1);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

erfb是近端信号数组长度×1矩阵，存放的是全部样本对应的误差信号，这个保存仅仅是为了plot用的。
然后补了64个零，然后做FFT，Ek是误差信号FFT的结果。

自适应调节

   Ek2 = Ek ./(pn + 0.001); % Normalized error
   
   
   
   
    
    
    
    1

pn是当前帧远端信号功率谱，Ek是误差信号频谱。Ek2是归一化误差频谱。NLMS公式要求。

    absEf = max(abs(Ek2), threshold);
    absEf = ones(N+1,1)*threshold./absEf;
    Ek2 = Ek2.*absEf;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

max的作用是为了防止归一化后误差频谱过小，最终得到的Ek2是一个限幅矩阵，如果该点的值比门限大，则取门限，如果该点的值比门限小，则保持不变。

 mEk = mufb.*Ek2;
   
   
   
   
    
    
    
    1

mufb是步长，对于16000情况，步长取了0.8.NLMS公式。

 PP = conj(XFm).*(ones(M,1) * mEk')';
    tmp = [PP ; flipud(conj(PP(2:N,:)))];
    IFPP = real(ifft(tmp));
    PH = IFPP(1:N,:);
    tmp = fft([PH;zeros(N,M)]);
    FPH = tmp(1:N+1,:);
    WFb = WFb + FPH;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7

PP是将远端信号的共轭乘以误差信号频谱，这一项用于调节步长，NLMS（步长=参考信号×步长×误差）的可变步长就提现在这里。PH是频域到时域的变换值。这和前面频域到时域的变换原理一样。WFb是权中系数的更新。

    if mod(kk, 10*mult) == 0
        WFbEn = sum(real(WFb.*conj(WFb)));
        %WFbEn = sum(abs(WFb));
        [tmp, dIdx] = max(WFbEn);

        WFbD = sum(abs(WFb(:, dIdx)),2);
        %WFbD = WFbD / (mean(WFbD) + 1e-10);
        WFbD = min(max(WFbD, 0.5), 4);
    end
     dIdxV(kk) = dIdx;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10

上述的作用是更新dIdx和dIdxV。这里的更新并不是每一次都更新，一来是为了稳定，而来也是变相的减少计算量，提高实时性。就算是每一次都更新dIdx，WebRTC计算速度评估的结果也是很满意的。WFb是权重向量的频谱表示，WFbEn是权重向量按列求和，得到的是16*1的矩阵。这样得到的是16个块对权重的累加和。这样的区分度比直接累加和要大。
[tmp, dIdx] = max(WFbEn);作用就是找到16个块中权重累加和最大值及其对应的索引。
WFbD首先计算了权重最大那个块dIdx的列，然后将其按行求和，得到的就是65*1矩阵。WFbD不能低于0.5也不能高于4，算法中并未使用到，plot性能分析时用到。
最后把索引值dIdx存放到dIdxV(kk)中，这样每来一帧，就会有一个最大索引值放到dIdxV向量中。

功率谱密度和相关性计算

NLP

这里的NLP不是native language processing，而是Non-linear processing的意思。

        ee = [eo;ekfb];
        eo = ekfb;
        window = wins;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

上述作用是将上次的误差和ekfb组合，其中eo可以理解为error old。eo也确实保存了上一次的误差。window是简单将窗函数赋值。

        tmp = fft(xx.*window);
        xf = tmp(1:N+1);
        tmp = fft(dd.*window);
        df = tmp(1:N+1);
        tmp = fft(ee.*window);
        ef = tmp(1:N+1);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6

上述代码是把xx，dd，ee加窗后做FFT变换，并且取了 fs/2 的频谱部分存放到xf，df以及ef中。加窗的目的是为了减小频谱泄露，提高谱分辨率。

        xfwm(:,1) = xf;
        xf = xfwm(:,dIdx);
        %fprintf(1,'%d: %f\n', kk, xf(4));
        dfm(:,1) = df;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4

将xf存放到xfwm的第一列，xfwm是65*16的矩阵，df做类似处理。
然后把dIdx指向的那一列传给xf，dIdx是之前计算的权重矩阵能量最大的那块的索引，这样从xfwm矩阵里把真正要处理近端信号对应的远端信号（speaker，参考信号）获取到。

        Se = gamma*Se + (1-gamma)*real(ef.*conj(ef));
        Sd = gamma*Sd + (1-gamma)*real(df.*conj(df));
        Sx = gamma*Sx + (1 - gamma)*real(xf.*conj(xf));
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

计算ef，df和xf的平滑功率谱，gamma这里取值是0.92.相对于8k信号取值略大。它们都是65*1的矩阵，包括了直流分量的能力，剩下的64点是 fs/2 及以下的频点能量。

        Sxd = gamma*Sxd + (1 - gamma)*xf.*conj(df);
        Sed = gamma*Sed + (1-gamma)*ef.*conj(df);
   
   
   
   
    
    
    
    1
    
    
    
    2

计算互功率谱，这里计算了远端信号和近端信号功率谱，如果该值较大，则说明它们的相关性较强，说明近端信号采集到了远端信号的概率很大，这时需要进行噪声抑制，同样的如果误差信号和近端信号功率谱较大，则说明估计的 y^ 是比较准的，误差信号里剩余的远端信号较少，需要进行噪声抑制的概率就小。它们也都是65*1矩阵，对应频点的bin。但是上述获得的是绝对值而非相对值，门限设置不容易，需要一个归一化的过程。归一化的过程可以通过求互相关得到。

        cohed = real(Sed.*conj(Sed))./(Se.*Sd + 1e-10);
        cohedAvg(kk) = mean(cohed(echoBandRange));
        cohxd = real(Sxd.*conj(Sxd))./(Sx.*Sd + 1e-10);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

如上，计算误差信号和近端信号的互相关，1e-10是为了防止除0报错。cohed越大，表示回声越小，cohxd越大，表示回声越大，这里就可以设置一个统一的门限评判上下限了。

cohedMean = mean(cohed(echoBandRange));
   
   
   
   
    
    
    
    1

计算设置的echoBandRange里频点的均值，如果echoBandRange设置的过大，则低音部分如鼓点声则不易消掉。

        hnled = min(1 - cohxd, cohed);
   
   
   
   
    
    
    
    1

这里的作用就是把最小值赋值给hnled，该值越大，则说明越不需要消回声。之所以取二者判断，是为了最大可能性的消除掉回声。

        [hnlSort,   hnlSortIdx] = sort(1-cohxd(echoBandRange));
        [xSort, xSortIdx] = sort(Sx);
   
   
   
   
    
    
    
    1
    
    
    
    2

对1-cohxd（echoBandRange）进行升序排序，同样对Sx也进行升序排序。

hnlSortQ = mean(1 - cohxd(echoBandRange));
   
   
   
   
    
    
    
    1

对远端和近端信号的带内互相关求均值。hnlSortQ表示远端和近端不相关性的平均值，其值越大约没有回声，与cohed含义一致。

 [hnlSort2, hnlSortIdx2] = sort(hnled(echoBandRange));
   
   
   
   
    
    
    
    1

对hnled进行升序排序。

        hnlQuant = 0.75;
        hnlQuantLow = 0.5;
        qIdx = floor(hnlQuant*length(hnlSort2));
        qIdxLow = floor(hnlQuantLow*length(hnlSort2));
        hnlPrefAvg = hnlSort2(qIdx);
        hnlPrefAvgLow = hnlSort2(qIdxLow);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6

这里主要取了两个值，一个值取在了排序后的3/4处，一个值取在了排序后的1/2处。

            if cohedMean > 0.98 & hnlSortQ > 0.9
                suppState = 0;
            elseif cohedMean < 0.95 | hnlSortQ < 0.8
                suppState = 1;
            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5

如果误差和近端信号的互相关均值大于0.98，且远端和近端频带内的互不相关大于0.9，则说明不需要进行回声抑制，将suppState标志设置成0，如果误差和近端信号小于0.95或者远端和近端频带内信号不相关性小于0.8则需要进行印制，在这个范围之外的，回声抑制标志保持前一帧的状态。

            if hnlSortQ < cohxdLocalMin & hnlSortQ < 0.75
                cohxdLocalMin = hnlSortQ;
            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

cohxdLocalMin的初始值是1，表示远端和近端完全不相关，这里判断计算得到的远端近端不相关性是否小于前一次的不相关性，如果小于且不相关性小于0.75，则更新cohxdLocalMin。

            if cohxdLocalMin == 1
                ovrd = 3;
                hnled = 1-cohxd;
                hnlPrefAvg = hnlSortQ;
                hnlPrefAvgLow = hnlSortQ;
            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6

如果cohxdLocalMin=1，则说明要么是发现远端和近端完全不相关，要么就是cohxdLocalMin一直没有更新，既然不相关性很大，那么也说明有回声的可能性小，那么使用较小的ovrd（over-driven）值，和较大的hnled（65*1）值。

            if suppState == 0
                hnled = cohed;
                hnlPrefAvg = cohedMean;
                hnlPrefAvgLow = cohedMean;
            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5

如果suppState==0，则说明不需要进行回声消除，直接用误差近端相关性修正误差信号，hnl的两个均值读取cohed的均值，在这种情况下hnled的值接近于1.

            if hnlPrefAvgLow < hnlLocalMin & hnlPrefAvgLow < 0.6
                hnlLocalMin = hnlPrefAvgLow;
                hnlMin = hnlPrefAvgLow;
                hnlNewMin = 1;
                hnlMinCtr = 0;
                if hnlMinCtr == 0
                    hnlMinCtr = hnlMinCtr + 1;
                else
                    hnlMinCtr = 0;
                    hnlMin = hnlLocalMin;
                    SeLocalMin = SeQ;
                    SdLocalMin = SdQ;
                    SeLocalAvg = 0;
                    minCtr = 0;
                    ovrd = max(log(0.0001)/log(hnlMin), 2);
                    divergeFact = hnlLocalMin;
                end
            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10
    
    
    
    11
    
    
    
    12
    
    
    
    13
    
    
    
    14
    
    
    
    15
    
    
    
    16
    
    
    
    17
    
    
    
    18

hnlLocalMin是hnl系数的最小值，在满足这条判断的情况下发现了更小的值，需要对其进行更新，同时表标志设置成1，计数清0，这种情况下回声的概率较大，所以把ovrd设大以增强抑制能力。

            if hnlMinCtr == 2
                hnlNewMin = 0;
                hnlMinCtr = 0;
                ovrd = max(log(0.00000001)/(log(hnlMin + 1e-10) + 1e-10), 5);

            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6

hnlMinCtr==2，说明之前有满足<0.6的块使得hnlMinCtr=2，然后其下一块又没有满足<0.6的条件，进而更新了ovrd值。默认是和3比较取最大值，这里调节成5是为了增加抑制效果，实际情况还需要针对系统调试。

            hnlLocalMin = min(hnlLocalMin + 0.0008/mult, 1);
            cohxdLocalMin = min(cohxdLocalMin + 0.0004/mult, 1);
   
   
   
   
    
    
    
    1
    
    
    
    2

跟新上述两个值，mult是 fs/8000 ,对于16kHz，就是2.就是0.0004和0.0002的差异。

            if ovrd < ovrdSm
                ovrdSm = 0.99*ovrdSm + 0.01*ovrd;
            else
                ovrdSm = 0.9*ovrdSm + 0.1*ovrd;
            end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5

平滑更新ovrdSm，上述结果倾向于保持ovrdSm是一个较大的值，这个较大的值是为了尽量抑制回声。

        ekEn = sum(Se);
        dkEn = sum(Sd);
   
   
   
   
    
    
    
    1
    
    
    
    2

按行求和，物理意义分别是误差能量和近端信号能量。

发散处理

 if divergeState == 0
            if ekEn > dkEn
                ef = df;
                divergeState = 1;
            end
        else
            if ekEn*1.05 < dkEn
                divergeState = 0;
            else
                ef = df;
            end
        end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10
    
    
    
    11
    
    
    
    12

如果不进行发散处理，误差能量大于近端能力，则用近端频谱更新误差频谱并把发散状态设置成1，如果误差能量的1.05倍小于近端能量，则发散处理标志设置成0.

        if ekEn > dkEn*19.95
            WFb=zeros(N+1,M); % Block-based FD NLMS
        end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

如果误差能量大于近端能量×19.95则，将权重系数矩阵设置成0.

        ekEnV(kk) = ekEn;
        dkEnV(kk) = dkEn;
   
   
   
   
    
    
    
    1
    
    
    
    2

相应能量存放在相应的向量中。

        hnlLocalMinV(kk) = hnlLocalMin;
        cohxdLocalMinV(kk) = cohxdLocalMin;
        hnlMinV(kk) = hnlMin;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3

上述三个向量保存对应值。

平滑滤波器系数和抑制指数

        wCurve = [0; aggrFact*sqrt(linspace(0,1,N))' + 0.1];
   
   
   
   
    
    
    
    1

权重系数曲线生成，线性均匀分布。

    hnled = weight.*min(hnlPrefAvg, hnled) + (1 - weight).*hnled;
   
   
   
   
    
    
    
    1

使用权重平滑hnled，wCurve分布是让65点中频率越高的点本次hnled占的比重越大，反之则以前的平滑结果所占比重大。

od = ovrdSm*(sqrt(linspace(0,1,N+1))' + 1);
   
   
   
   
    
    
    
    1

产生65*1的曲线，用作更新hnled的幂指数。

      hnled = hnled.^(od.*sshift);
   
   
   
   
    
    
    
    1

od作为幂指数跟新hnled。

输出回声消除后的信号

 hnl = hnled;
 ef = ef.*(hnl);
   
   
   
   
    
    
    
    1
    
    
    
    2

用hnl系数与误差频谱相乘，即频域卷积，就是将误差信号通过了传递函数为hnnl的滤波器。

        ovrdV(kk) = ovrdSm;
        hnledAvg(kk) = 1-mean(1-cohed(echoBandRange));
        hnlxdAvg(kk) = 1-mean(cohxd(echoBandRange));
        hnlSortQV(kk) = hnlPrefAvgLow;
        hnlPrefAvgV(kk) = hnlPrefAvg;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5

相关值的暂存
没有开启舒适噪声产生，则Fmix=ef。

    % Overlap and add in time domain for smoothness
    tmp = [Fmix ; flipud(conj(Fmix(2:N)))];
    mixw = wins.*real(ifft(tmp));
    mola = mbuf(end-N+1:end) + mixw(1:N);
    mbuf = mixw;
    ercn(pos:pos+N-1) = mola;
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6

则使用重叠想加法获得时域平滑信号。

    XFm(:,2:end) = XFm(:,1:end-1);
    YFm(:,2:end) = YFm(:,1:end-1);
    xfwm(:,2:end) = xfwm(:,1:end-1);
    dfm(:,2:end) = dfm(:,1:end-1);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4

全体后移一个块，进入下一块迭代。
执行完了之后，如果想听回声消除后信号的声音，使用如下命令：
sound(10*ercn,16000)
其中16000是输入信号的频率。

整体的Matlab代码如下：

% Partitioned block frequency domain adaptive filtering NLMS and
% standard time-domain sample-based NLMS
%near is micphone captured signal
fid=fopen('near.pcm', 'rb'); % Load far end
ssin=fread(fid,inf,'float32');
fclose(fid);
%far is speaker played music
fid=fopen('far.pcm', 'rb'); % Load fnear end
rrin=fread(fid,inf,'float32');
fclose(fid);

rand('state',13);
fs=16000;
mult=fs/8000;
if fs == 8000
cohRange = 2:3;
elseif fs==16000
cohRange = 2;
end

% Flags
NLPon=1; % NLP on
CNon=0; % Comfort noise on
PLTon=0; % Plotting on

M = 16; % Number of partitions
N = 64; % Partition length
L = M*N; % Filter length
if fs == 8000
    mufb = 0.6;
else
    mufb = 0.8;
end
VADtd=48;
alp = 0.15; % Power estimation factor 
alc = 0.1; % Coherence estimation factor
beta = 0.9; % Plotting factor
%% Changed a little %%
step = 0.1875;%0.1875; % Downward step size
%%
if fs == 8000
    threshold=2e-6; % DTrob threshold
else
    %threshold=0.7e-6;
    threshold=1.5e-6; 
end

if fs == 8000
    echoBandRange = ceil(300*2/fs*N):floor(1800*2/fs*N);
else
    echoBandRange = ceil(60*2/fs*N):floor(1500*2/fs*N);
end
suppState = 1;
transCtr = 0;

Nt=1;
vt=1;

ramp = 1.0003; % Upward ramp
rampd = 0.999; % Downward ramp
cvt = 20; % Subband VAD threshold;
nnthres = 20; % Noise threshold

shh=logspace(-1.3,-2.2,N+1)';
sh=[shh;flipud(shh(2:end-1))]; % Suppression profile

len=length(ssin);
w=zeros(L,1); % Sample-based TD(time domain) NLMS
WFb=zeros(N+1,M); % Block-based FD(frequency domain) NLMS
WFbOld=zeros(N+1,M); % Block-based FD NLMS
YFb=zeros(N+1,M);
erfb=zeros(len,1);
erfb3=zeros(len,1);

ercn=zeros(len,1);
zm=zeros(N,1);
XFm=zeros(N+1,M);
YFm=zeros(N+1,M);
pn0=10*ones(N+1,1);
pn=zeros(N+1,1);
NN=len;
Nb=floor(NN/N)-M;
erifb=zeros(Nb+1,1)+0.1;
erifb3=zeros(Nb+1,1)+0.1;
ericn=zeros(Nb+1,1)+0.1;
dri=zeros(Nb+1,1)+0.1;
start=1;
xo=zeros(N,1);
do=xo;
eo=xo;

echoBands=zeros(Nb+1,1);
cohxdAvg=zeros(Nb+1,1);
cohxdSlow=zeros(Nb+1,N+1);
cohedSlow=zeros(Nb+1,N+1);
%overdriveM=zeros(Nb+1,N+1);
cohxdFastAvg=zeros(Nb+1,1);
cohxdAvgBad=zeros(Nb+1,1);
cohedAvg=zeros(Nb+1,1);
cohedFastAvg=zeros(Nb+1,1);
hnledAvg=zeros(Nb+1,1);
hnlxdAvg=zeros(Nb+1,1);
ovrdV=zeros(Nb+1,1);
dIdxV=zeros(Nb+1,1);
SLxV=zeros(Nb+1,1);
hnlSortQV=zeros(Nb+1,1);
hnlPrefAvgV=zeros(Nb+1,1);
mutInfAvg=zeros(Nb+1,1);
%overdrive=zeros(Nb+1,1);
hnled = zeros(N+1, 1);
weight=zeros(N+1,1);
hnlMax = zeros(N+1, 1);
hnl = zeros(N+1, 1);
overdrive = ones(1, N+1);
xfwm=zeros(N+1,M);
dfm=zeros(N+1,M);
WFbD=ones(N+1,1);

fbSupp = 0;
hnlLocalMin = 1;
cohxdLocalMin = 1;
hnlLocalMinV=zeros(Nb+1,1);
cohxdLocalMinV=zeros(Nb+1,1);
hnlMinV=zeros(Nb+1,1);
dkEnV=zeros(Nb+1,1);
ekEnV=zeros(Nb+1,1);
ovrd = 2;
ovrdPos = floor((N+1)/4);
ovrdSm = 2;
hnlMin = 1;
minCtr = 0;
SeMin = 0;
SdMin = 0;
SeLocalAvg = 0;
SeMinSm = 0;
divergeFact = 1;
dIdx = 1;
hnlMinCtr = 0;
hnlNewMin = 0;
divergeState = 0;

Sy=ones(N+1,1);
Sym=1e7*ones(N+1,1);

wins=[0;sqrt(hanning(2*N-1))];
ubufn=zeros(2*N,1);
ebuf=zeros(2*N,1);
ebuf2=zeros(2*N,1);
ebuf4=zeros(2*N,1);
mbuf=zeros(2*N,1);

cohedFast = zeros(N+1,1);
cohxdFast = zeros(N+1,1);
cohxd = zeros(N+1,1);
Se = zeros(N+1,1);
Sd = zeros(N+1,1);
Sx = zeros(N+1,1);
SxBad = zeros(N+1,1);
Sed = zeros(N+1,1);
Sxd = zeros(N+1,1);
SxdBad = zeros(N+1,1);
hnledp=[];

cohxdMax = 0;

hh=waitbar(0,'Please wait...');
%progressbar(0);

%spaces = ' ';
%spaces = repmat(spaces, 50, 1);
%spaces = ['[' ; spaces ; ']'];
%fprintf(1, spaces);
%fprintf(1, '\n');

for kk=1:Nb
    pos = N * (kk-1) + start;

    % FD block method
    % ---------------------- Organize data

    %far is speaker played music
    xk = rrin(pos:pos+N-1);
    %near is micphone captured signal
    dk = ssin(pos:pos+N-1);

    %----------------------- far end signal process
    xx = [xo;xk];
    xo = xk;
    tmp = fft(xx);
    XX = tmp(1:N+1);

    dd = [do;dk]; % Overlap
    do = dk;
    tmp = fft(dd); % Frequency domain
    DD = tmp(1:N+1);

    % ------------------------far end Power estimation
    pn0 = (1 - alp) * pn0 + alp * real(XX.* conj(XX));
    pn = pn0;
%   pn = (1 - alp) * pn + alp * M * pn0;

    % ---------------------- Filtering
    XFm(:,1) = XX;
    for mm=0:(M-1)
        m=mm+1;
        YFb(:,m) = XFm(:,m) .* WFb(:,m);
    end
    yfk = sum(YFb,2);
    tmp = [yfk ; flipud(conj(yfk(2:N)))];
    ykt = real(ifft(tmp));
    ykfb = ykt(end-N+1:end);

    % ---------------------- Error estimation
    ekfb = dk - ykfb;
    %if sum(abs(ekfb)) < sum(abs(dk))
        %ekfb = dk - ykfb;
    % erfb(pos:pos+N-1) = ekfb;
    %else
        %ekfb = dk;
    % erfb(pos:pos+N-1) = dk;
    %end
%(kk-1)*(N*2)+1
    erfb(pos:pos+N-1) = ekfb;
    tmp = fft([zm;ekfb]); % FD version for cancelling part (overlap-save)
    Ek = tmp(1:N+1);

    % ------------------------ Adaptation
    %Ek2 = Ek ./(M*pn + 0.001); % Normalized error
    Ek2 = Ek ./(pn + 0.001); % Normalized error

    absEf = max(abs(Ek2), threshold);
    absEf = ones(N+1,1)*threshold./absEf;
    Ek2 = Ek2.*absEf;

    mEk = mufb.*Ek2;
    PP = conj(XFm).*(ones(M,1) * mEk')';
    tmp = [PP ; flipud(conj(PP(2:N,:)))];
    IFPP = real(ifft(tmp));
    PH = IFPP(1:N,:);
    tmp = fft([PH;zeros(N,M)]);
    FPH = tmp(1:N+1,:);
    WFb = WFb + FPH;

%     if mod(kk, 10*mult) == 0
        WFbEn = sum(real(WFb.*conj(WFb)));
        %WFbEn = sum(abs(WFb));
        [tmp, dIdx] = max(WFbEn);

        WFbD = sum(abs(WFb(:, dIdx)),2);
        %WFbD = WFbD / (mean(WFbD) + 1e-10);
        WFbD = min(max(WFbD, 0.5), 4);
%     end
    dIdxV(kk) = dIdx;

    % NLP
    if (NLPon)  
        ee = [eo;ekfb];
        eo = ekfb;
        window = wins;
        if fs == 8000
            gamma = 0.9;
        else
        gamma = 0.93;
        end

        tmp = fft(xx.*window);
        xf = tmp(1:N+1);
        tmp = fft(dd.*window);
        df = tmp(1:N+1);
        tmp = fft(ee.*window);
        ef = tmp(1:N+1);

        xfwm(:,1) = xf;
        xf = xfwm(:,dIdx);
        %fprintf(1,'%d: %f\n', kk, xf(4));
        dfm(:,1) = df;

        SxOld = Sx;

        Se = gamma*Se + (1-gamma)*real(ef.*conj(ef));
        Sd = gamma*Sd + (1-gamma)*real(df.*conj(df));
        Sx = gamma*Sx + (1 - gamma)*real(xf.*conj(xf));

        %xRatio = real(xfwm(:,1).*conj(xfwm(:,1))) ./ ...
        % (real(xfwm(:,2).*conj(xfwm(:,2))) + 1e-10);
        %xRatio = Sx ./ (SxOld + 1e-10);
        %SLx = log(1/(N+1)*sum(xRatio)) - 1/(N+1)*sum(log(xRatio));
        %SLxV(kk) = SLx;

%         freqSm = 0.9;
%         Sx = filter(freqSm, [1 -(1-freqSm)], Sx);
%         Sx(end:1) = filter(freqSm, [1 -(1-freqSm)], Sx(end:1));
%         Se = filter(freqSm, [1 -(1-freqSm)], Se);
%         Se(end:1) = filter(freqSm, [1 -(1-freqSm)], Se(end:1));
%         Sd = filter(freqSm, [1 -(1-freqSm)], Sd);
%         Sd(end:1) = filter(freqSm, [1 -(1-freqSm)], Sd(end:1));

        %SeFast = ef.*conj(ef);
        %SdFast = df.*conj(df);
        %SxFast = xf.*conj(xf);
        %cohedFast = 0.9*cohedFast + 0.1*SeFast ./ (SdFast + 1e-10);
        %cohedFast(find(cohedFast > 1)) = 1;
        %cohedFast(find(cohedFast > 1)) = 1 ./ cohedFast(find(cohedFast>1));
        %cohedFastAvg(kk) = mean(cohedFast(echoBandRange));
        %cohedFastAvg(kk) = min(cohedFast);

        %cohxdFast = 0.8*cohxdFast + 0.2*log(SdFast ./ (SxFast + 1e-10));
        %cohxdFastAvg(kk) = mean(cohxdFast(echoBandRange));

        % coherence
        Sxd = gamma*Sxd + (1 - gamma)*xf.*conj(df);
        Sed = gamma*Sed + (1-gamma)*ef.*conj(df);

%         Sxd = filter(freqSm, [1 -(1-freqSm)], Sxd);
%         Sxd(end:1) = filter(freqSm, [1 -(1-freqSm)], Sxd(end:1));
%         Sed = filter(freqSm, [1 -(1-freqSm)], Sed);
%         Sed(end:1) = filter(freqSm, [1 -(1-freqSm)], Sed(end:1));

        cohed = real(Sed.*conj(Sed))./(Se.*Sd + 1e-10);
        cohedAvg(kk) = mean(cohed(echoBandRange));
        %cohedAvg(kk) = cohed(6);
        %cohedAvg(kk) = min(cohed);

        cohxd = real(Sxd.*conj(Sxd))./(Sx.*Sd + 1e-10);
        freqSm = 0.6;
        cohxd(2:end) = filter(freqSm, [1 -(1-freqSm)], cohxd(2:end));
        cohxd(end:2) = filter(freqSm, [1 -(1-freqSm)], cohxd(end:2));
        cohxdAvg(kk) = mean(cohxd(echoBandRange));
        %cohxdAvg(kk) = (cohxd(32));
        %cohxdAvg(kk) = max(cohxd);

        %xf = xfm(:,dIdx);
        %SxBad = gamma*SxBad + (1 - gamma)*real(xf.*conj(xf));
        %SxdBad = gamma*SxdBad + (1 - gamma)*xf.*conj(df);
        %cohxdBad = real(SxdBad.*conj(SxdBad))./(SxBad.*Sd + 0.01);
        %cohxdAvgBad(kk) = mean(cohxdBad);

        %for j=1:N+1
        % mutInf(j) = 0.9*mutInf(j) + 0.1*information(abs(xfm(j,:)), abs(dfm(j,:)));
        %end
        %mutInfAvg(kk) = mean(mutInf);

        %hnled = cohedFast;
        %xIdx = find(cohxd > 1 - cohed);
        %hnled(xIdx) = 1 - cohxd(xIdx);
        %hnled = 1 - max(cohxd, 1-cohedFast);
        hnled = min(1 - cohxd, cohed);
        %hnled = 1 - cohxd;
        %hnled = max(1 - (cohxd + (1-cohedFast)), 0);
        %hnled = 1 - max(cohxd, 1-cohed);

        if kk > 1
            cohxdSlow(kk,:) = 0.99*cohxdSlow(kk-1,:) + 0.01*cohxd';
            cohedSlow(kk,:) = 0.99*cohedSlow(kk-1,:) + 0.01*(1-cohed)';
        end


        if 0
        %if kk > 50
            %idx = find(hnled > 0.3);
            hnlMax = hnlMax*0.9999;
            %hnlMax(idx) = max(hnlMax(idx), hnled(idx));
            hnlMax = max(hnlMax, hnled);
            %overdrive(idx) = max(log(hnlMax(idx))/log(0.99), 1);
            avgHnl = mean(hnlMax(echoBandRange));
            if avgHnl > 0.3
                overdrive = max(log(avgHnl)/log(0.99), 1);
            end
            weight(4:end) = max(hnlMax) - hnlMax(4:end);
        end



        %[hg, gidx] = max(hnled);
        %fnrg = Sx(gidx) / (Sd(gidx) + 1e-10);

        %[tmp, bidx] = find((Sx / Sd + 1e-10) > fnrg);
        %hnled(bidx) = hg;


        %cohed1 = mean(cohed(cohRange)); % range depends on bandwidth
        %cohed1 = cohed1^2;
        %echoBands(kk) = length(find(cohed(echoBandRange) < 0.25))/length(echoBandRange);

        %if (fbSupp == 0)
        % if (echoBands(kk) > 0.8)
        % fbSupp = 1;
        % end
        %else
        % if (echoBands(kk) < 0.6)
        % fbSupp = 0;
        % end
        %end
        %overdrive(kk) = 7.5*echoBands(kk) + 0.5;

% Factor by which to weight other bands
%if (cohed1 < 0.1)
% w = 0.8 - cohed1*10*0.4;
%else
% w = 0.4;
%end

% Weight coherence subbands
%hnled = w*cohed1 + (1 - w)*cohed;
%hnled = (hnled).^2;
%cohed(floor(N/2):end) = cohed(floor(N/2):end).^2;
        %if fbSupp == 1
        % cohed = zeros(size(cohed));
        %end
        %cohed = cohed.^overdrive(kk);

        %hnled = gamma*hnled + (1 - gamma)*cohed;
% Additional hf suppression
%hnledp = [hnledp ; mean(hnled)];
%hnled(floor(N/2):end) = hnled(floor(N/2):end).^2;
%ef = ef.*((weight*(min(1 - hnled)).^2 + (1 - weight).*(1 - hnled)).^2);

        cohedMean = mean(cohed(echoBandRange));
        %aggrFact = 4*(1-mean(hnled(echoBandRange))) + 1;
        %[hnlSort, hnlSortIdx] = sort(hnled(echoBandRange));
        [hnlSort,   hnlSortIdx] = sort(1-cohxd(echoBandRange));
        [xSort, xSortIdx] = sort(Sx);
        %aggrFact = (1-mean(hnled(echoBandRange)));
        %hnlSortQ = hnlSort(qIdx);
        hnlSortQ = mean(1 - cohxd(echoBandRange));
        %hnlSortQ = mean(1 - cohxd);

        [hnlSort2, hnlSortIdx2] = sort(hnled(echoBandRange));
        %[hnlSort2, hnlSortIdx2] = sort(hnled);
        hnlQuant = 0.75;
        hnlQuantLow = 0.5;
        qIdx = floor(hnlQuant*length(hnlSort2));
        qIdxLow = floor(hnlQuantLow*length(hnlSort2));
        hnlPrefAvg = hnlSort2(qIdx);
        hnlPrefAvgLow = hnlSort2(qIdxLow);
        %hnlPrefAvgLow = mean(hnled);
        %hnlPrefAvg = max(hnlSort2);
        %hnlPrefAvgLow = min(hnlSort2);

        %hnlPref = hnled(echoBandRange);
        %hnlPrefAvg = mean(hnlPref(xSortIdx((0.5*length(xSortIdx)):end)));

        %hnlPrefAvg = min(hnlPrefAvg, hnlSortQ);

        %hnlSortQIdx = hnlSortIdx(qIdx);
        %SeQ = Se(qIdx + echoBandRange(1) - 1);
        %SdQ = Sd(qIdx + echoBandRange(1) - 1);
        %SeQ = Se(qIdxLow + echoBandRange(1) - 1);
        %SdQ = Sd(qIdxLow + echoBandRange(1) - 1);
        %propLow = length(find(hnlSort < 0.1))/length(hnlSort);
        %aggrFact = min((1 - hnlSortQ)/2, 0.5);
        %aggrTerm = 1/aggrFact;

        %hnlg = mean(hnled(echoBandRange));
        %hnlg = hnlSortQ;
        %if suppState == 0
        % if hnlg < 0.05
        % suppState = 2;
        % transCtr = 0;
        % elseif hnlg < 0.75
        % suppState = 1;
        % transCtr = 0;
        % end
        %elseif suppState == 1
        % if hnlg > 0.8
        % suppState = 0;
        % transCtr = 0;
        % elseif hnlg < 0.05
        % suppState = 2;
        % transCtr = 0;
        % end
        %else
        % if hnlg > 0.8
        % suppState = 0;
        % transCtr = 0;
        % elseif hnlg > 0.25
        % suppState = 1;
        % transCtr = 0;
        % end
        %end
        %if kk > 50

            if cohedMean > 0.98 & hnlSortQ > 0.9
                %if suppState == 1
                % hnled = 0.5*hnled + 0.5*cohed;
                % %hnlSortQ = 0.5*hnlSortQ + 0.5*cohedMean;
                % hnlPrefAvg = 0.5*hnlPrefAvg + 0.5*cohedMean;
                %else
                % hnled = cohed;
                % %hnlSortQ = cohedMean;
                % hnlPrefAvg = cohedMean;
                %end
                suppState = 0;
            elseif cohedMean < 0.95 | hnlSortQ < 0.8
                %if suppState == 0
                % hnled = 0.5*hnled + 0.5*cohed;
                % %hnlSortQ = 0.5*hnlSortQ + 0.5*cohedMean;
                % hnlPrefAvg = 0.5*hnlPrefAvg + 0.5*cohedMean;
                %end
                suppState = 1;
            end

            if hnlSortQ < cohxdLocalMin & hnlSortQ < 0.75
                cohxdLocalMin = hnlSortQ;
            end

            if cohxdLocalMin == 1
                ovrd = 3;
                hnled = 1-cohxd;
                hnlPrefAvg = hnlSortQ;
                hnlPrefAvgLow = hnlSortQ;
            end

            if suppState == 0
                hnled = cohed;
                hnlPrefAvg = cohedMean;
                hnlPrefAvgLow = cohedMean;
            end

            %if hnlPrefAvg < hnlLocalMin & hnlPrefAvg < 0.6
            if hnlPrefAvgLow < hnlLocalMin & hnlPrefAvgLow < 0.6
                %hnlLocalMin = hnlPrefAvg;
                %hnlMin = hnlPrefAvg;
                hnlLocalMin = hnlPrefAvgLow;
                hnlMin = hnlPrefAvgLow;
                hnlNewMin = 1;
                hnlMinCtr = 0;
                if hnlMinCtr == 0
                    hnlMinCtr = hnlMinCtr + 1;
                else
                    hnlMinCtr = 0;
                    hnlMin = hnlLocalMin;
                    SeLocalMin = SeQ;
                    SdLocalMin = SdQ;
                    SeLocalAvg = 0;
                    minCtr = 0;
                    ovrd = max(log(0.0001)/log(hnlMin), 2);
                    divergeFact = hnlLocalMin;
                end
            end

            if hnlNewMin == 1
                hnlMinCtr = hnlMinCtr + 1;
            end
            if hnlMinCtr == 2
                hnlNewMin = 0;
                hnlMinCtr = 0;
                %ovrd = max(log(0.0001)/log(hnlMin), 2);
%                 ovrd = max(log(0.00001)/(log(hnlMin + 1e-10) + 1e-10), 3);
                ovrd = max(log(0.00000001)/(log(hnlMin + 1e-10) + 1e-10), 5);
                %ovrd = max(log(0.0001)/log(hnlPrefAvg), 2);
                %ovrd = max(log(0.001)/log(hnlMin), 2);
            end
            hnlLocalMin = min(hnlLocalMin + 0.0008/mult, 1);
            cohxdLocalMin = min(cohxdLocalMin + 0.0004/mult, 1);
            %divergeFact = hnlSortQ;


            %if minCtr > 0 & hnlLocalMin < 1
            % hnlMin = hnlLocalMin;
            % %SeMin = 0.9*SeMin + 0.1*sqrt(SeLocalMin);
            % SdMin = sqrt(SdLocalMin);
            % %SeMin = sqrt(SeLocalMin)*hnlSortQ;
            % SeMin = sqrt(SeLocalMin);
            % %ovrd = log(100/SeMin)/log(hnlSortQ);
            % %ovrd = log(100/SeMin)/log(hnlSortQ);
            % ovrd = log(0.01)/log(hnlMin);
            % ovrd = max(ovrd, 2);
            % ovrdPos = hnlSortQIdx;
            % %ovrd = max(ovrd, 1);
            % %SeMin = sqrt(SeLocalAvg/5);
            % minCtr = 0;
            %else
            % %SeLocalMin = 0.9*SeLocalMin +0.1*SeQ;
            % SeLocalAvg = SeLocalAvg + SeQ;
            % minCtr = minCtr + 1;
            %end

            if ovrd < ovrdSm
                ovrdSm = 0.99*ovrdSm + 0.01*ovrd;
            else
                ovrdSm = 0.9*ovrdSm + 0.1*ovrd;
            end
        %end

%         ekEn = sum(real(ekfb.^2));
%         dkEn = sum(real(dk.^2));
        ekEn = sum(Se);
        dkEn = sum(Sd);

        if divergeState == 0
            if ekEn > dkEn
                ef = df;
                divergeState = 1;
                %hnlPrefAvg = hnlSortQ;
                %hnled = (1 - cohxd);
            end
        else
            %if ekEn*1.1 < dkEn
            %if ekEn*1.26 < dkEn
            if ekEn*1.05 < dkEn
                divergeState = 0;
            else
                ef = df;
            end
        end

        if ekEn > dkEn*19.95
            WFb=zeros(N+1,M); % Block-based FD NLMS
        end

        ekEnV(kk) = ekEn;
        dkEnV(kk) = dkEn;

        hnlLocalMinV(kk) = hnlLocalMin;
        cohxdLocalMinV(kk) = cohxdLocalMin;
        hnlMinV(kk) = hnlMin;
        %cohxdMaxLocal = max(cohxdSlow(kk,:));
        %if kk > 50
        %cohxdMaxLocal = 1-hnlSortQ;
        %if cohxdMaxLocal > 0.5
        % %if cohxdMaxLocal > cohxdMax
        % odScale = max(log(cohxdMaxLocal)/log(0.95), 1);
        % %overdrive(7:end) = max(log(cohxdSlow(kk,7:end))/log(0.9), 1);
        % cohxdMax = cohxdMaxLocal;
        % end
        %end
        %end
        %cohxdMax = cohxdMax*0.999;

        %overdriveM(kk,:) = max(overdrive, 1);
        %aggrFact = 0.25;
        aggrFact = 0.3;
        %aggrFact = 0.5*propLow;
        %if fs == 8000
        % wCurve = [0 ; 0 ; aggrFact*sqrt(linspace(0,1,N-1))' + 0.1];
        %else
        % wCurve = [0; 0; 0; aggrFact*sqrt(linspace(0,1,N-2))' + 0.1];
        %end
        wCurve = [0; aggrFact*sqrt(linspace(0,1,N))' + 0.1];
        % For sync with C
        %if fs == 8000
        % wCurve = wCurve(2:end);
        %else
        % wCurve = wCurve(1:end-1);
        %end
        %weight = aggrFact*(sqrt(linspace(0,1,N+1)'));
        %weight = aggrFact*wCurve;
        weight = wCurve;
        %weight = aggrFact*ones(N+1,1);
        %weight = zeros(N+1,1);
        %hnled = weight.*min(hnled) + (1 - weight).*hnled;
        %hnled = weight.*min(mean(hnled(echoBandRange)), hnled) + (1 - weight).*hnled;
        %hnled = weight.*min(hnlSortQ, hnled) + (1 - weight).*hnled;

        %hnlSortQV(kk) = mean(hnled);
        %hnlPrefAvgV(kk) = mean(hnled(echoBandRange));

        hnled = weight.*min(hnlPrefAvg, hnled) + (1 - weight).*hnled;

        %od = aggrFact*(sqrt(linspace(0,1,N+1)') + aggrTerm);
        %od = 4*(sqrt(linspace(0,1,N+1)') + 1/4);

        %ovrdFact = (ovrdSm - 1) / sqrt(ovrdPos/(N+1));
        %ovrdFact = ovrdSm / sqrt(echoBandRange(floor(length(echoBandRange)/2))/(N+1));
        %od = ovrdFact*sqrt(linspace(0,1,N+1))' + 1;
        %od = ovrdSm*ones(N+1,1).*abs(WFb(:,dIdx))/(max(abs(WFb(:,dIdx)))+1e-10);

        %od = ovrdSm*ones(N+1,1);
        %od = ovrdSm*WFbD.*(sqrt(linspace(0,1,N+1))' + 1);

        od = ovrdSm*(sqrt(linspace(0,1,N+1))' + 1);
        %od = 4*(sqrt(linspace(0,1,N+1))' + 1);

        %od = 2*ones(N+1,1);
        %od = 2*ones(N+1,1);
        %sshift = ((1-hnled)*2-1).^3+1;
        sshift = ones(N+1,1);

        hnled = hnled.^(od.*sshift);

        %if hnlg > 0.75
            %if (suppState ~= 0)
            % transCtr = 0;
            %end
        % suppState = 0;
        %elseif hnlg < 0.6 & hnlg > 0.2
        % suppState = 1;
        %elseif hnlg < 0.1
            %hnled = zeros(N+1, 1);
            %if (suppState ~= 2)
            % transCtr = 0;
            %end
        % suppState = 2;
        %else
        % if (suppState ~= 2)
        % transCtr = 0;
        % end
        % suppState = 2;
        %end
        %if suppState == 0
        % hnled = ones(N+1, 1);
        %elseif suppState == 2
        % hnled = zeros(N+1, 1);
        %end
        %hnled(find(hnled < 0.1)) = 0;
        %hnled = hnled.^2;
        %if transCtr < 5
            %hnl = 0.75*hnl + 0.25*hnled;
        % transCtr = transCtr + 1;
        %else
            hnl = hnled;
        %end
        %hnled(find(hnled < 0.05)) = 0;
        ef = ef.*(hnl);

        %ef = ef.*(min(1 - cohxd, cohed).^2);
        %ef = ef.*((1-cohxd).^2);

        ovrdV(kk) = ovrdSm;
        %ovrdV(kk) = dIdx;
        %ovrdV(kk) = divergeFact;
        %hnledAvg(kk) = 1-mean(1-cohedFast(echoBandRange));
        hnledAvg(kk) = 1-mean(1-cohed(echoBandRange));
        hnlxdAvg(kk) = 1-mean(cohxd(echoBandRange));
        %hnlxdAvg(kk) = cohxd(5);
        %hnlSortQV(kk) = mean(hnled);
        hnlSortQV(kk) = hnlPrefAvgLow;
        hnlPrefAvgV(kk) = hnlPrefAvg;
        %hnlAvg(kk) = propLow;
        %ef(N/2:end) = 0;
        %ner = (sum(Sd) ./ (sum(Se.*(hnl.^2)) + 1e-10));

        % Comfort noise
        if (CNon)
            snn=sqrt(Sym);
            snn(1)=0; % Reject LF noise
            Un=snn.*exp(j*2*pi.*[0;rand(N-1,1);0]);

            % Weight comfort noise by suppression
            Un = sqrt(1-hnled.^2).*Un;
            Fmix = ef + Un;
        else
            Fmix = ef;
        end

    % Overlap and add in time domain for smoothness
    tmp = [Fmix ; flipud(conj(Fmix(2:N)))];
    mixw = wins.*real(ifft(tmp));
    mola = mbuf(end-N+1:end) + mixw(1:N);
    mbuf = mixw;
    ercn(pos:pos+N-1) = mola;%%%%%-------------you can hear the effect by sound(10*ercn,16000),add by Shichaog
    end % NLPon

    % Filter update
    % Ek2 = Ek ./(12*pn + 0.001); % Normalized error
    %     Ek2 = Ek2 * divergeFact;
    Ek2 = Ek ./(pn + 0.001); % Normalized error
    %Ek2 = Ek ./(100*pn + 0.001); % Normalized error

    %divergeIdx = find(abs(Ek) > abs(DD));
    %divergeIdx = find(Se > Sd);
    %threshMod = threshold*ones(N+1,1);
    %if length(divergeIdx) > 0
    %if sum(abs(Ek)) > sum(abs(DD))
        %WFb(divergeIdx,:) = WFb(divergeIdx,:) .* repmat(sqrt(Sd(divergeIdx)./(Se(divergeIdx)+1e-10))),1,M);
        %Ek2(divergeIdx) = Ek2(divergeIdx) .* sqrt(Sd(divergeIdx)./(Se(divergeIdx)+1e-10));
        %Ek2(divergeIdx) = Ek2(divergeIdx) .* abs(DD(divergeIdx))./(abs(Ek(divergeIdx))+1e-10);
        %WFb(divergeIdx,:) = WFbOld(divergeIdx,:);
        %WFb = WFbOld;
        %threshMod(divergeIdx) = threshMod(divergeIdx) .* abs(DD(divergeIdx))./(abs(Ek(divergeIdx))+1e-10);
    % threshMod(divergeIdx) = threshMod(divergeIdx) .* sqrt(Sd(divergeIdx)./(Se(divergeIdx)+1e-10));
    %end

%absEf = max(abs(Ek2), threshold);
%absEf = ones(N+1,1)*threshold./absEf;
%absEf = max(abs(Ek2), threshMod);
%absEf = threshMod./absEf;
%Ek2 = Ek2.*absEf;

    %if sum(Se) <= sum(Sd)

    % mEk = mufb.*Ek2;
    % PP = conj(XFm).*(ones(M,1) * mEk')';
    % tmp = [PP ; flipud(conj(PP(2:N,:)))];
    % IFPP = real(ifft(tmp));
    % PH = IFPP(1:N,:);
    % tmp = fft([PH;zeros(N,M)]);
    % FPH = tmp(1:N+1,:);
    % %WFbOld = WFb;
    % WFb = WFb + FPH;

    %else
    % WF = WFbOld;
    %end

% Shift old FFTs
    XFm(:,2:end) = XFm(:,1:end-1);
    YFm(:,2:end) = YFm(:,1:end-1);
    xfwm(:,2:end) = xfwm(:,1:end-1);
    dfm(:,2:end) = dfm(:,1:end-1);

%if mod(kk, floor(Nb/50)) == 0
    % fprintf(1, '.');
%end

if mod(kk, floor(Nb/100)) == 0
%if mod(kk, floor(Nb/500)) == 0
        %progressbar(kk/Nb);
        %figure(5)
        %plot(abs(WFb));
        %legend('1','2','3','4','5','6','7','8','9','10','11','12');
        %title(kk*N/fs);
        %figure(6)
        %plot(WFbD);
        %figure(6)
        %plot(threshMod)
        %if length(divergeIdx) > 0
        % plot(abs(DD))
        % hold on
        % plot(abs(Ek), 'r')
        % hold off
            %plot(min(sqrt(Sd./(Se+1e-10)),1))
            %axis([0 N 0 1]);
        %end
        %figure(6)
        %plot(cohedFast);
        %axis([1 N+1 0 1]);
        %plot(WFbEn);

        %figure(7)
        %plot(weight);
        %plot([cohxd 1-cohed]);
        %plot([cohxd 1-cohed 1-cohedFast hnled]);
        %plot([cohxd cohxdFast/max(cohxdFast)]);
        %legend('cohxd', '1-cohed', '1-cohedFast');
        %axis([1 65 0 1]);
        %pause(0.5);
        %overdrive
    end
end
%progressbar(1);

%figure(2);
%plot([feat(:,1) feat(:,2)+1 feat(:,3)+2 mfeat+3]);
%plot([feat(:,1) mfeat+1]);

%figure(3);
%plot(10*log10([dri erifb erifb3 ericn]));
%legend('Near-end','Error','Post NLP','Final',4);
% Compensate for delay
%ercn=[ercn(N+1:end);zeros(N,1)];
%ercn_=[ercn_(N+1:end);zeros(N,1)];

%figure(11);
%plot(cohxdSlow);

%figure(12);
%surf(cohxdSlow);
%shading interp;

%figure(13);
%plot(overdriveM);

%figure(14);
%surf(overdriveM);
%shading interp;

figure(10);
t = (0:Nb)*N/fs;
rrinSubSamp = rrin(N*(1:(Nb+1)));
plot(t, rrinSubSamp/max(abs(rrinSubSamp)),'b');
hold on
plot(t, hnledAvg, 'r');
plot(t, hnlxdAvg, 'g');
plot(t, hnlSortQV, 'y');
plot(t, hnlLocalMinV, 'k');
plot(t, cohxdLocalMinV, 'c');
plot(t, hnlPrefAvgV, 'm');
%plot(t, cohxdAvg, 'r');
%plot(cohxdFastAvg, 'r');
%plot(cohxdAvgBad, 'k');
%plot(t, cohedAvg, 'k');
%plot(t, 1-cohedFastAvg, 'k');
%plot(ssin(N*(1:floor(length(ssin)/N)))/max(abs(ssin)));
%plot(echoBands,'r');
%plot(overdrive, 'g');
%plot(erfb(N*(1:floor(length(erfb)/N)))/max(abs(erfb)));
hold off
%tight x;

% figure(11)
% plot(t, ovrdV);
%tightx;
%plot(mfeat,'r');
%plot(1-cohxyp_,'r');
%plot(Hnlxydp,'y');
%plot(hnledp,'k');
%plot(Hnlxydp, 'c');
%plot(ccohpd_,'k');
%plot(supplot_, 'g');
%plot(ones(length(mfeat),1)*rr1_, 'k');
%plot(ones(length(mfeat),1)*rr2_, 'k');
%plot(N*(1:length(feat)), feat);
%plot(Sep_,'r');
%axis([1 floor(length(erfb)/N) -1 1])
%hold off
%plot(10*log10([Se_, Sx_, Seu_, real(sf_.*conj(sf_))]));
%legend('Se','Sx','Seu','S');
%figure(5)
%plot([ercn ercn_]);

% figure(12)
% plot(t, dIdxV);
%plot(t, SLxV);
%tightx;

%figure(13)
%plot(t, [ekEnV dkEnV]);
%plot(t, dkEnV./(ekEnV+1e-10));
%tightx;

%close(hh);
%spclab(fs,ssin,erfb,ercn,'outxd.pcm');
%spclab(fs,rrin,ssin,erfb,1.78*ercn,'vqeOut-1.pcm');
%spclab(fs,erfb,'aecOutLp.pcm');
%spclab(fs,rrin,ssin,erfb,1.78*ercn,'aecOut25.pcm','vqeOut-1.pcm');
%spclab(fs,rrin,ssin,erfb,ercn,'aecOut-mba.pcm');
%spclab(fs,rrin,ssin,erfb,ercn,'aecOut.pcm');
%spclab(fs, ssin, erfb, ercn, 'out0.pcm');
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10
    
    
    
    11
    
    
    
    12
    
    
    
    13
    
    
    
    14
    
    
    
    15
    
    
    
    16
    
    
    
    17
    
    
    
    18
    
    
    
    19
    
    
    
    20
    
    
    
    21
    
    
    
    22
    
    
    
    23
    
    
    
    24
    
    
    
    25
    
    
    
    26
    
    
    
    27
    
    
    
    28
    
    
    
    29
    
    
    
    30
    
    
    
    31
    
    
    
    32
    
    
    
    33
    
    
    
    34
    
    
    
    35
    
    
    
    36
    
    
    
    37
    
    
    
    38
    
    
    
    39
    
    
    
    40
    
    
    
    41
    
    
    
    42
    
    
    
    43
    
    
    
    44
    
    
    
    45
    
    
    
    46
    
    
    
    47
    
    
    
    48
    
    
    
    49
    
    
    
    50
    
    
    
    51
    
    
    
    52
    
    
    
    53
    
    
    
    54
    
    
    
    55
    
    
    
    56
    
    
    
    57
    
    
    
    58
    
    
    
    59
    
    
    
    60
    
    
    
    61
    
    
    
    62
    
    
    
    63
    
    
    
    64
    
    
    
    65
    
    
    
    66
    
    
    
    67
    
    
    
    68
    
    
    
    69
    
    
    
    70
    
    
    
    71
    
    
    
    72
    
    
    
    73
    
    
    
    74
    
    
    
    75
    
    
    
    76
    
    
    
    77
    
    
    
    78
    
    
    
    79
    
    
    
    80
    
    
    
    81
    
    
    
    82
    
    
    
    83
    
    
    
    84
    
    
    
    85
    
    
    
    86
    
    
    
    87
    
    
    
    88
    
    
    
    89
    
    
    
    90
    
    
    
    91
    
    
    
    92
    
    
    
    93
    
    
    
    94
    
    
    
    95
    
    
    
    96
    
    
    
    97
    
    
    
    98
    
    
    
    99
    
    
    
    100
    
    
    
    101
    
    
    
    102
    
    
    
    103
    
    
    
    104
    
    
    
    105
    
    
    
    106
    
    
    
    107
    
    
    
    108
    
    
    
    109
    
    
    
    110
    
    
    
    111
    
    
    
    112
    
    
    
    113
    
    
    
    114
    
    
    
    115
    
    
    
    116
    
    
    
    117
    
    
    
    118
    
    
    
    119
    
    
    
    120
    
    
    
    121
    
    
    
    122
    
    
    
    123
    
    
    
    124
    
    
    
    125
    
    
    
    126
    
    
    
    127
    
    
    
    128
    
    
    
    129
    
    
    
    130
    
    
    
    131
    
    
    
    132
    
    
    
    133
    
    
    
    134
    
    
    
    135
    
    
    
    136
    
    
    
    137
    
    
    
    138
    
    
    
    139
    
    
    
    140
    
    
    
    141
    
    
    
    142
    
    
    
    143
    
    
    
    144
    
    
    
    145
    
    
    
    146
    
    
    
    147
    
    
    
    148
    
    
    
    149
    
    
    
    150
    
    
    
    151
    
    
    
    152
    
    
    
    153
    
    
    
    154
    
    
    
    155
    
    
    
    156
    
    
    
    157
    
    
    
    158
    
    
    
    159
    
    
    
    160
    
    
    
    161
    
    
    
    162
    
    
    
    163
    
    
    
    164
    
    
    
    165
    
    
    
    166
    
    
    
    167
    
    
    
    168
    
    
    
    169
    
    
    
    170
    
    
    
    171
    
    
    
    172
    
    
    
    173
    
    
    
    174
    
    
    
    175
    
    
    
    176
    
    
    
    177
    
    
    
    178
    
    
    
    179
    
    
    
    180
    
    
    
    181
    
    
    
    182
    
    
    
    183
    
    
    
    184
    
    
    
    185
    
    
    
    186
    
    
    
    187
    
    
    
    188
    
    
    
    189
    
    
    
    190
    
    
    
    191
    
    
    
    192
    
    
    
    193
    
    
    
    194
    
    
    
    195
    
    
    
    196
    
    
    
    197
    
    
    
    198
    
    
    
    199
    
    
    
    200
    
    
    
    201
    
    
    
    202
    
    
    
    203
    
    
    
    204
    
    
    
    205
    
    
    
    206
    
    
    
    207
    
    
    
    208
    
    
    
    209
    
    
    
    210
    
    
    
    211
    
    
    
    212
    
    
    
    213
    
    
    
    214
    
    
    
    215
    
    
    
    216
    
    
    
    217
    
    
    
    218
    
    
    
    219
    
    
    
    220
    
    
    
    221
    
    
    
    222
    
    
    
    223
    
    
    
    224
    
    
    
    225
    
    
    
    226
    
    
    
    227
    
    
    
    228
    
    
    
    229
    
    
    
    230
    
    
    
    231
    
    
    
    232
    
    
    
    233
    
    
    
    234
    
    
    
    235
    
    
    
    236
    
    
    
    237
    
    
    
    238
    
    
    
    239
    
    
    
    240
    
    
    
    241
    
    
    
    242
    
    
    
    243
    
    
    
    244
    
    
    
    245
    
    
    
    246
    
    
    
    247
    
    
    
    248
    
    
    
    249
    
    
    
    250
    
    
    
    251
    
    
    
    252
    
    
    
    253
    
    
    
    254
    
    
    
    255
    
    
    
    256
    
    
    
    257
    
    
    
    258
    
    
    
    259
    
    
    
    260
    
    
    
    261
    
    
    
    262
    
    
    
    263
    
    
    
    264
    
    
    
    265
    
    
    
    266
    
    
    
    267
    
    
    
    268
    
    
    
    269
    
    
    
    270
    
    
    
    271
    
    
    
    272
    
    
    
    273
    
    
    
    274
    
    
    
    275
    
    
    
    276
    
    
    
    277
    
    
    
    278
    
    
    
    279
    
    
    
    280
    
    
    
    281
    
    
    
    282
    
    
    
    283
    
    
    
    284
    
    
    
    285
    
    
    
    286
    
    
    
    287
    
    
    
    288
    
    
    
    289
    
    
    
    290
    
    
    
    291
    
    
    
    292
    
    
    
    293
    
    
    
    294
    
    
    
    295
    
    
    
    296
    
    
    
    297
    
    
    
    298
    
    
    
    299
    
    
    
    300
    
    
    
    301
    
    
    
    302
    
    
    
    303
    
    
    
    304
    
    
    
    305
    
    
    
    306
    
    
    
    307
    
    
    
    308
    
    
    
    309
    
    
    
    310
    
    
    
    311
    
    
    
    312
    
    
    
    313
    
    
    
    314
    
    
    
    315
    
    
    
    316
    
    
    
    317
    
    
    
    318
    
    
    
    319
    
    
    
    320
    
    
    
    321
    
    
    
    322
    
    
    
    323
    
    
    
    324
    
    
    
    325
    
    
    
    326
    
    
    
    327
    
    
    
    328
    
    
    
    329
    
    
    
    330
    
    
    
    331
    
    
    
    332
    
    
    
    333
    
    
    
    334
    
    
    
    335
    
    
    
    336
    
    
    
    337
    
    
    
    338
    
    
    
    339
    
    
    
    340
    
    
    
    341
    
    
    
    342
    
    
    
    343
    
    
    
    344
    
    
    
    345
    
    
    
    346
    
    
    
    347
    
    
    
    348
    
    
    
    349
    
    
    
    350
    
    
    
    351
    
    
    
    352
    
    
    
    353
    
    
    
    354
    
    
    
    355
    
    
    
    356
    
    
    
    357
    
    
    
    358
    
    
    
    359
    
    
    
    360
    
    
    
    361
    
    
    
    362
    
    
    
    363
    
    
    
    364
    
    
    
    365
    
    
    
    366
    
    
    
    367
    
    
    
    368
    
    
    
    369
    
    
    
    370
    
    
    
    371
    
    
    
    372
    
    
    
    373
    
    
    
    374
    
    
    
    375
    
    
    
    376
    
    
    
    377
    
    
    
    378
    
    
    
    379
    
    
    
    380
    
    
    
    381
    
    
    
    382
    
    
    
    383
    
    
    
    384
    
    
    
    385
    
    
    
    386
    
    
    
    387
    
    
    
    388
    
    
    
    389
    
    
    
    390
    
    
    
    391
    
    
    
    392
    
    
    
    393
    
    
    
    394
    
    
    
    395
    
    
    
    396
    
    
    
    397
    
    
    
    398
    
    
    
    399
    
    
    
    400
    
    
    
    401
    
    
    
    402
    
    
    
    403
    
    
    
    404
    
    
    
    405
    
    
    
    406
    
    
    
    407
    
    
    
    408
    
    
    
    409
    
    
    
    410
    
    
    
    411
    
    
    
    412
    
    
    
    413
    
    
    
    414
    
    
    
    415
    
    
    
    416
    
    
    
    417
    
    
    
    418
    
    
    
    419
    
    
    
    420
    
    
    
    421
    
    
    
    422
    
    
    
    423
    
    
    
    424
    
    
    
    425
    
    
    
    426
    
    
    
    427
    
    
    
    428
    
    
    
    429
    
    
    
    430
    
    
    
    431
    
    
    
    432
    
    
    
    433
    
    
    
    434
    
    
    
    435
    
    
    
    436
    
    
    
    437
    
    
    
    438
    
    
    
    439
    
    
    
    440
    
    
    
    441
    
    
    
    442
    
    
    
    443
    
    
    
    444
    
    
    
    445
    
    
    
    446
    
    
    
    447
    
    
    
    448
    
    
    
    449
    
    
    
    450
    
    
    
    451
    
    
    
    452
    
    
    
    453
    
    
    
    454
    
    
    
    455
    
    
    
    456
    
    
    
    457
    
    
    
    458
    
    
    
    459
    
    
    
    460
    
    
    
    461
    
    
    
    462
    
    
    
    463
    
    
    
    464
    
    
    
    465
    
    
    
    466
    
    
    
    467
    
    
    
    468
    
    
    
    469
    
    
    
    470
    
    
    
    471
    
    
    
    472
    
    
    
    473
    
    
    
    474
    
    
    
    475
    
    
    
    476
    
    
    
    477
    
    
    
    478
    
    
    
    479
    
    
    
    480
    
    
    
    481
    
    
    
    482
    
    
    
    483
    
    
    
    484
    
    
    
    485
    
    
    
    486
    
    
    
    487
    
    
    
    488
    
    
    
    489
    
    
    
    490
    
    
    
    491
    
    
    
    492
    
    
    
    493
    
    
    
    494
    
    
    
    495
    
    
    
    496
    
    
    
    497
    
    
    
    498
    
    
    
    499
    
    
    
    500
    
    
    
    501
    
    
    
    502
    
    
    
    503
    
    
    
    504
    
    
    
    505
    
    
    
    506
    
    
    
    507
    
    
    
    508
    
    
    
    509
    
    
    
    510
    
    
    
    511
    
    
    
    512
    
    
    
    513
    
    
    
    514
    
    
    
    515
    
    
    
    516
    
    
    
    517
    
    
    
    518
    
    
    
    519
    
    
    
    520
    
    
    
    521
    
    
    
    522
    
    
    
    523
    
    
    
    524
    
    
    
    525
    
    
    
    526
    
    
    
    527
    
    
    
    528
    
    
    
    529
    
    
    
    530
    
    
    
    531
    
    
    
    532
    
    
    
    533
    
    
    
    534
    
    
    
    535
    
    
    
    536
    
    
    
    537
    
    
    
    538
    
    
    
    539
    
    
    
    540
    
    
    
    541
    
    
    
    542
    
    
    
    543
    
    
    
    544
    
    
    
    545
    
    
    
    546
    
    
    
    547
    
    
    
    548
    
    
    
    549
    
    
    
    550
    
    
    
    551
    
    
    
    552
    
    
    
    553
    
    
    
    554
    
    
    
    555
    
    
    
    556
    
    
    
    557
    
    
    
    558
    
    
    
    559
    
    
    
    560
    
    
    
    561
    
    
    
    562
    
    
    
    563
    
    
    
    564
    
    
    
    565
    
    
    
    566
    
    
    
    567
    
    
    
    568
    
    
    
    569
    
    
    
    570
    
    
    
    571
    
    
    
    572
    
    
    
    573
    
    
    
    574
    
    
    
    575
    
    
    
    576
    
    
    
    577
    
    
    
    578
    
    
    
    579
    
    
    
    580
    
    
    
    581
    
    
    
    582
    
    
    
    583
    
    
    
    584
    
    
    
    585
    
    
    
    586
    
    
    
    587
    
    
    
    588
    
    
    
    589
    
    
    
    590
    
    
    
    591
    
    
    
    592
    
    
    
    593
    
    
    
    594
    
    
    
    595
    
    
    
    596
    
    
    
    597
    
    
    
    598
    
    
    
    599
    
    
    
    600
    
    
    
    601
    
    
    
    602
    
    
    
    603
    
    
    
    604
    
    
    
    605
    
    
    
    606
    
    
    
    607
    
    
    
    608
    
    
    
    609
    
    
    
    610
    
    
    
    611
    
    
    
    612
    
    
    
    613
    
    
    
    614
    
    
    
    615
    
    
    
    616
    
    
    
    617
    
    
    
    618
    
    
    
    619
    
    
    
    620
    
    
    
    621
    
    
    
    622
    
    
    
    623
    
    
    
    624
    
    
    
    625
    
    
    
    626
    
    
    
    627
    
    
    
    628
    
    
    
    629
    
    
    
    630
    
    
    
    631
    
    
    
    632
    
    
    
    633
    
    
    
    634
    
    
    
    635
    
    
    
    636
    
    
    
    637
    
    
    
    638
    
    
    
    639
    
    
    
    640
    
    
    
    641
    
    
    
    642
    
    
    
    643
    
    
    
    644
    
    
    
    645
    
    
    
    646
    
    
    
    647
    
    
    
    648
    
    
    
    649
    
    
    
    650
    
    
    
    651
    
    
    
    652
    
    
    
    653
    
    
    
    654
    
    
    
    655
    
    
    
    656
    
    
    
    657
    
    
    
    658
    
    
    
    659
    
    
    
    660
    
    
    
    661
    
    
    
    662
    
    
    
    663
    
    
    
    664
    
    
    
    665
    
    
    
    666
    
    
    
    667
    
    
    
    668
    
    
    
    669
    
    
    
    670
    
    
    
    671
    
    
    
    672
    
    
    
    673
    
    
    
    674
    
    
    
    675
    
    
    
    676
    
    
    
    677
    
    
    
    678
    
    
    
    679
    
    
    
    680
    
    
    
    681
    
    
    
    682
    
    
    
    683
    
    
    
    684
    
    
    
    685
    
    
    
    686
    
    
    
    687
    
    
    
    688
    
    
    
    689
    
    
    
    690
    
    
    
    691
    
    
    
    692
    
    
    
    693
    
    
    
    694
    
    
    
    695
    
    
    
    696
    
    
    
    697
    
    
    
    698
    
    
    
    699
    
    
    
    700
    
    
    
    701
    
    
    
    702
    
    
    
    703
    
    
    
    704
    
    
    
    705
    
    
    
    706
    
    
    
    707
    
    
    
    708
    
    
    
    709
    
    
    
    710
    
    
    
    711
    
    
    
    712
    
    
    
    713
    
    
    
    714
    
    
    
    715
    
    
    
    716
    
    
    
    717
    
    
    
    718
    
    
    
    719
    
    
    
    720
    
    
    
    721
    
    
    
    722
    
    
    
    723
    
    
    
    724
    
    
    
    725
    
    
    
    726
    
    
    
    727
    
    
    
    728
    
    
    
    729
    
    
    
    730
    
    
    
    731
    
    
    
    732
    
    
    
    733
    
    
    
    734
    
    
    
    735
    
    
    
    736
    
    
    
    737
    
    
    
    738
    
    
    
    739
    
    
    
    740
    
    
    
    741
    
    
    
    742
    
    
    
    743
    
    
    
    744
    
    
    
    745
    
    
    
    746
    
    
    
    747
    
    
    
    748
    
    
    
    749
    
    
    
    750
    
    
    
    751
    
    
    
    752
    
    
    
    753
    
    
    
    754
    
    
    
    755
    
    
    
    756
    
    
    
    757
    
    
    
    758
    
    
    
    759
    
    
    
    760
    
    
    
    761
    
    
    
    762
    
    
    
    763
    
    
    
    764
    
    
    
    765
    
    
    
    766
    
    
    
    767
    
    
    
    768
    
    
    
    769
    
    
    
    770
    
    
    
    771
    
    
    
    772
    
    
    
    773
    
    
    
    774
    
    
    
    775
    
    
    
    776
    
    
    
    777
    
    
    
    778
    
    
    
    779
    
    
    
    780
    
    
    
    781
    
    
    
    782
    
    
    
    783
    
    
    
    784
    
    
    
    785
    
    
    
    786
    
    
    
    787
    
    
    
    788
    
    
    
    789
    
    
    
    790
    
    
    
    791
    
    
    
    792
    
    
    
    793
    
    
    
    794
    
    
    
    795
    
    
    
    796
    
    
    
    797
    
    
    
    798
    
    
    
    799
    
    
    
    800
    
    
    
    801
    
    
    
    802
    
    
    
    803
    
    
    
    804
    
    
    
    805
    
    
    
    806
    
    
    
    807
    
    
    
    808
    
    
    
    809
    
    
    
    810
    
    
    
    811
    
    
    
    812
    
    
    
    813
    
    
    
    814
    
    
    
    815
    
    
    
    816
    
    
    
    817
    
    
    
    818
    
    
    
    819
    
    
    
    820
    
    
    
    821
    
    
    
    822
    
    
    
    823
    
    
    
    824
    
    
    
    825
    
    
    
    826
    
    
    
    827
    
    
    
    828
    
    
    
    829
    
    
    
    830
    
    
    
    831
    
    
    
    832
    
    
    
    833
    
    
    
    834
    
    
    
    835
    
    
    
    836
    
    
    
    837
    
    
    
    838
    
    
    
    839
    
    
    
    840
    
    
    
    841
    
    
    
    842
    
    
    
    843
    
    
    
    844
    
    
    
    845
    
    
    
    846
    
    
    
    847
    
    
    
    848
    
    
    
    849
    
    
    
    850
    
    
    
    851
    
    
    
    852
    
    
    
    853
    
    
    
    854
    
    
    
    855
    
    
    
    856
    
    
    
    857
    
    
    
    858
    
    
    
    859
    
    
    
    860
    
    
    
    861
    
    
    
    862
    
    
    
    863
    
    
    
    864
    
    
    
    865
    
    
    
    866
    
    
    
    867
    
    
    
    868
    
    
    
    869
    
    
    
    870
    
    
    
    871
    
    
    
    872
    
    
    
    873
    
    
    
    874
    
    
    
    875
    
    
    
    876
    
    
    
    877
    
    
    
    878
    
    
    
    879
    
    
    
    880
    
    
    
    881
    
    
    
    882
    
    
    
    883
    
    
    
    884
    
    
    
    885
    
    
    
    886
    
    
    
    887
    
    
    
    888
    
    
    
    889
    
    
    
    890
    
    
    
    891
    
    
    
    892
    
    
    
    893
    
    
    
    894
    
    
    
    895
    
    
    
    896
    
    
    
    897
    
    
    
    898
    
    
    
    899
    
    
    
    900
    
    
    
    901
    
    
    
    902
    
    
    
    903
    
    
    
    904
    
    
    
    905
    
    
    
    906
    
    
    
    907
    
    
    
    908
    
    
    
    909
    
    
    
    910
    
    
    
    911
    
    
    
    912
    
    
    
    913
    
    
    
    914
    
    
    
    915
    
    
    
    916
    
    
    
    917
    
    
    
    918
    
    
    
    919
    
    
    
    920
    
    
    
    921
    
    
    
    922
    
    
    
    923
    
    
    
    924
    
    
    
    925
    
    
    
    926
    
    
    
    927
    
    
    
    928
    
    
    
    929
    
    
    
    930

speex AEC算法

和WebRTC一样也是采用频域分块自适应滤波方法，不同的是权重调整的方式变化，我这边测试效果是计算量比WebRTC的大，且效果调节的没有WebRTC的好。这里也给出speex的源代码和测试方法。

%    Copyright (C) 2012      Waves Audio LTD
%    Copyright (C) 2003-2008 Jean-Marc Valin
%
%    File: speex_mdf.m
%    Echo canceller based on the MDF algorithm (see below)
% 
%    Redistribution and use in source and binary forms, with or without
%    modification, are permitted provided that the following conditions are
%    met:
% 
%    1. Redistributions of source code must retain the above copyright notice,
%    this list of conditions and the following disclaimer.
% 
%    2. Redistributions in binary form must reproduce the above copyright
%    notice, this list of conditions and the following disclaimer in the
%    documentation and/or other materials provided with the distribution.
% 
%    3. The name of the author may not be used to endorse or promote products
%    derived from this software without specific prior written permission.
% 
%    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
%    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
%    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
%    DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
%    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
%    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
%    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
%    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
%    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
%    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
%    POSSIBILITY OF SUCH DAMAGE.
%
%    Notes from original mdf.c:
%
%    The echo canceller is based on the MDF algorithm described in:
% 
%    J. S. Soo, K. K. Pang Multidelay block frequency adaptive filter, 
%    IEEE Trans. Acoust. Speech Signal Process., Vol. ASSP-38, No. 2, 
%    February 1990.
%    
%    We use the Alternatively Updated MDF (AUMDF) variant. Robustness to 
%    double-talk is achieved using a variable learning rate as described in:
%    
%    Valin, J.-M., On Adjusting the Learning Rate in Frequency Domain Echo 
%    Cancellation With Double-Talk. IEEE Transactions on Audio,
%    Speech and Language Processing, Vol. 15, No. 3, pp. 1030-1034, 2007.
%    http://people.xiph.org/~jm/papers/valin_taslp2006.pdf
%    
%    There is no explicit double-talk detection, but a continuous variation
%    in the learning rate based on residual echo, double-talk and background
%    noise.
%    
%    Another kludge that seems to work good: when performing the weight
%    update, we only move half the way toward the "goal" this seems to
%    reduce the effect of quantization noise in the update phase. This
%    can be seen as applying a gradient descent on a "soft constraint"
%    instead of having a hard constraint.
%    
%    Notes for this file:
%
%    Usage: 
%
%       speex_mdf_out = speex_mdf(Fs, u, d, filter_length, frame_size, dbg_var_name);
%       
%       Fs                  sample rate
%       u                   speaker signal, column vector in range [-1; 1]
%       d                   microphone signal, column vector in range [-1; 1]
%       filter_length       typically 250ms, i.e. 4096 @ 16k FS 
%                           must be a power of 2
%       frame_size          typically 8ms, i.e. 128 @ 16k Fs 
%                           must be a power of 2
%       dbg_var_name        internal state variable name to trace. 
%                           Default: 'st.leak_estimate'.
%
%    Jonathan Rouach 
%    

function  speex_mdf_out = speex_mdf(Fs, u, d, filter_length, frame_size, dbg_var_name)

fprintf('Starting Speex MDF (PBFDAF) algorithm.\n');

st = speex_echo_state_init_mc_mdf(frame_size, filter_length, 1, 1, Fs);

% which variable to trace
if nargin<6
    dbg_var_name = 'st.leak_estimate';
end
dbg = init_dbg(st, length(u));

[e, dbg] = main_loop(st, float_to_short(u), float_to_short(d), dbg);

speex_mdf_out.e = e/32768.0;
speex_mdf_out.var1 = dbg.var1;

    function x = float_to_short(x)
        x = x*32768.0;
        x(x< -32767.5) = -32768;
        x(x>  32766.5) =  32767;
        x = floor(0.5+x);
    end

    function [e, dbg] = main_loop(st, u, d, dbg)

        e = zeros(size(u));
        y = zeros(size(u));

        % prepare waitbar
        try h_wb = waitbar(0, 'Processing...'); catch; end
        end_point = length(u);

        for n = 1:st.frame_size:end_point
            nStep = floor(n/st.frame_size)+1;

            if mod(nStep, 128)==0 && update_waitbar_check_wasclosed(h_wb, n, end_point, st.sampling_rate)
                break;
            end

            u_frame = u(n:n+st.frame_size-1);
            d_frame = d(n:n+st.frame_size-1);

            [out, st] = speex_echo_cancellation_mdf(st, d_frame, u_frame);

            e(n:n+st.frame_size-1) = out*2;
            y(n:n+st.frame_size-1) = d_frame - out;
            dbg.var1(:, nStep) = reshape( eval(dbg_var_name),  numel(eval(dbg_var_name)), 1);

        end

        try close(h_wb); catch; end

    end
    function st = speex_echo_state_init_mc_mdf(frame_size, filter_length, nb_mic, nb_speakers, sample_rate)

        st.K = nb_speakers;
        st.C = nb_mic;
        C=st.C;
        K=st.K;

        st.frame_size = frame_size;
        st.window_size = 2*frame_size;
        N = st.window_size;
        st.M = fix((filter_length+st.frame_size-1)/frame_size);
        M = st.M;
        st.cancel_count=0;
        st.sum_adapt = 0;
        st.saturated = 0;
        st.screwed_up = 0;

        %    /* This is the default sampling rate */
        st.sampling_rate = sample_rate;
        st.spec_average = (st.frame_size)/( st.sampling_rate);
        st.beta0 = (2.0*st.frame_size)/st.sampling_rate;
        st.beta_max = (.5*st.frame_size)/st.sampling_rate;
        st.leak_estimate = 0;

        st.e = zeros(N, C);
        st.x = zeros(N, K);
        st.input = zeros(st.frame_size, C);
        st.y = zeros(N, C);
        st.last_y = zeros(N, C);
        st.Yf = zeros(st.frame_size+1, 1);
        st.Rf = zeros(st.frame_size+1, 1);
        st.Xf = zeros(st.frame_size+1, 1);
        st.Yh = zeros(st.frame_size+1, 1);
        st.Eh = zeros(st.frame_size+1, 1);

        st.X = zeros(N, K, M+1);
        st.Y = zeros(N, C);
        st.E = zeros(N, C);
        st.W = zeros(N, K, M, C);
        st.foreground = zeros(N, K, M, C);
        st.PHI = zeros(frame_size+1, 1);
        st.power = zeros(frame_size+1, 1);
        st.power_1 = ones((frame_size+1), 1);
        st.window = zeros(N, 1);
        st.prop = zeros(M, 1);
        st.wtmp = zeros(N, 1);

        st.window = .5-.5*cos(2*pi*((1:N)'-1)/N);

        % /* Ratio of ~10 between adaptation rate of first and last block */
        decay = exp(-1/M);
        st.prop(1, 1) = .7;
        for i=2:M
            st.prop(i, 1) = st.prop(i-1, 1) * decay;
        end

        st.prop = (.8 * st.prop)./sum(st.prop);

        st.memX = zeros(K, 1);
        st.memD = zeros(C, 1);
        st.memE = zeros(C, 1);
        st.preemph = .98;
        if (st.sampling_rate<12000)
            st.notch_radius = .9;
        elseif (st.sampling_rate<24000)
            st.notch_radius = .982;
        else
            st.notch_radius = .992;
        end

        st.notch_mem = zeros(2*C, 1);
        st.adapted = 0;
        st.Pey = 1;
        st.Pyy = 1;

        st.Davg1 = 0; st.Davg2 = 0;
        st.Dvar1 = 0; st.Dvar2 = 0;
    end

    function dbg = init_dbg(st, len)
        dbg.var1 = zeros(numel(eval(dbg_var_name)), fix(len/st.frame_size));
    end

    function [out, st] = speex_echo_cancellation_mdf(st, in, far_end)

        N = st.window_size;
        M = st.M;
        C = st.C;
        K = st.K;

        Pey_cur = 1;
        Pyy_cur = 1;

        out = zeros(st.frame_size, C);

        st.cancel_count = st.cancel_count + 1;

        %ss=.35/M;
        ss = 0.5/M;
        ss_1 = 1-ss;

        for chan = 1:C
            % Apply a notch filter to make sure DC doesn't end up causing problems
            [st.input(:, chan), st.notch_mem(:, chan)] = filter_dc_notch16(in(:, chan), st.notch_radius, st.frame_size, st.notch_mem(:, chan));
            % Copy input data to buffer and apply pre-emphasis
            for i=1:st.frame_size
                tmp32 = st.input(i, chan)- (st.preemph* st.memD(chan));
                st.memD(chan) = st.input(i, chan);
                st.input(i, chan) = tmp32;
            end
        end

        for speak = 1:K
            for i =1:st.frame_size
                st.x(i, speak) = st.x(i+st.frame_size, speak);
                tmp32 = far_end(i, speak) - st.preemph * st.memX(speak);
                st.x(i+st.frame_size, speak) = tmp32;
                st.memX(speak) = far_end(i, speak);
            end
        end

        % Shift memory
        st.X = circshift(st.X, [0, 0, 1]);

        for speak = 1:K
            %  Convert x (echo input) to frequency domain
            % MATLAB_MATCH: we divide by N to get values as in speex
            st.X(:, speak, 1) = fft(st.x(:, speak)) /N;
        end

        Sxx = 0;
        for speak = 1:K
            Sxx = Sxx + sum(st.x(st.frame_size+1:end, speak).^2);
            st.Xf = abs(st.X(1:st.frame_size+1, speak, 1)).^2;
        end

        Sff = 0;
        for chan = 1:C

            %  Compute foreground filter
            st.Y(:, chan) = 0;
            for speak=1:K
                for j=1:M
                    st.Y(:, chan) = st.Y(:, chan) + st.X(:, speak, j) .* st.foreground(:, speak, j, chan);
                end
            end
            % MATLAB_MATCH: we multiply by N to get values as in speex
            st.e(:, chan) = ifft(st.Y(:, chan)) * N;
            st.e(1:st.frame_size, chan) = st.input(:, chan) - st.e(st.frame_size+1:end, chan);
            % st.e : [out foreground | leak foreground ]
            Sff = Sff + sum(abs(st.e(1:st.frame_size, chan)).^2);

        end

        % Adjust proportional adaption rate */
        if (st.adapted)
            st.prop = mdf_adjust_prop (st.W, N, M, C, K);
        end

        % Compute weight gradient */
        if (st.saturated == 0)
            for chan = 1:C
                for speak = 1:K
                    for j=M:-1:1
                        st.PHI = [st.power_1; st.power_1(end-1:-1:2)] .* st.prop(j) .* conj(st.X(:, speak, (j+1))) .* st.E(:, chan);
                        st.W(:, j) = st.W(:, j) + st.PHI;
                    end
                end
            end
        else
            st.saturated = st.saturated -1;
        end

        %FIXME: MC conversion required */
        % Update weight to prevent circular convolution (MDF / AUMDF)
        for chan = 1:C
            for speak = 1:K
                for j = 1:M
                    % This is a variant of the Alternatively Updated MDF (AUMDF) */
                    % Remove the "if" to make this an MDF filter */
                    if (j==1 || mod(2+st.cancel_count,(M-1)) == j)
                        st.wtmp = ifft(st.W(:, speak, j, chan));
                        st.wtmp(st.frame_size+1:N) = 0;
                        st.W(:, speak, j, chan) = fft(st.wtmp);
                    end
                end
            end
        end

        % So we can use power_spectrum_accum */
        st.Yf = zeros(st.frame_size+1, 1);
        st.Rf = zeros(st.frame_size+1, 1);
        st.Xf = zeros(st.frame_size+1, 1);

        Dbf = 0;

        for chan = 1:C
            st.Y(:, chan) = 0;
            for speak=1:K
                for j=1:M
                    st.Y(:, chan) = st.Y(:, chan) + st.X(:, speak, j) .* st.W(:, speak, j, chan);
                end
            end
            % MATLAB_MATCH: we multiply by N to get values as in speex
            st.y(:,chan) = ifft(st.Y(:,chan)) * N;
            % st.y : [ ~ | leak background ]
        end

        See = 0;

        % Difference in response, this is used to estimate the variance of our residual power estimate */
        for chan = 1:C
            st.e(1:st.frame_size, chan) = st.e(st.frame_size+1:N, chan) - st.y(st.frame_size+1:N, chan);
            Dbf = Dbf + 10 + sum(abs(st.e(1:st.frame_size, chan)).^2);
            st.e(1:st.frame_size, chan) = st.input(:, chan) - st.y(st.frame_size+1:N, chan);
            % st.e : [ out background | leak foreground ]
           See = See + sum(abs(st.e(1:st.frame_size, chan)).^2);
        end

        % Logic for updating the foreground filter */

        % For two time windows, compute the mean of the energy difference, as well as the variance */
        VAR1_UPDATE = .5;
        VAR2_UPDATE = .25;
        VAR_BACKTRACK = 4;
        MIN_LEAK = .005;

        st.Davg1 = .6*st.Davg1 + .4*(Sff-See);
        st.Davg2 = .85*st.Davg2 + .15*(Sff-See);
        st.Dvar1 = .36*st.Dvar1 + .16*Sff*Dbf;
        st.Dvar2 = .7225*st.Dvar2 + .0225*Sff*Dbf;

        update_foreground = 0;

        % Check if we have a statistically significant reduction in the residual echo */
        % Note that this is *not* Gaussian, so we need to be careful about the longer tail */
        if (Sff-See)*abs(Sff-See) > (Sff*Dbf)
            update_foreground = 1;
        elseif (st.Davg1* abs(st.Davg1) > (VAR1_UPDATE*st.Dvar1))
            update_foreground = 1;
        elseif (st.Davg2* abs(st.Davg2) > (VAR2_UPDATE*(st.Dvar2)))
            update_foreground = 1;
        end

        % Do we update? */
        if (update_foreground)

            st.Davg1 = 0;
            st.Davg2 = 0;
            st.Dvar1 = 0;
            st.Dvar2 = 0;
            st.foreground = st.W;
            % Apply a smooth transition so as to not introduce blocking artifacts */
            for chan = 1:C
                st.e(st.frame_size+1:N, chan) = (st.window(st.frame_size+1:N) .* st.e(st.frame_size+1:N, chan)) + (st.window(1:st.frame_size) .* st.y(st.frame_size+1:N, chan));
            end
        else
            reset_background=0;
            % Otherwise, check if the background filter is significantly worse */

            if (-(Sff-See)*abs(Sff-See)> VAR_BACKTRACK*(Sff*Dbf))
                reset_background = 1;
            end
            if ((-st.Davg1 * abs(st.Davg1))> (VAR_BACKTRACK*st.Dvar1))
                reset_background = 1;
            end
            if ((-st.Davg2* abs(st.Davg2))> (VAR_BACKTRACK*st.Dvar2))
                reset_background = 1;
            end

            if (reset_background)

                % Copy foreground filter to background filter */
                st.W = st.foreground;

                % We also need to copy the output so as to get correct adaptation */
                for chan = 1:C
                    st.y(st.frame_size+1:N, chan) = st.e(st.frame_size+1:N, chan);
                    st.e(1:st.frame_size, chan) = st.input(:, chan) - st.y(st.frame_size+1:N, chan);
                end

                See = Sff;
                st.Davg1 = 0;
                st.Davg2 = 0;
                st.Dvar1 = 0;
                st.Dvar2 = 0;
            end
        end

        Sey = 0;
        Syy = 0;
        Sdd = 0;

        for chan = 1:C

            % Compute error signal (for the output with de-emphasis) */
            for i=1:st.frame_size
                tmp_out = st.input(i, chan)- st.e(i+st.frame_size, chan);
                tmp_out = tmp_out + st.preemph * st.memE(chan);
                %  This is an arbitrary test for saturation in the microphone signal */
                if (in(i,chan) <= -32000 || in(i,chan) >= 32000)
                    if (st.saturated == 0)
                        st.saturated = 1;
                    end
                end
                out(i, chan) = tmp_out;
                st.memE(chan) = tmp_out;
            end

            % Compute error signal (filter update version) */
            st.e(st.frame_size+1:N, chan) = st.e(1:st.frame_size, chan);
            st.e(1:st.frame_size, chan) = 0;
            % st.e : [ zeros | out background ]

            % Compute a bunch of correlations */
            % FIXME: bad merge */
            Sey = Sey + sum(st.e(st.frame_size+1:N, chan) .* st.y(st.frame_size+1:N, chan));
            Syy = Syy + sum(st.y(st.frame_size+1:N, chan).^2);
            Sdd = Sdd + sum(st.input.^2);

            % Convert error to frequency domain */
            % MATLAB_MATCH: we divide by N to get values as in speex
            st.E = fft(st.e) / N;

            st.y(1:st.frame_size, chan) = 0;
            % MATLAB_MATCH: we divide by N to get values as in speex
            st.Y = fft(st.y) / N;

            % Compute power spectrum of echo (X), error (E) and filter response (Y) */
            st.Rf = abs(st.E(1:st.frame_size+1,chan)).^2;
            st.Yf = abs(st.Y(1:st.frame_size+1,chan)).^2;
        end

        % Do some sanity check */
        if (~(Syy>=0 && Sxx>=0 && See >= 0))
            % Things have gone really bad */
            st.screwed_up = st.screwed_up + 50;
            out = out*0;
        elseif Sff > Sdd+ N*10000
            % AEC seems to add lots of echo instead of removing it, let's see if it will improve */
            st.screwed_up = st.screwed_up + 1;
        else
            % Everything's fine */
            st.screwed_up=0;
        end

        if (st.screwed_up>=50)
            disp('Screwed up, full reset');
            st = speex_echo_state_reset_mdf(st);
        end

        % Add a small noise floor to make sure not to have problems when dividing */
        See = max(See, N* 100);

        for speak = 1:K
            Sxx = Sxx + sum(st.x(st.frame_size+1:end, speak).^2);
            st.Xf = abs(st.X(1:st.frame_size+1, speak, 1)).^2;
        end

        % Smooth far end energy estimate over time */
        st.power = ss_1*st.power+ 1 + ss*st.Xf;

        % Compute filtered spectra and (cross-)correlations */

        Eh_cur = st.Rf - st.Eh;
        Yh_cur = st.Yf - st.Yh;
        Pey_cur = Pey_cur + sum(Eh_cur.*Yh_cur) ;
        Pyy_cur = Pyy_cur + sum(Yh_cur.^2);
        st.Eh = (1-st.spec_average)*st.Eh + st.spec_average*st.Rf;
        st.Yh = (1-st.spec_average)*st.Yh + st.spec_average*st.Yf;

        Pyy = sqrt(Pyy_cur);
        Pey = Pey_cur/Pyy;

        % Compute correlation updatete rate */
        tmp32 = st.beta0*Syy;
        if (tmp32 > st.beta_max*See)
            tmp32 = st.beta_max*See;
        end
        alpha = tmp32/ See;
        alpha_1 = 1- alpha;

        % Update correlations (recursive average) */
        st.Pey = alpha_1*st.Pey + alpha*Pey;
        st.Pyy = alpha_1*st.Pyy + alpha*Pyy;

        if st.Pyy<1
            st.Pyy =1;
        end

        % We don't really hope to get better than 33 dB (MIN_LEAK-3dB) attenuation anyway */
        if st.Pey< MIN_LEAK * st.Pyy
            st.Pey = MIN_LEAK * st.Pyy;
        end

        if (st.Pey> st.Pyy)
            st.Pey = st.Pyy;
        end

        % leak_estimate is the linear regression result */
        st.leak_estimate = st.Pey/st.Pyy;

        % This looks like a stupid bug, but it's right (because we convert from Q14 to Q15) */
        if (st.leak_estimate > 16383)
            st.leak_estimate = 32767;
        end

        % Compute Residual to Error Ratio */
        RER = (.0001*Sxx + 3.*st.leak_estimate*Syy) / See;
        % Check for y in e (lower bound on RER) */
        if (RER < Sey*Sey/(1+See*Syy))
            RER = Sey*Sey/(1+See*Syy);
        end
        if (RER > .5)
            RER = .5;
        end

        % We consider that the filter has had minimal adaptation if the following is true*/
        if (~st.adapted && st.sum_adapt > M && st.leak_estimate*Syy > .03*Syy)
            st.adapted = 1;
        end

        if (st.adapted)
            % Normal learning rate calculation once we're past the minimal adaptation phase */
            for i=1:st.frame_size+1

                % Compute frequency-domain adaptation mask */
                r = st.leak_estimate*st.Yf(i);
                e = st.Rf(i)+1;
                if (r>.5*e)
                    r = .5*e;
                end
                r = 0.7*r + 0.3*(RER*e);
                %st.power_1[i] = adapt_rate*r/(e*(1+st.power[i]));*/
                st.power_1(i) = (r/(e*st.power(i)+10));
            end
        else
            % Temporary adaption rate if filter is not yet adapted enough */
            adapt_rate=0;

            if (Sxx > N* 1000)

                tmp32 = 0.25* Sxx;
                if (tmp32 > .25*See)
                    tmp32 = .25*See;
                end
                adapt_rate = tmp32/ See;
            end
            st.power_1 = adapt_rate./(st.power+10);


            % How much have we adapted so far? */
            st.sum_adapt = st.sum_adapt+adapt_rate;
        end

        % FIXME: MC conversion required */
        st.last_y(1:st.frame_size) = st.last_y(st.frame_size+1:N);
        if (st.adapted)
            % If the filter is adapted, take the filtered echo */
            st.last_y(st.frame_size+1:N) = in-out;
        end

    end

    function [out,mem] = filter_dc_notch16(in, radius, len, mem)
        out = zeros(size(in));
        den2 = radius*radius + .7*(1-radius)*(1-radius);
        for i=1:len
            vin = in(i);
            vout = mem(1) + vin;
            mem(1) = mem(2) + 2*(-vin + radius*vout);
            mem(2) = vin - (den2*vout);
            out(i) = radius*vout; 
        end

    end

    function prop = mdf_adjust_prop(W, N, M, C, K)
        prop = zeros(M,1);
        for i=1:M
            tmp = 1;
            for chan=1:C
                for speak=1:K
                    tmp = tmp + sum(abs(W(1:N/2+1, K, i, C)).^2);
                end
            end
            prop(i) = sqrt(tmp);
        end
        max_sum = max(prop, 1);
        prop = prop + .1*max_sum;
        prop_sum = 1+sum(prop);
        prop = .99*prop / prop_sum;
    end

    % Resets echo canceller state */
    function st = speex_echo_state_reset_mdf(st)

        st.cancel_count=0;
        st.screwed_up = 0;
        N = st.window_size;
        M = st.M;
        C=st.C;
        K=st.K;

        st.e = zeros(N, C);
        st.x = zeros(N, K);
        st.input = zeros(st.frame_size, C);
        st.y = zeros(N, C);
        st.last_y = zeros(N, C);
        st.Yf = zeros(st.frame_size+1, 1);
        st.Rf = zeros(st.frame_size+1, 1);
        st.Xf = zeros(st.frame_size+1, 1);
        st.Yh = zeros(st.frame_size+1, 1);
        st.Eh = zeros(st.frame_size+1, 1);

        st.X = zeros(N, K, M+1);
        st.Y = zeros(N, C);
        st.E = zeros(N, C);
        st.W = zeros(N, K, M, C);
        st.foreground = zeros(N, K, M, C);
        st.PHI = zeros(N, 1);
        st.power = zeros(st.frame_size+1, 1);
        st.power_1 = ones((st.frame_size+1), 1);
        st.window = zeros(N, 1);
        st.prop = zeros(M, 1);
        st.wtmp = zeros(N, 1);

        st.memX = zeros(K, 1);
        st.memD = zeros(C, 1);
        st.memE = zeros(C, 1);

        st.saturated = 0;
        st.adapted = 0;
        st.sum_adapt = 0;
        st.Pey = 1;
        st.Pyy = 1;
        st.Davg1 = 0;
        st.Davg2 = 0;
        st.Dvar1 = 0;
        st.Dvar2 = 0;


    end

    function was_closed = update_waitbar_check_wasclosed(h, n, end_point, Fs)
        was_closed = 0;

        % update waitbar
        try
            waitbar(n/end_point, h, ['Processing... ', num2str(n/Fs, '%.2f'), 's / ', num2str(end_point/Fs, '%.2f'), 's' ]);
        catch ME
            % if it's no longer there (closed by user)
            if (strcmp(ME.identifier(1:length('MATLAB:waitbar:')), 'MATLAB:waitbar:'))
                was_closed = 1; % then get out of the loop
            end
        end

    end

end
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10
    
    
    
    11
    
    
    
    12
    
    
    
    13
    
    
    
    14
    
    
    
    15
    
    
    
    16
    
    
    
    17
    
    
    
    18
    
    
    
    19
    
    
    
    20
    
    
    
    21
    
    
    
    22
    
    
    
    23
    
    
    
    24
    
    
    
    25
    
    
    
    26
    
    
    
    27
    
    
    
    28
    
    
    
    29
    
    
    
    30
    
    
    
    31
    
    
    
    32
    
    
    
    33
    
    
    
    34
    
    
    
    35
    
    
    
    36
    
    
    
    37
    
    
    
    38
    
    
    
    39
    
    
    
    40
    
    
    
    41
    
    
    
    42
    
    
    
    43
    
    
    
    44
    
    
    
    45
    
    
    
    46
    
    
    
    47
    
    
    
    48
    
    
    
    49
    
    
    
    50
    
    
    
    51
    
    
    
    52
    
    
    
    53
    
    
    
    54
    
    
    
    55
    
    
    
    56
    
    
    
    57
    
    
    
    58
    
    
    
    59
    
    
    
    60
    
    
    
    61
    
    
    
    62
    
    
    
    63
    
    
    
    64
    
    
    
    65
    
    
    
    66
    
    
    
    67
    
    
    
    68
    
    
    
    69
    
    
    
    70
    
    
    
    71
    
    
    
    72
    
    
    
    73
    
    
    
    74
    
    
    
    75
    
    
    
    76
    
    
    
    77
    
    
    
    78
    
    
    
    79
    
    
    
    80
    
    
    
    81
    
    
    
    82
    
    
    
    83
    
    
    
    84
    
    
    
    85
    
    
    
    86
    
    
    
    87
    
    
    
    88
    
    
    
    89
    
    
    
    90
    
    
    
    91
    
    
    
    92
    
    
    
    93
    
    
    
    94
    
    
    
    95
    
    
    
    96
    
    
    
    97
    
    
    
    98
    
    
    
    99
    
    
    
    100
    
    
    
    101
    
    
    
    102
    
    
    
    103
    
    
    
    104
    
    
    
    105
    
    
    
    106
    
    
    
    107
    
    
    
    108
    
    
    
    109
    
    
    
    110
    
    
    
    111
    
    
    
    112
    
    
    
    113
    
    
    
    114
    
    
    
    115
    
    
    
    116
    
    
    
    117
    
    
    
    118
    
    
    
    119
    
    
    
    120
    
    
    
    121
    
    
    
    122
    
    
    
    123
    
    
    
    124
    
    
    
    125
    
    
    
    126
    
    
    
    127
    
    
    
    128
    
    
    
    129
    
    
    
    130
    
    
    
    131
    
    
    
    132
    
    
    
    133
    
    
    
    134
    
    
    
    135
    
    
    
    136
    
    
    
    137
    
    
    
    138
    
    
    
    139
    
    
    
    140
    
    
    
    141
    
    
    
    142
    
    
    
    143
    
    
    
    144
    
    
    
    145
    
    
    
    146
    
    
    
    147
    
    
    
    148
    
    
    
    149
    
    
    
    150
    
    
    
    151
    
    
    
    152
    
    
    
    153
    
    
    
    154
    
    
    
    155
    
    
    
    156
    
    
    
    157
    
    
    
    158
    
    
    
    159
    
    
    
    160
    
    
    
    161
    
    
    
    162
    
    
    
    163
    
    
    
    164
    
    
    
    165
    
    
    
    166
    
    
    
    167
    
    
    
    168
    
    
    
    169
    
    
    
    170
    
    
    
    171
    
    
    
    172
    
    
    
    173
    
    
    
    174
    
    
    
    175
    
    
    
    176
    
    
    
    177
    
    
    
    178
    
    
    
    179
    
    
    
    180
    
    
    
    181
    
    
    
    182
    
    
    
    183
    
    
    
    184
    
    
    
    185
    
    
    
    186
    
    
    
    187
    
    
    
    188
    
    
    
    189
    
    
    
    190
    
    
    
    191
    
    
    
    192
    
    
    
    193
    
    
    
    194
    
    
    
    195
    
    
    
    196
    
    
    
    197
    
    
    
    198
    
    
    
    199
    
    
    
    200
    
    
    
    201
    
    
    
    202
    
    
    
    203
    
    
    
    204
    
    
    
    205
    
    
    
    206
    
    
    
    207
    
    
    
    208
    
    
    
    209
    
    
    
    210
    
    
    
    211
    
    
    
    212
    
    
    
    213
    
    
    
    214
    
    
    
    215
    
    
    
    216
    
    
    
    217
    
    
    
    218
    
    
    
    219
    
    
    
    220
    
    
    
    221
    
    
    
    222
    
    
    
    223
    
    
    
    224
    
    
    
    225
    
    
    
    226
    
    
    
    227
    
    
    
    228
    
    
    
    229
    
    
    
    230
    
    
    
    231
    
    
    
    232
    
    
    
    233
    
    
    
    234
    
    
    
    235
    
    
    
    236
    
    
    
    237
    
    
    
    238
    
    
    
    239
    
    
    
    240
    
    
    
    241
    
    
    
    242
    
    
    
    243
    
    
    
    244
    
    
    
    245
    
    
    
    246
    
    
    
    247
    
    
    
    248
    
    
    
    249
    
    
    
    250
    
    
    
    251
    
    
    
    252
    
    
    
    253
    
    
    
    254
    
    
    
    255
    
    
    
    256
    
    
    
    257
    
    
    
    258
    
    
    
    259
    
    
    
    260
    
    
    
    261
    
    
    
    262
    
    
    
    263
    
    
    
    264
    
    
    
    265
    
    
    
    266
    
    
    
    267
    
    
    
    268
    
    
    
    269
    
    
    
    270
    
    
    
    271
    
    
    
    272
    
    
    
    273
    
    
    
    274
    
    
    
    275
    
    
    
    276
    
    
    
    277
    
    
    
    278
    
    
    
    279
    
    
    
    280
    
    
    
    281
    
    
    
    282
    
    
    
    283
    
    
    
    284
    
    
    
    285
    
    
    
    286
    
    
    
    287
    
    
    
    288
    
    
    
    289
    
    
    
    290
    
    
    
    291
    
    
    
    292
    
    
    
    293
    
    
    
    294
    
    
    
    295
    
    
    
    296
    
    
    
    297
    
    
    
    298
    
    
    
    299
    
    
    
    300
    
    
    
    301
    
    
    
    302
    
    
    
    303
    
    
    
    304
    
    
    
    305
    
    
    
    306
    
    
    
    307
    
    
    
    308
    
    
    
    309
    
    
    
    310
    
    
    
    311
    
    
    
    312
    
    
    
    313
    
    
    
    314
    
    
    
    315
    
    
    
    316
    
    
    
    317
    
    
    
    318
    
    
    
    319
    
    
    
    320
    
    
    
    321
    
    
    
    322
    
    
    
    323
    
    
    
    324
    
    
    
    325
    
    
    
    326
    
    
    
    327
    
    
    
    328
    
    
    
    329
    
    
    
    330
    
    
    
    331
    
    
    
    332
    
    
    
    333
    
    
    
    334
    
    
    
    335
    
    
    
    336
    
    
    
    337
    
    
    
    338
    
    
    
    339
    
    
    
    340
    
    
    
    341
    
    
    
    342
    
    
    
    343
    
    
    
    344
    
    
    
    345
    
    
    
    346
    
    
    
    347
    
    
    
    348
    
    
    
    349
    
    
    
    350
    
    
    
    351
    
    
    
    352
    
    
    
    353
    
    
    
    354
    
    
    
    355
    
    
    
    356
    
    
    
    357
    
    
    
    358
    
    
    
    359
    
    
    
    360
    
    
    
    361
    
    
    
    362
    
    
    
    363
    
    
    
    364
    
    
    
    365
    
    
    
    366
    
    
    
    367
    
    
    
    368
    
    
    
    369
    
    
    
    370
    
    
    
    371
    
    
    
    372
    
    
    
    373
    
    
    
    374
    
    
    
    375
    
    
    
    376
    
    
    
    377
    
    
    
    378
    
    
    
    379
    
    
    
    380
    
    
    
    381
    
    
    
    382
    
    
    
    383
    
    
    
    384
    
    
    
    385
    
    
    
    386
    
    
    
    387
    
    
    
    388
    
    
    
    389
    
    
    
    390
    
    
    
    391
    
    
    
    392
    
    
    
    393
    
    
    
    394
    
    
    
    395
    
    
    
    396
    
    
    
    397
    
    
    
    398
    
    
    
    399
    
    
    
    400
    
    
    
    401
    
    
    
    402
    
    
    
    403
    
    
    
    404
    
    
    
    405
    
    
    
    406
    
    
    
    407
    
    
    
    408
    
    
    
    409
    
    
    
    410
    
    
    
    411
    
    
    
    412
    
    
    
    413
    
    
    
    414
    
    
    
    415
    
    
    
    416
    
    
    
    417
    
    
    
    418
    
    
    
    419
    
    
    
    420
    
    
    
    421
    
    
    
    422
    
    
    
    423
    
    
    
    424
    
    
    
    425
    
    
    
    426
    
    
    
    427
    
    
    
    428
    
    
    
    429
    
    
    
    430
    
    
    
    431
    
    
    
    432
    
    
    
    433
    
    
    
    434
    
    
    
    435
    
    
    
    436
    
    
    
    437
    
    
    
    438
    
    
    
    439
    
    
    
    440
    
    
    
    441
    
    
    
    442
    
    
    
    443
    
    
    
    444
    
    
    
    445
    
    
    
    446
    
    
    
    447
    
    
    
    448
    
    
    
    449
    
    
    
    450
    
    
    
    451
    
    
    
    452
    
    
    
    453
    
    
    
    454
    
    
    
    455
    
    
    
    456
    
    
    
    457
    
    
    
    458
    
    
    
    459
    
    
    
    460
    
    
    
    461
    
    
    
    462
    
    
    
    463
    
    
    
    464
    
    
    
    465
    
    
    
    466
    
    
    
    467
    
    
    
    468
    
    
    
    469
    
    
    
    470
    
    
    
    471
    
    
    
    472
    
    
    
    473
    
    
    
    474
    
    
    
    475
    
    
    
    476
    
    
    
    477
    
    
    
    478
    
    
    
    479
    
    
    
    480
    
    
    
    481
    
    
    
    482
    
    
    
    483
    
    
    
    484
    
    
    
    485
    
    
    
    486
    
    
    
    487
    
    
    
    488
    
    
    
    489
    
    
    
    490
    
    
    
    491
    
    
    
    492
    
    
    
    493
    
    
    
    494
    
    
    
    495
    
    
    
    496
    
    
    
    497
    
    
    
    498
    
    
    
    499
    
    
    
    500
    
    
    
    501
    
    
    
    502
    
    
    
    503
    
    
    
    504
    
    
    
    505
    
    
    
    506
    
    
    
    507
    
    
    
    508
    
    
    
    509
    
    
    
    510
    
    
    
    511
    
    
    
    512
    
    
    
    513
    
    
    
    514
    
    
    
    515
    
    
    
    516
    
    
    
    517
    
    
    
    518
    
    
    
    519
    
    
    
    520
    
    
    
    521
    
    
    
    522
    
    
    
    523
    
    
    
    524
    
    
    
    525
    
    
    
    526
    
    
    
    527
    
    
    
    528
    
    
    
    529
    
    
    
    530
    
    
    
    531
    
    
    
    532
    
    
    
    533
    
    
    
    534
    
    
    
    535
    
    
    
    536
    
    
    
    537
    
    
    
    538
    
    
    
    539
    
    
    
    540
    
    
    
    541
    
    
    
    542
    
    
    
    543
    
    
    
    544
    
    
    
    545
    
    
    
    546
    
    
    
    547
    
    
    
    548
    
    
    
    549
    
    
    
    550
    
    
    
    551
    
    
    
    552
    
    
    
    553
    
    
    
    554
    
    
    
    555
    
    
    
    556
    
    
    
    557
    
    
    
    558
    
    
    
    559
    
    
    
    560
    
    
    
    561
    
    
    
    562
    
    
    
    563
    
    
    
    564
    
    
    
    565
    
    
    
    566
    
    
    
    567
    
    
    
    568
    
    
    
    569
    
    
    
    570
    
    
    
    571
    
    
    
    572
    
    
    
    573
    
    
    
    574
    
    
    
    575
    
    
    
    576
    
    
    
    577
    
    
    
    578
    
    
    
    579
    
    
    
    580
    
    
    
    581
    
    
    
    582
    
    
    
    583
    
    
    
    584
    
    
    
    585
    
    
    
    586
    
    
    
    587
    
    
    
    588
    
    
    
    589
    
    
    
    590
    
    
    
    591
    
    
    
    592
    
    
    
    593
    
    
    
    594
    
    
    
    595
    
    
    
    596
    
    
    
    597
    
    
    
    598
    
    
    
    599
    
    
    
    600
    
    
    
    601
    
    
    
    602
    
    
    
    603
    
    
    
    604
    
    
    
    605
    
    
    
    606
    
    
    
    607
    
    
    
    608
    
    
    
    609
    
    
    
    610
    
    
    
    611
    
    
    
    612
    
    
    
    613
    
    
    
    614
    
    
    
    615
    
    
    
    616
    
    
    
    617
    
    
    
    618
    
    
    
    619
    
    
    
    620
    
    
    
    621
    
    
    
    622
    
    
    
    623
    
    
    
    624
    
    
    
    625
    
    
    
    626
    
    
    
    627
    
    
    
    628
    
    
    
    629
    
    
    
    630
    
    
    
    631
    
    
    
    632
    
    
    
    633
    
    
    
    634
    
    
    
    635
    
    
    
    636
    
    
    
    637
    
    
    
    638
    
    
    
    639
    
    
    
    640
    
    
    
    641
    
    
    
    642
    
    
    
    643
    
    
    
    644
    
    
    
    645
    
    
    
    646
    
    
    
    647
    
    
    
    648
    
    
    
    649
    
    
    
    650
    
    
    
    651
    
    
    
    652
    
    
    
    653
    
    
    
    654
    
    
    
    655
    
    
    
    656
    
    
    
    657
    
    
    
    658
    
    
    
    659
    
    
    
    660
    
    
    
    661
    
    
    
    662
    
    
    
    663
    
    
    
    664
    
    
    
    665
    
    
    
    666
    
    
    
    667
    
    
    
    668
    
    
    
    669
    
    
    
    670
    
    
    
    671
    
    
    
    672
    
    
    
    673
    
    
    
    674
    
    
    
    675
    
    
    
    676
    
    
    
    677
    
    
    
    678
    
    
    
    679
    
    
    
    680
    
    
    
    681
    
    
    
    682
    
    
    
    683
    
    
    
    684
    
    
    
    685
    
    
    
    686
    
    
    
    687
    
    
    
    688
    
    
    
    689
    
    
    
    690
    
    
    
    691

测试方法

首先需要自己读取文件并设置相关的初始值
给出自己的一个样例

fid=fopen('near.pcm', 'rb'); % Load far end
ssin=fread(fid,inf,'float32');
fid=fopen('far.pcm', 'rb'); % Load fnear end
rrin=fread(fid,inf,'float32');
ssin=ssin(1:4096*200);
rrin=rrin(1:4096*200);
Fs=16000;
filter_length=4096;
frame_size=128;
speex_mdf_out = speex_mdf(Fs, rrin, ssin, filter_length, frame_size);
   
   
   
   
    
    
    
    1
    
    
    
    2
    
    
    
    3
    
    
    
    4
    
    
    
    5
    
    
    
    6
    
    
    
    7
    
    
    
    8
    
    
    
    9
    
    
    
    10

执行完之后，需要播放出来听：

sound(speex_mdf_out.e,16000)
   
   
   
   
    
    
    
    1

代码里名词术语

RERL:ERL+ERLE
RERL:residual_echo_return_loss
ERL:echo_return_loss
ERLE:echo_return_loss_enhancement
psd:power spectral density 功率谱密度
x: far end
d: near end
e: error
s: psd
nlp:non-linear processin

你可能感兴趣的:(回声消除)

IM音视频技术方案建议环信张翼
环信即时通讯平台提供了基于互联网和移动终端的实时语音、实时视频等通讯能力。环信将移动即时通讯能力通过API和客户端SDK包的方式提供给企业，帮助企业在自己的产品中便捷、快速的实现通讯和社交功能。2.1基础功能2.1.1视频能力环信支持基于IP网络的点对点实时语音和视频。通过多种技术包括自动增益控制、回声消除、抖动控制、丢包策略、动态带宽自适应等增强算法，保证高质量实时语音和视频体验。对于主流的多版
那些实时音视频开发中会用到开源项目攻城狮百里音视频音视频音视频开发 webrtc ffmpeg
实时音视频的开发学习有很多可以参考的开源项目。一个实时音视频应用共包括几个环节：采集、编码、前后处理、传输、解码、缓冲、渲染等很多环节。每一个细分环节，还有更细分的技术模块。比如，前后处理环节有美颜、滤镜、回声消除、噪声抑制等，采集有麦克风阵列等，编解码有VP8、VP9、H.264、H.265等。我们今天汇总了一些能帮助到正在学习或进行音视频开发的实时音视频开发者们的开源项目与几个也在为开源社区贡
18个实时音视频开发中会用到开源项目【零声教育】音视频开发进阶编程音视频开发程序员实时音视频开源 ffmpeg webrtc c++
实时音视频的开发学习有很多可以参考的开源项目。一个实时音视频应用共包括几个环节：采集、编码、前后处理、传输、解码、缓冲、渲染等很多环节。每一个细分环节，还有更细分的技术模块。比如，前后处理环节有美颜、滤镜、回声消除、噪声抑制等，采集有麦克风阵列等，编解码有VP8、VP9、H.264、H.265等。我们今天汇总了一些能帮助到正在学习或进行音视频开发的实时音视频开发者们的开源项目与几个也在为开源社区贡
AEC回声消除LMS算法与python实现周南音频科技教育学院(AI湖湘学派) 音频算法设计研究开发音频算法 python
加我微信hezkz17可以申请加入数字音频系统研究开发交流答疑群，加群附加赠送DSP音频项目核心开发资料，TWS降噪蓝牙耳机项目资料1通话场景2系统框图3算法运算4算法运算从维纳解到LMS5信号模块说明
智能音箱回声消除影响因素智能音箱设计人工智能智能音箱
1、何为回声消除回声消除（AcousticEchoCancellation，AEC），指通过自适应方法估计回波信号的大小，然后在接收信号中减去此估计值以抵消回波。2、回声消除的目的回声消除的目的是在音箱扬声器工作（播放音乐或语音）时，从麦克风中收集的信号中，去除自身播放的声音信号。否则，当音乐播放时，我们的声音信号会淹没在音乐声中，不能继续对音箱进行有效的语音控制。3、回声消除的原则麦克信号和回采
智慧灯杆sip广播可视对讲解决方案深圳锐科达网络音频设备音视频
智慧灯杆sip广播可视对讲解决方案智能路灯以城市公共设施的全面高效利用为出发点，根据路况加载智能照明、新能源汽车充电桩、城市广播、视频监控、WIFI热点、LED/LCD信息发布、环境监测、微型基站、停车场管理、井盖等。监控和USB手机充电灯功能，不仅能提高城市管理效率，还能方便民生服务，使得城市路灯照明达到“智能”状态。【方案概况】系统简介主要特点：一，采用数字音频处理技术，具有回声消除、噪声抑制
音视频通信 jaronho 音视频音视频
文章目录一、音视频通信流程二、流媒体协议1、RTSP2、RTMP3、HLS4、WebRTC一、音视频通信流程音视频通信完整流程有如下几个环节：采集、编码、前后处理、传输、解码、缓冲、渲染等。每一个细分环节，还有更细分的技术模块。比如，前后处理环节有美颜、滤镜、回声消除、噪声抑制等，采集有麦克风阵列等，编解码有H.263，H.264、H.265等。二、流媒体协议1、RTSPRTSP一般不用作直播场景
A2B音频总线在智能座舱中的应用怿星科技 HMI设计音视频汽车经验分享
01什么是A2B音频总线？车载A2B链路A2B全称是AutomotiveAudioBus，即车载音频总线。音频是智能座舱的核心功能，涵盖车载音响、语音识别、e-Call、消噪及回声消除等应用，随着汽车智能网联化的发展，对音频的开发要求也越来越高，需要加入更先进、功能丰富的信息娱乐功能以满足消费者的用户体验。但传统的模拟并行音频信号传输方式，难以在功能增加与整车轻量化（线缆的重量及成本减少）之间取得
开源音频处理代码 speex 全职编程-叶湫开源项目音视频 speex
Speex是一套主要针对语音的开源免费，无专利保护的音频压缩格式。speex是近年来开发出的一套功能强大的语音引擎，能够实现高质量和低比特率的编码。它不仅提供了基于码激励线性预测（CELP）算法的编/解码模块，而且在其最新发布的版本中还提供了声音预处理和声学回声消除模块，为保障IP网络中的语音通信质量提供了技术手段。此外，Speex还具有压缩后的比特率低（2.15~44.2kbps）的特点，并支持
前端声学信号处理—回声消除步履不停cyc
回声消除是前端声学信号处理的一个重要方法，本文针对回声的生成原理、回声消除应用场景及原理进行说明。一、回声消除（AEC）简介1.定义所谓的“回声”，是指设备本地扬声器播放的声音被麦克风采集之后形成的声学信号。回声消除就是指在保留本地用户语音的前提下，从麦克风采集的信号中消除这些回声的过程。因此使用回声消除算法解决的是设备扬声器和自身麦克风的耦合现象。2.使用场景目前最常见的两个场景是实时音视频通信
webrtc 设置不获取鼠标启用回声消除 shelutai webrtc 前端 javascript
数getDisplayMedia()（属于navigator.mediaDevices的一部分）与getUserMedia()类似，用于打开显示内容（或部分内容，如窗口）。返回的MediaStream与使用getUserMedia()时相同。显示鼠标与否getDisplayMedia()的约束条件与常规视频或音频输入资源的限制不同。{video:{cursor:'always'|'motion'|
WebRTC AEC回声消除算法拆解 heavy_truck WebRTC 信号处理系列讲解 webrtc 算法
WebRTCAEC算法流程分析——时延估计（一）其实，网上有很多类似资料，各个大厂研发不同应用场景设备的音频工程师基本都对其进行了拆解，有些闪烁其词，有些却很深奥，笔者随着对WebRTC了解的深入，逐渐感觉其算法构思巧夺天工，算法逻辑的设计也采用了很多技巧，这就导致没有一定的C语言基础，很难理解其精妙之处，笔者精读完之后不禁让拍案叫绝，作为交流，本系列文章有感而记之，并为来者谏。（笔者C代码水平有
音频特效生成与算法 3 _Rye_ 音频技术音视频语音识别人工智能
15｜AI变声：音频AI技术的集大成者AI技术在音频领域发展十分迅速。除了之前介绍的降噪、回声消除以及丢包补偿等方向可以用AI模型来提升音质听感之外，AI模型还有很多有趣的应用。其中比较常见的有ASR（AutomaticSpeechRecognition）可以理解为语音转文字，TTS（TextToSpeech）文字转语音和VPR（VoicePrintRecognition）声纹识别等。在之前说的音
音频处理之回声消除及调试经验 david_tym 传统音频音频
本文讲的回声（Echo）是指语音通信时产生的回声，即打电话时自己讲的话又从对方传回来被自己听到。回声在固话和手机上都有，小时还可以忍受，大时严重影响沟通交流，它是影响语音质量的重要因素之一。可能有的朋友要问了，为什么我打电话时没有听见自己的回声，那是因为市面上的成熟产品回声都被消除掉了。回声分为线路回声（lineecho）和声学回声（acousticecho），线路回声主要存在于固话中，是由于2-
回声消除-卡尔曼滤波 DEDSEC_Roger 语音技术音频
卡尔曼滤波卡尔曼滤波的设计过程中需要定义两个变量，一个是状态量，另一个是观测量状态量状态量是跟踪目标。将状态量记作xn\mathbf{x}_nxn，状态量的协方差矩阵记作Pn\mathbf{P}_nPn，可以由前一个时刻的状态，估计当前的状态估计过程表示为：xn=Fnxn−1\mathbf{x}_n=\mathbf{F}_n\mathbf{x}_{n-1}xn=Fnxn−1，其中xn\mathbf
回声消除 2 _Rye_ 音频技术语音识别网络人工智能
08｜回声消除算法实践上之前介绍了回声消除算法的基本原理。知道了回声消除会受到声学环境、采集播放设备等多种因素的影响。因此，要想实现一个鲁棒、高效的回声消除算法是一件比较有挑战的事情。而在实际的音频实时互动场景中，回声问题可能也是我们碰到的最多的问题之一。值得注意的是，音频处理往往是一环套一环的链路式的处理结构，回声消除作为音频前处理链路的一环很可能会对整体的音频体验产生影响。所以这次从整体上，了
回声消除实战 Learning together 音视频音视频
实时音频处理链路从贝尔实验室发明电话后，实时音频处理的技术不断发展，至今基于VoIP（VoiceoverInternetProtocol，基于IP的语音传输）的实时音频互动已经慢慢成为人们日常音频在线交流的主流方法。图1展示的就是这样一个“现代版”的基于VoIP的实时音频处理链路。实时音频可以分为上行链路和下行链路两个部分，其中上行链路中的音频处理步骤可以对应图1中的上半部分。我们可以看到，在采集
麦克风阵列技术二（自动增益控制自动噪声抑制回声消除语音活动检测） sxau_zhangtao 人工智能人机语音交互麦克风阵列技术自动增益控制自动噪声控制回声消除语音活动检测
麦克风阵列技术麦克风阵列技术详解自动增益控制自动增益处理分类AGC环自动噪声抑制原理及实现噪声噪声抑制的一般流程回声消除回声传统回声消除声学回声消除原理及实现语音活动检测音频端点检测原理及实现紧接上一个博客文章，此为第二部分。上一部分见：麦克风阵列技术一(名词解释背景介绍麦克风及音频信号麦克风阵列简介)麦克风阵列技术详解自动增益控制AGC：AutomaticGainControl，自动增益控制，使
麦克风阵列技术三（声源定位波束形成去混响麦克风阵列结构设计声学结构确认流程） sxau_zhangtao 人机语音交互人工智能声学结构确认流程声源定位波束形成去混响麦克风阵列结构设计
麦克风阵列技术麦克风阵列技术详解声源定位延时估计角度计算波束形成波束形成模型波束形成基本理论去混响麦克风阵列结构设计声学结构确认流程紧接上一个博客文章，此为第三部分。上一部分见：麦克风阵列技术二（自动增益控制自动噪声抑制回声消除语音活动检测）麦克风阵列技术详解声源定位麦克风阵列可以自动检测声源位置，跟踪说话人，声源定位信息既可以用于智能交互，也可以用于后续的空域滤波，对目标方向进行语音增强。利用麦
智能座舱架构与芯片- (9) 音频篇上风禾万里智能座舱架构音视频
一、音频总线音频是智能座舱的核心功能，涵盖车载音响、语音识别、e-Call、消噪及回声消除等应用，随着汽车智能网联化的发展，对音频的开发要求也越来越高。传统的车载音频系统采用模拟并行音频信号传输方式，难以在功能增加与整车轻量化（线缆的重量及成本减少）之间取得均衡。为了解决智能座舱空间中的音频问题，连接多个车内音频设备，需要有性能更高，效果更好的音频总线，用来连接和构建功能更丰富的车载音频系统。1.
【音视频开发】音频相关概念 - 总结 Van.Ghylivan 音视频开发音频音视频网络 ffmpeg
音频驱动（音频相关概念）音频驱动音频驱动（音频相关概念）声音定义声卡声道编解码PCM（脉冲编码调制）码率音频压缩编码有损压缩无损压缩无损压缩和有损压缩有损压缩无损压缩常见的编解码器常见的编码格式音频帧音频的算法处理回声消除高通滤波噪声消除（抑制）--webrtc[NS]声音定义声音是通过空气传播的一种连续的振动波，具有幅度和频率。物体的振动引起空气的震荡，人耳对这种震荡的感觉。声音用电信号表示时，
安克创新音频算法工程师(应届生)招聘凌逆战音视频
职位描述：负责音频处理算法的研发和优化，包括但不限于噪声抑制、回声消除、声反馈抑制、音效、声纹、唤醒、指令词识别等。持续跟进国际前沿技术方向，预研端侧可落地的音频技术，打造技术影响力。对音频处理系统进行模拟和实验，验证算法的性能，参与音频算法的性能评估和调试，解决实际应用中的问题。配合工程同学将算法落地至会议硬件、耳机、智能camera以及各种IOT和智能家居产品。职位要求：信号处理、计算机、电子
iOS AudioUnit 总结孙优秀丶Unique
iOSAudioUnit总结iOS的AudioUnit功能十分强大，使用图的形式连接各个节点，来实现我们不通的需求，AUGraph就是我们的图,，然后将AudioUnit连接到我们的图上面，就可以实现例如混音功能的实现。AudioUnit提供了低延迟的音频处理，可以实现，混音，回声消除，均衡器，压缩器，混响，滤波器等各个强大的功能。这里有一篇官方文档，图画的很nice以下综合几个不错的博客，混在一
Speex的移植和简单使用椰子～ linux 音视频
文章目录前言一、speex、speexdsp的简单介绍二、下载移植1.下载2.Linux下编译安装个人测试demo个人在工程中使用的部分代码前言只是小白在学习过程中的记录，可能存在错误。。。音频使用3A算法，Speex也支持。。3A:声学回声消除（AEC）、背景噪声抑制（ANS）、自动增益控制（AGC）三种音频算法的合称个人尝试之后发现，背景噪声消除效果较好，AEC和AGC似乎没什么用。。一、sp
speex算法在android上的移植 tinty_11 语音编程
最近在调speex接口参数，将speex算法的一些特性给添加进去，比如：降噪，静音检测，白噪声添加，增益等等。下面我们就先简单介绍一些spexx算法。speex语音算法主要是针对VOIP应用的一个开源算法，他集合了多种功能，除了如上所述的，还增加了回声消除（ACE）等功能，能够在多种平台进行应用。下面我主要介绍一下speex在android平台上的应用。首先我们来介绍一下speex算法的模块划分。
speex是一个专利免费/源码开源的dsp库软件架构师-叶秋常用软件开发工具推荐 SPEEX
https://www.speex.org/downloads/speex是一个专利免费/源码开源的dsp库。其包含预处理、回声消除、jitterbuffer、音频重采样、定点/浮点傅里叶变换等模块。speex库的API参考文档：speex-manual.pdf
Linphone 配置参数（噪音调试）々志尚
1，先找到跟语音相关的参数，其实有很多归纳一下无非就是回声消除参数、回声抑制参数、噪声处理参数、均衡器参数4个。2，要了解参数的用途。花费了一周时间还是值得的。agc=0#这个是自动增益，试过=1会啸叫回声消除的参数如下###echocancellation=1#回声消除这个必须=1，否则会听到自己说话的声音ec_tail_len=100#尾长表示回声时长，越长需要cpu处理能力越强ec_dela
QCC3071与QCC3072有什么区别？ TengTaiTech QCC307x/QCC517x 蓝牙 QCC QCC3071 QCC3072
特性QCC3071QCC3072蓝牙版本V5.3V5.3LEAudio支持支持支持24bit/96kHz高分辨率音频是是支持aptXVoice，可提高上行链路和下行链路的通话质量是是支持aptXAudio，包括aptXAdaptive是是Qualcomm®cVc™回声消除和噪声抑制(ECNS)技术最多3个麦克风最多2个麦克风支持Qualcomm自适应ANC-前馈、反馈、混合和自适应是否（支持高通混
回声消除 aec ai降噪唤醒sdk 自洽十点
https://blog.csdn.net/weixin_41733961/article/details/110918058https://blog.csdn.net/weixin_41733961/article/details/110870847https://blog.csdn.net/weixin_41733961/article/details/110876213
「专题速递」回声消除算法、低功耗音频、座舱音频系统、智能音频技术、低延时音效算法、手机外放增强算法... LiveVideoStack_ 音视频智能手机
随着多媒体和通信网络技术的持续升级，以及新型音视频应用场景的不断涌现，音频处理技术正朝着更加智能化和沉浸化的方向迅猛发展。人们对音频听觉体验的要求也逐渐提高，无论是在何种场景下，都期望获得更加清晰的声音，并感受到身临其境的沉浸感。在数字时代，音频已成为多媒体应用和通信的核心组成部分。从在线音乐流媒体到语音助手，从虚拟现实到远程会议，音频在各个领域都扮演着关键角色。为了满足用户的需求，音频技术不断演
[星球大战]阿纳金的背叛 comsci
本来杰迪圣殿的长老是不同意让阿纳金接受训练的......... 但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院
看懂它，你就可以任性的玩耍了！ aijuans JavaScript
javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 function jClass(b
Java常用工具包 Jodd Kai_Ge java jodd
Jodd 是一个开源的 Java 工具集，包含一些实用的工具类和小型框架。简单，却很强大！写道 Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb Jodd 被分成众多模块，按需选择，其中工具类模块有： jodd-core &nb
SpringMvc下载 120153216 springMVC
@RequestMapping(value = WebUrlConstant.DOWNLOAD) public void download(HttpServletRequest request,HttpServletResponse response,String fileName) { OutputStream os = null; InputStream is = null;
Python 标准异常总结 2002wmj python
Python标准异常总结 AssertionError 断言语句（assert）失败 AttributeError 尝试访问未知的对象属性 EOFError 用户输入文件末尾标志EOF（Ctrl+d） FloatingPointError 浮点计算错误 GeneratorExit generator.close()方法被调用的时候 ImportError 导入模块失
SQL函数返回临时表结构的数据用于查询 357029540 SQL Server
这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
java 时间格式化 | 比较大小| 时区个人笔记 7454103 java eclipse tomcat c MyEclipse
个人总结！不当之处多多包含！引用 1.0 如何设置 tomcat 的时区：位置：(catalina.bat---JAVA_OPTS 下面加上) set JAVA_OPT
时间获取Clander的用法 adminjun Clander 时间
/** * 得到几天前的时间 * @param d * @param day * @return */ public static Date getDateBefore(Date d,int day){ Calend
JVM初探与设置 aijuans java
JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
SQL中ON和WHERE的区别 avords
SQL中ON和WHERE的区别数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。 www.2cto.com 在使用left jion时，on和where条件的区别如下： 1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。
说说自信 houxinyou 工作生活
自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗? 无论工作还
WEBLOGIC事务超时设置 bijian1013 weblogic jta 事务超时
系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误：统计数据出错! 原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
两年已过去，再看该如何快速融入新团队 bingyingao java 互联网融入架构新团队
偶得的空闲，翻到了两年前的帖子该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
【Spark七十七】Spark分析Nginx和Apache的access.log bit1129 apache
Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式： Nginx的access.log解析正则表达式 val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
Erlang patch bookjovi erlang
Totally five patchs committed to erlang otp, just small patchs. IMO, erlang really is a interesting programming language, I really like its concurrency feature. but the functional programming style
log4j日志路径中加入日期 bro_feng java log4j
要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。实现方式 log4j: <appender name="serviceLog" class="org.apache.log4j.RollingFileAppender"> <param name="Encoding" v
读《研磨设计模式》-代码笔记-桥接模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /** * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
windows7下SVN和Eclipse插件安装 chenyu19891124 eclipse插件
今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
[转帖]工作流引擎设计思路 comsci 设计模式工作应用服务器 workflow 企业应用
作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 ================================================================================= 自开博以来不断有朋友来探讨工作流引擎该如何
Linux 查看内存，CPU及硬盘大小的方法 daizj linux cpu 内存硬盘大小
一、查看CPU信息的命令 [root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz model name :
linux 踢出在线用户 dongwei_6688 linux
两个步骤： 1.用w命令找到要踢出的用户，比如下面： [root@localhost ~]# w 18:16:55 up 39 days, 8:27, 3 users, load average: 0.03, 0.03, 0.00 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
放手吧,就像不曾拥有过一样 dcj3sjt126com
内容提要：静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
php二进制安全的含义 dcj3sjt126com PHP
PHP里，有string的概念。 string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。 byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
Linux下禁用T440s，X240的一体化触摸板(touchpad) gashero linux ThinkPad 触摸板
自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。 Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
graph_dfs hcx2013 Graph
package edu.xidian.graph; class MyStack { private final int SIZE = 20; private int[] st; private int top; public MyStack() { st = new int[SIZE]; top = -1; } public void push(i
Spring4.1新特性——Spring核心部分及其他 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
配置HiveServer2的安全策略之自定义用户名密码验证 liyonghui160com
具体从网上看 http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication LDAP Authentication using OpenLDAP Setting
一位30多的程序员生涯经验总结 pda158 编程工作生活咨询
1.客户在接触到产品之后，才会真正明白自己的需求。　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。 3.
分布式web服务架构的演变自由的奴隶 linux Web 应用服务器互联网
最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
初探Druid连接池之二——慢SQL日志记录 xingsan_zhang 日志连接池 druid 慢SQL
由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。 1.applicationContext.xml中增加如下配置： <bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc