See the OpenGL Programming Guide for information on using the OpenGL window configuration routines, including: glXgetconfig(3g), glXCreateContext(3g), and glXChooseVisual(3g).

There are two methods for creating a GL/X window:

Example 30-1 is a code fragment that shows how to create an IRIS GL playback window. (KeyReleaseMask is needed only if the application needs to listen to keystrokes when the mouse pointer is inside the movie window.)

/*********
*
* Open a connection to the X server, and create an X window
* suitable for GL rendering here.
*
*********/

static DMstatus createXWindow( Display **dpy, Window *win,int width, int height )
{
    XSetWindowAttributes childWinAttribs;

    /* 
     *Open a connection to the X server. 
     */

    *dpy = XOpenDisplay( 0 );
    if ( *dpy == NULL ) {
        fprintf( stderr, "%s: Cannot open display.\n", programName );
        return DM_FAILURE;
    }
    childWinAttribs.colormap = DefaultColormap( *dpy, DefaultScreen( *dpy ) );

    /* 
     * Even if we don't use it, childWinAttribs.border_pixel must be something.
     */

    childWinAttribs.border_pixel = 0;

    /* 
     * Create an X window configured for GL rendering, using
     * the helper functions defined in glxhelper.c
     */

    *win = GLXCreateWindow( *dpy, RootWindow( *dpy, DefaultScreen( *dpy ) ),
                           100, 100, width, height, 0, CWColormap|CWBorderPixel,
                           &childWinAttribs, GLXrgbSingleBuffer );
    XSelectInput( *dpy, *win, ExposureMask | StructureNotifyMask | KeyReleaseMask );
    return DM_SUCCESS;
}

You can control these settings for the playback display:

You can call the routines that configure the size, offset, and background color of the playback window whether or not a movie is currently playing within that window. Figure 30-1 diagrams the view settings.

Figure 30-1. Playback View Settings

void mvSetViewBackground ( MVid movieid, unsigned short red,
                          unsigned short green, unsigned short blue )

void mvGetViewBackground ( MVid movieid,
                           unsigned short* redreturn,
                           unsigned short* greenreturn,
                           unsigned short* bluereturn )

Setting and Getting the Viewing Area Size

This section explains how to specify the size of the viewing area used for rendering a movie within a window. The default view size is the width and height of the movie frame, as it is specified in the movie file.

The Movie Library zooms the movie frame to fill the specified area as closely as possible, while adhering to the pixel zooming restraints imposed by the IRIS GL or Open GL renderer. Any remaining area between the window and the movie viewing area is filled with the background color that you specified.

---

Note: Currently, only integer zooming (2×, 3×, and so on) is supported, regardless of the graphics hardware platform.

---

To specify the size of the movie viewing area, call mvSetViewSize(). Its function prototype is:

void mvSetViewSize ( MVid movieid, int newwidth, int newheight, DMboolean keepaspect )

where:

newwidth		is the requested width, in pixels, of the viewing area
newheight		is the requested height, in pixels, of the viewing area
keepaspect		controls whether the aspect ratio is preserved when zooming the movie: DM_TRUE preserves the aspect ratio DM_FALSE does not preserve the aspect ratio

To determine the viewing area size that the Movie Library will actually create for a desired width and height, call mvQueryViewSize(). Its function prototype is:

void mvQueryViewSize ( MVid movieid, int width, int height, DMboolean keepaspect,int* widthreturn, int* heightreturn )

where:

width		is the requested width, in pixels, of the viewing area
height		is the requested height, in pixels, of the viewing area
keepaspect		controls whether the aspect ratio is preserved when zooming the movie: DM_TRUE preserves the aspect ratio DM_FALSE does not preserve the aspect ratio
widthreturn		is a pointer into which the actual width, in pixels, of the viewing area is returned
heightreturn		is a pointer into which the actual height, in pixels, of the viewing area is returned

If a movie appears by itself with no other graphics in a GL/X window, you might want to ensure that your code chooses the proper window size by calling mvQueryViewSize() in advance, and using the results to resize the GL/X window to be the same size as the movie—or you can simply choose a background color for the unused portions of the display by calling mvSetViewBackground().

If the movie appears in a GL/X window along with other graphic elements, such as a movie that is embedded in a larger display, you might be more concerned about setting an exact view size, so you should set the view size carefully by first calling mvQueryViewSize() and then using the results as inputs to mvSetViewSize(). This makes sure that the Movie Library draws on the display only over regions that the movie frame actually occupies.

To get the requested view size, call mvGetViewSize(). Its function prototype is:

void mvGetViewSize ( MVid movieid, int *widthreturn, int *heightreturn)

where:

widthreturn		is a pointer into which the width is returned
heightreturn		is a pointer into which the height is returned

mvGetViewSize() always returns the last requested size of the movie view, regardless of the movie's actual view size. Thus, you can inspect both the requested size by calling mvGetViewSize(), and the actual frame size by calling mvQueryViewSize().

void mvSetViewOffset ( MVid movieid, int offsetx,
                       int offsety, DMboolean glcoordsystem )

void mvQueryViewOffset ( MVid movieid,
                         int offsetx,
                         int offsety,
                         int* offsetxreturn,
                         int* offsetyreturn,
                         DMboolean glcoordsystem )

void mvGetViewOffset ( MVid movieid, int* offsetxreturn,
                       int* offsetyreturn,
                       DMboolean glcoordsystem )

If the specified movie has an audio track, mvBindWindow() or mvBindOpenGLWindow() attempts to open an audio port by calling ALopenport() from the Audio Library. If the attempt is successful, an audio port with the name movipid:movieid is created:

where:

See the ALopenport(3A) man page for more information.

If it is not possible to open an audio port, either because there are no free audio ports or because your system does not have audio capability, the Movie Library plays the image track without playing the accompanying audio track.

---

Note: Audio is not part of the X protocol, so the audio track will not follow the DISPLAY variable if the movie is played remotely.

---

To play more than one movie in the same window, bind the different movies to the same window by calling mvBindWindow() or mvBindOpenGLWindow() with the same dpy and win values for each movieid.

Example 30-2 is a code fragment that binds several movies to a window, and then shifts the position of each movie so they do not overlap.

static DMstatus bindWinToMovies( MVid* movieList, int numMovies,Display* dpy, Window win )
{
    int  i;
    MVid currentMovie;

    for ( i = 0; i < numMovies; i++ ) {
        currentMovie = movieList[ i ];

        /* 
         * Bind the GL window to the movie.  This will cause several
         * movies to play in the same window.
         */
        if ( mvBindWindow( currentMovie, dpy, win ) != DM_SUCCESS ) {
            fprintf( stderr, "%s: Could not bind movie to window.\n",
                    getProgramName() );
            return DM_FAILURE;
        }
    }

    /*
     * Initially, all the movies appear at the same display location.
     * We call a helper function to move them so they do not overlap.
     * The helper function calls mvSetViewOffset(3mv) to accomplish
     * this task.
     */
    if ( setMovieViewOffsets() != DM_SUCCESS ) {
        return DM_FAILURE;
    }

    return DM_SUCCESS;
}

To set a movie into motion, call mvPlay(). Its function prototype is:

void mvPlay ( MVid movieid )

To halt playback, call mvStop(). Its function prototype is:

void mvStop ( MVid movieid )

Playing or stopping a movie does not affect any of the other settings such as playback speed or direction; for example, if you stop a movie that is playing backward, then start it again, the movie will continue to play backward.

If a movie has an audio track, the Movie Library plays the audio for you automatically if it is able to allocate an audio port.

void mvSetEnableAudio ( MVid movieid, DMboolean onoff )

DMboolean mvGetEnableAudio ( MVid movieid )

static void toggleAudioMuting( MVid *theMovies , int numMoviesInWin )
{
    int i;

    for( i = 0;i < numMoviesInWin; i++ ) {

        printf("%s: %d, toggle mute to ", getProgramName(), theMovies[i]);
        
        if ( mvGetEnableAudio( theMovies[i] ) ) {
            printf( "OFF\n" );
            mvSetEnableAudio( theMovies[i], DM_FALSE );
        } else {
            printf( "ON\n" );
            mvSetEnableAudio( theMovies[i], DM_TRUE );
        }
    }
}

void mvSetPrimaryAudio ( MVid movieid )

MVid mvGetPrimaryAudio ( void )

static void playTheMovies( MVid *theMovies, int numMoviesInWin )
{
    int i;

    mvSetPrimaryAudio( theMovies[0] );

    for( i = 0;i < numMoviesInWin; i++ ) {
        printf("%s: %d, play\n", getProgramName(), theMovies[i]);
        mvPlay( theMovies[i] );
    }
}

Looping is the process of repeatedly playing movie frames. You can define the starting and ending frame for movie playback, thereby allowing looping on an entire movie or only a fragment of the movie. You can define only one such loop per movie.

The playback loop mode, which is independent of the default loop mode that is stored in the movie, controls the playback behavior:

If the movie was playing backward when looping began, the movie will continue to loop backward.

void mvSetPlayLoopMode ( MVid movieid, MVloopmode newloopmode )

MVloopmode mvGetPlayLoopMode ( MVid movieid )

static void stepToNextLoopState ( MVid *theMovies,
                                  int numMoviesInWin )
{
    int i;
    MVloopmode loopMode;

    for( i = 0;i < numMoviesInWin; i++ ) {

        printf("%s: %d, change loop state to ",
               getProgramName(), theMovies[i]);

        switch ( mvGetPlayLoopMode( theMovies[i] ) ) {
        case MV_LOOP_NONE:
            loopMode = MV_LOOP_CONTINUOUSLY;
            printf( "CONTINUOUS\n" );
            break;
        case MV_LOOP_CONTINUOUSLY:
            loopMode = MV_LOOP_SWINGING;
            printf( "SWINGING\n" );
            break;
        case MV_LOOP_SWINGING:
            loopMode = MV_LOOP_NONE;
            printf( "NONE\n" );
            break;
        }
        mvSetPlayLoopMode( theMovies[i], loopMode );
    }
}

void mvSetPlayLoopCount( MVid movieid, MVframe newloopcount )

MVframe mvGetPlayLoopCount ( MVid movieid )

void mvSetPlayLoopLimit ( MVid movieid, MVframe newlooplimit)

MVframe mvGetPlayLoopLimit ( MVid movieid )

You can play or loop-play a movie fragment by selecting a start frame and an end frame within the movie. You can define only one such fragment per movie and the fragment must contain at least one frame.

The start frame number must be less than or equal to the end frame number; frame 0 (the first frame of the movie) is the default start frame. If the current frame is outside the range specified, the Movie Library treats the movie as having reached end-of-media.

To define the start frame for a movie (or fragment), call mvSetStartFrame(). Its function prototype is:

void mvSetStartFrame ( MVid movieid, MVframe startframe )

where:

To define the end frame of a movie (or fragment), call mvSetEndFrame(). Its function prototype is:

void mvSetEndFrame ( MVid movieid, MVframe endframe )

where:

To get the frame number where playback begins, call mvGetStartFrame(). Its function prototype is:

MVframe mvGetStartFrame ( MVid movieid )

To get the frame number where playback ends, call mvGetEndFrame(). Its function prototype is:

MVframe mvGetEndFrame ( MVid movieid )

This section explains how to use the Movie Library to respond to an interface such as a scroll bar that lets the user jump to a random location in a movie while it is playing.

The Movie Library has two routines for jumping to a particular frame in a movie: mvSetCurrentFrame() and mvScrubCurrentFrame(). Each routine is designed with a specific use in mind. mvScrubCurrentFrame() provides the quickest response by rapidly locating the nearest frame (keyframe for keyframed formats) to the selected frame; mvSetCurrentFrame() provides the most accurate response, by precisely locating and then showing the frame exactly as selected.

Their function prototypes are:

void mvScrubCurrentFrame( MVid movieid, MVframe newframe )
void mvSetCurrentFrame( MVid movieid, MVframe newframe )

where:

One way to use these routines is to call mvScrubCurrentFrame() to make coarse jumps while the user is dragging the scroll bar, then call mvSetCurrentFrame() to go to and display the exact frame when the user releases the mouse button. The triangular pointer in the Movie Player uses this technique.

To retrieve the location of the current frame, call mvGetCurrentFrame(). Its function prototype is:

MVframe mvGetCurrentFrame ( MVid movieid )

You can specify a multiplier for modifying a movie's natural frame rate. The natural frame rate is stored in the movie file and can be retrieved with mvGetImageRate(). The default playback speed is 1.0 times the natural frame rate.

To alter the normal playing speed, call mvSetPlaySpeed(), which expresses the new playback speed as a multiple of the movie's natural image frame rate. Its function prototype is:

void mvSetPlaySpeed ( MVid movieid, double newplayspeed )

where:

For example, if you specify a newplayspeed of 2.0, the movie plays twice as fast as it normally would. If you specify a negative value for newplayspeed, the movie plays in reverse.

You can measure the resulting frame rate by calling mvGetActualFrameRate(), as described in “Measuring the Current Frame Rate”.

For movies with audio, the Movie Library attempts to resample the audio to match the requested playback speed. This changes the pitch of the audio. The current implementation uses software techniques to perform audio resampling, so you should be aware that changing the speed of playback for a movie with an audio soundtrack consumes more processor time.

mvSetPlaySpeed() has no effect if the movie has been set to play every frame with mvSetPlayEveryFrame().

To determine the current setting for playback speed, call mvGetPlaySpeed(). Its function prototype is:

double mvGetPlaySpeed ( MVid movieid )

You can obtain the actual playback frame rate for a movie as it is playing; the Movie Library computes the frame rate over the last second of playback. The current frame rate is the movie's natural frame rate, in frames per second (FPS) modified by the speed factor set by mvSetPlaySpeed().

To determine the current frame rate, call mvGetActualFrameRate(). Its function prototype is:

DMstatus mvGetActualFrameRate ( MVid movieid,
                                double* ratereturn )

where:

If your application needs more detailed information about the rate of movie playback, you should check the timestamp information associated with movie frame events as described in “Handling Events”.

If the playback rate lags behind the time base, the Movie Library will drop (not display) image frames to stay in sync.

You can set a threshold value for the slowest acceptable playback speed and have the Movie Library notify you through the movie event queue if the playback speed falls below this minimum accepted speed by requesting MV_SLOW_PLAY events using mvSetSelectEvents().

The threshold value must be a number between 0 and 1, which is a fraction of the movie's current speed. The current speed of a movie is its natural frame rate, as specified in the movie file, multiplied by the speed factor set by mvSetPlaySpeed(). The threshold setting is global—it applies to all movies in your application. The default threshold is .5, meaning 50% of the current speed.

To set a minimum playback rate threshold, call mvSetSlowThreshold(). Its function prototype is:

void mvSetSlowThreshold ( double slowthresh )

where:

To retrieve the current minimum playback rate threshold, call mvGetSlowThreshold(). Its function prototype is:

double mvGetSlowThreshold ( void )

See “Checking and Correcting for Slow Playback” for an explanation of how to check for slow playback events and correct for them.

Some applications need to display every frame in a movie; for example, visualization applications where the user is looking for data patterns or trends must show every frame to ensure accuracy. The audio track is ignored (the movie plays silently) when you play every frame. In addition, the slow playback threshold is ignored when you play every frame, and you won't receive MV_SLOW_PLAYBACK events either.

To force the Movie Library to show every frame in sequence as fast as it can, call mvSetPlayEveryFrame(), passing in a value of DM_TRUE. Its function prototype is:

void mvSetPlayEveryFrame( MVid movieid, DMboolean sync )

where:

To find out if playback is set to play every frame, call mvGetPlayEveryFrame(). Its function prototype is:

DMboolean mvGetPlayEveryFrame( MVid movieid )

If the graphics you want to draw using the IRIS GL do not overlap any portion of the movie display, for example, if your application displays movies and graphics side-by-side in one window or in separate windows, you can use the mvGrabIrisGL() and mvReleaseIrisGL() routines. These routines essentially put movie rendering on hold while the application performs IRIS GL rendering. Their function prototypes are:

void mvGrabIrisGL ( void )
void  mvReleaseIrisGL ( void )

Use mvGrabIrisGL() and mvReleaseIrisGL() to surround the block of code that performs the IRIS GL drawing. Call mvGrabIrisGL() at the beginning of a block of IRIS GL calls, then call mvReleaseIrisGL() when the IRIS GL drawing is completed.

Example 30-6 is an excerpt from moviescreenGl.c , in /usr/people/4Dgifts/examples/dmedia/movie/moviescreen, that shows how to use mvGrabIrisGL() and mvReleaseIrisGL(). It uses the IRIS GL bgnpolygon() and endpolygon() routines to draw a box that covers up the distracting visual effects caused by moving the movie around the screen. See “Creating a Movie Screensaver Application” in Chapter 32 for more details about the moviescreen program.

void undrawSaverPicture()
{
    int  width;
    int  height;
    MVid imageTrack;
    MVid theMovie = getMovieID();

    if ( isFullScreen() )
        return;

    /*
     * Determine current size of movie on display
     */

    mvFindTrackByMedium( theMovie, DM_IMAGE, &imageTrack );
    width  = mvGetImageWidth( imageTrack );
    height = mvGetImageHeight( imageTrack );
    width *= getZoom();
    height *= getZoom();
    /*
     * Draw two black boxes to erase trailing garbage as 
     * movie dances around the display.
     */

    mvGrabIrisGL();
    bgnpolygon();
    {
        short vctr[2];
        if ( dx > 0 ) {

            vctr[0] = offsetx - 1;
            vctr[1] = offsety - 1;
            v2s( vctr );

            vctr[0] = offsetx +dx;
            vctr[1] = offsety - 1;
            v2s( vctr );
            vctr[0] = offsetx + dx;
            vctr[1] = offsety + height + 1;
            v2s( vctr );

            vctr[0] = offsetx - 1;
            vctr[1] = offsety + height + 1;
            v2s( vctr );

        } else {

            vctr[0] = offsetx + width;
            vctr[1] = offsety - 1;
            v2s( vctr );

            vctr[0] = offsetx + width + dx + 1;
            vctr[1] = offsety - 1;
            v2s( vctr );

            vctr[0] = offsetx + width + dx + 1;
            vctr[1] = offsety + height + 1;
            v2s( vctr );

            vctr[0] = offsetx + width;
            vctr[1] = offsety + height + 1;
            v2s( vctr );
        }
        if ( dy > 0 ) {

            vctr[0] = offsetx - 1;
            vctr[1] = offsety - 1;
            v2s( vctr );

            vctr[0] = offsetx + width + 1;
            vctr[1] = offsety - 1;
            v2s( vctr );

            vctr[0] = offsetx + width + 1;
            vctr[1] = offsety + dy;
            v2s( vctr );

            vctr[0] = offsetx - 1;
            vctr[1] = offsety + dy;
            v2s( vctr );
        } else {

            vctr[0] = offsetx - 1;
            vctr[1] = offsety + height;
            v2s( vctr );

            vctr[0] = offsetx + width + 1;
            vctr[1] = offsety + height;
            v2s( vctr );

            vctr[0] = offsetx + width + 1;
            vctr[1] = offsety + height + dy + 1;
            v2s( vctr );

            vctr[0] = offsetx - 1;
            vctr[1] = offsety + height + dy + 1;
            v2s( vctr );
        }
    }
    endpolygon();

     mvReleaseIrisGL();
}

The disadvantage of the automatic mvGrabIrisGL() – mvReleaseIrisGL() method is that you can't really synchronize the graphics and movie displays, so some things might not display exactly when you want them to.

This section describes a method that lets you disable the Movie Library's automatic display so that your application can control the display of movie frames. When you have explicit control over the display of movie frames, you can tell the Movie Library exactly when to show a frame. This technique lets you draw IRIS GL graphics on top of the movie frame.

To have your application (rather than the Movie Library) control the display of movie frames, call mvSetFrameDisplay(DM_FALSE). Its function prototype is:

void mvSetFrameDisplay ( DMboolean showframes )

where:

To retrieve the current frame display setting, call mvGetFrameDisplay(). Its function prototype is:

DMboolean mvGetFrameDisplay ( void )

When you disable the frame display, you have to tell the Movie Library when to display a frame by calling mvShowCurrentFrame() for every frame that you want to display. Its function prototype is:

void mvShowCurrentFrame ( MVid movieid )

To play a movie with manual frame display, you should include MV_EVENT_FRAME events in your event mask and call mvShowCurrentFrame() in response to those events.

Another way to use mvShowCurrentFrame() is to repaint a movie frame in response to an expose event from the window manager. See “Handling X Window Events” for more details.

You must use one of the two methods described in this section if you want to draw with the IRIS GL while using the Movie Library. The IRIS GL and the Movie Library use separate threads of execution, and the routines discussed in this section supply internal synchronization between the processes. The results of any other method of combining graphics and movies are unpredictable. See Appendix E, “Using Graphics and Share Groups,” in the Graphics Library Programming Guide for more information.

---

Tip: Advanced programmers might want to turn off the frame display in order to use a double-buffered RGB window. In this case, you have to create a window with the graphics configuration that you want, and you must call swapbuffers() from the GL and mvShowCurrentFrame() from the Movie Library yourself for every frame. This method is only for special cases; it is not the recommended way to combine graphics and movies.

---

Example 30-7 is an excerpt from moviescreenEvents.c , in /usr/people/4Dgifts/examples/dmedia/movie/moviescreen, that uses mvSetFrameDisplay() to temporarily disable movie display while initialization routines are carried out.

static void initSaverMovie( )
{
    MVid        newMovie;
    char        *movieName;

    movieName = pickMovieAtRandom( );

    if ( mvOpenFile( movieName, O_RDONLY, &newMovie ) ==
                     DM_FAILURE ) {
        printf("%s: Could not open movie %s\n",
               getProgramName(),movieName );
        exit( EXIT_FAILURE );
    }
    setMovieID( newMovie );

    /*
     * Disable movie display temporarily,
     * to avoid visual glitches.
     */

    mvSetFrameDisplay( DM_FALSE );

    setupMovieWindow( newMovie );
    setPlaybackLoopmode( newMovie );
    setVolumeLevel( newMovie );

    /*
     * play the movie
     */

    mvSetCurrentFrame( newMovie, 0 );
    mvSetFrameDisplay( DM_TRUE );
    mvPlay( newMovie );
}

An event mask specifies which events the application is interested in processing. The event mask is a bitwise or of the events.

Table 30-1 lists and describes the Movie Library events.

To set an event mask, call mvSetSelectEvents(). Its function prototype is:

void mvSetSelectEvents ( MVeventmask eventmask )

where:

For example, to receive all events, use the following:

mvSetSelectEvents( MV_EVENT_MASK_FRAME | MV_EVENT_MASK_STOP |
              MV_EVENT_MASK_ERROR | MV_EVENT_MASK_SLOW_PLAY )

To retrieve the current setting of the event mask, call mvGetSelectEvents(). Its function prototype is:

MVeventmask mvGetSelectEvents ( void )

Movie events are contained in an MVevent structure, which is a union of all of the Movie Library event structures. Each event structure contains fields that store information about the event. Some events have additional fields containing event-specific information.

Table 30-2 lists and describes the fields in the movie events.

See “Handling Movie Events” for an explanation of how to handle movie events, and see Example 30-9 for a code fragment that branches depending on the event type and then extracts information from the event fields.

The Movie Library provides a file descriptor that becomes active when you can read events from the movie event queue. To get a file descriptor for the movie event queue, call mvGetEventFD(). Its function prototype is:

DMstatus mvGetEventFD ( int *fdreturn )

where:

After you have set up the event mask and obtained a file descriptor for the movie event queue, you can create the event loop. You'll probably want to define separate window and movie event handling functions and call them from main().

Use one of the following methods to listen for movie and X11 events.

If you are using Xt or IRIS IM, you'll use the Movie Library routines for handling movie events that are described in this section, but you'll get the events from the X11 queue, as described in “Handling X Window Events”, so skip ahead to “Waiting for Movie Events” in this section to learn how to handle movie events.

If you are using Xlib, you need to create a loop that uses select() or poll() to wait for Movie Library events using a file descriptor set (fd_set). The basic structure of this loop is:

/* wait for libmovie events */
select(...);

/* process all libmovie events on queue before waiting again */
while ( mvPendingEvents() != 0 ) {
    mvNextEvent(&event);
    switch( event ) {
        /* ... */
    }
}

static DMstatus setupFDSet( Display *dpy, int *movieFD,
                           int *xFD, fd_set *theFDSet )
{
 
      if ( mvGetEventFD( movieFD ) != DM_SUCCESS ) {
        fprintf( stderr, "%s: Could not get movie event FD.\n",
            programName );
        return DM_FAILURE;
    }

    *xFD = ConnectionNumber( dpy );

    FD_ZERO( theFDSet );
    FD_SET( *movieFD, theFDSet );
    FD_SET( *xFD, theFDSet );

    return DM_SUCCESS;
}

int mvPendingEvents ( void )

void mvNextEvent ( MVevent* eventreturn )

void mvPeekEvent ( MVevent* eventreturn )

static DMboolean handleMovieEvents( )
{
    MVevent event;
 
    while ( mvPendingEvents() != 0 ) {
        mvNextEvent( &event );
        switch ( event.type ) {
            case MV_EVENT_FRAME:                /* a frame played */

                /* Uncomment and recompile to see which frames are played.
                 * 
                 * 
                 * printf( "%s: Played frame %d of movie %d.\n", 
                 *        getProgramName(), event.mvframe.frame, 
                 *        event.mvframe.id );
                 */

                break;

            case MV_EVENT_STOP:                 /* end of movie */
                printf( "%s: Playback of movie %d stopped.\n",
                       getProgramName(), event.mvstop.id );
                break;

            case MV_EVENT_ERROR:                /* error */
                fprintf( stderr, "%s: Error during playback: %s.\n",
                        getProgramName(), mvGetErrorStr( mvGetErrno() ) );
                return DM_FALSE;
                break;
        }
    }
    return DM_TRUE;
}

The method for handling the X events depends on whether you use Xlib or an X toolkit:

The two window events of greatest concern to Movie Library programmers are expose and resize events.

If a window containing a movie gets exposed, you must repaint the window; if it gets resized, you must resize and repaint the window.

To resize the window identified by win on the display dpy, call mvResizeWindow(). Its function prototype is:

void mvResizeWindow ( Display* dpy, Window win )

To repaint a window, call mvShowCurrentFrame(). Its function prototype is:

void mvShowCurrentFrame ( MVid movieid )

Example 30-10 is an excerpt from simplemovie.c , in /usr/people/4Dgifts/examples/dmedia/movie/misc, that shows how to handle window events from the X11 queue, in particular, expose and resize events. See “Creating a Simple Keyboard Interface for Playing Movies” in Chapter 32 for more information about simplemovie.c.

static DMboolean handleXEvents( MVid theMovie, Display *dpy, Window win )
{
    XEvent event;

    while ( XPending( dpy ) != 0 ) {

        XNextEvent( dpy, &event );

        switch ( event.type ) {
            case Expose:                     /* repaint display */
                mvShowCurrentFrame( theMovie );
                break;

            case ConfigureNotify:            /* window was resized */
                {
                    XWindowAttributes winAttrs;
                    int actual_width, actual_height;

                    mvResizeWindow( dpy, win );

                    XGetWindowAttributes( dpy, win, &winAttrs );

                    mvQueryViewSize( theMovie, winAttrs.width,
                                     winAttrs.height, DM_TRUE,
                                     &actual_width, &actual_height );
                    printf( "%s: actual width = %d, height = %d\n", 
                           programName, actual_width, actual_height );

                    mvSetViewSize( theMovie, winAttrs.width,
                                  winAttrs.height, DM_TRUE );
                }
                break;
…
        }
    }
 return DM_TRUE;
}

The Movie Library checks the playback speed once per second and sends a slow play event to the movie event queue if it finds that the last second of playback was too slow.

To check for slow playback, you must:

To check playback speed more frequently, you can choose to receive frame events and compute the difference between the two timestamps, which is the real time in milliseconds that has elapsed between the two events.

Playback may be slow because: