voirs_cli/commands/interactive/

synthesis.rs

//! Real-time synthesis engine for interactive mode
//!
//! Handles:
//! - Real-time text-to-speech synthesis
//! - Immediate audio playback
//! - Voice switching during session
//! - Audio parameter adjustments

use crate::audio::playback::{AudioData, AudioPlayer, PlaybackConfig};
use crate::error::{Result, VoirsCliError};
use std::sync::Arc;
use tokio::sync::RwLock;

/// Real-time synthesis engine
pub struct SynthesisEngine {
    /// VoiRS SDK pipeline for synthesis
    pipeline: Option<Arc<RwLock<voirs_sdk::VoirsPipeline>>>,

    /// Audio player for immediate playback
    audio_player: AudioPlayer,

    /// Current synthesis parameters
    current_speed: f32,
    current_pitch: f32,
    current_volume: f32,

    /// Available voices cache
    available_voices: Vec<String>,

    /// Current voice
    current_voice: Option<String>,
}

impl SynthesisEngine {
    /// Create a new synthesis engine
    pub async fn new() -> Result<Self> {
        // Initialize audio player with default config
        let config = PlaybackConfig::default();
        let audio_player = AudioPlayer::new(config).map_err(|e| {
            VoirsCliError::AudioError(format!("Failed to initialize audio player: {}", e))
        })?;

        // Load available voices
        let available_voices = Self::load_available_voices().await?;

        Ok(Self {
            pipeline: None,
            audio_player,
            current_speed: 1.0,
            current_pitch: 0.0,
            current_volume: 1.0,
            available_voices,
            current_voice: None,
        })
    }

    /// Load available voices from the system
    async fn load_available_voices() -> Result<Vec<String>> {
        // For now, return a list of common voices
        // In a real implementation, this would query the VoiRS system
        Ok(vec![
            "en-us-female-01".to_string(),
            "en-us-male-01".to_string(),
            "en-gb-female-01".to_string(),
            "ja-jp-female-01".to_string(),
        ])
    }

    /// Get list of available voices
    pub async fn list_voices(&self) -> Result<Vec<String>> {
        Ok(self.available_voices.clone())
    }

    /// Set the current voice
    pub async fn set_voice(&mut self, voice: &str) -> Result<()> {
        // Validate voice exists
        if !self.available_voices.contains(&voice.to_string()) {
            return Err(VoirsCliError::VoiceError(format!(
                "Voice '{}' not found. Available voices: {}",
                voice,
                self.available_voices.join(", ")
            )));
        }

        // Initialize pipeline if needed
        if self.pipeline.is_none() {
            self.pipeline = Some(Arc::new(RwLock::new(self.create_pipeline(voice).await?)));
        } else {
            // Switch voice in existing pipeline
            if let Some(ref pipeline) = self.pipeline {
                let mut pipeline_guard = pipeline.write().await;
                pipeline_guard.set_voice(voice).await.map_err(|e| {
                    VoirsCliError::SynthesisError(format!("Failed to set voice: {}", e))
                })?;
            }
        }

        self.current_voice = Some(voice.to_string());
        println!("✓ Voice set to: {}", voice);

        Ok(())
    }

    /// Create a new VoiRS pipeline
    async fn create_pipeline(&self, voice: &str) -> Result<voirs_sdk::VoirsPipeline> {
        // Create pipeline using VoiRS SDK builder
        let pipeline = voirs_sdk::VoirsPipeline::builder()
            .with_quality(voirs_sdk::QualityLevel::High)
            .with_voice(voice)
            .build()
            .await
            .map_err(|e| {
                VoirsCliError::SynthesisError(format!(
                    "Failed to create VoiRS pipeline for voice '{}': {}",
                    voice, e
                ))
            })?;

        Ok(pipeline)
    }

    /// Synthesize text to audio
    pub async fn synthesize(&self, text: &str) -> Result<Vec<f32>> {
        if self.pipeline.is_none() {
            return Err(VoirsCliError::SynthesisError(
                "No voice selected. Use ':voice <voice_name>' to set a voice.".to_string(),
            ));
        }

        // Use the VoiRS pipeline for real synthesis
        if let Some(pipeline) = &self.pipeline {
            // Build synthesis configuration
            let mut config = voirs_sdk::types::SynthesisConfig::default();
            config.speaking_rate = self.current_speed;
            config.pitch_shift = self.current_pitch;
            config.volume_gain = self.current_volume;

            // Perform synthesis
            let pipeline_guard = pipeline.read().await;
            match pipeline_guard.synthesize_with_config(text, &config).await {
                Ok(audio_buffer) => {
                    // Convert AudioBuffer to Vec<f32>
                    Ok(audio_buffer.samples().to_vec())
                }
                Err(e) => {
                    tracing::warn!("Synthesis failed, falling back to placeholder: {}", e);

                    // Fallback to simple sine wave generation
                    let sample_rate = 22050;
                    let duration_ms = text.len() as f32 * 50.0; // Rough estimate
                    let num_samples = (sample_rate as f32 * duration_ms / 1000.0) as usize;

                    let frequency = 440.0; // A4 note
                    let mut samples = Vec::with_capacity(num_samples);

                    for i in 0..num_samples {
                        let t = i as f32 / sample_rate as f32;
                        let sample = (2.0 * std::f32::consts::PI * frequency * t).sin()
                            * 0.1
                            * self.current_volume;
                        samples.push(sample);
                    }

                    // Simulate processing time for fallback
                    tokio::time::sleep(tokio::time::Duration::from_millis(
                        (text.len() as u64 * 10).min(500),
                    ))
                    .await;

                    Ok(samples)
                }
            }
        } else {
            Err(VoirsCliError::SynthesisError(
                "No pipeline available for synthesis".to_string(),
            ))
        }
    }

    /// Play audio data
    pub async fn play_audio(&mut self, audio_data: &[f32]) -> Result<()> {
        // Convert f32 samples to i16 for AudioData
        let samples_i16: Vec<i16> = audio_data
            .iter()
            .map(|&sample| (sample * i16::MAX as f32) as i16)
            .collect();

        let audio_data = AudioData {
            samples: samples_i16,
            sample_rate: 22050,
            channels: 1,
        };

        self.audio_player
            .play(&audio_data)
            .await
            .map_err(|e| VoirsCliError::AudioError(format!("Failed to play audio: {}", e)))?;

        Ok(())
    }

    /// Set synthesis speed
    pub async fn set_speed(&mut self, speed: f32) -> Result<()> {
        self.current_speed = speed.clamp(0.1, 3.0);

        // Apply to pipeline if available
        if let Some(ref pipeline) = self.pipeline {
            // In a real implementation, this would configure the pipeline
            println!("✓ Speed set to: {:.1}x", self.current_speed);
        }

        Ok(())
    }

    /// Set synthesis pitch
    pub async fn set_pitch(&mut self, pitch: f32) -> Result<()> {
        self.current_pitch = pitch.clamp(-12.0, 12.0);

        // Apply to pipeline if available
        if let Some(ref pipeline) = self.pipeline {
            // In a real implementation, this would configure the pipeline
            println!("✓ Pitch set to: {:.1} semitones", self.current_pitch);
        }

        Ok(())
    }

    /// Set synthesis volume
    pub async fn set_volume(&mut self, volume: f32) -> Result<()> {
        self.current_volume = volume.clamp(0.0, 2.0);

        // Apply to audio player
        self.audio_player
            .set_volume(self.current_volume)
            .map_err(|e| VoirsCliError::AudioError(format!("Failed to set volume: {}", e)))?;

        println!("✓ Volume set to: {:.1}", self.current_volume);

        Ok(())
    }

    /// Get current synthesis parameters
    pub fn current_params(&self) -> (f32, f32, f32) {
        (self.current_speed, self.current_pitch, self.current_volume)
    }

    /// Get current voice
    pub fn current_voice(&self) -> Option<&str> {
        self.current_voice.as_deref()
    }

    /// Check if synthesis engine is ready
    pub fn is_ready(&self) -> bool {
        self.pipeline.is_some()
    }
}