ksstringexpofn.m

非常好的数字处理教程

function ksksstringexpofn(action, datastruct)

    if nargin < 1
        action='init';
    end

	name = mfilename;
	figname = [name(1:end-2) '_fig'];
	f=findobj('Tag',figname);
    handles = get(f,'UserData');
    
    switch action
		case 'help'
			display_help(figname);
		case 'init'
				setdefaults;
				set(handles.loss_text,'Enable','inactive');
				%movegui(f,'center');

				set(handles.play,'Visible','off');
				set(handles.notestart_text,'Visible','off');
				set(handles.noteend_text,'Visible','off');
				set(handles.transpose_text,'Visible','off');
				set(handles.pianoroll,'Visible','off');
				set(handles.wetness_inst,'Visible','off');
				set(handles.wetness_room,'Visible','off');
		case 'resize'
				movegui(f,'onscreen');
		case 'play'
            if isfield(handles, 'audiodata');
                
                audiodata = handles.audiodata;
                if max(abs(audiodata.data)) > 0.9
                    audiodata.data = normalize(audiodata.data);
                end
                if (max(abs(audiodata.data)) > 1.0)
                    audiodata.data = normalize(audiodata.data);
                end
                play_audiodata(audiodata, handles.play);
            end

		case 'synthesize'
            if isfield(handles, 'mididata')
                startnote = str2num(get(handles.notestart_text,'String'));
                endnote = str2num(get(handles.noteend_text,'String'));
                
                if startnote > endnote
                    endnote = startnote;
                    set(handles.noteend_text,'String',num2str(endnote));
                end
                
                %numnotes = endnote - startnote + 1;
                Fs = str2num(get(handles.Fs_text,'String'));
                tempo = str2num(get(handles.tempo_text,'String'));
                temposcale = handles.mididata.tempo/tempo;
                
                set(handles.play,'Visible','off');
                %(delta time,absolute time, midi note number, note
                % duration, note velocity, channel)
                synth = [];
                
                % resample impulse responses
                if isfield(handles,'impulse_inst')
                    if handles.impulse_inst.Fs ~= Fs
                        impulse = resample(handles.impulse_inst.data,Fs,handles.impulse_inst.Fs);
                    else
                        impulse = handles.impulse_inst.data;
                    end
                    handles.impulse_instdata = impulse;
                end
                
                if isfield(handles,'impulse_room')
                    if handles.impulse_room.Fs ~= Fs
                        impulse = resample(handles.impulse_room.data,Fs,handles.impulse_room.Fs);
                    else
                        impulse = handles.impulse_room.data;
                    end
                    handles.impulse_roomdata = impulse;
                end
        
                handles.msgbox = waitbar(0,'Synthesizing...');
                for i=startnote:endnote
                    freq = 440*2^((handles.mididata.data(i,3)-69)/12);
                    set(handles.frequency_text,'String',num2str(freq));
                    amp = handles.mididata.data(i,5)/128/2;
                    set(handles.amplitude_text,'String',num2str(amp));
                    dur = handles.mididata.data(i,4)* ...
                        handles.mididata.ms_per_tick/1000*temposcale;
                    set(handles.duration_text,'String',num2str(dur));
                    if (dur > 0)
                        handles = synthesize(handles);
                        y = handles.audiodata.data;

                        starttime = (handles.mididata.data(i,2) - ...
                            handles.mididata.data(startnote,2))* ...
                            handles.mididata.ms_per_tick/1000*temposcale;
                        startindex = floor(starttime*Fs)+1;
                        endindex = startindex + size(y,1) - 1;
                        if size(synth,1) < endindex
                            synth = [synth; zeros(endindex-size(synth,1),size(y,2))];
                        end

                        synth(startindex:endindex,:) = ...
                            synth(startindex:endindex,:) + y;
                    end
                    waitbar((i-startnote+1)/(endnote-startnote+1),handles.msgbox);
                end
                close(handles.msgbox);
                handles.audiodata.data = synth;
                handles.audiodata.Fs = str2num(get(handles.Fs_text,'String'));
                set(handles.play,'Visible','on');
            else
                handles.msgbox = waitbar(0,'Synthesizing...');
                set(handles.play,'Visible','off');
                handles = synthesize(handles);
                set(handles.play,'Visible','on');
                waitbar(100,handles.msgbox);
                close(handles.msgbox);
            end
        case 'instmenu'
            contents = get(handles.instmenu,'String');
            switch contents{get(handles.instmenu,'Value')}
                case 'None'
                    if isfield(handles,'impulse_inst')
                        handles = rmfield(handles,'impulse_inst');
                        set(handles.infobox_inst,'String',{''});
                    end
                case 'Load'
                    handles.impulse_inst = load_audiodata;

                    filename = handles.impulse_inst.filenamepath;
                    [t,r] = strtok(filename,'/');
                    while ~isempty(r)
                        [t,r] = strtok(r,'/');
                    end
                    info = {...
                        ['Name: ' t]; ...
                        ['Fs: ' num2str(handles.impulse_inst.Fs)]; ...
                        ['Length: ' num2str(size(handles.impulse_inst.data,1))]; ...
                        ['Channels: ' num2str(size(handles.impulse_inst.data,2))]};
                    set(handles.infobox_inst,'String', info);
                    set(handles.wetness_inst,'Visible','on');
            
            end
        case 'roommenu'
            contents = get(handles.roommenu,'String');
            switch contents{get(handles.roommenu,'Value')}
                case 'None'
                    if isfield(handles,'impulse_room')
                        handles = rmfield(handles,'impulse_room');
                        set(handles.infobox_room,'String','');
                    end
                case 'Load'
                    handles.impulse_room = load_audiodata;

                    filename = handles.impulse_room.filenamepath;
                    [t,r] = strtok(filename,'/');
                    while ~isempty(r)
                        [t,r] = strtok(r,'/');
                    end
                    info = {...
                        ['Name: ' t]; ...
                        ['Fs: ' num2str(handles.impulse_room.Fs)]; ...
                        ['Length: ' num2str(size(handles.impulse_room.data,1))]; ...
                        ['Channels: ' num2str(size(handles.impulse_room.data,2))]};
                    set(handles.infobox_room,'String', info);
                    set(handles.wetness_room,'Visible','on');
            end
        case 'synthmenu'
            contents = get(handles.synthmenu,'String');
            switch contents{get(handles.synthmenu,'Value')}
                case 'Load'
                    savedir = pwd;
                    cd([ssumroot, 'data/MIDI']);
                    [filename,path] = uigetfile({'*.mid','MIDI (*.mid)';'*.*',...
                        'All files (*.*)'}, 'Select a MIDI file');
                    filenamepath = [path filename];
                    cd(savedir);

                    % Load MIDI data
                    [midi,info,ext,ms_per_quarter,ms_per_tick] ...
                        = midird3(filenamepath);
                    % Merge all tracks to one
                    midi = MergeTracks(midi);
                    %(delta time,absolute time, midi note number, note duration, note velocity, channel)
                    handles.mididata.data = midi;
                    handles.mididata.ms_per_tick = ms_per_tick;
                    handles.mididata.filename = filename;
                    duration = handles.mididata.data(end,2)*ms_per_tick/1000;
                    numnotes = size(handles.mididata.data,1);
                    handles.mididata.tempo = 1/(ms_per_quarter/1000)*60;
                    info = {...
                        ['Name: ' filename]; ...
                        ['Number of notes: ' num2str(numnotes)]; ...
                        ['Duration: ' num2str(duration) ' s']; ...
                        ['Tempo: ' num2str(handles.mididata.tempo)]};
                    set(handles.infobox_synth,'String', info);
                    set(handles.tempo_text,'String',num2str(handles.mididata.tempo));
                    set(handles.noteend_text,'String',num2str(numnotes));
                    
                    set(handles.notestart_text,'Visible','on');
                    set(handles.noteend_text,'Visible','on');
                    set(handles.tempo_text,'Visible','on');
                    set(handles.pianoroll,'Visible','on');
                    set(handles.transpose_text,'Visible','on');
                    set(handles.duration_text,'Enable','inactive');
                    set(handles.frequency_text,'Enable','inactive');
                    set(handles.amplitude_text,'Enable','inactive');
                case 'Note'
                    if isfield(handles,'mididata')
                        handles = rmfield(handles,'mididata');
                        set(handles.infobox_synth,'String','');
                    end
                    set(handles.notestart_text,'Visible','off');
                    set(handles.noteend_text,'Visible','off');
                    set(handles.tempo_text,'Visible','off');
                    set(handles.pianoroll,'Visible','off');
                    set(handles.transpose_text,'Visible','off');
                    set(handles.duration_text,'Enable','on');
                    set(handles.frequency_text,'Enable','on');
                    set(handles.amplitude_text,'Enable','on');
            end
        case {'fourierexpo', 'sonoexpo','reverbexpo'}
            if isfield(handles,'audiodata')
                audiodata = handles.audiodata;
                switch action
                    case 'fourierexpo'
                        fourierexpogui(audiodata);
                    case 'sonoexpo'
                        sonoexpogui(audiodata);
                    case 'reverbexpo'
                        reverbexpogui(audiodata);
                end
            end
        case 'pianoroll'
            if isfield(handles, 'mididata');
                startnote = str2num(get(handles.notestart_text,'String'));
                endnote = str2num(get(handles.noteend_text,'String'));
                if startnote > endnote
                    endnote = startnote;
                    set(handles.noteend_text,'String',num2str(endnote));
                end
                pianoroll(handles.mididata,1,startnote,endnote)
            end
        case 'fourier_room'
            if isfield(handles,'impulse_room'),
                fourierexpogui(handles.impulse_room);
            end
        case 'fourier_inst'
            if isfield(handles,'impulse_inst'),
                fourierexpogui(handles.impulse_inst);
            end
        case 'save'
            if isfield(handles,'audiodata')
                save_audiodata(handles.audiodata);
            end
		case 'print'
			print_figure(f);
		case 'close'
			close_figure(f,figname(1:end-4));
			return;
	end
	set(f,'UserData',handles);
    
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function ud = synthesize(ud)
    % Taken in large part from Julius Smith's paper in CMJ
    Fs = str2num(get(ud.Fs_text,'String'));
    duration = str2num(get(ud.duration_text,'String'));
    transpose = str2num(get(ud.transpose_text,'String')); % General volume scaling
    
    amp = str2num(get(ud.duration_text,'String'));
    freq = transpose*str2num(get(ud.frequency_text,'String'));
    delay_length = round(Fs/freq/2);
    if delay_length < 1
        delay_length = 1;
    end

    % For later, design fractional delay allpass
    %[num,den] = designAllpass(Fs/freq/2+1);

    excite_position = str2num(get(ud.excitepos_text,'String'));
    loss = 1.0 - str2num(get(ud.loss_text,'String'));
    pickups = floor(str2num(get(ud.pickups_text,'String')).*delay_length);
    numsamples = ceil(Fs*duration);

    % Initialize string

    excitepos = floor(delay_length*excite_position+1);
    if excitepos > delay_length
        excitepos = delay_length-1;