-
Notifications
You must be signed in to change notification settings - Fork 9
/
nodes.py
257 lines (223 loc) · 9.47 KB
/
nodes.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
import os
import random
import torch
import ffmpeg
import hashlib
import folder_paths
from huggingface_hub import hf_hub_download
from .uvr5.mdxnet import MDXNetDereverb
from .uvr5.vr import AudioPre, AudioPreDeEcho
from cuda_malloc import cuda_malloc_supported
input_path = folder_paths.get_input_directory()
output_path = folder_paths.get_output_directory()
base_path = os.path.dirname(input_path)
node_path = os.path.join(base_path,"custom_nodes/ComfyUI-UVR5")
weights_path = os.path.join(node_path, "uvr5")
device= "cuda" if cuda_malloc_supported() else "cpu"
is_half=True
class PreViewAudio:
@classmethod
def INPUT_TYPES(s):
return {"required":
{"audio": ("AUDIOPATH",),}
}
CATEGORY = "AIFSH_UVR5"
DESCRIPTION = "hello world!"
RETURN_TYPES = ()
OUTPUT_NODE = True
FUNCTION = "load_audio"
def load_audio(self, audio):
audio_name = os.path.basename(audio)
tmp_path = os.path.dirname(audio)
audio_root = os.path.basename(tmp_path)
return {"ui": {"audio":[audio_name,audio_root]}}
@classmethod
def IS_CHANGED(s, audio):
audio_path = folder_paths.get_annotated_filepath(audio)
m = hashlib.sha256()
with open(audio_path, 'rb') as f:
m.update(f.read())
return m.digest().hex()
class LoadAudioPath:
@classmethod
def INPUT_TYPES(s):
input_dir = input_path
files = [f for f in os.listdir(input_dir) if os.path.isfile(os.path.join(input_dir, f)) and f.split('.')[-1].lower() in ["wav", "mp3","flac","m4a"]]
return {"required":
{"audio": (sorted(files),)},
}
CATEGORY = "AIFSH_UVR5"
RETURN_TYPES = ("AUDIOPATH",)
FUNCTION = "load_audio"
def load_audio(self, audio):
audio_path = folder_paths.get_annotated_filepath(audio)
print(audio_path)
return (audio_path,)
@classmethod
def IS_CHANGED(s, audio):
audio_path = folder_paths.get_annotated_filepath(audio)
m = hashlib.sha256()
with open(audio_path, 'rb') as f:
m.update(f.read())
return m.digest().hex()
class UVR5:
"""
A example node
Class methods
-------------
INPUT_TYPES (dict):
Tell the main program input parameters of nodes.
IS_CHANGED:
optional method to control when the node is re executed.
Attributes
----------
RETURN_TYPES (`tuple`):
The type of each element in the output tulple.
RETURN_NAMES (`tuple`):
Optional: The name of each output in the output tulple.
FUNCTION (`str`):
The name of the entry-point method. For example, if `FUNCTION = "execute"` then it will run Example().execute()
OUTPUT_NODE ([`bool`]):
If this node is an output node that outputs a result/image from the graph. The SaveImage node is an example.
The backend iterates on these output nodes and tries to execute all their parents if their parent graph is properly connected.
Assumed to be False if not present.
CATEGORY (`str`):
The category the node should appear in the UI.
execute(s) -> tuple || None:
The entry point method. The name of this method must be the same as the value of property `FUNCTION`.
For example, if `FUNCTION = "execute"` then this method's name must be `execute`, if `FUNCTION = "foo"` then it must be `foo`.
"""
def __init__(self):
pass
@classmethod
def INPUT_TYPES(s):
"""
Return a dictionary which contains config for all input fields.
Some types (string): "MODEL", "VAE", "CLIP", "CONDITIONING", "LATENT", "IMAGE", "INT", "STRING", "FLOAT".
Input types "INT", "STRING" or "FLOAT" are special values for fields on the node.
The type can be a list for selection.
Returns: `dict`:
- Key input_fields_group (`string`): Can be either required, hidden or optional. A node class must have property `required`
- Value input_fields (`dict`): Contains input fields config:
* Key field_name (`string`): Name of a entry-point method's argument
* Value field_config (`tuple`):
+ First value is a string indicate the type of field or a list for selection.
+ Secound value is a config for type "INT", "STRING" or "FLOAT".
"""
model_list = ["HP5_only_main_vocal.pth","HP5-主旋律人声vocals+其他instrumentals.pth","HP5_only_main_vocal.pth",
"HP2_all_vocals.pth","HP2-人声vocals+非人声instrumentals.pth","HP3_all_vocals.pth",
"VR-DeEchoAggressive.pth","VR-DeEchoDeReverb.pth","VR-DeEchoNormal.pth","onnx_dereverb_By_FoxJoy"]
return {
"required": {
"audio": ("AUDIOPATH",),
"model": (model_list,{
"default": "HP5-主旋律人声vocals+其他instrumentals.pth"
}),
"agg":("INT",{
"default": 10,
"min": 0, #Minimum value
"max": 20, #Maximum value
"step": 1, #Slider's step
"display": "slider"
}),
"format0":(["wav", "flac", "mp3", "m4a"],{
"default": "wav"
})
},
}
RETURN_TYPES = ("AUDIOPATH","AUDIOPATH")
RETURN_NAMES = ("vocal_AUDIO","bgm_AUDIO")
FUNCTION = "split"
#OUTPUT_NODE = False
CATEGORY = "AIFSH_UVR5"
def split(self, audio, model,agg,format0):
if model == "onnx_dereverb_By_FoxJoy":
if not os.path.isfile(os.path.join(weights_path,"uvr5_weights/onnx_dereverb_By_FoxJoy", "vocals.onnx")):
hf_hub_download(
repo_id="lj1995/VoiceConversionWebUI",
filename="vocals.onnx",
subfolder= "uvr5_weights/onnx_dereverb_By_FoxJoy",
local_dir= weights_path
)
else:
if not os.path.isfile(os.path.join(weights_path,"uvr5_weights", model)):
hf_hub_download(
repo_id="lj1995/VoiceConversionWebUI",
filename=model,
subfolder= "uvr5_weights",
local_dir= weights_path
)
save_root_vocal = output_path
save_root_ins = output_path
vocal_AUDIO,bgm_AUDIO = self.uvr(model, audio, save_root_vocal,save_root_ins,agg, format0)
return (vocal_AUDIO,bgm_AUDIO,)
def uvr(self, model_name, inp_root, save_root_vocal,save_root_ins, agg, format0):
vocal_AUDIO,bgm_AUDIO = "", ""
inp_root = inp_root.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
save_root_vocal = (
save_root_vocal.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
)
save_root_ins = (
save_root_ins.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
)
is_hp3 = "HP3" in model_name
if model_name == "onnx_dereverb_By_FoxJoy":
pre_fun = MDXNetDereverb(15)
else:
func = AudioPre if "DeEcho" not in model_name else AudioPreDeEcho
pre_fun = func(
agg=int(agg),
model_path=os.path.join(weights_path, "uvr5_weights",model_name),
device=device,
is_half=is_half,
)
inp_path = inp_root
need_reformat = 1
done = 0
info = ffmpeg.probe(inp_path, cmd="ffprobe")
if (
info["streams"][0]["channels"] == 2
and info["streams"][0]["sample_rate"] == "44100"
):
need_reformat = 0
vocal_AUDIO,bgm_AUDIO = pre_fun._path_audio_(
inp_path, save_root_ins, save_root_vocal, format0,is_hp3
)
done = 1
else:
need_reformat = 1
if need_reformat == 1:
tmp_path = "%s/%s.reformatted.wav" % (
input_path,
os.path.basename(inp_path),
)
os.system(
f'ffmpeg -i "{inp_path}" -vn -acodec pcm_s16le -ac 2 -ar 44100 "{tmp_path}" -y'
)
inp_path = tmp_path
if done == 0:
vocal_AUDIO,bgm_AUDIO = pre_fun._path_audio_(
inp_path, save_root_ins, save_root_vocal, format0,is_hp3
)
print("%s->Success" % (os.path.basename(inp_path)))
try:
if model_name == "onnx_dereverb_By_FoxJoy":
del pre_fun.pred.model
del pre_fun.pred.model_
else:
del pre_fun.model
del pre_fun
except:
pass
print("clean_empty_cache")
if torch.cuda.is_available():
torch.cuda.empty_cache()
return vocal_AUDIO,bgm_AUDIO
"""
The node will always be re executed if any of the inputs change but
this method can be used to force the node to execute again even when the inputs don't change.
You can make this node return a number or a string. This value will be compared to the one returned the last time the node was
executed, if it is different the node will be executed again.
This method is used in the core repo for the LoadImage node where they return the image hash as a string, if the image hash
changes between executions the LoadImage node is executed again.
"""