Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

Remove torchaudio dependency. (#16457)

comfyanonymousb16023b004d3
diff --git a/.github/workflows/ruff.yml b/.github/workflows/ruff.yml
index b24d86a6b..aa82525c2 100644
--- a/.github/workflows/ruff.yml
+++ b/.github/workflows/ruff.yml
@@ -38,7 +38,7 @@ jobs:
- name: Install requirements
run: |
python -m pip install --upgrade pip
- pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+ pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install -r requirements.txt
- name: Install Pylint
diff --git a/.github/workflows/test-execution.yml b/.github/workflows/test-execution.yml
index 9012633d8..17e8ebb43 100644
--- a/.github/workflows/test-execution.yml
+++ b/.github/workflows/test-execution.yml
@@ -22,7 +22,7 @@ jobs:
- name: Install requirements
run: |
python -m pip install --upgrade pip
- pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+ pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install -r requirements.txt
pip install -r tests-unit/requirements.txt
- name: Run Execution Tests
diff --git a/.github/workflows/test-launch.yml b/.github/workflows/test-launch.yml
index 581c0474b..cfb4d559e 100644
--- a/.github/workflows/test-launch.yml
+++ b/.github/workflows/test-launch.yml
@@ -21,7 +21,7 @@ jobs:
- name: Install requirements
run: |
python -m pip install --upgrade pip
- pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+ pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install -r requirements.txt
pip install wait-for-it
working-directory: ComfyUI
diff --git a/.github/workflows/test-unit.yml b/.github/workflows/test-unit.yml
index d05179cd3..73850b441 100644
--- a/.github/workflows/test-unit.yml
+++ b/.github/workflows/test-unit.yml
@@ -22,7 +22,7 @@ jobs:
- name: Install requirements
run: |
python -m pip install --upgrade pip
- pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+ pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install -r requirements.txt
- name: Run Unit Tests
run: |
diff --git a/comfy/audio.py b/comfy/audio.py
new file mode 100644
index 000000000..5bf7b85a7
--- /dev/null
+++ b/comfy/audio.py
@@ -0,0 +1,213 @@
+# Audio DSP adapted from TorchAudio (BSD-2-Clause).
+# BSD 2-Clause License
+#
+# Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import math
+
+import numpy as np
+import scipy.signal
+import torch
+import torch.nn.functional as F
+
+
+def resample(waveform, orig_freq, new_freq, lowpass_filter_width=6, rolloff=0.99, resampling_method="sinc_interp_hann", beta=None):
+ """Bandlimited sinc resampling along the last dimension, on the input device."""
+ if orig_freq <= 0 or new_freq <= 0:
+ raise ValueError("Sample rates must be positive")
+ if orig_freq == new_freq:
+ return waveform
+ if int(orig_freq) != orig_freq or int(new_freq) != new_freq:
+ raise ValueError("Sample rates must be integers")
+ if not waveform.is_floating_point():
+ raise TypeError("Audio waveforms must be floating point")
+ if lowpass_filter_width <= 0:
+ raise ValueError("Lowpass filter width must be positive")
+
+ divisor = math.gcd(int(orig_freq), int(new_freq))
+ orig_freq = int(orig_freq) // divisor
+ new_freq = int(new_freq) // divisor
+ base_freq = min(orig_freq, new_freq) * rolloff
+ width = math.ceil(lowpass_filter_width * orig_freq / base_freq)
+ idx = torch.arange(-width, width + orig_freq, dtype=waveform.dtype, device=waveform.device)[None, None] / orig_freq
+ t = torch.arange(0, -new_freq, -1, dtype=waveform.dtype, device=waveform.device)[:, None, None] / new_freq + idx
+ t = (t * base_freq).clamp_(-lowpass_filter_width, lowpass_filter_width)
+ if resampling_method == "sinc_interp_hann":
+ window = torch.cos(t * math.pi / lowpass_filter_width / 2) ** 2
+ elif resampling_method == "sinc_interp_kaiser":
+ beta = torch.tensor(14.769656459379492 if beta is None else beta, device=waveform.device)
+ window = torch.i0(beta * torch.sqrt(1 - (t / lowpass_filter_width) ** 2)) / torch.i0(beta)
+ else:
+ raise ValueError(f"Unknown resampling method: {resampling_method}")
+ t *= math.pi
+ kernel = torch.where(t == 0, 1.0, t.sin() / t)
+ kernel *= window * (base_freq / orig_freq)
+
+ shape = waveform.shape
+ length = shape[-1]
+ waveform = waveform.reshape(-1, length)
+ waveform = F.pad(waveform, (width, width + orig_freq))
+ output = F.conv1d(waveform[:, None], kernel, stride=orig_freq)
+ output = output.transpose(1, 2).reshape(waveform.shape[0], -1)
+ # Match TorchAudio's float32 rounding to preserve existing output lengths.
+ target_length = math.ceil(np.float32(new_freq * length / orig_freq))
+ output = output[..., :target_length]
+ return output.reshape(*shape[:-1], output.shape[-1])
+
+
+def _hz_to_mel(freq):
+ if freq >= 1000.0:
+ return 15.0 + math.log(freq / 1000.0) / (math.log(6.4) / 27.0)
+ return freq / (200.0 / 3)
+
+
+class MelScale(torch.nn.Module):
+ """Slaney mel filterbank with area normalization."""
+
+ def __init__(self, n_mels, sample_rate, f_min, f_max, n_stft):
+ super().__init__()
+ if f_max is None:
+ f_max = sample_rate // 2
+ all_freqs = torch.linspace(0, sample_rate // 2, n_stft)
+ mels = torch.linspace(_hz_to_mel(f_min), _hz_to_mel(f_max), n_mels + 2)
+ freqs = (200.0 / 3) * mels
+ log_region = mels >= 15.0
+ freqs[log_region] = 1000.0 * torch.exp((math.log(6.4) / 27.0) * (mels[log_region] - 15.0))
+ diff = freqs[1:] - freqs[:-1]
+ slopes = freqs.unsqueeze(0) - all_freqs.unsqueeze(1)
+ fb = torch.minimum(-slopes[:, :-2] / diff[:-1], slopes[:, 2:] / diff[1:]).clamp_min(0)
+ fb *= (2.0 / (freqs[2:] - freqs[:-2])).unsqueeze(0)
+ self.register_buffer("fb", fb)
+
+ def forward(self, spectrogram):
+ return (spectrogram.transpose(-1, -2) @ self.fb).transpose(-1, -2)
+
+
+class _Spectrogram(torch.nn.Module):
+ def __init__(self, n_fft, win_length, hop_length, power):
+ super().__init__()
+ self.n_fft = n_fft
+ self.win_length = win_length
+ self.hop_length = hop_length
+ self.power = power
+ self.register_buffer("window", torch.hann_window(win_length))
+
+ def forward(self, waveform):
+ shape = waveform.shape
+ spec = torch.stft(waveform.reshape(-1, shape[-1]), self.n_fft, self.hop_length, self.win_length, self.window, center=True, pad_mode="reflect", normalized=False, onesided=True, return_complex=True)
+ spec = spec.reshape(*shape[:-1], *spec.shape[-2:]).abs()
+ return spec if self.power == 1.0 else spec.pow(self.power)
+
+
+class MelSpectrogram(torch.nn.Module):
+ """Hann-windowed magnitude/power spectrogram with Slaney mel normalization."""
+
+ def __init__(self, sample_rate, n_fft, hop_length, n_mels, f_min=0.0, f_max=None, win_length=None, power=2.0):
+ super().__init__()
+ self.spectrogram = _Spectrogram(n_fft, n_fft if win_length is None else win_length, hop_length, power)
+ self.mel_scale = MelScale(n_mels, sample_rate, f_min, f_max, n_fft // 2 + 1)
+
+ def forward(self, waveform):
+ return self.mel_scale(self.spectrogram(waveform))
+
+
+class _LFilter(torch.autograd.Function):
+ @staticmethod
+ def forward(ctx, waveform, a, b):
+ ctx.a = a
+ ctx.b = b
+ # SciPy supplies the compiled IIR loop; audio nodes normally run on CPU.
+ output = scipy.signal.lfilter(b, a, waveform.detach().cpu().numpy())
+ return torch.from_numpy(output).to(waveform)
+
+ @staticmethod
+ def backward(ctx, grad):
+ return _LFilter.apply(grad.flip(-1), ctx.a, ctx.b).flip(-1), None, None
+
+
+def _biquad(waveform, b0, b1, b2, a0, a1, a2):
+ a = torch.stack((a0, a1, a2)).detach().cpu().numpy()
+ b = torch.stack((b0, b1, b2)).detach().cpu().numpy()
+ return _LFilter.apply(waveform, a, b).clamp(-1, 1)
+
+
+def bass_biquad(waveform, sample_rate, gain, central_freq=100, Q=0.707):
+ dtype = waveform.dtype
+ device = waveform.device
+ central_freq = torch.as_tensor(central_freq, dtype=dtype, device=device)
+ Q = torch.as_tensor(Q, dtype=dtype, device=device)
+ gain = torch.as_tensor(gain, dtype=dtype, device=device)
+ w0 = 2 * math.pi * central_freq / sample_rate
+ alpha = torch.sin(w0) / 2 / Q
+ A = torch.exp(gain / 40 * math.log(10))
+ temp1 = 2 * torch.sqrt(A) * alpha
+ temp2 = (A - 1) * torch.cos(w0)
+ temp3 = (A + 1) * torch.cos(w0)
+ b0 = A * (A + 1 - temp2 + temp1)
+ b1 = 2 * A * (A - 1 - temp3)
+ b2 = A * (A + 1 - temp2 - temp1)
+ a0 = A + 1 + temp2 + temp1
+ a1 = -2 * (A - 1 + temp3)
+ a2 = A + 1 + temp2 - temp1
+ return _biquad(waveform, b0 / a0, b1 / a0, b2 / a0, a0 / a0, a1 / a0, a2 / a0)
+
+
+def equalizer_biquad(waveform, sample_rate, center_freq, gain, Q=0.707):
+ dtype = waveform.dtype
+ device = waveform.device
+ center_freq = torch.as_tensor(center_freq, dtype=dtype, device=device)
+ Q = torch.as_tensor(Q, dtype=dtype, device=device)
+ gain = torch.as_tensor(gain, dtype=dtype, device=device)
+ w0 = 2 * math.pi * center_freq / sample_rate
+ A = torch.exp(gain / 40.0 * math.log(10))
+ alpha = torch.sin(w0) / 2 / Q
+ b0 = 1 + alpha * A
+ b1 = -2 * torch.cos(w0)
+ b2 = 1 - alpha * A
+ a0 = 1 + alpha / A
+ a1 = -2 * torch.cos(w0)
+ a2 = 1 - alpha / A
+ return _biquad(waveform, b0, b1, b2, a0, a1, a2)
+
+
+def treble_biquad(waveform, sample_rate, gain, central_freq=3000, Q=0.707):
+ dtype = waveform.dtype
+ device = waveform.device
+ central_freq = torch.as_tensor(central_freq, dtype=dtype, device=device)
+ Q = torch.as_tensor(Q, dtype=dtype, device=device)
+ gain = torch.as_tensor(gain, dtype=dtype, device=device)
+ w0 = 2 * math.pi * central_freq / sample_rate
+ alpha = torch.sin(w0) / 2 / Q
+ A = torch.exp(gain / 40 * math.log(10))
+ temp1 = 2 * torch.sqrt(A) * alpha
+ temp2 = (A - 1) * torch.cos(w0)
+ temp3 = (A + 1) * torch.cos(w0)
+ b0 = A * (A + 1 + temp2 + temp1)
+ b1 = -2 * A * (A - 1 + temp3)
+ b2 = A * (A + 1 + temp2 - temp1)
+ a0 = A + 1 - temp2 + temp1
+ a1 = 2 * (A - 1 - temp3)
+ a2 = A + 1 - temp2 - temp1
+ return _biquad(waveform, b0, b1, b2, a0, a1, a2)
diff --git a/comfy/audio_encoders/audio_encoders.py b/comfy/audio_encoders/audio_encoders.py
index 457cf24f3..46f610db9 100644
--- a/comfy/audio_encoders/audio_encoders.py
+++ b/comfy/audio_encoders/audio_encoders.py
@@ -6,7 +6,7 @@ import comfy.model_management
import comfy.ops
import comfy.utils
import logging
-import torchaudio
+import comfy.audio
import torch
@@ -44,7 +44,7 @@ class AudioEncoderModel():
def encode_audio(self, audio, sample_rate):
comfy.model_management.load_model_gpu(self.patcher)
- audio = torchaudio.functional.resample(audio, sample_rate, self.model_sample_rate)
+ audio = comfy.audio.resample(audio, sample_rate, self.model_sample_rate)
out, all_layers = self.model(audio.to(self.load_device))
outputs = {}
outputs["encoded_audio"] = out
@@ -55,7 +55,7 @@ class AudioEncoderModel():
class SheetSage2AudioEncoder(AudioEncoderModel):
def generate_abc(self, audio, sample_rate, melody_only=True):
- audio = torchaudio.functional.resample(audio.float().mean(dim=1), sample_rate, self.model_sample_rate)
+ audio = comfy.audio.resample(audio.float().mean(dim=1), sample_rate, self.model_sample_rate)
comfy.model_management.load_model_gpu(self.patcher)
scores = []
for waveform in audio:
diff --git a/comfy/audio_encoders/whisper.py b/comfy/audio_encoders/whisper.py
index 93d3782f1..77c3c15ae 100755
--- a/comfy/audio_encoders/whisper.py
+++ b/comfy/audio_encoders/whisper.py
@@ -1,7 +1,7 @@
import torch
import torch.nn as nn
import torch.nn.functional as F
-import torchaudio
+import comfy.audio
from typing import Optional
from comfy.ldm.modules.attention import optimized_attention_masked
import comfy.ops
@@ -16,15 +16,13 @@ class WhisperFeatureExtractor(nn.Module):
self.chunk_length = 30
self.n_samples = 480000
- self.mel_spectrogram = torchaudio.transforms.MelSpectrogram(
+ self.mel_spectrogram = comfy.audio.MelSpectrogram(
sample_rate=self.sample_rate,
n_fft=self.n_fft,
hop_length=self.hop_length,
n_mels=self.n_mels,
f_min=0,
f_max=8000,
- norm="slaney",
- mel_scale="slaney",
).to(device)
def __call__(self, audio):
diff --git a/comfy/ldm/ace/vae/music_dcae_pipeline.py b/comfy/ldm/ace/vae/music_dcae_pipeline.py
index 3c8830c17..5ecd03e14 100644
--- a/comfy/ldm/ace/vae/music_dcae_pipeline.py
+++ b/comfy/ldm/ace/vae/music_dcae_pipeline.py
@@ -1,11 +1,7 @@
# Original from: https://github.com/ace-step/ACE-Step/blob/main/music_dcae/music_dcae_pipeline.py
import torch
from .autoencoder_dc import AutoencoderDC
-import logging
-try:
- import torchaudio
-except:
- logging.warning("torchaudio missing, ACE model will be broken")
+import comfy.audio
import torchvision.transforms as transforms
from .music_vocoder import ADaMoSHiFiGANV1
@@ -53,7 +49,7 @@ class MusicDCAE(torch.nn.Module):
sr = self.source_sample_rate
if sr != 44100:
- audios = torchaudio.functional.resample(audios, sr, 44100)
+ audios = comfy.audio.resample(audios, sr, 44100)
max_audio_len = audios.shape[-1]
if max_audio_len % (8 * 512) != 0:
@@ -83,7 +79,7 @@ class MusicDCAE(torch.nn.Module):
wav = self.vocoder.decode(mels[0]).squeeze(1)
if sr is not None:
- wav = torchaudio.functional.resample(wav, 44100, sr)
+ wav = comfy.audio.resample(wav, 44100, sr)
else:
sr = 44100
pred_wavs.append(wav)
diff --git a/comfy/ldm/ace/vae/music_log_mel.py b/comfy/ldm/ace/vae/music_log_mel.py
index 9c584eb7f..f68d598d0 100755
--- a/comfy/ldm/ace/vae/music_log_mel.py
+++ b/comfy/ldm/ace/vae/music_log_mel.py
@@ -2,11 +2,7 @@
import torch
import torch.nn as nn
from torch import Tensor
-import logging
-try:
- from torchaudio.transforms import MelScale
-except:
- logging.warning("torchaudio missing, ACE model will be broken")
+from comfy.audio import MelScale
import comfy.model_management
@@ -92,8 +88,6 @@ class LogMelSpectrogram(nn.Module):
self.f_min,
self.f_max,
self.n_fft // 2 + 1,
- "slaney",
- "slaney",
)
def compress(self, x: Tensor) -> Tensor:
diff --git a/comfy/ldm/lightricks/vae/audio_vae.py b/comfy/ldm/lightricks/vae/audio_vae.py
index f5b1756d3..7b117f071 100644
--- a/comfy/ldm/lightricks/vae/audio_vae.py
+++ b/comfy/ldm/lightricks/vae/audio_vae.py
@@ -1,7 +1,7 @@
import json
from dataclasses import dataclass
import torch
-import torchaudio
+import comfy.audio
from comfy.ldm.mmaudio.vae.distributions import DiagonalGaussianDistribution
from comfy.ldm.lightricks.symmetric_patchifier import AudioPatchifier
@@ -73,14 +73,14 @@ class AudioPreprocessor:
def resample(self, waveform: torch.Tensor, source_rate: int) -> torch.Tensor:
if source_rate == self.target_sample_rate:
return waveform
- return torchaudio.functional.resample(waveform, source_rate, self.target_sample_rate)
+ return comfy.audio.resample(waveform, source_rate, self.target_sample_rate)
def waveform_to_mel(
self, waveform: torch.Tensor, waveform_sample_rate: int, device
) -> torch.Tensor:
waveform = self.resample(waveform, waveform_sample_rate)
- mel_transform = torchaudio.transforms.MelSpectrogram(
+ mel_transform = comfy.audio.MelSpectrogram(
sample_rate=self.target_sample_rate,
n_fft=self.n_fft,
win_length=self.n_fft,
@@ -88,12 +88,7 @@ class AudioPreprocessor:
f_min=0.0,
f_max=self.target_sample_rate / 2.0,
n_mels=self.mel_bins,
- window_fn=torch.hann_window,
- center=True,
- pad_mode="reflect",
power=1.0,
- mel_scale="slaney",
- norm="slaney",
).to(device)
mel = mel_transform(waveform)
diff --git a/comfy/ldm/lightricks/vocoders/vocoder.py b/comfy/ldm/lightricks/vocoders/vocoder.py
index 2481d8bdd..efbc46081 100644
--- a/comfy/ldm/lightricks/vocoders/vocoder.py
+++ b/comfy/ldm/lightricks/vocoders/vocoder.py
@@ -92,9 +92,8 @@ class UpSample1d(nn.Module):
self.stride = ratio
if window_type == "hann":
- # Hann-windowed sinc filter — identical to torchaudio.functional.resample
- # with its default parameters (rolloff=0.99, lowpass_filter_width=6).
- # Uses replicate boundary padding, matching the reference resampler exactly.
+ # Uses the default Hann-windowed sinc parameters from comfy.audio.resample.
+ # Boundary padding is replicate here; comfy.audio.resample uses zeros.
rolloff = 0.99
lowpass_filter_width = 6
width = math.ceil(lowpass_filter_width / rolloff)
diff --git a/comfy/ldm/mmaudio/vae/autoencoder.py b/comfy/ldm/mmaudio/vae/autoencoder.py
index cbb9de302..769854dd3 100644
--- a/comfy/ldm/mmaudio/vae/autoencoder.py
+++ b/comfy/ldm/mmaudio/vae/autoencoder.py
@@ -6,12 +6,7 @@ import torch.nn as nn
from .distributions import DiagonalGaussianDistribution
from .vae import VAE_16k
from .bigvgan import BigVGANVocoder
-import logging
-
-try:
- import torchaudio
-except:
- logging.warning("torchaudio missing, MMAudio VAE model will be broken")
+import comfy.audio
def dynamic_range_compression_torch(x, C=1, clip_val=1e-5, *, norm_fn):
return norm_fn(torch.clamp(x, min=clip_val) * C)
@@ -145,12 +140,12 @@ class AudioAutoencoder(nn.Module):
mel_decoded = self.vae.decode(z)
audio = self.vocoder(mel_decoded)
- audio = torchaudio.functional.resample(audio, 16000, 44100)
+ audio = comfy.audio.resample(audio, 16000, 44100)
return audio
@torch.no_grad()
def encode(self, audio):
audio = audio.mean(dim=1)
- audio = torchaudio.functional.resample(audio, 44100, 16000)
+ audio = comfy.audio.resample(audio, 44100, 16000)
dist = self.encode_audio(audio)
return dist.mean
diff --git a/comfy/text_encoders/gemma4.py b/comfy/text_encoders/gemma4.py
index 0dcd226cb..07cd45aed 100644
--- a/comfy/text_encoders/gemma4.py
+++ b/comfy/text_encoders/gemma4.py
@@ -1,6 +1,6 @@
import torch
import torch.nn as nn
-import torchaudio.functional as AF
+import comfy.audio
import torchvision.transforms.functional as TVF
import numpy as np
from tokenizers import Tokenizer
@@ -1412,14 +1412,14 @@ class Gemma4_Tokenizer():
@staticmethod
def _resample_16k(waveform, sample_rate):
"""Mix to mono and resample to 16kHz. Kaiser params reproduce the reference (transformers
- load_audio -> librosa/soxr_hq) to ~1e-12 MSE using only torchaudio."""
+ load_audio -> librosa/soxr_hq) to ~1e-12 MSE using sinc resampling."""
if waveform.dim() > 1 and waveform.shape[0] > 1:
waveform = waveform.mean(dim=0, keepdim=True)
if waveform.dim() == 1:
waveform = waveform.unsqueeze(0)
audio = waveform.float()
if sample_rate != 16000:
- audio = AF.resample(audio, sample_rate, 16000, resampling_method="sinc_interp_kaiser",
+ audio = comfy.audio.resample(audio, sample_rate, 16000, resampling_method="sinc_interp_kaiser",
lowpass_filter_width=121, rolloff=0.9568384289091556, beta=21.01531462440614)
return audio.squeeze(0).contiguous()
diff --git a/comfy_api/latest/_ui.py b/comfy_api/latest/_ui.py
index 06e725070..f279059ce 100644
--- a/comfy_api/latest/_ui.py
+++ b/comfy_api/latest/_ui.py
@@ -9,11 +9,7 @@ from io import BytesIO
import av
import numpy as np
import torch
-try:
- import torchaudio
- TORCH_AUDIO_AVAILABLE = True
-except:
- TORCH_AUDIO_AVAILABLE = False
+import comfy.audio
from PIL import Image as PILImage
from PIL.PngImagePlugin import PngInfo
@@ -310,9 +306,7 @@ class AudioSaveHelper:
# Resample if necessary
if sample_rate != audio["sample_rate"]:
- if not TORCH_AUDIO_AVAILABLE:
- raise Exception("torchaudio is not available; cannot resample audio.")
- waveform = torchaudio.functional.resample(waveform, audio["sample_rate"], sample_rate)
+ waveform = comfy.audio.resample(waveform, audio["sample_rate"], sample_rate)
# Create output with specified format
output_buffer = BytesIO()
diff --git a/comfy_extras/nodes_audio.py b/comfy_extras/nodes_audio.py
index 9f689df62..d787f0486 100644
--- a/comfy_extras/nodes_audio.py
+++ b/comfy_extras/nodes_audio.py
@@ -1,5 +1,5 @@
import av
-import torchaudio
+import comfy.audio
import torch
import comfy.model_management
import folder_paths
@@ -85,7 +85,7 @@ class VAEEncodeAudio(IO.ComfyNode):
sample_rate = audio["sample_rate"]
vae_sample_rate = getattr(vae, "audio_sample_rate", 44100)
if vae_sample_rate != sample_rate:
- waveform = torchaudio.functional.resample(audio["waveform"], sample_rate, vae_sample_rate)
+ waveform = comfy.audio.resample(audio["waveform"], sample_rate, vae_sample_rate)
else:
waveform = audio["waveform"]
@@ -578,11 +578,11 @@ class JoinAudioChannels(IO.ComfyNode):
def match_audio_sample_rates(waveform_1, sample_rate_1, waveform_2, sample_rate_2):
if sample_rate_1 != sample_rate_2:
if sample_rate_1 > sample_rate_2:
- waveform_2 = torchaudio.functional.resample(waveform_2, sample_rate_2, sample_rate_1)
+ waveform_2 = comfy.audio.resample(waveform_2, sample_rate_2, sample_rate_1)
output_sample_rate = sample_rate_1
logging.info(f"Resampling audio2 from {sample_rate_2}Hz to {sample_rate_1}Hz for merging.")
else:
- waveform_1 = torchaudio.functional.resample(waveform_1, sample_rate_1, sample_rate_2)
+ waveform_1 = comfy.audio.resample(waveform_1, sample_rate_1, sample_rate_2)
output_sample_rate = sample_rate_2
logging.info(f"Resampling audio1 from {sample_rate_1}Hz to {sample_rate_2}Hz for merging.")
else:
@@ -835,7 +835,7 @@ class AudioEqualizer3Band(IO.ComfyNode):
# 1. Apply Low Shelf (Bass)
if low_gain_dB != 0:
- eq_waveform = torchaudio.functional.bass_biquad(
+ eq_waveform = comfy.audio.bass_biquad(
eq_waveform,
sample_rate,
gain=low_gain_dB,
@@ -845,7 +845,7 @@ class AudioEqualizer3Band(IO.ComfyNode):
# 2. Apply Peaking EQ (Mids)
if mid_gain_dB != 0:
- eq_waveform = torchaudio.functional.equalizer_biquad(
+ eq_waveform = comfy.audio.equalizer_biquad(
eq_waveform,
sample_rate,
center_freq=float(mid_freq),
@@ -855,7 +855,7 @@ class AudioEqualizer3Band(IO.ComfyNode):
# 3. Apply High Shelf (Treble)
if high_gain_dB != 0:
- eq_waveform = torchaudio.functional.treble_biquad(
+ eq_waveform = comfy.audio.treble_biquad(
eq_waveform,
sample_rate,
gain=high_gain_dB,
diff --git a/comfy_extras/nodes_lt.py b/comfy_extras/nodes_lt.py
index 9ca4bce3f..1062f4789 100644
--- a/comfy_extras/nodes_lt.py
+++ b/comfy_extras/nodes_lt.py
@@ -1,7 +1,7 @@
import nodes
import node_helpers
import torch
-import torchaudio
+import comfy.audio
import comfy.ldm.lightricks.duration_head
import comfy.model_management
import comfy.model_sampling
@@ -1033,7 +1033,7 @@ class LTXVReferenceAudio(io.ComfyNode):
sample_rate = reference_audio["sample_rate"]
vae_sample_rate = getattr(audio_vae, "audio_sample_rate", 44100)
if vae_sample_rate != sample_rate:
- waveform = torchaudio.functional.resample(reference_audio["waveform"], sample_rate, vae_sample_rate)
+ waveform = comfy.audio.resample(reference_audio["waveform"], sample_rate, vae_sample_rate)
else:
waveform = reference_audio["waveform"]
diff --git a/comfy_extras/nodes_minimax_h3.py b/comfy_extras/nodes_minimax_h3.py
index 1baa33cb3..1decd2dad 100644
--- a/comfy_extras/nodes_minimax_h3.py
+++ b/comfy_extras/nodes_minimax_h3.py
@@ -13,7 +13,7 @@ import math
import torch
import torch.nn.functional as F
-import torchaudio
+import comfy.audio
import nodes
import comfy.model_management
@@ -76,7 +76,7 @@ def _encode_ref_audio(audio_vae, audio):
sr = audio["sample_rate"]
vae_sr = getattr(audio_vae, "audio_sample_rate", 32000)
if sr != vae_sr:
- waveform = torchaudio.functional.resample(waveform, sr, vae_sr)
+ waveform = comfy.audio.resample(waveform, sr, vae_sr)
z = audio_vae.encode(waveform[:1].movedim(1, -1)) # [1, 32, 2, T]
return z, z.shape[-1]
diff --git a/comfy_extras/nodes_wandancer.py b/comfy_extras/nodes_wandancer.py
index fdb2b5e57..f8b9091fd 100644
--- a/comfy_extras/nodes_wandancer.py
+++ b/comfy_extras/nodes_wandancer.py
@@ -2,7 +2,7 @@ import math
import nodes
import node_helpers
import torch
-import torchaudio
+import comfy.audio
import comfy.model_management
import comfy.utils
import numpy as np
@@ -742,7 +742,7 @@ class WanDancerEncodeAudio(io.ComfyNode):
# resample to the sample rate used for feature extraction
resample_sr = base_fps * hop_length
- waveform = torchaudio.functional.resample(waveform, sample_rate, resample_sr)
+ waveform = comfy.audio.resample(waveform, sample_rate, resample_sr)
waveform_np = waveform.cpu().numpy().squeeze()
mel_spec = _compute_mel_spectrogram(waveform_np, model_sr, n_fft, hop_length, n_mels=128)
diff --git a/requirements.txt b/requirements.txt
index 7e2eddf57..d0a4ec04b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,7 +4,6 @@ comfyui-embedded-docs==0.5.12
torch
torchsde
torchvision
-torchaudio
numpy>=1.25.0
einops
transformers>=4.50.3