anbeime/skill / skills/tts-voice-synthesis
tts-voice-synthesis
Verified影片与视频编辑、内容创作者在制作视频配音或有声书时,当需要克隆音色、生成情感化配音或流式实时语音合成请用此技能。支持1.7B高质量与0.6B快速双模型,一键实现多语言方言配音,让语音创作更高效更自然。
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.2 KB |
| references/emotion_guide.md | markdown | 7.1 KB |
| references/model_config.md | markdown | 5.4 KB |
| references/usage_examples.md | markdown | 10.1 KB |
| scripts/tts_generate.py | script | 12.4 KB |
| scripts/voice_clone.py | script | 11.1 KB |
scripts/tts_generate.py
View on GitHub#!/usr/bin/env python3
"""
TTS Voice Generation Script
This script provides a unified interface for text-to-speech generation
supporting multiple TTS models (Fish-Speech, ChatTTS, CosyVoice).
"""
import argparse
import logging
import os
import sys
import warnings
warnings.filterwarnings('ignore')
import torch
import torchaudio
import numpy as np
from pathlib import Path
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='[%(asctime)s] %(levelname)s: %(message)s'
)
logger = logging.getLogger(__name__)
def parse_args():
"""Parse command line arguments"""
parser = argparse.ArgumentParser(
description="Generate speech from text using TTS models"
)
# Input arguments
parser.add_argument("--text", type=str, default=None,
help="Input text to synthesize")
parser.add_argument("--text_file", type=str, default=None,
help="Input text file path")
parser.add_argument("--output_path", type=str, required=True,
help="Output audio file path")
# Model selection
parser.add_argument("--model_name", type=str, default="fish-speech-1.5",
choices=["fish-speech-1.5", "chattts", "cosyvoice"],
help="TTS model to use")
parser.add_argument("--model_size", type=str, default=None,
help="Model size (1.7B, 0.6B)")
parser.add_argument("--model_path", type=str, default=None,
help="Path to model weights")
# Voice selection
parser.add_argument("--voice", type=str, default="default_female",
help="Voice name or path")
parser.add_argument("--voice_path", type=str, default=None,
help="Path to custom voice model")
# Audio parameters
parser.add_argument("--sample_rate", type=int, default=24000,
help="Audio sample rate")
parser.add_argument("--speed", type=float, default=1.0,
help="Speech speed (0.5-2.0)")
parser.add_argument("--pitch", type=float, default=1.0,
help="Pitch adjustment (0.5-2.0)")
parser.add_argument("--volume", type=float, default=1.0,
help="Volume adjustment (0.5-1.5)")
parser.add_argument("--audio_format", type=str, default="wav",
choices=["wav", "mp3", "flac"],
help="Output audio format")
# Emotion parameters
parser.add_argument("--emotion", type=str, default="neutral",
choices=["neutral", "happy", "sad", "angry",
"excited", "calm", "curious", "serious"],
help="Emotion type")
parser.add_argument("--emotion_strength", type=float, default=0.8,
help="Emotion strength (0.0-1.0)")
parser.add_argument("--emotion_per_sentence", type=bool, default=False,
help="Analyze emotion per sentence")
# Streaming parameters
parser.add_argument("--streaming", action="store_true", default=False,
help="Enable streaming generation")
parser.add_argument("--chunk_size", type=int, default=128,
help="Chunk size for streaming")
# Model-specific parameters
parser.add_argument("--temperature", type=float, default=0.7,
help="Sampling temperature (0.1-1.0)")
parser.add_argument("--top_p", type=float, default=0.9,
help="Top-p sampling probability")
parser.add_argument("--top_k", type=int, default=20,
help="Top-k sampling")
# Device
parser.add_argument("--device", type=str, default=None,
help="Device to use (cuda, cpu)")
return parser.parse_args()
class TTSGenerator:
"""Unified TTS Generator class"""
def __init__(self, model_name, model_path=None, device=None):
"""
Initialize TTS Generator
Args:
model_name: Name of the TTS model
model_path: Path to model weights
device: Device to use (cuda, cpu)
"""
self.model_name = model_name
self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
self.model = None
self.model_loaded = False
logger.info(f"Initializing TTS Generator with model: {model_name}")
logger.info(f"Device: {self.device}")
# Load model
self._load_model(model_path)
def _load_model(self, model_path):
"""Load the TTS model"""
logger.info(f"Loading model...")
try:
if self.model_name == "fish-speech-1.5":
self._load_fish_speech(model_path)
elif self.model_name == "chattts":
self._load_chattts(model_path)
elif self.model_name == "cosyvoice":
self._load_cosyvoice(model_path)
else:
raise ValueError(f"Unsupported model: {self.model_name}")
self.model_loaded = True
logger.info("Model loaded successfully")
except Exception as e:
logger.error(f"Failed to load model: {e}")
logger.warning("Model will be loaded on-the-fly")
self.model_loaded = False
def _load_fish_speech(self, model_path):
"""Load Fish-Speech model"""
# Placeholder for Fish-Speech model loading
logger.info("This is a placeholder for Fish-Speech model loading")
logger.info("In production, this would load the actual Fish-Speech model")
self.model = "fish-speech-placeholder"
def _load_chattts(self, model_path):
"""Load ChatTTS model"""
# Placeholder for ChatTTS model loading
logger.info("This is a placeholder for ChatTTS model loading")
logger.info("In production, this would load the actual ChatTTS model")
self.model = "chattts-placeholder"
def _load_cosyvoice(self, model_path):
"""Load CosyVoice model"""
# Placeholder for CosyVoice model loading
logger.info("This is a placeholder for CosyVoice model loading")
logger.info("In production, this would load the actual CosyVoice model")
self.model = "cosyvoice-placeholder"
def synthesize(self, text, voice="default_female", speed=1.0, pitch=1.0,
volume=1.0, emotion="neutral", emotion_strength=0.8,
streaming=False, **kwargs):
"""
Synthesize speech from text
Args:
text: Input text
voice: Voice name or path
speed: Speech speed
pitch: Pitch adjustment
volume: Volume adjustment
emotion: Emotion type
emotion_strength: Emotion strength
streaming: Enable streaming
Returns:
Audio data (numpy array)
"""
if not text:
raise ValueError("Text cannot be empty")
logger.info(f"Synthesizing speech for: {text[:50]}...")
logger.info(f"Voice: {voice}, Speed: {speed}, Pitch: {pitch}")
logger.info(f"Emotion: {emotion}, Strength: {emotion_strength}")
# Apply emotion adjustments
speed, pitch, volume = self._apply_emotion(
emotion, emotion_strength, speed, pitch, volume
)
# Synthesize (placeholder implementation)
audio = self._synthesize_placeholder(
text, voice, speed, pitch, volume
)
logger.info("Speech synthesis completed")
return audio
def _apply_emotion(self, emotion, strength, speed, pitch, volume):
"""Apply emotion adjustments to parameters"""
# Emotion parameter mappings
emotion_params = {
"neutral": {"speed": 1.0, "pitch": 1.0, "volume": 1.0},
"happy": {"speed": 1.2, "pitch": 1.1, "volume": 1.1},
"sad": {"speed": 0.85, "pitch": 0.85, "volume": 0.85},
"angry": {"speed": 1.25, "pitch": 1.25, "volume": 1.25},
"excited": {"speed": 1.4, "pitch": 1.3, "volume": 1.3},
"calm": {"speed": 0.95, "pitch": 1.0, "volume": 0.95},
"curious": {"speed": 0.95, "pitch": 1.05, "volume": 1.0},
"serious": {"speed": 1.0, "pitch": 1.0, "volume": 1.0},
}
# Get base emotion parameters
params = emotion_params.get(emotion, emotion_params["neutral"])
# Apply strength
speed = speed * (1 + (params["speed"] - 1) * strength)
pitch = pitch * (1 + (params["pitch"] - 1) * strength)
volume = volume * (1 + (params["volume"] - 1) * strength)
# Clamp values
speed = np.clip(speed, 0.5, 2.0)
pitch = np.clip(pitch, 0.5, 2.0)
volume = np.clip(volume, 0.5, 1.5)
logger.debug(f"Adjusted parameters - Speed: {speed:.2f}, "
f"Pitch: {pitch:.2f}, Volume: {volume:.2f}")
return speed, pitch, volume
def _synthesize_placeholder(self, text, voice, speed, pitch, volume):
"""
Placeholder synthesis implementation
In production, this would call the actual TTS model
"""
logger.warning("=" * 80)
logger.warning("This is a placeholder implementation!")
logger.warning("In production, this would:")
logger.warning(f" 1. Load the {self.model_name} model")
logger.warning(f" 2. Process text: '{text[:50]}...'")
logger.warning(f" 3. Use voice: {voice}")
logger.warning(f" 4. Apply speed={speed:.2f}, pitch={pitch:.2f}, volume={volume:.2f}")
logger.warning(f" 5. Generate audio waveform")
logger.warning("=" * 80)
# Generate dummy audio for demonstration
# In production, this would be the actual audio from the TTS model
duration = len(text) * 0.1 / speed # Estimate duration
sample_rate = 24000
num_samples = int(duration * sample_rate)
# Generate silent audio (placeholder)
audio = np.zeros(num_samples, dtype=np.float32)
return audio
def save_audio(self, audio, output_path, sample_rate=24000,
audio_format="wav", volume=1.0):
"""
Save audio to file
Args:
audio: Audio data (numpy array)
output_path: Output file path
sample_rate: Sample rate
audio_format: Audio format (wav, mp3, flac)
volume: Volume adjustment
"""
# Create output directory
os.makedirs(os.path.dirname(output_path), exist_ok=True)
# Apply volume
audio = audio * volume
# Clamp values
audio = np.clip(audio, -1.0, 1.0)
# Convert to tensor
audio_tensor = torch.from_numpy(audio).unsqueeze(0)
# Save audio
if audio_format == "wav":
torchaudio.save(output_path, audio_tensor, sample_rate)
elif audio_format == "mp3":
# For MP3, you would need additional library (like pydub or ffmpeg)
logger.warning("MP3 format requires additional libraries")
# Save as WAV as fallback
wav_path = output_path.replace(".mp3", ".wav")
torchaudio.save(wav_path, audio_tensor, sample_rate)
logger.info(f"Saved as WAV (MP3 not supported): {wav_path}")
elif audio_format == "flac":
torchaudio.save(output_path, audio_tensor, sample_rate,
format="flac")
logger.info(f"Audio saved to: {output_path}")
def main():
"""Main function"""
args = parse_args()
# Read input text
if args.text:
text = args.text
elif args.text_file:
with open(args.text_file, 'r', encoding='utf-8') as f:
text = f.read()
else:
logger.error("Either --text or --text_file must be provided")
return 1
# Initialize TTS generator
generator = TTSGenerator(
model_name=args.model_name,
model_path=args.model_path,
device=args.device
)
# Synthesize speech
audio = generator.synthesize(
text=text,
voice=args.voice,
speed=args.speed,
pitch=args.pitch,
volume=args.volume,
emotion=args.emotion,
emotion_strength=args.emotion_strength,
streaming=args.streaming
)
# Save audio
generator.save_audio(
audio=audio,
output_path=args.output_path,
sample_rate=args.sample_rate,
audio_format=args.audio_format,
volume=1.0 # Volume already applied in synthesis
)
logger.info("Done!")
return 0
if __name__ == "__main__":
sys.exit(main())
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |