def initSeparator(separator_params):
start_time = time.time()
from spleeter.separator import Separator
filename = separator_params['filename']
file_directory = separator_params['foldername']
print('---> processing ' + filename)
separator = Separator(separator_params['stems'])
codec = separator_params['codec']
separator.separate_to_file(filename,
file_directory,
codec=codec,
synchronous=False)
separator.join()
finish_time = time.time()
total = finish_time - start_time
print('---> Process finished in ' + str(total))
print('---> Files added to ' + file_directory)
print('---> Finishing program...')
separator._get_session().close()
os.startfile(file_directory)
return True
class SpleeterSeparator:
"""Performs source separation using Spleeter API."""
def __init__(self, cpu_separation: bool, bitrate=256):
"""Default constructor.
:param config: Separator config, defaults to None
"""
self.audio_bitrate = f'{bitrate}k'
self.audio_format = 'mp3'
self.sample_rate = 44100
self.spleeter_stem = 'config/4stems-16kHz.json'
self.separator = Separator(self.spleeter_stem,
stft_backend=STFTBackend.LIBROSA if
cpu_separation else STFTBackend.TENSORFLOW,
multiprocess=False)
self.audio_adapter = AudioAdapter.default()
def create_static_mix(self, parts, input_path, output_path):
"""Creates a static mix by performing source separation and adding the
parts to be kept into a single track.
:param parts: List of parts to keep ('vocals', 'drums', 'bass', 'other')
:param input_path: Path to source file
:param output_path: Path to output file
:raises e: FFMPEG error
"""
waveform, _ = self.audio_adapter.load(input_path,
sample_rate=self.sample_rate)
prediction = self.separator.separate(waveform)
out = np.zeros_like(prediction['vocals'])
part_count = 0
# Add up parts that were requested
for key in prediction:
if parts[key]:
out += prediction[key]
part_count += 1
self.audio_adapter.save(output_path, out, self.sample_rate,
self.audio_format, self.audio_bitrate)
def separate_into_parts(self, input_path, output_path):
"""Creates a dynamic mix
:param input_path: Input path
:param output_path: Output path
"""
self.separator.separate_to_file(input_path,
output_path,
self.audio_adapter,
codec='mp3',
duration=None,
bitrate=self.audio_bitrate,
filename_format='{instrument}.{codec}',
synchronous=False)
self.separator.join(600)
def splitfiles(source, filename):
import warnings
warnings.filterwarnings('ignore')
from spleeter.separator import Separator
stem = '2stems'
separator = Separator(f'spleeter:{stem}')
output_folder = source
song = source + '\\' + filename
separator.separate_to_file(song, output_folder, synchronous=False)
separator.join()
def extractAudioTracks(request_filename):
request_id = request_filename.split('.')[0]
upload_path = os.path.join(os.getcwd(), app.config['UPLOAD_FOLDER'],
request_filename)
output_path = os.path.join('/tmp/out/')
cache.set(request_id, 'PROCESSING')
separator = Separator('spleeter:5stems')
try:
separator.separate_to_file(upload_path, output_path)
separator.join()
except SpleeterError as error:
print('Errored during separation')
cache.set(request_id, 'ERROR;PROCESSING')
return
Process(target=uploadTracks, args=(
request_id,
output_path,
upload_path,
)).start()
def asyncSpleet(instance):
try:
audio_descriptors = ['media/'+str(instance.media.name)]
# Using embedded configuration.
separator = Separator('spleeter:2stems')
for i in audio_descriptors:
separator.separate_to_file(
i, 'media/', codec='mp3', synchronous=False)
separator.join()
except FileExistsError:
audio_descriptors = ['media/'+str(instance.media.name)]
# Using embedded configuration.
separator = Separator('spleeter:2stems')
for i in audio_descriptors:
separator.separate_to_file(
i, 'media/', codec='mp3', synchronous=False)
separator.join()
def main(file_path, output_dir, use_MWF):
st = time.time()
separator = Separator('spleeter:4stems', MWF=use_MWF)
# List of input to process.
audio_descriptors = glob.glob(os.path.join(file_path, '*.mp3'))
print('total {} songs to process'.format(len(audio_descriptors)))
random.shuffle(audio_descriptors)
# Batch separation export.
count = 0
for i in audio_descriptors:
print('=' * 100)
print(i)
PROCESS = check_done_or_not(i, output_dir)
print('PROCESS:', PROCESS)
if PROCESS:
try:
separator.separate_to_file(i, output_dir, synchronous=True)
except Exception as e:
# print(e)
error_class = e.__class__.__name__ #取得錯誤類型
detail = e.args[0] #取得詳細內容
cl, exc, tb = sys.exc_info() #取得Call Stack
lastCallStack = traceback.extract_tb(tb)[
-1] #取得Call Stack的最後一筆資料
fileName = lastCallStack[0] #取得發生的檔案名稱
lineNum = lastCallStack[1] #取得發生的行號
funcName = lastCallStack[2] #取得發生的函數名稱
errMsg = "File \"{}\", line {}, in {}: [{}] {}".format(
fileName, lineNum, funcName, error_class, detail)
print(errMsg)
count += 1
else:
print('Already processed:', i)
ed = time.time()
# Wait for batch to finish.
separator.join()
print('total spend {}s for {} song. average: {}s'.format(
ed - st, count, (ed - st) / count))
class SpleeterSeparator:
"""Performs source separation using Spleeter API."""
def __init__(self, config=None):
"""Default constructor.
:param config: Separator config, defaults to None
"""
if config is None:
self.audio_bitrate = '256k'
self.audio_format = 'mp3'
self.sample_rate = 44100
self.spleeter_stem = 'config/4stems-16kHz.json'
else:
self.audio_bitrate = config['audio_bitrate']
self.audio_format = config['audio_format']
self.sample_rate = config['sample_rate']
self.spleeter_stem = config['spleeter_stem']
# Use librosa backend as it is less memory intensive
self.separator = Separator(self.spleeter_stem,
stft_backend='librosa',
multiprocess=False)
self.audio_adapter = get_default_audio_adapter()
def create_static_mix(self, parts, input_path, output_path):
"""Creates a static mix by performing source separation and adding the
parts to be kept into a single track.
:param parts: List of parts to keep ('vocals', 'drums', 'bass', 'other')
:param input_path: Path to source file
:param output_path: Path to output file
:raises e: FFMPEG error
"""
waveform, _ = self.audio_adapter.load(input_path,
sample_rate=self.sample_rate)
prediction = self.separator.separate(waveform)
out = np.zeros_like(prediction['vocals'])
part_count = 0
# Add up parts that were requested
for key in prediction:
if parts[key]:
out += prediction[key]
part_count += 1
self.audio_adapter.save(output_path, out, self.separator._sample_rate,
self.audio_format, self.audio_bitrate)
def separate_into_parts(self, input_path, output_path):
"""Creates a dynamic mix
:param input_path: [description]
:type input_path: [type]
:param output_path: [description]
:type output_path: [type]
"""
self.separator.separate_to_file(input_path,
output_path,
self.audio_adapter,
codec='mp3',
bitrate=self.audio_bitrate,
filename_format='{instrument}.{codec}',
synchronous=False)
self.separator.join(600)
