Synchronisation de la fréquence d'images C ++ OpenCV VideoWriter

Je pense connaître la raison des vidéos de résultats à lecture rapide.

Dans le constructeur cv::VideoWriter videoWriter(path, fourcc, 30, size); vous définissez la fréquence d'images (FPS) de la vidéo résultante à 30. Cela signifie que la bibliothèque de CV attend exactement 30 images à write() par la fonction write() pour chaque seconde de flux vidéo résultant.

Aussi pour la bibliothèque de CV, il n'y a aucune différence à quelle vitesse vous appelez write() avec un nouveau cadre, vous pouvez l'appeler 5 fois par seconde ou 10 ou même 1000 fois. La seule chose qui compte, c'est que vous devez fournir exactement 30 images pour chaque seconde de vidéo, et la vitesse à laquelle vous fournissez ces 30 images n'a pas d'importance.

Je veux dire que toutes vos fonctionnalités de sleep(...) n'ont pas d'importance pour la classe CV VideoWriter. Et c'est toujours vrai pour toutes les bibliothèques de rendu / conversion vidéo. Donc, suspendre le thread ne change rien du tout.

Mais dans votre cas, vous dites que vous récupérez 10 images par seconde à partir des données vidéo en temps réel de la carte vidéo de votre grabber. Cela signifie que votre FPS est en réalité de 10 images par seconde. Donc, pour résoudre correctement votre tâche, les étapes suivantes doivent être effectuées:

1. Supprimez toutes les fonctionnalités de mise en pause, comme appeler sleep() . Ce n'est pas du tout nécessaire. Et ne change pas le comportement de VideoWriter.
2. Ensuite, la première façon de résoudre la tâche est de modifier votre constructeur cv::VideoWriter videoWriter(path, fourcc, 30, size); valeur 30 à 10. Cela résoudra déjà votre tâche, mais vous devez être sûr de saisir 10 images par seconde, pas plus ni moins. Ensuite, votre vidéo sera une vidéo correctement lue (vitesse correcte) avec une fréquence d'images de 10 images par seconde. C'est la solution la plus simple. La vidéo n'a pas besoin d'être à 30 FPS pour être lue correctement plus tard, la vidéo 10 FPS sera correctement lue plus tard par n'importe quel lecteur.
3. Une autre solution, si vous voulez vraiment que votre vidéo résultante joue 30 images par seconde, pas moins, pas plus, alors dupliquez chaque image de votre vidéo capturée trois fois, ainsi vous obtiendrez 30 images sur 10 images de votre vidéo capturée. Par duplication, je veux simplement dire que vous devez appeler videWriter.write(...) trois fois (dans une petite boucle) avec la même image unique, appelez cette write sans aucune pause (comme sleep ). Ensuite, votre vidéo résultante aura exactement 30 images par seconde.

Je pense que vous n'avez pas compris comment fonctionne CV::VideoWriter . Vous pensiez que write() rendait la vidéo résultante en temps réel, ce qui signifie que si vous la nourrissez de 10 images mais exactement en une seconde, la vitesse de la vidéo devrait être correcte. Mais cet auteur ne rend pas la vidéo en temps réel, ce qui signifie qu'il suppose simplement que 10 images passées ne constituent que 1/3 de seconde des vidéos résultantes, par conséquent, il s'attend à ce que 30 images soient écrites pendant 1 seconde résultante.

J'ai compris mon problème et c'était moi, pas OpenCV. En raison de l'environnement multithreading, j'écrivais les images (cv :: Mat) dans une file d'attente. Puisqu'il y a beaucoup de transformations YUV -> RGB -> BGR -> Crop etc. Je m'attendais à ce que l'objet cv :: Mat que j'ai mis dans la file d'attente soit une copie profonde. Au lieu de cela, le cv :: Mat était toujours le même objet. Ce qui signifie que même s'il y avait déjà 20 entrées cv :: Mat dans ma file d'attente, elles étaient toutes identiques et toutes "changées" chaque fois qu'il y avait une nouvelle image.

Si vous avez une caméra qui n'est pas en mesure de fournir une fréquence d'images constante de disons 30 images, vous pouvez également envisager de limiter la fréquence d'images vous-même à 25 par exemple et mesurer le temps écoulé depuis l'écriture de la dernière image. Vous pouvez également modifier votre fréquence d'images par des valeurs arbitraires, tant que la caméra est en mesure de la fournir. Un exemple d'implémentation:

m_fps = 25;
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point now;

while (1) {

    now = std::chrono::steady_clock::now();
    long duration = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start).count();
    
    if ((double)duration > (1e9 / m_fps)) {

        start = std::chrono::steady_clock::now();
        
        m_duration += duration;

        // Capture frame-by-frame
        if(m_cap->grab()) { m_cap->retrieve(m_frame); }

        // write frame
        m_writer->write(m_frame);
        cv::waitKey(1);

    }
}