LibVLC to OpenGL texture

poliok · Postby **poliok** » 28 Oct 2010 11:02

Hello,

I'm trying to read a movie as a OpenGL texture. I worked from that code http://wiki.videolan.org/LibVLC_SampleCode_SDL and now I got this one:

Code: Select all

#include <GL/glew.h>
#include <SDL/SDL.h>
#include <vlc/vlc.h>

#define VIDEOFILE "/home/test/resfiles/hd.mov" // The movie to read

// WIDTH, HEIGHT
#define W 800
#define H 800

GLuint textureId; // Texture ID

// SDL Structure
struct sdlStructure {
	SDL_Surface *sdlSurface;
	SDL_mutex *sdlMutex;
};
struct sdlStructure sdlStruct;



// Load a texture
void loadTexture() {

	void * rawData = (void *) malloc(W * H * 4);
	Uint8 * pixelSource;
	Uint8 * pixelDestination = (Uint8 *) rawData;
	Uint32 pix;

	for (unsigned int i = H; i > 0; i--) {
		for (unsigned int j = 0; j < W; j++) {
			pixelSource = (Uint8 *) sdlStruct.sdlSurface->pixels + (i-1) * sdlStruct.sdlSurface->pitch + j * 2;
			pix = *(Uint16 *) pixelSource;
			SDL_GetRGBA(pix, sdlStruct.sdlSurface->format, &(pixelDestination[0]), &(pixelDestination[1]), &(pixelDestination[2]), &(pixelDestination[3]));
			pixelDestination += 4;
		}
	}

	// Building the texture
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glBindTexture(GL_TEXTURE_2D, textureId);
	glTexImage2D(GL_TEXTURE_2D, 0, 4, W, H, 0, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) rawData);

	free(rawData);
}

// Lock func
static void * lockfct(void *data, void **p_pixels) {
	SDL_LockMutex(sdlStruct.sdlMutex);
	SDL_LockSurface(sdlStruct.sdlSurface);
	*p_pixels = sdlStruct.sdlSurface->pixels;
	return NULL;
}

// Unlock func
static void unlockfct(void *data, void *id, void * const *p_pixels) {
	SDL_UnlockSurface(sdlStruct.sdlSurface);
	SDL_UnlockMutex(sdlStruct.sdlMutex);
}

/**
 * Entry point (main func)
 */
int main(int argc, char **argv) {

	// Init SDL + OpenGL
	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) {
		return -1;
	}
	SDL_SetVideoMode(W, H, 16, SDL_OPENGL);
	glewInit();
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);

	// Init Texture
	glGenTextures(1, &textureId);
	glBindTexture(GL_TEXTURE_2D, textureId);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// Init SDL_surface
	sdlStruct.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
	sdlStruct.sdlMutex = SDL_CreateMutex();

	// Init LibVLC + media player
	const char *vlc_argv[] = {};
	int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
	libvlc_instance_t * libVlcInstance = libvlc_new(vlc_argc, vlc_argv);
	libvlc_media_t * media = libvlc_media_new_path(libVlcInstance, VIDEOFILE);
	libvlc_media_player_t * mediaPlayer = libvlc_media_player_new_from_media(media);
	libvlc_media_release(media);
	libvlc_release(libVlcInstance);

	libvlc_video_set_callbacks(mediaPlayer, lockfct, unlockfct, NULL, &sdlStruct);
	libvlc_video_set_format(mediaPlayer, "RV16", W, H, W*2);

	// Start reading the video
	libvlc_media_player_play(mediaPlayer);
	libvlc_state_t state = libvlc_media_player_get_state(mediaPlayer);

	while ((state != libvlc_Ended) && (state != libvlc_Error)) {

		loadTexture(); // Loading the texture

		// Square
		glBegin(GL_QUADS);
			glTexCoord2d(0, 1);
			glVertex2f(-0.75, 0.75);
			glTexCoord2d(1, 1);
			glVertex2f(0.75, 0.75);
			glTexCoord2d(1, 0);
			glVertex2f(0.75, -0.75);
			glTexCoord2d(0, 0);
			glVertex2f(-0.75, -0.75);
		glEnd();

		SDL_GL_SwapBuffers();

		state = libvlc_media_player_get_state(mediaPlayer);
	}

	// Frees
	libvlc_media_player_release(mediaPlayer);
	SDL_DestroyMutex(sdlStruct.sdlMutex);
	SDL_FreeSurface(sdlStruct.sdlSurface);

	SDL_Quit();
	return 0;
}

And... It works fine !!! \o/ ( Testing: g++ -otest main.o -lvlc -lSDL_image -lSDL -lGLEW )

Now my problem:
I want to optimize everything, and move the calls of the OpenGL functions to the "unlockfct()" function. Like this:

Code: Select all

#include <GL/glew.h>
#include <SDL/SDL.h>
#include <vlc/vlc.h>

#define VIDEOFILE "/home/test/resfiles/hd.mov" // The movie to read

// WIDTH, HEIGHT
#define W 800
#define H 800

GLuint textureId; // Texture ID

// SDL Structure
struct sdlStructure {
	SDL_Surface *sdlSurface;
	SDL_mutex *sdlMutex;
};
struct sdlStructure sdlStruct;



// Load a texture
void loadTexture() {

	void * rawData = (void *) malloc(W * H * 4);
	Uint8 * pixelSource;
	Uint8 * pixelDestination = (Uint8 *) rawData;
	Uint32 pix;

	for (unsigned int i = H; i > 0; i--) {
		for (unsigned int j = 0; j < W; j++) {
			pixelSource = (Uint8 *) sdlStruct.sdlSurface->pixels + (i-1) * sdlStruct.sdlSurface->pitch + j * 2;
			pix = *(Uint16 *) pixelSource;
			SDL_GetRGBA(pix, sdlStruct.sdlSurface->format, &(pixelDestination[0]), &(pixelDestination[1]), &(pixelDestination[2]), &(pixelDestination[3]));
			pixelDestination += 4;
		}
	}

	// Building the texture
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glBindTexture(GL_TEXTURE_2D, textureId);
	glTexImage2D(GL_TEXTURE_2D, 0, 4, W, H, 0, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) rawData);

	free(rawData);
}

// Lock func
static void * lockfct(void *data, void **p_pixels) {
	SDL_LockMutex(sdlStruct.sdlMutex);
	SDL_LockSurface(sdlStruct.sdlSurface);
	*p_pixels = sdlStruct.sdlSurface->pixels;
	return NULL;
}

// Unlock func
static void unlockfct(void *data, void *id, void * const *p_pixels) {

	loadTexture(); // Loading the texture

	SDL_UnlockSurface(sdlStruct.sdlSurface);
	SDL_UnlockMutex(sdlStruct.sdlMutex);

	// Square
	glBegin(GL_QUADS);
		glTexCoord2d(0, 1);
		glVertex2f(-0.75, 0.75);
		glTexCoord2d(1, 1);
		glVertex2f(0.75, 0.75);
		glTexCoord2d(1, 0);
		glVertex2f(0.75, -0.75);
		glTexCoord2d(0, 0);
		glVertex2f(-0.75, -0.75);
	glEnd();

	SDL_GL_SwapBuffers();
}

/**
 * Entry point (main func)
 */
int main(int argc, char **argv) {

	// Init SDL + OpenGL
	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) {
		return -1;
	}
	SDL_SetVideoMode(W, H, 16, SDL_OPENGL);
	glewInit();
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);

	// Init Texture
	glGenTextures(1, &textureId);
	glBindTexture(GL_TEXTURE_2D, textureId);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// Init SDL_surface
	sdlStruct.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
	sdlStruct.sdlMutex = SDL_CreateMutex();

	// Init LibVLC + media player
	const char *vlc_argv[] = {};
	int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
	libvlc_instance_t * libVlcInstance = libvlc_new(vlc_argc, vlc_argv);
	libvlc_media_t * media = libvlc_media_new_path(libVlcInstance, VIDEOFILE);
	libvlc_media_player_t * mediaPlayer = libvlc_media_player_new_from_media(media);
	libvlc_media_release(media);
	libvlc_release(libVlcInstance);

	libvlc_video_set_callbacks(mediaPlayer, lockfct, unlockfct, NULL, &sdlStruct);
	libvlc_video_set_format(mediaPlayer, "RV16", W, H, W*2);

	// Start reading the video
	libvlc_media_player_play(mediaPlayer);
	libvlc_state_t state = libvlc_media_player_get_state(mediaPlayer);

	while ((state != libvlc_Ended) && (state != libvlc_Error)) {

		state = libvlc_media_player_get_state(mediaPlayer);
	}

	// Frees
	libvlc_media_player_release(mediaPlayer);
	SDL_DestroyMutex(sdlStruct.sdlMutex);
	SDL_FreeSurface(sdlStruct.sdlSurface);

	SDL_Quit();
	return 0;
}

But then, it doesn't work at all.

So my question is just: "Why ?" O_o ?

Thanks in advance.

Regards.

Postby **erwan10** » 28 Oct 2010 20:54

Not sure I know the answer to your question, but I see two things that may be a problem ....

- proper locking mechanism (first program)
Since you're dealing with multiple threads, all threads accessing a common resource must lock it. Otherwise, your code is prone to crash (see code hereafter that highlights missing locks)

- lock/unlock/display functions
you have to be aware that those functions are not executed in your own thread (most likely the main thread), but in a vlc internal thread. Is it okay to issue OpenGL calls in multiple threads ?

// Load a texture
void loadTexture() {
...
SDL_LockMutex(sdlStruct.sdlMutex);
SDL_LockSurface(sdlStruct.sdlSurface);

for (unsigned int i = H; i > 0; i--) {
for (unsigned int j = 0; j < W; j++) {
pixelSource = (Uint8 *) sdlStruct.sdlSurface->pixels + (i-1) * sdlStruct.sdlSurface->pitch + j * 2;
pix = *(Uint16 *) pixelSource;
SDL_GetRGBA(pix, sdlStruct.sdlSurface->format, &(pixelDestination[0]), &(pixelDestination[1]), &(pixelDestination[2]), &(pixelDestination[3]));
pixelDestination += 4;
}
}

SDL_UnlockSurface(sdlStruct.sdlSurface);
SDL_UnlockMutex(sdlStruct.sdlMutex);

// Building the texture
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexImage2D(GL_TEXTURE_2D, 0, 4, W, H, 0, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) rawData);

free(rawData);
}

Postby **Jean-Baptiste Kempf** » 28 Oct 2010 21:12

Please share your code on the wiki too

poliok · Postby **poliok** » 04 Nov 2010 14:32

@erwan10,

1) Oops! I forgot to lock the resource... =\
2) Erf :/ Indeed, the OpenGL context must be shared between the threads. I think it's the origin of my problem. I'm going to find a different solution.

@j-b,

I will... when it will be optimized and commented.

Thx.

Postby **Jean-Baptiste Kempf** » 06 Nov 2010 20:32

You can always start soon

Tleavy · Postby **Tleavy** » 15 Nov 2010 08:21

I have been messing around with the code in this post. My goal is to render 4 different videos on GLQuads. I adapted the code and added the change for properly locking SDL and then expanded it as follows

Code: Select all

#include <GL/glew.h>
#include <SDL/SDL.h>
#include <vlc/vlc.h>

#define VIDEOFILE "/home/tleavy/Downloads/city.avi" // A movie to read
#define VIDEOFILE2 "/home/tleavy/Downloads/divx.avi" // A movie to read
#define VIDEOFILE3 "/home/tleavy/Downloads/cartoon.avi" // A movie to read
// WIDTH, HEIGHT
#define W 800
#define H 800

GLuint textureId; // Texture ID
GLuint textureId2;
GLuint textureId3;

// SDL Structure
struct sdlStructure {
   SDL_Surface *sdlSurface;
   SDL_mutex *sdlMutex;
};
struct sdlStructure sdlStruct;
struct sdlStructure sdlStruct2;
struct sdlStructure sdlStruct3;

// Load a texture for first block
void loadTexture() {

   void * rawData = (void *) malloc(W * H * 4);
   Uint8 * pixelSource;
   Uint8 * pixelDestination = (Uint8 *) rawData;
   Uint32 pix;
   
   SDL_LockMutex(sdlStruct.sdlMutex);
   SDL_LockSurface(sdlStruct.sdlSurface);

   for (unsigned int i = H; i > 0; i--) {
      for (unsigned int j = 0; j < W; j++) {
         pixelSource = (Uint8 *) sdlStruct.sdlSurface->pixels + (i-1) * sdlStruct.sdlSurface->pitch + j * 2;
         pix = *(Uint16 *) pixelSource;
         SDL_GetRGBA(pix, sdlStruct.sdlSurface->format, &(pixelDestination[0]), &(pixelDestination[1]), &(pixelDestination[2]), &(pixelDestination[3]));
         pixelDestination += 4;
      }
   }
     SDL_UnlockSurface(sdlStruct.sdlSurface);
     SDL_UnlockMutex(sdlStruct.sdlMutex);

   // Building the texture
   
   glBindTexture(GL_TEXTURE_2D, textureId);
   glTexImage2D(GL_TEXTURE_2D, 0, 4, W, H, 0, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) rawData);

   free(rawData);
}
// Load a texture for second block
void loadTexture2() {

   void * rawData = (void *) malloc(W * H * 4);
   Uint8 * pixelSource;
   Uint8 * pixelDestination = (Uint8 *) rawData;
   Uint32 pix;
   
   SDL_LockMutex(sdlStruct2.sdlMutex);
   SDL_LockSurface(sdlStruct2.sdlSurface);

   for (unsigned int i = H; i > 0; i--) {
      for (unsigned int j = 0; j < W; j++) {
         pixelSource = (Uint8 *) sdlStruct2.sdlSurface->pixels + (i-1) * sdlStruct2.sdlSurface->pitch + j * 2;
         pix = *(Uint16 *) pixelSource;
         SDL_GetRGBA(pix, sdlStruct2.sdlSurface->format, &(pixelDestination[0]), &(pixelDestination[1]), &(pixelDestination[2]), &(pixelDestination[3]));
         pixelDestination += 4;
      }
   }
     SDL_UnlockSurface(sdlStruct2.sdlSurface);
     SDL_UnlockMutex(sdlStruct2.sdlMutex);
   // Building the texture

   glBindTexture(GL_TEXTURE_2D, textureId2);
   glTexImage2D(GL_TEXTURE_2D, 0, 4, W, H, 0, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) rawData);

   free(rawData);
}

// Load a texture for third block

void loadTexture3() {

   void * rawData = (void *) malloc(W * H * 4);
   Uint8 * pixelSource;
   Uint8 * pixelDestination = (Uint8 *) rawData;
   Uint32 pix;

   SDL_LockMutex(sdlStruct3.sdlMutex);
   SDL_LockSurface(sdlStruct3.sdlSurface);

   for (unsigned int i = H; i > 0; i--) {
      for (unsigned int j = 0; j < W; j++) {
         pixelSource = (Uint8 *) sdlStruct3.sdlSurface->pixels + (i-1) * sdlStruct3.sdlSurface->pitch + j * 2;
         pix = *(Uint16 *) pixelSource;
         SDL_GetRGBA(pix, sdlStruct3.sdlSurface->format, &(pixelDestination[0]), &(pixelDestination[1]), &(pixelDestination[2]), &(pixelDestination[3]));
         pixelDestination += 4;
      }
   }
     SDL_UnlockSurface(sdlStruct3.sdlSurface);
     SDL_UnlockMutex(sdlStruct3.sdlMutex);
   // Building the texture
   
   glBindTexture(GL_TEXTURE_2D, textureId3);
   glTexImage2D(GL_TEXTURE_2D, 0, 4, W, H, 0, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) rawData);

   free(rawData);
}


// Lock func
static void * lockfct(void *data, void **p_pixels) {
   SDL_LockMutex(sdlStruct.sdlMutex);
   SDL_LockSurface(sdlStruct.sdlSurface);
   *p_pixels = sdlStruct.sdlSurface->pixels;
   return NULL;
}

// Unlock func
static void unlockfct(void *data, void *id, void * const *p_pixels) {
   SDL_UnlockSurface(sdlStruct.sdlSurface);
   SDL_UnlockMutex(sdlStruct.sdlMutex);
}

// Lock func 2
static void * lockfct2(void *data, void **p_pixels) {
   SDL_LockMutex(sdlStruct2.sdlMutex);
   SDL_LockSurface(sdlStruct2.sdlSurface);
   *p_pixels = sdlStruct2.sdlSurface->pixels;
   return NULL;
}

// Unlock func 2
static void unlockfct2(void *data, void *id, void * const *p_pixels) {
   SDL_UnlockSurface(sdlStruct2.sdlSurface);
   SDL_UnlockMutex(sdlStruct2.sdlMutex);
}

// Lock func 3
static void * lockfct3(void *data, void **p_pixels) {
   SDL_LockMutex(sdlStruct3.sdlMutex);
   SDL_LockSurface(sdlStruct3.sdlSurface);
   *p_pixels = sdlStruct3.sdlSurface->pixels;
   return NULL;
}

// Unlock func 3
static void unlockfct3(void *data, void *id, void * const *p_pixels) {
   SDL_UnlockSurface(sdlStruct3.sdlSurface);
   SDL_UnlockMutex(sdlStruct3.sdlMutex);
}
/**
* Entry point (main func)
*/
int main(int argc, char **argv) {

   // Init SDL + OpenGL
   if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) {
      return -1;
   }
   SDL_SetVideoMode(W, H, 16, SDL_OPENGL);
   glewInit();
   glEnable(GL_TEXTURE_2D);
   glEnable(GL_DEPTH_TEST);

   // Init Textures
   glGenTextures(1, &textureId);
   glBindTexture(GL_TEXTURE_2D, textureId);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glGenTextures(1, &textureId2);
   glBindTexture(GL_TEXTURE_2D, textureId2);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glGenTextures(1, &textureId3);
   glBindTexture(GL_TEXTURE_2D, textureId3);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

   // Init SDL_surfaces
   sdlStruct.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
   sdlStruct.sdlMutex = SDL_CreateMutex();
   sdlStruct2.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
   sdlStruct2.sdlMutex = SDL_CreateMutex();
   sdlStruct3.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
   sdlStruct3.sdlMutex = SDL_CreateMutex();

   // Init LibVLC + media player
   const char *vlc_argv[] = {};
   int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
   libvlc_instance_t * libVlcInstance = libvlc_new(vlc_argc, vlc_argv);
   libvlc_media_t * media = libvlc_media_new_path(libVlcInstance, VIDEOFILE);
   libvlc_media_player_t * mediaPlayer = libvlc_media_player_new_from_media(media);
   libvlc_media_release(media);
   libvlc_release(libVlcInstance);

   libvlc_video_set_callbacks(mediaPlayer, lockfct, unlockfct, NULL, &sdlStruct);
   libvlc_video_set_format(mediaPlayer, "RV16", W, H, W*2);

   // Init LibVLC Round2
   libvlc_instance_t * libVlcInstance2 = libvlc_new(vlc_argc, vlc_argv);
   libvlc_media_t * media2 = libvlc_media_new_path(libVlcInstance2, VIDEOFILE2);
   libvlc_media_player_t * mediaPlayer2 = libvlc_media_player_new_from_media(media2);
   libvlc_media_release(media2);
   libvlc_release(libVlcInstance2);

   libvlc_video_set_callbacks(mediaPlayer2, lockfct2, unlockfct2, NULL, &sdlStruct2);
   libvlc_video_set_format(mediaPlayer2, "RV16", W, H, W*2);

 //Round 3
 libvlc_instance_t * libVlcInstance3 = libvlc_new(vlc_argc, vlc_argv);
   libvlc_media_t * media3 = libvlc_media_new_path(libVlcInstance3, VIDEOFILE3);
   libvlc_media_player_t * mediaPlayer3 = libvlc_media_player_new_from_media(media3);
   libvlc_media_release(media3);
   libvlc_release(libVlcInstance3);

   libvlc_video_set_callbacks(mediaPlayer3, lockfct3, unlockfct3, NULL, &sdlStruct3);
   libvlc_video_set_format(mediaPlayer3, "RV16", W, H, W*2);

   // Start reading the video
   libvlc_media_player_play(mediaPlayer);
   libvlc_media_player_play(mediaPlayer2);
   libvlc_media_player_play(mediaPlayer3);
   libvlc_state_t state = libvlc_media_player_get_state(mediaPlayer);

   while ((state != libvlc_Ended) && (state != libvlc_Error)) {
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


      loadTexture(); // Loading the texture

      // Square
       glBegin(GL_QUADS);
         glTexCoord2d(0, 0);
         glVertex2f(-0.95, 0.00);
         glTexCoord2d(0, 1);
         glVertex2f(-0.95, 0.95);
         glTexCoord2d(1, 1);
         glVertex2f(0.00, 0.95);
         glTexCoord2d(1, 0);
         glVertex2f(0.00, 0.00);
      glEnd();

      loadTexture2(); 

      glBegin(GL_QUADS);
         glTexCoord2d(0, 0);
         glVertex2f(0.05, 0.00);
         glTexCoord2d(0, 1);
         glVertex2f(0.05, 0.95);
         glTexCoord2d(1, 1);
         glVertex2f(0.95, 0.95);
         glTexCoord2d(1, 0);
         glVertex2f(0.95, 0.00);
      glEnd();

     loadTexture3();

     glBegin(GL_QUADS);
         glTexCoord2d(0, 0);
         glVertex2f(-0.95, -0.95); 
         glTexCoord2d(0, 1);
         glVertex2f(-0.95, -0.05);
         glTexCoord2d(1, 1);
         glVertex2f(0.00, -0.05);
         glTexCoord2d(1, 0);
         glVertex2f(0.0, -0.95);
      glEnd();
   
      glFlush();
      SDL_GL_SwapBuffers();
      SDL_Delay(10);
      state = libvlc_media_player_get_state(mediaPlayer);
   }

   // Frees
   libvlc_media_player_stop(mediaPlayer);
   libvlc_media_player_stop(mediaPlayer2);
   libvlc_media_player_stop(mediaPlayer3);
   libvlc_media_player_release(mediaPlayer);
   libvlc_media_player_release(mediaPlayer2);
   libvlc_media_player_release(mediaPlayer3);
   SDL_DestroyMutex(sdlStruct.sdlMutex);
   SDL_FreeSurface(sdlStruct.sdlSurface);
   SDL_DestroyMutex(sdlStruct2.sdlMutex);
   SDL_FreeSurface(sdlStruct2.sdlSurface);
   SDL_DestroyMutex(sdlStruct3.sdlMutex);
   SDL_FreeSurface(sdlStruct3.sdlSurface);

   SDL_Quit();
   return 0;
}

The problem here is that the application randomly segmentation faults when you try to run it. You might be able to run it 5 times in a row say with no issues ... but then all of a sudden it will seg fault right on start ... it might do that a few times and then work fine again. As you add more vlc instances the problem gets worse. Also I know that because of the condition on the while loop there will be issues if the first video is done before the others. To fix that for now all videos are exactly 10 sec and when it works it works fine.

I'm assuming its a bug in the original code in this post, since most of my work is copy paste and add a number to make the additional functions needed for multiple videos.

Anyone got any ideas? My final goal is to bring in 4 webcam feeds and libvlc seems like the obvious way to do that.

The VideoLAN Forums

LibVLC to OpenGL texture

LibVLC to OpenGL texture

Re: LibVLC to OpenGL texture

Re: LibVLC to OpenGL texture

Re: LibVLC to OpenGL texture

Re: LibVLC to OpenGL texture

Re: LibVLC to OpenGL texture

Who is online