Crate voirs_cloning 

VoiRS Voice Cloning System

This crate provides comprehensive voice cloning capabilities including few-shot speaker adaptation, speaker verification, voice similarity measurement, and cross-language cloning.

Features

• Few-shot Learning: Clone voices with as little as 30 seconds of audio
• Speaker Verification: Verify speaker identity with high accuracy
• Cross-lingual Cloning: Clone voices across different languages
• Real-time Adaptation: Adapt speaker characteristics during synthesis
• Quality Assessment: Automated quality evaluation and similarity measurement
• Ethical Safeguards: Consent management, usage tracking, and authenticity detection
• Performance Optimization: SIMD-accelerated operations, GPU support, and quantization

Quick Start

Basic Voice Cloning

use voirs_cloning::{VoiceCloner, VoiceClonerBuilder, VoiceSample, CloningConfig};

// Create a voice cloner with default configuration
let cloner = VoiceClonerBuilder::new()
    .config(CloningConfig::default())
    .build()?;

// Prepare voice samples (at least 30 seconds recommended)
let audio_data = vec![0.1, -0.1, 0.2, -0.2]; // Your audio samples
let sample = VoiceSample::new("speaker1".to_string(), audio_data, 16000);

// Voice cloning is performed through speaker embedding and synthesis
println!("Voice cloner ready for synthesis");

Speaker Verification

use voirs_cloning::{SpeakerVerifier, VoiceSample};

let mut verifier = SpeakerVerifier::new(Default::default())?;

let reference_sample = VoiceSample::new("speaker1".to_string(), vec![0.1; 16000], 16000);
let test_sample = VoiceSample::new("speaker1".to_string(), vec![0.2; 16000], 16000);

// Verify speaker by comparing samples
let result = verifier.verify_samples(&reference_sample, &test_sample).await?;
println!("Verification passed: {}", result.verified);
println!("Similarity score: {}", result.score);

Few-shot Learning

use voirs_cloning::{FewShotLearner, FewShotConfig, VoiceSample};

// Configure few-shot learner for 3-shot learning
let config = FewShotConfig {
    num_shots: 3,
    quality_threshold: 0.5,
    ..Default::default()
};

let mut learner = FewShotLearner::new(config)?;

// Prepare 3 samples (30 seconds total recommended)
let samples = vec![
    VoiceSample::new("speaker1".to_string(), vec![0.1; 48000], 16000),
    VoiceSample::new("speaker1".to_string(), vec![0.2; 48000], 16000),
    VoiceSample::new("speaker1".to_string(), vec![0.3; 48000], 16000),
];

// Adapt speaker with few-shot learning
let result = learner.adapt_speaker("speaker1", &samples).await?;
println!("Adaptation confidence: {}", result.confidence);
println!("Quality score: {}", result.quality_score);

Quality Assessment

use voirs_cloning::{CloningQualityAssessor, VoiceSample};

let mut assessor = CloningQualityAssessor::new()?;

let original = VoiceSample::new("original".to_string(), vec![0.1; 16000], 16000);
let cloned = VoiceSample::new("cloned".to_string(), vec![0.11; 16000], 16000);

// Assess cloning quality
let metrics = assessor.assess_quality(&original, &cloned).await?;
println!("Overall quality: {}", metrics.overall_score);
println!("Speaker similarity: {}", metrics.speaker_similarity);
println!("Audio quality: {}", metrics.audio_quality);
println!("Naturalness: {}", metrics.naturalness);

Advanced Features

Cross-lingual Voice Cloning

use voirs_cloning::{FewShotLearner, FewShotConfig, VoiceSample};

let config = FewShotConfig {
    enable_cross_lingual: true,
    ..Default::default()
};

let mut learner = FewShotLearner::new(config)?;

let samples_en = vec![/* English samples */];
let result = learner
    .adapt_speaker_cross_lingual("speaker1", &samples_en, "en", "es")
    .await?;

Voice Morphing

use voirs_cloning::{VoiceMorpher, VoiceMorphingConfig, VoiceMorphingRequest, MorphingWeight, InterpolationMethod};

let morpher = VoiceMorpher::new(VoiceMorphingConfig::default())?;

// Morph between two speakers with 50/50 blend
let request = VoiceMorphingRequest {
    target_id: "morphed_voice".to_string(),
    speaker_weights: vec![
        MorphingWeight {
            speaker_id: "speaker1".to_string(),
            weight: 0.5,
            quality_boost: 1.0,
            temporal_variation: None,
        },
        MorphingWeight {
            speaker_id: "speaker2".to_string(),
            weight: 0.5,
            quality_boost: 1.0,
            temporal_variation: None,
        },
    ],
    config: VoiceMorphingConfig {
        interpolation_method: InterpolationMethod::Weighted,
        ..Default::default()
    },
    target_characteristics: None,
    morphing_duration: None,
};

let result = morpher.morph_voices(request).await?;

Age/Gender Adaptation

use voirs_cloning::{AgeGenderAdapter, VoiceAdaptationTarget, AgeCategory, GenderCategory, VoiceSample};

let mut adapter = AgeGenderAdapter::new();

let source_samples = vec![VoiceSample::new("speaker1".to_string(), vec![0.1; 16000], 16000)];

// Train adaptation model to sound younger and more feminine
let target = VoiceAdaptationTarget {
    age: AgeCategory::YoungAdult,
    gender: GenderCategory::Feminine,
    age_intensity: 0.7,
    gender_intensity: 0.7,
    identity_preservation: 0.8,
};

let model = adapter.train_adaptation_model("speaker1", &source_samples, target).await?;
let result = adapter.adapt_voice(&model, &source_samples).await?;

Performance Considerations

GPU Acceleration

Enable GPU acceleration for faster processing:

use voirs_cloning::{GpuAccelerator, GpuAccelerationConfig};

// Create GPU accelerator with default configuration
let config = GpuAccelerationConfig::default();
let accelerator = GpuAccelerator::new(config)?;

// GPU will be used automatically for supported operations

Model Quantization

Reduce memory footprint with quantization:

use voirs_cloning::{ModelQuantizer, QuantizationConfig, QuantizationPrecision};

// Create a CPU device for quantization
let device = candle_core::Device::Cpu;

let config = QuantizationConfig {
    precision: QuantizationPrecision::Int8,
    ..Default::default()
};

let quantizer = ModelQuantizer::new(config, device)?;

Ethical Usage

Consent Management

use voirs_cloning::ConsentManager;

// Create a consent manager for managing voice cloning consent
let manager = ConsentManager::new();

// The consent manager tracks and verifies consent for voice usage
// See the consent module documentation for complete usage examples
println!("Consent manager initialized");

Usage Tracking

use voirs_cloning::{UsageTracker, UsageTrackingConfig, CloningOperationType};

let tracker = UsageTracker::new(UsageTrackingConfig::default());

// Start tracking a voice cloning operation
let operation = tracker.start_operation(
    "user123".to_string(),
    "speaker1".to_string(),
    CloningOperationType::VoiceCloning
).await?;
println!("Tracking operation: {}", operation.id);

Architecture

The voice cloning system is organized into several specialized modules:

• core: Core voice cloning functionality and builder pattern
• embedding: Speaker embedding extraction and similarity computation
• few_shot: Few-shot learning algorithms for rapid adaptation
• verification: Speaker verification and identity validation
• quality: Quality assessment and perceptual evaluation
• consent: Ethical safeguards and consent management
• usage_tracking: Usage monitoring and audit logging
• authenticity: Deepfake detection and authenticity validation

Performance Benchmarks

Run benchmarks to measure performance:

cargo bench --features "acoustic-integration"

Feature Flags

• acoustic-integration: Enable integration with voirs-acoustic
• g2p-integration: Enable integration with voirs-g2p
• gpu: Enable GPU acceleration support
• cuda: Enable CUDA GPU support
• metal: Enable Metal GPU support
• wasm: Enable WebAssembly support

License

This crate is part of the VoiRS project. See LICENSE for details.

Re-exports

pub use ab_testing::ABTestConfig;

pub use ab_testing::ABTestResults;

pub use ab_testing::ABTestingFramework;

pub use ab_testing::CriteriaWeights;

pub use ab_testing::EvaluationResult;

pub use ab_testing::ObjectiveComparisonResults;

pub use ab_testing::ObjectiveMetrics;

pub use ab_testing::PracticalSignificance;

pub use ab_testing::TestConclusion;

pub use ab_testing::TestCondition;

pub use ab_testing::TestMethodology;

pub use ab_testing::TestStatistics;

pub use ab_testing::TestStatus;

pub use ab_testing::TestStatusType;

pub use age_gender_adaptation::AgeCategory;

pub use age_gender_adaptation::AgeGenderAdaptationConfig;

pub use age_gender_adaptation::AgeGenderAdaptationResult;

pub use age_gender_adaptation::AgeGenderAdapter;

pub use age_gender_adaptation::AgeGenderModel;

pub use age_gender_adaptation::F0Statistics;

pub use age_gender_adaptation::GenderCategory;

pub use age_gender_adaptation::SpectralCharacteristics;

pub use age_gender_adaptation::VoiceAdaptationTarget;

pub use age_gender_adaptation::VoiceCharacteristics;

pub use age_gender_adaptation::VoiceQualityMetrics;

pub use authenticity::ArtifactDetection;

pub use authenticity::ArtifactType;

pub use authenticity::AuthenticityConfig;

pub use authenticity::AuthenticityDetector;

pub use authenticity::AuthenticityMetadata;

pub use authenticity::AuthenticityResult;

pub use authenticity::DetectorResult;

pub use auto_scaling::AutoScaler;

pub use auto_scaling::AutoScalingConfig;

pub use auto_scaling::AutoScalingStats;

pub use auto_scaling::AutoScalingStrategy;

pub use auto_scaling::CostImpact;

pub use auto_scaling::ExpectedImpact;

pub use auto_scaling::InstanceHealth;

pub use auto_scaling::InstanceState;

pub use auto_scaling::PerformanceTier;

pub use auto_scaling::ScalableGpuInstance;

pub use auto_scaling::ScalingAction;

pub use auto_scaling::ScalingDecision;

pub use auto_scaling::ScalingTrigger;

pub use auto_scaling::WorkloadPrediction;

pub use config::CloningConfig;

pub use config::CloningConfigBuilder;

pub use config_management::ConfigChangeEvent;

pub use config_management::ConfigChangeType;

pub use config_management::ConfigFileFormat;

pub use config_management::ConfigManagerSettings;

pub use config_management::ConfigMetadata;

pub use config_management::ConfigSnapshot;

pub use config_management::ConfigSource;

pub use config_management::Environment;

pub use config_management::SystemConfiguration;

pub use config_management::UnifiedConfigManager;

pub use config_management::ValidationError;

pub use config_management::ValidationResult;

pub use config_management::ValidationWarning;

pub use consent::ConsentManager;

pub use consent::ConsentPermissions;

pub use consent::ConsentRecord;

pub use consent::ConsentStatistics;

pub use consent::ConsentStatus;

pub use consent::ConsentType;

pub use consent::ConsentUsageContext;

pub use consent::ConsentUsageResult;

pub use consent::ConsentVerificationMethod;

pub use consent::SubjectIdentity;

pub use consent::UsageRestrictions;

pub use core::AdaptationConfig;

pub use core::RealtimeSynthesisChunk;

pub use core::RealtimeSynthesisConfig;

pub use core::RealtimeSynthesisRequest;

pub use core::RealtimeSynthesisResponse;

pub use core::SpeakerAdaptationResult;

pub use core::StreamSynthesisChunk;

pub use core::StreamSynthesisRequest;

pub use core::StreamingSynthesisConfig;

pub use core::SynthesisConfig;

pub use core::VoiceCloner;

pub use core::VoiceClonerBuilder;

pub use embedding::SpeakerEmbedding;

pub use embedding::SpeakerEmbeddingExtractor;

pub use emotion_transfer::EmotionCategory;

pub use emotion_transfer::EmotionTransfer;

pub use emotion_transfer::EmotionTransferConfig;

pub use emotion_transfer::EmotionTransferRequest;

pub use emotion_transfer::EmotionTransferResult;

pub use emotion_transfer::EmotionTransferStatistics;

pub use emotion_transfer::EmotionalCharacteristics;

pub use emotion_transfer::ProsodyFeatures;

pub use enterprise_sso::AuthenticationMethod;

pub use enterprise_sso::AuthenticationRequest;

pub use enterprise_sso::AuthenticationResponse;

pub use enterprise_sso::AuthorizationResult;

pub use enterprise_sso::EnterpriseSSOManager;

pub use enterprise_sso::JWTConfig;

pub use enterprise_sso::OAuthProvider;

pub use enterprise_sso::PasswordPolicy;

pub use enterprise_sso::Permission;

pub use enterprise_sso::PermissionScope;

pub use enterprise_sso::RBACManager;

pub use enterprise_sso::Role;

pub use enterprise_sso::SAMLProvider;

pub use enterprise_sso::SSOConfig;

pub use enterprise_sso::UserSession;

pub use error_handling::ErrorClassification;

pub use error_handling::ErrorContext;

pub use error_handling::ErrorRecoveryManager;

pub use error_handling::ErrorReport;

pub use error_handling::ErrorReportingConfig;

pub use error_handling::ErrorSeverity;

pub use error_handling::ErrorStatistics;

pub use error_handling::PerformanceImpact;

pub use error_handling::RecoverableError;

pub use error_handling::RecoveryConfig;

pub use error_handling::RecoveryOperation;

pub use error_handling::RecoveryProgress;

pub use error_handling::RecoveryResult;

pub use error_handling::RecoveryState;

pub use error_handling::RecoveryStrategy;

pub use error_handling::RetryConfig;

pub use few_shot::DistanceMetric;

pub use few_shot::FewShotConfig;

pub use few_shot::FewShotLearner;

pub use few_shot::FewShotMetrics;

pub use few_shot::FewShotResult;

pub use few_shot::MetaLearningAlgorithm;

pub use few_shot::SampleQuality;

pub use gaming_plugins::AudioAttenuation;

pub use gaming_plugins::AudioRolloffType;

pub use gaming_plugins::CombatState;

pub use gaming_plugins::DynamicVoiceCharacteristics;

pub use gaming_plugins::EmotionalState;

pub use gaming_plugins::EnvironmentalFilter;

pub use gaming_plugins::GameContext;

pub use gaming_plugins::GameEngineType;

pub use gaming_plugins::GamePerformanceProfile;

pub use gaming_plugins::GameSession;

pub use gaming_plugins::GameVoiceProfile;

pub use gaming_plugins::GameVoiceResult;

pub use gaming_plugins::GamingPluginConfig;

pub use gaming_plugins::GamingPluginManager;

pub use gaming_plugins::ReverbSettings;

pub use gaming_plugins::SpatialAudioProperties;

pub use gaming_plugins::UnityPlugin;

pub use gaming_plugins::UnrealPlugin;

pub use gaming_plugins::VoiceInstance;

pub use gaming_plugins::VoicePlaybackState;

pub use gaming_plugins::WeatherEffects;

pub use gpu_acceleration::GpuAccelerationConfig;

pub use gpu_acceleration::GpuAccelerator;

pub use gpu_acceleration::GpuDeviceType;

pub use gpu_acceleration::GpuMemoryStats;

pub use gpu_acceleration::GpuOperationType;

pub use gpu_acceleration::GpuPerformanceMetrics;

pub use gpu_acceleration::GpuUtils;

pub use gpu_acceleration::TensorOperation;

pub use gpu_acceleration::TensorOperationResult;

pub use load_balancing::GpuAssignment;

pub use load_balancing::GpuDeviceInfo;

pub use load_balancing::GpuLoadBalancer;

pub use load_balancing::LoadBalancingConfig;

pub use load_balancing::LoadBalancingStats;

pub use load_balancing::LoadBalancingStrategy;

pub use load_balancing::PerformancePrediction;

pub use long_term_adaptation::AdaptationResult;

pub use long_term_adaptation::AdaptationStatistics;

pub use long_term_adaptation::AdaptationStrategy;

pub use long_term_adaptation::EfficiencyMetrics;

pub use long_term_adaptation::FeedbackCategory;

pub use long_term_adaptation::FeedbackContext;

pub use long_term_adaptation::FeedbackType;

pub use long_term_adaptation::LongTermAdaptationConfig;

pub use long_term_adaptation::LongTermAdaptationEngine;

pub use long_term_adaptation::ProcessingStatistics;

pub use long_term_adaptation::RequestMetadata as AdaptationRequestMetadata;

pub use long_term_adaptation::UserFeedback;

pub use long_term_stability::RiskLevel;

pub use long_term_stability::StabilityAssessment;

pub use long_term_stability::StabilityCheckResult;

pub use long_term_stability::StabilityConclusions;

pub use long_term_stability::StabilityStatistics;

pub use long_term_stability::StabilityTestConfig;

pub use long_term_stability::StabilityTestResults;

pub use long_term_stability::StabilityValidator;

pub use memory_optimization::AlertSeverity;

pub use memory_optimization::AlertType;

pub use memory_optimization::AllocationInfo;

pub use memory_optimization::AllocationType;

pub use memory_optimization::CacheLimits;

pub use memory_optimization::CompressedEmbedding;

pub use memory_optimization::DetailedMemoryStats;

pub use memory_optimization::GarbageCollectionResult;

pub use memory_optimization::LeakDetectionConfig;

pub use memory_optimization::LeakSummary;

pub use memory_optimization::MemoryAuditReport;

pub use memory_optimization::MemoryIssue;

pub use memory_optimization::MemoryIssueType;

pub use memory_optimization::MemoryLeakDetector;

pub use memory_optimization::MemoryManager;

pub use memory_optimization::MemoryOptimizationConfig;

pub use memory_optimization::MemoryOptimizationRecommendation;

pub use memory_optimization::MemoryPool;

pub use memory_optimization::MemoryPoolSizes;

pub use memory_optimization::MemoryPoolStats;

pub use memory_optimization::MemoryRecommendation;

pub use memory_optimization::MemoryStats;

pub use memory_optimization::OptimizationCategory;

pub use memory_optimization::OptimizationImpact;

pub use memory_optimization::PerformanceImpactAnalysis;

pub use memory_optimization::PooledObject;

pub use memory_optimization::RecommendationPriority;

pub use memory_optimization::RecommendationType;

pub use mobile::CacheStrategy;

pub use mobile::MobileCloningConfig;

pub use mobile::MobileCloningStats;

pub use mobile::MobileDeviceInfo;

pub use mobile::MobilePlatform;

pub use mobile::MobileVoiceCloner;

pub use mobile::NeonCloningOptimizer;

pub use mobile::PowerMode;

pub use mobile::ThermalState;

pub use model_loading::LoadingMetrics;

pub use model_loading::LoadingStrategy;

pub use model_loading::MemoryPressureLevel;

pub use model_loading::ModelInterface;

pub use model_loading::ModelLoadingConfig;

pub use model_loading::ModelLoadingManager;

pub use model_loading::ModelMemoryManager;

pub use model_loading::ModelMetadata;

pub use model_loading::ModelPreloader;

pub use model_loading::PreloadPriority;

pub use model_loading::PreloadRequest;

pub use model_loading::UsagePatternAnalyzer;

pub use multimodal::AudioVisualAligner;

pub use multimodal::ExpressionAnalysis;

pub use multimodal::FacialGeometry;

pub use multimodal::FacialGeometryAnalyzer;

pub use multimodal::HeadPose;

pub use multimodal::LipFeatures;

pub use multimodal::LipMovementAnalyzer;

pub use multimodal::MultimodalCloneRequest;

pub use multimodal::MultimodalCloner;

pub use multimodal::MultimodalConfig;

pub use multimodal::VisualDataType;

pub use multimodal::VisualFeatureExtractor;

pub use multimodal::VisualFeatures;

pub use multimodal::VisualSample;

pub use neural_codec::CodecCompressionRequest;

pub use neural_codec::CodecCompressionResult;

pub use neural_codec::CodecDecompressionResult;

pub use neural_codec::CodecMetadata;

pub use neural_codec::CodecPerformanceStats;

pub use neural_codec::CodecQualityMetrics;

pub use neural_codec::NeuralCodec;

pub use neural_codec::NeuralCodecConfig;

pub use neural_codec::NeuralCodecManager;

pub use perceptual_evaluation::AgeGroup;

pub use perceptual_evaluation::AudioExperience;

pub use perceptual_evaluation::EvaluationResponse;

pub use perceptual_evaluation::EvaluationResults;

pub use perceptual_evaluation::EvaluationSample;

pub use perceptual_evaluation::EvaluationScores;

pub use perceptual_evaluation::EvaluationStudy;

pub use perceptual_evaluation::ExpertiseLevel;

pub use perceptual_evaluation::HearingStatus;

pub use perceptual_evaluation::PerceptualEvaluationConfig;

pub use perceptual_evaluation::PerceptualEvaluator;

pub use perceptual_evaluation::StudyResults;

pub use performance_monitoring::AdaptationMonitor;

pub use performance_monitoring::PerformanceMeasurement;

pub use performance_monitoring::PerformanceMetrics;

pub use performance_monitoring::PerformanceMonitor;

pub use performance_monitoring::PerformanceStatistics;

pub use performance_monitoring::PerformanceTargets;

pub use performance_monitoring::TargetResults;

pub use personality::AnalysisMetadata;

pub use personality::ConversationalStyle;

pub use personality::LinguisticPreferences;

pub use personality::PersonalityComponents;

pub use personality::PersonalityProfile;

pub use personality::PersonalityTraits;

pub use personality::PersonalityTransferConfig;

pub use personality::PersonalityTransferEngine;

pub use personality::SpeakingPatterns;

pub use personality::TransferStats;

pub use plugins::CloningPlugin;

pub use plugins::ExamplePlugin;

pub use plugins::ParameterConstraints;

pub use plugins::ParameterType;

pub use plugins::ParameterValue;

pub use plugins::PluginCapabilities;

pub use plugins::PluginConfig;

pub use plugins::PluginContext;

pub use plugins::PluginDependency;

pub use plugins::PluginHealth;

pub use plugins::PluginHealthStatus;

pub use plugins::PluginManager;

pub use plugins::PluginManagerConfig;

pub use plugins::PluginManifest;

pub use plugins::PluginMemoryStats;

pub use plugins::PluginMetrics;

pub use plugins::PluginOperationMetrics;

pub use plugins::PluginParameter;

pub use plugins::PluginPerformanceMetrics;

pub use plugins::PluginRegistry;

pub use plugins::PluginValidationResult;

pub use preprocessing::AudioPreprocessor;

pub use preprocessing::PreprocessingPipeline;

pub use quality::CloningQualityAssessor;

pub use quality::QualityMetrics;

pub use quantization::LayerQuantizationConfig;

pub use quantization::ModelQuantizer;

pub use quantization::QuantizationConfig;

pub use quantization::QuantizationMemoryAnalysis;

pub use quantization::QuantizationMethod;

pub use quantization::QuantizationPrecision;

pub use quantization::QuantizationResult;

pub use quantization::QuantizationStatsSummary;

pub use quantization::QuantizedTensor;

pub use realtime_streaming::AdaptiveQualityController;

pub use realtime_streaming::AudioChunk;

pub use realtime_streaming::AudioDeviceConfig;

pub use realtime_streaming::AudioInputStream;

pub use realtime_streaming::AudioOutputStream;

pub use realtime_streaming::LatencyMode;

pub use realtime_streaming::NetworkConditions;

pub use realtime_streaming::QualityAdaptationStrategy;

pub use realtime_streaming::RealtimeStreamingEngine;

pub use realtime_streaming::SessionState;

pub use realtime_streaming::StreamingConfig;

pub use realtime_streaming::StreamingMetrics;

pub use realtime_streaming::StreamingSession;

pub use realtime_streaming::StreamingSessionType;

pub use realtime_streaming::VADAlgorithm;

pub use realtime_streaming::VoiceActivityDetector;

pub use realtime_streaming::VoiceProcessingPipeline;

pub use similarity::SimilarityMeasurer;

pub use similarity::SimilarityScore;

pub use storage::AccessStats;

pub use storage::CompressionAlgorithm;

pub use storage::CompressionInfo;

pub use storage::CompressionStatistics;

pub use storage::HealthIndicators;

pub use storage::MaintenanceReport;

pub use storage::MaintenanceStatistics;

pub use storage::ModelFilter;

pub use storage::SpeakerInfo;

pub use storage::StorageConfig;

pub use storage::StorageInfo;

pub use storage::StorageOperation;

pub use storage::StorageOperationResult;

pub use storage::StorageStatistics;

pub use storage::StorageTier;

pub use storage::StoredModelMetadata;

pub use storage::VoiceCharacteristicsSummary;

pub use storage::VoiceModelStorage;

pub use streaming_adaptation::AdaptationStep;

pub use streaming_adaptation::StreamingAdaptationConfig;

pub use streaming_adaptation::StreamingAdaptationManager;

pub use streaming_adaptation::StreamingAdaptationManagerStats;

pub use streaming_adaptation::StreamingAdaptationResult;

pub use streaming_adaptation::StreamingAdaptationSession;

pub use streaming_adaptation::StreamingAdaptationStats;

pub use thread_safety::CacheStats;

pub use thread_safety::ComponentHealthMonitor;

pub use thread_safety::ComponentRegistry;

pub use thread_safety::ComponentStatus;

pub use thread_safety::ModelCache;

pub use thread_safety::OperationCoordinator;

pub use thread_safety::OperationGuard;

pub use thread_safety::OperationState;

pub use thread_safety::OperationStatus;

pub use thread_safety::PerformanceMetrics as ThreadPerformanceMetrics;

pub use thread_safety::ResourceLimits;

pub use thread_safety::ResourceMonitor;

pub use types::CloningMethod;

pub use types::SpeakerData;

pub use types::SpeakerProfile;

pub use types::VoiceCloneRequest;

pub use types::VoiceCloneResult;

pub use types::VoiceSample;

pub use usage_tracking::CloningOperation;

pub use usage_tracking::CloningOperationType;

pub use usage_tracking::ComplianceStatus;

pub use usage_tracking::OperationRecord;

pub use usage_tracking::OperationRequestMetadata as RequestMetadata;

pub use usage_tracking::Priority;

pub use usage_tracking::ResourceUsage;

pub use usage_tracking::UsageOutcome;

pub use usage_tracking::UsageRecord;

pub use usage_tracking::UsageStatistics;

pub use usage_tracking::UsageStatus;

pub use usage_tracking::UsageTracker;

pub use usage_tracking::UsageTrackingConfig;

pub use usage_tracking::UserContext;

pub use usage_tracking::UserPreferences;

pub use verification::SpeakerVerifier;

pub use verification::VerificationResult;

pub use vits2::Vits2Cloner;

pub use vits2::Vits2Config;

pub use vits2::Vits2PerformanceStats;

pub use vits2::Vits2QualityMetrics;

pub use vits2::Vits2SynthesisRequest;

pub use vits2::Vits2SynthesisResult;

pub use voice_aging::AgeTransition;

pub use voice_aging::AgingCharacteristics;

pub use voice_aging::AgingCurveType;

pub use voice_aging::AgingFactors;

pub use voice_aging::AgingQuality;

pub use voice_aging::AgingStatistics;

pub use voice_aging::ArticulatoryAging;

pub use voice_aging::FormantAging;

pub use voice_aging::ProsodicAging;

pub use voice_aging::RespiratoryAging;

pub use voice_aging::StabilityFactors;

pub use voice_aging::TemporalModel;

pub use voice_aging::TransitionType;

pub use voice_aging::VariationFactors;

pub use voice_aging::VoiceAgingConfig;

pub use voice_aging::VoiceAgingEngine;

pub use voice_aging::VoiceAgingModel;

pub use voice_aging::VoiceAgingResult;

pub use voice_aging::VoiceQualityAging;

pub use voice_morphing::InterpolationMethod;

pub use voice_morphing::MorphingWeight;

pub use voice_morphing::RealtimeMorphingSession;

pub use voice_morphing::VoiceMorpher;

pub use voice_morphing::VoiceMorphingConfig;

pub use voice_morphing::VoiceMorphingRequest;

pub use voice_morphing::VoiceMorphingResult;

pub use zero_shot::ReferenceVoice;

pub use zero_shot::ZeroShotCloner;

pub use zero_shot::ZeroShotConfig;

pub use zero_shot::ZeroShotMethod;

pub use zero_shot::ZeroShotResult;

Modules

ab_testing

A/B Testing Framework for Voice Cloning Quality Comparison

acoustic

Acoustic model integration for voice cloning

adaptation

Speaker adaptation methods for voice cloning

adversarial_robustness

Adversarial Robustness for Voice Cloning Systems

age_gender_adaptation

Age and Gender Adaptation for Voice Cloning

api_standards

API Standards and Guidelines for voirs-cloning

authenticity

Authenticity Detection System for Voice Cloning

auto_scaling

Auto-scaling System for Dynamic GPU Resource Allocation

cloning_wizard

Cloning Wizard for VoiRS Voice Cloning

cloud_scaling

Cloud Scaling for VoiRS Voice Cloning

config

Configuration for voice cloning

config_management

Unified Configuration Management System

consent

Consent Management System for Voice Cloning

consent_crypto

Cryptographic Consent Verification System

consistency_models

Consistency Models for Fast Voice Synthesis

conversion

Real-time voice conversion system for live audio processing

core

Auto-generated module structure

deep_mos

Deep Learning-based MOS (Mean Opinion Score) Prediction

edge

Edge Deployment Optimizations for VoiRS Voice Cloning

embedding

Speaker embedding extraction and management

emotion_transfer

Emotion Transfer System

enterprise_sso

Enterprise Single Sign-On and Role-Based Access Control System

error_handling

Enhanced error handling and recovery system for voice cloning operations

few_shot

Auto-generated module structure

flow_matching

Flow Matching for Voice Synthesis

gaming_plugins

Gaming Engine Integration Plugins

gpu_acceleration

GPU Acceleration System

kernel_fusion

Kernel Fusion for Advanced SIMD Optimization

load_balancing

GPU Load Balancing System for Voice Cloning

long_term_adaptation

Long-term adaptation system for continuous learning from user feedback

long_term_stability

Long-term stability validation for voice cloning consistency

memory_optimization

Auto-generated module structure

misuse_prevention

Misuse Prevention System for Voice Cloning

mobile

Mobile Platform Optimizations for VoiRS Voice Cloning

model_loading

Advanced model loading and caching optimization system

multimodal

Multi-modal voice cloning using visual and audio cues

neural_codec

Neural Codec Implementation for Advanced Audio Compression and Quality Enhancement

perceptual_evaluation

Perceptual evaluation framework for voice cloning quality assessment

performance_monitoring

Performance monitoring and target validation for voice cloning operations

personality

Personality Transfer System for VoiRS Voice Cloning

plugins

Plugin Architecture for Custom Voice Cloning Models

prelude

Prelude module for convenient imports

preprocessing

Audio preprocessing for voice cloning

privacy_protection

Privacy Protection System for Voice Cloning

qat

Quantization-Aware Training (QAT)

quality

Auto-generated module structure

quality_visualization

Quality Visualization Dashboard for VoiRS Voice Cloning

quantization

Model quantization for edge deployment

realtime_streaming

Enhanced Real-time Streaming Synthesis System

similarity

Comprehensive speaker similarity measurement and objective quality metrics

ssl_verification

Self-Supervised Learning (SSL) Based Speaker Verification

storage

Efficient storage system for thousands of cloned voices

streaming_adaptation

Streaming adaptation for real-time model updates during synthesis

thread_safety

Advanced thread safety improvements for voice cloning

types

Core types for voice cloning

usage_tracking

Auto-generated module structure

utils

Utility modules for voice cloning system

verification

Speaker verification for voice cloning

visual_editor

Visual Voice Editor for VoiRS Voice Cloning

vits2

VITS2 (Variational Inference with adversarial learning for end-to-end Text-to-Speech 2) Implementation

vocoder

Vocoder integration for speaker-specific parameter conditioning

voice_aging

Voice aging system for modeling temporal voice changes

voice_library

Voice Library Management for VoiRS Voice Cloning

voice_morphing

Voice morphing and speaker blending implementation

zero_shot

Zero-shot voice cloning implementation

Enums

Error

Error types for voice cloning

Type Aliases

Result

Result type for voice cloning operations