Enregistrer un flux RTSP dans un fichier : capturer la vidéo de caméra IP sans réencodage¶

using System;
using System.Threading.Tasks;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;

namespace RTSPCaptureOriginalStream
{
    /// <summary>
    /// La classe RTSPRecorder encapsule la fonctionnalité d'enregistrement RTSP pour sauvegarder un flux RTSP dans un fichier.
    /// Elle utilise le SDK MediaBlocks pour créer un pipeline qui connecte une 
    /// source RTSP (comme une caméra IP) à un puits MP4 (fichier).
    /// </summary>
    public class RTSPRecorder : IAsyncDisposable
    {
        /// <summary>
        /// Le pipeline MediaBlocks qui gère le flux de données multimédias.
        /// </summary>
        public MediaBlocksPipeline Pipeline { get; private set; }

        // Champs privés pour les composants MediaBlock
        private MediaBlock _muxer;               // Multiplexeur conteneur MP4 (puits)
        private RTSPRAWSourceBlock _rtspRawSource; // Source de flux RTSP (fournit les flux bruts)
        private DecodeBinBlock _decodeBin;       // Facultatif : décodeur audio (si réencodage audio)
        private AACEncoderBlock _audioEncoder;   // Facultatif : encodeur audio AAC (si réencodage audio)
        private bool disposedValue;              // Drapeau pour empêcher les libérations multiples

        /// <summary>
        /// Événement déclenché lorsqu'une erreur survient dans le pipeline.
        /// </summary>
        public event EventHandler<ErrorsEventArgs> OnError;

        /// <summary>
        /// Événement déclenché lorsqu'un message de statut est disponible.
        /// </summary>
        public event EventHandler<string> OnStatusMessage;

        /// <summary>
        /// Nom de fichier de sortie pour l'enregistrement MP4.
        /// </summary>
        public string Filename { get; set; } = "output.mp4";

        /// <summary>
        /// Indique s'il faut réencoder l'audio au format AAC (recommandé pour la compatibilité).
        /// Si false, l'audio est transmis tel quel.
        /// </summary>
        public bool ReencodeAudio { get; set; } = true;

        /// <summary>
        /// Démarre la session d'enregistrement en créant et configurant le pipeline MediaBlocks.
        /// </summary>
        /// <param name="rtspSettings">Paramètres de configuration de la source RTSP.</param>
        /// <returns>True si le pipeline a démarré avec succès, false sinon.</returns>
        public async Task<bool> StartAsync(RTSPRAWSourceSettings rtspSettings)
        {
            // Créer un nouveau pipeline MediaBlocks
            Pipeline = new MediaBlocksPipeline();
            Pipeline.OnError += (sender, e) => OnError?.Invoke(this, e); // Remonter les erreurs

            OnStatusMessage?.Invoke(this, "Creating pipeline to record RTSP stream...");

            // 1. Créer le bloc source RTSP.
            // RTSPRAWSourceBlock fournit des flux élémentaires bruts et non décodés (vidéo et audio) depuis votre caméra IP ou autres caméras RTSP.
            _rtspRawSource = new RTSPRAWSourceBlock(rtspSettings);

            // 2. Créer le bloc puits MP4 (multiplexeur).
            // Ce bloc écrira les flux multimédias dans un fichier MP4.
            _muxer = new MP4SinkBlock(new MP4SinkSettings(Filename));

            // 3. Connecter le flux vidéo (passthrough)
            // Créer un pad d'entrée dynamique sur le multiplexeur pour le flux vidéo.
            // Nous connectons la sortie vidéo brute de la source RTSP directement au puits MP4.
            // Cela garantit que la vidéo n'est pas réencodée lors de l'enregistrement du flux caméra.
            var inputVideoPad = (_muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video);
            Pipeline.Connect(_rtspRawSource.VideoOutput, inputVideoPad);
            OnStatusMessage?.Invoke(this, "Video stream connected (passthrough for original quality video).");

            // 4. Connecter le flux audio (réencodage facultatif)
            // Cette section gère la manière dont l'audio du flux RTSP est traité et sauvegardé dans le fichier.
            if (rtspSettings.AudioEnabled)
            {
                // Créer un pad d'entrée dynamique sur le multiplexeur pour le flux audio.
                var inputAudioPad = (_muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio);

                if (ReencodeAudio)
                {
                    // Si le réencodage audio est activé (par ex. vers AAC pour la compatibilité) :
                    OnStatusMessage?.Invoke(this, "Setting up audio re-encoding to AAC for the recording...");

                    // Créer un bloc décodeur qui ne traite que l'audio.
                    // Nous devons décoder l'audio d'origine avant de le réencoder pour enregistrer le flux MP4 avec un audio compatible.
                    _decodeBin = new DecodeBinBlock(renderVideo: false, renderAudio: true, renderSubtitle: false) 
                    {
                         // On peut désactiver le convertisseur audio interne si l'on est sûr du format 
                         // ou si l'encodeur gère la conversion. Pour AAC, c'est généralement OK.
                         DisableAudioConverter = true 
                    };

                    // Créer un encodeur AAC avec les paramètres par défaut.
                    _audioEncoder = new AACEncoderBlock(new AVENCAACEncoderSettings());

                    // Connecter le pipeline de traitement audio :
                    // sortie audio RTSP -> décodeur -> encodeur AAC -> entrée audio du puits MP4
                    Pipeline.Connect(_rtspRawSource.AudioOutput, _decodeBin.Input);
                    Pipeline.Connect(_decodeBin.AudioOutput, _audioEncoder.Input);
                    Pipeline.Connect(_audioEncoder.Output, inputAudioPad);
                    OnStatusMessage?.Invoke(this, "Audio stream connected (re-encoding to AAC for MP4 file).");
                }
                else
                {
                    // Si le réencodage audio est désactivé, connecter l'audio RTSP directement au multiplexeur.
                    // Remarque : cela peut poser problème si le format audio d'origine n'est pas 
                    // compatible avec le conteneur MP4 (par ex. G.711 PCMU/PCMA) lors de la sauvegarde du flux RTSP.
                    // Les formats compatibles courants incluent AAC. Vérifiez le format audio de votre caméra.
                    Pipeline.Connect(_rtspRawSource.AudioOutput, inputAudioPad);
                    OnStatusMessage?.Invoke(this, "Audio stream connected (passthrough). Warning: Compatibility depends on original camera audio format for the file.");
                }
            }

            // 5. Démarrer le pipeline pour enregistrer la vidéo
            OnStatusMessage?.Invoke(this, "Starting recording pipeline to save RTSP stream to file...");
            bool success = await Pipeline.StartAsync();
            if (success)
            {
                OnStatusMessage?.Invoke(this, "Recording pipeline started successfully.");
            }
            else
            {
                OnStatusMessage?.Invoke(this, "Failed to start recording pipeline.");
            }
            return success;
        }

        /// <summary>
        /// Arrête l'enregistrement en stoppant le pipeline MediaBlocks.
        /// </summary>
        /// <returns>True si le pipeline a été arrêté avec succès, false sinon.</returns>
        public async Task<bool> StopAsync()
        {
            if (Pipeline == null)
                return false;

            OnStatusMessage?.Invoke(this, "Stopping recording pipeline...");
            bool success = await Pipeline.StopAsync();
            if (success)
            {
                OnStatusMessage?.Invoke(this, "Recording pipeline stopped successfully.");
            }
            else
            {
                OnStatusMessage?.Invoke(this, "Failed to stop recording pipeline.");
            }

            // Détacher le gestionnaire d'erreurs pour éviter les problèmes si StopAsync est appelé plusieurs fois
            // ou avant DisposeAsync
            if (Pipeline != null)
            {
                 Pipeline.OnError -= OnError;
            }

            return success;
        }

        /// <summary>
        /// Libère de manière asynchrone le RTSPRecorder et toutes ses ressources.
        /// Implémente le motif IAsyncDisposable pour un nettoyage correct des ressources.
        /// </summary>
        public async ValueTask DisposeAsync()
        {
            if (!disposedValue)
            {
                if (Pipeline != null)
                {
                    Pipeline.OnError -= (sender, e) => OnError?.Invoke(this, e); // Garantir le détachement
                    await Pipeline.DisposeAsync();
                    Pipeline = null;
                }

                // Libérer tous les composants MediaBlock
                // Utilisation de « as IDisposable » pour un cast et une libération sûrs.
                (_muxer as IDisposable)?.Dispose();
                _muxer = null;

                _rtspRawSource?.Dispose();
                _rtspRawSource = null;

                _decodeBin?.Dispose();
                _decodeBin = null;

                _audioEncoder?.Dispose();
                _audioEncoder = null;

                disposedValue = true;
            }
        }
    }
}

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using VisioForge.Core; // Pour VisioForgeX.DestroySDK()
using VisioForge.Core.Types.X.Sources; // Pour RTSPRAWSourceSettings
using RTSPCaptureOriginalStream; // Espace de noms de votre classe RTSPRecorder

class Demo
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("RTSP Camera to MP4 Capture (Original Video Stream)");
        Console.WriteLine("-------------------------------------------------");

        string rtspUrl = "rtsp://your_camera_ip:554/stream_path"; // Remplacer par votre URL RTSP
        string username = "admin"; // Remplacer par votre nom d'utilisateur, ou vide si aucun
        string password = "password"; // Remplacer par votre mot de passe, ou vide si aucun
        string outputFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "rtsp_original_capture.mp4");

        Directory.CreateDirectory(Path.GetDirectoryName(outputFilePath));

        Console.WriteLine($"Capturing from: {rtspUrl}");
        Console.WriteLine($"Saving to: {outputFilePath}");
        Console.WriteLine("Press any key to stop recording...");

        var cts = new CancellationTokenSource();
        RTSPRecorder recorder = null;

        try
        {
            recorder = new RTSPRecorder
            {
                Filename = outputFilePath,
                ReencodeAudio = true // Définir à false pour transmettre l'audio (vérifier la compatibilité)
            };

            recorder.OnError += (s, e) => Console.WriteLine($"ERROR: {e.Message}");
            recorder.OnStatusMessage += (s, msg) => Console.WriteLine($"STATUS: {msg}");

            // Configurer les paramètres de la source RTSP. Le ctor est privé — utilisez la fabrique async.
            var rtspSettings = await RTSPRAWSourceSettings.CreateAsync(
                new Uri(rtspUrl), username, password, audioEnabled: true);
            // Ajustez d'autres paramètres au besoin, par ex. limiter le transport à TCP uniquement :
            // rtspSettings.AllowedProtocols = RTSPSourceProtocol.TCP;

            if (await recorder.StartAsync(rtspSettings))
            {
                Console.ReadKey(true); // Attendre une touche pour arrêter
            }
            else
            {
                Console.WriteLine("Failed to start recording. Check status messages and RTSP URL/credentials.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
        finally
        {
            if (recorder != null)
            {
                Console.WriteLine("Stopping recording...");
                await recorder.StopAsync();
                await recorder.DisposeAsync();
                Console.WriteLine("Recording stopped and resources disposed.");
            }

            // Important : nettoyer les ressources du SDK VisioForge à la sortie de l'application
            VisioForgeX.DestroySDK(); 
        }

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey(true);
    }
}