* 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);/* * 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);extern DECLSPEC void SDL_UpdateRect		(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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);/* * 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_CreateRGBSurfaceextern 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_CreateRGBSurfaceFrom(void *pixels,			int width, int height, int depth, int pitch,			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);extern DECLSPEC void SDL_FreeSurface(SDL_Surface *surface);/* * 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);extern DECLSPEC void SDL_UnlockSurface(SDL_Surface *surface);/* * 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);/* Convenience macro -- load a surface from a file */#define SDL_LoadBMP(file)	SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)/* * 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);/* Convenience macro -- save a surface to a file */#define SDL_SaveBMP(surface, file) \		SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)/* * 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);/* * 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);/* * 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);