def plotPng(filepath, filename):
y, sr = librosa.load(filepath + filename, sr=None)
tempo, beats = librosa.beat.beat_track(y=y, sr=sr)
y_beats = librosa.clicks(frames=beats, sr=sr, length=len(y))
times = librosa.frames_to_time(beats, sr=sr)
y_beat_times = librosa.clicks(times=times, sr=sr)
# Or with a click frequency of 880Hz and a 500ms sample
y_beat_times880 = librosa.clicks(times=times,
sr=sr,
click_freq=880,
click_duration=0.5)
# Display click waveform next to the spectrogram
plt.figure()
S = librosa.feature.melspectrogram(y=y, sr=sr)
ax = plt.subplot(1, 1, 1)
librosa.display.specshow(librosa.power_to_db(S, ref=np.max),
x_axis='time',
y_axis='mel')
# plt.subplot(2, 1, 1, sharex=ax)
# librosa.display.waveplot(y_beat_times, sr=sr, label='Beat clicks')
plt.legend()
plt.xlim(0, 4)
plt.tight_layout()
portion = os.path.splitext(filename)
# os.rename(filename,portion[0]+".png")
# 切换文件路径,如无路径则要新建或者路径同上。否则会直接生成在当前文件夹下
os.chdir("F:/研究生记录/研一/语音分离/一阶段/语音分离结果/样本4/")
plt.savefig(portion[0] + ".png")
def Audio_Display(data):
# Sonify detected beat events
tempo, beats = librosa.beat.beat_track(y=audio_data, sr=sr)
audio_beats = librosa.clicks(frames=beats, sr=sr)
# Or generate a signal of the same length as audio_data
audio_beats = librosa.clicks(frames=beats, sr=sr, length=len(audio_data))
# Or use timing instead of frame indices
times = librosa.frames_to_time(beats, sr=sr)
audio_beat_times = librosa.clicks(times=times, sr=sr)
# Or with a click frequency of 880Hz and a 500ms sample
audio_beat_times880 = librosa.clicks(times=times, sr=sr,
click_freq=880, click_duration=0.5)
# Display click waveform next to the spectrogram
plt.figure()
Spec = librosa.feature.melspectrogram(y=audio_data, sr=sr)
ax = plt.subplot(3, 1, 2)
librosa.display.specshow(librosa.power_to_db(Spec, ref=np.max), x_axis='time', y_axis='mel')
plt.subplot(3, 1, 1)# , sharex=ax)
librosa.display.waveplot(audio_data, sr=sr, label='Beat Clicks') # Plot raw data to wave shape
plt.legend()
plt.xlim()
plt.tight_layout()
plt.subplot(3, 1, 3)
D = librosa.amplitude_to_db(librosa.stft(audio_data), ref=np.max)
librosa.display.specshow(D, y_axis='linear')
plt.colorbar(format='%+2.0f dB')
plt.title('Linear-frequency power spectrogram')
plt.show()
def changeTempo(current_tempo, onset_times, desired_tempo):
hi_hat, _ = librosa.load('./Thrown/test_sounds/sfx/closed_hi_hat.wav')
drum_hit, _ = librosa.load('./Thrown/test_sounds/sfx/drum_hit.wav')
desired_tempo_timing = 60 / desired_tempo
current_tempo_timing = 60 / current_tempo
scale_factor = desired_tempo_timing / current_tempo_timing
onset_frames1 = librosa.time_to_frames(onset_times, sr=sr)
clicks1 = librosa.clicks(frames=onset_frames1,
sr=sr,
click_duration=.01,
length=len(t[2][4]),
click=hi_hat)
sf.write('./Thrown/test_sounds/thrown_w_beat.wav', clicks1 + t[1][2], sr)
scaled_onset_times = []
for i in range(0, len(onset_times)):
scaled_onset_times.append(onset_times[i] * scale_factor)
scaled_beat_frames = []
for i in range(0, len(t[1][8])):
scaled_beat_frames.append(t[1][8][i] * scale_factor)
scaled_beat_times = []
for i in range(0, len(t[1][6])):
scaled_beat_times.append(t[1][6] * scale_factor)
onset_frames2 = librosa.time_to_frames(scaled_onset_times, sr=sr)
print(onset_frames2)
scaled_sample = librosa.effects.time_stretch(t[1][2], 1 / scale_factor)
clicks2 = librosa.clicks(frames=onset_frames2,
sr=sr,
click_duration=.01,
length=len(scaled_sample),
click=hi_hat)
clicks3 = librosa.clicks(frames=scaled_beat_frames,
sr=sr,
click_duration=.01,
length=len(scaled_sample),
click=drum_hit)
librosa.output.write_wav('./Thrown/test_sounds/thrown_altered_beat.wav',
clicks2 + clicks3 + scaled_sample, sr)
sf.write('./Thrown/test_sounds/altered_beat.wav', clicks2 + clicks3, sr)
plt.figure(figsize=(14, 5))
plt.title("Removing Percussive Sample, Scalability of Tempo Events")
plt.vlines(scaled_onset_times, -1, 1, color='c', linestyles='dashed')
plt.vlines(scaled_beat_times, -1, 1, color='y', linestyles='dashed')
plt.ylim(-1, 1)
plt.xlim(0, 5)
def createMidiFromAudioData():
i = 0
for i in range(len(input_audio_filename_array)):
input_audio_filename = input_audio_filename_array[i]
bpm = input_bpm_array[i]
auftakt_16th_notes_number = auftakt_16th_notes_number_array[i]
# foreground, background, background_percussiveの出力ファイル名
audio_filename_foreground = input_audio_filename + '_foreground.wav'
audio_filename_background = input_audio_filename + '_background.wav'
audio_filename_background_percussive = input_audio_filename + '_background_percussive.wav'
# 入力wavデータ読み込み、分離処理
x, sr = librosa.load(input_audio_filename)
S_foreground, S_background = separateMusicIntoForegroundAndBackground(x, sr)
background_harmonic, background_percussive = separateMusicIntoHarmonicAndPercussive(S_background)
# foreground, background, background_percussiveのwavファイル書き出し
librosa.output.write_wav(audio_filename_foreground, librosa.istft(S_foreground), sr)
librosa.output.write_wav(audio_filename_background, librosa.istft(S_background), sr)
librosa.output.write_wav(audio_filename_background_percussive, background_percussive, sr)
# ビート処理
onset_envelope = librosa.onset.onset_strength(background_percussive, sr=sr, hop_length=hop_length)
onset_frames = librosa.util.peak_pick(onset_envelope, 7, 7, 7, 7, 0.8, 5)
beat_frames_per_16th_note = trackBeatsPer16thNote(background_percussive, bpm, sr=sr, hop_length=hop_length,
offset_16th_notes=0)
quantized_onset_frames_per_16th_note, onset_frames_index_of_16th_notes = quantizeOnsetFramesPer16thNote(
onset_frames, beat_frames_per_16th_note)
strong_onset_frames, strong_onset_frames_index_of_16th_notes = getStrongOnsetFrames(onset_envelope,
beat_frames_per_16th_note,
onset_frames_index_of_16th_notes)
weak_onset_frames, weak_onset_frames_index_of_16th_notes = getWeakOnsetFrames(
strong_onset_frames_index_of_16th_notes, onset_frames_index_of_16th_notes, beat_frames_per_16th_note)
# クリック音入力
N = len(background_percussive)
T = N / float(sr)
# t = np.linspace(0, T, len(onset_envelope))
clicks_strong = librosa.clicks(frames=strong_onset_frames, sr=sr, hop_length=hop_length, length=N)
clicks_weak = librosa.clicks(frames=weak_onset_frames, sr=sr, hop_length=hop_length, click_freq=1000.0,
click_duration=0.01, length=N)
audio_filename_background_percussive_clicks = audio_filename_background_percussive + '_clicks.wav'
librosa.output.write_wav(audio_filename_background_percussive_clicks,
background_percussive + clicks_strong + clicks_weak, sr)
# リズム譜作成
midi_filename = input_audio_filename + '.mid'
createMidiRhythmScore(midi_filename, onset_frames_index_of_16th_notes, strong_onset_frames_index_of_16th_notes,
weak_onset_frames_index_of_16th_notes, bpm, auftakt_16th_notes_number)
def generate_click(file, filename, click_freq, click_duration, vol_adj_song, vol_adj_click, convert_folder):
saveFileExt = filename.rsplit('.', 1)[1].lower()
saveName = filename
if(saveFileExt != "wav"):
saveName = saveName.rsplit('.', 1)[0].lower() + ".wav"
inputAudio, _, newName = convert_file(file, filename, saveName, convert_folder)
sr = 44100
_, beats = beat_track(inputAudio, sr)
clickAudio = clicks(
frames = beats, # the beats to place clicks
sr = sr, # sample rate
length = len(inputAudio), # length of the song (necessary to align clicktrack and song)
click_freq = click_freq, # frequency of each click (in Hz)
click_duration = click_duration # duration of each click (in seconds)
)
inputAudio *= vol_adj_song
clickAudio *= vol_adj_click
sf.write(os.path.join(convert_folder, newName), inputAudio + clickAudio, sr)
return newName
def onset(x, sr):
# Short-time Fourier transform (for EQ, must do inverse Fourier transform after)
X = librosa.stft(x)
# Find the frames when onsets occur
onset_frames = librosa.onset.onset_detect(x, sr=sr)
print("Onset Frames = " + str(onset_frames) + "\n ")
# Find the times, in seconds, when onsets occur in the audio signal
onset_times = librosa.frames_to_time(onset_frames, sr=sr)
print("Onset Times = " + str(onset_times) + "\n ")
# Convert the onset frames into sample indices to play "BEEB" sound on it
onset_samples = librosa.frames_to_samples(onset_frames)
print("Onset Samples = " + str(onset_samples) + "\n ")
# Use the "length" parameter so the click track is the same length as the original signal
clicks = librosa.clicks(times=onset_times, length=len(x))
# Play the click track "added to" the original signal
sd.play(x + clicks, sr)
# Display the waveform of the original signal
librosa.display.waveplot(x, sr)
plt.title("Original Signal")
plt.show() # Close window to resume
return onset_frames, onset_times, onset_samples
def clicked():
bps = k1.get()
b = np.around(np.linspace(0,60,bps),decimals=2)
y_beats = librosa.clicks(times= b)
librosa.output.write_wav('metro.wav', y_beats, 22050)
tt = TapTester()
c = 0
player = MediaPlayer('metro.wav')
for i in range(1000):
# if tt.listen() == 1:
# if ((time.time()-start)% (2/3)) < 0.3:
# c += 1
# print("on beat")
# if c>1:
# print("streak x"+str(c))
# else:
# print("off beat")
# c = 0
if tt.listen() == 1:
if c == 0:
start = time.time()
if b[c]-0.1 <= round(time.time()-start,2) <= b[c]+0.1:
print("on beat x", str(c))
lbl_streak.configure(text = str(c)+"x Streak")
root.update()
c+=1
else:
c=0
def testMusic(musicFile, fps):
baseAudio, sampleRate = librosa.load(musicFile)
mmBeats = getBeatTimes(musicFile, fps)
print("Madmom found", len(mmBeats), "beats.")
mmClicks = librosa.clicks(mmBeats, sr=sampleRate, length=len(baseAudio))
librosa.output.write_wav('BEAT_TEST_' + musicFile, baseAudio + mmClicks,
sampleRate)
def overlap_click(original, click_position, sr=44100, click_freq=2000, click_duration=0.5):
"""
:param click_position: Notice that position should be given in second
:return: wave
"""
cwave = librosa.clicks(np.array(click_position), sr=44100, click_freq=4000, click_duration=0.05) / 2
original, wave = mono_pad_or_truncate(original, cwave)
return standardize(original + wave)
def compute_plot_tempogram_PLP(fn_wav,
Fs=22050,
N=500,
H=10,
Theta=np.arange(30, 601),
title='',
figsize=(8, 4),
plot_maxtempo=False):
"""Compute and plot Fourier-based tempogram and PLP function
Notebook: C6/C6S3_PredominantLocalPulse.ipynb"""
x, Fs = librosa.load(fn_wav, Fs)
nov, Fs_nov = LibFMP.C6.compute_novelty_spectrum(x,
Fs=Fs,
N=2048,
H=512,
gamma=100,
M=10,
norm=1)
nov, Fs_nov = LibFMP.C6.resample_signal(nov, Fs_in=Fs_nov, Fs_out=100)
L = len(nov)
H = 10
X, T_coef, F_coef_BPM = LibFMP.C6.compute_tempogram_Fourier(nov,
Fs=Fs_nov,
N=N,
H=H,
Theta=Theta)
nov_PLP = compute_PLP(X, Fs_nov, L, N, H, Theta)
tempogram = np.abs(X)
fig, ax = plt.subplots(2,
2,
gridspec_kw={
'width_ratios': [1, 0.05],
'height_ratios': [2, 1]
},
figsize=figsize)
LibFMP.B.plot_matrix(tempogram,
T_coef=T_coef,
F_coef=F_coef_BPM,
title=title,
ax=[ax[0, 0], ax[0, 1]],
ylabel='Tempo (BPM)',
colorbar=True)
if plot_maxtempo:
coef_k = np.argmax(tempogram, axis=0)
ax[0, 0].plot(T_coef, F_coef_BPM[coef_k], 'r.')
t_nov = np.arange(nov.shape[0]) / Fs_nov
peaks, properties = signal.find_peaks(nov_PLP, prominence=0.05)
peaks_sec = t_nov[peaks]
LibFMP.B.plot_signal(nov_PLP, Fs_nov, color='k', ax=ax[1, 0])
ax[1, 1].set_axis_off()
ax[1, 0].plot(peaks_sec, nov_PLP[peaks], 'ro')
plt.show()
x_peaks = librosa.clicks(peaks_sec, sr=Fs, click_freq=1000, length=len(x))
ipd.display(ipd.Audio(x + x_peaks, rate=Fs))
def play(self, with_clicks=False):
if not with_clicks:
return ipd.Audio(self.path, rate=self.sampling_rate)
else:
clicks = librosa.clicks(self.beat_times,
sr=self.sampling_rate,
length=len(self.waveform))
audio = self.waveform + clicks
return ipd.Audio(audio, rate=self.sampling_rate)
def saveAudioWithFormBeeps(audio, time, sr=22050, folder_name=''):
#check if folder exists or make it
checkMakeFolder(folder_name)
# generating a track with clicks at the start of forms
clicks = lr.clicks(times=lr.samples_to_time(time), length=len(audio))
# adsd the clicks to original audio and save it
sf.write(folder_name + 'audio_beeped.wav', audio + clicks, int(sr))
def drum_track(x, r):
drum_onsets = ADT([filename])[0]
clicks = librosa.clicks(times=drum_onsets['Kick'], sr=sr, length=len(x))
clicks = librosa.clicks(times=drum_onsets['Snare'], sr=sr, length=len(x))
clicks = librosa.clicks(times=drum_onsets['Hihat'], sr=sr, length=len(x))
# Compute average drum beat signal.
frame_sz = int(0.100 * sr)
def normalize(z):
return z / scipy.linalg.norm(z)
drum_type = ['Kick', 'Snare', 'Hihat']
drum_track_list = []
for iii in drum_type:
onset_samples = librosa.time_to_samples(iii, sr=sr)
x_avg = numpy.mean(
[normalize(x[i:i + frame_sz]) for i in onset_samples], axis=0)
# Compute average spectrum.
X = librosa.spectrum.fft.fft(x_avg)
Xmag = librosa.amplitude_to_db(abs(X))
def test_click_multi():
click = np.ones((3, 100))
yout = librosa.clicks(times=[0, 1, 2], sr=1000, click=click)
print(yout.shape)
assert yout.shape[0] == click.shape[0]
assert np.allclose(yout[..., :100], click)
assert np.allclose(yout[..., 1000:1100], click)
assert np.allclose(yout[..., 2000:2100], click)
def feature(file, num):
y, sr = librosa.load(file, sr=44100)
y_harmonic, y_percussive = librosa.effects.hpss(y)
tempo, beats = librosa.beat.beat_track(y=y,sr=sr)
tempo, beat_frames = librosa.beat.beat_track(y=y_percussive,sr=sr)
y_beats = librosa.clicks(frames=beats, sr=sr)
plt.figure(figsize=(6, 4))
D=librosa.amplitude_to_db(librosa.stft(y),ref=np.max)
librosa.display.specshow(D, y_axis='linear')
plt.title('STFT Linear-frequency power spectrogram')
plt.savefig('..\\SourceData\\STFT\\' + str(num) + '.JPG')
plt.close()
CQT=librosa.amplitude_to_db(librosa.cqt(y,sr = 44100), ref=np.max)
plt.figure(figsize=(6, 4))
librosa.display.specshow(CQT,y_axis='cqt_note')
plt.title('Constant-Q power spectrogram (note)')
plt.savefig('..\\SourceData\\CQT\\' + str(num) + '.JPG')
plt.close()
M=librosa.feature.mfcc(y=y, sr=sr)
plt.figure(figsize=(6, 4))
librosa.display.specshow(M, x_axis = 'time')
plt.title('MFCC')
plt.savefig('..\\SourceData\\MFCC\\' + str(num) + '.JPG')
plt.close()
Mfcc_delta = librosa.feature.delta(M)
Beat_Mfcc_delta = librosa.util.sync(np.vstack([M, Mfcc_delta]), beat_frames)
plt.figure(figsize=(6, 4))
librosa.display.specshow(Beat_Mfcc_delta, x_axis = 'time')
plt.title('Beat_Mfcc_delta')
plt.savefig('..\\SourceData\\MFCC_DELTA\\' + str(num) + '.JPG')
plt.close()
M=librosa.feature.chroma_stft(y=y, sr=sr)
plt.figure(figsize=(6, 4))
librosa.display.specshow(M, y_axis='chroma')
plt.title('Chroma_STFT')
plt.savefig('..\\SourceData\\Chroma_STFT\\' + str(num) + '.JPG')
plt.close()
C=librosa.feature.chroma_cqt(y=y, sr=sr)
plt.figure(figsize=(6, 4))
librosa.display.specshow(C,y_axis='chroma')
plt.title('Chroma_CQT')
plt.savefig('..\\SourceData\\Chroma_CQT\\' + str(num) + '.JPG')
plt.close()
def upload(request):
if request.method == 'POST':
myfile = request.FILES['audio']
fs = FileSystemStorage()
if fs.exists(myfile.name):
os.remove(os.path.join(settings.MEDIA_ROOT, myfile.name))
filename = fs.save(myfile.name, myfile)
# uploaded_file_url = fs.url(filename)
# filename_only = os.path.splitext(os.path.basename(uploaded_file_url))[0]
filename_only = filename.split('.')[-2]
x_2, sr_2 = librosa.load('media/' + filename)
total_time_original = len(x_2) / sr_2
x, sr = librosa.load('media/' + filename, duration=60)
onset_env = librosa.onset.onset_strength(y=x, sr=sr)
tempo, beat_times = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr, start_bpm=120, units='time')
total_time = len(x) / sr
# time = np.linspace(0, total_time, len(x))
# plt.plot(time, x, color='b', label='waveform')
# plt.vlines(beat_times, -1.5, 1.5, color='r', label='beat')
# plt.legend(['waveform','beat'])
# plt.xlabel("Times")
# plt.ylabel("Amplitude")
# start_sec = 10 # keyboard
# end_sec = 20 # keyboard
# plt.xlim(start_sec, end_sec)
# plt.show()
# dir_name = 'static/' + filename_only + '.png'
# plt.savefig(dir_name)
original_music = 'media/' + filename
beat_music = 'static/' + filename_only + '_beat.wav'
clicks = librosa.clicks(beat_times, sr=sr, length=len(x))
write(beat_music, sr, x + clicks)
beat_times_file = 'static/' + filename_only + '_beat.txt'
with open(beat_times_file, 'w') as f:
for item in beat_times:
f.write("%s\n" % round(item, 2))
f.close()
return render(request, 'list.html', {'filename': filename_only, 'tempo': int(tempo), 'time': int(total_time),
'soundfile': '/' + beat_music, 'beat_times': '/' + beat_times_file,
'soundfile_original': '/' + original_music, 'time_original': int(total_time_original),
'beat': beat_times})
return redirect('')
def generate_rhythm_clicks(rhythm, click_interval=0.25, sr=44100):
step_length_samples = int(librosa.time_to_samples(click_interval, sr=sr))
rhythm_length_samples = step_length_samples * (len(rhythm))
# Generate click times
pulse_click_times, step_click_times = generate_rhythm_times(
rhythm, click_interval)
# Generate pulse clicks
pulse_click_times = np.array(
[i * click_interval for i in range(len(rhythm)) if rhythm[i] != 0])
pulse_clicks = librosa.clicks(times=pulse_click_times,
click_freq=2000.0,
sr=sr,
length=rhythm_length_samples)
# Generate step clicks
step_click_times = np.array(
[i * click_interval for i in range(len(rhythm))])
step_clicks = librosa.clicks(times=step_click_times,
click_freq=1000.0,
sr=sr,
length=rhythm_length_samples)
step_clicks = np.hstack(
(step_clicks, np.zeros(step_length_samples,
dtype="int"))) # add last step samples
# Add zeros to pulse clicks so that it's the same length as the step clicks signal
pulse_clicks = np.hstack((pulse_clicks,
np.zeros(len(step_clicks) - len(pulse_clicks),
dtype="int")))
# Ensure proper length
pulse_clicks = pulse_clicks[:rhythm_length_samples]
step_clicks = step_clicks[:rhythm_length_samples]
return (pulse_clicks, step_clicks)
def clicks(wav, beats, clicks_volume=8):
r"""Returns a wav with clicks at the specified beats.
Arguments:
wav (1d numpy array): An audio wav at the sampling rate determined by
`beatfinder.constants`.
beats (1d numpy array): The beats in units of seconds.
clicks_volume (float between 0 and 10): The volume of the clicks (it
can also be set to 11).
"""
clicks = librosa.clicks(times=beats, sr=constants.sr, length=len(wav))
clicks *= clicks_volume / 10
return wav + clicks
def export_audio_with_click(proc_res, path_audio, path_output, sr=44100):
# extract time
times_beat = proc_res[np.where(proc_res[:, 1] != 1)][:, 0]
times_downbeat = proc_res[np.where(proc_res[:, 1] == 1)][:, 0]
# load
y, _ = librosa.core.load(path_audio, sr=sr)
# click audio
y_beat = librosa.clicks(
times=times_beat, sr=sr, click_freq=1200, click_duration=0.5) * 0.6
y_downbeat = librosa.clicks(times=times_downbeat,
sr=sr,
click_freq=600,
click_duration=0.5)
# merge
max_len = max(len(y), len(y_beat), len(y_downbeat))
y_integrate = np.zeros(max_len)
y_integrate[:len(y_beat)] += y_beat
y_integrate[:len(y_downbeat)] += y_downbeat
y_integrate[:len(y)] += y
librosa.output.write_wav(path_output, y_integrate, sr)
def sonify_music(self):
"""Function to sonify MFCC, Spectral Contrast, HFC and Tempo of the input signal"""
self.mfcc_outputs = []
self.contrast_outputs = []
self.hfcs = []
self.f0s = []
self.ats = []
for frame in self.FrameGenerator():
self.window()
self.Spectrum()
self.Phase(self.fft(self.windowed_x))
self.MFCC_seq()
self.mfcc_outputs.append(self.reconstruct_signal_from_mfccs())
self.contrast()
fft_filter = self.filter_by_valleys()
self.contrast_outputs.append(self.ISTFT(fft_filter))
self.hfcs.append(self.hfc())
self.spectral_peaks()
self.fundamental_frequency()
self.f0s.append(self.f0)
self.mfcc_outputs = self.output_array(self.mfcc_outputs)
self.contrast_outputs = self.output_array(self.contrast_outputs)
self.f0 = Counter(self.f0s).most_common()[0][0]
self.mel_bands_global()
self.bpm()
self.tempo_onsets = clicks(frames=self.ticks * self.fs,
length=len(self.signal),
sr=self.fs,
hop_length=self.H)
starts = self.ticks * self.fs
for i in starts:
self.frame = self.signal[int(i):int(i) + 1024]
self.Envelope()
self.AttackTime()
self.ats.append(self.attack_time)
starts = starts[np.where(self.ats < np.mean(self.ats))]
self.ats = np.array(self.ats)[np.where(self.ats < np.mean(self.ats))]
attacks = np.int64((np.array(self.ats) * self.fs) + starts)
self.attacks = self.create_clicks(attacks)
self.hfcs /= max(self.hfcs)
fir = firwin(11, 1.0 / 8, window="hamming")
self.filtered = np.convolve(self.hfcs, fir, mode="same")
self.climb_hills()
self.hfc_locs = np.array(
[i for i, x in enumerate(self.Filtered) if x > 0]) * self.H
self.hfc_locs = self.create_clicks(self.hfc_locs)
def overlay_rhythm_onto_audio(rhythm,
audio_samples,
measure_samples,
sr=44100,
plt_size=(16, 4),
click_colors={
"measure": "r",
"pulse": "r",
"step": "r"
}):
# Get overlay data
pulse_times, step_times, pulse_clicks, step_clicks = generate_rhythm_overlay(
rhythm, measure_samples, len(rhythm), sr)
measure_times = librosa.samples_to_time(measure_samples, sr=sr)
measure_clicks = librosa.clicks(times=measure_times,
sr=sr,
click_freq=3000.0,
length=len(audio_samples))
# Calculate max length in samples
available_lengths = [
len(audio_samples),
len(measure_clicks),
len(pulse_clicks),
len(step_clicks)
]
length_samples = min(available_lengths)
# Plot original waveform
plt.figure(figsize=plt_size)
librosa.display.waveplot(audio_samples, sr=sr, alpha=0.5)
# Plot rhythm clicks
plt.vlines(measure_times, -1, 1, color=click_colors["measure"])
plt.vlines(pulse_times, -0.5, 0.5, color=click_colors["pulse"])
plt.vlines(step_times, -0.25, 0.25, color=click_colors["step"], alpha=0.75)
# Play both clicks together with audio track
concatenated_audio_samples = ((audio_samples[:length_samples] * 2.0) +
(measure_clicks[:length_samples] * 0.25) +
(pulse_clicks[:length_samples] * 0.25) +
(step_clicks[:length_samples] * 0.25))
audio_display = ipd.Audio(concatenated_audio_samples, rate=sr)
return audio_display
def add_clicks(f):
x, sr = soundfile.read(io.BytesIO(f.read()))
if x.shape[1] > 1:
x = x[:, 0]
o_env = librosa.onset.onset_strength(x, sr=sr)
onset_frames = librosa.onset.onset_detect(onset_envelope=o_env,
sr=sr,
hop_length=128)[1:-1]
cowbell, _ = librosa.load('audio/cowbell.wav')
clicks = librosa.clicks(frames=onset_frames,
sr=sr,
length=len(x),
click=cowbell)
fout = io.BytesIO()
soundfile.write(fout, clicks + x, sr, format='WAV')
print(f'sample rate: {sr}\nlength of file: {len(x)}')
fout.seek(0)
return fout
def upload(request):
if request.method == 'POST':
myfile = request.FILES['audio']
fs = FileSystemStorage()
if fs.exists(myfile.name):
os.remove(os.path.join(settings.MEDIA_ROOT, myfile.name))
filename = fs.save(myfile.name, myfile)
filename_only = filename.split('.')[-2]
x_2, sr_2 = librosa.load('media/' + filename)
total_time_original = len(x_2) / sr_2
x, sr = librosa.load('media/' + filename, duration=60)
onset_env = librosa.onset.onset_strength(y=x, sr=sr)
tempo, beat_times = librosa.beat.beat_track(onset_envelope=onset_env,
sr=sr,
start_bpm=120,
units='time')
total_time = len(x) / sr
original_music = 'media/' + filename
beat_music = 'static/outputs/musics' + filename_only + '_beat.wav'
clicks = librosa.clicks(beat_times, sr=sr, length=len(x))
write(beat_music, sr, x + clicks)
beat_times_file = 'static/outputs/beats' + filename_only + '_beat.txt'
with open(beat_times_file, 'w') as f:
for item in beat_times:
f.write("%s\n" % round(item, 2))
f.close()
return render(
request, 'list.html', {
'filename': filename_only,
'tempo': int(tempo),
'time': int(total_time),
'soundfile': '/' + beat_music,
'beat_times': '/' + beat_times_file,
'soundfile_original': '/' + original_music,
'time_original': int(total_time_original)
})
return redirect('home1')
def compute_plot_sonify_beat(nov, Fs_nov, beat_ref, factor, title=None, figsize=(6,2)):
"""Compute, plot, and sonfy beat sequence from novelty function [FMP, Section 6.3.2]
Notebook: C6/C6S3_BeatTracking.ipynb"""
B = compute_beat_sequence(nov, beat_ref=beat_ref, factor=factor)
beats = np.zeros(len(nov))
beats[np.array(B,dtype=np.int32)] = 1#
if title is None:
tempo = beat_period_to_tempo(beat_ref, Fs_nov)
title = r'Optimal beat sequence ($\hat{\delta}=%d$, $F_\mathrm{s}=%d$, $\hat{\tau}=%0.0f$ BPM, $\lambda=%0.2f$)'%(beat_ref, Fs_nov, tempo, factor)
fig, ax, line = LibFMP.B.plot_signal(nov, Fs_nov, color='k', title=title, figsize=figsize)
T_coef = np.arange(nov.shape[0]) / Fs_nov
ax.plot(T_coef, beats, ':r', linewidth=1)
plt.show()
beats_sec = T_coef[B]
x_peaks = librosa.clicks(beats_sec, sr=Fs, click_freq=1000, length=len(x))
ipd.display(ipd.Audio(x + x_peaks, rate=Fs))
def sonify_music(self):
"""Function to sonify MFCC, Spectral Contrast, HFC and Tempo of the input signal"""
self.mfcc_outputs = []
self.contrast_outputs = []
self.hfcs = []
self.f0s = []
self.ats = []
for frame in self.FrameGenerator():
self.window()
self.Spectrum()
self.Phase(self.fft(self.windowed_x))
self.MFCC_seq()
self.mfcc_outputs.append(self.reconstruct_signal_from_mfccs())
self.contrast()
fft_filter = self.filter_by_valleys()
self.contrast_outputs.append(self.ISTFT(fft_filter))
self.hfcs.append(self.hfc())
self.spectral_peaks()
self.fundamental_frequency()
self.f0s.append(self.f0)
self.mfcc_outputs = self.output_array(self.mfcc_outputs)
self.contrast_outputs = self.output_array(self.contrast_outputs)
self.f0 = Counter(self.f0s).most_common()[0][0]
self.mel_bands_global()
self.bpm()
self.tempo_onsets = clicks(frames = self.ticks * self.fs, length = len(self.signal), sr = self.fs, hop_length = self.H)
starts = self.ticks * self.fs
for i in starts:
self.frame = self.signal[int(i):int(i)+1024]
self.Envelope()
self.AttackTime()
self.ats.append(self.attack_time)
starts = starts[np.where(self.ats < np.mean(self.ats))]
self.ats = np.array(self.ats)[np.where(self.ats < np.mean(self.ats))]
attacks = np.int64((np.array(self.ats) * self.fs) + starts)
self.attacks = self.create_clicks(attacks)
self.hfcs /= max(self.hfcs)
fir = firwin(11, 1.0 / 8, window = "hamming")
self.filtered = np.convolve(self.hfcs, fir, mode="same")
self.climb_hills()
self.hfc_locs = np.array([i for i, x in enumerate(self.Filtered) if x > 0]) * self.H
self.hfc_locs = self.create_clicks(self.hfc_locs)
def __test(times, frames, sr, hop_length, click_freq, click_duration, click, length):
y = librosa.clicks(times=times,
frames=frames,
sr=sr,
hop_length=hop_length,
click_freq=click_freq,
click_duration=click_duration,
click=click,
length=length)
if times is not None:
nmax = librosa.time_to_samples(times, sr=sr).max()
else:
nmax = librosa.frames_to_samples(frames, hop_length=hop_length).max()
if length is not None:
assert len(y) == length
elif click is not None:
assert len(y) == nmax + len(click)
def __test(times, frames, sr, hop_length, click_freq, click_duration, click, length):
y = librosa.clicks(times=times,
frames=frames,
sr=sr,
hop_length=hop_length,
click_freq=click_freq,
click_duration=click_duration,
click=click,
length=length)
if times is not None:
nmax = librosa.time_to_samples(times, sr=sr).max()
else:
nmax = librosa.frames_to_samples(frames, hop_length=hop_length).max()
if length is not None:
assert len(y) == length
elif click is not None:
assert len(y) == nmax + len(click)
def process(audio, fs):
spectrogram = \
librosa.amplitude_to_db(abs(librosa.core.stft(audio)), ref=np.max)
spectral_novelty = librosa.onset.onset_strength(audio, sr=fs)
peaks = librosa.util.peak_pick(spectral_novelty, 1, 1, 1, 1, 1, 1)
times = librosa.frames_to_time(np.arange(len(spectral_novelty)), sr=fs)
plt.subplot(2, 1, 1)
librosa.display.waveplot(audio)
plt.xlabel('Time')
plt.ylabel('Amplitude')
plt.vlines(times[peaks], audio.min(), audio.max(), color='r')
plt.subplot(2, 1, 2)
librosa.display.specshow(spectrogram, x_axis='time', y_axis='log')
plt.xlabel('Time')
plt.ylabel('Hz')
plt.vlines(times[peaks], 0, 10000, color='r')
plt.show()
clicks = librosa.clicks(frames=peaks, sr=fs, length=len(audio))
sd.play(audio + clicks, blocking=True)
def sonification_librosa( peaks, amplitudes, labels, length, featureRate, fs=44100 ):
#applying librosa sonification
sonification = np.zeros( length )
for i in [1,2,3]:
idxs = np.where(labels==i)
current_peaks = peaks[idxs]
freq = get_frequency(i)
current_sonification = librosa.clicks(current_peaks, sr=fs, click_freq=freq, length=length)
sonification += current_sonification
#scaling the sonificiations with the amplitude of the novelty curvve
for i in range(len(peaks)-1):
current_peak = int(peaks[i]*fs)
length = int(0.1*fs)
window = np.ones(length) #length of sonification is 100ms
window = window*amplitudes[i]
sonification[current_peak:current_peak+length] *= window
return sonification
def getFrames(path):
"""Gets onset frames and times
Parameters:
song (string): name of the song
Output:
.wav song with the clicks for developing purposes
.csv file with timesptamps of the clicks
Returns:
frames_time: list with all the times with onset
"""
y, sr = librosa.load(path)
# #get frames
onset_frames = librosa.onset.onset_detect(y=y, sr=sr)
# #turn frames into time
frames_time = librosa.frames_to_time(onset_frames, sr=sr)
# #create clicks
clicks = librosa.clicks(frames_time, sr=sr, length=len(y))
#output
librosa.output.write_wav(f'./output/audio-onset.wav', y + clicks, sr)
librosa.output.times_csv(f'./output/audio-onsetimes.csv', frames_time)
return frames_time
plt.ylim(0)
#peak_picking
#onset_frames = librosa.util.peak_pick(onset_envelope, 7, 7, 7, 7, 0.5, 5)
onset_frames = librosa.util.peak_pick(onset_envelope, 7, 7, 7, 7, 0.8, 5)
#検出したピークに縦線を描画(カラーバー）
plt.plot(t, onset_envelope)
plt.vlines(t[onset_frames], 0, onset_envelope.max(), color='r', alpha=0.7)
plt.xlabel('Time (sec)')
plt.xlim(0, T)
plt.ylim(0)
#検出したピークにクリック音を入れる
clicks = librosa.clicks(frames=onset_frames,
sr=sr,
hop_length=hop_length,
length=N)
#クリック音と共に出力
#librosa.output.write_wav('01.Track_1.background_percussive_click.wav', background_percussive+clicks, sr)
librosa.output.write_wav('01.Track_1.background_percussive_click_delta08.wav',
background_percussive + clicks, sr)
#RWC-MDB-P-2001-M06の01はbpm = 90なのでnumpyでarrayをつくる やることは16分でクォンタイズ
#BPM90で１小節が2.666666...秒
#beat, tempoの取得
tempo, beat_times = librosa.beat.beat_track(x,
sr=sr,
start_bpm=90,
units='time')
#アウフタクトの除去
#3/4,4/4,4/4
rythms = [[0, 0.33, 0.33], [0, 0.5], [0, 0.25, 0.25, 0.25]] #onset
measures = [4, 4, 4, 4] #4/4
names = ["ternary", "binary", "quaternary"]
bpm = [60, 120, 240]
sr = 44100
i = 0
for ticks in rythms:
for j in bpm:
beat_times = []
c = 0
measure = measures[i] * (60 / j)
for k in ticks:
c += (measure * k)
beat_times.append(c)
click = librosa.clicks(times=beat_times[0],
click_freq=1000,
sr=sr,
length=round(sr * measure))
clicks = librosa.clicks(times=beat_times[1:len(beat_times)],
click_freq=500,
sr=sr,
length=round(sr * measure))
s = click + clicks
signal = []
for l in range(0, 100): #number of repetitions
signal.append(s)
librosa.output.write_wav(
"[" + str(j) + "bpm]" + names[i] + '_clicks.wav',
np.array(signal).flatten(), sr)
i += 1
