/*
===============
GL_Info_f -- johnfitz
===============
*/
static void GL_Info_f (void)
{
Con_SafePrintf ("GL_VENDOR: %s\n", gl_vendor);
Con_SafePrintf ("GL_RENDERER: %s\n", gl_renderer);
Con_SafePrintf ("GL_VERSION: %s\n", gl_version);
Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions_nice);
}
void
InitConProc(HANDLE hFile, HANDLE heventParent, HANDLE heventChild)
{
DWORD dwID;
// ignore if we don't have all the events.
if (!hFile || !heventParent || !heventChild)
return;
hfileBuffer = hFile;
heventParentSend = heventParent;
heventChildSend = heventChild;
// so we'll know when to go away.
heventDone = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!heventDone) {
Con_SafePrintf("Couldn't create heventDone\n");
return;
}
if (!CreateThread(NULL,
0, (LPTHREAD_START_ROUTINE) RequestProc, 0, 0, &dwID)) {
CloseHandle(heventDone);
Con_SafePrintf("Couldn't create QHOST thread\n");
return;
}
// save off the input/output handles.
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
hStdin = GetStdHandle(STD_INPUT_HANDLE);
// force 80 character width, at least 25 character height
SetConsoleCXCY(hStdout, 80, 25);
}
/*
============
Cmd_List_f -- johnfitz
============
*/
void Cmd_List_f (void)
{
cmd_function_t *cmd;
const char *partial;
int len, count;
if (Cmd_Argc() > 1)
{
partial = Cmd_Argv (1);
len = Q_strlen(partial);
}
else
{
partial = NULL;
len = 0;
}
count=0;
for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
{
if (partial && Q_strncmp (partial,cmd->name, len))
{
continue;
}
Con_SafePrintf (" %s\n", cmd->name);
count++;
}
Con_SafePrintf ("%i commands", count);
if (partial)
{
Con_SafePrintf (" beginning with \"%s\"", partial);
}
Con_SafePrintf ("\n");
}
/*
================
SV_CheckVelocity
================
*/
void SV_CheckVelocity (edict_t *ent)
{
int i;
//
// bound velocity
//
for (i=0 ; i<3 ; i++)
{
if (IS_NAN(ent->v.velocity[i]))
{
Con_SafePrintf ("Got a NaN velocity on %s\n", pr_strings + ent->v.classname);
ent->v.velocity[i] = 0;
}
if (IS_NAN(ent->v.origin[i]))
{
Con_SafePrintf ("Got a NaN origin on %s\n", pr_strings + ent->v.classname);
ent->v.origin[i] = 0;
}
if (ent->v.velocity[i] > sv_maxvelocity.value)
ent->v.velocity[i] = sv_maxvelocity.value;
else if (ent->v.velocity[i] < -sv_maxvelocity.value)
ent->v.velocity[i] = -sv_maxvelocity.value;
}
}
void IN_StartupMouse (void)
{
HDC hdc;
if ( COM_CheckParm ("-nomouse") )
return;
mouseinitialized = true;
if (COM_CheckParm ("-dinput"))
{
dinput = IN_InitDInput ();
if (dinput)
{
Con_SafePrintf ("DirectInput initialized\n");
}
else
{
Con_SafePrintf ("DirectInput not initialized\n");
}
}
if (!dinput)
{
mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0);
if (mouseparmsvalid)
{
if ( COM_CheckParm ("-noforcemspd") )
newmouseparms[2] = originalmouseparms[2];
if ( COM_CheckParm ("-noforcemaccel") )
{
newmouseparms[0] = originalmouseparms[0];
newmouseparms[1] = originalmouseparms[1];
}
if ( COM_CheckParm ("-noforcemparms") )
{
newmouseparms[0] = originalmouseparms[0];
newmouseparms[1] = originalmouseparms[1];
newmouseparms[2] = originalmouseparms[2];
}
}
}
mouse_buttons = 3;
// if a fullscreen video mode was set before the mouse was initialized,
// set the mouse state appropriately
if (mouseactivatetoggle)
IN_ActivateMouse ();
}
/*
==================
Host_Maps_f
==================
*/
void Host_Maps_f (void)
{
int i;
filelist_item_t *level;
for (level = extralevels, i = 0; level; level = level->next, i++)
Con_SafePrintf (" %s\n", level->name);
if (i)
Con_SafePrintf ("%i map(s)\n", i);
else
Con_SafePrintf ("no maps found\n");
}
/*
==================
Host_Mods_f -- johnfitz
list all potential mod directories (contain either a pak file or a progs.dat)
==================
*/
void Host_Mods_f (void)
{
int i;
filelist_item_t *mod;
for (mod = modlist, i=0; mod; mod = mod->next, i++)
Con_SafePrintf (" %s\n", mod->name);
if (i)
Con_SafePrintf ("%i mod(s)\n", i);
else
Con_SafePrintf ("no mods found\n");
}
static void SV_Protocol_f (void)
{
int i;
switch (Cmd_Argc())
{
case 1:
Con_Printf ("sv_protocol is %d\n", sv_protocol);
break;
case 2:
i = atoi(Cmd_Argv(1));
if (i != PROTOCOL_NETQUAKE && i != PROTOCOL_FITZQUAKE && i != PROTOCOL_MARKV && i != PROTOCOL_RMQ)
Con_Printf ("sv_protocol must be %i, %i, %i or %i\n",
PROTOCOL_NETQUAKE, PROTOCOL_FITZQUAKE, PROTOCOL_MARKV, PROTOCOL_RMQ);
else
{
sv_protocol = i;
if (sv.active)
Con_Printf ("changes will not take effect until the next level load.\n");
}
break;
default:
Con_SafePrintf ("usage: sv_protocol <protocol>\n");
break;
}
}
DWORD RequestProc (DWORD dwNichts)
{
int *pBuffer;
DWORD dwRet;
HANDLE heventWait[2];
int iBeginLine, iEndLine;
heventWait[0] = heventParentSend;
heventWait[1] = heventDone;
while (1)
{
dwRet = WaitForMultipleObjects (2, heventWait, FALSE, INFINITE);
// heventDone fired, so we're exiting.
if (dwRet == WAIT_OBJECT_0 + 1)
break;
pBuffer = (int *) GetMappedBuffer (hfileBuffer);
// hfileBuffer is invalid. Just leave.
if (!pBuffer)
{
Con_SafePrintf ("Invalid hfileBuffer\n");
break;
}
switch (pBuffer[0])
{
case CCOM_WRITE_TEXT:
// Param1 : Text
pBuffer[0] = WriteText ((LPCTSTR) (pBuffer + 1));
break;
case CCOM_GET_TEXT:
// Param1 : Begin line
// Param2 : End line
iBeginLine = pBuffer[1];
iEndLine = pBuffer[2];
pBuffer[0] = ReadText ((LPTSTR) (pBuffer + 1), iBeginLine,
iEndLine);
break;
case CCOM_GET_SCR_LINES:
// No params
pBuffer[0] = GetScreenBufferLines (&pBuffer[1]);
break;
case CCOM_SET_SCR_LINES:
// Param1 : Number of lines
pBuffer[0] = SetScreenBufferLines (pBuffer[1]);
break;
}
ReleaseMappedBuffer (pBuffer);
SetEvent (heventChildSend);
}
return 0;
}
/*
================
VID_SetMode
================
*/
static int VID_SetMode (int width, int height, int bpp, qboolean fullscreen)
{
int temp;
Uint32 flags = DEFAULT_SDL_FLAGS;
char caption[50];
if (fullscreen)
flags |= SDL_FULLSCREEN;
// so Con_Printfs don't mess us up by forcing vid and snd updates
temp = scr_disabled_for_loading;
scr_disabled_for_loading = true;
CDAudio_Pause ();
BGM_Pause ();
//
// swap control (the "before SDL_SetVideoMode" part)
//
gl_swap_control = true;
if (SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, (vid_vsync.value) ? 1 : 0) == -1)
gl_swap_control = false;
bpp = SDL_VideoModeOK(width, height, bpp, flags);
draw_context = SDL_SetVideoMode(width, height, bpp, flags);
if (!draw_context)
Sys_Error ("Couldn't set video mode");
q_snprintf(caption, sizeof(caption), "QuakeSpasm %1.2f.%d", (float)FITZQUAKE_VERSION, QUAKESPASM_VER_PATCH);
SDL_WM_SetCaption(caption, caption);
vid.width = draw_context->w;
vid.height = draw_context->h;
vid.conwidth = vid.width & 0xFFFFFFF8;
vid.conheight = vid.conwidth * vid.height / vid.width;
vid.numpages = 2;
modestate = draw_context->flags & SDL_FULLSCREEN ? MS_FULLSCREEN : MS_WINDOWED;
CDAudio_Resume ();
BGM_Resume ();
scr_disabled_for_loading = temp;
// fix the leftover Alt from any Alt-Tab or the like that switched us away
ClearAllStates ();
Con_SafePrintf ("Video mode %dx%dx%d initialized\n",
draw_context->w,
draw_context->h,
draw_context->format->BitsPerPixel);
vid.recalc_refdef = 1;
// no pending changes
vid_changed = false;
return true;
}
static int VID_SetMode (int modenum, unsigned char *palette)
{
Uint32 flags;
int is_fullscreen;
in_mode_set = true;
if (screen)
SDL_FreeSurface(screen);
flags = (SDL_SWSURFACE|SDL_HWPALETTE);
if (vid_config_fscr.integer)
flags |= SDL_FULLSCREEN;
// Set the mode
screen = SDL_SetVideoMode(modelist[modenum].width, modelist[modenum].height, modelist[modenum].bpp, flags);
if (!screen)
return false;
// initial success. adjust vid vars.
vid.height = vid.conheight = modelist[modenum].height;
vid.width = vid.conwidth = modelist[modenum].width;
vid.buffer = vid.conbuffer = vid.direct = (pixel_t *) screen->pixels;
vid.rowbytes = vid.conrowbytes = screen->pitch;
vid.numpages = 1;
vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
if (!VID_AllocBuffers (vid.width, vid.height))
return false;
D_InitCaches (vid_surfcache, vid_surfcachesize);
// real success. set vid_modenum properly.
vid_modenum = modenum;
is_fullscreen = (screen->flags & SDL_FULLSCREEN) ? 1 : 0;
modestate = (is_fullscreen) ? MS_FULLDIB : MS_WINDOWED;
Cvar_SetValue ("vid_config_swx", modelist[vid_modenum].width);
Cvar_SetValue ("vid_config_swy", modelist[vid_modenum].height);
Cvar_SetValue ("vid_config_fscr", is_fullscreen);
IN_HideMouse ();
ClearAllStates();
VID_SetPalette (palette);
// setup the window manager stuff
VID_SetIcon();
SDL_WM_SetCaption(WM_TITLEBAR_TEXT, WM_ICON_TEXT);
Con_SafePrintf ("Video Mode: %ux%ux%d\n", vid.width, vid.height, modelist[modenum].bpp);
in_mode_set = false;
vid.recalc_refdef = 1;
return true;
}
/*
=============
ED_Print
For debugging
=============
*/
void ED_Print (edict_t *ed)
{
ddef_t *d;
int *v;
int i, j, l;
const char *name;
int type;
if (ed->free)
{
Con_Printf ("FREE\n");
return;
}
Con_SafePrintf("\nEDICT %i:\n", NUM_FOR_EDICT(ed)); //johnfitz -- was Con_Printf
for (i = 1; i < progs->numfielddefs; i++)
{
d = &pr_fielddefs[i];
name = PR_GetString(d->s_name);
l = strlen (name);
if (l > 1 && name[l - 2] == '_')
continue; // skip _x, _y, _z vars
v = (int *)((char *)&ed->v + d->ofs*4);
// if the value is still all 0, skip the field
type = d->type & ~DEF_SAVEGLOBAL;
for (j = 0; j < type_size[type]; j++)
{
if (v[j])
break;
}
if (j == type_size[type])
continue;
Con_SafePrintf ("%s", name); //johnfitz -- was Con_Printf
while (l++ < 15)
Con_SafePrintf (" "); //johnfitz -- was Con_Printf
Con_SafePrintf ("%s\n", PR_ValueString(d->type, (eval_t *)v)); //johnfitz -- was Con_Printf
}
}
/*
=================
VID_InitModelist
=================
*/
static void VID_InitModelist (void)
{
SDL_PixelFormat format;
SDL_Rect **modes;
Uint32 flags;
int i, j, k, originalnummodes, existingmode;
int bpps[] = {16, 24, 32}; // enumerate >8 bpp modes
originalnummodes = nummodes = 0;
format.palette = NULL;
// enumerate fullscreen modes
flags = DEFAULT_SDL_FLAGS | SDL_FULLSCREEN;
for (i = 0; i < (int)(sizeof(bpps)/sizeof(bpps[0])); i++)
{
if (nummodes >= MAX_MODE_LIST)
break;
format.BitsPerPixel = bpps[i];
modes = SDL_ListModes(&format, flags);
if (modes == (SDL_Rect **)0 || modes == (SDL_Rect **)-1)
continue;
for (j = 0; modes[j]; j++)
{
if (modes[j]->w > MAXWIDTH || modes[j]->h > MAXHEIGHT || nummodes >= MAX_MODE_LIST)
continue;
modelist[nummodes].width = modes[j]->w;
modelist[nummodes].height = modes[j]->h;
modelist[nummodes].bpp = bpps[i];
for (k=originalnummodes, existingmode = 0 ; k < nummodes ; k++)
{
if ((modelist[nummodes].width == modelist[k].width) &&
(modelist[nummodes].height == modelist[k].height) &&
(modelist[nummodes].bpp == modelist[k].bpp))
{
existingmode = 1;
break;
}
}
if (!existingmode)
{
nummodes++;
}
}
}
if (nummodes == originalnummodes)
Con_SafePrintf ("No fullscreen DIB modes found\n");
}
/*
=================
VID_DescribeModes_f -- johnfitz -- changed formatting, and added refresh rates after each mode.
=================
*/
static void VID_DescribeModes_f (void)
{
int i;
int lastwidth, lastheight, lastbpp, count;
lastwidth = lastheight = lastbpp = count = 0;
for (i = 0; i < nummodes; i++)
{
if (lastwidth != modelist[i].width || lastheight != modelist[i].height || lastbpp != modelist[i].bpp)
{
if (count > 0)
Con_SafePrintf ("\n");
Con_SafePrintf (" %4i x %4i x %i", modelist[i].width, modelist[i].height, modelist[i].bpp);
lastwidth = modelist[i].width;
lastheight = modelist[i].height;
lastbpp = modelist[i].bpp;
count++;
}
}
Con_Printf ("\n%i modes\n", count);
}
/*
============
Cvar_List_f
============
*/
void Cvar_List_f (void)
{
cvar_t *cvar;
char *partial;
int len, count;
if (Cmd_Argc() > 1)
{
partial = Cmd_Argv (1);
len = strlen(partial);
}
else
{
partial = NULL;
len = 0;
}
count=0;
for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
{
if (partial && strncmp (partial,cvar->name, len))
{
continue;
}
Con_SafePrintf ("%s%s %s \"%s\"\n",
cvar->archive ? "*" : " ",
cvar->server ? "s" : " ",
cvar->name,
cvar->string);
count++;
}
Con_SafePrintf ("%i cvars", count);
if (partial)
{
Con_SafePrintf (" beginning with \"%s\"", partial);
}
Con_SafePrintf ("\n");
}
static void S_SoundList (void)
{
int i;
sfx_t *sfx;
sfxcache_t *sc;
int size, total;
total = 0;
for (sfx = known_sfx, i = 0; i < num_sfx; i++, sfx++)
{
sc = (sfxcache_t *) Cache_Check (&sfx->cache);
if (!sc)
continue;
size = sc->length*sc->width*(sc->stereo + 1);
total += size;
if (sc->loopstart >= 0)
Con_SafePrintf ("L"); //johnfitz -- was Con_Printf
else
Con_SafePrintf (" "); //johnfitz -- was Con_Printf
Con_SafePrintf("(%2db) %6i : %s\n", sc->width*8, size, sfx->name); //johnfitz -- was Con_Printf
}
Con_Printf ("%i sounds, %i bytes\n", num_sfx, total); //johnfitz -- added count
}
/*
==============
SNDDMA_Submit
Send sound to device if buffer isn't really the dma buffer
===============
*/
void SNDDMA_Submit(void)
{
LPWAVEHDR h;
int wResult;
if (!wav_init)
return;
//
// find which sound blocks have completed
//
while (1)
{
if ( snd_completed == snd_sent )
{
Con_DPrintf ("Sound overrun\n");
break;
}
if ( ! (lpWaveHdr[ snd_completed & WAV_MASK].dwFlags & WHDR_DONE) )
{
break;
}
snd_completed++; // this buffer has been played
}
//
// submit two new sound blocks
//
while (((snd_sent - snd_completed) >> sample16) < 4)
{
h = lpWaveHdr + ( snd_sent&WAV_MASK );
snd_sent++;
/*
* Now the data block can be sent to the output device. The
* waveOutWrite function returns immediately and waveform
* data is sent to the output device in the background.
*/
wResult = waveOutWrite(hWaveOut, h, sizeof(WAVEHDR));
if (wResult != MMSYSERR_NOERROR)
{
Con_SafePrintf ("Failed to write block to device\n");
FreeSound ();
return;
}
}
}
void *COM_AllocBuf (char *Func, void *Buf, int *PSize, int NewSize, int OldLimit, char *Name)
{
// static int TotCalls = 0, AllocCalls = 0;
// ++TotCalls;
// Sanity ...
if (NewSize & 0xC0000000)
Sys_Error ("%s: invalid size for '%s': %dM", Func, Name, NewSize / (1024 * 1024));
if (OldLimit && NewSize > OldLimit)
{
Con_SafePrintf ("\x02%s: ", Func);
Con_SafePrintf ("excessive '%s' size %dk (normal max %dk)\n", Name, NewSize / 1024, OldLimit / 1024);
}
if (NewSize > *PSize || NewSize < *PSize / 2 && *PSize > MIN_ALLOC * 2)
{
// ++AllocCalls;
// Con_SafePrintf ("COM_AllocBuf: %s: %dk, Alloc:%d, Total:%d\n", Func, NewSize / 1024, AllocCalls, TotCalls);
if (Buf)
COM_FreeBuf (Buf);
if (NewSize < MIN_ALLOC)
NewSize = MIN_ALLOC;
Buf = malloc (NewSize);
if (!Buf)
Sys_Error ("%s: not enough memory for '%s': %dk", Func, Name, NewSize / 1024);
*PSize = NewSize;
}
return Buf;
}
/*
================
D_InitCaches
================
*/
void D_InitCaches (void *buffer, int size)
{
// Prevent unwanted printouts
if (!msg_suppress_1 && con_x == 0)
Con_SafePrintf ("%ik surface cache\n", size/1024);
sc_size = size - GUARDSIZE;
sc_base = (surfcache_t *)buffer;
sc_rover = sc_base;
sc_base->next = NULL;
sc_base->owner = NULL;
sc_base->size = sc_size;
D_ClearCacheGuard ();
}
/*
================
VID_AllocBuffers
================
*/
static qboolean VID_AllocBuffers (int width, int height)
{
int tsize, tbuffersize;
tbuffersize = width * height * sizeof (*d_pzbuffer);
tsize = D_SurfaceCacheForRes (width, height);
tbuffersize += tsize;
// see if there's enough memory, allowing for the normal mode 0x13 pixel,
// z, and surface buffers
//if ((host_parms->memsize - tbuffersize + SURFCACHE_SIZE_AT_320X200 +
// 0x10000 * 3) < MINIMUM_MEMORY)
// Pa3PyX: using hopefully better estimation now
// if total memory < needed surface cache + (minimum operational memory
// less surface cache for 320x200 and typical hunk state after init)
if (host_parms->memsize < tbuffersize + 0x180000 + 0xC00000)
{
Con_SafePrintf ("Not enough memory for video mode\n");
return false; // not enough memory for mode
}
vid_surfcachesize = tsize;
if (d_pzbuffer)
{
D_FlushCaches ();
Hunk_FreeToHighMark (VID_highhunkmark);
d_pzbuffer = NULL;
}
VID_highhunkmark = Hunk_HighMark ();
d_pzbuffer = (short *) Hunk_HighAllocName (tbuffersize, "video");
vid_surfcache = (byte *)d_pzbuffer +
width * height * sizeof (*d_pzbuffer);
return true;
}
/*
===============
COM_vsnprintf
===============
*/
int COM_vsnprintf (char *function, char *buffer, int buffersize, char *format, va_list argptr)
{
int result = vsnprintf (buffer, buffersize, format, argptr);
buffer[buffersize] = 0;
if (result < 0 || result >= buffersize)
{
static qboolean inside;
// Beware recursion here
if (!inside)
{
inside = true;
Con_SafePrintf ("%s: excessive string length, max = %d\n", function, buffersize);
}
inside = false;
return -1;
}
return result;
}
/*
==================
SNDDM_InitWav
Crappy windows multimedia base
==================
*/
qboolean SNDDMA_InitWav (void)
{
WAVEFORMATEX format;
int i;
HRESULT hr;
snd_sent = 0;
snd_completed = 0;
shm = &sn;
shm->channels = 2;
shm->samplebits = 16;
shm->speed = 11025;
memset (&format, 0, sizeof(format));
format.wFormatTag = WAVE_FORMAT_PCM;
format.nChannels = shm->channels;
format.wBitsPerSample = shm->samplebits;
format.nSamplesPerSec = shm->speed;
format.nBlockAlign = format.nChannels
*format.wBitsPerSample / 8;
format.cbSize = 0;
format.nAvgBytesPerSec = format.nSamplesPerSec
*format.nBlockAlign;
/* Open a waveform device for output using window callback. */
while ((hr = waveOutOpen((LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,
&format,
0, 0L, CALLBACK_NULL)) != MMSYSERR_NOERROR)
{
if (hr != MMSYSERR_ALLOCATED)
{
Con_SafePrintf ("waveOutOpen failed\n");
return false;
}
if (MessageBox (NULL,
"The sound hardware is in use by another app.\n\n"
"Select Retry to try to start sound again or Cancel to run Quake with no sound.",
"Sound not available",
MB_RETRYCANCEL | MB_SETFOREGROUND | MB_ICONEXCLAMATION) != IDRETRY)
{
Con_SafePrintf ("waveOutOpen failure;\n"
" hardware already in use\n");
return false;
}
}
/*
* Allocate and lock memory for the waveform data. The memory
* for waveform data must be globally allocated with
* GMEM_MOVEABLE and GMEM_SHARE flags.
*/
gSndBufSize = WAV_BUFFERS*WAV_BUFFER_SIZE;
hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, gSndBufSize);
if (!hData)
{
Con_SafePrintf ("Sound: Out of memory.\n");
FreeSound ();
return false;
}
lpData = GlobalLock(hData);
if (!lpData)
{
Con_SafePrintf ("Sound: Failed to lock.\n");
FreeSound ();
return false;
}
memset (lpData, 0, gSndBufSize);
/*
* Allocate and lock memory for the header. This memory must
* also be globally allocated with GMEM_MOVEABLE and
* GMEM_SHARE flags.
*/
hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
(DWORD) sizeof(WAVEHDR) * WAV_BUFFERS);
if (hWaveHdr == NULL)
{
Con_SafePrintf ("Sound: Failed to Alloc header.\n");
FreeSound ();
return false;
}
lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
if (lpWaveHdr == NULL)
{
Con_SafePrintf ("Sound: Failed to lock header.\n");
FreeSound ();
return false;
}
memset (lpWaveHdr, 0, sizeof(WAVEHDR) * WAV_BUFFERS);
/* After allocation, set up and prepare headers. */
for (i=0 ; i<WAV_BUFFERS ; i++)
{
lpWaveHdr[i].dwBufferLength = WAV_BUFFER_SIZE;
lpWaveHdr[i].lpData = lpData + i*WAV_BUFFER_SIZE;
if (waveOutPrepareHeader(hWaveOut, lpWaveHdr+i, sizeof(WAVEHDR)) !=
MMSYSERR_NOERROR)
{
Con_SafePrintf ("Sound: failed to prepare wave headers\n");
FreeSound ();
return false;
}
}
shm->soundalive = true;
shm->splitbuffer = false;
shm->samples = gSndBufSize/(shm->samplebits/8);
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = (unsigned char *) lpData;
sample16 = (shm->samplebits/8) - 1;
wav_init = true;
return true;
}
qboolean IN_InitDInput (void)
{
HRESULT hr;
DIPROPDWORD dipdw = {
{
sizeof(DIPROPDWORD), // diph.dwSize
sizeof(DIPROPHEADER), // diph.dwHeaderSize
0, // diph.dwObj
DIPH_DEVICE, // diph.dwHow
},
DINPUT_BUFFERSIZE, // dwData
};
if (!hInstDI)
{
hInstDI = LoadLibrary("dinput.dll");
if (hInstDI == NULL)
{
Con_SafePrintf ("Couldn't load dinput.dll\n");
return false;
}
}
if (!pDirectInputCreate)
{
pDirectInputCreate = (void *)GetProcAddress(hInstDI,"DirectInputCreateA");
if (!pDirectInputCreate)
{
Con_SafePrintf ("Couldn't get DI proc addr\n");
return false;
}
}
// register with DirectInput and get an IDirectInput to play with.
hr = iDirectInputCreate(global_hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL);
if (FAILED(hr))
{
return false;
}
// obtain an interface to the system mouse device.
hr = IDirectInput_CreateDevice(g_pdi, &GUID_SysMouse, &g_pMouse, NULL);
if (FAILED(hr))
{
Con_SafePrintf ("Couldn't open DI mouse device\n");
return false;
}
// set the data format to "mouse format".
hr = IDirectInputDevice_SetDataFormat(g_pMouse, &df);
if (FAILED(hr))
{
Con_SafePrintf ("Couldn't set DI mouse format\n");
return false;
}
// set the cooperativity level.
hr = IDirectInputDevice_SetCooperativeLevel(g_pMouse, mainwindow,
DISCL_EXCLUSIVE | DISCL_FOREGROUND);
if (FAILED(hr))
{
Con_SafePrintf ("Couldn't set DI coop level\n");
return false;
}
// set the buffer size to DINPUT_BUFFERSIZE elements.
// the buffer size is a DWORD property associated with the device
hr = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph);
if (FAILED(hr))
{
Con_SafePrintf ("Couldn't set DI buffersize\n");
return false;
}
return true;
}
int WINS_Init(void)
{
int i;
char buff[MAXHOSTNAMELEN];
char *p;
int r;
WORD wVersionRequested;
HINSTANCE hInst;
// initialize the Winsock function vectors (we do this instead of statically linking
// so we can run on Win 3.1, where there isn't necessarily Winsock)
hInst = LoadLibrary("wsock32.dll");
if (hInst == NULL) {
Con_SafePrintf("Failed to load winsock.dll\n");
winsock_lib_initialized = false;
return -1;
}
winsock_lib_initialized = true;
pWSAStartup = (void *)GetProcAddress(hInst, "WSAStartup");
pWSACleanup = (void *)GetProcAddress(hInst, "WSACleanup");
pWSAGetLastError = (void *)GetProcAddress(hInst, "WSAGetLastError");
psocket = (void *)GetProcAddress(hInst, "socket");
pioctlsocket = (void *)GetProcAddress(hInst, "ioctlsocket");
psetsockopt = (void *)GetProcAddress(hInst, "setsockopt");
precvfrom = (void *)GetProcAddress(hInst, "recvfrom");
psendto = (void *)GetProcAddress(hInst, "sendto");
pclosesocket = (void *)GetProcAddress(hInst, "closesocket");
pgethostname = (void *)GetProcAddress(hInst, "gethostname");
pgethostbyname = (void *)GetProcAddress(hInst, "gethostbyname");
pgethostbyaddr = (void *)GetProcAddress(hInst, "gethostbyaddr");
pgetsockname = (void *)GetProcAddress(hInst, "getsockname");
if (!pWSAStartup || !pWSACleanup || !pWSAGetLastError ||
!psocket || !pioctlsocket || !psetsockopt ||
!precvfrom || !psendto || !pclosesocket ||
!pgethostname || !pgethostbyname || !pgethostbyaddr ||
!pgetsockname) {
Con_SafePrintf("Couldn't GetProcAddress from winsock.dll\n");
return -1;
}
if (COM_CheckParm("-noudp")) {
return -1;
}
if (winsock_initialized == 0) {
wVersionRequested = MAKEWORD(1, 1);
r = pWSAStartup(MAKEWORD(1, 1), &winsockdata);
if (r) {
Con_SafePrintf("Winsock initialization failed.\n");
return -1;
}
}
winsock_initialized++;
// determine my name
if (pgethostname(buff, MAXHOSTNAMELEN) == SOCKET_ERROR) {
Con_DPrintf("Winsock TCP/IP Initialization failed.\n");
if (--winsock_initialized == 0) {
pWSACleanup();
}
return -1;
}
// if the quake hostname isn't set, set it to the machine name
if (Q_strcmp(hostname.string, "UNNAMED") == 0) {
// see if it's a text IP address (well, close enough)
for (p = buff; *p; p++)
if ((*p < '0' || *p > '9') && *p != '.') {
break;
}
// if it is a real name, strip off the domain; we only want the host
if (*p) {
for (i = 0; i < 15; i++)
if (buff[i] == '.') {
break;
}
buff[i] = 0;
}
Cvar_Set("hostname", buff);
}
i = COM_CheckParm("-ip");
if (i) {
if (i < com_argc-1) {
myAddr = inet_addr(com_argv[i+1]);
if (myAddr == INADDR_NONE) {
Sys_Error("%s is not a valid IP address", com_argv[i+1]);
}
strcpy(my_tcpip_address, com_argv[i+1]);
} else {
Sys_Error("NET_Init: you must specify an IP address after -ip");
}
} else {
myAddr = INADDR_ANY;
strcpy(my_tcpip_address, "INADDR_ANY");
}
if ((net_controlsocket = WINS_OpenSocket(0)) == -1) {
Con_Printf("WINS_Init: Unable to open control socket\n");
if (--winsock_initialized == 0) {
pWSACleanup();
}
return -1;
}
((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = INADDR_BROADCAST;
((struct sockaddr_in *)&broadcastaddr)->sin_port = htons((unsigned short)net_hostport);
Con_DPrintf("Winsock TCP/IP Initialized\n"); // edited
tcpipAvailable = true;
return net_controlsocket;
}
/*
===============
Host_Loadgame_f
===============
*/
void Host_Loadgame_f (void)
{
char name[MAX_OSPATH];
FILE *f;
char mapname[MAX_QPATH];
float time, tfloat;
char str[32768], *start;
int i, r, line; // Current line # in savegame file
edict_t *ent;
int entnum, numedicts_save;
int version;
float spawn_parms[NUM_SPAWN_PARMS];
qboolean Quote;
if (cmd_source != src_command)
return;
if (Cmd_Argc() != 2)
{
Con_Printf ("load <savename> : load a game\n");
return;
}
cls.demonum = -1; // stop demo loop in case this fails
sprintf (name, "%s/%s", com_gamedir, Cmd_Argv(1));
COM_DefaultExtension (name, ".sav");
// we can't call SCR_BeginLoadingPlaque, because too much stack space has
// been used. The menu calls it before stuffing loadgame command
// SCR_BeginLoadingPlaque ();
Con_SafePrintf ("Loading game from %s...\n", name);
f = fopen (name, "rb"); // Use binary mode to avoid EOF issues in savegame files
if (!f)
{
Con_Printf ("ERROR: couldn't open.\n");
return;
}
fscanf (f, "%i\n", &version);
if (version != SAVEGAME_VERSION)
{
fclose (f);
Con_Printf ("Savegame is version %i, not %i\n", version, SAVEGAME_VERSION);
return;
}
// Kludge to read saved games with newlines in title
do
fscanf (f, "%s\n", str);
while (!feof(f) && !strstr(str, "kills:"));
for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
fscanf (f, "%f\n", &spawn_parms[i]);
// this silliness is so we can load 1.06 save files, which have float skill values
fscanf (f, "%f\n", &tfloat);
current_skill = (int)(tfloat + 0.1);
Cvar_SetValue ("skill", (float)current_skill);
fscanf (f, "%s\n",mapname);
fscanf (f, "%f\n",&time);
CL_Disconnect_f ();
#ifdef QUAKE2
SV_SpawnServer (mapname, NULL);
#else
SV_SpawnServer (mapname);
#endif
if (!sv.active)
{
Con_Printf ("Couldn't load map\n");
return;
}
sv.paused = true; // pause until all clients connect
sv.loadgame = true;
// load the light styles
for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
{
fscanf (f, "%s\n", str);
sv.lightstyles[i] = Hunk_Alloc (strlen(str)+1);
strcpy (sv.lightstyles[i], str);
}
// load the edicts out of the savegame file
entnum = -1; // -1 is the globals
// Hack to avoid validation errors while parsing savegame file
numedicts_save = sv.num_edicts;
sv.num_edicts = MAX_EDICTS;
line = 86; // 85 lines before globals in savegame
while (!feof(f))
{
for (i=0, Quote = false ; i<sizeof(str)-1 ; i++)
{
r = fgetc (f);
if (r == EOF || !r)
break;
if (r == '\n')
++line;
str[i] = r;
// Handle multiline quoted strings containing '}'
if (!Quote)
{
if (r == '\"')
Quote = true;
else if (r == '}')
{
i++;
break;
}
}
else if (Quote)
{
if (r == '\"')
Quote = false;
}
}
if (i == sizeof(str)-1)
Sys_Error ("Loadgame buffer overflow (%d, max = %d) on line %d", i + 1, sizeof(str) - 1, line);
if (Quote)
Sys_Error ("Host_Loadgame_f: %s in quoted string on line %d", r == EOF ? "EOF" : "EOS", line);
str[i] = 0;
start = str;
start = COM_Parse(str);
if (!com_token[0])
break; // end of file
if (strcmp(com_token,"{"))
Sys_Error ("First token (%s) isn't a brace on line %d", com_token, line);
if (entnum == -1)
{ // parse the global vars
ED_ParseGlobals (start, line);
}
else
{ // parse an edict
ent = EDICT_NUM("Host_Loadgame_f1", entnum);
if (!pr_free[entnum])
ED_Free (ent); // Unlink from world
memset (&ent->v, 0, progs->entityfields * 4);
pr_free[entnum] = false;
ED_ParseEdict (start, ent, line);
// link it into the bsp tree
if (!pr_free[entnum])
{
int mindx = ent->v.modelindex;
model_t *model = sv.models[mindx];
char *mname = pr_String ("Host_Loadgame_f1", ent->v.model);
char *cname = pr_String ("Host_Loadgame_f2", ent->v.classname);
// Check for missing/invalid models (except e.g. player/eyes RoS switch)
if (mindx != 0 && (model == NULL || *mname != 0 && strcmp(model->name, mname) && strcmp(cname, "player")))
{
Con_Printf ("\x02Host_Loadgame_f: ");
if (model == NULL)
Con_Printf ("missing model");
else
Con_Printf ("invalid model (%s)", model->name);
Con_Printf (" for edict %d (%s)\n", entnum, ED_DbgEdict(&ent->v));
}
SV_LinkEdict (ent, false);
}
}
entnum++;
}
sv.num_edicts = numedicts_save;
// Free edicts not present in the savegame, might
// otherwise cause odd SV_TouchLinks errors
for (i = entnum; i < sv.num_edicts; ++i)
{
if (!pr_free[i])
{
ent = EDICT_NUM("Host_Loadgame_f2", i);
// Don't warn if edict_reuse is disabled
if (ent->area.prev && edict_reuse.value)
{
Con_Printf ("\002Host_Loadgame_f: ");
Con_Printf ("invalid touched edict (%d, max = %d)\n", i, entnum);
}
ED_Free (ent); // Unlink from world
}
}
sv.num_edicts = entnum; // Set new edict amount from savegame
// Count active edicts
for (i = sv.active_edicts = 0; i < sv.num_edicts; ++i)
{
if (!pr_free[i])
++sv.active_edicts;
}
ED_ChkEdict (true, false);
sv.time = time;
fclose (f);
for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
svs.clients->spawn_parms[i] = spawn_parms[i];
// Chack for different saved game mode
if (deathmatch.value != pr_global_struct->deathmatch ||
coop.value != pr_global_struct->coop ||
teamplay.value != pr_global_struct->teamplay)
{
Con_Printf ("\002Host_Loadgame_f: ");
Con_Printf ("saved game mode different (dm=%g/%g, coop=%g/%g, team=%g/%g)\n",
deathmatch.value, pr_global_struct->deathmatch, coop.value, pr_global_struct->coop, teamplay.value, pr_global_struct->teamplay);
}
if (cls.state != ca_dedicated)
{
CL_EstablishConnection ("local");
Host_Reconnect_f ();
}
}
/*
===============
Host_Savegame_f
===============
*/
void Host_Savegame_f (void)
{
char name[256];
FILE *f;
int i;
char comment[SAVEGAME_COMMENT_LENGTH+1];
if (cmd_source != src_command)
return;
if (!sv.active)
{
Con_Printf ("Not playing a local game.\n");
return;
}
if (cl.intermission)
{
Con_Printf ("Can't save in intermission.\n");
return;
}
if (svs.maxclients != 1)
{
Con_Printf ("Can't save multiplayer games.\n");
return;
}
if (Cmd_Argc() != 2)
{
Con_Printf ("save <savename> : save a game\n");
return;
}
if (strstr(Cmd_Argv(1), ".."))
{
Con_Printf ("Relative pathnames are not allowed.\n");
return;
}
for (i=0 ; i<svs.maxclients ; i++)
{
if (svs.clients[i].active && (svs.clients[i].edict->v.health <= 0) )
{
Con_Printf ("Can't savegame with a dead player\n");
return;
}
}
sprintf (name, "%s/%s", com_gamedir, Cmd_Argv(1));
COM_DefaultExtension (name, ".sav");
Con_SafePrintf ("Saving game to %s...\n", name);
f = fopen (name, "w");
if (!f)
{
Con_Printf ("ERROR: couldn't open.\n");
return;
}
fprintf (f, "%i\n", SAVEGAME_VERSION);
Host_SavegameComment (comment);
fprintf (f, "%s\n", comment);
for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
fprintf (f, "%f\n", svs.clients->spawn_parms[i]);
fprintf (f, "%d\n", current_skill);
fprintf (f, "%s\n", sv.name);
fprintf (f, "%f\n",sv.time);
// write the light styles
for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
{
if (sv.lightstyles[i])
fprintf (f, "%s\n", sv.lightstyles[i]);
else
fprintf (f,"m\n");
}
ED_WriteGlobals (f);
for (i=0 ; i<sv.num_edicts ; i++)
{
ED_Write (f, EDICT_NUM("Host_Savegame_f", i));
fflush (f);
}
fclose (f);
Con_SafePrintf ("done.\n");
}
/*
===================
VID_Init
===================
*/
void VID_Init (unsigned char *palette)
{
int width, height, i, temp;
SDL_Rect **enumlist;
const char *read_vars[] = {
"vid_config_fscr",
"vid_config_swx",
"vid_config_swy" };
#define num_readvars ( sizeof(read_vars)/sizeof(read_vars[0]) )
temp = scr_disabled_for_loading;
scr_disabled_for_loading = true;
Cvar_RegisterVariable (&vid_config_fscr);
Cvar_RegisterVariable (&vid_config_swy);
Cvar_RegisterVariable (&vid_config_swx);
Cvar_RegisterVariable (&vid_config_gly);
Cvar_RegisterVariable (&vid_config_glx);
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&_enable_mouse);
Cvar_RegisterVariable (&vid_showload);
Cmd_AddCommand ("vid_showinfo", VID_ShowInfo_f);
Cmd_AddCommand ("vid_listmodes", VID_ListModes_f);
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
Cmd_AddCommand ("vid_restart", VID_Restart_f);
// init sdl
// the first check is actually unnecessary
if ( (SDL_WasInit(SDL_INIT_VIDEO)) == 0 )
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
Sys_Error("VID: Couldn't load SDL: %s", SDL_GetError());
}
// this will contain the "best bpp" for the current display
// make sure to re-retrieve it if you ever re-init sdl_video
vid_info = SDL_GetVideoInfo();
// retrieve the list of fullscreen modes
enumlist = SDL_ListModes(NULL, SDL_SWSURFACE|SDL_HWPALETTE|SDL_FULLSCREEN);
// prepare the modelists, find the actual modenum for vid_default
VID_PrepareModes(enumlist);
// set vid_mode to our safe default first
Cvar_SetValue ("vid_mode", vid_default);
// perform an early read of config.cfg
CFG_ReadCvars (read_vars, num_readvars);
// windowed mode is default
// see if the user wants fullscreen
if (COM_CheckParm("-fullscreen") || COM_CheckParm("-f"))
{
Cvar_SetValue("vid_config_fscr", 1);
}
else if (COM_CheckParm("-window") || COM_CheckParm("-w"))
{
Cvar_SetValue("vid_config_fscr", 0);
}
if (vid_config_fscr.integer && !num_fmodes) // FIXME: see below, as well
Sys_Error ("No fullscreen modes available at this color depth");
width = vid_config_swx.integer;
height = vid_config_swy.integer;
// user is always right ...
i = COM_CheckParm("-width");
if (i && i < com_argc-1)
{ // FIXME: this part doesn't know about a disaster case
// like we aren't reported any fullscreen modes.
width = atoi(com_argv[i+1]);
i = COM_CheckParm("-height");
if (i && i < com_argc-1)
height = atoi(com_argv[i+1]);
else // proceed with 4/3 ratio
height = 3 * width / 4;
}
// user requested a mode either from the config or from the
// command line
// scan existing modes to see if this is already available
// if not, add this as the last "valid" video mode and set
// vid_mode to it only if it doesn't go beyond vid_maxwidth
i = 0;
while (i < *nummodes)
{
if (modelist[i].width == width && modelist[i].height == height)
break;
i++;
}
if (i < *nummodes)
{
Cvar_SetValue ("vid_mode", i);
}
else if ( (width <= vid_maxwidth && width >= MIN_WIDTH &&
height <= vid_maxheight && height >= MIN_HEIGHT) ||
COM_CheckParm("-force") )
{
modelist[*nummodes].width = width;
modelist[*nummodes].height = height;
modelist[*nummodes].halfscreen = 0;
modelist[*nummodes].fullscreen = 1;
modelist[*nummodes].bpp = 8;
q_snprintf (modelist[*nummodes].modedesc, MAX_DESC, "%d x %d (user mode)", width, height);
Cvar_SetValue ("vid_mode", *nummodes);
(*nummodes)++;
}
else
{
Con_SafePrintf ("ignoring invalid -width and/or -height arguments\n");
}
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.colormap = host_colormap;
vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
i = VID_SetMode(vid_mode.integer, palette);
if ( !i )
{
if (vid_mode.integer == vid_default)
Sys_Error ("Couldn't set video mode: %s", SDL_GetError());
// just one more try before dying
Con_SafePrintf ("Couldn't set video mode %d\n"
"Trying the default mode\n", vid_mode.integer);
//Cvar_SetValue("vid_config_fscr", 0);
Cvar_SetValue ("vid_mode", vid_default);
i = VID_SetMode(vid_default, palette);
if ( !i )
Sys_Error ("Couldn't set video mode: %s", SDL_GetError());
}
// lock the early-read cvars until Host_Init is finished
for (i = 0; i < (int)num_readvars; i++)
Cvar_LockVar (read_vars[i]);
scr_disabled_for_loading = temp;
vid_initialized = true;
vid_menudrawfn = VID_MenuDraw;
vid_menukeyfn = VID_MenuKey;
}
int SNDDMA_Init(void)
{
sndinitstat stat;
if (COM_CheckParm ("-wavonly"))
wavonly = true;
dsound_init = wav_init = 0;
stat = SIS_FAILURE; // assume DirectSound won't initialize
/* Init DirectSound */
if (!wavonly)
{
if (snd_firsttime || snd_isdirect)
{
stat = SNDDMA_InitDirect ();;
if (stat == SIS_SUCCESS)
{
snd_isdirect = true;
if (snd_firsttime)
Con_SafePrintf ("DirectSound initialized\n");
}
else
{
snd_isdirect = false;
Con_SafePrintf ("DirectSound failed to init\n");
}
}
}
// if DirectSound didn't succeed in initializing, try to initialize
// waveOut sound, unless DirectSound failed because the hardware is
// already allocated (in which case the user has already chosen not
// to have sound)
if (!dsound_init && (stat != SIS_NOTAVAIL))
{
if (snd_firsttime || snd_iswave)
{
snd_iswave = SNDDMA_InitWav ();
if (snd_iswave)
{
if (snd_firsttime)
Con_SafePrintf ("Wave sound initialized\n");
}
else
{
Con_SafePrintf ("Wave sound failed to init\n");
}
}
}
snd_firsttime = false;
if (!dsound_init && !wav_init)
{
if (snd_firsttime)
Con_SafePrintf ("No sound device initialized\n");
return 0;
}
return 1;
}
/*
==================
SNDDMA_InitDirect
Direct-Sound support
==================
*/
sndinitstat SNDDMA_InitDirect (void)
{
DSBUFFERDESC dsbuf;
DSBCAPS dsbcaps;
DWORD dwSize, dwWrite;
DSCAPS dscaps;
WAVEFORMATEX format, pformat;
HRESULT hresult;
int reps;
memset ((void *)&sn, 0, sizeof (sn));
shm = &sn;
shm->channels = 2;
shm->samplebits = 16;
shm->speed = 11025;
memset (&format, 0, sizeof(format));
format.wFormatTag = WAVE_FORMAT_PCM;
format.nChannels = shm->channels;
format.wBitsPerSample = shm->samplebits;
format.nSamplesPerSec = shm->speed;
format.nBlockAlign = format.nChannels
*format.wBitsPerSample / 8;
format.cbSize = 0;
format.nAvgBytesPerSec = format.nSamplesPerSec
*format.nBlockAlign;
if (!hInstDS)
{
hInstDS = LoadLibrary("dsound.dll");
if (hInstDS == NULL)
{
Con_SafePrintf ("Couldn't load dsound.dll\n");
return SIS_FAILURE;
}
pDirectSoundCreate = (void *)GetProcAddress(hInstDS,"DirectSoundCreate");
if (!pDirectSoundCreate)
{
Con_SafePrintf ("Couldn't get DS proc addr\n");
return SIS_FAILURE;
}
}
while ((hresult = iDirectSoundCreate(NULL, &pDS, NULL)) != DS_OK)
{
if (hresult != DSERR_ALLOCATED)
{
Con_SafePrintf ("DirectSound create failed\n");
return SIS_FAILURE;
}
if (MessageBox (NULL,
"The sound hardware is in use by another app.\n\n"
"Select Retry to try to start sound again or Cancel to run Quake with no sound.",
"Sound not available",
MB_RETRYCANCEL | MB_SETFOREGROUND | MB_ICONEXCLAMATION) != IDRETRY)
{
Con_SafePrintf ("DirectSoundCreate failure\n"
" hardware already in use\n");
return SIS_NOTAVAIL;
}
}
dscaps.dwSize = sizeof(dscaps);
if (DS_OK != pDS->lpVtbl->GetCaps (pDS, &dscaps))
{
Con_SafePrintf ("Couldn't get DS caps\n");
}
if (dscaps.dwFlags & DSCAPS_EMULDRIVER)
{
Con_SafePrintf ("No DirectSound driver installed\n");
FreeSound ();
return SIS_FAILURE;
}
if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_EXCLUSIVE))
{
Con_SafePrintf ("Set coop level failed\n");
FreeSound ();
return SIS_FAILURE;
}
// get access to the primary buffer, if possible, so we can set the
// sound hardware format
memset (&dsbuf, 0, sizeof(dsbuf));
dsbuf.dwSize = sizeof(DSBUFFERDESC);
dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER;
dsbuf.dwBufferBytes = 0;
dsbuf.lpwfxFormat = NULL;
memset(&dsbcaps, 0, sizeof(dsbcaps));
dsbcaps.dwSize = sizeof(dsbcaps);
primary_format_set = false;
if (!COM_CheckParm ("-snoforceformat"))
{
if (DS_OK == pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSPBuf, NULL))
{
pformat = format;
if (DS_OK != pDSPBuf->lpVtbl->SetFormat (pDSPBuf, &pformat))
{
if (snd_firsttime)
Con_SafePrintf ("Set primary sound buffer format: no\n");
}
else
{
if (snd_firsttime)
Con_SafePrintf ("Set primary sound buffer format: yes\n");
primary_format_set = true;
}
}
}
if (!primary_format_set || !COM_CheckParm ("-primarysound"))
{
// create the secondary buffer we'll actually work with
memset (&dsbuf, 0, sizeof(dsbuf));
dsbuf.dwSize = sizeof(DSBUFFERDESC);
dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY | DSBCAPS_LOCSOFTWARE;
dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE;
dsbuf.lpwfxFormat = &format;
memset(&dsbcaps, 0, sizeof(dsbcaps));
dsbcaps.dwSize = sizeof(dsbcaps);
if (DS_OK != pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSBuf, NULL))
{
Con_SafePrintf ("DS:CreateSoundBuffer Failed");
FreeSound ();
return SIS_FAILURE;
}
shm->channels = format.nChannels;
shm->samplebits = format.wBitsPerSample;
shm->speed = format.nSamplesPerSec;
if (DS_OK != pDSBuf->lpVtbl->GetCaps (pDSBuf, &dsbcaps))
{
Con_SafePrintf ("DS:GetCaps failed\n");
FreeSound ();
return SIS_FAILURE;
}
if (snd_firsttime)
Con_SafePrintf ("Using secondary sound buffer\n");
}
else
{
if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_WRITEPRIMARY))
{
Con_SafePrintf ("Set coop level failed\n");
FreeSound ();
return SIS_FAILURE;
}
if (DS_OK != pDSPBuf->lpVtbl->GetCaps (pDSPBuf, &dsbcaps))
{
Con_Printf ("DS:GetCaps failed\n");
return SIS_FAILURE;
}
pDSBuf = pDSPBuf;
Con_SafePrintf ("Using primary sound buffer\n");
}
// Make sure mixer is active
pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
if (snd_firsttime)
Con_SafePrintf(" %d channel(s)\n"
" %d bits/sample\n"
" %d bytes/sec\n",
shm->channels, shm->samplebits, shm->speed);
gSndBufSize = dsbcaps.dwBufferBytes;
// initialize the buffer
reps = 0;
while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, &lpData, &dwSize, NULL, NULL, 0)) != DS_OK)
{
if (hresult != DSERR_BUFFERLOST)
{
Con_SafePrintf ("SNDDMA_InitDirect: DS::Lock Sound Buffer Failed\n");
FreeSound ();
return SIS_FAILURE;
}
if (++reps > 10000)
{
Con_SafePrintf ("SNDDMA_InitDirect: DS: couldn't restore buffer\n");
FreeSound ();
return SIS_FAILURE;
}
}
memset(lpData, 0, dwSize);
// lpData[4] = lpData[5] = 0x7f; // force a pop for debugging
pDSBuf->lpVtbl->Unlock(pDSBuf, lpData, dwSize, NULL, 0);
/* we don't want anyone to access the buffer directly w/o locking it first. */
lpData = NULL;
pDSBuf->lpVtbl->Stop(pDSBuf);
pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &mmstarttime.u.sample, &dwWrite);
pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
shm->soundalive = true;
shm->splitbuffer = false;
shm->samples = gSndBufSize/(shm->samplebits/8);
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = (unsigned char *) lpData;
sample16 = (shm->samplebits/8) - 1;
dsound_init = true;
return SIS_SUCCESS;
}
int
WINS_Init(void)
{
int i;
int err;
char buff[MAXHOSTNAMELEN];
char *colon;
struct hostent *local;
struct qsockaddr addr;
if (COM_CheckParm("-noudp"))
return -1;
if (!winsock_initialized) {
err = WSAStartup(MAKEWORD(1,1), &winsockdata);
if (err) {
Con_SafePrintf("Winsock initialization failed.\n");
return -1;
}
}
winsock_initialized++;
/* determine my name & address */
myAddr.s_addr = htonl(INADDR_LOOPBACK);
err = gethostname(buff, MAXHOSTNAMELEN);
if (err) {
Con_Printf("%s: WARNING: gethostname failed.\n", __func__);
} else {
buff[MAXHOSTNAMELEN - 1] = 0;
blocktime = Sys_DoubleTime();
WSASetBlockingHook(BlockingHook);
local = gethostbyname(buff);
WSAUnhookBlockingHook();
if (!local) {
Con_Printf("%s: WARNING: gethostbyname timed out.\n", __func__);
} else if (local->h_addrtype != AF_INET) {
Con_Printf("%s: address from gethostbyname not IPv4\n", __func__);
} else {
myAddr = *(struct in_addr *)local->h_addr_list[0];
}
}
Con_Printf ("UDP, Local address: %s\n", inet_ntoa(myAddr));
i = COM_CheckParm("-ip");
if (i && i < com_argc - 1) {
bindAddr.s_addr = inet_addr(com_argv[i + 1]);
if (bindAddr.s_addr == INADDR_NONE)
Sys_Error("%s: %s is not a valid IP address", __func__,
com_argv[i + 1]);
Con_Printf("Binding to IP Interface Address of %s\n", com_argv[i + 1]);
} else {
bindAddr.s_addr = INADDR_NONE;
}
i = COM_CheckParm("-localip");
if (i && i < com_argc - 1) {
localAddr.s_addr = inet_addr(com_argv[i + 1]);
if (localAddr.s_addr == INADDR_NONE)
Sys_Error("%s: %s is not a valid IP address", __func__,
com_argv[i + 1]);
Con_Printf("Advertising %s as the local IP in response packets\n",
com_argv[i + 1]);
} else {
localAddr.s_addr = INADDR_NONE;
}
net_controlsocket = WINS_OpenSocket(0);
if (net_controlsocket == -1) {
Con_Printf("%s: Unable to open control socket\n", __func__);
if (--winsock_initialized == 0)
WSACleanup();
return -1;
}
broadcastaddr.sin_family = AF_INET;
broadcastaddr.sin_addr.s_addr = INADDR_BROADCAST;
broadcastaddr.sin_port = htons((unsigned short)net_hostport);
WINS_GetSocketAddr(net_controlsocket, &addr);
strcpy(my_tcpip_address, WINS_AddrToString(&addr));
colon = strrchr(my_tcpip_address, ':');
if (colon)
*colon = 0;
Con_Printf("Winsock TCP/IP Initialized (%s)\n", my_tcpip_address);
tcpipAvailable = true;
return net_controlsocket;
}