def create_pitch_alg(pitch_method="default", pitch_buffer_size=4*512, pitch_hop_size=256, pitch_samplerate=44100, pitch_tolerance=0.8, pitch_unit="midi"): pitch_alg = aubio.pitch(pitch_method, pitch_buffer_size, pitch_hop_size, pitch_samplerate) pitch_alg.set_tolerance(pitch_tolerance) pitch_alg.set_unit(pitch_unit) return pitch_alg
def aubio_f0yin(y, sr, nwind=1024, hop=512, method='yin', tolerance=None): ''' Applies f0 detection to a numpy vector using aubio ''' from aubio import pitch, fvec po = pitch(method, nwind, hop, sr) vs = fvec(nwind) if tolerance is not None: if tolerance > 0.0 and tolerance < 1.0: po.set_tolerance(tolerance) else: sys.stderr.write('Tolerance not set: Out of bounds\n') nsamples = y.shape[0] freq = [] time = [] conf = [] for ii in xrange(0,nsamples-nwind, hop): thisy = y[ii:ii+nwind] vs[:] = thisy time.append(float(ii+nwind/2)/sr) freq.append(po(vs)) conf.append(po.get_confidence()) return np.array(freq).squeeze(), np.array(time), np.array(conf)
def get_user_audio(): ''' Using pyaudio, this function takes in mic input and returns the respective midi pitch value. ''' # instantiate PyAudio object p = pyaudio.PyAudio() # open mic stream mic = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=PERIOD_SIZE_IN_FRAME) # Initiating Aubio's pitch detection object. pDetection = aubio.pitch(METHOD, CHUNK, HOP_SIZE, RATE) # Set unit. pDetection.set_unit("Hz") # Frequency under 5 dB will considered # as a silence (8 dB is a C1 or midi#0) pDetection.set_silence(-40) data = mic.read(PERIOD_SIZE_IN_FRAME) # Convert into number that Aubio understand. samples = np.fromstring(data, dtype=aubio.float_type) # Finally get the pitch. pitch = pDetection(samples)[0] midi = freq2midi(pitch) mic.stop_stream() mic.close() p.terminate() return midi
def _compute_pitch_contour(self, window): """ Computes the pitch contour of the audio data, along with the confidence curve. """ win_s = 4096 # fft size hop_s = 512 # hop size samplerate = 8000 tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) INT_TO_FLOAT = 1. / 32768. #2^15 (15 not 16 because it's signed) # convert to an array of 32-bit floats in the range [-1,1] pitch_input = np.float32(window * INT_TO_FLOAT) pitch_contour = [] confidence_curve = [] index = 0 while True: samples = pitch_input[index * hop_s:(index + 1) * hop_s] pitch_output = pitch_o(samples)[0] confidence = pitch_o.get_confidence() pitch_contour += [pitch_output] # append to contour confidence_curve += [confidence] index += 1 if (index + 1) * hop_s > len(pitch_input): break # stop when there are no more frames if self.debug: print("Pitch contour has length {}.".format(len(pitch_contour))) return pitch_contour, confidence_curve
def detect_pitch(self, mouse, stream) -> None: """ Detect pitch of input chunks :param mouse: mouse handler instance :param stream: pyaudio stream instance :returns: None """ pitch_detect = aubio.pitch("default", 2048, 2048 // 2, 44100) pitch_detect.set_unit("Hz") pitch_detect.set_silence(-40) print("Started. Hit the notes..") while True: data = stream.read(1024, exception_on_overflow=False) samples = np.fromstring(data, dtype=aubio.float_type) pitch = pitch_detect(samples)[0] # Compute the energy (volume) of the current frame. volume = np.sum(samples**2) / len(samples) volume = "{:.6f}".format(volume) mouse.handle_mouse(pitch)
def getPitch(filename): from aubio import pitch, source # buffer size (window size) - higher is good for lower frequencies win_s = 4096 hop_s = 512 s = source(filename) # wav samplerate is 44.1kH tolerance = 0.8 pitch_o = pitch("yin", win_s) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches, confidences = [], [] # total number of frames read total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] pitch = round(pitch, 3) confidence = pitch_o.get_confidence() if confidence < 0.60: pitch = 0 pitches += [pitch] confidences += [confidence] total_frames += read if read < hop_s: break return pitches
def setup(self, channels=None, samplerate=None, blocksize=None, totalframes=None): # Frame parameters setup if self._blocksize_s: self.input_blocksize = nextpow2(self._blocksize_s * samplerate) else: self.input_blocksize = 2048 if self._stepsize_s: self.input_stepsize = int(np.round(self._stepsize_s * samplerate)) else: self.input_stepsize = self.input_blocksize / 2 # Now that frames size metadata are properly set, we can do the set-up super(AubioPitch, self).setup(channels, samplerate, blocksize, totalframes) # Aubio Pitch set-up self.aubio_pitch = pitch( "default", self.input_blocksize, self.input_stepsize, samplerate) self.aubio_pitch.set_unit("freq") self.block_read = 0 self.pitches = [] self.pitch_confidences = []
def read_pitch(filename, chunk): win_s = chunk # fft size hop_s = win_s # hop size samplerate = 0 # if len( sys.argv ) > 2: samplerate = int(sys.argv[2]) s = source(filename, samplerate, hop_s) samplerate = s.samplerate pitch_o = pitch("default", win_s, hop_s, samplerate) pitch_o.set_unit("freq") pitches = [] # times = [] # total number of frames read total_frames = 0 while True: samples, read = s() cur_pitch = pitch_o(samples)[0] # print "%f %f" % (total_frames / float(samplerate), pitch) pitches.append(Pitch(cur_pitch, total_frames / float(samplerate))) total_frames += read if read < hop_s: break # print pitches if len(pitches) == 0: return None return pitches
def __init__(self, filename, title, unit='midi', method='yin', samplerate=12800, hop=512, win_s=4096): """ Default values 128000 / 512 = 25 sample per second. """ self.filename = filename self.title = title self.unit = unit self.hop = hop self.win_s = win_s # Support to frequency not completed and never used self.is_midi = self.unit == 'midi' self.method = method self.samplerate = samplerate self.s = source(filename, self.samplerate, self.hop) self.pitch_o = pitch(self.method, self.win_s, self.hop, self.samplerate) self.pitch_o.set_unit(self.unit) self.pitch_o.set_silence(self.silence) self.pitch_o.set_tolerance(self.tolerance)
def getPitch(filename): from aubio import pitch downsample = 1 samplerate = 44100 / downsample win_s = 1024 / downsample # fft size hop_s = 256/ downsample # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) total_frames = 0 pitches = [] confidences=[] while True: samples, read = s() pitch = pitch_o(samples)[0] confidence = pitch_o.get_confidence() confidences+=[confidence] pitches += [pitch] total_frames += read if read < hop_s: break pitches = array(pitches[1:]) confidences = array(confidences[1:]) cleaned_pitches = pitches cleaned_pitches = ma.masked_where(confidences < tolerance, cleaned_pitches,copy=False) cleaned_pitches = cleaned_pitches[~cleaned_pitches.mask] return max(cleaned_pitches)
def extract_pitch(sig, fs): """ Extract MIDI pitch of signal """ downsample = 1 samplerate = fs win_s = 4096 / downsample # fft size hop_s = 512 / downsample # hop size tolerance = 0.8 #['default', 'schmitt', 'fcomb', 'mcomb', 'yin', 'yinfft'] pitch_o = pitch("default", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read i = 0 while i + hop_s < len(sig[:,0]): samples = sig[i:i+hop_s][:,0] my_pitch = pitch_o(samples) #pitch = int(round(pitch)) confidence = pitch_o.get_confidence() #if confidence < 0.8: pitch = 0. #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence) pitches += [my_pitch] confidences += [confidences] i += hop_s pitches = np.array(pitches) pitches = pitches[pitches > 10] return np.median(pitches) # we return the median of the frequencies found
def pitches(filename, samplerate=None, downsample=1): if samplerate is None: samplerate = 44100 / downsample win_s = 4096 / downsample # fft size hop_s = 512 / downsample # hop size s = aubio.source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = aubio.pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] #pitch = int(round(pitch)) confidence = pitch_o.get_confidence() #if confidence < 0.8: pitch = 0. #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence) pitches += [pitch] confidences += [confidence] total_frames += read if read < hop_s: break return samples, pitches, confidences, total_frames
def get_pitch(filename): downsample = 1 samplerate = 44100 // downsample # if len( sys.argv ) > 2: samplerate = int(sys.argv[2]) win_s = 4096 // downsample # fft size hop_s = 512 // downsample # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("schmitt", win_s, hop_s, samplerate) pitch_o.set_unit("Hz") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read total_frames = 0 while True: samples, read = s() p = pitch_o(samples)[0] # pitch = int(round(p)) confidence = pitch_o.get_confidence() # if confidence < 0.8: p = 0. # print("%f %f %f" % (total_frames / float(samplerate), p, confidence)) pitches += [p] confidences += [confidence] total_frames += read if read < hop_s: break return np.mean(pitches)
def getAmp(filename): downsample = 8 samplerate = 44100 // downsample win_s = 4096 // downsample # fft size hop_s = 512 // downsample # hop size s = aubio.source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = aubio.pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("freq") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read total_frames = 0 counter = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] confidence = pitch_o.get_confidence() #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence) pitches += [pitch] confidences += [confidence] total_frames += read if read < hop_s: break letterList = [] newPitches = [] amplitudes = [] for index in range(0, len(pitches)): amp = getSection( filename, index, ) #, index + 5) amplitudes.append(amp.rms) return amplitudes
def getPitchDiff(path): downsample = 1 samplerate = 44100 / downsample win_s = 4096 / downsample # fft size hop_s = 512 / downsample # hop size s = source(path, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = aubio.pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] #pitch = int(round(pitch)) confidence = pitch_o.get_confidence() #if confidence < 0.8: pitch = 0. #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence) pitches += [pitch] confidences += [confidence] total_frames += read if read < hop_s: break return np.median(np.fabs(np.diff(pitches)))
def harmonize(name): # load data # y = AudioSegment.from_file(name+'.m4a', 'm4a') # y.export(name+'.wav', format='wav') y, sr = librosa.load(name) label = get_label(name, sr) # create pitch object (for pitch detection) p = aubio.pitch("default", samplerate=sr) # pad end of input vector with zeros pad_length = p.hop_size - y.shape[0] % p.hop_size y_padded = np.pad(y, (0, pad_length), 'constant', constant_values=0) # to reshape it in blocks of hop_size y_padded = y_padded.reshape(-1, p.hop_size) # input array should be of type aubio.float_type (defaults to float32) y_padded = y_padded.astype(aubio.float_type) # get sample index and note from original song idx_and_notes = get_idx_and_note(y_padded, p) for (i, n) in idx_and_notes: print(i/sr, n) # get mixed data mixed_data = mix_data(idx_and_notes, label, sr) # get corresponding chord ratios from chord label ratios = [(idx, get_target_keys(note, lab)) for (idx, note, lab) in mixed_data] # get chord data chord_data = get_chord_data(y, sr, ratios) # write result librosa.output.write_wav(name.split(".")[0]+"_t.wav", chord_data, sr)
def avg_frequence(path_to_music): downsample = 1 samplerate = 44100 // downsample win_s = 4096 // downsample hop_s = 512 // downsample src = aubio.source(path_to_music, samplerate, hop_s) samplerate = src.samplerate pitch_o = aubio.pitch("yinfft", win_s, hop_s, samplerate) total_frames = 0 counter = 0 total_pitch = 0 while True: counter += 1 samples, read = src() pitch = pitch_o(samples)[0] total_frames += read total_pitch += pitch if ((total_frames / float(samplerate)) > 5.1): break return (total_pitch/counter)
def __init__(self, song_path): super(AudioController, self).__init__() self.audio = Audio(2, input_func=self.receive_audio) self.mixer = Mixer() self.audio.set_generator(self.mixer) self.song = song_path melody_path = self.song + '_melody.wav' harmony_path = self.song + '_harmony.wav' self.melody_track = WaveGenerator(WaveFile(melody_path)) self.harmony_track = WaveGenerator(WaveFile(harmony_path)) self.mixer.add(self.melody_track) self.mixer.add(self.harmony_track) self.melody_mute = False self.harmony_mute = False self.pitch = 0 self.input_buffers = [] self.downsample = 1 self.samplerate = 44100 // self.downsample if len(sys.argv) > 2: self.samplerate = int(sys.argv[2]) self.win_s = 4096 // self.downsample # fft size self.hop_s = 512 // self.downsample # hop size self.tolerance = 0.8 self.pitch_o = pitch("yin", self.win_s, self.hop_s, self.samplerate) self.pitch_o.set_unit("midi") self.pitch_o.set_tolerance(self.tolerance)
def setup(self, channels=None, samplerate=None, blocksize=None, totalframes=None): super(AubioPitch, self).setup(channels, samplerate, blocksize, totalframes) self.aubio_pitch = pitch("default", self.input_blocksize, self.input_stepsize, samplerate) self.aubio_pitch.set_unit("freq") self.block_read = 0 self.pitches = [] self.pitch_confidences = []
def main(self, args): # Initiating PyAudio object. pA = pyaudio.PyAudio() # Open the microphone stream. mic = pA.open(format=self.FORMAT, channels=self.CHANNELS, rate=self.SAMPLE_RATE, input=True, frames_per_buffer=self.PERIOD_SIZE_IN_FRAME) # Initiating Aubio's pitch detection object. pDetection = aubio.pitch(self.METHOD, self.BUFFER_SIZE, self.HOP_SIZE, self.SAMPLE_RATE) # Set unit. pDetection.set_unit("Hz") # Frequency under -40 dB will considered # as a silence. pDetection.set_silence(-40) while True: # Update microphone stream data = mic.read(self.PERIOD_SIZE_IN_FRAME) # Translate to aubio samples = num.fromstring(data, dtype=aubio.float_type) # Find pitch from samples pitch = pDetection(samples)[0] # Get volume from samples volume = num.sum(samples**2) / len(samples) # Format volume for 6 digit float detect_pitch = self.pitch_detection(pitch) # Finally print the pitch and the volume. print( str(pitch) + " " + str(volume) + " " + (str(self.current_color)))
def initializeAudio(self): global file # opens file as wave file self.src = file + ".wav" samplerate = 0 self.total_frames = 0 # initialize aubio data self.a_source = aubio.source(self.src, samplerate, self.hop_s) self.samplerate = self.a_source.samplerate self.p = pyaudio.PyAudio() self.format = pyaudio.paFloat32 self.frames = self.hop_s self.channels = 1 self.p = pyaudio.PyAudio() self.a_tempo = aubio.tempo("default", self.win_s, self.hop_s, self.samplerate) self.pitch_o = aubio.pitch("yin", self.win_s, self.hop_s, self.samplerate) self.notes_o = aubio.notes("default", self.win_s, self.hop_s, self.samplerate) self.o = aubio.onset("default", self.win_s, self.hop_s, self.samplerate) self.o2 = aubio.onset("hfc", self.win_s, self.hop_s, self.samplerate) print("Audio set up for", file)
def record(): p = pyaudio.PyAudio() noteList = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"] buffer_size = 1024 pyaudio_format = pyaudio.paFloat32 n_channels = 1 samplerate = 44100 stream = p.open(format=pyaudio_format, channels=n_channels, rate=samplerate, input=True, frames_per_buffer=buffer_size) tolerance = 0.8 win_s = 4096 # fft size hop_s = buffer_size # hop size pitch_o = aubio.pitch("default", win_s, hop_s, samplerate) pitch_o.set_unit("Hz") pitch_o.set_tolerance(tolerance) audiobuffer = stream.read(buffer_size) signal = np.fromstring(audiobuffer, dtype=np.float32) pitch = pitch_o(signal)[0] confidence = pitch_o.get_confidence() #stream.stop_stream() #stream.close() #p.terminate() sungNote = hztoNote(pitch) # if(sungNote != None): # print(sungNote) return sungNote
def setup(self, channels=None, samplerate=None, blocksize=None, totalframes=None): super(AubioPitch, self).setup(channels, samplerate, blocksize, totalframes) # Frame parameters setup if self._blocksize_s: self.input_blocksize = nextpow2(self._blocksize_s * samplerate) else: self.input_blocksize = 2048 if self._stepsize_s: self.input_stepsize = nextpow2(self._stepsize_s * samplerate) else: self.input_stepsize = self.input_blocksize / 2 # Aubio Pitch set-up self.aubio_pitch = pitch( "default", self.input_blocksize, self.input_stepsize, samplerate) self.aubio_pitch.set_unit("freq") self.block_read = 0 self.pitches = [] self.pitch_confidences = []
def __init__(self): """ Initialize entrainer for detecting pitch and tempo. """ # Where is Praat? Assumes it has been added to your PATH. self.praat = "praat" # Where is the Praat script we will use for processing? self.script = "rr_entrain_speech.praat" # Define pitch ranges that will be considered speech. # - Human child speech: generally 250-400Hz. # - Human adult male speech: generally 85-180Hz. # - Human adult female speech: generally 165-255Hz. self._floor_pitch = 100 self._ceiling_pitch = 600 # For audio recording. self._buffer_size = 2048 self._samplerate = 44100 #TODO Pass sample rate in as argument? self._n_channels = 1 # Set up to detect pitch. _tolerance = 0.8 _win_s = 4096 # fft size _hop_s = self._buffer_size # hop size # Set up the aubio pitch detector. self.pitch_detector = aubio.pitch("default", _win_s, _hop_s, self._samplerate) self.pitch_detector.set_unit("Hz") self.pitch_detector.set_tolerance(_tolerance)
def read_frequencies(filename): #we will use the original amount of samples in the file #samplerate = 44100 s = source(filename) tolerance = 0.8 #yin is a frequency estimation algorithm pitch_o = pitch("yin", samplerate=s.samplerate) pitch_o.set_unit("Hz") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read total_frames = 0 while True: samples, read = s() this_pitch = pitch_o(samples)[0] confidence = pitch_o.get_confidence() pitches += [this_pitch] confidences += [confidence] total_frames += read if read < s.hop_size: break #close that audio when we are done with it s.close() return pitches, confidences
def setup(self, channels=None, samplerate=None, blocksize=None, totalframes=None): super(AubioPitch, self).setup(channels, samplerate, blocksize, totalframes) # Frame parameters setup if self._blocksize_s: self.input_blocksize = nextpow2(self._blocksize_s) else: self.input_blocksize = 2048 if self._stepsize_s: self.input_stepsize = nextpow2(self._stepsize_s) else: self.input_stepsize = nextpow2(self.input_blocksize / 2) self.result_blocksize = self.input_blocksize self.result_stepsize = self.input_stepsize self._PITCH_WINDOW = int(4096.0 / self.input_blocksize) self._BUFF_FRAMES = (self.process_pipe.processors[0].output_blocksize \ - (self.input_blocksize // 2)) // self.input_stepsize + 2 # Aubio Pitch set-up self.aubio_pitch = pitch( "default", self.input_blocksize, self.input_stepsize, samplerate) self.aubio_pitch.set_unit("freq") #Hz? self.block_read = 0 self.pitches = [] # self.pitch_confidences = [] self.pitch_stds = [] self.monotone = 0
def initializeMic(data): #Taken and modified from #https://gist.github.com/notalentgeek/48aeab398b6b74e3a9134a61b6b79a36 #Initializing audio objects to be used in getting audio input and #determining pitch BUFFER_SIZE = 2048 CHANNELS = 1 FORMAT = pyaudio.paFloat32 METHOD = "default" SAMPLE_RATE = 44100 HOP_SIZE = BUFFER_SIZE // 2 PERIOD_SIZE_IN_FRAME = HOP_SIZE #2048 // 2 # Initiating PyAudio object. data.pA = pyaudio.PyAudio() # Open the microphone stream. data.mic = data.pA.open(format=FORMAT, channels=CHANNELS, rate=SAMPLE_RATE, input=True, frames_per_buffer=PERIOD_SIZE_IN_FRAME) # Initiating Aubio's pitch detection object. data.pDetection = aubio.pitch(METHOD, BUFFER_SIZE, HOP_SIZE, SAMPLE_RATE) # Set unit. data.pDetection.set_unit("Hz") # Frequency under -40 dB will considered # as a silence. data.pDetection.set_silence(-40)
def setup(self): self.filename = sys.argv[1] # self.filename = "middle_c.wav" self.mixer.add(WaveGenerator(WaveFile(self.filename))) # print "filename: ", self.filename self.downsample = 1 self.samplerate = 44100 // self.downsample if len(sys.argv) > 2: self.samplerate = int(sys.argv[2]) self.win_s = 4096 // self.downsample # fft size self.hop_s = 512 // self.downsample # hop size self.s = source(self.filename, self.samplerate, self.hop_s) print "s", self.s self.samplerate = self.s.samplerate self.tolerance = 0.8 self.pitch_o = pitch("yin", self.win_s, self.hop_s, self.samplerate) self.pitch_o.set_unit("midi") self.pitch_o.set_tolerance(self.tolerance) self.pitches = [] self.confidences = [] # total number of frames read self.total_frames = 0
def pitchreader(filename, samplerate): from aubio import source, pitch downsample = 1 win_s = 4096 // downsample hop_s = 512 // downsample s = source(filename, int(samplerate), hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] totalFrames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] # pitch = int(round(pitch)) confidence = pitch_o.get_confidence() currentFrame = totalFrames / float(samplerate) yield pitch #can add back current frame if necessary pitches += [pitch] confidences += [confidence] totalFrames += read if read < hop_s: break
def _get_pitch(self, tolerance=0.8): def process_pitch(pitch_array): if self._bar_count == 0: return round(np.median(pitch_array)) bar_pitch_len = int(np.floor(len(pitch_array) / self._bar_count)) pitch_bars = [] for j in range(0, bar_pitch_len * self._bar_count, bar_pitch_len): pitch_bars += [ round(np.median(pitch_array[j:j + bar_pitch_len])) ] return pitch_bars pitch_o = pitch("yinfft", self._win_size, self._hop_size, self._samplerate) pitch_o.set_unit("Hz") pitch_o.set_tolerance(tolerance) if self._stereo: samples = self._get_samples(self._wav_array, 'L+R').astype(np.float32) else: samples = self._get_samples(self._wav_array, 'Mono').astype(np.float32) pitches = [] steps = len(samples) - (len(samples) % self._hop_size) for i in range(0, steps, self._hop_size): pitchin = pitch_o(samples[i:i + self._hop_size])[0] pitches += [pitchin] return process_pitch(pitches)
def __init__(self, get_audio_over_ros): """ Initialize entrainer for detecting pitch and tempo. """ # Where is Praat? Assumes it has been added to your PATH. self.praat = "praat" # Where is the Praat script we will use for processing? self.script = "rr_entrain_speech.praat" # These are the settings that the ROS android microphone node uses for # getting audio. These are defaults; we will update them after we get # the actual values from the audio messages. if get_audio_over_ros: self._buffer_size = 2048 self.samplerate = 44100 self.n_channels = 1 self.sample_size = 2 # Otherwise, we record audio from a local microphone. else: self._buffer_size = 2048 self.samplerate = 44100 self.n_channels = 1 # Set up the aubio pitch detector. self.pitch_detector = aubio.pitch( "default", 4096, # FFT size self._buffer_size, # hop size self.samplerate) self.pitch_detector.set_unit("Hz") self.pitch_detector.set_tolerance(0.8)
def iter_samples_to_pitches(samples, sample_rate=11025, method='yin', buf_size=2048, hop_size=256, yield_confidence=False): """Yield pitches. Parameters ---------- samples : numpy.ndarray Samples in Numpy array. Yields ------ pitch : float Pitch in Hertz confidence : float Confidence of the pitch detection. """ pitcher = aubio.pitch(method, buf_size, hop_size, int(sample_rate)) for sample_chunk in iter_chunk(samples): pitch = pitcher(sample_chunk.astype(np.float32))[0] if yield_confidence: confidence = pitcher.get_confidence() yield pitch, confidence else: yield pitch
def getOnset(f): s = source(f, 0, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("Hz") pitch_o.set_tolerance(tolerance) o = onset("default", win_s, hop_s, samplerate) notes_o = notes("default", win_s, hop_s, samplerate) # list of onsets, in seconds onsets = [] vel = [] pitches = [] # total number of frames read total_frames = 0 while True: samples, read = s() p = pitch_o(samples)[0] new_note = notes_o(samples) t = total_frames / float(samplerate) if o(samples) and p > 0: onsets.append(o.get_last_s()) pitches.append(p) if new_note[0] != 0: vel.append(new_note[1]) total_frames += read if read < hop_s: break return onsets, vel, pitches
def get_pitch(filename, average_frequency): win_s = 4096 hop_s = 512 s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] pitches += [pitch] confidence = pitch_o.get_confidence() confidences += [confidence] total_frames += read if read < hop_s: break average_frequency = int(np.array(pitches).mean()) return average_frequency
def aubio_f0yin(y, sr, nwind=1024, hop=512, method='yin', tolerance=None): ''' Applies f0 detection to a numpy vector using aubio ''' from aubio import pitch, fvec po = pitch(method, nwind, hop, sr) vs = fvec(nwind) if tolerance is not None: if tolerance > 0.0 and tolerance < 1.0: po.set_tolerance(tolerance) else: sys.stderr.write('Tolerance not set: Out of bounds\n') nsamples = y.shape[0] freq = [] time = [] conf = [] for ii in xrange(0, nsamples - nwind, hop): thisy = y[ii:ii + nwind] vs[:] = thisy time.append(float(ii + nwind / 2) / sr) freq.append(po(vs)) conf.append(po.get_confidence()) return np.array(freq).squeeze(), np.array(time), np.array(conf)
def getPitch(filename): from aubio import source, pitch downsample = 1 samplerate = RATE//downsample win_s = 4096 // downsample # fft size hop_s = 512 // downsample # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches, confidences = [], [] # total number of frames read total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] pitch = round(pitch, 3) confidence = pitch_o.get_confidence() if confidence < 0.40: pitch = 0 pitches += [pitch] confidences += [confidence] total_frames += read if read < hop_s: break concat = 4 pitches=pitches[concat:] confidences=confidences[concat:] return pitches
def Extract_Pitch(row, col): pitch_List = [] sample_rate = 44100 x = np.zeros(44100) for i in range(44100): x[i] = np.sin(2. * np.pi * i * 225. / sample_rate) # create pitch object p = aubio.pitch("yin", samplerate=sample_rate) # pad end of input vector with zeros pad_length = p.hop_size - x.shape[0] % p.hop_size x_padded = np.pad(x, (0, pad_length), 'constant', constant_values=0) # to reshape it in blocks of hop_size x_padded = x_padded.reshape(-1, p.hop_size) # input array should be of type aubio.float_type (defaults to float32) x_padded = x_padded.astype(aubio.float_type) if(row==grid_size.nRow and grid_size==grid_size.nCol): for frame, i in zip(x_padded, range(len(x_padded))): time_str = "%.2f" % (i * p.hop_size / float(sample_rate)) pitch_candidate = p(frame)[0] + row + col + 100 # print(pitch_candidate) pitch_List.append(pitch_candidate) else: for frame, i in zip(x_padded, range(len(x_padded))): time_str = "%.2f" % (i * p.hop_size / float(sample_rate)) pitch_candidate = p(frame)[0] + row + col + 100 # print(pitch_candidate) pitch_List.append(pitch_candidate) return pitch_List
def get_pitches(filename): downsample = 1 # 0 is default sample rate samplerate = 0 // downsample win_s = 4096 // downsample # fft size hop_s = 512 // downsample # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("Hz") # Hz pitch_o.set_tolerance(tolerance) pitches = [] # total number of frames read total_frames = 0 while True: samples, read = s() raw_pitch = pitch_o(samples)[0] confidence = pitch_o.get_confidence() current = Pitch(time=float((total_frames / float(samplerate))), conf=confidence, raw_pitch=raw_pitch) hz, octave, note = get_note_octave_deviation(raw_pitch) if confidence > 0.8: pitches += [current] # f.write("hertz: " + str(raw_pitch)+" octave: "+str(octave)+" note: "+ str(note) + "\n") total_frames += read if read < hop_s: return pitches
def test_run_on_ones(self): " running on ones gives 0 " p = pitch('default', 2048, 512, 32000) f = fvec(512) f[:] = 1 for _ in range(10): assert_equal(p(f), 0.)
def iter_samples_to_pitches( samples, sample_rate=11025, method='yin', buf_size=2048, hop_size=256, yield_confidence=False): """Yield pitches. Parameters ---------- samples : numpy.ndarray Samples in Numpy array. Yields ------ pitch : float Pitch in Hertz confidence : float Confidence of the pitch detection. """ pitcher = aubio.pitch(method, buf_size, hop_size, int(sample_rate)) for sample_chunk in iter_chunk(samples): pitch = pitcher(sample_chunk.astype(np.float32))[0] if yield_confidence: confidence = pitcher.get_confidence() yield pitch, confidence else: yield pitch
def analyzePitch(grain): s = source(grain["file"], int(grain["sampleRate"]), int(float(grain["frameCount"]))) samplerate = s.samplerate tolerance = 0.8 pitch_out = pitch("yin", int(float(grain["frameCount"])), int(float(grain["frameCount"])), samplerate) samples, read = s() pitchFreq = pitch_out(samples)[0].item() del s return pitchFreq
def __init__(self, sample_rate=11025, buf_size=1024, hop_size=256, n_mfcc_filters=40, n_mfcc_coeffs=13, pitch_method='yin'): """Initialize feature extractor.""" self._sample_rate = int(sample_rate) self._pvoc = aubio.pvoc(buf_size, hop_size) self._mfcc = aubio.mfcc(buf_size, n_mfcc_filters, n_mfcc_coeffs, self._sample_rate) self._pitch = aubio.pitch( method=pitch_method, buf_size=buf_size, hop_size=hop_size, samplerate=self._sample_rate)
def __init__(self, args): self.parse_options(args, self.valid_opts) self.pitch = aubio.pitch(**self.options) if args.pitch_unit is not None: self.pitch.set_unit(args.pitch_unit) if args.threshold is not None: self.pitch.set_tolerance(args.threshold) if args.silence is not None: self.pitch.set_silence(args.silence) super(process_pitch, self).__init__(args)
def run_pitch_on_sinusoid(self, method, buf_size, hop_size, samplerate, freq): # create pitch object p = pitch(method, buf_size, hop_size, samplerate) # duration in seconds seconds = .3 # duration in samples duration = seconds * samplerate # increase to the next multiple of hop_size duration = duration - duration % hop_size + hop_size; # build sinusoid sinvec = self.build_sinusoid(duration, freq, samplerate) self.run_pitch(p, sinvec, freq)
def getpitches(filename, samplerate): #downsample = 1 #samplerate = 44100 / downsample win_s = 4096 / downsample # fft size hop_s = HOP_SIZE / downsample # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) o = onset("default", win_s, hop_s, samplerate) onsets = [] pitches = [] confidences = [] #number = 0 # total number of frames read total_frames = 0 while True: samples, read = s() pitch1 = pitch_o(samples)[0] #pitch = int(round(pitch)) confidence = pitch_o.get_confidence() if o(samples): # print "%f" % o.get_last_s() onsets.append(o.get_last()) #if confidence < 0.8: pitch = 0. #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence) pitches += [pitch1] confidences += [confidence] total_frames += read #number = number + 1 if read < hop_s: break if 0: sys.exit(0) ''' print onsets print pitches print confidences ''' return pitches, onsets
def getPitch(filename): from aubio import pitch for f in gb.glob(filename): frate, inputdata = sc.read(f) downsample = 1 samplerate = frate / downsample window = 1024 / downsample # fft size hopsize = 256/ downsample sound = source(filename, samplerate, hopsize) samplerate = sound.samplerate tolerance = 0.8 # Setting the FFT Algorithm pitchlist = pitch("yin", window, hopsize, samplerate) pitchlist.set_unit("midi") # Setting the tolerance level to 80 percent pitchlist.set_tolerance(tolerance) total_frames = 0 pitches = [] confidences=[] while True: samples, read = sound() pitch = pitchlist(samples)[0] confidence = pitchlist.get_confidence() confidences+=[confidence] pitches += [pitch] total_frames += read if read < hopsize: break # getting the file list of pitch from various sound samples pitches = array(pitches[1:]) confidences = array(confidences[1:]) cleaned_pitches = pitches loudness = abs(an.loudness(inputdata)) # EXtracting all those pitch levels that are above the confidence values cleaned_pitches = ma.masked_where(confidences < tolerance, cleaned_pitches,copy=False) cleaned_pitches = cleaned_pitches[~cleaned_pitches.mask] # condition to check whether there exists a fundamental frequency for the given sound signal if len(cleaned_pitches)==0: maxValue = 0 else: maxValue = max(cleaned_pitches) return maxValue,loudness
def __init__(self, options): self.algorithm = options.settings['palg'] self.frame_size = float(options.settings['framesize']) self.frame_multiplier = int(options.settings['pframemult']) self.hop_multiplier = float(options.settings['phopmult']) self.samplerate = float(options.settings['samplerate']) self.tolerance = float(options.settings['ptolerance']) self.sysexnumber = options.settings['psysexnum'] self.sysex_command_array = [] if options.settings['psysexnum'] != 'None': for command in options.settings['psysexnum'].split(' '): self.sysex_command_array.append(int(command, 0)) self.control_number = False if options.settings['pcontrolnum'] != 'None': self.control_number = int(options.settings['pcontrolnum'], 0) self.send_note_ons = False if options.settings['pnoteon'] == 'True': self.send_note_ons = True if options.settings['pnoteoff'] == 'True': self.send_note_offs = True self.count = int(options.settings['pcount']) self.low_cutoff = int(options.settings['plowcutoff']) self.high_cutoff = int(options.settings['phighcutoff']) self.fold_octaves = False if options.settings['pfoldoctaves'] == 'True': self.fold_octaves = True self.num_offset = int(options.settings['pnumoffset']) self.midi_processor = None self.pitch_object = pitch(self.algorithm, int(self.frame_size * self.frame_multiplier), int(self.frame_size * self.frame_multiplier * self.hop_multiplier), int(self.samplerate)) if self.tolerance != 'None': self.pitch_object.set_tolerance(self.tolerance) self.pitch_object.set_unit('midi') self.frame_arrays = np.zeros( (int(self.frame_multiplier), int(self.frame_size)), dtype=np.float32) self.frame_count = 0 self.most_pitches = [-1] self.pitch_count = 0 self.last_pitch = 0
def pitch_extraction (self, algorithm = "yin", tolerance = 0.95, unit = "midi"): self.tolerance = tolerance self.unit = unit win_s = 1024*4 hop_s = 512 pitch_o = aubio.pitch(algorithm, win_s, hop_s, self.samplerate) pitch_o.set_unit(self.unit) pitch_o.set_tolerance(self.tolerance) self._pitches = [] self._confidences = [] # total number of frames read total_frames = 0 i = 0 print "Starting extraction ..." while True: samples = self._waveform [i*hop_s:(i+1)*hop_s] samples = np.float32(samples) pitch = pitch_o(samples)[0] confidence = pitch_o.get_confidence() self._pitches += [pitch] self._confidences += [confidence] i += 1 if (i+1)*hop_s > len(self._waveform): break self._pitches = np.array(self._pitches).flatten() self._filtered_pitches = None self._discrete_pitches = None plt.plot (self._pitches) #for i in range(len(self._beats)): # plt.axvline (self._beats[i], color = 'crimson') plt.title ("Pitches") plt.show() #plt.plot (self._confidences) #plt.show() self._cleaned_pitches = self._pitches self._cleaned_pitches = np.ma.masked_where(self._confidences < self.tolerance, self._cleaned_pitches) plt.plot (self._pitches) plt.title ("Cleaned Pitches -- tolerance: "+str(self.tolerance)) plt.show()
def get_stats_for_pitch_method(method, freqs, samplerate = samplerate): """ for a given pitch method and a list of frequency, generate a sinewave and get mean deviation """ means = np.zeros(len(freqs)) medians = np.zeros(len(freqs)) for freq, fn in zip(freqs, range(len(freqs))): s = sinewave(freq, .50).reshape(-1, hop_size) #s = (sinewave(freq, .50) + .0*sinewave(freq/2., .50)).reshape(-1, hop_size) p = pitch(method, buf_size, hop_size, samplerate = samplerate) candidates = np.zeros(len(s)) #samples = np.zeros(buf_size) for frame, i in zip(s, range(len(s))): candidates[i] = p(frame)[0] # skip first few candidates candidates = candidates[4:] means[fn] = np.mean(candidates[candidates != 0] - freq) medians[fn] = np.median(candidates[candidates != 0] - freq) print (freq, means[fn], medians[fn]) return means, medians
def get_pitch(signal, sr, block_size, hop, tolerance = 0.7, unit = 'seconds'): pitch_o = aubio.pitch("yin", block_size, hop, sr) pitch_o.set_unit('Hz') pitch_o.set_tolerance(tolerance) signal = signal.astype('float32') signal_win = np.array_split(signal, np.arange(hop, len(signal), hop)) pitches = _find_pitches(signal_win, pitch_o, tolerance) if unit == 'seconds': pitches = [(frame_idx * hop / sr, value) for frame_idx, value in pitches] elif unit == 'samples': pitches = [(frame_idx * hop, value) for frame_idx, value in pitches] else: raise NotImplemented('Unit %s is not implemented', unit) if not pitches: raise ValueError('No pitches!') return pitches
def analyzePitches(self, music_file): s = source(music_file, self.sample_rate, self.hop_size) pitch_o = pitch("yin", self.win_size, self.hop_size, self.sample_rate) pitch_o.set_unit("freq") pitch_o.set_tolerance(self.tolerance) total_frames = 0 # total number of frames read while True: samples, read = s() curr_pitch = pitch_o(samples)[0] confidence = pitch_o.get_confidence() silence = self.hearingThreshold(curr_pitch) self.pitch_data[0].append(curr_pitch) self.pitch_data[1].append(confidence) self.pitch_data[2].append(silence) total_frames += read if read < self.hop_size: break return self.pitch_data
def _parse_(self, filename, samplerate): s = source(filename, samplerate, self.hop_s) pitch_o = pitch("default", self.win_s, self.hop_s, samplerate) pitch_o.set_unit("midi") tempo_o = tempo("default", self.win_s, self.hop_s, samplerate) delay = 4. * self.hop_s notes = [] # total number of frames read total_frames = 0 samplerate = float(samplerate) previous_samples = [] while read < hop_s: samples, read = s() pitch = pitch_o(samples)[0] is_beat = tempo_o(samples) # BUG: doesn't work if sample starts on beat FIRST if is_beat: this_beat = int(total_frames - delay + is_beat[0] * hop_s) average = sum(previous_samples)/len(previous_samples) note, octave = SimpleConverter.MusicalNote.hertz_to_note(average) notes += [(note, octave, total_frames/samplerate)] previous_samples = [] # don't want to add otherwise because higher chance at transition zone else: previous_samples += [pitch] total_frames += read notes = [SimpleConverter.MusicalNote(note[0] + str(note[1]), note[2]) \ for note in notes] return notes
def __init__(self, sample_rate=None, buffersize=None): self.sample_rate = sample_rate or self.sample_rate self.buffersize = buffersize or self.buffersize self.window_size = self.buffersize * 2 self.stream = None self.onset = aubio.onset( 'specflux', self.window_size, self.buffersize, self.sample_rate) self.onset.set_threshold(0.3) self.onset.set_silence(-20.) self.tempo = aubio.tempo( 'default', self.window_size, self.buffersize, self.sample_rate) self.energy = aubio.specdesc('specflux', self.buffersize * 2) self.pv = aubio.pvoc(self.buffersize * 2, self.buffersize) self.pitch = aubio.pitch( "yinfft", self.window_size, self.buffersize, self.sample_rate) self.pitch.set_unit("midi") self.pitch.set_tolerance(0.8) self.py_audio = pyaudio.PyAudio()
def analyzeHarmonicRatios(grain): maxPermissableFreq = 4409 #Maximum to get 4 harmonics numHarmonics = 4 w = wavefile.load(grain["file"]) data = w[1][0] s = source(grain["file"], w[0], len(data)) samplerate = s.samplerate # Compute the fundamental using the "yin" algorithm pitch_o = pitch("yin", len(data), len(data), samplerate) samples, read = s() fundamental = pitch_o(samples)[0] if (fundamental > maxPermissableFreq): return None # Get the periodogram to get energies at harmonics data = data * numpy.hanning(len(data)) f, Pxx_den = signal.periodogram(data, w[0]) Pxx_den = 10 * numpy.log10(Pxx_den) # Set the current harmonic to be twice the fundamental fundEnergy = Pxx_den[freqToBin(f, fundamental)] curHarm = fundamental * 2 curHarmCount = 0 ratios = [] while(curHarmCount < numHarmonics): ratio = fundEnergy / Pxx_den[freqToBin(f, curHarm)] #Do not allow infinites, probably caused by 0 energy if math.isnan(ratio) or math.isinf(ratio): print("Ratio " + str(curHarmCount) + " is " + str(ratio)) return None ratios.append(fundEnergy / Pxx_den[freqToBin(f, curHarm)]) curHarm += fundamental curHarmCount += 1 return ratios
def get_pitches(audio, sample_rate=11025, method='yin', buf_size=2048, hop_size=256): """Return estimated pitches for audio. The 'yin' method from the `aubio` module is used for the pitch detection. Multiple values are returned, one for each chunk. Parameters ---------- audio : numpy.array or pydub.AudioSegment or string Audio data. Returns ------- pitches : numpy.array Array with pitch and confidence information. """ if type(audio) == np.ndarray: samples = audio elif type(audio) == AudioSegment or type(audio) == str: samples = get_samples_mono_11025(audio) sample_rate = 11025 else: raise ValueError('audio input has the wrong type') pitcher = aubio.pitch(method, buf_size, hop_size, int(sample_rate)) # Iterate over chunks in the sample pitches = [] for sample_chunk in iter_chunk(samples, chunk_size=hop_size): if len(sample_chunk) < hop_size: # Zeropadding if too short sample_chunk = np.hstack( (sample_chunk, np.zeros(hop_size - len(sample_chunk)))) pitch = pitcher(sample_chunk.astype(np.float32))[0] confidence = pitcher.get_confidence() pitches.append((pitch, confidence)) return np.array(pitches)
def aubiopitch(filename, pitchType, ptolerance, samplerate): from aubio import pitch win_s = 4096 # fft size hop_s = 512 # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate # pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o = pitch(pitchType, win_s, hop_s, samplerate) pitch_o.set_unit("freq") pitch_o.set_tolerance(ptolerance) pitches = [] confidences = [] timings = [] # total number of frames read total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] #pitch = int(round(pitch)) confidence = pitch_o.get_confidence() #if confidence < 0.8: pitch = 0. # print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence) # timings += [total_frames / float(samplerate)] pitches += [pitch] confidences += [confidence] total_frames += read if read < hop_s: break times = [t * hop_s for t in range(len(pitches))] for item in times: print "%f" % (item/float(samplerate)) with open('audata_notes','w') as datas: for item in times: datas.write('\n{0}'.format(item/float(samplerate))) return times
p = pyaudio.PyAudio() instream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=hop_s) outstream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, output=True, stream_callback = callback) # set up YIN pitch tracking algo tolerance = 0.8 pitch_o = aubio.pitch("yin", win_s, hop_s, RATE) pitch_o.set_unit("freq") pitch_o.set_tolerance(tolerance) print "Recording" try: outstream.start_stream() print "Finished?: " + str(outstream.is_active()) while True: data_str = instream.read(hop_s) data = numpy.fromstring(data_str,'Float32') pitch = pitch_o(data)[0] print "Pitch: %.5f Hz"%pitch for i in xrange(len(data_str)): frameBuffer.append(data_str[i])
filename = sys.argv[1] downsample = 1 samplerate = 44100 / downsample if len( sys.argv ) > 2: samplerate = int(sys.argv[2]) win_s = 4096 / downsample # fft size hop_s = 512 / downsample # hop size s = source(filename, samplerate, hop_s) samplerate = s.samplerate tolerance = 0.7 pitch_o = pitch("yin", win_s, hop_s, samplerate) pitch_o.set_unit("midi") pitch_o.set_tolerance(tolerance) pitches = [] confidences = [] # total number of frames read total_frames = 0 while True: samples, read = s() pitch = pitch_o(samples)[0] #pitch = int(round(pitch)) confidence = pitch_o.get_confidence() #if confidence < 0.8: pitch = 0. #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence)