Référence de l'interface de l'encodeur H.264¶

using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// Interface de configuration de l'encodeur H.264/AVC (Advanced Video Coding).
    /// Fournit un controle complet des parametres d'encodage H.264, dont
    /// le controle de debit, les profils/niveaux, la structure GOP et les modes de controle de debit.
    /// </summary>
    [ComImport]
    [Guid("09FA2EA3-4773-41a8-90DC-9499D4061E9F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IH264Encoder
    {
        /// <summary>
        /// Obtient le debit binaire cible pour l'encodage.
        /// </summary>
        /// <param name="plValue">Recoit le debit en bits par seconde (bps)</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_Bitrate([Out] out int plValue);

        /// <summary>
        /// Definit le debit binaire cible pour l'encodage.
        /// </summary>
        /// <param name="lValue">Debit en bits par seconde (bps). Plage typique : 500 000 a 50 000 000</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_Bitrate([In] int lValue);

        /// <summary>
        /// Obtient le mode de controle de debit.
        /// </summary>
        /// <param name="pValue">Recoit le mode de controle de debit (0=CBR, 1=VBR)</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_RateControl([Out] out int pValue);

        /// <summary>
        /// Definit le mode de controle de debit.
        /// </summary>
        /// <param name="value">Mode de controle : 0 = CBR (debit constant), 1 = VBR (debit variable)</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_RateControl([In] int value);

        /// <summary>
        /// Obtient le mode d'encodage de macroblocs.
        /// </summary>
        /// <param name="pValue">Recoit le mode d'encodage MB</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_MbEncoding([Out] out int pValue);

        /// <summary>
        /// Definit le mode d'encodage de macroblocs (affecte la complexite et la qualite d'encodage).
        /// </summary>
        /// <param name="value">Valeur du mode d'encodage MB</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_MbEncoding([In] int value);

        /// <summary>
        /// Obtient l'etat d'activation du GOP (Group of Pictures).
        /// </summary>
        /// <param name="pValue">Recoit true si GOP est active, false sinon</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_GOP([Out] [MarshalAs(UnmanagedType.Bool)] out bool pValue);

        /// <summary>
        /// Active ou desactive la structure GOP (Group of Pictures).
        /// </summary>
        /// <param name="value">True pour activer GOP, false pour desactiver (toutes images I)</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_GOP([In] [MarshalAs(UnmanagedType.Bool)] bool value);

        /// <summary>
        /// Obtient l'etat de l'ajustement automatique du debit.
        /// </summary>
        /// <param name="pValue">Recoit true si le debit auto est active, false sinon</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_AutoBitrate([Out] [MarshalAs(UnmanagedType.Bool)] out bool pValue);

        /// <summary>
        /// Active ou desactive l'ajustement automatique du debit.
        /// Lorsqu'il est active, l'encodeur ajuste automatiquement le debit selon la complexite du contenu.
        /// </summary>
        /// <param name="value">True pour activer le debit auto, false pour un debit fixe</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_AutoBitrate([In] [MarshalAs(UnmanagedType.Bool)] bool value);

        /// <summary>
        /// Obtient le profil H.264.
        /// </summary>
        /// <param name="pValue">Recoit la valeur du profil</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_Profile([Out] out int pValue);

        /// <summary>
        /// Definit le profil H.264 (Baseline, Main, High, etc.).
        /// </summary>
        /// <param name="value">Valeur du profil : 66=Baseline, 77=Main, 100=High</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_Profile([In] int value);

        /// <summary>
        /// Obtient le niveau H.264.
        /// </summary>
        /// <param name="pValue">Recoit la valeur du niveau</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_Level([Out] out int pValue);

        /// <summary>
        /// Definit le niveau H.264 (contraint la resolution, le debit et la frequence d'images).
        /// </summary>
        /// <param name="value">Valeur du niveau : 10=Level 1.0, 11=Level 1.1, ..., 51=Level 5.1</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_Level([In] int value);

        /// <summary>
        /// Obtient le mode d'usage (compromis qualite/vitesse).
        /// </summary>
        /// <param name="pValue">Recoit la valeur du mode d'usage</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_Usage([Out] out int pValue);

        /// <summary>
        /// Definit le mode d'usage pour optimiser qualite vs vitesse.
        /// </summary>
        /// <param name="value">Mode : 0=Qualite, 1=Equilibre, 2=Vitesse</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_Usage([In] int value);

        /// <summary>
        /// Obtient le mode de timing sequentiel.
        /// </summary>
        /// <param name="pValue">Recoit la valeur du timing sequentiel</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_SequentialTiming([Out] out int pValue);

        /// <summary>
        /// Definit le mode de timing sequentiel pour le traitement des images.
        /// </summary>
        /// <param name="value">Valeur du mode de timing sequentiel</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_SequentialTiming([In] int value);

        /// <summary>
        /// Obtient les intervalles de slices pour les images IDR et P.
        /// </summary>
        /// <param name="piIDR">Recoit l'intervalle des images IDR</param>
        /// <param name="piP">Recoit l'intervalle des images P</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_SliceIntervals([Out] out int piIDR, [Out] out int piP);

        /// <summary>
        /// Definit les intervalles de slices pour les images IDR (Instantaneous Decoder Refresh) et P.
        /// Les images IDR sont des images-cles completes, les images P sont des images predites.
        /// </summary>
        /// <param name="piIDR">Intervalle des images IDR (toutes les N images). Typique : 30-300</param>
        /// <param name="piP">Intervalle des images P. Typique : 1-3</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_SliceIntervals([In] ref int piIDR, [In] ref int piP);

        /// <summary>
        /// Obtient le debit maximal pour l'encodage VBR.
        /// </summary>
        /// <param name="plValue">Recoit le debit maximal en bps</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_MaxBitrate([Out] out int plValue);

        /// <summary>
        /// Definit le debit maximal pour l'encodage a debit variable (VBR).
        /// Applicable uniquement lorsque le controle de debit est defini sur VBR.
        /// </summary>
        /// <param name="lValue">Debit maximal en bits par seconde (bps)</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_MaxBitrate([In] int lValue);

        /// <summary>
        /// Obtient le debit minimal pour l'encodage VBR.
        /// </summary>
        /// <param name="plValue">Recoit le debit minimal en bps</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int get_MinBitrate([Out] out int plValue);

        /// <summary>
        /// Definit le debit minimal pour l'encodage a debit variable (VBR).
        /// Applicable uniquement lorsque le controle de debit est defini sur VBR.
        /// </summary>
        /// <param name="lValue">Debit minimal en bits par seconde (bps)</param>
        /// <returns>HRESULT (0 pour reussite)</returns>
        [PreserveSig]
        int put_MinBitrate([In] int lValue);
    }
}

h264Encoder.put_RateControl(0);  // Mode CBR
h264Encoder.put_Bitrate(5000000); // 5 Mbps fixe

h264Encoder.put_RateControl(1);     // Mode VBR
h264Encoder.put_Bitrate(5000000);   // Cible 5 Mbps
h264Encoder.put_MinBitrate(3000000); // Minimum 3 Mbps
h264Encoder.put_MaxBitrate(8000000); // Maximum 8 Mbps

h264Encoder.put_Bitrate(5000000); // 5 Mbps pour 1080p

int idr = 120;  // Image-cle toutes les 120 images (4 secondes a 30 fps)
int p = 1;      // Image P toutes les images
h264Encoder.put_SliceIntervals(ref idr, ref p);

using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;

public class H264HighQualityEncoder
{
    public void ConfigureHighQuality1080p(IBaseFilter videoEncoder)
    {
        // Interroger l'interface de l'encodeur H.264
        var h264Encoder = videoEncoder as IH264Encoder;
        if (h264Encoder == null)
        {
            Console.WriteLine("Error: Filter does not support IH264Encoder");
            return;
        }

        // Parametres haute qualite 1080p
        h264Encoder.put_Profile(100);           // High Profile
        h264Encoder.put_Level(41);              // Level 4.1 (1080p @ 30 fps)
        h264Encoder.put_RateControl(1);         // Mode VBR
        h264Encoder.put_Bitrate(10000000);      // Cible 10 Mbps
        h264Encoder.put_MinBitrate(6000000);    // Minimum 6 Mbps
        h264Encoder.put_MaxBitrate(15000000);   // Maximum 15 Mbps
        h264Encoder.put_Usage(0);               // Mode qualite
        h264Encoder.put_GOP(true);              // Activer la structure GOP
        h264Encoder.put_AutoBitrate(true);      // Ajustement de debit auto

        // Definir l'intervalle d'image-cle : 120 images (4 secondes a 30 fps)
        int idr = 120;
        int p = 1;
        h264Encoder.put_SliceIntervals(ref idr, ref p);

        Console.WriteLine("H.264 encoder configured for high-quality 1080p:");
        h264Encoder.get_Bitrate(out int bitrate);
        h264Encoder.get_Profile(out int profile);
        h264Encoder.get_Level(out int level);
        Console.WriteLine($"  Bitrate: {bitrate / 1000000.0:F1} Mbps");
        Console.WriteLine($"  Profile: {profile} (High)");
        Console.WriteLine($"  Level: {level / 10.0:F1}");
    }
}

public class H264LiveStreamingEncoder
{
    public void ConfigureLiveStreaming720p(IBaseFilter videoEncoder)
    {
        var h264Encoder = videoEncoder as IH264Encoder;
        if (h264Encoder == null)
            return;

        // Parametres streaming en direct 720p
        h264Encoder.put_Profile(77);            // Main Profile (bonne compatibilite)
        h264Encoder.put_Level(31);              // Level 3.1 (720p @ 30 fps)
        h264Encoder.put_RateControl(0);         // Mode CBR pour streaming
        h264Encoder.put_Bitrate(3500000);       // 3.5 Mbps constant
        h264Encoder.put_Usage(1);               // Mode equilibre
        h264Encoder.put_GOP(true);              // Activer GOP
        h264Encoder.put_AutoBitrate(false);     // Debit fixe pour streaming

        // Faible latence : image-cle toutes les 2 secondes
        int idr = 60;  // 2 secondes a 30 fps
        int p = 1;
        h264Encoder.put_SliceIntervals(ref idr, ref p);

        Console.WriteLine("H.264 encoder configured for live streaming");
        Console.WriteLine("  720p @ 3.5 Mbps CBR");
        Console.WriteLine("  Keyframe interval: 2 seconds");
    }
}

public class H264FastRecording
{
    public void ConfigureFastRecording(IBaseFilter videoEncoder)
    {
        var h264Encoder = videoEncoder as IH264Encoder;
        if (h264Encoder == null)
            return;

        // Parametres d'enregistrement rapide
        h264Encoder.put_Profile(66);            // Baseline (encodage le plus rapide)
        h264Encoder.put_Level(40);              // Level 4.0 (1080p @ 30 fps)
        h264Encoder.put_RateControl(0);         // Mode CBR
        h264Encoder.put_Bitrate(8000000);       // 8 Mbps
        h264Encoder.put_Usage(2);               // Mode vitesse (encodage rapide)
        h264Encoder.put_GOP(true);              // Activer GOP
        h264Encoder.put_AutoBitrate(false);     // Debit fixe

        // Intervalle d'image-cle plus long pour un encodage plus rapide
        int idr = 300;  // 10 secondes a 30 fps
        int p = 1;
        h264Encoder.put_SliceIntervals(ref idr, ref p);

        Console.WriteLine("H.264 encoder configured for fast recording");
    }
}