lpc_project.m

LPC vocoder LPC vocoder with several option Graphical user interface Also included several .wav f

        for k=0:order_Callback(source,eventdata)
            Rn(k+1,i)=autocorr(k,WINDOW_DATA(:,i)); %find autocorrelations
        end
    [alpha(:,i),G(1,i)]=durbin_method(Rn(:,i),order_Callback(source,...
        eventdata));
    end
    
    %save('gains.mat','G');
    %save('alphas.mat','alpha');
    
    %Determine real excitation function for debug mode
        %Ge = SpeechDebug3(DATA,alpha,SHIFT,G,size(Y,1));
        %size(Ge)

    
    %Find LPC Spectrum and actual Spectrum for each frame
    gain=ones(fftSize_Callback(source,eventdata),NFRAMES);
    for i=1:NFRAMES
        gain(:,i)=G(1,i)*gain(:,i);
    end
    LPC_SpecG=gain./fft([ones(1,NFRAMES);-alpha],...
        fftSize_Callback(source,eventdata));
    LPC_Spec=1./fft([ones(1,NFRAMES);-alpha],fftSize_Callback(source,...
        eventdata));
    Spec=fft(WINDOW_DATA,fftSize_Callback(source,eventdata));
    
    %Generate Excitation Function and Filter Excitation Function with LPC
    %Spectrum
    pulse=excitation(Y,asynch_m,PP);
    [PULSE_DATA,PFRAMES]=frames(pulse,SHIFT,frame_size);
    PULSE_DATA=PULSE_DATA(:,1:NFRAMES);
    gain=ones(frame_size,NFRAMES);
    for i=1:NFRAMES
        gain(:,i)=G(1,i)*gain(:,i);
    end
    G_PULSE_DATA=gain.*PULSE_DATA;
    PULSE_SPEC=fft(PULSE_DATA,fftSize_Callback(source,eventdata));
    PULSE_SPECTRUM=fft(G_PULSE_DATA,fftSize_Callback(source,eventdata));
    Y_HAT_DATA=PULSE_SPECTRUM.*LPC_Spec;
    
    %Resynthesize Speech
    Y_HAT=synthesize(Y_HAT_DATA,fftSize_Callback(source,eventdata),...
        w_hat,NFRAMES,SHIFT,size(Y,1));
    %sound(Y/max(abs(Y)),FS);
    %sound(Y_HAT/max(abs(Y_HAT)),FS);
    
    %Gather data for graphical display
        
    spectra(:,:,1)=20*log10(abs(Spec)); %original signal frequency domain
    temporal(:,:,1)=DATA; %original signal time domain
    
    LPC_HAT=synthesize(LPC_SpecG,fftSize_Callback(source,eventdata),...
        w_hat,NFRAMES,SHIFT,size(Y,1));
    [LPC_DATA,LFRAMES]=frames(LPC_HAT,SHIFT,frame_size);
    LPC_DATA=LPC_DATA(:,1:NFRAMES);
    spectra(:,:,2)=20*log10(abs(LPC_SpecG)); %LPC signal frequency domain
    temporal(:,:,2)=LPC_DATA; %LPC signal time domain
    
    [Ysynth_DATA,YFRAMES]=frames(Y_HAT,SHIFT,frame_size);
    Ysynth_DATA=Ysynth_DATA(:,1:NFRAMES);
    spectra(:,:,3)=20*log10(abs(Y_HAT_DATA)); %synthesized signal frequency domain
    temporal(:,:,3)=Ysynth_DATA; %synthesized signal time domain
    
    spectra(:,:,4)=20*log10(abs(PULSE_SPECTRUM)); %excitation signal frequency domain
    temporal(:,:,4)=PULSE_DATA; %excitation signal time domain %
    
    %temporal(:,:,5)=Ge;
    
    spectra=spectra(1:fftSize_Callback(source,eventdata)/2,:,:); %
    
    curFrame=round(NFRAMES/2); %
    
    t=(0:(size(Y,1)-1))*(1000/FS);
    t=transpose(t);
    [t_frame,xFRAMES]=frames(t,SHIFT,frame_size);
    t_frame=t_frame(:,1:NFRAMES); %
    f=FS/2*linspace(0,1,fftSize_Callback(source,eventdata)/2); %
    
    Graphics_Output
       
toc
end
    
    function Graphics_Output
    axes(h);
    if state1 == 1
        plot(f,spectra(:,curFrame,1),'r');
        hold on;
    end
    if state2 == 1
        plot(f,spectra(:,curFrame,2),'b');
        hold on;
    end
    if state3 == 1
        plot(f,spectra(:,curFrame,3),'g');
        hold on;
    end
    if state4 == 1
        plot(f,spectra(:,curFrame,4),'m');
    end
    hold off;
    xlabel('Frequency (Hz)');
    ylabel('Magnitude (dB)');
    title('Signal Spectra Comparisons');
    AXIS tight;
    
    axes(ha);
    if state1 == 1
        plot(t_frame(:,curFrame),temporal(:,curFrame,...
            1)/max(abs(temporal(:,curFrame,1))),'r');
        hold on;
    end
    if state2 == 1
        plot(t_frame(:,curFrame),temporal(:,curFrame,...
            2)/max(abs(temporal(:,curFrame,2))),'b');
        hold on;
    end
    if state3 == 1
        plot(t_frame(:,curFrame),temporal(:,curFrame,...
            3)/max(abs(temporal(:,curFrame,3))),'g');
        hold on;
    end
    if state4 == 1
        plot(t_frame(:,curFrame),temporal(:,curFrame,...
            4)/max(abs(temporal(:,curFrame,4))),'m');
        hold on;
    end
    %plot(t_frame(:,curFrame),temporal(:,curFrame,5)/max(abs(temporal(:,curFrame,5))),'k');
    hold off;
    xlabel('Time (ms)');
    ylabel('Amplitude');
    title('Temporal Signal Comparisons');
    AXIS tight;
    end

function Speech_File = S_File_Callback(source,eventdata)
    Speech_File = get(S_File,'String');
end

function Pitch_File = P_File_Callback(source,eventdata)
    Pitch_File = get(P_File,'String');
end

function m = measure_Callback(source,eventdata) 
    m = str2num(get(measure,'String'));
end

function f_dur = fd_Callback(source,eventdata)
    f_dur = str2num(get(fd,'String'));
end

function overlap = fo_Callback(source,eventdata)
    overlap = str2num(get(fo,'String'));
end

function [str,val] = winType_Callback(source,eventdata) 
    str = get(winType, 'String');
    val = get(winType,'Value');
end

function NFFT = fftSize_Callback(source,eventdata) 
    NFFT = str2num(get(fftSize,'String'));
end

function p = order_Callback(source,eventdata) 
    p = str2num(get(order,'String'));
end

function backbutton_Callback(source,eventdata)
    if curFrame>1
        curFrame=curFrame-1;
        Graphics_Output;
    end
end

function startbutton_Callback(source,eventdata)
    if curFrame>1
        curFrame=1;
        Graphics_Output;
    end
end

function forwardbutton_Callback(source,eventdata)
    if curFrame<NFRAMES
        curFrame=curFrame+1;
        Graphics_Output;
    end
end

function finishbutton_Callback(source,eventdata)
    if curFrame<NFRAMES
        curFrame=NFRAMES;
        Graphics_Output;
    end
end


function original_Callback(source,eventdata)
    if (get(original,'Value') == get(original,'Max'))
        state1=1;
        Graphics_Output;
    else
        state1=0;
        Graphics_Output;
    end
end

function originalbutton_Callback(source,eventdata)
    sound(Y/max(abs(Y)),FS);
end

function LPC_Callback(source,eventdata)
    if (get(LPC_SIG,'Value') == get(original,'Max'))
        state2=1;
        Graphics_Output;
    else
        state2=0;
        Graphics_Output;
    end
end

function LPCbutton_Callback(source,eventdata)
end

function syn_Callback(source,eventdata)
    if (get(syn_sig,'Value') == get(original,'Max'))
        state3=1;
        Graphics_Output;
    else
        state3=0;
        Graphics_Output;
    end
end

function syn_sigbutton_Callback(source,eventdata)
    sound(Y_HAT/max(abs(Y_HAT)),FS);
end

function excit_Callback(source,eventdata)
    if (get(excit_sig,'Value') == get(original,'Max'))
        state4=1;
        Graphics_Output;
    else
        state4=0;
        Graphics_Output;
    end
end

function excitbutton_Callback(source,eventdata)
end

end