sdl.c

VLC Player Source Code

    {
        switch( event.type )
        {
        /* Resizing of window */
        case SDL_VIDEORESIZE:
            p_vout->i_changes |= VOUT_SIZE_CHANGE;
            p_vout->i_window_width = p_vout->p_sys->i_width = event.resize.w;
            p_vout->i_window_height = p_vout->p_sys->i_height = event.resize.h;
            break;

        /* Mouse move */
        case SDL_MOUSEMOTION:
            vout_PlacePicture( p_vout, p_vout->p_sys->i_width,
                               p_vout->p_sys->i_height,
                               &i_x, &i_y, &i_width, &i_height );

            /* Compute the x coordinate and check if the value is
               in [0,p_vout->fmt_in.i_visible_width] */
            val.i_int = ( event.motion.x - i_x ) *
                        p_vout->fmt_in.i_visible_width / i_width +
                        p_vout->fmt_in.i_x_offset;

            if( (int)(event.motion.x - i_x) < 0 )
                val.i_int = 0;
            else if( (unsigned int)val.i_int > p_vout->fmt_in.i_visible_width )
                val.i_int = p_vout->fmt_in.i_visible_width;

            var_Set( p_vout, "mouse-x", val );

            /* compute the y coordinate and check if the value is
               in [0,p_vout->fmt_in.i_visible_height] */
            val.i_int = ( event.motion.y - i_y ) *
                        p_vout->fmt_in.i_visible_height / i_height +
                        p_vout->fmt_in.i_y_offset;

            if( (int)(event.motion.y - i_y) < 0 )
                val.i_int = 0;
            else if( (unsigned int)val.i_int > p_vout->fmt_in.i_visible_height )
                val.i_int = p_vout->fmt_in.i_visible_height;

            var_Set( p_vout, "mouse-y", val );

            val.b_bool = true;
            var_Set( p_vout, "mouse-moved", val );

            if( p_vout->p_sys->b_cursor )
            {
                if( p_vout->p_sys->b_cursor_autohidden )
                {
                    p_vout->p_sys->b_cursor_autohidden = 0;
                    SDL_ShowCursor( 1 );
                }
                else
                {
                    p_vout->p_sys->i_lastmoved = mdate();
                }
            }
            break;

        /* Mouse button released */
        case SDL_MOUSEBUTTONUP:
            switch( event.button.button )
            {
            case SDL_BUTTON_LEFT:
                {
                    var_Get( p_vout, "mouse-button-down", &val );
                    val.i_int &= ~1;
                    var_Set( p_vout, "mouse-button-down", val );

                    val.b_bool = true;
                    var_Set( p_vout, "mouse-clicked", val );

                    val.b_bool = false;
                    var_Set( p_vout->p_libvlc, "intf-popupmenu", val );
                }
                break;

            case SDL_BUTTON_MIDDLE:
                {
                    var_Get( p_vout, "mouse-button-down", &val );
                    val.i_int &= ~2;
                    var_Set( p_vout, "mouse-button-down", val );

                    vlc_value_t val;
                    var_Get( p_vout->p_libvlc, "intf-show", &val );
                    val.b_bool = !val.b_bool;
                    var_Set( p_vout->p_libvlc, "intf-show", val );
                }
                break;

            case SDL_BUTTON_RIGHT:
                {
                    intf_thread_t *p_intf;

                    var_Get( p_vout, "mouse-button-down", &val );
                    val.i_int &= ~4;
                    var_Set( p_vout, "mous-button-down", val );
                    p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
                                                      FIND_ANYWHERE );
                    if( p_intf )
                    {
                        p_intf->b_menu_change = 1;
                        vlc_object_release( p_intf );
                    }

                    val.b_bool = true;
                    var_Set( p_vout->p_libvlc, "intf-popupmenu", val );
                }
                break;
            }
            break;

        /* Mouse button pressed */
        case SDL_MOUSEBUTTONDOWN:
            switch( event.button.button )
            {
            case SDL_BUTTON_LEFT:
                var_Get( p_vout, "mouse-button-down", &val );
                val.i_int |= 1;
                var_Set( p_vout, "mouse-button-down", val );

                /* detect double-clicks */
                if( ( mdate() - p_vout->p_sys->i_lastpressed ) < 300000 )
                    p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;

                p_vout->p_sys->i_lastpressed = mdate();
                break;

            case SDL_BUTTON_MIDDLE:
                var_Get( p_vout, "mouse-button-down", &val );
                val.i_int |= 2;
                var_Set( p_vout, "mouse-button-down", val );
                break;

            case SDL_BUTTON_RIGHT:
                var_Get( p_vout, "mouse-button-down", &val );
                val.i_int |= 4;
                var_Set( p_vout, "mouse-button-down", val );
                break;
            }
            break;

        /* Quit event (close the window) */
        case SDL_QUIT:
            {
#if 0
                playlist_t *p_playlist = pl_Yield( p_vout );
                if( p_playlist != NULL )
                {
                    playlist_Stop( p_playlist );
                    pl_Release( p_vout );
                }
#else
#warning FIXME FIXME ?
#endif
            }
            break;

        /* Key pressed */
        case SDL_KEYDOWN:
            /* convert the key if possible */
            val.i_int = ConvertKey( event.key.keysym.sym );

            if( !val.i_int )
            {
                /* Find the right caracter */
                if( ( event.key.keysym.unicode & 0xff80 ) == 0 )
                {
                    val.i_int = event.key.keysym.unicode & 0x7f;
                    /* FIXME: find a better solution than this
                              hack to find the right caracter */
                    if( val.i_int >= 1 && val.i_int <= 26 )
                        val.i_int += 96;
                    else if( val.i_int >= 65 && val.i_int <= 90 )
                        val.i_int += 32;
                }
            }

            if( val.i_int )
            {
                if( ( event.key.keysym.mod & KMOD_SHIFT ) )
                {
                    val.i_int |= KEY_MODIFIER_SHIFT;
                }
                if( ( event.key.keysym.mod & KMOD_CTRL ) )
                {
                    val.i_int |= KEY_MODIFIER_CTRL;
                }
                if( ( event.key.keysym.mod & KMOD_ALT ) )
                {
                    val.i_int |= KEY_MODIFIER_ALT;
                }
                var_Set( p_vout->p_libvlc, "key-pressed", val );
            }

        default:
            break;
        }
    }

    /* Fullscreen change */
    if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
    {
        vlc_value_t val_fs;

        /* Update the object variable and trigger callback */
        val_fs.b_bool = !p_vout->b_fullscreen;
        p_vout->b_fullscreen = !p_vout->b_fullscreen;
        var_Set( p_vout, "fullscreen", val_fs );

        /*TODO: add the "always on top" code here !*/

        p_vout->p_sys->b_cursor_autohidden = 0;
        SDL_ShowCursor( p_vout->p_sys->b_cursor &&
                        ! p_vout->p_sys->b_cursor_autohidden );

        p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
        p_vout->i_changes |= VOUT_SIZE_CHANGE;
    }

    /* Crop or Aspect Ratio Changes */
    if( p_vout->i_changes & VOUT_CROP_CHANGE ||
        p_vout->i_changes & VOUT_ASPECT_CHANGE )
    {
        p_vout->i_changes &= ~VOUT_CROP_CHANGE;
        p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;

        p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
        p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
        p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
        p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
        p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
        p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
        p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
        p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;

        p_vout->i_changes |= VOUT_SIZE_CHANGE;
    }

    /* Size change */
    if( p_vout->i_changes & VOUT_SIZE_CHANGE )
    {
        msg_Dbg( p_vout, "video display resized (%dx%d)",
                 p_vout->p_sys->i_width, p_vout->p_sys->i_height );

        CloseDisplay( p_vout );
        OpenDisplay( p_vout );

        /* We don't need to signal the vout thread about the size change if
         * we can handle rescaling ourselves */
        if( p_vout->p_sys->p_overlay != NULL )
            p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
    }

    /* Pointer change */
    if( ! p_vout->p_sys->b_cursor_autohidden &&
        ( mdate() - p_vout->p_sys->i_lastmoved >
            p_vout->p_sys->i_mouse_hide_timeout ) )
    {
        /* Hide the mouse automatically */
        p_vout->p_sys->b_cursor_autohidden = 1;
        SDL_ShowCursor( 0 );
    }

    return VLC_SUCCESS;
}

/*****************************************************************************
 * Key events handling
 *****************************************************************************/
static const struct
{
    SDLKey sdl_key;
    int i_vlckey;
} sdlkeys_to_vlckeys[] =
{
    { SDLK_F1,  KEY_F1 },
    { SDLK_F2,  KEY_F2 },
    { SDLK_F3,  KEY_F3 },
    { SDLK_F4,  KEY_F4 },
    { SDLK_F5,  KEY_F5 },
    { SDLK_F6,  KEY_F6 },
    { SDLK_F7,  KEY_F7 },
    { SDLK_F8,  KEY_F8 },
    { SDLK_F9,  KEY_F9 },
    { SDLK_F10, KEY_F10 },
    { SDLK_F11, KEY_F11 },
    { SDLK_F12, KEY_F12 },

    { SDLK_RETURN, KEY_ENTER },
    { SDLK_KP_ENTER, KEY_ENTER },
    { SDLK_SPACE, KEY_SPACE },
    { SDLK_ESCAPE, KEY_ESC },

    { SDLK_MENU, KEY_MENU },
    { SDLK_LEFT, KEY_LEFT },
    { SDLK_RIGHT, KEY_RIGHT },
    { SDLK_UP, KEY_UP },
    { SDLK_DOWN, KEY_DOWN },

    { SDLK_HOME, KEY_HOME },
    { SDLK_END, KEY_END },
    { SDLK_PAGEUP, KEY_PAGEUP },
    { SDLK_PAGEDOWN,  KEY_PAGEDOWN },

    { SDLK_INSERT, KEY_INSERT },
    { SDLK_DELETE, KEY_DELETE },
    /*TODO: find a equivalent for SDL 
    { , KEY_MEDIA_NEXT_TRACK }
    { , KEY_MEDIA_PREV_TRACK }
    { , KEY_VOLUME_MUTE }
    { , KEY_VOLUME_DOWN }
    { , KEY_VOLUME_UP }
    { , KEY_MEDIA_PLAY_PAUSE }
    { , KEY_MEDIA_PLAY_PAUSE }*/

    { 0, 0 }
};

static int ConvertKey( SDLKey sdl_key )
{
    int i;
    for( i=0; sdlkeys_to_vlckeys[i].sdl_key != 0; i++ )
    {
        if( sdlkeys_to_vlckeys[i].sdl_key == sdl_key )
        {
            return sdlkeys_to_vlckeys[i].i_vlckey;
        }
    }
    return 0;
}


/*****************************************************************************
 * Display: displays previously rendered output
 *****************************************************************************
 * This function sends the currently rendered image to the display.
 *****************************************************************************/
static void Display( vout_thread_t *p_vout, picture_t *p_pic )
{
    unsigned int x, y, w, h;
    SDL_Rect disp;

    vout_PlacePicture( p_vout, p_vout->p_sys->i_width, p_vout->p_sys->i_height,
                       &x, &y, &w, &h );
    disp.x = x;
    disp.y = y;
    disp.w = w;
    disp.h = h;

    if( p_vout->p_sys->p_overlay == NULL )
    {
        /* RGB picture */
        SDL_Flip( p_vout->p_sys->p_display );
    }
    else
    {
        /* Overlay picture */
        SDL_UnlockYUVOverlay( p_pic->p_sys->p_overlay);
        SDL_DisplayYUVOverlay( p_pic->p_sys->p_overlay , &disp );
        SDL_LockYUVOverlay( p_pic->p_sys->p_overlay);
    }
}

/* following functions are local */

/*****************************************************************************
 * OpenDisplay: open and initialize SDL device
 *****************************************************************************
 * Open and initialize display according to preferences specified in the vout