path: root/src/i_video.c

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: i_video.c 653 2006-09-22 20:32:00Z fraggle $
//
// Copyright(C) 1993-1996 Id Software, Inc.
// Copyright(C) 2005 Simon Howard
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
// $Log$
// Revision 1.43  2006/01/12 01:34:48  fraggle
// Combine mouse motion for tics into single events.
//
// Revision 1.42  2006/01/02 20:27:45  fraggle
// Clear the screen AFTER initialising the loading disk buffer, so that
// bits of loading disk are not visible on the initial screen melt.
//
// Revision 1.41  2006/01/02 00:06:30  fraggle
// Make functions static.  Remove unused variable.
//
// Revision 1.40  2005/10/17 19:46:22  fraggle
// Guard against multiple video shutdowns better.  Fix crash due to improper
// screen clear at startup.
//
// Revision 1.39  2005/10/16 20:55:50  fraggle
// Fix the '-cdrom' command-line option.
//
// Revision 1.38  2005/10/15 22:50:57  fraggle
// Fix pink icon on startup
//
// Revision 1.37  2005/10/15 15:59:14  fraggle
// Map mouse buttons correctly.
//
// Revision 1.36  2005/10/15 15:45:03  fraggle
// Check the return code from SDL_LockSurface to ensure a surface has been
// properly locked.  Fixes crash when switching applications while running
// fullscreen.
//
// Revision 1.35  2005/10/02 03:16:29  fraggle
// ENDOOM support using text mode emulation
//
// Revision 1.34  2005/10/02 03:03:40  fraggle
// Make sure loading disk is only shown if the display is initialised
//
// Revision 1.33  2005/09/27 22:33:42  fraggle
// Always use SDL_Flip to update the screen.  Fixes problems in Windows when
// running fullscreen, introduced by fixes to the disk icon code.
//
// Revision 1.32  2005/09/26 21:44:30  fraggle
// Fix melting crap on startup - oops
//
// Revision 1.31  2005/09/25 00:31:32  fraggle
// Fix disk icon appearing before palette is set (pink disk!)
// Cleanup and commenting
//
// Revision 1.30  2005/09/24 23:44:49  fraggle
// Enforce sane screenmultiply values
//
// Revision 1.29  2005/09/24 23:41:07  fraggle
// Fix "loading" icon for all video modes
//
// Revision 1.28  2005/09/24 22:04:03  fraggle
// Add application icon to running program
//
// Revision 1.27  2005/09/17 20:50:46  fraggle
// Mouse acceleration code to emulate old DOS drivers
//
// Revision 1.26  2005/09/14 21:55:47  fraggle
// Lock surfaces properly when we have to (fixes crash under Windows 98)
//
// Revision 1.25  2005/09/11 20:25:56  fraggle
// Second configuration file to allow chocolate doom-specific settings.
// Adjust some existing command line logic (for graphics settings and
// novert) to adjust for this.
//
// Revision 1.24  2005/09/08 22:05:17  fraggle
// Allow alt-tab away while running fullscreen
//
// Revision 1.23  2005/09/07 20:44:23  fraggle
// Fix up names of functions
// Make the quit button work (pops up the "quit doom?" prompt).
// Fix focus detection to release the mouse and ignore mouse events
// when window is not focused.
//
// Revision 1.22  2005/09/04 23:18:30  fraggle
// Remove dead code.  Cope with the screen not having width == pitch.  Lock
// the SDL screen surface properly. Rewrite 2x scaling code.
//
// Revision 1.21  2005/09/01 00:01:36  fraggle
// -nograbmouse option
//
// Revision 1.20  2005/08/31 23:58:28  fraggle
// smarter mouse grabbing for windowed mode
//
// Revision 1.19  2005/08/31 21:35:42  fraggle
// Display the game name in the title bar.  Move game start code to later
// in initialisation because of the IWAD detection changes.
//
// Revision 1.18  2005/08/10 08:45:35  fraggle
// Remove "if (french)" stuff, FRENCH define, detect french wad automatically
//
// Revision 1.17  2005/08/07 20:01:00  fraggle
// Clear the screen on startup
//
// Revision 1.16  2005/08/07 03:09:33  fraggle
// Fix gamma correction
//
// Revision 1.15  2005/08/07 02:59:23  fraggle
// Clear disk image when loading at startup
//
// Revision 1.14  2005/08/06 17:30:30  fraggle
// Only change palette on screen updates
//
// Revision 1.13  2005/08/04 22:23:07  fraggle
// Use zone memory function.  Add command line options
//
// Revision 1.12  2005/08/04 19:54:56  fraggle
// Use keysym value rather than unicode value (fixes problems with shift
// key)
//
// Revision 1.11  2005/08/04 18:42:15  fraggle
// Silence compiler warnings
//
// Revision 1.10  2005/08/04 01:13:46  fraggle
// Loading disk
//
// Revision 1.9  2005/08/03 22:19:52  fraggle
// Set some flags to fix palette and improve performance
//
// Revision 1.8  2005/08/03 21:58:02  fraggle
// Working scale*2
//
// Revision 1.7  2005/07/25 20:50:55  fraggle
// mouse
//
// Revision 1.6  2005/07/24 02:14:04  fraggle
// Move to SDL for graphics.
// Translate key scancodes to correct internal format when reading
// settings from config file - backwards compatible with config files
// for original exes
//
// Revision 1.5  2005/07/23 21:32:47  fraggle
// Add missing errno.h, fix crash on startup when no IWAD present
//
// Revision 1.4  2005/07/23 19:17:11  fraggle
// Use ANSI-standard limit constants.  Remove LINUX define.
//
// Revision 1.3  2005/07/23 17:27:04  fraggle
// Stop crash on shutdown
//
// Revision 1.2  2005/07/23 16:44:55  fraggle
// Update copyright to GNU GPL
//
// Revision 1.1.1.1  2005/07/23 16:19:58  fraggle
// Initial import
//
//
// DESCRIPTION:
//	DOOM graphics stuff for X11, UNIX.
//
//-----------------------------------------------------------------------------

static const char
rcsid[] = "$Id: i_video.c 653 2006-09-22 20:32:00Z fraggle $";

#include <SDL.h>
#include <ctype.h>
#include <math.h>

#include "chocolate_doom_icon.c"

#include "config.h"
#include "deh_main.h"
#include "doomdef.h"
#include "doomstat.h"
#include "d_main.h"
#include "i_system.h"
#include "i_timer.h"
#include "m_argv.h"
#include "m_swap.h"
#include "s_sound.h"
#include "sounds.h"
#include "v_video.h"
#include "w_wad.h"
#include "z_zone.h"

// Alternate screenheight for letterbox mode

#define LETTERBOX_SCREENHEIGHT 240

enum
{
    FULLSCREEN_OFF,
    FULLSCREEN_ON,
    FULLSCREEN_LETTERBOX,
};

extern void M_QuitDOOM();

static SDL_Surface *screen;

// palette
static SDL_Color palette[256];
static boolean palette_to_set;

static int windowwidth, windowheight;

// display has been set up?

static boolean initialised = false;

// disable mouse?

static boolean nomouse = false;
extern int usemouse;

// if true, screens[0] is screen->pixel

static boolean native_surface;

// Automatically adjust video settings if the selected mode is 
// not a valid video mode.

int autoadjust_video_settings = 1;

// Run in full screen mode?  (int type for config code)

int fullscreen = FULLSCREEN_ON;

// Time to wait for the screen to settle on startup before starting the
// game (ms)

int startup_delay = 0;

// Grab the mouse? (int type for config code)

int grabmouse = true;

// Flag indicating whether the screen is currently visible:
// when the screen isnt visible, don't render the screen

boolean screenvisible;

// Blocky mode,
// replace each 320x200 pixel with screenmultiply*screenmultiply pixels.
// According to Dave Taylor, it still is a bonehead thing
// to use ....

int screenmultiply = 1;

// disk image data and background overwritten by the disk to be
// restored by EndRead

static byte *disk_image = NULL;
static int disk_image_w, disk_image_h;
static byte *saved_background;
static boolean window_focused;

// Mouse acceleration
//
// This emulates some of the behavior of DOS mouse drivers by increasing
// the speed when the mouse is moved fast.
//
// The mouse input values are input directly to the game, but when
// the values exceed the value of mouse_threshold, they are multiplied
// by mouse_acceleration to increase the speed.

float mouse_acceleration = 2.0;
int mouse_threshold = 10;

static boolean MouseShouldBeGrabbed()
{
    // if the window doesnt have focus, never grab it

    if (!window_focused)
        return false;

    // always grab the mouse when full screen (dont want to 
    // see the mouse pointer)

    if (fullscreen != FULLSCREEN_OFF)
        return true;

    // if we specify not to grab the mouse, never grab
 
    if (!grabmouse)
        return false;

    // when menu is active or game is paused, release the mouse 
 
    if (menuactive || paused)
        return false;

    // only grab mouse when playing levels (but not demos)

    return (gamestate == GS_LEVEL) && !demoplayback;
}

// Update the value of window_focused when we get a focus event
//
// We try to make ourselves be well-behaved: the grab on the mouse
// is removed if we lose focus (such as a popup window appearing),
// and we dont move the mouse around if we aren't focused either.

static void UpdateFocus(void)
{
    Uint8 state;

    state = SDL_GetAppState();

    // We should have input (keyboard) focus and be visible 
    // (not minimised)

    window_focused = (state & SDL_APPINPUTFOCUS) && (state & SDL_APPACTIVE);

    // Should the screen be grabbed?

    screenvisible = (state & SDL_APPACTIVE) != 0;
}

static void LoadDiskImage(void)
{
    patch_t *disk;
    int y;

    if (M_CheckParm("-cdrom") > 0)
        disk = (patch_t *) W_CacheLumpName(DEH_String("STCDROM"), PU_STATIC);
    else
        disk = (patch_t *) W_CacheLumpName(DEH_String("STDISK"), PU_STATIC);

    V_DrawPatch(0, 0, 0, disk);
    disk_image_w = SHORT(disk->width);
    disk_image_h = SHORT(disk->height);

    disk_image = Z_Malloc(disk_image_w * disk_image_h, PU_STATIC, NULL);
    saved_background = Z_Malloc(disk_image_w * disk_image_h, PU_STATIC, NULL);

    for (y=0; y<disk_image_h; ++y) 
    {
        memcpy(disk_image + disk_image_w * y,
               screens[0] + SCREENWIDTH * y,
               disk_image_w);
        memset(screens[0] + SCREENWIDTH * y, 0, disk_image_w);
    }

    Z_Free(disk);
}

//
// Translates the SDL key
//

static int TranslateKey(SDL_keysym *sym)
{
    switch(sym->sym)
    {
      case SDLK_LEFT:	return KEY_LEFTARROW;
      case SDLK_RIGHT:	return KEY_RIGHTARROW;
      case SDLK_DOWN:	return KEY_DOWNARROW;
      case SDLK_UP:	return KEY_UPARROW;
      case SDLK_ESCAPE:	return KEY_ESCAPE;
      case SDLK_RETURN:	return KEY_ENTER;
      case SDLK_TAB:	return KEY_TAB;
      case SDLK_F1:	return KEY_F1;
      case SDLK_F2:	return KEY_F2;
      case SDLK_F3:	return KEY_F3;
      case SDLK_F4:	return KEY_F4;
      case SDLK_F5:	return KEY_F5;
      case SDLK_F6:	return KEY_F6;
      case SDLK_F7:	return KEY_F7;
      case SDLK_F8:	return KEY_F8;
      case SDLK_F9:	return KEY_F9;
      case SDLK_F10:	return KEY_F10;
      case SDLK_F11:	return KEY_F11;
      case SDLK_F12:	return KEY_F12;
	
      case SDLK_BACKSPACE: return KEY_BACKSPACE;
      case SDLK_DELETE:	return KEY_DEL;

      case SDLK_PAUSE:	return KEY_PAUSE;

      case SDLK_EQUALS:
      case SDLK_KP_EQUALS:	return KEY_EQUALS;

      case SDLK_MINUS:          return KEY_MINUS;

      case SDLK_LSHIFT:
      case SDLK_RSHIFT:
	return KEY_RSHIFT;
	
      case SDLK_LCTRL:
      case SDLK_RCTRL:
	return KEY_RCTRL;
	
      case SDLK_LALT:
      case SDLK_LMETA:
      case SDLK_RALT:
      case SDLK_RMETA:
        return KEY_RALT;

      case SDLK_CAPSLOCK: return KEY_CAPSLOCK;
      case SDLK_SCROLLOCK: return KEY_SCRLCK;

      case SDLK_KP0: return KEYP_0;
      case SDLK_KP1: return KEYP_1;
      case SDLK_KP2: return KEYP_2;
      case SDLK_KP3: return KEYP_3;
      case SDLK_KP4: return KEYP_4;
      case SDLK_KP5: return KEYP_5;
      case SDLK_KP6: return KEYP_6;
      case SDLK_KP7: return KEYP_7;
      case SDLK_KP8: return KEYP_8;
      case SDLK_KP9: return KEYP_9;

      case SDLK_HOME: return KEY_HOME;
      case SDLK_INSERT: return KEY_INS;
      case SDLK_END: return KEY_END;
      case SDLK_PAGEUP: return KEY_PGUP;
      case SDLK_PAGEDOWN: return KEY_PGDN;
      case SDLK_KP_MULTIPLY: return KEYP_MULTIPLY;
      case SDLK_KP_PLUS: return KEYP_PLUS;
      case SDLK_KP_MINUS: return KEYP_MINUS;
      case SDLK_KP_DIVIDE: return KEYP_DIVIDE;

      default:
        return tolower(sym->sym);
    }
}

void I_ShutdownGraphics(void)
{
    if (initialised)
    {
        SDL_ShowCursor(1);
        SDL_WM_GrabInput(SDL_GRAB_OFF);

        SDL_QuitSubSystem(SDL_INIT_VIDEO);
    
        initialised = false;
    }
}



//
// I_StartFrame
//
void I_StartFrame (void)
{
    // er?

}

static int MouseButtonState(void)
{
    Uint8 state = SDL_GetMouseState(NULL, NULL);
    int result = 0;

    // Note: button "0" is left, button "1" is right,
    // button "2" is middle for Doom.  This is different
    // to how SDL sees things.

    if (state & SDL_BUTTON(1))
        result |= 1;
    if (state & SDL_BUTTON(3))
        result |= 2;
    if (state & SDL_BUTTON(2))
        result |= 4;

    return result;
}

static int AccelerateMouse(int val)
{
    if (val < 0)
        return -AccelerateMouse(-val);

    if (val > mouse_threshold)
    {
        return (val - mouse_threshold) * mouse_acceleration + mouse_threshold;
    }
    else
    {
        return val;
    }
}

void I_GetEvent(void)
{
    SDL_Event sdlevent;
    event_t event;

    // possibly not needed
    
    SDL_PumpEvents();

    // put event-grabbing stuff in here
    
    while (SDL_PollEvent(&sdlevent))
    {
        // ignore mouse events when the window is not focused

        if (!window_focused 
         && (sdlevent.type == SDL_MOUSEMOTION
          || sdlevent.type == SDL_MOUSEBUTTONDOWN
          || sdlevent.type == SDL_MOUSEBUTTONUP))
        {
            continue;
        }

        // process event
        
        switch (sdlevent.type)
        {
            case SDL_KEYDOWN:
                event.type = ev_keydown;
                event.data1 = TranslateKey(&sdlevent.key.keysym);
		event.data2 = sdlevent.key.keysym.unicode;
                D_PostEvent(&event);
                break;
            case SDL_KEYUP:
                event.type = ev_keyup;
                event.data1 = TranslateKey(&sdlevent.key.keysym);
                D_PostEvent(&event);
                break;
                /*
            case SDL_MOUSEMOTION:
                event.type = ev_mouse;
                event.data1 = MouseButtonState();
                event.data2 = AccelerateMouse(sdlevent.motion.xrel);
                event.data3 = -AccelerateMouse(sdlevent.motion.yrel);
                D_PostEvent(&event);
                break;
                */
            case SDL_MOUSEBUTTONDOWN:
		if (usemouse && !nomouse)
		{
                    event.type = ev_mouse;
                    event.data1 = MouseButtonState();
                    event.data2 = event.data3 = 0;
                    D_PostEvent(&event);
		}
                break;
            case SDL_MOUSEBUTTONUP:
		if (usemouse && !nomouse)
		{
                    event.type = ev_mouse;
                    event.data1 = MouseButtonState();
                    event.data2 = event.data3 = 0;
                    D_PostEvent(&event);
		}
                break;
            case SDL_QUIT:
                // bring up the "quit doom?" prompt
                S_StartSound(NULL,sfx_swtchn);
                M_QuitDOOM(0);
                break;
            case SDL_ACTIVEEVENT:
                // need to update our focus state
                UpdateFocus();
                break;
            default:
                break;
        }
    }
}

//
// Read the change in mouse state to generate mouse motion events
//
// This is to combine all mouse movement for a tic into one mouse
// motion event.

static void I_ReadMouse(void)
{
    int x, y;
    event_t ev;

    SDL_GetRelativeMouseState(&x, &y);

    if (x != 0 || y != 0) 
    {
        ev.type = ev_mouse;
        ev.data1 = MouseButtonState();
        ev.data2 = AccelerateMouse(x);
        ev.data3 = -AccelerateMouse(y);
        
        D_PostEvent(&ev);
    }

    if (MouseShouldBeGrabbed())
    {
        SDL_WarpMouse(screen->w / 2, screen->h / 2);
        SDL_PumpEvents();
        SDL_GetRelativeMouseState(NULL, NULL);
    }
}

//
// I_StartTic
//
void I_StartTic (void)
{
    I_GetEvent();

    if (usemouse && !nomouse)
    {
        I_ReadMouse();
    }
}


//
// I_UpdateNoBlit
//
void I_UpdateNoBlit (void)
{
    // what is this?
}

static void UpdateGrab(void)
{
    static boolean currently_grabbed = false;
    boolean grab;

    grab = MouseShouldBeGrabbed();

    if (grab && !currently_grabbed)
    {
        SDL_ShowCursor(0);
        SDL_WM_GrabInput(SDL_GRAB_ON);
    }

    if (!grab && currently_grabbed)
    {
        SDL_ShowCursor(1);
        SDL_WM_GrabInput(SDL_GRAB_OFF);
    }

    currently_grabbed = grab;

}

// Update a small portion of the screen
//
// Does 2x stretching and buffer blitting if neccessary

static void BlitArea(int x1, int y1, int x2, int y2)
{
    int w = x2 - x1;
    int y_offset;

    // Y offset when running in letterbox mode

    if (fullscreen == FULLSCREEN_LETTERBOX)
    {
        y_offset = (LETTERBOX_SCREENHEIGHT - SCREENHEIGHT) / 2;
    }
    else
    {
        y_offset = 0;
    }
    
    // Need to byte-copy from buffer into the screen buffer

    if (screenmultiply == 1 && !native_surface)
    {
        byte *bufp, *screenp;
        int y;
        int pitch;

        if (SDL_LockSurface(screen) >= 0)
        {
            pitch = screen->pitch;
            bufp = screens[0] + y1 * SCREENWIDTH + x1;
            screenp = (byte *) screen->pixels + (y1 + y_offset) * pitch + x1;
    
            for (y=y1; y<y2; ++y)
            {
                memcpy(screenp, bufp, w);
                screenp += pitch;
                bufp += SCREENWIDTH;
            }
    
            SDL_UnlockSurface(screen);
        }
    }

    // scales the screen size before blitting it

    if (screenmultiply == 2)
    {
        byte *bufp, *screenp, *screenp2;
        int x, y;
        int pitch;

        if (SDL_LockSurface(screen) >= 0)
        {
            pitch = screen->pitch * 2;
            bufp = screens[0] + y1 * SCREENWIDTH + x1;
            screenp = (byte *) screen->pixels 
                    + (y1 + y_offset) * pitch 
                    + x1 * 2;
            screenp2 = screenp + screen->pitch;
    
            for (y=y1; y<y2; ++y)
            {
                byte *sp, *sp2, *bp;
                sp = screenp;
                sp2 = screenp2;
                bp = bufp;
    
                for (x=x1; x<x2; ++x)
                {
                    *sp++ = *bp;  *sp++ = *bp;
                    *sp2++ = *bp; *sp2++ = *bp;
                    ++bp;
                }
                screenp += pitch;
                screenp2 += pitch;
                bufp += SCREENWIDTH;
            }
    
            SDL_UnlockSurface(screen);
        }
    }

    if (screenmultiply == 3)
    {
        byte *bufp, *screenp, *screenp2, *screenp3;
        int x, y;
        int pitch;

        if (SDL_LockSurface(screen) >= 0)
        {
            pitch = screen->pitch * 3;
            bufp = screens[0] + y1 * SCREENWIDTH + x1;
            screenp = (byte *) screen->pixels 
                    + (y1 + y_offset) * pitch 
                    + x1 * 3;
            screenp2 = screenp + screen->pitch;
            screenp3 = screenp2 + screen->pitch;
    
            for (y=y1; y<y2; ++y)
            {
                byte *sp, *sp2, *sp3, *bp;
                sp = screenp;
                sp2 = screenp2;
                sp3 = screenp3;
                bp = bufp;
    
                for (x=x1; x<x2; ++x)
                {
                    *sp++ = *bp;  *sp++ = *bp;  *sp++ = *bp;
                    *sp2++ = *bp; *sp2++ = *bp; *sp2++ = *bp;
                    *sp3++ = *bp; *sp3++ = *bp; *sp3++ = *bp;
                    ++bp;
                }
                screenp += pitch;
                screenp2 += pitch;
                screenp3 += pitch;
                bufp += SCREENWIDTH;
            }
    
            SDL_UnlockSurface(screen);
        }
    }

    if (screenmultiply == 4)
    {
        byte *bufp, *screenp, *screenp2, *screenp3, *screenp4;
        int x, y;
        int pitch;

        if (SDL_LockSurface(screen) >= 0)
        {
            pitch = screen->pitch * 4;
            bufp = screens[0] + y1 * SCREENWIDTH + x1;
            screenp = (byte *) screen->pixels 
                    + (y1 + y_offset) * pitch 
                    + x1 * 4;
            screenp2 = screenp + screen->pitch;
            screenp3 = screenp2 + screen->pitch;
            screenp4 = screenp3 + screen->pitch;
    
            for (y=y1; y<y2; ++y)
            {
                byte *sp, *sp2, *sp3, *sp4, *bp;
                sp = screenp;
                sp2 = screenp2;
                sp3 = screenp3;
                sp4 = screenp4;
                bp = bufp;
    
                for (x=x1; x<x2; ++x)
                {
                    *sp++ = *bp;  *sp++ = *bp;  *sp++ = *bp;  *sp++ = *bp;
                    *sp2++ = *bp; *sp2++ = *bp; *sp2++ = *bp; *sp2++ = *bp;
                    *sp3++ = *bp; *sp3++ = *bp; *sp3++ = *bp; *sp3++ = *bp;
                    *sp4++ = *bp; *sp4++ = *bp; *sp4++ = *bp; *sp4++ = *bp;
                    ++bp;
                }
                screenp += pitch;
                screenp2 += pitch;
                screenp3 += pitch;
                screenp4 += pitch;
                bufp += SCREENWIDTH;
            }
    
            SDL_UnlockSurface(screen);
        }
    }
}

static void UpdateRect(int x1, int y1, int x2, int y2)
{
    // Do stretching and blitting

    BlitArea(x1, y1, x2, y2);

    // Update the area

    SDL_UpdateRect(screen, 
                   x1 * screenmultiply, 
                   y1 * screenmultiply, 
                   (x2-x1) * screenmultiply, 
                   (y2-y1) * screenmultiply);
}

void I_BeginRead(void)
{
    int y;

    if (!initialised || disk_image == NULL)
        return;

    // save background and copy the disk image in

    for (y=0; y<disk_image_h; ++y)
    {
        byte *screenloc = 
               screens[0] 
                 + (SCREENHEIGHT - 1 - disk_image_h + y) * SCREENWIDTH
                 + (SCREENWIDTH - 1 - disk_image_w);

        memcpy(saved_background + y * disk_image_w,
               screenloc,
               disk_image_w);
        memcpy(screenloc, disk_image + y * disk_image_w, disk_image_w);
    }

    UpdateRect(SCREENWIDTH - disk_image_w, SCREENHEIGHT - disk_image_h,
               SCREENWIDTH, SCREENHEIGHT);
}

void I_EndRead(void)
{
    int y;

    if (!initialised || disk_image == NULL)
        return;

    // save background and copy the disk image in

    for (y=0; y<disk_image_h; ++y)
    {
        byte *screenloc = 
               screens[0] 
                 + (SCREENHEIGHT - 1 - disk_image_h + y) * SCREENWIDTH
                 + (SCREENWIDTH - 1 - disk_image_w);

        memcpy(screenloc, saved_background + y * disk_image_w, disk_image_w);
    }

    UpdateRect(SCREENWIDTH - disk_image_w, SCREENHEIGHT - disk_image_h,
               SCREENWIDTH, SCREENHEIGHT);
}

//
// I_FinishUpdate
//
void I_FinishUpdate (void)
{
    static int	lasttic;
    int		tics;
    int		i;
    // UNUSED static unsigned char *bigscreen=0;

    if (!initialised)
        return;

    if (noblit)
        return;
    
    UpdateGrab();

    // Don't update the screen if the window isn't visible.
    // Not doing this breaks under Windows when we alt-tab away 
    // while fullscreen.

    if (!(SDL_GetAppState() & SDL_APPACTIVE))
        return;

    // draws little dots on the bottom of the screen
    if (devparm)
    {

	i = I_GetTime();
	tics = i - lasttic;
	lasttic = i;
	if (tics > 20) tics = 20;

	for (i=0 ; i<tics*2 ; i+=4)
	    screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
	for ( ; i<20*4 ; i+=4)
	    screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
    
    }

    // draw to screen

    BlitArea(0, 0, SCREENWIDTH, SCREENHEIGHT);
    
    // If we have a palette to set, the act of setting the palette
    // updates the screen

    if (palette_to_set)
    {
        SDL_SetColors(screen, palette, 0, 256);
        palette_to_set = 0;
    }
    else
    {
        SDL_Flip(screen);
    }
}


//
// I_ReadScreen
//
void I_ReadScreen (byte* scr)
{
    memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
}


//
// I_SetPalette
//
void I_SetPalette (byte *doompalette)
{
    int i;

    for (i=0; i<256; ++i) 
    {
        palette[i].r = gammatable[usegamma][*doompalette++];
        palette[i].g = gammatable[usegamma][*doompalette++];
        palette[i].b = gammatable[usegamma][*doompalette++];
    }

    palette_to_set = 1;
}

// 
// Set the window caption
//

void I_SetWindowCaption(void)
{
    char *buf;

    buf = Z_Malloc(strlen(gamedescription) + strlen(PACKAGE_STRING) + 10, 
                   PU_STATIC, NULL);
    sprintf(buf, "%s - %s", gamedescription, PACKAGE_STRING);

    SDL_WM_SetCaption(buf, NULL);

    Z_Free(buf);
}

// Set the application icon

void I_SetWindowIcon(void)
{
    SDL_Surface *surface;

    surface = SDL_CreateRGBSurfaceFrom(chocolate_doom_data,
                                       chocolate_doom_w,
                                       chocolate_doom_h,
                                       24,
                                       chocolate_doom_w * 3,
                                       0xff << 0,
                                       0xff << 8,
                                       0xff << 16,
                                       0);

    SDL_WM_SetIcon(surface, NULL);
    SDL_FreeSurface(surface);
}

// Get window dimensions for the current settings

static void GetWindowDimensions(int *windowwidth, int *windowheight)
{
    *windowwidth = SCREENWIDTH * screenmultiply;

    if (fullscreen == FULLSCREEN_LETTERBOX)
        *windowheight = LETTERBOX_SCREENHEIGHT * screenmultiply;
    else
        *windowheight = SCREENHEIGHT * screenmultiply;
}

// Check if the screen mode for the current settings is in the list available
// Not all machines support running in 320x200/640x400 (only support 4:3)
// Some don't even support modes below 640x480.

static boolean CheckValidFSMode(void)
{
    SDL_Rect **modes;
    int i;
    int w, h;

    GetWindowDimensions(&w, &h);

    modes = SDL_ListModes(NULL, SDL_FULLSCREEN);

    for (i=0; modes[i]; ++i)
    {
        if (w == modes[i]->w && h == modes[i]->h)
            return true;
    }

    // not found

    return false;
}

void I_InitGraphics(void)
{
    SDL_Event dummy;
    int flags = 0;

    SDL_Init(SDL_INIT_VIDEO);

    flags |= SDL_SWSURFACE | SDL_HWPALETTE | SDL_DOUBLEBUF;

    // mouse grabbing

    if (M_CheckParm("-grabmouse"))
    {
        grabmouse = true;
    }
    else if (M_CheckParm("-nograbmouse"))
    {
        grabmouse = false;
    }

    // default to fullscreen mode, allow override with command line
    // nofullscreen because we love prboom

    if (M_CheckParm("-window") || M_CheckParm("-nofullscreen"))
    {
        fullscreen = FULLSCREEN_OFF;
    }
    else if (M_CheckParm("-fullscreen"))
    {
        fullscreen = FULLSCREEN_ON;
    }

    if (fullscreen != FULLSCREEN_OFF)
    {
        flags |= SDL_FULLSCREEN;
    }

    nomouse = M_CheckParm("-nomouse") > 0;

    // scale-by-2 mode
 
    if (M_CheckParm("-1"))
    {
        screenmultiply = 1;
    }
    else if (M_CheckParm("-2"))
    {
        screenmultiply = 2;
    }
    else if (M_CheckParm("-3"))
    {
        screenmultiply = 3;
    }
    else if (M_CheckParm("-4"))
    {
        screenmultiply = 4;
    }

    if (screenmultiply < 1)
        screenmultiply = 1;
    if (screenmultiply > 4)
        screenmultiply = 4;

    if (fullscreen && autoadjust_video_settings)
    {
        int oldw, oldh;
        int old_fullscreen, old_screenmultiply;

        GetWindowDimensions(&oldw, &oldh);
        old_screenmultiply = screenmultiply;
        old_fullscreen = fullscreen;

        if (!CheckValidFSMode() && screenmultiply == 1 
         && fullscreen == FULLSCREEN_ON)
        {
            // 320x200 is not valid.

            // Try turning on letterbox mode - avoid doubling up
            // the screen if possible

            fullscreen = FULLSCREEN_LETTERBOX;

            if (!CheckValidFSMode())
            {
                // That doesn't work. Change it back.

                fullscreen = FULLSCREEN_ON;
            }
        }

        if (!CheckValidFSMode() && screenmultiply == 1)
        {
            // Try doubling up the screen to 640x400

            screenmultiply = 2;
        }

        if (!CheckValidFSMode() && fullscreen == FULLSCREEN_ON)
        {
            // This is not a valid mode.  Try turning on letterbox mode

            fullscreen = FULLSCREEN_LETTERBOX;
        }

        if (old_fullscreen != fullscreen 
         || old_screenmultiply != screenmultiply)
        {
            printf("I_InitGraphics: %ix%i resolution is not supported "
                   "on this machine. \n", oldw, oldh);
            printf("I_InitGraphics: Video settings adjusted to "
                   "compensate:\n");
            
            if (fullscreen != old_fullscreen)
                printf("\tletterbox mode on (fullscreen=2)\n");
            if (screenmultiply != old_screenmultiply)
                printf("\tscreenmultiply=%i\n", screenmultiply);
            
            printf("NOTE: Your video settings have been adjusted.  "
                   "To disable this behavior,\n"
                   "set autoadjust_video_settings to 0 in your "
                   "configuration file.\n");
        }
        
        if (!CheckValidFSMode())
        {
            printf("I_InitGraphics: WARNING: Unable to find a valid "
                   "fullscreen video mode to run in.\n");
        }
    }

    GetWindowDimensions(&windowwidth, &windowheight);

    screen = SDL_SetVideoMode(windowwidth, windowheight, 8, flags);

    if (screen == NULL)
    {
        I_Error("Error setting video mode: %s\n", SDL_GetError());
    }

    // Start with a clear black screen
    // (screen will be flipped after we set the palette)

    if (SDL_LockSurface(screen) >= 0)
    {
        byte *screenpixels;
        int y;

        screenpixels = (byte *) screen->pixels;

        for (y=0; y<screen->h; ++y)
            memset(screenpixels + screen->pitch * y, 0, screen->w);

        SDL_UnlockSurface(screen);
    }
    
    // Set the palette

    I_SetPalette (W_CacheLumpName (DEH_String("PLAYPAL"),PU_CACHE));
    SDL_SetColors(screen, palette, 0, 256);

    // Setup title and icon

    I_SetWindowCaption();
    I_SetWindowIcon();

    UpdateFocus();
    UpdateGrab();

    // On some systems, it takes a second or so for the screen to settle
    // after changing modes.  We include the option to add a delay when
    // setting the screen mode, so that the game doesn't start immediately
    // with the player unable to see anything.

    if (fullscreen)
    {
        SDL_Delay(startup_delay);
    }

    // Check if we have a native surface we can use
    // If we have to lock the screen, draw to a buffer and copy
    // Likewise if the screen pitch is not the same as the width
    // If we have to multiply, drawing is done to a separate 320x200 buf

    native_surface = !SDL_MUSTLOCK(screen) 
                  && screenmultiply == 1 
                  && screen->pitch == SCREENWIDTH;

    // If not, allocate a buffer and copy from that buffer to the 
    // screen when we do an update

    if (native_surface)
    {
	screens[0] = (unsigned char *) (screen->pixels);

        if (fullscreen == FULLSCREEN_LETTERBOX)
        {
            screens[0] += ((LETTERBOX_SCREENHEIGHT - SCREENHEIGHT) * screen->pitch) / 2;
        }
    }
    else
    {
	screens[0] = (unsigned char *) Z_Malloc (SCREENWIDTH * SCREENHEIGHT, PU_STATIC, NULL);
    }

    // Loading from disk icon

    LoadDiskImage();

    memset(screens[0], 0, SCREENWIDTH * SCREENHEIGHT);

    // We need SDL to give us translated versions of keys as well

    SDL_EnableUNICODE(1);

    // Repeat key presses - this is what Vanilla Doom does
    // Not sure about repeat rate - probably dependent on which DOS
    // driver is used.  This is good enough though.

    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);

    // clear out any events waiting at the start
  
    while (SDL_PollEvent(&dummy));

    initialised = true;
}