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 _initialize_onset(self):
self.onset_high = aubio.onset(
"specflux", self._config['fft_size'],
self._config['mic_rate'] // self._config['sample_rate'],
self._config['mic_rate'])
self.onset_soft = aubio.onset(
"phase", self._config['fft_size'],
self._config['mic_rate'] // self._config['sample_rate'],
self._config['mic_rate'])
self.onset_mids = aubio.onset(
"specdiff", self._config['fft_size'],
self._config['mic_rate'] // self._config['sample_rate'],
self._config['mic_rate'])
def getOnsetTimes(self): #returns list of onset times
win_s = 1024 // 2 # fft size
hop_s = win_s // 2 # hop size: number of samples between each successive FFT window
filename = self.path
samplerate = 44100
s = source(filename, samplerate,
hop_s) #creates source object (iterable)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# list of onsets, in samples
onsets = []
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
onsets.append(float("%f" % o.get_last_s()))
total_frames += read
if read < hop_s: break #reached end of the file
return onsets
def create_detector(self, samplerate):
self.onset = aubio.onset(self.method, self.buf_size, self.hop_size,
samplerate)
self.onset.set_minioi_ms(self.minioi_ms)
self.onset.set_threshold(self.threshold)
self.onset.set_compression(self.compression)
self.onset.set_silence(self.silence)
def interonset_time(filename):
win_s = 512 # fft size
hop_s = win_s // 2 # hop size
samplerate = 44100
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# list of onsets, in samples
onsets = []
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
onsets.append(o.get_last())
total_frames += read
if read < hop_s: break
time = [float(x) / samplerate for x in onsets]
times = [x - time[i - 1] for i, x in enumerate(time)][1:]
print(times)
return time
def getOnsets(filename, samplerate=44100):
win_s = 512 # fft size
hop_s = win_s // 2 # hop size
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# list of onsets, in samples
onsets = []
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
# print("%f" % o.get_last_s())
onsets.append(o.get_last())
total_frames += read
if read < hop_s: break
return onsets
def aubiodata(filename, onsetType, threshold, silence):
win_s = 512 # fft size
hop_s = win_s / 2 # hop size
samplerate = 0 # Just an initial setting
# threshold = 0.8
# silence = -10
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset(onsetType, win_s, hop_s, samplerate)
o.set_threshold(threshold)
o.set_silence(silence)
# list of onsets, in seconds
onsets = []
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
# print "%f" % o.get_last_s()
onsets.append(o.get_last_s())
total_frames += read
if read < hop_s: break
# 'onsets' holds, at each entry, the time where an onset is detected (in seconds).
return onsets
def aubiodata(filename, onsetType, threshold, silence): win_s = 512 # fft size hop_s = win_s / 2 # hop size samplerate = 0 # Just an initial setting # threshold = 0.8 # silence = -10 s = source(filename, samplerate, hop_s) samplerate = s.samplerate o = onset(onsetType, win_s, hop_s, samplerate) o.set_threshold(threshold) o.set_silence(silence) # list of onsets, in seconds onsets = [] # total number of frames read total_frames = 0 while True: samples, read = s() if o(samples): # print "%f" % o.get_last_s() onsets.append(o.get_last_s()) total_frames += read if read < hop_s: break # 'onsets' holds, at each entry, the time where an onset is detected (in seconds). return onsets
def __init__(self):
self.redis = redis.StrictRedis(host=redishost, port=6379, password="", decode_responses=True)
self.p = pyaudio.PyAudio()
stream = self.p.open(format=self.FORMAT,
channels=self.CHANNELS,
rate=self.RATE,
input=True,
output=True,
input_device_index = self.get_input_device_index(),
output_device_index = self.get_output_device_index(),
frames_per_buffer = self.CHUNK,
stream_callback=self.callback)
self.a_onset = aubio.onset("default", self.CHUNK, self.hop_s, self.RATE)
self.a_tempo = aubio.tempo("specflux", self.CHUNK, self.hop_s, self.RATE)
self.a_pitch = aubio.pitch("default", self.CHUNK, self.hop_s, self.RATE)
self.a_notes = aubio.notes("default", self.CHUNK, self.hop_s, self.RATE)
n_filters = 40 # required
n_coeffs = 13 # I wonder if i made this 1....
self.a_pvoc = aubio.pvoc(self.CHUNK, self.hop_s)
self.a_mfcc = aubio.mfcc(self.CHUNK, n_filters, n_coeffs, self.RATE)
self.tolerance = 0.8
self.a_pitch.set_tolerance(self.tolerance)
self.highest_pitch = 0
self.lowest_pitch = 99999999
self.average_pitch = 0
self.average_pitch_samples = 0
self.last_average = 0
self.colors = None
self.pitch_range = None
self.range_counter = 0
self.all_notes = set()
stream.start_stream()
def onSet(self):
win_s = 512 # fft size
hop_s = win_s // 2 # hop size
filename = self.song
samplerate = 0
if len(sys.argv) > 2: samplerate = int(sys.argv[2])
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# list of onsets, in samples
onsets = []
# storage for plotted data
desc = []
tdesc = []
allsamples_max = zeros(0, )
downsample = 2 # to plot n samples / hop_s
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
#print("%f" % (o.get_last_s()))
self.allOnsets.append(o.get_last_s())
onsets.append(o.get_last())
if read < hop_s: break
for i in range(len(self.allOnsets)):
self.allOnsets[i] = int(self.allOnsets[i] * 1000)
def onset_detector(rate=44100
,window_size=4096
,hop_size=1024
,method="default"
,tolerance=0.7
):
return onset(method, window_size, hop_size, rate);
def setup(self, channels=None, samplerate=None, blocksize=None, totalframes=None):
super(AubioOnsetRate, self).setup(channels, samplerate, blocksize, totalframes)
self.win_s = 512
self.hop_s = self.win_s / 2
self.t = onset("default", self.win_s, self.hop_s, 1)
self.block_read = 0
self.onsets = []
def segment_from_onsets(filename, dur):
win_s = 1024
hop_s = 256
s = source(filename, 0, hop_s)
sr = s.samplerate
o = onset("hfc", win_s, hop_s, sr)
o.set_threshold(0.2)
o.set_silence(-30.)
o.set_minioi_s(dur)
raw_onsets = []
chunks = []
while 1:
samples, read = s()
if o(samples):
raw_onsets.append(o.get_last())
chunks.append(samples.copy())
if read < hop_s:
break
y = np.concatenate(chunks)
raw_segments = np.split(y, raw_onsets)[1:]
segment_len = int(sr * dur)
segments, onsets = [], []
for seg, ost in zip(raw_segments, raw_onsets):
if len(seg) < segment_len:
pass
else:
onsets.append(ost)
segments.append(seg[:segment_len])
segments = np.stack(segments)
segments /= np.abs(segments).max(1, keepdims=True)
return segments, np.array(onsets) / sr, y, sr
def generate_data_for_file(path, n_samples):
sample_rate = 0
aubio_source = source(path, sample_rate, HOP_SIZE)
sample_rate = aubio_source.samplerate
aubio_onset = onset('default', FFT_WIN_SIZE, HOP_SIZE, sample_rate)
onsets = []
while True:
chunk, read = aubio_source()
if aubio_onset(chunk):
onsets.append(aubio_onset.get_last())
if read < HOP_SIZE: break
samples = wavfile.read(path)[1]
slices = np.split(samples, onsets)
snippets = []
for slice in slices:
if len(slice) == 0:
continue
mono = 0.5 * (slice[:, 0] + slice[:, 1])
mono = mono / np.sqrt(np.dot(mono, mono))
fixed_len = trim_or_pad(mono, n_samples)
snippets.append(fixed_len)
return np.vstack(snippets)
def analyzeAudio(file, pickedCloser, pickedShelter, pickedFriends):
win_s = 512 # fft size
hop_s = win_s // 2 # hop size
filename = file
samplerate = 44100
if len( sys.argv ) > 2: samplerate = int(sys.argv[2])
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# list of onsets, in samples
onsetFrames = []
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
onsetFrames.append(total_frames)
total_frames += read
if read < hop_s: break
if(pickedCloser):
closer.onsetFrames = onsetFrames
elif(pickedShelter):
shelter.onsetFrames = onsetFrames
elif(pickedFriends):
friends.onsetFrames = onsetFrames
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 compute_onsets_aubio(y=None, sr=None, **kwargs):
"""Compute onset detection function with aubio
"""
if 'method' in kwargs:
method = kwargs['method']
else:
# use aubio default
method = 'default'
src = data_load_aubio(filename=kwargs['filename'])
# list of onsets: sparse, event-based?
onsets = []
# onset detector aubio
onset_detector = aubio.onset(method=method, samplerate=src.samplerate)
# onset_detector.set_threshold(1.0)
while True:
samples, read = src()
# print(samples.shape)
if read < src.hop_size:
break
onset_detector(samples)
onsets.append(onset_detector.get_thresholded_descriptor())
return {'onsets': np.array(onsets), 'src': src}
def setup(self, channels=None, samplerate=None, blocksize=None, totalframes=None):
super(AubioTemporal, self).setup(channels, samplerate, blocksize, totalframes)
self.o = onset("default", self.input_blocksize, self.input_stepsize, samplerate)
self.t = tempo("default", self.input_blocksize, self.input_stepsize, samplerate)
self.block_read = 0
self.onsets = []
self.beats = []
self.beat_confidences = []
def test_all_methods(self):
for method in [
'default', 'energy', 'hfc', 'complexdomain', 'complex',
'phase', 'wphase', 'mkl', 'kl', 'specflux', 'specdiff',
'old_default'
]:
o = onset(method=method, buf_size=512, hop_size=256)
o(fvec(256))
def __init__(self, config):
self._chunk = config['perf_chunk']
self._samp_rate = config['perf_sr']
self._onset_detector = aubio.onset('default', self._chunk, self._chunk,
self._samp_rate)
self._result = False # use boolean to represent onset
def start(self):
self.stream = self.p.open(format=self.FORMAT,
channels=self.CHANNELS,
rate=self.RATE,
input=True,
frames_per_buffer=self.CHUNK,
stream_callback=self.get_callback())
self.stream.start_stream()
self.o = onset("default", self.win_s, self.hop_s, self.RATE)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fps = FPSCounter('Beat Processor')
self.win_s = 1024
self.hop_s = self.frames_per_buffer = int(self.config['MIC_RATE'] /
self.config['FPS'])
self.onset_detect = aubio.onset('energy', self.win_s, self.hop_s,
self.config['MIC_RATE'])
self.beat_detect = aubio.tempo('hfc', self.win_s, self.hop_s,
self.config['MIC_RATE'])
def _initialize_onset(self):
self.onset_high = aubio.onset(
"specflux",
self._config["fft_size"],
self._config["mic_rate"] // self._config["sample_rate"],
self._config["mic_rate"],
)
self.onset_soft = aubio.onset(
"phase",
self._config["fft_size"],
self._config["mic_rate"] // self._config["sample_rate"],
self._config["mic_rate"],
)
self.onset_mids = aubio.onset(
"specdiff",
self._config["fft_size"],
self._config["mic_rate"] // self._config["sample_rate"],
self._config["mic_rate"],
)
def __init__(self, config):
super().__init__(config)
self.config = self.config.get('Beat', {})
self.win_s = 1024
self.hop_s = self.frames_per_buffer = int(
self.capconfig['SampleRate'] / self.capconfig['FPS'])
self.onset_detect = aubio.onset('energy', self.win_s, self.hop_s,
self.capconfig['SampleRate'])
self.beat_detect = aubio.tempo('hfc', self.win_s, self.hop_s,
self.capconfig['SampleRate'])
def setup(self,
channels=None,
samplerate=None,
blocksize=None,
totalframes=None):
super(AubioTemporal, self).setup(channels, samplerate, blocksize,
totalframes)
self.o = onset("default", self.input_blocksize, self.input_stepsize,
samplerate)
self.t = tempo("default", self.input_blocksize, self.input_stepsize,
samplerate)
def get_tight_score(self):
o = onset("energy", self.win_s, self.hop_s, self.source.samplerate)
onsets = []
total_frames = 0
while True:
samples, read = self.source()
if o(samples):
onsets.append(o.get_last())
total_frames += read
if read < self.hop_s: break
tsmean = numpy.mean(onsets)
ts = tsmean / 100000
print ts
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 initAudio():
src = aubio.source(VID_FILE_NAME)
o = aubio.onset(method="specflux",
buf_size=src.hop_size * 2,
hop_size=src.hop_size,
samplerate=src.samplerate)
onsets = []
while True:
samples, read = src()
if o(samples):
onsets.append(o.get_last())
if read < src.hop_size:
break
return onsets, src.samplerate
def __init__(self, fs,
nfft: int = 512,
hop: int = 256,
onset_detector_type: str = 'hfc',
onset_threshold: float = 0.01,
onset_silence_threshold: float = -90,
min_duration_s: float = 0.02):
self.hop = hop
self.onset_detector = onset(onset_detector_type, nfft, hop, fs)
if onset_threshold:
self.onset_detector.set_threshold(onset_threshold)
if onset_silence_threshold:
self.onset_detector.set_silence(onset_silence_threshold)
if min_duration_s:
self.onset_detector.set_minioi_s(min_duration_s)
def points_from_onsets(audio_file_name):
source = aubio_source(audio_file_name)
onset = aubio.onset(args.labels_from_onsets_method,
samplerate=source.samplerate)
onset.set_threshold(args.labels_from_onsets_threshold)
onset.set_minioi_ms(args.labels_from_onsets_min_length * 1000)
onset.set_silence(args.labels_from_onsets_min_volume)
points = []
while True:
samples, read = source()
if onset(samples):
points.append(onset.get_last() / source.samplerate)
if read < source.hop_size:
break
return set(points)
def __init__(self, args):
self.parse_options(args, self.valid_opts)
self.onset = aubio.onset(**self.options)
if args.threshold is not None:
self.onset.set_threshold(args.threshold)
if args.minioi:
if args.minioi.endswith('ms'):
self.onset.set_minioi_ms(float(args.minioi[:-2]))
elif args.minioi.endswith('s'):
self.onset.set_minioi_s(float(args.minioi[:-1]))
else:
self.onset.set_minioi(int(args.minioi))
if args.silence:
self.onset.set_silence(args.silence)
super(process_onset, self).__init__(args)
def __init__(self, args):
self.parse_options(args, self.valid_opts)
self.onset = aubio.onset(**self.options)
if args.threshold is not None:
self.onset.set_threshold(args.threshold)
if args.minioi:
if args.minioi.endswith('ms'):
self.onset.set_minioi_ms(float(args.minioi[:-2]))
elif args.minioi.endswith('s'):
self.onset.set_minioi_s(float(args.minioi[:-1]))
else:
self.onset.set_minioi(int(args.minioi))
if args.silence:
self.onset.set_silence(args.silence)
super(process_onset, self).__init__(args)
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 _cut_analyze(options):
hopsize = options.hop_size
bufsize = options.buf_size
samplerate = options.samplerate
source_uri = options.source_uri
# analyze pass
from aubio import onset, tempo, source
s = source(source_uri, samplerate, hopsize)
if samplerate == 0:
samplerate = s.samplerate
options.samplerate = samplerate
if options.beat:
o = tempo(options.onset_method,
bufsize,
hopsize,
samplerate=samplerate)
else:
o = onset(options.onset_method,
bufsize,
hopsize,
samplerate=samplerate)
if options.minioi:
if options.minioi.endswith('ms'):
o.set_minioi_ms(int(options.minioi[:-2]))
elif options.minioi.endswith('s'):
o.set_minioi_s(int(options.minioi[:-1]))
else:
o.set_minioi(int(options.minioi))
o.set_threshold(options.threshold)
timestamps = []
total_frames = 0
while True:
samples, read = s()
if o(samples):
timestamps.append(o.get_last())
if options.verbose:
print("%.4f" % o.get_last_s())
total_frames += read
if read < hopsize:
break
del s
return timestamps, total_frames
def onsets_aubio(samples: np.ndarray,
sr: int,
method='mkl',
winsize=1024,
hopsize=512,
threshold=0.03,
mingap=0.050,
silencedb=-70) -> List[float]:
"""
Detect onsets in samples
Args:
samples: the samples, as numpy array (1D), between -1 and 1
sr: the sample rate of samples
winsize: the size of the fft window size, in samples
hopsize: the hop size, in samples
threshold: depends on the method. The lower this value, the more probable
is it that an onset is detected
method: the method to detect onsets. One of:
- `energy`: local energy,
- `hfc`: high frequency content,
- `complex`: complex domain,
- `phase`: phase-based method,
- `wphase`: weighted phase deviation,
- `specdiff`: spectral difference,
- `kl`: Kullback-Liebler,
- `mkl`: modified Kullback-Liebler,
- `specflux`: spectral flux.
mingap: the min. amount of time (in seconds) between two onsets
silencedb: onsets will only be detected if the amplitude exceeds this value (in dB)
Returns:
a list of floats, representing the times of the offsets
"""
assert isinstance(samples, np.ndarray) and len(samples.shape) == 1
import aubio
ao = aubio.onset(method, buf_size=winsize, hop_size=hopsize)
ao.set_threshold(threshold)
ao.set_silence(silencedb)
ao.set_minioi_s(mingap)
samples = samples.astype('float32')
onsets = [
ao.get_last() / sr for chunk in chunks(samples, hopsize, padwith=0.0)
if ao(chunk)
]
return onsets
def get_onsets(self, song_file):
win_s = 512
hop_s = win_s // 2
filename = song_file
samplerate = 0
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
onsets = []
total_frames = 0
while True:
samples, read = s()
if o(samples):
onsets.append(o.get_last_s())
total_frames += read
if read < hop_s: break
return onsets
def _cut_analyze(options):
hopsize = options.hop_size
bufsize = options.buf_size
samplerate = options.samplerate
source_uri = options.source_uri
# analyze pass
from aubio import onset, tempo, source
s = source(source_uri, samplerate, hopsize)
if samplerate == 0:
samplerate = s.samplerate
options.samplerate = samplerate
if options.beat:
o = tempo(options.onset_method, bufsize, hopsize,
samplerate=samplerate)
else:
o = onset(options.onset_method, bufsize, hopsize,
samplerate=samplerate)
if options.minioi:
if options.minioi.endswith('ms'):
o.set_minioi_ms(int(options.minioi[:-2]))
elif options.minioi.endswith('s'):
o.set_minioi_s(int(options.minioi[:-1]))
else:
o.set_minioi(int(options.minioi))
o.set_threshold(options.threshold)
timestamps = []
total_frames = 0
while True:
samples, read = s()
if o(samples):
timestamps.append(o.get_last())
if options.verbose:
print("%.4f" % o.get_last_s())
total_frames += read
if read < hopsize:
break
del s
return timestamps, total_frames
def test_get_methods(self):
o = onset(method='default', buf_size=512, hop_size=256)
assert o.get_silence() == -70
o.set_silence(-20)
assert_almost_equal(o.get_silence(), -20)
assert o.get_compression() == 1
o.set_compression(.99)
assert_almost_equal(o.get_compression(), .99)
assert o.get_awhitening() == 0
o.set_awhitening(1)
assert o.get_awhitening() == 1
o.get_last()
o.get_last_ms()
o.get_last_s()
o.get_descriptor()
o.get_thresholded_descriptor()
def detect_onset(sig, fs):
""" Detect the onset of sound event
Returns: (onset, offset) tuple of indecies """
win_s = 512 # fft size
hop_s = win_s / 2 # hop size
o = onset("hfc", win_s, hop_s, fs)
# list of onsets, in samples
onsets = []
# storage for plotted data
desc = []
tdesc = []
allsamples_max = np.zeros(0,)
downsample = 2 # to plot n samples / hop_s
# total number of frames read
total_frames = 0
i = 0
while i + hop_s < len(sig[:,0]):
samples = sig[i:i+hop_s][:,0] # LEFT CHANNEL!
if o(samples):
# print "%f" % (o.get_last_s())
# onsets.append((o.get_last(), samples))
onsets.append(o.get_last())
# keep some data to plot it later
new_maxes = (abs(samples.reshape(hop_s/downsample, downsample))).max(axis=0)
allsamples_max = np.hstack([allsamples_max, new_maxes])
desc.append(o.get_descriptor())
tdesc.append(o.get_thresholded_descriptor())
total_frames += hop_s
i += hop_s
allsamples_max = (allsamples_max > 0) * allsamples_max
allsamples_max_times = [float(t) * hop_s / downsample / fs for t in range(len(allsamples_max)) ]
# this is the onset corr. to the peak in energy in signal
max_energy_onset = int(float(np.argmax(allsamples_max)) * hop_s / downsample)
return min(onsets, key=lambda x:abs(x - max_energy_onset))
def calculate_onsets(self, sample, sample_rate):
"""
Calculate onsets of the given signal
Parameters
----------
sample : 1-d array
Single-channel audio sample.
sample_rate : int
Sample rate in Hz.
Returns
-------
out : list
Calculated onsets
"""
# Pad with zeros
filler = self._hop_size - (len(sample) % self._hop_size) # number of zeros
sample = np.pad(sample, (0, filler), 'constant') # padding
# Configure onsets' detector
onset_detector = onset(self._type, self._window_size, self._hop_size, sample_rate)
onset_detector.set_threshold(self._threshold)
onset_detector.set_minioi_s(0.5)
# onset_detector.set_delay_s(1.0)
# Calculate onsets
onsets = []
windowed_sample = np.array_split(sample, np.arange(self._hop_size, len(sample), self._hop_size))
for frame in windowed_sample:
if onset_detector(frame.astype('float32')):
onsets.append(onset_detector.get_last())
early_onsets = [value for value in onsets if value > sample_rate * 0.5 and value < 2 * sample_rate]
if not early_onsets:
onsets = [value for value in onsets if value > self._window_size]
return onsets
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 get_onset_times(filepath, sr=22050, win_s = 512, method='default'): """ INPUT: filepath - path to audio file sr - sample rate win_s - fft window size method - see http://aubio.org/manpages/latest/aubionotes.1.html for methods offered OUTPUT: onset_times - array_type - times for when notes are believed to begin """ hop_s = win_s / 2 # hop size filename = filepath samplerate = sr #set up the aubio system calls s = source(filename, samplerate, hop_s) samplerate = s.samplerate o = onset(method, win_s, hop_s, samplerate) # list of onsets, in samples onsets = [] # total number of frames read total_frames = 0 while True: samples, read = s() if o(samples): #print "%f" % o.get_last_s() onsets.append(o.get_last()) total_frames += read if read < hop_s: break #convert the onset samples to the corresponding time of occurrence and return return librosa.core.samples_to_time(onsets, sr=samplerate)
def track_energy():
"""Track attacks of instrument, maintain global float energy"""
global energy
energy = 0.25
win_size = 512 # fft size
hop_size = 256
s = Stream(block_length = hop_size)
o = onset("default", win_size, hop_size, s.sample_rate)
come_up_steps = ceil(come_up_secs * s.sample_rate/hop_size)
built_energy = 0
built_steps = 0
onsets = 0
s.start()
while True:
vec = s.read(hop_size)
# mix down to mono
mono_vec = vec.sum(-1) / float(s.input_channels)
if o(mono_vec):
print "beat" + str(onsets)
onsets += 1
built_energy = (nu * (energy + built_steps * built_energy) + (1-nu) - energy)/(built_steps+come_up_steps)
built_steps += come_up_steps
if built_steps == 0 :
energy = (1-eta) * energy
else:
energy += built_energy
built_steps -= 1
# print "energy = %f, total = %f" % (energy,energy + built_energy * built_steps)
s.stop()
def calculate_onsets(self, sample, sample_rate):
"""
Calculate onsets of the given signal
Parameters
----------
sample : 1-d array
Single-channel audio sample.
sample_rate : int
Sample rate in Hz.
Returns
-------
out : list
Calculated onsets
"""
# Pad with zeros
filler = self._hop_size - (len(sample) % self._hop_size) # number of zeros
sample = np.pad(sample, (0, filler), 'constant') # padding
# Configure onsets' detector
onset_detector = onset(self._type, self._window_size, self._hop_size, sample_rate)
onset_detector.set_threshold(self._threshold)
# Calculate onsets
onsets = []
windowed_sample = np.array_split(sample, np.arange(self._hop_size, len(sample), self._hop_size))
for frame in windowed_sample:
if onset_detector(frame.astype('float32')):
onsets.append(onset_detector.get_last())
# Discard artifact - somehow always onset is detected at zero
if (len(onsets) > 0 and onsets[0] == 0):
onsets.pop(0)
return onsets
def get_onset(name):
win_s = 512 # fft size
hop_s = win_s / 2 # hop size
filename = name
samplerate = 0
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
#print "%f" % o.get_last_s()
onsets.append(round(o.get_last_s(),4))
total_frames += read
if read < hop_s: break
return onsets
def test_members(self):
o = onset()
assert_equal ([o.buf_size, o.hop_size, o.method, o.samplerate],
[1024,512,'default',44100])
win_s = 512 # fft size
hop_s = win_s / 2 # hop size
if len(sys.argv) < 2:
print "Usage: %s <filename> [samplerate]" % sys.argv[0]
sys.exit(1)
filename = sys.argv[1]
samplerate = 0
if len( sys.argv ) > 2: samplerate = int(sys.argv[2])
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate
o = onset("default", win_s, hop_s, samplerate)
# list of onsets, in samples
onsets = []
# total number of frames read
total_frames = 0
while True:
samples, read = s()
if o(samples):
print "%f" % o.get_last_s()
onsets.append(o.get_last())
total_frames += read
if read < hop_s: break
#print len(onsets)
def test_all_methods(self):
for method in ['default', 'energy', 'hfc', 'complexdomain', 'complex',
'phase', 'wphase', 'mkl', 'kl', 'specflux', 'specdiff',
'old_default']:
o = onset(method=method, buf_size=512, hop_size=256)
o(fvec(256))
options, args = parse_args()
hopsize = options.hopsize
bufsize = options.bufsize
samplerate = options.samplerate
source_file = options.source_file
from aubio import onset, tempo, source, sink
s = source(source_file, samplerate, hopsize)
if samplerate == 0: samplerate = s.get_samplerate()
if options.beat:
o = tempo(options.onset_method, bufsize, hopsize)
else:
o = onset(options.onset_method, bufsize, hopsize)
if options.minioi:
if options.minioi.endswith('ms'):
o.set_minioi_ms(int(options.minioi[:-2]))
elif options.minioi.endswith('s'):
o.set_minioi_s(int(options.minioi[:-1]))
else:
o.set_minioi(int(options.minioi))
o.set_threshold(options.threshold)
timestamps = []
total_frames = 0
# analyze pass
while True:
samples, read = s()
if o(samples):
def get_detector(self):
detector = aubio.onset(self.method, self.winsize, self.hopsize,
self.samplerate)
detector.set_threshold(self.threshold)
detector.set_silence(self.silence)
return detector
def setUp(self):
self.o = onset(samplerate = self.samplerate)
def create_onset_alg(onset_method="default", onset_buffer_size=512,
onset_hop_size=256, onset_samplerate=44100,
onset_threshold=0.):
onset_alg = aubio.onset(onset_method, onset_buffer_size, onset_hop_size, onset_samplerate)
onset_alg.set_threshold(onset_threshold)
return onset_alg
