# Projet ox_speak_rs - Structure du Code

## Structure des Modules

```
ox_speak_rs/
├── src/
│   ├── main.rs                  # Point d'entrée de l'application
│   ├── modules/                 # Modules fonctionnels
│   │   ├── mod.rs               # Exports des modules
│   │   ├── audio_processor_in.rs # Traitement audio d'entrée
│   │   ├── audio_processor_out.rs # Traitement audio de sortie
│   │   ├── audio_opus.rs        # Encodage/décodage Opus
│   │   ├── audio_stats.rs       # Statistiques audio
│   │   ├── client.rs            # Client réseau UDP
│   │   ├── client_old.rs        # Ancienne implémentation du client
│   │   ├── config.rs            # Configuration (commenté)
│   │   ├── audio_client.rs      # Client audio (vide)
│   │   └── utils.rs             # Utilitaires pour les modules (vide)
│   └── utils/                   # Utilitaires génériques
│       ├── mod.rs               # Exports des utilitaires
│       ├── real_time_event.rs   # Gestion d'événements temps réel
│       ├── ringbuf.rs           # Implémentation de buffer circulaire
│       └── ringbuf.md           # Documentation du buffer circulaire
```

## Hiérarchie des Structures

### Module Principal (main.rs)
- Initialise les composants principaux
- Configure les threads de traitement audio

### Modules Audio

#### audio_processor_in.rs
- `Microphone`
  - Gère l'accès au périphérique d'entrée audio
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `start()`: Démarre la capture audio
    - `stop()`: Arrête la capture
    - `get_config()`: Récupère la configuration
    - `change_device()`: Change le périphérique d'entrée
    - `list_available_devices()`: Liste les périphériques disponibles

- `AudioCapture`
  - Gère le processus de capture audio
  - Utilise `Microphone` pour l'accès au périphérique
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `start_capture()`: Démarre la capture
    - `is_silence()`: Détecte le silence dans un buffer

- `Subscriber`
  - Structure pour les abonnés aux événements audio

- `AudioEventBus`
  - Bus d'événements pour la distribution des données audio
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `new_with_capacity()`: Crée avec une capacité spécifiée
    - `subscribe_raw()`: S'abonne aux données brutes
    - `subscribe_encoded()`: S'abonne aux données encodées
    - `notify_raw()`: Notifie les abonnés avec données brutes
    - `notify_encoded()`: Notifie les abonnés avec données encodées

#### audio_processor_out.rs
- `Speaker`
  - Gère l'accès au périphérique de sortie audio
  - Méthodes:
    - `new()`: Crée une nouvelle instance

#### audio_opus.rs
- `AudioOpus`
  - Configuration de base pour le codec Opus
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `create_encoder()`: Crée un encodeur
    - `create_decoder()`: Crée un décodeur

- `AudioOpusEncoder`
  - Gère l'encodage audio avec Opus
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `encode()`: Encode des données audio
    - `encode_reuse()`: Encode avec réutilisation de buffer

- `AudioOpusDecoder`
  - Gère le décodage audio avec Opus
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `decode()`: Décode des données audio

#### audio_stats.rs
- `AudioBufferWithStats`
  - Buffer audio avec statistiques
  - Méthodes:
    - `new_frame()`: Crée un nouveau frame avec stats
    - `calculate_peak_rms_simd()`: Calcule pic et RMS avec SIMD
    - `now_nanos()`: Horodatage en nanosecondes

- `GlobalAudioStats`
  - Statistiques audio globales
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `get_live_stats()`: Récupère les stats en temps réel
    - `now_nanos()`: Horodatage en nanosecondes

- `LiveAudioStats`
  - Statistiques audio en temps réel
  - Méthodes:
    - `volume_bar_with_timing()`: Affiche barre de volume
    - `timing_analysis()`: Analyse de timing

### Modules Réseau

#### client.rs
- `MessageType` (enum)
  - Types de messages réseau
  - Variantes: Keepalive, Hello, Bye, Command, Status, Audio, Error

- `UdpClient`
  - Client UDP pour communication réseau
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `send()`: Envoie des données
    - `try_recv()`: Tente de recevoir des données
    - `start()`: Démarre le client
    - `stop()`: Arrête le client
    - `get_audio_sender()`: Récupère le sender audio
    - `create_audio_handle()`: Crée un handle audio

- `Client`
  - Wrapper autour de UdpClient
  - Méthodes:
    - `new()`: Crée une nouvelle instance

- `MessageCall` (enum)
  - Représente les messages sortants
  - Variantes: KeepAlive, Hello, Bye, Command, Audio, Error
  - Méthodes:
    - `serialize()`: Sérialise le message
    - Constructeurs pour chaque type de message

- `MessageEvent` (enum)
  - Représente les messages entrants
  - Variantes: Status, Audio, Error

- `AudioHandle`
  - Gère l'envoi de frames audio
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `send_audio_frame()`: Envoie un frame audio

### Utilitaires

#### real_time_event.rs
- `RealTimeEventInner`
  - Implémentation interne pour la gestion d'événements

- `RealTimeEvent`
  - API publique pour notification et attente d'événements
  - Méthodes:
    - `new()`: Crée une nouvelle instance
    - `notify()`: Notifie les listeners
    - `wait()`: Attend une notification

#### ringbuf.rs
- `RingBufWriter<T>`
  - Écrit dans un buffer circulaire
  - Méthodes:
    - `push()`: Ajoute un élément
    - `push_slice()`: Ajoute un slice d'éléments

- `RingBufReader<T>`
  - Lit depuis un buffer circulaire
  - Méthodes:
    - `pop_blocking()`: Récupère un élément (bloquant)
    - `try_pop()`: Tente de récupérer un élément

- `InnerRingBuf<T>`
  - Implémentation interne du buffer circulaire
  - Méthodes:
    - `next()`: Calcule l'index suivant

- Fonction `ringbuf<T>()`
  - Crée une paire (writer, reader) de buffer circulaire