shithub: duke3d

ref: 08e6666c5a1665c22175da3609b209c1bff1671e
dir: /Engine/src/display.c/

View raw version
/*
 * An SDL replacement for BUILD's VESA code.
 *
 *  Written by Ryan C. Gordon. (icculus@clutteredmind.org)
 *
 * Please do NOT harrass Ken Silverman about any code modifications
 *  (including this file) to BUILD.
 */

/*
 * "Build Engine & Tools" Copyright (c) 1993-1997 Ken Silverman
 * Ken Silverman's official web site: "http://www.advsys.net/ken"
 * See the included license file "BUILDLIC.TXT" for license info.
 * This file IS NOT A PART OF Ken Silverman's original release
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#define BUILD_NOMOUSEGRAB    "BUILD_NOMOUSEGRAB"
#define BUILD_WINDOWED       "BUILD_WINDOWED"
#define BUILD_SDLDEBUG       "BUILD_SDLDEBUG"
#define BUILD_RENDERER       "BUILD_RENDERER"
#define BUILD_GLLIBRARY      "BUILD_GLLIBRARY"
#define BUILD_USERSCREENRES  "BUILD_USERSCREENRES"
#define BUILD_MAXSCREENRES   "BUILD_MAXSCREENRES"
#define BUILD_HALLOFMIRRORS  "BUILD_HALLOFMIRRORS"
#define BUILD_GLDUMP         "BUILD_GLDUMP"
#define BUILD_SDLJOYSTICK    "BUILD_SDLJOYSTICK"

#include "build.h"
#include "display.h"
#include "fixedPoint_math.h"
#include "engine.h"
#include "sdl_util.h"
#include "icon.h"
#include "draw.h"
#include "cache.h"


/*
 * !!! remove the surface_end checks, for speed's sake. They are a
 * !!!  needed safety right now. --ryan.
 */


#define DEFAULT_MAXRESWIDTH  MAXXDIM
#define DEFAULT_MAXRESHEIGHT MAXYDIM


#define UNLOCK_SURFACE_AND_RETURN  if (SDL_MUSTLOCK(surface)) SDL_UnlockSurface(surface); return;


	/* !!! move these elsewhere? */
int32_t xres, yres, dukebytesperline, imageSize, maxpages;
uint8_t* frameplace;

//The frambuffer address
uint8_t* frameoffset;
uint8_t  *screen, vesachecked;
int32_t buffermode, origbuffermode, linearmode;
uint8_t  permanentupdate = 0, vgacompatible;

static SDL_Window* window = NULL;
static SDL_Renderer* renderer = NULL;
static SDL_Texture* texture = NULL;
static SDL_Surface* surface = NULL;
static SDL_Surface* surface_rgba = NULL;

static int32_t mouse_relative_x = 0;
static int32_t mouse_relative_y = 0;
static short mouse_buttons = 0;
static unsigned int lastkey = 0;
/* so we can make use of setcolor16()... - DDOI */
static uint8_t  drawpixel_color=0;

static uint32_t scancodes[SDL_NUM_SCANCODES];

static int32_t last_render_ticks = 0;
int32_t total_render_time = 1;
int32_t total_rendered_frames = 0;

static char *titleName = NULL;

#define print_tf_state(str, val) printf("%s: {%s}\n", str, (val) ? "true" : "false" )

void* get_framebuffer(void)
{
	return surface->pixels;
}

/*
 * !!! This is almost an entire copy of the original setgamemode().
 * !!!  Figure out what is needed for just 2D mode, and separate that
 * !!!  out. Then, place the original setgamemode() back into engine.c,
 * !!!  and remove our simple implementation (and this function.)
 * !!!  Just be sure to keep the non-DOS things, like the window's
 * !!!  titlebar caption.   --ryan.
 */
static uint8_t  screenalloctype = 255;
static void init_new_res_vars(void)
{
	int i = 0;
	int j = 0;

	setupmouse();

	xdim = xres = surface->w;
	ydim = yres = surface->h;

	printf("init_new_res_vars %d %d\n", xdim, ydim);

	numpages = 1; // we always expose the same surface to the drawing engine.
	dukebytesperline = surface->w;
	vesachecked = 1;
	vgacompatible = 1;
	linearmode = 1;
	qsetmode = surface->h;
	activepage = visualpage = 0;


	frameoffset = frameplace = (uint8_t*)surface->pixels;

	if (screen != NULL)
	{
		if (screenalloctype == 0) free((void*)screen);
		if (screenalloctype == 1) suckcache((int32_t*)screen);
		screen = NULL;
	} /* if */


	switch (vidoption)
	{
	case 1:i = xdim * ydim; break;
	case 2: xdim = 320; ydim = 200; i = xdim * ydim; break;
	default: assert(0);
	}
	j = ydim * 4 * sizeof(int32_t);  /* Leave room for horizlookup&horizlookup2 */

	if (horizlookup)
		free(horizlookup);

	if (horizlookup2)
		free(horizlookup2);

	horizlookup = (int32_t*)malloc(j);
	horizlookup2 = (int32_t*)malloc(j);

	j = 0;

	//Build lookup table (X screespace -> frambuffer offset.
	for (i = 0; i <= ydim; i++)
	{
		ylookup[i] = j;
		j += dukebytesperline;
	}

	horizycent = ((ydim * 4) >> 1);

	/* Force drawrooms to call dosetaspect & recalculate stuff */
	oxyaspect = oxdimen = oviewingrange = -1;

	//Let the Assembly module how many pixels to skip when drawing a column
	setBytesPerLine(dukebytesperline);


	setview(0L, 0L, xdim - 1, ydim - 1);

	setbrightness(curbrightness, palette);

	if (searchx < 0) {
		searchx = halfxdimen;
		searchy = (ydimen >> 1);
	}
}

static void go_to_new_vid_mode(int w, int h)
{
	if (window != NULL)
	{
		SDL_FreeSurface(surface_rgba);
		SDL_FreeSurface(surface);
		SDL_DestroyTexture(texture);
		SDL_DestroyRenderer(renderer);
		SDL_DestroyWindow(window);
		SDL_QuitSubSystem(SDL_INIT_VIDEO);
		window = NULL;
	}

	SDL_CHECK_SUCCESS( SDL_InitSubSystem(SDL_INIT_VIDEO) );

	window = SDL_CreateWindow(
		titleName,
		SDL_WINDOWPOS_CENTERED,
		SDL_WINDOWPOS_CENTERED,
		w, h,
		(FullScreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0) | SDL_WINDOW_ALLOW_HIGHDPI);

	SDL_CHECK_NOT_NULL(window, "create window");

	// don't override higher-res app icon on OS X or Windows
        // plan9 has no window icons
#if !PLATFORM_MACOSX && !WIN32 && !defined(__plan9__)
	SDL_Surface* image = SDL_LoadBMP_RW(SDL_RWFromMem(iconBMP, sizeof(iconBMP)), 1);
	Uint32 colorkey = 0; // index in this image to be transparent
	SDL_SetColorKey(image, SDL_TRUE, colorkey);
	SDL_SetWindowIcon(window, image);
	SDL_FreeSurface(image);
#endif
	
	getvalidvesamodes();
	SDL_ClearError();

	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
	SDL_CHECK_NOT_NULL(renderer, "create renderer");

#ifndef __plan9__
	SDL_RendererInfo rendererInfo;
	SDL_CHECK_SUCCESS(SDL_GetRendererInfo(renderer, &rendererInfo));
	printf("SDL Renderer: '%s'.\n", rendererInfo.name);
#endif

	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "nearest");
	//SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");
	
	SDL_CHECK_SUCCESS(SDL_RenderSetLogicalSize(renderer, w, h));

	texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, w, h);
	SDL_CHECK_NOT_NULL(texture, "create texture");
	
	surface = SDL_CreateRGBSurface(0, w, h, 8, 0, 0, 0, 0);
	SDL_CHECK_NOT_NULL(surface, "create palettized surface");

	const Uint32 rmask = 0x00ff0000;
	const Uint32 gmask = 0x0000ff00;
	const Uint32 bmask = 0x000000ff;
	const Uint32 amask = 0xff000000;

	surface_rgba = SDL_CreateRGBSurface(0, w, h, 32, rmask, gmask, bmask, amask);
	SDL_CHECK_NOT_NULL(surface_rgba, "create RGBA surface");

	init_new_res_vars();
}

static void present_framebuffer(void)
{
	SDL_CHECK_SUCCESS(SDL_BlitSurface(surface, NULL, surface_rgba, NULL));
	SDL_CHECK_SUCCESS(SDL_UpdateTexture(texture, NULL, surface_rgba->pixels, surface_rgba->pitch));
	SDL_CHECK_SUCCESS(SDL_RenderClear(renderer));
	SDL_CHECK_SUCCESS(SDL_RenderCopy(renderer, texture, NULL, NULL));
	SDL_RenderPresent(renderer);
}

static int sdl_mouse_button_filter(SDL_MouseButtonEvent *event)
{
		/*
		 * What bits BUILD expects:
		 *  0 left button pressed if 1
		 *  1 right button pressed if 1
		 *  2 middle button pressed if 1
		 *
		 *   (That is, this is what Int 33h (AX=0x05) returns...)
		 *
		 *  additionally bits 3&4 are set for the mouse wheel
		 */
	Uint8 button = event->button;
	if (button >= sizeof (mouse_buttons) * 8)
		return(0);

	if (button == SDL_BUTTON_RIGHT)
		button = SDL_BUTTON_MIDDLE;
	else if (button == SDL_BUTTON_MIDDLE)
		button = SDL_BUTTON_RIGHT;

	if (((const SDL_MouseButtonEvent*)event)->state)
		mouse_buttons |= 1<<(button-1);
	else if (button != 4 && button != 5)
		mouse_buttons ^= 1<<(button-1);
#if 0
	Uint8 bmask = SDL_GetMouseState(NULL, NULL);
	mouse_buttons = 0;
	if (bmask & SDL_BUTTON_LMASK) mouse_buttons |= 1;
	if (bmask & SDL_BUTTON_RMASK) mouse_buttons |= 2;
	if (bmask & SDL_BUTTON_MMASK) mouse_buttons |= 4;
#endif

	return(0);
} /* sdl_mouse_up_filter */


static int sdl_mouse_motion_filter(SDL_Event const *event)
{
	if (surface == NULL)
		return(0);

	if (event->type == SDL_JOYBALLMOTION)
	{
		mouse_relative_x = event->jball.xrel/100;
		mouse_relative_y = event->jball.yrel/100;
	}
	else
	{
		if (SDL_GetRelativeMouseMode() == SDL_TRUE)
		{
			mouse_relative_x += event->motion.xrel;
			mouse_relative_y += event->motion.yrel;
			//printf("sdl_mouse_motion_filter: mrx=%d, mry=%d, mx=%d, my=%d\n",
			//	mouse_relative_x, mouse_relative_y, event->motion.xrel, event->motion.yrel);

			// mouse_relative_* is already reset in
			// readmousexy(). It must not be
			// reset here because calling this function does not mean
			// we always handle the mouse.
			// FIX_00001: Mouse speed is uneven and slower in windowed mode vs fullscreen mode.
		}
		else
			mouse_relative_x = mouse_relative_y = 0;
	}

	return(0);
} /* sdl_mouse_motion_filter */


	/*
	 * The windib driver can't alert us to the keypad enter key, which
	 *  Ken's code depends on heavily. It sends it as the same key as the
	 *  regular return key. These users will have to hit SHIFT-ENTER,
	 *  which we check for explicitly, and give the engine a keypad enter
	 *  enter event.
	 */
static int handle_keypad_enter_hack(const SDL_Event *event)
{
	static int kp_enter_hack = 0;
	int retval = 0;

	if (event->key.keysym.sym == SDLK_RETURN)
	{
		if (event->key.state == SDL_PRESSED)
		{
			if (event->key.keysym.mod & KMOD_SHIFT)
			{
				kp_enter_hack = 1;
				lastkey = SDL_SCANCODE_KP_ENTER;
				retval = 1;
			} /* if */
		} /* if */

		else  /* key released */
		{
			if (kp_enter_hack)
			{
				kp_enter_hack = 0;
				lastkey = SDL_SCANCODE_KP_ENTER;
				retval = 1;
			} /* if */
		} /* if */
	} /* if */

	return(retval);
} /* handle_keypad_enter_hack */

void fullscreen_toggle_and_change_driver(void)
{
	
//  FIX_00002: New Toggle Windowed/FullScreen system now simpler and will 
//  dynamically change for Windib or Directx driver. Windowed/Fullscreen 
//  toggle also made available from menu.
//  Replace attempt_fullscreen_toggle(SDL_Surface **surface, Uint32 *flags)

	int32_t x,y;
	x = surface->w;
	y = surface->h;

	FullScreen =!FullScreen;
	_platform_init(0, NULL, "Duke Nukem 3D", "Duke3D");
	_setgamemode(x,y);
	//vscrn();

	return;
}

static int sdl_key_filter(const SDL_Event *event)
{
	int extended;

	if ( (event->key.keysym.sym == SDLK_m) &&
		 (event->key.state == SDL_PRESSED) &&
		 (event->key.keysym.mod & KMOD_CTRL) )
	{
		// FIX_00005: Mouse pointer can be toggled on/off (see mouse menu or use CTRL-M)
		// This is usefull to move the duke window when playing in window mode.
  
		if (SDL_GetRelativeMouseMode() == SDL_TRUE)
		{
			SDL_CHECK_SUCCESS( SDL_SetRelativeMouseMode(SDL_FALSE) );
		}
		else
		{
			SDL_CHECK_SUCCESS( SDL_SetRelativeMouseMode(SDL_TRUE) );
		}

		return(0);
	}

	if (((event->key.keysym.sym == SDLK_RETURN) ||
		(event->key.keysym.sym == SDLK_KP_ENTER)) &&
		(event->key.state == SDL_PRESSED) &&
		(event->key.keysym.mod & KMOD_ALT))
	{
		fullscreen_toggle_and_change_driver();

		// hack to discard the ALT key...
		lastkey = scancodes[SDL_SCANCODE_RALT] >> 8; // extended
		keyhandler();
		lastkey = (scancodes[SDL_SCANCODE_RALT] & 0xff) + 0x80; // Simulating Key up
		keyhandler();
		lastkey = (scancodes[SDL_SCANCODE_LALT] & 0xff) + 0x80; // Simulating Key up (not extended)
		keyhandler();
		SDL_SetModState(KMOD_NONE); // SDL doesnt see we are releasing the ALT-ENTER keys

		return(0);
	}

	if (!handle_keypad_enter_hack(event))
		lastkey = scancodes[event->key.keysym.scancode];

//	printf("key.keysym.sym=%d\n", event->key.keysym.sym);

	if (lastkey == 0x0000)   /* No DOS equivalent defined. */
		return(0);

	extended = ((lastkey & 0xFF00) >> 8);
	if (extended != 0)
	{
		lastkey = extended;
		keyhandler();
		lastkey = (scancodes[event->key.keysym.scancode] & 0xFF);
	} /* if */

	if (event->key.state == SDL_RELEASED)
		lastkey += 128;  /* +128 signifies that the key is released in DOS. */

	keyhandler();
	return(0);
} /* sdl_key_filter */


static int root_sdl_event_filter(const SDL_Event *event)
{
	switch (event->type)
	{
		case SDL_KEYUP:
			// FIX_00003: Pause mode is now fully responsive - (Thx to Jonathon Fowler tips)
			if(event->key.keysym.sym == SDLK_PAUSE)
				break;
		case SDL_KEYDOWN:
			return(sdl_key_filter(event));
		case SDL_JOYBUTTONDOWN:
		case SDL_JOYBUTTONUP:
			{
				//Do Nothing

				//printf("Joybutton UP/DOWN\n");
				//return(sdl_joystick_button_filter((const SDL_MouseButtonEvent*)event));
				return 0;
			}
		case SDL_JOYBALLMOTION:
		case SDL_MOUSEMOTION:
			return(sdl_mouse_motion_filter(event));
		case SDL_MOUSEBUTTONUP:
		case SDL_MOUSEBUTTONDOWN:
			return(sdl_mouse_button_filter((const SDL_MouseButtonEvent*)event));
		case SDL_QUIT:
			/* !!! rcg TEMP */
			Error(EXIT_SUCCESS, "Exit through SDL\n");
		default:
			//printf("This event is not handled: %d\n",event->type);
			break;
	} /* switch */

	return(1);
} /* root_sdl_event_filter */


static void handle_events(void)
{
	SDL_Event event;

	while(SDL_PollEvent(&event))
		root_sdl_event_filter(&event);
} /* handle_events */


/* bleh...public version... */
void _handle_events(void)
{
	handle_events();
} /* _handle_events */


static SDL_Joystick *joystick = NULL;
void _joystick_init(void)
{
	const char  *envr = getenv(BUILD_SDLJOYSTICK);
	int favored = 0;
	int numsticks;
	int i;

	if (joystick != NULL)
	{
		printf("Joystick appears to be already initialized.\n");
		printf("...deinitializing for stick redetection...\n");
		_joystick_deinit();
	} /* if */

	if ((envr != NULL) && (strcmp(envr, "none") == 0))
	{
		printf("Skipping joystick detection/initialization at user request\n");
		return;
	} /* if */

	printf("Initializing SDL joystick subsystem...");
	printf(" (export environment variable BUILD_SDLJOYSTICK=none to skip)\n");

	if (SDL_Init(SDL_INIT_JOYSTICK|SDL_INIT_NOPARACHUTE) != 0)
	{
		printf("SDL_Init(SDL_INIT_JOYSTICK) failed: [%s].\n", SDL_GetError());
		return;
	} /* if */

	numsticks = SDL_NumJoysticks();
	printf("SDL sees %d joystick%s.\n", numsticks, numsticks == 1 ? "" : "s");
	if (numsticks == 0)
		return;

	for (i = 0; i < numsticks; i++)
	{
		joystick = SDL_JoystickOpen(i);
		if (joystick == NULL)
		{
			printf("Joystick #%d failed to init: %s\n", i, SDL_GetError());
			return;
		}

		const char  *stickname = SDL_JoystickName(joystick);
		if ((envr != NULL) && (strcmp(envr, stickname) == 0))
			favored = i;

		printf("Stick #%d: [%s]\n", i, stickname);

		SDL_JoystickClose(joystick);
	} /* for */

	printf("Using Stick #%d.", favored);
	if ((envr == NULL) && (numsticks > 1))
		printf("Set BUILD_SDLJOYSTICK to one of the above names to change.\n");

	joystick = SDL_JoystickOpen(favored);
	if (joystick == NULL)
	{
		printf("Joystick #%d failed to init: %s\n", favored, SDL_GetError());
		return;
	} /* if */

	printf("Joystick initialized. %d axes, %d buttons, %d hats, %d balls.\n",
			  SDL_JoystickNumAxes(joystick), SDL_JoystickNumButtons(joystick),
			  SDL_JoystickNumHats(joystick), SDL_JoystickNumBalls(joystick));

	SDL_JoystickEventState(SDL_QUERY);
} /* _joystick_init */


void _joystick_deinit(void)
{
	if (joystick != NULL)
	{
		printf("Closing joystick device...\n");
		SDL_JoystickClose(joystick);
		printf("Joystick device closed. Deinitializing SDL subsystem...\n");
		SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
		printf("SDL joystick subsystem deinitialized.\n");
		joystick = NULL;
	} /* if */
} /* _joystick_deinit */


int _joystick_update(void)
{
	if (joystick == NULL)
		return(0);

	SDL_JoystickUpdate();
	return(1);
} /* _joystick_update */


int _joystick_axis(int axis)
{
	if (joystick == NULL)
	{
		return(0);
	}

	return(SDL_JoystickGetAxis(joystick, axis));
} /* _joystick_axis */

int _joystick_hat(int hat)
{
	if (joystick == NULL)
	{
		return(-1);
	}

	return(SDL_JoystickGetHat(joystick, hat));
} /* _joystick_axis */

int _joystick_button(int button)
{
	if (joystick == NULL)
		return(0);

	return(SDL_JoystickGetButton(joystick, button) != 0);
} /* _joystick_button */


uint8_t  _readlastkeyhit(void)
{
	return(lastkey);
} /* _readlastkeyhit */



#if (!defined __DATE__)
#define __DATE__ "a long, int32_t time ago"
#endif

static void output_sdl_versions(void)
{
/* FIXME plan9 */
#ifndef __plan9__
	SDL_version linked_ver;
	SDL_GetVersion(&linked_ver);

	SDL_version compiled_ver;
	SDL_VERSION(&compiled_ver);

	printf("SDL Display driver for the BUILD engine initializing.\n");
	printf("SDL Compiled %s against SDL version %d.%d.%d ...\n", __DATE__, compiled_ver.major, compiled_ver.minor, compiled_ver.patch);
	printf("SDL Linked against SDL version %d.%d.%d ...\n", linked_ver.major, linked_ver.minor, linked_ver.patch);
#endif
}

/* lousy -ansi flag.  :) */
static char  *string_dupe(const char  *str)
{
	char  *retval = malloc(strlen(str) + 1);
	if (retval != NULL)
		strcpy(retval, str);
	return(retval);
}

void _platform_init(int argc, char  **argv, const char  *title, const char  *iconName)
{
	int64_t timeElapsed;

	// FIX_00061: "ERROR: Two players have the same random ID" too frequent cuz of internet windows times
	timeElapsed = SDL_GetTicks();
	srand(timeElapsed&0xFFFFFFFF);

	SDL_CHECK_SUCCESS( SDL_Init(SDL_INIT_VIDEO) );
	
	if (title == NULL)
		title = "BUILD";

	titleName = string_dupe(title);
	set_sdl_scancodes(scancodes, sizeof(scancodes) / sizeof(scancodes[0]));

	output_sdl_versions();

	printf("SDL Video Driver: '%s'.\n", SDL_GetCurrentVideoDriver());
}

// Capture BMP of the current frame
void screencapture(char  *filename)
{
//  FIX_00006: better naming system for screenshots + message when pic is taken. 
//  Use ./screenshots folder. Screenshot code rerwritten. Faster and
//  makes smaller files. Doesn't freeze or lag the game anymore.
  
	if (SDL_SaveBMP(surface, filename))
	{
		printf("SDL failed to save screenshot '%s' (%s)\n", filename, SDL_GetError());
	}
}


void setvmode(int mode)
{

	if (mode == 0x3)  /* text mode. */
	{
		SDL_QuitSubSystem(SDL_INIT_VIDEO);
		return;
	} else
		printf("setvmode(0x%x) is unsupported in SDL driver.\n", mode);

} 

int _setgamemode(int32_t daxdim, int32_t daydim)
{
	int validated, i;

	if (daxdim > MAXXDIM || daydim > MAXYDIM)
	{
		printf("Resolution %dx%d is too high. Changed to %dx%d\n", daxdim, daydim, MAXXDIM,MAXYDIM);
		daxdim = MAXXDIM;
		daydim = MAXYDIM;
	}

	getvalidvesamodes();

	validated = 0;
	for(i=0; i<validmodecnt; i++){
		if(validmodexdim[i] == daxdim && validmodeydim[i] == daydim)
			validated = 1;
	}

	if(!validated){
		printf("Resolution %dx%d unsupported. Changed to 640x480\n", daxdim, daydim);
		daxdim = 640;
		daydim = 480;
	}

	go_to_new_vid_mode(daxdim, daydim);

	qsetmode = 200;
	last_render_ticks = getticks();

	return(0);
} /* setgamemode */


static int get_dimensions_from_str(const char  *str, int32_t *_w, int32_t *_h)
{
	char  *xptr = NULL;
	char  *ptr = NULL;
	int32_t w = -1;
	int32_t h = -1;

	if (str == NULL)
		return(0);

	xptr = strchr(str, 'x');
	if (xptr == NULL)
		return(0);

	w = strtol(str, &ptr, 10);
	if (ptr != xptr)
		return(0);

	xptr++;
	h = strtol(xptr, &ptr, 10);
	if ( (*xptr == '\0') || (*ptr != '\0') )
		return(0);

	if ((w <= 1) || (h <= 1))
		return(0);

	if (_w != NULL)
		*_w = w;

	if (_h != NULL)
		*_h = h;

	return(1);
} /* get_dimensions_from_str */


static inline void get_max_screen_res(int32_t *max_w, int32_t *max_h)
{
	int32_t w = DEFAULT_MAXRESWIDTH;
	int32_t h = DEFAULT_MAXRESHEIGHT;
	const char  *envr = getenv(BUILD_MAXSCREENRES);

	if (envr != NULL)
	{
		if (!get_dimensions_from_str(envr, &w, &h))
		{
			printf("User's resolution ceiling [%s] is bogus!\n", envr);
			w = DEFAULT_MAXRESWIDTH;
			h = DEFAULT_MAXRESHEIGHT;
		} /* if */
	} /* if */

	if (max_w != NULL)
		*max_w = w;

	if (max_h != NULL)
		*max_h = h;
}


static void add_vesa_mode(int w, int h)
{
	validmode[validmodecnt] = validmodecnt;
	validmodexdim[validmodecnt] = w;
	validmodeydim[validmodecnt] = h;
	validmodecnt++;
}

/* Let the user specify a specific mode via environment variable. */
static inline void add_user_defined_resolution(void)
{
	int32_t w;
	int32_t h;
	const char  *envr = getenv(BUILD_USERSCREENRES);

	if (envr == NULL)
		return;

	if (get_dimensions_from_str(envr, &w, &h))
		add_vesa_mode(w, h);
	else
		printf("User defined resolution [%s] is bogus!\n", envr);
} /* add_user_defined_resolution */

static void remove_vesa_mode(int index, const char  *reason)
{
	int i;

	assert(index < validmodecnt);
	//printf("Removing resolution #%d, %dx%d [%s].\n",index, validmodexdim[index], validmodeydim[index], reason);

	for (i = index; i < validmodecnt - 1; i++)
	{
		validmode[i] = validmode[i + 1];
		validmodexdim[i] = validmodexdim[i + 1];
		validmodeydim[i] = validmodeydim[i + 1];
	} /* for */

	validmodecnt--;
} /* remove_vesa_mode */


static inline void cull_large_vesa_modes(void)
{
	int32_t max_w;
	int32_t max_h;
	int i;
 
	get_max_screen_res(&max_w, &max_h);
	printf("Setting resolution ceiling to (%dx%d).\n", max_w, max_h);

	for (i = 0; i < validmodecnt; i++)
	{
		if ((validmodexdim[i] > max_w) || (validmodeydim[i] > max_h))
		{
			remove_vesa_mode(i, "above resolution ceiling");
			i--;  /* list shrinks. */
		} /* if */
	} /* for */
} /* cull_large_vesa_modes */


static inline void cull_duplicate_vesa_modes(void)
{
	int i;
	int j;

	for (i = 0; i < validmodecnt; i++){
		for (j = i + 1; j < validmodecnt; j++){
			if ( (validmodexdim[i] == validmodexdim[j]) &&(validmodeydim[i] == validmodeydim[j]) ){
				remove_vesa_mode(j, "duplicate");
				j--;  /* list shrinks. */
			}
		}
	}
} 


#define swap_macro(tmp, x, y) { tmp = x; x = y; y = tmp; }

/* be sure to call cull_duplicate_vesa_modes() before calling this. */
static inline void sort_vesa_modelist(void)
{
	int i;
	int sorted;
	int32_t tmp;

	do
	{
		sorted = 1;
		for (i = 0; i < validmodecnt - 1; i++)
		{
			if ( (validmodexdim[i] >= validmodexdim[i+1]) &&
				 (validmodeydim[i] >= validmodeydim[i+1]) )
			{
				sorted = 0;
				swap_macro(tmp, validmode[i], validmode[i+1]);
				swap_macro(tmp, validmodexdim[i], validmodexdim[i+1]);
				swap_macro(tmp, validmodeydim[i], validmodeydim[i+1]);
			} /* if */
		} /* for */
	} while (!sorted);
} /* sort_vesa_modelist */


static inline void cleanup_vesa_modelist(void)
{
	cull_large_vesa_modes();
	cull_duplicate_vesa_modes();
	sort_vesa_modelist();
} /* cleanup_vesa_modelist */


static inline void output_vesa_modelist(void)
{
	char  buffer[512];
	char  numbuf[20];
	int i;

	buffer[0] = '\0';

	for (i = 0; i < validmodecnt; i++)
	{
		sprintf(numbuf, " (%dx%d)",(int32_t) validmodexdim[i], (int32_t) validmodeydim[i]);

		if ( (strlen(buffer) + strlen(numbuf)) >= (sizeof (buffer) - 1) )
			strcpy(buffer + (sizeof (buffer) - 5), " ...");
		else
			strcat(buffer, numbuf);
	} /* for */

	printf("Final sorted modelist:%s\n", buffer);
} 


void getvalidvesamodes(void)
{
	static int already_checked = 0;
	int i;
	int stdres[][2] = {
		{320, 240},
		{640, 480},
		{800, 600},
		{1024, 768},
		{1280, 960},
		{1440, 1080},
		{1600, 1200},
		{1920, 1440},
		{2560, 1920},
		{2880, 2160}
	};

	if (already_checked)
		return;

	already_checked = 1;
	validmodecnt = 0;
	vidoption = 1;  /* !!! tmp */
	
	// Fill in the standard 4:3 resolutions that the display supports
	int numModes = SDL_GetNumDisplayModes(0);
	int maxWidth = 0;
	int maxHeight = 0;
	
	for (i = 0; i < numModes; ++i)
	{
		SDL_DisplayMode mode;
		SDL_CHECK_SUCCESS(SDL_GetDisplayMode(0, i, &mode));

		maxWidth = max(maxWidth, mode.w);
		maxHeight = max(maxHeight, mode.h);
	}
	
	for (i = 0; i < sizeof(stdres) / sizeof(stdres[0]); i++)
	{
		assert(stdres[i][0] / 4 == stdres[i][1] / 3);

		if (stdres[i][0] <= maxWidth && stdres[i][1] <= maxHeight)
		{
			add_vesa_mode(stdres[i][0], stdres[i][1]);
		}
	}
	
	/* Now add specific resolutions that the user wants... */
	add_user_defined_resolution();

	/* get rid of dupes and bogus resolutions... */
	cleanup_vesa_modelist();

	/* print it out for debugging purposes... */
	output_vesa_modelist();
} 

uint8_t lastPalette[768];
void WriteTranslucToFile(void)
{
	uint8_t buffer[65535*4];
	uint8_t tga_header[18];
	uint8_t* transPointer = transluc;
	uint8_t* bufferPointer = buffer;
	int i;
	FILE* file;

	for (i=0; i < 65535; i++) {

		bufferPointer[0] = (lastPalette[(*transPointer)*3+0]) / 63.0 * 255;
		bufferPointer[1] = (lastPalette[(*transPointer)*3+1]) / 63.0 * 255;
		bufferPointer[2] = (lastPalette[(*transPointer)*3+2]) / 63.0 * 255;
		bufferPointer[3] = 255;

		printf("%d,",*transPointer);
		if (i%255 ==0)
			printf("\n");

		transPointer +=1;
		bufferPointer+=4;
	}

	file = fopen("transluc.tga", "w");

	memset(tga_header, 0, 18);
	tga_header[2] = 2;
	tga_header[12] = (256 & 0x00FF);
	tga_header[13] = (256  & 0xFF00) / 256;
	tga_header[14] = (256  & 0x00FF) ;
	tga_header[15] =(256 & 0xFF00) / 256;
	tga_header[16] = 32 ;

	fwrite(&tga_header, 18, sizeof(uint8_t), file);
	fwrite(buffer, 65535, 4, file);
	fclose(file);
}

void WritePaletteToFile(uint8_t* palette,const char* filename,int width, int height)
{    
	uint8_t tga_header[18];
	uint8_t* buffer;
	uint8_t* palettePointer = palette;
	uint8_t* bufferPointer ;
	int i;

	FILE* file = fopen(filename, "w");

	memset(tga_header, 0, 18);
	tga_header[2] = 2;
	tga_header[12] = (width & 0x00FF);
	tga_header[13] = (width  & 0xFF00) / 256;
	tga_header[14] = (height  & 0x00FF) ;
	tga_header[15] =(height & 0xFF00) / 256;
	tga_header[16] = 32 ;

	fwrite(&tga_header, 18, sizeof(uint8_t), file);

	bufferPointer = buffer = malloc(width*height*4);

	for (i = 0 ; i < width*height ; i++)
	{
		bufferPointer[0] = palettePointer[0] / 63.0 * 255;
		bufferPointer[1] = palettePointer[1] / 63.0 * 255;
		bufferPointer[2] = palettePointer[2] / 63.0 * 255;
		bufferPointer[3] = 255;

		bufferPointer += 4;
		palettePointer+= 3;
	}

	fwrite(buffer, width*height, 4, file);
	fclose(file);

	free(buffer);
}


void WriteLastPaletteToFile()
{
	WritePaletteToFile(lastPalette,"lastPalette.tga",16,16);
}

void VBE_getPalette(int32_t start, int32_t num, uint8_t* palettebuffer)
{
	SDL_Color* sdlp = surface->format->palette->colors + start;
	uint8_t* p = palettebuffer + (start * 4);
	int i;

	for (i = 0; i < num; i++)
	{
		*p++ = (Uint8)((((float)sdlp->b) / 255.0) * 63.0);
		*p++ = (Uint8)((((float)sdlp->g) / 255.0) * 63.0);
		*p++ = (Uint8)((((float)sdlp->r) / 255.0) * 63.0);
		*p++ = sdlp->a;   /* This byte is unused in both SDL and BUILD. */
		sdlp++;
	}
}

void VBE_setPalette(uint8_t  *palettebuffer)
/*
 * (From Ken's docs:)
 *   Set (num) palette palette entries starting at (start)
 *   palette entries are in a 4-byte format in this order:
 *       0: Blue (0-63)
 *       1: Green (0-63)
 *       2: Red (0-63)
 *       3: Reserved
 *
 * Naturally, the bytes are in the reverse order that SDL wants them...
 *  More importantly, SDL wants the color elements in a range from 0-255,
 *  so we do a conversion.
 */
{
	SDL_Color fmt_swap[256];
	SDL_Color *sdlp = fmt_swap;
	uint8_t  *p = palettebuffer;
	int i;
	//static updated=0;

	//if (updated >=1 )
	//    return ;

	//WritePaletteToFile(palettebuffer,"lastPalette.tga",16,16);
	//updated++;

   
	//CODE EXPLORATION
	//Used only to write the last palette to file.
	memcpy(lastPalette, palettebuffer, 768);

	for (i = 0; i < 256; i++){
		sdlp->b = (Uint8) ((((float) *p++) / 63.0) * 255.0);
		sdlp->g = (Uint8) ((((float) *p++) / 63.0) * 255.0);
		sdlp->r = (Uint8) ((((float) *p++) / 63.0) * 255.0);
		sdlp->a = *p++;   /* This byte is unused in BUILD, too. */
		sdlp++;
	}

	SDL_CHECK_SUCCESS( SDL_SetPaletteColors(surface->format->palette, fmt_swap, 0, 256) );
}

void VBE_presentPalette(void)
{
	// tanguyf: updating the palette is not immediate with a buffered surface, screen needs updating as well.
	// Call this function if nextpage() is not called. E.g. static intro logo.
	present_framebuffer();
}

void _uninitengine(void)
{
   SDL_QuitSubSystem(SDL_INIT_VIDEO);
} /* _uninitengine */

int setupmouse(void)
{

	SDL_Event event;

	if (surface == NULL)
		return(0);

	SDL_CHECK_SUCCESS( SDL_SetRelativeMouseMode(SDL_TRUE) );

	mouse_relative_x = mouse_relative_y = 0;

	/*
	 * this global usually gets set by BUILD, but it's a one-shot
	 *  deal, and we may not have an SDL surface at that point. --ryan.
	 */
	moustat = 1;

	// FIX_00063: Duke's angle changing or incorrect when using toggle fullscreen/window mode
	while(SDL_PollEvent(&event)); // Empying the various pending events (especially the mouse one)

	//SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);

	return(1);
} /* setupmouse */


void readmousexy(short *x, short *y)
{
	if (x)
		*x = mouse_relative_x << 2;
	if (y)
		*y = mouse_relative_y << 2;

	mouse_relative_x = mouse_relative_y = 0;
} /* readmousexy */


void readmousebstatus(short *bstatus)
{
	if (bstatus)
		*bstatus = mouse_buttons;

	// special wheel treatment: make it like a button click
	if(mouse_buttons&8)
		mouse_buttons ^= 8;
	if(mouse_buttons&16)
		mouse_buttons ^= 16;

} /* readmousebstatus */


void _updateScreenRect(int32_t x, int32_t y, int32_t w, int32_t h)
{
	SDL_Rect rect = { x, y, w, h };

	SDL_CHECK_SUCCESS(SDL_BlitSurface(surface, &rect, surface_rgba, &rect));
	SDL_CHECK_SUCCESS(SDL_UpdateTexture(texture, &rect, surface_rgba->pixels, surface_rgba->pitch));
	SDL_CHECK_SUCCESS(SDL_RenderCopy(renderer, texture, &rect, &rect));
	SDL_RenderPresent(renderer);
}

//int counter= 0 ;
//char bmpName[256];
void _nextpage(void)
{
	Uint32 ticks;

	_handle_events();

	present_framebuffer();

	//sprintf(bmpName,"%d.bmp",counter++);
	//SDL_SaveBMP(surface,bmpName);

	//if (CLEAR_FRAMEBUFFER)
	//    SDL_FillRect(surface,NULL,0);

	ticks = getticks();
	total_render_time = (ticks - last_render_ticks);
	if (total_render_time > 1000){
		total_rendered_frames = 0;
		total_render_time = 1;
		last_render_ticks = ticks;
	}
	total_rendered_frames++;
} 

uint8_t  readpixel(uint8_t* offset)
{
	return *offset;
} 

void drawpixel(uint8_t* location, uint8_t pixel)
{
	*location = pixel;
}

/* Fix this up The Right Way (TM) - DDOI */
void setcolor16(uint8_t col)
{
	drawpixel_color = col;
}

void drawpixel16(int32_t offset)
{
	drawpixel((uint8_t*)surface->pixels + offset, drawpixel_color);
} /* drawpixel16 */


void fillscreen16(int32_t offset, int32_t color, int32_t blocksize)
{
	Uint8 *surface_end;
	Uint8 *wanted_end;
	Uint8 *pixels;

	if (SDL_MUSTLOCK(surface))
		SDL_LockSurface(surface);

	pixels = get_framebuffer();

	/* Make this function pageoffset aware - DDOI */
	if (!pageoffset) {
		offset = offset << 3;
		offset += 640*336;
	}

	surface_end = (pixels + (surface->w * surface->h)) - 1;
	wanted_end = (pixels + offset) + blocksize;

	if (offset < 0)
		offset = 0;

	if (wanted_end > surface_end)
		blocksize = surface_end - (pixels + offset);

	memset(pixels + offset, (int) color, blocksize);

	if (SDL_MUSTLOCK(surface))
		SDL_UnlockSurface(surface);

	_nextpage();
} /* fillscreen16 */


/* Most of this line code is taken from Abrash's "Graphics Programming Blackbook".
Remember, sharing code is A Good Thing. AH */
static inline void DrawHorizontalRun (uint8_t  **ScreenPtr, int XAdvance, int RunLength, uint8_t  Color)
{
	int i;
	uint8_t  *WorkingScreenPtr = *ScreenPtr;

	for (i=0; i<RunLength; i++)
	{
		*WorkingScreenPtr = Color;
		WorkingScreenPtr += XAdvance;
	}
	WorkingScreenPtr += surface->w;
	*ScreenPtr = WorkingScreenPtr;
}

static inline void DrawVerticalRun (uint8_t  **ScreenPtr, int XAdvance, int RunLength, uint8_t  Color)
{
	int i;
	uint8_t  *WorkingScreenPtr = *ScreenPtr;

	for (i=0; i<RunLength; i++)
	{
		*WorkingScreenPtr = Color;
		WorkingScreenPtr += surface->w;
	}
	WorkingScreenPtr += XAdvance;
	*ScreenPtr = WorkingScreenPtr;
}

void drawline16(int32_t XStart, int32_t YStart, int32_t XEnd, int32_t YEnd, uint8_t  Color)
{
	int Temp, AdjUp, AdjDown, ErrorTerm, XAdvance, XDelta, YDelta;
	int WholeStep, InitialPixelCount, FinalPixelCount, i, RunLength;
	uint8_t  *ScreenPtr;
	int32_t dx, dy;

	if (SDL_MUSTLOCK(surface))
		SDL_LockSurface(surface);

	dx = XEnd-XStart;
	dy = YEnd-YStart;

	//Analyse the slope
	if (dx >= 0)
	{
		if ((XStart > 639) || (XEnd < 0)) return;
		if (XStart < 0) { if (dy) YStart += scale(0-XStart,dy,dx); XStart = 0; }
		if (XEnd > 639) { if (dy) YEnd += scale(639-XEnd,dy,dx); XEnd = 639; }
	}
	else
	{
		if ((XEnd > 639) || (XStart < 0)) return;
		if (XEnd < 0) { if (dy) YEnd += scale(0-XEnd,dy,dx); XEnd = 0; }
		if (XStart > 639) { if (dy) YStart += scale(639-XStart,dy,dx); XStart = 639; }
	}
	if (dy >= 0)
	{
		if ((YStart >= ydim16) || (YEnd < 0)) return;
		if (YStart < 0) { if (dx) XStart += scale(0-YStart,dx,dy); YStart = 0; }
		if (YEnd >= ydim16) { if (dx) XEnd += scale(ydim16-1-YEnd,dx,dy); YEnd = ydim16-1; }
	}
	else
	{
		if ((YEnd >= ydim16) || (YStart < 0)) return;
		if (YEnd < 0) { if (dx) XEnd += scale(0-YEnd,dx,dy); YEnd = 0; }
		if (YStart >= ydim16) { if (dx) XStart += scale(ydim16-1-YStart,dx,dy); YStart = ydim16-1; }
	}

	/* Make sure the status bar border draws correctly - DDOI */
	if (!pageoffset) { YStart += 336; YEnd += 336; }

	/* We'll always draw top to bottom */
	if (YStart > YEnd) {
		Temp = YStart;
		YStart = YEnd;
		YEnd = Temp;
		Temp = XStart;
		XStart = XEnd;
		XEnd = Temp;
	}

	/* Point to the bitmap address first pixel to draw */
	ScreenPtr = (uint8_t  *) (get_framebuffer()) + XStart + (surface->w * YStart);

	/* Figure out whether we're going left or right, and how far we're going horizontally */
	if ((XDelta = XEnd - XStart) < 0)
	{
		XAdvance = (-1);
		XDelta = -XDelta;
	} else {
		XAdvance = 1;
	}

	/* Figure out how far we're going vertically */
	YDelta = YEnd - YStart;

	/* Special cases: Horizontal, vertical, and diagonal lines */
	if (XDelta == 0)
	{
		for (i=0; i <= YDelta; i++)
		{
			*ScreenPtr = Color;
			ScreenPtr += surface->w;
		}

		UNLOCK_SURFACE_AND_RETURN;
	}
	if (YDelta == 0)
	{
		for (i=0; i <= XDelta; i++)
		{
			*ScreenPtr = Color;
			ScreenPtr += XAdvance;
		}
		UNLOCK_SURFACE_AND_RETURN;
	}
	if (XDelta == YDelta)
	{
		for (i=0; i <= XDelta; i++)
		{
			*ScreenPtr = Color;
			ScreenPtr += XAdvance + surface->w;
		}
		UNLOCK_SURFACE_AND_RETURN;
	}

	/* Determine whether the line is X or Y major, and handle accordingly */
	if (XDelta >= YDelta) /* X major line */
	{
		WholeStep = XDelta / YDelta;
		AdjUp = (XDelta % YDelta) * 2;
		AdjDown = YDelta * 2;
		ErrorTerm = (XDelta % YDelta) - (YDelta * 2);

		InitialPixelCount = (WholeStep / 2) + 1;
		FinalPixelCount = InitialPixelCount;

		if ((AdjUp == 0) && ((WholeStep & 0x01) == 0)) InitialPixelCount--;
		if ((WholeStep & 0x01) != 0) ErrorTerm += YDelta;

		DrawHorizontalRun(&ScreenPtr, XAdvance, InitialPixelCount, Color);

		for (i=0; i<(YDelta-1); i++)
		{
			RunLength = WholeStep;
			if ((ErrorTerm += AdjUp) > 0)
			{
			RunLength ++;
			ErrorTerm -= AdjDown;
			}

			DrawHorizontalRun(&ScreenPtr, XAdvance, RunLength, Color);
		 }

		 DrawHorizontalRun(&ScreenPtr, XAdvance, FinalPixelCount, Color);

		 UNLOCK_SURFACE_AND_RETURN;
	} else {	/* Y major line */
		WholeStep = YDelta / XDelta;
		AdjUp = (YDelta % XDelta) * 2;
		AdjDown = XDelta * 2;
		ErrorTerm = (YDelta % XDelta) - (XDelta * 2);
		InitialPixelCount = (WholeStep / 2) + 1;
		FinalPixelCount = InitialPixelCount;

		if ((AdjUp == 0) && ((WholeStep & 0x01) == 0)) InitialPixelCount --;
		if ((WholeStep & 0x01) != 0) ErrorTerm += XDelta;

		DrawVerticalRun(&ScreenPtr, XAdvance, InitialPixelCount, Color);

		for (i=0; i<(XDelta-1); i++)
		{
			RunLength = WholeStep;
			if ((ErrorTerm += AdjUp) > 0)
			{
				RunLength ++;
				ErrorTerm -= AdjDown;
			}

			DrawVerticalRun(&ScreenPtr, XAdvance, RunLength, Color);
		}

		DrawVerticalRun(&ScreenPtr, XAdvance, FinalPixelCount, Color);
		UNLOCK_SURFACE_AND_RETURN;
	 }
} /* drawline16 */


void clear2dscreen(void)
{
	SDL_Rect rect;

	rect.x = rect.y = 0;
	rect.w = surface->w;

	if (qsetmode == 350)
		rect.h = 350;
	else if (qsetmode == 480)
	{
		if (ydim16 <= 336)
			rect.h = 336;
		else
			rect.h = 480;
	} /* else if */

	SDL_FillRect(surface, &rect, 0);
} /* clear2dscreen */


void _idle(void)
{
	if (surface != NULL)
		_handle_events();
	SDL_Delay(1);
} /* _idle */

void *_getVideoBase(void)
{
	return((void *) surface->pixels);
}


//-------------------------------------------------------------------------------------------------
//  TIMER
//=================================================================================================




// FIX_00007: game speed corrected. The game speed is now as the real
// DOS duke3d. Unloading a full 200 bullet pistol must take 45.1 sec.
// SDL timer was not fast/accurate enough and was slowing down the gameplay,
// so bad


static int64_t timerfreq=0;
static int32_t timerlastsample=0;
static int timerticspersec=0;
static void (*usertimercallback)(void) = NULL;

//  This timer stuff is all Ken's idea.

//
// installusertimercallback() -- set up a callback function to be called when the timer is fired
//
void (*installusertimercallback(void (*callback)(void)))(void)
{
	void (*oldtimercallback)(void);

	oldtimercallback = usertimercallback;
	usertimercallback = callback;

	return oldtimercallback;
}


/*
 inittimer() -- initialise timer
 FCS: The tickspersecond parameter is a ratio value that helps replicating
	  oldschool DOS tick per seconds.
 
	  The way the timer work is:
	  float newSystemTickPerSecond = [0,1]
	  tickPerSecond on a DOS system = tickspersecond * newSystemTickPerSecond ;
*/

int inittimer(int tickspersecond)
{
	int64_t t;	

	if (timerfreq) return 0;	// already installed

	//printf("Initialising timer, with tickPerSecond=%d\n",tickspersecond);

	timerfreq = 1000;
	timerticspersec = tickspersecond;
	t = SDL_GetTicks();
	timerlastsample = (int32_t)(t*timerticspersec / timerfreq);

	usertimercallback = NULL;

	return 0;
}

//
// uninittimer() -- shut down timer
//
void uninittimer(void)
{
	if (!timerfreq) return;

	timerfreq=0;
	timerticspersec = 0;
}

//
// sampletimer() -- update totalclock
//
void sampletimer(void)
{
	int64_t i;
	int32_t n;
	
	if (!timerfreq) return;

	i = SDL_GetTicks();

	n = (int32_t)(i*timerticspersec / timerfreq) - timerlastsample;
	if (n>0) {
		totalclock += n;
		timerlastsample += n;
	}

	if (usertimercallback) for (; n>0; n--) usertimercallback();
}

/*
   getticks() -- returns the windows ticks count
   FCS: This seeems to be only used in the multiplayer code
*/
uint32_t getticks(void)
{
	int64_t i;
	i = SDL_GetTicks();
	return (uint32_t)(i*(int32_t)(1000)/timerfreq);
}

//
// gettimerfreq() -- returns the number of ticks per second the timer is configured to generate
//
int gettimerfreq(void)
{
	return timerticspersec;
}