Bonjour à tous,

J'ai une application OpenGL que je veux diffuser en "streaming".
Par exemple j'ai ce petit programme OpenGL :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <SDL/SDL.h>
#include <GL/glew.h>
 
int main(int argc, char **argv) {
 
	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD);
	SDL_SetVideoMode(800, 600, 16, SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_OPENGL | SDL_FULLSCREEN);
 
	bool running = true;
	SDL_Event event;
	int rightColor = 0;
	int leftColor = 0;
 
	while (running) {
 
		// Events
		while (SDL_PollEvent(&event)) {
			switch (event.type) {
			case SDL_QUIT:
				running = false;
				break;
			case SDL_KEYDOWN:
				switch (event.key.keysym.sym) {
				case SDLK_ESCAPE:
					running = false;
					break;
				}
			}
		}
 
		// Quad
		glClear(GL_COLOR_BUFFER_BIT);
		glBegin(GL_QUADS);
			glColor3ub(0, 0, leftColor);
			glVertex2d(-0.75, -0.75);
			glVertex2d(-0.75, 0.75);
			glColor3ub(rightColor, 0, 0);
			glVertex2d(0.75, 0.75);
			glVertex2d(0.75, -0.75);
		glEnd();
 
		glFlush();
		SDL_GL_SwapBuffers();
 
		rightColor = 1+(int)((float)rand()/32767*254);
		leftColor = 1+(int)((float)rand()/32767*254);
 
        SDL_Delay(800);
	}
 
	SDL_Quit();
	return 0;
}
Il affiche juste un rectangle qui change de couleur.

D'un autre côté j'ai un programme qui utilise VLC (LibVLC plus exactement) pour lire une vidéo.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>
#include <stdlib.h>
#include <vlc/vlc.h>
#include <unistd.h>
 
static void quit_on_exception(libvlc_exception_t *excp) {
	if (libvlc_exception_raised(excp)) {
		fprintf(stderr, "error: %s\n", libvlc_exception_get_message(excp));
		exit(EXIT_FAILURE);
	}
}
 
int main(int argc, char **argv) {
	libvlc_exception_t excp;
	libvlc_instance_t *inst;
	libvlc_media_t *media; // Media à traiter
	libvlc_media_player_t *mediaPlayer; // "Media player" LibVLC
	char *filename = "/home/test/Bureau/out.ogv";
 
	// LibVLC Init
	libvlc_exception_init(&excp);
	inst = libvlc_new(argc, argv, &excp);
	quit_on_exception(&excp);
	media = libvlc_media_new(inst, filename, &excp);
	quit_on_exception(&excp);
	mediaPlayer = libvlc_media_player_new_from_media(media, &excp);
	quit_on_exception(&excp);
	libvlc_media_release(media);
 
	// Now playing
	libvlc_media_player_play(mediaPlayer, &excp);
	quit_on_exception(&excp);
 
	usleep(10000000);
 
	// Stop the movie
	libvlc_media_player_stop(mediaPlayer, &excp);
	quit_on_exception(&excp);
 
	libvlc_media_player_release(mediaPlayer);
	libvlc_release(inst);
 
	return 0;
 
}
J'ai pour obligation d'utiliser cette lib car je veux également pouvoir lire des vidéos de différents formats (ça j'y arrive, d'ailleurs le programme fonctionne).

Ma question est donc : comment modifier ces deux programmes pour les faire communiquer ? Concrètement je veux pouvoir rediriger l'animation OpenGL sous la forme d'un flux vidéo et lire ce flux à l'aide du second programme.

Après plusieurs heures de recherches j'ai vu que certains parlaient d'utiliser glReadPixels(). Cela permettrait de stocker en mémoire les pixels du buffer (pour ensuite les transférer vers VLC) maintenant je n'en sais pas plus.
Je précise qu'une solution exclusivement locale (i.e. sur un même PC, mais conservant cette architecture en 2 programmes distincts) me conviendrait tout à fait.

Merci d'avance pour tout commentaire/réponse/idée même vaseuse/figue molle/insulte/... et bonne journée.