def play_audio(self): if self.play_button.isChecked(): data = preprocess_audio(self.data, spikes_only=self.play_spike_audio) # Track progress if settings.show_audio_line: self.audio_line = self.addLine(x=0) self.audio_timer = pg.QtCore.QTimer() self.audio_timer.setInterval(AUDIO_TIMER_UPDATE) self.audio_timer.timeout.connect(self.update_audio_line) sd.stop() sd.play(data) if settings.show_audio_line: self.audio_timer.start() # Notify all other audio components self.guard = True self.src.s.stop_audio.emit() else: sd.stop() self.audio_timer.stop() if settings.show_audio_line: self.audio_line.hide() self.audio_line = None
def ellis_bpm(fname, start_bpm, hpss=True, hop_length=512, tightness=100.0, plot=False, sound=False): y, sr = librosa.load(fname, sr=None) log.debug(u'Estimating tempo: {}'.format(TERM.cyan(fname))) if hpss: log.debug(TERM.magenta("Getting percussive elements")) y_harmonic, y_percussive = librosa.effects.hpss(y) chunks = np.array_split(y_percussive, PLOT_SPLIT) log.debug(TERM.magenta("Estimating beats per minute")) bpm, beat_frames = librosa.beat.beat_track(y=y_percussive, sr=sr, start_bpm=start_bpm, hop_length=hop_length, tightness=tightness) else: log.debug(TERM.magenta("Estimating beats per minute")) bpm, beat_frames = librosa.beat.beat_track(y=y, sr=sr, start_bpm=start_bpm, hop_length=hop_length, tightness=tightness) chunks = np.array_split(y, PLOT_SPLIT) log.debug(u'Tempo: {:6.2f} bpm'.format(bpm)) if plot: plt.figure(figsize=(16,10)) curr_frame = 0 for i in range(PLOT_SPLIT): plt.subplot(PLOT_SPLIT * 100 + 11 + i) plt.plot(curr_frame + np.arange(len(chunks[i])), chunks[i], 'g') for b in beat_frames: plt.axvline(x=b*hop_length, color='k') plt.xlim([curr_frame, len(chunks[i]) + curr_frame]) curr_frame += len(chunks[i]) plt.show(block=False) if sound: beat_times = librosa.frames_to_time(beat_frames, sr=sr, hop_length=hop_length) clicks = mir_eval.sonify.clicks(beat_times, sr, length=len(y)) sd.play(y + clicks, sr) input('Press Return key to stop sound') sd.stop() return bpm
def get_hpss(filename): # Get sound file (input sr = None, as we don't want to resample) log.debug(u"Loading {}".format(TERM.green(filename))) y, sr = librosa.load(filename, sr=None) log.debug(TERM.magenta("Filtering high frequencies")) y_filt = fir_lowpass(y, 5000, sr) # Get the percussive and harmonic elements log.debug(TERM.magenta("Splitting into harmonic and percussive")) y_harmonic, y_percussive = librosa.effects.hpss(y_filt) y_spss = {"harmonic":y_harmonic, "percussive":y_percussive} # Play each in turn while True: component = get_response("Which component do you want to play?", ["harmonic", "percussive"], numbered=True) if component is None: return None sd.play(y_spss[component], sr) input('Press Return key to stop sound') sd.stop()
def stop_playback(self): sd.stop()
def stop_tone(): sd.stop()
def stopSound(self): # function for stop audio if self.fileName: sd.stop()
def __init__(self, starterWindow): """ Main loop of the UI :param mainWindow: QMainWindow Object """ super(equalizerApp, self).setupUi(starterWindow) # Set Main View self.tabWidget.setCurrentIndex(0) # Setup popup Window self.popup_window = QtWidgets.QMainWindow() self.pop_ui = Ui_OtherWindow() self.pop_ui.setupUi(self.popup_window) # Initializations self.signalFile = ... # the file loaded ---> data, Sampling Rate self.signalDataType = ... # contains the data type of the signal self.signalFourier = ... # fourier transform of the signal file data self.signalBands = ... # Contains the signal bands self.signalBandsCopy = ... # contains a copy of the signal bands for modification purposes self.signalModification = ... # Contains the signal with the modified data self.signalModificationInv = ... # Contains the data to be played and writen to wave self.filename = ... # contains the file path self.format = ... # contains the file format self.loadThread = loaderThread() # contains the loader thread self.sliderValuesClicked = {0:..., 1:..., 2:..., 3:..., 4:..., 5:..., 6:..., 7:..., 8:..., 9:...} # list contains the last pressed values self.results = {1:[], 2:[]} self.resultCounter = 1 # encapsulations self.sliders = [self.verticalSlider, self.verticalSlider_2, self.verticalSlider_3, self.verticalSlider_4, self.verticalSlider_5, self.verticalSlider_6, self.verticalSlider_7, self.verticalSlider_8, self.verticalSlider_9, self.verticalSlider_10] # Widgets encapsulations self.frontWidgets = [self.inputSignalGraph, self.sliderChangedGraph] self.outputWidgets = [self.inputTimeOriginal, self.outputTimeModified, self.inputFourierOriginal, self.outputFourierModified] self.compareWidgets = [self.result1Plot, self.result2Plot] self.differenceWidgets = [self.pop_ui.timeDifference, self.pop_ui.fourierDifference] self.allWidgets = [self.frontWidgets, self.outputWidgets, self.compareWidgets, self.differenceWidgets] # buttons encapsulations self.playerButtons = [self.playButton, self.stopButton] self.outputButtons = [self.resetBands, self.showResult, self.playResult] self.saveButtons = [self.saveFile_btn, self.showDifference_btn, self.saveResult_btn, self.compareResult_btn] self.resultButtons = {1: [self.playCompare, self.stopCompare], 2: [self.playCompare_2, self.stopCompare_2]} self.windows = [self.rectangle, self.hanning, self.hamming] # Top Titles self.widgetTitles = ["Original Signal", "Changes Applied"] self.outputWidgetsTitles = ["Original Signal in Time", "Output Signal in Time", "Original Signal Fourier", "Output Signal Fourier"] self.compareTitles = ["First Result", "Second Result"] self.differenceTitles = ["Time Difference", "Fourier Difference"] self.allTitles = [self.widgetTitles, self.outputWidgetsTitles, self.compareTitles, self.differenceTitles] # Bottom Titles self.widgetsBottomLabels = ["No. of Samples", "Frequencies"] self.outputWidgetsBottomLabels = ["No. of Samples", "No. of Samples", "Frequencies", "Frequencies"] self.compareBottomLabels = ["Frequencies", "Frequencies"] self.differenceBottomLabels = ["No. of Samples", "Frequencies"] self.allButtomLabels = [self.widgetsBottomLabels, self.outputWidgetsBottomLabels, self.compareBottomLabels, self.differenceBottomLabels] # pens configurations (Plot Colors) self.pens = [pg.mkPen(color=(255, 0, 0)), pg.mkPen(color=(0, 255, 0)), pg.mkPen(color=(0, 0, 255)), pg.mkPen(color=(200, 87, 125)), pg.mkPen(color=(123, 34, 203))] for encap in zip(self.allWidgets, self.allTitles, self.allButtomLabels): for widget, title, label in zip(encap[0], encap[1], encap[2]): widget.plotItem.setTitle(title) widget.plotItem.showGrid(True, True, alpha=0.8) widget.plotItem.setLabel("bottom", text=label) # Setup Y Range in Time Plot widgets for i in range(0, 2): self.outputWidgets[i].setYRange(-30000, 30000) self.inputSignalGraph.setYRange(-30000, 30000) # CONNECTIONSx self.actionload.triggered.connect(self.loadFile) for slider in self.sliders: slider.id = self.sliders.index(slider) slider.signal.connect(self.sliderChanged) self.playButton.clicked.connect(lambda : sd.play(self.signalFile["data"] , self.signalFile['frequency'])) self.stopButton.clicked.connect(lambda : sd.stop()) self.playResult.clicked.connect(lambda : sd.play(self.signalModificationInv.astype(self.signalDataType), self.signalFile['frequency'])) self.resetBands.clicked.connect(self.resetAllBands) # Save Output Buttons self.showResult.clicked.connect(self.showResultOutput) self.saveFile_btn.clicked.connect(lambda: self.saveWaveFile(self.signalFile['frequency'], self.signalModificationInv)) # Difference Button self.showDifference_btn.clicked.connect(self.showDifferenceWindow) #Compare Results self.saveResult_btn.clicked.connect(self.saveResult) self.compareResult_btn.clicked.connect(self.compareResults) self.playCompare.clicked.connect(lambda : sd.play(self.results[1][1].astype(self.signalDataType), self.signalFile['frequency'])) self.playCompare_2.clicked.connect(lambda : sd.play(self.results[2][1].astype(self.signalDataType), self.signalFile['frequency'])) self.stopCompare.clicked.connect(lambda : sd.stop()) self.stopCompare_2.clicked.connect(lambda : sd.stop())
def stop(): """Stop playing Sound snd.""" sounddevice.stop()
def start(self): """ Start sample program """ # move to local namespace bpm = self.settings['bpm'] ts = self.settings['time_signature'] measures = self.settings['measures'] layers = self.settings['layers'] samplerate = self.settings['samplerate'] channels = self.settings['channels'] cannon = self.settings['cannon'] # boolean # precalculate useful values entrysize = samplerate * measures * ts[0] * (60. / bpm) # countdown for b in xrange(1, ts[0] + 1): print 'Down measure {}/{}...'.format(b, ts[0]) time.sleep(60. / bpm) self.recording = np.zeros((layers, int(entrysize), channels)) print 'Recording...' for phrase in xrange(100): # set with variable # define condition for writing new layers of music if cannon: condition = True else: condition = phrase < layers sd.stop() # Catch layers... if condition: print 'RECORDING...' temp_recording = sd.playrec(np.sum(self.recording, axis=0), samplerate=samplerate, channels=channels) else: sd.play(np.sum(self.recording, axis=0), samplerate, loop=False, blocking=False) for m in xrange(1, measures + 1): #clear_screen() print 'Measure {}/{}...'.format(m, measures) ### On the beat ### for b in xrange(1, ts[0] + 1): print 'Beat {}/{}'.format(b, ts[0]) time.sleep(60. / bpm) if condition: pickle.dump(temp_recording, open('data.p', 'wb')) #filtered_recording = butter_highpass_filter(temp_recording,5,samplerate) filtered_recording = my_filter(temp_recording) self.recording[phrase % layers, :, :] = filtered_recording #plt.plot(filtered_recording) #plt.show() print 'End recording.' # play looped track #sd.play(self.recording,loop=False,blocking=False) for m in xrange(1, measures + 1): print 'Measure {}/{}...'.format(m, measures) for b in xrange(1, ts[0] + 1): print 'Beat {}/{}'.format(b, ts[0]) time.sleep(60. / bpm)
def playsound(data): sd.play(data, fs) sleep(data.shape[0] / fs) sd.stop() pass
def discard(self): sd.stop()
def stop_playback(self): sd.stop() sd.wait() filename = self.file_path[:-4] + 'filtered.wav' sf.write(filename, self.data, self.fs)
def stop_playback_button(self): sd.stop() sd.wait() filename = AudioTool.file_path[:-4] + 'filtered.wav' sf.write(filename, AudioTool.data, AudioTool.fs) self.dismiss_popup
def discard_button(self): sd.stop() self.dismiss_popup()
def stop(): '''Stop playing Sound snd.''' sounddevice.stop()
def stop(self): '''Stop playing this Sound.''' sounddevice.stop()
def __del__(self): """ Class destuctor. """ if self.isPlaying: sd.stop()
def stop(): try: sd.stop(snd) except: sd.stop(data)
def play(self, duration=1.0, blocking=False, loop=False, device=11): sd.play(self.wave, loop=loop, mapping=self.channels, device=device) if blocking: sleep(duration) sd.stop()
def buttonStop(): sd.stop() try: os.remove("selectedTrack.wav") except: print("nothing to delete")
def on_relaese(sd): sd.stop()
def stop(): sd.stop();
def stop(self): sd.stop()
def stop(self): """ Can be used to stop playing before the end """ sd.stop()
def stop(): """ Stop playing audio. """ sd.stop()
def stop(self): """Stop playing of this (and all other) sound.""" sounddevice.stop()
def stop_music(event=None): sd.stop() sd.default.reset()
def gread(signal): #TODO:Eu preciso uma forma melhor de ordenar meus listeners, mas por enquanto 0 eh o static e 1 o dynamic #TODO: este eh um ponto de falha, mudar os nodes ligados podem mudar a ordem estabelecida if signal.type == gsignal.ACTION: AudioTrack.play() if signal.type == gsignal.ACTION2: if (AudioTrack.mode == 0): AudioTrack.mode = 2 AudioTrack.tick = 0 AudioTrack.recbuffer = np.zeros((480000, 1)) sd.rec(out=AudioTrack.recbuffer) elif (AudioTrack.mode == 2): AudioTrack.mode = 0 sd.stop() else: print( "Erro: Não foi iniciar uma gravação, o controlador de áudio está ocupado" ) #TODO: fazer display gráfico do erro, usar algo estilo toast em android? if signal.type == gsignal.ACTION3: #modular o sinal indicado por trackname.iterator e subtrackname.iterator #TODO: consertar um gub bem obvio onde o trackname e o subtrackname vao estar trocados #TODO: sugestao: alterar o modulate de forma que seja simetrico pro carrier e pro signal track = AudioTrack.modulateamplitude( AudioTrack.tracklist[AudioTrack.tracknames.iterator], AudioTrack.tracklist[AudioTrack.subtracknames.iterator]) AudioTrack.savetrack(track, track.name) if signal.type == gsignal.ACTION4: track = AudioTrack.addtracks( AudioTrack.tracklist[AudioTrack.tracknames.iterator], AudioTrack.tracklist[AudioTrack.subtracknames.iterator]) AudioTrack.savetrack(track, track.name) if signal.type == gsignal.ACTION5: #TODO:eventualmente atualizar o demodulate de forma que não preciso informar o breakin track = AudioTrack.demodulateamplitude( AudioTrack.tracklist[AudioTrack.tracknames.iterator], AudioTrack.breakin.iterator + 1) AudioTrack.savetrack(track, track.name) if signal.type == gsignal.SELECT4: #Trocar o tracknames com o subtracknames hold = AudioTrack.tracknames.iterator AudioTrack.tracknames.iterator = AudioTrack.subtracknames.iterator AudioTrack.subtracknames.iterator = hold if signal.type == gsignal.SAVE: if (AudioTrack.mode == 0): AudioTrack.save() else: print( "Erro: Não foi possível salvar a ammostra de som, está certo de que ainda não está gravando?" ) #TODO: fazer display gráfico do erro, usar algo estilo toast em android? if signal.type == gsignal.SELECT: audiotrack = AudioTrack.tracklist[signal.content] if (AudioTrack.displaymode.iterator == 0): AudioTrack.trackablegraph.content = audiotrack.track else: AudioTrack.trackablegraph.content = audiotrack.fourier AudioTrack.detectTone(audiotrack.fourier) if signal.type == gsignal.SELECT2: audiotrack = AudioTrack.tracklist[AudioTrack.tracknames.iterator] if (AudioTrack.displaymode.iterator == 0): AudioTrack.trackablegraph.content = audiotrack.track else: AudioTrack.trackablegraph.content = audiotrack.fourier
def excitation(exc_parameters): """Creates excitation file based off of the parameters parsed. Described below. """ # settings # This is as a fraction of the maximum amplitude 1 = 2.96 V conversion_factor = float(exc_parameters['cfact']) #-0.845 amplitude = conversion_factor * float(exc_parameters['amplitude']) stable = float(exc_parameters['stable']) # stable duration in seconds # Doesn't necessarily work for other sample rates sample_rate = float(exc_parameters['sample_rate']) # recording duration in seconds duration = float(exc_parameters['duration']) frequency = float(exc_parameters['frequency']) # Frequency # Stable "Voltage" actually a fraction of max output positive values only v1 = conversion_factor * float(exc_parameters['v1']) # Recording Start "Voltage" actually a fraction of max output 0.1 = ~0.045V v2 = conversion_factor * float(exc_parameters['v2']) # Recording stop "Voltage" actually a fraction of max output 1.0 = ~1.265 v3 = conversion_factor * float(exc_parameters['v3']) sramp = np.linspace(v1, v1, int(stable * sample_rate)) # ramp for stable period ramp = np.linspace(v2, v3, int(duration * sample_rate)) # ramp for excitation volt_range = np.append(sramp, ramp, axis=0) # stable duration # Left channel wave form xls = np.ones(int(stable * sample_rate)) # Right Channel waveform xrs = np.ones(int(stable * sample_rate)) s_left_channel = xls * v1 # modified to remove amplitude s_right_channel = xrs * v1 s_left_channel -= sramp s_right_channel += sramp stable_waveform_stereo = np.vstack( (s_left_channel, s_right_channel)).T # combine left and right channels # record duration xl = np.linspace(0, duration * 2 * np.pi, int(duration * sample_rate)) xr = np.linspace(0, duration * 2 * np.pi, int(duration * sample_rate)) left_channel = amplitude * np.sin(frequency * xl) right_channel = amplitude * np.sin(frequency * xr + np.pi) left_channel -= ramp right_channel += ramp # combine left and right channels waveform_stereo = np.vstack((left_channel, right_channel)).T # create total waveform total_waveform = (np.append(stable_waveform_stereo, waveform_stereo, axis=0)) # record data rec_data = sd.playrec(total_waveform, sample_rate, channels=1) time.sleep(stable + duration) sd.stop() rec = len(rec_data) zeroCol = np.zeros(rec, dtype=int) df = pd.DataFrame(zeroCol) df.insert(loc=1, column=1, value=rec_data) blank_samples = 4000 df.iloc[0:blank_samples, 1] = 0 return df, volt_range
## Generating the waveform print("Synthesizing the waveform:") # Synthesizing the waveform is fairly straightforward. Remember that the longer the # spectrogram, the more time-efficient the vocoder. generated_wav = vocoder.infer_waveform(spec) ## Post-generation # There's a bug with sounddevice that makes the audio cut one second earlier, so we # pad it. generated_wav = np.pad(generated_wav, (0, synthesizer.sample_rate), mode="constant") # Play the audio (non-blocking) if not args.no_sound: sd.stop() sd.play(generated_wav, synthesizer.sample_rate) # Save it on the disk fpath = "%02d - %s.wav" % (num_generated, line[:10]) print(generated_wav.dtype) librosa.output.write_wav(fpath, generated_wav.astype(np.float32), synthesizer.sample_rate) num_generated += 1 print("\nSaved output as %s\n\n" % fpath) except Exception as e: print("Caught exception: %s" % repr(e)) print("Restarting\n")
def send_over_sound(message): # set device to play sound from sd.default.device = 3 # int(input("Please select Microphone:\t")) # Samples per second sps = 44100 spp = int(2560 * 2) # Base Frequency that must match receiver freq_hz = 1200.0 # Attenuation so the sound is reasonable volume atten = 0.1 # Convert message to binary. message_binary = ' '.join(f"{ord(x):07b}" for x in message) print(message_binary) message_binary = message_binary.replace(" ", "") print(len(message_binary)) # make sure the message is divisible by 3 for encoding while (len(message_binary) % 3 != 0): message_binary += "0" # print message in binary print([message_binary[i:i + 7] for i in range(0, len(message_binary), 7)]) message_binary_list = [3.33, 3.66] # encode message no symbols beside each other will be the same. for i in range(0, len(message_binary), 3): if message_binary[i] == "0" and message_binary[ i + 1] == "0" and message_binary[i + 2] == "0": message_binary_list.append(0.66) elif message_binary[i] == "0" and message_binary[ i + 1] == "0" and message_binary[i + 2] == "1": message_binary_list.append(1) elif message_binary[i] == "0" and message_binary[ i + 1] == "1" and message_binary[i + 2] == "0": message_binary_list.append(1.33) elif message_binary[i] == "0" and message_binary[ i + 1] == "1" and message_binary[i + 2] == "1": message_binary_list.append(1.66) elif message_binary[i] == "1" and message_binary[ i + 1] == "0" and message_binary[i + 2] == "0": message_binary_list.append(2) elif message_binary[i] == "1" and message_binary[ i + 1] == "0" and message_binary[i + 2] == "1": message_binary_list.append(2.33) elif message_binary[i] == "1" and message_binary[ i + 1] == "1" and message_binary[i + 2] == "0": message_binary_list.append(2.66) elif message_binary[i] == "1" and message_binary[ i + 1] == "1" and message_binary[i + 2] == "1": message_binary_list.append(3) transmit_lenght = len(message_binary_list) if message_binary_list[transmit_lenght - 2] == message_binary_list[transmit_lenght - 1]: message_binary_list[transmit_lenght - 1] = 3.33 message_binary_list.append(3.66) message_binary_list.append(3.33) message_binary_list.append(3.66) print(message_binary_list) # NumpPy to calculate the waveform # Calculate the duration of the message duration_s = ((len(message_binary_list)) * spp) / sps duration_s = math.ceil(duration_s) print(duration_s) # Calculate the number of samples total_samples = sps * duration_s each_sample_number = np.arange(total_samples) # convert message list to numpy array message_array = np.array(message_binary_list) scaled_message_array = np.array([0, 0]) # Scale message to have spp samples per symbol for i in message_binary_list: a = np.full((1, spp), i) scaled_message_array = np.concatenate( (scaled_message_array, np.full((1, spp), i)), axis=None) # pad message with zeros to ensure array is full scaled_message_array = np.pad( scaled_message_array, (0, total_samples - len(scaled_message_array)), "constant") # set symbol frequency message_array = scaled_message_array * freq_hz # calculate waveform waveform = np.sin(2 * np.pi * each_sample_number * message_array / sps) # lower volume waveform_quiet = waveform * atten # generate graph for debug # plt.title("Matplotlib demo") # plt.xlabel("x axis caption") # plt.ylabel("y axis caption") # plt.plot(each_sample_number, waveform_quiet) # dont show graph # plt.show() # Play the waveform out the speakers sd.play(waveform_quiet, sps) time.sleep(duration_s) sd.stop() return
def play(self, wav, sample_rate): sd.stop() sd.play(wav, sample_rate)
def DieProgramDie(): sd.stop() print('') print('') print('') print('Thanks for making some dumb music, Panga!')