#!/usr/bin/env python

import math

from gnuradio import gr
from gnuradio import audio
import sys
from gnuradio import mc4020
def high_speed_adc (fg, input_rate):
    return mc4020.source (input_rate, mc4020.BTTV_EXTEND_RAW_LINES |mc4020.BTTV_DEC3 | mc4020.BTTV_NOGAP , "/dev/video0");
#mc4020.BTTV_EXTEND_RAW_LINES | mc4020.BTTV_NOGAP |mc4020.BTTV_DEC3
#    return gr.file_source (1, "/pub/tmp/pixels.raw", False)
#   return gr.file_source (gr.sizeof_short, "/pub/tmp/pixels.raw", False)
#return gr.file_source (gr.sizeof_short, "dummy.dat", False)
#
# return a gr.flow_graph
#

#pre_dec=int(25)

def build_chan_filter(freq,input_rate,cfir_decimation,band_width,trans_width):
   # compute FIR filter taps for channel selection
    channel_coeffs = \
      gr.firdes.low_pass (
        1.0,          # gain
        input_rate,   # sampling rate
        band_width,#128*1024, #250e3,        low pass cutoff freq
        trans_width,#256*1024, #8*100e3,       width of trans. band
        gr.firdes.WIN_HAMMING)

    # input: short; output: complex
    chan_filter1 = \
      gr.freq_xlating_fir_filter_scf (
        cfir_decimation,
        channel_coeffs,
        freq,        # 1st station freq
        input_rate)
    return chan_filter1

def build_graph (freq1, freq2,input_rate,cfir_decimation,audio_decimation,chan_filter1,chan_filter2):
    #input_rate = 20e6
    #input_rate = 8.5e6
    #input_rate = 5140800
    #input_rate = 16384000
    #cfir_decimation = 125
    #cfir_decimation = 62
    #audio_decimation = 4

    quad_rate = input_rate / cfir_decimation
    audio_rate = quad_rate / audio_decimation

    fg = gr.flow_graph ()
    
    # use high speed ADC as input source
    # src = gr.high_speed_adc (input_rate)
    src = high_speed_adc (fg, input_rate)
    #src = gr.keep_one_in_n(2,pre_dec)
    #fg.connect(src0,src)
    #sampling_freq = freq1*10
    #ampl = 0.1

    #fg = gr.flow_graph ()
    #src = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, freq1, ampl)
    
  
    
    (head1, tail1) = \
      build_pipeline (fg, quad_rate,
                      audio_decimation,1.0)
    
    # sound card as final sink
   # audio_sink = gr.audio_sink_oss (int (audio_rate)) # FIXME oss
    audio_sink = audio.sink (int (audio_rate))
   
    # now wire it all together
    fg.connect (src, chan_filter1)
    fg.connect (chan_filter1, head1)
 #   fg.connect (tail1, (audio_sink, 0))

    # two stations at once?
    if freq2:
        # Extract the second station and connect
        # it to a second pipeline...

        # input: short; output: complex
        #chan_filter2 = \
        #  gr.freq_xlating_fir_filter_scf (
        #    cfir_decimation,
        #    channel_coeffs,
        #    freq2,        # 2nd station freq
        #    input_rate)

        (head2, tail2) = \
          build_pipeline (fg, quad_rate,
                          audio_decimation,1.0)

        fg.connect (src, chan_filter2)
        fg.connect (chan_filter2, head2)
        #fg.connect (tail2, (audio_sink, 1))
 	subtract=gr.sub_ff()
    	fg.connect (tail1,(subtract, 0))
    	fg.connect (tail2,(subtract, 1))
    	fg.connect (subtract, (audio_sink, 0))
    	fg.connect (tail2, (audio_sink, 1))
    else:
	fg.connect (tail1, (audio_sink, 0))
    
    return fg

def build_pipeline (fg, quad_rate, audio_decimation,volume):
    '''Given a flow_graph, fg, construct a pipeline
    for demodulating a broadcast FM signal.  The
    input is the downconverteed complex baseband
    signal. The output is the demodulated audio.

    build_pipeline returns a two element tuple
    containing the input and output endpoints.
    '''
    fm_demod_gain = 2200.0/32768.0
    audio_rate = quad_rate / audio_decimation
    #volume = 1.0

    # input: complex; output: float
    fm_demod = \
      gr.quadrature_demod_cf (volume*fm_demod_gain)

    # compute FIR filter taps for audio filter
    width_of_transition_band = audio_rate / 32
    audio_coeffs = \
      gr.firdes.low_pass (
        1.0,            # gain
        quad_rate,      # sampling rate
        17000, #audio_rate/2 - width_of_transition_band,
        width_of_transition_band,
        gr.firdes.WIN_HAMMING)

    # input: float; output: float
    audio_filter = \
      gr.fir_filter_fff (audio_decimation,
                         audio_coeffs)

    fg.connect (fm_demod, audio_filter)
    return ((fm_demod, 0), (audio_filter, 0))
    

def man (freq1,freq2):
    #nargs = len (args)
    #if nargs == 1:
    #    freq1 = float (args[0]) * 1e6
    #    freq2 = None
    #elif nargs == 2:
    #    freq1 = float (args[0]) * 1e6
    #    freq2 = float (args[1]) * 1e6
    #else:
    #    sys.stderr.write ('usage: fm_demod freq1 [freq2]\n')
    #    sys.exit (1)

    # connect to RF front end
    #rf_front_end = gr.microtune_4937_eval_board ()
    #if not rf_front_end.board_present_p ():
    #    raise IOError, 'RF front end not found'

    # set front end gain
    #rf_front_end.set_AGC (300)
    #IF_freq = rf_front_end.get_output_freq ()
    #IF_freq = 5.75e6
    IF_freq = 5.5e6
    if not freq2:      # one station

    #    rf_front_end.set_RF_freq (freq1)
        fg = build_graph (freq1, None)

    else:              # two stations

        if abs (freq1 - freq2) > 5.5e6:
            raise IOError, 'freqs too far apart'

        target_freq = (freq1 + freq2) / 2
        #actual_freq = rf_front_end.set_RF_freq (target_freq)
        actual_freq = target_freq
        
        fg = build_graph (IF_freq + freq1 - actual_freq,
                          IF_freq + freq2 - actual_freq)
    
    print "Just before run!"
    
    #fg.run ()          # FIXME
    #fg.start()
    #fg.start ()        # fork thread(s) and return
    #raw_input ('Press Enter to quit: ')
    #fg.stop ()
    return fg

if __name__ == '__main__':
    #f1 = float (sys.argv[1:][0]) 
    nargs = len (sys.argv[1:])
    if nargs == 1:
        freq1 = float (sys.argv[1:][0]) * 1e6
        freq2 = None
    elif nargs == 2:
        freq1 = float (sys.argv[1:][0]) * 1e6
        freq2 = float (sys.argv[1:][1]) * 1e6
    else:
	freq1 = 5.5 * 1e6
	#freq2 = 5.788 * 1e6 #
	freq2 = 5.742187 * 1e6
        #sys.stderr.write ('usage: fm_demod freq1 [freq2]\n')
        #sys.exit (1)
    #fg2=man (freq1,freq2)
    #input_rate = 16384000 #1024*640*25
    #input_rate = 8164800 #567*288*50
    #input_rate = 16329600 #2268/2 *288*50
    #input_rate = 17718464 #= pllfreq/2
    in_dec=3
    pal_fsc=int(35468950)
    real_rate=pal_fsc/in_dec
    input_norm = int(50*692*1024)#pal_fsc#int(674*1024*50)
    input_rate =  int(input_norm/in_dec) #35468950 #38900000.0 #0.9*35.46=31922055 #35468950 #32659200 2268*288*50
    #input_rate =  35468950
    #orig cfir_decimation = 125
    #orig audio_decimation = 5
    cfir_decimation = int(125/in_dec)#250
    audio_decimation = 6
    chan_filter1=build_chan_filter(int((freq1*input_norm)/pal_fsc),input_rate,cfir_decimation, \
       250*1e3,800*1e3)
    #chan_filter2=build_chan_filter(int((freq2*input_norm)/pal_fsc),input_rate,cfir_decimation, \
    #       10*1e3,100*1e3)
 
    fg2=build_graph((freq1*input_norm)/pal_fsc,None,input_rate,cfir_decimation,audio_decimation,chan_filter1,None)
    #fg2=build_graph(freq1,freq2,chan_filter1)
    letter=""
    fg2.start ()        # fork thread(s) and return    
    while (letter!="x"):
        #print(freq1)
    	letter=raw_input ( 'Press x Enter to quit: ')
	if letter=="'": 
		freq1+=100000
    	elif letter==";": 
		freq1-=100000
        elif letter==">": 
		freq1+=10000
	elif letter=="<": 
		freq1-=10000
	elif letter==".": 
		freq1+=1000
	elif letter==",": 
		freq1-=1000
        else: 
		freq1+=10000
	print(freq1)
	chan_filter1.set_center_freq( (freq1*input_norm)/pal_fsc ) 
    fg2.stop ()
    #fg2=man (freq1,freq2)
    #fg2.start ()   
    print "Just after main!"