def encode_mp3(wav,
path,
bitrate=320,
samplerate=44100,
channels=2,
verbose=False):
try:
import lameenc
except ImportError:
print(
"Failed to call lame encoder. Maybe it is not installed? "
"On windows, run `python.exe -m pip install -U lameenc`, "
"on OSX/Linux, run `python3 -m pip install -U lameenc`, "
"then try again.",
file=sys.stderr)
sys.exit(1)
encoder = lameenc.Encoder()
encoder.set_bit_rate(bitrate)
encoder.set_in_sample_rate(samplerate)
encoder.set_channels(channels)
encoder.set_quality(2) # 2-highest, 7-fastest
if not verbose:
encoder.silence()
wav = wav.transpose(0, 1).numpy()
mp3_data = encoder.encode(wav.tobytes())
mp3_data += encoder.flush()
with open(path, "wb") as f:
f.write(mp3_data)
def save_loop(self, start_offset, loop_offset, output_path,
loop_seconds, should_add_loop_end):
encoder = lameenc.Encoder()
encoder.set_in_sample_rate(self.rate)
encoder.set_channels(self.channels)
encoder.set_bit_rate(320)
encoder.set_quality(2)
frames_to_write = round(loop_seconds * self.frames_per_sec)
progress = tqdm(total=frames_to_write, unit="frames")
with open(output_path, 'wb') as file:
i = 0
# NOTE some precision on the buffer's length might help
for _ in range(frames_to_write):
file.write(encoder.encode(self.frames[i]))
progress.update(1)
i += 1
if i == loop_offset:
i = start_offset
if should_add_loop_end:
while i < len(self.frames):
file.write(encoder.encode(self.frames[i]))
progress.update(1)
i += 1
file.write(encoder.flush())
def input(self, source) -> None:
"""
Set the input for this output
:param source: The input to set or None to clear
"""
if self._input is source:
return
if self._input is not None:
self._input.remove_callback(self._input_callback)
if self._encoder is not None:
if source is not None and source.channels != self._channels:
try:
self.notify_callbacks(self._encoder.flush())
except RuntimeError:
# If the encoder hasn't encoded anything, it's fine
pass
self._encoder = None
self._input = None
if source is not None:
if self._encoder is None:
try:
self._encoder = lameenc.Encoder()
self._encoder.set_channels(source.channels)
self._encoder.set_quality(self._quality)
self._encoder.set_bit_rate(self._bit_rate)
self._channels = source.channels
except:
self._encoder = None
raise
self._input = source
self._input.add_callback(self._input_callback)
def __init__(self, global_config, encoderQ, writerQ, thread_control):
threading.Thread.__init__(self)
self.thread_control = thread_control
self.encoderQ = encoderQ
self.writerQ = writerQ
self.BITRATE = 192
self.SAMPLERATE = int(
global_config.get('input', 'Rate', fallback='44100'))
self.CHANNELS = int(
global_config.get('input', 'Channels', fallback='1'))
self.QUALITY = 2
if 'encoding' in global_config:
config = global_config['encoding']
self.BITRATE = config.getint('BitRate', self.BITRATE)
self.SAMPLERATE = config.getint('SampleRate', self.SAMPLERATE)
self.CHANNELS = config.getint('Channels', self.CHANNELS)
self.QUALITY = config.getint('Quality', self.QUALITY)
self.encoder = lameenc.Encoder()
self.encoder.set_bit_rate(self.BITRATE)
self.encoder.set_in_sample_rate(self.SAMPLERATE)
self.encoder.set_channels(self.CHANNELS)
self.encoder.set_quality(self.QUALITY)
print("initialized MP3 Encoder %dkbps,%dkHz,%d channels,%d quality" %
(self.BITRATE, self.SAMPLERATE, self.CHANNELS, self.QUALITY))
def create_mp3_encoder(args, audio_params):
mp3_encoder = lameenc.Encoder()
mp3_encoder.set_bit_rate(args.mp3_compression_bit_rate)
mp3_encoder.set_in_sample_rate(audio_params.sample_rate_hz)
mp3_encoder.set_channels(1)
mp3_encoder.set_quality(args.mp3_compression_quality)
return mp3_encoder
def write_replacement(path, encoding, n_samples, n_channels, sample_rate):
destination = os.path.join(out_dir, path)
destination_dir = os.path.split(destination)[0]
os.makedirs(destination_dir, exist_ok=True)
sample_width = 2 # 16 bit
samples = bytes(n_samples * n_channels * sample_width)
# Generate a silent WAV file in memory.
with io.BytesIO() as f:
wav = wave.open(f, mode='wb')
wav.setnchannels(n_channels)
wav.setframerate(sample_rate)
wav.setsampwidth(sample_width)
wav.writeframes(samples)
wav.close()
f.seek(0)
wav_data = f.read()
if encoding == 'mp3':
encoder = lameenc.Encoder()
encoder.set_bit_rate(64)
encoder.set_in_sample_rate(sample_rate)
encoder.set_channels(n_channels)
encoder.set_quality(7) # 2-highest, 7-fastest
mp3_data = encoder.encode(wav_data) + encoder.flush()
with open(destination, 'wb') as f:
f.write(mp3_data)
elif encoding == 'wav':
with open(destination, 'wb') as f:
f.write(wav_data)
else:
print(f"Unknown encoding for {path}. Skipped!")
def encode_mp3(wav, path, samplerate=44100, bitrate=320, verbose=False):
"""Save given audio as mp3. This should work on all OSes."""
C, T = wav.shape
wav = i16_pcm(wav)
encoder = lameenc.Encoder()
encoder.set_bit_rate(bitrate)
encoder.set_in_sample_rate(samplerate)
encoder.set_channels(C)
encoder.set_quality(2) # 2-highest, 7-fastest
if not verbose:
encoder.silence()
wav = wav.transpose(0, 1).numpy()
mp3_data = encoder.encode(wav.tobytes())
mp3_data += encoder.flush()
with open(path, "wb") as f:
f.write(mp3_data)
def apply_lameenc(self, samples, sample_rate):
try:
import lameenc
except ImportError:
print(
"Failed to import the lame encoder. Maybe it is not installed? "
"To install the optional lameenc dependency of audiomentations,"
" do `pip install audiomentations[extras]` instead of"
" `pip install audiomentations`",
file=sys.stderr,
)
raise
assert len(samples.shape) == 1
assert samples.dtype == np.float32
int_samples = convert_float_samples_to_int16(samples)
encoder = lameenc.Encoder()
encoder.set_bit_rate(self.parameters["bitrate"])
encoder.set_in_sample_rate(sample_rate)
encoder.set_channels(1)
encoder.set_quality(7) # 2 = highest, 7 = fastest
encoder.silence()
mp3_data = encoder.encode(int_samples.tobytes())
mp3_data += encoder.flush()
# Write a temporary MP3 file that will then be decoded
tmp_dir = tempfile.gettempdir()
tmp_file_path = os.path.join(
tmp_dir, "tmp_compressed_{}.mp3".format(str(uuid.uuid4())[0:12])
)
with open(tmp_file_path, "wb") as f:
f.write(mp3_data)
degraded_samples, _ = librosa.load(tmp_file_path, sample_rate)
os.unlink(tmp_file_path)
return degraded_samples
def encode_mp3(wav, path, sr, verbose=False):
try:
import lameenc
except ImportError:
print(
"Failed to call lame encoder. Maybe it is not installed? "
"On windows, run `python.exe -m pip install -U lameenc`, "
"on OSX/Linux, run `python3 -m pip install -U lameenc`, "
"then try again.",
file=sys.stderr)
sys.exit(1)
encoder = lameenc.Encoder()
encoder.set_bit_rate(320)
encoder.set_in_sample_rate(sr)
encoder.set_channels(1)
encoder.set_quality(2) # 2-highest, 7-fastest
if not verbose:
encoder.silence()
#wav = wav * 2**15
mp3_data = encoder.encode(wav.tostring())
mp3_data += encoder.flush()
with open(path, "wb") as f:
f.write(mp3_data)
def input(self, source) -> None:
"""
Set the input for this output
:param source: The input to set or None to clear
"""
if self._input is source:
return
if self._input is not None:
self._input.remove_callback(self._input_callback)
if self._encoder is not None:
self.notify_callbacks(self._encoder.flush())
self._encoder = None
self._input = None
if source is not None:
try:
self._encoder = lameenc.Encoder()
self._encoder.set_channels(source.channels)
self._encoder.set_quality(self._quality)
self._encoder.set_bit_rate(self._bit_rate)
except:
self._encoder = None
raise
self._input = source
self._input.add_callback(self._input_callback)