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;
}
Exemple #2
0
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;
}
Exemple #4
0
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);
}