Discussion :

[poliok]

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.

[coda_blank]

regarde du côté de la notion de render to target en OpenGL notamment avec l'utilisation des frame buffer object : au lieu de faire ton rendu dans le back buffer (écran), tu le stockes dans une texture que tu pourras lire pixel par pixel et reproduire dans ton application vlc

j'espère m'être bien fait comprendre

au passage j'en profite pour demander à ceux qui passeraient par ici si l'on peut appliquer la même chose avec une application Qt : c'est-à-dire récupérer le rendu dans une texture et la réafficher dans une frame de l'interface Qt sans avoir une chute des performances