def info_audiofile_sloppy(fp):
info = {}
info['duration'] = af.duration(fp, sloppy=True)
info['samples'] = af.samples(fp)
info['channels'] = af.channels
info['sampling_rate'] = af.sampling_rate
return info
def make_noise(text_length, filename):
# checking audio file to match with
nb_samples = audiofile.samples(filename)
sampling_rate = audiofile.sampling_rate(filename) # in Hz
# Generate random logarithmic noise
noise = np.random.lognormal(0, 1, nb_samples)
noise /= np.amax(np.abs(noise))
# Filter with bandpass filter
nyq = 0.5 * sampling_rate
low = text_length / nyq
high = (50 + text_length) / nyq
order = 1
b, a = signal.butter(order, [low, high], btype="band")
filtered_noise = signal.lfilter(b, a, noise)
# create Gaussian enveloppe
t = np.linspace(start=-0.5, stop=0.5, num=nb_samples, endpoint=False)
i, e = signal.gausspulse(t, fc=5, retenv=True, bwr=-6.0)
out_signal = np.multiply(filtered_noise, e)
out_signal *= 30
# write audio file
audiofile.write(filename + ".noise.wav", out_signal, sampling_rate)
print("text length was :", text_length)
def test_broken_file(non_audio_file):
# Only match the beginning of error message
# as the default soundfile message differs at the end on macOS
error_msg = 'Error opening'
# Reading file
with pytest.raises(RuntimeError, match=error_msg):
af.read(non_audio_file)
# Metadata
if audeer.file_extension(non_audio_file) == 'wav':
with pytest.raises(RuntimeError, match=error_msg):
af.bit_depth(non_audio_file)
else:
assert af.bit_depth(non_audio_file) is None
with pytest.raises(RuntimeError, match=error_msg):
af.channels(non_audio_file)
with pytest.raises(RuntimeError, match=error_msg):
af.duration(non_audio_file)
with pytest.raises(RuntimeError, match=error_msg):
af.samples(non_audio_file)
with pytest.raises(RuntimeError, match=error_msg):
af.sampling_rate(non_audio_file)
def test_empty_file(empty_file):
# Reading file
signal, sampling_rate = af.read(empty_file)
assert len(signal) == 0
# Metadata
for sloppy in [True, False]:
assert af.duration(empty_file, sloppy=sloppy) == 0.0
assert af.channels(empty_file) == 1
assert af.sampling_rate(empty_file) == sampling_rate
assert af.samples(empty_file) == 0
if audeer.file_extension(empty_file) == 'wav':
assert af.bit_depth(empty_file) == 16
else:
assert af.bit_depth(empty_file) is None
def test_mp3(tmpdir, magnitude, sampling_rate, channels):
# Currently we are not able to setup the Windows runner with MP3 support
# https://github.com/audeering/audiofile/issues/51
if sys.platform == 'win32':
return
signal = sine(magnitude=magnitude,
sampling_rate=sampling_rate,
channels=channels)
# Create wav file and use sox to convert to mp3
wav_file = str(tmpdir.join('signal.wav'))
mp3_file = str(tmpdir.join('signal.mp3'))
af.write(wav_file, signal, sampling_rate)
subprocess.call(['sox', wav_file, mp3_file])
assert audeer.file_extension(mp3_file) == 'mp3'
sig, fs = af.read(mp3_file)
assert_allclose(_magnitude(sig), magnitude, rtol=0, atol=tolerance(16))
assert fs == sampling_rate
assert _channels(sig) == channels
if channels == 1:
assert sig.ndim == 1
else:
assert sig.ndim == 2
assert af.channels(mp3_file) == _channels(sig)
assert af.sampling_rate(mp3_file) == sampling_rate
assert af.samples(mp3_file) == _samples(sig)
assert af.duration(mp3_file) == _duration(sig, sampling_rate)
assert af.duration(mp3_file,
sloppy=True) == sox.file_info.duration(mp3_file)
assert af.bit_depth(mp3_file) is None
# Test additional arguments to read with sox
offset = 0.1
duration = 0.5
sig, fs = af.read(mp3_file, offset=offset, duration=duration)
assert _duration(sig, sampling_rate) == duration
sig, fs = af.read(mp3_file, offset=offset)
# Don't test for 48000 Hz and 2 channels
# https://github.com/audeering/audiofile/issues/23
if not (sampling_rate == 48000 and channels == 2):
assert_allclose(
_duration(sig, sampling_rate),
af.duration(mp3_file) - offset,
rtol=0,
atol=tolerance('duration', sampling_rate),
)
def test_formats():
files = [
'gs-16b-1c-44100hz.opus',
'gs-16b-1c-8000hz.amr',
'gs-16b-1c-44100hz.m4a',
'gs-16b-1c-44100hz.aac',
]
header_durations = [ # as given by mediainfo
15.839,
15.840000,
15.833,
None,
]
files = [os.path.join(ASSETS_DIR, f) for f in files]
for file, header_duration in zip(files, header_durations):
signal, sampling_rate = af.read(file)
assert af.channels(file) == _channels(signal)
assert af.sampling_rate(file) == sampling_rate
assert af.samples(file) == _samples(signal)
duration = _duration(signal, sampling_rate)
assert af.duration(file) == duration
if header_duration is None:
# Here we expect samplewise precision
assert af.duration(file, sloppy=True) == duration
else:
# Here we expect limited precision
# as the results differ between soxi and mediainfo
precision = 1
sloppy_duration = round(af.duration(file, sloppy=True), precision)
header_duration = round(header_duration, precision)
assert sloppy_duration == header_duration
assert af.bit_depth(file) is None
if file.endswith('m4a'):
# Test additional arguments to read with ffmpeg
offset = 0.1
duration = 0.5
sig, fs = af.read(file, offset=offset, duration=duration)
assert _duration(sig, sampling_rate) == duration
sig, fs = af.read(file, offset=offset)
assert _duration(sig, sampling_rate) == af.duration(file) - offset
import numpy as np from scipy import signal import audiofile # coming from generate.py text_length = 5000 filmename = "test_1.wav" # checking files nb_samples = audiofile.samples(filmename) sampling_rate = audiofile.sampling_rate(filmename) # in Hz # Generate random noise noise = np.random.lognormal(0, 1, nb_samples) noise /= np.amax(np.abs(noise)) # Filter with bandpass filter nyq = 0.5 * sampling_rate low = text_length / nyq high = (50 + text_length) / nyq order = 1 b, a = signal.butter(order, [low, high], btype='band') filtered_noise = signal.lfilter(b, a, noise) # create Gaussian enveloppe #t = np.linspace(start=-0.5,stop=0.5, num=nb_samples, endpoint=False) #i, e = signal.gausspulse(t, fc=5, retenv=True, bwr=-6.0) #out_signal = np.multiply(filtered_noise, e) #out_signal *= 0.3 #out_signal = i
def test_wav(tmpdir, bit_depth, duration, sampling_rate, channels, always_2d):
file = str(tmpdir.join('signal.wav'))
signal = sine(duration=duration,
sampling_rate=sampling_rate,
channels=channels)
sig, fs = write_and_read(
file,
signal,
sampling_rate,
bit_depth=bit_depth,
always_2d=always_2d,
)
# Expected number of samples
samples = int(np.ceil(duration * sampling_rate))
# Compare with sox implementation to check write()
assert_allclose(sox.file_info.duration(file),
duration,
rtol=0,
atol=tolerance('duration', sampling_rate))
assert sox.file_info.sample_rate(file) == sampling_rate
assert sox.file_info.channels(file) == channels
assert sox.file_info.num_samples(file) == samples
assert sox.file_info.bitdepth(file) == bit_depth
# Compare with signal values to check read()
assert_allclose(_duration(sig, fs),
duration,
rtol=0,
atol=tolerance('duration', sampling_rate))
assert fs == sampling_rate
assert _channels(sig) == channels
assert _samples(sig) == samples
# Test audiofile metadata methods
assert_allclose(af.duration(file),
duration,
rtol=0,
atol=tolerance('duration', sampling_rate))
assert af.sampling_rate(file) == sampling_rate
assert af.channels(file) == channels
assert af.samples(file) == samples
assert af.bit_depth(file) == bit_depth
# Test types of audiofile metadata methods
assert type(af.duration(file)) is float
assert type(af.sampling_rate(file)) is int
assert type(af.channels(file)) is int
assert type(af.samples(file)) is int
# Test dimensions of array
if channels == 1 and not always_2d:
assert sig.ndim == 1
else:
assert sig.ndim == 2
# Test additional arguments to read
if sampling_rate > 100:
offset = 0.001
duration = duration - 2 * offset
sig, fs = af.read(
file,
offset=offset,
duration=duration,
always_2d=always_2d,
)
assert _samples(sig) == int(np.ceil(duration * sampling_rate))