def test_time_to_frame_ind(self):
sample_rate = 22050
win_size = 256
hop_size = 128
fc = feature_container.FeatureContainer("fake_audio_path", sample_rate,
win_size, hop_size)
assert fc.time_to_frame_ind(0.015) == 2
def test_features_empty_features(self):
features = ["feat1", "feat2"]
configs = ["config1", "config2"]
fc = feature_container.FeatureContainer("fake_audio_path", 22050, 256,
128)
fc.features["feat1"]["data"] = np.random.sample(10)
fc.features["feat1"]["config"] = "config1"
fc.features["feat2"]["config"] = "config2"
assert not all(fc.has_features(list(zip(features, configs))))
def execute(self, audio_path):
""" Executes the feature extractors.
Args:
audio_path (tuple of str): path of the audio file to process, as a
tuple (audio root, audio path relative to audio root).
Example: ('/some/path', 'somefile.wav')
Returns:
A tuple (Featurecontainer, boolean) containing, respectively, the
feature container and whether it has been created or not.
"""
if not isinstance(audio_path, tuple):
raise exceptions.ParameterError(
'The first argument must be a tuple' +
'<audio path root>, <audio relative path>)')
fc = None
has_features = [False for fe in self._feature_extractors]
if self._feature_container_root:
feature_container_path = os.path.join(
self._feature_container_root,
os.path.splitext(audio_path[1])[0] +
feature_container.FC_EXTENSION)
fc = feature_container.FeatureContainer.load(
feature_container_path)
# check if feature container exists and has all required features
if fc:
has_features = fc.has_features([(fe.name, fe.config) \
for fe in self._feature_extractors])
if all(has_features):
logger.debug(
'Feature container %s with all required features found!',
feature_container_path)
return fc, False
info = audio.info(os.path.join(*audio_path))
n_samples = int((info.frames - self._audio_frame_gen._win_size) /
self._audio_frame_gen._hop_size) + 1
if not fc or not any(has_features):
# if fc has none of the desired features, create a new one
fc = feature_container.FeatureContainer(
audio_path[1], info.samplerate,
self._audio_frame_gen._win_size,
self._audio_frame_gen._hop_size)
compute_spectrum = False
compute_power_spectrum = False
for fe in self._feature_extractors:
# allocate memory for features
fc.features[fe.name]["data"] = np.empty((n_samples, fe.size),
dtype="float32")
fc.features[fe.name]["config"] = fe.config
# check what to compute
if isinstance(fe, ffe.SpectrumFrameFeatureExtractor):
compute_spectrum = True
elif isinstance(fe, ffe.PowerSpectrumFrameFeatureExtractor):
compute_spectrum = True
compute_power_spectrum = True
frame_gen = self._audio_frame_gen.execute(os.path.join(*audio_path))
for i, frame in enumerate(frame_gen):
if compute_spectrum:
spectrum = np.abs(np.fft.rfft(frame))
if compute_power_spectrum:
power_spectrum = spectrum**2
for fe in compress(self._feature_extractors,
[not hf for hf in has_features]):
if isinstance(fe, ffe.AudioFrameFeatureExtractor):
fc.features[fe.name]["data"][i] = \
fe.execute(frame)
elif isinstance(fe, ffe.SpectrumFrameFeatureExtractor):
fc.features[fe.name]["data"][i] = \
fe.execute(spectrum)
elif isinstance(fe, ffe.PowerSpectrumFrameFeatureExtractor):
fc.features[fe.name]["data"][i] = \
fe.execute(power_spectrum)
# if feature_container_root is set, write feature container
if self._feature_container_root:
fc.save(self._feature_container_root)
return fc, True
def test_init(self):
try:
feature_container.FeatureContainer("fake_audio_path", 22050, 256,
128)
except:
pytest.fail("Unexpected Error")