PBO to image/video

Bonsoir,

Comme je ne trouve pas de réponse claire à mon problème je vous pose la question:

Comment faire un film à partir d'un PBO bien rempli ?

Mon programme actuel me permet d'afficher en temps réel des points d'une équation dont les coordonnées sont calculées par CUDA avec un buffer partagée (le tout dans une fenêtre générée avec Glut). J'aimerais à terme que les informations de ce PBO soient stockées sous formes d'images que je pourrais transformer en vidéo via ffmpeg ou directement en clip vidéo avec une librairie.
Mon équation va se complexifier et prendre plus de temps à calculer, mes images arrivant de moins en moins rapidement il ne sera plus nécessaire de les afficher directement mais plutôt de les accumuler dans un clip vidéo.

Je me demande qu'elle serait la méthode la plus performante (si elle existe):

• Enregistrer directement mon buffer dans une image

• Utiliser une librairie d'imagerie pour faire un film

• Transformer le PBO en une texture et enregistrer cette texture en image

• Transformer le PBO en FBO puis l'enregistrer

• Transformer le PBO en autre chose et l'enregistrer

Le plus embetant c'est que je ne sais faire aucune de ces choses là :D Je comprends le principe mais je n'ai jamais codé en OpenGL.

De plus il faudrait que tout cela se fasse offscreen, sans affichage puisque je n'ai pas besoin de voir la même image pendant quelques secondes et que ça accélérera le processus.

Si vous avez des idées n'hésitez pas!
Merci

Bonsoir,

D'après ce que vous décrivez :

Si vous voulez que votre application crée un film, il faudra forcément extraire les données du GPU vers le CPU. Donc il faudrait cumuler :

Citation:

---

* Enregistrer directement mon buffer dans une image

---

Citation:

---

* Utiliser une librairie d'imagerie pour faire un film

---

En effet, récupérer un PBO est normalement ce qu'il a de plus rapide pour une copie d'image de GPU à CPU (je parle biensûr en termes d'accessibilité). Jettez un coup d'oeil du côté de la présentation de Song Ho Ahn : ici. Vous devrez vous penchez sur glMapBuffer et GL_PIXEL_PACK_BUFFER. Prêtez une attention particulière au "ping pong" des buffers si possible, cela devrait alléger le processus (cf "Asynchronous Read-back").

Les autres méthodes seront plus lentes, car elles reprendront le chemin ci-dessus:

Citation:

---

* Transformer le PBO en une texture et enregistrer cette texture en image

---

Citation:

---

* Transformer le PBO en FBO puis l'enregistrer

---

Cependant, le fait que vous utilisiez CUDA et que vous recherchiez des performances tendrait plutôt à utiliser les données générées et gérés uniquement par CUDA. En effet, CUDA peut utiliser le fait que le bus PCIe est bi-directionnel; malheureusement, OpenGL aura beaucoup plus de difficulté sur ce point (plafond à environ 2.8Go/s pour CUDA sur une GTX 260 contre environ 600Mo/s pour OpenGL).
Je vous conseillerai d'effectuer tout le traitement et le rapatriement des données par CUDA en laissant une copie possible vers un PBO.

Cela donnerait par exemple,

• Data (CPU) => Data1 (GPU) (CUDA)
• Kernel sur Data1 (GPU) => Data2(GPU) [et DataPBO (optionnel, pour affichage)] (CUDA)
• Data2 (GPU) => Data' (CPU) (CUDA)
• [Affichage de DataPBO, optionnel] (OpenGL)

Cordialement

Merci pour votre réponse claire et rapide.

J'ai cependant quelques interrogations:

Si je n'affiche pas les résultats je n'utilise pas OpenGL puisque je crée mon image grâce à CUDA qui sera constituée de coordonnées de points.
Mon idée était de stocker un certain nombre d'images sur la carte et générées par OpenGL afin de réduire les échanges entre GPU et CPU à chaque lancement de kernel. En effet les données qui viennent d'être calculées servent à l'itération suivante.
Une fois la mémoire de ma carte pleine je rapatrie les images et recommence.

Je ne sais pas si c'est possible et qu'elle solution est la plus rapide.

Merci encore.

Vous pouvez faire cela avec CUDA : il suffit de créer un certain nombre de tableaux de données du côté du GPU (et un seul PBO si vous voulez faire de la visualisation). Ensuite, jouez avec ces buffers comme s'ils étaient générés par OpenGL.

J'avoue que j'ai du mal à saisir votre problème...

En fait, je voudrais éviter de passer par le stockage de fichier image (coder une fonction d'enregistrement de buffer en bmp) puis de créer un film à partir de ces bmp.

Les buffers contiennent l'information dont j'ai besoin, je ne sais juste pas comment la traiter. Il faudrait que je trouve un moyen ( = une bibliothèque?) permettant de créer un film à partir des différents buffers (qu'il faudra surement traiter) que sont mes images.

Je me rends compte que ce n'est plus un problème OpenGL vu que je n'ai pas forcement besoin de l'utiliser pour ce que je veux faire.

Edit: ffmpeg semble être ma solution mais cela m'oblige à stocker mes buffers sous forme d'images

Un film n'est qu'une succession d'images indexées sur le temps, donc tu seras forcé à un moment où à un autre de passer par le stockage en format image (ce même si tu passes par un format qui fait de l'interpolation entre plusieurs images pour calculer une compression ad hoc).

J'aurais préféré ne pas le faire en deux étapes : Créations des images puis création du film alors que l'on pourrait faire une création du film au fur et a mesure que l'on crée les images.

Ca c'est largement faisable si tu prends un conteneur de type Matroska et que tu mets directement tes images avec tes index de temps dedans.