- Bump PORTREVISION.

- Remove FreeBSD 4.x support (USE_GCC=3.4+).
- Fix various sound problems, including crashes [1].

Obtained from:	games/q2p [1]

4 files changed, 2166 insertions, 8 deletions

diff --git a/games/qudos/Makefile b/games/qudos/Makefile
index 914dc83897d1..737490515a01 100644
--- a/games/qudos/Makefile
+++ b/games/qudos/Makefile
@@ -7,7 +7,7 @@
 
 PORTNAME=	qudos
 PORTVERSION=	0.40.1
-PORTREVISION=	5
+PORTREVISION=	6
 CATEGORIES=	games
 MASTER_SITES=	http://qudos.quakedev.com/linux/quake2/engines/QuDos/
 DISTNAME=	QuDos-${PORTVERSION}-src
@@ -19,7 +19,6 @@ MAINTAINER=	alepulver@FreeBSD.org
 COMMENT=	Enhaced OpenGL only Quake II engine
 
 USE_BZIP2=	yes
-USE_GCC=	3.4+
 USE_GMAKE=	yes
 
 OPTIONS=	3ZB2 "Build 3zb2 modification (bots)" on \
diff --git a/games/qudos/files/patch-src__client__snd_dma.c b/games/qudos/files/patch-src__client__snd_dma.c
index 339524ec38ae..98c604886a2e 100644
--- a/games/qudos/files/patch-src__client__snd_dma.c
+++ b/games/qudos/files/patch-src__client__snd_dma.c
@@ -1,11 +1,1790 @@
---- ./src/client/snd_dma.c.orig	Fri Jun  9 16:42:59 2006
-+++ ./src/client/snd_dma.c	Sun Jun 11 15:08:02 2006
-@@ -149,7 +149,7 @@
- 		    snddriver = Cvar_Get("snd_driver", "oss", CVAR_ARCHIVE);
+--- src/client/snd_dma.c.orig	Fri Jun  9 16:42:59 2006
++++ src/client/snd_dma.c	Thu Sep 13 20:17:11 2007
+@@ -1,27 +1,23 @@
+ /*
+- * Copyright (C) 1997-2001 Id Software, Inc.
+- *
+- * 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.
+- *
+- */
+-/* snd_dma.c -- main control for any streaming sound output device */
++Copyright (C) 1997-2001 Id Software, Inc.
+ 
+-#include "client.h"
+-#include "snd_loc.h"
+-#include "snd_ogg.h"
++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.
++
++*/
++// snd_dma.c -- main control for any streaming sound output device
+ 
+ #if defined (__unix__)
+ #include <sys/types.h>
+@@ -31,26 +27,30 @@
+ #include <dlfcn.h>
+ #endif
+ 
+-void		S_Play    (void);
+-void		S_SoundList(void);
+-void		S_Update_ ();
+-void		S_StopAllSounds(void);
++#include "client.h"
++#include "snd_loc.h"
++#include "snd_ogg.h"
+ 
+-/* ======================================================================= */
+-/* Internal sound data & structures */
+-/* ======================================================================= */
++void S_Play(void);
++void S_SoundList(void);
++void S_Update_(void);
+ 
+-/* only begin attenuating sound volumes when outside the FULLVOLUME range */
++
++// =======================================================================
++// Internal sound data & structures
++// =======================================================================
++
++// only begin attenuating sound volumes when outside the FULLVOLUME range
+ #define		SOUND_FULLVOLUME	80
+ 
+ #define		SOUND_LOOPATTENUATE	0.003
+ 
+ int		s_registration_sequence;
+ 
+-channel_t	channels[MAX_CHANNELS];
++channel_t   channels[MAX_CHANNELS];
+ 
+ qboolean	snd_initialized = false;
+-int		sound_started = 0;
++int		sound_started=0;
+ 
+ dma_t		dma;
+ 
+@@ -61,13 +61,13 @@
+ 
+ qboolean	s_registering;
+ 
+-int		soundtime;	/* sample PAIRS */
+-int		paintedtime;	/* sample PAIRS */
++int		soundtime;	// sample PAIRS
++int   		paintedtime; 	// sample PAIRS
+ 
+-/* during registration it is possible to have more sounds */
+-/* than could actually be referenced during gameplay, */
+-/* because we don't want to free anything until we are */
+-/* sure we won't need it. */
++// during registration it is possible to have more sounds
++// than could actually be referenced during gameplay,
++// because we don't want to free anything until we are
++// sure we won't need it.
+ #define		MAX_SFX		(MAX_SOUNDS*2)
+ sfx_t		known_sfx[MAX_SFX];
+ int		num_sfx;
+@@ -79,37 +79,49 @@
+ 
+ int		s_beginofs;
+ 
+-cvar_t         *s_volume;
+-cvar_t         *s_testsound;
+-cvar_t         *s_loadas8bit;
+-cvar_t         *s_khz;
+-cvar_t         *s_show;
+-cvar_t         *s_mixahead;
++cvar_t		*s_volume;
++cvar_t		*s_testsound;
++cvar_t		*s_loadas8bit;
++cvar_t		*s_khz;
++cvar_t		*s_show;
++cvar_t		*s_mixahead;
++#ifdef _WIN32
++cvar_t		*s_primary;
++#endif
++#if defined (__unix__)
++cvar_t          *snddriver;
++#endif
++
+ 
+ int		s_rawend;
+-portable_samplepair_t s_rawsamples[MAX_RAW_SAMPLES];
++portable_samplepair_t	s_rawsamples[MAX_RAW_SAMPLES];
+ 
+-cvar_t		*snddriver;
+-static void 	*snddriver_library = NULL;
+-qboolean 	snddriver_active = 0;
++#if defined (__unix__)
++static void * snddriver_library = NULL;
++qboolean snddriver_active = 0;
++
++/* dlsymbols */
+ qboolean (*SNDDMA_Init)(struct sndinfo *);
+ int (*SNDDMA_GetDMAPos)(void);
+ void (*SNDDMA_Shutdown)(void);
+ void (*SNDDMA_BeginPainting)(void);
+ void (*SNDDMA_Submit)(void);
++
+ struct sndinfo si;
++#endif
+ 
+-/* ==================================================================== */
+-/* User-setable variables */
+-/* ==================================================================== */
++// ====================================================================
++// User-setable variables
++// ====================================================================
+ 
+-void
+-S_SoundInfo_f(void)
++
++void S_SoundInfo_f(void)
+ {
+ 	if (!sound_started) {
+-		Com_Printf("Sound system not started\n");
++		Com_Printf ("Sound system not started\n");
+ 		return;
+ 	}
++	
+ 	Com_Printf("Stereo: %d\n", dma.channels - 1);
+ 	Com_Printf("Samples: %d\n", dma.samples);
+ 	Com_Printf("Samplepos: %d\n", dma.samplepos);
+@@ -121,35 +133,48 @@
+ 
+ 
+ /*
+- * ================ S_Init ================
+- */
+-void
+-S_Init(void)
++================
++S_Init
++================
++*/
++void S_Init (void)
+ {
+-	cvar_t         *cv;
++	cvar_t	*cv;
+ 
+-	Com_Printf("\n======== Sound Initialization ========\n");
++	Com_Printf("\x02""\n^3Sound Status^r\n");
+ 
+-	cv = Cvar_Get("s_initsound", "1", 0);
++	cv = Cvar_Get ("s_initsound", "1", 0);
+ 	if (!cv->value)
+-		Com_Printf("not initializing.\n");
++		Com_Printf ("Not initializing.\n");
+ 	else {
+-		s_volume = Cvar_Get("s_volume", "0.7", CVAR_ARCHIVE);
+-		s_khz = Cvar_Get("s_khz", "44", CVAR_ARCHIVE);
+-		s_loadas8bit = Cvar_Get("s_loadas8bit", "0", 0);
+-		s_mixahead = Cvar_Get("s_mixahead", "0.2", CVAR_ARCHIVE);
+-		s_show = Cvar_Get("s_show", "0", 0);
+-		s_testsound = Cvar_Get("s_testsound", "0", 0);
++		s_volume = Cvar_Get ("s_volume", "0.7", CVAR_ARCHIVE);
++		s_khz = Cvar_Get ("s_khz", "44", CVAR_ARCHIVE);
++		s_loadas8bit = Cvar_Get ("s_loadas8bit", "0", 0);
++		s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE);
++		s_show = Cvar_Get ("s_show", "0", 0);
++		s_testsound = Cvar_Get ("s_testsound", "0", 0);
++#ifdef _WIN32
++		s_primary = Cvar_Get ("s_primary", "0", CVAR_ARCHIVE);	// win32 specific
++		
++		if (!SNDDMA_Init())
++			return;
++#endif
++
++#if defined (__unix__)
+ 
+ 		{
+ 		    char fn[MAX_OSPATH];
+ 		    struct stat st;
+ 
+ 		    /* load sound driver */
+-		    snddriver = Cvar_Get("snd_driver", "oss", CVAR_ARCHIVE);
++		    snddriver = Cvar_Get("snd_ref", "oss", CVAR_ARCHIVE);
  
  		    /* Com_Printf("Loading %s sound output driver", snddriver->string); */
--		    snprintf(fn, MAX_OSPATH, "./snd_%s.so", snddriver->string);
-+		    snprintf(fn, MAX_OSPATH, LIBDIR "/snd_%s.so", snddriver->string);
++#ifdef LIBDIR
++		    snprintf(fn, MAX_OSPATH, LIBDIR"/snd_%s.so", snddriver->string);
++#else	 
+ 		    snprintf(fn, MAX_OSPATH, "./snd_%s.so", snddriver->string);
++#endif
  		    if (stat(fn, &st) == -1) {
  		    	Com_Printf("\nload %s failed: %s\n", fn, strerror(errno));
  			return;
+@@ -183,13 +208,14 @@
+ 		si.sndspeed = Cvar_Get("sndspeed", "0", CVAR_ARCHIVE);
+ 		si.sndchannels = Cvar_Get("sndchannels", "2", CVAR_ARCHIVE);
+ 		si.snddevice = Cvar_Get("snddevice", "/dev/dsp", CVAR_ARCHIVE);
+-		si.s_khz = Cvar_Get("s_khz", "0", CVAR_ARCHIVE);
++		si.s_khz = Cvar_Get("s_khz", "44", CVAR_ARCHIVE);
+ 		si.Com_Printf = Com_Printf;
+ 		si.S_PaintChannels = S_PaintChannels;
+ 		
+ 		if (!SNDDMA_Init(&si))
+ 			return;
+-			
++#endif
++		
+ 		Cmd_AddCommand("play", S_Play);
+ 		Cmd_AddCommand("stopsound", S_StopAllSounds);
+ 		Cmd_AddCommand("soundlist", S_SoundList);
+@@ -197,7 +223,7 @@
+ 		Cmd_AddCommand("ogg_init", OGG_Init);
+ 		Cmd_AddCommand("ogg_shutdown", OGG_Shutdown);
+ 
+-		S_InitScaletable();
++		S_InitScaletable ();
+ 
+ 		sound_started = 1;
+ 		num_sfx = 0;
+@@ -205,151 +231,150 @@
+ 		soundtime = 0;
+ 		paintedtime = 0;
+ 
+-		Com_Printf("Sound sampling rate: %i\n", dma.speed);
++		Com_Printf ("Sound sampling rate: %i\n", dma.speed);
+ 		
+ 		S_SoundInfo_f();
+ 
+-		S_StopAllSounds();
+-
++		S_StopAllSounds ();
++		
+ 		OGG_Init();
+ 	}
+-	
+-	Com_Printf("\n");
+ }
+ 
+ 
+-/* ======================================================================= */
+-/* Shutdown sound engine */
+-/* ======================================================================= */
++// =======================================================================
++// Shutdown sound engine
++// =======================================================================
+ 
+-void
+-S_Shutdown(void)
++void S_Shutdown(void)
+ {
+ 	int		i;
+-	sfx_t          *sfx;
++	sfx_t	*sfx;
+ 
+ 	if (!sound_started)
+ 		return;
+-
++	
+ 	OGG_Shutdown();
+-
+-	Cmd_RemoveCommand("ogg_init");
+-	Cmd_RemoveCommand("ogg_shutdown");
+ 	
+ 	SNDDMA_Shutdown();
+-
++	
+ 	sound_started = 0;
+ 
+ 	Cmd_RemoveCommand("play");
+ 	Cmd_RemoveCommand("stopsound");
+ 	Cmd_RemoveCommand("soundlist");
+ 	Cmd_RemoveCommand("soundinfo");
++	Cmd_RemoveCommand("ogg_init");
++	Cmd_RemoveCommand("ogg_shutdown");
+ 
+-	/* free all sounds */
+-	for (i = 0, sfx = known_sfx; i < num_sfx; i++, sfx++) {
++	// free all sounds
++	for (i=0, sfx=known_sfx ; i < num_sfx ; i++,sfx++) {
+ 		if (!sfx->name[0])
+ 			continue;
+ 		if (sfx->cache)
+-			Z_Free(sfx->cache);
+-		memset(sfx, 0, sizeof(*sfx));
++			Z_Free (sfx->cache);
++		memset (sfx, 0, sizeof(*sfx));
+ 	}
+ 
+ 	num_sfx = 0;
+-	
++#if defined (__unix__)
+ 	if (snddriver_library) {
+-	    SNDDMA_Init = NULL;
+-	    SNDDMA_Shutdown = NULL;
+-	    SNDDMA_Submit = NULL;
+-	    SNDDMA_GetDMAPos = NULL;
+-	    SNDDMA_BeginPainting = NULL;
+-	    dlclose(snddriver_library);
+-	    memset(&si, 0, sizeof(struct sndinfo));
+-	    snddriver_library = NULL;
+-	    snddriver_active = false;
+-	    memset(&dma, 0, sizeof(dma_t));
++		SNDDMA_Init = NULL;
++		SNDDMA_Shutdown = NULL;
++		SNDDMA_Submit = NULL;
++		SNDDMA_GetDMAPos = NULL;
++		SNDDMA_BeginPainting = NULL;
++		dlclose(snddriver_library);
++		memset(&si, 0, sizeof(struct sndinfo));
++		snddriver_library = NULL;
++		snddriver_active = false;
++		memset(&dma, 0, sizeof(dma_t));
+ 	}
+-	
++#endif
+ }
+ 
+ 
+-/* ======================================================================= */
+-/* Load a sound */
+-/* ======================================================================= */
++// =======================================================================
++// Load a sound
++// =======================================================================
+ 
+ /*
+- * ================== S_FindName
+- *
+- * ==================
+- */
+-sfx_t          *
+-S_FindName(char *name, qboolean create)
++==================
++S_FindName
++
++==================
++*/
++sfx_t *S_FindName (char *name, qboolean create)
+ {
+-	int		i;
+-	sfx_t          *sfx;
++	int	i;
++	sfx_t	*sfx;
+ 
+ 	if (!name)
+-		Com_Error(ERR_FATAL, "S_FindName: NULL\n");
++		Com_Error (ERR_FATAL, "S_FindName: NULL\n");
+ 	if (!name[0])
+-		Com_Error(ERR_FATAL, "S_FindName: empty name\n");
++		Com_Error (ERR_FATAL, "S_FindName: empty name\n");
+ 
+ 	if (strlen(name) >= MAX_QPATH)
+-		Com_Error(ERR_FATAL, "Sound name too long: %s", name);
++		Com_Error (ERR_FATAL, "Sound name too long: %s", name);
+ 
+-	/* see if already loaded */
+-	for (i = 0; i < num_sfx; i++)
++	// see if already loaded
++	for (i=0 ; i < num_sfx ; i++)
+ 		if (!strcmp(known_sfx[i].name, name)) {
+ 			return &known_sfx[i];
+ 		}
++
+ 	if (!create)
+ 		return NULL;
+ 
+-	/* find a free sfx */
+-	for (i = 0; i < num_sfx; i++)
++	// find a free sfx
++	for (i=0 ; i < num_sfx ; i++)
+ 		if (!known_sfx[i].name[0])
+-			/* registration_sequence < s_registration_sequence) */
+ 			break;
+ 
+ 	if (i == num_sfx) {
+ 		if (num_sfx == MAX_SFX)
+-			Com_Error(ERR_FATAL, "S_FindName: out of sfx_t");
++			Com_Error (ERR_FATAL, "S_FindName: out of sfx_t");
+ 		num_sfx++;
+ 	}
++	
+ 	sfx = &known_sfx[i];
+-	memset(sfx, 0, sizeof(*sfx));
+-	Q_strncpyz(sfx->name, name, sizeof(sfx->name));
++	memset (sfx, 0, sizeof(*sfx));
++	strcpy (sfx->name, name);
+ 	sfx->registration_sequence = s_registration_sequence;
+-
++	
+ 	return sfx;
+ }
+ 
+ 
+ /*
+- * ==================
+- * S_AliasName
+- * ==================
+- */
+-sfx_t *
+-S_AliasName(char *aliasname, char *truename)
++==================
++S_AliasName
++
++==================
++*/
++sfx_t *S_AliasName (char *aliasname, char *truename)
+ {
+-	sfx_t          *sfx;
+-	char           *s;
+-	int		i;
++	sfx_t	*sfx;
++	char	*s;
++	int	i;
+ 
+-	s = Z_Malloc(MAX_QPATH);
+-	Q_strncpyz(s, truename, MAX_QPATH);
++	s = Z_Malloc (MAX_QPATH);
++	strcpy (s, truename);
+ 
+-	/* find a free sfx */
+-	for (i = 0; i < num_sfx; i++)
++	// find a free sfx
++	for (i=0 ; i < num_sfx ; i++)
+ 		if (!known_sfx[i].name[0])
+ 			break;
+ 
+ 	if (i == num_sfx) {
+ 		if (num_sfx == MAX_SFX)
+-			Com_Error(ERR_FATAL, "S_FindName: out of sfx_t");
++			Com_Error (ERR_FATAL, "S_FindName: out of sfx_t");
+ 		num_sfx++;
+ 	}
++	
+ 	sfx = &known_sfx[i];
+-	Q_strncpyz(sfx->name, aliasname, sizeof(sfx->name));
++	memset (sfx, 0, sizeof(*sfx));
++	strcpy (sfx->name, aliasname);
+ 	sfx->registration_sequence = s_registration_sequence;
+ 	sfx->truename = s;
+ 
+@@ -358,113 +383,112 @@
+ 
+ 
+ /*
+- * ===================== S_BeginRegistration
+- *
+- * =====================
+- */
+-void
+-S_BeginRegistration(void)
++=====================
++S_BeginRegistration
++
++=====================
++*/
++void S_BeginRegistration (void)
+ {
+ 	s_registration_sequence++;
+ 	s_registering = true;
+ }
+ 
+ /*
+- * ================== S_RegisterSound
+- *
+- * ==================
+- */
+-sfx_t          *
+-S_RegisterSound(char *name)
++==================
++S_RegisterSound
++
++==================
++*/
++sfx_t *S_RegisterSound (char *name)
+ {
+-	sfx_t          *sfx;
++	sfx_t	*sfx;
+ 
+ 	if (!sound_started)
+ 		return NULL;
+ 
+-	sfx = S_FindName(name, true);
++	sfx = S_FindName (name, true);
+ 	sfx->registration_sequence = s_registration_sequence;
+ 
+ 	if (!s_registering)
+-		S_LoadSound(sfx);
++		S_LoadSound (sfx);
+ 
+ 	return sfx;
+ }
+ 
+ 
+ /*
+- * ===================== S_EndRegistration
+- *
+- * =====================
+- */
+-void
+-S_EndRegistration(void)
++=====================
++S_EndRegistration
++
++=====================
++*/
++void S_EndRegistration (void)
+ {
+ 	int		i;
+-	sfx_t          *sfx;
++	sfx_t	*sfx;
+ 	int		size;
+ 
+-	/* free any sounds not from this registration sequence */
+-	for (i = 0, sfx = known_sfx; i < num_sfx; i++, sfx++) {
++	// free any sounds not from this registration sequence
++	for (i=0, sfx=known_sfx ; i < num_sfx ; i++,sfx++) {
+ 		if (!sfx->name[0])
+ 			continue;
+-		if (sfx->registration_sequence != s_registration_sequence) {	/* don't need this sound */
+-			if (sfx->cache)	/* it is possible to have a leftover */
+-				Z_Free(sfx->cache);	/* from a server that
+-							 * didn't finish loading */
+-			memset(sfx, 0, sizeof(*sfx));
+-		} else {	/* make sure it is paged in */
++		if (sfx->registration_sequence != s_registration_sequence) { // don't need this sound
++			if (sfx->cache)	// it is possible to have a leftover
++				Z_Free (sfx->cache);	// from a server that didn't finish loading
++			memset (sfx, 0, sizeof(*sfx));
++		}
++		else { // make sure it is paged in
+ 			if (sfx->cache) {
+-				size = sfx->cache->length * sfx->cache->width;
+-				Com_PageInMemory((byte *) sfx->cache, size);
++				size = sfx->cache->length*sfx->cache->width;
++				Com_PageInMemory ((byte *)sfx->cache, size);
+ 			}
+ 		}
+ 
+ 	}
+ 
+-	/* load everything in */
+-	for (i = 0, sfx = known_sfx; i < num_sfx; i++, sfx++) {
++	// load everything in
++	for (i=0, sfx=known_sfx ; i < num_sfx ; i++,sfx++) {
+ 		if (!sfx->name[0])
+ 			continue;
+-		S_LoadSound(sfx);
++		S_LoadSound (sfx);
+ 	}
+ 
+ 	s_registering = false;
+ }
+ 
+ 
+-/*
+- * ===========================================================================
+- * ==
+- */
++//=============================================================================
+ 
+ /*
+- * ================= S_PickChannel =================
+- */
+-channel_t      *
+-S_PickChannel(int entnum, int entchannel)
++=================
++S_PickChannel
++=================
++*/
++channel_t *S_PickChannel(int entnum, int entchannel)
+ {
+ 	int		ch_idx;
+ 	int		first_to_die;
+ 	int		life_left;
+-	channel_t      *ch;
++	channel_t	*ch;
+ 
+-	if (entchannel < 0)
+-		Com_Error(ERR_DROP, "S_PickChannel: entchannel<0");
++	if (entchannel<0)
++		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+ 
+-	/* Check for replacement sound, or find the best one to replace */
++	// Check for replacement sound, or find the best one to replace
+ 	first_to_die = -1;
+ 	life_left = 0x7fffffff;
+-	for (ch_idx = 0; ch_idx < MAX_CHANNELS; ch_idx++) {
+-		if (entchannel != 0	/* channel 0 never overrides */
++	
++	for (ch_idx=0 ; ch_idx < MAX_CHANNELS ; ch_idx++) {
++		if (entchannel != 0 // channel 0 never overrides
+ 		    && channels[ch_idx].entnum == entnum
+-		    && channels[ch_idx].entchannel == entchannel) {	/* always override sound
+-									 * from same entity */
++		    && channels[ch_idx].entchannel == entchannel) { // always override sound from same entity
+ 			first_to_die = ch_idx;
+ 			break;
+ 		}
+-		/* don't let monster sounds override player sounds */
+-		if (channels[ch_idx].entnum == cl.playernum + 1 && entnum != cl.playernum + 1 && channels[ch_idx].sfx)
++
++		// don't let monster sounds override player sounds
++		if (channels[ch_idx].entnum == cl.playernum+1 && entnum != cl.playernum+1 && channels[ch_idx].sfx)
+ 			continue;
+ 
+ 		if (channels[ch_idx].end - paintedtime < life_left) {
+@@ -477,114 +501,121 @@
+ 		return NULL;
+ 
+ 	ch = &channels[first_to_die];
+-	memset(ch, 0, sizeof(*ch));
++	memset (ch, 0, sizeof(*ch));
+ 
+ 	return ch;
+-}
++}       
+ 
+ /*
+- * ================= S_SpatializeOrigin
+- *
+- * Used for spatializing channels and autosounds =================
+- */
+-void
+-S_SpatializeOrigin(vec3_t origin, float master_vol, float dist_mult, int *left_vol, int *right_vol)
++=================
++S_SpatializeOrigin
++
++Used for spatializing channels and autosounds
++=================
++*/
++void S_SpatializeOrigin (vec3_t origin, float master_vol, float dist_mult, int *left_vol, int *right_vol)
+ {
+ 	vec_t		dot;
+ 	vec_t		dist;
+-	vec_t		lscale  , rscale, scale;
++	vec_t		lscale, rscale, scale;
+ 	vec3_t		source_vec;
+ 
+ 	if (cls.state != ca_active) {
+ 		*left_vol = *right_vol = 255;
+ 		return;
+ 	}
+-	/* calculate stereo seperation and distance attenuation */
++
++	// calculate stereo seperation and distance attenuation
+ 	VectorSubtract(origin, listener_origin, source_vec);
+ 
+ 	dist = VectorNormalize(source_vec);
+ 	dist -= SOUND_FULLVOLUME;
+ 	if (dist < 0)
+-		dist = 0;	/* close enough to be at full volume */
+-	dist *= dist_mult;	/* different attenuation levels */
+-
++		dist = 0;			// close enough to be at full volume
++	dist *= dist_mult;		// different attenuation levels
++	
+ 	dot = DotProduct(listener_right, source_vec);
+ 
+-	if (dma.channels == 1 || !dist_mult) {	/* no attenuation = no
+-						 * spatialization */
++	if (dma.channels == 1 || !dist_mult) { // no attenuation = no spatialization
+ 		rscale = 1.0;
+ 		lscale = 1.0;
+-	} else {
++	}
++	else {
+ 		rscale = 0.5 * (1.0 + dot);
+-		lscale = 0.5 * (1.0 - dot);
++		lscale = 0.5*(1.0 - dot);
+ 	}
+ 
+-	/* add in distance effect */
++	// add in distance effect
+ 	scale = (1.0 - dist) * rscale;
+-	*right_vol = (int)(master_vol * scale);
++	*right_vol = (int) (master_vol * scale);
+ 	if (*right_vol < 0)
+ 		*right_vol = 0;
+ 
+ 	scale = (1.0 - dist) * lscale;
+-	*left_vol = (int)(master_vol * scale);
++	*left_vol = (int) (master_vol * scale);
+ 	if (*left_vol < 0)
+ 		*left_vol = 0;
+ }
+ 
+ /*
+- * ================= S_Spatialize =================
+- */
+-void
+-S_Spatialize(channel_t * ch)
++=================
++S_Spatialize
++=================
++*/
++void S_Spatialize(channel_t *ch)
+ {
+ 	vec3_t		origin;
+ 
+-	/* anything coming from the view entity will always be full volume */
+-	if (ch->entnum == cl.playernum + 1) {
++	// anything coming from the view entity will always be full volume
++	if (ch->entnum == cl.playernum+1) {
+ 		ch->leftvol = ch->master_vol;
+ 		ch->rightvol = ch->master_vol;
+ 		return;
+ 	}
++
+ 	if (ch->fixed_origin) {
+-		VectorCopy(ch->origin, origin);
+-	} else
+-		CL_GetEntitySoundOrigin(ch->entnum, origin);
++		VectorCopy (ch->origin, origin);
++	}
++	else
++		CL_GetEntitySoundOrigin (ch->entnum, origin);
+ 
+-	S_SpatializeOrigin(origin, ch->master_vol, ch->dist_mult, &ch->leftvol, &ch->rightvol);
+-}
++	S_SpatializeOrigin (origin, ch->master_vol, ch->dist_mult, &ch->leftvol, &ch->rightvol);
++}           
+ 
+ 
+ /*
+- * ================= S_AllocPlaysound =================
+- */
+-playsound_t    *
+-S_AllocPlaysound(void)
++=================
++S_AllocPlaysound
++=================
++*/
++playsound_t *S_AllocPlaysound (void)
+ {
+-	playsound_t    *ps;
++	playsound_t	*ps;
+ 
+ 	ps = s_freeplays.next;
+ 	if (ps == &s_freeplays)
+-		return NULL;	/* no free playsounds */
++		return NULL;		// no free playsounds
+ 
+-	/* unlink from freelist */
++	// unlink from freelist
+ 	ps->prev->next = ps->next;
+ 	ps->next->prev = ps->prev;
+-
++	
+ 	return ps;
+ }
+ 
+ 
+ /*
+- * ================= S_FreePlaysound =================
+- */
+-void
+-S_FreePlaysound(playsound_t * ps)
++=================
++S_FreePlaysound
++=================
++*/
++void S_FreePlaysound (playsound_t *ps)
+ {
+-	/* unlink from channel */
++	// unlink from channel
+ 	ps->prev->next = ps->next;
+ 	ps->next->prev = ps->prev;
+ 
+-	/* add to free list */
++	// add to free list
+ 	ps->next = s_freeplays.next;
+ 	s_freeplays.next->prev = ps;
+ 	ps->prev = &s_freeplays;
+@@ -594,113 +625,118 @@
+ 
+ 
+ /*
+- * =============== S_IssuePlaysound
+- *
+- * Take the next playsound and begin it on the channel This is never called
+- * directly by S_Play*, but only by the update loop. ===============
+- */
+-void
+-S_IssuePlaysound(playsound_t * ps)
++===============
++S_IssuePlaysound
++
++Take the next playsound and begin it on the channel
++This is never called directly by S_Play*, but only
++by the update loop.
++===============
++*/
++void S_IssuePlaysound (playsound_t *ps)
+ {
+-	channel_t      *ch;
+-	sfxcache_t     *sc;
++	channel_t	*ch;
++	sfxcache_t	*sc;
+ 
+ 	if (s_show->value)
+-		Com_Printf("Issue %i\n", ps->begin);
+-	/* pick a channel to play on */
++		Com_Printf ("Issue %i\n", ps->begin);
++	// pick a channel to play on
+ 	ch = S_PickChannel(ps->entnum, ps->entchannel);
+ 	if (!ch) {
+-		S_FreePlaysound(ps);
++		S_FreePlaysound (ps);
+ 		return;
+ 	}
+-	/* spatialize */
++
++	// spatialize
+ 	if (ps->attenuation == ATTN_STATIC)
+ 		ch->dist_mult = ps->attenuation * 0.001;
+ 	else
+ 		ch->dist_mult = ps->attenuation * 0.0005;
++		
+ 	ch->master_vol = ps->volume;
+ 	ch->entnum = ps->entnum;
+ 	ch->entchannel = ps->entchannel;
+ 	ch->sfx = ps->sfx;
+-	VectorCopy(ps->origin, ch->origin);
++	VectorCopy (ps->origin, ch->origin);
+ 	ch->fixed_origin = ps->fixed_origin;
+ 
+ 	S_Spatialize(ch);
+ 
+ 	ch->pos = 0;
+-	sc = S_LoadSound(ch->sfx);
++	sc = S_LoadSound (ch->sfx);
+ 	ch->end = paintedtime + sc->length;
+ 
+-	/* free the playsound */
+-	S_FreePlaysound(ps);
++	// free the playsound
++	S_FreePlaysound (ps);
+ }
+ 
+-struct sfx_s   *
+-S_RegisterSexedSound(entity_state_t * ent, char *base)
++struct sfx_s *S_RegisterSexedSound (entity_state_t *ent, char *base)
+ {
+-	int		n;
+-	char           *p;
+-	struct sfx_s   *sfx;
+-	fileHandle_t	f;
+-	char		model[MAX_QPATH];
+-	char		sexedFilename[MAX_QPATH];
+-	char		maleFilename[MAX_QPATH];
++	int			n;
++	char			*p;
++	struct sfx_s		*sfx;
++	fileHandle_t		f;
++	char			model[MAX_QPATH];
++	char			sexedFilename[MAX_QPATH];
++	char			maleFilename[MAX_QPATH];
+ 
+-	/* determine what model the client is using */
++	// determine what model the client is using
+ 	model[0] = 0;
+ 	n = CS_PLAYERSKINS + ent->number - 1;
+ 	if (cl.configstrings[n][0]) {
+ 		p = strchr(cl.configstrings[n], '\\');
+ 		if (p) {
+ 			p += 1;
+-			Q_strncpyz(model, p, sizeof(model));
++			strcpy(model, p);
+ 			p = strchr(model, '/');
+ 			if (p)
+ 				*p = 0;
+ 		}
+ 	}
+-	/* if we can't figure it out, they're male */
++	// if we can't figure it out, they're male
+ 	if (!model[0])
+-		Q_strncpyz(model, "male", sizeof(model));
++		strcpy(model, "male");
+ 
+-	/* see if we already know of the model specific sound */
+-	Com_sprintf(sexedFilename, sizeof(sexedFilename), "#players/%s/%s", model, base + 1);
+-	sfx = S_FindName(sexedFilename, false);
++	// see if we already know of the model specific sound
++	Com_sprintf (sexedFilename, sizeof(sexedFilename), "#players/%s/%s", model, base+1);
++	sfx = S_FindName (sexedFilename, false);
+ 
+ 	if (!sfx) {
+-		/* no, so see if it exists */
+-		FS_FOpenFile(&sexedFilename[1], &f, FS_READ);
++		// no, so see if it exists
++		FS_FOpenFile (&sexedFilename[1], &f, FS_READ);
+ 		if (f) {
+-			/* yes, close the file and register it */
+-			FS_FCloseFile(f);
+-			sfx = S_RegisterSound(sexedFilename);
++			// yes, close the file and register it
++			FS_FCloseFile (f);
++			sfx = S_RegisterSound (sexedFilename);
+ 		} else {
+-			/* no, revert to the male sound in the pak0.pak */
+-			Com_sprintf(maleFilename, sizeof(maleFilename), "player/%s/%s", "male", base + 1);
+-			sfx = S_AliasName(sexedFilename, maleFilename);
++			// no, revert to the male sound in the pak0.pak
++			Com_sprintf (maleFilename, sizeof(maleFilename), "player/%s/%s", "male", base+1);
++			sfx = S_AliasName (sexedFilename, maleFilename);
+ 		}
+ 	}
++
+ 	return sfx;
+ }
+ 
+ 
+-/* ======================================================================= */
+-/* Start a sound effect */
+-/* ======================================================================= */
++// =======================================================================
++// Start a sound effect
++// =======================================================================
+ 
+ /*
+- * ==================== S_StartSound
+- *
+- * Validates the parms and ques the sound up if pos is NULL, the sound will be
+- * dynamically sourced from the entity Entchannel 0 will never override a
+- * playing sound ====================
+- */
+-void
+-S_StartSound(vec3_t origin, int entnum, int entchannel, sfx_t * sfx, float fvol, float attenuation, float timeofs)
++====================
++S_StartSound
++
++Validates the parms and ques the sound up
++if pos is NULL, the sound will be dynamically sourced from the entity
++Entchannel 0 will never override a playing sound
++====================
++*/
++void S_StartSound(vec3_t origin, int entnum, int entchannel, sfx_t *sfx, float fvol, float attenuation, float timeofs)
+ {
+-	sfxcache_t     *sc;
++	sfxcache_t	*sc;
+ 	int		vol;
+-	playsound_t    *ps, *sort;
++	playsound_t	*ps, *sort;
+ 	int		start;
+ 
+ 	if (!sound_started)
+@@ -712,22 +748,23 @@
+ 	if (sfx->name[0] == '*')
+ 		sfx = S_RegisterSexedSound(&cl_entities[entnum].current, sfx->name);
+ 
+-	/* make sure the sound is loaded */
+-	sc = S_LoadSound(sfx);
++	// make sure the sound is loaded
++	sc = S_LoadSound (sfx);
+ 	if (!sc)
+-		return;		/* couldn't load the sound's data */
++		return;		// couldn't load the sound's data
+ 
+-	vol = fvol * 255;
++	vol = fvol*255;
+ 
+-	/* make the playsound_t */
+-	ps = S_AllocPlaysound();
++	// make the playsound_t
++	ps = S_AllocPlaysound ();
+ 	if (!ps)
+ 		return;
+ 
+ 	if (origin) {
+-		VectorCopy(origin, ps->origin);
++		VectorCopy (origin, ps->origin);
+ 		ps->fixed_origin = true;
+-	} else
++	}
++	else
+ 		ps->fixed_origin = false;
+ 
+ 	ps->entnum = entnum;
+@@ -736,16 +773,18 @@
+ 	ps->volume = vol;
+ 	ps->sfx = sfx;
+ 
+-	/* drift s_beginofs */
++	// drift s_beginofs
+ 	start = cl.frame.servertime * 0.001 * dma.speed + s_beginofs;
+ 	if (start < paintedtime) {
+ 		start = paintedtime;
+ 		s_beginofs = start - (cl.frame.servertime * 0.001 * dma.speed);
+-	} else if (start > paintedtime + 0.3 * dma.speed) {
++	}
++	else if (start > paintedtime + 0.3 * dma.speed) {
+ 		start = paintedtime + 0.1 * dma.speed;
+ 		s_beginofs = start - (cl.frame.servertime * 0.001 * dma.speed);
+-	} else {
+-		s_beginofs -= 10;
++	}
++	else {
++		s_beginofs-=10;
+ 	}
+ 
+ 	if (!timeofs)
+@@ -753,10 +792,11 @@
+ 	else
+ 		ps->begin = start + timeofs * dma.speed;
+ 
+-	/* sort into the pending sound list */
+-	for (sort = s_pendingplays.next;
+-	    sort != &s_pendingplays && sort->begin < ps->begin;
+-	    sort = sort->next);
++	// sort into the pending sound list
++	for (sort = s_pendingplays.next ; 
++		sort != &s_pendingplays && sort->begin < ps->begin ;
++		sort = sort->next)
++			;
+ 
+ 	ps->next = sort;
+ 	ps->prev = sort->prev;
+@@ -767,33 +807,35 @@
+ 
+ 
+ /*
+- * ================== S_StartLocalSound ==================
+- */
+-void
+-S_StartLocalSound(char *sound)
++==================
++S_StartLocalSound
++==================
++*/
++void S_StartLocalSound (char *sound)
+ {
+-	sfx_t          *sfx;
++	sfx_t	*sfx;
+ 
+ 	if (!sound_started)
+ 		return;
+-
+-	sfx = S_RegisterSound(sound);
++		
++	sfx = S_RegisterSound (sound);
+ 	if (!sfx) {
+-		Com_Printf("S_StartLocalSound: can't cache %s\n", sound);
++		Com_Printf ("S_StartLocalSound: can't cache %s\n", sound);
+ 		return;
+ 	}
+-	S_StartSound(NULL, cl.playernum + 1, 0, sfx, 1, 1, 0);
++	S_StartSound (NULL, cl.playernum+1, 0, sfx, 1, 1, 0);
+ }
+ 
+ 
+ /*
+- * ================== S_ClearBuffer ==================
+- */
+-void
+-S_ClearBuffer(void)
++==================
++S_ClearBuffer
++==================
++*/
++void S_ClearBuffer (void)
+ {
+ 	int		clear;
+-
++		
+ 	if (!sound_started)
+ 		return;
+ 
+@@ -804,72 +846,61 @@
+ 	else
+ 		clear = 0;
+ 
+-	SNDDMA_BeginPainting();
+-	if (dma.buffer) {
+-		/* memset(dma.buffer, clear, dma.samples * dma.samplebits/8); */
+-		int		i;
+-		unsigned char  *ptr = (unsigned char *)dma.buffer;
+-
+-		/*
+-		 * clear it manually because the buffer might be writeonly
+-		 * (mmap)
+-		 */
+-		i = dma.samples * dma.samplebits / 8;
+-		while (i--) {
+-			*ptr = clear;
+-			ptr++;
+-		}
+-	}
+-	SNDDMA_Submit();
++	SNDDMA_BeginPainting ();
++	if (dma.buffer)
++		memset(dma.buffer, clear, dma.samples * dma.samplebits/8);
++	SNDDMA_Submit ();
+ }
+ 
+ /*
+- * ================== S_StopAllSounds ==================
+- */
+-void
+-S_StopAllSounds(void)
++==================
++S_StopAllSounds
++==================
++*/
++void S_StopAllSounds(void)
+ {
+ 	int		i;
+ 
+ 	if (!sound_started)
+ 		return;
+ 
+-	/* clear all the playsounds */
++	// clear all the playsounds
+ 	memset(s_playsounds, 0, sizeof(s_playsounds));
+ 	s_freeplays.next = s_freeplays.prev = &s_freeplays;
+ 	s_pendingplays.next = s_pendingplays.prev = &s_pendingplays;
+ 
+-	for (i = 0; i < MAX_PLAYSOUNDS; i++) {
++	for (i=0 ; i<MAX_PLAYSOUNDS ; i++) {
+ 		s_playsounds[i].prev = &s_freeplays;
+ 		s_playsounds[i].next = s_freeplays.next;
+ 		s_playsounds[i].prev->next = &s_playsounds[i];
+ 		s_playsounds[i].next->prev = &s_playsounds[i];
+ 	}
+ 
+-	/* clear all the channels */
++	// clear all the channels
+ 	memset(channels, 0, sizeof(channels));
+ 
+-	S_ClearBuffer();
++	S_ClearBuffer ();
+ }
+ 
+ /*
+- * ================== S_AddLoopSounds
+- *
+- * Entities with a ->sound field will generated looped sounds that are
+- * automatically started, stopped, and merged together as the entities are
+- * sent to the client ==================
+- */
+-void
+-S_AddLoopSounds(void)
++==================
++S_AddLoopSounds
++
++Entities with a ->sound field will generated looped sounds
++that are automatically started, stopped, and merged together
++as the entities are sent to the client
++==================
++*/
++void S_AddLoopSounds (void)
+ {
+-	int		i         , j;
+-	int		sounds     [MAX_EDICTS];
+-	int		left      , right, left_total, right_total;
+-	channel_t      *ch;
+-	sfx_t          *sfx;
+-	sfxcache_t     *sc;
++	int		i, j;
++	int		sounds[MAX_EDICTS];
++	int		left, right, left_total, right_total;
++	channel_t	*ch;
++	sfx_t		*sfx;
++	sfxcache_t	*sc;
+ 	int		num;
+-	entity_state_t *ent;
++	entity_state_t	*ent;
+ 
+ 	if (cl_paused->value)
+ 		return;
+@@ -880,47 +911,99 @@
+ 	if (!cl.sound_prepped)
+ 		return;
+ 
+-	for (i = 0; i < cl.frame.num_entities; i++) {
+-		num = (cl.frame.parse_entities + i) & (MAX_PARSE_ENTITIES - 1);
++	for (i=0 ; i<cl.frame.num_entities ; i++) {
++		num = (cl.frame.parse_entities + i)&(MAX_PARSE_ENTITIES-1);
+ 		ent = &cl_parse_entities[num];
+ 		sounds[i] = ent->sound;
+ 	}
+ 
+-	for (i = 0; i < cl.frame.num_entities; i++) {
++	for (i=0 ; i<cl.frame.num_entities ; i++) {
+ 		if (!sounds[i])
+ 			continue;
+ 
+ 		sfx = cl.sound_precache[sounds[i]];
+ 		if (!sfx)
+-			continue;	/* bad sound effect */
++			continue;		// bad sound effect
+ 		sc = sfx->cache;
+ 		if (!sc)
+ 			continue;
+ 
+-		num = (cl.frame.parse_entities + i) & (MAX_PARSE_ENTITIES - 1);
++		num = (cl.frame.parse_entities + i)&(MAX_PARSE_ENTITIES-1);
+ 		ent = &cl_parse_entities[num];
+ 
+-		/* find the total contribution of all sounds of this type */
+-		S_SpatializeOrigin(ent->origin, 255.0, SOUND_LOOPATTENUATE,
+-		    &left_total, &right_total);
+-		for (j = i + 1; j < cl.frame.num_entities; j++) {
++		// find the total contribution of all sounds of this type
++		S_SpatializeOrigin (ent->origin, 255.0, SOUND_LOOPATTENUATE,
++			&left_total, &right_total);
++#if 0
++		for (j=i+1 ; j<cl.frame.num_entities ; j++) {
+ 			if (sounds[j] != sounds[i])
+ 				continue;
+-			sounds[j] = 0;	/* don't check this again later */
++			sounds[j] = 0;	// don't check this again later
+ 
+-			num = (cl.frame.parse_entities + j) & (MAX_PARSE_ENTITIES - 1);
++			num = (cl.frame.parse_entities + j)&(MAX_PARSE_ENTITIES-1);
+ 			ent = &cl_parse_entities[num];
+ 
+-			S_SpatializeOrigin(ent->origin, 255.0, SOUND_LOOPATTENUATE,
+-			    &left, &right);
++			S_SpatializeOrigin (ent->origin, 255.0, SOUND_LOOPATTENUATE, 
++				&left, &right);
+ 			left_total += left;
+ 			right_total += right;
+ 		}
++#else
++		// Knightmare- find correct origin for bmodels without origin brushes 
++		if (ent->solid == 31) { // special value for bmodels
++			cmodel_t   *cmodel;
++			vec3_t      origin_v;
++			int         k;
++
++			cmodel = cl.model_clip[ent->modelindex];
++
++			if (cmodel) { // find bbox here
++				for (k = 0; k < 3; k++)
++					origin_v[k] = ent->origin[k]+0.5*(cmodel->mins[k]+cmodel->maxs[k]);
++			}
++			else {
++				VectorCopy(ent->origin, origin_v);
++			}
++			
++			// find the total contribution of all sounds of this type
++			S_SpatializeOrigin (origin_v, 255.0, SOUND_LOOPATTENUATE, &left_total, &right_total);
++
++			for (j = i + 1; j < cl.frame.num_entities; j++) {
++				if (sounds[j] != sounds[i])
++					continue;
+ 
++				sounds[j] = 0; // don't check this again later
++				num = (cl.frame.parse_entities + j) & (MAX_PARSE_ENTITIES-1);
++				ent = &cl_parse_entities[num];
++				S_SpatializeOrigin (origin_v, 255.0, SOUND_LOOPATTENUATE, 
++					&left, &right);
++				left_total += left;
++				right_total += right;
++			}
++		} 
++		else { 
++			// find the total contribution of all sounds of this type 
++			S_SpatializeOrigin (ent->origin, 255.0, SOUND_LOOPATTENUATE, &left_total, &right_total);
++
++			for (j=i+1 ; j<cl.frame.num_entities ; j++)  { 
++				if (sounds[j] != sounds[i])
++					continue;
++
++				sounds[j] = 0; // don't check this again later
++				num = (cl.frame.parse_entities + j) & (MAX_PARSE_ENTITIES-1);
++				ent = &cl_parse_entities[num];
++				S_SpatializeOrigin(ent->origin, 255.0, SOUND_LOOPATTENUATE,
++					&left, &right);
++				left_total += left;
++				right_total += right;
++			}
++		}
++		// end Knightmare
++#endif
+ 		if (left_total == 0 && right_total == 0)
+-			continue;	/* not audible */
++			continue;		// not audible
+ 
+-		/* allocate a channel */
++		// allocate a channel
+ 		ch = S_PickChannel(0, 0);
+ 		if (!ch)
+ 			return;
+@@ -931,45 +1014,34 @@
+ 			right_total = 255;
+ 		ch->leftvol = left_total;
+ 		ch->rightvol = right_total;
+-		ch->autosound = true;	/* remove next frame */
++		ch->autosound = true;	// remove next frame
+ 		ch->sfx = sfx;
+-
+-		/*
+-		 * PATCH: eliasm
+-		 *
+-		 * Sometimes, the sc->length argument can become 0, and in that
+-		 * case we get a SIGFPE in the next modulo operation. The
+-		 * workaround checks for this situation and in that case,
+-		 * sets the pos and end parameters to 0.
+-		 *
+-		 * ch->pos = paintedtime % sc->length; ch->end = paintedtime +
+-		 * sc->length - ch->pos;
+-		 */
++		/* sometimes, the sc->length argument can become 0, and in that
++		 * case we get a SIGFPE in the next modulo.  The workaround checks
++		 * for this situation and sets the pos and end to zero if true */
+ 		if (sc->length == 0) {
+-			ch->pos = 0;
+-			ch->end = 0;
+-		} else {
++		    ch->pos = ch->end = 0;
++		}
++		else {
+ 			ch->pos = paintedtime % sc->length;
+ 			ch->end = paintedtime + sc->length - ch->pos;
+ 		}
+ 	}
+ }
+ 
+-/*
+- * ===========================================================================
+- * ==
+- */
++//=============================================================================
+ 
+ /*
+- * ============ S_RawSamples
+- *
+- * Cinematic streaming and voice over network ============
+- */
+-void
+-S_RawSamples(int samples, int rate, int width, int channels, byte * data)
++============
++S_RawSamples
++
++Cinematic streaming and voice over network
++============
++*/
++void S_RawSamples (int samples, int rate, int width, int channels, byte *data)
+ {
+ 	int		i;
+-	int		src       , dst;
++	int		src, dst;
+ 	float		scale;
+ 
+ 	if (!sound_started)
+@@ -979,94 +1051,99 @@
+ 		s_rawend = paintedtime;
+ 	scale = (float)rate / dma.speed;
+ 
+-	/* Com_Printf ("%i < %i < %i\n", soundtime, paintedtime, s_rawend); */
+ 	if (channels == 2 && width == 2) {
+-		if (scale == 1.0) {	/* optimized case */
+-			for (i = 0; i < samples; i++) {
+-				dst = s_rawend & (MAX_RAW_SAMPLES - 1);
++		if (scale == 1.0) { // optimized case
++			for (i=0 ; i<samples ; i++) {
++				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+ 				s_rawend++;
+ 				s_rawsamples[dst].left =
+-				    LittleShort(((short *)data)[i * 2]) << 8;
++				    LittleShort(((short *)data)[i*2]) << 8;
+ 				s_rawsamples[dst].right =
+-				    LittleShort(((short *)data)[i * 2 + 1]) << 8;
++				    LittleShort(((short *)data)[i*2+1]) << 8;
+ 			}
+ 		} else {
+-			for (i = 0;; i++) {
+-				src = i * scale;
++			for (i=0 ; ; i++) {
++				src = i*scale;
+ 				if (src >= samples)
+ 					break;
+-				dst = s_rawend & (MAX_RAW_SAMPLES - 1);
++				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+ 				s_rawend++;
+ 				s_rawsamples[dst].left =
+-				    LittleShort(((short *)data)[src * 2]) << 8;
++				    LittleShort(((short *)data)[src*2]) << 8;
+ 				s_rawsamples[dst].right =
+-				    LittleShort(((short *)data)[src * 2 + 1]) << 8;
++				    LittleShort(((short *)data)[src*2+1]) << 8;
+ 			}
+ 		}
+ 	} else if (channels == 1 && width == 2) {
+-		for (i = 0;; i++) {
+-			src = i * scale;
++		for (i=0 ; ; i++) {
++			src = i*scale;
+ 			if (src >= samples)
+ 				break;
+-			dst = s_rawend & (MAX_RAW_SAMPLES - 1);
++			dst = s_rawend&(MAX_RAW_SAMPLES-1);
+ 			s_rawend++;
+ 			s_rawsamples[dst].left =
+ 			    LittleShort(((short *)data)[src]) << 8;
+ 			s_rawsamples[dst].right =
+ 			    LittleShort(((short *)data)[src]) << 8;
+ 		}
+-	} else if (channels == 2 && width == 1) {
+-		for (i = 0;; i++) {
+-			src = i * scale;
++	}
++	else if (channels == 2 && width == 1) {
++		for (i=0 ; ; i++) {
++			src = i*scale;
+ 			if (src >= samples)
+ 				break;
+-			dst = s_rawend & (MAX_RAW_SAMPLES - 1);
++			dst = s_rawend&(MAX_RAW_SAMPLES-1);
+ 			s_rawend++;
+ 			s_rawsamples[dst].left =
+-			    ((char *)data)[src * 2] << 16;
++			    ((char *)data)[src*2] << 16;
+ 			s_rawsamples[dst].right =
+-			    ((char *)data)[src * 2 + 1] << 16;
++			    ((char *)data)[src*2+1] << 16;
+ 		}
+-	} else if (channels == 1 && width == 1) {
+-		for (i = 0;; i++) {
+-			src = i * scale;
++	}
++	else if (channels == 1 && width == 1) {
++		for (i=0 ; ; i++) {
++			src = i*scale;
+ 			if (src >= samples)
+ 				break;
+-			dst = s_rawend & (MAX_RAW_SAMPLES - 1);
++			dst = s_rawend&(MAX_RAW_SAMPLES-1);
+ 			s_rawend++;
+ 			s_rawsamples[dst].left =
+-			    (((byte *) data)[src] - 128) << 16;
+-			s_rawsamples[dst].right = (((byte *) data)[src] - 128) << 16;
++			    (((byte *)data)[src]-128) << 16;
++			s_rawsamples[dst].right = (((byte *)data)[src]-128) << 16;
+ 		}
+ 	}
+ }
+ 
++//=============================================================================
++
+ /*
+- * ============ S_Update
+- *
+- * Called once each time through the main loop ============
+- */
+-void
+-S_Update(vec3_t origin, vec3_t forward, vec3_t right, vec3_t up)
++============
++S_Update
++
++Called once each time through the main loop
++============
++*/
++void S_Update(vec3_t origin, vec3_t forward, vec3_t right, vec3_t up)
+ {
+ 	int		i;
+ 	int		total;
+-	channel_t      *ch;
+-	channel_t      *combine;
++	channel_t	*ch;
++	channel_t	*combine;
+ 
+ 	if (!sound_started)
+ 		return;
+ 
+-	/* if the laoding plaque is up, clear everything */
+-	/* out to make sure we aren't looping a dirty */
+-	/* dma buffer while loading */
++	// if the laoding plaque is up, clear everything
++	// out to make sure we aren't looping a dirty
++	// dma buffer while loading
+ 	if (cls.disable_screen) {
+-		S_ClearBuffer();
++		S_ClearBuffer ();
+ 		return;
+ 	}
+-	/* rebuild scale tables if volume is modified */
++
++	// rebuild scale tables if volume is modified
+ 	if (s_volume->modified)
+-		S_InitScaletable();
++		S_InitScaletable ();
+ 
+ 	VectorCopy(origin, listener_origin);
+ 	VectorCopy(forward, listener_forward);
+@@ -1075,166 +1152,170 @@
+ 
+ 	combine = NULL;
+ 
+-	/* update spatialization for dynamic sounds	 */
++	// update spatialization for dynamic sounds	
+ 	ch = channels;
+-	for (i = 0; i < MAX_CHANNELS; i++, ch++) {
++	for (i=0 ; i<MAX_CHANNELS; i++, ch++) {
+ 		if (!ch->sfx)
+ 			continue;
+-		if (ch->autosound) {	/* autosounds are regenerated fresh
+-					 * each frame */
+-			memset(ch, 0, sizeof(*ch));
++		if (ch->autosound) { // autosounds are regenerated fresh each frame
++			memset (ch, 0, sizeof(*ch));
+ 			continue;
+ 		}
+-		S_Spatialize(ch);	/* respatialize channel */
++		S_Spatialize(ch);         // respatialize channel
+ 		if (!ch->leftvol && !ch->rightvol) {
+-			memset(ch, 0, sizeof(*ch));
++			memset (ch, 0, sizeof(*ch));
+ 			continue;
+ 		}
+ 	}
+ 
+-	/* add loopsounds */
+-	S_AddLoopSounds();
++	// add loopsounds
++	S_AddLoopSounds ();
+ 
+ 	//
+-	/* debugging output */
+-	    //
+-	    if (s_show->value) {
++	// debugging output
++	//
++	if (s_show->value) {
+ 		total = 0;
+ 		ch = channels;
+-		for (i = 0; i < MAX_CHANNELS; i++, ch++)
+-			if (ch->sfx && (ch->leftvol || ch->rightvol)) {
+-				Com_Printf("%3i %3i %s\n", ch->leftvol, ch->rightvol, ch->sfx->name);
++		for (i=0 ; i<MAX_CHANNELS; i++, ch++)
++			if (ch->sfx && (ch->leftvol || ch->rightvol) ) {
++				Com_Printf ("%3i %3i %s\n", ch->leftvol, ch->rightvol, ch->sfx->name);
+ 				total++;
+ 			}
+-		Com_Printf("----(%i)---- painted: %i\n", total, paintedtime);
++		
++		Com_Printf ("----(%i)---- painted: %i\n", total, paintedtime);
+ 	}
+-	/* mix some sound */
++
++// mix some sound
+ 	S_Update_();
+-	
+-	/* stream music */
++// stream music
+ 	OGG_Stream();
+-	
++#if defined (__unix__)
++#if defined (WITH_AUDACIOUS)
++	AUDACIOUS_MP3_Frame();
++#elif defined (WITH_XMMS)
++	XMMS_MP3_Frame();
++#endif
++#endif
++#if defined (_WIN32)
++	WINAMP_MP3_Frame();
++#endif
+ }
+ 
+-void
+-GetSoundtime(void)
++void GetSoundtime(void)
+ {
+ 	int		samplepos;
+-	static int	buffers;
+-	static int	oldsamplepos;
++	static	int	buffers;
++	static	int	oldsamplepos;
+ 	int		fullsamples;
+-
++	
+ 	fullsamples = dma.samples / dma.channels;
+ 
+-	/* it is possible to miscount buffers if it has wrapped twice between */
+-	/* calls to S_Update.  Oh well. */
++	// it is possible to miscount buffers if it has wrapped twice between
++	// calls to S_Update.  Oh well.
+ 	samplepos = SNDDMA_GetDMAPos();
+ 
+ 	if (samplepos < oldsamplepos) {
+-		buffers++;	/* buffer wrapped */
+-
+-		if (paintedtime > 0x40000000) {	/* time to chop things off to
+-						 * avoid 32 bit limits */
++		buffers++;					// buffer wrapped
++		
++		if (paintedtime > 0x40000000) { // time to chop things off to avoid 32 bit limits
+ 			buffers = 0;
+ 			paintedtime = fullsamples;
+-			S_StopAllSounds();
++			S_StopAllSounds ();
+ 		}
+ 	}
+ 	oldsamplepos = samplepos;
+ 
+-	soundtime = buffers * fullsamples + samplepos / dma.channels;
++	soundtime = buffers*fullsamples + samplepos/dma.channels;
+ }
+ 
+-void
+-S_Update_(void)
++
++void S_Update_(void)
+ {
+-	unsigned	endtime;
++	unsigned        endtime;
+ 	int		samps;
+ 
+ 	if (!sound_started)
+ 		return;
+ 
+-	SNDDMA_BeginPainting();
++	SNDDMA_BeginPainting ();
+ 
+ 	if (!dma.buffer)
+ 		return;
+ 
+-	/* Updates DMA time */
++	// Updates DMA time
+ 	GetSoundtime();
+ 
+-	/* check to make sure that we haven't overshot */
++	// check to make sure that we haven't overshot
+ 	if (paintedtime < soundtime) {
+-		Com_DPrintf("S_Update_ : overflow\n");
++		Com_DPrintf ("S_Update_ : overflow\n");
+ 		paintedtime = soundtime;
+ 	}
+-	/* mix ahead of current position */
++
++	// mix ahead of current position
+ 	endtime = soundtime + s_mixahead->value * dma.speed;
+-	/* endtime = (soundtime + 4096) & ~4095; */
+ 
+-	/* mix to an even submission block size */
+-	endtime = (endtime + dma.submission_chunk - 1)
+-	    & ~(dma.submission_chunk - 1);
+-	samps = dma.samples >> (dma.channels - 1);
++	// mix to an even submission block size
++	endtime = (endtime + dma.submission_chunk-1)
++		& ~(dma.submission_chunk-1);
++	samps = dma.samples >> (dma.channels-1);
+ 	if (endtime - soundtime > samps)
+ 		endtime = soundtime + samps;
+ 
+-	S_PaintChannels(endtime);
++	S_PaintChannels (endtime);
+ 
+-	SNDDMA_Submit();
++	SNDDMA_Submit ();
+ }
+ 
+ /*
+- *
+- * ============================================================================
+- * ===
+- *
+- * console functions
+- *
+- * =================
+- * =============================================================
+- */
++===============================================================================
+ 
+-void
+-S_Play(void)
+-{
+-	int		i;
+-	char		name[256];
+-	sfx_t          *sfx;
++console functions
+ 
++===============================================================================
++*/
++
++void S_Play(void)
++{
++	int 	i;
++	char name[256];
++	sfx_t	*sfx;
++	
+ 	i = 1;
+-	while (i < Cmd_Argc()) {
++	while (i<Cmd_Argc()) {
+ 		if (!strrchr(Cmd_Argv(i), '.')) {
+-			Q_strncpyz(name, Cmd_Argv(i), sizeof(name));
+-			strncat(name, ".wav", sizeof(name) - strlen(name) - 1);
+-		} else
+-			Q_strncpyz(name, Cmd_Argv(i), sizeof(name));
++			strcpy(name, Cmd_Argv(i));
++			strcat(name, ".wav");
++		}
++		else
++			strcpy(name, Cmd_Argv(i));
++			
+ 		sfx = S_RegisterSound(name);
+-		S_StartSound(NULL, cl.playernum + 1, 0, sfx, 1.0, 1.0, 0);
++		S_StartSound(NULL, cl.playernum+1, 0, sfx, 1.0, 1.0, 0);
+ 		i++;
+ 	}
+ }
+ 
+-void
+-S_SoundList(void)
++void S_SoundList(void)
+ {
+ 	int		i;
+-	sfx_t          *sfx;
+-	sfxcache_t     *sc;
+-	int		size      , total;
++	sfx_t		*sfx;
++	sfxcache_t	*sc;
++	int		size, total;
+ 
+ 	total = 0;
+-	for (sfx = known_sfx, i = 0; i < num_sfx; i++, sfx++) {
++	for (sfx=known_sfx, i=0 ; i<num_sfx ; i++, sfx++) {
+ 		if (!sfx->registration_sequence)
+ 			continue;
+ 		sc = sfx->cache;
+ 		if (sc) {
+-			size = sc->length * sc->width * (sc->stereo + 1);
++			size = sc->length*sc->width*(sc->stereo+1);
+ 			total += size;
+ 			if (sc->loopstart >= 0)
+-				Com_Printf("L");
++				Com_Printf ("L");
+ 			else
+-				Com_Printf(" ");
+-			Com_Printf("(%2db) %6i : %s\n", sc->width * 8, size, sfx->name);
++				Com_Printf (" ");
++			Com_Printf("(%2db) %6i : %s\n",sc->width*8,  size, sfx->name);
+ 		} else {
+ 			if (sfx->name[0] == '*')
+ 				Com_Printf("  placeholder : %s\n", sfx->name);
+@@ -1242,5 +1323,6 @@
+ 				Com_Printf("  not loaded  : %s\n", sfx->name);
+ 		}
+ 	}
+-	Com_Printf("Total resident: %i\n", total);
++	Com_Printf ("Total resident: %i\n", total);
+ }
++
diff --git a/games/qudos/files/patch-src__unix__snd_oss.c b/games/qudos/files/patch-src__unix__snd_oss.c
new file mode 100644
index 000000000000..5b4b362eb464
--- /dev/null
+++ b/games/qudos/files/patch-src__unix__snd_oss.c
@@ -0,0 +1,173 @@
+--- src/unix/snd_oss.c.orig	Thu Sep 13 20:13:40 2007
++++ src/unix/snd_oss.c	Thu Sep 13 20:17:00 2007
+@@ -25,12 +25,7 @@
+ #include <sys/mman.h>
+ #include <sys/shm.h>
+ #include <sys/wait.h>
+-#if defined(__FreeBSD__)
+ #include <sys/soundcard.h>
+-#endif
+-#if defined(__linux__)
+-#include <linux/soundcard.h>
+-#endif
+ #include <stdio.h>
+ 
+ #include "../client/client.h"
+@@ -43,7 +38,12 @@
+ 
+ struct sndinfo * si;
+ 
+-static int tryrates[] = { 48000, 44100, 22050, 11025, 8000 };
++static int tryrates[] = {
++	48000, 
++	44100,
++	22050,
++	11025
++};
+ 
+ qboolean
+ SNDDMA_Init(struct sndinfo * s) 
+@@ -53,22 +53,22 @@
+ 	int		fmt;
+ 	int		tmp;
+ 	int		i;
+-	struct audio_buf_info info;
++	struct		audio_buf_info info;
+ 	int		caps;
+-	
++
+ 	if (snd_inited)
+ 		return 1;
+ 
+ 	snd_inited = 0;
+ 
+ 	si = s;
+-	
++
++#if defined (__linux__)
+ 	if(!strcmp(si->snddevice->string, "default"))  //silly alsa default
+ 		si->snddevice->string = "/dev/dsp";
+-
++#endif
+ 	/*
+-	 * open /dev/dsp, confirm capability to mmap, and get size of dma
+-	 * buffer
++	 * open /dev/dsp, confirm capability to mmap, and get size of dma buffer
+ 	 */
+ 	if (audio_fd == -1) {
+ 		audio_fd = open(si->snddevice->string, O_RDWR);
+@@ -100,8 +100,8 @@
+ 		audio_fd = -1;
+ 		return 0;
+ 	}
+-	/* set sample bits & speed */
+-	
++
++	/* set sample bits & speed */	
+ 	si->dma->samplebits = (int)si->sndbits->value;
+ 	if (si->dma->samplebits != 16 && si->dma->samplebits != 8) {
+         	ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &fmt);
+@@ -139,22 +139,11 @@
+ 	}
+ 
+ 	si->dma->speed = (int)si->sndspeed->value;
+-
+-	if (!si->dma->speed) {	
+-		
+-		if (si->s_khz->value == 48) {
+-			si->dma->speed = 48000;
+-		}
+-		else if (si->s_khz->value == 44) {
+-			si->dma->speed = 44100;
+-		}
+-		else if (si->s_khz->value == 22) {
+-			si->dma->speed = 22050;
+-		}
+-		else  {
+-			si->dma->speed = 11025;
+-		}
+-			si->dma->speed = 48000; /** Uhh **/
++	if (!si->dma->speed) {
++		if (si->s_khz->value == 48)      si->dma->speed = 48000;
++		else if (si->s_khz->value == 44) si->dma->speed = 44100;
++		else if (si->s_khz->value == 22) si->dma->speed = 22050;
++		else                             si->dma->speed = 11025;	
+ 	}
+ 	
+ 	if (!si->dma->speed) {
+@@ -163,6 +152,7 @@
+ 				break;
+ 		si->dma->speed = tryrates[i];
+ 	}
++
+ 	si->dma->channels = (int)si->sndchannels->value;
+ 	if (si->dma->channels < 1 || si->dma->channels > 2)
+ 		si->dma->channels = 2;
+@@ -177,8 +167,9 @@
+ 		               si->dma->channels);
+ 		close(audio_fd);
+ 		audio_fd = -1;
+-        return 0;
++        	return 0;
+ 	}
++
+ 	if (tmp)
+ 		si->dma->channels = 2;
+ 	else
+@@ -204,7 +195,6 @@
+ 	si->dma->submission_chunk = 1;
+ 
+ 	/* memory map the dma buffer */
+-
+ 	if (!si->dma->buffer)
+ 		si->dma->buffer = (unsigned char *)mmap(NULL, info.fragstotal
+ 		         * info.fragsize, PROT_WRITE, MAP_FILE|MAP_SHARED, audio_fd, 0);
+@@ -215,8 +205,8 @@
+ 		audio_fd = -1;
+ 		return 0;
+ 	}
+-	/* toggle the trigger & start her up */
+ 
++	/* toggle the trigger & start her up */
+ 	tmp = 0;
+ 	rc = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp);
+ 	if (rc < 0) {
+@@ -235,12 +225,12 @@
+ 	    audio_fd = -1;
+ 	    return 0;
+ 	}
+-
+-
+-	si->Com_Printf("\nInitializing OSS Sound System\n");
+-	si->Com_Printf("Buffer size: %d\n", info.fragstotal * info.fragsize);
+-
++	
+ 	si->dma->samplepos = 0;
++	
++	si->Com_Printf("Initializing OSS Sound System\n");
++	si->Com_Printf("Buffer size: %d\n", info.fragstotal * info.fragsize);
++	
+ 	snd_inited = 1;
+ 	return 1;
+ }
+@@ -262,11 +252,6 @@
+ 		return 0;
+ 	}
+ 
+-	/*
+-	 * dma.samplepos = (count.bytes / (dma.samplebits / 8)) &
+-	 * (dma.samples-1);
+-	 */
+-	/* fprintf(stderr, "%d    \r", count.ptr); */
+ 	si->dma->samplepos = count.ptr / (si->dma->samplebits / 8);
+ 
+ 	return si->dma->samplepos;
+@@ -286,7 +271,7 @@
+ 		snd_inited = 0;
+ 	}
+ #else
+-	printf ("SNDDMA_Shutdown\n");
++	si->Com_Printf("SNDDMA_Shutdown\n");
+ 	if (snd_inited) {
+ 		munmap (si->dma->buffer, si->dma->samples *si->dma->samplebits / 8);
+ 		si->dma->buffer = 0L;
diff --git a/games/qudos/files/patch-src__unix__snd_sdl.c b/games/qudos/files/patch-src__unix__snd_sdl.c
new file mode 100644
index 000000000000..2d9f9a5ba3e2
--- /dev/null
+++ b/games/qudos/files/patch-src__unix__snd_sdl.c
@@ -0,0 +1,207 @@
+--- src/unix/snd_sdl.c.orig	Thu Sep 13 20:13:49 2007
++++ src/unix/snd_sdl.c	Thu Sep 13 20:17:03 2007
+@@ -1,47 +1,47 @@
+ /*
+- * snd_sdl.c
+- *
+- * Sound code taken from SDLQuake and modified to work with Quake2 Robert Bäuml
+- * 2001-12-25
+- *
+- * 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:
+- *
+- * Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA
+- * 02111-1307, USA
+- *
+- * $Id: snd_sdl.c,v 1.2 2002/02/09 20:29:38 relnev Exp $
+- */
++	snd_sdl.c
++
++	Sound code taken from SDLQuake and modified to work with Quake2
++	Robert B�ml 2001-12-25
++
++	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:
++
++		Free Software Foundation, Inc.
++		59 Temple Place - Suite 330
++		Boston, MA  02111-1307, USA
++
++	$Id: snd_sdl.c,v 1.2 2002/02/09 20:29:38 relnev Exp $
++*/
+ 
+ #include "SDL.h"
+ 
+ #include "../client/client.h"
+ #include "../client/snd_loc.h"
+ 
+-static int  snd_inited;
+-static dma_t *shm;
++int  snd_inited = 0;
+ 
+ struct sndinfo * si;
+ 
+ static void
+ paint_audio (void *unused, Uint8 * stream, int len)
+ {
+-	if (shm) {
+-		shm->buffer = stream;
+-		shm->samplepos += len / (shm->samplebits / 4);
+-		/* Check for samplepos overflow? */
+-		si->S_PaintChannels (shm->samplepos);
++	if (snd_inited) {
++		si->dma->buffer = stream;
++		si->dma->samplepos += len / (si->dma->samplebits / 4);
++		// Check for samplepos overflow?
++		si->S_PaintChannels (si->dma->samplepos);
+ 	}
+ }
+ 
+@@ -50,6 +50,7 @@
+ {
+ 	SDL_AudioSpec desired, obtained;
+ 	int desired_bits, freq;
++	char	drivername[128];
+ 	
+ 	if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
+ 		if (SDL_Init(SDL_INIT_AUDIO) < 0) {
+@@ -68,19 +69,11 @@
+ 		
+ 	/* Set up the desired format */
+ 	freq = si->s_khz->value;
+-	
+-	if (freq == 48) {
+-		desired.freq = 48000;
+-	}
+-	else if (freq == 44) {
+-		desired.freq = 44100;
+-	}
+-	else if (freq == 22) {
+-		desired.freq = 22050;
+-	}
+-	else {
+-		desired.freq = 11025;
+-	}
++	if (freq == 48)      desired.freq = 48000;
++	else if (freq == 44) desired.freq = 44100;
++	else if (freq == 22) desired.freq = 22050;
++	else if (freq == 11) desired.freq = 11025;
++	else                 desired.freq = 44100;
+ 	
+ 	switch (desired_bits) {
+ 		case 8:
+@@ -96,20 +89,14 @@
+ 			si->Com_Printf ("Unknown number of audio bits: %d\n", desired_bits);
+ 			return 0;
+ 	}
++        
+ 	desired.channels = si->sndchannels->value;
+-	
+-	if (desired.freq == 48000) {
+-		desired.samples = 4096;
+-	}
+-	else if (desired.freq == 44100) {
+-		desired.samples = 2048;
+-	}
+-	else if (desired.freq == 22050) {
+-		desired.samples = 1024;
+-	}
+-	else {
+-		desired.samples = 512;
+-	}
++        
++	if (desired.freq == 48000)      desired.samples = 4096;
++	else if (desired.freq == 44100) desired.samples = 2048;
++	else if (desired.freq == 22050) desired.samples = 1024;
++	else if (desired.freq == 11025) desired.samples = 512;
++	else                            desired.samples = 2048;
+ 		
+ 	desired.callback = paint_audio;
+ 	
+@@ -133,7 +120,6 @@
+ 				/* Supported */
+ 				break;
+ 			}
+-			/* Unsupported, fall through */ ;
+ 		default:
+ 			/* Not supported -- force SDL to do our bidding */
+ 			SDL_CloseAudio ();
+@@ -147,16 +133,21 @@
+ 	SDL_PauseAudio (0);
+ 
+ 	/* Fill the audio DMA information block */
+-	shm = si->dma;
+-	shm->samplebits = (obtained.format & 0xFF);
+-	shm->speed = obtained.freq;
+-	shm->channels = obtained.channels;
+-	shm->samples = obtained.samples * shm->channels;
+-	shm->samplepos = 0;
+-	shm->submission_chunk = 1;
+-	shm->buffer = NULL;
++	si->dma->samplebits = (obtained.format & 0xFF);
++	si->dma->speed = obtained.freq;
++	si->dma->channels = obtained.channels;
++	si->dma->samples = obtained.samples * si->dma->channels;
++	si->dma->samplepos = 0;
++	si->dma->submission_chunk = 1;
++	si->dma->buffer = NULL;
+ 
+-	si->Com_Printf("\nInitializing SDL Sound System\n");
++	if (SDL_AudioDriverName(drivername, sizeof (drivername)) == NULL)
++		strcpy(drivername, "(UNKNOWN)");
++
++	si->Com_Printf("Initializing SDL Sound System\n");
++	si->Com_Printf("Audio driver: %s\n", drivername);
++	si->Com_Printf("DMA buffer address: 0x%x \n", (int) si->dma->buffer);
++	si->Com_Printf("Channels: %5d\n", MAX_CHANNELS);
+ 
+ 	snd_inited = 1;
+ 	return 1;
+@@ -165,12 +156,13 @@
+ int
+ SNDDMA_GetDMAPos (void)
+ {
+-	return shm->samplepos;
++	return si->dma->samplepos;
+ }
+ 
+ void
+ SNDDMA_Shutdown (void)
+ {
++	si->Com_Printf("SNDDMA_Shutdown\n");
+ 	if (snd_inited) {
+ 		SDL_CloseAudio ();
+ 		snd_inited = 0;
+@@ -183,8 +175,8 @@
+ }
+ 
+ /*
+-	SNDDMA_Submit
+-	Send sound to device if buffer isn't really the dma buffer
++SNDDMA_Submit
++Send sound to device if buffer isn't really the dma buffer
+ */
+ void
+ SNDDMA_Submit (void)