;; /*
;;     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_RCSID
;; static char rcsid =
;;  "@(#) $Id: SDL_video.lsh,v 1.2 2002/10/28 19:55:43 profshadoko Exp $";
;; #endif
;; 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(de SDL_video_dummy () (sdlheader "SDL_video.h"))

;; /* 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 __cplusplus
;; extern "C" {
;; #endif
;; 
;; /* Transparency definitions: These define alpha as the opacity of a surface */
(libload "libc/constants")

(defconstant "SDL_ALPHA_OPAQUE" 255)
(defconstant "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() */
(defconstant "SDL_SWSURFACE"	0x00000000) ;	/* Surface is in system memory */
(defconstant "SDL_HWSURFACE"	0x00000001) ;	/* Surface is in video memory */
(defconstant "SDL_ASYNCBLIT"	0x00000004) ;	/* Use asynchronous blits if possible */
;; /* Available for SDL_SetVideoMode() */
(defconstant "SDL_ANYFORMAT"	0x10000000) ;	/* Allow any video depth/pixel-format */
(defconstant "SDL_HWPALETTE"	0x20000000) ;	/* Surface has exclusive palette */
(defconstant "SDL_DOUBLEBUF"	0x40000000) ;	/* Set up double-buffered video mode */
(defconstant "SDL_FULLSCREEN"	0x80000000) ;	/* Surface is a full screen display */
(defconstant "SDL_OPENGL"      0x00000002) ;      /* Create an OpenGL rendering context */
(defconstant "SDL_OPENGLBLIT"	0x0000000A) ;	/* Create an OpenGL rendering context and use it for blitting */
(defconstant "SDL_RESIZABLE"	0x00000010) ;	/* This video mode may be resized */
(defconstant "SDL_NOFRAME"	0x00000020) ;	/* No window caption or edge frame */
;; /* Used internally (read-only) */
(defconstant "SDL_HWACCEL"	0x00000100) ;	/* Blit uses hardware acceleration */
(defconstant "SDL_SRCCOLORKEY"	0x00001000) ;	/* Blit uses a source color key */
(defconstant "SDL_RLEACCELOK"	0x00002000) ;	/* Private flag */
(defconstant "SDL_RLEACCEL"	0x00004000) ;	/* Surface is RLE encoded */
(defconstant "SDL_SRCALPHA"	0x00010000) ;	/* Blit uses source alpha blending */
(defconstant "SDL_PREALLOC"	0x01000000) ;	/* Surface uses preallocated memory */
;; 
#? (SDL_MUSTLOCK <surface>)
;;.PRE
;; /* 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))
(de SDL_MUSTLOCK(surface)
    ((-gptr- "SDL_Surface *") surface)
    (bool #{  SDL_MUSTLOCK($surface) #}))

;; 
;; 
;; /* 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
;;  */
(defconstant "SDL_YV12_OVERLAY"  0x32315659) ;	/* Planar mode: Y + V + U  (3 planes) */
(defconstant "SDL_IYUV_OVERLAY"  0x56555949) ;	/* Planar mode: Y + U + V  (3 planes) */
(defconstant "SDL_YUY2_OVERLAY"  0x32595559) ;	/* Packed mode: Y0+U0+Y1+V0 (1 plane) */
(defconstant "SDL_UYVY_OVERLAY"  0x59565955) ;	/* Packed mode: U0+Y0+V0+Y1 (1 plane) */
(defconstant "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() */

(defconstant "SDL_GL_RED_SIZE" 0)
(defconstant "SDL_GL_GREEN_SIZE" 1)
(defconstant "SDL_GL_BLUE_SIZE" 2)
(defconstant "SDL_GL_ALPHA_SIZE" 3)
(defconstant "SDL_GL_BUFFER_SIZE" 4)
(defconstant "SDL_GL_DOUBLEBUFFER" 5)
(defconstant "SDL_GL_DEPTH_SIZE" 6)
(defconstant "SDL_GL_STENCIL_SIZE" 7)
(defconstant "SDL_GL_ACCUM_RED_SIZE" 8)
(defconstant "SDL_GL_ACCUM_GREEN_SIZE" 9)
(defconstant "SDL_GL_ACCUM_BLUE_SIZE" 10)
(defconstant "SDL_GL_ACCUM_ALPHA_SIZ" 11)


(defconstant "SDL_LOGPAL" 0x01) ;
(defconstant "SDL_PHYSPAL" 0x02) ;
;; 
;; /* Function prototypes */
;; 
#? (SDL_VideoInit <driver_name> <flags>)
;;.PRE
;; /* 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);
(de SDL_VideoInit(driver_name flags)
    ((-str-) driver_name)
    ((Uint32) flags)
    (int #{ SDL_VideoInit((char *)$driver_name->data, $flags) #}))

#? (SDL_VideoQuit)
;;.PRE
;; extern DECLSPEC void SDL_VideoQuit(void);
(de SDL_VideoQuit()
    #{ SDL_VideoQuit() #} ())

;; 
#? (SDL_VideoDriverName <namebuf> <maxlen>)
;;.PRE
;; /* 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);
(de SDL_VideoDriverName(namebuf maxlen)
    ((-gptr- "char *") namebuf)
    ((-int-) maxlen)
    (gptr #{ SDL_VideoDriverName($namebuf, $maxlen) #}))

#? (SDL_GetVideoSurface)
;;.PRE
;; /*
;;  * 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);
(de SDL_GetVideoSurface()
    (gptr #{ SDL_GetVideoSurface() #}))

#? (SDL_GetVideoInfo)
;;.PRE
;; /*
;;  * 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);
(de SDL_GetVideoInfo()
    (gptr #{ SDL_GetVideoInfo() #}))

#? (SDL_VideoModeOK <width> <height> <bpp> <flags>)
;;.PRE
;; /* 
;;  * 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);
(de SDL_VideoModeOK(width height bpp flags)
    ((-int-) width height bpp flags)
    (int #{  SDL_VideoModeOK($width, $height, $bpp, $flags) #}))

#? (SDL_ListModes <format> <flags>)
;;.PRE
;; /*
;;  * 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);
(de SDL_ListModes(format flags)
    ((-gptr- "SDL_PixelFormat *") format)
    ((Uint32) flags)
    (gptr #{ SDL_ListModes($format, $flags) #}))

#? (SDL_SetVideoMode <width> <height> <bpp> <flags>)
;;.PRE
;; /*
;;  * 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.
;;  *
;;  * If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
;;  * video memory, if possible, and you may have to call SDL_LockSurface()
;;  * in order to access the raw framebuffer.  Otherwise, the video surface
;;  * will be created in system memory.
;;  *
;;  * If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
;;  * updates asynchronously, but you must always lock before accessing pixels.
;;  * SDL will wait for updates to complete before returning from the lock.
;;  *
;;  * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
;;  * that the colors set by SDL_SetColors() will be the colors you get.
;;  * Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
;;  * of the colors exactly the way they are requested, and you should look
;;  * at the video surface structure to determine the actual palette.
;;  * If SDL cannot guarantee that the colors you request can be set, 
;;  * i.e. if the colormap is shared, then the video surface may be created
;;  * under emulation in system memory, overriding the SDL_HWSURFACE flag.
;;  *
;;  * If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
;;  * a fullscreen video mode.  The default is to create a windowed mode
;;  * if the current graphics system has a window manager.
;;  * If the SDL library is able to set a fullscreen video mode, this flag 
;;  * will be set in the surface that is returned.
;;  *
;;  * If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
;;  * two surfaces in video memory and swap between them when you call 
;;  * SDL_Flip().  This is usually slower than the normal single-buffering
;;  * scheme, but prevents "tearing" artifacts caused by modifying video 
;;  * memory while the monitor is refreshing.  It should only be used by 
;;  * applications that redraw the entire screen on every update.
;;  *
;;  * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
;;  * window manager, if any, to resize the window at runtime.  When this
;;  * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
;;  * and you must respond to the event by re-calling SDL_SetVideoMode()
;;  * with the requested size (or another size that suits the application).
;;  *
;;  * If SDL_NOFRAME is set in 'flags', the SDL library will create a window
;;  * without any title bar or frame decoration.  Fullscreen video modes have
;;  * this flag set automatically.
;;  *
;;  * This function returns the video framebuffer surface, or NULL if it fails.
;;  *
;;  * If you rely on functionality provided by certain video flags, check the
;;  * flags of the returned surface to make sure that functionality is available.
;;  * SDL will fall back to reduced functionality if the exact flags you wanted
;;  * are not available.
;;  */
;; extern DECLSPEC SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags);
(de SDL_SetVideoMode(width height bpp flags)
  ((-int-) width height bpp flags)
  (gptr #{ SDL_SetVideoMode($width, $height, $bpp, $flags) #}))

;; 
#? (SDL_UpdateRects <screen> <numrects> <rects>)
;;.PRE
;; /*
;;  * Makes sure the given list of rectangles is updated on the given screen.
;;  * If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
;;  * screen.
;;  * These functions should not be called while 'screen' is locked.
;;  */
;; extern DECLSPEC void SDL_UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects);
(de SDL_UpdateRects(screen numrects rects)
  ((-gptr- "SDL_Surface *") screen)
  ((-gptr- "SDL_Rect *") rects)
  ((-int-) numrects)
  #{ SDL_UpdateRects($screen, $numrects, $rects) #} ())

#? (SDL_UpdateRect <screen> <x> <y> <w> <h>)
;;.PRE
;; extern DECLSPEC void SDL_UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
(de SDL_UpdateRect(screen x y w h)
  ((-gptr- "SDL_Surface *") screen)
  ((-int-) x y w h)
  #{ SDL_UpdateRect($screen, $x, $y, $w, $h) #} ())

;; 
#? (SDL_Flip <screen>)
;;.PRE
;; /*
;;  * On hardware that supports double-buffering, this function sets up a flip
;;  * and returns.  The hardware will wait for vertical retrace, and then swap
;;  * video buffers before the next video surface blit or lock will return.
;;  * On hardware that doesn not support double-buffering, this is equivalent
;;  * to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
;;  * The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
;;  * setting the video mode for this function to perform hardware flipping.
;;  * This function returns 0 if successful, or -1 if there was an error.
;;  */
;; extern DECLSPEC int SDL_Flip(SDL_Surface *screen);
(de SDL_Flip(screen)
  ((-gptr- "SDL_Surface *") screen)
  (int #{ SDL_Flip($screen) #}))

;; 
#? (SDL_SetGamma <red> <green> <blue>)
;;.PRE
;; /*
;;  * Set the gamma correction for each of the color channels.
;;  * The gamma values range (approximately) between 0.1 and 10.0
;;  * 
;;  * If this function isn't supported directly by the hardware, it will
;;  * be emulated using gamma ramps, if available.  If successful, this
;;  * function returns 0, otherwise it returns -1.
;;  */
;; extern DECLSPEC int SDL_SetGamma(float red, float green, float blue);
(de SDL_SetGamma(red green blue)
  ((-float-) red green blue)
  (int #{ SDL_SetGamma($red, $green, $blue) #}))

#? (SDL_SetGammaRamp <red> <green> <blue>)
;;.PRE
;; /*
;;  * Set the gamma translation table for the red, green, and blue channels
;;  * of the video hardware.  Each table is an array of 256 16-bit quantities,
;;  * representing a mapping between the input and output for that channel.
;;  * The input is the index into the array, and the output is the 16-bit
;;  * gamma value at that index, scaled to the output color precision.
;;  * 
;;  * You may pass NULL for any of the channels to leave it unchanged.
;;  * If the call succeeds, it will return 0.  If the display driver or
;;  * hardware does not support gamma translation, or otherwise fails,
;;  * this function will return -1.
;;  */
;; extern DECLSPEC int SDL_SetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
(de SDL_SetGammaRamp(red green blue)
  ((-gptr- "unsigned short *") red green blue)
  (int #{ SDL_SetGammaRamp($red, $green, $blue) #}))

#? (SDL_GetGammaRamp <red> <green> <blue>)
;;.PRE
;; /*
;;  * Retrieve the current values of the gamma translation tables.
;;  * 
;;  * You must pass in valid pointers to arrays of 256 16-bit quantities.
;;  * Any of the pointers may be NULL to ignore that channel.
;;  * If the call succeeds, it will return 0.  If the display driver or
;;  * hardware does not support gamma translation, or otherwise fails,
;;  * this function will return -1.
;;  */
;; extern DECLSPEC int SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
(de SDL_GetGammaRamp(red green blue)
  ((-gptr- "unsigned short *") red green blue)
  (int #{ SDL_GetGammaRamp($red, $green, $blue) #}))

#? (SDL_SetColors <surface> <colors> <firstcolor> <ncolors>)
;;.PRE
;; /*
;;  * Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
;;  * is not a palettized surface, this function does nothing, returning 0.
;;  * If all of the colors were set as passed to SDL_SetColors(), it will
;;  * return 1.  If not all the color entries were set exactly as given,
;;  * it will return 0, and you should look at the surface palette to
;;  * determine the actual color palette.
;;  *
;;  * When 'surface' is the surface associated with the current display, the
;;  * display colormap will be updated with the requested colors.  If 
;;  * SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
;;  * will always return 1, and the palette is guaranteed to be set the way
;;  * you desire, even if the window colormap has to be warped or run under
;;  * emulation.
;;  */
;; extern DECLSPEC int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors);
(de SDL_SetColors(surface colors firstcolor ncolors)
  ((-gptr- "SDL_Surface *") surface)
  ((-gptr- "SDL_Color *") colors)
  ((-int-) firstcolor ncolors)
  (int #{ SDL_SetColors($surface, $colors,  $firstcolor, $ncolors) #}))

#? (SDL_SetPalette <surface> <flags> <colors> <firstcolor> <ncolors>)
;;.PRE
;; /*
;;  * Sets a portion of the colormap for a given 8-bit surface.
;;  * 'flags' is one or both of:
;;  * SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
;;  *                to/from the surface,
;;  * SDL_PHYSPAL -- set physical palette, which controls how pixels look on
;;  *                the screen
;;  * Only screens have physical palettes. Separate change of physical/logical
;;  * palettes is only possible if the screen has SDL_HWPALETTE set.
;;  *
;;  * The return value is 1 if all colours could be set as requested, and 0
;;  * otherwise.
;;  *
;;  * SDL_SetColors() is equivalent to calling this function with
;;  *     flags = (SDL_LOGPAL|SDL_PHYSPAL).
;;  */
;; extern DECLSPEC int SDL_SetPalette(SDL_Surface *surface, int flags,
;; 				   SDL_Color *colors, int firstcolor,
;; 				   int ncolors);
(de SDL_SetPalette(surface flags colors firstcolor ncolors)
  ((-gptr- "SDL_Surface *") surface)
  ((-gptr- "SDL_Color *") colors)
  ((-int-) flags firstcolor ncolors)
  (int #{ SDL_SetPalette($surface, $flags, $colors, $firstcolor, $ncolors) #}))

#? (SDL_MapRGB <format> <r> <g> <b>)
;;.PRE
;; /*
;;  * Maps an RGB triple to an opaque pixel value for a given pixel format
;;  */
;; extern DECLSPEC Uint32 SDL_MapRGB(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
(de SDL_MapRGB(format r g b)
  ((-gptr- "SDL_PixelFormat *") format)
  ((-int-) r g b)
  (int #{ SDL_MapRGB($format, (Uint8)$r, (Uint8)$g, (Uint8)$b) #}))

#? (SDL_MapRGBA <format> <r> <g> <b> <a>)
;;.PRE
;; /*
;;  * Maps an RGBA quadruple to a pixel value for a given pixel format
;;  */
;; extern DECLSPEC Uint32 SDL_MapRGBA(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
(de SDL_MapRGBA(format r g b a)
  ((-gptr- "SDL_PixelFormat *") format)
  ((-int-) r g b a)
  (int #{ SDL_MapRGBA($format, (Uint8)$r, (Uint8)$g, (Uint8)$b, (Uint8)$a) #}))

#? (SDL_GetRGB <format> <r> <g> <b> <a>)
;;.PRE
;; /*
;;  * Maps a pixel value into the RGB components for a given pixel format
;;  */
;; extern DECLSPEC void SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt, Uint8 *r, Uint8 *g, Uint8 *b);
(de SDL_GetRGB(pixel fmt r g b)
  ((-gptr- "SDL_PixelFormat *") fmt)
  ((-int-) pixel)
  ((-int-) r g b)
  #{ SDL_GetRGB($pixel, $fmt, (Uint8 *)$r, (Uint8 *)$g, (Uint8 *)$b) #} ())

#? (SDL_GetRGBA <format> <r> <g> <b> <a>)
;;.PRE
;; /*
;;  * Maps a pixel value into the RGBA components for a given pixel format
;;  */
;; extern DECLSPEC void SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt,Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
(de SDL_GetRGBA(pixel fmt r g b a)
  ((-gptr- "SDL_PixelFormat *") fmt)
  ((-int-) pixel)
  ((-int-) r g b a)
  #{ SDL_GetRGBA($pixel, $fmt, (Uint8 *)$r, (Uint8 *)$g, (Uint8 *)$b, (Uint8 *)$a) #} ())

#? (SDL_CreateRGBSurface <flags> <width> <height> <depth> <rmask> <gmask> <bmask> <amask>)
;;.PRE
;; /*
;;  * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
;;  * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
;;  * If the depth is greater than 8 bits, the pixel format is set using the
;;  * flags '[RGB]mask'.
;;  * If the function runs out of memory, it will return NULL.
;;  *
;;  * The 'flags' tell what kind of surface to create.
;;  * SDL_SWSURFACE means that the surface should be created in system memory.
;;  * SDL_HWSURFACE means that the surface should be created in video memory,
;;  * with the same format as the display surface.  This is useful for surfaces
;;  * that will not change much, to take advantage of hardware acceleration
;;  * when being blitted to the display surface.
;;  * SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
;;  * this surface, but you must always lock it before accessing the pixels.
;;  * SDL will wait for current blits to finish before returning from the lock.
;;  * SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
;;  * If the hardware supports acceleration of colorkey blits between
;;  * two surfaces in video memory, SDL will try to place the surface in
;;  * video memory. If this isn't possible or if there is no hardware
;;  * acceleration available, the surface will be placed in system memory.
;;  * SDL_SRCALPHA means that the surface will be used for alpha blits and 
;;  * if the hardware supports hardware acceleration of alpha blits between
;;  * two surfaces in video memory, to place the surface in video memory
;;  * if possible, otherwise it will be placed in system memory.
;;  * If the surface is created in video memory, blits will be _much_ faster,
;;  * but the surface format must be identical to the video surface format,
;;  * and the only way to access the pixels member of the surface is to use
;;  * the SDL_LockSurface() and SDL_UnlockSurface() calls.
;;  * If the requested surface actually resides in video memory, SDL_HWSURFACE
;;  * will be set in the flags member of the returned surface.  If for some
;;  * reason the surface could not be placed in video memory, it will not have
;;  * the SDL_HWSURFACE flag set, and will be created in system memory instead.
;;  */
;; #define SDL_AllocSurface    SDL_CreateRGBSurface
;; extern DECLSPEC SDL_Surface *SDL_CreateRGBSurface
;; 			(Uint32 flags, int width, int height, int depth, 
;; 			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
;; extern DECLSPEC SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
(de SDL_CreateRGBSurface(flags width height depth rmask gmask bmask amask)
  ((-int-) flags width height depth rmask gmask bmask amask)
  (gptr #{ SDL_CreateRGBSurface($flags, $width, $height, $depth, $rmask, $gmask, $bmask, $amask) #}))

#? (SDL_CreateRGBSurfaceFrom <pixels> <width> <height> <depth> <pitch> <rmask> <gmask> <bmask> <amask>)
;;.PRE
;; extern DECLSPEC SDL_Surface *SDL_CreateRGBSurfaceFrom
;;                  (void *pixels, int width, int height, int depth, int pitch, 
;;                   Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
(de SDL_CreateRGBSurfaceFrom(pixels width height depth pitch rmask gmask bmask amask)
  ((-gptr-) pixels)
  ((-int-)  width height depth pitch rmask gmask bmask amask)
  (gptr #{ SDL_CreateRGBSurfaceFrom($pixels, $width, $height, $depth, $pitch, $rmask, $gmask, $bmask, $amask) #}))

#? (SDL_FreeSurface <surface>)
;;.PRE
;; extern DECLSPEC void SDL_FreeSurface(SDL_Surface *surface);
(de SDL_FreeSurface(surface)
  ((-gptr- "SDL_Surface *") surface)
  #{ SDL_FreeSurface($surface) #} ())

#? (SDL_LockSurface <surface>)
;;.PRE
;; /*
;;  * SDL_LockSurface() sets up a surface for directly accessing the pixels.
;;  * Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
;;  * to and read from 'surface->pixels', using the pixel format stored in 
;;  * 'surface->format'.  Once you are done accessing the surface, you should 
;;  * use SDL_UnlockSurface() to release it.
;;  *
;;  * Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
;;  * to 0, then you can read and write to the surface at any time, and the
;;  * pixel format of the surface will not change.  In particular, if the
;;  * SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
;;  * will not need to lock the display surface before accessing it.
;;  * 
;;  * No operating system or library calls should be made between lock/unlock
;;  * pairs, as critical system locks may be held during this time.
;;  *
;;  * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
;;  */
;; extern DECLSPEC int SDL_LockSurface(SDL_Surface *surface);
(de SDL_LockSurface(surface)
  ((-gptr- "SDL_Surface *") surface)
  (int #{ SDL_LockSurface($surface) #}))

#? (SDL_UnlockSurface <surface>)
;;.PRE
;; extern DECLSPEC void SDL_UnlockSurface(SDL_Surface *surface);
(de SDL_UnlockSurface(surface)
  ((-gptr- "SDL_Surface *") surface)
  #{ SDL_UnlockSurface($surface) #} ())

#? (SDL_LoadBMP_RW <src> <freesrc>)
;;.PRE
;; /*
;;  * Load a surface from a seekable SDL data source (memory or file.)
;;  * If 'freesrc' is non-zero, the source will be closed after being read.
;;  * Returns the new surface, or NULL if there was an error.
;;  * The new surface should be freed with SDL_FreeSurface().
;;  */
;; extern DECLSPEC SDL_Surface * SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
(de SDL_LoadBMP_RW(src freesrc)
  ((-gptr- "SDL_RWops *") src)
  ((-int-) freesrc)
  (gptr #{ SDL_LoadBMP_RW($src, $freesrc) #}))

;; /* Convenience macro -- load a surface from a file */
;; #define SDL_LoadBMP(file)	SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
;; 
#? (SDL_SaveBMP_RW <surface> <dst> <freedst>)
;;.PRE
;; /*
;;  * Save a surface to a seekable SDL data source (memory or file.)
;;  * If 'freedst' is non-zero, the source will be closed after being written.
;;  * Returns 0 if successful or -1 if there was an error.
;;  */
;; extern DECLSPEC int SDL_SaveBMP_RW
;; 		(SDL_Surface *surface, SDL_RWops *dst, int freedst);
(de SDL_SaveBMP_RW(surface dst freedst)
  ((-gptr- "SDL_Surface *") surface)
  ((-gptr- "SDL_RWops *") dst)
  ((-int-) freedst)
  (int #{ SDL_SaveBMP_RW($surface, $dst, $freedst) #}))

;; /* Convenience macro -- save a surface to a file */
;; #define SDL_SaveBMP(surface, file) \
;; 		SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
;; 
#? (SDL_SetColorKey <surface> <flag> <key>)
;;.PRE
;; /*
;;  * Sets the color key (transparent pixel) in a blittable surface.
;;  * If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL), 
;;  * 'key' will be the transparent pixel in the source image of a blit.
;;  * SDL_RLEACCEL requests RLE acceleration for the surface if present,
;;  * and removes RLE acceleration if absent.
;;  * If 'flag' is 0, this function clears any current color key.
;;  * This function returns 0, or -1 if there was an error.
;;  */
;; extern DECLSPEC int SDL_SetColorKey
;; 			(SDL_Surface *surface, Uint32 flag, Uint32 key);
;; extern DECLSPEC int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
(de SDL_SetColorKey(surface flag key)
  ((-gptr- "SDL_Surface *") surface)
  ((-int-) flag key)
  (int #{ SDL_SetColorKey($surface, $flag, $key) #}))

#? (SDL_SetAlpha <surface> <flag> <alpha>)
;;.PRE
;; /*
;;  * This function sets the alpha value for the entire surface, as opposed to
;;  * using the alpha component of each pixel. This value measures the range
;;  * of transparency of the surface, 0 being completely transparent to 255
;;  * being completely opaque. An 'alpha' value of 255 causes blits to be
;;  * opaque, the source pixels copied to the destination (the default). Note
;;  * that per-surface alpha can be combined with colorkey transparency.
;;  *
;;  * If 'flag' is 0, alpha blending is disabled for the surface.
;;  * If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
;;  * OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
;;  * surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed.
;;  */
;; extern DECLSPEC int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
(de SDL_SetAlpha(surface flag alpha)
  ((-gptr- "SDL_Surface *") surface)
  ((-int-) flag alpha)
  (int #{ SDL_SetAlpha($surface, $flag, $alpha) #}))

#? (SDL_SetClipRect <surface> <rect>)
;;.PRE
;; /*
;;  * Sets the clipping rectangle for the destination surface in a blit.
;;  *
;;  * If the clip rectangle is NULL, clipping will be disabled.
;;  * If the clip rectangle doesn't intersect the surface, the function will
;;  * return SDL_FALSE and blits will be completely clipped.  Otherwise the
;;  * function returns SDL_TRUE and blits to the surface will be clipped to
;;  * the intersection of the surface area and the clipping rectangle.
;;  *
;;  * Note that blits are automatically clipped to the edges of the source
;;  * and destination surfaces.
;;  */
;; extern DECLSPEC SDL_bool SDL_SetClipRect(SDL_Surface *surface, SDL_Rect *rect);
(de SDL_SetClipRect(surface rect)
  ((-gptr- "SDL_Surface *") surface)
  ((-gptr- "SDL_Rect *") rect)
  (bool #{ SDL_SetClipRect($surface, $rect) #}))

#? (SDL_GetClipRect <surface> <rect>)
;;.PRE
;; /*
;;  * Gets the clipping rectangle for the destination surface in a blit.
;;  * 'rect' must be a pointer to a valid rectangle which will be filled
;;  * with the correct values.
;;  */
;; extern DECLSPEC void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect);
(de SDL_GetClipRect(surface rect)
  ((-gptr- "SDL_Surface *") surface)
  ((-gptr- "SDL_Rect *") rect)
  #{ SDL_GetClipRect($surface, $rect) #} ())

#? (SDL_ConvertSurface <src> <fmt> <flags>)
;;.PRE
;; /*
;;  * Creates a new surface of the specified format, and then copies and maps 
;;  * the given surface to it so the blit of the converted surface will be as 
;;  * fast as possible.  If this function fails, it returns NULL.
;;  *
;;  * The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those 
;;  * semantics.  You can also pass SDL_RLEACCEL in the flags parameter and
;;  * SDL will try to RLE accelerate colorkey and alpha blits in the resulting
;;  * surface.
;;  *
;;  * This function is used internally by SDL_DisplayFormat().
;;  */
;; extern DECLSPEC SDL_Surface *SDL_ConvertSurface
;; 			(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
(de SDL_ConvertSurface(src fmt flags)
  ((-gptr- "SDL_Surface *") src)
  ((-gptr- "SDL_PixelFormat *") fmt)
  ((-int-) flags)
  (gptr #{ SDL_ConvertSurface($src, $fmt, $flags) #}))

#? (SDL_BlitSurface <src> <srcrect> <dst> <dstrect>)
;;.PRE
;; /*
;;  * This performs a fast blit from the source surface to the destination
;;  * surface.  It assumes that the source and destination rectangles are
;;  * the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
;;  * surface (src or dst) is copied.  The final blit rectangles are saved
;;  * in 'srcrect' and 'dstrect' after all clipping is performed.
;;  * If the blit is successful, it returns 0, otherwise it returns -1.
;;  *
;;  * The blit function should not be called on a locked surface.
;;  *
;;  * The blit semantics for surfaces with and without alpha and colorkey
;;  * are defined as follows:
;;  *
;;  * RGBA->RGB:
;;  *     SDL_SRCALPHA set:
;;  * 	alpha-blend (using alpha-channel).
;;  * 	SDL_SRCCOLORKEY ignored.
;;  *     SDL_SRCALPHA not set:
;;  * 	copy RGB.
;;  * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
;;  * 	RGB values of the source colour key, ignoring alpha in the
;;  * 	comparison.
;;  * 
;;  * RGB->RGBA:
;;  *     SDL_SRCALPHA set:
;;  * 	alpha-blend (using the source per-surface alpha value);
;;  * 	set destination alpha to opaque.
;;  *     SDL_SRCALPHA not set:
;;  * 	copy RGB, set destination alpha to opaque.
;;  *     both:
;;  * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
;;  * 	source colour key.
;;  * 
;;  * RGBA->RGBA:
;;  *     SDL_SRCALPHA set:
;;  * 	alpha-blend (using the source alpha channel) the RGB values;
;;  * 	leave destination alpha untouched. [Note: is this correct?]
;;  * 	SDL_SRCCOLORKEY ignored.
;;  *     SDL_SRCALPHA not set:
;;  * 	copy all of RGBA to the destination.
;;  * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
;;  * 	RGB values of the source colour key, ignoring alpha in the
;;  * 	comparison.
;;  * 
;;  * RGB->RGB: 
;;  *     SDL_SRCALPHA set:
;;  * 	alpha-blend (using the source per-surface alpha value).
;;  *     SDL_SRCALPHA not set:
;;  * 	copy RGB.
;;  *     both:
;;  * 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
;;  * 	source colour key.
;;  *
;;  * If either of the surfaces were in video memory, and the blit returns -2,
;;  * the video memory was lost, so it should be reloaded with artwork and 
;;  * re-blitted:
;; 	while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
;; 		while ( SDL_LockSurface(image) < 0 )
;; 			Sleep(10);
;; 		-- Write image pixels to image->pixels --
;; 		SDL_UnlockSurface(image);
;; 	}
;;  * This happens under DirectX 5.0 when the system switches away from your
;;  * fullscreen application.  The lock will also fail until you have access
;;  * to the video memory again.
;;  */
;; /* You should call SDL_BlitSurface() unless you know exactly how SDL
;;    blitting works internally and how to use the other blit functions.
;; */
;; #define SDL_BlitSurface SDL_UpperBlit
(dmd SDL_BlitSurface (a b c d) `(SDL_UpperBlit ,a ,b ,c ,d))

#? (SDL_UpperBlit <src> <srcrect> <dst> <dstrect>)
;;.PRE
;; /* This is the public blit function, SDL_BlitSurface(), and it performs
;;    rectangle validation and clipping before passing it to SDL_LowerBlit()
;; */
;; extern DECLSPEC int SDL_UpperBlit
;; 			(SDL_Surface *src, SDL_Rect *srcrect,
;; 			 SDL_Surface *dst, SDL_Rect *dstrect);
(de SDL_UpperBlit(src srcrect dst dstrect)
  ((-gptr- "SDL_Surface *") src dst)
  ((-gptr- "SDL_Rect *") srcrect dstrect)
  (int #{ SDL_UpperBlit($src, $srcrect, $dst, $dstrect) #}))

#? (SDL_LowerBlit <src> <srcrect> <dst> <dstrect>)
;;.PRE
;; /* This is a semi-private blit function and it performs low-level surface
;;    blitting only.
;; */
;; extern DECLSPEC int SDL_LowerBlit
;; 			(SDL_Surface *src, SDL_Rect *srcrect,
;; 			 SDL_Surface *dst, SDL_Rect *dstrect);
(de SDL_LowerBlit(src srcrect dst dstrect)
  ((-gptr- "SDL_Surface *") src dst)
  ((-gptr- "SDL_Rect *") srcrect dstrect)
  (int #{ SDL_LowerBlit($src, $srcrect, $dst, $dstrect) #}))

#? (SDL_FillRect <dst> <dstrect> <color>)
;;.PRE
;; /*
;;  * This function performs a fast fill of the given rectangle with 'color'
;;  * The given rectangle is clipped to the destination surface clip area
;;  * and the final fill rectangle is saved in the passed in pointer.
;;  * If 'dstrect' is NULL, the whole surface will be filled with 'color'
;;  * The color should be a pixel of the format used by the surface, and 
;;  * can be generated by the SDL_MapRGB() function.
;;  * This function returns 0 on success, or -1 on error.
;;  */
;; extern DECLSPEC int SDL_FillRect
;; 		(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
(de SDL_FillRect(dst dstrect color)
  ((-gptr- "SDL_Surface *") dst)
  ((-gptr- "SDL_Rect *") dstrect)
  ((-int-) color)
  (int #{ SDL_FillRect($dst, $dstrect, $color) #}))

#? (SDL_DisplayFormat <surface>)
;;.PRE
;; /* 
;;  * This function takes a surface and copies it to a new surface of the
;;  * pixel format and colors of the video framebuffer, suitable for fast
;;  * blitting onto the display surface.  It calls SDL_ConvertSurface()
;;  *
;;  * If you want to take advantage of hardware colorkey or alpha blit
;;  * acceleration, you should set the colorkey and alpha value before
;;  * calling this function.
;;  *
;;  * If the conversion fails or runs out of memory, it returns NULL
;;  */
;; extern DECLSPEC SDL_Surface * SDL_DisplayFormat(SDL_Surface *surface);
(de SDL_DisplayFormat(surface)
  ((-gptr- "SDL_Surface *") surface)
  (gptr #{ SDL_DisplayFormat($surface) #}))

#? (SDL_DisplayFormatAlpha <surface>)
;;.PRE
;; /* 
;;  * This function takes a surface and copies it to a new surface of the
;;  * pixel format and colors of the video framebuffer (if possible),
;;  * suitable for fast alpha blitting onto the display surface.
;;  * The new surface will always have an alpha channel.
;;  *
;;  * If you want to take advantage of hardware colorkey or alpha blit
;;  * acceleration, you should set the colorkey and alpha value before
;;  * calling this function.
;;  *
;;  * If the conversion fails or runs out of memory, it returns NULL
;;  */
;; extern DECLSPEC SDL_Surface * SDL_DisplayFormatAlpha(SDL_Surface *surface);
(de SDL_DisplayFormatAlpha(surface)
  ((-gptr- "SDL_Surface *") surface)
  (gptr #{ SDL_DisplayFormatAlpha($surface) #}))

;; 
;; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
;; /* YUV video surface overlay functions                                       */
;; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
;; 

#? (SDL_CreateYUVOverlay <width> <height> <format> <display>)
;;.PRE
;; /* This function creates a video output overlay
;;    Calling the returned surface an overlay is something of a misnomer because
;;    the contents of the display surface underneath the area where the overlay
;;    is shown is undefined - it may be overwritten with the converted YUV data.
;; */
;; extern DECLSPEC SDL_Overlay *SDL_CreateYUVOverlay(int width, int height,
;; 				Uint32 format, SDL_Surface *display);
(de SDL_CreateYUVOverlay(width height format display)
  ((-gptr- "SDL_Surface *") display)
  ((-int-) width height format)
  (gptr #{ SDL_CreateYUVOverlay($width, $height, $format, $display) #}))

#? (SDL_LockYUVOverlay <overlay>)
;;.PRE
;; /* Lock an overlay for direct access, and unlock it when you are done */
;; extern DECLSPEC int SDL_LockYUVOverlay(SDL_Overlay *overlay);
(de SDL_LockYUVOverlay(overlay)
  ((-gptr- "SDL_Overlay *") overlay)
  (int #{ SDL_LockYUVOverlay($overlay) #}))

#? (SDL_UnlockYUVOverlay <overlay>)
;;.PRE
;; extern DECLSPEC void SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
(de SDL_UnlockYUVOverlay(overlay)
  ((-gptr- "SDL_Overlay *") overlay)
  #{ SDL_UnlockYUVOverlay($overlay) #} ())

#? (SDL_DisplayYUVOverlay <overlay> <dstrect>)
;;.PRE
;; /* Blit a video overlay to the display surface.
;;    The contents of the video surface underneath the blit destination are
;;    not defined.  
;;    The width and height of the destination rectangle may be different from
;;    that of the overlay, but currently only 2x scaling is supported.
;; */
;; extern DECLSPEC int SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
(de SDL_DisplayYUVOverlay(overlay dstrect)
  ((-gptr- "SDL_Overlay *") overlay)
  ((-gptr- "SDL_Rect *") dstrect)
  (int #{ SDL_DisplayYUVOverlay($overlay, $dstrect) #}))

#? (SDL_FreeYUVOverlay <overlay>)
;;.PRE
;; /* Free a video overlay */
;; extern DECLSPEC void SDL_FreeYUVOverlay(SDL_Overlay *overlay);
(de SDL_FreeYUVOverlay(overlay)
  ((-gptr- "SDL_Overlay *") overlay)
  #{ SDL_FreeYUVOverlay($overlay) #} ())

;; 
;; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
;; /* OpenGL support functions.                                                 */
;; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
;; 
#? (SDL_GL_LoadLibrary <path>)
;;.PRE
;; /*
;;  * Dynamically load a GL driver, if SDL is built with dynamic GL.
;;  *
;;  * SDL links normally with the OpenGL library on your system by default,
;;  * but you can compile it to dynamically load the GL driver at runtime.
;;  * If you do this, you need to retrieve all of the GL functions used in
;;  * your program from the dynamic library using SDL_GL_GetProcAddress().
;;  *
;;  * This is disabled in default builds of SDL.
;;  */
;; extern DECLSPEC int SDL_GL_LoadLibrary(const char *path);
(de SDL_GL_LoadLibrary(path)
  ((-str-) path)
  (int #{ SDL_GL_LoadLibrary((char *)$path->data) #}))

#? (SDL_GL_GetProcAddress <proc>)
;;.PRE
;; /*
;;  * Get the address of a GL function (for extension functions)
;;  */
;; extern DECLSPEC void *SDL_GL_GetProcAddress(const char* proc);
(de SDL_GL_GetProcAddress(proc)
  ((-str-) proc)
  #{ SDL_GL_GetProcAddress((char *)$proc->data) #} ())

#? (SDL_GL_SetAttribute <attr> <value>)
;;.PRE
;; /*
;;  * Set an attribute of the OpenGL subsystem before intialization.
;;  */
;; extern DECLSPEC int SDL_GL_SetAttribute(SDL_GLattr attr, int value);
(de SDL_GL_SetAttribute(attr value)
  ((-int-) attr value)
  (int #{ SDL_GL_SetAttribute((SDL_GLattr)$attr, $value) #}))

#? (SDL_GL_GetAttribute <attr> <value>)
;;.PRE
;; /*
;;  * Get an attribute of the OpenGL subsystem from the windowing
;;  * interface, such as glX. This is of course different from getting
;;  * the values from SDL's internal OpenGL subsystem, which only
;;  * stores the values you request before initialization.
;;  *
;;  * Developers should track the values they pass into SDL_GL_SetAttribute
;;  * themselves if they want to retrieve these values.
;;  */
;; extern DECLSPEC int SDL_GL_GetAttribute(SDL_GLattr attr, int* value);
(de SDL_GL_GetAttribute( attr value)
  ((-int-) attr)
  ((-gptr- "int *") value)
  (int #{ SDL_GL_GetAttribute( (SDL_GLattr)$attr, $value) #}))

#? (SDL_GL_SwapBuffers) 
;;.PRE
;; /*
;;  * Swap the OpenGL buffers, if double-buffering is supported.
;;  */
;; extern DECLSPEC void SDL_GL_SwapBuffers(void);
(de SDL_GL_SwapBuffers() #{ SDL_GL_SwapBuffers() #} ())

;; /*
;;  * Internal functions that should not be called unless you have read
;;  * and understood the source code for these functions.
;;  */
;; extern DECLSPEC void SDL_GL_UpdateRects(int numrects, SDL_Rect* rects);
;; extern DECLSPEC void SDL_GL_Lock(void);
;; extern DECLSPEC void SDL_GL_Unlock(void);
;; 
;; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
;; /* These functions allow interaction with the window manager, if any.        */
;; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
;; 

#? (SDL_WM_SetCaption <title> <icon>)
;;.PRE
;; /*
;;  * Sets/Gets the title and icon text of the display window
;;  */
;; extern DECLSPEC void SDL_WM_SetCaption(const char *title, const char *icon);
(de SDL_WM_SetCaption(title icon)
  ((-str-) title icon)
  #{ SDL_WM_SetCaption((char *)$title->data, (char *)$icon->data) #} ())

#? (SDL_WM_GetCaption <title> <icon>)
;;.PRE
;; extern DECLSPEC void SDL_WM_GetCaption(char **title, char **icon);
(de SDL_WM_GetCaption(title icon)
  ((-gptr- "char **") title icon)
  #{ SDL_WM_GetCaption($title, $icon) #} ())

#? (SDL_WM_SetIcon <icon> <mask>)
;;.PRE
;; /*
;;  * Sets the icon for the display window.
;;  * This function must be called before the first call to SDL_SetVideoMode().
;;  * It takes an icon surface, and a mask in MSB format.
;;  * If 'mask' is NULL, the entire icon surface will be used as the icon.
;;  */
;; extern DECLSPEC void SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
(de SDL_WM_SetIcon(icon mask)
  ((-gptr- "SDL_Surface *") icon)
  ((-gptr- "unsigned char *") mask)
  #{ SDL_WM_SetIcon($icon, $mask) #} ())

#? (SDL_WM_IconifyWindow)
;;.PRE
;; /*
;;  * This function iconifies the window, and returns 1 if it succeeded.
;;  * If the function succeeds, it generates an SDL_APPACTIVE loss event.
;;  * This function is a noop and returns 0 in non-windowed environments.
;;  */
;; extern DECLSPEC int SDL_WM_IconifyWindow(void);
(de SDL_WM_IconifyWindow()
  (int #{ SDL_WM_IconifyWindow() #}))

#? (SDL_WM_ToggleFullScreen <surface>)
;;.PRE
;; /*
;;  * Toggle fullscreen mode without changing the contents of the screen.
;;  * If the display surface does not require locking before accessing
;;  * the pixel information, then the memory pointers will not change.
;;  *
;;  * If this function was able to toggle fullscreen mode (change from 
;;  * running in a window to fullscreen, or vice-versa), it will return 1.
;;  * If it is not implemented, or fails, it returns 0.
;;  *
;;  * The next call to SDL_SetVideoMode() will set the mode fullscreen
;;  * attribute based on the flags parameter - if SDL_FULLSCREEN is not
;;  * set, then the display will be windowed by default where supported.
;;  *
;;  * This is currently only implemented in the X11 video driver.
;;  */
;; extern DECLSPEC int SDL_WM_ToggleFullScreen(SDL_Surface *surface);
(de SDL_WM_ToggleFullScreen(surface)
  ((-gptr- "SDL_Surface *") surface)
  (int #{ SDL_WM_ToggleFullScreen($surface) #}))

#? (SDL_WM_GrabInput <mode>)
;;.PRE
;; /*
;;  * This function allows you to set and query the input grab state of
;;  * the application.  It returns the new input grab state.
;;  */
;; typedef enum {
;; 	SDL_GRAB_QUERY = -1,
;; 	SDL_GRAB_OFF = 0,
;; 	SDL_GRAB_ON = 1,
;; 	SDL_GRAB_FULLSCREEN	/* Used internally */
;; } SDL_GrabMode;
(defconstant "SDL_GRAB_QUERY" -1)
(defconstant "SDL_GRAB_OFF" 0)
(defconstant "SDL_GRAB_ON" 1)
;; /*
;;  * Grabbing means that the mouse is confined to the application window,
;;  * and nearly all keyboard input is passed directly to the application,
;;  * and not interpreted by a window manager, if any.
;;  */
;; extern DECLSPEC SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode);
(de SDL_WM_GrabInput(mode)
  ((-int-) mode)
  (int #{ SDL_WM_GrabInput($mode) #}))

;; /* Not in public API at the moment - do not use! */
;; extern DECLSPEC int SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
;;                                     SDL_Surface *dst, SDL_Rect *dstrect);
(de SDL_SoftStretch(src srcrect dst dstrect)
  ((-gptr- "SDL_Surface *") src dst)
  ((-gptr- "SDL_Rect *") srcrect dstrect)
  (int #{ SDL_SoftStretch($src, $srcrect, $dst, $dstrect) #}))

;; /* Ends C function definitions when using C++ */
;; #ifdef __cplusplus
;; }
;; #endif
;; #include "close_code.h"
;; 
;; #endif /* _SDL_video_h */


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(sdladdfuncs SDL_MUSTLOCK SDL_VideoInit
	  SDL_VideoQuit SDL_VideoDriverName SDL_GetVideoSurface SDL_GetVideoInfo
	  SDL_VideoModeOK SDL_ListModes SDL_SetVideoMode SDL_UpdateRects
	  SDL_UpdateRect SDL_Flip SDL_SetGamma SDL_SetGammaRamp SDL_GetGammaRamp
	  SDL_SetColors SDL_SetPalette SDL_MapRGB SDL_MapRGBA SDL_GetRGB
	  SDL_GetRGBA SDL_CreateRGBSurface SDL_CreateRGBSurfaceFrom
	  SDL_FreeSurface SDL_LockSurface SDL_UnlockSurface SDL_LoadBMP_RW
	  SDL_SaveBMP_RW SDL_SetColorKey SDL_SetAlpha SDL_SetClipRect
	  SDL_GetClipRect SDL_ConvertSurface SDL_UpperBlit SDL_LowerBlit
	  SDL_FillRect SDL_DisplayFormat SDL_DisplayFormatAlpha
	  SDL_CreateYUVOverlay SDL_LockYUVOverlay SDL_UnlockYUVOverlay
	  SDL_DisplayYUVOverlay SDL_FreeYUVOverlay SDL_GL_LoadLibrary
	  SDL_GL_GetProcAddress SDL_GL_SetAttribute SDL_GL_GetAttribute
	  SDL_GL_SwapBuffers SDL_WM_SetCaption SDL_WM_GetCaption SDL_WM_SetIcon
	  SDL_WM_IconifyWindow SDL_WM_ToggleFullScreen SDL_WM_GrabInput
	  SDL_SoftStretch
          )
