Page MenuHomePhabricator
Files F4880270

No OneTemporary
Actions

View Options

diff --git a/AutoCoverTool/online/common.py b/AutoCoverTool/online/common.py
new file mode 100644
index 0000000..982a1f0
--- /dev/null
+++ b/AutoCoverTool/online/common.py
@@ -0,0 +1,163 @@
+# -*-encoding=utf8-*-
+import time
+import pymysql
+
+banned_user_map = {
+ "host": "sg-songbook00.db.starmaker.co",
+ "user": "worker",
+ "passwd": "gRYppQtdTpP3nFzH",
+ "db": "starmaker"
+}
+
+gs_songbook_test_banned_user_map = {
+ "host": "sg-test-server-goapi-1",
+ "user": "root",
+ "passwd": "solo2018",
+ "db": "av_db"
+}
+
+banned_user_map_v1 = {
+ "host": "sg-starmaker-device-r2.db.starmaker.co",
+ "user": "worker",
+ "passwd": "gRYppQtdTpP3nFzH",
+ "db": "mis"
+}
+
+banned_user_map_v2 = {
+ "host": "sg-sm-img-r1.starmaker.co",
+ "user": "worker",
+ "passwd": "gRYppQtdTpP3nFzH",
+ "db": "sm"
+}
+
+# 做一下shared库的查询依赖
+shard_map = {
+ "shard_sm_12": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_13": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_14": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_15": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_30": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_31": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_20": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_21": "sg-shard02-r2.db.starmaker.co",
+ "shard_sm_22": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_23": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_24": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_25": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_26": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_27": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_28": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_29": "sg-shard03-r2.db.starmaker.co",
+ "shard_sm_0": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_1": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_2": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_3": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_4": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_5": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_16": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_17": "sg-shard00-r2.db.starmaker.co",
+ "shard_sm_6": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_7": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_8": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_9": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_10": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_11": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_18": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_19": "sg-shard01-r2.db.starmaker.co",
+ "shard_sm_32": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_33": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_34": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_35": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_36": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_37": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_38": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_39": "sg-shard04-r2.db.starmaker.co",
+ "shard_sm_40": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_41": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_42": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_43": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_44": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_45": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_46": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_47": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_48": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_49": "sg-shard05-r2.db.starmaker.co",
+ "shard_sm_50": "sg-shard05-r2.db.starmaker.co",
+ "name": "shard_sm_{}",
+ "port": 3306,
+ "user": "readonly",
+ "passwd": "JKw6woZgRXsveegL"
+}
+
+
+def connect_db(host="research-db-r1.starmaker.co", port=3306, user="root", passwd="Qrdl1130", db=""):
+ print("connect mysql host={} port={} user={} passwd={} db={}".format(host, port, user, passwd, db))
+ return pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=db)
+
+
+def get_data_by_mysql(sql, ban=banned_user_map):
+ db = connect_db(host=ban["host"], passwd=ban["passwd"], user=ban["user"],
+ db=ban["db"])
+ db_cursor = db.cursor()
+ if len(sql) < 100:
+ print("execute = {}".format(sql))
+ else:
+ print("execute = {}...".format(sql[:100]))
+
+ db_cursor.execute(sql)
+ res = db_cursor.fetchall()
+ db_cursor.close()
+ db.close()
+ print("res size={}".format(len(res)))
+ return res
+
+
+def get_shard_db(user_id):
+ return int(float(user_id)) >> 48
+
+
+def get_shard_data_by_sql(sql, user_id):
+ shard_id = get_shard_db(user_id)
+ db_name = shard_map["name"].format(shard_id)
+ host = shard_map[db_name]
+ db = connect_db(host=host, passwd=shard_map["passwd"], user=shard_map["user"], db=db_name)
+ db_cursor = db.cursor()
+ if len(sql) < 100:
+ print("execute = {}".format(sql))
+ else:
+ print("execute = {}...".format(sql[:100]))
+
+ db_cursor.execute(sql)
+ res = db_cursor.fetchall()
+ db_cursor.close()
+ db.close()
+ print("res size={}".format(len(res)))
+ return res
+
+
+def read_file(in_file):
+ with open(in_file, "r") as f:
+ lines = f.readlines()
+ return lines
+
+
+def write2file(file_path, data):
+ with open(file_path, "w") as f:
+ for line in data:
+ line += "\n"
+ f.write(line)
+
+
+def update_db(sql, ban=banned_user_map):
+ db = connect_db(host=ban["host"], passwd=ban["passwd"], user=ban["user"],
+ db=ban["db"])
+ db_cursor = db.cursor()
+ if len(sql) < 100:
+ print("execute = {}".format(sql))
+ else:
+ print("execute = {}...".format(sql[:100]))
+
+ db_cursor.execute(sql)
+ db.commit()
+ db_cursor.close()
+ db.close()
diff --git a/AutoCoverTool/online/inference_one.py b/AutoCoverTool/online/inference_one.py
new file mode 100644
index 0000000..36e71d5
--- /dev/null
+++ b/AutoCoverTool/online/inference_one.py
@@ -0,0 +1,677 @@
+"""
+单个处理的逻辑
+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_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_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, 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)
+ 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
new file mode 100644
index 0000000..2213f50
--- /dev/null
+++ b/AutoCoverTool/online/inference_worker.py
@@ -0,0 +1,237 @@
+"""
+离线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)
+ 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)
+ 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()
diff --git a/AutoCoverTool/online/readme.txt b/AutoCoverTool/online/readme.txt
new file mode 100644
index 0000000..5d82d70
--- /dev/null
+++ b/AutoCoverTool/online/readme.txt
@@ -0,0 +1,44 @@
+自动翻唱工具
+功能: 输入原唱的音频文件，输出一个翻唱的作品
+结构介绍:
+---online
+ ---common.py // 共用代码
+ ---inference_one.py // 给定一个音频，输出一个翻唱作品
+ ---inference_worker.py // 从数据库中不断读取获取音频，然后下载制作好翻唱作品后，上传cos，并将信息保存到数据库
+
+环境安装:
+1. python环境安装:
+ 环境安装:
+ 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
+
+2. 可执行文件安装:
+ 直接从sg-prod-ipaint-gpu-1的对应位置拷贝即可,如果需要编译，则进入到ref/tools/mixer中编译前三个,在本仓库的上一次目录中编译dereverbrate
+ 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"
+
+3. 模型资源相关
+ 从sg-prod-ipaint-gpu-1的data目录拷贝train_users数据
+ data/models/split_dirty_frame_v5_3_epoch3_852.pth
+ self.speakers_model_path = "data/train_users/{}/logs/32k/G_2000.pth"
+ self.speakers_model_config = "data/train_users/{}/config/config.json"
+ 将上面的三个都拷贝到代码的data目录即可
+
+快速使用:
+1. 线上使用: python3 inference_worker.py
+2. 离线跑单个: python3 inference_one.py
+
+
diff --git a/AutoCoverTool/ref/music_remover/separate_interface.py b/AutoCoverTool/ref/music_remover/separate_interface.py
index ea3bb73..646d96a 100644
--- a/AutoCoverTool/ref/music_remover/separate_interface.py
+++ b/AutoCoverTool/ref/music_remover/separate_interface.py
@@ -1,103 +1,103 @@
"""
分离的对外函数
"""
import os
import sys
import time
import shutil
import logging
from demucs.pretrained import get_model
from demucs.separate import *
# 第三方二进制文件
gs_standard_audio_exe = "/opt/soft/bin/standard_audio"
gs_ffmpeg_exe = "ffmpeg"
# 全局配置
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# 错误码
ERR_CODE_SUCCESS = 0
ERR_CODE_INPUT_FILE_NOT_EXISTS = 1
class SeparateInterface:
"""
分离器对外接口,只生成伴奏
"""
def __init__(self):
sp_start = time.time()
# 评价之后该版本模型的效果效果最佳,性能也合适
# 对比评价过mdx_extra_q和htdemucs_ft
# 其中mdx_extra_q和mdx_extra速度一致，但是和声保留情况不如后者
# htdemucs_ft耗时是mdx_extra的1.6倍，在部分歌曲消去的程度上比mdx_extra好，但是和声没有mdx_extra保留的完整|详情见xishuashua的开头和声部分
self.model = get_model('mdx_extra')
self.tmp_dir = os.path.join("/tmp/separate")
if not os.path.exists(self.tmp_dir):
os.makedirs(self.tmp_dir)
logging.info("SeparateInterface: load model spent = {}".format(time.time() - sp_start))
def process_logic(self, cid, cache_dir, in_file, vocal_out_file, acc_out_file, dev='cuda'):
model = self.model
sp_start = time.time()
wav = load_track(in_file, model.audio_channels, model.samplerate)
logging.info("--------load_track:cid={},sp={}".format(cid, time.time() - sp_start))
# 模型推理
sp_start = time.time()
ref = wav.mean(0)
wav = (wav - ref.mean()) / ref.std()
# wav[None] -> 增加一个维度,原来是[2, xxx] -> [1, 2, xxx]
sources = apply_model(model, wav[None], device=dev, shifts=1, split=True, overlap=0.25, progress=True,
num_workers=0)[0]
sources = sources * ref.std() + ref.mean()
logging.info("--------apply_model:cid={},sp={}".format(cid, time.time() - sp_start))
# 只保留伴奏
sources = list(sources)
vocals = sources.pop(model.sources.index("vocals"))
if vocals is not None:
save_audio(vocals, vocal_out_file, samplerate=model.samplerate)
other_stem = th.zeros_like(sources[0])
for sc in sources:
other_stem += sc
if acc_out_file is not None:
save_audio(other_stem, acc_out_file, samplerate=model.samplerate)
if vocal_out_file is not None:
if not os.path.exists(vocal_out_file):
return False
if acc_out_file is not None:
if not os.path.exists(acc_out_file):
return False
return True
def process(self, cid, in_file, vocal_out_file, acc_out_file, dev='cuda'):
if not os.path.exists(in_file):
return ERR_CODE_INPUT_FILE_NOT_EXISTS
st_time = time.time()
logging.info("--------process:cid={},{},{},{}".format(cid, in_file, vocal_out_file, acc_out_file))
cache_dir = os.path.join(self.tmp_dir, str(cid))
if os.path.exists(cache_dir):
shutil.rmtree(cache_dir)
os.makedirs(cache_dir)
# 核心处理逻辑
ret = self.process_logic(cid, cache_dir, in_file, vocal_out_file, acc_out_file, dev)
shutil.rmtree(cache_dir)
logging.info(
"--------finish:cid={},{},{},{}|{}|sp={}\n\n".format(cid, in_file, vocal_out_file, acc_out_file, dev, ret,
time.time() - st_time))
return ret
-#
+
# if __name__ == '__main__':
# si = SeparateInterface()
# in_f = sys.argv[1]
# out_f = sys.argv[2]
# dev = sys.argv[3] # cuda或者cpu
# for i in range(0, 3):
# si.process(str(1), in_f, out_f, dev)
diff --git a/AutoCoverTool/script/inference_one.py b/AutoCoverTool/script/inference_one.py
deleted file mode 100644
index 3565bec..0000000
--- a/AutoCoverTool/script/inference_one.py
+++ /dev/null
@@ -1,1529 +0,0 @@
-"""
-单个处理的逻辑
-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
-
-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_denoise_exe = "/opt/soft/bin/denoise_exe"
-gs_draw_volume_exe = "/opt/soft/bin/draw_volume_v1"
-gs_simple_mixer_path = "/opt/soft/bin/simple_mixer"
-gs_rever_path = "/data/rsync/jianli.yang/dereverbrate/build/dereverbrate_test"
-
-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
-from ref.split_dirty_frame.dataset.dataset import file2mfcc
-
-
-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.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 = SeparateInterface()
- self.replace_vocal_frame_inst = ReplaceVocalFrame("data/models/split_dirty_frame_v5_3_epoch3_852.pth")
- 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 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_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):
- 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:
- 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
- logging.info("start inference_speaker ...")
- out_songs = self.inference_speaker()
- logging.info("start get_new_vocal_rate ...")
- # out_songs = self.get_new_vocal_rate(out_songs)
- dv_out_list = self.preprocess_vocal(out_songs, self.vocal_path)
- 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 = self.after_process(self.cid, self.work_dir, src_path, dv_out_path, self.vocal_path, self.acc_path,
- True, True)
- if err != 0:
- logging.info("after_process err {}".format(err))
- logging.info("finish:cid={},work_dir={}----------------------->>>>>>>>".format(cid, work_dir))
- return gs_err_code_success
-
- 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 None, gs_err_code_trans2_442
-
- 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 None, gs_err_code_reverb
- print("cid = {}, reverb_by_vocal sp={}".format(self.cid, time.time() - st))
- return file_dst, gs_err_code_success
-
- 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:
- # 抓取混响
- effect_file, err = self.reverb_by_vocal(in_file)
- if err != gs_err_code_success:
- return err
-
- 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
- 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
- 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
-
- # 合并转码后再做一次拉伸，保证响度
- 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
- 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
-
- # 编码为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
-
- # 拷贝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
-
-
-def test_volume_dir():
- base_dir = "/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_3_w4"
- # arr = [
- # "611752105015523266/cache/611752105015523266_5066549357604730.wav",
- # "611752105017233541/cache/611752105017233541_6755399442719465.wav",
- # "611752105030414513/cache/611752105030414513_1125899914308640.wav",
- # "611752105030414549/cache/611752105030414549_5066549357604730.wav",
- # "611752105030414557/cache/611752105030414557_8162774327817435.wav",
- # "611752105030414588/cache/611752105030414588_1125899914308640.wav",
- # "611752105030414597/cache/611752105030414597_6755399374234747.wav",
- # "611752105030414613/cache/611752105030414613_5066549357604730.wav",
- # "611752105030414615/cache/611752105030414615_1125899914308640.wav",
- # "611752105030414619/cache/611752105030414619_5066549357604730.wav",
- # "611752105030414633/cache/611752105030414633_8162774327817435.wav",
- # "611752105030414638/cache/611752105030414638_8162774329368194.wav",
- # "611752105030414689/cache/611752105030414689_8162774327817435.wav",
- # "611752105030414702/cache/611752105030414702_6755399374234747.wav",
- # "611752105030414742/cache/611752105030414742_5066549357604730.wav",
- # "611752105030414763/cache/611752105030414763_1125899914308640.wav",
- # "611752105030414773/cache/611752105030414773_8162774329368194.wav",
- # "611752105030414777/cache/611752105030414777_8162774329368194.wav",
- # "611752105030414779/cache/611752105030414779_1125899914308640.wav",
- # "611752105030414784/cache/611752105030414784_6755399442719465.wav",
- # "611752105030414890/cache/611752105030414890_5066549357604730.wav",
- # "611752105030414915/cache/611752105030414915_5066549357604730.wav",
- # "611752105030414925/cache/611752105030414925_1125899914308640.wav",
- # "611752105030414929/cache/611752105030414929_1125899914308640.wav",
- # "611752105030414935/cache/611752105030414935_3634463651.wav",
- # "611752105030414943/cache/611752105030414943_6755399374234747.wav",
- # "611752105030414957/cache/611752105030414957_12384898975368914.wav",
- # "611752105030414962/cache/611752105030414962_8162774327817435.wav",
- # "611752105030414976/cache/611752105030414976_10414574138721494.wav",
- # "611752105030414993/cache/611752105030414993_12947848931397021.wav",
- # "611752105030414995/cache/611752105030414995_5066549357604730.wav",
- # "611752105030415003/cache/611752105030415003_12947848931397021.wav",
- # "611752105030415014/cache/611752105030415014_10414574138721494.wav",
- # "611752105030415018/cache/611752105030415018_8162774329368194.wav",
- # "611752105030415032/cache/611752105030415032_6755399442719465.wav",
- # "611752105030415056/cache/611752105030415056_3096224748076687.wav",
- # "611752105030415067/cache/611752105030415067_1125899914308640.wav",
- # "611752105030415071/cache/611752105030415071_5910973794723621.wav",
- # "611752105030415074/cache/611752105030415074_1125899914308640.wav",
- # "611752105030415083/cache/611752105030415083_1125899914308640.wav",
- # "611752105030415087/cache/611752105030415087_5910973794723621.wav",
- # "611752105030415100/cache/611752105030415100_10414574138721494.wav",
- # "611752105030415103/cache/611752105030415103_8162774329368194.wav"
- # ]
- # arr = [
- # "611752105020256284/cache/611752105020256284_8162774329368194.wav",
- # "611752105020286433/cache/611752105020286433_1125899914308640.wav",
- # "611752105020286443/cache/611752105020286443_12384898975368914.wav",
- # "611752105020286446/cache/611752105020286446_5629499489839033.wav",
- # "611752105020290639/cache/611752105020290639_3634463651.wav",
- # "611752105020290695/cache/611752105020290695_1125899914308640.wav",
- # "611752105020315328/cache/611752105020315328_8162774329368194.wav",
- # "611752105020315368/cache/611752105020315368_1688849864840588.wav",
- # "611752105020336950/cache/611752105020336950_3634463651.wav",
- # "611752105020343687/cache/611752105020343687_8162774327817435.wav",
- # "611752105020343699/cache/611752105020343699_1125899914308640.wav",
- # "611752105020351134/cache/611752105020351134_10414574138721494.wav",
- # "611752105020357112/cache/611752105020357112_8162774327817435.wav",
- # "611752105020378620/cache/611752105020378620_8162774327817435.wav",
- # "611752105020387015/cache/611752105020387015_1125899914308640.wav",
- # "611752105020394121/cache/611752105020394121_1125899914308640.wav",
- # "611752105020394297/cache/611752105020394297_3634463651.wav",
- # "611752105020411654/cache/611752105020411654_3096224751151928.wav",
- # "611752105020417688/cache/611752105020417688_12947848931397021.wav",
- # "611752105020563523/cache/611752105020563523_8162774327817435.wav",
- # "611752105021332759/cache/611752105021332759_3634463651.wav",
- # "611752105022446809/cache/611752105022446809_8162774327817435.wav",
- # "611752105022647082/cache/611752105022647082_8162774327817435.wav",
- # "611752105022667231/cache/611752105022667231_8162774327817435.wav",
- # "611752105022735101/cache/611752105022735101_5066549357604730.wav",
- # "611752105022736204/cache/611752105022736204_1125899914308640.wav",
- # "611752105022745595/cache/611752105022745595_10414574138721494.wav",
- # "611752105022770952/cache/611752105022770952_1125899914308640.wav",
- # "611752105022842004/cache/611752105022842004_3634463651.wav",
- # "611752105022842477/cache/611752105022842477_1125899914308640.wav",
- # "611752105023434557/cache/611752105023434557_6755399374234747.wav",
- # "611752105023532439/cache/611752105023532439_8162774329368194.wav",
- # "611752105023623965/cache/611752105023623965_3096224748076687.wav",
- # "611752105024250202/cache/611752105024250202_8162774327817435.wav",
- # "611752105024628047/cache/611752105024628047_5066549357604730.wav",
- # "611752105024676794/cache/611752105024676794_6755399442719465.wav",
- # "611752105024678976/cache/611752105024678976_6755399442719465.wav",
- # "611752105024679221/cache/611752105024679221_8162774329368194.wav",
- # "611752105024953316/cache/611752105024953316_1688849864840588.wav",
- # "611752105025104181/cache/611752105025104181_6755399374234747.wav",
- # "611752105026189342/cache/611752105026189342_5910973794723621.wav",
- # "611752105026523547/cache/611752105026523547_1125899914308640.wav",
- # "611752105026707760/cache/611752105026707760_3096224748076687.wav",
- # "611752105026771723/cache/611752105026771723_8162774327817435.wav",
- # "611752105026946178/cache/611752105026946178_10414574140317353.wav",
- # "611752105027047993/cache/611752105027047993_5066549357604730.wav",
- # "611752105027188746/cache/611752105027188746_5066549357604730.wav",
- # "611752105027189453/cache/611752105027189453_8162774329368194.wav",
- # "611752105027302268/cache/611752105027302268_5066549357604730.wav",
- # "611752105027557408/cache/611752105027557408_1125899914308640.wav",
- # "611752105028650636/cache/611752105028650636_8162774327817435.wav",
- # "611752105028683824/cache/611752105028683824_1125899914308640.wav",
- # "611752105029990849/cache/611752105029990849_7036874421386111.wav",
- # "611752105029993297/cache/611752105029993297_6755399374234747.wav",
- # "611752105030077711/cache/611752105030077711_3096224748076687.wav",
- # "611752105030104548/cache/611752105030104548_5629499489839033.wav",
- # "611752105030419624/cache/611752105030419624_8162774327817435.wav",
- # "611752105030419633/cache/611752105030419633_1125899914308640.wav",
- # "611752105030419688/cache/611752105030419688_1125899914308640.wav",
- # "611752105030433779/cache/611752105030433779_3634463651.wav"
- # ]
-
- arr = [
- "611752105020256284/cache/611752105020256284_8162774329368194.wav",
- "611752105020286433/cache/611752105020286433_1125899914308640.wav",
- "611752105020286443/cache/611752105020286443_12384898975368914.wav",
- "611752105020286446/cache/611752105020286446_5629499489839033.wav",
- "611752105020290639/cache/611752105020290639_3634463651.wav",
- "611752105020290695/cache/611752105020290695_1125899914308640.wav",
- "611752105020315328/cache/611752105020315328_8162774329368194.wav",
- "611752105020315368/cache/611752105020315368_1688849864840588.wav",
- "611752105020336950/cache/611752105020336950_3634463651.wav",
- "611752105020343687/cache/611752105020343687_8162774327817435.wav"
- ]
- s_inst = SongCoverInference()
- for vocal_file in arr:
- sstime = time.time()
- i_file = os.path.join(base_dir, vocal_file)
- cur_dir = "/".join(i_file.split("/")[:-1])
- # e_file = os.path.join(base_dir, vocal_file.replace(".wav", "_dev_441.wav"))
- # e_file = os.path.join(base_dir, vocal_file.replace(".wav", "_442_dr.wav"))
- e_file = os.path.join(base_dir, vocal_file.replace(".wav", "_442_dr_v2.wav"))
- v_file = os.path.join(cur_dir, "vocal.wav")
- a_file = os.path.join(cur_dir, "acc.wav")
- cur_id = cur_dir.split("/")[-1]
- err = s_inst.after_process(cur_id, cur_dir, i_file, e_file, v_file, a_file, True, False)
- print("err={}, sp={}".format(err, time.time() - sstime))
-
-
-def get_metop500():
- arr = [
- "611752105030249067",
- "611752105030248972",
- "611752105030249414",
- "611752105030249374",
- "611752105030249030",
- "611752105030249127",
- "611752105030249091",
- "611752105030249233",
- "611752105030249036",
- "611752105030249281",
- "611752105030249040",
- "611752105030249052",
- "611752105030249394",
- "611752105030249347",
- "611752105030249342",
- "611752105030249282",
- "611752105030249292",
- "611752105030249356",
- "611752105030249302",
- "611752105030249377",
- "611752105030248973",
- "611752105030249393",
- "611752105030249398",
- "611752105030250695",
- "611752105030249213",
- "611752105030250739",
- "611752105030249206",
- "611752105030249074",
- "611752105030249387",
- "611752105030250702",
- "611752105030249365",
- "611752105030249011",
- "611752105030249319",
- "611752105030249016",
- "611752105030249176",
- "611752105030250690",
- "611752105030250691",
- "611752105030249032",
- "611752105030249370",
- "611752105030249410",
- "611752105030249355",
- "611752105030250730",
- "611752105030249022",
- "611752105030249240",
- "611752105030249296",
- "611752105030249070",
- "611752105030249322",
- "611752105030249402",
- "611752105030249386",
- "611752105030249280",
- "611752105030249038",
- "611752105030250743",
- "611752105030249136",
- "611752105030249034",
- "611752105030249403",
- "611752105030249104",
- "611752105030249105",
- "611752105030249359",
- "611752105030250728",
- "611752105030249338",
- "611752105030249216",
- "611752105030249334",
- "611752105030249037",
- "611752105030249264",
- "611752105030249284",
- "611752105030249267",
- "611752105030249010",
- "611752105030249431",
- "611752105030249364",
- "611752105030249243",
- "611752105030249397",
- "611752105030249041",
- "611752105030249118",
- "611752105030249283",
- "611752105030249340",
- "611752105030249250",
- "611752105030249048",
- "611752105030249336",
- "611752105030249371",
- "611752105030249372",
- "611752105030249273",
- "611752105030249366",
- "611752105030249352",
- "611752105030249049",
- "611752105030249278",
- "611752105030249401",
- "611752105030249258",
- "611752105030249160",
- "611752105030249348",
- "611752105030249071",
- "611752105030249175",
- "611752105030249053",
- "611752105030249035",
- "611752105030249375",
- "611752105030249417",
- "611752105030249055",
- "611752105030249275",
- "611752105030249177",
- "611752105028480653",
- "611752105030249385",
- "611752105030249406",
- "611752105030249383",
- "611752105030249295",
- "611752105030250699",
- "611752105030249289",
- "611752105030248965",
- "611752105030249128",
- "611752105030249173",
- "611752105030249019",
- "611752105030249333",
- "611752105030249361",
- "611752105030250733",
- "611752105030249112",
- "611752105030249293",
- "611752105030249391",
- "611752105030249195",
- "611752105030249324",
- "611752105030249388",
- "611752105030249134",
- "611752105030249073",
- "611752105030249174",
- "611752105030249353",
- "611752105030249287",
- "611752105030249113",
- "611752105030249227"
- ]
- all = [
- "611752105026649069",
- "611752105027201163",
- "611752105027601574",
- "611752105027602999",
- "611752105028392007",
- "611752105028480056",
- "611752105028480075",
- "611752105028480653",
- "611752105029330944",
- "611752105029790637",
- "611752105029951597",
- "611752105029951604",
- "611752105029951624",
- "611752105029956352",
- "611752105030248965",
- "611752105030248971",
- "611752105030248972",
- "611752105030248973",
- "611752105030248974",
- "611752105030248975",
- "611752105030248976",
- "611752105030248977",
- "611752105030248978",
- "611752105030248979",
- "611752105030248980",
- "611752105030248981",
- "611752105030248982",
- "611752105030248983",
- "611752105030248985",
- "611752105030248986",
- "611752105030248987",
- "611752105030248988",
- "611752105030248989",
- "611752105030248990",
- "611752105030248991",
- "611752105030248992",
- "611752105030248993",
- "611752105030248994",
- "611752105030248995",
- "611752105030248996",
- "611752105030248997",
- "611752105030248998",
- "611752105030248999",
- "611752105030249000",
- "611752105030249001",
- "611752105030249002",
- "611752105030249003",
- "611752105030249004",
- "611752105030249005",
- "611752105030249006",
- "611752105030249007",
- "611752105030249008",
- "611752105030249009",
- "611752105030249010",
- "611752105030249011",
- "611752105030249012",
- "611752105030249013",
- "611752105030249014",
- "611752105030249015",
- "611752105030249016",
- "611752105030249017",
- "611752105030249018",
- "611752105030249019",
- "611752105030249020",
- "611752105030249021",
- "611752105030249022",
- "611752105030249023",
- "611752105030249024",
- "611752105030249025",
- "611752105030249026",
- "611752105030249027",
- "611752105030249028",
- "611752105030249029",
- "611752105030249030",
- "611752105030249031",
- "611752105030249032",
- "611752105030249033",
- "611752105030249034",
- "611752105030249035",
- "611752105030249036",
- "611752105030249037",
- "611752105030249038",
- "611752105030249039",
- "611752105030249040",
- "611752105030249041",
- "611752105030249042",
- "611752105030249043",
- "611752105030249044",
- "611752105030249045",
- "611752105030249046",
- "611752105030249047",
- "611752105030249048",
- "611752105030249049",
- "611752105030249050",
- "611752105030249051",
- "611752105030249052",
- "611752105030249053",
- "611752105030249054",
- "611752105030249055",
- "611752105030249056",
- "611752105030249057",
- "611752105030249058",
- "611752105030249059",
- "611752105030249060",
- "611752105030249062",
- "611752105030249063",
- "611752105030249064",
- "611752105030249065",
- "611752105030249067",
- "611752105030249068",
- "611752105030249070",
- "611752105030249071",
- "611752105030249072",
- "611752105030249073",
- "611752105030249074",
- "611752105030249075",
- "611752105030249076",
- "611752105030249077",
- "611752105030249078",
- "611752105030249079",
- "611752105030249080",
- "611752105030249081",
- "611752105030249082",
- "611752105030249083",
- "611752105030249084",
- "611752105030249085",
- "611752105030249086",
- "611752105030249087",
- "611752105030249088",
- "611752105030249089",
- "611752105030249090",
- "611752105030249091",
- "611752105030249092",
- "611752105030249093",
- "611752105030249094",
- "611752105030249095",
- "611752105030249096",
- "611752105030249098",
- "611752105030249099",
- "611752105030249100",
- "611752105030249101",
- "611752105030249102",
- "611752105030249103",
- "611752105030249104",
- "611752105030249105",
- "611752105030249106",
- "611752105030249107",
- "611752105030249108",
- "611752105030249109",
- "611752105030249110",
- "611752105030249111",
- "611752105030249112",
- "611752105030249113",
- "611752105030249114",
- "611752105030249115",
- "611752105030249116",
- "611752105030249117",
- "611752105030249118",
- "611752105030249119",
- "611752105030249120",
- "611752105030249121",
- "611752105030249122",
- "611752105030249123",
- "611752105030249124",
- "611752105030249125",
- "611752105030249126",
- "611752105030249127",
- "611752105030249128",
- "611752105030249129",
- "611752105030249130",
- "611752105030249131",
- "611752105030249132",
- "611752105030249133",
- "611752105030249134",
- "611752105030249135",
- "611752105030249136",
- "611752105030249137",
- "611752105030249138",
- "611752105030249139",
- "611752105030249140",
- "611752105030249141",
- "611752105030249142",
- "611752105030249143",
- "611752105030249144",
- "611752105030249145",
- "611752105030249146",
- "611752105030249147",
- "611752105030249148",
- "611752105030249150",
- "611752105030249151",
- "611752105030249152",
- "611752105030249153",
- "611752105030249154",
- "611752105030249155",
- "611752105030249157",
- "611752105030249158",
- "611752105030249159",
- "611752105030249160",
- "611752105030249161",
- "611752105030249162",
- "611752105030249163",
- "611752105030249165",
- "611752105030249166",
- "611752105030249167",
- "611752105030249168",
- "611752105030249170",
- "611752105030249171",
- "611752105030249172",
- "611752105030249173",
- "611752105030249174",
- "611752105030249175",
- "611752105030249176",
- "611752105030249177",
- "611752105030249178",
- "611752105030249179",
- "611752105030249180",
- "611752105030249181",
- "611752105030249182",
- "611752105030249183",
- "611752105030249185",
- "611752105030249186",
- "611752105030249187",
- "611752105030249188",
- "611752105030249189",
- "611752105030249190",
- "611752105030249191",
- "611752105030249192",
- "611752105030249193",
- "611752105030249194",
- "611752105030249195",
- "611752105030249196",
- "611752105030249197",
- "611752105030249198",
- "611752105030249199",
- "611752105030249200",
- "611752105030249201",
- "611752105030249202",
- "611752105030249203",
- "611752105030249204",
- "611752105030249205",
- "611752105030249206",
- "611752105030249207",
- "611752105030249208",
- "611752105030249209",
- "611752105030249210",
- "611752105030249211",
- "611752105030249212",
- "611752105030249213",
- "611752105030249214",
- "611752105030249216",
- "611752105030249217",
- "611752105030249218",
- "611752105030249219",
- "611752105030249220",
- "611752105030249221",
- "611752105030249223",
- "611752105030249224",
- "611752105030249225",
- "611752105030249226",
- "611752105030249227",
- "611752105030249228",
- "611752105030249229",
- "611752105030249230",
- "611752105030249231",
- "611752105030249232",
- "611752105030249233",
- "611752105030249234",
- "611752105030249235",
- "611752105030249236",
- "611752105030249237",
- "611752105030249238",
- "611752105030249239",
- "611752105030249240",
- "611752105030249241",
- "611752105030249242",
- "611752105030249243",
- "611752105030249244",
- "611752105030249245",
- "611752105030249247",
- "611752105030249248",
- "611752105030249249",
- "611752105030249250",
- "611752105030249251",
- "611752105030249252",
- "611752105030249253",
- "611752105030249255",
- "611752105030249256",
- "611752105030249257",
- "611752105030249258",
- "611752105030249259",
- "611752105030249260",
- "611752105030249261",
- "611752105030249262",
- "611752105030249264",
- "611752105030249265",
- "611752105030249266",
- "611752105030249267",
- "611752105030249269",
- "611752105030249270",
- "611752105030249271",
- "611752105030249273",
- "611752105030249274",
- "611752105030249275",
- "611752105030249277",
- "611752105030249278",
- "611752105030249279",
- "611752105030249280",
- "611752105030249281",
- "611752105030249282",
- "611752105030249283",
- "611752105030249284",
- "611752105030249287",
- "611752105030249288",
- "611752105030249289",
- "611752105030249290",
- "611752105030249292",
- "611752105030249293",
- "611752105030249294",
- "611752105030249295",
- "611752105030249296",
- "611752105030249297",
- "611752105030249298",
- "611752105030249299",
- "611752105030249300",
- "611752105030249301",
- "611752105030249302",
- "611752105030249303",
- "611752105030249307",
- "611752105030249308",
- "611752105030249309",
- "611752105030249310",
- "611752105030249313",
- "611752105030249314",
- "611752105030249315",
- "611752105030249316",
- "611752105030249317",
- "611752105030249318",
- "611752105030249319",
- "611752105030249320",
- "611752105030249321",
- "611752105030249322",
- "611752105030249323",
- "611752105030249324",
- "611752105030249325",
- "611752105030249327",
- "611752105030249328",
- "611752105030249329",
- "611752105030249330",
- "611752105030249331",
- "611752105030249332",
- "611752105030249333",
- "611752105030249334",
- "611752105030249336",
- "611752105030249337",
- "611752105030249338",
- "611752105030249339",
- "611752105030249340",
- "611752105030249341",
- "611752105030249342",
- "611752105030249343",
- "611752105030249344",
- "611752105030249345",
- "611752105030249346",
- "611752105030249347",
- "611752105030249348",
- "611752105030249349",
- "611752105030249350",
- "611752105030249351",
- "611752105030249352",
- "611752105030249353",
- "611752105030249354",
- "611752105030249355",
- "611752105030249356",
- "611752105030249357",
- "611752105030249358",
- "611752105030249359",
- "611752105030249360",
- "611752105030249361",
- "611752105030249362",
- "611752105030249363",
- "611752105030249364",
- "611752105030249365",
- "611752105030249366",
- "611752105030249367",
- "611752105030249368",
- "611752105030249369",
- "611752105030249370",
- "611752105030249371",
- "611752105030249372",
- "611752105030249373",
- "611752105030249374",
- "611752105030249375",
- "611752105030249376",
- "611752105030249377",
- "611752105030249378",
- "611752105030249379",
- "611752105030249380",
- "611752105030249381",
- "611752105030249383",
- "611752105030249384",
- "611752105030249385",
- "611752105030249386",
- "611752105030249387",
- "611752105030249388",
- "611752105030249389",
- "611752105030249390",
- "611752105030249391",
- "611752105030249392",
- "611752105030249393",
- "611752105030249394",
- "611752105030249395",
- "611752105030249396",
- "611752105030249397",
- "611752105030249398",
- "611752105030249399",
- "611752105030249401",
- "611752105030249402",
- "611752105030249403",
- "611752105030249404",
- "611752105030249405",
- "611752105030249406",
- "611752105030249407",
- "611752105030249408",
- "611752105030249409",
- "611752105030249410",
- "611752105030249412",
- "611752105030249413",
- "611752105030249414",
- "611752105030249415",
- "611752105030249416",
- "611752105030249417",
- "611752105030249418",
- "611752105030249419",
- "611752105030249420",
- "611752105030249421",
- "611752105030249431",
- "611752105030249624",
- "611752105030250688",
- "611752105030250689",
- "611752105030250690",
- "611752105030250691",
- "611752105030250692",
- "611752105030250693",
- "611752105030250695",
- "611752105030250697",
- "611752105030250698",
- "611752105030250699",
- "611752105030250700",
- "611752105030250701",
- "611752105030250702",
- "611752105030250704",
- "611752105030250707",
- "611752105030250711",
- "611752105030250712",
- "611752105030250713",
- "611752105030250714",
- "611752105030250715",
- "611752105030250716",
- "611752105030250717",
- "611752105030250718",
- "611752105030250719",
- "611752105030250720",
- "611752105030250721",
- "611752105030250723",
- "611752105030250725",
- "611752105030250726",
- "611752105030250728",
- "611752105030250729",
- "611752105030250730",
- "611752105030250731",
- "611752105030250732",
- "611752105030250733",
- "611752105030250735",
- "611752105030250736",
- "611752105030250738",
- "611752105030250739",
- "611752105030250740",
- "611752105030250741",
- "611752105030250742",
- "611752105030250743"
- ]
-
- new_arr = []
- for sid in all:
- if sid in arr:
- continue
- new_arr.append(sid)
- print("len={}".format(len(new_arr)))
- return new_arr
-
-
-def get_me_3_w4_zy():
- arr = [
- "611752105015523266",
- "611752105016527562",
- "611752105017233541",
- "611752105019423720",
- "611752105030113709",
- "611752105030414513",
- "611752105030414549",
- "611752105030414557",
- "611752105030414568",
- "611752105030414576",
- "611752105030414580",
- "611752105030414584",
- "611752105030414588",
- "611752105030414590",
- "611752105030414597",
- "611752105030414600",
- "611752105030414608",
- "611752105030414613",
- "611752105030414615",
- "611752105030414619",
- "611752105030414633",
- "611752105030414638",
- "611752105030414644",
- "611752105030414647",
- "611752105030414655",
- "611752105030414660",
- "611752105030414663",
- "611752105030414669",
- "611752105030414674",
- "611752105030414678",
- "611752105030414680",
- "611752105030414682",
- "611752105030414686",
- "611752105030414689",
- "611752105030414696",
- "611752105030414702",
- "611752105030414706",
- "611752105030414707",
- "611752105030414711",
- "611752105030414717",
- "611752105030414729",
- "611752105030414742",
- "611752105030414752",
- "611752105030414757",
- "611752105030414761",
- "611752105030414763",
- "611752105030414766",
- "611752105030414773",
- "611752105030414776",
- "611752105030414777",
- "611752105030414779",
- "611752105030414784",
- "611752105030414890",
- "611752105030414907",
- "611752105030414915",
- "611752105030414919",
- "611752105030414925",
- "611752105030414929",
- "611752105030414932",
- "611752105030414935",
- "611752105030414937",
- "611752105030414943",
- "611752105030414948",
- "611752105030414949",
- "611752105030414957",
- "611752105030414962",
- "611752105030414963",
- "611752105030414968",
- "611752105030414973",
- "611752105030414976",
- "611752105030414981",
- "611752105030414986",
- "611752105030414988",
- "611752105030414990",
- "611752105030414993",
- "611752105030414995",
- "611752105030415003",
- "611752105030415007",
- "611752105030415009",
- "611752105030415014",
- "611752105030415018",
- "611752105030415032",
- "611752105030415044",
- "611752105030415050",
- "611752105030415052",
- "611752105030415056",
- "611752105030415058",
- "611752105030415062",
- "611752105030415067",
- "611752105030415071",
- "611752105030415074",
- "611752105030415078",
- "611752105030415083",
- "611752105030415087",
- "611752105030415094",
- "611752105030415100",
- "611752105030415103",
- "611752105030425986",
- "611752105030426004"
- ]
- return arr
-
-
-def generate_arr():
- # arr = [
- # "611752105020256284",
- # "611752105020282612",
- # "611752105020282613",
- # "611752105020286433",
- # "611752105020286443",
- # "611752105020286446",
- # "611752105020286501",
- # "611752105020290639",
- # "611752105020290695",
- # "611752105020315328",
- # "611752105020315368",
- # "611752105020325137",
- # "611752105020336946",
- # "611752105020336950",
- # "611752105020343687",
- # "611752105020343699",
- # "611752105020350988",
- # "611752105020350990",
- # "611752105020351134",
- # "611752105020357112",
- # "611752105020376320",
- # "611752105020378620",
- # "611752105020382559",
- # "611752105020387015",
- # "611752105020390950",
- # "611752105020394121",
- # "611752105020394297",
- # "611752105020411654",
- # "611752105020417488",
- # "611752105020417688",
- # "611752105020548211",
- # "611752105020563523",
- # "611752105021273980",
- # "611752105021285282",
- # "611752105021330812",
- # "611752105021332759",
- # "611752105021375100",
- # "611752105021442406",
- # "611752105021442417",
- # "611752105021453011",
- # "611752105022345104",
- # "611752105022389596",
- # "611752105022446809",
- # "611752105022647082",
- # "611752105022667231",
- # "611752105022735101",
- # "611752105022736204",
- # "611752105022745595",
- # "611752105022770952",
- # "611752105022842004",
- # "611752105022842477",
- # "611752105023434557",
- # "611752105023532439",
- # "611752105023623965",
- # "611752105023811083",
- # "611752105024250202",
- # "611752105024429936",
- # "611752105024628047",
- # "611752105024676794",
- # "611752105024678976",
- # "611752105024679221",
- # "611752105024714646",
- # "611752105024786030",
- # "611752105024953316",
- # "611752105025104181",
- # "611752105025231610",
- # "611752105025510149",
- # "611752105026189342",
- # "611752105026523547",
- # "611752105026707760",
- # "611752105026771723",
- # "611752105026946178",
- # "611752105027047993",
- # "611752105027188746",
- # "611752105027189453",
- # "611752105027302268",
- # "611752105027557408",
- # "611752105027588072",
- # "611752105028650636",
- # "611752105028683824",
- # "611752105029689090",
- # "611752105029954089",
- # "611752105029954168",
- # "611752105029955214",
- # "611752105029990849",
- # "611752105029993297",
- # "611752105030047424",
- # "611752105030077711",
- # "611752105030104548",
- # "611752105030419624",
- # "611752105030419633",
- # "611752105030419688",
- # "611752105030433779"
- # ]
-
- # arr = get_metop500()
- arr = get_me_3_w4_zy()
- s_inst = SongCoverInference()
- for sid in arr:
- sstime = time.time()
- dir = os.path.join("/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_3_w4_zy", sid)
- # dir = os.path.join("/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_top500", sid)
- err = s_inst.process_one(sid, dir, True)
- print("sid={}, err={}, sp={}".format(sid, err, time.time() - sstime))
-
-
-def test_rate():
- arr = [
- "611752105020256284",
- "611752105020286433",
- "611752105020286443",
- "611752105020286446",
- "611752105020290639",
- "611752105020290695",
- "611752105020315328",
- "611752105020315368",
- "611752105020336950",
- "611752105020343687",
- "611752105020343699",
- "611752105020351134",
- "611752105020357112",
- "611752105020378620",
- "611752105020387015",
- "611752105020394121",
- "611752105020394297",
- "611752105020411654",
- "611752105020417688",
- "611752105020548211",
- "611752105020563523",
- "611752105021285282",
- "611752105021332759",
- "611752105022446809",
- "611752105022647082",
- "611752105022667231",
- "611752105022735101",
- "611752105022736204",
- "611752105022745595",
- "611752105022770952",
- "611752105022842004",
- "611752105022842477",
- "611752105023434557",
- "611752105023532439",
- "611752105023623965",
- "611752105024250202",
- "611752105024628047",
- "611752105024676794",
- "611752105024678976",
- "611752105024679221",
- "611752105024953316",
- "611752105025104181",
- "611752105026189342",
- "611752105026523547",
- "611752105026707760",
- "611752105026771723",
- "611752105026946178",
- "611752105027047993",
- "611752105027188746",
- "611752105027189453",
- "611752105027302268",
- "611752105027557408",
- "611752105028650636",
- "611752105028683824",
- "611752105029990849",
- "611752105029993297",
- "611752105030077711",
- "611752105030104548",
- "611752105030419624",
- "611752105030419633",
- "611752105030419688",
- "611752105030433779"
- ]
- s_inst = SongCoverInference()
- for sid in arr:
- vocal_path = "data/inf_users/me_3_w4/{}/cache/vocal.wav".format(sid)
- tm = s_inst.get_start_ms(vocal_path)
- print("res,{},{}".format(vocal_path, tm))
-
-
-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 = s_inst.process_one(cid, os.path.join(base_dir, cid), False)
- print("cid={} RealFinish err={} sp={}".format(cid, err, time.time() - st))
-
-
-if __name__ == '__main__':
- test()
- # test_rate()
- # test_volume_dir()
- # generate_arr()
- # test_volume_dir()
- # s_inst = SongCoverInference()
- # sstime = time.time()
- # err = s_inst.process_one("611752105030249038",
- # "/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_top500/611752105030249038", False)
- # # i_file = "/data/rsync/jianli.yang/AutoCoverTool/data/out_data/me_top500/611752105030249121/611752105030249121_5629499489839033.wav"
- # # e_file = "/data/rsync/jianli.yang/AutoCoverTool/data/out_data/me_top500/611752105030249121/611752105030249121_5629499489839033.wav"
- # # v_file = "/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_top500/611752105030249121/vocal.wav"
- # # a_file = "/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_top500/611752105030249121/acc.wav"
- # # w_dir = "/data/rsync/jianli.yang/AutoCoverTool/data/inf_users/me_top500/611752105030249121"
- # #
- # # err = s_inst.after_process("611752105030248965", w_dir, i_file, e_file, v_file, a_file)
- # print("err={}, sp={}".format(err, time.time() - sstime))

File Metadata

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

Event Timeline