def client_connect(ccname): env = get_env() vpn = DB.Vpn(env['HOSTNAME']) if not vpn in DB.vpns: register_vpn() user = DB.users[env['COMMON_NAME']] if not user or not user.exists(): user = create_user(vpn, env) addr = Address(env['TRUSTED_IP'], env['TRUSTED_PORT']) cluster = DB.Cluster(user, vpn.chal) connection = DB.Connection(addr) cluster.connections.add(connection) connection.update(addr=addr, vpn=vpn, user=user, cluster=cluster, alive=True) if CONNECTION_TTL is not None: connection.expire(alive=CONNECTION_TTL) logging.info("New connection from {cn}@{ip}:{port} on vlan {vlan}".format( cn=env['COMMON_NAME'], vlan=user.vlan, ip=addr.ip, port=addr.port)) with open(ccname, 'w') as ccfile: ccfile.write(CCTEMPLATE.format(vlan=user.vlan)) if env["PUSH_ADDR"] and env["PUSH_MASK"]: ccfile.write( IFCONFIG.format(addr=env["PUSH_ADDR"], mask=env["PUSH_MASK"]))
def _get_initial_narrow_environment(self, proc, argv, ctx={}): """char** _get_initial_narrow_environment ()""" ptr_size = self.get_ptr_size() env = common.get_env(proc.emu) total = ptr_size sptr = total pptr = 0 fmt_env = [] for k, v in env.items(): envstr = '%s=%s\x00' % (k, v) envstr = envstr.encode('utf-8') total += len(envstr) fmt_env.append(envstr) total += ptr_size sptr += ptr_size pMem = proc.default_heap_alloc(self.ptr_size * 2) pptr = pMem sptr += pMem for v in fmt_env: common.mem_write(proc.uc_eng, pptr, sptr.to_bytes(ptr_size, 'little')) pptr += ptr_size common.mem_write(proc.uc_eng, sptr, v) sptr += len(v) return pMem
def _get_initial_narrow_environment(self, proc, argv, ctx={}): """char** _get_initial_narrow_environment ()""" ptr_size = self.win_emu.get_ptr_size() env = common.get_env(self.win_emu) total = ptr_size sptr = total pptr = 0 fmt_env = [] for k, v in env.items(): envstr = '%s=%s\x00' % (k, v) envstr = envstr.encode('utf-8') total += len(envstr) fmt_env.append(envstr) total += ptr_size sptr += ptr_size pMem = self.win_emu.mem_manager.alloc_heap(proc.proc_default_heap, ptr_size * 2) pptr = pMem sptr += pMem for v in fmt_env: proc.write_mem_self(pptr, sptr.to_bytes(ptr_size, 'little')) pptr += ptr_size proc.write_mem_self(sptr, v) sptr += len(v) return pMem
def main(): env = get_env() with xmlrpc.client.ServerProxy(mgm_uri(env)) as client: vlan = client.connect_user(env['NAUM_CHAL'], env['COMMON_NAME'], env['TRUSTED_IP'], int(env['TRUSTED_PORT'])) with open(sys.argv[1], 'w') as ovpn_dyn: ovpn_dyn.write(OVPN_DYN_TEMPLATE.format(vlan=vlan))
def client_disconnect(): env = get_env() client = '{TRUSTED_IP}:{TRUSTED_PORT}'.format(**env) connection = DB.Connection(Address(env['TRUSTED_IP'], env['TRUSTED_PORT'])) if connection.exists(): connection.delete('alive') else: logging.warn("Connection {} removed from Redis prior to disconnect".format(client))
def register_vpn(): env = get_env() chal = DB.Challenge(env['NAUM_CHAL']) if len(chal.files) == 0: chal.files.extend(env['NAUM_FILES']) vpn = DB.Vpn(env['HOSTNAME']) vpn.update(veth=env['NAUM_VETHHOST'], veth_state='down', chal=chal) DB.vpns.add(vpn)
def client_disconnect(): env = get_env() client = '{TRUSTED_IP}:{TRUSTED_PORT}'.format(**env) connection = DB.Connection(Address(env['TRUSTED_IP'], env['TRUSTED_PORT'])) try: connection.user.connections.remove(connection) # That's a mouthful if len(connection.user.connections) == 0: connection.user.status = 'disconnected' connection.alive = False except RedisKeyError: logging.warn( "Connection {} removed from Redis prior to disconnect".format( client))
def register_vpn(): env = get_env() chal = DB.Challenge(env['NAUM_CHAL']) # Assign the list of files for this challenge. chal.files.clear() chal.files.extend(env['NAUM_FILES']) vpn = DB.Vpn(env['HOSTNAME']) vpn.update(veth=env['NAUM_VETHHOST'], veth_state=DB.Vpn.VETH_DOWN, chal=chal) DB.vpns.add(vpn)
def GetTempPath(self, proc, argv, ctx={}): ''' DWORD GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer ); ''' nBufferLength, lpBuffer = argv rv = 0 cw = common.get_char_width(ctx) tempdir = common.get_env(proc.emu).get('temp', 'C:\\Windows\\temp\\') if cw == 2: new = (tempdir).encode('utf-16le') + b'\x00\x00' else: new = (tempdir).encode('utf-8') + b'\x00' rv = len(tempdir) if lpBuffer: argv[1] = tempdir proc.uc_eng.mem_write(lpBuffer, new) return rv
def client_connect(ccname): env = get_env() vpn = DB.Vpn(env['HOSTNAME']) if not vpn in DB.vpns: register_vpn() user = DB.users[env['COMMON_NAME']] if user: user.status = 'active' else: user = create_user(vpn, env) addr = Address(env['TRUSTED_IP'], env['TRUSTED_PORT']) connection = DB.Connection(addr) connection.update(addr=addr, vpn=vpn, user=user, alive=True) user.connections.add(connection) logging.info("New connection from {cn}@{ip}:{port} on vlan {vlan}".format( cn=env['COMMON_NAME'], vlan=user.vlan, ip=addr.ip, port=addr.port)) with open(args.ccname, 'w') as ccfile: ccfile.write(CCTEMPLATE.format(vlan=user.vlan))
import matplotlib.pyplot as plt import common # This should give a Fourier transform with a frequency spectrum that is # entirely real, starts at 1 and goes to 0 at 0.5 the sample rate def est_autocorr(x): """ Estimate autocorrelation by inverse transforming the powerspectrum """ X = np.fft.fft(x) S = X * np.conj(X) r = np.fft.ifft(X) return r N = common.get_env('N', default=512, conv=int) n = np.arange(N) t = np.arange(-N / 2 + 0.5, N / 2) t_eval = np.concatenate((np.arange(N / 2), np.arange(1, N / 2 + 1)[::-1] * -1)) a = common.get_env('a', default=0.5, conv=float) x = a * np.power(np.sinc(t_eval * a), 2) X = np.fft.fft(x) r = est_autocorr(x) fig, axs = plt.subplots(3, 1) axs[0].plot(n, x) axs[1].plot(n, np.real(X)) axs[2].plot(n, np.abs(r)) # It really seems that the square of the sinc is its own autocorrelation # function print(np.sum(np.abs(x - r)))
def ping(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = PingForm(request.POST) # check whether it's valid: if form.is_valid(): # process the data in form.cleaned_data as required # ... # redirect to a new URL: src_ip = form.cleaned_data['src_ip'] dst_ip = form.cleaned_data['dst_ip'] router = form.cleaned_data['router'] #html = '<html><body>SIP: %s DIP: %s router: %s</body></html>' % (src_ip, dst_ip, router) #return HttpResponse(html) static_path = settings.STATIC_ROOT pwd = settings.ROOT_PATH JSON_FILE = pwd + '/don/ovs/don.json' params = { 'json_file' : pwd + '/don/ovs/don.json', 'src_ip' : src_ip, 'dst_ip' : dst_ip, 'router' : router, 'path_file' : static_path + '/don/ping.html', 'username' : 'cirros', 'passwd' : 'cubswin:)', 'count' : 2, 'timeout' : 2, 'debug' : True, 'plot' : False, } response = path.path(params) if response: error_text = response messages.error(request,error_text) return render(request, 'don/ovs/ping.html', {'form': form}) JSON_FILE = pwd + '/don/ovs/don.json' COMPUTE_DOT_FILE = None COMPUTE_SVG_FILE = None NETWORK_DOT_FILE = None NETWORK_SVG_FILE = None COMBINED_DOT_FILE = static_path + '/don/ping.dot' COMBINED_SVG_FILE = static_path + '/don/ping.svg' # HIGHLIGHT_FILE = pwd + '/don/ovs/static/ping.html' HIGHLIGHT_FILE = static_path + '/don/ping.html' plotter = DotGenerator(JSON_FILE, COMPUTE_DOT_FILE, COMPUTE_SVG_FILE, NETWORK_DOT_FILE, NETWORK_SVG_FILE, COMBINED_DOT_FILE, COMBINED_SVG_FILE, HIGHLIGHT_FILE, ) plotter.plot_combined() plotter.generate_combined_svg() # return HttpResponseRedirect('/static/path.html') return render(request, 'don/ovs/path.html') # if a GET (or any other method) we'll create a blank form else: form = PingForm() BASE_DIR = settings.ROOT_PATH + '/don/ovs/' myenv = os.environ.copy() myenv.update(get_env(BASE_DIR + 'admin-openrc.sh')) output = execute_cmd(['nova', 'list'], sudo=False, shell=False, env=myenv).split('\n'); ip_list = get_instance_ips(output) ip_list.sort() router_op = execute_cmd(['neutron', 'router-list'], sudo=False, shell=False, env=myenv).split('\n'); router_list = get_router_names(router_op) router_list.sort() # insert first value of select menu ip_opt = zip(ip_list,ip_list) router_opt = zip(router_list,router_list) # ip_opt.insert(0,('','Select IP address')) # router_opt.insert(0,('','Select Router')) form.fields['src_ip'].widget.choices = ip_opt form.fields['dst_ip'].widget.choices = ip_opt form.fields['router'].widget.choices = router_opt return render(request, 'don/ovs/ping.html', {'form': form})
import math def spectral_flux(x, H, W, window_type='hann'): if W >= 4: w = signal.get_window(window_type, W) else: w = np.ones(W) w /= np.sum(W) spec_flux_i = 0 X = np.fft.fft(common.frame(x, H, W) * w[:, None], axis=0) spec_flux = np.sum(np.abs(np.diff(np.abs(X), axis=0)), axis=0) return spec_flux INPUT = common.get_env('INPUT', check_if_none=True) WINDOW_TYPE = common.get_env('WINDOW_TYPE', default='hann') SAMPLE_RATE = common.get_env('SAMPLE_RATE', conv=float, default=16e3) ATTACK_THRESH = common.get_env('ATTACK_THRESH', conv=float, default=0.05) H = common.get_env('H', conv=int, default=2) W = common.get_env('W', conv=int, default=8) ALPHA = common.get_env('ALPHA', conv=float, default=.01) x = np.fromfile(INPUT) filter_co_hz = 2000 filter_order = 16 filter_ripple = 3 b, a = signal.cheby1(filter_order, filter_ripple, filter_co_hz, btype='highpass',
__doc__ = """ take a soundfile and the score used to render it (see scripts/synth_af_score.py) and use this score to determine the points that are fixed in a time stretch. Produce a file that is the time-stretched version of the input file, but with the attacks preserved. """ import classic_puckette_timestretch import synth_af_score import common import time_map_tstretch import numpy as np if __name__ == '__main__': SCORE_FILE = common.get_env('SCORE_FILE', check_if_none=True) SOUND_FILE = common.get_env('SOUND_FILE', check_if_none=True) OUTPUT = common.get_env('OUTPUT', check_if_none=True) # smaller numbers mean longer file TSTRETCH_FACTOR = common.get_env('TSTRETCH_FACTOR', default=1, conv=float) # move the locked points forward or backward in time by a fixed amount LOCK_OFFSET = common.get_env('LOCK_OFFSET', default=0, conv=int) # a time after the lock time within which all the points are locked # this value is multiplied by H+W because we cannot lock 2 points closer # than that amount of time LOCK_WINDOW = common.get_env('LOCK_WINDOW', default=0, conv=int) H = common.get_env('H', default=256, conv=int) W = common.get_env('W', default=1024, conv=int) SAMPLE_RATE = common.get_env('SAMPLE_RATE', 16000, float) x = np.fromfile(SOUND_FILE, 'float64') orig_len_x = len(x)
def extract_ts_samps(scorefile,sample_rate): ts_samps=[ts_to_ts_samps(ts,sample_rate) for ts in extract_ts(scorefile)] return ts_samps def render_score_to_array(scorefile,sample_rate,sample_file_directory=None): fundisp=const_sr_fun_dispatcher(sample_rate) sound_files=score_extract_unique_filenames(scorefile) sound_segs=load_files_into_arrays(sound_files,sample_file_directory) longest_seg_len=get_length_longest_array([sound_segs[k] for k in sound_segs.keys()]) max_ts=score_extract_maximum_timestamp(scorefile) len_output=int(np.ceil(max_ts*sample_rate)+longest_seg_len) y=np.zeros(len_output) with open(scorefile,'r') as f: for line in f.readlines(): filename,ts,proc=extract_score_fields(line) x=run_procs_on_array(sound_segs[filename],proc,fundisp) ts_samps=ts_to_ts_samps(ts,sample_rate) y[ts_samps:ts_samps+len(x)]+=x return y if __name__ == '__main__': SAMPLE_FILE_DIRECTORY=common.get_env('SAMPLE_FILE_DIRECTORY') SAMPLE_RATE=common.get_env('SAMPLE_RATE',16000,float) SCORE_FILE=common.get_env('SCORE_FILE',check_if_none=True) OUTPUT=common.get_env('OUTPUT',check_if_none=True) y=render_score_to_array(SCORE_FILE,SAMPLE_RATE,sample_file_directory=SAMPLE_FILE_DIRECTORY) y=common.normalize(y) y.tofile(OUTPUT)
def main(): env = get_env() with xmlrpc.client.ServerProxy(mgm_uri(env)) as client: client.register_challenge(env['NAUM_CHAL'], env['NAUM_VETHHOST'], env['NAUM_FILES'])
def gei(n, i): return common.get_env(n, default=i, conv=int)
def ping(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = PingForm(request.POST) # check whether it's valid: if form.is_valid(): # process the data in form.cleaned_data as required # ... # redirect to a new URL: src_ip = form.cleaned_data['src_ip'] dst_ip = form.cleaned_data['dst_ip'] router = form.cleaned_data['router'] # html = '<html><body>SIP: %s DIP: %s router: %s</body></html>' % (src_ip, dst_ip, router) # return HttpResponse(html) static_path = settings.STATIC_ROOT pwd = settings.ROOT_PATH JSON_FILE = pwd + '/don/ovs/don.json' params = { 'json_file': pwd + '/don/ovs/don.json', 'src_ip': src_ip, 'dst_ip': dst_ip, 'router': router, 'path_file': static_path + '/don/ping.html', 'username': '******', 'passwd': 'cubswin:)', 'count': 2, 'timeout': 2, 'debug': True, 'plot': False, } response = path.path(params) if response: error_text = response messages.error(request, error_text) return render(request, 'don/ovs/ping.html', {'form': form}) JSON_FILE = pwd + '/don/ovs/don.json' COMPUTE_DOT_FILE = None COMPUTE_SVG_FILE = None NETWORK_DOT_FILE = None NETWORK_SVG_FILE = None COMBINED_DOT_FILE = static_path + '/don/ping.dot' COMBINED_SVG_FILE = static_path + '/don/ping.svg' # HIGHLIGHT_FILE = pwd + '/don/ovs/static/ping.html' HIGHLIGHT_FILE = static_path + '/don/ping.html' plotter = DotGenerator( JSON_FILE, COMPUTE_DOT_FILE, COMPUTE_SVG_FILE, NETWORK_DOT_FILE, NETWORK_SVG_FILE, COMBINED_DOT_FILE, COMBINED_SVG_FILE, HIGHLIGHT_FILE, ) plotter.plot_combined() plotter.generate_combined_svg() # return HttpResponseRedirect('/static/path.html') return render(request, 'don/ovs/path.html') # if a GET (or any other method) we'll create a blank form else: form = PingForm() BASE_DIR = settings.ROOT_PATH + '/don/ovs/' myenv = os.environ.copy() myenv.update(get_env(BASE_DIR + 'admin-openrc.sh')) output = execute_cmd(['nova', 'list'], sudo=False, shell=False, env=myenv).split('\n') ip_list = get_instance_ips(output) ip_list.sort() router_op = execute_cmd(['neutron', 'router-list'], sudo=False, shell=False, env=myenv).split('\n') router_list = get_router_names(router_op) router_list.sort() # insert first value of select menu ip_opt = zip(ip_list, ip_list) router_opt = zip(router_list, router_list) # ip_opt.insert(0,('','Select IP address')) # router_opt.insert(0,('','Select Router')) form.fields['src_ip'].widget.choices = ip_opt form.fields['dst_ip'].widget.choices = ip_opt form.fields['router'].widget.choices = router_opt return render(request, 'don/ovs/ping.html', {'form': form})
a = a.copy() a = a / a[0] a = a[1:] p = len(a) r = np.zeros_like(a) r[-1] = a[-1] for j in np.arange(p - 1)[::-1]: s = 1 / (1 - r[j + 1] * np.conj(r[j + 1])) a[:j + 1] = s * (a[:j + 1] - r[j + 1] * np.conj(a[:j + 1][::-1])) r[j] = a[j] return r # From test/attack_estimation_studies/tri_freq_response.py it seems sinc^2 is # its own autocorrelation, so we use this for the filter design number of poles P = common.get_env('P', default=2, conv=int) acc_mult = common.get_env('acc_mult', default=1, conv=int) def fit_allpole_triangular_lowpass( # number of poles P, # length multiplier (because a longer autocorrelation sequence might give a # better fit, but it seems like actually not) acc_mult=1): # It seems the feedforward coefficients other than the first one often get # forced to 0, so we just use an allpole model Q = 0 # length of autocorrelation sequence we need
def gef(n, f): return common.get_env(n, default=f, conv=float)
# Compare the performance of the DFT and IIR implementations of the high # frequency weighting filter import numpy as np from scipy import signal import common import spectral_difference import subprocess import high_freq_weighting_filter import matplotlib.pyplot as plt INPUT = common.get_env('INPUT', check_if_none=True) WINDOW_TYPE = common.get_env('WINDOW_TYPE', default='hann') SAMPLE_RATE = common.get_env('SAMPLE_RATE', conv=float, default=16e3) # hop size of DFT implementation H = common.get_env('H', conv=int, default=2) # window size of DFT implementation W = common.get_env('W', conv=int, default=8) # number of poles in IIR implementation P = common.get_env('P', conv=int, default=2) X_LIM = common.get_env('X_LIM', conv=eval, default=(0, 2)) # Max search window sizes H_LMAX = common.get_env('H_LMAX', conv=int, default=5) W_LMAX = common.get_env('W_LMAX', conv=int, default=10) # How many times greater the max has to be to get counted A_LMAX = common.get_env('A_LMAX', conv=float, default=1.5) # Coefficient of smoothing filter A_SMOOTH = common.get_env('A_SMOOTH', conv=float, default=1e-2) # Max search window sizes for averaging filter H_ASLMAX = common.get_env('H_ASLMAX', conv=int, default=5) W_ASLMAX = common.get_env('W_ASLMAX', conv=int, default=10)
#!/usr/bin/env python3 from os import system, chdir, path, mkdir from os.path import join from common import WORKSPACE_ROOT, get_env GROUTE_PATH = path.join(WORKSPACE_ROOT, "groute") GROUTE_BUILD_PATH = path.join(GROUTE_PATH, "build") chdir(WORKSPACE_ROOT) if not path.exists(GROUTE_PATH): system("git clone --recursive https://github.com/groute/groute.git") chdir(GROUTE_PATH) system("git checkout 7a77c467867b55c92110bad019447eb305fe6ec1") system("git apply %s" % (join(WORKSPACE_ROOT, "groute.patch"))) chdir(GROUTE_PATH) if not path.exists(GROUTE_BUILD_PATH): mkdir(GROUTE_BUILD_PATH) chdir(GROUTE_BUILD_PATH) env_dict = get_env() CMAKE_PATH = env_dict["cmake_path"] GCC_PATH = env_dict["gcc_path"] GPP_PATH = env_dict["gpp_path"] system("cmake .. -DCMAKE_C_COMPILER=%s -DCMAKE_CXX_COMPILER=%s" % (GCC_PATH, GPP_PATH)) system("n=$(nproc) && make -j $n")
# The time-stretcher uses the audio-rate time-stretch and pitch-shift signals import numpy as np from scipy import signal from pitch_shift import pitch_shifter import window_tools from classic_puckette_timestretch import pvoc_synth import matplotlib.pyplot as plt import rel_del_line from time_map_tstretch import attack_avoider import attack_finder import common import envelopes import lfo # Environment variables SR = common.get_env('SR', default=16000, conv=int) W = common.get_env('W', default=1024, conv=int) H = common.get_env('H', default=256, conv=int) IN_FILE = common.get_env('IN_FILE', default='/tmp/in.f64') OUT_FILE = common.get_env('OUT_FILE', default='/tmp/out.f64') LMAX_FILT_RATE = common.get_env('LMAX_FILT_RATE', default=SR, conv=float) # Gate parameters GATE_F0 = common.get_env('GATE_F0', default=1, conv=float) / SR GATE_F1 = common.get_env('GATE_F1', default=GATE_F0 * SR, conv=float) / SR # Time-stretch LFO parameters TS_FM0 = common.get_env('TS_FM0', default=0.5, conv=float) / SR TS_FM1 = common.get_env('TS_FM1', default=TS_FM0 * SR, conv=float) / SR TS_MIN = common.get_env('TS_MIN', default=0.5, conv=float) TS_MAX = common.get_env('TS_MAX', default=1.5, conv=float) # Pitch-shift LFO parameters PS_FM0 = common.get_env('PS_FM0', default=0.75, conv=float) / SR
import numpy as np import matplotlib.pyplot as plt import common IN_FILE = common.get_env('IN_FILE', default='/tmp/out.f64') SR = common.get_env('SR', default=16000, conv=int) x = np.fromfile(IN_FILE, dtype='float64') N = len(x) n = np.arange(N) t = n / SR plt.plot(t, x) plt.show()
import math def spectral_flux(x, H, W, window_type='hann'): if W >= 4: w = signal.get_window(window_type, W) else: w = np.ones(W) w /= np.sum(W) spec_flux_i = 0 X = np.fft.fft(common.frame(x, H, W) * w[:, None], axis=0) spec_flux = np.sum(np.abs(np.diff(np.abs(X), axis=0)), axis=0) return spec_flux INPUT = common.get_env('INPUT', check_if_none=True) WINDOW_TYPE = common.get_env('WINDOW_TYPE', default='hann') SAMPLE_RATE = common.get_env('SAMPLE_RATE', conv=float, default=16e3) ATTACK_THRESH = common.get_env('ATTACK_THRESH', conv=float, default=0.05) H = common.get_env('H', conv=int, default=2) W = common.get_env('W', conv=int, default=8) ALPHA = common.get_env('ALPHA', conv=float, default=.01) # whether or not to normalize the spectral flux NORMALIZE = common.get_env('NORMALIZE', conv=int, default=0) # filter coefficient for smoothing the instantaneous amplitude ALPHA_NORMALIZE = common.get_env('ALPHA_NORMALIZE', conv=float, default=0.01) # threshold for the instantaneous amplitude below which no normalization is # carried out (because very small amplitudes will cause huge values) # value in dB THRESH_NORMALIZE = common.get_env('THRESH_NORMALIZE', conv=float, default=-60) X_LIM = common.get_env('X_LIM', conv=eval, default=(0, 2))
# Test avoiding attacks while time stretching using attack_avoider import numpy as np import matplotlib.pyplot as plt import time_map_tstretch import classic_puckette_timestretch import common import attack_finder SAMPLE_RATE=16000 W=common.get_env('W',default=2048,conv=int) H=common.get_env('H',default=512,conv=int) S=common.get_env('S',default=0.5,conv=float) NG_TH=common.get_env('NG_TH',default=-30,conv=float) attack_times=np.array([0.5,1.,1.25]) attack_times=(attack_times*SAMPLE_RATE).astype('int') av=time_map_tstretch.attack_avoider( attack_times, -3*H, W+2*H, H) # make signal sigs=[] for fname in [ '/tmp/piano_adj_beg/60.f64', '/tmp/piano_adj_beg/64.f64', '/tmp/piano_adj_beg/67.f64']:
import common import numpy as np from scipy.interpolate import interp1d INPUT = common.get_env('INPUT', default='/tmp/in.f64') OUTPUT = common.get_env('OUTPUT', default='/tmp/out.f64') S = common.get_env('S', default=1., conv=float) x = np.fromfile(INPUT, dtype='float64') n = np.arange(len(x)) t = np.arange(0, len(x) - 1, S) interp = interp1d(n, x, kind='cubic') y = interp(t) y.tofile(OUTPUT)
# Take a sound file # Do some processing to get the attacks, be it spectral flux or high-frequency weighting # Look for the local peaks. In order to filter out spurious peaks, we do a sort # of noise-gating of the spectral flux signal by looking at the RMS amplitude import numpy as np from scipy import signal import common import spectral_difference import subprocess import high_freq_weighting_filter import matplotlib.pyplot as plt import window_tools SAMPLE_RATE = common.get_env('SAMPLE_RATE', conv=float, default=16e3) INPUT = common.get_env('INPUT', check_if_none=True) OUTPUT = common.get_env('OUTPUT', default='/tmp/cut-%d.f64') OUTPUT_SUMMARY = common.get_env('OUTPUT_SUMMARY', default='/tmp/cut_summary.txt') # window type for the spectral flux WINDOW_TYPE_SF = common.get_env('WINDOW_TYPE_SF', default='hann') # hop size of spectral flux H_SF = common.get_env('H_SF', conv=int, default=256) # window size of DFT implementation W_SF = common.get_env('W_SF', conv=int, default=1024) # smoothing factor (0-1) for SF SMOOTH_SF = common.get_env('SMOOTH_SF', conv=float, default=1) SF_THRESH = common.get_env('SF_THRESH', conv=float, default=0.01) MAX_SEG_LEN = common.get_env('MAX_SEG_LEN', conv=float, default=float('inf')) # If not None, Instead of using the most recent local minimum in the spectral
import attack_finder import numpy as np import mir_eval import common import matplotlib.pyplot as plt def gef(n, f): return common.get_env(n, default=f, conv=float) def gei(n, i): return common.get_env(n, default=i, conv=int) SOUNDFILE = common.get_env('SOUNDFILE', check_if_none=True) SAMPLE_RATE = common.get_env('SAMPLE_RATE', default=16e3, conv=float) SCOREFILE = common.get_env('SCOREFILE', check_if_none=True) # true time stamps in seconds ts = synth_af_score.extract_ts(SCOREFILE) ts = np.sort(np.array(ts)) x = np.fromfile(SOUNDFILE) # estimated time stamps H = gei('H', 256) W = gei('W', 256) alpha = gef('ALPHA', 1) thresh = gef('THRESH', 3e-3) ts_est, a = attack_finder.attack_region_estimation(x, H, W, alpha, thresh) a_ts = ts_est[:-1][(np.diff(a) > 0)] / SAMPLE_RATE
import numpy as np from scipy import signal from pitch_shift import pitch_shifter import window_tools from classic_puckette_timestretch import pvoc_synth import matplotlib.pyplot as plt import rel_del_line from time_map_tstretch import attack_avoider import attack_finder import common REAL_TIME = False from_file = True adjust_for_attacks = True SR = common.get_env('SR', default=16000, conv=int) W = 1024 H = 256 if from_file: x = np.fromfile('/tmp/me.f64', dtype='float64') N = 0 while N < (len(x) - H): N += H x = x[:N] n = np.arange(N) x += np.random.standard_normal(N) * 1e-8 attack_time_pairs = attack_finder.attacks_from_spectral_diff( x, lmax_filt_rate=SR) attack_times = np.array([b for a, b in attack_time_pairs]) else:
@author: mingrui """ import sys import torch from common import get_env, play from dqn_agent import Agent if __name__ == '__main__': if len(sys.argv) == 1: dqn_fname = None else: dqn_fname = sys.argv[1] # get env env, state_size, action_size = get_env() # load and play with trained agent agent = None if dqn_fname is not None: agent = Agent(state_size, action_size, seed=0) agent.dqn_local.load_state_dict(torch.load(dqn_fname)) print('Playing with agent {}...'.format(dqn_fname)) play(env, agent) else: # play ranomly print('Playing randomly...') play(env) env.close()