def add_white_noise(original_audio_path,
modified_audio_path,
target_snr_in_db,
offset=None,
duration=None):
"""
:param original_audio_path:
:param modified_audio_path:
:param target_snr_in_db:
:param offset:
:param duration:
"""
original_audio_data, sr = audio_manager.load_audio(
audio_path=original_audio_path, offset=offset, duration=duration)
modified_audio_data = audio_effects.add_white_noise(
audio_data=original_audio_data, target_snr_in_db=target_snr_in_db)
audio_manager.save_audio(audio_path=modified_audio_path,
audio_data=modified_audio_data,
sr=sr)
def apply_pitch_shifting(original_audio_path,
modified_audio_path,
target_pitch_shift_in_percent,
offset=None,
duration=None):
"""
:param target_pitch_shift_in_percent:
:param original_audio_path:
:param modified_audio_path:
:param offset:
:param duration:
"""
original_audio_data, sr = audio_manager.load_audio(
audio_path=original_audio_path, offset=offset, duration=duration)
modified_audio_data = audio_effects.pitch_shift(
audio_data=original_audio_data,
sr=sr,
pitch_shift_in_percent=target_pitch_shift_in_percent)
audio_manager.save_audio(audio_path=modified_audio_path,
audio_data=modified_audio_data,
sr=sr)
def apply_speed_change(original_audio_path,
modified_audio_path,
target_speed_in_percent,
offset=None,
duration=None):
"""
:param original_audio_path:
:param modified_audio_path:
:param target_speed_in_percent:
:param offset:
:param duration:
"""
audio_data, sr = audio_manager.load_audio(audio_path=original_audio_path,
offset=offset,
duration=duration)
modified_audio_data, target_sr = audio_effects.speed_change(
audio_data=audio_data,
sr=sr,
target_speed_in_percent=target_speed_in_percent)
audio_manager.save_audio(audio_path=modified_audio_path,
audio_data=modified_audio_data,
sr=sr)
def apply_time_stretching(original_audio_path,
modified_audio_path,
target_duration_in_percent,
offset=None,
duration=None):
"""
:param target_duration_in_percent:
:param original_audio_path:
:param modified_audio_path:
:param offset:
:param duration:
"""
original_audio_data, sr = audio_manager.load_audio(
audio_path=original_audio_path, offset=offset, duration=duration)
modified_audio_data = audio_effects.time_stretch(
audio_data=original_audio_data,
sr=sr,
time_stretching_in_percent=target_duration_in_percent)
audio_manager.save_audio(audio_path=modified_audio_path,
audio_data=modified_audio_data,
sr=sr)
tolerance=0.31)
# FingerprintManager object
fingerprint_manager = FingerprintManager(
db_path="../../../Databases/Quads_Test.db")
# results path
result_path = "../../../Results_2/Quad/Granularity/"
for t in range(5, 35, 5):
query_audios = dir_manager.find_wav_files(src_dir=src_dir)
dir_manager.create_dir(result_path)
count = 901
for i in query_audios:
audio_id = i.split("/")[7].split(".")[0]
# loading a time series audio data from one of the query audio
start = time.time()
audio_data = audio_manager.load_audio(audio_path=i,
sr=7000,
offset=10.0,
duration=t)
# computing stft based spectrogram of time series audio data
spectrogram = stft.compute_spectrogram_magnitude_in_db(
audio_data=audio_data)
# extracting spectral peaks from STFT based spectrogram
spectral_peaks = peak_extractor.spectral_peaks(spectrogram=spectrogram)
# generate quad based fingerprints
audio_fingerprints = fingerprint_generator.generate_fingerprints(
spectral_peaks=spectral_peaks[0],
spectrogram=spectrogram,
number_of_quads_per_second=500)
# query matches
match = fingerprint_manager.query_audio(
audio_fingerprints=audio_fingerprints,
spectral_peaks=spectral_peaks[0],
# an object to extract spectral peaks from STFT based spectrogram
peak_extractor = PeakExtractor(maximum_filter_width=150, maximum_filter_height=75)
# an object to generate fingerprints using the association of four spectral peaks
fingerprint_generator = FingerprintGenerator(
frames_per_second=219,
target_zone_width=2,
target_zone_center=4,
number_of_quads_per_second=9,
tolerance=0.0
)
# Data manager object
fingerprint_manager = FingerprintManager(db_path="../../../Databases/Quads_Test_1.db")
count = 1
for i in reference_audios:
audio_title = i.split("/")[5].split(".")[0]
# loading time series audio data of one of reference audio
audio_data = audio_manager.load_audio(audio_path=i, sr=7000)
# computing the spectrogram of time series audio data
spectrogram = stft.compute_spectrogram_magnitude_in_db(audio_data=audio_data)
# extracting spectral peaks from STFT based spectrogram
spectral_peaks = peak_extractor.extract_spectral_peaks(spectrogram=spectrogram)
# generate fingerprints using the association of four spectral peaks
audio_fingerprints = fingerprint_generator.generate_fingerprints(spectral_peaks=spectral_peaks[0],
spectrogram=spectrogram)
# storing fingerprints
fingerprint_manager.store_fingerprints(audio_fingerprints=audio_fingerprints,
spectral_peaks=spectral_peaks[0],
audio_title=audio_title)
print("Done Fingerprinting ", count, audio_title)
count += 1
from Utilities import dir_manager
from Utilities import audio_manager
from Core import STFT
from Core import PeakExtractor
# source directory for reference audio files
src_dir = "../../../Test_Data/Reference_Audios/"
# retrieving all mp3 files under specified source directory
mp3_files = dir_manager.find_mp3_files(src_dir=src_dir)
# loading 10 seconds time series audio data from one of the reference audio file
audio_data = audio_manager.load_audio(audio_path=mp3_files[1],
sr=7000,
offset=10.0,
duration=10.0)
# computing STFT based spectrogram for a respective time series audio data
stft = STFT(n_fft=1024, hop_length=32, sr=7000)
spectrogram = stft.compute_spectrogram_magnitude_in_db(audio_data=audio_data)
# extracting spectral peaks from STFT based spectrogram
peak_extractor = PeakExtractor(maximum_filter_height=75,
maximum_filter_width=150)
spectral_peaks = peak_extractor.spectral_peaks(spectrogram=spectrogram)
print(spectral_peaks[0])
SAMPLING_RATE = 7000
# a source directory for all reference audios
src_dir = "../../../Test_Data/Reference_Audios"
# retrieving all reference audios under specified source directory
reference_audios = dir_manager.find_mp3_files(src_dir=src_dir)
# Declaring an object for Short Time Fourier Transform (STFT)
stft = STFT(n_fft=1024, hop_length=32, sr=7000)
# Spectral peak extractor object
peak_extractor = PeakExtractor(maximum_filter_width=150, maximum_filter_height=75)
# Fingerprint generator object
fingerprint_generator = FingerprintGenerator(
frames_per_second=219,
target_zone_width=1,
target_zone_center=2,
number_of_quads_per_second=9,
tolerance=0.31)
# reading 10 second audio data sampled at 7KHz
audio_data = audio_manager.load_audio(audio_path=reference_audios[0], sr=SAMPLING_RATE, offset=10.0, duration=10.0)
# computing spectrogram of times series audio data.
spectrogram = stft.compute_spectrogram_magnitude_in_db(audio_data=audio_data)
print(spectrogram)
# extracting spectral peaks from the spectrogram of the audio.
spectral_peaks = peak_extractor.extract_spectral_peaks(spectrogram=spectrogram)
print(spectral_peaks)
# generate audio fingerprints
audio_fingerprints = fingerprint_generator.generate_fingerprints(
spectral_peaks=spectral_peaks[0],
spectrogram=spectrogram)
print(audio_fingerprints)
tempo information's.
'''
peak_extractor = PeakExtractor(maximum_filter_width=150,
maximum_filter_height=75)
'''
Instantiating a fingerprint generator object. A fingerprint generator function will accept
spectral peaks extracted from STFT based spectrogram of an audio and it will return audio
fingerprints generated using the association of four spectral peaks.
'''
fingerprint_generator = FingerprintGenerator(target_zone_width=1,
target_zone_center=2,
tolerance=0.31)
for i in query_audios:
audio_data = audio_manager.load_audio(audio_path=i,
offset=0.0,
duration=5.0)
spectrogram = stft.compute_spectrogram_magnitude_in_db(
audio_data=audio_data)
spectral_peaks = peak_extractor.spectral_peaks(spectrogram=spectrogram)
audio_fingerprints = fingerprint_generator.generate_fingerprints(
spectral_peaks=spectral_peaks[0])
# print(audio_fingerprints)
match_in_bins = match_fingerprints.match_fingerprints(
raw_data_index=raw_data_index,
rtree_index=r_tree_index,
fingerprints=audio_fingerprints,
tolerance=0.0)
match = verify_matches.verify_matches(matches_in_bins=match_in_bins)
print(i, match)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
"""
from Utilities import directory_manager
from Utilities import file_manager
from Utilities import audio_manager
from EffectsManager import effects_manager
# directory path for full length reference audios
source_dir = "../../Test_Data/Reference_Audios"
# directory path for short snippet reference audios
dist_dir = "../../Test_Data/Ref_Audios/"
# reference audios
reference_audios = directory_manager.find_mp3_files(source_dir=source_dir)
for i in reference_audios[0:10]:
audio_name = i.split("/")[4].split(".")[0]
# reading only 5 second audio duration
audio_excerpt, sr = audio_manager.load_audio(audio_path=i, offset=10.0, duration=5.0)
# saving the 5 second audio duration
audio_manager.save_audio(audio_path=dist_dir + audio_name + ".wav", audio_data=audio_excerpt, sr=sr)
