Eric Coissac
6f8a80a58a
Cette mise à jour refactorise les nœuds audio pour utiliser la méthode `boxed()` lors de l'enregistrement des enfants, améliorant ainsi la cohérence et la lisibilité du code. Les méthodes `make()` sont ajoutées pour faciliter la création d'instances boxées des nœuds, et les exemples sont mis à jour en conséquence.
114 lines
3.9 KiB
Rust
Executable File
114 lines
3.9 KiB
Rust
Executable File
//! Convertisseur de fichiers audio vers FLAC 24-bit
|
|
//!
|
|
//! Ce programme démontre l'utilisation de la chaîne :
|
|
//! 1. FileSource - Lecture d'un fichier audio (FLAC, MP3, OGG, WAV, AIFF)
|
|
//! 2. ToI24Node - Conversion vers 24-bit signed integer
|
|
//! 3. FlacFileSink - Écriture au format FLAC
|
|
//!
|
|
//! La nouvelle architecture AudioPipelineNode permet de :
|
|
//! - Construire le pipeline en enregistrant des enfants avec register()
|
|
//! - Insérer des nœuds de conversion de type pour garantir la profondeur de bit souhaitée
|
|
//! - Lancer tout le pipeline avec un seul appel à run() sur la racine
|
|
//! - Arrêter proprement tout le pipeline avec un CancellationToken
|
|
//!
|
|
//! Usage:
|
|
//! cargo run --example convert_to_flac24 -- <input_file> <output_file>
|
|
//!
|
|
//! Exemple:
|
|
//! cargo run --example convert_to_flac24 -- input.mp3 output.flac
|
|
//! cargo run --example convert_to_flac24 -- input16bit.flac output24bit.flac
|
|
|
|
use pmoaudio::{AudioPipelineNode, FileSource, FlacFileSink, ToI24Node};
|
|
use std::env;
|
|
use tokio_util::sync::CancellationToken;
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Initialiser tracing pour le debug
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
|
|
.init();
|
|
|
|
// Récupérer les arguments
|
|
let args: Vec<String> = env::args().collect();
|
|
if args.len() != 3 {
|
|
eprintln!("Usage: {} <input_file> <output_file>", args[0]);
|
|
eprintln!();
|
|
eprintln!("Converts any audio file to FLAC with 24-bit depth.");
|
|
eprintln!();
|
|
eprintln!("Supported input formats:");
|
|
eprintln!(" - FLAC (8/16/24/32-bit)");
|
|
eprintln!(" - MP3");
|
|
eprintln!(" - OGG Vorbis");
|
|
eprintln!(" - WAV");
|
|
eprintln!(" - AIFF");
|
|
eprintln!();
|
|
eprintln!("Example:");
|
|
eprintln!(" {} input.mp3 output.flac", args[0]);
|
|
eprintln!(" {} input16bit.flac output24bit.flac", args[0]);
|
|
std::process::exit(1);
|
|
}
|
|
|
|
let input_path = &args[1];
|
|
let output_path = &args[2];
|
|
|
|
println!("=== Audio to FLAC 24-bit Converter ===");
|
|
println!();
|
|
println!("Input: {}", input_path);
|
|
println!("Output: {}", output_path);
|
|
println!();
|
|
println!("Pipeline: FileSource → ToI24Node → FlacFileSink");
|
|
println!();
|
|
|
|
// Créer le pipeline: FileSource → ToI24Node → FlacFileSink
|
|
let mut source = FileSource::new(input_path);
|
|
|
|
// Le ToI24Node convertit tous les chunks audio en 24-bit
|
|
// Cela garantit que le FlacFileSink encodera en 24-bit
|
|
let mut converter = ToI24Node::new();
|
|
|
|
let sink = FlacFileSink::new(output_path);
|
|
|
|
// Construire la chaîne: source → converter → sink
|
|
converter.register(sink.boxed());
|
|
source.register(converter.boxed());
|
|
|
|
// Créer un token d'arrêt pour contrôle manuel si besoin
|
|
let stop_token = CancellationToken::new();
|
|
|
|
// Lancer tout le pipeline - run() spawne automatiquement tous les enfants
|
|
println!("Processing...");
|
|
let start = std::time::Instant::now();
|
|
|
|
let result = Box::new(source).run(stop_token).await;
|
|
|
|
let elapsed = start.elapsed();
|
|
|
|
// Vérifier le résultat
|
|
match result {
|
|
Ok(()) => {
|
|
println!();
|
|
println!(
|
|
"✓ Conversion completed successfully in {:.2}s",
|
|
elapsed.as_secs_f64()
|
|
);
|
|
println!(" Output file: {}", output_path);
|
|
println!();
|
|
|
|
// Afficher des informations supplémentaires si possible
|
|
if let Ok(metadata) = std::fs::metadata(output_path) {
|
|
let size_mb = metadata.len() as f64 / (1024.0 * 1024.0);
|
|
println!(" File size: {:.2} MB", size_mb);
|
|
}
|
|
}
|
|
Err(e) => {
|
|
eprintln!();
|
|
eprintln!("✗ Conversion error: {}", e);
|
|
eprintln!();
|
|
return Err(e.into());
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|