Btw, have you seen the SDL/smpeg/OpenGL example here...
http://www.gamedev.net/community/for...opic_id=348801

Well this is the class used in there converted...

[pascal]
unit SDLMovie;

interface

uses
sdl,
gl,
glu,
glext,
smpeg;

type
TSDLMovie = class
private
// Surface for the main screen
screen : PSDL_Surface;

// Surface for the movie
movieSurface : PSDL_Surface;

// Holds the movie information
movieInfo : SMPEG_Info;

// Load the movie
movie : PSMPEG;

// The max we can scale by
MaxScaleX, MaxScaleY, MaxScale : integer;

// Locations on screen to draw at
X, Y : integer;

procedure DrawIMG( img : PSDL_Surface; X, Y : integer );

public
constructor Create;


// Free our movie
destructor Destroy; override;


procedure ClearScreen;

// Set's the volume on a scale of 0 - 100
procedure SetVolume( vol : integer );


// Scale the movie by the desired factors
procedure Scale( w, h : integer );


// Scale the movie by the desired factor
procedure ScaleBy( factor : integer );

// Sets the region of the video to be shown
procedure SetDisplayRegion( x, y, w, h : integer );

// Set the position that the movie should be drawn at on the screen

procedure SetPosition( ax, ay : integer );


// Check for any errors

procedure CheckErrors;

// Load the movie
procedure Load( const fileName : string; s : PSDL_Surface; maxscalex : integer = 1; maxscaley : integer = 1 );

// Set the looping of hte movie

procedure SetLoop( val : integer );

// Play the movie

procedure Play;

// Pause the movie

procedure Pause;

// Stops the movie, but keeps current position

procedure Stop;

// Rewind the movie back to 0:00:00

procedure Rewind;

// Seek a number of bytes into the movie

procedure Seek( bytes : integer );

// Skip a number of seconds

procedure Skip( seconds : single );


// Render some frame of the movie

procedure RenderFrame( frame : integer );


// Render the final frame of the movie

procedure RenderFinal;


// Draw the movie surface to the main screen at x, y

procedure DisplayAt( x, y : integer );

// Draw the movie surface to the main screen at x, y

procedure Display;


// Return the current info for the movie
function GetInfo : SMPEG_Info;

// Get the current status of the movie, can be SMPEG_ERROR = -1, SMPEG_STOPPED, SMPEG_PLAYING
function GetStatus : SMPEGstatus;
end;

implementation

{ TSDLMovie }

procedure TSDLMovie.CheckErrors;
begin
// Maybe out put to logger
{ char* error = SMPEG_error( movie );
if( error )
printf( "Error: %s\n", error ); }
end;

procedure TSDLMovie.ClearScreen;
begin
SDL_FillRect( movieSurface, 0, 0 );
end;

constructor TSDLMovie.Create;
begin
MaxScaleX := 1;
MaxScaleY := 1;
MaxScale := 1;

screen := nil;
movieSurface := nil;
movie := nil;
X := 0;
Y := 0;
end;

destructor TSDLMovie.Destroy;
begin
Stop;
SMPEG_delete( movie );
movie := nil;
SDL_FreeSurface( movieSurface );
movieSurface := nil;
inherited;
end;

procedure TSDLMovie.Display;
begin
DrawIMG( movieSurface, X, Y );
end;

procedure TSDLMovie.DisplayAt( x, y : integer );
begin
DrawIMG( movieSurface, x, y );
end;

procedure TSDLMovie.DrawIMG( img : PSDL_Surface; X, Y : integer );
var
bmpFile : PSDL_Surface;
texture : GLuint;
begin
//SDL_Surface* bmpFile = MirrorSurfaceX(img);
bmpFile := img;

// Standard OpenGL texture creation code
// glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );

glGenTextures( 1, @texture );
glBindTexture( GL_TEXTURE_2D, texture );

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 0 );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0 );

gluBuild2DMipmaps( GL_TEXTURE_2D, 4, bmpFile.w, bmpFile.h, GL_BGRA_EXT, GL_UNSIGNED_BYTE, bmpFile.pixels );

//Free surface after using it
SDL_FreeSurface( bmpFile );

glBindTexture( GL_TEXTURE_2D, texture );
glPushMatrix;
glTranslatef( 0.0, 0.0, -5.0 );
glBegin( GL_QUADS );
glTexCoord2f( 0.0, 0.0 ); glVertex3f( -1.0, -1.0, 1.0 );
glTexCoord2f( 1.0, 0.0 ); glVertex3f( 1.0, -1.0, 1.0 );
glTexCoord2f( 1.0, 1.0 ); glVertex3f( 1.0, 1.0, 1.0 );
glTexCoord2f( 0.0, 1.0 ); glVertex3f( -1.0, 1.0, 1.0 );
glEnd;
glPopMatrix;
glDeleteTextures( 1, @texture );
end;

function TSDLMovie.GetInfo : SMPEG_Info;
begin
SMPEG_getinfo( movie, @movieInfo );
result := movieInfo;
end;

function TSDLMovie.GetStatus : SMPEGstatus;
begin
result := SMPEG_status( movie );
end;

procedure TSDLMovie.Load( const fileName : string; s : PSDL_Surface;
maxscalex, maxscaley : integer );
var
tempSurface2 : PSDL_Surface;
begin
MaxScaleX := maxscalex;
MaxScaleY := maxscaley;

// Limit how much we can scale by
if ( maxscalex > maxscaley ) then
MaxScale := maxscaley
else
MaxScale := maxscalex;

// Assign the screen surface
screen := s;

// Load the movie and store the information about it
movie := SMPEG_new( PChar( fileName ), @movieInfo, 0 );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}

// Create a temporary surface to render the movie to
tempSurface2 := SDL_CreateRGBSurface( SDL_SWSURFACE, movieInfo.width * MaxScaleX, movieInfo.height * MaxScaleY, 32, screen.format.Rmask, screen.format.Gmask, screen.format.Bmask, screen.format.Amask );

// Now make a surface optimized for the main screen
movieSurface := SDL_DisplayFormat( tempSurface2 );

// Free the temporary surface
SDL_FreeSurface( tempSurface2 );

// Set the surface to draw to
SMPEG_setdisplay( movie, movieSurface, nil, nil );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}

// Set the display region
SMPEG_setdisplayregion( movie, 0, 0, movieInfo.width, movieInfo.height );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.Pause;
begin
SMPEG_pause( movie );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.Play;
begin
SMPEG_play( movie );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.RenderFinal;
begin
SMPEG_renderFinal( movie, movieSurface, 0, 0 );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.RenderFrame( frame : integer );
begin
SMPEG_renderFrame( movie, frame );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.Rewind;
begin
SMPEG_rewind( movie );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.Scale( w, h : integer );
begin
// Prevent a divide by 0
if ( w = 0 ) then
w := 1;
if ( h = 0 ) then
h := 1;

SMPEG_scaleXY( movie, w, h );
{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.ScaleBy( factor : integer );
begin
// Prevent a divide by 0
if ( factor = 0 ) then
factor := 1;
// Make sure we don't scale larger than the surface size
if ( factor > MaxScale ) then
factor := MaxScale;

SMPEG_scale( movie, factor );
{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.Seek( bytes : integer );
begin
SMPEG_seek( movie, bytes );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.SetDisplayRegion( x, y, w, h : integer );
begin
SMPEG_setdisplayregion( movie, x, y, w, h );
{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}

end;

procedure TSDLMovie.SetLoop( val : integer );
begin
SMPEG_loop( movie, val );
{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.SetPosition( ax, ay : integer );
begin
X := ax;
Y := ay;
end;

procedure TSDLMovie.SetVolume( vol : integer );
begin
SMPEG_setvolume( movie, vol );
end;

procedure TSDLMovie.Skip( seconds : single );
begin
SMPEG_skip( movie, seconds );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

procedure TSDLMovie.Stop;
begin
SMPEG_stop( movie );

{$IFDEF _DEBUG}
CheckErrors;
{$ENDIF}
end;

end.
[/pascal]

It's not tested, but it does compile.