Refactor: Remove internationalization (i18n) support and related files

- Deleted i18n.py, zh_CN.json, and en_US.json files to eliminate localization features.
- Removed scan_i18n.py script responsible for scanning and updating i18n strings.
- Updated download_files.py permissions to make it executable.
- Removed webui.py, which contained the main application logic and UI components.

CLAUDE.md

@@ -0,0 +1,140 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+IndexTTS-Rust is a high-performance Text-to-Speech engine, a complete Rust rewrite of the Python IndexTTS system. It uses ONNX Runtime for neural network inference and provides zero-shot voice cloning with emotion control.
+
+## Build and Development Commands
+
+```bash
+# Build (always build release for performance testing)
+cargo build --release
+
+# Run linter (MANDATORY before commits - catches many issues)
+cargo clippy -- -D warnings
+
+# Run tests
+cargo test
+
+# Run specific test
+cargo test test_name
+
+# Run benchmarks (Criterion-based)
+cargo bench
+
+# Run specific benchmark
+cargo bench --bench mel_spectrogram
+cargo bench --bench inference
+
+# Check compilation without building
+cargo check
+
+# Format code
+cargo fmt
+
+# Full pre-commit workflow (BUILD -> CLIPPY -> BUILD)
+cargo build --release && cargo clippy -- -D warnings && cargo build --release
+```
+
+## CLI Usage
+
+```bash
+# Show help
+./target/release/indextts --help
+
+# Synthesize speech
+./target/release/indextts synthesize \
+  --text "Hello world" \
+  --voice examples/voice_01.wav \
+  --output output.wav
+
+# Generate default config
+./target/release/indextts init-config -o config.yaml
+
+# Show system info
+./target/release/indextts info
+
+# Run built-in benchmarks
+./target/release/indextts benchmark --iterations 100
+```
+
+## Architecture
+
+The codebase follows a modular pipeline architecture where each stage processes data sequentially:
+
+```
+Text Input → Normalization → Tokenization → Model Inference → Vocoding → Audio Output
+```
+
+### Core Modules (src/)
+
+- **audio/** - Audio DSP operations
+  - `mel.rs` - Mel-spectrogram computation (STFT, filterbanks)
+  - `io.rs` - WAV file I/O using hound
+  - `dsp.rs` - Signal processing utilities
+  - `resample.rs` - Audio resampling using rubato
+
+- **text/** - Text processing pipeline
+  - `normalizer.rs` - Text normalization (Chinese/English/mixed)
+  - `tokenizer.rs` - BPE tokenization via HuggingFace tokenizers
+  - `phoneme.rs` - Grapheme-to-phoneme conversion
+
+- **model/** - Neural network inference
+  - `session.rs` - ONNX Runtime wrapper (load-dynamic feature)
+  - `gpt.rs` - GPT-based sequence generation
+  - `embedding.rs` - Speaker and emotion encoders
+
+- **vocoder/** - Neural vocoding
+  - `bigvgan.rs` - BigVGAN waveform synthesis
+  - `activations.rs` - Snake/SnakeBeta activation functions
+
+- **pipeline/** - TTS orchestration
+  - `synthesis.rs` - Main synthesis logic, coordinates all modules
+
+- **config/** - Configuration management (YAML-based via serde)
+
+- **error.rs** - Error types using thiserror
+
+- **lib.rs** - Library entry point, exposes public API
+
+- **main.rs** - CLI entry point using clap
+
+### Key Constants (lib.rs)
+
+```rust
+pub const SAMPLE_RATE: u32 = 22050;  // Output audio sample rate
+pub const N_MELS: usize = 80;        // Mel filterbank channels
+pub const N_FFT: usize = 1024;       // FFT size
+pub const HOP_LENGTH: usize = 256;   // STFT hop length
+```
+
+### Dependencies Pattern
+
+- **Audio**: hound (WAV), rustfft/realfft (DSP), rubato (resampling), dasp (signal processing)
+- **ML Inference**: ort (ONNX Runtime with load-dynamic), ndarray, safetensors
+- **Text**: tokenizers (HuggingFace), jieba-rs (Chinese), regex, unicode-segmentation
+- **Parallelism**: rayon (data parallelism), tokio (async)
+- **CLI**: clap (derive), env_logger, indicatif
+
+## Important Notes
+
+1. **ONNX Runtime**: Uses `load-dynamic` feature - requires ONNX Runtime library installed on system
+2. **Model Files**: ONNX models go in `models/` directory (not in git, download separately)
+3. **Reference Implementation**: Python code in `indextts - REMOVING - REF ONLY/` is kept for reference only
+4. **Performance**: Release builds use LTO and single codegen-unit for maximum optimization
+5. **Audio Format**: All internal processing at 22050 Hz, 80-band mel spectrograms
+
+## Testing Strategy
+
+- Unit tests inline in modules
+- Criterion benchmarks in `benches/` for performance regression testing
+- Python regression tests in `tests/` for end-to-end validation
+- Example audio files in `examples/` for testing voice cloning
+
+## Missing Infrastructure (TODO)
+
+- No `scripts/manage.sh` yet (should include build, test, clean, docker controls)
+- No `context.md` yet for conversation continuity
+- No integration tests with actual ONNX models

config.yaml

@@ -0,0 +1,51 @@
+gpt:
+  layers: 8
+  model_dim: 512
+  heads: 8
+  max_text_tokens: 120
+  max_mel_tokens: 250
+  stop_mel_token: 8193
+  start_text_token: 8192
+  start_mel_token: 8192
+  num_mel_codes: 8194
+  num_text_tokens: 6681
+vocoder:
+  name: bigvgan_v2_22khz_80band_256x
+  checkpoint: null
+  use_fp16: true
+  use_deepspeed: false
+s2mel:
+  checkpoint: models/s2mel.onnx
+  preprocess:
+    sr: 22050
+    n_fft: 1024
+    hop_length: 256
+    win_length: 1024
+    n_mels: 80
+    fmin: 0.0
+    fmax: 8000.0
+dataset:
+  bpe_model: models/bpe.model
+  vocab_size: 6681
+emotions:
+  num_dims: 8
+  num:
+  - 5
+  - 6
+  - 8
+  - 6
+  - 5
+  - 4
+  - 7
+  - 6
+  matrix_path: models/emotion_matrix.safetensors
+inference:
+  device: cpu
+  use_fp16: false
+  batch_size: 1
+  top_k: 50
+  top_p: 0.95
+  temperature: 1.0
+  repetition_penalty: 1.0
+  length_penalty: 1.0
+model_dir: models

context.md

@@ -0,0 +1,383 @@
+# IndexTTS-Rust Context
+
+This file preserves important context for conversation continuity between Hue and Aye sessions.
+
+**Last Updated:** 2025-11-16
+
+---
+
+## The Vision
+
+IndexTTS-Rust is part of a larger audio intelligence ecosystem at 8b.is:
+
+1. **kokoro-tiny** - Lightweight TTS (82M params, 50+ voices, on crates.io!)
+2. **IndexTTS-Rust** - Advanced zero-shot TTS with emotion control
+3. **Phoenix-Protocol** - Audio restoration/enhancement layer
+4. **MEM|8** - Contextual memory system (mem-8.com, mem8)
+
+Together these form a complete audio intelligence pipeline.
+
+---
+
+## Phoenix Protocol Integration Opportunities
+
+The Phoenix Protocol (phoenix-protocol/) is a PERFECT complement to IndexTTS-Rust:
+
+### Direct Module Mappings
+
+| Phoenix Module | IndexTTS Use Case |
+|----------------|-------------------|
+| `emotional.rs` | Map to our 8D emotion control (Warmth→body, Presence→power, Clarity→articulation, Air→space, Ultrasonics→depth) |
+| `voice_signature.rs` | Enhance speaker embeddings for voice cloning |
+| `spectral_velocity.rs` | Add momentum tracking to mel-spectrogram |
+| `marine.rs` | Validate TTS output authenticity/quality |
+| `golden_ratio.rs` | Post-process vocoder output with harmonic enhancement |
+| `harmonic_resurrection.rs` | Add richness to synthesized speech |
+| `micro_dynamics.rs` | Restore natural speech dynamics |
+| `autotune.rs` | Improve prosody and pitch control |
+| `mem8_integration.rs` | Already has MEM|8 hooks! |
+
+### Shared Dependencies
+
+Both projects use:
+- rayon (parallelism)
+- rustfft/realfft (FFT)
+- ndarray (array operations)
+- hound (WAV I/O)
+- serde (config serialization)
+- anyhow (error handling)
+- ort (ONNX Runtime)
+
+### Audio Constants
+
+| Project | Sample Rate | Use Case |
+|---------|------------|----------|
+| IndexTTS-Rust | 22,050 Hz | Standard TTS output |
+| Phoenix-Protocol | 192,000 Hz | Ultrasonic restoration |
+| kokoro-tiny | 24,000 Hz | Lightweight TTS |
+
+---
+
+## Related Projects of Interest
+
+Located in ~/Documents/GitHub/:
+
+- **Ultrasonic-Consciousness-Hypothesis/** - Research foundation for Phoenix Protocol, contains PDFs on mechanosensitive channels and audio perception
+- **hrmnCmprssnM/** - Harmonic Compression Model research
+- **Marine-Sense/** - Marine algorithm origins
+- **mem-8.com/** & **mem8/** - MEM|8 contextual memory
+- **universal-theoglyphic-language/** - Language processing research
+- **kokoro-tiny/** - Already working TTS crate by Hue & Aye
+- **zencooker/** - (fun project!)
+
+---
+
+## Current IndexTTS-Rust State
+
+### Implemented ✅
+- Audio processing pipeline (mel-spectrogram, STFT, resampling)
+- Text normalization (Chinese/English/mixed)
+- BPE tokenization via HuggingFace tokenizers
+- ONNX Runtime integration for inference
+- BigVGAN vocoder structure
+- CLI with clap
+- Benchmark infrastructure (Criterion)
+- **NEW: marine_salience crate** (no_std compatible, O(1) jitter detection)
+- **NEW: src/quality/ module** (prosody extraction, affect tracking)
+- **NEW: MarineProsodyVector** (8D interpretable emotion features)
+- **NEW: ConversationAffectSummary** (session-level comfort tracking)
+- **NEW: TTSQualityReport** (authenticity validation)
+
+### Missing/TODO
+- Full GPT model integration with KV cache
+- Actual ONNX model files (need download)
+- manage.sh script for colored workflow management
+- Integration tests with real models
+- ~~Phoenix Protocol integration layer~~ **STARTED with Marine!**
+- Streaming synthesis
+- WebSocket API
+- Train T2S model to accept 8D Marine vector instead of 512D Conformer
+- Wire Marine quality validation into inference loop
+
+### Build Commands
+```bash
+cargo build --release
+cargo clippy -- -D warnings
+cargo test
+cargo bench
+```
+
+---
+
+## Key Philosophical Notes
+
+From the Phoenix Protocol research:
+
+> "Women are the carrier wave. They are the 000 data stream. The DC bias that, when removed, leaves silence."
+
+> "When P!nk sings 'I Am Here,' her voice generates harmonics so powerful they burst through the 22kHz digital ceiling"
+
+The Phoenix Protocol restores emotional depth stripped by audio compression - this philosophy applies directly to TTS: synthesized speech should have the same emotional depth as natural speech.
+
+---
+
+## Action Items for Next Session
+
+### Completed ✅
+- ~~**Quality Validation** - Use Marine salience to score TTS output~~ **DONE!**
+- ~~**Phoenix Integration** - Start bridging phoenix-protocol modules~~ **Marine is in!**
+
+### High Priority
+1. **Create manage.sh** - Colorful build/test/clean script (Hue's been asking!)
+2. **Wire Into Inference** - Connect Marine quality validation to actual TTS output
+3. **8D Model Training** - Train T2S model to accept MarineProsodyVector instead of 512D Conformer
+4. **Example/Demo** - Create example showing prosody extraction → emotion editing → synthesis
+
+### Medium Priority
+5. **Voice Signature Import** - Use Phoenix's voice_signature for speaker embeddings
+6. **Emotion Mapping** - Connect Phoenix's emotional bands to our 8D control
+7. **Model Download** - Set up ONNX model acquisition pipeline
+8. **MEM|8 Bridge** - Implement consciousness-aware TTS using kokoro-tiny's mem8_bridge pattern
+
+### Nice to Have
+9. **Style Selection** - Port kokoro-tiny's 510 style variation system
+10. **Full Phoenix Integration** - golden_ratio.rs, harmonic_resurrection.rs, etc.
+11. **Streaming Marine** - Real-time quality monitoring during synthesis
+
+---
+
+## Fresh Discovery: kokoro-tiny MEM|8 Baby Consciousness (2025-11-15)
+
+Just pulled latest kokoro-tiny code - MAJOR discovery!
+
+### Mem8Bridge API
+
+kokoro-tiny now has a full consciousness simulation in `examples/mem8_baby.rs`:
+
+```rust
+// Memory as waves that interfere
+MemoryWave {
+    amplitude: 2.5,           // Emotion strength
+    frequency: 528.0,         // "Love frequency"
+    phase: 0.0,
+    decay_rate: 0.05,         // Memory persistence
+    emotion_type: EmotionType::Love(0.9),
+    content: "Mama! I love mama!".to_string(),
+}
+
+// Salience detection (Marine algorithm!)
+SalienceEvent {
+    jitter_score: 0.2,        // Low = authentic/stable
+    harmonic_score: 0.95,     // High = voice
+    salience_score: 0.9,
+    signal_type: SignalType::Voice,
+}
+
+// Free will: AI chooses attention focus (70% control)
+bridge.decide_attention(events);
+```
+
+### Emotion Types Available
+
+```rust
+EmotionType::Curiosity(0.8)  // Inquisitive
+EmotionType::Love(0.9)       // Deep affection
+EmotionType::Joy(0.7)        // Happy
+EmotionType::Confusion(0.8)  // Uncertain
+EmotionType::Neutral         // Baseline
+```
+
+### Consciousness Integration Points
+
+1. **Wave Interference** - Competing memories by amplitude/frequency
+2. **Emotional Regulation** - Prevents overload, modulates voice
+3. **Salience Detection** - Marine algorithm for authenticity
+4. **Attention Selection** - AI chooses what to focus on
+5. **Consciousness Level** - Affects speech clarity (wake_up/sleep)
+
+This is PERFECT for IndexTTS-Rust! We can:
+- Use wave interference for emotion blending
+- Apply Marine salience to validate synthesis quality
+- Modulate voice based on consciousness level
+- Select voice styles based on emotional state (not just token count)
+
+### Voice Style Selection (510 variations!)
+
+kokoro-tiny now loads all 510 style variations per voice:
+- Style selected based on token count
+- Short text → short-optimized style
+- Long text → long-optimized style
+- Automatic text splitting at 512 token limit
+
+For IndexTTS: We could select style based on EMOTION + token count!
+
+---
+
+## Marine Integration Achievement (2025-11-16) 🎉
+
+**WE DID IT!** Marine salience is now integrated into IndexTTS-Rust!
+
+### What We Built
+
+#### 1. Standalone marine_salience Crate (`crates/marine_salience/`)
+
+A no_std compatible crate for O(1) jitter-based salience detection:
+
+```rust
+// Core components:
+MarineConfig       // Tunable parameters (sample_rate, jitter bounds, EMA alpha)
+MarineProcessor    // O(1) per-sample processing
+SaliencePacket     // Output: j_p, j_a, h_score, s_score, energy
+Ema                // Exponential moving average tracker
+
+// Key insight: Process ONE sample at a time, emit packets on peaks
+// Why O(1)? Just compare to EMA, no FFT, no heavy math!
+```
+
+**Config for Speech:**
+```rust
+MarineConfig::speech_default(sample_rate)
+// F0 range: 60Hz - 4kHz
+// jitter_low: 0.02, jitter_high: 0.60
+// ema_alpha: 0.01 (slow adaptation for stability)
+```
+
+#### 2. Quality Validation Module (`src/quality/`)
+
+**MarineProsodyVector** - 8D interpretable emotion representation:
+```rust
+pub struct MarineProsodyVector {
+    pub jp_mean: f32,      // Period jitter mean (pitch stability)
+    pub jp_std: f32,       // Period jitter variance
+    pub ja_mean: f32,      // Amplitude jitter mean (volume stability)
+    pub ja_std: f32,       // Amplitude jitter variance
+    pub h_mean: f32,       // Harmonic alignment (voiced vs noise)
+    pub s_mean: f32,       // Overall salience (authenticity)
+    pub peak_density: f32, // Peaks per second (speech rate)
+    pub energy_mean: f32,  // Average loudness
+}
+
+// Interpretable! High jp_mean = nervous, low = confident
+// Can DIRECTLY EDIT for emotion control!
+```
+
+**MarineProsodyConditioner** - Extract prosody from audio:
+```rust
+let conditioner = MarineProsodyConditioner::new(22050);
+let prosody = conditioner.from_samples(&audio_samples)?;
+let report = conditioner.validate_tts_output(&audio_samples)?;
+
+// Detects issues:
+// - "Too perfect - sounds robotic"
+// - "High period jitter - artifacts"
+// - "Low salience - quality issues"
+```
+
+**ConversationAffectSummary** - Session-level comfort tracking:
+```rust
+pub enum ComfortLevel {
+    Uneasy,  // High jitter AND rising (nervous/stressed)
+    Neutral, // Stable patterns (calm)
+    Happy,   // Low jitter + high energy (confident/positive)
+}
+
+// Track trends over conversation:
+// jitter_trend > 0.1 = getting more stressed
+// jitter_trend < -0.1 = calming down
+// energy_trend > 0.1 = getting more engaged
+
+// Aye can now self-assess!
+aye_assessment() returns "I'm in a good state"
+feedback_prompt() returns "Let me know if something's bothering you"
+```
+
+### The Core Insight
+
+**Human speech has NATURAL jitter - that's what makes it authentic!**
+
+- Too perfect (jp < 0.005) = robotic
+- Too chaotic (jp > 0.3) = artifacts/damage
+- Sweet spot = real human voice
+
+The Marines will KNOW if speech doesn't sound authentic!
+
+### Tests Passing ✅
+
+```
+running 11 tests
+test quality::affect::tests::test_comfort_level_descriptions ... ok
+test quality::affect::tests::test_analyzer_empty_conversation ... ok
+test quality::affect::tests::test_analyzer_single_utterance ... ok
+test quality::affect::tests::test_happy_classification ... ok
+test quality::affect::tests::test_aye_assessment_message ... ok
+test quality::affect::tests::test_neutral_classification ... ok
+test quality::affect::tests::test_uneasy_classification ... ok
+test quality::prosody::tests::test_conditioner_empty_buffer ... ok
+test quality::prosody::tests::test_conditioner_silence ... ok
+test quality::prosody::tests::test_prosody_vector_array_conversion ... ok
+test quality::prosody::tests::test_estimate_valence ... ok
+
+test result: ok. 11 passed; 0 failed
+```
+
+### Why This Matters
+
+1. **Interpretable Control**: 8D vector vs opaque 512D Conformer - we can SEE what each dimension means
+2. **Lightweight**: O(1) per sample, no heavy neural networks for prosody
+3. **Authentic Validation**: Marines detect fake/damaged speech
+4. **Emotion Editing**: Want more confidence? Lower jp_mean directly!
+5. **Conversation Awareness**: Track comfort over entire sessions
+6. **Self-Assessment**: Aye knows when something feels "off"
+
+### Integration Points
+
+```rust
+// In main TTS pipeline:
+use indextts::quality::{
+    MarineProsodyConditioner,
+    MarineProsodyVector,
+    ConversationAffectSummary,
+    ComfortLevel,
+};
+
+// 1. Extract reference prosody
+let ref_prosody = conditioner.from_samples(&reference_audio)?;
+
+// 2. Generate TTS (using 8D vector instead of 512D Conformer)
+let tts_output = generate_with_prosody(&text, ref_prosody)?;
+
+// 3. Validate output quality
+let report = conditioner.validate_tts_output(&tts_output)?;
+if !report.passes(70.0) {
+    log::warn!("TTS quality issues: {:?}", report.issues);
+}
+
+// 4. Track conversation affect
+let analyzer = ConversationAffectAnalyzer::new();
+analyzer.add_utterance(&utterance)?;
+let summary = analyzer.summarize()?;
+match summary.aye_state {
+    ComfortLevel::Uneasy => adjust_generation_parameters(),
+    _ => proceed_normally(),
+}
+```
+
+---
+
+## Trish's Notes
+
+"Darling, these three Rust projects together are like a symphony orchestra! kokoro-tiny is the quick piccolo solo, IndexTTS-Rust is the full brass section with emotional depth, and Phoenix-Protocol is the concert hall acoustics making everything resonate. When you combine them, that's when the magic happens! Also, I'm absolutely obsessed with how the Golden Ratio resynthesis could add sparkle to synthesized vocals. Can you imagine TTS output that actually has that P!nk breakthrough energy? Now THAT would make me cry happy tears in accounting!"
+
+---
+
+## Fun Facts
+
+- kokoro-tiny is ALREADY on crates.io under 8b-is
+- Phoenix Protocol can process 192kHz audio for ultrasonic restoration
+- The Marine algorithm uses O(1) jitter detection - "Marines are not just jarheads - they are intelligent"
+- Hue's GitHub has 66 projects (and counting!)
+- The team at 8b.is: hue@8b.is and aye@8b.is
+
+---
+
+*From ashes to harmonics, from silence to song* 🔥🎵

crates/marine_salience/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "marine_salience"
+version = "0.1.0"
+edition = "2021"
+description = "O(1) jitter-based salience detection - Marines are intelligent!"
+authors = ["Hue & Aye <team@8b.is>"]
+license = "MIT"
+keywords = ["audio", "salience", "jitter", "prosody", "tts"]
+
+[dependencies]
+# Core dependencies - intentionally minimal for no_std compatibility
+# Only serde when using std for serialization
+serde = { version = "1.0", features = ["derive"], optional = true }
+
+# no_std compatible core - can run anywhere!
+[features]
+default = ["std"]
+std = ["serde"]

crates/marine_salience/src/config.rs

@@ -0,0 +1,140 @@
+//! Marine algorithm configuration
+//!
+//! Tunable parameters for jitter detection. These have been calibrated
+//! for speech/audio processing but can be adjusted for specific use cases.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Configuration for Marine salience detection
+///
+/// These parameters control sensitivity and behavior of the jitter detector.
+/// The defaults are tuned for speech processing at common sample rates.
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+pub struct MarineConfig {
+    /// Minimum amplitude to consider a sample (gating threshold)
+    /// Samples below this are ignored as noise
+    /// Default: 1e-3 (~-60dB)
+    pub clip_threshold: f32,
+
+    /// EMA smoothing factor for period tracking (0..1)
+    /// Lower = smoother, slower adaptation
+    /// Default: 0.01
+    pub ema_period_alpha: f32,
+
+    /// EMA smoothing factor for amplitude tracking (0..1)
+    /// Default: 0.01
+    pub ema_amp_alpha: f32,
+
+    /// Minimum inter-peak period in samples
+    /// Rejects peaks closer than this (filters high-frequency noise)
+    /// Default: sample_rate / 4000 (~4kHz upper F0)
+    pub min_period: u32,
+
+    /// Maximum inter-peak period in samples
+    /// Rejects peaks farther than this (filters very low frequencies)
+    /// Default: sample_rate / 60 (~60Hz lower F0)
+    pub max_period: u32,
+
+    /// Threshold below which jitter is considered "low" (stable)
+    /// Default: 0.02
+    pub jitter_low: f32,
+
+    /// Threshold above which jitter is considered "high" (unstable)
+    /// Default: 0.60
+    pub jitter_high: f32,
+}
+
+impl MarineConfig {
+    /// Create config optimized for speech at given sample rate
+    ///
+    /// # Arguments
+    /// * `sample_rate` - Audio sample rate in Hz (e.g., 22050, 44100)
+    ///
+    /// # Example
+    /// ```
+    /// use marine_salience::MarineConfig;
+    /// let config = MarineConfig::speech_default(22050);
+    /// assert!(config.min_period < config.max_period);
+    /// ```
+    pub const fn speech_default(sample_rate: u32) -> Self {
+        // F0 range: ~60Hz (low male) to ~4kHz (includes harmonics)
+        let min_period = sample_rate / 4000; // Upper bound
+        let max_period = sample_rate / 60;   // Lower bound
+
+        Self {
+            clip_threshold: 1e-3,
+            ema_period_alpha: 0.01,
+            ema_amp_alpha: 0.01,
+            min_period,
+            max_period,
+            jitter_low: 0.02,
+            jitter_high: 0.60,
+        }
+    }
+
+    /// Create config for high-sensitivity detection
+    /// More peaks detected, faster adaptation
+    pub const fn high_sensitivity(sample_rate: u32) -> Self {
+        let min_period = sample_rate / 8000;
+        let max_period = sample_rate / 40;
+
+        Self {
+            clip_threshold: 5e-4,
+            ema_period_alpha: 0.05,
+            ema_amp_alpha: 0.05,
+            min_period,
+            max_period,
+            jitter_low: 0.01,
+            jitter_high: 0.50,
+        }
+    }
+
+    /// Create config for TTS output validation
+    /// Tuned to detect synthetic artifacts
+    pub const fn tts_validation(sample_rate: u32) -> Self {
+        let min_period = sample_rate / 4000;
+        let max_period = sample_rate / 80;
+
+        Self {
+            clip_threshold: 1e-3,
+            ema_period_alpha: 0.02,
+            ema_amp_alpha: 0.02,
+            min_period,
+            max_period,
+            jitter_low: 0.015, // Stricter for synthetic speech
+            jitter_high: 0.40, // More sensitive to artifacts
+        }
+    }
+}
+
+impl Default for MarineConfig {
+    fn default() -> Self {
+        // Default to 22050 Hz (common TTS sample rate)
+        Self::speech_default(22050)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_speech_default_periods() {
+        let config = MarineConfig::speech_default(22050);
+        assert!(config.min_period < config.max_period);
+        assert_eq!(config.min_period, 22050 / 4000); // 5 samples
+        assert_eq!(config.max_period, 22050 / 60);   // 367 samples
+    }
+
+    #[test]
+    fn test_different_sample_rates() {
+        let config_22k = MarineConfig::speech_default(22050);
+        let config_44k = MarineConfig::speech_default(44100);
+        let config_48k = MarineConfig::speech_default(48000);
+
+        // Higher sample rates = more samples per period
+        assert!(config_44k.max_period > config_22k.max_period);
+        assert!(config_48k.max_period > config_44k.max_period);
+    }
+}

crates/marine_salience/src/ema.rs

@@ -0,0 +1,126 @@
+//! Exponential Moving Average (EMA) for smooth tracking
+//!
+//! EMA smooths noisy measurements while maintaining responsiveness.
+//! Used to track period and amplitude patterns in Marine algorithm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Exponential Moving Average tracker
+///
+/// EMA formula: value = alpha * new + (1 - alpha) * old
+/// - Higher alpha = faster response, more noise
+/// - Lower alpha = slower response, smoother
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+pub struct Ema {
+    /// Smoothing factor (0..1)
+    alpha: f32,
+    /// Current smoothed value
+    value: f32,
+    /// Whether we've received at least one sample
+    initialized: bool,
+}
+
+impl Ema {
+    /// Create new EMA with given smoothing factor
+    ///
+    /// # Arguments
+    /// * `alpha` - Smoothing factor (0..1). Higher = faster adaptation.
+    ///
+    /// # Example
+    /// ```
+    /// use marine_salience::ema::Ema;
+    /// let mut ema = Ema::new(0.1); // 10% new, 90% old
+    /// ema.update(100.0);
+    /// assert_eq!(ema.get(), 100.0); // First value becomes baseline
+    /// ema.update(200.0);
+    /// assert!((ema.get() - 110.0).abs() < 0.01); // 0.1*200 + 0.9*100
+    /// ```
+    pub const fn new(alpha: f32) -> Self {
+        Self {
+            alpha,
+            value: 0.0,
+            initialized: false,
+        }
+    }
+
+    /// Update EMA with new measurement
+    pub fn update(&mut self, x: f32) {
+        if !self.initialized {
+            // First value becomes the baseline
+            self.value = x;
+            self.initialized = true;
+        } else {
+            // EMA update: new = alpha * x + (1 - alpha) * old
+            self.value = self.alpha * x + (1.0 - self.alpha) * self.value;
+        }
+    }
+
+    /// Get current smoothed value
+    pub fn get(&self) -> f32 {
+        self.value
+    }
+
+    /// Check if EMA has been initialized (received at least one sample)
+    pub fn is_ready(&self) -> bool {
+        self.initialized
+    }
+
+    /// Reset EMA to uninitialized state
+    pub fn reset(&mut self) {
+        self.value = 0.0;
+        self.initialized = false;
+    }
+
+    /// Get the smoothing factor
+    pub fn alpha(&self) -> f32 {
+        self.alpha
+    }
+
+    /// Set a new smoothing factor
+    pub fn set_alpha(&mut self, alpha: f32) {
+        self.alpha = alpha.clamp(0.0, 1.0);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_first_value_becomes_baseline() {
+        let mut ema = Ema::new(0.1);
+        assert!(!ema.is_ready());
+        ema.update(42.0);
+        assert!(ema.is_ready());
+        assert_eq!(ema.get(), 42.0);
+    }
+
+    #[test]
+    fn test_ema_smoothing() {
+        let mut ema = Ema::new(0.1);
+        ema.update(100.0);
+        ema.update(200.0);
+        // 0.1 * 200 + 0.9 * 100 = 20 + 90 = 110
+        assert!((ema.get() - 110.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_high_alpha_fast_response() {
+        let mut ema = Ema::new(0.9);
+        ema.update(100.0);
+        ema.update(200.0);
+        // 0.9 * 200 + 0.1 * 100 = 180 + 10 = 190
+        assert!((ema.get() - 190.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_reset() {
+        let mut ema = Ema::new(0.1);
+        ema.update(100.0);
+        assert!(ema.is_ready());
+        ema.reset();
+        assert!(!ema.is_ready());
+        assert_eq!(ema.get(), 0.0);
+    }
+}

crates/marine_salience/src/lib.rs

@@ -0,0 +1,42 @@
+//! # Marine Salience - O(1) Jitter-Based Authenticity Detection
+//!
+//! "Marines are not just jarheads - they are actually very intelligent"
+//!
+//! This crate provides a universal salience primitive that can detect the
+//! "authenticity" of audio signals by measuring timing and amplitude jitter.
+//!
+//! ## Why "Marine"?
+//! - Marines are stable and reliable under pressure
+//! - Low jitter = authentic/stable signal
+//! - High jitter = damaged/synthetic signal
+//!
+//! ## Use Cases
+//! - **TTS Quality Validation** - Is synthesized speech authentic?
+//! - **Prosody Extraction** - Extract 8D interpretable emotion vectors
+//! - **Conversation Affect** - Track comfort level over sessions
+//! - **Real-time Monitoring** - O(1) per sample processing
+//!
+//! ## Core Insight
+//! Human voice has NATURAL jitter patterns. Perfect smoothness = synthetic.
+//! The Marine algorithm detects these patterns to distinguish authentic
+//! from damaged or artificial audio.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod config;
+pub mod ema;
+pub mod packet;
+pub mod processor;
+
+// Re-export main types
+pub use config::MarineConfig;
+pub use packet::SaliencePacket;
+pub use processor::MarineProcessor;
+
+/// Marine algorithm version
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Default jitter thresholds tuned for speech
+/// These values accommodate natural musical/speech variation
+pub const DEFAULT_JITTER_LOW: f32 = 0.02;  // Below = very stable
+pub const DEFAULT_JITTER_HIGH: f32 = 0.60; // Above = heavily damaged

crates/marine_salience/src/packet.rs

@@ -0,0 +1,122 @@
+//! Salience packet - the output of Marine analysis
+//!
+//! Contains jitter measurements and quality scores for a detected peak.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Salience packet emitted on peak detection
+///
+/// Contains all the jitter and quality metrics for a single audio event.
+/// These packets can be aggregated to form prosody vectors or quality scores.
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+pub struct SaliencePacket {
+    /// Period jitter - timing instability between peaks
+    /// Lower = more stable/musical, Higher = more chaotic
+    /// Range: 0.0+ (normalized difference from expected period)
+    pub j_p: f32,
+
+    /// Amplitude jitter - loudness instability
+    /// Lower = consistent volume, Higher = erratic dynamics
+    /// Range: 0.0+ (normalized difference from expected amplitude)
+    pub j_a: f32,
+
+    /// Harmonic alignment score
+    /// 1.0 = perfectly voiced/harmonic, 0.0 = noise
+    /// For now this is simplified; can be enhanced with FFT
+    pub h_score: f32,
+
+    /// Overall salience score (authenticity)
+    /// 1.0 = perfect quality, 0.0 = heavily damaged
+    /// Computed from inverse of combined jitter
+    pub s_score: f32,
+
+    /// Local peak energy (amplitude squared)
+    /// Represents loudness at this event
+    pub energy: f32,
+
+    /// Sample index where this peak occurred
+    /// Useful for temporal analysis
+    pub sample_index: u64,
+}
+
+impl SaliencePacket {
+    /// Create a new salience packet
+    pub fn new(
+        j_p: f32,
+        j_a: f32,
+        h_score: f32,
+        s_score: f32,
+        energy: f32,
+        sample_index: u64,
+    ) -> Self {
+        Self {
+            j_p,
+            j_a,
+            h_score,
+            s_score,
+            energy,
+            sample_index,
+        }
+    }
+
+    /// Get combined jitter metric
+    /// Average of period and amplitude jitter
+    pub fn combined_jitter(&self) -> f32 {
+        (self.j_p + self.j_a) / 2.0
+    }
+
+    /// Check if this represents high-quality audio
+    /// (low jitter, high salience)
+    pub fn is_high_quality(&self, threshold: f32) -> bool {
+        self.s_score >= threshold
+    }
+
+    /// Check if this indicates damaged/synthetic audio
+    pub fn is_damaged(&self, jitter_threshold: f32) -> bool {
+        self.combined_jitter() > jitter_threshold
+    }
+}
+
+/// Special salience markers for non-peak events
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+pub enum SalienceMarker {
+    /// Normal peak detected
+    Peak(SaliencePacket),
+    /// Fracture/gap detected (silence)
+    Fracture,
+    /// High noise floor detected
+    Noise,
+    /// Insufficient data for analysis
+    Insufficient,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_combined_jitter() {
+        let packet = SaliencePacket::new(0.1, 0.3, 1.0, 0.8, 0.5, 0);
+        assert!((packet.combined_jitter() - 0.2).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_is_high_quality() {
+        let good = SaliencePacket::new(0.01, 0.02, 1.0, 0.95, 0.5, 0);
+        let bad = SaliencePacket::new(0.5, 0.6, 0.5, 0.3, 0.5, 0);
+
+        assert!(good.is_high_quality(0.8));
+        assert!(!bad.is_high_quality(0.8));
+    }
+
+    #[test]
+    fn test_is_damaged() {
+        let good = SaliencePacket::new(0.01, 0.02, 1.0, 0.95, 0.5, 0);
+        let bad = SaliencePacket::new(0.5, 0.6, 0.5, 0.3, 0.5, 0);
+
+        assert!(!good.is_damaged(0.3));
+        assert!(bad.is_damaged(0.3));
+    }
+}

crates/marine_salience/src/processor.rs

@@ -0,0 +1,334 @@
+//! Core Marine processor - O(1) per-sample jitter detection
+//!
+//! The heart of the Marine algorithm. Processes audio samples one at a time,
+//! detecting peaks and computing jitter metrics in constant time.
+//!
+//! "Marines are not just jarheads - they are actually very intelligent"
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use crate::config::MarineConfig;
+use crate::ema::Ema;
+use crate::packet::{SalienceMarker, SaliencePacket};
+
+/// Marine salience processor
+///
+/// Processes audio samples one at a time, detecting peaks and computing
+/// jitter metrics. Designed for O(1) per-sample operation.
+///
+/// # Example
+/// ```
+/// use marine_salience::{MarineConfig, MarineProcessor};
+///
+/// let config = MarineConfig::speech_default(22050);
+/// let mut processor = MarineProcessor::new(config);
+///
+/// // Process samples (e.g., from audio buffer)
+/// let samples = vec![0.0, 0.5, 1.0, 0.5, 0.0, -0.5, -1.0, -0.5];
+/// for sample in &samples {
+///     if let Some(marker) = processor.process_sample(*sample) {
+///         match marker {
+///             marine_salience::packet::SalienceMarker::Peak(packet) => {
+///                 println!("Peak detected! Salience: {:.2}", packet.s_score);
+///             }
+///             _ => {}
+///         }
+///     }
+/// }
+/// ```
+pub struct MarineProcessor {
+    /// Configuration parameters
+    cfg: MarineConfig,
+
+    /// Previous sample (t-2)
+    prev2: f32,
+    /// Previous sample (t-1)
+    prev1: f32,
+    /// Current sample index
+    idx: u64,
+
+    /// Sample index of last detected peak
+    last_peak_idx: u64,
+    /// Amplitude of last detected peak
+    last_peak_amp: f32,
+
+    /// EMA tracker for inter-peak periods
+    ema_period: Ema,
+    /// EMA tracker for peak amplitudes
+    ema_amp: Ema,
+
+    /// Number of peaks detected so far
+    peak_count: u64,
+}
+
+impl MarineProcessor {
+    /// Create a new Marine processor with given configuration
+    pub fn new(cfg: MarineConfig) -> Self {
+        Self {
+            cfg,
+            prev2: 0.0,
+            prev1: 0.0,
+            idx: 0,
+            last_peak_idx: 0,
+            last_peak_amp: 0.0,
+            ema_period: Ema::new(cfg.ema_period_alpha),
+            ema_amp: Ema::new(cfg.ema_amp_alpha),
+            peak_count: 0,
+        }
+    }
+
+    /// Process a single audio sample - O(1) operation
+    ///
+    /// Returns Some(SalienceMarker) when a peak is detected or special
+    /// condition occurs, None otherwise.
+    ///
+    /// # Arguments
+    /// * `sample` - Audio sample value (typically -1.0 to 1.0)
+    ///
+    /// # Returns
+    /// - `Some(Peak(packet))` - Peak detected with jitter metrics
+    /// - `Some(Fracture)` - Silence/gap detected
+    /// - `Some(Noise)` - High noise floor detected
+    /// - `None` - No significant event at this sample
+    pub fn process_sample(&mut self, sample: f32) -> Option<SalienceMarker> {
+        let i = self.idx;
+        self.idx += 1;
+
+        // Pre-gating: ignore samples below threshold
+        if sample.abs() < self.cfg.clip_threshold {
+            self.prev2 = self.prev1;
+            self.prev1 = sample;
+            return None;
+        }
+
+        // Peak detection: prev1 is peak if prev2 < prev1 > sample
+        // Simple local maximum detection
+        let is_peak = i >= 2
+            && self.prev1.abs() >= self.cfg.clip_threshold
+            && self.prev1.abs() > self.prev2.abs()
+            && self.prev1.abs() > sample.abs();
+
+        let mut result = None;
+
+        if is_peak {
+            let peak_idx = i - 1;
+            let amp = self.prev1.abs();
+            let energy = amp * amp;
+
+            // Calculate period (time since last peak)
+            let period = if self.last_peak_idx == 0 {
+                0.0
+            } else {
+                (peak_idx - self.last_peak_idx) as f32
+            };
+
+            // Only process if period is within valid range
+            if period > self.cfg.min_period as f32 && period < self.cfg.max_period as f32 {
+                if self.ema_period.is_ready() {
+                    // Calculate jitter metrics
+                    let jp = (period - self.ema_period.get()).abs() / self.ema_period.get();
+                    let ja = (amp - self.ema_amp.get()).abs() / self.ema_amp.get();
+
+                    // Harmonic score (simplified - TODO: FFT-based detection)
+                    // For now, assume voiced content (h = 1.0)
+                    // In production, this would check for harmonic structure
+                    let h = 1.0;
+
+                    // Salience score: inverse of combined jitter
+                    // Higher jitter = lower salience
+                    let s = 1.0 / (1.0 + jp + ja);
+
+                    result = Some(SalienceMarker::Peak(SaliencePacket::new(
+                        jp, ja, h, s, energy, peak_idx,
+                    )));
+                }
+
+                // Update EMAs with new measurements
+                self.ema_period.update(period);
+                self.ema_amp.update(amp);
+            }
+
+            self.last_peak_idx = peak_idx;
+            self.last_peak_amp = amp;
+            self.peak_count += 1;
+        }
+
+        // Update sample history
+        self.prev2 = self.prev1;
+        self.prev1 = sample;
+
+        result
+    }
+
+    /// Process a buffer of samples, collecting all salience packets
+    ///
+    /// More efficient than calling process_sample repeatedly when you
+    /// have a full buffer available.
+    ///
+    /// # Arguments
+    /// * `samples` - Buffer of audio samples
+    ///
+    /// # Returns
+    /// Vector of salience packets for all detected peaks
+    #[cfg(feature = "std")]
+    pub fn process_buffer(&mut self, samples: &[f32]) -> Vec<SaliencePacket> {
+        let mut packets = Vec::new();
+
+        for &sample in samples {
+            if let Some(SalienceMarker::Peak(packet)) = self.process_sample(sample) {
+                packets.push(packet);
+            }
+        }
+
+        packets
+    }
+
+    /// Reset processor state (start fresh)
+    pub fn reset(&mut self) {
+        self.prev2 = 0.0;
+        self.prev1 = 0.0;
+        self.idx = 0;
+        self.last_peak_idx = 0;
+        self.last_peak_amp = 0.0;
+        self.ema_period.reset();
+        self.ema_amp.reset();
+        self.peak_count = 0;
+    }
+
+    /// Get number of peaks detected so far
+    pub fn peak_count(&self) -> u64 {
+        self.peak_count
+    }
+
+    /// Get current sample index
+    pub fn current_index(&self) -> u64 {
+        self.idx
+    }
+
+    /// Check if processor has enough data for reliable jitter
+    pub fn is_warmed_up(&self) -> bool {
+        self.peak_count >= 3 && self.ema_period.is_ready()
+    }
+
+    /// Get current expected period (from EMA)
+    pub fn expected_period(&self) -> Option<f32> {
+        if self.ema_period.is_ready() {
+            Some(self.ema_period.get())
+        } else {
+            None
+        }
+    }
+
+    /// Get current expected amplitude (from EMA)
+    pub fn expected_amplitude(&self) -> Option<f32> {
+        if self.ema_amp.is_ready() {
+            Some(self.ema_amp.get())
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_peak_detection() {
+        let config = MarineConfig::speech_default(22050);
+        let mut processor = MarineProcessor::new(config);
+
+        // Create simple signal with peaks
+        // Peak at sample 10, 20, 30...
+        let mut samples = vec![0.0; 100];
+        for i in (10..100).step_by(10) {
+            samples[i] = 0.5; // Peak
+            if i > 0 {
+                samples[i - 1] = 0.3; // Rising edge
+            }
+            if i < 99 {
+                samples[i + 1] = 0.3; // Falling edge
+            }
+        }
+
+        let mut peak_count = 0;
+        for sample in &samples {
+            if let Some(SalienceMarker::Peak(_)) = processor.process_sample(*sample) {
+                peak_count += 1;
+            }
+        }
+
+        // Should detect several peaks (not all due to period constraints)
+        assert!(peak_count > 0);
+    }
+
+    #[test]
+    fn test_jitter_calculation() {
+        let mut config = MarineConfig::speech_default(22050);
+        config.min_period = 5;
+        config.max_period = 20;
+        let mut processor = MarineProcessor::new(config);
+
+        // Create signal with consistent period of 10 samples
+        let mut detected_packets = vec![];
+        for cycle in 0..10 {
+            for i in 0..10 {
+                let sample = if i == 5 {
+                    0.8 // Peak in middle
+                } else if i == 4 || i == 6 {
+                    0.5 // Edges
+                } else {
+                    0.01 // Just above threshold
+                };
+
+                if let Some(SalienceMarker::Peak(packet)) = processor.process_sample(sample) {
+                    detected_packets.push(packet);
+                }
+            }
+        }
+
+        // With consistent periods, later packets should have low jitter
+        if detected_packets.len() > 3 {
+            let last = detected_packets.last().unwrap();
+            // Jitter should be relatively low for consistent signal
+            assert!(last.j_p < 0.5, "Period jitter too high: {}", last.j_p);
+        }
+    }
+
+    #[test]
+    fn test_reset() {
+        let config = MarineConfig::speech_default(22050);
+        let mut processor = MarineProcessor::new(config);
+
+        // Process some samples
+        for _ in 0..100 {
+            processor.process_sample(0.5);
+        }
+        assert!(processor.current_index() > 0);
+
+        // Reset and verify
+        processor.reset();
+        assert_eq!(processor.current_index(), 0);
+        assert_eq!(processor.peak_count(), 0);
+        assert!(!processor.is_warmed_up());
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn test_process_buffer() {
+        let mut config = MarineConfig::speech_default(22050);
+        config.min_period = 5;
+        config.max_period = 50;
+        let mut processor = MarineProcessor::new(config);
+
+        // Generate test signal with peaks
+        let mut samples = Vec::new();
+        for _ in 0..20 {
+            samples.extend_from_slice(&[0.01, 0.3, 0.8, 0.3, 0.01]);
+        }
+
+        let packets = processor.process_buffer(&samples);
+        // Should detect multiple peaks
+        assert!(packets.len() > 0);
+    }
+}

docs/Integrating Marine Algorithm into IndexTTS-Rust.md

@@ -0,0 +1,450 @@
+
+
+# **A Technical Report on the Integration of the Marine Salience Algorithm into the IndexTTS2-Rust Architecture**
+
+## **Executive Summary**
+
+This report details a comprehensive technical framework for the integration of the novel Marine Algorithm 1 into the existing IndexTTS-Rust project. The IndexTTS-Rust system is understood to be a Rust implementation of the IndexTTS2 architecture, a cascaded autoregressive (AR) Text-to-Speech (TTS) model detailed in the aaai2026.tex paper.1
+
+The primary objective of this integration is to leverage the unique, time-domain salience detection capabilities of the Marine Algorithm (e.g., jitter analysis) 1 to significantly improve the quality, controllability, and emotional expressiveness of the synthesized speech.
+
+The core of this strategy involves **replacing the Conformer-based emotion perceiver of the IndexTTS2 Text-to-Semantic (T2S) module** 1 with a new, lightweight, and prosodically-aware Rust module based on the Marine Algorithm. This report provides a full analysis of the architectural foundations, a detailed integration strategy, a complete Rust-level implementation guide, and an analysis of the training and inferential implications of this modification.
+
+## **Part 1: Architectural Foundations: The IndexTTS2 Pipeline and the Marine Salience Primitive**
+
+A successful integration requires a deep, functional understanding of the two systems being merged. This section deconstructs the IndexTTS2 architecture as the "host" system 1 and re-frames the Marine Algorithm 1 as the "implant" feature extractor.
+
+### **1.1 Deconstruction of the IndexTTS2 Generative Pipeline**
+
+The aaai2026.tex paper describes IndexTTS2 as a state-of-the-art, cascaded zero-shot TTS system.1 Its architecture is composed of three distinct, sequentially-trained modules:
+
+1. **Text-to-Semantic (T2S) Module:** This is an autoregressive (AR) Transformer-based model. Its primary function is to convert a sequence of text inputs into a sequence of "semantic tokens." This module is the system's "brain," determining the content, rhythm, and prosody of the speech.  
+2. **Semantic-to-Mel (S2M) Module:** This is a non-autoregressive (NAR) model. It takes the discrete semantic tokens from the T2S module and converts them into a dense mel-spectrogram. This module functions as the system's "vocal tract," rendering the semantic instructions into a spectral representation. The paper notes this module "incorporate\[s\] GPT latent representations to significantly improve the stability of the generated speech".1  
+3. **Vocoder Module:** This is a pre-trained BigVGANv2 vocoder.1 Its sole function is to perform the final conversion from the mel-spectrogram (from S2M) into a raw audio waveform.
+
+The critical component for this integration is the **T2S Conditioning Mechanism**. The IndexTTS2 T2S module's behavior is conditioned on two separate audio prompts, a design intended to achieve disentangled control 1:
+
+* **Timbre Prompt:** This audio prompt is processed by a "speaker perceiver conditioner" to generate a speaker attribute vector, c. This vector defines *who* is speaking (i.e., the vocal identity).  
+* **Style Prompt:** This *separate* audio prompt is processed by a "Conformer-based emotion perceiver conditioner" to generate an emotion vector, e. This vector defines *how* they are speaking (i.e., the emotion, prosody, and rhythm).
+
+The T2S Transformer then consumes these vectors, additively combined, as part of its input: \[c \+ e, p,..., E\_text,..., E\_sem\].1
+
+A key architectural detail is the IndexTTS2 paper's explicit use of a **Gradient Reversal Layer (GRL)** "to eliminate emotion-irrelevant information" and achieve "speaker-emotion disentanglement".1 The presence of a GRL, an adversarial training technique, strongly implies that the "Conformer-based emotion perceiver" is *not* naturally adept at this separation. A general-purpose Conformer, when processing the style prompt, will inevitably encode both prosodic features (pitch, energy) and speaker-specific features (formants, timbre). The GRL is thus employed as an adversarial "patch" to force the e vector to be "ignorant" of the speaker. This reveals a complex, computationally-heavy, and potentially fragile point in the IndexTTS2 design—a weakness that the Marine Algorithm is perfectly suited to address.
+
+### **1.2 The Marine Algorithm as a Superior Prosodic Feature Extractor**
+
+The marine-Universal-Salience-algoritm.tex paper 1 introduces the Marine Algorithm as a "universal, modality-agnostic salience detector" that operates in the time domain with O(1) per-sample complexity. While its described applications are broad, its specific mechanics make it an ideal, purpose-built *prosody quantifier* for speech.
+
+The algorithm's 5-step process (Pre-gating, Peak Detection, Jitter Computation, Harmonic Alignment, Salience Score) 1 is, in effect, a direct measurement of the suprasegmental features that define prosody:
+
+* **Period Jitter ($J\_p$):** Defined as $J\_p \= |T\_i \- \\text{EMA}(T)|$, this metric quantifies the instability of the time between successive peaks (the fundamental period).1 In speech, this is a direct, time-domain correlate for *pitch instability*. High, structured $J\_p$ (i.e., high jitter with a stable EMA) represents intentional prosodic features like vibrato, vocal fry, or creaky voice—all key carriers of emotion.  
+* **Amplitude Jitter ($J\_a$):** Defined as $J\_a \= |A\_i \- \\text{EMA}(A)|$, this metric quantifies the instability of peak amplitudes.1 In speech, this is a correlate for *amplitude shimmer* or "vocal roughness," which are strong cues for affective states such as arousal, stress, or anger.  
+* **Harmonic Alignment ($H$):** This check for integer-multiple relationships in peak spacing 1 directly measures the *purity* and *periodicity* of the tone. It quantifies the distinction between a clear, voiced, harmonic sound and a noisy, chaotic, or unvoiced signal (e.g., breathiness, whispering, or a scream).  
+* **Energy ($E$) and Peak Detection:** The algorithm's pre-gating ($\\theta\_c$) and peak detection steps inherently track the signal's energy and the *density* of glottal pulses, which correlate directly to loudness and fundamental frequency (pitch), respectively.
+
+The algorithm's description as "biologically plausible" and analogous to cochlear/amygdalar filtering 1 is not merely conceptual. It signifies that the algorithm is *a priori* biased to extract the same low-level features that the human auditory system uses to perceive emotion and prosody. This makes it a far more "correct" feature extractor for this task than a generic, large-scale Conformer, which learns from statistical correlation rather than first principles. Furthermore, its O(1) complexity 1 makes it orders of magnitude more efficient than the Transformer-based Conformer it will replace.
+
+## **Part 2: Integration Strategy: Replacing the T2S Emotion Perceiver**
+
+The integration path is now clear. The IndexTTS2 T2S module 1 requires a clean, disentangled prosody vector e. The original Conformer-based conditioner provides a "polluted" vector that must be "cleaned" by a GRL.1 The Marine Algorithm 1 is, by its very design, a *naturally disentangled* prosody extractor.
+
+### **2.1 Formal Proposal: The MarineProsodyConditioner**
+
+The formal integration strategy is as follows:
+
+1. The "Conformer-based emotion perceiver conditioner" 1 is **removed** from the IndexTTS2 architecture.  
+2. A new, from-scratch Rust module, tentatively named the MarineProsodyConditioner, is **created**.  
+3. This new module's sole function is to accept the file path to the style\_prompt audio, load its samples, and process them using a Rust implementation of the Marine Algorithm.1  
+4. It will aggregate the resulting time-series of salience data into a single, fixed-size feature vector, e', which will serve as the new "emotion vector."
+
+### **2.2 Feature Vector Engineering: Defining the New e'**
+
+The Marine Algorithm produces a *stream* of SaliencePackets, one for each detected peak.1 The T2S Transformer, however, requires a *single, fixed-size* conditioning vector.1 We must therefore define an aggregation strategy to distill this time-series into a descriptive statistical summary.
+
+The proposed feature vector, the MarineProsodyVector (our new e'), will be an 8-dimensional vector composed of the mean and standard deviation of the algorithm's key outputs over the entire duration of the style prompt.
+
+**Table 1: MarineProsodyVector Struct Definition**
+
+This table defines the precise "interface" between the marine\_salience crate and the indextts\_rust crate.
+
+| Field | Type | Description | Source |
+| :---- | :---- | :---- | :---- |
+| jp\_mean | f32 | Mean Period Jitter ($J\_p$). Correlates to average pitch instability. | 1 |
+| jp\_std | f32 | Std. Dev. of $J\_p$. Correlates to *variance* in pitch instability. | 1 |
+| ja\_mean | f32 | Mean Amplitude Jitter ($J\_a$). Correlates to average vocal roughness. | 1 |
+| ja\_std | f32 | Std. Dev. of $J\_a$. Correlates to *variance* in vocal roughness. | 1 |
+| h\_mean | f32 | Mean Harmonic Alignment ($H$). Correlates to average tonal purity. | 1 |
+| s\_mean | f32 | Mean Salience Score ($S$). Correlates to overall signal "structuredness". | 1 |
+| peak\_density | f32 | Number of detected peaks per second. Correlates to fundamental frequency (F0/pitch). | 1 |
+| energy\_mean | f32 | Mean energy ($E$) of detected peaks. Correlates to loudness/amplitude. | 1 |
+
+This small, 8-dimensional vector is dense, interpretable, and packed with prosodic information, in stark contrast to the opaque, high-dimensional, and entangled vector produced by the original Conformer.1
+
+### **2.3 Theoretical Justification: The Synergistic Disentanglement**
+
+This integration provides a profound architectural improvement by solving the speaker-style disentanglement problem more elegantly and efficiently than the original IndexTTS2 design.1
+
+The central challenge in the original architecture is that the Conformer-based conditioner processes the *entire* signal, capturing both temporal features (pitch, which is prosody) and spectral features (formants, which define speaker identity). This "entanglement" necessitates the use of the adversarial GRL to "un-learn" the speaker information.1
+
+The Marine Algorithm 1 fundamentally sidesteps this problem. Its design is based on **peak detection, spacing, and amplitude**.1 It is almost entirely *blind* to the complex spectral-envelope (formant) information that defines a speaker's unique timbre. It measures the *instability* of the fundamental frequency, not the F0 itself, and the *instability* of the amplitude, not the spectral shape.
+
+Therefore, the MarineProsodyVector (e') is **naturally disentangled**. It is a *pure* representation of prosody, containing negligible speaker-identity information.
+
+When this new e' vector is fed into the T2S model's input, \[c \+ e',...\], the system receives two *orthogonal* conditioning vectors:
+
+1. c (from the speaker perceiver 1): Contains the speaker's timbre (formants, etc.).  
+2. e' (from the MarineProsodyConditioner 1): Contains the speaker's prosody (jitter, rhythm, etc.).
+
+This clean separation provides two major benefits:
+
+1. **Superior Timbre Cloning:** The speaker vector c no longer has to "compete" with an "entangled" style vector e. The T2S model will receive a cleaner speaker signal, leading to more accurate zero-shot voice cloning.  
+2. **Superior Emotional Expression:** The style vector e' is a clean, simple, and interpretable signal. The T2S Transformer will be able to learn the mapping from (e.g.) jp\_mean \= 0.8 to "generate creaky semantic tokens" much more easily than from an opaque 512-dimensional Conformer embedding.
+
+This change simplifies the T2S model's learning task, which should lead to faster convergence and higher final quality. The GRL 1 may become entirely unnecessary, further simplifying the training regime and stabilizing the model.
+
+## **Part 3: Implementation Guide: A IndexTTS-Rust Integration**
+
+This section provides a concrete, code-level guide for implementing the proposed integration.
+
+### **3.1 Addressing the README.md Data Gap**
+
+A critical limitation in preparing this analysis is the repeated failure to access the user-provided IndexTTS-Rust README.md file.2 This file contains the project's specific file structure, API definitions, and module layout.
+
+To overcome this, this report will posit a **hypothetical yet idiomatic Rust project structure** based on the logical components described in the IndexTTS2 paper.1 All subsequent code examples will adhere to this structure. The project owner is expected to map these file paths and function names to their actual, private codebase.
+
+### **3.2 Table 2: Hypothetical IndexTTS-Rust Project Structure**
+
+The following workspace structure is assumed for all implementation examples.
+
+Plaintext
+
+indextts\_rust\_workspace/  
+├── Cargo.toml                (Workspace root)  
+│  
+├── indextts\_rust/            (The main application/library crate)  
+│   ├── Cargo.toml  
+│   └── src/  
+│       ├── main.rs           (Binary entry point)  
+│       ├── lib.rs            (Library entry point & API)  
+│       ├── error.rs          (Project-wide error types)  
+│       ├── audio.rs          (Audio I/O: e.g., fn load\_wav\_samples)  
+│       ├── vocoder.rs        (Wrapper for BigVGANv2 model)  
+│       ├── t2s/  
+│       │   ├── mod.rs        (T2S module definition)  
+│       │   ├── model.rs      (AR Transformer implementation)  
+│       │   └── conditioner.rs(Handles 'c' and 'e' vector generation)  
+│       └── s2m/  
+│           ├── mod.rs        (S2M module definition)  
+│           └── model.rs      (NAR model implementation)  
+│  
+└── marine\_salience/          (The NEW crate for the Marine Algorithm)  
+    ├── Cargo.toml  
+    └── src/  
+        ├── lib.rs            (Public API: MarineProcessor, etc.)  
+        ├── config.rs         (MarineConfig struct)  
+        ├── processor.rs      (MarineProcessor struct and logic)  
+        ├── ema.rs            (EmaTracker helper struct)  
+        └── packet.rs         (SaliencePacket struct)
+
+### **3.3 Crate Development: marine\_salience**
+
+A new, standalone Rust crate, marine\_salience, should be created. This crate will encapsulate all logic for the Marine Algorithm 1, ensuring it is modular, testable, and reusable.
+
+**Table 3: marine\_salience Crate \- Public API Definition**
+
+| Struct / fn | Field / Signature | Type | Description |
+| :---- | :---- | :---- | :---- |
+| MarineConfig | clip\_threshold | f32 | $\\theta\_c$, pre-gating sensitivity.1 |
+|  | ema\_period\_alpha | f32 | Smoothing factor for Period EMA. |
+|  | ema\_amplitude\_alpha | f32 | Smoothing factor for Amplitude EMA. |
+| SaliencePacket | j\_p | f32 | Period Jitter ($J\_p$).1 |
+|  | j\_a | f32 | Amplitude Jitter ($J\_a$).1 |
+|  | h\_score | f32 | Harmonic Alignment score ($H$).1 |
+|  | s\_score | f32 | Final Salience Score ($S$).1 |
+|  | energy | f32 | Peak energy ($E$).1 |
+| MarineProcessor | new(config: MarineConfig) | Self | Constructor. |
+|  | process\_sample(\&mut self, sample: f32, sample\_idx: u64) | Option\<SaliencePacket\> | The O(1) processing function. |
+
+**marine\_salience/src/processor.rs (Implementation Sketch):**
+
+The MarineProcessor struct will hold the state, including EmaTracker instances for period and amplitude, the last\_peak\_sample index, last\_peak\_amplitude, and the current\_direction of the signal (e.g., \+1 for rising, \-1 for falling).
+
+The process\_sample function is the O(1) core, implementing the algorithm from 1:
+
+1. **Pre-gating:** Check if sample.abs() \> config.clip\_threshold.  
+2. **Peak Detection:** Track the signal's direction. A change from \+1 (rising) to \-1 (falling) signifies a peak at sample\_idx \- 1, as per the formula x(n-1) \< x(n) \> x(n+1).1  
+3. **Jitter Computation:** If a peak is detected at n:  
+   * Calculate current period $T\_i \= (n \- self.last\_peak\_sample)$.  
+   * Calculate current amplitude $A\_i \= sample\_at(n)$.  
+   * Calculate $J\_p \= |T\_i \- self.ema\_period.value()|$.1  
+   * Calculate $J\_a \= |A\_i \- self.ema\_amplitude.value()|$.1  
+   * Update the EMAs: self.ema\_period.update(T\_i), self.ema\_amplitude.update(A\_i).  
+4. **Harmonic Alignment:** Perform the check for $H$.1  
+5. **Salience Score:** Compute $S \= w\_e E \+ w\_j(1/J) \+ w\_h H$.1  
+6. Update self.last\_peak\_sample \= n, self.last\_peak\_amplitude \= A\_i.  
+7. Return Some(SaliencePacket {... }).  
+8. If no peak is detected, return None.
+
+### **3.4 Modifying the indextts\_rust Crate**
+
+With the marine\_salience crate complete, the indextts\_rust crate can now be modified.
+
+indextts\_rust/Cargo.toml:  
+Add the new crate as a dependency:
+
+Ini, TOML
+
+\[dependencies\]  
+marine\_salience \= { path \= "../marine\_salience" }  
+\#... other dependencies (tch, burn, ndarray, etc.)
+
+indextts\_rust/src/t2s/conditioner.rs:  
+This is the central modification. The file responsible for generating the e vector is completely refactored.
+
+Rust
+
+// BEFORE: Original Conformer-based   
+//  
+// use tch::Tensor;  
+// use crate::audio::AudioData;  
+//  
+// // This struct holds the large, complex Conformer model  
+// pub struct ConformerEmotionPerceiver {  
+//     //... model weights...  
+// }  
+//  
+// impl ConformerEmotionPerceiver {  
+//     pub fn get\_style\_embedding(\&self, audio: \&AudioData) \-\> Result\<Tensor, ModelError\> {  
+//         // 1\. Convert AudioData to mel-spectrogram tensor  
+//         // 2\. Pass spectrogram through Conformer layers  
+//         // 3\. (GRL logic is applied during training)  
+//         // 4\. Return an opaque, high-dimensional 'e' vector  
+//         //    (e.g., )  
+//     }  
+// }
+
+// AFTER: New MarineProsodyConditioner  
+//  
+use marine\_salience::processor::{MarineProcessor, SaliencePacket};  
+use marine\_salience::config::MarineConfig;  
+use crate::audio::load\_wav\_samples; // From hypothetical audio.rs  
+use std::path::Path;  
+use anyhow::Result;
+
+// This is the struct defined in Table 1  
+\#  
+pub struct MarineProsodyVector {  
+    pub jp\_mean: f32,  
+    pub jp\_std: f32,  
+    pub ja\_mean: f32,  
+    pub ja\_std: f32,  
+    pub h\_mean: f32,  
+    pub s\_mean: f32,  
+    pub peak\_density: f32,  
+    pub energy\_mean: f32,  
+}
+
+// This new struct and function replace the Conformer  
+pub struct MarineProsodyConditioner {  
+    config: MarineConfig,  
+}
+
+impl MarineProsodyConditioner {  
+    pub fn new(config: MarineConfig) \-\> Self {  
+        Self { config }  
+    }
+
+    pub fn get\_marine\_style\_vector(&self, style\_prompt\_path: \&Path, sample\_rate: f32) \-\> Result\<MarineProsodyVector\> {  
+        // 1\. Load audio samples  
+        // Assumes audio.rs provides this function  
+        let samples \= load\_wav\_samples(style\_prompt\_path)?;   
+        let duration\_sec \= samples.len() as f32 / sample\_rate;
+
+        // 2\. Instantiate and run the MarineProcessor  
+        let mut processor \= MarineProcessor::new(self.config.clone());  
+        let mut packets \= Vec::\<SaliencePacket\>::new();
+
+        for (i, sample) in samples.iter().enumerate() {  
+            if let Some(packet) \= processor.process\_sample(\*sample, i as u64) {  
+                packets.push(packet);  
+            }  
+        }
+
+        if packets.is\_empty() {  
+            return Err(anyhow::anyhow\!("No peaks detected in style prompt."));  
+        }
+
+        // 3\. Aggregate packets into the final feature vector  
+        let num\_packets \= packets.len() as f32;  
+          
+        let mut jp\_mean \= 0.0;  
+        let mut ja\_mean \= 0.0;  
+        let mut h\_mean \= 0.0;  
+        let mut s\_mean \= 0.0;  
+        let mut energy\_mean \= 0.0;  
+          
+        for p in \&packets {  
+            jp\_mean \+= p.j\_p;  
+            ja\_mean \+= p.j\_a;  
+            h\_mean \+= p.h\_score;  
+            s\_mean \+= p.s\_score;  
+            energy\_mean \+= p.energy;  
+        }  
+          
+        jp\_mean /= num\_packets;  
+        ja\_mean /= num\_packets;  
+        h\_mean /= num\_packets;  
+        s\_mean /= num\_packets;  
+        energy\_mean /= num\_packets;
+
+        // Calculate standard deviation (variance)  
+        let mut jp\_std \= 0.0;  
+        let mut ja\_std \= 0.0;  
+        for p in \&packets {  
+            jp\_std \+= (p.j\_p \- jp\_mean).powi(2);  
+            ja\_std \+= (p.j\_a \- ja\_mean).powi(2);  
+        }  
+        jp\_std \= (jp\_std / num\_packets).sqrt();  
+        ja\_std \= (ja\_std / num\_packets).sqrt();  
+          
+        let peak\_density \= num\_packets / duration\_sec;
+
+        Ok(MarineProsodyVector {  
+            jp\_mean,  
+            jp\_std,  
+            ja\_mean,  
+            ja\_std,  
+            h\_mean,  
+            s\_mean,  
+            peak\_density,  
+            energy\_mean,  
+        })  
+    }  
+}
+
+### **3.5 Updating the T2S Model (indextts\_rust/src/t2s/model.rs)**
+
+This change is **breaking** and **mandatory**. The IndexTTS2 T2S model 1 was trained on a high-dimensional e vector (e.g., 512-dim). Our new e' vector is 8-dimensional. The T2S model's architecture must be modified to accept this.
+
+The change will be in the T2S Transformer's input embedding layer, which projects the conditioning vectors into the model's main hidden dimension (e.g., 1024-dim).
+
+**(Example using tch-rs or burn pseudo-code):**
+
+Rust
+
+// In src/t2s/model.rs  
+//  
+// pub struct T2S\_Transformer {  
+//   ...  
+//    speaker\_projector: nn::Linear,  
+//    style\_projector: nn::Linear, // The layer to change  
+//   ...  
+// }  
+//  
+// impl T2S\_Transformer {  
+//    pub fn new(config: \&T2S\_Config, vs: \&nn::Path) \-\> Self {  
+//      ...  
+//       // BEFORE:  
+//       // let style\_projector \= nn::linear(  
+//       //     vs / "style\_projector",  
+//       //     512, // Original Conformer 'e' dimension   
+//       //     config.hidden\_dim,  
+//       //     Default::default()  
+//       // );  
+//  
+//       // AFTER:  
+//       let style\_projector \= nn::linear(  
+//           vs / "style\_projector",  
+//           8,   // New MarineProsodyVector 'e'' dimension  
+//           config.hidden\_dim,  
+//           Default::default()  
+//       );  
+//      ...  
+//    }  
+// }
+
+This change creates a new, untrained model. The S2M and Vocoder modules 1 can remain unchanged, but the T2S module must now be retrained.
+
+## **Part 4: Training, Inference, and Qualitative Implications**
+
+This architectural change has profound, positive implications for the entire system, from training to user-facing control.
+
+### **4.1 Retraining the T2S Module**
+
+The modification in Part 3.5 is a hard-fork of the model architecture; retraining the T2S module 1 is not optional.
+
+**Training Plan:**
+
+1. **Model:** The S2M and Vocoder modules 1 can be completely frozen. Only the T2S module with the new 8-dimensional style\_projector (from 3.5) needs to be trained.  
+2. **Dataset Preprocessing:** The *entire* training dataset used for the original IndexTTS2 1 must be re-processed.  
+   * For *every* audio file in the dataset, the MarineProsodyConditioner::get\_marine\_style\_vector function (from 3.4) must be run *once*.  
+   * The resulting 8-dimensional MarineProsodyVector must be saved as the new "ground truth" style label for that utterance.  
+3. **Training:** The T2S module is now trained as described in the aaai2026.tex paper.1 During the training step, it will load the pre-computed MarineProsodyVector as the e' vector, which will be added to the c (speaker) vector and fed into the Transformer.  
+4. **Hypothesis:** This training run is expected to converge *faster* and to a *higher* qualitative ceiling. The model is no longer burdened by the complex, adversarial GRL-based disentanglement.1 It is instead learning a much simpler, more direct correlation between a clean prosody vector (e') and the target semantic token sequences.
+
+### **4.2 Inference-Time Control**
+
+This integration unlocks a new, powerful mode of "synthetic" or "direct" prosody control, fulfilling the proposals implicit in the user's query.
+
+* **Mode 1: Reference-Based (Standard):**  
+  * A user provides a style\_prompt.wav.  
+  * The get\_marine\_style\_vector function (from 3.4) is called.  
+  * The resulting MarineProsodyVector e' is fed into the T2S model.  
+  * This "copies" the prosody from the reference audio, just as the original IndexTTS2 1 intended, but with higher fidelity.  
+* **Mode 2: Synthetic-Control (New):**  
+  * The user provides *no* style prompt.  
+  * Instead, the user *directly constructs* the 8-dimensional MarineProsodyVector to achieve a desired effect. The application's UI could expose 8 sliders for these values.  
+  * **Example 1: "Agitated / Rough Voice"**  
+    * e' \= MarineProsodyVector { jp\_mean: 0.8, jp\_std: 0.5, ja\_mean: 0.7, ja\_std: 0.4,... }  
+  * **Example 2: "Stable / Monotone Voice"**  
+    * e' \= MarineProsodyVector { jp\_mean: 0.05, jp\_std: 0.01, ja\_mean: 0.05, ja\_std: 0.01,... }  
+  * **Example 3: "High-Pitch / High-Energy Voice"**  
+    * e' \= MarineProsodyVector { peak\_density: 300.0, energy\_mean: 0.9,... }
+
+This provides a small, interpretable, and powerful "control panel" for prosody, a significant breakthrough in controllable TTS that was not possible with the original opaque Conformer embedding.1
+
+### **4.3 Bridging to Downstream Fidelity (S2M)**
+
+The benefits of this integration propagate through the entire cascade. The S2M module's quality is directly dependent on the quality of the semantic tokens it receives from T2S.1
+
+The aaai2026.tex paper 1 states the S2M module uses "GPT latent representations to significantly improve the stability of the generated speech." This suggests the S2M is a powerful and stable *renderer*. However, a renderer is only as good as the instructions it receives.
+
+In the original system, the S2M module likely received semantic tokens with "muddled" or "averaged-out" prosody, resulting from the T2S model's struggle with the entangled e vector. The S2M's "stability" 1 may have come at the *cost* of expressiveness, as it learned to smooth over inconsistent prosodic instructions.
+
+With the new MarineProsodyConditioner, the T2S model will now produce semantic tokens that are *far more richly, explicitly, and accurately* encoded with prosodic intent. The S2M module's "GPT latents" 1 will receive a higher-fidelity, more consistent input signal. This creates a synergistic effect: the S2M's stable rendering capabilities 1 will now be applied to a *more expressive* set of instructions. The result is an end-to-end system that is *both* stable *and* highly expressive.
+
+## **Part 5: Report Conclusions and Future Trajectories**
+
+### **5.1 Summary of Improvements**
+
+The integration framework detailed in this report achieves the project's goals by:
+
+1. **Replacing** a computationally heavy, black-box Conformer 1 with a lightweight, O(1), biologically-plausible, and Rust-native MarineProcessor.1  
+2. **Solving** a core architectural-art problem in the IndexTTS2 design by providing a *naturally disentangled*, speaker-invariant prosody vector, which simplifies or obviates the need for the adversarial GRL.1  
+3. **Unlocking** a powerful "synthetic control" mode, allowing users to *directly* manipulate prosody at inference time via an 8-dimensional, interpretable control vector.  
+4. **Improving** end-to-end system quality by providing a cleaner, more explicit prosodic signal to the T2S module 1, which in turn provides a higher-fidelity semantic token stream to the S2M module.1
+
+### **5.2 Future Trajectories**
+
+This new architecture opens two significant avenues for future research.
+
+1\. True Streaming Synthesis with Dynamic Conditioning  
+The IndexTTS2 T2S module is autoregressive 1, and the Marine Algorithm is O(1) per-sample.1 This is a perfect combination for real-time applications.  
+A future version could implement a "Dynamic Conditioning" mode. In this mode, a MarineProcessor runs on a live microphone input (e.g., from the user) in a parallel thread. It continuously calculates the MarineProsodyVector over a short, sliding window (e.g., 500ms). This e' vector is then *hot-swapped* into the T2S model's conditioning state *during* the autoregressive generation loop. The result would be a TTS model that mirrors the user's emotional prosody in real-time.
+
+2\. Active Quality Monitoring (Vocoder Feedback Loop)  
+The Marine Algorithm is a "universal... salience detector" that distinguishes "structured signals from noise".1 This capability can be used as a quality metric for the vocoder's output.  
+An advanced implementation could create a feedback loop:
+
+1. The BigVGANv2 vocoder 1 produces its output audio.  
+2. This audio is *immediately* fed *back* into a MarineProcessor.  
+3. The processor analyzes the output. The key insight from the Marine paper 1 is the use of the **Exponential Moving Average (EMA)**.  
+   * **Desired Prosody (e.g., vocal fry):** Will produce high $J\_p$/$J\_a$, but the $\\text{EMA}(T)$ and $\\text{EMA}(A)$ will remain *stable*. The algorithm will correctly identify this as a *structured* signal.  
+   * **Undesired Artifact (e.g., vocoder hiss, phase noise):** Will produce high $J\_p$/$J\_a$, but the $\\text{EMA}(T)$ and $\\text{EMA}(A)$ will become *unstable*. The algorithm will correctly identify this as *unstructured noise*.
+
+This creates a quantitative, real-time metric for "output fidelity" that can distinguish desirable prosody from undesirable artifacts. This metric could be used to automatically flag or discard bad generations, or even as a reward function for a Reinforcement Learning (RL) agent tasked with fine-tuning the S2M or Vocoder modules.
+
+#### **Works cited**
+
+1. marine-Universal-Salience-algoritm.tex  
+2. accessed December 31, 1969, uploaded:IndexTTS-Rust README.md

examples/analyze_chris.rs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00940abda6dd597d7dacdbb97761fb0635d0dcc7dc30d5391fe159129008b03a
+size 8470

examples/marine_test.rs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d179d8f3adc5338e94ee2b92f366a36d03c32b51767223d1eefeb42ce9165374
+size 10845

requirements.txt

@@ -1,32 +0,0 @@
-accelerate==1.8.1
-descript-audiotools==0.7.2
-transformers==4.52.1
-tokenizers==0.21.0
-cn2an==0.5.22
-ffmpeg-python==0.2.0
-Cython==3.0.7
-g2p-en==2.1.0
-jieba==0.42.1
-json5==0.10.0
-keras==2.9.0
-numba==0.58.1
-numpy==1.26.2
-pandas==2.1.3
-matplotlib==3.8.2
-munch==4.0.0
-opencv-python==4.9.0.80
-tensorboard==2.9.1
-librosa==0.10.2.post1
-safetensors==0.5.2
-deepspeed==0.17.1
-modelscope==1.27.0
-omegaconf
-sentencepiece
-gradio
-tqdm
-textstat
-huggingface_hub
-spaces
-
-WeTextProcessing; platform_machine != "Darwin"
-wetext; platform_system == "Darwin"

src/audio/mod.rs

@@ -4,7 +4,7 @@
 
 mod dsp;
 mod io;
-mod mel;
+pub mod mel;
 mod resample;
 
 pub use dsp::{apply_preemphasis, dynamic_range_compression, dynamic_range_decompression, normalize_audio, normalize_audio_peak, apply_fade};

src/audio/resample.rs

@@ -31,7 +31,7 @@ pub fn resample(audio: &AudioData, target_sr: u32) -> Result<AudioData> {
     let mut input_buffer = vec![vec![0.0f32; input_frames_needed]];
     let mut output_samples = Vec::new();
 
-    let mut pos = 0;
+    let mut pos = 0;    
     while pos < audio.samples.len() {
         // Fill input buffer
         let end = (pos + input_frames_needed).min(audio.samples.len());

src/lib.rs

@@ -27,6 +27,7 @@ pub mod config;
 pub mod error;
 pub mod model;
 pub mod pipeline;
+pub mod quality;
 pub mod text;
 pub mod vocoder;
 
@@ -34,6 +35,11 @@ pub use config::Config;
 pub use error::{Error, Result};
 pub use pipeline::IndexTTS;
 
+// Re-export Marine quality validation
+pub use quality::{
+    ComfortLevel, ConversationAffectSummary, MarineProsodyConditioner, MarineProsodyVector,
+};
+
 /// Library version
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 

src/quality/affect.rs

@@ -0,0 +1,445 @@
+//! Conversation Affect Tracking - Session-level comfort analysis
+//!
+//! After a conversation, Aye can determine: "This felt uneasy / ok / happy"
+//! based on Marine prosody patterns over time.
+//!
+//! The key insight: jitter patterns reveal emotional state
+//! - Rising jitter over conversation = increasing tension
+//! - Stable low jitter = calm exchange
+//! - High energy + low jitter = positive/confident
+
+use super::prosody::MarineProsodyVector;
+
+/// Comfort level classification
+///
+/// After a conversation, this represents the overall emotional tone.
+/// Used by Aye to self-assess: "How did I make you feel?"
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ComfortLevel {
+    /// High jitter AND rising over session - tension/nervousness
+    Uneasy,
+    /// Stable but low energy, or mildly jittery but not escalating
+    Neutral,
+    /// Good energy, low/stable jitter - positive interaction
+    Happy,
+}
+
+impl ComfortLevel {
+    /// Convert to emoji representation
+    pub fn emoji(&self) -> &'static str {
+        match self {
+            ComfortLevel::Uneasy => "😟",
+            ComfortLevel::Neutral => "😐",
+            ComfortLevel::Happy => "😊",
+        }
+    }
+
+    /// Convert to descriptive string
+    pub fn description(&self) -> &'static str {
+        match self {
+            ComfortLevel::Uneasy => "uneasy or tense",
+            ComfortLevel::Neutral => "neutral or stable",
+            ComfortLevel::Happy => "comfortable and positive",
+        }
+    }
+
+    /// Convert to numeric score (-1 = uneasy, 0 = neutral, 1 = happy)
+    pub fn score(&self) -> i8 {
+        match self {
+            ComfortLevel::Uneasy => -1,
+            ComfortLevel::Neutral => 0,
+            ComfortLevel::Happy => 1,
+        }
+    }
+}
+
+/// Conversation affect summary
+///
+/// Aggregates Marine prosody data over an entire conversation to
+/// provide session-level emotional assessment.
+#[derive(Debug, Clone)]
+pub struct ConversationAffectSummary {
+    /// Comfort level of the human speaker (if analyzed)
+    pub human_state: Option<ComfortLevel>,
+    /// Comfort level of Aye's output
+    pub aye_state: ComfortLevel,
+    /// Overall audio/structure quality (0..1)
+    pub quality_score: f32,
+    /// Number of utterances analyzed
+    pub utterance_count: usize,
+    /// Session duration in seconds
+    pub duration_seconds: f32,
+    /// Mean prosody statistics
+    pub mean_prosody: MarineProsodyVector,
+    /// Jitter trend (positive = rising, negative = falling)
+    pub jitter_trend: f32,
+    /// Energy trend (positive = rising, negative = falling)
+    pub energy_trend: f32,
+}
+
+impl ConversationAffectSummary {
+    /// Generate Aye's self-assessment message
+    pub fn aye_assessment(&self) -> String {
+        let emoji = self.aye_state.emoji();
+        let desc = self.aye_state.description();
+
+        let quality_desc = if self.quality_score > 0.8 {
+            "very good"
+        } else if self.quality_score > 0.6 {
+            "good"
+        } else if self.quality_score > 0.4 {
+            "moderate"
+        } else {
+            "low"
+        };
+
+        format!(
+            "{} Aye thinks this conversation felt {}. Audio quality was {} ({:.0}%). \
+             {} {} utterances over {:.1} seconds.",
+            emoji,
+            desc,
+            quality_desc,
+            self.quality_score * 100.0,
+            if self.jitter_trend > 0.05 {
+                "Tension seemed to increase."
+            } else if self.jitter_trend < -0.05 {
+                "Tension seemed to decrease."
+            } else {
+                "Emotional tone stayed consistent."
+            },
+            self.utterance_count,
+            self.duration_seconds
+        )
+    }
+
+    /// Generate prompt for asking human for feedback
+    pub fn feedback_prompt(&self) -> String {
+        format!(
+            "Aye would like to improve. How did this conversation make you feel?\n\
+             A) Uneasy or tense 😟\n\
+             B) Neutral or okay 😐\n\
+             C) Comfortable and positive 😊\n\n\
+             Aye's self-assessment: {} ({})",
+            self.aye_state.emoji(),
+            self.aye_state.description()
+        )
+    }
+}
+
+/// Conversation affect analyzer
+///
+/// Collects prosody vectors over a conversation and computes
+/// session-level emotional state.
+pub struct ConversationAffectAnalyzer {
+    /// Collected prosody vectors
+    utterances: Vec<MarineProsodyVector>,
+    /// Total audio duration
+    total_duration_seconds: f32,
+    /// Configuration thresholds
+    config: AffectAnalyzerConfig,
+}
+
+/// Configuration for affect classification
+#[derive(Debug, Clone, Copy)]
+pub struct AffectAnalyzerConfig {
+    /// Threshold for "high" combined jitter
+    pub high_jitter_threshold: f32,
+    /// Threshold for "rising" jitter trend
+    pub rising_jitter_threshold: f32,
+    /// Threshold for "high" energy (happy indicator)
+    pub high_energy_threshold: f32,
+}
+
+impl Default for AffectAnalyzerConfig {
+    fn default() -> Self {
+        Self {
+            high_jitter_threshold: 0.4,
+            rising_jitter_threshold: 0.1,
+            high_energy_threshold: 0.5,
+        }
+    }
+}
+
+impl ConversationAffectAnalyzer {
+    /// Create new analyzer with default config
+    pub fn new() -> Self {
+        Self {
+            utterances: Vec::new(),
+            total_duration_seconds: 0.0,
+            config: AffectAnalyzerConfig::default(),
+        }
+    }
+
+    /// Create with custom configuration
+    pub fn with_config(config: AffectAnalyzerConfig) -> Self {
+        Self {
+            utterances: Vec::new(),
+            total_duration_seconds: 0.0,
+            config,
+        }
+    }
+
+    /// Add an utterance's prosody to the conversation
+    pub fn add_utterance(&mut self, prosody: MarineProsodyVector, duration_seconds: f32) {
+        self.utterances.push(prosody);
+        self.total_duration_seconds += duration_seconds;
+    }
+
+    /// Reset analyzer for new conversation
+    pub fn reset(&mut self) {
+        self.utterances.clear();
+        self.total_duration_seconds = 0.0;
+    }
+
+    /// Analyze conversation and produce affect summary
+    pub fn analyze(&self) -> Option<ConversationAffectSummary> {
+        if self.utterances.is_empty() {
+            return None;
+        }
+
+        let n = self.utterances.len() as f32;
+
+        // Calculate mean prosody
+        let mut mean_prosody = MarineProsodyVector::zeros();
+        for p in &self.utterances {
+            mean_prosody.jp_mean += p.jp_mean;
+            mean_prosody.jp_std += p.jp_std;
+            mean_prosody.ja_mean += p.ja_mean;
+            mean_prosody.ja_std += p.ja_std;
+            mean_prosody.h_mean += p.h_mean;
+            mean_prosody.s_mean += p.s_mean;
+            mean_prosody.peak_density += p.peak_density;
+            mean_prosody.energy_mean += p.energy_mean;
+        }
+        mean_prosody.jp_mean /= n;
+        mean_prosody.jp_std /= n;
+        mean_prosody.ja_mean /= n;
+        mean_prosody.ja_std /= n;
+        mean_prosody.h_mean /= n;
+        mean_prosody.s_mean /= n;
+        mean_prosody.peak_density /= n;
+        mean_prosody.energy_mean /= n;
+
+        // Calculate trends (first vs last)
+        let jitter_trend = if self.utterances.len() >= 2 {
+            let first = self.utterances.first().unwrap().combined_jitter();
+            let last = self.utterances.last().unwrap().combined_jitter();
+            last - first
+        } else {
+            0.0
+        };
+
+        let energy_trend = if self.utterances.len() >= 2 {
+            let first = self.utterances.first().unwrap().energy_mean;
+            let last = self.utterances.last().unwrap().energy_mean;
+            last - first
+        } else {
+            0.0
+        };
+
+        // Classify comfort level
+        let aye_state = self.classify_comfort(
+            mean_prosody.combined_jitter(),
+            jitter_trend,
+            mean_prosody.energy_mean,
+        );
+
+        let quality_score = mean_prosody.s_mean;
+
+        Some(ConversationAffectSummary {
+            human_state: None, // Would require analyzing human audio
+            aye_state,
+            quality_score,
+            utterance_count: self.utterances.len(),
+            duration_seconds: self.total_duration_seconds,
+            mean_prosody,
+            jitter_trend,
+            energy_trend,
+        })
+    }
+
+    /// Classify comfort level based on jitter and energy patterns
+    fn classify_comfort(
+        &self,
+        mean_jitter: f32,
+        trend_jitter: f32,
+        mean_energy: f32,
+    ) -> ComfortLevel {
+        let high_jitter = mean_jitter > self.config.high_jitter_threshold;
+        let rising_jitter = trend_jitter > self.config.rising_jitter_threshold;
+
+        if high_jitter && rising_jitter {
+            // Jitter is high AND getting worse = tension/unease
+            ComfortLevel::Uneasy
+        } else if mean_energy > self.config.high_energy_threshold && !high_jitter {
+            // Good energy with stable jitter = positive/happy
+            ComfortLevel::Happy
+        } else {
+            // In-between: stable but low energy, or slightly jittery but stable
+            ComfortLevel::Neutral
+        }
+    }
+
+    /// Get number of utterances collected
+    pub fn utterance_count(&self) -> usize {
+        self.utterances.len()
+    }
+
+    /// Get total duration
+    pub fn total_duration(&self) -> f32 {
+        self.total_duration_seconds
+    }
+}
+
+impl Default for ConversationAffectAnalyzer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_comfort_level_descriptions() {
+        assert_eq!(ComfortLevel::Uneasy.emoji(), "😟");
+        assert_eq!(ComfortLevel::Neutral.emoji(), "😐");
+        assert_eq!(ComfortLevel::Happy.emoji(), "😊");
+
+        assert_eq!(ComfortLevel::Uneasy.score(), -1);
+        assert_eq!(ComfortLevel::Neutral.score(), 0);
+        assert_eq!(ComfortLevel::Happy.score(), 1);
+    }
+
+    #[test]
+    fn test_analyzer_empty_conversation() {
+        let analyzer = ConversationAffectAnalyzer::new();
+        assert!(analyzer.analyze().is_none());
+    }
+
+    #[test]
+    fn test_analyzer_single_utterance() {
+        let mut analyzer = ConversationAffectAnalyzer::new();
+        let prosody = MarineProsodyVector {
+            jp_mean: 0.1,
+            jp_std: 0.05,
+            ja_mean: 0.1,
+            ja_std: 0.05,
+            h_mean: 1.0,
+            s_mean: 0.8,
+            peak_density: 50.0,
+            energy_mean: 0.6,
+        };
+        analyzer.add_utterance(prosody, 2.0);
+
+        let summary = analyzer.analyze().unwrap();
+        assert_eq!(summary.utterance_count, 1);
+        assert_eq!(summary.duration_seconds, 2.0);
+    }
+
+    #[test]
+    fn test_uneasy_classification() {
+        let mut analyzer = ConversationAffectAnalyzer::new();
+
+        // First utterance: moderate jitter
+        analyzer.add_utterance(
+            MarineProsodyVector {
+                jp_mean: 0.3,
+                jp_std: 0.1,
+                ja_mean: 0.3,
+                ja_std: 0.1,
+                h_mean: 1.0,
+                s_mean: 0.5,
+                peak_density: 50.0,
+                energy_mean: 0.3,
+            },
+            1.0,
+        );
+
+        // Second utterance: HIGH jitter (rising trend)
+        analyzer.add_utterance(
+            MarineProsodyVector {
+                jp_mean: 0.6,
+                jp_std: 0.2,
+                ja_mean: 0.5,
+                ja_std: 0.2,
+                h_mean: 0.8,
+                s_mean: 0.3,
+                peak_density: 60.0,
+                energy_mean: 0.4,
+            },
+            1.0,
+        );
+
+        let summary = analyzer.analyze().unwrap();
+        assert_eq!(summary.aye_state, ComfortLevel::Uneasy);
+        assert!(summary.jitter_trend > 0.0); // Rising jitter
+    }
+
+    #[test]
+    fn test_happy_classification() {
+        let mut analyzer = ConversationAffectAnalyzer::new();
+
+        // High energy, low jitter = happy
+        analyzer.add_utterance(
+            MarineProsodyVector {
+                jp_mean: 0.1,
+                jp_std: 0.05,
+                ja_mean: 0.1,
+                ja_std: 0.05,
+                h_mean: 1.0,
+                s_mean: 0.9,
+                peak_density: 80.0,
+                energy_mean: 0.7,
+            },
+            2.0,
+        );
+
+        let summary = analyzer.analyze().unwrap();
+        assert_eq!(summary.aye_state, ComfortLevel::Happy);
+    }
+
+    #[test]
+    fn test_neutral_classification() {
+        let mut analyzer = ConversationAffectAnalyzer::new();
+
+        // Low energy, moderate jitter = neutral
+        analyzer.add_utterance(
+            MarineProsodyVector {
+                jp_mean: 0.2,
+                jp_std: 0.1,
+                ja_mean: 0.2,
+                ja_std: 0.1,
+                h_mean: 1.0,
+                s_mean: 0.7,
+                peak_density: 40.0,
+                energy_mean: 0.3,
+            },
+            1.5,
+        );
+
+        let summary = analyzer.analyze().unwrap();
+        assert_eq!(summary.aye_state, ComfortLevel::Neutral);
+    }
+
+    #[test]
+    fn test_aye_assessment_message() {
+        let summary = ConversationAffectSummary {
+            human_state: None,
+            aye_state: ComfortLevel::Happy,
+            quality_score: 0.85,
+            utterance_count: 5,
+            duration_seconds: 30.0,
+            mean_prosody: MarineProsodyVector::zeros(),
+            jitter_trend: -0.1,
+            energy_trend: 0.2,
+        };
+
+        let message = summary.aye_assessment();
+        assert!(message.contains("😊"));
+        assert!(message.contains("comfortable"));
+        assert!(message.contains("85%"));
+        assert!(message.contains("5 utterances"));
+    }
+}

src/quality/mod.rs

@@ -0,0 +1,12 @@
+//! Quality validation module using Marine salience
+//!
+//! Provides TTS output validation, prosody extraction, and conversation
+//! affect tracking using the Marine algorithm.
+//!
+//! "Marines are not just jarheads - they are actually very intelligent"
+
+pub mod prosody;
+pub mod affect;
+
+pub use prosody::{MarineProsodyConditioner, MarineProsodyVector};
+pub use affect::{ComfortLevel, ConversationAffectSummary};

src/quality/prosody.rs

@@ -0,0 +1,421 @@
+//! Marine Prosody Conditioner - Extract 8D interpretable emotion vectors
+//!
+//! Uses Marine salience to extract prosodic features from reference audio.
+//! These features are interpretable and can be directly edited for control.
+//!
+//! The 8D vector captures:
+//! 1. Period jitter (mean & std) - pitch stability
+//! 2. Amplitude jitter (mean & std) - roughness/strain
+//! 3. Harmonic alignment - voiced vs noisy
+//! 4. Overall salience - authenticity score
+//! 5. Peak density - speech rate/intensity
+//! 6. Energy - loudness
+
+use crate::error::{Error, Result};
+
+/// 8-dimensional prosody vector extracted from audio
+///
+/// These features capture the "emotional signature" of speech:
+/// - Low jitter + high energy = confident/happy
+/// - High jitter + low energy = nervous/uneasy
+/// - Stable patterns = calm, unstable = agitated
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct MarineProsodyVector {
+    /// Mean period jitter (pitch stability)
+    /// Lower = more stable pitch, Higher = more variation
+    pub jp_mean: f32,
+
+    /// Standard deviation of period jitter
+    /// Captures consistency of pitch patterns
+    pub jp_std: f32,
+
+    /// Mean amplitude jitter (volume stability)
+    /// Lower = consistent volume, Higher = erratic
+    pub ja_mean: f32,
+
+    /// Standard deviation of amplitude jitter
+    /// Captures volume pattern consistency
+    pub ja_std: f32,
+
+    /// Mean harmonic alignment score
+    /// 1.0 = perfectly voiced, 0.0 = noise
+    pub h_mean: f32,
+
+    /// Mean overall salience score
+    /// Overall authenticity/quality rating
+    pub s_mean: f32,
+
+    /// Peak density (peaks per second)
+    /// Related to speech rate and intensity
+    pub peak_density: f32,
+
+    /// Mean energy level
+    /// Average loudness of detected peaks
+    pub energy_mean: f32,
+}
+
+impl MarineProsodyVector {
+    /// Create zero vector (baseline)
+    pub fn zeros() -> Self {
+        Self {
+            jp_mean: 0.0,
+            jp_std: 0.0,
+            ja_mean: 0.0,
+            ja_std: 0.0,
+            h_mean: 1.0,
+            s_mean: 1.0,
+            peak_density: 0.0,
+            energy_mean: 0.0,
+        }
+    }
+
+    /// Convert to f32 array for neural network input
+    pub fn to_array(&self) -> [f32; 8] {
+        [
+            self.jp_mean,
+            self.jp_std,
+            self.ja_mean,
+            self.ja_std,
+            self.h_mean,
+            self.s_mean,
+            self.peak_density,
+            self.energy_mean,
+        ]
+    }
+
+    /// Create from f32 array
+    pub fn from_array(arr: [f32; 8]) -> Self {
+        Self {
+            jp_mean: arr[0],
+            jp_std: arr[1],
+            ja_mean: arr[2],
+            ja_std: arr[3],
+            h_mean: arr[4],
+            s_mean: arr[5],
+            peak_density: arr[6],
+            energy_mean: arr[7],
+        }
+    }
+
+    /// Get combined jitter (average of period and amplitude)
+    pub fn combined_jitter(&self) -> f32 {
+        (self.jp_mean + self.ja_mean) / 2.0
+    }
+
+    /// Estimate emotional valence from prosody
+    /// Returns value from -1.0 (negative) to 1.0 (positive)
+    pub fn estimate_valence(&self) -> f32 {
+        // High energy + low jitter = positive
+        // Low energy + high jitter = negative
+        let jitter_factor = 1.0 / (1.0 + self.combined_jitter());
+        let energy_factor = self.energy_mean.sqrt();
+
+        // Combine factors, normalize to -1..1 range
+        (jitter_factor * energy_factor * 2.0 - 1.0).clamp(-1.0, 1.0)
+    }
+
+    /// Estimate arousal/intensity level
+    /// Returns value from 0.0 (calm) to 1.0 (excited)
+    pub fn estimate_arousal(&self) -> f32 {
+        // High peak density + high energy + some jitter variance = high arousal
+        let density_factor = (self.peak_density / 100.0).clamp(0.0, 1.0);
+        let energy_factor = self.energy_mean.sqrt();
+        let variance_factor = (self.jp_std + self.ja_std).clamp(0.0, 1.0);
+
+        ((density_factor + energy_factor + variance_factor) / 3.0).clamp(0.0, 1.0)
+    }
+}
+
+impl Default for MarineProsodyVector {
+    fn default() -> Self {
+        Self::zeros()
+    }
+}
+
+/// Marine-based prosody conditioner for TTS
+///
+/// Replaces heavy Conformer-style extractors with lightweight, interpretable
+/// Marine salience features. This gives you:
+/// - 8D interpretable emotion vector
+/// - Direct editability for control
+/// - Biologically plausible processing
+/// - O(n) linear time extraction
+pub struct MarineProsodyConditioner {
+    sample_rate: u32,
+    jitter_low: f32,
+    jitter_high: f32,
+    min_period: u32,
+    max_period: u32,
+    ema_alpha: f32,
+}
+
+impl MarineProsodyConditioner {
+    /// Create new prosody conditioner for given sample rate
+    pub fn new(sample_rate: u32) -> Self {
+        // F0 range: ~60Hz (low male) to ~4kHz (includes harmonics)
+        let min_period = sample_rate / 4000;
+        let max_period = sample_rate / 60;
+
+        Self {
+            sample_rate,
+            jitter_low: 0.02,
+            jitter_high: 0.60,
+            min_period,
+            max_period,
+            ema_alpha: 0.01,
+        }
+    }
+
+    /// Extract prosody vector from audio samples
+    ///
+    /// Analyzes the audio to produce an 8D prosody vector capturing
+    /// the emotional/stylistic characteristics of the speech.
+    ///
+    /// # Arguments
+    /// * `samples` - Audio samples (typically -1.0 to 1.0 range)
+    ///
+    /// # Returns
+    /// * `Ok(MarineProsodyVector)` - Extracted prosody features
+    /// * `Err` - If insufficient peaks detected
+    pub fn from_samples(&self, samples: &[f32]) -> Result<MarineProsodyVector> {
+        if samples.is_empty() {
+            return Err(Error::Audio("Empty audio buffer".into()));
+        }
+
+        // Detect peaks and collect jitter measurements
+        let mut peaks: Vec<PeakInfo> = Vec::new();
+        let clip_threshold = 1e-3;
+
+        // Simple peak detection
+        for i in 1..samples.len().saturating_sub(1) {
+            let prev = samples[i - 1].abs();
+            let curr = samples[i].abs();
+            let next = samples[i + 1].abs();
+
+            if curr > prev && curr > next && curr > clip_threshold {
+                peaks.push(PeakInfo {
+                    index: i,
+                    amplitude: curr,
+                });
+            }
+        }
+
+        if peaks.len() < 3 {
+            // Not enough peaks for meaningful analysis
+            return Ok(MarineProsodyVector::zeros());
+        }
+
+        // Calculate inter-peak periods and jitter
+        let mut periods: Vec<f32> = Vec::new();
+        let mut amplitudes: Vec<f32> = Vec::new();
+        let mut jp_values: Vec<f32> = Vec::new();
+        let mut ja_values: Vec<f32> = Vec::new();
+
+        // Use EMA for tracking
+        let mut ema_period = 0.0f32;
+        let mut ema_amp = 0.0f32;
+        let mut ema_initialized = false;
+
+        for i in 1..peaks.len() {
+            let period = (peaks[i].index - peaks[i - 1].index) as f32;
+            let amp = peaks[i].amplitude;
+
+            // Check if period is in valid range
+            if period > self.min_period as f32 && period < self.max_period as f32 {
+                periods.push(period);
+                amplitudes.push(amp);
+
+                if !ema_initialized {
+                    ema_period = period;
+                    ema_amp = amp;
+                    ema_initialized = true;
+                } else {
+                    // Calculate jitter
+                    let jp = (period - ema_period).abs() / ema_period;
+                    let ja = (amp - ema_amp).abs() / ema_amp;
+                    jp_values.push(jp);
+                    ja_values.push(ja);
+
+                    // Update EMA
+                    ema_period = self.ema_alpha * period + (1.0 - self.ema_alpha) * ema_period;
+                    ema_amp = self.ema_alpha * amp + (1.0 - self.ema_alpha) * ema_amp;
+                }
+            }
+        }
+
+        if jp_values.is_empty() {
+            return Ok(MarineProsodyVector::zeros());
+        }
+
+        // Compute statistics
+        let n = jp_values.len() as f32;
+        let duration_sec = samples.len() as f32 / self.sample_rate as f32;
+
+        // Mean calculations
+        let jp_mean = jp_values.iter().sum::<f32>() / n;
+        let ja_mean = ja_values.iter().sum::<f32>() / n;
+        let energy_mean = amplitudes.iter().map(|a| a * a).sum::<f32>() / amplitudes.len() as f32;
+
+        // Std calculations
+        let jp_var = jp_values.iter().map(|x| (x - jp_mean).powi(2)).sum::<f32>() / n;
+        let ja_var = ja_values.iter().map(|x| (x - ja_mean).powi(2)).sum::<f32>() / n;
+        let jp_std = jp_var.sqrt();
+        let ja_std = ja_var.sqrt();
+
+        // Harmonic score (simplified - assume voiced content)
+        let h_mean = 1.0;
+
+        // Overall salience score
+        let s_mean = 1.0 / (1.0 + jp_mean + ja_mean);
+
+        // Peak density
+        let peak_density = peaks.len() as f32 / duration_sec;
+
+        Ok(MarineProsodyVector {
+            jp_mean,
+            jp_std,
+            ja_mean,
+            ja_std,
+            h_mean,
+            s_mean,
+            peak_density,
+            energy_mean,
+        })
+    }
+
+    /// Validate TTS output quality using Marine salience
+    ///
+    /// Returns quality score and potential issues detected
+    pub fn validate_tts_output(&self, samples: &[f32]) -> Result<TTSQualityReport> {
+        let prosody = self.from_samples(samples)?;
+
+        let mut issues = Vec::new();
+
+        // Check for common TTS problems
+        if prosody.jp_mean < 0.005 {
+            issues.push("Too perfect - sounds robotic (add natural variation)");
+        }
+
+        if prosody.jp_mean > 0.3 {
+            issues.push("High period jitter - possible artifacts");
+        }
+
+        if prosody.ja_mean > 0.4 {
+            issues.push("High amplitude jitter - volume inconsistency");
+        }
+
+        if prosody.s_mean < 0.4 {
+            issues.push("Low salience - audio quality issues");
+        }
+
+        if prosody.peak_density < 10.0 {
+            issues.push("Low peak density - missing speech energy");
+        }
+
+        let quality_score = prosody.s_mean * 100.0;
+
+        Ok(TTSQualityReport {
+            prosody,
+            quality_score,
+            issues,
+        })
+    }
+
+    /// Get the configured sample rate
+    pub fn sample_rate(&self) -> u32 {
+        self.sample_rate
+    }
+}
+
+/// Internal peak information
+struct PeakInfo {
+    index: usize,
+    amplitude: f32,
+}
+
+/// TTS quality validation report
+#[derive(Debug, Clone)]
+pub struct TTSQualityReport {
+    /// Extracted prosody vector
+    pub prosody: MarineProsodyVector,
+    /// Overall quality score (0-100)
+    pub quality_score: f32,
+    /// List of detected issues
+    pub issues: Vec<&'static str>,
+}
+
+impl TTSQualityReport {
+    /// Check if quality passes threshold
+    pub fn passes(&self, threshold: f32) -> bool {
+        self.quality_score >= threshold && self.issues.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_prosody_vector_array_conversion() {
+        let vec = MarineProsodyVector {
+            jp_mean: 0.1,
+            jp_std: 0.05,
+            ja_mean: 0.2,
+            ja_std: 0.1,
+            h_mean: 0.9,
+            s_mean: 0.8,
+            peak_density: 50.0,
+            energy_mean: 0.3,
+        };
+
+        let arr = vec.to_array();
+        let reconstructed = MarineProsodyVector::from_array(arr);
+
+        assert_eq!(vec.jp_mean, reconstructed.jp_mean);
+        assert_eq!(vec.s_mean, reconstructed.s_mean);
+    }
+
+    #[test]
+    fn test_conditioner_empty_buffer() {
+        let conditioner = MarineProsodyConditioner::new(22050);
+        let result = conditioner.from_samples(&[]);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_conditioner_silence() {
+        let conditioner = MarineProsodyConditioner::new(22050);
+        let silence = vec![0.0; 1000];
+        let prosody = conditioner.from_samples(&silence).unwrap();
+        // Should return zeros for silence
+        assert_eq!(prosody.peak_density, 0.0);
+    }
+
+    #[test]
+    fn test_estimate_valence() {
+        let positive = MarineProsodyVector {
+            jp_mean: 0.01,
+            jp_std: 0.01,
+            ja_mean: 0.01,
+            ja_std: 0.01,
+            h_mean: 1.0,
+            s_mean: 0.95,
+            peak_density: 100.0,
+            energy_mean: 0.8,
+        };
+
+        let negative = MarineProsodyVector {
+            jp_mean: 0.5,
+            jp_std: 0.3,
+            ja_mean: 0.4,
+            ja_std: 0.2,
+            h_mean: 0.7,
+            s_mean: 0.4,
+            peak_density: 30.0,
+            energy_mean: 0.1,
+        };
+
+        // Higher energy + lower jitter should give more positive valence
+        assert!(positive.estimate_valence() > negative.estimate_valence());
+    }
+}

tools/convert_to_onnx.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+Convert IndexTTS-2 PyTorch models to ONNX format for Rust inference!
+
+This script converts the three main models:
+1. GPT model (gpt.pth) - Autoregressive text-to-semantic generation
+2. S2Mel model (s2mel.pth) - Semantic-to-mel spectrogram conversion
+3. BigVGAN - Mel-to-waveform vocoder (already available as ONNX from NVIDIA)
+
+Usage:
+    python tools/convert_to_onnx.py
+
+Output:
+    models/gpt.onnx
+    models/s2mel.onnx
+    models/bigvgan.onnx (if needed, otherwise use NVIDIA's)
+
+Why ONNX?
+    - Cross-platform: Works on Windows, Linux, macOS, M1/M2 Macs
+    - Fast: ONNX Runtime is highly optimized
+    - Rust-native: ort crate provides excellent ONNX Runtime bindings
+    - No Python: Production inference without Python dependency hell!
+
+Author: Aye & Hue @ 8b.is
+"""
+
+import os
+import sys
+
+# Setup paths
+script_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(script_dir)
+os.chdir(project_root)
+
+# Set HF cache
+os.environ['HF_HUB_CACHE'] = './checkpoints/hf_cache'
+
+print("=" * 70)
+print("  IndexTTS-2 PyTorch to ONNX Converter")
+print("  For Rust inference with ort crate!")
+print("=" * 70)
+print()
+
+# Check for models
+if not os.path.exists("checkpoints/gpt.pth"):
+    print("ERROR: Models not found!")
+    print("Run: python tools/download_files.py -s huggingface")
+    sys.exit(1)
+
+import torch
+import torch.onnx
+import numpy as np
+from pathlib import Path
+
+# Add reference code to path
+sys.path.insert(0, "indextts - REMOVING - REF ONLY")
+
+# Create output directory
+output_dir = Path("models")
+output_dir.mkdir(exist_ok=True)
+
+print(f"PyTorch version: {torch.__version__}")
+print(f"Output directory: {output_dir}")
+print()
+
+
+def export_speaker_encoder():
+    """
+    Export the CAM++ speaker encoder to ONNX.
+
+    This model extracts speaker embeddings from reference audio.
+    Input: mel spectrogram [batch, n_mels, time]
+    Output: speaker embedding [batch, 192]
+    """
+    print("\n" + "=" * 50)
+    print("Exporting Speaker Encoder (CAM++)")
+    print("=" * 50)
+
+    try:
+        from omegaconf import OmegaConf
+        from indextts.s2mel.modules.campplus.DTDNN import CAMPPlus
+
+        # Load config
+        cfg = OmegaConf.load("checkpoints/config.yaml")
+
+        # Create model
+        model = CAMPPlus(feat_dim=80, embedding_size=192)
+
+        # Load weights
+        weights_path = "./checkpoints/hf_cache/models--funasr--campplus/snapshots/fb71fe990cbf6031ae6987a2d76fe64f94377b7e/campplus_cn_common.bin"
+        if os.path.exists(weights_path):
+            state_dict = torch.load(weights_path, map_location='cpu')
+            model.load_state_dict(state_dict)
+            print(f"Loaded weights from: {weights_path}")
+
+        model.eval()
+
+        # CAMPPlus expects [batch, time, n_mels] NOT [batch, n_mels, time]!
+        # This is the key insight - the model processes time-series of mel features
+        dummy_input = torch.randn(1, 100, 80)  # [batch, time, features]
+
+        # Verify forward pass works before export
+        with torch.no_grad():
+            test_output = model(dummy_input)
+            print(f"Forward pass works! Output shape: {test_output.shape}")
+
+        # Export to ONNX
+        output_path = output_dir / "speaker_encoder.onnx"
+        torch.onnx.export(
+            model,
+            dummy_input,
+            str(output_path),
+            input_names=['mel_spectrogram'],
+            output_names=['speaker_embedding'],
+            dynamic_axes={
+                'mel_spectrogram': {0: 'batch', 1: 'time'},  # time is dim 1!
+                'speaker_embedding': {0: 'batch'}
+            },
+            opset_version=18,  # Use 18+ for latest features
+            do_constant_folding=True,
+        )
+
+        # Verify the export
+        import onnx
+        onnx_model = onnx.load(str(output_path))
+        onnx.checker.check_model(onnx_model)
+
+        print(f"✓ Exported: {output_path}")
+        print(f"  Input: mel_spectrogram [batch, time, 80]")  # Corrected!
+        print(f"  Output: speaker_embedding [batch, 192]")
+        print(f"✓ ONNX model verified!")
+        return True
+
+    except Exception as e:
+        print(f"✗ Failed to export speaker encoder: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def export_gpt_model():
+    """
+    Export the GPT autoregressive model to ONNX.
+
+    This is the most complex model - generates semantic tokens from text.
+    We may need to export it in parts due to KV caching.
+
+    Input: text_tokens [batch, seq_len], speaker_embedding [batch, 192]
+    Output: semantic_codes [batch, code_len]
+    """
+    print("\n" + "=" * 50)
+    print("Exporting GPT Model (Autoregressive)")
+    print("=" * 50)
+
+    try:
+        from omegaconf import OmegaConf
+
+        # Load the full model config
+        cfg = OmegaConf.load("checkpoints/config.yaml")
+
+        # This is tricky - GPT models with KV caching are hard to export
+        # We might need to:
+        # 1. Export just the forward pass without caching
+        # 2. Or export separate encoder/decoder parts
+
+        print("GPT model export is complex due to:")
+        print("  - Autoregressive generation with KV caching")
+        print("  - Dynamic sequence lengths")
+        print("  - Multiple internal components")
+        print()
+        print("Options:")
+        print("  A) Export without KV cache (slower but simpler)")
+        print("  B) Export encoder + single-step decoder (efficient)")
+        print("  C) Use torch.compile + ONNX tracing")
+        print()
+
+        # For now, let's try the simpler approach
+        from infer_v2 import IndexTTS2
+
+        # Load model
+        tts = IndexTTS2(
+            cfg_path="checkpoints/config.yaml",
+            model_dir="checkpoints",
+            use_fp16=False,
+            device="cpu"
+        )
+
+        # Get the GPT component
+        gpt = tts.gpt
+        gpt.eval()
+
+        print(f"GPT model loaded: {type(gpt)}")
+        print(f"Parameters: {sum(p.numel() for p in gpt.parameters()):,}")
+
+        # The GPT model architecture:
+        # - Text encoder (embeddings + transformer)
+        # - Speaker conditioning
+        # - Autoregressive decoder
+
+        # Let's export the text encoder first
+        output_path = output_dir / "gpt_encoder.onnx"
+
+        # Create dummy inputs
+        text_tokens = torch.randint(0, 30000, (1, 32), dtype=torch.int64)
+
+        # This will likely fail due to complex control flow
+        # but let's try!
+        print(f"Attempting GPT export (may require modifications)...")
+
+        # For now, just report what we learned
+        print()
+        print("Note: Full GPT export requires modifying the model code")
+        print("to remove dynamic control flow. Creating a wrapper...")
+
+        return False
+
+    except Exception as e:
+        print(f"✗ Failed to export GPT: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def export_s2mel_model():
+    """
+    Export the Semantic-to-Mel model (flow matching).
+
+    This converts semantic codes to mel spectrograms.
+    Input: semantic_codes [batch, code_len], speaker_embedding [batch, 192]
+    Output: mel_spectrogram [batch, 80, mel_len]
+    """
+    print("\n" + "=" * 50)
+    print("Exporting S2Mel Model (Flow Matching)")
+    print("=" * 50)
+
+    try:
+        from omegaconf import OmegaConf
+
+        cfg = OmegaConf.load("checkpoints/config.yaml")
+
+        print("S2Mel model (Diffusion/Flow Matching) is also complex:")
+        print("  - Multiple denoising steps (iterative)")
+        print("  - CFM (Conditional Flow Matching) requires ODE solving")
+        print()
+        print("Export strategy:")
+        print("  1. Export the single denoising step")
+        print("  2. Run iteration loop in Rust")
+        print()
+
+        return False
+
+    except Exception as e:
+        print(f"✗ Failed to export S2Mel: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def export_bigvgan():
+    """
+    Export BigVGAN vocoder to ONNX.
+
+    Good news: NVIDIA provides pre-trained BigVGAN models!
+    Even better: They're designed for easy ONNX export.
+
+    Input: mel_spectrogram [batch, 80, mel_len]
+    Output: waveform [batch, 1, wave_len]
+    """
+    print("\n" + "=" * 50)
+    print("Exporting BigVGAN Vocoder")
+    print("=" * 50)
+
+    try:
+        # BigVGAN from NVIDIA is easier to export
+        # Let's check if we already have it
+
+        print("BigVGAN options:")
+        print("  1. Use NVIDIA's pre-exported ONNX (recommended)")
+        print("     https://github.com/NVIDIA/BigVGAN")
+        print()
+        print("  2. Export from PyTorch weights (we'll do this)")
+        print()
+
+        # Try to load BigVGAN
+        try:
+            from bigvgan import bigvgan
+            model = bigvgan.BigVGAN.from_pretrained(
+                'nvidia/bigvgan_v2_22khz_80band_256x',
+                use_cuda_kernel=False
+            )
+            model.eval()
+            model.remove_weight_norm()  # Important for ONNX!
+
+            print(f"BigVGAN loaded from HuggingFace")
+            print(f"Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+            # Create dummy input
+            dummy_mel = torch.randn(1, 80, 100)
+
+            # Export
+            output_path = output_dir / "bigvgan.onnx"
+            torch.onnx.export(
+                model,
+                dummy_mel,
+                str(output_path),
+                input_names=['mel_spectrogram'],
+                output_names=['waveform'],
+                dynamic_axes={
+                    'mel_spectrogram': {0: 'batch', 2: 'mel_length'},
+                    'waveform': {0: 'batch', 2: 'wave_length'}
+                },
+                opset_version=18,  # Use 18+ for latest features
+                do_constant_folding=True,
+            )
+
+            print(f"✓ Exported: {output_path}")
+            print(f"  Input: mel_spectrogram [batch, 80, mel_len]")
+            print(f"  Output: waveform [batch, 1, wave_len]")
+
+            # Verify the export
+            import onnx
+            onnx_model = onnx.load(str(output_path))
+            onnx.checker.check_model(onnx_model)
+            print(f"✓ ONNX model verified!")
+
+            return True
+
+        except ImportError:
+            print("bigvgan package not installed, installing...")
+            os.system("pip install bigvgan")
+            print("Please re-run the script.")
+            return False
+
+    except Exception as e:
+        print(f"✗ Failed to export BigVGAN: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    print("\nStarting ONNX conversion...\n")
+
+    results = {}
+
+    # Export each component
+    results['speaker_encoder'] = export_speaker_encoder()
+    results['gpt'] = export_gpt_model()
+    results['s2mel'] = export_s2mel_model()
+    results['bigvgan'] = export_bigvgan()
+
+    # Summary
+    print("\n" + "=" * 70)
+    print("  CONVERSION SUMMARY")
+    print("=" * 70)
+
+    for name, success in results.items():
+        status = "✓ SUCCESS" if success else "✗ NEEDS WORK"
+        print(f"  {name:20} {status}")
+
+    print()
+
+    if all(results.values()):
+        print("All models converted! Ready for Rust inference.")
+    else:
+        print("Some models need manual intervention.")
+        print()
+        print("For complex models (GPT, S2Mel), consider:")
+        print("  1. Modifying the Python code to remove dynamic control flow")
+        print("  2. Using torch.jit.trace with concrete inputs")
+        print("  3. Exporting subcomponents separately")
+        print("  4. Using ONNX Runtime's transformer optimizations")
+
+    print()
+    print("Output directory:", output_dir.absolute())
+
+
+if __name__ == "__main__":
+    main()

tools/i18n/i18n.py

@@ -1,36 +0,0 @@
-import json
-import locale
-import os
-
-I18N_JSON_DIR : os.PathLike = os.path.join(os.path.dirname(os.path.relpath(__file__)), 'locale')
-
-def load_language_list(language):
-    with open(os.path.join(I18N_JSON_DIR, f"{language}.json"), "r", encoding="utf-8") as f:
-        language_list = json.load(f)
-    return language_list
-
-def scan_language_list():
-    language_list = []
-    for name in os.listdir(I18N_JSON_DIR):
-        if name.endswith(".json"):language_list.append(name.split('.')[0])
-    return language_list
-
-class I18nAuto:
-    def __init__(self, language=None):
-        if language in ["Auto", None]:
-            language = locale.getdefaultlocale()[0]
-            # getlocale can't identify the system's language ((None, None))
-        if not os.path.exists(os.path.join(I18N_JSON_DIR, f"{language}.json")):
-            language = "en_US"
-        self.language = language
-        self.language_map = load_language_list(language)
-
-    def __call__(self, key):
-        return self.language_map.get(key, key)
-
-    def __repr__(self):
-        return "Use Language: " + self.language
-
-if __name__ == "__main__":
-    i18n = I18nAuto(language='en_US')
-    print(i18n)

tools/i18n/locale/en_US.json

@@ -1,49 +0,0 @@
-{
-  "本软件以自拟协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.": "This software is open-sourced under customized license. The author has no control over the software, and users of the software, as well as those who distribute the audio generated by the software, assume full responsibility.",
-  "如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录LICENSE.": "If you do not agree to these terms, you are not permitted to use or reference any code or files within the software package. For further details, please refer to the LICENSE files in the root directory.",
-  "时长必须为正数": "Duration must be a positive number",
-  "请输入有效的浮点数": "Please enter a valid floating-point number",
-  "使用情感参考音频": "Use emotion reference audio",
-  "使用情感向量控制": "Use emotion vectors",
-  "使用情感描述文本控制": "Use text description to control emotion",
-  "上传情感参考音频": "Upload emotion reference audio",
-  "情感权重": "Emotion control weight",
-  "喜": "Happy",
-  "怒": "Angry",
-  "哀": "Sad",
-  "惧": "Afraid",
-  "厌恶": "Disgusted",
-  "低落": "Melancholic",
-  "惊喜": "Surprised",
-  "平静": "Calm",
-  "情感描述文本": "Emotion description",
-  "请输入情绪描述（或留空以自动使用目标文本作为情绪描述）": "Please input an emotion description (or leave blank to automatically use the main text prompt)",
-  "高级生成参数设置": "Advanced generation parameter settings",
-  "情感向量之和不能超过1.5，请调整后重试。": "The sum of the emotion vectors cannot exceed 1.5. Please adjust and try again.",
-  "音色参考音频": "Voice Reference",
-  "音频生成": "Speech Synthesis",
-  "文本": "Text",
-  "生成语音": "Synthesize",
-  "生成结果": "Synthesis Result",
-  "功能设置": "Settings",
-  "分句设置": "Text segmentation settings",
-  "参数会影响音频质量和生成速度": "These parameters affect the audio quality and generation speed.",
-  "分句最大Token数": "Max tokens per generation segment",
-  "建议80~200之间，值越大，分句越长；值越小，分句越碎；过小过大都可能导致音频质量不高": "Recommended range: 80 - 200. Larger values require more VRAM but improves the flow of the speech, while lower values require less VRAM but means more fragmented sentences. Values that are too small or too large may lead to less coherent speech.",
-  "预览分句结果": "Preview of the audio generation segments",
-  "序号": "Index",
-  "分句内容": "Content",
-  "Token数": "Token Count",
-  "情感控制方式": "Emotion control method",
-  "GPT2 采样设置": "GPT-2 Sampling Configuration",
-  "参数会影响音频多样性和生成速度详见": "Influences both the diversity of the generated audio and the generation speed. For further details, refer to",
-  "是否进行采样": "Enable GPT-2 sampling",
-  "生成Token最大数量，过小导致音频被截断": "Maximum number of tokens to generate. If text exceeds this, the audio will be cut off.",
-  "请上传情感参考音频": "Please upload the emotion reference audio",
-  "当前模型版本": "Current model version: ",
-  "请输入目标文本": "Please input the text to synthesize",
-  "例如：委屈巴巴、危险在悄悄逼近": "e.g. deeply sad, danger is creeping closer",
-  "与音色参考音频相同": "Same as the voice reference",
-  "情感随机采样": "Randomize emotion sampling",
-  "显示实验功能": "Show experimental features"
-}

tools/i18n/locale/zh_CN.json

@@ -1,44 +0,0 @@
-{
-  "本软件以自拟协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.": "本软件以自拟协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.",
-  "如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录LICENSE.": "如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录LICENSE.",
-  "时长必须为正数": "时长必须为正数",
-  "请输入有效的浮点数": "请输入有效的浮点数",
-  "使用情感参考音频": "使用情感参考音频",
-  "使用情感向量控制": "使用情感向量控制",
-  "使用情感描述文本控制": "使用情感描述文本控制",
-  "上传情感参考音频": "上传情感参考音频",
-  "情感权重": "情感权重",
-  "喜": "喜",
-  "怒": "怒",
-  "哀": "哀",
-  "惧": "惧",
-  "厌恶": "厌恶",
-  "低落": "低落",
-  "惊喜": "惊喜",
-  "平静": "平静",
-  "情感描述文本": "情感描述文本",
-  "请输入情绪描述（或留空以自动使用目标文本作为情绪描述）": "请输入情绪描述（或留空以自动使用目标文本作为情绪描述）",
-  "高级生成参数设置": "高级生成参数设置",
-  "情感向量之和不能超过1.5，请调整后重试。": "情感向量之和不能超过1.5，请调整后重试。",
-  "音色参考音频":  "音色参考音频",
-  "音频生成": "音频生成",
-  "文本": "文本",
-  "生成语音": "生成语音",
-  "生成结果": "生成结果",
-  "功能设置": "功能设置",
-  "分句设置": "分句设置",
-  "参数会影响音频质量和生成速度": "参数会影响音频质量和生成速度",
-  "分句最大Token数": "分句最大Token数",
-  "建议80~200之间，值越大，分句越长；值越小，分句越碎；过小过大都可能导致音频质量不高": "建议80~200之间，值越大，分句越长；值越小，分句越碎；过小过大都可能导致音频质量不高",
-  "预览分句结果": "预览分句结果",
-  "序号": "序号",
-  "分句内容": "分句内容",
-  "Token数": "Token数",
-  "情感控制方式": "情感控制方式",
-  "GPT2 采样设置": "GPT2 采样设置",
-  "参数会影响音频多样性和生成速度详见": "参数会影响音频多样性和生成速度详见",
-  "是否进行采样": "是否进行采样",
-  "生成Token最大数量，过小导致音频被截断": "生成Token最大数量，过小导致音频被截断",
-  "显示实验功能": "显示实验功能",
-  "例如：委屈巴巴、危险在悄悄逼近": "例如：委屈巴巴、危险在悄悄逼近"
-}

tools/i18n/scan_i18n.py

@@ -1,131 +0,0 @@
-import ast
-import glob
-import json
-import os
-from collections import OrderedDict
-
-I18N_JSON_DIR   : os.PathLike = os.path.join(os.path.dirname(os.path.relpath(__file__)), 'locale')
-DEFAULT_LANGUAGE: str         = "zh_CN" # 默认语言
-TITLE_LEN       : int         = 60      # 标题显示长度
-KEY_LEN         : int         = 30      # 键名显示长度
-SHOW_KEYS       : bool        = False   # 是否显示键信息
-SORT_KEYS       : bool        = False   # 是否按全局键名写入文件
-
-def extract_i18n_strings(node):
-    i18n_strings = []
-
-    if (
-        isinstance(node, ast.Call)
-        and isinstance(node.func, ast.Name)
-        and node.func.id == "i18n"
-    ):
-        for arg in node.args:
-            if isinstance(arg, ast.Str):
-                i18n_strings.append(arg.s)
-
-    for child_node in ast.iter_child_nodes(node):
-        i18n_strings.extend(extract_i18n_strings(child_node))
-
-    return i18n_strings
-
-def scan_i18n_strings():
-    """
-    scan the directory for all .py files (recursively)
-    for each file, parse the code into an AST
-    for each AST, extract the i18n strings
-    """
-    strings = []
-    print(" Scanning Files and Extracting i18n Strings ".center(TITLE_LEN, "="))
-    for filename in glob.iglob("**/*.py", recursive=True):
-        try:
-            with open(filename, "r", encoding="utf-8") as f:
-                code = f.read()
-                if "I18nAuto" in code:
-                    tree = ast.parse(code)
-                    i18n_strings = extract_i18n_strings(tree)
-                    print(f"{filename.ljust(KEY_LEN*3//2)}: {len(i18n_strings)}")
-                    if SHOW_KEYS:
-                        print("\n".join([s for s in i18n_strings]))
-                    strings.extend(i18n_strings)
-        except Exception as e:
-            print(f"\033[31m[Failed] Error occur at {filename}: {e}\033[0m")
-
-    code_keys = set(strings)
-    print(f"{'Total Unique'.ljust(KEY_LEN*3//2)}: {len(code_keys)}")
-    return code_keys
-
-def update_i18n_json(json_file, standard_keys):
-    standard_keys = sorted(standard_keys)
-    print(f" Process {json_file} ".center(TITLE_LEN, "="))
-    # 读取 JSON 文件
-    with open(json_file, "r", encoding="utf-8") as f:
-        json_data = json.load(f, object_pairs_hook=OrderedDict)
-    # 打印处理前的 JSON 条目数
-    len_before = len(json_data)
-    print(f"{'Total Keys'.ljust(KEY_LEN)}: {len_before}")
-    # 识别缺失的键并补全
-    miss_keys = set(standard_keys) - set(json_data.keys())
-    if len(miss_keys) > 0:
-        print(f"{'Missing Keys (+)'.ljust(KEY_LEN)}: {len(miss_keys)}")
-        for key in miss_keys:
-            if DEFAULT_LANGUAGE in json_file:
-                # 默认语言的键值相同.
-                json_data[key] = key
-            else:
-                # 其他语言的值设置为 #! + 键名以标注未被翻译.
-                json_data[key] = "#!" + key
-            if SHOW_KEYS:
-                print(f"{'Added Missing Key'.ljust(KEY_LEN)}: {key}")
-    # 识别多余的键并删除
-    diff_keys = set(json_data.keys()) - set(standard_keys)
-    if len(diff_keys) > 0:
-        print(f"{'Unused Keys  (-)'.ljust(KEY_LEN)}: {len(diff_keys)}")
-        for key in diff_keys:
-            del json_data[key]
-            if SHOW_KEYS:
-                print(f"{'Removed Unused Key'.ljust(KEY_LEN)}: {key}")
-    # 按键顺序排序
-    json_data = OrderedDict(
-        sorted(
-            json_data.items(),
-            key=lambda x: (
-                list(standard_keys).index(x[0]) if x[0] in standard_keys and not x[1].startswith('#!') else len(json_data),
-            )
-        )
-    )
-    # 打印处理后的 JSON 条目数
-    if len(miss_keys) != 0 or len(diff_keys) != 0:
-        print(f"{'Total Keys (After)'.ljust(KEY_LEN)}: {len(json_data)}")
-    # 识别有待翻译的键
-    num_miss_translation = 0
-    duplicate_items = {}
-    for key, value in json_data.items():
-        if value.startswith("#!"):
-            num_miss_translation += 1
-            if SHOW_KEYS:
-                print(f"{'Missing Translation'.ljust(KEY_LEN)}: {key}")
-        if value in duplicate_items:
-            duplicate_items[value].append(key)
-        else:
-            duplicate_items[value] = [key]
-    # 打印是否有重复的值
-    for value, keys in duplicate_items.items():
-        if len(keys) > 1:
-            print("\n".join([f"\033[31m{'[Failed] Duplicate Value'.ljust(KEY_LEN)}: {key} -> {value}\033[0m" for key in keys]))
-
-    if num_miss_translation > 0:
-        print(f"\033[31m{'[Failed] Missing Translation'.ljust(KEY_LEN)}: {num_miss_translation}\033[0m")
-    else:
-        print(f"\033[32m[Passed] All Keys Translated\033[0m")
-    # 将处理后的结果写入 JSON 文件
-    with open(json_file, "w", encoding="utf-8") as f:
-        json.dump(json_data, f, ensure_ascii=False, indent=4, sort_keys=SORT_KEYS)
-        f.write("\n")
-    print(f" Updated {json_file} ".center(TITLE_LEN, "=") + '\n')
-
-if __name__ == "__main__":
-    code_keys = scan_i18n_strings()
-    for json_file in os.listdir(I18N_JSON_DIR):
-        if json_file.endswith(r".json"):
-            json_file = os.path.join(I18N_JSON_DIR, json_file)
-            update_i18n_json(json_file, code_keys)

webui.py

@@ -1,392 +0,0 @@
-import spaces
-import json
-import os
-import sys
-import threading
-import time
-
-import warnings
-
-import numpy as np
-
-warnings.filterwarnings("ignore", category=FutureWarning)
-warnings.filterwarnings("ignore", category=UserWarning)
-
-import pandas as pd
-
-current_dir = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(current_dir)
-sys.path.append(os.path.join(current_dir, "indextts"))
-
-import argparse
-parser = argparse.ArgumentParser(
-    description="IndexTTS WebUI",
-    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-)
-parser.add_argument("--verbose", action="store_true", default=False, help="Enable verbose mode")
-parser.add_argument("--port", type=int, default=7860, help="Port to run the web UI on")
-parser.add_argument("--host", type=str, default="0.0.0.0", help="Host to run the web UI on")
-parser.add_argument("--model_dir", type=str, default="./checkpoints", help="Model checkpoints directory")
-parser.add_argument("--fp16", action="store_true", default=False, help="Use FP16 for inference if available")
-parser.add_argument("--deepspeed", action="store_true", default=False, help="Use DeepSpeed to accelerate if available")
-parser.add_argument("--cuda_kernel", action="store_true", default=False, help="Use CUDA kernel for inference if available")
-parser.add_argument("--gui_seg_tokens", type=int, default=120, help="GUI: Max tokens per generation segment")
-cmd_args = parser.parse_args()
-
-from tools.download_files import download_model_from_huggingface
-download_model_from_huggingface(os.path.join(current_dir,"checkpoints"),
-                                os.path.join(current_dir, "checkpoints","hf_cache"))
-
-import gradio as gr
-from indextts.infer_v2 import IndexTTS2
-from tools.i18n.i18n import I18nAuto
-
-i18n = I18nAuto(language="Auto")
-MODE = 'local'
-tts = IndexTTS2(model_dir=cmd_args.model_dir,
-                cfg_path=os.path.join(cmd_args.model_dir, "config.yaml"),
-                use_fp16=cmd_args.fp16,
-                use_deepspeed=cmd_args.deepspeed,
-                use_cuda_kernel=cmd_args.cuda_kernel,
-                )
-# 支持的语言列表
-LANGUAGES = {
-    "中文": "zh_CN",
-    "English": "en_US"
-}
-EMO_CHOICES = [i18n("与音色参考音频相同"),
-                i18n("使用情感参考音频"),
-                i18n("使用情感向量控制"),
-                i18n("使用情感描述文本控制")]
-EMO_CHOICES_BASE = EMO_CHOICES[:3]  # 基础选项
-EMO_CHOICES_EXPERIMENTAL = EMO_CHOICES  # 全部选项（包括文本描述）
-
-os.makedirs("outputs/tasks",exist_ok=True)
-os.makedirs("prompts",exist_ok=True)
-
-MAX_LENGTH_TO_USE_SPEED = 70
-with open("examples/cases.jsonl", "r", encoding="utf-8") as f:
-    example_cases = []
-    for line in f:
-        line = line.strip()
-        if not line:
-            continue
-        example = json.loads(line)
-        if example.get("emo_audio",None):
-            emo_audio_path = os.path.join("examples",example["emo_audio"])
-        else:
-            emo_audio_path = None
-        example_cases.append([os.path.join("examples", example.get("prompt_audio", "sample_prompt.wav")),
-                              EMO_CHOICES[example.get("emo_mode",0)],
-                              example.get("text"),
-                             emo_audio_path,
-                             example.get("emo_weight",1.0),
-                             example.get("emo_text",""),
-                             example.get("emo_vec_1",0),
-                             example.get("emo_vec_2",0),
-                             example.get("emo_vec_3",0),
-                             example.get("emo_vec_4",0),
-                             example.get("emo_vec_5",0),
-                             example.get("emo_vec_6",0),
-                             example.get("emo_vec_7",0),
-                             example.get("emo_vec_8",0),
-                             example.get("emo_text") is not None]
-                             )
-
-def normalize_emo_vec(emo_vec):
-    # emotion factors for better user experience
-    k_vec = [0.75,0.70,0.80,0.80,0.75,0.75,0.55,0.45]
-    tmp = np.array(k_vec) * np.array(emo_vec)
-    if np.sum(tmp) > 0.8:
-        tmp = tmp * 0.8/ np.sum(tmp)
-    return tmp.tolist()
-
-@spaces.GPU
-def gen_single(emo_control_method,prompt, text,
-               emo_ref_path, emo_weight,
-               vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8,
-               emo_text,emo_random,
-               max_text_tokens_per_segment=120,
-                *args, progress=gr.Progress()):
-    output_path = None
-    if not output_path:
-        output_path = os.path.join("outputs", f"spk_{int(time.time())}.wav")
-    # set gradio progress
-    tts.gr_progress = progress
-    do_sample, top_p, top_k, temperature, \
-        length_penalty, num_beams, repetition_penalty, max_mel_tokens = args
-    kwargs = {
-        "do_sample": bool(do_sample),
-        "top_p": float(top_p),
-        "top_k": int(top_k) if int(top_k) > 0 else None,
-        "temperature": float(temperature),
-        "length_penalty": float(length_penalty),
-        "num_beams": num_beams,
-        "repetition_penalty": float(repetition_penalty),
-        "max_mel_tokens": int(max_mel_tokens),
-        # "typical_sampling": bool(typical_sampling),
-        # "typical_mass": float(typical_mass),
-    }
-    if type(emo_control_method) is not int:
-        emo_control_method = emo_control_method.value
-    if emo_control_method == 0:  # emotion from speaker
-        emo_ref_path = None  # remove external reference audio
-    if emo_control_method == 1:  # emotion from reference audio
-        # normalize emo_alpha for better user experience
-        emo_weight = emo_weight * 0.8
-        pass
-    if emo_control_method == 2:  # emotion from custom vectors
-        vec = [vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8]
-        vec = normalize_emo_vec(vec)
-    else:
-        # don't use the emotion vector inputs for the other modes
-        vec = None
-
-    if emo_text == "":
-        # erase empty emotion descriptions; `infer()` will then automatically use the main prompt
-        emo_text = None
-
-    print(f"Emo control mode:{emo_control_method},weight:{emo_weight},vec:{vec}")
-    output = tts.infer(spk_audio_prompt=prompt, text=text,
-                       output_path=output_path,
-                       emo_audio_prompt=emo_ref_path, emo_alpha=emo_weight,
-                       emo_vector=vec,
-                       use_emo_text=(emo_control_method==3), emo_text=emo_text,use_random=emo_random,
-                       verbose=cmd_args.verbose,
-                       max_text_tokens_per_segment=int(max_text_tokens_per_segment),
-                       **kwargs)
-    return gr.update(value=output,visible=True)
-
-def update_prompt_audio():
-    update_button = gr.update(interactive=True)
-    return update_button
-
-with gr.Blocks(title="IndexTTS Demo") as demo:
-    mutex = threading.Lock()
-    gr.HTML('''
-    <h2><center>IndexTTS2: A Breakthrough in Emotionally Expressive and Duration-Controlled Auto-Regressive Zero-Shot Text-to-Speech</h2>
-<p align="center">
-<a href='https://arxiv.org/abs/2506.21619'><img src='https://img.shields.io/badge/ArXiv-2506.21619-red'></a>
-</p>
-    ''')
-
-    with gr.Tab(i18n("音频生成")):
-        with gr.Row():
-            os.makedirs("prompts",exist_ok=True)
-            prompt_audio = gr.Audio(label=i18n("音色参考音频"),key="prompt_audio",
-                                    sources=["upload","microphone"],type="filepath")
-            prompt_list = os.listdir("prompts")
-            default = ''
-            if prompt_list:
-                default = prompt_list[0]
-            with gr.Column():
-                input_text_single = gr.TextArea(label=i18n("文本"),key="input_text_single", placeholder=i18n("请输入目标文本"), info=f"{i18n('当前模型版本')}{tts.model_version or '1.0'}")
-                gen_button = gr.Button(i18n("生成语音"), key="gen_button",interactive=True)
-            output_audio = gr.Audio(label=i18n("生成结果"), visible=True,key="output_audio")
-        experimental_checkbox = gr.Checkbox(label=i18n("显示实验功能"),value=False)
-        with gr.Accordion(i18n("功能设置")):
-            # 情感控制选项部分
-            with gr.Row():
-                emo_control_method = gr.Radio(
-                    choices=EMO_CHOICES_BASE,
-                    type="index",
-                    value=EMO_CHOICES_BASE[0],label=i18n("情感控制方式"))
-        # 情感参考音频部分
-        with gr.Group(visible=False) as emotion_reference_group:
-            with gr.Row():
-                emo_upload = gr.Audio(label=i18n("上传情感参考音频"), type="filepath")
-
-        # 情感随机采样
-        with gr.Row(visible=False) as emotion_randomize_group:
-            emo_random = gr.Checkbox(label=i18n("情感随机采样"), value=False)
-
-        # 情感向量控制部分
-        with gr.Group(visible=False) as emotion_vector_group:
-            with gr.Row():
-                with gr.Column():
-                    vec1 = gr.Slider(label=i18n("喜"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                    vec2 = gr.Slider(label=i18n("怒"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                    vec3 = gr.Slider(label=i18n("哀"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                    vec4 = gr.Slider(label=i18n("惧"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                with gr.Column():
-                    vec5 = gr.Slider(label=i18n("厌恶"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                    vec6 = gr.Slider(label=i18n("低落"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                    vec7 = gr.Slider(label=i18n("惊喜"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-                    vec8 = gr.Slider(label=i18n("平静"), minimum=0.0, maximum=1.0, value=0.0, step=0.05)
-
-        with gr.Group(visible=False) as emo_text_group:
-            with gr.Row():
-                emo_text = gr.Textbox(label=i18n("情感描述文本"),
-                                      placeholder=i18n("请输入情绪描述（或留空以自动使用目标文本作为情绪描述）"),
-                                      value="",
-                                      info=i18n("例如：委屈巴巴、危险在悄悄逼近"))
-
-
-        with gr.Row(visible=False) as emo_weight_group:
-            emo_weight = gr.Slider(label=i18n("情感权重"), minimum=0.0, maximum=1.0, value=0.8, step=0.01)
-
-        with gr.Accordion(i18n("高级生成参数设置"), open=False,visible=False) as advanced_settings_group:
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown(f"**{i18n('GPT2 采样设置')}** _{i18n('参数会影响音频多样性和生成速度详见')} [Generation strategies](https://huggingface.co/docs/transformers/main/en/generation_strategies)._")
-                    with gr.Row():
-                        do_sample = gr.Checkbox(label="do_sample", value=True, info=i18n("是否进行采样"))
-                        temperature = gr.Slider(label="temperature", minimum=0.1, maximum=2.0, value=0.8, step=0.1)
-                    with gr.Row():
-                        top_p = gr.Slider(label="top_p", minimum=0.0, maximum=1.0, value=0.8, step=0.01)
-                        top_k = gr.Slider(label="top_k", minimum=0, maximum=100, value=30, step=1)
-                        num_beams = gr.Slider(label="num_beams", value=3, minimum=1, maximum=10, step=1)
-                    with gr.Row():
-                        repetition_penalty = gr.Number(label="repetition_penalty", precision=None, value=10.0, minimum=0.1, maximum=20.0, step=0.1)
-                        length_penalty = gr.Number(label="length_penalty", precision=None, value=0.0, minimum=-2.0, maximum=2.0, step=0.1)
-                    max_mel_tokens = gr.Slider(label="max_mel_tokens", value=1500, minimum=50, maximum=tts.cfg.gpt.max_mel_tokens, step=10, info=i18n("生成Token最大数量，过小导致音频被截断"), key="max_mel_tokens")
-                    # with gr.Row():
-                    #     typical_sampling = gr.Checkbox(label="typical_sampling", value=False, info="不建议使用")
-                    #     typical_mass = gr.Slider(label="typical_mass", value=0.9, minimum=0.0, maximum=1.0, step=0.1)
-                with gr.Column(scale=2):
-                    gr.Markdown(f'**{i18n("分句设置")}** _{i18n("参数会影响音频质量和生成速度")}_')
-                    with gr.Row():
-                        initial_value = max(20, min(tts.cfg.gpt.max_text_tokens, cmd_args.gui_seg_tokens))
-                        max_text_tokens_per_segment = gr.Slider(
-                            label=i18n("分句最大Token数"), value=initial_value, minimum=20, maximum=tts.cfg.gpt.max_text_tokens, step=2, key="max_text_tokens_per_segment",
-                            info=i18n("建议80~200之间，值越大，分句越长；值越小，分句越碎；过小过大都可能导致音频质量不高"),
-                        )
-                    with gr.Accordion(i18n("预览分句结果"), open=True) as segments_settings:
-                        segments_preview = gr.Dataframe(
-                            headers=[i18n("序号"), i18n("分句内容"), i18n("Token数")],
-                            key="segments_preview",
-                            wrap=True,
-                        )
-            advanced_params = [
-                do_sample, top_p, top_k, temperature,
-                length_penalty, num_beams, repetition_penalty, max_mel_tokens,
-                # typical_sampling, typical_mass,
-            ]
-        
-        if len(example_cases) > 2:
-            example_table = gr.Examples(
-                examples=example_cases[:-2],
-                examples_per_page=20,
-                inputs=[prompt_audio,
-                        emo_control_method,
-                        input_text_single,
-                        emo_upload,
-                        emo_weight,
-                        emo_text,
-                        vec1,vec2,vec3,vec4,vec5,vec6,vec7,vec8,experimental_checkbox]
-            )
-        elif len(example_cases) > 0:
-            example_table = gr.Examples(
-                examples=example_cases,
-                examples_per_page=20,
-                inputs=[prompt_audio,
-                        emo_control_method,
-                        input_text_single,
-                        emo_upload,
-                        emo_weight,
-                        emo_text,
-                        vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, experimental_checkbox]
-            )
-
-    def on_input_text_change(text, max_text_tokens_per_segment):
-        if text and len(text) > 0:
-            text_tokens_list = tts.tokenizer.tokenize(text)
-
-            segments = tts.tokenizer.split_segments(text_tokens_list, max_text_tokens_per_segment=int(max_text_tokens_per_segment))
-            data = []
-            for i, s in enumerate(segments):
-                segment_str = ''.join(s)
-                tokens_count = len(s)
-                data.append([i, segment_str, tokens_count])
-            return {
-                segments_preview: gr.update(value=data, visible=True, type="array"),
-            }
-        else:
-            df = pd.DataFrame([], columns=[i18n("序号"), i18n("分句内容"), i18n("Token数")])
-            return {
-                segments_preview: gr.update(value=df),
-            }
-
-    def on_method_select(emo_control_method):
-        if emo_control_method == 1:  # emotion reference audio
-            return (gr.update(visible=True),
-                    gr.update(visible=False),
-                    gr.update(visible=False),
-                    gr.update(visible=False),
-                    gr.update(visible=True)
-                    )
-        elif emo_control_method == 2:  # emotion vectors
-            return (gr.update(visible=False),
-                    gr.update(visible=True),
-                    gr.update(visible=True),
-                    gr.update(visible=False),
-                    gr.update(visible=False)
-                    )
-        elif emo_control_method == 3:  # emotion text description
-            return (gr.update(visible=False),
-                    gr.update(visible=True),
-                    gr.update(visible=False),
-                    gr.update(visible=True),
-                    gr.update(visible=True)
-                    )
-        else:  # 0: same as speaker voice
-            return (gr.update(visible=False),
-                    gr.update(visible=False),
-                    gr.update(visible=False),
-                    gr.update(visible=False),
-                    gr.update(visible=False)
-                    )
-
-    def on_experimental_change(is_exp):
-        # 切换情感控制选项
-        # 第三个返回值实际没有起作用
-        if is_exp:
-            return gr.update(choices=EMO_CHOICES_EXPERIMENTAL, value=EMO_CHOICES_EXPERIMENTAL[0]), gr.update(visible=True),gr.update(value=example_cases)
-        else:
-            return gr.update(choices=EMO_CHOICES_BASE, value=EMO_CHOICES_BASE[0]), gr.update(visible=False),gr.update(value=example_cases[:-2])
-
-    emo_control_method.select(on_method_select,
-        inputs=[emo_control_method],
-        outputs=[emotion_reference_group,
-                 emotion_randomize_group,
-                 emotion_vector_group,
-                 emo_text_group,
-                 emo_weight_group]
-    )
-
-    input_text_single.change(
-        on_input_text_change,
-        inputs=[input_text_single, max_text_tokens_per_segment],
-        outputs=[segments_preview]
-    )
-
-    experimental_checkbox.change(
-        on_experimental_change,
-        inputs=[experimental_checkbox],
-        outputs=[emo_control_method, advanced_settings_group,example_table.dataset]  # 高级参数Accordion
-    )
-
-    max_text_tokens_per_segment.change(
-        on_input_text_change,
-        inputs=[input_text_single, max_text_tokens_per_segment],
-        outputs=[segments_preview]
-    )
-
-    prompt_audio.upload(update_prompt_audio,
-                         inputs=[],
-                         outputs=[gen_button])
-
-    gen_button.click(gen_single,
-                     inputs=[emo_control_method,prompt_audio, input_text_single, emo_upload, emo_weight,
-                            vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8,
-                             emo_text,emo_random,
-                             max_text_tokens_per_segment,
-                             *advanced_params,
-                     ],
-                     outputs=[output_audio])
-
-
-
-if __name__ == "__main__":
-    demo.queue(20)
-    demo.launch(server_name=cmd_args.host, server_port=cmd_args.port)