int ONScripter::playMPEG(const char *filename, bool click_flag, bool loop_flag)
{
unsigned long length = script_h.cBR->getFileLength( filename );
if (length == 0){
fprintf( stderr, " *** can't find file [%s] ***\n", filename );
return 0;
}
#ifdef ANDROID
playVideoAndroid(filename);
return 0;
#endif
int ret = 0;
#if !defined(MP3_MAD) && !defined(USE_SDL_RENDERER)
unsigned char *mpeg_buffer = new unsigned char[length];
script_h.cBR->getFile( filename, mpeg_buffer );
SMPEG *mpeg_sample = SMPEG_new_rwops( SDL_RWFromMem( mpeg_buffer, length ), NULL, 0 );
if ( !SMPEG_error( mpeg_sample ) ){
SMPEG_enableaudio( mpeg_sample, 0 );
if ( audio_open_flag ){
SMPEG_actualSpec( mpeg_sample, &audio_format );
SMPEG_enableaudio( mpeg_sample, 1 );
}
SMPEG_enablevideo( mpeg_sample, 1 );
SMPEG_setdisplay( mpeg_sample, screen_surface, NULL, NULL );
SMPEG_setvolume( mpeg_sample, music_volume );
SMPEG_loop(mpeg_sample, loop_flag);
Mix_HookMusic( mp3callback, mpeg_sample );
SMPEG_play( mpeg_sample );
bool done_flag = false;
while( !(done_flag & click_flag) && SMPEG_status(mpeg_sample) == SMPEG_PLAYING ){
SDL_Event event;
while( SDL_PollEvent( &event ) ){
switch (event.type){
case SDL_KEYUP:
if ( ((SDL_KeyboardEvent *)&event)->keysym.sym == SDLK_RETURN ||
((SDL_KeyboardEvent *)&event)->keysym.sym == SDLK_SPACE ||
((SDL_KeyboardEvent *)&event)->keysym.sym == SDLK_ESCAPE )
done_flag = true;
break;
case SDL_QUIT:
ret = 1;
case SDL_MOUSEBUTTONUP:
done_flag = true;
break;
default:
break;
}
}
SDL_Delay( 10 );
}
SMPEG_stop( mpeg_sample );
Mix_HookMusic( NULL, NULL );
SMPEG_delete( mpeg_sample );
}
delete[] mpeg_buffer;
#else
fprintf( stderr, "mpegplay command is disabled.\n" );
#endif
return ret;
}
void playVideo(const string &file) {
//myFillRect(screen, NULL, 0);
//SDL_GL_SwapBuffers();
SMPEG *mpeg;
SMPEG_Info info;
mpeg = SMPEG_new(file.c_str(), &info, false);
bool hasAudio = (info.has_audio > 0);
if ( SMPEG_error(mpeg) ) {
dout << "MPEG error: " << SMPEG_error(mpeg) << endl;
exit(1);
}
int done = 0;
SDL_Surface *videoSurface = SDL_AllocSurface( SDL_SWSURFACE,
nearestPow2(info.width),
nearestPow2(info.height),
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000 );
if ( !videoSurface ) {
dout << "Failed to allocate memory for video playback" << endl;
exit(1);
}
SMPEG_enablevideo(mpeg, 1);
SDL_mutex *mutex = SDL_CreateMutex();
SMPEG_setdisplay(mpeg, videoSurface, mutex, videoUpdate );
SMPEG_scaleXY(mpeg, info.width, info.height);
//SMPEG_setdisplayregion(mpeg, 0, 0, info.width, info.height);
//SMPEG_setdisplay(mpeg, screen, NULL, update);
if(hasAudio) {
SDL_AudioSpec audiofmt;
Uint16 format;
int freq, channels;
/* Tell SMPEG what the audio format is */
Mix_QuerySpec(&freq, &format, &channels);
audiofmt.format = format;
audiofmt.freq = freq;
audiofmt.channels = channels;
SMPEG_actualSpec(mpeg, &audiofmt);
/* Hook in the MPEG music mixer */
Mix_HookMusic(SMPEG_playAudioSDL, mpeg);
SMPEG_enableaudio(mpeg, 1);
SMPEG_setvolume(mpeg, 100);
} else {
Mix_PauseMusic();
SMPEG_enableaudio(mpeg, 0);
}
glBlendFunc(GL_ONE, GL_ZERO);
glEnable(GL_TEXTURE_2D);
SMPEG_play(mpeg);
while( !done && SMPEG_status( mpeg ) == SMPEG_PLAYING ) {
SDL_Event event;
while ( SDL_PollEvent(&event) ) {
switch (event.type) {
case SDL_KEYDOWN:
{
if ( event.key.keysym.sym == SDLK_SPACE ) {
done = 1;
}
break;
}
case SDL_QUIT:
{
exit(1);
}
default:
break;
}
}
if(drawVideoFrame) {
SDL_mutexP(mutex);
drawVideoFrame = false;
drawVideo(videoSurface, info.width, info.height);
//printf("draw in %i\n", time(NULL));
SDL_mutexV(mutex);
SDL_GL_SwapBuffers();
}
}
SMPEG_stop(mpeg);
if(hasAudio) {
Mix_HookMusic(NULL, NULL);
} else {
Mix_ResumeMusic();
}
SDL_FreeSurface(videoSurface);
myFillRect(screen, NULL, 0);
SDL_GL_SwapBuffers();
SMPEG_delete(mpeg);
}
static PyObject*
movie_set_display (PyObject* self, PyObject* args)
{
SMPEG* movie = PyMovie_AsSMPEG (self);
PyObject* surfobj, *posobj=NULL;
GAME_Rect *rect, temp;
int x=0, y=0;
if (!PyArg_ParseTuple (args, "O|O", &surfobj, &posobj))
return NULL;
if (!SDL_WasInit (SDL_INIT_VIDEO))
return RAISE (PyExc_SDLError,
"cannot convert without pygame.display initialized");
Py_XDECREF (((PyMovieObject*) self)->surftarget);
((PyMovieObject*) self)->surftarget = NULL;
if (PySurface_Check (surfobj))
{
SMPEG_Info info;
SDL_Surface* surf;
if (posobj == NULL)
{
Py_BEGIN_ALLOW_THREADS;
SMPEG_getinfo (movie, &info);
SMPEG_scaleXY (movie, info.width, info.height);
Py_END_ALLOW_THREADS;
x = y = 0;
}
else if (TwoIntsFromObj (posobj, &x, &y))
{
Py_BEGIN_ALLOW_THREADS;
SMPEG_getinfo (movie, &info);
SMPEG_scaleXY (movie, info.width, info.height);
Py_END_ALLOW_THREADS;
}
else if ((rect = GameRect_FromObject (posobj, &temp)))
{
x = rect->x;
y = rect->y;
Py_BEGIN_ALLOW_THREADS;
SMPEG_scaleXY (movie, rect->w, rect->h);
Py_END_ALLOW_THREADS;
}
else
return RAISE (PyExc_TypeError, "Invalid position argument");
surf = PySurface_AsSurface (surfobj);
Py_BEGIN_ALLOW_THREADS;
SMPEG_getinfo (movie, &info);
SMPEG_enablevideo (movie, 1);
SMPEG_setdisplay (movie, surf, NULL, NULL);
SMPEG_move (movie, x, y);
Py_END_ALLOW_THREADS;
}
else
{
Py_BEGIN_ALLOW_THREADS;
SMPEG_enablevideo (movie, 0);
Py_END_ALLOW_THREADS;
if (surfobj != Py_None)
return RAISE (PyExc_TypeError, "destination must be a Surface");
}
Py_RETURN_NONE;
}
int main(int argc, char *argv[])
{
int use_audio, use_video;
int fullscreen;
int scalesize;
int scale_width, scale_height;
int loop_play;
int i, pause;
int volume;
Uint32 seek;
float skip;
int bilinear_filtering;
SDL_Surface *screen = NULL;
SMPEG *mpeg;
SMPEG_Info info;
char *basefile;
const char *title = NULL;
SDL_version sdlver;
SMPEG_version smpegver;
int fd;
char buf[32];
int status;
/* Get the command line options */
use_audio = 1;
use_video = 1;
fullscreen = 0;
scalesize = 1;
scale_width = 0;
scale_height = 0;
loop_play = 0;
volume = 100;
seek = 0;
skip = 0;
bilinear_filtering = 0;
fd = 0;
for ( i=1; argv[i] && (argv[i][0] == '-') && (argv[i][1] != 0); ++i ) {
if ( (strcmp(argv[i], "--noaudio") == 0) ||
(strcmp(argv[i], "--nosound") == 0) ) {
use_audio = 0;
} else if ( strcmp(argv[i], "--novideo") == 0 ) {
use_video = 0;
} else if ( strcmp(argv[i], "--fullscreen") == 0 ) {
fullscreen = 1;
} else if ((strcmp(argv[i], "--double") == 0)||(strcmp(argv[i], "-2") == 0)) {
scalesize = 2;
} else if ((strcmp(argv[i], "--loop") == 0) || (strcmp(argv[i], "-l") == 0)) {
loop_play = 1;
} else if ( strcmp(argv[i], "--bilinear") == 0 ) {
bilinear_filtering = 1;
} else if ((strcmp(argv[i], "--seek") == 0)||(strcmp(argv[i], "-S") == 0)) {
++i;
if ( argv[i] ) {
seek = atol(argv[i]);
}
} else if ((strcmp(argv[i], "--skip") == 0)||(strcmp(argv[i], "-k") == 0)) {
++i;
if ( argv[i] ) {
skip = (float)atof(argv[i]);
}
} else if ((strcmp(argv[i], "--volume") == 0)||(strcmp(argv[i], "-v") == 0)) {
++i;
if (i >= argc)
{
fprintf(stderr, "Please specify volume when using --volume or -v\n");
return(1);
}
if ( argv[i] ) {
volume = atoi(argv[i]);
}
if ( ( volume < 0 ) || ( volume > 100 ) ) {
fprintf(stderr, "Volume must be between 0 and 100\n");
volume = 100;
}
} else if ((strcmp(argv[i], "--title") == 0)||(strcmp(argv[i], "-t") == 0)) {
++i;
if (i >= argc)
{
fprintf(stderr, "Please specify title when using --title or -t\n");
return(1);
}
if ( argv[i] ) {
title = argv[i];
}
} else if ((strcmp(argv[i], "--version") == 0) ||
(strcmp(argv[i], "-V") == 0)) {
sdlver = *SDL_Linked_Version();
SMPEG_VERSION(&smpegver);
printf("SDL version: %d.%d.%d\n"
"SMPEG version: %d.%d.%d\n",
sdlver.major, sdlver.minor, sdlver.patch,
smpegver.major, smpegver.minor, smpegver.patch);
return(0);
} else if ((strcmp(argv[i], "--scale") == 0)||(strcmp(argv[i], "-s") == 0)) {
++i;
if ( argv[i] ) {
sscanf(argv[i], "%dx%d", &scale_width, &scale_height);
}
} else if ((strcmp(argv[i], "--help") == 0) || (strcmp(argv[i], "-h") == 0)) {
usage(argv[0]);
return(0);
} else {
fprintf(stderr, "Warning: Unknown option: %s\n", argv[i]);
}
}
/* If there were no arguments just print the usage */
if (argc == 1) {
usage(argv[0]);
return(0);
}
#if defined(linux) || defined(__FreeBSD__) /* Plaympeg doesn't need a mouse */
putenv("SDL_NOMOUSE=1");
#endif
/* Play the mpeg files! */
status = 0;
for ( ; argv[i]; ++i ) {
/* Initialize SDL */
if ( use_video ) {
if ((SDL_Init(SDL_INIT_VIDEO) < 0) || !SDL_VideoDriverName(buf, 1)) {
fprintf(stderr, "Warning: Couldn't init SDL video: %s\n",
SDL_GetError());
fprintf(stderr, "Will ignore video stream\n");
use_video = 0;
}
}
if ( use_audio ) {
if ((SDL_Init(SDL_INIT_AUDIO) < 0) || !SDL_AudioDriverName(buf, 1)) {
fprintf(stderr, "Warning: Couldn't init SDL audio: %s\n",
SDL_GetError());
fprintf(stderr, "Will ignore audio stream\n");
use_audio = 0;
}
}
/* Allow Ctrl-C when there's no video output */
signal(SIGINT, next_movie);
/* Create the MPEG stream */
#ifdef NET_SUPPORT
#ifdef RAW_SUPPORT
/* Check if source is an IP address and port*/
if((fd = raw_open(argv[i])) != 0)
mpeg = SMPEG_new_descr(fd, &info, use_audio);
else
#endif
#ifdef HTTP_SUPPORT
/* Check if source is an http URL */
if((fd = http_open(argv[i])) != 0)
mpeg = SMPEG_new_descr(fd, &info, use_audio);
else
#endif
#ifdef FTP_SUPPORT
/* Check if source is an http URL */
if((fd = ftp_open(argv[i])) != 0)
mpeg = SMPEG_new_descr(fd, &info, use_audio);
else
#endif
#endif
#ifdef VCD_SUPPORT
/* Check if source is a CDROM device */
if((fd = vcd_open(argv[i])) != 0)
mpeg = SMPEG_new_descr(fd, &info, use_audio);
else
#endif
{
if(strcmp(argv[i], "-") == 0) /* Use stdin for input */
mpeg = SMPEG_new_descr(0, &info, use_audio);
else
mpeg = SMPEG_new(argv[i], &info, use_audio);
}
if ( SMPEG_error(mpeg) ) {
fprintf(stderr, "%s: %s\n", argv[i], SMPEG_error(mpeg));
SMPEG_delete(mpeg);
status = -1;
continue;
}
SMPEG_enableaudio(mpeg, use_audio);
SMPEG_enablevideo(mpeg, use_video);
SMPEG_setvolume(mpeg, volume);
/* Enable software bilinear filtering, if desired */
if ( bilinear_filtering ) {
SMPEG_Filter *filter;
filter = SMPEGfilter_bilinear();
filter = SMPEG_filter( mpeg, filter );
filter->destroy(filter);
}
/* Print information about the video */
basefile = strrchr(argv[i], '/');
if ( basefile ) {
++basefile;
} else {
basefile = argv[i];
}
if ( info.has_audio && info.has_video ) {
printf("%s: MPEG system stream (audio/video)\n", basefile);
} else if ( info.has_audio ) {
printf("%s: MPEG audio stream\n", basefile);
} else if ( info.has_video ) {
printf("%s: MPEG video stream\n", basefile);
}
if ( info.has_video ) {
printf("\tVideo %dx%d resolution\n", info.width, info.height);
}
if ( info.has_audio ) {
printf("\tAudio %s\n", info.audio_string);
}
if ( info.total_size ) {
printf("\tSize: %d\n", info.total_size);
}
if ( info.total_time ) {
printf("\tTotal time: %f\n", info.total_time);
}
/* Set up video display if needed */
if ( info.has_video && use_video ) {
const SDL_VideoInfo *video_info;
Uint32 video_flags;
int video_bpp;
int width, height;
/* Get the "native" video mode */
video_info = SDL_GetVideoInfo();
switch (video_info->vfmt->BitsPerPixel) {
case 16:
case 24:
case 32:
video_bpp = video_info->vfmt->BitsPerPixel;
break;
default:
video_bpp = 16;
break;
}
if ( scale_width ) {
width = scale_width;
} else {
width = info.width;
}
width *= scalesize;
if ( scale_height ) {
height = scale_height;
} else {
height = info.height;
}
height *= scalesize;
video_flags = SDL_SWSURFACE;
if ( fullscreen ) {
video_flags = SDL_FULLSCREEN|SDL_DOUBLEBUF|SDL_HWSURFACE;
}
video_flags |= SDL_ASYNCBLIT;
video_flags |= SDL_RESIZABLE;
screen = SDL_SetVideoMode(width, height, video_bpp, video_flags);
if ( screen == NULL ) {
fprintf(stderr, "Unable to set %dx%d video mode: %s\n",
width, height, SDL_GetError());
continue;
}
if (title != NULL) {
SDL_WM_SetCaption(title, title);
} else {
SDL_WM_SetCaption(argv[i], "plaympeg");
}
if ( screen->flags & SDL_FULLSCREEN ) {
SDL_ShowCursor(0);
}
SMPEG_setdisplay(mpeg, screen, NULL, update);
SMPEG_scaleXY(mpeg, screen->w, screen->h);
} else {
SDL_QuitSubSystem(SDL_INIT_VIDEO);
use_video = 0;
}
/* Set any special playback parameters */
if ( loop_play ) {
SMPEG_loop(mpeg, 1);
}
/* Seek starting position */
if(seek) SMPEG_seek(mpeg, seek);
/* Skip seconds to starting position */
if(skip) SMPEG_skip(mpeg, skip);
/* Play it, and wait for playback to complete */
SMPEG_play(mpeg);
done = 0;
pause = 0;
while ( ! done && ( pause || (SMPEG_status(mpeg) == SMPEG_PLAYING) ) ) {
SDL_Event event;
while ( use_video && SDL_PollEvent(&event) ) {
switch (event.type) {
case SDL_VIDEORESIZE: {
SDL_Surface *old_screen = screen;
SMPEG_pause(mpeg);
screen = SDL_SetVideoMode(event.resize.w, event.resize.h, screen->format->BitsPerPixel, screen->flags);
if ( old_screen != screen ) {
SMPEG_setdisplay(mpeg, screen, NULL, update);
}
SMPEG_scaleXY(mpeg, screen->w, screen->h);
SMPEG_pause(mpeg);
}
break;
case SDL_KEYDOWN:
if ( (event.key.keysym.sym == SDLK_ESCAPE) || (event.key.keysym.sym == SDLK_q) ) {
// Quit
done = 1;
} else if ( event.key.keysym.sym == SDLK_RETURN ) {
// toggle fullscreen
if ( event.key.keysym.mod & KMOD_ALT ) {
SDL_WM_ToggleFullScreen(screen);
fullscreen = (screen->flags & SDL_FULLSCREEN);
SDL_ShowCursor(!fullscreen);
}
} else if ( event.key.keysym.sym == SDLK_UP ) {
// Volume up
if ( volume < 100 ) {
if ( event.key.keysym.mod & KMOD_SHIFT ) { // 10+
volume += 10;
} else if ( event.key.keysym.mod & KMOD_CTRL ) { // 100+
volume = 100;
} else { // 1+
volume++;
}
if ( volume > 100 )
volume = 100;
SMPEG_setvolume(mpeg, volume);
}
} else if ( event.key.keysym.sym == SDLK_DOWN ) {
// Volume down
if ( volume > 0 ) {
if ( event.key.keysym.mod & KMOD_SHIFT ) {
volume -= 10;
} else if ( event.key.keysym.mod & KMOD_CTRL ) {
volume = 0;
} else {
volume--;
}
if ( volume < 0 )
volume = 0;
SMPEG_setvolume(mpeg, volume);
}
} else if ( event.key.keysym.sym == SDLK_PAGEUP ) {
// Full volume
volume = 100;
SMPEG_setvolume(mpeg, volume);
} else if ( event.key.keysym.sym == SDLK_PAGEDOWN ) {
// Volume off
volume = 0;
SMPEG_setvolume(mpeg, volume);
} else if ( event.key.keysym.sym == SDLK_SPACE ) {
// Toggle play / pause
if ( SMPEG_status(mpeg) == SMPEG_PLAYING ) {
SMPEG_pause(mpeg);
pause = 1;
} else {
SMPEG_play(mpeg);
pause = 0;
}
} else if ( event.key.keysym.sym == SDLK_RIGHT ) {
// Forward
if ( event.key.keysym.mod & KMOD_SHIFT ) {
SMPEG_skip(mpeg, 100);
} else if ( event.key.keysym.mod & KMOD_CTRL ) {
SMPEG_skip(mpeg, 50);
} else {
SMPEG_skip(mpeg, 5);
}
} else if ( event.key.keysym.sym == SDLK_LEFT ) {
// Reverse
if ( event.key.keysym.mod & KMOD_SHIFT ) {
} else if ( event.key.keysym.mod & KMOD_CTRL ) {
} else {
}
} else if ( event.key.keysym.sym == SDLK_KP_MINUS ) {
// Scale minus
if ( scalesize > 1 ) {
scalesize--;
}
} else if ( event.key.keysym.sym == SDLK_KP_PLUS ) {
// Scale plus
scalesize++;
} else if ( event.key.keysym.sym == SDLK_f ) {
// Toggle filtering on/off
if ( bilinear_filtering ) {
SMPEG_Filter *filter = SMPEGfilter_null();
filter = SMPEG_filter( mpeg, filter );
filter->destroy(filter);
bilinear_filtering = 0;
} else {
SMPEG_Filter *filter = SMPEGfilter_bilinear();
filter = SMPEG_filter( mpeg, filter );
filter->destroy(filter);
bilinear_filtering = 1;
}
}
break;
case SDL_QUIT:
done = 1;
break;
default:
break;
}
}
SDL_Delay(1000/2);
}
SMPEG_delete(mpeg);
}
SDL_Quit();
#if defined(RAW_SUPPORT) || defined(HTTP_SUPPORT) || defined(FTP_SUPPORT) || \
defined(VCD_SUPPORT)
if(fd) close(fd);
#endif
return(status);
}