Ejemplo n.º 1
0
def prepare_audio_filters():
	forder = 256 
	forderd = 0 

	tf_rangel = 100000
	tf_rangeh = 170000
	# audio filters
	tf = SP['audio_lfreq']
	N, Wn = sps.buttord([(tf-tf_rangel) / (freq_hz / 2.0), (tf+tf_rangel) / (freq_hz / 2.0)], [(tf-tf_rangeh) / (freq_hz / 2.0), (tf+tf_rangeh)/(freq_hz / 2.0)], 1, 15)
	Baudl, Aaudl = sps.butter(N, Wn, btype='bandpass')

	tf = SP['audio_rfreq']
	N, Wn = sps.buttord([(tf-tf_rangel) / (freq_hz / 2.0), (tf+tf_rangel) / (freq_hz / 2.0)], [(tf-tf_rangeh) / (freq_hz / 2.0), (tf+tf_rangeh)/(freq_hz / 2.0)], 1, 15)
	N, Wn = sps.buttord([(tf-tf_rangel) / (freq_hz / 2.0), (tf+tf_rangel) / (freq_hz / 2.0)], [(tf-tf_rangeh) / (freq_hz / 2.0), (tf+tf_rangeh)/(freq_hz / 2.0)], 5, 15)
	Baudr, Aaudr = sps.butter(N, Wn, btype='bandpass')

	N, Wn = sps.buttord(0.016 / (afreq / 2.0), 0.024 / (afreq / 2.0), 2, 15) 
	audiolp_filter_b, audiolp_filter_a = sps.butter(N, Wn)
	
	# USE FIR
	audiolp_filter_b = sps.firwin(257, .020 / (afreq / 2.0))
	audiolp_filter_a = [1.0]

	N, Wn = sps.buttord(3.1 / (freq / 2.0), 3.5 / (freq / 2.0), 1, 20) 
	audiorf_filter_b, audiorf_filter_a = sps.butter(N, Wn, btype='lowpass')

	[Baudrf_FDLS, Aaudrf_FDLS] = fdls.FDLS_fromfilt(audiorf_filter_b, audiorf_filter_a, forder, forderd, 0)
	SP['fft_audiorf_lpf'] = Faudrf = np.fft.fft(Baudrf_FDLS, blocklen)

	[Baudiolp_FDLS, Aaudiolp_FDLS] = fdls.FDLS_fromfilt(audiolp_filter_b, audiolp_filter_a, forder, forderd, 0)

	FiltAPost = np.fft.fft(Baudiolp_FDLS, blocklen)
	SP['fft_audiolpf'] = FiltAPost * FiltAPost #* FiltAPost

	[Baudl_FDLS, Aaudl_FDLS] = fdls.FDLS_fromfilt(Baudl, Aaudl, forder, forderd, 0)
	[Baudr_FDLS, Aaudr_FDLS] = fdls.FDLS_fromfilt(Baudr, Aaudr, forder, forderd, 0)

	Faudl = np.fft.fft(Baudl_FDLS, blocklen)
	Faudr = np.fft.fft(Baudr_FDLS, blocklen)

	SP['fft_audio_left'] = Faudrf * Faudl * fft_hilbert
	SP['fft_audio_right'] = Faudrf * Faudr * fft_hilbert
Ejemplo n.º 2
0
def prepare_video_filters():
	# TODO:  test these CLV+innerCAV parameters.  Should be same on PAL+NTSC 
	t1 = 25
	t2 = 13.75
	
	[tf_b, tf_a] = sps.zpk2tf(-t2*(10**-8), -t1*(10**-8), t1 / t2)
	SP['f_emp'] = sps.bilinear(tf_b, tf_a, 1/(freq_hz/2))

	# RF BPF and analog audio cut filters
	SP['f_videorf_bpf'] = sps.butter(1, [SP['vbpf'][0]/(freq_hz/2), SP['vbpf'][1]/(freq_hz/2)], btype='bandpass')

	if SP['analog_audio'] == True:
		SP['f_aleft_stop'] = sps.butter(1, [(SP['audio_lfreq'] - 750000)/(freq_hz/2), (SP['audio_lfreq'] + 750000)/(freq_hz/2)], btype='bandstop')
		SP['f_aright_stop'] = sps.butter(1, [(SP['audio_rfreq'] - 750000)/(freq_hz/2), (SP['audio_rfreq'] + 750000)/(freq_hz/2)], btype='bandstop')

	# standard post-demod LPF
	lowpass_filter_b, lowpass_filter_a = sps.butter(SP['vlpf_order'], SP['vlpf_freq']/(freq_hz/2), 'low')
	
	# post-demod deemphasis filter
	[tf_b, tf_a] = sps.zpk2tf(-SP['deemp'][1]*(10**-8), -SP['deemp'][0]*(10**-8), SP['deemp'][0] / SP['deemp'][1])
	SP['f_deemp'] = sps.bilinear(tf_b, tf_a, 1/(freq_hz/2))

	# if AC3:
	#SP['f_arightcut'] = sps.butter(1, [(2650000)/(freq_hz/2), (3150000)/(freq_hz/2)], btype='bandstop')

	# prepare for FFT: convert above filters to FIR using FDLS techniques first
	forder = 256 
	forderd = 0 

	[Bbpf_FDLS, Abpf_FDLS] = fdls.FDLS_fromfilt(SP['f_videorf_bpf'][0], SP['f_videorf_bpf'][1], forder, forderd, 0, phasemult = 1.00)
	[Bemp_FDLS, Aemp_FDLS] = fdls.FDLS_fromfilt(SP['f_emp'][0], SP['f_emp'][1], forder, forderd, 0)
	[Bdeemp_FDLS, Adeemp_FDLS] = fdls.FDLS_fromfilt(SP['f_deemp'][0], SP['f_deemp'][1], forder, forderd, 0)
	[Bplpf_FDLS, Aplpf_FDLS] = fdls.FDLS_fromfilt(lowpass_filter_b, lowpass_filter_a, forder, forderd, 0)

	Fbpf = np.fft.fft(Bbpf_FDLS, blocklen)
	Femp = np.fft.fft(Bemp_FDLS, blocklen)

	SP['fft_video'] = Fbpf * fft_hilbert

	if SP['analog_audio'] == True:
		[Bcutl_FDLS, Acutl_FDLS] = fdls.FDLS_fromfilt(SP['f_aleft_stop'][0], SP['f_aleft_stop'][1], forder, forderd, 0, phasemult = 1.00)
		[Bcutr_FDLS, Acutr_FDLS] = fdls.FDLS_fromfilt(SP['f_aright_stop'][0], SP['f_aright_stop'][1], forder, forderd, 0, phasemult = 1.00)
		Fcutl = np.fft.fft(Bcutl_FDLS, blocklen)
		Fcutr = np.fft.fft(Bcutr_FDLS, blocklen)
		SP['fft_video'] *= (Fcutl * Fcutr)
	
	SP['fft_video_inner'] = SP['fft_video'] * Femp

	# Post processing:  lowpass filter + deemp
	Fplpf = np.fft.fft(Bplpf_FDLS, blocklen)
	Fdeemp = np.fft.fft(Bdeemp_FDLS, blocklen)
	SP['fft_post'] = Fplpf * Fdeemp	

	# determine freq offset and mult for output stage	
	hz_ire_scale = (SP['videorf_100ire'] - SP['videorf_0ire']) / 100
	minn = SP['videorf_0ire'] + (hz_ire_scale * -60)
	SP['output_minfreq'] = sminn = minn / (freq_hz / tau)

	out_scale = 65534.0 / (SP['ire_max'] - SP['ire_min'])
	SP['output_scale'] = (freq_hz / tau) * (out_scale / hz_ire_scale)
Ejemplo n.º 3
0
w, hbpf = freqz(Bbpf, Abpf, worN=1024)
w, hcutl = freqz(Bcutl, Acutl, worN=1024)
w, hcutr = freqz(Bcutl, Acutr, worN=1024)

h = hbpf * hcutl * hcutr

w = w / (np.pi * 2.0)
Am = np.absolute(h)
Th = np.angle(h)

[Bfdls, Afdls] = FDLS(w, Am, Th, forder, forderd, 0)

utils.doplot(Bfdls, Afdls)
exit()

[Bbpf_FDLS, Abpf_FDLS] = fdls.FDLS_fromfilt(Bbpf, Abpf, forder, forderd, 0)
[Bcutl_FDLS, Acutl_FDLS] = fdls.FDLS_fromfilt(Bcutl, Acutl, forder, forderd, 0)
[Bcutr_FDLS, Acutr_FDLS] = fdls.FDLS_fromfilt(Bcutr, Acutr, forder, forderd, 0)

Fbpf = np.fft.fft(Bbpf_FDLS, blocklen)
Fcutl = np.fft.fft(Bcutl_FDLS, blocklen)
Fcutr = np.fft.fft(Bcutr_FDLS, blocklen)

[Baudl_FDLS, Aaudl_FDLS] = fdls.FDLS_fromfilt(Baudl, Aaudl, forder, forderd, 0)
[Baudr_FDLS, Aaudr_FDLS] = fdls.FDLS_fromfilt(Baudr, Aaudr, forder, forderd, 0)

Faudl = np.fft.fft(Baudl_FDLS, blocklen)
Faudr = np.fft.fft(Baudr_FDLS, blocklen)

Fhilbert = np.fft.fft(hilbert_filter, blocklen)
Ejemplo n.º 4
0
                          btype='bandstop')
Bcutr, Acutr = sps.butter(1, [2.416 / (freq / 2), 3.176 / (freq / 2)],
                          btype='bandstop')
Bcut, Acut = sps.butter(1, [2.055 / (freq / 2), 3.176 / (freq / 2)],
                        btype='bandstop')
# AC3 - Bcutr, Acutr = sps.butter(1, [2.68/(freq/2), 3.08/(freq/2)], btype='bandstop')

#utils.doplot(Bcut, Acut)

lowpass_filter_b, lowpass_filter_a = sps.butter(5, (4.4 / (freq / 2)), 'low')

forder = 256
forderd = 0
[Bbpf_FDLS, Abpf_FDLS] = fdls.FDLS_fromfilt(Bbpf,
                                            Abpf,
                                            forder,
                                            forderd,
                                            0,
                                            phasemult=1.00)
[Bcutl_FDLS, Acutl_FDLS] = fdls.FDLS_fromfilt(Bcutl,
                                              Acutl,
                                              forder,
                                              forderd,
                                              0,
                                              phasemult=1.00)
[Bcutr_FDLS, Acutr_FDLS] = fdls.FDLS_fromfilt(Bcutr,
                                              Acutr,
                                              forder,
                                              forderd,
                                              0,
                                              phasemult=1.00)