def online(): print("Online analysis") duration = 10 # seconds fs = 48000 sd.default.samplerate = fs with sd.Stream(channels=2, blocksize=1*fs, dtype="float32", callback=callback): sd.sleep(duration*10000000)
def run(self, conn): import sounddevice as sd import generate self.tone = generate.GenerateTone(freq=700, vol=1.0/400000) self.playing = False self.running = True self.pos = 0 self.thread = threading.Thread(target=self.input_thread, args=(conn, )) self.thread.start() with sd.OutputStream(channels=1, callback=self.callback, samplerate=48000, latency='low') as stream: while self.running: sd.sleep(100) self.thread.join()
def run(self, conn, freq): import sounddevice as sd import generate self.tone = generate.GenerateTone(freq=freq, vol=1.0/400000) self.playing = False self.running = True self.broken = False self.pos = 0 self.thread = threading.Thread(target=self.input_thread, args=(conn, )) self.thread.start() print sd.query_devices() print sd.default.device #raise SystemExit() with sd.OutputStream(channels=1, callback=self.callback,samplerate=48000, blocksize=2048, latency='low') as stream: while self.running: sd.sleep(1000) self.thread.join()
global ws ws.send(r'{"identifier" : "{\"channel\": \"NoiseLevelChannel\"}", "command": "message", "data": "{\"action\": \"new_value\", \"value\": '+ str(value) +'}"}') def connect_ws(): global ws ws = create_connection(ws_target) ws.send(r'{"identifier":"{\"channel\": \"NoiseLevelChannel\"}", "command": "subscribe"}') print ws.recv() def send_to_http(value): global cookies, token payload = {'authenticity_token': token, 'noise_level[value]': volume_norm} r = requests.post(http_target, data=payload, cookies = cookies) def connect_http(): global cookies, token r = requests.get(http_target) cookies = r.cookies token = p.findall(r.text)[0] def print_sound(indata, outdata, frames, time, status): volume_norm = np.linalg.norm(indata)*10 send_to_ws(volume_norm) sleep(delay) # print volume_norm #connect_http() connect_ws() with sd.Stream(callback=print_sound): sd.sleep(duration * 1000)
stream = rtmixer.Recorder( device=device, channels=channels, blocksize=blocksize, latency=latency, samplerate=samplerate) buffer = bytearray(10 * int(stream.samplerate) * stream.samplesize) ringbuffer = rtmixer.RingBuffer(stream.samplesize * channels, 128) print('checking stats before opening stream:') print_stats(stream) assert stream.stats.blocks == 0 assert stream.stats.input_overflows == 0 with stream: print('waiting a few seconds ...') sd.sleep(3 * 1000) print('checking stats:') action = stream.fetch_and_reset_stats() stream.wait(action) print_stats(action) print('starting recording to buffer ...') action = stream.record_buffer(buffer, channels=channels) stream.wait(action) print('result:') print_action(action) print('stats from finished recording:') print_stats(action) print('starting recording to ringbuffer ...') action = stream.record_ringbuffer(ringbuffer, channels=channels) # NB: We are writing to the ringbuffer, but we are not reading from it, # which will lead to an overflow
def main(): options = options_play.get_options() samplerate = options["samplerate"] sd.default.samplerate = samplerate synth = Synth(no_of_voices=options["no_of_voices"], no_of_bass_voices=1, waveform=options["waveform"], samplerate=samplerate, transposition_factor=options["transposition_factor"], attack_time=options["attack_time"], release_time=options["release_time"], decay_time=options["decay_time"], after_decay_level=options["after_decay_level"], bass_attack_time=options["bass_attack_time"], bass_release_time=options["bass_release_time"], bass_decay_time=options["bass_decay_time"], bass_after_decay_level=options["bass_after_decay_level"], bass_transposition_factor=1.0, volume=options["volume"]) # set-up pygame dislay full_screen = options["fullscreen"] pygame.init() if full_screen: os.environ['SDL_VIDEO_WINDOW_POS'] = "0,0" info = pygame.display.Info() options["size_x"] = info.current_w options["size_y"] = info.current_h display = pygame.display.set_mode((info.current_w, info.current_h), pygame.NOFRAME) else: display = pygame.display.set_mode( (options["size_x"], options["size_y"])) freq_board = FrequencyBoard( options["size_x"], options["size_y"], filename=options["frequency_board"], transition_size=options["transition_size"], wildcard_frequency=options["wildcard_frequency"], shuffle_row_frequencies=options["shuffle_row_frequencies"]) for ix in range(options["size_x"]): for iy in range(options["size_y"]): color = freq_board.colors[iy][ix][::-1] display.set_at((ix, iy), color) pygame.display.update() # initialize variables running = True is_sliding = False bass_hold = False current_bass_key = None current_bass_keys = Set([]) bass_frequencies = freq_board.get_bass_frequencies( options["bass_frequencies_filename"]) bass_keys = get_bass_keys() bass_change = 2.0**(1.0 / 96.0) bass_change_pressed = False with sd.OutputStream(channels=1, callback=synth, samplerate=samplerate): while running: sd.sleep(1) keys = pygame.key.get_pressed() # bass transpose if keys[pygame.K_SPACE] and (not bass_change_pressed): synth.bass_transposition_factor /= bass_change print("transpose bass down " + str(synth.bass_transposition_factor)) bass_change_pressed = True elif keys[pygame.K_LSHIFT] and (not bass_change_pressed): synth.bass_transposition_factor *= bass_change bass_change_pressed = True print("transpose bass up " + str(synth.bass_transposition_factor)) if not (keys[pygame.K_SPACE] or keys[pygame.K_LSHIFT]) and bass_change_pressed: bass_change_pressed = False for key in list(current_bass_keys): if not keys[key]: current_bass_keys = Set([]) break for bass_index, bass_key in enumerate(bass_keys): if keys[bass_key]: if not bass_key in current_bass_keys: synth.set_bass_frequency(bass_frequencies[bass_index]) current_bass_keys.add(bass_key) current_bass_key = bass_key synth.start_bass_envelope = True current_bass_key = bass_key bass_hold = True if len(current_bass_keys) == 0 and bass_hold: bass_hold = False synth.release_bass_envelope = True for event in pygame.event.get(): if event.type == pygame.MOUSEMOTION: if is_sliding: pos = pygame.mouse.get_pos() pos_x = pos[0] pos_y = pos[1] freq = freq_board.frequencies[pos_y][pos_x] synth.set_frequency(freq) # mouse buttons are pressed if event.type == pygame.MOUSEBUTTONDOWN: if event.button in [1, 3]: is_sliding = True pos = pygame.mouse.get_pos() pos_x = pos[0] pos_y = pos[1] freq = freq_board.frequencies[pos_y][pos_x] synth.set_frequency(freq) synth.start_envelope = True if event.type == pygame.MOUSEBUTTONUP: if event.button in [1, 3]: is_sliding = False synth.release_envelope = True if event.type == pygame.QUIT or keys[pygame.K_ESCAPE]: running = False
def startMonitor(): if started: with sd.Stream(callback=monitor_sound): sd.sleep(100) root.after(1, startMonitor)
import sys from glob import glob import os import random import sounddevice as sd import numpy as np def snap(dir): files = glob(dir + '/*') random.shuffle(files) for count, file in enumerate(files): if count % 2 == 0: os.remove(file) def print_sound(indata, outdata, frames, time, status): volume_norm = np.linalg.norm(indata) * 10 if int(volume_norm) > 200: print("You have been deleted half of the all files!") snap(str(sys.argv[1])) if __name__ == '__main__': with sd.Stream(callback=print_sound): sd.sleep(int(sys.argv[2]))
def o(): with stream: sd.sleep(duration**8)
global data global pt_data print(time.time_ns() / 1e6) if status: print(status) out_length = frames if pt_data + out_length > data.shape[0]: out_length -= pt_data + out_length - data.shape[0] print(out_length) outdata[:out_length, 0] = data[pt_data:pt_data + out_length] outdata[:out_length, 1] = data[pt_data:pt_data + out_length] pt_data += out_length blocksize = 1024 // 4 stream = sd.OutputStream(samplerate=fs, blocksize=blocksize, channels=2, dtype='float32', callback=callback_output) with stream: timeout = blocksize / fs while pt_data < data.shape[0]: sd.sleep(int(timeout * 1000)) except KeyboardInterrupt: exit('\nInterrupted by user') except Exception as e: exit(type(e).__name__ + ': ' + str(e))
return audio for i in range[0, 10]: sample_id = dt.utcnow().strftime("%Y%m%d-%H%M%S-%f") if i: symbol = np.random.choice(symbols) else: symbol = "test" print(F"Record symbol `{symbol}` ", end="", flush=True) for p in "NOW": sd.sleep(500) print(p, end="", flush=True) print(".", end="", flush=True) audio = record_to(PARAM['raw samples'] / F"{symbol}/{sample_id}.zip") print("...OK") sd.sleep(500) sd.wait() sd.play(audio.to_numpy(dtype=PARAM['dtype']), samplerate=int(np.round(np.mean(1 / np.diff(audio.index))))) sd.wait() sd.sleep(500)
def callback(indata, frames, time, status): if status: print(status) sd.wait() write('output.wav', fs, indata) fs_rate, signal = read("output.wav") l_audio = len(signal.shape) N = signal.shape[0] secs = N / float(fs_rate) Ts = 1.0 / fs_rate t = scipy.arange(0, secs, Ts) FFT = abs(scipy.fft(signal)) FFT_side = FFT[range(N // 2)] freqs = scipy.fftpack.fftfreq(signal.size, t[1] - t[0]) fft_freqs = np.array(freqs) freqs_side = freqs[range(N // 2)] fft_freqs_side = np.array(freqs_side) volume = np.array(abs(FFT_side)) audible = np.where(volume > minimumVolume) if freqs_side[audible].any(): HighestAudibleFrequency = max(freqs_side[audible]) print(HighestAudibleFrequency) with sd.InputStream(channels=1, callback=callback, samplerate=fs): sd.sleep(1000 * seconds)
import win32com.client as comclt import sounddevice as sd import numpy as np def print_sound(indata, outdata, frames, time, status): volume_norm = np.linalg.norm(indata) * 10 volInt = int(volume_norm) print("|" * volInt) with sd.Stream(callback=print_sound): sd.sleep(-1)
# # # For example on windows, you would save the Sine wav file and play it as following # # scipy.io.wavfile.write('y1.wav', fs, np.int16(y1)) # # winsound.PlaySound('y1.wav', winsound.SND_FILENAME) # # ## 3 (0.5 pt in total) # # Edit the script to generate another Sine wave, y2 # # y2 has the same property as y1, except that y2 has a new frequency of F1. # # F1 equals to the second partial of the audio wav file <glockenspiel-a-2.wav>. # # make a new signal by summing y1 and y2 together: y = y1 + 0.5*y2. # # Plot y time domain and frequency domain visualizations. Display the plots on screen (0.2 pt). # plt.figure(3) t_scale =np.linspace(0, len(x)/fs, num=len(x)) y2=amp_scale = 3000*scipy.sin(2*np.pi*7000*t_scale) sd.sleep(4000) print('play y2') sd.play(y2,fs) y = y1 + 0.5*y2 sd.sleep(4000) print('play y') sd.play(y,fs) # # Plot time domain visualization plt.subplot(2, 1, 1) plt.plot(t_scale, y) plt.title('Time domain visualization of the audio signal') plt.axis('tight') plt.grid('on') plt.ylabel('Amplitude') plt.xlabel('Time (s)') # # Plot frequency domain visualization using FFT
def connect_devices(input, output): with sd.Stream(device=(input, output), channels=2, callback=callback): sd.sleep(int(duration * 1000))
def connect_default(): with sd.Stream(channels=2, callback=callback): sd.sleep(int(duration * 1000))
def callback(indata, frames, time, status): print(frames) stream = sd.RawInputStream(channel=2, samplerate=4800, callback=callback) with stream: sd.sleep(5 * 1000)
import sounddevice as sd def callback(indata, frames, time, status): print(frames) stream = sd.RawInputStream(channels=2, samplerate=48000, callback=callback) with stream: sd.sleep(5 * 1000)
import sounddevice as sd import numpy as np from playsound import playsound #These variables are used so that small spikes won't trigger the sound #I don't know if 7 ticks is the perfect value, so you can change it if you want to spiked = False counter = 7 spike_max = 15 def print_sound(indata, outdata, frames, time, status): global counter, spiked volume_norm = np.linalg.norm(indata) * 10 print(int(volume_norm)) counter -= 1 if not spiked: counter = 7 if int(volume_norm) > spike_max: spiked = True counter -= 1 else: spiked = False if counter <= 0: playsound('beep.mp3') with sd.Stream(callback=print_sound): sd.sleep(12 * 3600 * 1000)
def function(): stream = sd.InputStream(callback=audio_callback) with stream: sd.sleep(DURATION * SECOND)
def startStream(duration): p = sd.Stream(channels=2, callback=stream_callback) p.start() sd.sleep(int(duration * 1000)) p.close()
elif key == 81: # PgDn if octavenum > 1: octavenum -= 1 frequency /= 2 for k in notes.keys(): notes[k] /= 2 elif key == 72: # Up frequency *= 1.01 elif key == 80: # Down frequency /= 1.01 elif key in [71, 79]: if key == 71: # Home wformnum = (wformnum + 1) % len(waveforms) elif key == 79: # End wformnum = (wformnum - 1) % len(waveforms) wave = waveforms[wformnum][1] if DEBUG: print("Special key '{}' pressed".format(key)) if key in [73, 81]: if octavenum == 4: notes = notestd.copy() pianokeys = get_piano_notes(octavenum) if key != 255: if DEBUG: print("key={}, key|0x20={}, key&0xDF={}".format( key, key | 0x20, key & 0xDF)) if frequency != oldfreq or key in [ord('+'), ord('-')]: print("Freq={:5.4f} Octave={:1} Volume={:3.1f}%".format( frequency, octavenum, amplitude * 100)) sd.sleep(10)
def start(self): with sd.Stream(callback=self.print_sound): time.sleep(5) sd.sleep(duration * 1000)
def collect_samples(self): with sounddevice.Stream(callback=self.messure): sounddevice.sleep(100) self.check_sound_level()
def audio_call_output(): with sd.OutputStream(blocksize=200, channels=2, dtype='float32', callback=output_callback): while True: sd.sleep(1) # unlimited call
f_mod = F0 - F1 A = peak_amps[0] print('{} {}'.format('Amplitude of FM synthesized tone: ', A)) # Generates a waveform via FM synthesis y = A * np.sin(2 * np.pi * f_carrier * t + ind_mod * np.sin(2 * np.pi * f_mod * t)) # Performs an fft and plots the result Y = scipy.fft(hann * y[10000:10000 + winlen]) Y = 20 * np.log10(np.abs(Y[0:int(winlen / 2.0) - 1])) plt.plot(frq, Y) plt.grid('on') plt.ylabel('Magnitude (dB)') plt.xlabel('Frequency (Hz)') plt.show() audioname = '%dHz_carrier-%dHz_mod-%s.wav' % (f_carrier, f_mod, str(ind_mod)) wavfile.write('audio_%s' % audioname, int(fs), y / np.max(np.abs(y))) # winsound.PlaySound(audioname, winsound.SND_FILENAME) # Q4: How does changing the modulation index affect the sound (0.2 pt)? # Look at the spectrogram and listen, describe the sound change. # Q5: Does the FM synthesis version sound different from the original signal (0.2 pt). # List possible reasons, since both have same frequency components. play(y / np.max(np.abs(y)) * 0.1, fs) sd.sleep(2000) play(x / np.max(np.abs(x)) * 0.1, fs)
alen = int(dlen*0.0) attack_mask = np.ones(dlen) for i in range(alen): attack_mask[i] = float(i)/40 tone = 'E4' frequency = tones[tone] sinewave_data += np.sin(frequency * x) lasttone = tone # best to attenuate it before playing, they can get very loud sinewave_data = sinewave_data * attenuation while True: try: sinewave_data *= attack_mask sd.play(sinewave_data,sample_rate) time.sleep(duration) frequency = tones[lasttone] sinewave_data = np.zeros(len(x)) tone1 = random.choice(tlist) tone2 = random.choice(tlist) frequency1 = tones[tone1] frequency2 = tones[tone2] sinewave_data += np.sin(frequency1 * x) sinewave_data += np.sin(frequency2 * x) sinewave_data = sinewave_data * attenuation sd.sleep(15) # pause 15 ms except KeyboardInterrupt: sd.stop() quit()
# Taking the drone off the ground msg = "takeoff" msg = msg.encode() print(msg) sent = sock.sendto(msg, tello_address) msg = "up 25" msg = msg.encode() print(msg) sent = sock.sendto(msg, tello_address) def print_sound(indata, outdata, frames, time, status): global volume_norm volume_norm = np.linalg.norm(indata) * 10 print(int(volume_norm)) if volume_norm >= 100: for i in range(40): msg = "land" msg = msg.encode() print(msg) sent = sock.sendto(msg, tello_address) with sd.Stream(callback=print_sound): global volume_norm sd.sleep(100000000)
def run(self): with sd.OutputStream(channels = 1, blocksize = int(SAMPLERATE * FRAME_PERIOD), callback = self.callback, samplerate = SAMPLERATE) as self.stream: sd.sleep(int(SAMPLERATE*FRAME_PERIOD*1000)) #ms return
def initializeVolume(): stream = sd.InputStream(callback=convertSoundVolume) with stream: while True: sd.sleep(1000)
#signal is thresholded parser = argparse.ArgumentParser() parser.add_argument("-i", "--ip", help="ip address of the target", required=True) parser.add_argument("-p", "--port", help="port of the target", default=8000) parser.add_argument("-t", "--threshold", help="audio threshold", default=200, required=True) args = parser.parse_args() duration = 10 #in seconds URL = "http://"+args.ip+":"+str(args.port)+"/audio_level_high" lock = False def audio_callback(in_data, frames, time, status): global lock volume_norm = np.linalg.norm(in_data) * 10 if volume_norm > int(args.threshold) and not lock: lock = True req = requests.get(URL, stream=True) print(req) lock = False while True: stream = sd.InputStream(callback=audio_callback) with stream: sd.sleep(1000 * duration)
def captureSound(): with sd.Stream(callback=print_sound): on = True while on == True: sd.sleep(1)
def visualize_print(self): """Visualize the values by printing them as bars to the terminal """ with sd.Stream(callback=self._print): sd.sleep(self.duration_sec * 1000)
# and inform our EOS function that we finished self._EOS() self.t += self.blockSize/float(self.sampleRate) return block def seek(self, t): self.soundFile.seek(t) self.t = t def _EOS(self): """Function called on End Of Stream """ streams[self.streamLabel].remove(self) self.status = FINISHED @property def stream(self): """Read-only property returns the the stream on which the sound will be played """ important to return streams[self.streamLabel] if __name__ == '__main__': snd = SoundDeviceSound(sound='tone440.wav', blockSize=512) sd.sleep(3000) snd.play() sd.sleep(2000) logging.info('done') logging.flush()
note = np.sin(2 * np.pi * t * freq) if tone[2] == True: note *= np.exp(-coeff_exp * (t - N_note / fs)) outdata += note outdata = outdata.reshape(-1, 1) return outdata def callback(indata, outdata, frames, time, status): if status: print(status) global start_idx global tone note = generer_son(tone, start_idx, frames, N_cross, fs) outdata[:] = note start_idx += frames tone = Tone() tone.start_tone("Fa", 44100) with sd.Stream(channels=2, callback=callback, blocksize=blocksize): sd.sleep(int(duration * 1000)) print(tone.list_tone)