git.sesse.net Git - vlc/blob - plugins/sdl/vout_sdl.c

   1 /*****************************************************************************
   2  * vout_sdl.c: SDL video output display method
   3  *****************************************************************************
   4  * Copyright (C) 1998, 1999, 2000 VideoLAN
   5  *
   6  * Authors:
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #include "defs.h"
  27
  28 #include <errno.h>                                                 /* ENOMEM */
  29 #include <stdlib.h>                                                /* free() */
  30 #include <string.h>                                            /* strerror() */
  31
  32 #include <SDL/SDL.h>
  33
  34 #include "config.h"
  35 #include "common.h"
  36 #include "threads.h"
  37 #include "mtime.h"
  38 #include "plugins.h"
  39
  40 #include "video.h"
  41 #include "video_output.h"
  42
  43 #include "intf_msg.h"
  44
  45 /*****************************************************************************
  46  * vout_sys_t: video output SDL method descriptor
  47  *****************************************************************************
  48  * This structure is part of the video output thread descriptor.
  49  * It describes the SDL specific properties of an output thread.
  50  *****************************************************************************/
  51 typedef struct vout_sys_s
  52 {
  53     SDL_Surface *   p_display;                             /* display device */
  54     Uint8   *   p_buffer[2];
  55                                                      /* Buffers informations */
  56     boolean_t   b_must_acquire;           /* must be acquired before writing */
  57 }   vout_sys_t;
  58
  59 /*****************************************************************************
  60  * Local prototypes
  61  *****************************************************************************/
  62 static int     SDLOpenDisplay   ( vout_thread_t *p_vout,
  63                                   char *psz_display, void *p_data );
  64 static void    SDLCloseDisplay  ( vout_thread_t *p_vout );
  65
  66 /*****************************************************************************
  67  * vout_SDLCreate: allocate SDL video thread output method
  68  *****************************************************************************
  69  * This function allocate and initialize a SDL vout method. It uses some of the
  70  * vout properties to choose the correct mode, and change them according to the
  71  * mode actually used.
  72  *****************************************************************************/
  73 int vout_SDLCreate( vout_thread_t *p_vout, char *psz_display,
  74                     int i_root_window, void *p_data )
  75 {
  76     /* Allocate structure */
  77     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  78     if( p_vout->p_sys == NULL )
  79     {
  80         intf_ErrMsg( "error: %s\n", strerror(ENOMEM) );
  81         return( 1 );
  82     }
  83
  84     /* Open and initialize device */
  85
  86     if( SDLOpenDisplay( p_vout, psz_display, p_data ) )
  87     {
  88         intf_ErrMsg( "error: can't initialize SDL display\n" );
  89         free( p_vout->p_sys );
  90         return( 1 );
  91     }
  92     return( 0 );
  93 }
  94
  95 /*****************************************************************************
  96  * vout_SDLInit: initialize SDL video thread output method
  97  *****************************************************************************
  98  * This function initialize the SDL display device.
  99  *****************************************************************************/
 100 int vout_SDLInit( vout_thread_t *p_vout )
 101 {
 102     /* Acquire first buffer */
 103     if( p_vout->p_sys->b_must_acquire )
 104     {
 105                 SDL_LockSurface(p_vout->p_sys->p_display);
 106     }
 107
 108     return( 0 );
 109 }
 110
 111 /*****************************************************************************
 112  * vout_SDLEnd: terminate Sys video thread output method
 113  *****************************************************************************
 114  * Terminate an output method created by vout_SDLCreate
 115  *****************************************************************************/
 116 void vout_SDLEnd( vout_thread_t *p_vout )
 117 {
 118     /* Release buffer */
 119     if( p_vout->p_sys->b_must_acquire )
 120     {
 121         SDL_UnlockSurface ( p_vout->p_sys->p_display );
 122     }
 123 }
 124
 125 /*****************************************************************************
 126  * vout_SDLDestroy: destroy Sys video thread output method
 127  *****************************************************************************
 128  * Terminate an output method created by vout_SDLCreate
 129  *****************************************************************************/
 130 void vout_SDLDestroy( vout_thread_t *p_vout )
 131 {
 132     SDLCloseDisplay( p_vout );
 133     free( p_vout->p_sys );
 134 }
 135
 136 /*****************************************************************************
 137  * vout_SDLManage: handle Sys events
 138  *****************************************************************************
 139  * This function should be called regularly by video output thread. It returns
 140  * a non null value if an error occured.
 141  *****************************************************************************/
 142 int vout_SDLManage( vout_thread_t *p_vout )
 143 {
 144     /* FIXME: 8bpp: change palette ?? */
 145     return( 0 );
 146 }
 147
 148 /*****************************************************************************
 149  * vout_SDLDisplay: displays previously rendered output
 150  *****************************************************************************
 151  * This function send the currently rendered image to the display, wait until
 152  * it is displayed and switch the two rendering buffer, preparing next frame.
 153  *****************************************************************************/
 154 void vout_SDLDisplay( vout_thread_t *p_vout )
 155 {
 156     SDL_Overlay * screen;
 157     SDL_Rect    disp;
 158     if(1)
 159     {
 160         /* Change display frame */
 161         if( p_vout->p_sys->b_must_acquire )
 162         {
 163
 164             SDL_Flip( p_vout->p_sys->p_display );
 165
 166             /* Swap buffers and change write frame */
 167             SDL_LockSurface ( p_vout->p_sys->p_display );
 168         }
 169     }
 170     else
 171     {
 172         /*
 173          * p_vout->yuv.p_buffer contains the YUV buffer to render
 174          */
 175
 176         screen = SDL_CreateYUVOverlay( p_vout->i_width, p_vout->i_height , SDL_IYUV_OVERLAY, p_vout->p_sys->p_display );
 177         screen->pixels = p_vout->yuv.p_buffer;
 178         disp.x = 0;
 179         disp.y = 0;
 180         disp.w = p_vout->i_width;
 181         disp.h = p_vout->i_height;
 182         SDL_DisplayYUVOverlay( screen , &disp );
 183     }
 184 }
 185
 186 /* following functions are local */
 187
 188 /*****************************************************************************
 189  * SDLOpenDisplay: open and initialize SDL device
 190  *****************************************************************************
 191  * Open and initialize display according to preferences specified in the vout
 192  * thread fields.
 193  *****************************************************************************/
 194 static int SDLOpenDisplay( vout_thread_t *p_vout, char *psz_display, void *p_data )
 195 {
 196
 197     /* Initialize library */
 198     if( SDL_Init(SDL_INIT_VIDEO) < 0 )
 199     {
 200         intf_ErrMsg( "error: can't initialize SDL library: %s\n",
 201                      SDL_GetError() );
 202         return( 1 );
 203     }
 204
 205     /* Open display
 206      * TODO: Check that we can request for a DOUBLEBUF HWSURFACE display
 207      */
 208     if(psz_display != NULL && strcmp(psz_display,"fullscreen")==0)
 209     {
 210         p_vout->p_sys->p_display = SDL_SetVideoMode(p_vout->i_width,
 211             p_vout->i_height,
 212             0,
 213             SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN );
 214         SDL_ShowCursor( 0 );
 215     } else {
 216         p_vout->p_sys->p_display = SDL_SetVideoMode(p_vout->i_width,
 217             p_vout->i_height,
 218             0,
 219             SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF  );
 220         SDL_ShowCursor( 1 );
 221     }
 222
 223     if( p_vout->p_sys->p_display == NULL )
 224     {
 225         intf_ErrMsg( "error: can't open DISPLAY default display\n" );
 226         return( 1 );
 227     }
 228     SDL_WM_SetCaption( VOUT_TITLE , VOUT_TITLE );
 229     SDL_EventState(SDL_KEYUP , SDL_IGNORE);     /* ignore keys up */
 230
 231     /* Check buffers properties */
 232     p_vout->p_sys->b_must_acquire = 1;          /* always acquire */
 233         p_vout->p_sys->p_buffer[ 0 ] =
 234              p_vout->p_sys->p_display->pixels;
 235
 236         SDL_Flip(p_vout->p_sys->p_display);
 237         p_vout->p_sys->p_buffer[ 1 ] =
 238              p_vout->p_sys->p_display->pixels;
 239         SDL_Flip(p_vout->p_sys->p_display);
 240
 241     /* Set graphic context colors */
 242
 243 /*
 244         col_fg.r = col_fg.g = col_fg.b = -1;
 245     col_bg.r = col_bg.g = col_bg.b = 0;
 246     if( ggiSetGCForeground(p_vout->p_sys->p_display,
 247                            ggiMapColor(p_vout->p_sys->p_display,&col_fg)) ||
 248         ggiSetGCBackground(p_vout->p_sys->p_display,
 249                            ggiMapColor(p_vout->p_sys->p_display,&col_bg)) )
 250     {
 251         intf_ErrMsg("error: can't set colors\n");
 252         ggiClose( p_vout->p_sys->p_display );
 253         ggiExit();
 254         return( 1 );
 255     }
 256 */
 257
 258     /* Set clipping for text */
 259     SDL_SetClipping(p_vout->p_sys->p_display, 0, 0,
 260                     p_vout->p_sys->p_display->w,
 261                     p_vout->p_sys->p_display->h);
 262
 263
 264
 265     /* Set thread information */
 266     p_vout->i_width =           p_vout->p_sys->p_display->w;
 267     p_vout->i_height =          p_vout->p_sys->p_display->h;
 268
 269     p_vout->i_bytes_per_line = p_vout->p_sys->p_display->format->BytesPerPixel *
 270                                 p_vout->p_sys->p_display->w ;
 271
 272     p_vout->i_screen_depth =    p_vout->p_sys->p_display->format->BitsPerPixel;
 273     p_vout->i_bytes_per_pixel = p_vout->p_sys->p_display->format->BytesPerPixel;
 274     p_vout->i_red_mask =        p_vout->p_sys->p_display->format->Rmask;
 275     p_vout->i_green_mask =      p_vout->p_sys->p_display->format->Gmask;
 276     p_vout->i_blue_mask =       p_vout->p_sys->p_display->format->Bmask;
 277
 278     /* FIXME: palette in 8bpp ?? */
 279     /* Set and initialize buffers */
 280     vout_SetBuffers( p_vout, p_vout->p_sys->p_buffer[ 0 ],
 281                              p_vout->p_sys->p_buffer[ 1 ] );
 282
 283     return( 0 );
 284 }
 285
 286 /*****************************************************************************
 287  * SDLCloseDisplay: close and reset SDL device
 288  *****************************************************************************
 289  * This function returns all resources allocated by SDLOpenDisplay and restore
 290  * the original state of the device.
 291  *****************************************************************************/
 292 static void SDLCloseDisplay( vout_thread_t *p_vout )
 293 {
 294     SDL_FreeSurface( p_vout->p_sys->p_display );
 295     SDL_Quit();
 296 }
 297