Capture vidéo vers MPEG-TS en C# et .NET : guide complet¶

// Instance de la classe pour le moteur de capture vidéo
VideoCaptureCoreX videoCapture;

private async Task StartCaptureAsync()
{
    // Initialiser le SDK VisioForge
    await VisioForgeX.InitSDKAsync();

    // Créer l'instance VideoCaptureCoreX et l'associer au contrôle UI VideoView
    videoCapture = new VideoCaptureCoreX(videoView: VideoView1);

    // Obtenir la liste des périphériques de capture vidéo disponibles
    var videoSources = await DeviceEnumerator.Shared.VideoSourcesAsync();

    // Initialiser les paramètres de la source vidéo
    VideoCaptureDeviceSourceSettings videoSourceSettings = null;

    // Obtenir le premier périphérique de capture vidéo disponible
    var videoDevice = videoSources[0];

    // Tenter d'obtenir les capacités HD de résolution et de fréquence d'images depuis le périphérique
    var videoFormat = videoDevice.GetHDVideoFormatAndFrameRate(out VideoFrameRate frameRate);
    if (videoFormat != null)
    {
        // Configurer la source vidéo avec le format HD
        videoSourceSettings = new VideoCaptureDeviceSourceSettings(videoDevice)
        {
            Format = videoFormat.ToFormat()
        };

        // Définir la fréquence d'images de capture
        videoSourceSettings.Format.FrameRate = frameRate;
    }

    // Configurer le périphérique de capture vidéo avec les paramètres
    videoCapture.Video_Source = videoSourceSettings;

    // Configurer la capture audio (microphone)

    // Initialiser les paramètres de la source audio
    IVideoCaptureBaseAudioSourceSettings audioSourceSettings = null;

    // Obtenir les périphériques de capture audio disponibles via l'API DirectSound
    var audioApi = AudioCaptureDeviceAPI.DirectSound;
    var audioDevices = await DeviceEnumerator.Shared.AudioSourcesAsync(audioApi);

    // Obtenir le premier périphérique de capture audio disponible
    var audioDevice = audioDevices[0];
    if (audioDevice != null)
    {
        // Obtenir le format audio par défaut pris en charge par le périphérique
        var audioFormat = audioDevice.GetDefaultFormat();
        if (audioFormat != null)
        {
            // Configurer la source audio avec le format par défaut
            audioSourceSettings = audioDevice.CreateSourceSettingsVC(audioFormat);
        }
    }

    // Configurer le périphérique de capture audio avec les paramètres
    videoCapture.Audio_Source = audioSourceSettings;

    // Configurer le périphérique de lecture audio
    // Obtenir le premier périphérique de sortie audio disponible
    var audioOutputDevice = (await DeviceEnumerator.Shared.AudioOutputsAsync())[0];

    // Configurer le moteur de rendu audio pour la lecture via le périphérique sélectionné
    videoCapture.Audio_OutputDevice = new AudioRendererSettings(audioOutputDevice);

    // Activer la surveillance et l'enregistrement audio
    videoCapture.Audio_Play = true;    // Activer la surveillance audio en temps réel
    videoCapture.Audio_Record = true;   // Activer l'enregistrement audio vers le fichier de sortie

    // Configurer la sortie MPEG Transport Stream
    var mpegtsOutput = new MPEGTSOutput("output.ts");

    // Configurer l'encodeur vidéo avec accélération matérielle si disponible
    if (NVENCH264EncoderSettings.IsAvailable())
    {
        // Utiliser l'encodeur matériel NVIDIA
        mpegtsOutput.Video = new NVENCH264EncoderSettings();
    }
    else if (QSVH264EncoderSettings.IsAvailable())
    {
        // Utiliser l'encodeur matériel Intel Quick Sync
        mpegtsOutput.Video = new QSVH264EncoderSettings();
    }
    else if (AMFH264EncoderSettings.IsAvailable())
    {
        // Utiliser l'encodeur matériel AMD
        mpegtsOutput.Video = new AMFH264EncoderSettings();
    }
    else
    {
        // Repli vers l'encodeur logiciel
        mpegtsOutput.Video = new OpenH264EncoderSettings();
    }

    // Configurer l'encodeur audio pour la sortie MPEG-TS
    // mpegtsOutput.Audio = ...

    // Ajouter la sortie MPEG-TS au pipeline de capture
    // autostart: true signifie que la sortie démarre automatiquement avec la capture
    videoCapture.Outputs_Add(mpegtsOutput, autostart: true);

    // Démarrer le processus de capture
    await videoCapture.StartAsync();
}

private async Task StopCaptureAsync()
{
    // Arrêter toute la capture et l'encodage
    await videoCapture.StopAsync();

    // Nettoyer les ressources
    await videoCapture.DisposeAsync();
}

// Instance du pipeline
MediaBlocksPipeline pipeline;

private async Task StartCaptureAsync()
{
    // Initialiser le SDK
    await VisioForgeX.InitSDKAsync();

    // Créer une nouvelle instance du pipeline
    pipeline = new MediaBlocksPipeline();

    // Obtenir le premier périphérique vidéo disponible et configurer le format HD
    var device = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
    var formatItem = device.GetHDVideoFormatAndFrameRate(out VideoFrameRate frameRate);
    var videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
    {
        Format = formatItem.ToFormat()
    };
    videoSourceSettings.Format.FrameRate = frameRate;

    // Créer le bloc source vidéo avec les paramètres configurés
    var videoSource = new SystemVideoSourceBlock(videoSourceSettings);

    // Obtenir le premier périphérique audio disponible et configurer le format par défaut
    var audioDevice = (await DeviceEnumerator.Shared.AudioSourcesAsync())[0];
    var audioFormat = audioDevice.GetDefaultFormat();
    var audioSourceSettings = audioDevice.CreateSourceSettings(audioFormat);
    var audioSource = new SystemAudioSourceBlock(audioSourceSettings);

    // Créer le bloc de rendu vidéo et le connecter au contrôle UI VideoView
    var videoRenderer = new VideoRendererBlock(pipeline, videoView: VideoView1) { IsSync = false };

    // Créer le bloc de rendu audio pour la lecture
    var audioRenderer = new AudioRendererBlock() { IsSync = false };

    // Note : IsSync est false pour maximiser les performances d'encodage

    // Créer les tees vidéo et audio
    var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);
    var audioTee = new TeeBlock(2, MediaBlockPadMediaType.Audio);

    // Créer le multiplexeur MPEG-TS
    var muxer = new MPEGTSSinkBlock(new MPEGTSSinkSettings("output.ts"));

    // Créer les encodeurs vidéo et audio avec accélération matérielle si disponible
    var videoEncoder = new H264EncoderBlock();
    var audioEncoder = new AACEncoderBlock();

    // Connecter les blocs de traitement vidéo :
    // Source -> Tee -> Renderer (aperçu) et Encoder -> Muxer
    pipeline.Connect(videoSource.Output, videoTee.Input);
    pipeline.Connect(videoTee.Outputs[0], videoRenderer.Input);
    pipeline.Connect(videoTee.Outputs[1], videoEncoder.Input);
    pipeline.Connect(videoEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video));

    // Connecter les blocs de traitement audio :
    // Source -> Tee -> Renderer (lecture) et Encoder -> Muxer
    pipeline.Connect(audioSource.Output, audioTee.Input);
    pipeline.Connect(audioTee.Outputs[0], audioRenderer.Input);
    pipeline.Connect(audioTee.Outputs[1], audioEncoder.Input);
    pipeline.Connect(audioEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio));

    // Démarrer le traitement du pipeline
    await pipeline.StartAsync();
}

private async Task StopCaptureAsync()
{
    // Arrêter tout le traitement du pipeline
    await pipeline.StopAsync();

    // Nettoyer les ressources
    await pipeline.DisposeAsync();
    pipeline = null;
}

using VisioForge.Core.Types.X.Sinks;

// Créer les paramètres de découpe pour des segments de 5 minutes
var mpegtsOutput = new MPEGTSOutput("recording_%05d.ts", useAAC: true);
mpegtsOutput.Sink = new MPEGTSSplitSinkSettings("recording_%05d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(5),  // Nouveau fichier toutes les 5 minutes
    SplitMaxFiles = 12,  // Ne conserver que les 12 derniers fichiers (1 heure au total)
    M2TSMode = false
};

// Ajouter au pipeline de capture
videoCapture.Outputs_Add(mpegtsOutput, autostart: true);

using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.MediaBlocks.Sinks;

// Créer le multiplexeur MPEG-TS avec les paramètres de découpe
var splitSettings = new MPEGTSSplitSinkSettings("output_%05d.ts")
{
    SplitDuration = TimeSpan.FromMinutes(10),  // Découper toutes les 10 minutes
    SplitFileSize = 100 * 1024 * 1024,  // Ou lorsque le fichier atteint 100 Mo
    SplitMaxFiles = 6,  // Conserver les 6 derniers fichiers
    StartIndex = 0
};

var muxer = new MPEGTSSinkBlock(splitSettings);

// Connecter les encodeurs vidéo et audio au multiplexeur
pipeline.Connect(videoEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoder.Output, (muxer as IMediaBlockDynamicInputs).CreateNewInput(MediaBlockPadMediaType.Audio));