function pb=itera_decode_rayleigh(rho_in_dB,itera,dfhtrel,trel,K,formerstate1)
% this function simulate the iterative MAP decoding process
% of the DFH system in the multipath rayleigh fading channel

% information source
rho=10^(rho_in_dB/10);
sgma=sqrt(1/(2*rho));
len=1000;
source=[randint(1,len-K),zeros(1,K)];

% outer encoder 
code1=zeros(1,2*len);
code1=convenc(source,trel,[]);

% interleave the output of the outer encoder
inte_in=zeros(1,len);
inte_out=zeros(1,len); 
for i=1:len
    inte_in(i)=change2deci(code1(1,2*i-1:2*i),2);
end
posit=zeros(size(inte_out));
[inte_out,posit]=interleave(inte_in);

% generate transmitted frequency sequence 
nextstate=dfhtrel.nextstates;
formerstate=dfhtrel.formerstates;
fanout=dfhtrel.numinput;
number_of_out=dfhtrel.numoutput;
number_of_states=dfhtrel.numstates;
output=dfhtrel.outputs;
df=1;
fset=[0:df:df*(number_of_out-1)];
f=zeros(1,len);
P=0;
for i=1:len
    fnum=output(P+1,inte_out(i)+1);
    f(i)=fset(fnum+1);
    P=nextstate(P+1,inte_out(i)+1);
end

% raised cosine pulse shaping
T=1;
ts=1/128;
t=[0:ts:T-ts];
x=sqrt(2)*cos(2*pi*kron(f,t));
Delay=2*length(t);
R=0.5;
Fd=1;
Fs=4;
yf=rcosine(Fd,Fs,'fir/sqrt',R,Delay);
yo=rcosflt(x,Fd,Fs,'filter/Fs',yf);

% randomly generate multipath delay
%Mps=3;
%for k=1:2
    %while(1)
        %TausOri=rand(1,Mps);
        %TausOri=sort(TausOri,2);
        %Tausdelta=TausOri(:,2:Mps)-TausOri(:,1:Mps-1);
        %TuasSTD=sum((Tausdelta>0.1*ones(1,Mps-1))&(Tausdelta<0.3*ones(1,Mps-1)),2);
        %if(TuasSTD==Mps-1)
            %break
            %end
            %end
    %TausOri=TausOri-TausOri(1);
    %TausSam(k,:)=floor((10*TausOri/T)*length(t));
    %end

% generate inner encoder output and transmit in HF channel
TausOri=1.3
TausSam=floor((TausOri/T)*length(t)*Fs);
%pulse=sqrt(2)*cos(2*pi*kron(f,t));
%sig=zeros(2,3*len*length(t));
%for k=1:2
    %for pathID=1:Mps
        %fading(pathID,:)=kron(raylrnd(1/sqrt(2),1,len),ones(1,length(t)));
        %Tausam=TausSam(k,pathID);
        %sig(k,Tausam+1:Tausam+len*length(t))=sig(k,Tausam+1:Tausam+len*length(t))+...
            %fading(pathID,:).*pulse;
            %end
    %sigout(k,:)=sig(k,TausSam(k,1)+1:TausSam(k,1)+len*length(t));
    %sigout(k,:)=sigout(k,:)+sgma*randn(1,len*length(t));
    %end
Tausam=[0,TausSam];
sig=zeros(1,2*length(yo));
sig1=zeros(1,length(yo));
for k=1:2
    %fading(k,:)=kron(raylrnd(1/sqrt(2),1,len),ones(1,length(t)));
    %sig(Tausam(k)+1:Tausam(k)+len*length(t))=sig(Tausam(k)+1:Tausam(k)+len*length(t))+...
        %fading(k,:).*pulse+sgma*randn(1,len*length(t));
    sig(Tausam(k)+1:Tausam(k)+length(yo))=sig(Tausam(k)+1:Tausam(k)+length(yo))+yo;  
end
%signal=sig(Tausam(1)+1:Tausam(1)+len*length(t));
sig1=sig(1:length(yo));
yr=rcosflt(signal,Fd, Fs, 'filter/Fs',yf);
signal=yr(1+Fs*2*length(t):1+Fs*2*length(t)+Fs*length(t)*length(f)-1);

% switched diversity receive
%thresh=0.2;
%signal=zeros(1,len*length(t));
%step=50;
%swit=0;
%for i=1:step:len*length(t)-step+1
    %pow=(abs(sigout(swit+1,i)))^2;
    %if(pow<thresh)
        %swit=rem(swit+1,2);
        %signal(i:i+step-1)=sigout(swit+1,i:i+step-1);
        %else
        %signal(i:i+step-1)=sigout(swit+1,i:i+step-1);
        %end
        %end

% FFT processing
%demod=reshape(signal,length(t),len);
%demod=ts*fft(demod,128);
%Pdemod=demod.*conj(demod)/128;
%demod_input=Pdemod(1:64,:)./sgma^2;
demod=reshape(signal,Fs*length(t),len);
demod=fft(demod,512)/512;
Pdemod=demod.*conj(demod);

% iterative 
num_of_err=0;
extrin=zeros(fanout-1,len);
for j=0:itera-1
    inner_output=inner_decode(demod_input,extrin,nextstate,formerstate,fanout,number_of_states,output);
    outer_input=deinterleave(inner_output,posit);
    outer_out_c=outer_decode_c(outer_input,trel,formerstate1);
    extrin=interleave1(outer_out_c,posit);
end
inner_output=inner_decode(demod_input,extrin,nextstate,formerstate,fanout,number_of_states,output);
outer_input=deinterleave(inner_output,posit);
outer_out_u=outer_decode_u(outer_input,trel,formerstate1);
for j=1:len
    if(source(j)~=outer_out_u(j))
        num_of_err=num_of_err+1;
    end
end
pb=num_of_err/len;