reecriture decoder flac en stream

pmoaudiocache/examples/test_flac_debug.rs

@@ -0,0 +1,43 @@
+use pmoaudiocache::cache;
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::DEBUG)
+        .init();
+
+    let cache_dir = "/tmp/test_audio_cache_debug";
+    std::fs::create_dir_all(cache_dir)?;
+
+    println!("Creating cache in: {}", cache_dir);
+
+    let cache = Arc::new(cache::new_cache(cache_dir, 100)?);
+
+    // URL MP3 de test - petit fichier
+    let test_url = "https://fr.getsamplefiles.com/download/mp3/sample-3.mp3";
+
+    println!("\nDownloading: {}", test_url);
+    let pk = cache::add_with_metadata_extraction(&cache, test_url, Some("test")).await?;
+
+    println!("\nPK: {}", pk);
+    let file_path = cache.file_path(&pk);
+    println!("File path: {}", file_path.display());
+
+    // Vérifier le format
+    let data = std::fs::read(&file_path)?;
+    if data.len() >= 4 {
+        let header = &data[0..4];
+        if header == b"fLaC" {
+            println!("✓ File is FLAC!");
+        } else if header[0..3] == *b"ID3" || (header.len() >= 2 && header[0] == 0xFF && (header[1] & 0xE0) == 0xE0) {
+            println!("✗ File is still MP3!");
+            println!("   Header: {:02X} {:02X} {:02X} {:02X}", header[0], header[1], header[2], header[3]);
+        } else {
+            println!("? Unknown format");
+            println!("   Header: {:02X} {:02X} {:02X} {:02X}", header[0], header[1], header[2], header[3]);
+        }
+    }
+
+    Ok(())
+}

pmoaudiocache/examples/test_streaming_flac.rs

@@ -0,0 +1,69 @@
+//! Exemple de test pour la conversion FLAC en streaming
+//!
+//! Cet exemple télécharge un fichier audio depuis une URL et le convertit
+//! en FLAC en utilisant la fonction create_flac_transformer().
+
+use pmoaudiocache::cache;
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Initialiser le logger
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .init();
+
+    // Créer un répertoire temporaire pour le cache
+    let cache_dir = "/tmp/test_audio_cache";
+    std::fs::create_dir_all(cache_dir)?;
+
+    println!("Création du cache audio avec conversion FLAC streaming...");
+    let cache = Arc::new(cache::new_cache(cache_dir, 100)?);
+
+    // URL de test - fichier audio de test public
+    // Note: Remplacez par une URL valide de votre choix
+    let test_url = "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3";
+
+    println!("Téléchargement et conversion de: {}", test_url);
+    println!("Ceci va télécharger le fichier en streaming et le convertir en FLAC...");
+
+    // Ajouter le fichier au cache avec conversion FLAC
+    match cache::add_with_metadata_extraction(&cache, test_url, Some("test:streaming")).await {
+        Ok(pk) => {
+            println!("✓ Fichier converti avec succès!");
+            println!("  Clé primaire: {}", pk);
+
+            let file_path = cache.file_path(&pk);
+            println!("  Chemin: {}", file_path.display());
+
+            if let Ok(metadata) = std::fs::metadata(&file_path) {
+                println!("  Taille: {} bytes", metadata.len());
+            }
+
+            // Récupérer les métadonnées audio
+            match cache::get_metadata(&cache, &pk) {
+                Ok(metadata) => {
+                    println!("  Métadonnées:");
+                    if let Some(title) = &metadata.title {
+                        println!("    Titre: {}", title);
+                    }
+                    if let Some(artist) = &metadata.artist {
+                        println!("    Artiste: {}", artist);
+                    }
+                    if let Some(duration) = metadata.duration_secs {
+                        println!("    Durée: {}s", duration);
+                    }
+                }
+                Err(e) => println!("  Impossible de lire les métadonnées: {}", e),
+            }
+        }
+        Err(e) => {
+            eprintln!("✗ Erreur lors de la conversion: {}", e);
+            return Err(e);
+        }
+    }
+
+    println!("\nTest terminé avec succès!");
+
+    Ok(())
+}