// Emacs style mode select   -*- C++ -*-
//-----------------------------------------------------------------------------
//
// Copyright (C) 1993-1996 by id Software, Inc.
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program 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 General Public License for more details.
//-----------------------------------------------------------------------------
/// \file
/// \brief SRB2 graphics stuff for SDL

#include <stdlib.h>

#ifndef _WIN32_WCE
#include <signal.h>
#endif

#ifdef _MSC_VER
#pragma warning(disable : 4214 4244)
#endif

#ifdef HAVE_SDL

#include "SDL.h"

#ifdef _MSC_VER
#pragma warning(default : 4214 4244)
#endif

#if SDL_VERSION_ATLEAST(1,2,9) && defined (_arch_dreamcast)
#define HAVE_DCSDL
#include "SDL_dreamcast.h"
#endif

#if SDL_VERSION_ATLEAST(1,2,9) && defined (GP2X)
#define HAVE_GP2XSDL
#include "SDL_gp2x.h"
#endif

#if SDL_VERSION_ATLEAST(1,3,0)
#define SDLK_EQUALS SDLK_KP_EQUALSAS400
#define SDLK_LMETA SDLK_LGUI
#define SDLK_RMETA SDLK_RGUI
#else
#define HAVE_SDLMETAKEYS
#endif

#ifdef HAVE_TTF
#include "i_ttf.h"
#endif

#ifdef HAVE_IMAGE
#include "SDL_image.h"
#elseif !(defined (DC) || defined (_WIN32_WCE) || defined (PSP) || defined(GP2X))
#define LOAD_XPM //I want XPM!
#include "IMG_xpm.c" //Alam: I don't want to add SDL_Image.dll/so
#define HAVE_IMAGE //I have SDL_Image, sortof
#endif

#ifdef HAVE_IMAGE
#include "SDL_icon.xpm"
#endif

#include "../doomdef.h"

#if defined (_WIN32) && !defined (_XBOX)
#include "SDL_syswm.h"
#endif

#ifdef _arch_dreamcast
#include <conio/conio.h>
#include <dc/maple.h>
#include <dc/maple/vmu.h>
//#include "SRB2DC/VMU.xbm"
//#include <dc/pvr.h>
//#define malloc pvr_mem_malloc
//#define free pvr_mem_free
#endif

#if defined (_XBOX) && defined (__GNUC__)
#include <openxdk/debug.h>
#endif

#include "../doomstat.h"
#include "../i_system.h"
#include "../v_video.h"
#include "../m_argv.h"
#include "../m_menu.h"
#include "../d_main.h"
#include "../s_sound.h"
#include "../i_sound.h"  // midi pause/unpause
#include "../i_joy.h"
#include "../st_stuff.h"
#include "../g_game.h"
#include "../i_video.h"
#include "../console.h"
#include "../command.h"
#include "sdlmain.h"
#ifdef HWRENDER
#include "../hardware/hw_main.h"
#include "../hardware/hw_drv.h"
// For dynamic referencing of HW rendering functions
#include "hwsym_sdl.h"
#include "ogl_sdl.h"
#endif

#ifdef REMOTE_DEBUGGING
#ifdef _WII
#include <debug.h>
#endif
#endif

#ifdef HAVE_FILTER
#define FILTERS
#include "filter/filters.h"
#endif

// maximum number of windowed modes (see windowedModes[][])
#if defined (_WIN32_WCE) || defined (DC) || defined (PSP) || defined(GP2X)
#define MAXWINMODES (1)
#elif defined (WII)
#define MAXWINMODES (8)
#elif defined (_PS3)
#define MAXWINMODES (26)
#else
#define MAXWINMODES (27)
#endif

/**	\brief
*/
static INT32 numVidModes = -1;

/**	\brief
*/
static char vidModeName[33][32]; // allow 33 different modes

rendermode_t rendermode=render_soft;

boolean highcolor = false;

// synchronize page flipping with screen refresh
#if defined(DC) || (defined(GP2X) && !defined(HAVE_GP2XSDL))
consvar_t cv_vidwait = {"vid_wait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
#else
consvar_t cv_vidwait = {"vid_wait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
#endif
static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};

UINT8 graphics_started = 0; // Is used in console.c and screen.c

// To disable fullscreen at startup; is set in VID_PrepareModeList
boolean allow_fullscreen = false;
static SDL_bool disable_fullscreen = SDL_FALSE;
#define USE_FULLSCREEN (disable_fullscreen||!allow_fullscreen)?0:cv_fullscreen.value
static SDL_bool disable_mouse = SDL_FALSE;
#define USE_MOUSEINPUT (!disable_mouse && cv_usemouse.value && SDL_GetAppState() & SDL_APPACTIVE)
#define MOUSE_MENU false //(!disable_mouse && cv_usemouse.value && menuactive && !USE_FULLSCREEN)
#define MOUSEBUTTONS_MAX MOUSEBUTTONS

// first entry in the modelist which is not bigger than MAXVIDWIDTHxMAXVIDHEIGHT
static      INT32          firstEntry = 0;

// SDL vars
#ifndef HWRENDER //[segabor] !!! I had problem compiling this source with gcc 3.3
static      SDL_Surface *vidSurface = NULL;
#endif
static      SDL_Surface *bufSurface = NULL;
static      SDL_Surface *icoSurface = NULL;
static      SDL_Color    localPalette[256];
static      SDL_Rect   **modeList = NULL;
#ifdef DC
static       Uint8       BitsPerPixel = 15;
#else
static       Uint8       BitsPerPixel = 16;
#endif
static       Uint16      realwidth = BASEVIDWIDTH;
static       Uint16      realheight = BASEVIDHEIGHT;
#ifdef _WIN32_WCE
static const Uint32      surfaceFlagsW = SDL_HWPALETTE; //Can't handle WinCE changing sides
#else
static const Uint32      surfaceFlagsW = SDL_HWPALETTE/*|SDL_RESIZABLE*/;
#endif
#ifdef _PSP
static const Uint32      surfaceFlagsF = SDL_HWSURFACE|SDL_FULLSCREEN;
#else
static const Uint32      surfaceFlagsF = SDL_HWPALETTE|SDL_FULLSCREEN;
#endif
static       SDL_bool    mousegrabok = SDL_TRUE;
#define HalfWarpMouse(x,y) SDL_WarpMouse((Uint16)(x/2),(Uint16)(y/2))
#if defined (_WIN32_WCE) || defined (DC) || defined (PSP) || defined(GP2X)
static       SDL_bool    videoblitok = SDL_TRUE;
#else
static       SDL_bool    videoblitok = SDL_FALSE;
#endif
static       SDL_bool    exposevideo = SDL_FALSE;

// windowed video modes from which to choose from.
static INT32 windowedModes[MAXWINMODES][2] =
{
#if !(defined (_WIN32_WCE) || defined (DC) || defined (PSP) || defined (GP2X))
#ifndef WII
#ifndef _PS3
	{1920,1200}, // 1.60,6.00
#endif
	{1680,1050}, // 1.60,5.25
	{1600,1200}, // 1.33,5.00
	{1600,1000}, // 1.60,5.00
	{1536,1152}, // 1.33,4.80
	{1536, 960}, // 1.60,4.80
	{1440, 900}, // 1.60,4.50
	{1400,1050}, // 1.33,4.375
	{1400, 875}, // 1.60,4.375
	{1360, 850}, // 1.60,4.25
	{1280, 960}, // 1.33,4.00
	{1280, 800}, // 1.60,4.00
	{1152, 864}, // 1.33,3.60
	{1120, 700}, // 1.60,3.50
	{1024, 768}, // 1.33,3.20
	{ 960, 720}, // 1.33,3.00
	{ 960, 600}, // 1.60,3.00
	{ 800, 600}, // 1.33,2.50
	{ 800, 500}, // 1.60,2.50
#endif
	{ 640, 480}, // 1.33,2.00
	{ 640, 400}, // 1.60,2.00
	{ 576, 432}, // 1.33,1.80
	{ 512, 384}, // 1.33,1.60
	{ 416, 312}, // 1.33,1.30
	{ 400, 300}, // 1.33,1.25
	{ 320, 240}, // 1.33,1.00
#endif
	{ 320, 200}, // 1.60,1.00
};

static void SDLSetMode(INT32 width, INT32 height, INT32 bpp, Uint32 flags)
{
	const char *SDLVD = I_GetEnv("SDL_VIDEODRIVER");
#ifdef _WIN32_WCE
	if (bpp < 16)
		bpp = 16; // 256 mode poo
#endif
#ifdef _WII
	bpp = 16; // 8-bit mode poo
#endif
#ifdef DC
	if (bpp < 15)
		bpp = 15;
	height = 240;
#endif
#ifdef PSP
	bpp = 16;
#endif
#ifdef GP2X
	bpp = 16;
#ifdef HAVE_GP2XSDL
	height = 240;
#endif
#endif
#ifdef FILTERS
	bpp = Setupf2x(width, height, bpp);
#endif
	if (SDLVD && strncasecmp(SDLVD,"glSDL",6) == 0) //for glSDL videodriver
		vidSurface = SDL_SetVideoMode(width, height,0,SDL_DOUBLEBUF);
#ifdef _WII // don't want it to use HWSURFACE, so make it first here
	else if (SDL_VideoModeOK(width, height, bpp, flags|SDL_SWSURFACE|SDL_DOUBLEBUF) >= bpp) // SDL Wii uses double buffering
		vidSurface = SDL_SetVideoMode(width, height, bpp, flags|SDL_SWSURFACE|SDL_DOUBLEBUF);
#endif
	else if (cv_vidwait.value && videoblitok && SDL_VideoModeOK(width, height, bpp, flags|SDL_HWSURFACE|SDL_DOUBLEBUF) >= bpp)
		vidSurface = SDL_SetVideoMode(width, height, bpp, flags|SDL_HWSURFACE|SDL_DOUBLEBUF);
	else if (videoblitok && SDL_VideoModeOK(width, height, bpp, flags|SDL_HWSURFACE) >= bpp)
		vidSurface = SDL_SetVideoMode(width, height, bpp, flags|SDL_HWSURFACE);
	else if (SDL_VideoModeOK(width, height, bpp, flags|SDL_SWSURFACE) >= bpp)
		vidSurface = SDL_SetVideoMode(width, height, bpp, flags|SDL_SWSURFACE);
	else return;
	realwidth = (Uint16)width;
	realheight = (Uint16)height;
#ifdef HAVE_DCSDL
	//SDL_DC_SetWindow(320,200);
	SDL_DC_EmulateMouse(SDL_FALSE);
	SDL_DC_EmulateKeyboard(SDL_TRUE);
#endif
#ifdef HAVE_GP2XSDL
	SDL_ShowCursor(SDL_DISABLE); //For GP2X Open2x
#endif
#ifdef FILTERS
	if (vidSurface && preSurface && f2xSurface)
	{
		vid.width = width/2;
		vid.height = height/2;
	}
#endif
}

//
//  Translates the SDL key into SRB2 key
//

static INT32 SDLatekey(SDLKey sym)
{
	INT32 rc = sym + 0x80;

#ifdef _WIN32_WCE
	if (sym == SDLK_KP8)
		sym = SDLK_UP;
	else if (sym == SDLK_KP4)
		sym = SDLK_LEFT;
	else if (sym == SDLK_KP6)
		sym = SDLK_RIGHT;
	else if (sym == SDLK_KP2)
		sym = SDLK_DOWN;
#endif

	switch (sym)
	{
		case SDLK_LEFT:
			rc = KEY_LEFTARROW;
			break;
		case SDLK_RIGHT:
			rc = KEY_RIGHTARROW;
			break;
		case SDLK_DOWN:
			rc = KEY_DOWNARROW;
			break;
		case SDLK_UP:
			rc = KEY_UPARROW;
			break;

		case SDLK_ESCAPE:
			rc = KEY_ESCAPE;
			break;
		case SDLK_SPACE:
			rc = KEY_SPACE;
			break;
		case SDLK_RETURN:
		case SDLK_KP_ENTER:
			rc = KEY_ENTER;
			break;
		case SDLK_TAB:
			rc = KEY_TAB;
			break;
		case SDLK_F1:
			rc = KEY_F1;
			break;
		case SDLK_F2:
			rc = KEY_F2;
			break;
		case SDLK_F3:
			rc = KEY_F3;
			break;
		case SDLK_F4:
			rc = KEY_F4;
			break;
		case SDLK_F5:
			rc = KEY_F5;
			break;
		case SDLK_F6:
			rc = KEY_F6;
			break;
		case SDLK_F7:
			rc = KEY_F7;
			break;
		case SDLK_F8:
			rc = KEY_F8;
			break;
		case SDLK_F9:
			rc = KEY_F9;
			break;
		case SDLK_F10:
			rc = KEY_F10;
			break;
		case SDLK_F11:
			rc = KEY_F11;
			break;
		case SDLK_F12:
			rc = KEY_F12;
			break;

		case SDLK_BACKSPACE:
			rc = KEY_BACKSPACE;
			break;
		case SDLK_DELETE:
			rc = KEY_DEL;
			break;

		case SDLK_KP_EQUALS: //Alam & Logan: WTF? Mac KB haves one! XD
		case SDLK_PAUSE:
			rc = KEY_PAUSE;
			break;

		case SDLK_EQUALS:
		case SDLK_PLUS:
			rc = KEY_EQUALS;
			break;

		case SDLK_MINUS:
			rc = KEY_MINUS;
			break;

		case SDLK_LSHIFT:
			rc = KEY_LSHIFT;
			break;

		case SDLK_RSHIFT:
			rc = KEY_RSHIFT;
			break;

		case SDLK_CAPSLOCK:
			rc = KEY_CAPSLOCK;
			break;

		case SDLK_LCTRL:
			rc = KEY_LCTRL;
			break;
		case SDLK_RCTRL:
			rc = KEY_RCTRL;
			break;

		case SDLK_LALT:
			rc = KEY_LALT;
			break;
		case SDLK_RALT:
			rc = KEY_RALT;
			break;

		case SDLK_NUMLOCK:
			rc = KEY_NUMLOCK;
			break;
		case SDLK_SCROLLOCK:
			rc = KEY_SCROLLLOCK;
			break;

		case SDLK_PAGEUP:
			rc = KEY_PGUP;
			break;
		case SDLK_PAGEDOWN:
			rc = KEY_PGDN;
			break;
		case SDLK_END:
			rc = KEY_END;
			break;
		case SDLK_HOME:
			rc = KEY_HOME;
			break;
		case SDLK_INSERT:
			rc = KEY_INS;
			break;

		case SDLK_KP0:
			rc = KEY_KEYPAD0;
			break;
		case SDLK_KP1:
			rc = KEY_KEYPAD1;
			break;
		case SDLK_KP2:
			rc = KEY_KEYPAD2;
			break;
		case SDLK_KP3:
			rc = KEY_KEYPAD3;
			break;
		case SDLK_KP4:
			rc = KEY_KEYPAD4;
			break;
		case SDLK_KP5:
			rc = KEY_KEYPAD5;
			break;
		case SDLK_KP6:
			rc = KEY_KEYPAD6;
			break;
		case SDLK_KP7:
			rc = KEY_KEYPAD7;
			break;
		case SDLK_KP8:
			rc = KEY_KEYPAD8;
			break;
		case SDLK_KP9:
			rc = KEY_KEYPAD9;
			break;

		case SDLK_KP_PERIOD:
			rc = KEY_KPADDEL;
			break;
		case SDLK_KP_DIVIDE:
			rc = KEY_KPADSLASH;
			break;
		case SDLK_KP_MULTIPLY:
			rc = '*';
			break;
		case SDLK_KP_MINUS:
			rc = KEY_MINUSPAD;
			break;
		case SDLK_KP_PLUS:
			rc = KEY_PLUSPAD;
			break;

#ifndef _arch_dreamcast
		case SDLK_LSUPER:
#ifdef HAVE_SDLMETAKEYS
		case SDLK_LMETA:
#endif
			rc = KEY_LEFTWIN;
			break;
		case SDLK_RSUPER:
#ifdef HAVE_SDLMETAKEYS
		case SDLK_RMETA:
#endif
			rc = KEY_RIGHTWIN;
			break;

		case SDLK_MENU:
			rc = KEY_MENU;
			break;
#endif

		default:
			if (sym >= SDLK_SPACE && sym <= SDLK_DELETE)
				rc = sym - SDLK_SPACE + ' ';
			else if (sym >= 'A' && sym <= 'Z')
				rc = sym - 'A' + 'a';
			else if (sym)
			{
				I_OutputMsg("Unknown Keycode %i, Name: %s\n",sym, SDL_GetKeyName( sym ));
			}
			else if (!sym) rc = 0;
			break;
	}

	return rc;
}

static void SDLdoUngrabMouse(void)
{
	if (SDL_GRAB_ON == SDL_WM_GrabInput(SDL_GRAB_QUERY))
	{
		SDL_WM_GrabInput(SDL_GRAB_OFF);
	}
}

void SDLforceUngrabMouse(void)
{
	if (SDL_WasInit(SDL_INIT_VIDEO)==SDL_INIT_VIDEO)
		SDL_WM_GrabInput(SDL_GRAB_OFF);
}

static void VID_Command_NumModes_f (void)
{
	CONS_Printf(M_GetText("%d video mode(s) available(s)\n"), VID_NumModes());
}

static void SurfaceInfo(const SDL_Surface *infoSurface, const char *SurfaceText)
{
	INT32 vfBPP;
	const SDL_Surface *VidSur = SDL_GetVideoSurface();

	if (!infoSurface)
		return;

	if (!SurfaceText)
		SurfaceText = M_GetText("Unknown Surface");

	vfBPP = infoSurface->format?infoSurface->format->BitsPerPixel:0;

	CONS_Printf("\x82" "%s\n", SurfaceText);
	CONS_Printf(M_GetText(" %ix%i at %i bit color\n"), infoSurface->w, infoSurface->h, vfBPP);

	if (infoSurface->flags&SDL_HWSURFACE)
		CONS_Printf("%s", M_GetText(" Stored in video memory\n"));
	else if (infoSurface->flags&SDL_OPENGL)
		CONS_Printf("%s", M_GetText(" Stored in an OpenGL context\n"));
	else if (infoSurface->flags&SDL_PREALLOC)
		CONS_Printf("%s", M_GetText(" Uses preallocated memory\n"));
	else
		CONS_Printf("%s", M_GetText(" Stored in system memory\n"));

	if (infoSurface->flags&SDL_ASYNCBLIT)
		CONS_Printf("%s", M_GetText(" Uses asynchronous blits if possible\n"));
	else
		CONS_Printf("%s", M_GetText(" Uses synchronous blits if possible\n"));

	if (infoSurface->flags&SDL_ANYFORMAT)
		CONS_Printf("%s", M_GetText(" Allows any pixel-format\n"));

	if (infoSurface->flags&SDL_HWPALETTE)
		CONS_Printf("%s", M_GetText(" Has exclusive palette access\n"));
	else if (VidSur == infoSurface)
		CONS_Printf("%s", M_GetText(" Has nonexclusive palette access\n"));

	if (infoSurface->flags&SDL_DOUBLEBUF)
		CONS_Printf("%s", M_GetText(" Double buffered\n"));
	else if (VidSur == infoSurface)
		CONS_Printf("%s", M_GetText(" No hardware flipping\n"));

	if (infoSurface->flags&SDL_FULLSCREEN)
		CONS_Printf("%s", M_GetText(" Full screen\n"));
	else if (infoSurface->flags&SDL_RESIZABLE)
		CONS_Printf("%s", M_GetText(" Resizable window\n"));
	else if (VidSur == infoSurface)
		CONS_Printf("%s", M_GetText(" Nonresizable window\n"));

	if (infoSurface->flags&SDL_HWACCEL)
		CONS_Printf("%s", M_GetText(" Uses hardware acceleration blit\n"));
	if (infoSurface->flags&SDL_SRCCOLORKEY)
		CONS_Printf("%s", M_GetText(" Use colorkey blitting\n"));
	if (infoSurface->flags&SDL_RLEACCEL)
		CONS_Printf("%s", M_GetText(" Colorkey RLE acceleration blit\n"));
	if (infoSurface->flags&SDL_SRCALPHA)
		CONS_Printf("%s", M_GetText(" Use alpha blending acceleration blit\n"));

}

static void VID_Command_Info_f (void)
{
	const SDL_VideoInfo *videoInfo;
	videoInfo = SDL_GetVideoInfo(); //Alam: Double-Check
	if (videoInfo)
	{
		CONS_Printf("%s", M_GetText("Video Interface Capabilities:\n"));
		if (videoInfo->hw_available)
			CONS_Printf("%s", M_GetText(" Hardware surfaces\n"));
		if (videoInfo->wm_available)
			CONS_Printf("%s", M_GetText(" Window manager\n"));
		//UnusedBits1  :6
		//UnusedBits2  :1
		if (videoInfo->blit_hw)
			CONS_Printf("%s", M_GetText(" Accelerated blits HW-2-HW\n"));
		if (videoInfo->blit_hw_CC)
			CONS_Printf("%s", M_GetText(" Accelerated blits HW-2-HW with Colorkey\n"));
		if (videoInfo->wm_available)
			CONS_Printf("%s", M_GetText(" Accelerated blits HW-2-HW with Alpha\n"));
		if (videoInfo->blit_sw)
		{
			CONS_Printf("%s", M_GetText(" Accelerated blits SW-2-HW\n"));
			if (!M_CheckParm("-noblit")) videoblitok = SDL_TRUE;
		}
		if (videoInfo->blit_sw_CC)
			CONS_Printf("%s", M_GetText(" Accelerated blits SW-2-HW with Colorkey\n"));
		if (videoInfo->blit_sw_A)
			CONS_Printf("%s", M_GetText(" Accelerated blits SW-2-HW with Alpha\n"));
		if (videoInfo->blit_fill)
			CONS_Printf("%s", M_GetText(" Accelerated Color filling\n"));
		//UnusedBits3  :16
		if (videoInfo->video_mem)
			CONS_Printf(M_GetText(" There is %i KB of video memory\n"), videoInfo->video_mem);
		else
			CONS_Printf("%s", M_GetText(" There no video memory for SDL\n"));
		//*vfmt
	}
	SurfaceInfo(bufSurface, M_GetText("Current Engine Mode"));
#ifdef FILTERS
	SurfaceInfo(preSurface, M_GetText("Prebuffer Mode"));
	SurfaceInfo(f2xSurface, M_GetText("Postbuffer Mode"));
#endif
	SurfaceInfo(vidSurface, M_GetText("Current Video Mode"));
}

static void VID_Command_ModeList_f(void)
{
#if !defined (DC) && !defined (_WIN32_WCE) && !defined (_PSP) &&  !defined(GP2X)
	INT32 i;
#ifdef HWRENDER
	if (rendermode == render_opengl)
		modeList = SDL_ListModes(NULL, SDL_OPENGL|SDL_FULLSCREEN);
	else
#endif
	modeList = SDL_ListModes(NULL, surfaceFlagsF|SDL_HWSURFACE); //Alam: At least hardware surface

	if (modeList == (SDL_Rect **)0 && cv_fullscreen.value)
	{
		CONS_Printf("%s", M_GetText("No video modes present\n"));
		cv_fullscreen.value = 0;
	}
	else if (modeList != (SDL_Rect **)0)
	{
		numVidModes = 0;
		if (modeList == (SDL_Rect **)-1)
			numVidModes = -1; // should not happen with fullscreen modes
		else while (modeList[numVidModes])
			numVidModes++;
	}
	CONS_Printf(M_GetText("Found %d FullScreen Video Modes:\n"), numVidModes);
	for (i=0 ; i<numVidModes; i++)
	{ // fullscreen modes
		INT32 modeNum = firstEntry + i;
		if (modeNum >= numVidModes)
			break;

		CONS_Printf(M_GetText("%dx%d and "),
				modeList[modeNum]->w,
				modeList[modeNum]->h);
	}
	CONS_Printf("%s", M_GetText("None\n"));
#endif
}

static void VID_Command_Mode_f (void)
{
	INT32 modenum;

	if (COM_Argc()!= 2)
	{
		CONS_Printf(M_GetText("vid_mode <modenum> : set video mode, current video mode %i\n"), vid.modenum);
		return;
	}

	modenum = atoi(COM_Argv(1));

	if (modenum >= VID_NumModes())
		CONS_Printf(M_GetText("Video mode not present\n"));
	else
		setmodeneeded = modenum+1; // request vid mode change
}

#if defined(RPC_NO_WINDOWS_H) && !defined(_WIN32_WCE)
static VOID MainWndproc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(hWnd);
	UNREFERENCED_PARAMETER(message);
	UNREFERENCED_PARAMETER(wParam);
	switch (message)
	{
		case WM_SETTEXT:
			COM_BufAddText((LPCSTR)lParam);
			break;
	}
}
#endif

#if 0 //#ifdef _WIN32
	// Disable Composition in Vista DWM (Desktop Window Manager) ----------------
static HMODULE DMdll = NULL;
typedef HRESULT (CALLBACK *P_DwmIsCompositionEnabled) (BOOL *pfEnabled);
static P_DwmIsCompositionEnabled pfnDwmIsCompositionEnabled = NULL;
typedef HRESULT (CALLBACK *P_DwmEnableComposition) (BOOL   fEnable);
static P_DwmEnableComposition pfnDwmEnableComposition = NULL;
static BOOL AeroWasEnabled = FALSE;

static inline VOID UnloadDM(VOID)
{
	pfnDwmEnableComposition = NULL;
	pfnDwmIsCompositionEnabled = NULL;
	if (DMdll) FreeLibrary(DMdll);
	DMdll = NULL;
}

static inline BOOL LoadDM(VOID)
{
	if (DMdll)
		return TRUE;

	DMdll = LoadLibraryA("dwmapi.dll");
	if (DMdll)
		I_OutputMsg("dmwapi.dll loaded, Vista's Desktop Window Manager API\n");
	else
		return FALSE;

	pfnDwmIsCompositionEnabled = (P_DwmIsCompositionEnabled)GetProcAddress(DMdll, "DwmIsCompositionEnabled");
	if (pfnDwmIsCompositionEnabled)
		I_OutputMsg("Composition Aero API found, DwmIsCompositionEnabled\n");

	pfnDwmEnableComposition = (P_DwmEnableComposition)GetProcAddress(DMdll, "DwmEnableComposition");
	if (pfnDwmEnableComposition)
		I_OutputMsg("Composition Aero API found, DwmEnableComposition\n");

	return TRUE;
}

static inline VOID DisableAero(VOID)
{
	BOOL pfnDwmEnableCompositiond = FALSE;
	AeroWasEnabled = FALSE;

	if (!LoadDM())
		return;

	if (pfnDwmIsCompositionEnabled && SUCCEEDED(pfnDwmIsCompositionEnabled(&pfnDwmEnableCompositiond)))
		I_OutputMsg("Got the result of DwmIsCompositionEnabled, %i\n", pfnDwmEnableCompositiond);
	else
		return;

	if ((AeroWasEnabled = pfnDwmEnableCompositiond))
		I_OutputMsg("Disable the Aero rendering\n");
	else
		return;

	if (pfnDwmEnableComposition && SUCCEEDED(pfnDwmEnableComposition(FALSE)))
		I_OutputMsg("Aero rendering disabled\n");
	else
		I_OutputMsg("We failed to disable the Aero rendering\n");
}

static inline VOID ResetAero(VOID)
{
	if (pfnDwmEnableComposition && AeroWasEnabled)
	{
		if (SUCCEEDED(pfnDwmEnableComposition(AeroWasEnabled)))
			I_OutputMsg("Aero rendering setting restored\n");
		else
			I_OutputMsg("We failed to restore Aero rendering\n");
	}
	UnloadDM();
}
#endif

static inline void SDLJoyRemap(event_t *event)
{
#if defined(GP2X)
#define GP2X_BUTTON_UP              (0)
#define GP2X_BUTTON_DOWN            (4)
#define GP2X_BUTTON_LEFT            (2)
#define GP2X_BUTTON_RIGHT           (6)
#define GP2X_BUTTON_UPLEFT          (1)
#define GP2X_BUTTON_UPRIGHT         (7)
#define GP2X_BUTTON_DOWNLEFT        (3)
#define GP2X_BUTTON_DOWNRIGHT       (5)
#define GP2X_BUTTON_CLICK           (18)
#define GP2X_BUTTON_A               (12)
#define GP2X_BUTTON_B               (13)
#define GP2X_BUTTON_X               (14)
#define GP2X_BUTTON_Y               (15)
#define GP2X_BUTTON_L               (10)
#define GP2X_BUTTON_R               (11)
#define GP2X_BUTTON_START           (8)
#define GP2X_BUTTON_SELECT          (9)
#define GP2X_BUTTON_VOLUP           (16)
#define GP2X_BUTTON_VOLDOWN         (17)
	if ((event->type == ev_keydown || event->type == ev_keyup) && (KEY_JOY1 <= event->data1 && event->data1 <= KEY_JOY1+JOYBUTTONS))
	{
		INT32 button = event->data1-KEY_JOY1;
		if (button <= 7)
		{
			static UINT8 DPAD = 0;
			if (event->type == ev_keyup)
			{
				event->type = ev_console;
				DPAD &= ~(1<<button);
			}
			else
			{
				event->type = ev_joystick;
				DPAD |= 1<<button;
			}
			event->data2 = event->data3 = INT32_MAX;
			if ((DPAD & (1<<GP2X_BUTTON_UP)) && ((DPAD & (1<<GP2X_BUTTON_UPLEFT)) || (DPAD & (1<<GP2X_BUTTON_UPRIGHT))))
				button = GP2X_BUTTON_UP;
			if ((DPAD & (1<<GP2X_BUTTON_LEFT)) && ((DPAD & (1<<GP2X_BUTTON_UPLEFT)) || (DPAD & (1<<GP2X_BUTTON_DOWNLEFT))))
				button = GP2X_BUTTON_LEFT;
			if ((DPAD & (1<<GP2X_BUTTON_DOWN)) && ((DPAD & (1<<GP2X_BUTTON_DOWNLEFT)) || (DPAD & (1<<GP2X_BUTTON_DOWNRIGHT))))
				button = GP2X_BUTTON_DOWN;
			if ((DPAD & (1<<GP2X_BUTTON_RIGHT)) && ((DPAD & (1<<GP2X_BUTTON_UPRIGHT)) || (DPAD & (1<<GP2X_BUTTON_DOWNRIGHT))))
				button = GP2X_BUTTON_RIGHT;
			if (DPAD == 0)
			{
				event->type = ev_joystick;
				event->data2 = event->data3 = 0;
			}
			else switch (button)
			{
				case GP2X_BUTTON_UP:
					event->data3 = -1;
					break;
				case GP2X_BUTTON_DOWN:
					event->data3 = 1;
					break;
				case GP2X_BUTTON_LEFT:
					event->data2 = -1;
					break;
				case GP2X_BUTTON_RIGHT:
					event->data2 = 1;
					break;
				case GP2X_BUTTON_UPLEFT:
					event->data2 = -1;
					event->data3 = -1;
					break;
				case GP2X_BUTTON_UPRIGHT:
					event->data2 = 1;
					event->data3 = -1;
					break;
				case GP2X_BUTTON_DOWNLEFT:
					event->data2 = -1;
					event->data3 = 1;
					break;
				case GP2X_BUTTON_DOWNRIGHT:
					event->data2 = 1;
					event->data3 = 1;
				default:
					break;
			}
			event->data1 = 0;
			return;
		}
		else switch (button)
		{
			case GP2X_BUTTON_CLICK:
				event->data1 = KEY_ENTER;
				break;
			case GP2X_BUTTON_A:
				event->data1 = KEY_JOY1+0;
				break;
			case GP2X_BUTTON_B:
				event->data1 = KEY_JOY1+2;
				break;
			case GP2X_BUTTON_X:
				event->data1 = KEY_JOY1+3;
				break;
			case GP2X_BUTTON_Y:
				event->data1 = KEY_JOY1+1;
				break;
			case GP2X_BUTTON_L:
				event->data1 = KEY_JOY1+4;
				break;
			case GP2X_BUTTON_R:
				event->data1 = KEY_JOY1+5;
				break;
			case GP2X_BUTTON_START:
				event->data1 = KEY_ESCAPE;
				break;
			case GP2X_BUTTON_SELECT:
				event->data1 = KEY_JOY1+8;
				break;
			case GP2X_BUTTON_VOLUP:
				event->data1 = KEY_JOY1+6;
				break;
			case GP2X_BUTTON_VOLDOWN:
				event->data1 = KEY_JOY1+7;
				break;
			default:
				break;
		}
		//I_OutputMsg("Button %i: event key %i and type: %i\n", button, event->data1, event->type);
	}
#elif defined(_PSP)
	if (event->data1 > KEY_JOY1 + 9 + 2) // All button after D-Pad and Select/Start
		event->data1 -= 4; // remap D-pad to Hats, offset of -4
	else if (event->data1 == KEY_JOY1 + 6) // Down
		event->data1 = KEY_HAT1+1;
	else if (event->data1 == KEY_JOY1 + 7) // Left
		event->data1 = KEY_HAT1+2;
	else if (event->data1 == KEY_JOY1 + 8) // Up
		event->data1 = KEY_HAT1+0;
	else if (event->data1 == KEY_JOY1 + 9) // Right
		event->data1 = KEY_HAT1+3;
	else if (event->data1 == KEY_JOY1 + 10) // Select
		event->data1 = KEY_TAB;
	else if (event->data1 == KEY_JOY1 + 11) // Start
		event->data1 = KEY_ESCAPE;
#else
	(void)event;
#endif
}

static INT32 SDLJoyAxis(const Sint16 axis, evtype_t which)
{
#ifdef _arch_dreamcast // -128 to 127 SDL for DC have give us a smaller range
	INT32 raxis = axis*8;
#else // -32768 to 32767
	INT32 raxis = axis/32;
#endif
	if (which == ev_joystick)
	{
		if (Joystick.bGamepadStyle)
		{
			// gamepad control type, on or off, live or die
			if (raxis < -(JOYAXISRANGE/2))
				raxis = -1;
			else if (raxis > (JOYAXISRANGE/2))
				raxis = 1;
			else
				raxis = 0;
		}
		else
		{
			raxis = JoyInfo.scale!=1?((raxis/JoyInfo.scale)*JoyInfo.scale):raxis;

#ifdef SDL_JDEADZONE
			if (-SDL_JDEADZONE <= raxis && raxis <= SDL_JDEADZONE)
				raxis = 0;
#endif
		}
	}
	else if (which == ev_joystick2)
	{
		if (Joystick2.bGamepadStyle)
		{
			// gamepad control type, on or off, live or die
			if (raxis < -(JOYAXISRANGE/2))
				raxis = -1;
			else if (raxis > (JOYAXISRANGE/2))
				raxis = 1;
			else raxis = 0;
		}
		else
		{
			raxis = JoyInfo2.scale!=1?((raxis/JoyInfo2.scale)*JoyInfo2.scale):raxis;

#ifdef SDL_JDEADZONE
			if (-SDL_JDEADZONE <= raxis && raxis <= SDL_JDEADZONE)
				raxis = 0;
#endif
		}
	}
	return raxis;
}

void I_GetEvent(void)
{
	SDL_Event inputEvent;
	static SDL_bool sdlquit = SDL_FALSE; //Alam: once, just once
	event_t event;

	if (!graphics_started)
		return;

	memset(&inputEvent, 0x00, sizeof(inputEvent));
	while (SDL_PollEvent(&inputEvent))
	{
		memset(&event,0x00,sizeof (event_t));
		switch (inputEvent.type)
		{
			case SDL_ACTIVEEVENT:
				if (inputEvent.active.state  & (SDL_APPACTIVE|SDL_APPINPUTFOCUS))
				{
					// pause music when alt-tab
					if (inputEvent.active.gain /*&& !paused */)
					{
						static SDL_bool firsttimeonmouse = SDL_TRUE;
						if (!firsttimeonmouse)
						{
							if (cv_usemouse.value) I_StartupMouse();
						}
						else firsttimeonmouse = SDL_FALSE;
						//if (!netgame && !con_destlines) paused = false;
						if (gamestate == GS_LEVEL)
							if (!paused) I_ResumeSong(0); //resume it
					}
					else /*if (!paused)*/
					{
						if (!disable_mouse)
							SDLforceUngrabMouse();
						if (!netgame && gamestate == GS_LEVEL) paused = true;
						memset(gamekeydown, 0, NUMKEYS);
						//S_PauseSound();
						if (gamestate == GS_LEVEL)
							I_PauseSong(0); //pause it
					}
				}
				if (MOUSE_MENU)
				{
					SDLdoUngrabMouse();
					break;
				}
				if ((SDL_APPMOUSEFOCUS&inputEvent.active.state) && USE_MOUSEINPUT && inputEvent.active.gain)
					HalfWarpMouse(realwidth, realheight);
				break;
			case SDL_KEYDOWN:
			case SDL_KEYUP:
				/// \todo inputEvent.key.which?
				if (inputEvent.type == SDL_KEYUP)
					event.type = ev_keyup;
				else if (inputEvent.type == SDL_KEYDOWN)
					event.type = ev_keydown;
				else break;
				event.data1 = SDLatekey(inputEvent.key.keysym.sym);
				if (event.data1) D_PostEvent(&event);
				break;
			case SDL_MOUSEMOTION:
				/// \todo inputEvent.motion.which
				if (MOUSE_MENU)
				{
					SDLdoUngrabMouse();
					break;
				}
				if (USE_MOUSEINPUT)
				{
					// If the event is from warping the pointer back to middle
					// of the screen then ignore it.
					if ((inputEvent.motion.x == realwidth/2) &&
					    (inputEvent.motion.y == realheight/2))
					{
						break;
					}
					else
					{
						event.data2 = +inputEvent.motion.xrel;
						event.data3 = -inputEvent.motion.yrel;
					}
					event.type = ev_mouse;
					D_PostEvent(&event);
					// Warp the pointer back to the middle of the window
					//  or we cannot move any further if it's at a border.
					if ((inputEvent.motion.x < (realwidth/2 )-(realwidth/4 )) ||
					    (inputEvent.motion.y < (realheight/2)-(realheight/4)) ||
					    (inputEvent.motion.x > (realwidth/2 )+(realwidth/4 )) ||
					    (inputEvent.motion.y > (realheight/2)+(realheight/4) ) )
					{
						//if (SDL_GRAB_ON == SDL_WM_GrabInput(SDL_GRAB_QUERY) || !mousegrabok)
							HalfWarpMouse(realwidth, realheight);
					}
				}
				break;
			case SDL_MOUSEBUTTONDOWN:
			case SDL_MOUSEBUTTONUP:
				/// \todo inputEvent.button.which
				if (USE_MOUSEINPUT)
				{
					if (inputEvent.type == SDL_MOUSEBUTTONUP)
						event.type = ev_keyup;
					else if (inputEvent.type == SDL_MOUSEBUTTONDOWN)
						event.type = ev_keydown;
					else break;
					if (inputEvent.button.button==SDL_BUTTON_WHEELUP || inputEvent.button.button==SDL_BUTTON_WHEELDOWN)
					{
						if (inputEvent.type == SDL_MOUSEBUTTONUP)
							event.data1 = 0; //Alam: dumb! this could be a real button with some mice
						else
							event.data1 = KEY_MOUSEWHEELUP + inputEvent.button.button - SDL_BUTTON_WHEELUP;
					}
					else if (inputEvent.button.button == SDL_BUTTON_MIDDLE)
						event.data1 = KEY_MOUSE1+2;
					else if (inputEvent.button.button == SDL_BUTTON_RIGHT)
						event.data1 = KEY_MOUSE1+1;
					else if (inputEvent.button.button <= MOUSEBUTTONS)
						event.data1 = KEY_MOUSE1 + inputEvent.button.button - SDL_BUTTON_LEFT;
					if (event.data1) D_PostEvent(&event);
				}
				break;
			case SDL_JOYAXISMOTION:
				inputEvent.jaxis.which++;
				inputEvent.jaxis.axis++;
				event.data1 = event.data2 = event.data3 = INT32_MAX;
				if (cv_usejoystick.value == inputEvent.jaxis.which)
				{
					event.type = ev_joystick;
				}
				else if (cv_usejoystick.value == inputEvent.jaxis.which)
				{
					event.type = ev_joystick2;
				}
				else break;
				//axis
				if (inputEvent.jaxis.axis > JOYAXISSET*2)
					break;
				//vaule
				if (inputEvent.jaxis.axis%2)
				{
					event.data1 = inputEvent.jaxis.axis / 2;
					event.data2 = SDLJoyAxis(inputEvent.jaxis.value, event.type);
				}
				else
				{
					inputEvent.jaxis.axis--;
					event.data1 = inputEvent.jaxis.axis / 2;
					event.data3 = SDLJoyAxis(inputEvent.jaxis.value, event.type);
				}
				D_PostEvent(&event);
				break;
			case SDL_JOYBALLMOTION:
			case SDL_JOYHATMOTION:
				break; //NONE
			case SDL_JOYBUTTONDOWN:
			case SDL_JOYBUTTONUP:
				inputEvent.jbutton.which++;
				if (cv_usejoystick.value == inputEvent.jbutton.which)
					event.data1 = KEY_JOY1;
				else if (cv_usejoystick.value == inputEvent.jbutton.which)
					event.data1 = KEY_2JOY1;
				else break;
				if (inputEvent.type == SDL_JOYBUTTONUP)
					event.type = ev_keyup;
				else if (inputEvent.type == SDL_JOYBUTTONDOWN)
					event.type = ev_keydown;
				else break;
				if (inputEvent.jbutton.button < JOYBUTTONS)
					event.data1 += inputEvent.jbutton.button;
				else
					break;
				SDLJoyRemap(&event);
				if (event.type != ev_console) D_PostEvent(&event);
				break;
#ifndef  _WIN32_WCE
			case SDL_QUIT:
				if (!sdlquit)
				{
					sdlquit = SDL_TRUE;
					M_QuitResponse('y');
				}
				break;
#endif
#if defined(RPC_NO_WINDOWS_H) && !defined(_WIN32_WCE)
			case SDL_SYSWMEVENT:
				MainWndproc(inputEvent.syswm.msg->hwnd,
					inputEvent.syswm.msg->msg,
					inputEvent.syswm.msg->wParam,
					inputEvent.syswm.msg->lParam);
				break;
#endif
			case SDL_VIDEORESIZE:
				if (gamestate == GS_LEVEL || gamestate == GS_TITLESCREEN || gamestate == GS_EVALUATION)
				    setmodeneeded = VID_GetModeForSize(inputEvent.resize.w,inputEvent.resize.h)+1;
				if (render_soft == rendermode)
				{
#ifdef FILTERS
					INT32 filtervalue = cv_filter.value;
					if (blitfilter) CV_SetValue(&cv_filter,1);
#endif
					SDLSetMode(realwidth, realheight, vid.bpp*8, surfaceFlagsW);
					if (vidSurface) SDL_SetColors(vidSurface, localPalette, 0, 256);
#ifdef FILTERS
					CV_SetValue(&cv_filter,filtervalue);
#endif
				}
				else
					SDLSetMode(realwidth, realheight, vid.bpp*8, surfaceFlagsW);
				if (!vidSurface)
					I_Error("Could not reset vidmode: %s\n",SDL_GetError());
				break;
			case SDL_VIDEOEXPOSE:
				exposevideo = SDL_TRUE;
				break;
			default:
				break;
		}
	}
	//reset wheel like in win32, I don't understand it but works
	gamekeydown[KEY_MOUSEWHEELDOWN] = gamekeydown[KEY_MOUSEWHEELUP] = 0;
}

void I_StartupMouse(void)
{
	static SDL_bool firsttimeonmouse = SDL_TRUE;

	if (disable_mouse)
		return;

	if (!firsttimeonmouse)
		HalfWarpMouse(realwidth, realheight); // warp to center
	else
		firsttimeonmouse = SDL_FALSE;
	if (cv_usemouse.value)
		return;
	else
		SDLdoUngrabMouse();
}

//
// I_OsPolling
//
void I_OsPolling(void)
{
	if (consolevent)
		I_GetConsoleEvents();
	if (SDL_WasInit(SDL_INIT_JOYSTICK) == SDL_INIT_JOYSTICK)
	{
		SDL_JoystickUpdate();
		I_GetJoystickEvents();
		I_GetJoystick2Events();
	}
#ifdef _arch_dreamcast
	//vmu_set_icon(VMU_bits);
#endif

	I_GetMouseEvents();

	I_GetEvent();
}

//
// I_UpdateNoBlit
//
void I_UpdateNoBlit(void)
{
	if (!vidSurface)
		return;
#ifdef HWRENDER
	if (rendermode != render_soft)
		OglSdlFinishUpdate(cv_vidwait.value);
	else
#endif
	if (vidSurface->flags&SDL_DOUBLEBUF)
		SDL_Flip(vidSurface);
	else if (exposevideo)
		SDL_UpdateRect(vidSurface, 0, 0, 0, 0);
	exposevideo = SDL_FALSE;
}

// I_SkipFrame
//
// Returns true if it thinks we can afford to skip this frame
// from PrBoom's src/SDL/i_video.c
static inline boolean I_SkipFrame(void)
{
	static boolean skip = false;

	if (render_soft != rendermode)
		return false;

	skip = !skip;

#if 0 //(defined (GP2X) || defined (PSP) || defined (_arch_dreamcast))
	return skip;
#endif

	switch (gamestate)
	{
		case GS_LEVEL:
			if (!paused)
				return false;
		case GS_WAITINGPLAYERS:
			return skip; // Skip odd frames
		default:
			return false;
	}
}

static inline SDL_bool SDLmatchVideoformat(void)
{
	const SDL_PixelFormat *vidformat = vidSurface->format;
	const INT32 vfBPP = vidformat?vidformat->BitsPerPixel:0;
	return (((vfBPP == 8 && vid.bpp == 1 &&
	 !vidformat->Rmask && !vidformat->Gmask && !vidformat->Bmask) ||
	 (vfBPP == 15 && vid.bpp == 2 && vidformat->Rmask == 0x7C00 &&
	 vidformat->Gmask == 0x03E0 && vidformat->Bmask == 0x001F )) &&
	 !vidformat->Amask && (vidSurface->flags & SDL_RLEACCEL) == 0);
}

//
// I_FinishUpdate
//
void I_FinishUpdate(void)
{
	if (!vidSurface)
		return; //Alam: No software or OpenGl surface

	if (I_SkipFrame())
		return;

	if (cv_ticrate.value)
		SCR_DisplayTicRate();

	if (cv_showping.value && netgame && consoleplayer != serverplayer)
		SCR_DisplayLocalPing();

	if (render_soft == rendermode && screens[0])
	{
		SDL_Rect *dstrect = NULL;
		SDL_Rect rect = {0, 0, 0, 0};
		SDL_PixelFormat *vidformat = vidSurface->format;
		int lockedsf = 0, blited = 0;

		rect.w = (Sint16)vid.width;
		rect.h = (Sint16)vid.height;

		if (vidSurface->h > vid.height)
			rect.y = (Sint16)((vidSurface->h-vid.height)/2);

		dstrect = &rect;


		if (!bufSurface && !vid.direct) //Double-Check
		{
			if (vid.bpp == 1) bufSurface = SDL_CreateRGBSurfaceFrom(screens[0],vid.width,vid.height,8,
				(int)vid.rowbytes,0x00000000,0x00000000,0x00000000,0x00000000); // 256 mode
			else if (vid.bpp == 2) bufSurface = SDL_CreateRGBSurfaceFrom(screens[0],vid.width,vid.height,15,
				(int)vid.rowbytes,0x00007C00,0x000003E0,0x0000001F,0x00000000); // 555 mode
			if (bufSurface) SDL_SetColors(bufSurface, localPalette, 0, 256);
			else I_OutputMsg("No system memory for SDL buffer surface\n");
		}

#ifdef FILTERS
		FilterBlit(bufSurface);
		if (f2xSurface) //Alam: filter!
		{
			//I_OutputMsg("2x Filter Code\n");
			blited = SDL_BlitSurface(f2xSurface,NULL,vidSurface,NULL);
		}
		else
#endif
#if 0
		if (SDLmatchVideoformat() && !vid.direct)//Alam: DOS Way
		{
			if (SDL_MUSTLOCK(vidSurface)) lockedsf = SDL_LockSurface(vidSurface);
			if (lockedsf == 0)
			{
				if (vidSurface->pixels > vid.height)
				{
					UINT8 *ptr = vidSurface->pixels;
					size_t half_excess = vidSurface->pitch*(vidSurface->height-vid.height)/2;
					memset(ptr, 0x1F, half_excess);
					ptr += half_excess;
					VID_BlitLinearScreen(screens[0], ptr, vid.width*vid.bpp, vid.height,
					                     vid.rowbytes, vidSurface->pitch);
					ptr += vid.height*vidSurface->pitch;
					memset(ptr, 0x1F, half_excess);
				}
				else
				VID_BlitLinearScreen(screens[0], vidSurface->pixels, vid.width*vid.bpp,
				                     vid.height, vid.rowbytes, vidSurface->pitch );
				if (SDL_MUSTLOCK(vidSurface)) SDL_UnlockSurface(vidSurface);
			}
		}
		else
#endif
		if (bufSurface) //Alam: New Way to send video data
		{
			blited = SDL_BlitSurface(bufSurface,NULL,vidSurface,dstrect);
		}
		else if (vid.bpp == 1 && !vid.direct)
		{
			Uint8 *bP,*vP; //Src, Dst
			Uint16 bW, vW; // Pitch Remainder
			Sint32 pH, pW; //Height, Width
			bP = (Uint8 *)screens[0];
			bW = (Uint16)(vid.rowbytes - vid.width);
			//I_OutputMsg("Old Copy Code\n");
			if (SDL_MUSTLOCK(vidSurface)) lockedsf = SDL_LockSurface(vidSurface);
			vP = (Uint8 *)vidSurface->pixels;
			vW = (Uint16)(vidSurface->pitch - vidSurface->w*vidformat->BytesPerPixel);
			if (vidSurface->h > vid.height)
				vP += vidSurface->pitch*(vidSurface->h-vid.height)/2;
			if (lockedsf == 0 && vidSurface->pixels)
			{
				if (vidformat->BytesPerPixel == 2)
				{
					for (pH=0;pH < vidSurface->h;pH++)
					{
						for (pW=0;pW < vidSurface->w;pW++)
						{
							*((Uint16 *)(void *)vP) = (Uint16)SDL_MapRGB(vidformat,
								localPalette[*bP].r,localPalette[*bP].g,localPalette[*bP].b);
							bP++;
							vP += 2;
						}
						bP += bW;
						vP += vW;
					}
				}
				else if (vidformat->BytesPerPixel == 3)
				{
					for (pH=0;pH < vidSurface->h;pH++)
					{
						for (pW=0;pW < vidSurface->w;pW++)
						{
							*((Uint32 *)(void *)vP) = SDL_MapRGB(vidformat,
								localPalette[*bP].r,localPalette[*bP].g,localPalette[*bP].b);
							bP++;
							vP += 3;
						}
						bP += bW;
						vP += vW;
					}
				}
				else if (vidformat->BytesPerPixel == 4)
				{
					for (pH=0;pH < vidSurface->h;pH++)
					{
						for (pW=0;pW < vidSurface->w;pW++)
						{
							*((Uint32 *)(void *)vP) = SDL_MapRGB(vidformat,
								localPalette[*bP].r,localPalette[*bP].g,localPalette[*bP].b);
							bP++;
							vP += 4;
						}
						bP += bW;
						vP += vW;
					}
				}
				else
				{
					;//NOP
				}
			}
			if (SDL_MUSTLOCK(vidSurface)) SDL_UnlockSurface(vidSurface);
		}
		else /// \todo 15t15,15tN, others?
		{
			;//NOP
		}

#ifdef HAVE_GP2XSDL
		//if (blited == 0)
			SDL_GP2X_WaitForBlitter();
#endif

		if (lockedsf == 0 && blited == 0 && vidSurface->flags&SDL_DOUBLEBUF)
			SDL_Flip(vidSurface);
		else if (blited != -2 && lockedsf == 0) //Alam: -2 for Win32 Direct, yea, i know
			SDL_UpdateRect(vidSurface, rect.x, rect.y, 0, 0); //Alam: almost always
		else
			I_OutputMsg("%s\n",SDL_GetError());
	}
#ifdef HWRENDER
	else
	{
		OglSdlFinishUpdate(cv_vidwait.value);
	}
#endif
	exposevideo = SDL_FALSE;
}

//
// I_UpdateNoVsync
//
void I_UpdateNoVsync(void)
{
	INT32 real_vidwait = cv_vidwait.value;
	cv_vidwait.value = 0;
	I_FinishUpdate();
	cv_vidwait.value = real_vidwait;
}

//
// I_ReadScreen
//
void I_ReadScreen(UINT8 *scr)
{
	if (rendermode != render_soft)
		I_Error ("I_ReadScreen: called while in non-software mode");
	else
		VID_BlitLinearScreen(screens[0], scr,
			vid.width*vid.bpp, vid.height,
			vid.rowbytes, vid.rowbytes);
}

//
// I_SetPalette
//
void I_SetPalette(RGBA_t *palette)
{
	size_t i;
	for (i=0; i<256; i++)
	{
		localPalette[i].r = palette[i].s.red;
		localPalette[i].g = palette[i].s.green;
		localPalette[i].b = palette[i].s.blue;
	}
	if (vidSurface) SDL_SetColors(vidSurface, localPalette, 0, 256);
	if (bufSurface) SDL_SetColors(bufSurface, localPalette, 0, 256);
}

// return number of fullscreen + X11 modes
INT32 VID_NumModes(void)
{
	if (USE_FULLSCREEN && numVidModes != -1)
		return numVidModes - firstEntry;
	else
		return MAXWINMODES;
}

const char *VID_GetModeName(INT32 modeNum)
{
	if (USE_FULLSCREEN && numVidModes != -1) // fullscreen modes
	{
		modeNum += firstEntry;
		if (modeNum >= numVidModes)
			return NULL;

		sprintf(&vidModeName[modeNum][0], "%dx%d",
			modeList[modeNum]->w,
			modeList[modeNum]->h);
	}
	else // windowed modes
	{
		if (modeNum > MAXWINMODES)
			return NULL;

		sprintf(&vidModeName[modeNum][0], "%dx%d",
			windowedModes[modeNum][0],
			windowedModes[modeNum][1]);
	}
	return &vidModeName[modeNum][0];
}

INT32 VID_GetModeForSize(INT32 w, INT32 h)
{
	INT32 matchMode = -1, i;
	VID_PrepareModeList();
	if (USE_FULLSCREEN && numVidModes != -1)
	{
		for (i=firstEntry; i<numVidModes; i++)
		{
			if (modeList[i]->w == w &&
			    modeList[i]->h == h)
			{
				matchMode = i;
				break;
			}
		}
		if (-1 == matchMode) // use smaller mode
		{
			w -= w%BASEVIDWIDTH;
			h -= h%BASEVIDHEIGHT;
			for (i=firstEntry; i<numVidModes; i++)
			{
				if (modeList[i]->w == w &&
				    modeList[i]->h == h)
				{
					matchMode = i;
					break;
				}
			}
			if (-1 == matchMode) // use smallest mode
				matchMode = numVidModes-1;
		}
		matchMode -= firstEntry;
	}
	else
	{
		for (i=0; i<MAXWINMODES; i++)
		{
			if (windowedModes[i][0] == w &&
			    windowedModes[i][1] == h)
			{
				matchMode = i;
				break;
			}
		}
		if (-1 == matchMode) // use smaller mode
		{
			w -= w%BASEVIDWIDTH;
			h -= h%BASEVIDHEIGHT;
			for (i=0; i<MAXWINMODES; i++)
			{
				if (windowedModes[i][0] == w &&
				    windowedModes[i][1] == h)
				{
					matchMode = i;
					break;
				}
			}
			if (-1 == matchMode) // use smallest mode
				matchMode = MAXWINMODES-1;
		}
	}
	return matchMode;
}

void VID_PrepareModeList(void)
{
	INT32 i;

	firstEntry = 0;

#ifdef HWRENDER
	if (rendermode == render_opengl)
		modeList = SDL_ListModes(NULL, SDL_OPENGL|SDL_FULLSCREEN);
	else
#endif
	modeList = SDL_ListModes(NULL, surfaceFlagsF|SDL_HWSURFACE); //Alam: At least hardware surface

	if (disable_fullscreen?0:cv_fullscreen.value) // only fullscreen needs preparation
	{
		if (-1 != numVidModes)
		{
			for (i=0; i<numVidModes; i++)
			{
				if (modeList[i]->w <= MAXVIDWIDTH &&
					modeList[i]->h <= MAXVIDHEIGHT)
				{
					firstEntry = i;
					break;
				}
			}
		}
	}
	allow_fullscreen = true;
}

static inline void SDLESSet(void)
{
#ifdef HAVE_DCSDL
	INT32 j;
	SDL_DC_SetVideoDriver(SDL_DC_DIRECT_VIDEO); //SDL_DC_DMA_VIDEO
	for (j=0;j<4;j++)
	{
		SDL_DC_MapKey(j,SDL_DC_START,SDLK_ESCAPE);
		SDL_DC_MapKey(j,SDL_DC_A,SDLK_UNKNOWN);
		SDL_DC_MapKey(j,SDL_DC_B,SDLK_UNKNOWN);
		SDL_DC_MapKey(j,SDL_DC_X,SDLK_UNKNOWN);
		SDL_DC_MapKey(j,SDL_DC_Y,SDLK_UNKNOWN);
		SDL_DC_MapKey(j,SDL_DC_L,SDLK_UNKNOWN);
		SDL_DC_MapKey(j,SDL_DC_R,SDLK_UNKNOWN);
		//SDL_DC_MapKey(j,SDL_DC_LEFT,SDLK_UNKNOWN);
		//SDL_DC_MapKey(j,SDL_DC_RIGHT,SDLK_UNKNOWN);
		//SDL_DC_MapKey(j,SDL_DC_UP,SDLK_UNKNOWN);
		//SDL_DC_MapKey(j,SDL_DC_DOWN,SDLK_UNKNOWN);
	}
	//SDL_DC_MapKey(0,SDL_DC_L,SDLK_LEFTBRACKET);
	//SDL_DC_MapKey(0,SDL_DC_R,SDLK_RIGHTBRACKET);
	//SDL_DC_MapKey(0,SDL_DC_START,SDLK_UNKNOWN);
	//SDL_DC_MapKey(1,SDL_DC_L,SDLK_z);
	//SDL_DC_MapKey(1,SDL_DC_R,SDLK_x);
#endif
#ifdef HAVE_GP2XSDL
	SDL_GP2X_MiniDisplay(0,0);
	//SDL_GP2X_DenyGfxMemory(NULL, 0);
	SDL_GP2X_AllowGfxMemory(NULL, 0);
#endif
}

static void SDLWMSet(void)
{
#ifdef RPC_NO_WINDOWS_H
	SDL_SysWMinfo SDLWM;
	memset(&SDLWM,0,sizeof (SDL_SysWMinfo));
	SDL_VERSION(&SDLWM.version)
	if (SDL_GetWMInfo(&SDLWM))
		vid.WndParent = SDLWM.window;
	else
		vid.WndParent = INVALID_HANDLE_VALUE;
	if (vid.WndParent != INVALID_HANDLE_VALUE)
	{
		SetFocus(vid.WndParent);
		ShowWindow(vid.WndParent, SW_SHOW);
	}
#ifndef _WIN32_WCE
	SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
#endif
#endif
	SDL_EventState(SDL_VIDEORESIZE, SDL_IGNORE);
}

static void* SDLGetDirect(void)
{
#if 0 //#ifndef __MACH__ // Do not directly access the MacOSX's OpenGL memory
	if (!SDL_MUSTLOCK(vidSurface) && SDLmatchVideoformat())
	{
		vid.rowbytes = vidSurface->pitch;
		return vidSurface->pixels;
	}
#endif // you can not use the video memory in pixels member in fullscreen mode
	return NULL;
}

INT32 VID_SetMode(INT32 modeNum)
{
#ifdef _WIN32_WCE
	(void)modeNum;
#else
	SDLdoUngrabMouse();
	vid.recalc = true;
	BitsPerPixel = (Uint8)cv_scr_depth.value;
	//vid.bpp = BitsPerPixel==8?1:2;
	// Window title
	SDL_WM_SetCaption("SRB2Kart "VERSIONSTRING, "SRB2Kart");

	if (render_soft == rendermode)
	{
		//Alam: SDL_Video system free vidSurface for me
		if (vid.buffer) free(vid.buffer);
		vid.buffer = NULL;
		if (bufSurface) SDL_FreeSurface(bufSurface);
		bufSurface = NULL;
	}

	if (USE_FULLSCREEN)
	{
		if (numVidModes != -1)
		{
			modeNum += firstEntry;
			vid.width = modeList[modeNum]->w;
			vid.height = modeList[modeNum]->h;
		}
		else
		{
			vid.width = windowedModes[modeNum][0];
			vid.height = windowedModes[modeNum][1];
		}
		if (render_soft == rendermode)
		{
			SDLSetMode(vid.width, vid.height, BitsPerPixel, surfaceFlagsF);

			if (!vidSurface)
			{
				cv_fullscreen.value = 0;
				modeNum = VID_GetModeForSize(vid.width,vid.height);
				vid.width = windowedModes[modeNum][0];
				vid.height = windowedModes[modeNum][1];
				SDLSetMode(vid.width, vid.height, BitsPerPixel, surfaceFlagsW);
				if (!vidSurface)
					I_Error("Could not set vidmode: %s\n",SDL_GetError());
			}
		}
#ifdef HWRENDER
		else // (render_soft != rendermode)
		{
			if (!OglSdlSurface(vid.width, vid.height, true))
			{
				cv_fullscreen.value = 0;
				modeNum = VID_GetModeForSize(vid.width,vid.height);
				vid.width = windowedModes[modeNum][0];
				vid.height = windowedModes[modeNum][1];
				if (!OglSdlSurface(vid.width, vid.height,false))
					I_Error("Could not set vidmode: %s\n",SDL_GetError());
			}

			realwidth = (Uint16)vid.width;
			realheight = (Uint16)vid.height;
		}
#endif
	}
	else //(cv_fullscreen.value)
	{
		vid.width = windowedModes[modeNum][0];
		vid.height = windowedModes[modeNum][1];

		if (render_soft == rendermode)
		{
			SDLSetMode(vid.width, vid.height, BitsPerPixel, surfaceFlagsW);
			if (!vidSurface)
				I_Error("Could not set vidmode: %s\n",SDL_GetError());
		}
#ifdef HWRENDER
		else //(render_soft != rendermode)
		{
			if (!OglSdlSurface(vid.width, vid.height, false))
				I_Error("Could not set vidmode: %s\n",SDL_GetError());
			realwidth = (Uint16)vid.width;
			realheight = (Uint16)vid.height;
		}
#endif
	}

	vid.modenum = VID_GetModeForSize(vidSurface->w,vidSurface->h);

	if (render_soft == rendermode)
	{
		vid.rowbytes = vid.width*vid.bpp;
		vid.direct = SDLGetDirect();
		vid.buffer = malloc(vid.rowbytes*vid.height*NUMSCREENS);
		if (vid.buffer) memset(vid.buffer,0x00,vid.rowbytes*vid.height*NUMSCREENS);
		else I_Error ("Not enough memory for video buffer\n");
	}

#if 0 // broken
	if (!cv_stretch.value && (float)vid.width/vid.height != ((float)BASEVIDWIDTH/BASEVIDHEIGHT))
		vid.height = (INT32)(vid.width * ((float)BASEVIDHEIGHT/BASEVIDWIDTH));// Adjust the height to match
#endif
#endif
	I_StartupMouse();

	SDLWMSet();

	return true;
}

void I_StartupGraphics(void)
{
	static char SDLNOMOUSE[] = "SDL_NOMOUSE=1";
	static char SDLVIDEOMID[] = "SDL_VIDEO_CENTERED=center";

	if (dedicated)
	{
		rendermode = render_none;
		return;
	}
	if (graphics_started)
		return;

	COM_AddCommand ("vid_nummodes", VID_Command_NumModes_f);
	COM_AddCommand ("vid_info", VID_Command_Info_f);
	COM_AddCommand ("vid_modelist", VID_Command_ModeList_f);
	COM_AddCommand ("vid_mode", VID_Command_Mode_f);
	CV_RegisterVar (&cv_vidwait);
	CV_RegisterVar (&cv_stretch);
#ifdef FILTERS
	CV_RegisterVar (&cv_filter);
#endif
#ifdef _PSP // pitch is 0, mod of 0 crash
	disable_mouse = true;
#else
	disable_mouse = M_CheckParm("-nomouse");
#endif
	if (disable_mouse)
		I_PutEnv(SDLNOMOUSE);
	if (!I_GetEnv("SDL_VIDEO_CENTERED"))
		I_PutEnv(SDLVIDEOMID);
	disable_fullscreen = M_CheckParm("-win");

	keyboard_started = true;
#ifdef _arch_dreamcast
	conio_shutdown();
#endif

#if !defined(HAVE_TTF)
#ifdef _WIN32 // Initialize Audio as well, otherwise Win32's DirectX can not use audio
	if (SDL_InitSubSystem(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0)
#else //SDL_OpenAudio will do SDL_InitSubSystem(SDL_INIT_AUDIO)
	if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
#endif
	{
#ifdef _WIN32
		if (SDL_WasInit(SDL_INIT_AUDIO)==0)
			CONS_Printf(M_GetText("Couldn't initialize SDL's Audio System with Video System: %s\n"), SDL_GetError());
		if (SDL_WasInit(SDL_INIT_VIDEO)==0)
#endif
		{
			CONS_Printf(M_GetText("Couldn't initialize SDL's Video System: %s\n"), SDL_GetError());
			return;
		}
	}
#ifdef REMOTE_DEBUGGING
#ifdef _WII
	_break(); // break for debugger
#endif
#endif
#endif
	{
		char vd[100]; //stack space for video name
		CONS_Printf(M_GetText("Starting up with video driver : %s\n"), SDL_VideoDriverName(vd,100));
		if (strncasecmp(vd, "gcvideo", 8) == 0 || strncasecmp(vd, "fbcon", 6) == 0 || strncasecmp(vd, "wii", 4) == 0 || strncasecmp(vd, "psl1ght", 8) == 0)
			framebuffer = SDL_TRUE;
	}
	if (M_CheckParm("-software"))
		rendermode = render_soft;
	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY>>1,SDL_DEFAULT_REPEAT_INTERVAL<<2);
	SDLESSet();
	VID_Command_ModeList_f();
	vid.buffer = NULL;  // For software mode
	vid.width = BASEVIDWIDTH; // Default size for startup
	vid.height = BASEVIDHEIGHT; // BitsPerPixel is the SDL interface's
	vid.recalc = true; // Set up the console stufff
	vid.direct = NULL; // Maybe direct access?
	vid.bpp = 1; // This is the game engine's Bpp
	vid.WndParent = NULL; //For the window?

#ifdef HAVE_TTF
	I_ShutdownTTF();
#endif

	// Window title
#ifdef _WIN32_WCE
	SDL_WM_SetCaption("SRB2Kart "VERSIONSTRING, "SRB2Kart");
#else
	SDL_WM_SetCaption("SRB2Kart: Starting up", "SRB2Kart");
#endif

	// Window icon
#ifdef HAVE_IMAGE
	icoSurface = IMG_ReadXPMFromArray(SDL_icon_xpm);
#endif
	SDL_WM_SetIcon(icoSurface, NULL);

#ifdef _WIN32
	//DisableAero(); //also disable Aero on Vista
#endif

#ifdef HWRENDER
	if (M_CheckParm("-opengl") || rendermode == render_opengl)
	{
		rendermode = render_opengl;
		HWD.pfnInit             = hwSym("Init",NULL);
		HWD.pfnFinishUpdate     = NULL;
		HWD.pfnDraw2DLine       = hwSym("Draw2DLine",NULL);
		HWD.pfnDrawPolygon      = hwSym("DrawPolygon",NULL);
		HWD.pfnSetBlend         = hwSym("SetBlend",NULL);
		HWD.pfnClearBuffer      = hwSym("ClearBuffer",NULL);
		HWD.pfnSetTexture       = hwSym("SetTexture",NULL);
		HWD.pfnReadRect         = hwSym("ReadRect",NULL);
		HWD.pfnGClipRect        = hwSym("GClipRect",NULL);
		HWD.pfnClearMipMapCache = hwSym("ClearMipMapCache",NULL);
		HWD.pfnSetSpecialState  = hwSym("SetSpecialState",NULL);
		HWD.pfnSetPalette       = hwSym("SetPalette",NULL);
		HWD.pfnGetTextureUsed   = hwSym("GetTextureUsed",NULL);
		HWD.pfnDrawMD2          = hwSym("DrawMD2",NULL);
		HWD.pfnDrawMD2i         = hwSym("DrawMD2i",NULL);
		HWD.pfnSetTransform     = hwSym("SetTransform",NULL);
		HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
#ifdef SHUFFLE
		HWD.pfnPostImgRedraw    = hwSym("PostImgRedraw",NULL);
#endif
		HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
		HWD.pfnStartScreenWipe  = hwSym("StartScreenWipe",NULL);
		HWD.pfnEndScreenWipe    = hwSym("EndScreenWipe",NULL);
		HWD.pfnDoScreenWipe     = hwSym("DoScreenWipe",NULL);
		HWD.pfnDrawIntermissionBG=hwSym("DrawIntermissionBG",NULL);
		HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
		// check gl renderer lib
		if (HWD.pfnGetRenderVersion() != VERSION)
			I_Error("%s", M_GetText("The version of the renderer doesn't match the version of the executable\nBe sure you have installed SRB2 properly.\n"));
#if 1 //#ifdef  _WIN32_WCE
		vid.width = BASEVIDWIDTH;
		vid.height = BASEVIDHEIGHT;
#else
		vid.width = 640; // hack to make voodoo cards work in 640x480
		vid.height = 480;
#endif
		if (HWD.pfnInit(I_Error)) // let load the OpenGL library
		{
			/*
			* We want at least 1 bit R, G, and B,
			* and at least 16 bpp. Why 1 bit? May be more?
			*/
			SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 1);
			SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 1);
			SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 1);
			SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
			if (!OglSdlSurface(vid.width, vid.height, (USE_FULLSCREEN)))
				if (!OglSdlSurface(vid.width, vid.height, !(USE_FULLSCREEN)))
					rendermode = render_soft;
		}
		else
			rendermode = render_soft;
	}
#else
	rendermode = render_soft; //force software mode when there no HWRENDER code
#endif
	if (render_soft == rendermode)
	{
#if defined(_WII)
		vid.width = 640;
		vid.height = 480;
#elif defined(_PS3)
		vid.width = 720;
		vid.height = 480;
#else
		vid.width = BASEVIDWIDTH;
		vid.height = BASEVIDHEIGHT;
#endif
		SDLSetMode(vid.width, vid.height, BitsPerPixel, surfaceFlagsW);
		if (!vidSurface)
		{
			CONS_Printf(M_GetText("Could not set vidmode: %s\n") ,SDL_GetError());
			vid.rowbytes = 0;
			graphics_started = true;
			return;
		}
		vid.rowbytes = vid.width * vid.bpp;
		vid.direct = SDLGetDirect();
		vid.buffer = malloc(vid.rowbytes*vid.height*NUMSCREENS);
		if (vid.buffer) memset(vid.buffer,0x00,vid.rowbytes*vid.height*NUMSCREENS);
		else CONS_Printf("%s", M_GetText("Not enough memory for video buffer\n"));
	}
	if (M_CheckParm("-nomousegrab"))
		mousegrabok = SDL_FALSE;
#ifdef _DEBUG
	else
	{
		char videodriver[4] = {'S','D','L',0};
		if (!M_CheckParm("-mousegrab") &&
		    SDL_VideoDriverName(videodriver,4) &&
		    strncasecmp("X11",videodriver,4) == 0)
			mousegrabok = SDL_FALSE; //X11's XGrabPointer not good
	}
#endif
	realwidth = (Uint16)vid.width;
	realheight = (Uint16)vid.height;

	VID_Command_Info_f();
	if (!disable_mouse) SDL_ShowCursor(SDL_DISABLE);
	SDLdoUngrabMouse();

	SDLWMSet();

	graphics_started = true;
}

void I_ShutdownGraphics(void)
{
	const rendermode_t oldrendermode = rendermode;

	rendermode = render_none;
	if (icoSurface) SDL_FreeSurface(icoSurface);
	icoSurface = NULL;
	if (render_soft == oldrendermode)
	{
		vidSurface = NULL; //Alam: SDL_Video system free vidSurface for me
		if (vid.buffer) free(vid.buffer);
		vid.buffer = NULL;
		if (bufSurface) SDL_FreeSurface(bufSurface);
		bufSurface = NULL;
#ifdef FILTERS
		if (preSurface) SDL_FreeSurface(preSurface);
		preSurface = NULL;
		if (f2xSurface) SDL_FreeSurface(f2xSurface);
		f2xSurface = NULL;
#endif
	}

	// was graphics initialized anyway?
	if (!graphics_started)
		return;
	CONS_Printf("I_ShutdownGraphics: ");
#ifdef _WIN32
	//ResetAero();
#endif
	graphics_started = false;
	CONS_Printf("%s", M_GetText("shut down\n"));
#ifdef HWRENDER
	if (GLUhandle)
		hwClose(GLUhandle);
#endif
#ifndef _arch_dreamcast
	SDL_QuitSubSystem(SDL_INIT_VIDEO);
#endif
	framebuffer = SDL_FALSE;
}
#endif