Voice Conversion

import torch
import torchaudio as ta
from chatterbox.vc import ChatterboxVC

# Load the voice conversion model
model = ChatterboxVC.from_pretrained(device="cuda")

# Convert voice
source_audio = "original_speaker.wav"
target_voice = "desired_voice.wav"

wav = model.generate(
    audio=source_audio,
    target_voice_path=target_voice
)

ta.save("converted.wav", wav, model.sr)

import torch
import torchaudio as ta
from chatterbox.vc import ChatterboxVC

# Automatically detect the best available device
if torch.cuda.is_available():
    device = "cuda"
elif torch.backends.mps.is_available():
    device = "mps"
else:
    device = "cpu"

print(f"Using device: {device}")

model = ChatterboxVC.from_pretrained(device=device)

source_audio = "source.wav"
target_voice = "target.wav"

wav = model.generate(
    audio=source_audio,
    target_voice_path=target_voice
)

ta.save("converted.wav", wav, model.sr)

import torch
import torchaudio as ta
from chatterbox.vc import ChatterboxVC
from pathlib import Path

model = ChatterboxVC.from_pretrained(device="cuda")

# Set target voice once
target_voice = "celebrity_voice.wav"
model.set_target_voice(target_voice)

# Process multiple files with the same target voice
source_files = [
    "speaker1.wav",
    "speaker2.wav",
    "speaker3.wav"
]

for i, source_file in enumerate(source_files):
    wav = model.generate(audio=source_file)
    ta.save(f"converted_{i}.wav", wav, model.sr)

import torchaudio as ta
from chatterbox.vc import ChatterboxVC

model = ChatterboxVC.from_pretrained(device="cuda")

# Pre-set the target voice
model.set_target_voice("my_target_voice.wav")

# Generate without specifying target_voice_path each time
wav = model.generate(audio="source1.wav")
ta.save("converted1.wav", wav, model.sr)

wav = model.generate(audio="source2.wav")
ta.save("converted2.wav", wav, model.sr)

# Internal processing flow (for reference)
# 1. Load source audio and resample to 16kHz
audio_16k, _ = librosa.load(source_audio, sr=16000)

# 2. Tokenize source audio
speech_tokens, _ = tokenizer(audio_16k)

# 3. Load target voice and extract embeddings
target_audio, _ = librosa.load(target_voice, sr=24000)
ref_dict = s3gen.embed_ref(target_audio[:240000])  # First 10 seconds

# 4. Generate with voice transformation
output_wav = s3gen.inference(speech_tokens, ref_dict)

import perth
import librosa

# Load the converted audio
converted_audio, sr = librosa.load("converted.wav", sr=None)

# Initialize watermarker
watermarker = perth.PerthImplicitWatermarker()

# Extract watermark
watermark = watermarker.get_watermark(converted_audio, sample_rate=sr)
print(f"Extracted watermark: {watermark}")  # 0.0 or 1.0