Caméra industrielle haute vitesse avec callbacks + traitement asynchrone : Analyse approfondie du code C# Hikvision

Présentation : Dans les applications de vision industrielle à grande vitesse comme l'inspection de électrodes de batteries ou la détection de wafers semi-conducteurs, "la caméra peut atteindre 90fps, mais descend à 20fps lors de l'enregistrement" est un cauchemar fréquent pour les ingénieurs. L'architecture classique provoque facilement des pertes de frames sévères, des fuites mémoire voire des blocages système dus aux goulots d'étranglement I/O. Cet article présente une solution C# d'enregistrement d'images haute vitesse basée sur le modèle producteur-consommateur avec file circulaire, accompagnée de code pratique utilisant le SDK MVS de Hikvision, vous permettant de gérer facilement 4K@60fps en écriture continue !

一、Problématique : Pourquoi votre caméra haute vitesse perd-elle des frames ?

Dans les systèmes de vition industrielle, le flux de données images ressemble à un torrent :

• Bande passante élevée : 4K@60fps en RAW atteint 1.8GB/s ;
• Goulot d'étranglement I/O : Un SSD NVMe classique offre 3–5GB/s en écriture continue, et avec plusieurs caméras ou un traitement complexe, le disque sature instantanément ;
• Défauts d'architecture : Écrire directement dans un fichier, traiter ou transmettre sur le réseau depuis la fonction callback de la caméra bloque le thread d'acquisition, causant un débordement du buffer interne et des pertes de frames.

Inconvénients des solutions classiques : ❌ Callback écrivant directement sur disque : Thread d'acquisition bloqué par I/O, chute dramatique du fps ; ❌ File simple avec verrou : Forte contention en concurrence élevée, latence incontrôlable ; ❌ Mémoire croissante sans limite : Non-libération des buffers SDK, causant des fuites mémoire.

Solution principale : Découpler acquisition et traitement, introduire une file circulaire (Ring Buffer) comme couche intermédiaire pour réaliser un pipeline de traitement asynchrone.

二、Conception architecturale : Producteur-consommateur avec file circulaire

Nous utilisons le modèle classique producteur-consommateur combiné avec une file circulaire bornée pour construire un pipeline d'images haute performence :

Avantages principaux :

✅ Acquisition zéro blocage : Le callback caméra ne fait que copier le pointeur/données dans la file, temps en microsecondes ; ✅ Mémoire contrôlée : Capacité fixe de la file, pas d'explosion mémoire ; ✅ Débit maximalisé : Thread d'écriture dédié peut écrire en lot, compresser ou prétraiter pour exploiter pleinement les performances disque ; ✅ Sécurité des threads : Opérations atomiques et variables de condition garantissent la cohérence des données en environnement multithread.

三、Implémentation pratique C# : Enregistrement haute vitesse avec SDK MVS

Le code suivant est basé sur .NET 6+ et le SDK MVS de Hikvision (wrapper C#), démontrant le processus complet.

1. Définition de la structure de données de trame

public class TrameImage
{
    public byte[] Donnees { get; set; }      // Données brutes de l'image
    public uint Largeur { get; set; }        // Largeur
    public uint Hauteur { get; set; }        // Hauteur
    public ulong HorodatageUs { get; set; }  // Horodatage (microsecondes)
    public string IdentifiantCam { get; set; } // Identifiant caméra
}

2. Implémentation d'une file circulaire non-bolquante (version simplifiée)

Note : En C#, être complètement lock-free est difficile, ici nous utilisons ConcurrentQueue avec un sémaphore pour simuler une file bornée efficace. En production, on peut optimiser vers un RingBuffer personnalisé.

using System.Collections.Concurrent;
using System.Threading;

public class FileCirculaire<T>
{
    private readonly ConcurrentQueue<T> _file = new();
    private readonly int _capacite;
    private readonly SemaphoreSlim _pasPlein;
    private readonly SemaphoreSlim _pasVide;

    public FileCirculaire(int capacite)
    {
        _capacite = capacite;
        _pasPlein = new SemaphoreSlim(capacite, capacite);
        _pasVide = new SemaphoreSlim(0, capacite);
    }

    // Appel producteurs : mise en file bloquante
    public void Enfiler(T element)
    {
        _pasPlein.Wait();
        _file.Enfiler(element);
        _pasVide.Release();
    }

    // Appel consommateurs : retrait bloquant
    public T Defiler(CancellationToken jetonAnnulation = default)
    {
        _pasVide.Wait(jetonAnnulation);
        if (_file.TryDefiler(out var element))
        {
            _pasPlein.Release();
            return element;
        }
        throw new InvalidOperationException("État de file incohérent");
    }

    public void Vider()
    {
        while (_file.TryDefiler(out _)) { }
        _pasPlein.Release(_capacite);
        _pasVide.Reset();
    }
}

3. Service d'enregistrement haute vitesse (EnregistreurHautDebit)

using System.IO;
using System.Threading.Tasks;

public class EnregistreurHautDebit : IDisposable
{
    private readonly FileCirculaire<TrameImage> _fileCirculaire;
    private readonly CancellationTokenSource _cts;
    private Task _tacheEcriture;
    private readonly string _repertoireSortie;
    private bool _estActif;

    public EnregistreurHautDebit(string repertoireSortie, int capaciteBuffer = 20)
    {
        _repertoireSortie = repertoireSortie;
        _fileCirculaire = new FileCirculaire<TrameImage>(capaciteBuffer);
        _cts = new CancellationTokenSource();
        Directory.CreateDirectory(repertoireSortie);
    }

    // Interface producteur : appelé par le callback caméra
    public void SurNouvelleTrame(TrameImage trame)
    {
        if (_estActif)
        {
            _fileCirculaire.Enfiler(trame);
        }
    }

    public void Demarrer()
    {
        _estActif = true;
        _tacheEcriture = Task.Run(() => BoucleEcriture(_cts.Token));
    }

    public void Arreter()
    {
        _estActif = false;
        _cts.Cancel();
        _tacheEcriture?.Wait();
        _fileCirculaire.Vider();
    }

    private void BoucleEcriture(CancellationToken jeton)
    {
        try
        {
            while (!jeton.IsCancellationRequested)
            {
                var trame = _fileCirculaire.Defiler(jeton);
                EnregistrerTrame(trame);
            }
        }
        catch (OperationCanceledException) { /* Sortie normale */ }
    }

    private void EnregistrerTrame(TrameImage trame)
    {
        var nomFichier = $"trame_{trame.HorodatageUs:D19}.bin";
        var chemin = Path.Combine(_repertoireSortie, nomFichier);
        
        using var fs = new FileStream(chemin, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.SequentialScan);
        fs.Write(trame.Donnees, 0, trame.Donnees.Length);
        // Extensible : compression LZ4, conversion TIFF, métadonnées, etc.
    }

    public void Dispose()
    {
        Arreter();
        _cts.Dispose();
    }
}

4. Intégration côté acquisition caméra (SDK MVS)

Suppose que MvCameraControl.Net.dll est référencé

using Hikvision.MvCameraControl; // Espace de noms exemple

public class CaptateurHikvision : IDisposable
{
    private uint _handle;
    private readonly EnregistreurHautDebit _enregistreur;
    private bool _estActif;

    public CaptateurHikvision(string repertoireSortie, string ipAppareil)
    {
        _enregistreur = new EnregistreurHautDebit(repertoireSortie, 20);

        // Création du handle
        MV_CC_CreateHandle(& _handle, ...); 
        // Ouverture de l'appareil
        MV_CC_OpenDevice(_handle);
        // Configuration du mode de capture, etc. (abréégé)
    }

    public void Demarrer()
    {
        _enregistreur.Demarrer();
        _estActif = true;

        // Enregistrement de la fonction callback (non-bloquante)
        MV_CC_RegisterImageCallBackEx(_handle, SurTrameRecue, IntPtr.Zero);

        // Début de la capture
        MV_CC_StartGrabbing(_handle);
    }

    // Fonction callback caméra (s'exécute sur un thread non-UI)
    private void SurTrameRecue(IntPtr pDonnees, ref MV_FRAME_OUT_INFO_EX info, IntPtr pUtilisateur)
    {
        if (!_estActif) return;

        // Copie rapide des données (éviter de garder le buffer SDK trop longtemps)
        var donneesTrame = new byte[info.nFrameLen];
        Marshal.Copy(pDonnees, donneesTrame, 0, donneesTrame.Length);

        var trame = new TrameImage
        {
            Donnees = donneesTrame,
            Largeur = info.nLargeur,
            Hauteur = info.nHauteur,
            HorodatageUs = ((ulong)info.nTimeStampHigh << 32) | info.nTimeStampLow,
            IdentifiantCam = "Hikvision"
        };

        // Enfilement (completion en millisecondes)
        _enregistreur.SurNouvelleTrame(trame);

        // 【Crucial】Libérer le buffer SDK sinon fuite mémoire
        MV_CC_FreeImageBuffer(_handle, pDonnees);
    }

    public void Arreter()
    {
        _estActif = false;
        MV_CC_StopGrabbing(_handle);
        _enregistreur.Arreter();
    }

    public void Dispose()
    {
        Arreter();
        MV_CC_CloseDevice(_handle);
        MV_CC_DestroyHandle(_handle);
    }
}

四、Optimisation des performances et guide de prévention des pièges

Techniques d'optimisation avancées

1. Réutilisation du pool mémoire : Éviter les allocations fréquentes de byte[], utiliser ArrayPool<byte> ou un pool d'objets personnalisé ;
2. I/O asynchrone : Utiliser les écritures asynchrones (WriteAsync) de FileStream pour améliorer le débit ;
3. Écriture par lots : Le thread consommateur peut accumuler plusieurs trames avant d'écrire, réduisant les appels système ;
4. Préallocation disque : Créer un gros fichier à l'avance et utiliser SetEndOfFile pour éviter la fragmentation du système de fichiers.

cinq pièges mortels du SDK Hikvision

五、Comparaison des résultats pratiques (4K@60fps, RAW 12MB/trame)

Conclusion : Une architecture appropriée permet au système d'atteindre véritablement la fréquence d'images maximale de la caméra !

六、Résumé

Les règles d'or de l'enregistrement d'images haute vitesse :

"Callback uniquement pour l'enfilement, jamais toucher au disque""Préallouer la mémoire, pas de new en cours d'exécution""Thread d'écriture unique, par lots c'est plus efficace"

En utilisant le modèle producteur-consommateur et la file circulaire, nous avons réussi à découpler l'acquisition d'images et les I/O disque, résolvant non seulement le problème de perte de frames, mais实现 une solution industrielle stable en mémoire et hautement extensible.

Cette architecture s'adapte parfaitement aux caméras Hikvision, Basler ou Baumer. Il suffit de remplacer la partie des appels SDK, la logique principale reste通用 !