def plot_response():
    thinkplot.preplot(cols=2)

    response = thinkdsp.read_wave("180961__kleeb__gunshots.wav")
    response = response.segment(start=0.26, duration=5.0)
    response.normalize()
    response.plot()
    thinkplot.config(xlabel="time", xlim=[0, 5.0], ylabel="amplitude", ylim=[-1.05, 1.05])

    thinkplot.subplot(2)
    transfer = response.make_spectrum()
    transfer.plot()
    thinkplot.config(xlabel="frequency", xlim=[0, 22500], ylabel="amplitude")

    thinkplot.save(root="systems6")

    wave = thinkdsp.read_wave("92002__jcveliz__violin-origional.wav")
    wave.ys = wave.ys[: len(response)]
    wave.normalize()
    spectrum = wave.make_spectrum()

    output = (spectrum * transfer).make_wave()
    output.normalize()

    wave.plot(color="0.7")
    output.plot(alpha=0.4)
    thinkplot.config(xlabel="time", xlim=[0, 5.0], ylabel="amplitude", ylim=[-1.05, 1.05])
    thinkplot.save(root="systems7")

def plot_bass():
    wave = thinkdsp.read_wave('328878__tzurkan__guitar-phrase-tzu.wav')
    wave.normalize()
    wave.plot()

    wave.make_spectrum(full=True).plot()


    sampled = sample(wave, 4)
    sampled.make_spectrum(full=True).plot()

    spectrum = sampled.make_spectrum(full=True)
    boxcar = make_boxcar(spectrum, 4)
    boxcar.plot()

    filtered = (spectrum * boxcar).make_wave()
    filtered.scale(4)
    filtered.make_spectrum(full=True).plot()

    plot_segments(wave, filtered)


    diff = wave.ys - filtered.ys
    #thinkplot.plot(diff)
    np.mean(abs(diff))

    sinc = boxcar.make_wave()
    ys = np.roll(sinc.ys, 50)
    thinkplot.plot(ys[:100])

def main():
    wave = thinkdsp.read_wave('328878__tzurkan__guitar-phrase-tzu.wav')
    wave.normalize()

    plot_sampling3(wave, 'sampling5')
    plot_sincs(wave)

    plot_beeps()
    plot_am()

    wave = thinkdsp.read_wave('263868__kevcio__amen-break-a-160-bpm.wav')
    wave.normalize()
    plot_impulses(wave)

    plot_sampling(wave, 'sampling3')
    plot_sampling2(wave, 'sampling4')

def plot_convolution():
    response = thinkdsp.read_wave("180961__kleeb__gunshots.wav")
    response = response.segment(start=0.26, duration=5.0)
    response.normalize()

    dt = 1
    shift = dt * response.framerate
    factor = 0.5

    gun2 = response + shifted_scaled(response, shift, factor)
    gun2.plot()
    thinkplot.config(xlabel="time (s)", ylabel="amplitude", ylim=[-1.05, 1.05], legend=False)
    thinkplot.save(root="systems8")

    signal = thinkdsp.SawtoothSignal(freq=410)
    wave = signal.make_wave(duration=0.1, framerate=response.framerate)

    total = 0
    for j, y in enumerate(wave.ys):
        total += shifted_scaled(response, j, y)

    total.normalize()

    wave.make_spectrum().plot(high=500, color="0.7", label="original")
    segment = total.segment(duration=0.2)
    segment.make_spectrum().plot(high=1000, label="convolved")
    thinkplot.config(xlabel="frequency (Hz)", ylabel="amplitude")
    thinkplot.save(root="systems9")

    def __init__(self,filename = "flesh_wound.wav", signal_type = "saw", pitch = 240, num_channel = 1024, num_band = 32):
        
        self.num_bands = num_band
        self.num_channels = num_channel

        if filename == 'record':
            chunk = 1024
            self.framerate = 41000
            self.pya = pyaudio.PyAudio() # initialize pyaudio
            self.stream = self.pya.open(format = pyaudio.paInt16,
               channels = 1,
               rate = self.framerate,
               input = True,
               output = True,
               frames_per_buffer = chunk)
            data = get_samples_from_mic(self.framerate,300,chunk)
            self.voice_wave = thinkdsp.Wave(data,self.framerate)
            self.stream.close()
            self.pya.terminate()
        else:
            self.voice_wave = thinkdsp.read_wave(filename) # read in recording
            self.framerate= self.voice_wave.framerate # determine framerate
            self.duration = self.voice_wave.duration # determine duration
        self.voice_wave.normalize
        self.signal_type = signal_type # list of the type of signals to generate
        self.pitch = pitch # list of fundementals for the generated waves        
        
        seg_voi = self.segmentor(self.voice_wave)        
        
        self.sig_wave = self.Sig_generate()
        seg_sig = self.segmentor(self.sig_wave)
        
        voded_wave = self.vocode(seg_voi,seg_sig)
        
        self.vocoded_wave = voded_wave

def segment_violin(start=1.2, duration=0.6):
    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    # extract a segment
    segment = wave.segment(start, duration)
    segment.normalize()
    segment.apodize()
    segment.write('violin_segment1.wav')

    # plot the spectrum
    spectrum = segment.make_spectrum()
    n = len(spectrum.hs)
    spectrum.plot(high=n/2)
    thinkplot.Save(root='violin2',
                   xlabel='frequency (Hz)',
                   ylabel='amplitude density')

    # print the top 5 peaks
    peaks = spectrum.peaks()
    for amp, freq in peaks[:10]:
        print freq, amp

    # compare the segments to a 440 Hz Triangle wave
    note = thinkdsp.make_note(69, 0.6, 
                              sig_cons=thinkdsp.TriangleSignal, 
                              framerate=segment.framerate)

    wfile = thinkdsp.WavFileWriter('violin_segment2.wav', note.framerate)
    wfile.write(note)
    wfile.write(segment)
    wfile.write(note)
    wfile.close()

def segment_violin(start=1.2, duration=0.6):
    """Load a violin recording and plot its spectrum.

    start: start time of the segment in seconds
    duration: in seconds
    """
    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    # extract a segment
    segment = wave.segment(start, duration)
    segment.normalize()

    # plot the spectrum
    spectrum = segment.make_spectrum()

    thinkplot.preplot(1)
    spectrum.plot(high=10000)
    thinkplot.Save(root='sounds3',
                   xlabel='Frequency (Hz)',
                   ylabel='Amplitude',
                   formats=FORMATS,
                   legend=False)

    # print the top 5 peaks
    peaks = spectrum.peaks()
    for amp, freq in peaks[:10]:
        print(freq, amp)

def segment_spectrum(filename, start, duration=1.0):
    """Plots the spectrum of a segment of a WAV file.

    Output file names are the given filename plus a suffix.

    filename: string
    start: start time in s
    duration: segment length in s
    """
    wave = thinkdsp.read_wave(filename)
    plot_waveform(wave)

    # extract a segment
    segment = wave.segment(start, duration)
    segment.ys = segment.ys[:1024]
    print len(segment.ys)

    segment.normalize()
    segment.apodize()
    spectrum = segment.make_spectrum()

    segment.play()

    # plot the spectrum
    n = len(spectrum.hs)
    spectrum.plot()

    thinkplot.save(root=filename,
                   xlabel='frequency (Hz)',
                   ylabel='amplitude density')

def violin_example(start=1.2, duration=0.6):
    """Demonstrates methods in the thinkdsp module.
    """
    # read the violin recording
    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    # extract a segment
    segment = wave.segment(start, duration)

    # make the spectrum
    spectrum = segment.make_spectrum()

    # apply a filter
    spectrum.low_pass(600)

    # invert the spectrum
    filtered = spectrum.make_wave()

    # prepare the original and filtered segments
    filtered.normalize()
    filtered.apodize()
    segment.apodize()

    # write the original and filtered segments to a file
    filename = 'filtered.wav'
    wfile = thinkdsp.WavFileWriter(filename, segment.framerate)
    wfile.write(segment)
    wfile.write(filtered)
    wfile.close()

    thinkdsp.play_wave(filename)

def main():
    
    # make_figures()

    wave = thinkdsp.read_wave('28042__bcjordan__voicedownbew.wav')
    wave.unbias()
    wave.normalize()
    track_pitch(wave)

    
    return


    thinkplot.preplot(rows=1, cols=2)
    plot_shifted(wave, 0.0003)
    thinkplot.config(xlabel='time (s)',
                     ylabel='amplitude',
                     ylim=[-1, 1])

    thinkplot.subplot(2)
    plot_shifted(wave, 0.00225)
    thinkplot.config(xlabel='time (s)',
                     ylim=[-1, 1])

    thinkplot.save(root='autocorr3')

def plot_amen2():
    wave = thinkdsp.read_wave('263868__kevcio__amen-break-a-160-bpm.wav')
    wave.normalize()

    ax1 = thinkplot.preplot(6, rows=4)
    wave.make_spectrum(full=True).plot(label='spectrum')
    xlim = [-22050-250, 22050]
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax2 = thinkplot.subplot(2)
    impulses = make_impulses(wave, 4)
    impulses.make_spectrum(full=True).plot(label='impulses')
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax3 = thinkplot.subplot(3)
    sampled = wave * impulses
    spectrum = sampled.make_spectrum(full=True)
    spectrum.plot(label='sampled')
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax4 = thinkplot.subplot(4)
    spectrum.low_pass(5512.5)
    spectrum.plot(label='filtered')
    thinkplot.config(xlim=xlim, xlabel='Frequency (Hz)')

    thinkplot.save(root='sampling4',
                   formats=FORMATS)

def plot_beeps():
    wave = thinkdsp.read_wave('253887__themusicalnomad__positive-beeps.wav')
    wave.normalize()

    thinkplot.preplot(3)

    # top left
    ax1 = plt.subplot2grid((4, 2), (0, 0), rowspan=2)
    plt.setp(ax1.get_xticklabels(), visible=False)

    wave.plot()
    thinkplot.config(title='Input waves', legend=False)

    # bottom left
    imp_sig = thinkdsp.Impulses([0.01, 0.4, 0.8, 1.2], 
                                amps=[1, 0.5, 0.25, 0.1])
    impulses = imp_sig.make_wave(start=0, duration=1.3, 
                                 framerate=wave.framerate)

    ax2 = plt.subplot2grid((4, 2), (2, 0), rowspan=2, sharex=ax1)
    impulses.plot()
    thinkplot.config(xlabel='Time (s)')

    # center right
    convolved = wave.convolve(impulses)

    ax3 = plt.subplot2grid((4, 2), (1, 1), rowspan=2)
    plt.title('Convolution')
    convolved.plot()
    thinkplot.config(xlabel='Time (s)')

    thinkplot.save(root='sampling1',
                   formats=FORMATS,
                   legend=False)

def read_response():
    """Reads the impulse response file and removes the initial silence.
    """
    response = thinkdsp.read_wave('180960__kleeb__gunshot.wav')
    start = 0.26
    response = response.segment(start=start)
    response.shift(-start)
    response.normalize()
    return response

def getSpectrum(start=0, duration=1, input_file="raw-epdf.wav", low_pass=22000, high_pass=20):
	# read the recording
	wave = thinkdsp.read_wave(input_file)

	segment = wave.segment(start, duration)
	spectrum = segment.make_spectrum()

	spectrum.low_pass(low_pass)
	spectrum.high_pass(high_pass)

	return spectrum

def violin_spectrogram():
    """Makes a spectrogram of a violin recording.
    """
    wave = thinkdsp.read_wave("92002__jcveliz__violin-origional.wav")

    seg_length = 2048
    spectrogram = wave.make_spectrogram(seg_length)
    spectrogram.plot(high=seg_length / 8)

    # TODO: try imshow?

    thinkplot.save("spectrogram1", xlabel="time (s)", ylabel="frequency (Hz)", formats=["pdf"])

def vocode_audiofiles(filepath_1, filepath_2, num_filters=20, chunk_size=1024):
    """
	"Fuses" two audiofiles using the Vocoder-algorithm.
	Note: If the length of the audiofiles differ, the longer file gets cut to the length of the shorter one.
	If the framerate differs, the file with the lower framerate is converted to the higher one, using the average-algorithm.
	# TODO: Implement what is described up there /\

	:param filepath_1 (str): Path to a .wav file
	:param filepath_2 (str): Path to a .wav file
	:param num_filters (int: Amount of filters the vocoder uses
	:param chunk_size (int): Size each chunk should have (debug)
	:return: toolset.Wave
	"""
    assert isinstance(filepath_1, str) and isinstance(filepath_1, str), "Filepaths must be of type %s" % type(" ")
    wave1 = toolset.to_wave(thinkdsp.read_wave(filepath_1))
    wave2 = toolset.to_wave(thinkdsp.read_wave(filepath_2))

    smaller_signal_length = min(wave1.length, wave2.length)

    result = np.zeros(smaller_signal_length - (smaller_signal_length % chunk_size))

    print "Starting to vocode two signals with length %i..." % smaller_signal_length

    vocoder = vc.Vocoder(wave1.framerate, np.hamming, num_filters, chunk_size)

    debug_num_chunks = len(result) / chunk_size - 1
    debug_factor = 100.0 / debug_num_chunks
    for i in range(len(result) / chunk_size - 1):
        # Status update:
        print "%g%% done, processing chunk no. %i out of %i " % (round(i * debug_factor, 2), i, debug_num_chunks)
        # Start - und ende des momentanen Chunks berechnen:
        start, end = i * chunk_size, (i + 1) * chunk_size
        # Modulator- und Carrier-Chunk "herausschneiden":
        modulator = toolset.Wave(wave1.ys[start:end], wave1.framerate)
        carrier = toolset.Wave(wave2.ys[start:end], wave2.framerate)
        # Vocoder-Effekt auf die beiden Signale Anwenden:
        result[start:end] = vocoder.vocode(modulator, carrier)

    print "~job's done~"
    return toolset.Wave(result, wave1.framerate)

def plot_amen():
    wave = thinkdsp.read_wave('263868__kevcio__amen-break-a-160-bpm.wav')
    wave.normalize()

    ax1 = thinkplot.preplot(2, rows=2)
    wave.make_spectrum(full=True).plot()

    xlim = [-22050, 22050]
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax2 = thinkplot.subplot(2, sharey=ax1)
    sampled = sample(wave, 4)
    sampled.make_spectrum(full=True).plot()
    thinkplot.config(xlim=xlim, xlabel='Frequency (Hz)')

    thinkplot.show()
    return

def plot_correlate():
    """Plots the autocorrelation function computed by np.
    """
    wave = thinkdsp.read_wave('28042__bcjordan__voicedownbew.wav')
    wave.normalize()
    segment = wave.segment(start=0.2, duration=0.01)

    lags, corrs = autocorr(segment)

    N = len(segment)
    corrs2 = np.correlate(segment.ys, segment.ys, mode='same')
    lags = np.arange(-N//2, N//2)
    thinkplot.plot(lags, corrs2)
    thinkplot.config(xlabel='Lag', 
                     ylabel='Correlation', 
                     xlim=[-N//2, N//2])
    thinkplot.save(root='autocorr9')

def plot_tuning(start=7.0, duration=0.006835):
    """Plots three cycles of a tuning fork playing A4.

    duration: float
    """
    period = duration/3
    freq = 1/period
    print period, freq

    wave = thinkdsp.read_wave('18871__zippi1__sound-bell-440hz.wav')

    segment = wave.segment(start, duration)
    segment.normalize()

    segment.plot()
    thinkplot.Save(root='tuning1',
                   xlabel='time (s)',
                   axis=[0, duration, -1.05, 1.05])

def plot_violin(start=1.30245, duration=0.00683):
    """Plots three cycles of a violin playing A4.

    duration: float
    """
    period = duration/3
    freq = 1/period
    print freq

    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    segment = wave.segment(start, duration)
    segment.normalize()

    segment.plot()
    thinkplot.Save(root='violin1',
                   xlabel='time (s)',
                   axis=[0, duration, -1.05, 1.05])