Pipeline Media Blocks : fonctionnalités principales¶

using VisioForge.Core.MediaBlocks;

// Créer une instance de pipeline standard
var pipeline = new MediaBlocksPipeline();

// Optionnellement, vous pouvez attribuer un nom à votre pipeline pour faciliter son identification
pipeline.Name = "MainVideoPlayer";

// S'abonner aux événements d'erreur pour capturer et gérer les exceptions
pipeline.OnError += (sender, args) =>
{
    // Journaliser le message d'erreur
    Debug.WriteLine($"Erreur du pipeline : {args.Message}");

    // Mettre en œuvre une récupération d'erreur appropriée selon le message
    if (args.Message.Contains("Access denied"))
    {
        // Gérer les problèmes de permissions
    }
    else if (args.Message.Contains("File not found"))
    {
        // Gérer les erreurs de fichier manquant
    }
};

// Obtenir la durée totale du média (renvoie TimeSpan.Zero pour les flux en direct)
var duration = await pipeline.DurationAsync();
Console.WriteLine($"Durée du média : {duration.TotalSeconds} secondes");

// Obtenir la position de lecture courante
var position = await pipeline.Position_GetAsync();
Console.WriteLine($"Position actuelle : {position.TotalSeconds} secondes");

// Recherche basique à une position temporelle spécifique
await pipeline.Position_SetAsync(TimeSpan.FromSeconds(10));

// Recherche alignée sur une image clé pour une navigation plus efficace
await pipeline.Position_SetAsync(TimeSpan.FromMinutes(2), seekToKeyframe: true);

// Relire la position courante (par ex. pour une barre de progression)
var current = await pipeline.Position_GetAsync();

// Démarrer la lecture immédiatement
await pipeline.StartAsync();

// Précharger le média sans démarrer la lecture (utile pour réduire le délai au démarrage)
await pipeline.StartAsync(onlyPreload: true);
await pipeline.ResumeAsync(); // Démarrer le pipeline préchargé quand vous êtes prêt

// Vérifier l'état actuel du pipeline
var state = pipeline.State;
if (state == PlaybackState.Play)
{
    Console.WriteLine("Le pipeline est en cours de lecture");
}

// S'abonner aux événements importants de changement d'état
pipeline.OnStart += (sender, args) =>
{
    Console.WriteLine("La lecture du pipeline a démarré");
    UpdateUIForPlaybackState();
};

pipeline.OnStop += (sender, args) =>
{
    Console.WriteLine("La lecture du pipeline est arrêtée");
    Console.WriteLine($"Arrêté à la position : {args.Position.TotalSeconds} secondes");
    ResetPlaybackControls();
};

pipeline.OnPause += (sender, args) =>
{
    Console.WriteLine("La lecture du pipeline est en pause");
    UpdatePauseButtonState();
};

pipeline.OnResume += (sender, args) =>
{
    Console.WriteLine("La lecture du pipeline a repris");
    UpdatePlayButtonState();
};

// Mettre en pause la lecture courante
await pipeline.PauseAsync();

// Reprendre la lecture depuis l'état de pause
await pipeline.ResumeAsync();

// Opération d'arrêt standard
await pipeline.StopAsync();

// Arrêt forcé dans les scénarios sensibles au temps (peut affecter l'intégrité du fichier de sortie)
await pipeline.StopAsync(force: true);

// Connexion basique entre deux blocs
pipeline.Connect(block1.Output, block2.Input);

// Connecter des blocs avec des types de médias spécifiques
pipeline.Connect(videoSource.GetOutputPadByType(MediaBlockPadMediaType.Video), 
                 videoEncoder.GetInputPadByType(MediaBlockPadMediaType.Video));

// Créer un multiplexeur MP4 spécialisé pour l'enregistrement — le constructeur prend le nom de fichier de sortie (ou MP4SinkSettings)
var mp4Muxer = new MP4SinkBlock("output_recording.mp4");

// Demander une nouvelle entrée vidéo au multiplexeur
var videoInput = mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Video);

// Connecter une source vidéo à l'entrée nouvellement créée
pipeline.Connect(videoSource.Output, videoInput);

// De même pour l'audio
var audioInput = mp4Muxer.CreateNewInput(MediaBlockPadMediaType.Audio);
pipeline.Connect(audioSource.Output, audioInput);

// Modèle de libération synchrone
try
{
    // Utiliser le pipeline
}
finally
{
    pipeline.Dispose();
}

// Libération asynchrone (à privilégier pour les applications UI)
try
{
    // Utiliser le pipeline
}
finally
{
    await pipeline.DisposeAsync();
}

// Libération automatique avec l'instruction « using »
using (var pipeline = new MediaBlocksPipeline())
{
    // Configurer et utiliser le pipeline
    await pipeline.StartAsync();
    // Le pipeline sera automatiquement libéré à la sortie de ce bloc
}

// Déclaration « using » C# 8.0+
using var pipeline = new MediaBlocksPipeline();
// Le pipeline sera libéré à la sortie de la méthode englobante

// Obtenir la vitesse de lecture courante
double currentRate = await pipeline.Rate_GetAsync();

// Définir la vitesse de lecture (1.0 = vitesse normale)
await pipeline.Rate_SetAsync(0.5);  // Ralenti (demi-vitesse)
await pipeline.Rate_SetAsync(2.0);  // Vitesse double

// Activer la boucle pour une lecture continue
pipeline.Loop = true;

// Écouter les événements de boucle
pipeline.OnLoop += (sender, args) =>
{
    Console.WriteLine("Le média a bouclé au début");
    UpdateLoopCounter();
};

// Activer le mode débogage pour une journalisation plus détaillée
pipeline.Debug_Mode = true;
pipeline.Debug_Dir = Path.Combine(Environment.GetFolderPath(
    Environment.SpecialFolder.MyDocuments), "PipelineDebugLogs");