shithub: qk1

Info  •  Files  •  Log  •  Branches

fix and simplify sound

- don't buffer writes to /dev/audio, nuke all the stupid cargocult multiproc
  bullshit
- write variable number of samples based on time from last write + a bit
  more to avoid underruns
- move all sound code to snd.c, refactor sampling code, remove useless cvars
  and commands

--- a/bspfile.h

+++ b/bspfile.h

@@ -177,15 +177,6 @@

 	int			lightofs;		// start of [numstyles*surfsize] samples

 } dface_t;

-

-

-#define	AMBIENT_WATER	0

-#define	AMBIENT_SKY		1

-#define	AMBIENT_SLIME	2

-#define	AMBIENT_LAVA	3

-

-#define	NUM_AMBIENTS			4		// automatic ambient sounds

-

 // leaf 0 is the generic CONTENTS_SOLID leaf, used for all solid areas

 // all other leafs need visibility info

 typedef struct

@@ -199,7 +190,7 @@

 	unsigned short		firstmarksurface;

 	unsigned short		nummarksurfaces;

-	byte		ambient_level[NUM_AMBIENTS];

+	byte		ambient_level[Namb];

 } dleaf_t;

 #pragma pack off

--- a/cd.c

+++ b/cd.c

@@ -52,7 +52,7 @@

 {

 	int a, n, afd, fd;

 	char s[24];

-	uchar buf[SNBUF];

+	uchar buf[8192];

 	short *p;

 	if((afd = open("/dev/audio", OWRITE)) < 0)

--- a/cl_main.c

+++ b/cl_main.c

@@ -82,7 +82,7 @@

 void CL_Disconnect (void)

 {

 // stop sounds (especially looping!)

-	S_StopAllSounds (true);

+	stopallsfx();

 // bring the console down and fade the colors back to normal

 //	SCR_BringDownConsole ();

--- a/cl_parse.c

+++ b/cl_parse.c

@@ -96,12 +96,12 @@

     if (field_mask & SND_VOLUME)

 		volume = MSG_ReadByte ();

 	else

-		volume = DEFAULT_SOUND_PACKET_VOLUME;

+		volume = Spktvol;

     if (field_mask & SND_ATTENUATION)

 		attenuation = MSG_ReadByte () / 64.0;

 	else

-		attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;

+		attenuation = Spktatt;

 	channel = MSG_ReadShort ();

 	sound_num = MSG_ReadByte ();

@@ -115,7 +115,7 @@

 	for (i=0 ; i<3 ; i++)

 		pos[i] = MSG_ReadCoord ();

-    S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);

+    startsfx (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);

 }       

 /*

@@ -261,7 +261,7 @@

 			return;

 		}

 		strcpy (sound_precache[numsounds], str);

-		S_TouchSound (str);

+		touchsfx (str);

 	}

 //

@@ -279,13 +279,11 @@

 		CL_KeepaliveMessage ();

 	}

-	S_BeginPrecaching ();

 	for (i=1 ; i<numsounds ; i++)

 	{

-		cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);

+		cl.sound_precache[i] = precachesfx (sound_precache[i]);

 		CL_KeepaliveMessage ();

 	}

-	S_EndPrecaching ();

 // local state

@@ -667,7 +665,7 @@

 	vol = MSG_ReadByte ();

 	atten = MSG_ReadByte ();

-	S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);

+	staticsfx (cl.sound_precache[sound_num], org, vol, atten);

 }

@@ -794,7 +792,7 @@

 		case svc_stopsound:

 			i = MSG_ReadShort();

-			S_StopSound(i>>3, i&7);

+			stopsfx(i>>3, i&7);

 			break;

 		case svc_updatename:

--- a/cl_tent.c

+++ b/cl_tent.c

@@ -8,13 +8,13 @@

 entity_t	cl_temp_entities[MAX_TEMP_ENTITIES];

 beam_t		cl_beams[MAX_BEAMS];

-sfx_t			*cl_sfx_wizhit;

-sfx_t			*cl_sfx_knighthit;

-sfx_t			*cl_sfx_tink1;

-sfx_t			*cl_sfx_ric1;

-sfx_t			*cl_sfx_ric2;

-sfx_t			*cl_sfx_ric3;

-sfx_t			*cl_sfx_r_exp3;

+Sfx			*cl_sfx_wizhit;

+Sfx			*cl_sfx_knighthit;

+Sfx			*cl_Sfxink1;

+Sfx			*cl_sfx_ric1;

+Sfx			*cl_sfx_ric2;

+Sfx			*cl_sfx_ric3;

+Sfx			*cl_sfx_r_exp3;

 /*

 =================

@@ -23,13 +23,13 @@

 */

 void CL_InitTEnts (void)

 {

-	cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");

-	cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");

-	cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");

-	cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");

-	cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");

-	cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");

-	cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");

+	cl_sfx_wizhit = precachesfx ("wizard/hit.wav");

+	cl_sfx_knighthit = precachesfx ("hknight/hit.wav");

+	cl_Sfxink1 = precachesfx ("weapons/tink1.wav");

+	cl_sfx_ric1 = precachesfx ("weapons/ric1.wav");

+	cl_sfx_ric2 = precachesfx ("weapons/ric2.wav");

+	cl_sfx_ric3 = precachesfx ("weapons/ric3.wav");

+	cl_sfx_r_exp3 = precachesfx ("weapons/r_exp3.wav");

 }

 /*

@@ -103,7 +103,7 @@

 		pos[1] = MSG_ReadCoord ();

 		pos[2] = MSG_ReadCoord ();

 		R_RunParticleEffect (pos, vec3_origin, 20, 30);

-		S_StartSound (-1, 0, cl_sfx_wizhit, pos, 1, 1);

+		startsfx (-1, 0, cl_sfx_wizhit, pos, 1, 1);

 		break;

 	case TE_KNIGHTSPIKE:			// spike hitting wall

@@ -111,7 +111,7 @@

 		pos[1] = MSG_ReadCoord ();

 		pos[2] = MSG_ReadCoord ();

 		R_RunParticleEffect (pos, vec3_origin, 226, 20);

-		S_StartSound (-1, 0, cl_sfx_knighthit, pos, 1, 1);

+		startsfx (-1, 0, cl_sfx_knighthit, pos, 1, 1);

 		break;

 	case TE_SPIKE:			// spike hitting wall

@@ -120,16 +120,16 @@

 		pos[2] = MSG_ReadCoord ();

 		R_RunParticleEffect (pos, vec3_origin, 0, 10);

 		if ( rand() % 5 )

-			S_StartSound (-1, 0, cl_sfx_tink1, pos, 1, 1);

+			startsfx (-1, 0, cl_Sfxink1, pos, 1, 1);

 		else

 		{

 			rnd = rand() & 3;

 			if (rnd == 1)

-				S_StartSound (-1, 0, cl_sfx_ric1, pos, 1, 1);

+				startsfx (-1, 0, cl_sfx_ric1, pos, 1, 1);

 			else if (rnd == 2)

-				S_StartSound (-1, 0, cl_sfx_ric2, pos, 1, 1);

+				startsfx (-1, 0, cl_sfx_ric2, pos, 1, 1);

 			else

-				S_StartSound (-1, 0, cl_sfx_ric3, pos, 1, 1);

+				startsfx (-1, 0, cl_sfx_ric3, pos, 1, 1);

 		}

 		break;

 	case TE_SUPERSPIKE:			// super spike hitting wall

@@ -139,16 +139,16 @@

 		R_RunParticleEffect (pos, vec3_origin, 0, 20);

 		if ( rand() % 5 )

-			S_StartSound (-1, 0, cl_sfx_tink1, pos, 1, 1);

+			startsfx (-1, 0, cl_Sfxink1, pos, 1, 1);

 		else

 		{

 			rnd = rand() & 3;

 			if (rnd == 1)

-				S_StartSound (-1, 0, cl_sfx_ric1, pos, 1, 1);

+				startsfx (-1, 0, cl_sfx_ric1, pos, 1, 1);

 			else if (rnd == 2)

-				S_StartSound (-1, 0, cl_sfx_ric2, pos, 1, 1);

+				startsfx (-1, 0, cl_sfx_ric2, pos, 1, 1);

 			else

-				S_StartSound (-1, 0, cl_sfx_ric3, pos, 1, 1);

+				startsfx (-1, 0, cl_sfx_ric3, pos, 1, 1);

 		}

 		break;

@@ -169,7 +169,7 @@

 		dl->radius = 350;

 		dl->die = cl.time + 0.5;

 		dl->decay = 300;

-		S_StartSound (-1, 0, cl_sfx_r_exp3, pos, 1, 1);

+		startsfx (-1, 0, cl_sfx_r_exp3, pos, 1, 1);

 		break;

 	case TE_TAREXPLOSION:			// tarbaby explosion

@@ -178,7 +178,7 @@

 		pos[2] = MSG_ReadCoord ();

 		R_BlobExplosion (pos);

-		S_StartSound (-1, 0, cl_sfx_r_exp3, pos, 1, 1);

+		startsfx (-1, 0, cl_sfx_r_exp3, pos, 1, 1);

 		break;

 	case TE_LIGHTNING1:				// lightning bolts

@@ -225,7 +225,7 @@

 		dl->radius = 350;

 		dl->die = cl.time + 0.5;

 		dl->decay = 300;

-		S_StartSound (-1, 0, cl_sfx_r_exp3, pos, 1, 1);

+		startsfx (-1, 0, cl_sfx_r_exp3, pos, 1, 1);

 		break;

 	default:

--- a/client.h

+++ b/client.h

@@ -179,7 +179,7 @@

 // information that is static for the entire time connected to a server

 //

 	struct model_s		*model_precache[MAX_MODELS];

-	struct sfx_s		*sound_precache[MAX_SOUNDS];

+	Sfx *sound_precache[MAX_SOUNDS];

 	char		levelname[40];	// for display on solo scoreboard

 	int			viewentity;		// cl_entitites[cl.viewentity] = player

--- a/console.c

+++ b/console.c

@@ -223,7 +223,7 @@

 	if (txt[0] == 1)

 	{

 		mask = 128;		// go to colored text

-		S_LocalSound ("misc/talk.wav");

+		localsfx ("misc/talk.wav");

 	// play talk wav

 		txt++;

 	}

--- a/dat.h

+++ b/dat.h

@@ -1,3 +1,5 @@

+typedef struct Sfx Sfx;

+

 enum{

 	Npath = 64,

 	Nfspath = 128,

@@ -5,7 +7,9 @@

 	Nsav = 12,

 	Nsavcm = 40,

 	Nsavver = 5,

-	Nparms = 16

+	Nparms = 16,

+

+	Te9 = 1000000000

 };

 extern char fsdir[];

@@ -13,3 +17,21 @@

 extern char savs[][Nsavcm];

 extern int savcanld[];

+

+enum{

+	Fpsmin = 10,

+	Fpsmax = 72

+};

+

+enum{

+	Ambwater = 0,

+	Ambsky,

+	Ambslime,

+	Amblava,

+	Namb

+};

+

+enum{

+	Spktvol = 255

+};

+#define Spktatt 1.0

--- a/draw.c

+++ b/draw.c

@@ -809,10 +809,6 @@

 	int			x,y;

 	byte		*pbuf;

-	VID_UnlockBuffer ();

-	S_ExtraUpdate ();

-	VID_LockBuffer ();

-

 	for (y=0 ; y<vid.height ; y++)

 	{

 		int	t;

@@ -826,10 +822,6 @@

 				pbuf[x] = 0;

 		}

 	}

-

-	VID_UnlockBuffer ();

-	S_ExtraUpdate ();

-	VID_LockBuffer ();

 }

 //=============================================================================

--- a/fns.h

+++ b/fns.h

@@ -1,3 +1,13 @@

+void	stepsnd(vec3_t, vec3_t, vec3_t, vec3_t);

+void	stopallsfx(void);

+void	stopsfx(int, int);

+void	startsfx(int, int, Sfx *, vec3_t, float, float);

+void	localsfx(char *);

+void	staticsfx(Sfx *, vec3_t, float, float);

+void	touchsfx(char *);

+Sfx*	precachesfx(char *);

+void	shutsnd(void);

+int	initsnd(void);

 void	setcvar(char*, char*);

 void	setcvarv(char*, float);

 void	abortdemo(void);

--- a/fs.c

+++ b/fs.c

@@ -344,10 +344,10 @@

 	switch(mth){

 	case Fhunk: buf = Hunk_AllocName(m + 1, r); break;

 	case Fcache: buf = Cache_Alloc(loadcache, m + 1, r); break;

-	case Fstack: buf = m+1 <= loadsize ? loadbuf : Hunk_TempAlloc(m+1);

+	case Fstack: buf = m + 1 <= loadsize ? loadbuf : Hunk_TempAlloc(m + 1); break;

 	}

 	if(buf == nil)

-		fatal("loadlmp %s %d: memory allocation failed: %r", f, m+1);

+		fatal("loadlmp %s %d: memory allocation failed: %r", f, m + 1);

 	buf[m] = 0;

 	Draw_BeginDisc();

 	eread(bf, buf, m);

@@ -684,7 +684,7 @@

 		goto exit;

 	n = strtol(s, nil, 10);

 	if(n != Nsavver){

-		werrstr("invalid version %d\n", n);

+		werrstr("invalid version %d", n);

 		goto exit;

 	}

 	Brdline(bf, '\n');

--- a/host.c

+++ b/host.c

@@ -57,7 +57,6 @@

 cvar_t	temp1 = {"temp1","0"};

-

 /*

 ================

 Host_EndGame

@@ -426,43 +425,8 @@

 	memset(&cl, 0, sizeof cl);

 }

-

-//============================================================================

-

-

 /*

 ===================

-Host_FilterTime

-

-Returns false if the time is too short to run a frame

-===================

-*/

-qboolean Host_FilterTime (float time)

-{

-	realtime += time;

-

-	if (!cls.timedemo && realtime - oldrealtime < 1.0/72.0)

-		return false;		// framerate is too high

-

-	host_frametime = realtime - oldrealtime;

-	oldrealtime = realtime;

-

-	if (host_framerate.value > 0)

-		host_frametime = host_framerate.value;

-	else

-	{	// don't allow really long or short frames

-		if (host_frametime > 0.1)

-			host_frametime = 0.1;

-		if (host_frametime < 0.001)

-			host_frametime = 0.001;

-	}

-	

-	return true;

-}

-

-

-/*

-===================

 Host_GetConsoleCommands

 Add them exactly as if they had been typed at the console

@@ -511,15 +475,21 @@

 	SV_SendClientMessages ();

 }

+static int

+boundfps(float t)

+{

+	realtime += t;

+	if(!cls.timedemo && realtime - oldrealtime < 1.0 / Fpsmax)

+		return -1;

+	host_frametime = realtime - oldrealtime;

+	oldrealtime = realtime;

+	if(host_framerate.value > 0)

+		host_frametime = host_framerate.value;

+	else if(host_frametime > 1.0 / Fpsmin)

+		host_frametime = 1.0 / Fpsmin;

+	return 0;

+}

-

-/*

-==================

-Host_Frame

-

-Runs all active servers

-==================

-*/

 void _Host_Frame (float time)

 {

 	static double		time1 = 0;

@@ -532,10 +502,9 @@

 // keep the random time dependent

 	rand ();

-	

-// decide the simulation time

-	if (!Host_FilterTime (time))

-		return;			// don't run too fast, or packets will flood out

+

+	if(boundfps(time) < 0)

+		return;

 // get new key events

 	Sys_SendKeyEvents ();

@@ -595,11 +564,11 @@

 // update audio

 	if (cls.signon == SIGNONS)

 	{

-		S_Update (r_origin, vpn, vright, vup);

+		stepsnd (r_origin, vpn, vright, vup);

 		CL_DecayLights ();

 	}

 	else

-		S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);

+		stepsnd (vec3_origin, vec3_origin, vec3_origin, vec3_origin);

 	CDAudio_Update();

@@ -711,7 +680,8 @@

 		Draw_Init ();

 		SCR_Init ();

 		R_Init ();

-		S_Init ();

+		if(initsnd() < 0)

+			fprint(2, "initsnd: %r\n");

 		CDAudio_Init ();

 		Sbar_Init ();

 		CL_Init ();

@@ -753,7 +723,7 @@

 	CDAudio_Shutdown ();

 	NET_Shutdown ();

-	S_Shutdown();

+	shutsnd();

 	IN_Shutdown ();

 	if (cls.state != ca_dedicated)

--- a/menu.c

+++ b/menu.c

@@ -296,13 +296,13 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (++m_main_cursor >= MAIN_ITEMS)

 			m_main_cursor = 0;

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (--m_main_cursor < 0)

 			m_main_cursor = MAIN_ITEMS - 1;

 		break;

@@ -375,13 +375,13 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (++m_singleplayer_cursor >= SINGLEPLAYER_ITEMS)

 			m_singleplayer_cursor = 0;

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (--m_singleplayer_cursor < 0)

 			m_singleplayer_cursor = SINGLEPLAYER_ITEMS - 1;

 		break;

@@ -483,7 +483,7 @@

 		break;

 	case K_ENTER:

-		S_LocalSound ("misc/menu2.wav");

+		localsfx ("misc/menu2.wav");

 		if (!savcanld[load_cursor])

 			return;

 		m_state = m_none;

@@ -499,7 +499,7 @@

 	case K_UPARROW:

 	case K_LEFTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		load_cursor--;

 		if (load_cursor < 0)

 			load_cursor = Nsav-1;

@@ -507,7 +507,7 @@

 	case K_DOWNARROW:

 	case K_RIGHTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		load_cursor++;

 		if (load_cursor >= Nsav)

 			load_cursor = 0;

@@ -532,7 +532,7 @@

 	case K_UPARROW:

 	case K_LEFTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		load_cursor--;

 		if (load_cursor < 0)

 			load_cursor = Nsav-1;

@@ -540,7 +540,7 @@

 	case K_DOWNARROW:

 	case K_RIGHTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		load_cursor++;

 		if (load_cursor >= Nsav)

 			load_cursor = 0;

@@ -592,13 +592,13 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (++m_multiplayer_cursor >= MULTIPLAYER_ITEMS)

 			m_multiplayer_cursor = 0;

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (--m_multiplayer_cursor < 0)

 			m_multiplayer_cursor = MULTIPLAYER_ITEMS - 1;

 		break;

@@ -700,7 +700,7 @@

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		setup_cursor--;

 		if (setup_cursor < 0)

 			setup_cursor = NUM_SETUP_CMDS-1;

@@ -707,7 +707,7 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		setup_cursor++;

 		if (setup_cursor >= NUM_SETUP_CMDS)

 			setup_cursor = 0;

@@ -716,7 +716,7 @@

 	case K_LEFTARROW:

 		if (setup_cursor < 2)

 			return;

-		S_LocalSound ("misc/menu3.wav");

+		localsfx ("misc/menu3.wav");

 		if (setup_cursor == 2)

 			setup_top = setup_top - 1;

 		if (setup_cursor == 3)

@@ -726,7 +726,7 @@

 		if (setup_cursor < 2)

 			return;

 forward:

-		S_LocalSound ("misc/menu3.wav");

+		localsfx ("misc/menu3.wav");

 		if (setup_cursor == 2)

 			setup_top = setup_top + 1;

 		if (setup_cursor == 3)

@@ -916,13 +916,13 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (++m_net_cursor >= m_net_items)

 			m_net_cursor = 0;

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (--m_net_cursor < 0)

 			m_net_cursor = m_net_items - 1;

 		break;

@@ -983,7 +983,7 @@

 void M_AdjustSliders (int dir)

 {

-	S_LocalSound ("misc/menu3.wav");

+	localsfx ("misc/menu3.wav");

 	switch (options_cursor)

 	{

@@ -1170,7 +1170,7 @@

 		return;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		options_cursor--;

 		if (options_cursor < 0)

 			options_cursor = OPTIONS_ITEMS-1;

@@ -1177,7 +1177,7 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		options_cursor++;

 		if (options_cursor >= OPTIONS_ITEMS)

 			options_cursor = 0;

@@ -1340,7 +1340,7 @@

 	if (bind_grab)

 	{	// defining a key

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		if (k != '`')

 		{

 			sprint (cmd, "bind \"%s\" \"%s\"\n", Key_KeynumToString (k), bindnames[keys_cursor][0]);

@@ -1359,7 +1359,7 @@

 	case K_LEFTARROW:

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		keys_cursor--;

 		if (keys_cursor < 0)

 			keys_cursor = NUMCOMMANDS-1;

@@ -1367,7 +1367,7 @@

 	case K_DOWNARROW:

 	case K_RIGHTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		keys_cursor++;

 		if (keys_cursor >= NUMCOMMANDS)

 			keys_cursor = 0;

@@ -1375,7 +1375,7 @@

 	case K_ENTER:		// go into bind mode

 		M_FindKeysForCommand (bindnames[keys_cursor][0], keys);

-		S_LocalSound ("misc/menu2.wav");

+		localsfx ("misc/menu2.wav");

 		if (keys[1] != -1)

 			M_UnbindCommand (bindnames[keys_cursor][0]);

 		bind_grab = true;

@@ -1383,7 +1383,7 @@

 	case K_BACKSPACE:		// delete bindings

 	case K_DEL:				// delete bindings

-		S_LocalSound ("misc/menu2.wav");

+		localsfx ("misc/menu2.wav");

 		M_UnbindCommand (bindnames[keys_cursor][0]);

 		break;

 	}

@@ -1707,7 +1707,7 @@

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		serialConfig_cursor--;

 		if (serialConfig_cursor < 0)

 			serialConfig_cursor = NUM_SERIALCONFIG_CMDS-1;

@@ -1714,7 +1714,7 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		serialConfig_cursor++;

 		if (serialConfig_cursor >= NUM_SERIALCONFIG_CMDS)

 			serialConfig_cursor = 0;

@@ -1723,7 +1723,7 @@

 	case K_LEFTARROW:

 		if (serialConfig_cursor > 2)

 			break;

-		S_LocalSound ("misc/menu3.wav");

+		localsfx ("misc/menu3.wav");

 		if (serialConfig_cursor == 0)

 		{

@@ -1755,7 +1755,7 @@

 		if (serialConfig_cursor > 2)

 			break;

 forward:

-		S_LocalSound ("misc/menu3.wav");

+		localsfx ("misc/menu3.wav");

 		if (serialConfig_cursor == 0)

 		{

@@ -1933,7 +1933,7 @@

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		modemConfig_cursor--;

 		if (modemConfig_cursor < 0)

 			modemConfig_cursor = NUM_MODEMCONFIG_CMDS-1;

@@ -1940,7 +1940,7 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		modemConfig_cursor++;

 		if (modemConfig_cursor >= NUM_MODEMCONFIG_CMDS)

 			modemConfig_cursor = 0;

@@ -1954,7 +1954,7 @@

 				modemConfig_dialing = 'T';

 			else

 				modemConfig_dialing = 'P';

-			S_LocalSound ("misc/menu1.wav");

+			localsfx ("misc/menu1.wav");

 		}

 		break;

@@ -2135,7 +2135,7 @@

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		lanConfig_cursor--;

 		if (lanConfig_cursor < 0)

 			lanConfig_cursor = NUM_LANCONFIG_CMDS-1;

@@ -2142,7 +2142,7 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		lanConfig_cursor++;

 		if (lanConfig_cursor >= NUM_LANCONFIG_CMDS)

 			lanConfig_cursor = 0;

@@ -2637,7 +2637,7 @@

 		break;

 	case K_UPARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		gameoptions_cursor--;

 		if (gameoptions_cursor < 0)

 			gameoptions_cursor = NUM_GAMEOPTIONS-1;

@@ -2644,7 +2644,7 @@

 		break;

 	case K_DOWNARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		gameoptions_cursor++;

 		if (gameoptions_cursor >= NUM_GAMEOPTIONS)

 			gameoptions_cursor = 0;

@@ -2653,7 +2653,7 @@

 	case K_LEFTARROW:

 		if (gameoptions_cursor == 0)

 			break;

-		S_LocalSound ("misc/menu3.wav");

+		localsfx ("misc/menu3.wav");

 		M_NetStart_Change (-1);

 		break;

@@ -2660,12 +2660,12 @@

 	case K_RIGHTARROW:

 		if (gameoptions_cursor == 0)

 			break;

-		S_LocalSound ("misc/menu3.wav");

+		localsfx ("misc/menu3.wav");

 		M_NetStart_Change (1);

 		break;

 	case K_ENTER:

-		S_LocalSound ("misc/menu2.wav");

+		localsfx ("misc/menu2.wav");

 		if (gameoptions_cursor == 0)

 		{

 			if (sv.active)

@@ -2821,7 +2821,7 @@

 	case K_UPARROW:

 	case K_LEFTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		slist_cursor--;

 		if (slist_cursor < 0)

 			slist_cursor = hostCacheCount - 1;

@@ -2829,7 +2829,7 @@

 	case K_DOWNARROW:

 	case K_RIGHTARROW:

-		S_LocalSound ("misc/menu1.wav");

+		localsfx ("misc/menu1.wav");

 		slist_cursor++;

 		if (slist_cursor >= hostCacheCount)

 			slist_cursor = 0;

@@ -2836,7 +2836,7 @@

 		break;

 	case K_ENTER:

-		S_LocalSound ("misc/menu2.wav");

+		localsfx ("misc/menu2.wav");

 		m_return_state = m_state;

 		m_return_onerror = true;

 		slist_sorted = false;

@@ -2883,12 +2883,7 @@

 		scr_copyeverything = 1;

 		if (scr_con_current)

-		{

 			Draw_ConsoleBackground (vid.height);

-			VID_UnlockBuffer ();

-			S_ExtraUpdate ();

-			VID_LockBuffer ();

-		}

 		else

 			Draw_FadeScreen ();

@@ -2979,13 +2974,9 @@

 	if (m_entersound)

 	{

-		S_LocalSound ("misc/menu2.wav");

+		localsfx ("misc/menu2.wav");

 		m_entersound = false;

 	}

-

-	VID_UnlockBuffer ();

-	S_ExtraUpdate ();

-	VID_LockBuffer ();

 }

 void

--- a/mkfile

+++ b/mkfile

@@ -4,6 +4,7 @@

 TARG=quake

 OFILES=\

+	cd.$O\

 	cl_demo.$O\

 	cl_input.$O\

 	cl_main.$O\

@@ -30,14 +31,16 @@

 	fs.$O\

 	host.$O\

 	host_cmd.$O\

+	in.$O\

 	keys.$O\

-	menu.$O\

 	mathlib.$O\

+	menu.$O\

 	model.$O\

+	net_bsd.$O\

+	net_dgrm.$O\

 	net_loop.$O\

 	net_main.$O\

-	net_dgrm.$O\

-	net_bsd.$O\

+	net_udp.$O\

 	pr_cmds.$O\

 	pr_edict.$O\

 	pr_exec.$O\

@@ -45,36 +48,30 @@

 	r_aclip.$O\

 	r_alias.$O\

 	r_bsp.$O\

-	r_light.$O\

 	r_draw.$O\

 	r_efrag.$O\

 	r_edge.$O\

-	r_misc.$O\

+	r_light.$O\

 	r_main.$O\

+	r_misc.$O\

+	r_part.$O\

 	r_sky.$O\

 	r_sprite.$O\

 	r_surf.$O\

-	r_part.$O\

 	r_vars.$O\

 	screen.$O\

 	sbar.$O\

+	snd.$O\

 	sv_main.$O\

-	sv_phys.$O\

 	sv_move.$O\

+	sv_phys.$O\

 	sv_user.$O\

-	zone.$O\

+	sys.$O\

+	vid.$O\

 	view.$O\

 	wad.$O\

 	world.$O\

-	snd_dma.$O\

-	snd_mem.$O\

-	snd_mix.$O\

-	in.$O\

-	sys.$O\

-	vid.$O\

-	snd.$O\

-	cd.$O\

-	net_udp.$O\

+	zone.$O\

 HFILES=\

 	dat.h\

@@ -109,7 +106,6 @@

 	sbar.h\

 	screen.h\

 	server.h\

-	sound.h\

 	spritegn.h\

 	sys.h\

 	vid.h\

--- a/model.h

+++ b/model.h

@@ -141,7 +141,7 @@

 	msurface_t	**firstmarksurface;

 	int			nummarksurfaces;

 	int			key;			// BSP sequence number for leaf's contents

-	byte		ambient_sound_level[NUM_AMBIENTS];

+	byte		ambient_sound_level[Namb];

 } mleaf_t;

 // !!! if this is changed, it must be changed in asm_i386.h too !!!

--- a/quakedef.h

+++ b/quakedef.h

@@ -167,7 +167,15 @@

 #include "protocol.h"

 #include "cmd.h"

 #include "sbar.h"

-#include "sound.h"

+

+struct Sfx{

+	char s[Npath];

+	cache_user_t cu;

+};

+

+extern cvar_t bgmvolume;

+extern cvar_t volume;

+

 #include "render.h"

 #include "client.h"

 #include "progs.h"

--- a/r_edge.c

+++ b/r_edge.c

@@ -689,10 +689,6 @@

 	// the next scan

 		if (span_p >= max_span_p)

 		{

-			VID_UnlockBuffer ();

-			S_ExtraUpdate ();	// don't let sound get messed up if going slow

-			VID_LockBuffer ();

-		

 			if (r_drawculledpolys)

 			{

 				R_DrawCulledPolys ();

--- a/r_main.c

+++ b/r_main.c

@@ -881,13 +881,6 @@

 		db_time2 = Sys_FloatTime ();

 		se_time1 = db_time2;

 	}

-

-	if (!r_dspeeds.value)

-	{

-		VID_UnlockBuffer ();

-		S_ExtraUpdate ();	// don't let sound get messed up if going slow

-		VID_LockBuffer ();

-	}

 	if (!(r_drawpolys | r_drawculledpolys))

 		R_ScanEdges ();

@@ -927,22 +920,8 @@

 	if (!cl_entities[0].model || !cl.worldmodel)

 		fatal ("R_RenderView: NULL worldmodel");

-		

-	if (!r_dspeeds.value)

-	{

-		VID_UnlockBuffer ();

-		S_ExtraUpdate ();	// don't let sound get messed up if going slow

-		VID_LockBuffer ();

-	}

 	R_EdgeDrawing ();

-

-	if (!r_dspeeds.value)

-	{

-		VID_UnlockBuffer ();

-		S_ExtraUpdate ();	// don't let sound get messed up if going slow

-		VID_LockBuffer ();

-	}

 	if (r_dspeeds.value)

 	{

--- a/screen.c

+++ b/screen.c

@@ -609,7 +609,7 @@

 */

 void SCR_BeginLoadingPlaque (void)

 {

-	S_StopAllSounds (true);

+	stopallsfx();

 	if (cls.state != ca_connected)

 		return;

@@ -702,9 +702,6 @@

 	scr_drawdialog = true;

 	SCR_UpdateScreen ();

 	scr_drawdialog = false;

-	

-	S_ClearBuffer ();		// so dma doesn't loop current sound

-

 	do

 	{

 		key_count = -1;		// wait for a key down and up

--- a/snd.c

+++ b/snd.c

@@ -1,94 +1,832 @@

 #include <u.h>

 #include <libc.h>

-#include <thread.h>

 #include "dat.h"

 #include "quakedef.h"

 #include "fns.h"

+cvar_t bgmvolume = {"bgmvolume", "1", 1};

+cvar_t volume = {"volume", "0.7", 1};

+

+typedef struct Chan Chan;

+

 enum{

-	Nbuf = 8

+	Srate = 44100,

+	Ssize = 2,

+	Sch = 2,

+	Sblk = Ssize * Sch,

+	Ssamp = Srate / Fpsmin,

+	Snbuf = Ssamp * Sblk,

+

+	Nchan = 128,

+	Ndyn = 8,

+	Sstat = Ndyn + Namb

 };

-static int afd;

-static int stid = -1;

-static uint wpos;

-static Channel *schan;

-static QLock sndlock;

+static float Clipdist = 1000.0;

+struct Chan{

+	Sfx *sfx;

+	int chvol;

+	int lvol;

+	int rvol;

+	vec_t attf;

+	vec3_t zp;

+	int entn;

+	int entch;

+	int p;

+	int n;

+};

+static Chan chans[Nchan], *che;

+static int afd = -1;

+static uchar mixbuf[Snbuf];

+static vlong sndt, sampt;

+static int nsamp;

+static int sampbuf[Ssamp*Sch*sizeof(int)];

+static int scalt[32][256];

+

+static Sfx *ambsfx[Namb];

+

+typedef struct

+{

+	int 	length;

+	int 	speed;

+	int 	width;

+	int 	stereo;

+	int loop;

+	byte	data[1];		// variable sized

+} sfxcache_t;

+

+typedef struct

+{

+	int		rate;

+	int		width;

+	int		channels;

+	int		loopofs;

+	int		samples;

+	int		dataofs;

+} wavinfo_t;

+

+static vec3_t		listener_origin;

+static vec3_t		listener_forward;

+static vec3_t		listener_right;

+static vec3_t		listener_up;

+#define	MAX_SFX		512

+static Sfx		*known_sfx;		// hunk allocated [MAX_SFX]

+static int			num_sfx;

+

+static cvar_t precache = {"precache", "1"};

+static cvar_t loadas8bit = {"loadas8bit", "0"};

+static cvar_t ambient_level = {"ambient_level", "0.3"};

+static cvar_t ambient_fade = {"ambient_fade", "100"};

+

+static byte	*data_p;

+static byte 	*iff_end;

+static byte 	*last_chunk;

+static byte 	*iff_data;

+

+/* TODO: refuctor wav loading */

 static void

-sproc(void *)

+resample(sfxcache_t *sc, byte *data, float stepscale)

 {

-	int n;

+	int inwidth;

+	int		outcount;

+	int		srcsample;

+	int		i;

+	int		sample, samplefrac, fracstep;

-	for(;;){

-		if(recv(schan, nil) < 0)

-			break;

-		if((n = write(afd, shm->buffer, SNBUF)) != SNBUF)

-			break;

-		qlock(&sndlock);

-		wpos += n;

-		qunlock(&sndlock);

+	inwidth = sc->width;

+	outcount = sc->length / stepscale;

+	sc->length = outcount;

+	sc->speed = Srate;

+	if (loadas8bit.value)

+		sc->width = 1;

+	else

+		sc->width = inwidth;

+	sc->stereo = 0;

+

+	if (stepscale == 1 && inwidth == 1 && sc->width == 1)

+	{

+// fast special case

+		for (i=0 ; i<outcount ; i++)

+			((signed char *)sc->data)[i]

+			= (int)( (unsigned char)(data[i]) - 128);

 	}

+	else

+	{

+// general case

+		samplefrac = 0;

+		fracstep = stepscale*256;

+		for (i=0 ; i<outcount ; i++)

+		{

+			srcsample = samplefrac >> 8;

+			samplefrac += fracstep;

+			if (inwidth == 2)

+				sample = LittleShort ( ((short *)data)[srcsample] );

+			else

+				sample = (int)( (unsigned char)(data[srcsample]) - 128) << 8;

+			if (sc->width == 2)

+				((short *)sc->data)[i] = sample;

+			else

+				((signed char *)sc->data)[i] = sample >> 8;

+		}

+	}

 }

-qboolean

-SNDDMA_Init(void)

+static short

+GetLittleShort(void)

 {

-	if((afd = open("/dev/audio", OWRITE)) < 0){

-		fprint(2, "open: %r\n");

-		return 0;

+	short val;

+

+	val = *data_p;

+	val = val + (*(data_p+1)<<8);

+	data_p += 2;

+	return val;

+}

+

+static int

+GetLittleLong(void)

+{

+	int val;

+

+	val = *data_p;

+	val = val + (*(data_p+1)<<8);

+	val = val + (*(data_p+2)<<16);

+	val = val + (*(data_p+3)<<24);

+	data_p += 4;

+	return val;

+}

+

+static void

+FindNextChunk(char *name)

+{

+	int iff_chunk_len;

+

+	while (1)

+	{

+		data_p=last_chunk;

+

+		if (data_p >= iff_end)

+		{	// didn't find the chunk

+			data_p = nil;

+			return;

+		}

+		

+		data_p += 4;

+		iff_chunk_len = GetLittleLong();

+		if (iff_chunk_len < 0)

+		{

+			data_p = nil;

+			return;

+		}

+//		if (iff_chunk_len > 1024*1024)

+//			fatal ("FindNextChunk: %d length is past the 1 meg sanity limit", iff_chunk_len);

+		data_p -= 8;

+		last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );

+		if(strncmp((char *)data_p, name, 4) == 0)

+			return;

 	}

+}

-	shm = &sn;

-	shm->splitbuffer = 0;

-	shm->submission_chunk = 1;

-	shm->samplebits = SAMPLESZ;

-	shm->speed = RATE;

-	shm->channels = 2;

-	shm->samples = NSAMPLE;

-	shm->samplepos = 0;

-	if((shm->buffer = mallocz(SNBUF, 1)) == nil)

-		sysfatal("mallocz: %r\n");

+static void

+FindChunk(char *name)

+{

+	last_chunk = iff_data;

+	FindNextChunk (name);

+}

-	wpos = 0;

-	if((schan = chancreate(sizeof(int), Nbuf)) == nil)

-		sysfatal("SNDDMA_Init:chancreate: %r");

-	if((stid = proccreate(sproc, nil, 8192)) < 0)

-		sysfatal("SNDDMA_Init:proccreate: %r");

-	return 1;

+static wavinfo_t

+GetWavinfo(char *name, byte *wav, vlong wavlength)

+{

+	wavinfo_t	info;

+	int     i;

+	int     format;

+	int		samples;

+

+	memset(&info, 0, sizeof info);

+

+	if (!wav)

+		return info;

+		

+	iff_data = wav;

+	iff_end = wav + wavlength;

+

+// find "RIFF" chunk

+	FindChunk("RIFF");

+	if(!(data_p && strncmp((char *)data_p+8, "WAVE", 4) == 0))

+	{

+		Con_Printf("Missing RIFF/WAVE chunks\n");

+		return info;

+	}

+

+// get "fmt " chunk

+	iff_data = data_p + 12;

+

+	FindChunk("fmt ");

+	if (!data_p)

+	{

+		Con_Printf("Missing fmt chunk\n");

+		return info;

+	}

+	data_p += 8;

+	format = GetLittleShort();

+	if (format != 1)

+	{

+		Con_Printf("Microsoft PCM format only\n");

+		return info;

+	}

+

+	info.channels = GetLittleShort();

+	info.rate = GetLittleLong();

+	data_p += 4+2;

+	info.width = GetLittleShort() / 8;

+

+// get cue chunk

+	FindChunk("cue ");

+	if (data_p)

+	{

+		data_p += 32;

+		info.loopofs = GetLittleLong();

+

+	// if the next chunk is a LIST chunk, look for a cue length marker

+		FindNextChunk ("LIST");

+		if (data_p)

+		{

+			if(strncmp((char *)data_p+28, "mark", 4) == 0)

+			{	// this is not a proper parse, but it works with cooledit...

+				data_p += 24;

+				i = GetLittleLong ();	// samples in loop

+				info.samples = info.loopofs + i;

+//				Con_Printf("looped length: %d\n", i);

+			}

+		}

+	}

+	else

+		info.loopofs = -1;

+

+// find data chunk

+	FindChunk("data");

+	if (!data_p)

+	{

+		Con_Printf("Missing data chunk\n");

+		return info;

+	}

+

+	data_p += 4;

+	samples = GetLittleLong () / info.width;

+

+	if (info.samples)

+	{

+		if (samples < info.samples)

+			fatal ("Sound %s has a bad loop length", name);

+	}

+	else

+		info.samples = samples;

+

+	info.dataofs = data_p - wav;

+	

+	return info;

 }

-uint

-SNDDMA_GetDMAPos(void)

+static sfxcache_t *

+loadsfx(Sfx *sfx)

 {

-	if(stid < 0)

-		return 0;

-	qlock(&sndlock);

-	shm->samplepos = wpos / SAMPLEB;

-	qunlock(&sndlock);

-	return shm->samplepos;

+	wavinfo_t info;

+	int len;

+	float stepscale;

+	sfxcache_t *sc;

+	uchar *u, buf[1024];	/* avoid dirtying the cache heap */

+

+	if(sc = Cache_Check(&sfx->cu), sc != nil)

+		return sc;

+	u = loadstklmp(va("sound/%s", sfx->s), buf, sizeof buf, &len);

+	if(u == nil){

+		fprint(2, "loadsfx: %r\n");

+		return nil;

+	}

+	info = GetWavinfo(sfx->s, u, len);

+	if(info.channels != 1){

+		fprint(2, "loadsfx: non mono wave %s\n", sfx->s);

+		return nil;

+	}

+	stepscale = (float)info.rate / Srate;	

+	len = info.samples / stepscale;

+	len *= info.width * info.channels;

+	if(sc = Cache_Alloc(&sfx->cu, len + sizeof *sc, sfx->s), sc == nil)

+		return nil;

+	sc->length = info.samples;

+	sc->loop = info.loopofs;

+	if(info.loopofs >= 0)

+		sc->loop /= stepscale;

+	sc->speed = info.rate;

+	sc->width = info.width;

+	sc->stereo = info.channels;

+	resample(sc, u + info.dataofs, stepscale);

+	return sc;

 }

+static void

+sndout(void)

+{

+	int v, vol, *pb, *pe;

+	uchar *p;

+

+	vol = volume.value * 256;

+	p = mixbuf;

+	pb = sampbuf;

+	pe = sampbuf + nsamp * 2;

+	while(pb < pe){

+		v = *pb++ * vol >> 8;

+		if(v > 0x7fff)

+			v = 0x7fff;

+		else if(v < -0x8000)

+			v = -0x8000;

+		p[0] = v;

+		p[1] = v >> 8;

+		p += 2;

+	}

+}

+

+static void

+sample8(Chan *c, void *d, int n)

+{

+	int v, *pb, *pe, *ls, *rs;

+	uchar *p;

+

+	if(c->lvol > 255)

+		c->lvol = 255;

+	if(c->rvol > 255)

+		c->rvol = 255;

+	ls = scalt[c->lvol >> 3];

+	rs = scalt[c->rvol >> 3];

+	p = (uchar *)d + c->p;

+	pb = sampbuf;

+	pe = sampbuf + n * 2;

+	while(pb < pe){

+		v = *p++;

+		*pb++ += ls[v];

+		*pb++ += rs[v];

+	}

+}

+

+static void

+sample16(Chan *c, void *d, int n)

+{

+	int v, *pb, *pe, lv, rv;

+	short *p;

+

+	lv = c->lvol;

+	rv = c->rvol;

+	p = (short *)d + c->p;

+	pb = sampbuf;

+	pe = sampbuf + n * 2;

+	while(pb < pe){

+		v = *p++;

+		*pb++ += v * lv >> 8;

+		*pb++ += v * rv >> 8;

+	}

+}

+

+static void

+samplesfx(void)

+{

+	int n, m;

+	Chan *c;

+	sfxcache_t *sc;

+	void (*sf)(Chan *, void *, int);

+

+	memset(sampbuf, 0, sizeof sampbuf);

+	for(c=chans; c<che; c++){

+		if(c->sfx == nil)

+			continue;

+		if(c->lvol == 0 && c->rvol == 0)

+			continue;

+		if(sc = loadsfx(c->sfx), sc == nil)

+			continue;

+		sf = sc->width == 1 ? sample8 : sample16;

+		n = nsamp;

+		while(n > 0){

+			m = n < c->n ? n : c->n;

+			if(m > 0)

+				sf(c, sc->data, m);

+			c->p += m;

+			c->n -= m;

+			n -= m;

+			if(c->n <= 0){

+				if(sc->loop >= 0){

+					c->p = sc->loop;

+					c->n = sc->length - c->p;

+				}else{

+					c->sfx = nil;

+					break;

+				}

+			}

+		}

+	}

+	sndout();

+}

+

+static void

+spatialize(Chan *c)

+{

+	vec_t Δr, m;

+	vec3_t src;

+

+	if(c->entn == cl.viewentity){

+		c->lvol = c->chvol;

+		c->rvol = c->chvol;

+		return;

+	}

+	VectorSubtract(c->zp, listener_origin, src);

+	Δr = 1.0 - VectorNormalize(src) * c->attf;

+	m = DotProduct(listener_right, src);

+	c->rvol = Δr * (1.0 + m) * c->chvol;

+	if(c->rvol < 0)

+		c->rvol = 0;

+	c->lvol = Δr * (1.0 - m) * c->chvol;

+	if(c->lvol < 0)

+		c->lvol = 0;

+}

+

+static void

+ambs(void)

+{

+	uchar *av;

+	float vol;

+	Chan *c, *e;

+	mleaf_t *l;

+	Sfx **sfx;

+

+	if(cl.worldmodel == nil)

+		return;

+	c = chans;

+	e = chans + Namb;

+	l = Mod_PointInLeaf(listener_origin, cl.worldmodel);

+	if(l == nil || !ambient_level.value){

+		while(c < e)

+			c++->sfx = nil;

+		return;

+	}

+	sfx = ambsfx;

+	av = l->ambient_sound_level;

+	while(c < e){

+		c->sfx = *sfx++;

+		vol = ambient_level.value * *av++;

+		if(vol < 8)

+			vol = 0;

+		if(c->chvol < vol){

+			c->chvol += host_frametime * ambient_fade.value;

+			if(c->chvol > vol)

+				c->chvol = vol;

+		}else if(c->chvol > vol){

+			c->chvol -= host_frametime * ambient_fade.value;

+			if(c->chvol < vol)

+				c->chvol = vol;

+		}

+		c->lvol = c->chvol;

+		c->rvol = c->chvol;

+		c++;

+	}

+}

+

 void

-SNDDMA_Shutdown(void)

+stepsnd(vec3_t origin, vec3_t forward, vec3_t right, vec3_t up)

 {

-	if(stid < 0)

+	Chan *c, *sum;

+

+	if(afd < 0)

 		return;

+	VectorCopy(origin, listener_origin);

+	VectorCopy(forward, listener_forward);

+	VectorCopy(right, listener_right);

+	VectorCopy(up, listener_up);

+	ambs();

+	sum = nil;

+	for(c=chans+Namb; c<che; c++){

+		if(c->sfx == nil)

+			continue;

+		spatialize(c);

+		if(c->lvol == 0 && c->rvol == 0)

+			continue;

+		/* sum static sounds to avoid useless remixing */

+		if(c >= chans + Sstat){

+			if(sum != nil && sum->sfx == c->sfx){

+				sum->lvol += c->lvol;

+				sum->rvol += c->rvol;

+				c->lvol = c->rvol = 0;

+				continue;

+			}

+			for(sum=chans + Sstat; sum<c; sum++)

+				if(sum->sfx == c->sfx)

+					break;

+			if(sum == che)

+				sum = nil;

+			else if(sum != c){

+				sum->lvol += c->lvol;

+				sum->rvol += c->rvol;

+				c->lvol = c->rvol = 0;

+			}

+		}

+	}

+	if(sndt == 0)

+		sndt = nsec() - Te9 / Fpsmax;

+	nsamp = (nsec() - sndt) / (Te9 / Srate);

+	if(!cls.timedemo)

+		nsamp = nsamp + 15 & ~15;

+	if(nsamp > Ssamp)

+		nsamp = Ssamp;

+	samplesfx();

+	sampt += nsamp;

+	nsamp *= Sblk;

+	if(write(afd, mixbuf, nsamp) != nsamp){

+		fprint(2, "sndwrite: %r\n");

+		shutsnd();

+	}

+	sndt = nsec();

+}

-	threadint(stid);

-	stid = -1;

-	close(afd);

-	free(shm->buffer);

-	if(schan != nil)

-		chanfree(schan);

-	schan = nil;

+void

+stopallsfx(void)

+{

+	if(afd < 0)

+		return;

+	memset(chans, 0, sizeof chans);

+	che = chans + Sstat;

 }

 void

-SNDDMA_Submit(void)

+stopsfx(int n, int ch)

 {

-	if(nbsend(schan, nil) < 0){

-		fprint(2, "SNDDMA_Submit:nbsend: %r\n");

-		SNDDMA_Shutdown();

+	Chan *c, *e;

+

+	if(afd < 0)

+		return;

+	c = chans;

+	e = chans + Ndyn;

+	while(c < e){

+		if(c->entn == n && c->entch == ch){

+			c->sfx = nil;

+			return;

+		}

+		c++;

 	}

+}

+

+static Chan *

+pickchan(int entn, int entch)

+{

+	int Δt;

+	Chan *c, *p, *e;

+

+	p = nil;

+	Δt = 0x7fffffff;

+	for(c=chans+Namb, e=c+Ndyn; c<e; c++){

+		if(entch != 0 && c->entn == entn

+		&& (c->entch == entch || entch == -1)){

+			p = c;

+			break;

+		}

+		if(c->entn == cl.viewentity && entn != cl.viewentity && c->sfx != nil)

+			continue;

+		if(c->n < Δt){

+			Δt = c->n;

+			p = c;

+		}

+	}

+	if(p != nil)

+		p->sfx = nil;

+	return p;

+}       

+

+void

+startsfx(int entn, int entch, Sfx *sfx, vec3_t zp, float vol, float att)

+{

+	int skip;

+	Chan *c, *c2, *e;

+	sfxcache_t *sc;

+

+	if(afd < 0 || sfx == nil)

+		return;

+	if(c = pickchan(entn, entch), c == nil)

+		return;

+	memset(c, 0, sizeof *c);

+	VectorCopy(zp, c->zp);

+	c->attf = att / Clipdist;

+	c->chvol = vol * 255;

+	c->entn = entn;

+	c->entch = entch;

+	spatialize(c);

+	if(c->lvol == 0 && c->rvol == 0)

+		return;

+	if(sc = loadsfx(sfx), sc == nil)

+		return;

+	c->sfx = sfx;

+	c->p = 0;

+	c->n = sc->length;

+	/* don't sum identical sfx started on the same frame */

+	for(c2=chans+Namb, e=chans+Sstat; c2<e; c2++){

+		if(c2 == c || c2->sfx != sfx || c2->p != 0)

+			continue;

+		skip = nrand(Srate / Fpsmin);

+		if(skip >= c->n)

+			skip = c->n - 1;

+		c->p += skip;

+		c->n -= skip;

+		break;

+	}

+}

+

+void

+localsfx(char *s)

+{

+	Sfx *sfx;

+

+	if(afd < 0)

+		return;

+	sfx = precachesfx(s);

+	startsfx(cl.viewentity, -1, sfx, vec3_origin, 1, 1);

+}

+

+void

+staticsfx(Sfx *sfx, vec3_t zp, float vol, float att)

+{

+	Chan *c;

+	sfxcache_t *sc;

+

+	if(sfx == nil)

+		return;

+	if(che >= chans + nelem(chans)){

+		fprint(2, "staticsfx: channel overflow\n");

+		return;

+	}

+	c = che++;

+	if(sc = loadsfx(sfx), sc == nil)

+		return;

+	if(sc->loop < 0){

+		fprint(2, "staticsfx %s: nonlooped static sound\n", sfx->s);

+		return;

+	}

+	c->sfx = sfx;

+	VectorCopy(zp, c->zp);

+	c->chvol = vol;

+	c->attf = (att / 64) / Clipdist;

+	c->n = sc->length;

+	spatialize(c);

+}

+

+static Sfx *

+findsfx(char *s)

+{

+	Sfx *sfx, *e;

+

+	if(s == nil)

+		fatal("findsfx: nil pointer\n");

+	if(strlen(s) >= Npath)

+		fatal("findsfx: path too long %s", s);

+	sfx = known_sfx;

+	e = known_sfx + num_sfx;

+	while(sfx < e){

+		if(strcmp(sfx->s, s) == 0)

+			return sfx;

+		sfx++;

+	}

+	if(num_sfx == MAX_SFX)

+		fatal("findsfx: sfx list overflow");

+	strcpy(sfx->s, s);

+	num_sfx++;

+	return sfx;

+}

+

+void

+touchsfx(char *s)

+{

+	Sfx *sfx;

+

+	if(afd < 0)

+		return;

+	sfx = findsfx(s);

+	Cache_Check(&sfx->cu);

+}

+

+Sfx *

+precachesfx(char *s)

+{

+	Sfx *sfx;

+

+	if(afd < 0)

+		return nil;

+	sfx = findsfx(s);

+	if(precache.value)

+		loadsfx(sfx);

+	return sfx;

+}

+

+static void

+playsfx(void)

+{

+	static int hash = 345;

+	int i;

+	char *s;

+	Sfx *sfx;

+

+	if(Cmd_Argc() < 2){

+		Con_Printf("play wav [wav..]: play a wav lump\n");

+		return;

+	}

+	i = 1;

+	while(i < Cmd_Argc()){

+		if(strrchr(Cmd_Argv(i), '.') == nil)

+			s = va("%s.wav", Cmd_Argv(i));

+		else

+			s = Cmd_Argv(i);

+		sfx = precachesfx(s);

+		startsfx(hash++, 0, sfx, listener_origin, 1.0, 1.0);

+		i++;

+	}

+}

+

+static void

+playvolsfx(void)

+{

+	static int hash = 543;

+	int i;

+	float vol;

+	char *s;

+	Sfx *sfx;

+

+	if(Cmd_Argc() < 3){

+		Con_Printf("play wav vol [wav vol]..: play an amplified wav lump\n");

+		return;

+	}

+	i = 1;

+	while(i < Cmd_Argc()){

+		if(strrchr(Cmd_Argv(i), '.') == nil)

+			s = va("%s.wav", Cmd_Argv(i));

+		else

+			s = Cmd_Argv(i);

+		sfx = precachesfx(s);

+		vol = atof(Cmd_Argv(++i));

+		startsfx(hash++, 0, sfx, listener_origin, vol, 1.0);

+		i++;

+	}

+}

+

+static void

+sfxlist(void)

+{

+	char c;

+	int sz, sum;

+	Sfx *sfx, *e;

+	sfxcache_t *sc;

+

+	sum = 0;

+	for(sfx=known_sfx, e=known_sfx+num_sfx; sfx<e; sfx++){

+		if(sc = Cache_Check(&sfx->cu), sc == nil)

+			continue;

+		sz = sc->length * sc->width * (sc->stereo + 1);

+		sum += sz;

+		c = sc->loop >= 0 ? 'L' : ' ';

+		Con_Printf("%c(%2db) %6d : %s\n", c, sc->width * 8, sz, sfx->s);

+	}

+	Con_Printf("Total resident: %d\n", sum);

+}

+

+void

+shutsnd(void)

+{

+	if(afd < 0)

+		return;

+	close(afd);

+}

+

+int

+initsnd(void)

+{

+	int i, j, *p;

+

+	if(afd = open("/dev/audio", OWRITE), afd < 0)

+		return -1;

+	for(p=scalt[1], i=8; i<8*nelem(scalt); i+=8)

+		for(j=0; j<256; j++)

+			*p++ = (char)j * i;

+	Cmd_AddCommand("play", playsfx);

+	Cmd_AddCommand("playvol", playvolsfx);

+	Cmd_AddCommand("stopsound", stopallsfx);

+	Cmd_AddCommand("soundlist", sfxlist);

+	Cvar_RegisterVariable(&volume);

+	Cvar_RegisterVariable(&precache);

+	Cvar_RegisterVariable(&loadas8bit);

+	Cvar_RegisterVariable(&bgmvolume);

+	Cvar_RegisterVariable(&ambient_level);

+	Cvar_RegisterVariable(&ambient_fade);

+

+	if(host_parms.memsize < 0x800000){

+		setcvar("loadas8bit", "1");

+		fprint(2, "initsnd: forcing 8bit width\n");

+	}

+	known_sfx = Hunk_AllocName(MAX_SFX * sizeof *known_sfx, "Sfx");

+	num_sfx = 0;

+	ambsfx[Ambwater] = precachesfx("ambience/water1.wav");

+	ambsfx[Ambsky] = precachesfx("ambience/wind2.wav");

+	stopallsfx();

+	return 0;

 }

--- a/snd_dma.c

+++ /dev/null

@@ -1,916 +1,0 @@

-#include <u.h>

-#include <libc.h>

-#include "dat.h"

-#include "quakedef.h"

-#include "fns.h"

-

-void S_Play(void);

-void S_PlayVol(void);

-void S_SoundList(void);

-void S_Update_(void);

-void S_StopAllSounds(qboolean clear);

-void S_StopAllSoundsC(void);

-

-// =======================================================================

-// Internal sound data & structures

-// =======================================================================

-

-channel_t   channels[MAX_CHANNELS];

-int			total_channels;

-

-int				snd_blocked = 0;

-static qboolean	snd_ambient = 1;

-static qboolean	snd_initialized;

-

-// pointer should go away

-volatile dma_t *shm;

-volatile dma_t sn;

-

-vec3_t		listener_origin;

-vec3_t		listener_forward;

-vec3_t		listener_right;

-vec3_t		listener_up;

-vec_t		sound_nominal_clip_dist=1000.0;

-

-int			soundtime;		// sample PAIRS

-int   		paintedtime; 	// sample PAIRS

-

-

-#define	MAX_SFX		512

-sfx_t		*known_sfx;		// hunk allocated [MAX_SFX]

-int			num_sfx;

-

-sfx_t		*ambient_sfx[NUM_AMBIENTS];

-

-int 		desired_speed = 11025;

-int 		desired_bits = 16;

-

-int sound_started=0;

-

-cvar_t bgmvolume = {"bgmvolume", "1", true};

-cvar_t volume = {"volume", "0.7", true};

-

-cvar_t nosound = {"nosound", "0"};

-cvar_t precache = {"precache", "1"};

-cvar_t loadas8bit = {"loadas8bit", "0"};

-cvar_t bgmbuffer = {"bgmbuffer", "4096"};

-cvar_t ambient_level = {"ambient_level", "0.3"};

-cvar_t ambient_fade = {"ambient_fade", "100"};

-cvar_t snd_noextraupdate = {"snd_noextraupdate", "0"};

-cvar_t snd_show = {"snd_show", "0"};

-cvar_t _snd_mixahead = {"_snd_mixahead", "0.1", true};

-

-

-// ====================================================================

-// User-setable variables

-// ====================================================================

-

-

-//

-// Fake dma is a synchronous faking of the DMA progress used for

-// isolating performance in the renderer.  The fakedma_updates is

-// number of times S_Update() is called per second.

-//

-

-qboolean fakedma = false;

-int fakedma_updates = 15;

-

-

-void S_AmbientOff (void)

-{

-	snd_ambient = false;

-}

-

-

-void S_AmbientOn (void)

-{

-	snd_ambient = true;

-}

-

-

-void S_SoundInfo_f(void)

-{

-	if (!sound_started || !shm)

-	{

-		Con_Printf ("sound system not started\n");

-		return;

-	}

-

-    Con_Printf("%5d stereo\n", shm->channels - 1);

-    Con_Printf("%5d samples\n", shm->samples);

-    Con_Printf("%5d samplepos\n", shm->samplepos);

-    Con_Printf("%5d samplebits\n", shm->samplebits);

-    Con_Printf("%5d submission_chunk\n", shm->submission_chunk);

-    Con_Printf("%5d speed\n", shm->speed);

-    Con_Printf("%#p dma buffer\n", shm->buffer);

-	Con_Printf("%5d total_channels\n", total_channels);

-}

-

-

-/*

-================

-S_Startup

-================

-*/

-

-void S_Startup (void)

-{

-	int		rc;

-

-	if (!snd_initialized)

-		return;

-

-	if (!fakedma)

-	{

-		rc = SNDDMA_Init();

-

-		if (!rc)

-		{

-			Con_Printf("S_Startup: SNDDMA_Init failed.\n");

-			sound_started = 0;

-			return;

-		}

-	}

-

-	sound_started = 1;

-}

-

-

-/*

-================

-S_Init

-================

-*/

-void S_Init (void)

-{

-

-	Con_Printf("\nSound Initialization\n");

-

-	if (COM_CheckParm("-nosound"))

-		return;

-

-	if (COM_CheckParm("-simsound"))

-		fakedma = true;

-

-	Cmd_AddCommand("play", S_Play);

-	Cmd_AddCommand("playvol", S_PlayVol);

-	Cmd_AddCommand("stopsound", S_StopAllSoundsC);

-	Cmd_AddCommand("soundlist", S_SoundList);

-	Cmd_AddCommand("soundinfo", S_SoundInfo_f);

-

-	Cvar_RegisterVariable(&nosound);

-	Cvar_RegisterVariable(&volume);

-	Cvar_RegisterVariable(&precache);

-	Cvar_RegisterVariable(&loadas8bit);

-	Cvar_RegisterVariable(&bgmvolume);

-	Cvar_RegisterVariable(&bgmbuffer);

-	Cvar_RegisterVariable(&ambient_level);

-	Cvar_RegisterVariable(&ambient_fade);

-	Cvar_RegisterVariable(&snd_noextraupdate);

-	Cvar_RegisterVariable(&snd_show);

-	Cvar_RegisterVariable(&_snd_mixahead);

-

-	if (host_parms.memsize < 0x800000)

-	{

-		setcvar("loadas8bit", "1");

-		Con_Printf ("loading all sounds as 8bit\n");

-	}

-

-	snd_initialized = true;

-

-	S_Startup ();

-

-	SND_InitScaletable ();

-

-	known_sfx = Hunk_AllocName(MAX_SFX * sizeof *known_sfx, "sfx_t");

-	num_sfx = 0;

-

-// create a piece of DMA memory

-

-	if (fakedma)

-	{

-		shm = Hunk_AllocName(sizeof *shm, "shm");

-		shm->splitbuffer = 0;

-		shm->samplebits = 16;

-		shm->speed = 22050;

-		shm->channels = 2;

-		shm->samples = 32768;

-		shm->samplepos = 0;

-		shm->soundalive = true;

-		shm->gamealive = true;

-		shm->submission_chunk = 1;

-		shm->buffer = Hunk_AllocName(1<<16, "shmbuf");

-	}

-

-	if(shm != nil)

-		Con_Printf ("Sound sampling rate: %d\n", shm->speed);

-

-	// provides a tick sound until washed clean

-

-//	if (shm->buffer)

-//		shm->buffer[4] = shm->buffer[5] = 0x7f;	// force a pop for debugging

-

-	ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");

-	ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");

-

-	S_StopAllSounds (true);

-}

-

-

-// =======================================================================

-// Shutdown sound engine

-// =======================================================================

-

-void S_Shutdown(void)

-{

-	if(!sound_started)

-		return;

-	if(shm != nil)

-		shm->gamealive = 0;

-	if(!fakedma)

-		SNDDMA_Shutdown();

-	shm = nil;

-	sound_started = 0;

-}

-

-

-// =======================================================================

-// Load a sound

-// =======================================================================

-

-/*

-==================

-S_FindName

-

-==================

-*/

-sfx_t *S_FindName (char *name)

-{

-	int		i;

-	sfx_t	*sfx;

-

-	if (name == nil)

-		fatal ("S_FindName: NULL\n");

-

-	if(strlen(name) >= Npath)

-		fatal ("Sound name too long: %s", name);

-

-// see if already loaded

-	for (i=0 ; i < num_sfx ; i++)

-		if(strcmp(known_sfx[i].name, name) == 0)

-			return &known_sfx[i];

-

-	if (num_sfx == MAX_SFX)

-		fatal ("S_FindName: out of sfx_t");

-	

-	sfx = &known_sfx[i];

-	strcpy (sfx->name, name);

-

-	num_sfx++;

-	

-	return sfx;

-}

-

-

-/*

-==================

-S_TouchSound

-

-==================

-*/

-void S_TouchSound (char *name)

-{

-	sfx_t	*sfx;

-	

-	if (!sound_started)

-		return;

-

-	sfx = S_FindName (name);

-	Cache_Check (&sfx->cache);

-}

-

-/*

-==================

-S_PrecacheSound

-

-==================

-*/

-sfx_t *S_PrecacheSound (char *name)

-{

-	sfx_t	*sfx;

-

-	if (!sound_started || nosound.value)

-		return nil;

-

-	sfx = S_FindName (name);

-	

-// cache it in

-	if (precache.value)

-		S_LoadSound (sfx);

-	

-	return sfx;

-}

-

-

-//=============================================================================

-

-/*

-=================

-SND_PickChannel

-=================

-*/

-channel_t *SND_PickChannel(int entnum, int entchannel)

-{

-    int ch_idx;

-    int first_to_die;

-    int life_left;

-

-// Check for replacement sound, or find the best one to replace

-    first_to_die = -1;

-    life_left = 0x7fffffff;

-    for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++)

-    {

-		if (entchannel != 0		// channel 0 never overrides

-		&& channels[ch_idx].entnum == entnum

-		&& (channels[ch_idx].entchannel == entchannel || entchannel == -1) )

-		{	// allways 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.viewentity && entnum != cl.viewentity && channels[ch_idx].sfx)

-			continue;

-

-		if (channels[ch_idx].end - paintedtime < life_left)

-		{

-			life_left = channels[ch_idx].end - paintedtime;

-			first_to_die = ch_idx;

-		}

-   }

-

-	if (first_to_die == -1)

-		return nil;

-

-	if (channels[first_to_die].sfx)

-		channels[first_to_die].sfx = nil;

-

-    return &channels[first_to_die];    

-}       

-

-/*

-=================

-SND_Spatialize

-=================

-*/

-void SND_Spatialize(channel_t *ch)

-{

-    vec_t dot;

-    vec_t dist;

-    vec_t lscale, rscale, scale;

-    vec3_t source_vec;

-

-// anything coming from the view entity will allways be full volume

-	if (ch->entnum == cl.viewentity)

-	{

-		ch->leftvol = ch->master_vol;

-		ch->rightvol = ch->master_vol;

-		return;

-	}

-

-// calculate stereo seperation and distance attenuation

-

-	VectorSubtract(ch->origin, listener_origin, source_vec);

-	

-	dist = VectorNormalize(source_vec) * ch->dist_mult;

-	

-	dot = DotProduct(listener_right, source_vec);

-

-	if (shm->channels == 1)

-	{

-		rscale = 1.0;

-		lscale = 1.0;

-	}

-	else

-	{

-		rscale = 1.0 + dot;

-		lscale = 1.0 - dot;

-	}

-

-// add in distance effect

-	scale = (1.0 - dist) * rscale;

-	ch->rightvol = (int) (ch->master_vol * scale);

-	if (ch->rightvol < 0)

-		ch->rightvol = 0;

-

-	scale = (1.0 - dist) * lscale;

-	ch->leftvol = (int) (ch->master_vol * scale);

-	if (ch->leftvol < 0)

-		ch->leftvol = 0;

-}           

-

-

-// =======================================================================

-// Start a sound effect

-// =======================================================================

-

-void S_StartSound(int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol, float attenuation)

-{

-	channel_t *target_chan, *check;

-	sfxcache_t	*sc;

-	int		vol;

-	int		ch_idx;

-	int		skip;

-

-	if (!sound_started)

-		return;

-

-	if (!sfx)

-		return;

-

-	if (nosound.value)

-		return;

-

-	vol = fvol*255;

-

-// pick a channel to play on

-	target_chan = SND_PickChannel(entnum, entchannel);

-	if (!target_chan)

-		return;

-		

-// spatialize

-	memset(target_chan, 0, sizeof *target_chan);

-	VectorCopy(origin, target_chan->origin);

-	target_chan->dist_mult = attenuation / sound_nominal_clip_dist;

-	target_chan->master_vol = vol;

-	target_chan->entnum = entnum;

-	target_chan->entchannel = entchannel;

-	SND_Spatialize(target_chan);

-

-	if (!target_chan->leftvol && !target_chan->rightvol)

-		return;		// not audible at all

-

-// new channel

-	sc = S_LoadSound (sfx);

-	if (!sc)

-	{

-		target_chan->sfx = nil;

-		return;		// couldn't load the sound's data

-	}

-

-	target_chan->sfx = sfx;

-	target_chan->pos = 0.0;

-    target_chan->end = paintedtime + sc->length;	

-

-// if an identical sound has also been started this frame, offset the pos

-// a bit to keep it from just making the first one louder

-	check = &channels[NUM_AMBIENTS];

-    for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++, check++)

-    {

-		if (check == target_chan)

-			continue;

-		if (check->sfx == sfx && !check->pos)

-		{

-			skip = rand () % (int)(0.1*shm->speed);

-			if (skip >= target_chan->end)

-				skip = target_chan->end - 1;

-			target_chan->pos += skip;

-			target_chan->end -= skip;

-			break;

-		}

-		

-	}

-}

-

-void S_StopSound(int entnum, int entchannel)

-{

-	int i;

-

-	for (i=0 ; i<MAX_DYNAMIC_CHANNELS ; i++)

-	{

-		if (channels[i].entnum == entnum

-			&& channels[i].entchannel == entchannel)

-		{

-			channels[i].end = 0;

-			channels[i].sfx = nil;

-			return;

-		}

-	}

-}

-

-void S_StopAllSounds(qboolean clear)

-{

-	int		i;

-

-	if (!sound_started)

-		return;

-

-	total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;	// no statics

-

-	for (i=0 ; i<MAX_CHANNELS ; i++)

-		if (channels[i].sfx)

-			channels[i].sfx = nil;

-

-	memset(channels, 0, sizeof channels);

-

-	if (clear)

-		S_ClearBuffer ();

-}

-

-void S_StopAllSoundsC (void)

-{

-	S_StopAllSounds (true);

-}

-

-void S_ClearBuffer (void)

-{

-	int		clear;

-		

-	if (!sound_started || shm == nil || shm->buffer == nil)

-		return;

-

-	if (shm->samplebits == 8)

-		clear = 0x80;

-	else

-		clear = 0;

-

-	memset(shm->buffer, clear, shm->samples * shm->samplebits/8);

-}

-

-

-/*

-=================

-S_StaticSound

-=================

-*/

-void S_StaticSound (sfx_t *sfx, vec3_t origin, float vol, float attenuation)

-{

-	channel_t	*ss;

-	sfxcache_t		*sc;

-

-	if (!sfx)

-		return;

-

-	if (total_channels == MAX_CHANNELS)

-	{

-		Con_Printf ("total_channels == MAX_CHANNELS\n");

-		return;

-	}

-

-	ss = &channels[total_channels];

-	total_channels++;

-

-	sc = S_LoadSound (sfx);

-	if (!sc)

-		return;

-

-	if (sc->loopstart == -1)

-	{

-		Con_Printf ("Sound %s not looped\n", sfx->name);

-		return;

-	}

-	

-	ss->sfx = sfx;

-	VectorCopy (origin, ss->origin);

-	ss->master_vol = vol;

-	ss->dist_mult = (attenuation/64) / sound_nominal_clip_dist;

-    ss->end = paintedtime + sc->length;	

-	

-	SND_Spatialize (ss);

-}

-

-

-//=============================================================================

-

-/*

-===================

-S_UpdateAmbientSounds

-===================

-*/

-void S_UpdateAmbientSounds (void)

-{

-	mleaf_t		*l;

-	float		vol;

-	int			ambient_channel;

-	channel_t	*chan;

-

-	if (!snd_ambient)

-		return;

-

-// calc ambient sound levels

-	if (!cl.worldmodel)

-		return;

-

-	l = Mod_PointInLeaf (listener_origin, cl.worldmodel);

-	if (!l || !ambient_level.value)

-	{

-		for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++)

-			channels[ambient_channel].sfx = nil;

-		return;

-	}

-

-	for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++)

-	{

-		chan = &channels[ambient_channel];	

-		chan->sfx = ambient_sfx[ambient_channel];

-	

-		vol = ambient_level.value * l->ambient_sound_level[ambient_channel];

-		if (vol < 8)

-			vol = 0;

-

-	// don't adjust volume too fast

-		if (chan->master_vol < vol)

-		{

-			chan->master_vol += host_frametime * ambient_fade.value;

-			if (chan->master_vol > vol)

-				chan->master_vol = vol;

-		}

-		else if (chan->master_vol > vol)

-		{

-			chan->master_vol -= host_frametime * ambient_fade.value;

-			if (chan->master_vol < vol)

-				chan->master_vol = vol;

-		}

-		

-		chan->leftvol = chan->rightvol = chan->master_vol;

-	}

-}

-

-

-/*

-============

-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, j;

-	int			total;

-	channel_t	*ch;

-	channel_t	*combine;

-

-	if (!sound_started || (snd_blocked > 0))

-		return;

-

-	VectorCopy(origin, listener_origin);

-	VectorCopy(forward, listener_forward);

-	VectorCopy(right, listener_right);

-	VectorCopy(up, listener_up);

-	

-// update general area ambient sound sources

-	S_UpdateAmbientSounds ();

-

-	combine = nil;

-

-// update spatialization for static and dynamic sounds	

-	ch = channels+NUM_AMBIENTS;

-	for (i=NUM_AMBIENTS ; i<total_channels; i++, ch++)

-	{

-		if (!ch->sfx)

-			continue;

-		SND_Spatialize(ch);         // respatialize channel

-		if (!ch->leftvol && !ch->rightvol)

-			continue;

-

-	// try to combine static sounds with a previous channel of the same

-	// sound effect so we don't mix five torches every frame

-	

-		if (i >= MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS)

-		{

-		// see if it can just use the last one

-			if (combine && combine->sfx == ch->sfx)

-			{

-				combine->leftvol += ch->leftvol;

-				combine->rightvol += ch->rightvol;

-				ch->leftvol = ch->rightvol = 0;

-				continue;

-			}

-		// search for one

-			combine = channels+MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;

-			for (j=MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS ; j<i; j++, combine++)

-				if (combine->sfx == ch->sfx)

-					break;

-					

-			if (j == total_channels)

-			{

-				combine = nil;

-			}

-			else

-			{

-				if (combine != ch)

-				{

-					combine->leftvol += ch->leftvol;

-					combine->rightvol += ch->rightvol;

-					ch->leftvol = ch->rightvol = 0;

-				}

-				continue;

-			}

-		}

-		

-		

-	}

-

-//

-// debugging output

-//

-	if (snd_show.value)

-	{

-		total = 0;

-		ch = channels;

-		for (i=0 ; i<total_channels; i++, ch++)

-			if (ch->sfx && (ch->leftvol || ch->rightvol) )

-			{

-				//Con_Printf ("%3d %3d %s\n", ch->leftvol, ch->rightvol, ch->sfx->name);

-				total++;

-			}

-		

-		Con_Printf ("----(%d)----\n", total);

-	}

-

-// mix some sound

-	S_Update_();

-}

-

-void GetSoundtime(void)

-{

-	uint		samplepos;

-	static	int		buffers;

-	static	uint		oldsamplepos;

-	int		fullsamples;

-	

-	fullsamples = shm->samples / shm->channels;

-

-// 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 = 0;

-			paintedtime = fullsamples;

-			S_StopAllSounds (true);

-		}

-	}

-	oldsamplepos = samplepos;

-

-	soundtime = buffers*fullsamples + samplepos/shm->channels;

-}

-

-void S_ExtraUpdate (void)

-{

-

-	if (snd_noextraupdate.value)

-		return;		// don't pollute timings

-	S_Update_();

-}

-

-void S_Update_(void)

-{

-	unsigned        endtime;

-	int				samps;

-	

-	if (!sound_started || (snd_blocked > 0))

-		return;

-

-// Updates DMA time

-	GetSoundtime();

-

-// check to make sure that we haven't overshot

-	if (paintedtime < soundtime)

-	{

-		//Con_Printf ("S_Update_ : overflow\n");

-		paintedtime = soundtime;

-	}

-

-// mix ahead of current position

-	endtime = soundtime + _snd_mixahead.value * shm->speed;

-	samps = shm->samples >> (shm->channels-1);

-	if (endtime - soundtime > samps)

-		endtime = soundtime + samps;

-

-	S_PaintChannels (endtime);

-

-	SNDDMA_Submit ();

-}

-

-/*

-===============================================================================

-

-console functions

-

-===============================================================================

-*/

-

-void S_Play(void)

-{

-	static int hash=345;

-	int 	i;

-	char name[256];

-	sfx_t	*sfx;

-	

-	i = 1;

-	while (i<Cmd_Argc())

-	{

-		if(strrchr(Cmd_Argv(i), '.') == nil)

-		{

-			strcpy(name, Cmd_Argv(i));

-			strcat(name, ".wav");

-		}

-		else

-			strcpy(name, Cmd_Argv(i));

-		sfx = S_PrecacheSound(name);

-		S_StartSound(hash++, 0, sfx, listener_origin, 1.0, 1.0);

-		i++;

-	}

-}

-

-void S_PlayVol(void)

-{

-	static int hash=543;

-	int i;

-	float vol;

-	char name[256];

-	sfx_t	*sfx;

-	

-	i = 1;

-	while (i<Cmd_Argc())

-	{

-		if(strrchr(Cmd_Argv(i), '.') == nil)

-		{

-			strcpy(name, Cmd_Argv(i));

-			strcat(name, ".wav");

-		}

-		else

-			strcpy(name, Cmd_Argv(i));

-		sfx = S_PrecacheSound(name);

-		vol = atof(Cmd_Argv(i+1));

-		S_StartSound(hash++, 0, sfx, listener_origin, vol, 1.0);

-		i+=2;

-	}

-}

-

-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 = Cache_Check (&sfx->cache);

-		if (!sc)

-			continue;

-		size = sc->length*sc->width*(sc->stereo+1);

-		total += size;

-		if (sc->loopstart >= 0)

-			Con_Printf ("L");

-		else

-			Con_Printf (" ");

-		Con_Printf("(%2db) %6d : %s\n",sc->width*8,  size, sfx->name);

-	}

-	Con_Printf ("Total resident: %d\n", total);

-}

-

-

-void S_LocalSound (char *sound)

-{

-	sfx_t	*sfx;

-

-	if (nosound.value)

-		return;

-	if (!sound_started)

-		return;

-		

-	sfx = S_PrecacheSound (sound);

-	if (!sfx)

-	{

-		Con_Printf ("S_LocalSound: can't cache %s\n", sound);

-		return;

-	}

-	S_StartSound (cl.viewentity, -1, sfx, vec3_origin, 1, 1);

-}

-

-

-void S_ClearPrecache (void)

-{

-}

-

-

-void S_BeginPrecaching (void)

-{

-}

-

-

-void S_EndPrecaching (void)

-{

-}

-

--- a/snd_mem.c

+++ /dev/null

@@ -1,324 +1,0 @@

-#include <u.h>

-#include <libc.h>

-#include "dat.h"

-#include "quakedef.h"

-#include "fns.h"

-

-int			cache_full_cycle;

-

-byte *S_Alloc (int size);

-

-/*

-================

-ResampleSfx

-================

-*/

-void ResampleSfx (sfx_t *sfx, int inrate, int inwidth, byte *data)

-{

-	int		outcount;

-	int		srcsample;

-	float	stepscale;

-	int		i;

-	int		sample, samplefrac, fracstep;

-	sfxcache_t	*sc;

-	

-	sc = Cache_Check (&sfx->cache);

-	if (!sc)

-		return;

-

-	stepscale = (float)inrate / shm->speed;	// this is usually 0.5, 1, or 2

-

-	outcount = sc->length / stepscale;

-	sc->length = outcount;

-	if (sc->loopstart != -1)

-		sc->loopstart = sc->loopstart / stepscale;

-

-	sc->speed = shm->speed;

-	if (loadas8bit.value)

-		sc->width = 1;

-	else

-		sc->width = inwidth;

-	sc->stereo = 0;

-

-// resample / decimate to the current source rate

-

-	if (stepscale == 1 && inwidth == 1 && sc->width == 1)

-	{

-// fast special case

-		for (i=0 ; i<outcount ; i++)

-			((signed char *)sc->data)[i]

-			= (int)( (unsigned char)(data[i]) - 128);

-	}

-	else

-	{

-// general case

-		samplefrac = 0;

-		fracstep = stepscale*256;

-		for (i=0 ; i<outcount ; i++)

-		{

-			srcsample = samplefrac >> 8;

-			samplefrac += fracstep;

-			if (inwidth == 2)

-				sample = LittleShort ( ((short *)data)[srcsample] );

-			else

-				sample = (int)( (unsigned char)(data[srcsample]) - 128) << 8;

-			if (sc->width == 2)

-				((short *)sc->data)[i] = sample;

-			else

-				((signed char *)sc->data)[i] = sample >> 8;

-		}

-	}

-}

-

-//=============================================================================

-

-/*

-==============

-S_LoadSound

-==============

-*/

-sfxcache_t *S_LoadSound (sfx_t *s)

-{

-    char	namebuffer[256];

-	byte	*data;

-	wavinfo_t	info;

-	int		len;

-	float	stepscale;

-	sfxcache_t	*sc;

-	byte	stackbuf[1*1024];		// avoid dirtying the cache heap

-

-// see if still in memory

-	sc = Cache_Check (&s->cache);

-	if (sc)

-		return sc;

-

-//Con_Printf ("S_LoadSound: %x\n", (int)stackbuf);

-// load it in

-	strcpy(namebuffer, "sound/");

-	strcat(namebuffer, s->name);

-

-//	Con_Printf ("loading %s\n",namebuffer);

-

-	data = loadstklmp(namebuffer, stackbuf, sizeof stackbuf, &len);

-	if(data == nil){

-		Con_Printf("Couldn't load %s: %r\n", namebuffer);

-		return nil;

-	}

-

-	info = GetWavinfo (s->name, data, len);

-	if (info.channels != 1)

-	{

-		Con_Printf ("%s is a stereo sample\n",s->name);

-		return nil;

-	}

-

-	stepscale = (float)info.rate / shm->speed;	

-	len = info.samples / stepscale;

-

-	len = len * info.width * info.channels;

-

-	sc = Cache_Alloc(&s->cache, len + sizeof *sc, s->name);

-	if (!sc)

-		return nil;

-	

-	sc->length = info.samples;

-	sc->loopstart = info.loopstart;

-	sc->speed = info.rate;

-	sc->width = info.width;

-	sc->stereo = info.channels;

-

-	ResampleSfx (s, sc->speed, sc->width, data + info.dataofs);

-

-	return sc;

-}

-

-

-

-/*

-===============================================================================

-

-WAV loading

-

-===============================================================================

-*/

-

-

-byte	*data_p;

-byte 	*iff_end;

-byte 	*last_chunk;

-byte 	*iff_data;

-int 	iff_chunk_len;

-

-

-short GetLittleShort(void)

-{

-	short val;

-

-	val = *data_p;

-	val = val + (*(data_p+1)<<8);

-	data_p += 2;

-	return val;

-}

-

-int GetLittleLong(void)

-{

-	int val;

-

-	val = *data_p;

-	val = val + (*(data_p+1)<<8);

-	val = val + (*(data_p+2)<<16);

-	val = val + (*(data_p+3)<<24);

-	data_p += 4;

-	return val;

-}

-

-void FindNextChunk(char *name)

-{

-	while (1)

-	{

-		data_p=last_chunk;

-

-		if (data_p >= iff_end)

-		{	// didn't find the chunk

-			data_p = nil;

-			return;

-		}

-		

-		data_p += 4;

-		iff_chunk_len = GetLittleLong();

-		if (iff_chunk_len < 0)

-		{

-			data_p = nil;

-			return;

-		}

-//		if (iff_chunk_len > 1024*1024)

-//			fatal ("FindNextChunk: %d length is past the 1 meg sanity limit", iff_chunk_len);

-		data_p -= 8;

-		last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );

-		if(strncmp((char *)data_p, name, 4) == 0)

-			return;

-	}

-}

-

-void FindChunk(char *name)

-{

-	last_chunk = iff_data;

-	FindNextChunk (name);

-}

-

-

-void DumpChunks(void)

-{

-	char	str[5];

-	

-	str[4] = 0;

-	data_p=iff_data;

-	do

-	{

-		memcpy (str, data_p, 4);

-		data_p += 4;

-		iff_chunk_len = GetLittleLong();

-		Con_Printf ("0x%zud : %s (%d)\n", (uintptr)(data_p - 4), str, iff_chunk_len);

-		data_p += (iff_chunk_len + 1) & ~1;

-	} while (data_p < iff_end);

-}

-

-/*

-============

-GetWavinfo

-============

-*/

-wavinfo_t GetWavinfo (char *name, byte *wav, vlong wavlength)

-{

-	wavinfo_t	info;

-	int     i;

-	int     format;

-	int		samples;

-

-	memset(&info, 0, sizeof info);

-

-	if (!wav)

-		return info;

-		

-	iff_data = wav;

-	iff_end = wav + wavlength;

-

-// find "RIFF" chunk

-	FindChunk("RIFF");

-	if(!(data_p && strncmp((char *)data_p+8, "WAVE", 4) == 0))

-	{

-		Con_Printf("Missing RIFF/WAVE chunks\n");

-		return info;

-	}

-

-// get "fmt " chunk

-	iff_data = data_p + 12;

-// DumpChunks ();

-

-	FindChunk("fmt ");

-	if (!data_p)

-	{

-		Con_Printf("Missing fmt chunk\n");

-		return info;

-	}

-	data_p += 8;

-	format = GetLittleShort();

-	if (format != 1)

-	{

-		Con_Printf("Microsoft PCM format only\n");

-		return info;

-	}

-

-	info.channels = GetLittleShort();

-	info.rate = GetLittleLong();

-	data_p += 4+2;

-	info.width = GetLittleShort() / 8;

-

-// get cue chunk

-	FindChunk("cue ");

-	if (data_p)

-	{

-		data_p += 32;

-		info.loopstart = GetLittleLong();

-//		Con_Printf("loopstart=%d\n", sfx->loopstart);

-

-	// if the next chunk is a LIST chunk, look for a cue length marker

-		FindNextChunk ("LIST");

-		if (data_p)

-		{

-			if(strncmp((char *)data_p+28, "mark", 4) == 0)

-			{	// this is not a proper parse, but it works with cooledit...

-				data_p += 24;

-				i = GetLittleLong ();	// samples in loop

-				info.samples = info.loopstart + i;

-//				Con_Printf("looped length: %d\n", i);

-			}

-		}

-	}

-	else

-		info.loopstart = -1;

-

-// find data chunk

-	FindChunk("data");

-	if (!data_p)

-	{

-		Con_Printf("Missing data chunk\n");

-		return info;

-	}

-

-	data_p += 4;

-	samples = GetLittleLong () / info.width;

-

-	if (info.samples)

-	{

-		if (samples < info.samples)

-			fatal ("Sound %s has a bad loop length", name);

-	}

-	else

-		info.samples = samples;

-

-	info.dataofs = data_p - wav;

-	

-	return info;

-}

-

--- a/snd_mix.c

+++ /dev/null

@@ -1,278 +1,0 @@

-#include <u.h>

-#include <libc.h>

-#include "dat.h"

-#include "quakedef.h"

-#include "fns.h"

-

-#define DWORD	u32int

-

-#define	PAINTBUFFER_SIZE	512

-portable_samplepair_t paintbuffer[PAINTBUFFER_SIZE];

-int		snd_scaletable[32][256];

-int 	*snd_p, snd_linear_count, snd_vol;

-short	*snd_out;

-

-

-void Snd_WriteLinearBlastStereo16 (void)

-{

-	int		i;

-	int		val;

-

-	for (i=0 ; i<snd_linear_count ; i+=2)

-	{

-		val = (snd_p[i]*snd_vol)>>8;

-		if (val > 0x7fff)

-			snd_out[i] = 0x7fff;

-		else if (val < (short)0x8000)

-			snd_out[i] = (short)0x8000;

-		else

-			snd_out[i] = val;

-

-		val = (snd_p[i+1]*snd_vol)>>8;

-		if (val > 0x7fff)

-			snd_out[i+1] = 0x7fff;

-		else if (val < (short)0x8000)

-			snd_out[i+1] = (short)0x8000;

-		else

-			snd_out[i+1] = val;

-	}

-}

-

-void S_TransferStereo16 (int endtime)

-{

-	int		lpos;

-	int		lpaintedtime;

-	DWORD	*pbuf;

-

-	snd_vol = volume.value*256;

-

-	snd_p = (int *) paintbuffer;

-	lpaintedtime = paintedtime;

-

-	pbuf = (DWORD *)shm->buffer;

-

-	while (lpaintedtime < endtime)

-	{

-	// handle recirculating buffer issues

-		lpos = lpaintedtime & ((shm->samples>>1)-1);

-

-		snd_out = (short *) pbuf + (lpos<<1);

-

-		snd_linear_count = (shm->samples>>1) - lpos;

-		if (lpaintedtime + snd_linear_count > endtime)

-			snd_linear_count = endtime - lpaintedtime;

-

-		snd_linear_count <<= 1;

-

-	// write a linear blast of samples

-		Snd_WriteLinearBlastStereo16 ();

-

-		snd_p += snd_linear_count;

-		lpaintedtime += (snd_linear_count>>1);

-	}

-}

-

-void S_TransferPaintBuffer(int endtime)

-{

-	int 	out_idx;

-	int 	count;

-	int 	out_mask;

-	int 	*p;

-	int 	step;

-	int		val;

-	int		snd_vol;

-	DWORD	*pbuf;

-

-	if (shm->samplebits == 16 && shm->channels == 2)

-	{

-		S_TransferStereo16 (endtime);

-		return;

-	}

-	

-	p = (int *) paintbuffer;

-	count = (endtime - paintedtime) * shm->channels;

-	out_mask = shm->samples - 1; 

-	out_idx = paintedtime * shm->channels & out_mask;

-	step = 3 - shm->channels;

-	snd_vol = volume.value*256;

-

-	pbuf = (DWORD *)shm->buffer;

-

-	if (shm->samplebits == 16)

-	{

-		short *out = (short *) pbuf;

-		while (count--)

-		{

-			val = (*p * snd_vol) >> 8;

-			p+= step;

-			if (val > 0x7fff)

-				val = 0x7fff;

-			else if (val < (short)0x8000)

-				val = (short)0x8000;

-			out[out_idx] = val;

-			out_idx = (out_idx + 1) & out_mask;

-		}

-	}

-	else if (shm->samplebits == 8)

-	{

-		unsigned char *out = (unsigned char *) pbuf;

-		while (count--)

-		{

-			val = (*p * snd_vol) >> 8;

-			p+= step;

-			if (val > 0x7fff)

-				val = 0x7fff;

-			else if (val < (short)0x8000)

-				val = (short)0x8000;

-			out[out_idx] = (val>>8) + 128;

-			out_idx = (out_idx + 1) & out_mask;

-		}

-	}

-}

-

-

-/*

-===============================================================================

-

-CHANNEL MIXING

-

-===============================================================================

-*/

-

-void SND_PaintChannelFrom8 (channel_t *ch, sfxcache_t *sc, int endtime);

-void SND_PaintChannelFrom16 (channel_t *ch, sfxcache_t *sc, int endtime);

-

-void S_PaintChannels(int endtime)

-{

-	int 	i;

-	int 	end;

-	channel_t *ch;

-	sfxcache_t	*sc;

-	int		ltime, count;

-

-	while (paintedtime < endtime)

-	{

-	// if paintbuffer is smaller than DMA buffer

-		end = endtime;

-		if (endtime - paintedtime > PAINTBUFFER_SIZE)

-			end = paintedtime + PAINTBUFFER_SIZE;

-

-	// clear the paint buffer

-		memset(paintbuffer, 0, (end - paintedtime) * sizeof *paintbuffer);

-

-	// paint in the channels.

-		ch = channels;

-		for (i=0; i<total_channels ; i++, ch++)

-		{

-			if (!ch->sfx)

-				continue;

-			if (!ch->leftvol && !ch->rightvol)

-				continue;

-			sc = S_LoadSound (ch->sfx);

-			if (!sc)

-				continue;

-

-			ltime = paintedtime;

-

-			while (ltime < end)

-			{	// paint up to end

-				if (ch->end < end)

-					count = ch->end - ltime;

-				else

-					count = end - ltime;

-

-				if (count > 0)

-				{	

-					if (sc->width == 1)

-						SND_PaintChannelFrom8(ch, sc, count);

-					else

-						SND_PaintChannelFrom16(ch, sc, count);

-	

-					ltime += count;

-				}

-

-			// if at end of loop, restart

-				if (ltime >= ch->end)

-				{

-					if (sc->loopstart >= 0)

-					{

-						ch->pos = sc->loopstart;

-						ch->end = ltime + sc->length - ch->pos;

-					}

-					else				

-					{	// channel just stopped

-						ch->sfx = nil;

-						break;

-					}

-				}

-			}

-															  

-		}

-

-	// transfer out according to DMA format

-		S_TransferPaintBuffer(end);

-		paintedtime = end;

-	}

-}

-

-void SND_InitScaletable (void)

-{

-	int		i, j;

-	

-	for (i=0 ; i<32 ; i++)

-		for (j=0 ; j<256 ; j++)

-			snd_scaletable[i][j] = ((signed char)j) * i * 8;

-}

-

-

-void SND_PaintChannelFrom8 (channel_t *ch, sfxcache_t *sc, int count)

-{

-	int 	data;

-	int	*lscale, *rscale;

-	uchar	*sfx;

-	int	i;

-

-	if (ch->leftvol > 255)

-		ch->leftvol = 255;

-	if (ch->rightvol > 255)

-		ch->rightvol = 255;

-		

-	lscale = snd_scaletable[ch->leftvol >> 3];

-	rscale = snd_scaletable[ch->rightvol >> 3];

-	sfx = (uchar *)((uintptr)sc->data + (uintptr)ch->pos);

-

-	for (i=0 ; i<count ; i++)

-	{

-		data = sfx[i];

-		paintbuffer[i].left += lscale[data];

-		paintbuffer[i].right += rscale[data];

-	}

-	

-	ch->pos += count;

-}

-

-

-void SND_PaintChannelFrom16 (channel_t *ch, sfxcache_t *sc, int count)

-{

-	int data;

-	int left, right;

-	int leftvol, rightvol;

-	signed short *sfx;

-	int	i;

-

-	leftvol = ch->leftvol;

-	rightvol = ch->rightvol;

-	sfx = (signed short *)sc->data + ch->pos;

-

-	for (i=0 ; i<count ; i++)

-	{

-		data = sfx[i];

-		left = (data * leftvol) >> 8;

-		right = (data * rightvol) >> 8;

-		paintbuffer[i].left += left;

-		paintbuffer[i].right += right;

-	}

-

-	ch->pos += count;

-}

-

--- a/sound.h

+++ /dev/null

@@ -1,159 +1,0 @@

-// sound.h -- client sound i/o functions

-

-enum{

-	NSAMPLE = 4096,

-	SAMPLESZ = 16,

-	SAMPLEB = SAMPLESZ / 8,

-	RATE = 44100,

-	SNBUF = SAMPLEB * NSAMPLE

-};

-

-#define DEFAULT_SOUND_PACKET_VOLUME 255

-#define DEFAULT_SOUND_PACKET_ATTENUATION 1.0

-

-// !!! if this is changed, it much be changed in asm_i386.h too !!!

-typedef struct

-{

-	int left;

-	int right;

-} portable_samplepair_t;

-

-typedef struct sfx_s

-{

-	char 	name[Npath];

-	cache_user_t	cache;

-} sfx_t;

-

-// !!! if this is changed, it much be changed in asm_i386.h too !!!

-typedef struct

-{

-	int 	length;

-	int 	loopstart;

-	int 	speed;

-	int 	width;

-	int 	stereo;

-	byte	data[1];		// variable sized

-} sfxcache_t;

-

-typedef struct

-{

-	qboolean		gamealive;

-	qboolean		soundalive;

-	qboolean		splitbuffer;

-	int				channels;

-	int				samples;				// mono samples in buffer

-	int				submission_chunk;		// don't mix less than this #

-	uint				samplepos;				// in mono samples

-	int				samplebits;

-	int				speed;

-	unsigned char	*buffer;

-} dma_t;

-

-// !!! if this is changed, it much be changed in asm_i386.h too !!!

-typedef struct

-{

-	sfx_t	*sfx;			// sfx number

-	int		leftvol;		// 0-255 volume

-	int		rightvol;		// 0-255 volume

-	int		end;			// end time in global paintsamples

-	int 	pos;			// sample position in sfx

-	int		looping;		// where to loop, -1 = no looping

-	int		entnum;			// to allow overriding a specific sound

-	int		entchannel;		//

-	vec3_t	origin;			// origin of sound effect

-	vec_t	dist_mult;		// distance multiplier (attenuation/clipK)

-	int		master_vol;		// 0-255 master volume

-} channel_t;

-

-typedef struct

-{

-	int		rate;

-	int		width;

-	int		channels;

-	int		loopstart;

-	int		samples;

-	int		dataofs;		// chunk starts this many bytes from file start

-} wavinfo_t;

-

-void S_Init (void);

-void S_Startup (void);

-void S_Shutdown (void);

-void S_StartSound (int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol,  float attenuation);

-void S_StaticSound (sfx_t *sfx, vec3_t origin, float vol, float attenuation);

-void S_StopSound (int entnum, int entchannel);

-void S_StopAllSounds(qboolean clear);

-void S_ClearBuffer (void);

-void S_Update (vec3_t origin, vec3_t v_forward, vec3_t v_right, vec3_t v_up);

-void S_ExtraUpdate (void);

-

-sfx_t *S_PrecacheSound (char *sample);

-void S_TouchSound (char *sample);

-void S_ClearPrecache (void);

-void S_BeginPrecaching (void);

-void S_EndPrecaching (void);

-void S_PaintChannels(int endtime);

-void S_InitPaintChannels (void);

-

-// picks a channel based on priorities, empty slots, number of channels

-channel_t *SND_PickChannel(int entnum, int entchannel);

-

-// spatializes a channel

-void SND_Spatialize(channel_t *ch);

-

-// initializes cycling through a DMA buffer and returns information on it

-qboolean SNDDMA_Init(void);

-

-// gets the current DMA position

-uint SNDDMA_GetDMAPos(void);

-

-// shutdown the DMA xfer.

-void SNDDMA_Shutdown(void);

-

-// ====================================================================

-// User-setable variables

-// ====================================================================

-

-#define	MAX_CHANNELS			128

-#define	MAX_DYNAMIC_CHANNELS	8

-

-

-extern	channel_t   channels[MAX_CHANNELS];

-// 0 to MAX_DYNAMIC_CHANNELS-1	= normal entity sounds

-// MAX_DYNAMIC_CHANNELS to MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS -1 = water, etc

-// MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS to total_channels = static sounds

-

-extern	int			total_channels;

-

-//

-// Fake dma is a synchronous faking of the DMA progress used for

-// isolating performance in the renderer.  The fakedma_updates is

-// number of times S_Update() is called per second.

-//

-

-extern qboolean 		fakedma;

-extern int 			fakedma_updates;

-extern int		paintedtime;

-extern vec3_t listener_origin;

-extern vec3_t listener_forward;

-extern vec3_t listener_right;

-extern vec3_t listener_up;

-extern volatile dma_t *shm;

-extern volatile dma_t sn;

-extern vec_t sound_nominal_clip_dist;

-

-extern	cvar_t loadas8bit;

-extern	cvar_t bgmvolume;

-extern	cvar_t volume;

-

-extern int		snd_blocked;

-

-void S_LocalSound (char *s);

-sfxcache_t *S_LoadSound (sfx_t *s);

-

-wavinfo_t GetWavinfo (char *name, byte *wav, vlong wavlength);

-

-void SND_InitScaletable (void);

-void SNDDMA_Submit(void);

-

-void S_AmbientOff (void);

-void S_AmbientOn (void);

--- a/sv_main.c

+++ b/sv_main.c

@@ -135,9 +135,9 @@

 	channel = (ent<<3) | channel;

 	field_mask = 0;

-	if (volume != DEFAULT_SOUND_PACKET_VOLUME)

+	if (volume != Spktvol)

 		field_mask |= SND_VOLUME;

-	if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)

+	if (attenuation != Spktatt)

 		field_mask |= SND_ATTENUATION;

 // directed messages go only to the entity the are targeted on

--- a/sys.c

+++ b/sys.c

@@ -61,10 +61,8 @@

 static void

 croak(void *, char *note)

 {

-	if(strncmp(note, "sys:", 4) == 0){

+	if(strncmp(note, "sys:", 4) == 0)

 		IN_Shutdown();

-		SNDDMA_Shutdown();

-	}

 	noted(NDFLT);

 }

@@ -102,7 +100,7 @@

 	Host_Init(&parms);

-	oldtime = Sys_FloatTime() - 0.1;

+	oldtime = Sys_FloatTime() - 1.0 / Fpsmax;

 	for(;;){

 		// find time spent rendering last frame

 		newtime = Sys_FloatTime();