Vidéo libvlc (sur SDL_Surface) en texture OpenGL

Version imprimable

[Résolu] Vidéo libvlc (sur SDL_Surface) en texture OpenGL

Bonjour à tous,

Je cherche à afficher une texture vidéo sur un carré OpenGL. Je veux utiliser libvlc pour lire un maximum de formats.
J'ai trouvé ce tuto pour lire une vidéo sur un SDL_Surface : http://wiki.videolan.org/LibVLC_SampleCode_SDL
Ce dernier fonctionne plutôt bien.

Maintenant j'essaie juste d'intégrer un Quad OpenGL là-dedans et d'utiliser la vidéo comme texture mais le seul résultat que j'obtiens est un carré blanc sur fond noir. :/

Voici mon code :

Code:

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
#include <stdio.h>
#include <stdint.h>
#include <math.h>
#include <stdlib.h>
 
#include <SDL/SDL.h>
#include <SDL/SDL_mutex.h>
#include <GL/glu.h>
 
#include <vlc/vlc.h>
 
#define WIDTH 640
#define HEIGHT 480
#define VIDEO_FILE "/home/user/path/movie.avi"
 
 
struct ctx {
	SDL_Surface *surf;
	SDL_mutex *mutex;
};
 
static void catchEx (libvlc_exception_t *ex) {
	if(libvlc_exception_raised(ex)) {
		fprintf(stderr, "Exception libvlc : %s\n", libvlc_exception_get_message(ex));
		exit(EXIT_FAILURE);
	}
	libvlc_exception_clear(ex);
}
 
static void lock(struct ctx *ctx, void **pp_ret) {
	SDL_LockMutex(ctx->mutex);
	SDL_LockSurface(ctx->surf);
	*pp_ret = ctx->surf->pixels;
}
 
static void unlock(struct ctx *ctx) {
	SDL_UnlockSurface(ctx->surf);
	SDL_UnlockMutex(ctx->mutex);
}
 
 
 
int main(int argc, char *argv[])
{
    char clock[64], cunlock[64], cdata[64];
    char width[32], height[32], pitch[32];
    libvlc_exception_t ex;
    libvlc_instance_t *libvlc;
    libvlc_media_t *m;
    libvlc_media_player_t *mp;
    char const *vlc_argv[] =
    {
        "--quiet",					/* Ne rien afficher */
        "--ignore-config",			/* Pas d'utilisation des fichiers de configuration de VLC */
        "--no-osd",					/* Pas d'affichage par dessus la vidéo */
        "--noaudio",				/* Pas de son */
        "--vout", "vmem",
        "--vmem-width", width,
        "--vmem-height", height,
        "--vmem-pitch", pitch,
        "--vmem-chroma", "RV16",
        "--vmem-lock", clock,
        "--vmem-unlock", cunlock,
        "--vmem-data", cdata
    };
    int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
 
    SDL_Surface *screen;
    SDL_Event event;
    int done = 0, action = 0;
 
    struct ctx ctx;
 
    /*
     *  Initialise libSDL
     */
    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1)
    {
        printf("cannot initialize SDL\n");
        return EXIT_FAILURE;
    }
 
    ctx.surf = SDL_CreateRGBSurface(SDL_SWSURFACE, WIDTH, HEIGHT, 16, 0xf800, 0x07e0, 0x001f, 0);
 
    ctx.mutex = SDL_CreateMutex();
 
    int options = SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_OPENGL;
 
    screen = SDL_SetVideoMode(1280, 800, 0, options);
    if(!screen)
    {
        printf("cannot set video mode\n");
        return EXIT_FAILURE;
    }
 
 
 
    /* Récupérer un numéro pour une texture */
    GLuint image;
    glGenTextures(1, &image);
 
 
 
 
    /*
     *  Initialise libVLC
     */
    sprintf(clock, "%lld", (long long int)(intptr_t)lock);
    sprintf(cunlock, "%lld", (long long int)(intptr_t)unlock);
    sprintf(cdata, "%lld", (long long int)(intptr_t)&ctx);
    sprintf(width, "%i", WIDTH);
    sprintf(height, "%i", HEIGHT);
    sprintf(pitch, "%i", WIDTH * 2);
 
    libvlc_exception_init(&ex);
 
    libvlc = libvlc_new(vlc_argc, vlc_argv, &ex);
    catchEx(&ex);
 
    m = libvlc_media_new(libvlc, VIDEO_FILE, &ex);
    catchEx(&ex);
 
    mp = libvlc_media_player_new_from_media(m, &ex);
    catchEx(&ex);
 
    libvlc_media_release(m);
    libvlc_media_player_play(mp, &ex);
    catchEx(&ex);
 
    while(!done) {
        action = 0;
 
        /* Keys: enter (fullscreen), space (pause), escape (quit) */
        while( SDL_PollEvent( &event ) )
        {
            switch(event.type)
            {
            case SDL_QUIT:
                done = 1;
                break;
            case SDL_KEYDOWN:
                action = event.key.keysym.sym;
                break;
            }
        }
 
        switch(action)
        {
        case SDLK_ESCAPE:
            done = 1;
            break;
        }
 
 
        /* Blitting the surface does not prevent it from being locked and
         * written to by another thread, so we use this additional mutex. */
        SDL_LockMutex(ctx.mutex);
        //SDL_BlitSurface(ctx.surf, NULL, screen, NULL);
 
 
        /* Charger une texture */
        glBindTexture(GL_TEXTURE_2D, image);
 
        /* Générer une texture */
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ctx.surf->w, ctx.surf->h, 0, GL_RGB, GL_UNSIGNED_BYTE, ctx.surf->pixels);
 
        /* Des bon paramètres */
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
		glBegin(GL_QUADS);
			glTexCoord2d(0, 1);
			glVertex2f(0, 0.9);
			glTexCoord2d(1, 1);
			glVertex2f(0.9, 0.9);
			glTexCoord2d(1, 0);
			glVertex2f(0.9, -0.9);
			glTexCoord2d(0, 0);
			glVertex2f(0, -0.9);
		glEnd();
 
        SDL_UnlockMutex(ctx.mutex);
 
        //SDL_Flip(screen);
	glFlush();
        SDL_GL_SwapBuffers();
        SDL_Delay(10);
 
    }
 
    /*
     * Stop stream and clean up libVLC
     */
    libvlc_media_player_stop(mp, &ex);
    catchEx(&ex);
 
 
    libvlc_media_player_release(mp);
    libvlc_release(libvlc);
 
    /*
     * Close window and clean up libSDL
     */
    SDL_DestroyMutex(ctx.mutex);
    SDL_FreeSurface(ctx.surf);
 
    SDL_Quit();
 
    return 0;
}

Voilà donc si quelqu"un a une idée qui permettrait de faire fonctionner ce code, ce serait chouette.

Merci. :]

PS : Au cas où, mes libs de compilation : g++ -otest main.o -lvlc -lSDL_image -lSDL -lGL

Bonjour,

Voici un premier site à visiter: http://nehe.developpez.com/tutoriel/06-texture/

Maintenant, moi je ne sais qu'afficher une texture, et je ne sais pas le faire avec libvlc, donc je ne vais corriger que vos erreurs liés à OpenGL ( si j'y arrive )

Je pense qu'il faut faire ceci qu'une seule fois:
Code:

1 2 3 4 5 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ctx.surf->w, ctx.surf->h, 0, GL_RGB, GL_UNSIGNED_BYTE, ctx.surf->pixels); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Enfin le faire plusieurs fois ne doit pas être vraiment grave.
Sauf si les pixels change tout le temps. ( Je ne parle que pour glTexImage2D() )

Il y a au moins un:
Code:

1 2 glBind(GL_TEXTURE2D, 0);
Manquant après l'affichage ( après le glEnd() ).

Et il manque la libération de la texture
Code:

1 2 glDeleteTextures(1, &image);
Je n'ai pas vraiment d'explication pour le pourquoi cela ne s'affiche pas.
Peut être que vous devriez afficher le retour de glGetError(). ( Si différent à GL_NO_ERROR y a une erreur )

Bonjour et merci pour la réponse, :]

Mes pixels changent souvent car je lis une vidéo, d'où la nécessité de réexécuter ces instructions à chaque fois.

J'ai pas mal amélioré le code (notamment sur vos conseils). J'ai rajouté une fonction loadTexture (qui charge une texture à partir d'un SDL_Surface) et cela prend forme.

En fait voilà ce que j'obtiens : http://img208.imageshack.us/img208/7343/facei.png (en animé, bien sur). Comme vous le voyez il me reste un souci à régler : retrouver la bonne couleur pour la vidéo.

Voici mon code corrigé (jusque là) :

Code:

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
#include <stdio.h>
#include <stdint.h>
#include <math.h>
#include <stdlib.h>
 
#include <SDL/SDL.h>
#include <SDL/SDL_mutex.h>
#include <GL/glu.h>
 
#include <vlc/vlc.h>
 
#define WIDTH 1024
#define HEIGHT 768
#define VIDEO_FILE "/home/user/path/movie.avi"
 
 
struct ctx {
	SDL_Surface *surf;
	SDL_mutex *mutex;
};
 
static void catchEx (libvlc_exception_t *ex) {
	if(libvlc_exception_raised(ex)) {
		fprintf(stderr, "Exception libvlc : %s\n", libvlc_exception_get_message(ex));
		exit(EXIT_FAILURE);
	}
	libvlc_exception_clear(ex);
}
 
static void lock(struct ctx *ctx, void **pp_ret) {
	SDL_LockMutex(ctx->mutex);
	SDL_LockSurface(ctx->surf);
	*pp_ret = ctx->surf->pixels;
}
 
static void unlock(struct ctx *ctx) {
	SDL_UnlockSurface(ctx->surf);
	SDL_UnlockMutex(ctx->mutex);
}
 
 
 
int loadTexture(SDL_Surface *sdlimage) {
	GLuint retval;
	void *raw;
	int w, h, i, j, bpp;
	Uint8 *srcPixel, *dstPixel;
	Uint32 truePixel;
	GLenum errorCode;
 
	if (sdlimage->format->BytesPerPixel < 2) {
		printf("Bad image -- not true color!\n");
		SDL_FreeSurface(sdlimage);
		return 0;
	}
 
	w = sdlimage->w;
	h = sdlimage->h;
 
	raw = (void *) malloc(w * h * 4);
	dstPixel = (Uint8 *) raw;
 
	bpp = sdlimage->format->BytesPerPixel;
 
	for (i = h - 1; i >= 0; i--) {
		for (j = 0; j < w; j++) {
			srcPixel = (Uint8 *) sdlimage->pixels + i * sdlimage->pitch + j	* bpp;
			switch (bpp) {
			case 1:
				truePixel = *srcPixel;
				break;
 
			case 2:
				truePixel = *(Uint16 *) srcPixel;
				break;
 
			case 3:
				if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
					truePixel = srcPixel[0] << 16 | srcPixel[1] << 8 | srcPixel[2];
				} else {
					truePixel = srcPixel[0] | srcPixel[1] << 8 | srcPixel[2] << 16;
				}
				break;
 
			case 4:
				truePixel = *(Uint32 *) srcPixel;
				break;
 
			default:
				printf("Image bpp of %d unusable\n", bpp);
				SDL_UnlockSurface(sdlimage);
				SDL_FreeSurface(sdlimage);
				free(raw);
				return 0;
			}
 
			SDL_GetRGBA(truePixel, sdlimage->format, &(dstPixel[0]), &(dstPixel[1]), &(dstPixel[2]), &(dstPixel[3]));
			dstPixel++;
			dstPixel++;
			dstPixel++;
			dstPixel++;
		}
	}
 
	while (glGetError()) {
		;
	}
 
	glBindTexture(GL_TEXTURE_2D, retval);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
 
	errorCode = glGetError();
	if (errorCode != 0) {
		if (errorCode == GL_OUT_OF_MEMORY) {
			printf("Out of texture memory!\n");
		}
 
		glDeleteTextures(1, &retval);
		free(raw);
		return 0;
	}
 
	gluBuild2DMipmaps(GL_TEXTURE_2D, 4, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) raw);
 
	errorCode = glGetError();
	if (errorCode != 0) {
		if (errorCode == GL_OUT_OF_MEMORY) {
			printf("Out of texture memory!\n");
		}
 
		glDeleteTextures(1, &retval);
		free(raw);
		return 0;
	}
 
	return retval;
}
 
 
 
 
int main(int argc, char *argv[])
{
    char clock[64], cunlock[64], cdata[64];
    char width[32], height[32], pitch[32];
    libvlc_exception_t ex;
    libvlc_instance_t *libvlc;
    libvlc_media_t *m;
    libvlc_media_player_t *mp;
    char const *vlc_argv[] = {
        "--quiet",
        "--ignore-config",
        "--vout", "vmem",
        "--vmem-width", width,
        "--vmem-height", height,
        "--vmem-pitch", pitch,
        "--vmem-chroma", "RV32",
        "--vmem-lock", clock,
        "--vmem-unlock", cunlock,
        "--vmem-data", cdata
    };
    int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
 
    SDL_Event event;
    int done = 0, action = 0;
 
    struct ctx ctx;
 
    /*
     *  Init libSDL
     */
    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) {
        printf("cannot initialize SDL\n");
        exit(EXIT_FAILURE);
    }
 
    ctx.surf = SDL_CreateRGBSurface(SDL_SWSURFACE, WIDTH, HEIGHT, 32, 0xf800, 0x07e0, 0x001f, 0);
 
    ctx.mutex = SDL_CreateMutex();
 
    if( ! SDL_SetVideoMode(1280, 800, 0, SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_OPENGL) ) {
        printf("cannot set video mode\n");
        exit(EXIT_FAILURE);
    }
 
    glEnable(GL_TEXTURE_2D);
    GLuint image;
    glGenTextures(1, &image);
 
 
 
 
    /*
     *  Init libVLC
     */
    sprintf(clock, "%lld", (long long int)(intptr_t)lock);
    sprintf(cunlock, "%lld", (long long int)(intptr_t)unlock);
    sprintf(cdata, "%lld", (long long int)(intptr_t)&ctx);
    sprintf(width, "%i", WIDTH);
    sprintf(height, "%i", HEIGHT);
    sprintf(pitch, "%i", WIDTH * 4);
 
    libvlc_exception_init(&ex);
 
	libvlc = libvlc_new(vlc_argc, vlc_argv, &ex);
	catchEx(&ex);
 
	m = libvlc_media_new(libvlc, VIDEO_FILE, &ex);
	catchEx(&ex);
 
	mp = libvlc_media_player_new_from_media(m, &ex);
	catchEx(&ex);
 
	libvlc_media_release(m);
	libvlc_media_player_play(mp, &ex);
	catchEx(&ex);
 
    while(!done) {
        action = 0;
 
        /* Keys: enter (fullscreen), space (pause), escape (quit) */
        while( SDL_PollEvent( &event ) ) {
            switch(event.type)
            {
            case SDL_QUIT:
                done = 1;
                break;
            case SDL_KEYDOWN:
                action = event.key.keysym.sym;
                break;
            }
        }
 
        switch(action) {
        case SDLK_ESCAPE:
            done = 1;
            break;
        }
 
 
 
		glClear(GL_COLOR_BUFFER_BIT);
 
        /* Blitting the surface does not prevent it from being locked and
         * written to by another thread, so we use this additional mutex. */
        SDL_LockMutex(ctx.mutex);
        image = loadTexture(ctx.surf);
        SDL_UnlockMutex(ctx.mutex);
 
		glBegin(GL_QUADS);
			glTexCoord2d(0, 1);
			glVertex2f(0, 0.9);
			glTexCoord2d(1, 1);
			glVertex2f(0.9, 0.9);
			glTexCoord2d(1, 0);
			glVertex2f(0.9, -0.9);
			glTexCoord2d(0, 0);
			glVertex2f(0, -0.9);
		glEnd();
 
		glFlush();
        SDL_GL_SwapBuffers();
        SDL_Delay(10);
 
    }
 
    glDeleteTextures(1, &image);
 
 
    /*
     * Stop stream and clean up libVLC
     */
    libvlc_media_player_stop(mp, &ex);
    catchEx(&ex);
 
 
    libvlc_media_player_release(mp);
    libvlc_release(libvlc);
 
    /*
     * Close window and clean up libSDL
     */
    SDL_DestroyMutex(ctx.mutex);
    SDL_FreeSurface(ctx.surf);
 
    SDL_Quit();
 
    exit(EXIT_SUCCESS);
}

Quelque chose qui peut peut-être mettre sur la piste :
Lorsque je change le chroma à RV16 j'obtiens ceci : http://img406.imageshack.us/img406/885/halfface.png
Là l'image est correcte mais la texture ne s'affiche que sur la moitié gauche de mon carré.

Toujours pareil : si vous avez une idée de l'endroit d'où peut provenir ce bug, merci de me l'indiquer. :)

Bon week-end. \o/

08/05/2010, 00h36
LittleWhite
HUm, je peux dire, qu'il peut y avoir un problème avec cette ligne:
Code:

1 2 gluBuild2DMipmaps(GL_TEXTURE_2D, 4, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) raw);
Il faut faire coincider les couleurs de la video avec celle que vous dites à OpenGL de lire.
Il y a aussi des extensions OpenGL pour supporter plus de format. Donc c'est une piste possible.

Je n'ai pas compris ou vous avez changé le code, pour avoir une meilleure image ( la half face )

( Et finalement, l'image finale, me dit quelque chose :s , ou est je pu voir ça, un tutoriel ? )

Pour avoir la "half face" je change le code au niveau de cet endroit :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 char const *vlc_argv[] = { "--quiet", "--ignore-config", "--vout", "vmem", "--vmem-width", width, "--vmem-height", height, "--vmem-pitch", pitch, "--vmem-chroma", "RV32", "--vmem-lock", clock, "--vmem-unlock", cunlock, "--vmem-data", cdata };
En fait, il s'agit des options que l'on passe à libvlc pour la lecture de la vidéo. Lorsque l'option "--vmem-chroma" est à "RV32" j'obtiens l'image : http://img208.imageshack.us/img208/7343/facei.png
Et lorsque l'option "--vmem-chroma" est à "RV16" j'obtiens la "half face" : http://img406.imageshack.us/img406/885/halfface.png
Le "chroma" m'a incité à penser que cela trouvait son origine dans la couleur.

L'image en question est issue du tutoriel de Nehe (http://nehe.gamedev.net/lesson.asp?index=07 - lesson 35) pour la lecture de fichiers AVI en texture. Nehe utilise cependant la library Avifile (http://avifile.sourceforge.net/) alors que je veux le faire avec libvlc (bien évidemment pour lire un maximum de formats nativement).

Quoiqu'il en soit j'ai trouvé! :D Tout l'art consistait à harmoniser les paramètres de profondeur de couleurs.

J'ai donc changé les lignes suivantes et cela fonctionne :
1)

Code:

"--vmem-chroma", "RV32",

en

Code:

"--vmem-chroma", "RV16",

2)

Code:

ctx.surf = SDL_CreateRGBSurface(SDL_SWSURFACE, WIDTH, HEIGHT, 32, 0xf800, 0x07e0, 0x001f, 0);

en

Code:

ctx.surf = SDL_CreateRGBSurface(SDL_SWSURFACE, WIDTH, HEIGHT, 16, 0xf800, 0x07e0, 0x001f, 0);

3)

Code:

sprintf(pitch, "%i", WIDTH * 4);

en

Code:

sprintf(pitch, "%i", WIDTH * 2);

Merci pour l'aide et au plaisir.