def panMove(snd0, snd1, fil, nch, mult): if snd0.isPlaying() == True: pass else: snd0.play() snd1.play() ff = float(1 / po.sndinfo(fil)[1] / 4) sin = po.Sine(freq=ff, phase=0) cos = po.Sine(freq=ff, phase=0.25) ini = np.random.randint(0, nch) step = np.random.randint(0, int(nch / 2) + 1) end = (ini + step) % nch snd0.out(ini, 0).setMul(mult * cos) snd1.out(end, 0).setMul(mult * sin) snd0.stop(wait=po.sndinfo(fil)[1]) snd1.stop(wait=po.sndinfo(fil)[1])
def __init__(self, id, filename, loopmode=0, transpo=1, gain=0, playing=0, directout=True, startpoint=0, endpoint=-1, crossfade=5, channel=0): self.id = id self.filename = filename sndfolder = os.path.join(QLiveLib.getVar("projectFolder"), "sounds") info = sndinfo(os.path.join(sndfolder, self.filename)) if info is None: self.valid = False self.duration = -1 else: self.valid = True self.duration = info[1] self.loopmode = loopmode self.transpo = transpo self.gain = gain self.playing = playing self.directout = directout self.startpoint = startpoint self.endpoint = self.duration self.crossfade = crossfade self.channel = channel self.playerRef = None self.currentCue = 0 self.cues = {} self.saveCue()
def filter_file(s, src, target, type, freq, q=1): """ freq : float or PyoObject, optional Cutoff or center frequency of the filter. Defaults to 1000. q : float or PyoObject, optional Q of the filter, defined (for bandpass filters) as freq/bandwidth. Should be between 1 and 500. Defaults to 1. type : int, optional Filter type. Five possible values : 0 : lowpass (default) 1 : highpass 2 : bandpass 3 : bandstop 4 : allpass example of use: s = Server(duplex=0, audio="offline") for file in glob.glob("*.wav"): filter_file(s, file, "filtered/"+file, type = 1, freq = 300, q = 1) s.shutdown() """ from pyo import sndinfo duration = sndinfo(src)[1] s.boot() s.recordOptions(dur=duration, filename=target, fileformat=0, sampletype=0) sf = SfPlayer(src, speed=1, loop=False) f = Biquad(sf, freq=freq, q=q, type=type).mix(2).out() # highpass s.start() s.stop() s.shutdown()
def getSoundInfo(self, path): """ Retrieves information of the sound and prints it to the console. return (number of channels, sampling rate, duration, fraction of a table, length in samples, bitrate) """ print '--------------------------------------' print path info = sndinfo(path) if info is not None: type = info[4] samprate = int(info[2]) chnls = info[3] nsamps = info[0] dur = info[1] bitrate = INV_BIT_DEPTHS.get(info[5], -1) for i in range(24): size = math.pow(2, (i + 1)) if size > nsamps: break tableFrac = nsamps / size print "channels = %d" % chnls print "sampling rate = %s" % samprate print "number of samples = %s" % nsamps print "duration in sec. = %s" % dur print "bitrate = %s" % bitrate print "type = %s" % type return (chnls, samprate, dur, tableFrac, nsamps, bitrate, type) else: print "Unable to get sound infos..." return None
def __init__(self, index: int, frequency: float): closest_frequency = tools.find_closest_item( frequency, self.available_frequencies) second_closest_frequency = tools.find_closest_item( frequency, tuple(f for f in self.available_frequencies if f != closest_frequency), ) if (self.freq_used_counter[closest_frequency] <= self.freq_used_counter[second_closest_frequency]): choosen_frequency = closest_frequency else: choosen_frequency = second_closest_frequency print(frequency, choosen_frequency) self.freq_used_counter.update({choosen_frequency: 1}) self.choosen_sample = self.samples[choosen_frequency] self.pitch_factor = frequency / choosen_frequency self.frequency = frequency self.duration = pyo.sndinfo(self.choosen_sample)[1] + self.tail self.index = index self.bandwidth = 2 self.original_amp = 0.7 self.bp_amp = 0.0000009 self.lp_freq = 11000
def __init__(self, index: int, frequency: float): if frequency < 300: frequency *= 2 closest_frequency = tools.find_closest_item( frequency, self.available_frequencies) print(frequency, closest_frequency) second_closest_frequency = tools.find_closest_item( frequency, tuple(f for f in self.available_frequencies if f != closest_frequency), ) if (self.freq_used_counter[closest_frequency] <= self.freq_used_counter[second_closest_frequency]): choosen_frequency = closest_frequency else: choosen_frequency = second_closest_frequency self.freq_used_counter.update({choosen_frequency: 1}) self.choosen_sample = self.samples[choosen_frequency] self.pitch_factor = frequency / choosen_frequency print(self.pitch_factor) self.frequency = frequency self.duration = pyo.sndinfo(self.choosen_sample)[1] + self.tail self.index = index
def OnDropFiles(self, x, y, filenames): x, y = self.grid.CalcUnscrolledPosition(x, y) col = self.grid.XToCol(x) row = self.grid.YToRow(y) if row > -1 and col == ID_COL_FILENAME: filename = filenames[0] if sndinfo(filename) is not None: self.grid.copyToSoundsFolder(filename) self.grid.setSelRow(row) self.grid.loadSound(os.path.basename(filename))
def render(self): s = pyo.Server(audio="offline") s.boot() sndinfo = pyo.sndinfo(self.path) s.recordOptions(filename=self.complete_output_path, dur=sndinfo[1]) source = pyo.SfPlayer(self.path) source_envelope = pyo.Expseg(list( zip(self.source_envelope.times, self.source_envelope.levels)), exp=5) waveguide_envelope = pyo.Expseg( list( zip(self.waveguide_envelope.times, self.waveguide_envelope.levels)), exp=5, ) filter_envelope = pyo.Expseg( list(zip(self.filter_envelope.times, self.filter_envelope.levels)), exp=5, ) filter_q_envelope = pyo.Linseg( list( zip(self.filter_q_envelope.times, self.filter_q_envelope.levels))) waveguide = pyo.Waveguide( source, freq=self.frequencies, minfreq=self.minfreq, mul=self.waveguide_mul, dur=self.waveguide_dur, ) bandpass = pyo.Resonx( waveguide, self.frequencies, q=filter_q_envelope, stages=4, mul=self.bandpass_mul, ) lfo = pyo.Sine(freq=self.pan_lfo_frequency, mul=0.5, add=0.5) bandpass_pan = pyo.Pan(bandpass, outs=2, pan=lfo) filter_q_envelope.play() filter_envelope.play() source_envelope.play() waveguide_envelope.play() (bandpass_pan * filter_envelope).out() (waveguide * waveguide_envelope).out() (source * source_envelope).out() s.start()
def __init__(self, sf_path_meta_track_pairs: dict): self.sf_path_meta_track_pairs = sf_path_meta_track_pairs durations = [] channels_per_meta_track = {} for meta_track, sf_path_meta_track_pair in sf_path_meta_track_pairs.items( ): if meta_track != "keyboard": sf_path, _ = sf_path_meta_track_pair info = pyo.sndinfo("{}.wav".format(sf_path)) duration, nchannels = info[1], info[3] durations.append(duration) channels_per_meta_track.update({meta_track: nchannels}) self.duration = max(durations) + self.tail
def __init__(self, id, filename, loopmode=0, transpo=1, gain=0, playing=0, directout=True, startpoint=0, endpoint=-1, crossfade=5, channel=0): interpTime = QLiveLib.getVar("globalInterpTime") self.id = id self.filename = filename sndfolder = os.path.join(QLiveLib.getVar("projectFolder"), "sounds") info = sndinfo(os.path.join(sndfolder, self.filename)) if info is None: self.valid = False self.duration = -1 self.sndchnls = -1 else: self.valid = True self.duration = info[1] self.sndchnls = info[3] self.loopmode = loopmode self.transpo = transpo self.gain = gain self.playing = playing self.directout = directout self.startpoint = startpoint self.endpoint = self.duration self.crossfade = crossfade self.channel = channel self.transpox = interpTime self.gainx = interpTime self.transpoDict = None self.gainDict = None self.showInterp = 0 self.playerRef = None self.transpoAutoWindow = None self.gainAutoWindow = None self.cues = {} self.copied = {} currentCue = QLiveLib.getVar("CuesPanel").getCurrentCue() self.addCue(0) self.addCue(currentCue)
def _essentia(path: str, params=None) -> float: """Using essentia to calculate the bpm of a given files. This function has been copied from the essentia examples here: https://essentia.upf.edu/essentia_python_examples.html """ info = pyo.sndinfo(path) audio = es.MonoLoader(filename=path, sampleRate=info[2])() # Compute beat positions and BPM rhythm_extractor = es.RhythmExtractor2013(method="multifeature") bpm, beats, beats_confidence, _, beats_intervals = rhythm_extractor( audio) return bpm
def select_song(path=None): # call out to the newer helper function: song = get_random_song(path) # ices2 needs this logger.debug('Selected song: {0}'.format(song)) song_duration = sndinfo(song)[1] now = datetime.datetime.now() # tag for update at now + song duration removal_date = now + datetime.timedelta(seconds=song_duration) song_stamp = '{0}({1}).stamp'.format(song, removal_date) open(song_stamp, 'a').close() # write music info to a txt which will be available in the web player song_info = get_song_info(os.path.splitext(song)[0] + '.py') f = open(os.path.join(RADIOPYO_PATH, CURRENT_SONG_INFO_FILE), 'w+') current_info = ('<h6>Now playing <em>{0}</em> by {1}</h6> ({2} sec)' .format(song_info['TITLE'], song_info['ARTIST'], song_info['DURATION'])) f.write(current_info) f.close()
def select_song(path=None): # call out to the newer helper function: song = get_random_song(path) # ices2 needs this logger.debug('Selected song: {0}'.format(song)) song_duration = sndinfo(song)[1] now = datetime.datetime.now() # tag for update at now + song duration removal_date = now + datetime.timedelta(seconds=song_duration) song_stamp = '{0}({1}).stamp'.format(song, removal_date) open(song_stamp, 'a').close() # write music info to a txt which will be available in the web player song_info = get_song_info(os.path.splitext(song)[0] + '.py') f = open(os.path.join(RADIOPYO_PATH, CURRENT_SONG_INFO_FILE), 'w+') current_info = ( '<h6>Now playing <em>{0}</em> by {1}</h6> ({2} sec)'.format( song_info['TITLE'], song_info['ARTIST'], song_info['DURATION'])) f.write(current_info) f.close()
def __init__(self, index: int, frequency: float): if index in tuple(range(0, 5)): choosen_frequency = 527.13 frequency *= 2 elif index in tuple(range(5, 8)): choosen_frequency = 394.636 elif index in tuple(range(8, 14)): choosen_frequency = 279.6 else: raise NotImplementedError(index) self.choosen_sample = self.samples[choosen_frequency] self.pitch_factor = frequency / choosen_frequency print(self.pitch_factor) self.frequency = frequency self.duration = pyo.sndinfo(self.choosen_sample)[1] + self.tail self.index = index
def __init__(self, path, overlap=0.2, speed=1, mul=1, state=0, delay=None): self._path = path self._mul = mul self._speed = speed self._overlap = overlap self._time = None self._pattern = pyo.Pattern(self._control) self._infos = pyo.sndinfo(path) self._duration = self._infos[1] self._player0 = pyo.SfPlayer(path, speed=speed, mul=0.5, interp=3) self._player1 = pyo.SfPlayer(path, speed=speed, mul=0.5, interp=3) self._mix = pyo.Mix( [self._player0, self._player1], voices=2, mul=mul ) self._base_objs = self._mix.getBaseObjects() self._state = state self.setOverlap(overlap) self._player0.stop() self._player1.stop() if delay is not None: self._pattern.time = delay
def __init__( self, voice: old.Melody, new_sample_positions: tuple, sample_per_change: tuple, make_envelope: bool, average_volume: float, min_volume: float, max_volume: float, duration: float, tempo_factor: float, shadow_time: float, crossfade_duration: float = 0.25, anticipation_time: float = 0, overlaying_time: float = 0, attack_duration: infit.InfIt = infit.Value(0.5), release_duration: infit.InfIt = infit.Value(0.5), random_seed: int = 100, ) -> None: assert max_volume > min_volume assert min_volume > average_volume if not isinstance(attack_duration, infit.InfIt): attack_duration = infit.Value(attack_duration) if not isinstance(release_duration, infit.InfIt): release_duration = infit.Value(release_duration) import random as random_module random_module.seed(random_seed) self.__random_module = random_module voice.delay = rhy.Compound(voice.delay).stretch(tempo_factor) voice.dur = rhy.Compound(voice.dur).stretch(tempo_factor) self.__sndinfo_per_sample = { sample: pyo.sndinfo(sample) for sample in set(sample_per_change) } self.__n_channels_per_sample = { sample: self.__sndinfo_per_sample[sample][3] for sample in self.__sndinfo_per_sample } self.__duration_per_sample = { sample: self.__sndinfo_per_sample[sample][1] for sample in self.__sndinfo_per_sample } self.__new_sample_positions = new_sample_positions self.__sample_per_change = sample_per_change self.__duration = duration self.__envelope = self.mk_envelope( voice, shadow_time, duration, average_volume, min_volume, max_volume, make_envelope, anticipation_time, overlaying_time, ) self.__anticipation_time = anticipation_time self.__overlaying_time = overlaying_time self.__tempo_factor = tempo_factor self.__attack_duration = attack_duration self.__release_duration = release_duration self.__crossfade_duration = crossfade_duration self.__halved_crossfade_duration = crossfade_duration * 0.5
""" import os import pyo import random s = pyo.Server(duplex=0, audio="offline").boot() # input sound sndpath = "./test.aif" # output folder recpath = os.path.join("./rendered") if not os.path.isdir(recpath): os.mkdir(recpath) # output file duration NUM = 10 orig_dur = pyo.sndinfo(sndpath)[1] dur = pyo.sndinfo(sndpath)[1] * NUM s.recordOptions(dur=dur, filename=os.path.join(recpath, "pyo_test.wav"), fileformat=0, sampletype=0) ############################ # Start an oscillator with a frequency of 250 Hz #syn = pyo.SineLoop(freq=[250,251], feedback=.07, mul=.2).out() #def callback(arg): # # Change the oscillator's frequency to 300 Hz after 2 seconds # syn.freq = arg #a = pyo.CallAfter(callback, 2, [300,301])
import pyo import time path = "example.wav" frames, duration, sampRate, channels, fileFormat, sampType = pyo.sndinfo(path) server = pyo.Server() server.boot() print("booted server") server.start() sound = pyo.SfPlayer(path).out() soundHigh = pyo.FreqShift(sound, shift = 10) soundLow = pyo.FreqShift(sound, shift = -10) soundQuiet = sound * .6 soundLoud = sound / .6 rec = pyo.Record(sound, "test.wav") recHigh = pyo.Record(soundHigh, "example_high.wav") recLow = pyo.Record(soundLow, "example_low.wav") recQuiet = pyo.Record(soundQuiet, "example_quiet.wav") recLoud = pyo.Record(soundLoud, "example_loud.wav") print("start recording...") time.sleep(duration) print("stop recording.") rec.stop() recHigh.stop() recLow.stop() recQuiet.stop() recLoud.stop()