/*    SDL - Simple DirectMedia Layer    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga    This library is free software; you can redistribute it and/or    modify it under the terms of the GNU Library General Public    License as published by the Free Software Foundation; either    version 2 of the License, or (at your option) any later version.    This library is distributed in the hope that it will be useful,    but WITHOUT ANY WARRANTY; without even the implied warranty of    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    Library General Public License for more details.    You should have received a copy of the GNU Library General Public    License along with this library; if not, write to the Free    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    Sam Lantinga    slouken@devolution.com*/#ifdef SAVE_RCSIDstatic char rcsid = "@(#) SDL_video.h,v 1.1 2002/10/20 13:03:12 forgotten Exp";#endif/* Header file for access to the SDL raw framebuffer window */#ifndef _SDL_video_h#define _SDL_video_h#include <stdio.h>#include "SDL_types.h"#include "SDL_mutex.h"#include "SDL_rwops.h"#include "begin_code.h"/* Set up for C function definitions, even when using C++ */#ifdef __cplusplusextern "C" {#endif/* Transparency definitions: These define alpha as the opacity of a surface */#define SDL_ALPHA_OPAQUE 255#define SDL_ALPHA_TRANSPARENT 0/* Useful data types */typedef struct {	Sint16 x, y;	Uint16 w, h;} SDL_Rect;typedef struct {	Uint8 r;	Uint8 g;	Uint8 b;	Uint8 unused;} SDL_Color;typedef struct {	int       ncolors;	SDL_Color *colors;} SDL_Palette;/* Everything in the pixel format structure is read-only */typedef struct SDL_PixelFormat {	SDL_Palette *palette;	Uint8  BitsPerPixel;	Uint8  BytesPerPixel;	Uint8  Rloss;	Uint8  Gloss;	Uint8  Bloss;	Uint8  Aloss;	Uint8  Rshift;	Uint8  Gshift;	Uint8  Bshift;	Uint8  Ashift;	Uint32 Rmask;	Uint32 Gmask;	Uint32 Bmask;	Uint32 Amask;	/* RGB color key information */	Uint32 colorkey;	/* Alpha value information (per-surface alpha) */	Uint8  alpha;} SDL_PixelFormat;/* typedef for private surface blitting functions */struct SDL_Surface;typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,			struct SDL_Surface *dst, SDL_Rect *dstrect);/* This structure should be treated as read-only, except for 'pixels',   which, if not NULL, contains the raw pixel data for the surface.*/typedef struct SDL_Surface {	Uint32 flags;				/* Read-only */	SDL_PixelFormat *format;		/* Read-only */	int w, h;				/* Read-only */	Uint16 pitch;				/* Read-only */	void *pixels;				/* Read-write */	int offset;				/* Private */	/* Hardware-specific surface info */	struct private_hwdata *hwdata;	/* clipping information */	SDL_Rect clip_rect;			/* Read-only */	Uint32 unused1;				/* for binary compatibility */	/* Allow recursive locks */	Uint32 locked;				/* Private */	/* info for fast blit mapping to other surfaces */	struct SDL_BlitMap *map;		/* Private */	/* format version, bumped at every change to invalidate blit maps */	unsigned int format_version;		/* Private */	/* Reference count -- used when freeing surface */	int refcount;				/* Read-mostly */} SDL_Surface;/* These are the currently supported flags for the SDL_surface *//* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */#define SDL_SWSURFACE	0x00000000	/* Surface is in system memory */#define SDL_HWSURFACE	0x00000001	/* Surface is in video memory */#define SDL_ASYNCBLIT	0x00000004	/* Use asynchronous blits if possible *//* Available for SDL_SetVideoMode() */#define SDL_ANYFORMAT	0x10000000	/* Allow any video depth/pixel-format */#define SDL_HWPALETTE	0x20000000	/* Surface has exclusive palette */#define SDL_DOUBLEBUF	0x40000000	/* Set up double-buffered video mode */#define SDL_FULLSCREEN	0x80000000	/* Surface is a full screen display */#define SDL_OPENGL      0x00000002      /* Create an OpenGL rendering context */#define SDL_OPENGLBLIT	0x0000000A	/* Create an OpenGL rendering context and use it for blitting */#define SDL_RESIZABLE	0x00000010	/* This video mode may be resized */#define SDL_NOFRAME	0x00000020	/* No window caption or edge frame *//* Used internally (read-only) */#define SDL_HWACCEL	0x00000100	/* Blit uses hardware acceleration */#define SDL_SRCCOLORKEY	0x00001000	/* Blit uses a source color key */#define SDL_RLEACCELOK	0x00002000	/* Private flag */#define SDL_RLEACCEL	0x00004000	/* Surface is RLE encoded */#define SDL_SRCALPHA	0x00010000	/* Blit uses source alpha blending */#define SDL_PREALLOC	0x01000000	/* Surface uses preallocated memory *//* Evaluates to true if the surface needs to be locked before access */#define SDL_MUSTLOCK(surface)	\  (surface->offset ||		\  ((surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_RLEACCEL)) != 0))/* Useful for determining the video hardware capabilities */typedef struct {	Uint32 hw_available :1;	/* Flag: Can you create hardware surfaces? */	Uint32 wm_available :1;	/* Flag: Can you talk to a window manager? */	Uint32 UnusedBits1  :6;	Uint32 UnusedBits2  :1;	Uint32 blit_hw      :1;	/* Flag: Accelerated blits HW --> HW */	Uint32 blit_hw_CC   :1;	/* Flag: Accelerated blits with Colorkey */	Uint32 blit_hw_A    :1;	/* Flag: Accelerated blits with Alpha */	Uint32 blit_sw      :1;	/* Flag: Accelerated blits SW --> HW */	Uint32 blit_sw_CC   :1;	/* Flag: Accelerated blits with Colorkey */	Uint32 blit_sw_A    :1;	/* Flag: Accelerated blits with Alpha */	Uint32 blit_fill    :1;	/* Flag: Accelerated color fill */	Uint32 UnusedBits3  :16;	Uint32 video_mem;	/* The total amount of video memory (in K) */	SDL_PixelFormat *vfmt;	/* Value: The format of the video surface */} SDL_VideoInfo;/* The most common video overlay formats.   For an explanation of these pixel formats, see:	http://www.webartz.com/fourcc/indexyuv.htm   For information on the relationship between color spaces, see:   http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html */#define SDL_YV12_OVERLAY  0x32315659	/* Planar mode: Y + V + U  (3 planes) */#define SDL_IYUV_OVERLAY  0x56555949	/* Planar mode: Y + U + V  (3 planes) */#define SDL_YUY2_OVERLAY  0x32595559	/* Packed mode: Y0+U0+Y1+V0 (1 plane) */#define SDL_UYVY_OVERLAY  0x59565955	/* Packed mode: U0+Y0+V0+Y1 (1 plane) */#define SDL_YVYU_OVERLAY  0x55595659	/* Packed mode: Y0+V0+Y1+U0 (1 plane) *//* The YUV hardware video overlay */typedef struct SDL_Overlay {	Uint32 format;				/* Read-only */	int w, h;				/* Read-only */	int planes;				/* Read-only */	Uint16 *pitches;			/* Read-only */	Uint8 **pixels;				/* Read-write */	/* Hardware-specific surface info */	struct private_yuvhwfuncs *hwfuncs;	struct private_yuvhwdata *hwdata;	/* Special flags */	Uint32 hw_overlay :1;	/* Flag: This overlay hardware accelerated? */	Uint32 UnusedBits :31;} SDL_Overlay;/* Public enumeration for setting the OpenGL window attributes. */typedef enum {    SDL_GL_RED_SIZE,    SDL_GL_GREEN_SIZE,    SDL_GL_BLUE_SIZE,    SDL_GL_ALPHA_SIZE,    SDL_GL_BUFFER_SIZE,    SDL_GL_DOUBLEBUFFER,    SDL_GL_DEPTH_SIZE,    SDL_GL_STENCIL_SIZE,    SDL_GL_ACCUM_RED_SIZE,    SDL_GL_ACCUM_GREEN_SIZE,    SDL_GL_ACCUM_BLUE_SIZE,    SDL_GL_ACCUM_ALPHA_SIZE} SDL_GLattr;/* flags for SDL_SetPalette() */#define SDL_LOGPAL 0x01#define SDL_PHYSPAL 0x02/* Function prototypes *//* These functions are used internally, and should not be used unless you * have a specific need to specify the video driver you want to use. * You should normally use SDL_Init() or SDL_InitSubSystem(). * * SDL_VideoInit() initializes the video subsystem -- sets up a connection * to the window manager, etc, and determines the current video mode and * pixel format, but does not initialize a window or graphics mode. * Note that event handling is activated by this routine. * * If you use both sound and video in your application, you need to call * SDL_Init() before opening the sound device, otherwise under Win32 DirectX, * you won't be able to set full-screen display modes. */extern DECLSPEC int SDL_VideoInit(const char *driver_name, Uint32 flags);extern DECLSPEC void SDL_VideoQuit(void);/* This function fills the given character buffer with the name of the * video driver, and returns a pointer to it if the video driver has * been initialized.  It returns NULL if no driver has been initialized. */extern DECLSPEC char *SDL_VideoDriverName(char *namebuf, int maxlen);/* * This function returns a pointer to the current display surface. * If SDL is doing format conversion on the display surface, this * function returns the publicly visible surface, not the real video * surface. */extern DECLSPEC SDL_Surface * SDL_GetVideoSurface(void);/* * This function returns a read-only pointer to information about the * video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt' * member of the returned structure will contain the pixel format of the * "best" video mode. */extern DECLSPEC const SDL_VideoInfo * SDL_GetVideoInfo(void);/*  * Check to see if a particular video mode is supported. * It returns 0 if the requested mode is not supported under any bit depth, * or returns the bits-per-pixel of the closest available mode with the * given width and height.  If this bits-per-pixel is different from the * one used when setting the video mode, SDL_SetVideoMode() will succeed, * but will emulate the requested bits-per-pixel with a shadow surface. * * The arguments to SDL_VideoModeOK() are the same ones you would pass to * SDL_SetVideoMode() */extern DECLSPEC int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);/* * Return a pointer to an array of available screen dimensions for the * given format and video flags, sorted largest to smallest.  Returns  * NULL if there are no dimensions available for a particular format,  * or (SDL_Rect **)-1 if any dimension is okay for the given format. * * If 'format' is NULL, the mode list will be for the format given  * by SDL_GetVideoInfo()->vfmt */extern DECLSPEC SDL_Rect ** SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);/* * Set up a video mode with the specified width, height and bits-per-pixel. * * If 'bpp' is 0, it is treated as the current display bits per pixel. * * If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the * requested bits-per-pixel, but will return whatever video pixel format is * available.  The default is to emulate the requested pixel format if it * is not natively available. *