Encodeurs H264¶

Video Capture SDK .Net Video Edit SDK .Net Media Blocks SDK .Net

VideoCaptureCoreX VideoEditCoreX MediaBlocksPipeline

Ce document fournit des informations détaillées sur les encodeurs H264 disponibles, leurs fonctionnalités, options de contrôle de débit et exemples d'utilisation.

Pour les moteurs Windows uniquement, consultez la page sortie MP4.

Vue d'ensemble¶

Les encodeurs H264 suivants sont disponibles :

Encodeur AMD AMF H264 (accéléré par GPU)
Encodeur NVIDIA NVENC H264 (accéléré par GPU)
Encodeur Intel QSV H264 (accéléré par GPU)
Encodeur OpenH264 (logiciel)
Encodeur Apple Media H264 (accéléré matériellement pour les appareils Apple)
Encodeur VAAPI H264 (accélération matérielle Linux)
Encodeur matériel Android H264 (MediaCodec, sélectionne automatiquement le meilleur encodeur du SoC)

Encodeur AMD AMF H264¶

L'Advanced Media Framework (AMF) d'AMD fournit un encodage accéléré par le matériel sur les GPU AMD.

Caractéristiques clés¶

Encodage accéléré par le matériel
Plusieurs options de préréglages (Balanced, Speed, Quality)
Taille de GOP configurable
Prise en charge du codage entropique CABAC
Diverses méthodes de contrôle de débit

Options de contrôle de débit¶

public enum AMFH264EncoderRateControl
{
    Default = -1,     // Par défaut, dépend de l'usage
    CQP = 0,         // QP constant
    CBR = 1,         // Débit constant
    VBR = 2,         // VBR contraint par crête
    LCVBR = 3        // VBR contraint par latence
}

Exemple d'utilisation¶

var settings = new AMFH264EncoderSettings
{
    Bitrate = 5000,              // 5 Mbps
    CABAC = true,
    RateControl = AMFH264EncoderRateControl.CBR,
    Preset = AMFH264EncoderPreset.Quality,
    Profile = AMFH264EncoderProfile.Main,
    Level = AMFH264EncoderLevel.Level4_2,
    GOPSize = 30
};

var encoder = new H264EncoderBlock(settings);

Encodeur NVIDIA NVENC H264¶

L'encodeur vidéo basé sur le matériel de NVIDIA fournit un encodage H264 efficace sur les GPU NVIDIA.

Caractéristiques clés¶

Encodage accéléré par le matériel
Prise en charge des B-frames
Quantification adaptative
Images de référence multiples
Prédiction pondérée
Prise en charge du look-ahead

Options de contrôle de débit¶

Héritées de NVENCBaseEncoderSettings avec des options supplémentaires spécifiques à H264 :

Débit constant (CBR)
Débit variable (VBR)
QP constant (CQP)
VBR basé sur la qualité

Exemple d'utilisation¶

var settings = new NVENCH264EncoderSettings
{
    Bitrate = 5000,
    MaxBitrate = 8000,
    RCLookahead = 20,
    BFrames = 2,
    Profile = NVENCH264Profile.High,
    Level = NVENCH264Level.Level4_2,
    TemporalAQ = true
};

var encoder = new H264EncoderBlock(settings);

Encodeur Intel Quick Sync Video (QSV) H264¶

Encodeur vidéo matériel d'Intel disponible sur les processeurs Intel avec graphiques intégrés.

Caractéristiques clés¶

Encodage accéléré par le matériel
Mode basse latence
Multiples méthodes de contrôle de débit
Prise en charge des B-frames
Options de contrôle de débit intelligent

Options de contrôle de débit¶

public enum QSVH264EncRateControl
{
    CBR = 1,         // Débit constant
    VBR = 2,         // Débit variable
    CQP = 3,         // Quantificateur constant
    AVBR = 4,        // VBR moyen
    LA_VBR = 8,      // VBR avec look-ahead
    ICQ = 9,         // CQP intelligent
    VCM = 10,        // Mode visioconférence
    LA_ICQ = 11,     // ICQ avec look-ahead
    LA_HRD = 13,     // LA conforme HRD
    QVBR = 14        // VBR défini par la qualité
}

Exemple d'utilisation¶

var settings = new QSVH264EncoderSettings
{
    Bitrate = 5000,
    MaxBitrate = 8000,
    RateControl = QSVH264EncRateControl.VBR,
    Profile = QSVH264EncProfile.High,
    Level = QSVH264EncLevel.Level4_2,
    LowLatency = true,
    BFrames = 2
};

var encoder = new H264EncoderBlock(settings);

Encodeur OpenH264¶

Encodeur H264 logiciel open source de Cisco.

Caractéristiques clés¶

Encodage logiciel
Plusieurs niveaux de complexité
Détection de changement de scène
Quantification adaptative
Prise en charge du débruitage

Options de contrôle de débit¶

public enum OpenH264RCMode
{
    Quality = 0,     // Mode qualité
    Bitrate = 1,     // Mode débit
    Buffer = 2,      // Basé sur le tampon
    Off = -1         // Contrôle de débit désactivé
}

Exemple d'utilisation¶

var settings = new OpenH264EncoderSettings
{
    Bitrate = 5000,
    RateControl = OpenH264RCMode.Bitrate,
    Profile = OpenH264Profile.Main,
    Level = OpenH264Level.Level4_2,
    Complexity = OpenH264Complexity.Medium,
    EnableDenoise = true,
    SceneChangeDetection = true
};

var encoder = new H264EncoderBlock(settings);

Encodeur Apple Media H264¶

Encodeur accéléré par le matériel pour les plateformes Apple.

Caractéristiques clés¶

Accélération matérielle sur les appareils Apple
Prise en charge de l'encodage en temps réel
Options de réordonnancement d'images
Encodage basé sur la qualité

Exemple d'utilisation¶

var settings = new AppleMediaH264EncoderSettings
{
    Bitrate = 5000,
    AllowFrameReordering = true,
    Quality = 0.8,
    Realtime = true
};

var encoder = new H264EncoderBlock(settings);

Encodeur VAAPI H264¶

Encodeur Video Acceleration API pour les systèmes Linux.

Caractéristiques clés¶

Accélération matérielle sur Linux
Prise en charge de plusieurs profils
Quantification Trellis
Prise en charge des B-frames
Diverses méthodes de contrôle de débit

Options de contrôle de débit¶

public enum VAAPIH264RateControl
{
    CQP = 1,                 // QP constant
    CBR = 2,                 // Débit constant
    VBR = 4,                 // Débit variable
    VBRConstrained = 5,      // VBR contraint
    ICQ = 7,                 // CQP intelligent
    QVBR = 8                 // VBR défini par la qualité
}

Exemple d'utilisation¶

var settings = new VAAPIH264EncoderSettings
{
    Bitrate = 5000,
    RateControl = VAAPIH264RateControl.CBR,
    Profile = VAAPIH264EncoderProfile.Main,
    MaxBFrames = 2,
    Trellis = true,
    CABAC = true
};

var encoder = new H264EncoderBlock(settings);

Encodeur matériel Android H264¶

Sur Android (API 21+), utilisez AndroidH264EncoderSettings. Il encapsule l'API Android MediaCodec via la famille d'éléments amcvidenc-* de GStreamer, en détectant automatiquement le meilleur encodeur matériel sur l'appareil (Qualcomm, Exynos, MediaTek, etc.) — ainsi, une seule classe de paramètres couvre tous les SoC Android.

Exemple d'utilisation¶

// La compilation est exclusivement Android (ce type est gardé par le préprocesseur __ANDROID__).
var settings = new AndroidH264EncoderSettings
{
    Bitrate = 8_000,                           // kbit/s (donc 8000 = 8 Mbps)
    IFrameInterval = TimeSpan.FromSeconds(2),  // Cadence des images-clés
    ParseStream = true,                        // Laissez true sauf si vous injectez des images brutes dans SRT
};

// Optionnel : épingler un nom d'élément encodeur spécifique, contournant l'auto-détection.
// settings.CodecName = "amcvidenc-c2qtiavcencoder";  // Chemin Qualcomm Codec2, par exemple

var encoder = new H264EncoderBlock(settings);

Caractéristiques clés¶

Une seule classe de paramètres pour tous les SoC Android — pas de types par fournisseur
Bitrate en kbit/s (l'élément GStreamer reçoit des bits/sec en interne)
IFrameInterval est un TimeSpan — sur Android 25+, les fractions de seconde fonctionnent (i-frame-interval-float) ; les versions plus anciennes tronquent aux secondes entières
CodecName remplace l'auto-détection lorsque vous savez quel élément amcvidenc-* vous voulez

Sac de propriétés¶

Seuls CustomH264EncoderSettings et AndroidH264EncoderSettings exposent un dictionnaire Properties pour transmettre les propriétés brutes des éléments GStreamer qui n'ont pas d'enveloppe C# de première classe. Les implémentations standard (OpenH264, NVENCH264, QSVH264, AMFH264, AppleMediaH264, VAAPIH264) n'en exposent pas — leurs options de réglage sont exposées en tant que propriétés C# typées sur la classe de paramètres.

// Paramètres Custom ou Android uniquement
var settings = new CustomH264EncoderSettings("x264enc");
settings.Properties["bitrate-mode"] = "constant";
settings.Properties["complexity"] = "max";

Bonnes pratiques¶

Sélection de l'encodeur
Utilisez les encodeurs matériels (AMD, NVIDIA, Intel) lorsqu'ils sont disponibles pour de meilleures performances
Repliez-vous sur OpenH264 lorsque l'encodage matériel n'est pas disponible
Utilisez les encodeurs spécifiques aux plateformes (Apple Media, VAAPI, matériel Android) lorsque vous ciblez des plateformes spécifiques
Sélection du contrôle de débit
Utilisez CBR pour les applications de streaming où un débit constant est important
Utilisez VBR pour l'encodage hors-ligne où la qualité est plus importante que la cohérence du débit
Utilisez CQP pour la plus haute qualité lorsque le débit n'est pas une préoccupation
Envisagez d'utiliser les options look-ahead pour une meilleure qualité lorsque la latence n'est pas critique
Optimisation des performances
Ajustez la taille de GOP selon le type de contenu (plus petite pour beaucoup de mouvement, plus grande pour du contenu statique)
Activez CABAC pour une meilleure efficacité de compression lorsque la latence n'est pas critique
Utilisez un profil et un niveau appropriés aux appareils cibles
Envisagez les B-frames pour une meilleure compression, mais soyez conscient de l'impact sur la latence
Détection de plateforme — utilisez la méthode statique IsAvailable() sur chaque classe de paramètres pour choisir un encodeur concret à l'exécution :

if (NVENCH264EncoderSettings.IsAvailable())
{
    encoder = new H264EncoderBlock(new NVENCH264EncoderSettings { Bitrate = 6_000 });
}
else if (QSVH264EncoderSettings.IsAvailable())
{
    encoder = new H264EncoderBlock(new QSVH264EncoderSettings { Bitrate = 6_000 });
}
else if (AMFH264EncoderSettings.IsAvailable())
{
    encoder = new H264EncoderBlock(new AMFH264EncoderSettings { Bitrate = 6_000 });
}
else
{
    // Solution de repli logicielle
    encoder = new H264EncoderBlock(new OpenH264EncoderSettings { Bitrate = 6_000 });
}