No OneTemporary
Actions

Size

37 KB

Subscribers

None

View Options

	diff --git a/AutoCoverTool/online/inference_one.py b/AutoCoverTool/online/inference_one.py
	index c49d449..570d4a0 100644
	--- a/AutoCoverTool/online/inference_one.py
	+++ b/AutoCoverTool/online/inference_one.py
	@@ -1,677 +1,682 @@
	"""
	单个处理的逻辑
	song_id:
	---src.mp3 // 源数据，需要提前放进去
	---cache
	---vocal.wav // 分离之后产生
	---acc.wav // 分离之后产生
	---vocal_32.wav // 分离之后产生
	---song_id_sp1.wav // 合成之后产生
	---song_id_sp2.wav // 合成之后产生
	---song_id_sp2_d.wav // 降噪之后生成
	---song_id_sp2_dv.wav // 降噪+拉伸之后产生 [占比太高的不产生]
	---song_id_sp2_dve442.wav // 手动调整之后产生
	---song_id_sp2_dve442_replace.wav // 替换之后产生
	---song_id_sp2_dve442_replace_mix.wav // 人声+伴奏混合之后产生
	---song_id
	--acc.mp3 // 44k双声道320k
	--vocal.mp3 // 44k双声道320k
	--src.mp3 // 44k双声道320k
	--song_id_sp2_dv.mp3 // 44k单声道320k
	---song_id_out // 对外输出
	--src.mp3 // 原始音频
	--song_id_sp2_dv_replace_mix.mp3 // 制作完成的音频

	环境安装:
	conda create -n auto_song_cover python=3.9
	# 安装demucs环境[进入到ref.music_remover 执行pip install -r requirements.txt]
	# 安装so_vits_svc环境[进入到ref.so_vits_svc 执行pip install -r requirements.txt]
	pip install librosa
	pip install scikit-maad
	pip install praat-parselmouth
	pip install matplotlib
	pip install torchvision
	pip install madmom
	pip install torchstat
	环境设置:
	export PATH=$PATH:/data/gpu_env_common/env/bin/ffmpeg/bin
	export PYTHONPATH=$PWD:$PWD/ref/music_remover/demucs:$PWD/ref/so_vits_svc:$PWD/ref/split_dirty_frame
	"""

	import os
	import time
	import shutil
	import random
	import logging
	import librosa

	logging.basicConfig(filename='/tmp/inference.log', level=logging.INFO)

	gs_err_code_success = 0
	gs_err_code_no_src_mp3 = 1
	gs_err_code_separate = 2
	gs_err_code_trans_32 = 3
	gs_err_code_encode_err = 4
	gs_err_code_replace_err = 5
	gs_err_code_replace_trans_err = 6
	gs_err_code_mix_err = 7
	gs_err_code_mix_transcode_err = 8
	gs_err_code_no_src_dir = 9
	gs_err_code_volume_err = 10
	gs_err_code_trans2_442 = 11
	gs_err_code_reverb = 12
	gs_err_code_no_good_choice = 13
	gs_err_code_preprocess_vocal = 14
	+gs_err_code_replace_except_err = 15

	gs_denoise_exe = "/opt/soft/bin/denoise_exe"
	gs_draw_volume_exe = "/opt/soft/bin/draw_volume"
	gs_simple_mixer_path = "/opt/soft/bin/simple_mixer"
	gs_rever_path = "/opt/soft/bin/dereverbrate"

	from ref.music_remover.separate_interface import SeparateInterface
	from ref.so_vits_svc.inference_main import *
	from ref.split_dirty_frame.script.process_one import ReplaceVocalFrame, construct_power_fragment


	class SongCoverInference:
	def __init__(self):
	self.work_dir = None
	self.cache_dir = None
	self.cid = None
	self.src_mp3 = None
	self.vocal_path = None
	self.vocal_32_path = None
	self.acc_path = None
	self.speakers = [
	10414574138721494,
	10414574140317353,
	1688849864840588,
	3634463651,
	5629499489839033,
	5910973794723621,
	6755399374234747,
	8162774327817435,
	8162774329368194,
	1125899914308640, # 以下为男声,包括这个
	12384898975368914,
	12947848931397021,
	3096224748076687,
	3096224751151928,
	5066549357604730,
	5348024335101054,
	6755399442719465,
	7036874421386111
	]

	self.speakers2gender = {
	10414574138721494: 1,
	10414574140317353: 1,
	1688849864840588: 1,
	3634463651: 1,
	5629499489839033: 1,
	5910973794723621: 1,
	6755399374234747: 1,
	8162774327817435: 1,
	8162774329368194: 1,
	1125899914308640: 0, # 0是男
	12384898975368914: 0,
	12947848931397021: 0,
	3096224748076687: 0,
	3096224751151928: 0,
	5066549357604730: 0,
	5348024335101054: 0,
	6755399442719465: 0,
	7036874421386111: 0
	}
	self.speakers_model_path = "data/train_users/{}/logs/32k/G_2000.pth"
	self.speakers_model_config = "data/train_users/{}/config/config.json"

	st = time.time()
	self.separate_inst = None
	logging.info("post process ... ReplaceVocalFrame init sp={}".format(time.time() - st))
	self.replace_vocal_frame_inst = None
	logging.info("SongCoverInference init sp={}".format(time.time() - st))

	def separate(self, cid, src_mp3, vocal_path, acc_path):
	"""
	人声伴奏分离
	:param cid:
	:param src_mp3:
	:param vocal_path:
	:param acc_path:
	:return:
	"""
	st = time.time()
	if self.separate_inst is None:
	self.separate_inst = SeparateInterface()
	if not self.separate_inst.process(cid, src_mp3, vocal_path, acc_path):
	return gs_err_code_separate
	if not os.path.exists(vocal_path) or not os.path.exists(acc_path):
	return gs_err_code_separate

	# 转码出一个32k单声道的数据
	cmd = "ffmpeg -i {} -ar 32000 -ac 1 -y {} -loglevel fatal".format(vocal_path, self.vocal_32_path)
	os.system(cmd)
	if not os.path.exists(self.vocal_32_path):
	return gs_err_code_trans_32
	print("separate:cid={}\|sp={}".format(cid, time.time() - st))
	return gs_err_code_success

	def get_start_ms(self, vocal_path):
	"""
	给定原始音频，找一段连续10s的音频
	:param vocal_path:
	:return:
	"""
	audio, sr = librosa.load(vocal_path, sr=16000)
	audio = librosa.util.normalize(audio)
	# 帧长100ms,帧移10ms,计算能量
	power_arr = []
	for i in range(0, len(audio) - 1600, 160):
	power_arr.append(np.sum(np.abs(audio[i:i + 160])) / 160)
	# 将能量小于等于10的部分做成段
	power_arr = construct_power_fragment(power_arr)
	fragments = []
	last_pos = 0
	for idx, line in enumerate(power_arr):
	start = round(float(line[0]) * 0.01, 3)
	duration = round(float(line[1]) * 0.01, 3)
	fragments.append([last_pos, start - last_pos])
	last_pos = start + duration
	if last_pos < len(audio) / sr:
	fragments.append([last_pos, len(audio) / sr - last_pos])

	# 合并数据，两者间隔在50ms以内的合并起来
	idx = 0
	while idx < len(fragments) - 1:
	if fragments[idx + 1][0] - (fragments[idx][0] + fragments[idx][1]) < 0.05:
	fragments[idx][1] = fragments[idx + 1][0] + fragments[idx + 1][1] - fragments[idx][0]
	del fragments[idx + 1]
	idx -= 1
	idx += 1

	# out_file = vocal_path + "_power.csv"
	# with open(out_file, "w") as f:
	# f.write("Name\tStart\tDuration\tTime Format\tType\n")
	# for fragment in fragments:
	# start = round(float(fragment[0]), 3)
	# duration = round(float(fragment[1]), 3)
	# strr = "{}\t{}\t{}\t{}\n".format("11", start, duration, "decimal\tCue\t")
	# f.write(strr)

	# 筛选出开始的位置
	# 1. 连续时长大于10s，当前段长度大于3s
	# 2. 不可用
	# 从0到fragments[idx], 包含idx其中人声段的总和
	tot_vocal_duration = [fragments[0][1]]
	for i in range(1, len(fragments)):
	tot_vocal_duration.append(tot_vocal_duration[i - 1] + fragments[i][1])

	# 计算出任意两段之间非人声占比
	for i in range(0, len(fragments)):
	if fragments[i][1] >= 3:
	now_tot = 0
	if i > 0:
	now_tot = tot_vocal_duration[i - 1]
	for j in range(i + 1, len(fragments)):
	cur_rate = tot_vocal_duration[j] - now_tot
	cur_rate = cur_rate / (fragments[j][1] + fragments[j][0] - fragments[i][0])
	if cur_rate > 0.1:
	return fragments[i][0]
	return -1

	def inference_speaker(self):
	"""
	推理生成合成后的音频
	随机取5个干声,选择占比最小的，并且要求占比小于0.3
	:return:
	"""
	st = time.time()
	- out_speakers = random.sample(self.speakers, 5)
	+ out_speakers = random.sample(self.speakers, 15)
	out_songs_dict = {}
	for speaker in out_speakers:
	model_path = self.speakers_model_path.format(speaker)
	config_path = self.speakers_model_config.format(speaker)
	song_path = os.path.join(self.cache_dir, "{}_{}.wav".format(self.cid, speaker))
	try:
	inf(model_path, config_path, self.vocal_32_path, song_path, "prod")
	except Exception as ex:
	logging.info("cid={}, inference_speaker err={}".format(self.cid, ex))
	continue
	if os.path.exists(song_path):
	if self.replace_vocal_frame_inst is None:
	self.replace_vocal_frame_inst = ReplaceVocalFrame(
	"data/models/split_dirty_frame_v5_3_epoch3_852.pth")
	rate = self.replace_vocal_frame_inst.get_rate(song_path)
	if rate < 0.3:
	out_songs_dict[song_path] = rate

	# 从内部选择占比最低的
	out_songs = []
	if len(out_songs_dict.keys()) > 0:
	st_sec = self.get_start_ms(self.vocal_path)
	song_msg = sorted(out_songs_dict.items(), key=lambda kv: kv[1])[0]
	out_songs = [song_msg[0]]
	logging.info("GetRate:cid={},song={},rate={},st_tm={}".format(self.cid, song_msg[0], round(song_msg[1], 2),
	round(st_sec, 3)))
	print("GetRate:cid={},song={},rate={},st_tm={}".format(self.cid, song_msg[0], round(song_msg[1], 2),
	round(st_sec, 3)))
	# logging.info("inference_speaker len = {} finish sp = {}".format(len(out_songs), time.time() - st))
	print("inference_speaker len = {} finish sp = {}".format(len(out_songs), time.time() - st))
	return out_songs

	def get_new_vocal_rate(self, songs):
	"""
	获取人声的比率
	:param songs:
	:return:
	"""
	st = time.time()
	need_to_process_song = []
	for song in songs:
	if self.replace_vocal_frame_inst is None:
	self.replace_vocal_frame_inst = ReplaceVocalFrame("data/models/split_dirty_frame_v5_3_epoch3_852.pth")
	rate = self.replace_vocal_frame_inst.get_rate(song)
	logging.info("{} {} replace_rate={}".format(self.cid, song, rate))
	if rate < 1.0:
	need_to_process_song.append(song)
	logging.info(
	"get_new_vocal_rate belen = {} len = {} finish sp = {}".format(len(songs), len(need_to_process_song),
	time.time() - st))
	return need_to_process_song

	def preprocess_vocal(self, songs, vocal_path):
	"""
	1. 降噪
	2. 拉伸
	:param songs:
	:param vocal_path: 参考的音频信号
	:return:
	"""
	st = time.time()
	dv_out_list = []
	for song in songs:
	denoise_path = str(song).replace(".wav", "_d.wav")
	cmd = "{} {} {}".format(gs_denoise_exe, song, denoise_path)
	os.system(cmd)
	if not os.path.exists(denoise_path):
	print("{} {} ERROR denoise".format(self.cid, song))
	continue
	# 拉伸
	volume_path = str(song).replace(".wav", "_dv.wav")
	cmd = "{} {} {} {}".format(gs_draw_volume_exe, denoise_path, vocal_path, volume_path)
	os.system(cmd)
	if not os.path.exists(volume_path):
	print("{} {} ERROR denoise".format(self.cid, volume_path))
	continue
	dv_out_list.append(volume_path)
	print(
	"preprocess_vocal belen = {} len = {} finish sp = {}".format(len(songs), len(dv_out_list),
	time.time() - st))
	return dv_out_list

	def output(self, dv_out_list):
	"""
	对外输出数据
	:param dv_out_list:
	:return:
	"""
	st = time.time()
	out_dir = os.path.join(self.work_dir, self.cid)
	if os.path.exists(out_dir):
	shutil.rmtree(out_dir)
	os.makedirs(out_dir)

	# 拷贝数据
	dst_mp3_path = os.path.join(out_dir, "src_mp3")
	dst_acc_path = os.path.join(out_dir, "acc.mp3")
	dst_vocal_path = os.path.join(out_dir, "vocal.mp3")
	shutil.copyfile(self.src_mp3, dst_mp3_path)
	cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(self.acc_path, dst_acc_path)
	os.system(cmd)
	if not os.path.exists(dst_acc_path):
	return gs_err_code_encode_err
	cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(self.vocal_path, dst_vocal_path)
	os.system(cmd)
	if not os.path.exists(dst_vocal_path):
	return gs_err_code_encode_err

	# 将所有数据放到out_dir中，用于给人工标注
	for dv_wav in dv_out_list:
	dv_wav_name = str(dv_wav).split("/")[-1].replace(".wav", "_441.mp3")
	dst_dv_path = os.path.join(out_dir, dv_wav_name)

	cmd = "ffmpeg -i {} -ar 44100 -ac 1 -ab 320k -y {} -loglevel fatal".format(dv_wav, dst_dv_path)
	os.system(cmd)
	if not os.path.exists(dst_dv_path):
	print("{} encode err!".format(cmd))
	continue
	logging.info(
	"preprocess_vocal output sp = {}".format(time.time() - st))

	def process_one(self, cid, work_dir, enable_output=False):
	logging.info("\nstart:cid={},work_dir={}----------------------->>>>>>>>".format(cid, work_dir))
	self.cid = cid
	self.work_dir = work_dir

	# 所有不对外交付的，全部放到这里
	self.cache_dir = os.path.join(work_dir, "cache")
	if os.path.exists(self.cache_dir):
	shutil.rmtree(self.cache_dir)
	os.makedirs(self.cache_dir)

	self.src_mp3 = os.path.join(self.work_dir, "src.mp3")
	if not os.path.exists(self.src_mp3):
	return gs_err_code_no_src_mp3
	self.vocal_path = os.path.join(self.cache_dir, "vocal.wav")
	self.vocal_32_path = os.path.join(self.cache_dir, "vocal_32.wav")
	self.acc_path = os.path.join(self.cache_dir, "acc.wav")

	if not os.path.exists(self.vocal_32_path):
	logging.info("start separate ... {} {} {}".format(self.src_mp3, self.vocal_path, self.acc_path))
	err = self.separate(cid, self.src_mp3, self.vocal_path, self.acc_path)
	if err != gs_err_code_success:
	return err, None, None
	logging.info("start inference_speaker ...")
	out_songs = self.inference_speaker()
	dv_out_list = self.preprocess_vocal(out_songs, self.vocal_path)
	if len(dv_out_list) == 0:
	return gs_err_code_no_good_choice, None, None

	mix_mp3_path = None
	gender = -1
	if enable_output:
	self.output(dv_out_list)
	else:
	# 默认全部处理一遍
	for dv_out_path in dv_out_list:
	src_path = dv_out_path.replace("_dv.wav", ".wav")
	err, mix_mp3_path = self.after_process(self.cid, self.work_dir, src_path, dv_out_path, self.vocal_path,
	self.acc_path,
	True, False)
	if err != gs_err_code_success:
	logging.info("after_process err {}".format(err))

	# 取出性别属性
	if err == gs_err_code_success and mix_mp3_path is not None:
	gender = self.speakers2gender[int(str(os.path.basename(mix_mp3_path)).split("_")[1])]
	logging.info("finish:cid={},work_dir={}----------------------->>>>>>>>".format(cid, work_dir))
	return gs_err_code_success, mix_mp3_path, gender

	def reverb_by_vocal(self, file):
	st = time.time()
	file_442 = file.replace(".wav", "_442.wav")
	if not os.path.exists(file_442):
	cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {}".format(file, file_442)
	os.system(cmd)
	if not os.path.exists(file_442):
	return gs_err_code_trans2_442, None

	file_dst = file.replace(".wav", "_442_dr.wav")
	cmd = "{} {} {} {}".format(gs_rever_path, self.vocal_path, file_442, file_dst)
	os.system(cmd)
	if not os.path.exists(file_dst):
	return gs_err_code_reverb, None
	print("cid = {}, reverb_by_vocal sp={}".format(self.cid, time.time() - st))
	return gs_err_code_success, file_dst

	def after_process(self, cid, work_dir, in_file, effect_file, vocal_file, acc_file, need_draw=True,
	need_reverb=True):
	"""
	后处理逻辑
	将处理好的音频进行替换，然后和伴奏进行混合，最后进行编码
	:return:
	"""
	if need_reverb:
	# 抓取混响
	err, effect_file = self.reverb_by_vocal(in_file)
	if err != gs_err_code_success:
	return err, None

	if need_draw:
	# 增加一个拉伸的步骤
	volume_path = str(effect_file).replace(".wav", "_dv.wav")
	cmd = "{} {} {} {}".format(gs_draw_volume_exe, effect_file, vocal_file, volume_path)
	print(cmd)
	os.system(cmd)
	if not os.path.exists(volume_path):
	print("{} {} ERROR draw volume".format(self.cid, volume_path))
	return gs_err_code_volume_err, None
	effect_file = volume_path

	st = time.time()
	self.cid = cid
	self.work_dir = work_dir
	self.src_mp3 = os.path.join(self.work_dir, "src.mp3")
	if not os.path.exists(self.work_dir):
	return gs_err_code_no_src_dir
	self.replace_vocal_frame_inst.process(in_file, effect_file, vocal_file)
	dst_path = effect_file + "_replace.wav"
	if not os.path.exists(dst_path):
	return gs_err_code_replace_err, None
	print("replace_vocal_frame_inst sp = {}".format(time.time() - st))

	# 转码
	dst_path_442 = dst_path.replace("_replace.wav", "_replace442.wav")
	cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {} -loglevel fatal".format(dst_path, dst_path_442)
	os.system(cmd)
	if not os.path.exists(dst_path_442):
	return gs_err_code_replace_trans_err, None

	# 合并转码后再做一次拉伸，保证响度
	volume_path = str(dst_path_442).replace(".wav", "_dv.wav")
	cmd = "{} {} {} {}".format(gs_draw_volume_exe, dst_path_442, vocal_file, volume_path)
	print(cmd)
	os.system(cmd)
	if not os.path.exists(volume_path):
	print("{} {} ERROR draw volume".format(self.cid, volume_path))
	return gs_err_code_volume_err, None
	dst_path_442 = volume_path

	# 混合
	mix_path = dst_path_442.replace("_replace442.wav", "_replace442_mix.wav")
	cmd = "{} {} {} {}".format(gs_simple_mixer_path, dst_path_442, acc_file, mix_path)
	print("{}".format(cmd))
	os.system(cmd)
	if not os.path.exists(mix_path):
	return gs_err_code_mix_err, None

	# 编码为mp3
	output_dir = os.path.join(self.work_dir, self.cid + "_out")
	if not os.path.exists(output_dir):
	os.makedirs(output_dir)
	name = str(mix_path).replace("_replace442_mix.wav", "_replace442_mix.mp3").split("/")[-1]
	mix_path_mp3 = os.path.join(output_dir, name)
	cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(mix_path, mix_path_mp3)
	os.system(cmd)
	if not os.path.exists(mix_path_mp3):
	return gs_err_code_mix_transcode_err, None

	# 拷贝src到output_dir
	# shutil.copyfile(self.src_mp3, os.path.join(output_dir, "src.mp3"))
	# logging.info("after_process sp = {}".format(time.time() - st))
	return gs_err_code_success, mix_path_mp3

	####################################新对外接口############################################################
	def prepare_env(self, cid, work_dir, create_dir=False):
	self.cid = cid
	self.work_dir = work_dir

	# 所有不对外交付的，全部放到这里
	self.cache_dir = os.path.join(work_dir, "cache")
	if create_dir:
	if os.path.exists(self.cache_dir):
	shutil.rmtree(self.cache_dir)
	os.makedirs(self.cache_dir)

	self.src_mp3 = os.path.join(self.work_dir, "src.mp3")
	if not os.path.exists(self.src_mp3):
	return gs_err_code_no_src_mp3
	self.vocal_path = os.path.join(self.cache_dir, "vocal.wav")
	self.vocal_32_path = os.path.join(self.cache_dir, "vocal_32.wav")
	self.acc_path = os.path.join(self.cache_dir, "acc.wav")
	return gs_err_code_success

	def generate_svc_file(self, cid, work_dir):
	"""
	:param cid:
	:param work_dir:
	:return:err_code, 生成出的svc的文件名称
	"""
	err = self.prepare_env(cid, work_dir, create_dir=True)
	if err != gs_err_code_success:
	return err, None

	# 音源分离
	if not os.path.exists(self.vocal_32_path):
	st = time.time()
	err = self.separate(cid, self.src_mp3, self.vocal_path, self.acc_path)
	logging.info("cid={},separate,sp={}".format(self.cid, time.time() - st))
	if err != gs_err_code_success:
	return err, None

	# 生成svc,只保留一个最佳的
	st = time.time()
	out_songs = self.inference_speaker()
	if len(out_songs) == 0:
	return gs_err_code_no_good_choice, None
	logging.info("cid={},inference_speaker,{},sp={}".format(self.cid, out_songs[0], time.time() - st))

	# 预处理人声
	dv_out_list = self.preprocess_vocal(out_songs, self.vocal_path)
	if len(dv_out_list) == 0:
	return gs_err_code_preprocess_vocal, None
	return gs_err_code_success, dv_out_list[0]

	def effect(self, cid, work_dir, svc_file):
	st = time.time()
	err = self.prepare_env(cid, work_dir)
	if err != gs_err_code_success:
	return err, None
	logging.info("cid={},effect_and_mix,{},sp={}".format(self.cid, svc_file, time.time() - st))
	# 做音效
	st = time.time()
	err, effect_file = self.reverb_by_vocal(svc_file)
	if err != gs_err_code_success:
	return err, None
	logging.info("cid={},reverb_by_vocal,{},sp={}".format(self.cid, svc_file, time.time() - st))
	return err, effect_file

	def mix(self, cid, work_dir, svc_file, effect_file):
	"""
	做音效以及合并
	:param cid:
	:param work_dir:
	:param svc_file:
	:param effect_file:
	:return: err_code, 完成的mp3文件
	"""
	st = time.time()
	err = self.prepare_env(cid, work_dir)
	if err != gs_err_code_success:
	return err, None
	logging.info("cid={},effect_and_mix,{},sp={}".format(self.cid, svc_file, time.time() - st))

	# 拉伸
	st = time.time()
	volume_path = str(effect_file).replace(".wav", "_dv.wav")
	cmd = "{} {} {} {}".format(gs_draw_volume_exe, effect_file, self.vocal_path, volume_path)
	os.system(cmd)
	if not os.path.exists(volume_path):
	print("{} {} ERROR draw volume".format(self.cid, volume_path))
	return gs_err_code_volume_err, None
	effect_file = volume_path
	logging.info("cid={},draw_volume,{},sp={}".format(self.cid, svc_file, time.time() - st))

	# 替换
	st = time.time()
	- self.replace_vocal_frame_inst.process(svc_file, effect_file, self.vocal_path)
	+ try:
	+ self.replace_vocal_frame_inst.process(svc_file, effect_file, self.vocal_path)
	+ except Exception as ex:
	+ logging.info("{},replace_vocal_frame_inst, {}", self.cid, ex)
	+ return gs_err_code_replace_except_err, None
	dst_path = effect_file + "_replace.wav"
	if not os.path.exists(dst_path):
	return gs_err_code_replace_err, None
	logging.info("cid={},replace_vocal_frame_inst,{},sp={}".format(self.cid, svc_file, time.time() - st))

	# 转码
	st = time.time()
	dst_path_442 = dst_path.replace("_replace.wav", "_replace442.wav")
	cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {} -loglevel fatal".format(dst_path, dst_path_442)
	os.system(cmd)
	if not os.path.exists(dst_path_442):
	return gs_err_code_replace_trans_err, None
	logging.info("cid={},transcode,{},sp={}".format(self.cid, svc_file, time.time() - st))

	# 合并转码后再做一次拉伸，保证响度
	st = time.time()
	volume_path = str(dst_path_442).replace("_replace442.wav", "_replace442_dv.wav")
	cmd = "{} {} {} {}".format(gs_draw_volume_exe, dst_path_442, self.vocal_path, volume_path)
	os.system(cmd)
	if not os.path.exists(volume_path):
	print("{} {} ERROR draw volume".format(self.cid, volume_path))
	return gs_err_code_volume_err, None
	dst_path_442 = volume_path
	logging.info("cid={},draw_volume2,{},sp={}".format(self.cid, svc_file, time.time() - st))

	# 混合
	st = time.time()
	mix_path = dst_path_442.replace("_replace442_dv.wav", "_replace442_dv_mix.wav")
	cmd = "{} {} {} {}".format(gs_simple_mixer_path, dst_path_442, self.acc_path, mix_path)
	os.system(cmd)
	if not os.path.exists(mix_path):
	return gs_err_code_mix_err, None
	logging.info("cid={},mixer,{},sp={}".format(self.cid, svc_file, time.time() - st))

	# 编码为mp3
	st = time.time()
	output_dir = os.path.join(self.work_dir, self.cid + "_out")
	if not os.path.exists(output_dir):
	os.makedirs(output_dir)
	name = str(mix_path).replace("_replace442_dv_mix.wav", "_replace442_dv_mix.mp3").split("/")[-1]
	mix_path_mp3 = os.path.join(output_dir, name)
	cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(mix_path, mix_path_mp3)
	print(cmd)
	os.system(cmd)
	if not os.path.exists(mix_path_mp3):
	return gs_err_code_mix_transcode_err, None
	logging.info("cid={},encode,{},sp={}".format(self.cid, svc_file, time.time() - st))
	return gs_err_code_success, mix_path_mp3

	def get_gender(self, svc_file):
	return self.speakers2gender[int(os.path.basename(svc_file).split("_")[1])]

	def process_one_logic(self, cid, work_dir):
	"""
	搞成两部分:
	1. 分离数据+5次推理，获取最佳结果,并保存
	2. 利用最佳结果做音效以及合并
	:return:
	"""
	err, svc_file = self.generate_svc_file(cid, work_dir)
	gender = -1
	if err != gs_err_code_success:
	return err, svc_file, gender,
	gender = self.get_gender(svc_file)
	err, effect_file = self.effect(cid, work_dir, svc_file)
	if err != gs_err_code_success:
	return err, svc_file, gender
	err, mix_mp3_path = self.mix(cid, work_dir, svc_file, effect_file)
	return err, mix_mp3_path, gender


	def test():
	arr = [
	# "611752105020343687",
	# "611752105023532439",
	"611752105030419688",
	]
	base_dir = "/data/rsync/jianli.yang/AutoCoverTool/data/test"
	s_inst = SongCoverInference()
	for cid in arr:
	st = time.time()
	# err, mix_mp3, gender = s_inst.process_one(cid, os.path.join(base_dir, cid), False)
	err, mix_mp3, gender = s_inst.process_one_logic(cid, os.path.join(base_dir, cid))
	print(mix_mp3, gender)
	print("cid={} RealFinish err={} sp={}".format(cid, err, time.time() - st))


	if __name__ == '__main__':
	test()
	diff --git a/AutoCoverTool/online/inference_worker.py b/AutoCoverTool/online/inference_worker.py
	index 2213f50..3ad3882 100644
	--- a/AutoCoverTool/online/inference_worker.py
	+++ b/AutoCoverTool/online/inference_worker.py
	@@ -1,237 +1,239 @@
	"""
	离线worker
	数据库字段要求:
	// 其中state的状态
	// 0:默认,1:被取走,<0异常情况，2完成
	// 超时到一定程度也会被重新放回来
	数据库格式:
	id,song_id,url,state,svc_url,create_time,update_time,gender
	启动时的环境要求:
	export PATH=$PATH:/data/gpu_env_common/env/bin/ffmpeg/bin
	export PYTHONPATH=$PWD:$PWD/ref/music_remover/demucs:$PWD/ref/so_vits_svc:$PWD/ref/split_dirty_frame
	"""

	import os
	import shutil
	import logging
	import multiprocessing as mp

	from online.inference_one import *
	from online.common import *

	gs_actw_err_code_download_err = 10001
	gs_actw_err_code_trans_err = 10002
	gs_actw_err_code_upload_err = 10003

	gs_state_default = 0
	gs_state_use = 1
	gs_state_finish = 2

	GS_REGION = "ap-singapore"
	GS_BUCKET_NAME = "starmaker-sg-1256122840"
	# GS_COSCMD = "/bin/coscmd"
	GS_COSCMD = "/opt/soft/anaconda3/bin/coscmd"
	GS_RES_DIR = "/srv/dreambooth_worker_resource"
	GS_CONFIG_PATH = os.path.join(GS_RES_DIR, ".online_cos.conf")


	def exec_cmd(cmd):
	ret = os.system(cmd)
	if ret != 0:
	return False
	return True


	def exec_cmd_and_result(cmd):
	r = os.popen(cmd)
	text = r.read()
	r.close()
	return text


	def upload_file2cos(key, file_path, region=GS_REGION, bucket_name=GS_BUCKET_NAME):
	"""
	将文件上传到cos
	:param key: 桶上的具体地址
	:param file_path: 本地文件地址
	:param region: 区域
	:param bucket_name: 桶地址
	:return:
	"""
	cmd = "{} -c {} -r {} -b {} upload {} {}".format(GS_COSCMD, GS_CONFIG_PATH, region, bucket_name, file_path, key)
	if exec_cmd(cmd):
	cmd = "{} -c {} -r {} -b {} info {}".format(GS_COSCMD, GS_CONFIG_PATH, region, bucket_name, key) \
	+ "\| grep Content-Length \|awk \'{print $2}\'"
	res_str = exec_cmd_and_result(cmd)
	logging.info("{},res={}".format(key, res_str))
	size = float(res_str)
	if size > 0:
	return True
	return False
	return False


	def post_process_err_callback(msg):
	print("ERROR\|post_process\|task_error_callback:", msg)


	def effect(queue, finish_queue):
	"""
	1. 添加音效
	2. 混音
	3. 上传到服务端
	:return:
	"""
	inst = SongCoverInference()
	while True:
	logging.info("effect start get...")
	data = queue.get()
	song_id, work_dir, svc_file, gender = data
	logging.info("effect:{},{},{},{}".format(song_id, work_dir, svc_file, gender))
	err, effect_file = inst.effect(song_id, work_dir, svc_file)
	msg = [song_id, err, svc_file, effect_file, gender]
	logging.info("effect,finish:cid={},state={},svc_file={},effect_file={},gender={}". \
	format(song_id, err, svc_file, effect_file, gender))
	finish_queue.put(msg)


	class AutoCoverToolWorker:
	def __init__(self):
	self.base_dir = "/tmp"
	self.work_dir = ""
	self.inst = SongCoverInference()

	def update_state(self, song_id, state):
	sql = "update svc_queue_table set state={},update_time={} where song_id = {}". \
	format(state, int(time.time()), song_id)
	banned_user_map['db'] = "av_db"
	update_db(sql, banned_user_map)

	def get_one_data(self):
	sql = "select song_id, url from svc_queue_table where state = 0 order by create_time desc limit 1"
	banned_user_map["db"] = "av_db"
	data = get_data_by_mysql(sql, banned_user_map)
	if len(data) == 0:
	return None, None
	song_id, song_url = data[0]
	if song_id != "":
	self.update_state(song_id, gs_state_use)
	return str(song_id), song_url

	def pre_process(self, work_dir, song_url):
	"""
	创建文件夹，下载数据
	:return:
	"""

	ext = str(song_url).split(".")[-1]
	dst_file = "{}/src_origin.{}".format(work_dir, ext)
	cmd = "wget {} -O {}".format(song_url, dst_file)
	print(cmd)
	os.system(cmd)
	if not os.path.exists(dst_file):
	return gs_actw_err_code_download_err
	dst_mp3_file = "{}/src.mp3".format(work_dir)
	cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {} ".format(dst_file, dst_mp3_file)
	os.system(cmd)
	if not os.path.exists(dst_mp3_file):
	return gs_actw_err_code_trans_err
	return gs_err_code_success

	def post_process(self, msg):
	song_id, err, svc_file, effect_file, gender = msg
	work_dir = os.path.join(self.base_dir, str(song_id))
	if err != gs_err_code_success:
	self.update_state(song_id, -err)
	return

	# 替换和混音
	err, mix_path_mp3 = self.inst.mix(song_id, work_dir, svc_file, effect_file)
	logging.info(
	"post_process:song_id={},work_dir={},svc_file={},gender={}".format(song_id, work_dir, svc_file, gender))

	svc_url = None
	state = gs_state_finish
	if err != gs_err_code_success:
	state = -err
	else:
	# 上传到cos
	mix_name = os.path.basename(mix_path_mp3)
	key = "av_res/svc_res/{}".format(mix_name)
	if not upload_file2cos(key, mix_path_mp3):
	state = -err
	else:
	state = gs_state_finish
	svc_url = key
	logging.info("upload_file2cos:song_id={},key={},mix_path_mp3={}".format(song_id, key, mix_path_mp3))

	# 更新数据库
	if state != gs_state_finish:
	self.update_state(song_id, state)
	return

	sql = "update svc_queue_table set state={},update_time={},svc_url=\"{}\",gender={} where song_id = {}". \
	format(gs_state_finish, int(time.time()), svc_url, gender, song_id)
	logging.info("post_process:song_id={},sql={}".format(song_id, sql))
	banned_user_map['db'] = "av_db"
	update_db(sql, banned_user_map)

	def process(self):
	logging.info("start_process....")
	worker_num = 4
	worker_queue = mp.Manager().Queue(maxsize=int(worker_num * 1.5))
	finish_queue = mp.Manager().Queue(maxsize=int(worker_num * 1.5))
	pool = mp.Pool(processes=worker_num)
	for i in range(worker_num):
	pool.apply_async(effect,
	args=(worker_queue, finish_queue),
	error_callback=post_process_err_callback)

	while True:
	# 将堆积的内容处理一遍
	while finish_queue.qsize() > 0:
	msg = finish_queue.get(timeout=1)
	self.post_process(msg)
	song_id, err, svc_file, effect_file, gender = msg
	work_dir = os.path.join(self.base_dir, str(song_id))
	logging.info("clear = song_id={},work_dir={}".format(song_id, work_dir))
	shutil.rmtree(work_dir)

	song_id, song_url = self.get_one_data()
	logging.info("\n\nget_one_data = {},{}".format(song_id, song_url))
	if song_id is None:
	time.sleep(5)
	continue

	# 创建空间
	work_dir = os.path.join(self.base_dir, str(song_id))
	if os.path.exists(work_dir):
	shutil.rmtree(work_dir)
	os.makedirs(work_dir)
	logging.info("song_id={},work_dir={},finish".format(song_id, work_dir))

	# 预处理
	err = self.pre_process(work_dir, song_url)
	if err != gs_err_code_success:
	self.update_state(song_id, -err)
	+ shutil.rmtree(work_dir)
	continue
	logging.info("song_id={},work_dir={},pre_process".format(song_id, work_dir))

	# 获取svc数据
	err, svc_file = self.inst.generate_svc_file(song_id, work_dir)
	if err != gs_err_code_success:
	self.update_state(song_id, -err)
	+ shutil.rmtree(work_dir)
	continue
	logging.info("song_id={},work_dir={},generate_svc_file".format(song_id, work_dir))

	# 做音效处理的异步代码
	gender = self.inst.get_gender(svc_file)
	worker_queue.put([song_id, work_dir, svc_file, gender])
	logging.info("song_id={},work_dir={},svc_file={},gender={}".format(song_id, work_dir, svc_file, gender))
	pool.close()
	pool.join()


	if __name__ == '__main__':
	actw = AutoCoverToolWorker()
	actw.process()

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 12, 08:29 (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1347148
Default Alt Text: (37 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions