No OneTemporary
Actions

Size

82 KB

Subscribers

None

View Options

	diff --git a/AutoCoverTool/online/inference_one.py b/AutoCoverTool/online/inference_one.py
	index a59619e..d1cde10 100644
	--- a/AutoCoverTool/online/inference_one.py
	+++ b/AutoCoverTool/online/inference_one.py
	@@ -1,712 +1,713 @@
	"""
	单个处理的逻辑
	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: 2,
	10414574140317353: 2,
	1688849864840588: 2,
	3634463651: 2,
	5629499489839033: 2,
	5910973794723621: 2,
	6755399374234747: 2,
	8162774327817435: 2,
	8162774329368194: 2,
	1125899914308640: 1, # 1是男
	12384898975368914: 1,
	12947848931397021: 1,
	3096224748076687: 1,
	3096224751151928: 1,
	5066549357604730: 1,
	5348024335101054: 1,
	6755399442719465: 1,
	7036874421386111: 1
	}
	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, 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))
	return gs_err_code_success, out_songs[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))

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

	# 做音效
	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()
	try:
	if self.replace_vocal_frame_inst is None:
	self.replace_vocal_frame_inst = ReplaceVocalFrame("data/models/split_dirty_frame_v5_3_epoch3_852.pth")
	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.replace(".wav", "")).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",
	# "611752105030485748",
	# "611752105030485685",
	"dzq",
	]
	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))


	def test_gene_svc():
	base_dir = "/data/rsync/jianli.yang/AutoCoverTool/data/test"
	# cid = "clean_yibo"
	cid = "dzq"
	work_dir = os.path.join(base_dir, cid)
	st = time.time()
	- speaker = "1125899914308640_v1"
	+ speaker = "jianli"
	speakers_model_path = "data/train_users/{}/logs/32k/G_2000.pth"
	speakers_model_config = "data/train_users/{}/config/config.json"
	model_path = speakers_model_path.format(speaker)
	config_path = speakers_model_config.format(speaker)

	# 缓存目录:
	cache_dir = os.path.join(work_dir, "cache")
	if os.path.exists(cache_dir):
	shutil.rmtree(cache_dir)
	os.makedirs(cache_dir)
	song_path = os.path.join(cache_dir, "{}_{}.wav".format(cid, speaker))
	- vocal_path = os.path.join(work_dir, "vocal_32.wav")
	+ # vocal_path = os.path.join(work_dir, "vocal_32.wav")
	+ vocal_path = os.path.join(work_dir, "test_silce.wav")
	inf(model_path, config_path, vocal_path, song_path, "prod")
	print("finish....")


	if __name__ == '__main__':
	test_gene_svc()
	diff --git a/AutoCoverTool/online/tone_shift_one.py b/AutoCoverTool/online/tone_shift_one.py
	index 585ed35..d734c21 100644
	--- a/AutoCoverTool/online/tone_shift_one.py
	+++ b/AutoCoverTool/online/tone_shift_one.py
	@@ -1,232 +1,267 @@
	"""
	变调的方式做处理
	1. 下载
	2. 分离
	3. 针对于人声变调+2，伴奏+1
	4. 合成
	"""

	import os
	import json
	import shutil
	import librosa
	import logging
	import numpy as np
	from ref.music_remover.separate_interface import SeparateInterface
	from online.inference_worker import upload_file2cos, gs_state_use, gs_state_finish, gs_state_default
	from online.common import *

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

	gs_tone_shift_exe = "/opt/soft/bin/tone_shift_exe"
	gs_simple_mixer_path = "/opt/soft/bin/simple_mixer"

	gs_err_code_success = 0
	gs_err_code_tone_shift = 1
	gs_err_code_mix = 2
	gs_err_code_transcode = 3
	gs_err_code_upload = 4
	gs_err_code_download = 5
	gs_err_code_trans_to_mp3 = 6
	gs_err_code_separate = 7
	gs_err_code_duration_too_long = 8
	gs_err_code_duration_no_vocal = 9
	gs_err_code_duration_err = 10
	+gs_err_code_transcode_acc = 11
	+gs_err_code_upload_acc = 12


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


	def get_d(audio_path):
	cmd = "ffprobe -v quiet -print_format json -show_format -show_streams {}".format(audio_path)
	data = exec_cmd(cmd)
	data = json.loads(data)
	# 返回秒
	if 'format' in data.keys() and 'duration' in data['format']:
	return float(data["format"]["duration"])
	return -1


	def get_mean_power(audio_path):
	sr = 44100
	audio, sr = librosa.load(audio_path, sr=sr, mono=True)
	mm = np.mean(np.abs(audio))
	return mm


	class ToneShift:
	def __init__(self):
	self.separate_inst = SeparateInterface()

	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_url_by_id(self, song_id):
	sql = "select song_id, url from svc_queue_table where song_id={}".format(song_id)
	banned_user_map["db"] = "av_db"
	data = get_data_by_mysql(sql)
	if len(data) == 0:
	return None, None
	return str(data[0][0]), data[0][1]

	- def get_one_data(self):
	- sql = "select song_id, url from svc_queue_table where state = 0 and song_src=3 order by create_time desc limit 1"
	+ def get_one_data_logic(self):
	+ """
	+ 按照5,4,3的优先级进行获取
	+ :return:
	+ """
	+ song_src_arr = [5, 4, 3]
	+ for song_src in song_src_arr:
	+ song_id, song_url = self.get_one_data(song_src=song_src)
	+ if song_id is not None:
	+ return song_id, song_url
	+ return None, None
	+
	+ def get_one_data(self, song_src=3):
	+ sql = "select song_id, url from svc_queue_table where state = 0 and song_src={} order by create_time desc limit 1".format(
	+ song_src)
	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:
	"""

	if "?sign=" in song_url:
	return gs_err_code_download
	ext = str(song_url).split(".")[-1]
	dst_file = "{}/src_origin.{}".format(work_dir, ext)
	cmd = "wget {} -O {}".format(song_url, dst_file)
	os.system(cmd)
	if not os.path.exists(dst_file):
	return gs_err_code_download

	duration = get_d(dst_file)
	if duration < 0:
	return gs_err_code_duration_err
	print("Duration:", dst_file, duration)
	if duration > 20 * 60:
	return gs_err_code_duration_too_long

	- dst_mp3_file = "{}/src.mp3".format(work_dir)
	+ dst_mp3_file = "{}/src.wav".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_err_code_trans_to_mp3
	return gs_err_code_success

	def tone_shift_one(self, in_file, dst_file, pitch):
	cmd = "{} {} {} {}".format(gs_tone_shift_exe, in_file, dst_file, pitch)
	os.system(cmd)
	return os.path.exists(dst_file)

	def mix(self, cid, vocal_path, acc_path, tp):
	if tp == 1:
	vocal_pitch = 2
	acc_pitch = 0
	else:
	vocal_pitch = -2
	acc_pitch = 0

	vocal_path_2 = vocal_path.replace(".wav", "_{}.wav".format(vocal_pitch))
	acc_path_2 = acc_path.replace(".wav", "_{}.wav".format(acc_pitch))
	err = self.tone_shift_one(vocal_path, vocal_path_2, vocal_pitch)
	if not err:
	return gs_err_code_tone_shift, None

	err = self.tone_shift_one(acc_path, acc_path_2, acc_pitch)
	if not err:
	return gs_err_code_tone_shift, None

	base_dir = os.path.dirname(vocal_path)
	mix_path = "{}/mix_{}_{}.wav".format(base_dir, vocal_pitch, acc_pitch)
	cmd = "{} {} {} {}".format(gs_simple_mixer_path, vocal_path_2, acc_path_2, mix_path)
	print("exec_cmd={}".format(cmd))
	os.system(cmd)

	if not os.path.exists(mix_path):
	return gs_err_code_mix, None

	# 转码
	- mix_path_mp3 = mix_path.replace(".wav", ".mp3")
	- cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(mix_path, mix_path_mp3)
	+ mix_path_mp3 = mix_path.replace(".wav", ".mp4")
	+ cmd = "ffmpeg -i {} -b:a 128k -c:a aac -ar 44100 -ac 2 -y {} -loglevel fatal".format(mix_path, mix_path_mp3)
	os.system(cmd)
	if not os.path.exists(mix_path_mp3):
	return gs_err_code_transcode, None

	# 上传到cos
	mix_name = os.path.basename(mix_path_mp3)
	key = "av_res/svc_res_tone_shift/{}/{}".format(str(cid), mix_name)
	if not upload_file2cos(key, mix_path_mp3):
	return gs_err_code_upload, None
	return gs_err_code_success, key

	+ def upload_acc(self, cid, acc_path):
	+ # 转码
	+ mix_path_aac = acc_path.replace(".wav", ".m4a")
	+ cmd = "ffmpeg -i {} -b:a 128k -c:a aac -ar 44100 -ac 2 -y {} -loglevel fatal".format(acc_path, mix_path_aac)
	+ os.system(cmd)
	+ if not os.path.exists(mix_path_aac):
	+ return gs_err_code_transcode_acc, None
	+
	+ # 上传
	+ mix_name = os.path.basename(mix_path_aac)
	+ key = "av_res/svc_res_tone_shift/{}/{}".format(str(cid), mix_name)
	+ if not upload_file2cos(key, mix_path_aac):
	+ return gs_err_code_upload_acc, None
	+ return gs_err_code_success, key
	+
	def process_one(self, cid, work_dir):
	"""
	:param cid:
	:param work_dir:
	:return:
	"""
	- src_mp3 = os.path.join(work_dir, "src.mp3")
	+ src_mp3 = os.path.join(work_dir, "src.wav")
	vocal_path = os.path.join(work_dir, "vocal.wav")
	acc_path = os.path.join(work_dir, "acc.wav")
	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, []

	# 当人声的平均能量小于一定值时，则认为无人声(0.01是经验值判定，样本分析来看)
	# 无人声的样本[0.0056, 0.0003], 有人声的样本(目前最小)[0.046, 0.049]
	print("power:{},{}".format(cid, get_mean_power(vocal_path)))
	if get_mean_power(vocal_path) < 0.02:
	return gs_err_code_duration_no_vocal, []
	err, type1_mix_mp3 = self.mix(cid, vocal_path, acc_path, 1)
	if err != gs_err_code_success:
	return err, []

	err, type2_mix_mp3 = self.mix(cid, vocal_path, acc_path, 2)
	if err != gs_err_code_success:
	return err, []
	- return gs_err_code_success, [type1_mix_mp3, type2_mix_mp3]
	+
	+ # 上传伴奏文件
	+ err, acc_path_m4a = self.upload_acc(cid, acc_path)
	+ if err != gs_err_code_success:
	+ return err, []
	+ return gs_err_code_success, [type1_mix_mp3, type2_mix_mp3, acc_path_m4a]

	def process_worker(self):
	logging.info("start process_worker .....")
	base_dir = "/tmp/tone_shift_one"
	if not os.path.exists(base_dir):
	os.makedirs(base_dir)
	while True:
	worker_st = time.time()
	- cid, song_url = self.get_one_data()
	- # cid, song_url = self.get_url_by_id('611752105022612883')
	+ cid, song_url = self.get_one_data_logic()
	+ # cid, song_url = self.get_url_by_id('611752105029706360')
	if cid is None:
	time.sleep(5)
	logging.info("get one data is None ...")
	continue

	work_dir = os.path.join(base_dir, str(cid))
	if os.path.exists(work_dir):
	shutil.rmtree(work_dir)
	os.makedirs(work_dir)
	err = self.pre_process(work_dir, song_url)
	if err != gs_err_code_success:
	self.update_state(str(cid), -err)
	continue

	st = time.time()
	err, data = self.process_one(str(cid), work_dir)
	logging.info("process_finish,{},{}".format(cid, time.time() - st))
	- if err == gs_err_code_success and len(data) == 2:
	+ if err == gs_err_code_success and len(data) != 0:
	sql = "update svc_queue_table set state={},update_time={},svc_url=\"{}\" where song_id = {}". \
	format(gs_state_finish, int(time.time()), ",".join(data), str(cid))
	banned_user_map['db'] = "av_db"
	update_db(sql, banned_user_map)
	else:
	self.update_state(str(cid), -err)
	shutil.rmtree(work_dir)
	logging.info("process_finish,{},{}".format(cid, time.time() - worker_st))


	if __name__ == '__main__':
	ts = ToneShift()
	ts.process_worker()
	diff --git a/AutoCoverTool/ref/so_vits_svc/inference_main.py b/AutoCoverTool/ref/so_vits_svc/inference_main.py
	index 20a9439..e1579ec 100644
	--- a/AutoCoverTool/ref/so_vits_svc/inference_main.py
	+++ b/AutoCoverTool/ref/so_vits_svc/inference_main.py
	@@ -1,83 +1,83 @@
	import io
	import os
	import sys
	import logging
	import time
	from pathlib import Path

	import librosa
	import numpy as np
	import soundfile

	from inference import infer_tool
	from inference import slicer
	from inference.infer_tool import Svc

	logging.getLogger('numba').setLevel(logging.WARNING)
	-chunks_dict = infer_tool.read_temp("ref/so-vits-svc/inference/chunks_temp.json")
	+chunks_dict = infer_tool.read_temp("ref/so_vits_svc/inference/chunks_temp.json")


	def inf(model_path, config_path, raw_audio_path, dst_path, dev):
	# model_path = "logs/32k/G_174000-Copy1.pth"
	# config_path = "configs/config.json"
	svc_model = Svc(model_path, config_path)
	out_dir = os.path.dirname(dst_path)
	print(dst_path)
	os.makedirs(out_dir, exist_ok=True)
	# 支持多个wav文件，放在raw文件夹下
	tran = 0
	spk_list = ['speaker0'] # 每次同时合成多语者音色
	slice_db = -40 # 默认-40，嘈杂的音频可以-30，干声保留呼吸可以-50
	wav_format = 'wav' # 音频输出格式

	# infer_tool.fill_a_to_b(trans, clean_names)
	# for clean_name, tran in zip(clean_names, trans):
	# raw_audio_path = f"raw/{clean_name}"
	# if "." not in raw_audio_path:
	# raw_audio_path += ".wav"
	infer_tool.format_wav(raw_audio_path)
	wav_path = Path(raw_audio_path).with_suffix('.wav')
	chunks = slicer.cut(wav_path, db_thresh=slice_db)
	audio_data, audio_sr = slicer.chunks2audio(wav_path, chunks)

	for spk in spk_list:
	audio = []
	for (slice_tag, data) in audio_data:
	print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
	length = int(np.ceil(len(data) / audio_sr * svc_model.target_sample))
	raw_path = io.BytesIO()
	soundfile.write(raw_path, data, audio_sr, format="wav")
	raw_path.seek(0)
	if slice_tag:
	print('jump empty segment')
	_audio = np.zeros(length)
	else:
	out_audio, out_sr = svc_model.infer(spk, tran, raw_path, dev == "test")
	_audio = out_audio.cpu().numpy()
	audio.extend(list(_audio))
	soundfile.write(dst_path, audio, svc_model.target_sample, format=wav_format)


	if __name__ == '__main__':
	g_model = sys.argv[1] # 模型地址
	g_config = sys.argv[2] # 配置文件地址
	g_audio_path = sys.argv[3] # 输入的音频文件地址,wav
	g_dst_path = sys.argv[4] # 输出的音频文件地址
	if os.path.exists(g_dst_path):
	print("{} success ...".format(g_dst_path))
	exit(0)

	g_dev = "prod"
	if len(sys.argv) > 5:
	g_dev = sys.argv[5]

	g_aa, g_sr = librosa.load(g_audio_path)
	d = librosa.get_duration(g_aa, g_sr)
	# if g_dev != "test":
	# if d > 250:
	# print("{} too long".format(g_audio_path))
	# exit(0)

	st = time.time()
	inf(g_model, g_config, g_audio_path, g_dst_path, g_dev)
	print("{}, inference sp={}".format(g_audio_path, time.time() - st))
	diff --git a/AutoCoverTool/ref/so_vits_svc/models.py b/AutoCoverTool/ref/so_vits_svc/models.py
	index 09c4045..3e3498b 100644
	--- a/AutoCoverTool/ref/so_vits_svc/models.py
	+++ b/AutoCoverTool/ref/so_vits_svc/models.py
	@@ -1,352 +1,357 @@
	import copy
	import math
	import torch
	from torch import nn
	from torch.nn import functional as F

	import attentions
	import commons
	import modules

	from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
	from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
	from commons import init_weights, get_padding
	from vdecoder.hifigan.models import Generator
	from utils import f0_to_coarse

	class ResidualCouplingBlock(nn.Module):
	def __init__(self,
	channels,
	hidden_channels,
	kernel_size,
	dilation_rate,
	n_layers,
	n_flows=4,
	gin_channels=0):
	super().__init__()
	self.channels = channels
	self.hidden_channels = hidden_channels
	self.kernel_size = kernel_size
	self.dilation_rate = dilation_rate
	self.n_layers = n_layers
	self.n_flows = n_flows
	self.gin_channels = gin_channels

	self.flows = nn.ModuleList()
	for i in range(n_flows):
	self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
	self.flows.append(modules.Flip())

	def forward(self, x, x_mask, g=None, reverse=False):
	if not reverse:
	for flow in self.flows:
	x, _ = flow(x, x_mask, g=g, reverse=reverse)
	else:
	for flow in reversed(self.flows):
	x = flow(x, x_mask, g=g, reverse=reverse)
	return x


	class Encoder(nn.Module):
	def __init__(self,
	in_channels,
	out_channels,
	hidden_channels,
	kernel_size,
	dilation_rate,
	n_layers,
	gin_channels=0):
	super().__init__()
	self.in_channels = in_channels
	self.out_channels = out_channels
	self.hidden_channels = hidden_channels
	self.kernel_size = kernel_size
	self.dilation_rate = dilation_rate
	self.n_layers = n_layers
	self.gin_channels = gin_channels

	self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
	self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
	self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)

	def forward(self, x, x_lengths, g=None):
	# print(x.shape,x_lengths.shape)
	x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
	x = self.pre(x) * x_mask
	x = self.enc(x, x_mask, g=g)
	stats = self.proj(x) * x_mask
	m, logs = torch.split(stats, self.out_channels, dim=1)
	z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
	return z, m, logs, x_mask


	class TextEncoder(nn.Module):
	def __init__(self,
	in_channels,
	out_channels,
	hidden_channels,
	kernel_size,
	dilation_rate,
	n_layers,
	gin_channels=0,
	filter_channels=None,
	n_heads=None,
	p_dropout=None):
	super().__init__()
	self.in_channels = in_channels
	self.out_channels = out_channels
	self.hidden_channels = hidden_channels
	self.kernel_size = kernel_size
	self.dilation_rate = dilation_rate
	self.n_layers = n_layers
	self.gin_channels = gin_channels
	self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
	self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
	self.f0_emb = nn.Embedding(256, hidden_channels)

	self.enc_ = attentions.Encoder(
	hidden_channels,
	filter_channels,
	n_heads,
	n_layers,
	kernel_size,
	p_dropout)

	def forward(self, x, x_lengths, f0=None):
	+ # x->(b,256,frame_num), x_lengths -> (b)
	+ # commons.sequence_mask 对于batch层级有价值，x_lengths是每个batch中每一个元素的帧数
	+ # 比如输入（[3,5,2]， 5）那么得到 3 * 5的True/False矩阵，其中第一层矩阵为3个true,2个false,第二层全true，第三层前两个true,其余false
	+ # 作用一个批次中允许不同长度的数据一起训练，此时较短的乘以false，剔除影响
	x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
	x = self.pre(x) * x_mask
	x = x + self.f0_emb(f0).transpose(1,2)
	x = self.enc_(x * x_mask, x_mask)
	stats = self.proj(x) * x_mask
	m, logs = torch.split(stats, self.out_channels, dim=1)
	z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask

	return z, m, logs, x_mask



	class DiscriminatorP(torch.nn.Module):
	def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
	super(DiscriminatorP, self).__init__()
	self.period = period
	self.use_spectral_norm = use_spectral_norm
	norm_f = weight_norm if use_spectral_norm == False else spectral_norm
	self.convs = nn.ModuleList([
	norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
	norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
	norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
	norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
	norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
	])
	self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))

	def forward(self, x):
	fmap = []

	# 1d to 2d
	b, c, t = x.shape
	if t % self.period != 0: # pad first
	n_pad = self.period - (t % self.period)
	x = F.pad(x, (0, n_pad), "reflect")
	t = t + n_pad
	x = x.view(b, c, t // self.period, self.period)

	for l in self.convs:
	x = l(x)
	x = F.leaky_relu(x, modules.LRELU_SLOPE)
	fmap.append(x)
	x = self.conv_post(x)
	fmap.append(x)
	x = torch.flatten(x, 1, -1)

	return x, fmap


	class DiscriminatorS(torch.nn.Module):
	def __init__(self, use_spectral_norm=False):
	super(DiscriminatorS, self).__init__()
	norm_f = weight_norm if use_spectral_norm == False else spectral_norm
	self.convs = nn.ModuleList([
	norm_f(Conv1d(1, 16, 15, 1, padding=7)),
	norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
	norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
	norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
	norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
	norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
	])
	self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))

	def forward(self, x):
	fmap = []

	for l in self.convs:
	x = l(x)
	x = F.leaky_relu(x, modules.LRELU_SLOPE)
	fmap.append(x)
	x = self.conv_post(x)
	fmap.append(x)
	x = torch.flatten(x, 1, -1)

	return x, fmap


	class MultiPeriodDiscriminator(torch.nn.Module):
	def __init__(self, use_spectral_norm=False):
	super(MultiPeriodDiscriminator, self).__init__()
	periods = [2,3,5,7,11]

	discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
	discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
	self.discriminators = nn.ModuleList(discs)

	def forward(self, y, y_hat):
	y_d_rs = []
	y_d_gs = []
	fmap_rs = []
	fmap_gs = []
	for i, d in enumerate(self.discriminators):
	y_d_r, fmap_r = d(y)
	y_d_g, fmap_g = d(y_hat)
	y_d_rs.append(y_d_r)
	y_d_gs.append(y_d_g)
	fmap_rs.append(fmap_r)
	fmap_gs.append(fmap_g)

	return y_d_rs, y_d_gs, fmap_rs, fmap_gs
	-
	-
	+
	+
	class SpeakerEncoder(torch.nn.Module):
	def __init__(self, mel_n_channels=80, model_num_layers=3, model_hidden_size=256, model_embedding_size=256):
	super(SpeakerEncoder, self).__init__()
	self.lstm = nn.LSTM(mel_n_channels, model_hidden_size, model_num_layers, batch_first=True)
	self.linear = nn.Linear(model_hidden_size, model_embedding_size)
	self.relu = nn.ReLU()

	def forward(self, mels):
	self.lstm.flatten_parameters()
	_, (hidden, _) = self.lstm(mels)
	embeds_raw = self.relu(self.linear(hidden[-1]))
	return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
	-
	+
	def compute_partial_slices(self, total_frames, partial_frames, partial_hop):
	mel_slices = []
	for i in range(0, total_frames-partial_frames, partial_hop):
	mel_range = torch.arange(i, i+partial_frames)
	mel_slices.append(mel_range)
	-
	+
	return mel_slices
	-
	+
	def embed_utterance(self, mel, partial_frames=128, partial_hop=64):
	mel_len = mel.size(1)
	last_mel = mel[:,-partial_frames:]
	-
	+
	if mel_len > partial_frames:
	mel_slices = self.compute_partial_slices(mel_len, partial_frames, partial_hop)
	mels = list(mel[:,s] for s in mel_slices)
	mels.append(last_mel)
	mels = torch.stack(tuple(mels), 0).squeeze(1)
	-
	+
	with torch.no_grad():
	partial_embeds = self(mels)
	embed = torch.mean(partial_embeds, axis=0).unsqueeze(0)
	#embed = embed / torch.linalg.norm(embed, 2)
	else:
	with torch.no_grad():
	embed = self(last_mel)
	-
	+
	return embed


	class SynthesizerTrn(nn.Module):
	"""
	Synthesizer for Training
	"""

	- def __init__(self,
	+ def __init__(self,
	spec_channels,
	segment_size,
	inter_channels,
	hidden_channels,
	filter_channels,
	n_heads,
	n_layers,
	kernel_size,
	p_dropout,
	- resblock,
	- resblock_kernel_sizes,
	- resblock_dilation_sizes,
	- upsample_rates,
	- upsample_initial_channel,
	+ resblock,
	+ resblock_kernel_sizes,
	+ resblock_dilation_sizes,
	+ upsample_rates,
	+ upsample_initial_channel,
	upsample_kernel_sizes,
	gin_channels,
	ssl_dim,
	n_speakers,
	**kwargs):

	super().__init__()
	self.spec_channels = spec_channels
	self.inter_channels = inter_channels
	self.hidden_channels = hidden_channels
	self.filter_channels = filter_channels
	self.n_heads = n_heads
	self.n_layers = n_layers
	self.kernel_size = kernel_size
	self.p_dropout = p_dropout
	self.resblock = resblock
	self.resblock_kernel_sizes = resblock_kernel_sizes
	self.resblock_dilation_sizes = resblock_dilation_sizes
	self.upsample_rates = upsample_rates
	self.upsample_initial_channel = upsample_initial_channel
	self.upsample_kernel_sizes = upsample_kernel_sizes
	self.segment_size = segment_size
	self.gin_channels = gin_channels
	self.ssl_dim = ssl_dim
	self.emb_g = nn.Embedding(n_speakers, gin_channels)

	self.enc_p_ = TextEncoder(ssl_dim, inter_channels, hidden_channels, 5, 1, 16,0, filter_channels, n_heads, p_dropout)
	hps = {
	"sampling_rate": 32000,
	"inter_channels": 192,
	"resblock": "1",
	"resblock_kernel_sizes": [3, 7, 11],
	"resblock_dilation_sizes": [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
	"upsample_rates": [10, 8, 2, 2],
	"upsample_initial_channel": 512,
	"upsample_kernel_sizes": [16, 16, 4, 4],
	"gin_channels": 256,
	}
	self.dec = Generator(h=hps)
	self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
	self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)

	def forward(self, c, f0, spec, g=None, mel=None, c_lengths=None, spec_lengths=None):
	- # hubert特征, f0, 幅度谱特征, 说话人id,mel谱特征
	+ # hubert特征(b,256,frame_num), f0 (frame_num), 幅度谱特征, 说话人id,mel谱特征
	if c_lengths == None:
	- c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
	+ c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device) # (b, frame_num)
	if spec_lengths == None:
	spec_lengths = (torch.ones(spec.size(0)) * spec.size(-1)).to(spec.device)

	+ # 说话人信息embding
	g = self.emb_g(g).transpose(1,2)

	z_ptemp, m_p, logs_p, _ = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
	- z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
	+ z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)

	z_p = self.flow(z, spec_mask, g=g)
	z_slice, pitch_slice, ids_slice = commons.rand_slice_segments_with_pitch(z, f0, spec_lengths, self.segment_size)

	# o = self.dec(z_slice, g=g)
	o = self.dec(z_slice, g=g, f0=pitch_slice)

	return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q)

	def infer(self, c, f0, g=None, mel=None, c_lengths=None):
	if c_lengths == None:
	c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
	g = self.emb_g(g).transpose(1,2)

	z_p, m_p, logs_p, c_mask = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
	z = self.flow(z_p, c_mask, g=g, reverse=True)

	o = self.dec(z * c_mask, g=g, f0=f0)

	return o
	diff --git a/AutoCoverTool/script/get_song_url.py b/AutoCoverTool/script/get_song_url.py
	index ab483db..6514536 100644
	--- a/AutoCoverTool/script/get_song_url.py
	+++ b/AutoCoverTool/script/get_song_url.py
	@@ -1,827 +1,827 @@
	"""
	获取歌曲的地址

	# song_src=2 是来源108和109的歌曲，未被洗过的
	# song_src=1 是曲库给的
	# song_src=3 # 用于轻变调的
	"""
	from script.common import *
	from copy import deepcopy
	from online.common import update_db


	def get_url_by_song_id(song_id):
	sql = "select task_url,starmaker_songid from silence where starmaker_songid = {} order by task_id desc limit 1".format(
	song_id)
	ban = deepcopy(banned_user_map)
	ban["db"] = "starmaker_musicbook"
	data = get_data_by_mysql(sql, ban)
	if len(data) > 0:
	return data[0][0]
	return None


	def process():
	arr = [
	"611752105020327762",
	"611752105020332343",
	"611752105020332580",
	"611752105020382477",
	"611752105020384960",
	"611752105020390942",
	"611752105020402448",
	"611752105022612883",
	"611752105022614531",
	"611752105022647060",
	"611752105022647065",
	"611752105022647066",
	"611752105022647079",
	"611752105022704186",
	"611752105022728482",
	"611752105022728546",
	"611752105022729259",
	"611752105022729263",
	"611752105022729268",
	"611752105022731042",
	"611752105022731053",
	"611752105022731127",
	"611752105022734755",
	"611752105022736024",
	"611752105022738473",
	"611752105022739648",
	"611752105022739650",
	"611752105022740713",
	"611752105022741712",
	"611752105022743896",
	"611752105022746068",
	"611752105022746733",
	"611752105022747108",
	"611752105022753906",
	"611752105022757968",
	"611752105022763051",
	"611752105022763880",
	"611752105022763884",
	"611752105022764224",
	"611752105022764688",
	"611752105022764801",
	"611752105022765022",
	"611752105022766341",
	"611752105022767186",
	"611752105022767294",
	"611752105022768062",
	"611752105022768419",
	"611752105022768837",
	"611752105022770004",
	"611752105022770306",
	"611752105022772154",
	"611752105022773633",
	"611752105022773776",
	"611752105022774040",
	"611752105022774127",
	"611752105022774220",
	"611752105022774502",
	"611752105022775091",
	"611752105022775486",
	"611752105022775600",
	"611752105022775907",
	"611752105022775939",
	"611752105022776719",
	"611752105022776721",
	"611752105022776761",
	"611752105022776857",
	"611752105022777051",
	"611752105022777076",
	"611752105022777120",
	"611752105022777328",
	"611752105022777496",
	"611752105022777573",
	"611752105022777600",
	"611752105022777607",
	"611752105022777608",
	"611752105022777611",
	"611752105022777835",
	"611752105022778042",
	"611752105022779020",
	"611752105022779294",
	"611752105022779784",
	"611752105022780210",
	"611752105022780284",
	"611752105022780287",
	"611752105022780345",
	"611752105022780355",
	"611752105022780818",
	"611752105022780961",
	"611752105022780965",
	"611752105022781011",
	"611752105022781144",
	"611752105022781193",
	"611752105022781267",
	"611752105022781268",
	"611752105022781374",
	"611752105022781387",
	"611752105022781807",
	"611752105022782935",
	"611752105022783480",
	"611752105022783776",
	"611752105022783967",
	"611752105022784390",
	"611752105022784996",
	"611752105022785018",
	"611752105022785313",
	"611752105022785621",
	"611752105022785681",
	"611752105022812895",
	"611752105022818025",
	"611752105022823781",
	"611752105022825467",
	"611752105022835406",
	"611752105022835415",
	"611752105022835751",
	"611752105022836470",
	"611752105022837186",
	"611752105022837452",
	"611752105022837464",
	"611752105022838205",
	"611752105022838206",
	"611752105022839030",
	"611752105022839189",
	"611752105022839975",
	"611752105022840319",
	"611752105022840550",
	"611752105022840637",
	"611752105022841089",
	"611752105022841308",
	"611752105022841355",
	"611752105022842120",
	"611752105022842184",
	"611752105022842241",
	"611752105022842989",
	"611752105022843089",
	"611752105022843139",
	"611752105022843331",
	"611752105022843710",
	"611752105022843728",
	"611752105022876795",
	"611752105022973113",
	"611752105023086347",
	"611752105023091102",
	"611752105023104185",
	"611752105023162802",
	"611752105023184121",
	"611752105023219237",
	"611752105023234496",
	"611752105023246015",
	"611752105023246857",
	"611752105023258864",
	"611752105023262008",
	"611752105023301455",
	"611752105023306231",
	"611752105023329571",
	"611752105023411931",
	"611752105023449798",
	"611752105023458990",
	"611752105023610603",
	"611752105023678577",
	"611752105023683356",
	"611752105023683357",
	"611752105023725727",
	"611752105023783626",
	"611752105023841037",
	"611752105023908922",
	"611752105023929521",
	"611752105024170140",
	"611752105024183682",
	"611752105024231227",
	"611752105024415490",
	"611752105024466658",
	"611752105024618170",
	"611752105024683212",
	"611752105024728134",
	"611752105024765795",
	"611752105024766050",
	"611752105025090763",
	"611752105025188532",
	"611752105025242121",
	"611752105025348359",
	"611752105025455871",
	"611752105025458749",
	"611752105025458753",
	"611752105025458809",
	"611752105025467555",
	"611752105025475926",
	"611752105025486355",
	"611752105025492732",
	"611752105025496983",
	"611752105025503613",
	"611752105025504662",
	"611752105025506533",
	"611752105025515144",
	"611752105025520678",
	"611752105025521388",
	"611752105025524664",
	"611752105025524932",
	"611752105025526555",
	"611752105025542775",
	"611752105025542802",
	"611752105025543710",
	"611752105025555350",
	"611752105025558173",
	"611752105025565020",
	"611752105025565029",
	"611752105025565034",
	"611752105025565044",
	"611752105025578884",
	"611752105025580424",
	"611752105025581305",
	"611752105025584544",
	"611752105025720331",
	"611752105025840622",
	"611752105026003288",
	"611752105026090255",
	"611752105026110280",
	"611752105026110299",
	"611752105026110309",
	"611752105026110320",
	"611752105026110324",
	"611752105026110363",
	"611752105026110435",
	"611752105026150525",
	"611752105026152312",
	"611752105026152320",
	"611752105026180638",
	"611752105026180797",
	"611752105026205984",
	"611752105026227884",
	"611752105026343282",
	"611752105026343284",
	"611752105026388268",
	"611752105026417620",
	"611752105026449246",
	"611752105026462848",
	"611752105026465098",
	"611752105026533365",
	"611752105026533380",
	"611752105026533386",
	"611752105026533657",
	"611752105026536897",
	"611752105026536911",
	"611752105026536913",
	"611752105026577993",
	"611752105026580839",
	"611752105026614487",
	"611752105026666894",
	"611752105026666899",
	"611752105026666904",
	"611752105026666918",
	"611752105026666950",
	"611752105026666964",
	"611752105026666995",
	"611752105026667014",
	"611752105026667025",
	"611752105026716551",
	"611752105026779831",
	"611752105027030955",
	"611752105027147459",
	"611752105027186707",
	"611752105027201043",
	"611752105027216307",
	"611752105027228689",
	"611752105027228702",
	"611752105027326105",
	"611752105027460089",
	"611752105027460125",
	"611752105027484924",
	"611752105027601574",
	"611752105027648113",
	"611752105027802526",
	"611752105027854263",
	"611752105028204403",
	"611752105028408823",
	"611752105028477541",
	"611752105028507652",
	"611752105028558157",
	"611752105028593043",
	"611752105028793344",
	"611752105028815367",
	"611752105028820643",
	"611752105028820644",
	"611752105028837845",
	"611752105028858612",
	"611752105028858622",
	"611752105028878359",
	"611752105028879009",
	"611752105028916096",
	"611752105028916098",
	"611752105028975585",
	"611752105028990740",
	"611752105029006327",
	"611752105029041707",
	"611752105029047058",
	"611752105029047269",
	"611752105029054046",
	"611752105029059915",
	"611752105029090034",
	"611752105029204262",
	"611752105029272970",
	"611752105029290667",
	"611752105029291290",
	"611752105029291293",
	"611752105029291297",
	"611752105029291304",
	"611752105029306974",
	"611752105029372452",
	"611752105029432803",
	"611752105029648535",
	"611752105029648872",
	"611752105029648891",
	"611752105029788767",
	"611752105029953987",
	"611752105029954740",
	"611752105029954853",
	"611752105029955024",
	"611752105029956615",
	"611752105029990162",
	"611752105029990799",
	"611752105029991249",
	"611752105030119229",
	"611752105030146069",
	"611752105030220820",
	"611752105030228836",
	"611752105030249168",
	"611752105030249302",
	"611752105030279605",
	"61175210503042544",
	"611752105030447267",
	"611752105030449043",
	"611752105030454452",
	"611752105030470921",
	"611752105030483301",
	"611752105030483312",
	"611752105030483313",
	"611752105030483344",
	"611752105030483414",
	"611752105030483415",
	"611752105030485565",
	"611752105030485569",
	"611752105030485602",
	"611752105030485608",
	"611752105030485620",
	"611752105030485663",
	"611752105030485711",
	"611752105030485733",
	"611752105030485745",
	"611752105030485799",
	"611752105030486000",
	"611752105030486306",
	"611752105030488510",
	"611752105030488594",
	"611752105030488665",
	"611752105030488713",
	"611752105030488727",
	"611752105030488744",
	"611752105030488814",
	"611752105030488836",
	"611752105030488852",
	"611752105030488864",
	"611752105030488880",
	"611752105030488962",
	"611752105030488997",
	"611752105030489153",
	"611752105030489354",
	"611752105030489380",
	"611752105030489394",
	"611752105030489403",
	"611752105030489415",
	"611752105030494882",
	"611752105030499117",
	"611752105030499185",
	"611752105030499265",
	"611752105030499310",
	"611752105030500582",
	"611752105030501929",
	"611752105030501994",
	"611752105030502109",
	"611752105030502463",
	"611752105030503847",
	"611752105030506310",
	"611752105030507034",
	"611752105030516849",
	"611752105030517044",
	"611752105030517093",
	"611752105030532792",
	"611752105030532858",
	"611752105030532869",
	"611752105030534180",
	"611752105030534293",
	"611752105030534503",
	"611752105030535017",
	"611752105030538184",
	"611752105030544325",
	"611752105030547499",
	"611752105030547630",
	"611752105030547632",
	"611752105030547638",
	"611752105030547849",
	"611752105030547881",
	"611752105030549919",
	"611752105030554063",
	"611752105030554076",
	"611752105030556613",
	"611752105030557261",
	"611752105030557355",
	"611752105030558647",
	"611752105030558663",
	"611752105030559471",
	"611752105030559472",
	"611752105030562192",
	"611752105030562194",
	"611752105030562196",
	"611752105030562197",
	"611752105030562199",
	"611752105030562203",
	"611752105030562205",
	"611752105030562209",
	"611752105030562211",
	"611752105030562213",
	"611752105030562214",
	"611752105030562218",
	"611752105030562221",
	"611752105030562227",
	"611752105030562228",
	"611752105030562231",
	"611752105030562234",
	"611752105030562236",
	"611752105030562239",
	"611752105030562243",
	"611752105030562245",
	"611752105030562248",
	"611752105030562251",
	"611752105030562254",
	"611752105030562255",
	"611752105030562259",
	"611752105030562262",
	"611752105030562263",
	"611752105030562266",
	"611752105030562268",
	"611752105030562271",
	"611752105030562274",
	"611752105030562277",
	"611752105030562283",
	"611752105030562286",
	"611752105030562289",
	"611752105030562291",
	"611752105030562296",
	"611752105030562302",
	"611752105030562303",
	"611752105030562306",
	"611752105030562311",
	"611752105030562314",
	"611752105030562316",
	"611752105030562322",
	"611752105030562325",
	"611752105030562327",
	"611752105030562333",
	"611752105030562335",
	"611752105030562337",
	"611752105030562338",
	"611752105030562345",
	"611752105030562351",
	"611752105030562378",
	"611752105030562380",
	"611752105030562383",
	"611752105030562386",
	"611752105030562389",
	"611752105030562391",
	"611752105030562392",
	"611752105030562397",
	"611752105030562398",
	"611752105030562399",
	"611752105030562401",
	"611752105030562404",
	"611752105030562405",
	"611752105030562411",
	"611752105030562413",
	"611752105030562414",
	"611752105030562417",
	"611752105030562419",
	"611752105030562424",
	"611752105030562425",
	"611752105030562426",
	"611752105030562428",
	"611752105030562431",
	"611752105030562448",
	"611752105030562457",
	"611752105030562459",
	"611752105030562460",
	"611752105030562463",
	"611752105030562470",
	"611752105030562472",
	"611752105030562473",
	"611752105030562483",
	"611752105030562489",
	"611752105030562493",
	"611752105030562494",
	"611752105030562499",
	"611752105030562502",
	"611752105030562504",
	"611752105030562507",
	"611752105030562512",
	"611752105030562513",
	"611752105030562517",
	"611752105030562522",
	"611752105030562919",
	"611752105030562921",
	"611752105030562924",
	"611752105030562925",
	"611752105030562929",
	"611752105030562931",
	"611752105030562936",
	"611752105030562938",
	"611752105030562939",
	"611752105030562940",
	"611752105030562943",
	"611752105030562946",
	"611752105030562950",
	"611752105030562953",
	"611752105030562954",
	"611752105030562959",
	"611752105030562960",
	"611752105030562962",
	"611752105030562968",
	"611752105030562974",
	"611752105030562978",
	"611752105030562979",
	"611752105030562981",
	"611752105030562983",
	"611752105030562986",
	"611752105030562988",
	"611752105030562999",
	"611752105030563001",
	"611752105030563003",
	"611752105030563005",
	"611752105030563006",
	"611752105030563010",
	"611752105030563014",
	"611752105030563022",
	"611752105030563025",
	"611752105030563028",
	"611752105030563031",
	"611752105030563034",
	"611752105030563035",
	"611752105030563043",
	"611752105030564818",
	"611752105030568345",
	"611752105030568348",
	"611752105030578193",
	"611752105030582372",
	"611752105030590839",
	"611752105030590840",
	"611752105030590845",
	"611752105030590847",
	"611752105030595548",
	"611752105030595730",
	"611752105030597299",
	"611752105030597505",
	"611752105030605279",
	"611752105030605833",
	"611752105030606179",
	"611752105030615341",
	"611752105030617237",
	"611752105030617286",
	"611752105030617308",
	"611752105030617321",
	"611752105030617329",
	"611752105030617332",
	"611752105030617344",
	"611752105030623889",
	"611752105030623893",
	"611752105030629479",
	"611752105030629626",
	"611752105030644584",
	"611752105030644604",
	"611752105030645910",
	"611752105030645928",
	"611752105030645939",
	"611752105030645952",
	"611752105030645965",
	"611752105030645979",
	"611752105030645993",
	"611752105030646025",
	"611752105030646052",
	"611752105030646076",
	"611752105030646106",
	"611752105030646134",
	"611752105030646147",
	"611752105030647154",
	"611752105030647258",
	"611752105030647263",
	"611752105030647335",
	"611752105030647409",
	"611752105030647439",
	"611752105030647456",
	"611752105030647469",
	"611752105030647493",
	"611752105030647496",
	"611752105030647512",
	"611752105030647526",
	"611752105030647735",
	"611752105030647850",
	"611752105030647856",
	"611752105030647863",
	"611752105030649520",
	"611752105030649525",
	"611752105030649535",
	"611752105030649557",
	"611752105030649597",
	"611752105030649603",
	"611752105030649621",
	"611752105030649627",
	"611752105030649645",
	"611752105030649647",
	"611752105030649648",
	"611752105030649650",
	"611752105030649652",
	"611752105030649657",
	"611752105030649661",
	"611752105030650191",
	"611752105030650212",
	"611752105030650762",
	"611752105030650773",
	"611752105030650788",
	"611752105030650800",
	"611752105030650807",
	"611752105030652092",
	"611752105030652107",
	"611752105030652116",
	"611752105030652135",
	"611752105030652143",
	"611752105030652148",
	"611752105030652183",
	"611752105030652188",
	"611752105030652306",
	"611752105030652522",
	"611752105030652547",
	"611752105030652554",
	"611752105030652565",
	"611752105030652580",
	"611752105030652586",
	"611752105030652606",
	"611752105030652613",
	"611752105030652619",
	"611752105030652628",
	"611752105030652635",
	"611752105030652645",
	"611752105030652657",
	"611752105030652666",
	"611752105030652675",
	"611752105030652710",
	"611752105030652734",
	"611752105030652740",
	"611752105030652759",
	"611752105030652832",
	"611752105030652843",
	"611752105030652867",
	"611752105030652890",
	"611752105030652901",
	"611752105030652955",
	"611752105030652962",
	"611752105030653015",
	"611752105030653040",
	"611752105030653077",
	"611752105030653092",
	"611752105030653100",
	"611752105030653125",
	"611752105030653141",
	"611752105030653177",
	"611752105030659127",
	"611752105030659135",
	"611752105030659138",
	"611752105030659139",
	"611752105030659140",
	"611752105030659145",
	"611752105030659146",
	"611752105030659150",
	"611752105030659157",
	"611752105030659158",
	"611752105030659160",
	"611752105030659164",
	"611752105030659167",
	"611752105030659176",
	"611752105030659178",
	"611752105030659180",
	"611752105030659183",
	"611752105030659190",
	"611752105030659197",
	"611752105030659201",
	"611752105030659205",
	"611752105030659206",
	"611752105030659210",
	"611752105030659213",
	"611752105030659214",
	"611752105030659222",
	"611752105030659228",
	"611752105030659230",
	"611752105030659235",
	"611752105030659239",
	"611752105030659241",
	"611752105030659245",
	"611752105030659247",
	"611752105030659248",
	"611752105030659249",
	"611752105030659252",
	"611752105030659253",
	"611752105030659255",
	"611752105030659259",
	"611752105030659261",
	"611752105030659263",
	"611752105030659265",
	"611752105030659266",
	"611752105030659268",
	"611752105030659271",
	"611752105030659272",
	"611752105030659275",
	"611752105030659276",
	"611752105030659279",
	"611752105030659280",
	"611752105030659285",
	"611752105030659286",
	"611752105030659287",
	"611752105030659892",
	"611752105030659898",
	"611752105030659904",
	"611752105030659907",
	"611752105030659915",
	"611752105030659923",
	"611752105030659929",
	"611752105030659936",
	"611752105030659942",
	"611752105030659957",
	"611752105030659965",
	"611752105030659974",
	"611752105030659982",
	"611752105030659986",
	"611752105030659992",
	"611752105030659998",
	"611752105030660002",
	"611752105030660009",
	"611752105030660018",
	"611752105030660030",
	"611752105030660038",
	"611752105030661242"
	]

	ban = deepcopy(banned_user_map)
	ban["db"] = "av_db"

	for sid in arr:
	url = get_url_by_song_id(sid)
	if url is not None:
	print("out,{},{}".format(url, sid))
	# 不在数据库中
	sql = "select song_id from svc_queue_table where song_id={} and song_src=3".format(sid)
	data = get_data_by_mysql(sql, ban)
	if len(data) == 0:
	tm = int(time.time())
	sql = "replace INTO svc_queue_table (song_id, url, create_time, update_time, song_src) VALUES ({}, \"{}\",{}, {}, 3)" \
	.format(sid, url, tm, tm)
	update_db(sql, ban)


	def get_data_from_song():
	sql = """
	select tb1.song_id, tb1.recording_count
	from (
	select song_id,recording_count
	from starmaker.song
	where song_src in (108,109) and song_status = 2
	order by recording_count desc
	) as tb1
	left join
	(
	select song_id
	from av_db.svc_queue_table
	) as tb2
	on tb1.song_id = tb2.song_id
	where tb2.song_id is null
	- order by tb1.recording_count desc limit 1000
	+ order by tb1.recording_count desc limit 5000
	"""
	ban = deepcopy(banned_user_map)
	ban_v1 = deepcopy(banned_user_map)
	ban["db"] = "starmaker_musicbook"
	ban_v1["db"] = "av_db"
	data = get_data_by_mysql(sql, ban)
	for dt in data:
	sid = dt[0]
	url = get_url_by_song_id(sid)
	if url is not None:
	print("out,{},{}".format(url, sid))
	tm = int(time.time())
	sql = "insert INTO svc_queue_table (song_id, url, create_time, update_time, song_src) VALUES ({}, \"{}\", {}, {}, 3)" \
	.format(sid, url, tm, tm)
	update_db(sql, ban_v1)


	if __name__ == '__main__':
	# get_diff_song()
	get_data_from_song()
	# process()

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions