function [d_bin, valid, Zf] = cfo_coarse_int(x, N, carrier_pilot, bins_search, Zi)

if (~isfield(Zi, 'valid'))
    Zi = struct('valid', 1, 'Xm', zeros(size(x)), 'Xv', zeros(size(x)), 'Zk', [], 'd_bin', []);
end

alpha = 0.01;
rho = 0.999;
k_boost = 4.0;
noise_eps = 1e-3;
max_window = 3;
noise_floor_k = 0.75*k_boost;

if 1
    bin_pilots = c2i(N, carrier_pilot)-1;
    bin_min = max(0, min(bin_pilots)-bins_search);
    bin_max = min(N-1, max(bin_pilots)+bins_search);
    
    Xk = zeros(size(x));
    valid = 0;
    d_bin = Zi.d_bin;
    Zk = fft(x, N);
    if ~isempty(Zi.Zk)
        Xk = Zk .* conj(Zi.Zk);
        Zi.Xm = (1-alpha)*Zi.Xm + alpha*Xk;
        Zi.Xv = Zi.Xv*rho;
        Zi.Xv = max(Zi.Xm, Zi.Xv);
        Xt = abs(Zi.Xv(bin_min+1:bin_max+1));

        xnoise = noiseFloor(Xt, noise_floor_k) + noise_eps;
        bins = bin_min+find_bins(Xt, xnoise, k_boost, max_window);
        
        if (~isempty(bins))
            k = 1;
            for b=1:length(bins)
                bin_c = bins(b);
                for n=1:length(bin_pilots)
                    bin_p = bin_pilots(n);
                    if (abs(bin_c - bin_p) < bins_search)
                        d_bin = [d_bin (bin_c - bin_p)];
                    end
                end
            end
            h = zeros(length(bin_pilots), 1);
            if length(d_bin) == length(bin_pilots)
                valid = 1;
                for k=1:length(d_bin)
                    for b=1:length(d_bin)
                        if d_bin(b) == d_bin(k)
                            h(k) = h(k) + 1;
                        end
                    end
                end
            end
        end
        
        if 1
            plot(bin_min+(0:length(Xt)-1), abs(Xt), '-*', bin_min+(0:length(Xt)-1), xnoise, 'g-'); grid;
            a = axis;
            hold on;
            if ~isempty(bins)
                for b=1:length(bins)
                    x = [bins(b) bins(b)];
                    y = [a(3) a(4)];
                    plot(x,y, 'r-');
                end
            end
            hold off;
            pause (0.01); 
        end
    end
    Zi.Zk = Zk;

end
Zf = Zi;
    
function bins = find_bins(x, xnoise, kboost, max_window)

bins = [];
for n=1:length(x)
    if (x(n) >= (kboost*xnoise(n)))
        smin = max(1, n-max_window);
        smax = min(length(x), n+max_window);
        [v, nn] = max(x(smin:smax));
        winner = nn + smin-2;
        if isempty(find(bins == winner))
            bins = [bins winner];  
        end
        n = min(length(x), n + max_window);
    end
end
bins = bins';

function y = noiseFloor(x, kn)
y = zeros(size(x));
y(1) = x(1);
for n=2:length(x)
    if (x(n) < kn*y(n-1))
        y(n) = 0.5*y(n-1) + 0.5*x(n);
    else
        y(n) = y(n-1);
    end
end