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     free( p_vout->p_sys );
 124 }
 125
 126 /*****************************************************************************
 127  * vout_SDLDestroy: destroy Sys video thread output method
 128  *****************************************************************************
 129  * Terminate an output method created by vout_SDLCreate
 130  *****************************************************************************/
 131 void vout_SDLDestroy( vout_thread_t *p_vout )
 132 {
 133     // SDLCloseDisplay( p_vout );
 134     free( p_vout->p_sys );
 135 }
 136
 137 /*****************************************************************************
 138  * vout_SDLManage: handle Sys events
 139  *****************************************************************************
 140  * This function should be called regularly by video output thread. It returns
 141  * a non null value if an error occured.
 142  *****************************************************************************/
 143 int vout_SDLManage( vout_thread_t *p_vout )
 144 {
 145     /* FIXME: 8bpp: change palette ?? */
 146     return( 0 );
 147 }
 148
 149 /*****************************************************************************
 150  * vout_SDLDisplay: displays previously rendered output
 151  *****************************************************************************
 152  * This function send the currently rendered image to the display, wait until
 153  * it is displayed and switch the two rendering buffer, preparing next frame.
 154  *****************************************************************************/
 155 void vout_SDLDisplay( vout_thread_t *p_vout )
 156 {
 157     SDL_Overlay * screen;
 158     SDL_Rect    disp;
 159     if(1)
 160     {
 161         /* Change display frame */
 162         if( p_vout->p_sys->b_must_acquire )
 163         {
 164             SDL_Flip( p_vout->p_sys->p_display );
 165         }
 166         /* Swap buffers and change write frame */
 167         if( p_vout->p_sys->b_must_acquire )
 168         {
 169             SDL_LockSurface ( p_vout->p_sys->p_display );
 170         }
 171     }
 172     else
 173     {
 174         /*
 175          * p_vout->yuv.p_buffer contains the YUV buffer to render
 176          */
 177
 178         screen = SDL_CreateYUVOverlay( p_vout->i_width, p_vout->i_height , SDL_IYUV_OVERLAY, p_vout->p_sys->p_display );
 179         screen->pixels = p_vout->yuv.p_buffer;
 180         disp.x = 0;
 181         disp.y = 0;
 182         disp.w = p_vout->i_width;
 183         disp.h = p_vout->i_height;
 184         SDL_DisplayYUVOverlay( screen , &disp );
 185     }
 186 }
 187
 188 /* following functions are local */
 189
 190 /*****************************************************************************
 191  * SDLOpenDisplay: open and initialize SDL device
 192  *****************************************************************************
 193  * Open and initialize display according to preferences specified in the vout
 194  * thread fields.
 195  *****************************************************************************/
 196 static int SDLOpenDisplay( vout_thread_t *p_vout, char *psz_display, void *p_data )
 197 {
 198     /* Initialize library */
 199     if( SDL_Init(SDL_INIT_VIDEO) < 0 )
 200     {
 201         intf_ErrMsg( "error: can't initialize SDL library: %s\n",
 202                      SDL_GetError() );
 203         return( 1 );
 204     }
 205
 206     /* Open display
 207      * TODO: Check that we can request for a DOUBLEBUF HWSURFACE display
 208      */
 209     if(psz_display != NULL && strcmp(psz_display,"fullscreen")==0)
 210     {
 211         p_vout->p_sys->p_display = SDL_SetVideoMode(p_vout->i_width,
 212             p_vout->i_height,
 213             15,
 214             SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN );
 215     } else {
 216         p_vout->p_sys->p_display = SDL_SetVideoMode(p_vout->i_width,
 217             p_vout->i_height,
 218             15,
 219             SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF );
 220     }
 221
 222     if( p_vout->p_sys->p_display == NULL )
 223     {
 224         intf_ErrMsg( "error: can't open DISPLAY default display\n" );
 225         return( 1 );
 226     }
 227     SDL_EventState(SDL_KEYUP , SDL_IGNORE);     /* ignore keys up */
 228
 229     /* Check buffers properties */
 230     p_vout->p_sys->b_must_acquire = 1;          /* always acquire */
 231         p_vout->p_sys->p_buffer[ 0 ] =
 232              p_vout->p_sys->p_display->pixels;
 233
 234         SDL_Flip(p_vout->p_sys->p_display);
 235         p_vout->p_sys->p_buffer[ 1 ] =
 236              p_vout->p_sys->p_display->pixels;
 237         SDL_Flip(p_vout->p_sys->p_display);
 238
 239     /* Set graphic context colors */
 240
 241 /*
 242         col_fg.r = col_fg.g = col_fg.b = -1;
 243     col_bg.r = col_bg.g = col_bg.b = 0;
 244     if( ggiSetGCForeground(p_vout->p_sys->p_display,
 245                            ggiMapColor(p_vout->p_sys->p_display,&col_fg)) ||
 246         ggiSetGCBackground(p_vout->p_sys->p_display,
 247                            ggiMapColor(p_vout->p_sys->p_display,&col_bg)) )
 248     {
 249         intf_ErrMsg("error: can't set colors\n");
 250         ggiClose( p_vout->p_sys->p_display );
 251         ggiExit();
 252         return( 1 );
 253     }
 254 */
 255
 256     /* Set clipping for text */
 257     SDL_SetClipping(p_vout->p_sys->p_display, 0, 0,
 258                          p_vout->p_sys->p_display->w,
 259                          p_vout->p_sys->p_display->h );
 260
 261
 262
 263     /* Set thread information */
 264     p_vout->i_width =           p_vout->p_sys->p_display->w;
 265     p_vout->i_height =          p_vout->p_sys->p_display->h;
 266
 267     p_vout->i_bytes_per_line = p_vout->p_sys->p_display->format->BytesPerPixel *
 268                                 p_vout->p_sys->p_display->w ;
 269
 270     p_vout->i_screen_depth =    p_vout->p_sys->p_display->format->BitsPerPixel;
 271     p_vout->i_bytes_per_pixel = p_vout->p_sys->p_display->format->BytesPerPixel;
 272     p_vout->i_red_mask =        p_vout->p_sys->p_display->format->Rmask;
 273     p_vout->i_green_mask =      p_vout->p_sys->p_display->format->Gmask;
 274     p_vout->i_blue_mask =       p_vout->p_sys->p_display->format->Bmask;
 275
 276     /* FIXME: palette in 8bpp ?? */
 277     /* Set and initialize buffers */
 278     vout_SetBuffers( p_vout, p_vout->p_sys->p_buffer[ 0 ],
 279                              p_vout->p_sys->p_buffer[ 1 ] );
 280
 281     return( 0 );
 282 }
 283
 284 /*****************************************************************************
 285  * SDLCloseDisplay: close and reset SDL device
 286  *****************************************************************************
 287  * This function returns all resources allocated by SDLOpenDisplay and restore
 288  * the original state of the device.
 289  *****************************************************************************/
 290 static void SDLCloseDisplay( vout_thread_t *p_vout )
 291 {
 292     SDL_FreeSurface( p_vout->p_sys->p_display );
 293     SDL_Quit();
 294 }
 295