--- np2/x11/soundmng.c	2003/11/27 17:25:55	1.3
+++ np2/x11/soundmng.c	2011/12/24 17:50:44	1.18
@@ -10,8 +10,6 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@@ -33,13 +31,7 @@ BYTE
 snddrv_drv2num(const char* cfgstr)
 {
 
-	if (strcasecmp(cfgstr, "NetBSD") == 0)
-		return SNDDRV_NETBSD;
-	else if (strcasecmp(cfgstr, "OSS") == 0)
-		return SNDDRV_OSS;
-	else if (strcasecmp(cfgstr, "ESD") == 0)
-		return SNDDRV_ESD;
-	else if (strcasecmp(cfgstr, "SDL") == 0)
+	if (strcasecmp(cfgstr, "SDL") == 0)
 		return SNDDRV_SDL;
 	return SNDDRV_NODRV;
 }
@@ -49,12 +41,6 @@ snddrv_num2drv(BYTE num)
 {
 
 	switch (num) {
-	case SNDDRV_NETBSD:
-		return "NetBSD";
-	case SNDDRV_OSS:
-		return "OSS";
-	case SNDDRV_ESD:
-		return "ESD";
 	case SNDDRV_SDL:
 		return "SDL";
 	}
@@ -69,32 +55,43 @@ snddrv_num2drv(BYTE num)
 #include "dosio.h"
 #include "parts.h"
 
+#include "sysmng.h"
 #include "sound.h"
+
 #if defined(VERMOUTH_LIB)
 #include "vermouth.h"
-#endif
 
-#include "sysmng.h"
-
-#if defined(VERMOUTH_LIB)
 MIDIMOD vermouth_module = NULL;
 #endif
 
 /*
  * driver
  */
-int audio_fd = -1;
-snddrv_t snddrv;
-
+static struct {
+	BOOL (*drvinit)(UINT rate, UINT samples);
+	BOOL (*drvterm)(void);
+	void (*drvlock)(void);
+	void (*drvunlock)(void);
+
+	void (*sndplay)(void);
+	void (*sndstop)(void);
+
+	void *(*pcmload)(UINT num, const char *path);
+	void (*pcmdestroy)(void *cookie, UINT num);
+	void (*pcmplay)(void *cookie, UINT num, BOOL loop);
+	void (*pcmstop)(void *cookie, UINT num);
+	void (*pcmvolume)(void *cookie, UINT num, int volume);
+} snddrv;
+static int audio_fd = -1;
 static BOOL opened = FALSE;
-static UINT mute = 0;
 static UINT opna_frame;
 
 static BOOL nosound_setup(void);
+static BOOL sdlaudio_setup(void);
 
 static void PARTSCALL (*fnmix)(SINT16* dst, const SINT32* src, UINT size);
 
-#if defined(__GNUC__) && (defined(i386) || defined(__i386__))
+#if defined(GCC_CPU_ARCH_IA32)
 void PARTSCALL _saturation_s16(SINT16 *dst, const SINT32 *src, UINT size);
 void PARTSCALL _saturation_s16x(SINT16 *dst, const SINT32 *src, UINT size);
 void PARTSCALL saturation_s16mmx(SINT16 *dst, const SINT32 *src, UINT size);
@@ -103,24 +100,37 @@ void PARTSCALL saturation_s16mmx(SINT16 
 /*
  * PCM
  */
-static void *pcm_channel[SOUND_MAXPCM];
+typedef struct {
+	void *cookie;
+	char *path;
+	int volume;
+} pcm_channel_t;
+static pcm_channel_t *pcm_channel[SOUND_MAXPCM];
 
 static void soundmng_pcminit(void);
 static void soundmng_pcmdestroy(void);
 
+#ifndef	PCM_VOULE_DEFAULT
+#define	PCM_VOULE_DEFAULT	25
+#endif
+int pcm_volume_default = PCM_VOULE_DEFAULT;
+
 /*
  * buffer
  */
-int sound_nextbuf;
-char *sound_event;
-char *sound_buffer[NSOUNDBUFFER];
+#ifndef	NSOUNDBUFFER
+#define	NSOUNDBUFFER	2
+#endif
+static char *sound_buffer[NSOUNDBUFFER];
+static int sound_nextbuf;
+static char *sound_event;
 
 static BOOL buffer_init(void);
 static void buffer_destroy(void);
 static void buffer_clear(void);
 
 
-UINT
+static UINT
 calc_blocksize(UINT size)
 {
 	UINT s = size;
@@ -131,83 +141,26 @@ calc_blocksize(UINT size)
 	return s;
 }
 
-UINT
-calc_fragment(UINT size)
-{
-	UINT f;
-
-	for (f = 0; size > (UINT)(1 << f); f++)
-		continue;
-	return f;
-}
-
-void
+static void
 snddrv_setup(void)
 {
 
 	if (np2oscfg.snddrv < SNDDRV_DRVMAX) {
 		switch (np2oscfg.snddrv) {
-#if defined(USE_NETBSDAUDIO)
-		case SNDDRV_NETBSD:
-			netbsdaudio_setup();
-			return;
-#endif
-#if defined(USE_OSSAUDIO)
-		case SNDDRV_OSS:
-			ossaudio_setup();
-			return;
-#endif
-#if defined(USE_ESDAUDIO)
-		case SNDDRV_ESD:
-			esdaudio_setup();
-			return;
-#endif
 #if defined(USE_SDLAUDIO) || defined(USE_SDLMIXER)
 		case SNDDRV_SDL:
-#if defined(USE_SDLMIXER)
-			sdlmixer_setup();
-#else
 			sdlaudio_setup();
-#endif
 			return;
 #endif
 		}
 	} else {
-#if defined(USE_SDLMIXER)
-		if (sdlmixer_setup() == SUCCESS) {
-			np2oscfg.snddrv = SNDDRV_SDL;
-			sysmng_update(SYS_UPDATEOSCFG);
-			return;
-		} else
-#endif
-#if defined(USE_SDLAUDIO)
+#if defined(USE_SDLAUDIO) || defined(USE_SDLMIXER)
 		if (sdlaudio_setup() == SUCCESS) {
 			np2oscfg.snddrv = SNDDRV_SDL;
 			sysmng_update(SYS_UPDATEOSCFG);
 			return;
 		} else
 #endif
-#if defined(USE_ESDAUDIO)
-		if (esdaudio_setup() == SUCCESS) {
-			np2oscfg.snddrv = SNDDRV_ESD;
-			sysmng_update(SYS_UPDATEOSCFG);
-			return;
-		} else
-#endif
-#if defined(USE_OSSAUDIO)
-		if (ossaudio_setup() == SUCCESS) {
-			np2oscfg.snddrv = SNDDRV_OSS;
-			sysmng_update(SYS_UPDATEOSCFG);
-			return;
-		} else
-#endif
-#if defined(USE_NETBSDAUDIO)
-		if (netbsdaudio_setup() == SUCCESS) {
-			np2oscfg.snddrv = SNDDRV_NETBSD;
-			sysmng_update(SYS_UPDATEOSCFG);
-			return;
-		} else
-#endif
 		{
 			/* Nothing to do */
 			/* fall thourgh "no match" */
@@ -220,13 +173,26 @@ snddrv_setup(void)
 	sysmng_update(SYS_UPDATEOSCFG);
 }
 
+static void
+sounddrv_lock(void)
+{
+
+	(*snddrv.drvlock)();
+}
+
+static void
+sounddrv_unlock(void)
+{
+
+	(*snddrv.drvunlock)();
+}
+
 UINT
 soundmng_create(UINT rate, UINT bufmsec)
 {
+	pcm_channel_t *chan;
 	UINT samples;
-#if defined(VERMOUTH_LIB)
-	UINT num;
-#endif
+	int i;
 
 	if (opened || ((rate != 11025) && (rate != 22050) && (rate != 44100))) {
 		return 0;
@@ -237,6 +203,15 @@ soundmng_create(UINT rate, UINT bufmsec)
 	else if (bufmsec > 1000)
 		bufmsec = 1000;
 
+	for (i = 0; i < SOUND_MAXPCM; i++) {
+		chan = pcm_channel[i];
+		if (chan != NULL && chan->cookie != NULL) {
+			soundmng_pcmstop(i);
+			(*snddrv.pcmdestroy)(chan->cookie, i);
+			chan->cookie = NULL;
+		}
+	}
+
 	snddrv_setup();
 
 	samples = (rate * bufmsec) / 1000 / 2;
@@ -245,6 +220,7 @@ soundmng_create(UINT rate, UINT bufmsec)
 
 	if ((*snddrv.drvinit)(rate, samples) != SUCCESS) {
 		audio_fd = -1;
+		nosound_setup();
 		np2oscfg.snddrv = SNDDRV_NODRV;
 		sysmng_update(SYS_UPDATEOSCFG);
 		return 0;
@@ -252,16 +228,22 @@ soundmng_create(UINT rate, UINT bufmsec)
 
 #if defined(VERMOUTH_LIB)
 	vermouth_module = midimod_create(rate);
-	for (num = 0; num < 128; num++) {
-		midimod_loadprogram(vermouth_module, num);
-		midimod_loadrhythm(vermouth_module, num);
-	}
+	midimod_loadall(vermouth_module);
 #endif
 
 	soundmng_setreverse(FALSE);
 	buffer_init();
 	soundmng_reset();
 
+	for (i = 0; i < SOUND_MAXPCM; i++) {
+		chan = pcm_channel[i];
+		if (chan != NULL && chan->path != NULL) {
+			chan->cookie = (*snddrv.pcmload)(i, chan->path);
+			if (chan->cookie != NULL)
+				(*snddrv.pcmvolume)(chan->cookie, i, chan->volume);
+		}
+	}
+
 	opened = TRUE;
 
 	return samples;
@@ -271,8 +253,10 @@ void
 soundmng_reset(void)
 {
 
+	sounddrv_lock();
 	sound_nextbuf = 0;
 	sound_event = NULL;
+	sounddrv_unlock();
 	buffer_clear();
 }
 
@@ -291,8 +275,6 @@ soundmng_destroy(void)
 		}
 		(*snddrv.sndstop)();
 		(*snddrv.drvterm)();
-		buffer_destroy();
-		nosound_setup();
 		audio_fd = -1;
 		opened = FALSE;
 	}
@@ -302,18 +284,14 @@ void
 soundmng_play(void)
 {
 
-	if (!mute) {
-		(*snddrv.sndplay)();
-	}
+	(*snddrv.sndplay)();
 }
 
 void
 soundmng_stop(void)
 {
 
-	if (!mute) {
-		(*snddrv.sndstop)();
-	}
+	(*snddrv.sndstop)();
 }
 
 BOOL
@@ -332,6 +310,7 @@ soundmng_deinitialize(void)
 
 	soundmng_pcmdestroy();
 	soundmng_destroy();
+	buffer_destroy();
 }
 
 void
@@ -341,6 +320,7 @@ soundmng_sync(void)
 	SINT16 *q;
 
 	if (opened) {
+		sounddrv_lock();
 		if (sound_event) {
 			pcm = sound_pcmlock();
 			q = (SINT16 *)sound_event;
@@ -348,6 +328,7 @@ soundmng_sync(void)
 			(*fnmix)(q, pcm, opna_frame);
 			sound_pcmunlock(pcm);
 		}
+		sounddrv_unlock();
 	}
 }
 
@@ -355,7 +336,17 @@ void
 soundmng_setreverse(BOOL reverse)
 {
 
-#if defined(__GNUC__) && (defined(i386) || defined(__i386__))
+#if defined(GCC_CPU_ARCH_AMD64)
+	if (!reverse) {
+		if (mmxflag & (MMXFLAG_NOTSUPPORT|MMXFLAG_DISABLE)) {
+			fnmix = satuation_s16;
+		} else {
+			fnmix = saturation_s16mmx;
+		}
+	} else {
+		fnmix = satuation_s16x;
+	}
+#elif defined(GCC_CPU_ARCH_IA32)
 	if (!reverse) {
 		if (mmxflag & (MMXFLAG_NOTSUPPORT|MMXFLAG_DISABLE)) {
 			fnmix = _saturation_s16;
@@ -377,7 +368,7 @@ soundmng_setreverse(BOOL reverse)
 /*
  * PCM function
  */
-void
+static void
 soundmng_pcminit(void)
 {
 	int i;
@@ -387,15 +378,24 @@ soundmng_pcminit(void)
 	}
 }
 
-void
+static void
 soundmng_pcmdestroy(void)
 {
+	pcm_channel_t *chan;
 	int i;
 
 	for (i = 0; i < SOUND_MAXPCM; i++) {
-		if (pcm_channel[i]) {
-			(*snddrv.pcmdestroy)(pcm_channel[i], i);
+		chan = pcm_channel[i];
+		if (chan != NULL) {
 			pcm_channel[i] = NULL;
+			if (chan->cookie != NULL) {
+				(*snddrv.pcmdestroy)(chan->cookie, i);
+				chan->cookie = NULL;
+			}
+			if (chan->path != NULL) {
+				_MFREE(chan->path);
+				chan->path = NULL;
+			}
 		}
 	}
 }
@@ -403,13 +403,31 @@ soundmng_pcmdestroy(void)
 BOOL
 soundmng_pcmload(UINT num, const char *filename)
 {
+	pcm_channel_t *chan;
+	struct stat sb;
+	int rv;
 
 	if (num < SOUND_MAXPCM) {
-		if (pcm_channel[num])
-			(*snddrv.pcmdestroy)(pcm_channel[num], num);
-		pcm_channel[num] = (*snddrv.pcmload)(num, filename);
-		if (pcm_channel[num])
-			return SUCCESS;
+		rv = stat(filename, &sb);
+		if (rv < 0)
+			return FAILURE;
+
+		chan = pcm_channel[num];
+		if (chan != NULL) {
+			if (strcmp(filename, chan->path)) {
+				_MFREE(chan->path);
+				chan->path = strdup(filename);
+			}
+		} else {
+			chan = _MALLOC(sizeof(*chan), "pcm channel");
+			if (chan == NULL)
+				return FAILURE;
+			chan->cookie = NULL;
+			chan->path = strdup(filename);
+			chan->volume = pcm_volume_default;
+			pcm_channel[num] = chan;
+		}
+		return SUCCESS;
 	}
 	return FAILURE;
 }
@@ -417,18 +435,28 @@ soundmng_pcmload(UINT num, const char *f
 void
 soundmng_pcmvolume(UINT num, int volume)
 {
+	pcm_channel_t *chan;
 
-	if ((num < SOUND_MAXPCM) && (pcm_channel[num])) {
-		(*snddrv.pcmvolume)(pcm_channel[num], num, volume);
+	if (num < SOUND_MAXPCM) {
+		chan = pcm_channel[num];
+		if (chan != NULL) {
+			chan->volume = volume;
+			if (chan->cookie != NULL)
+				(*snddrv.pcmvolume)(chan->cookie, num, volume);
+		}
 	}
 }
 
 BOOL
 soundmng_pcmplay(UINT num, BOOL loop)
 {
+	pcm_channel_t *chan;
 
-	if ((num < SOUND_MAXPCM) && (pcm_channel[num])) {
-		(*snddrv.pcmplay)(pcm_channel[num], num, loop);
+	if (num < SOUND_MAXPCM) {
+		chan = pcm_channel[num];
+		if (chan != NULL && chan->cookie != NULL) {
+			(*snddrv.pcmplay)(chan->cookie, num, loop);
+		}
 		return SUCCESS;
 	}
 	return FAILURE;
@@ -437,9 +465,13 @@ soundmng_pcmplay(UINT num, BOOL loop)
 void
 soundmng_pcmstop(UINT num)
 {
+	pcm_channel_t *chan;
 
-	if ((num < SOUND_MAXPCM) && (pcm_channel[num])) {
-		(*snddrv.pcmstop)(pcm_channel[num], num);
+	if (num < SOUND_MAXPCM) {
+		chan = pcm_channel[num];
+		if (chan != NULL && chan->cookie != NULL) {
+			(*snddrv.pcmstop)(chan->cookie, num);
+		}
 	}
 }
 
@@ -451,16 +483,19 @@ buffer_init(void)
 {
 	int i;
 
+	sounddrv_lock();
 	for (i = 0; i < NSOUNDBUFFER; i++) {
-		if (sound_buffer[i]) {
+		if (sound_buffer[i] != NULL) {
 			_MFREE(sound_buffer[i]);
 		}
 		sound_buffer[i] = (char *)_MALLOC(opna_frame, "sound buffer");
 		if (sound_buffer[i] == NULL) {
-			fprintf(stderr, "buffer_init: can't alloc memory\n");
+			g_printerr("buffer_init: can't alloc memory\n");
+			sounddrv_unlock();
 			return FAILURE;
 		}
 	}
+	sounddrv_unlock();
 	return SUCCESS;
 }
 
@@ -469,11 +504,13 @@ buffer_clear(void)
 {
 	int i;
 
+	sounddrv_lock();
 	for (i = 0; i < NSOUNDBUFFER; i++) {
 		if (sound_buffer[i]) {
 			memset(sound_buffer[i], 0, opna_frame);
 		}
 	}
+	sounddrv_unlock();
 }
 
 static void
@@ -481,12 +518,14 @@ buffer_destroy(void)
 {
 	int i;
 
+	sounddrv_lock();
 	for (i = 0; i < NSOUNDBUFFER; i++) {
-		if (sound_buffer[i]) {
+		if (sound_buffer[i] != NULL) {
 			_MFREE(sound_buffer[i]);
 			sound_buffer[i] = NULL;
 		}
 	}
+	sounddrv_unlock();
 }
 
 /*
@@ -496,9 +535,6 @@ static BOOL
 nosound_drvinit(UINT rate, UINT bufmsec)
 {
 
-	UNUSED(rate);
-	UNUSED(bufmsec);
-
 	return SUCCESS;
 }
 
@@ -510,6 +546,20 @@ nosound_drvterm(void)
 }
 
 static void
+nosound_drvlock(void)
+{
+
+	/* Nothing to do */
+}
+
+static void
+nosound_drvunlock(void)
+{
+
+	/* Nothing to do */
+}
+
+static void
 nosound_sndplay(void)
 {
 
@@ -523,55 +573,38 @@ nosound_sndstop(void)
 	/* Nothing to do */
 }
 
-void *
+static void *
 nosound_pcmload(UINT num, const char *path)
 {
 
-	UNUSED(num);
-	UNUSED(path);
-
 	return NULL;
 }
 
-void
-nosound_pcmdestroy(void *chanp, UINT num)
+static void
+nosound_pcmdestroy(void *cookie, UINT num)
 {
 
-	UNUSED(chanp);
-	UNUSED(num);
-
 	/* Nothing to do */
 }
 
-void
-nosound_pcmplay(void *chanp, UINT num, BOOL loop)
+static void
+nosound_pcmplay(void *cookie, UINT num, BOOL loop)
 {
 
-	UNUSED(chanp);
-	UNUSED(num);
-	UNUSED(loop);
-
 	/* Nothing to do */
 }
 
-void
-nosound_pcmstop(void *chanp, UINT num)
+static void
+nosound_pcmstop(void *cookie, UINT num)
 {
 
-	UNUSED(chanp);
-	UNUSED(num);
-
 	/* Nothing to do */
 }
 
-void
-nosound_pcmvolume(void *chanp, UINT num, int volume)
+static void
+nosound_pcmvolume(void *cookie, UINT num, int volume)
 {
 
-	UNUSED(chanp);
-	UNUSED(num);
-	UNUSED(volume);
-
 	/* Nothing to do */
 }
 
@@ -581,6 +614,8 @@ nosound_setup(void)
 
 	snddrv.drvinit = nosound_drvinit;
 	snddrv.drvterm = nosound_drvterm;
+	snddrv.drvlock = nosound_drvlock;
+	snddrv.drvunlock = nosound_drvunlock;
 	snddrv.sndplay = nosound_sndplay;
 	snddrv.sndstop = nosound_sndstop;
 	snddrv.pcmload = nosound_pcmload;
@@ -592,67 +627,107 @@ nosound_setup(void)
 	return SUCCESS;
 }
 
-#if defined(USE_NETBSDAUDIO) || defined(USE_OSSAUDIO) || defined(USE_ESDAUDIO)
-/*
- * common driver
- */
-static pthread_t ptid;
-static BOOL is_proc;
-
-static void *
-buffer_play(void *arg)
+#if defined(GCC_CPU_ARCH_AMD64)
+void PARTSCALL
+_saturation_s16(SINT16 *dst, const SINT32 *src, UINT size)
 {
-	char *buf;
-	size_t len = opna_frame;
-	size_t s;
-	ssize_t r;
-	int nextbuf;
-
-	UNUSED(arg);
-
-	is_proc = TRUE;
-	while (is_proc) {
-		nextbuf = sound_nextbuf;
-		if (sound_event)
-			memset(sound_event, 0, len);
-		sound_nextbuf = (sound_nextbuf + 1) % NSOUNDBUFFER;
-		sound_event = sound_buffer[sound_nextbuf];
-
-		buf = sound_buffer[nextbuf];
-		s = 0;
-		for (;;) {
-			r = write(audio_fd, buf + s, len - s);
-			if (r >= 0) {
-				s += r;
-				if (len <= s)
-					break;
-			}
-		}
-	}
-	is_proc = FALSE;
-
-	return NULL;
+	asm volatile (
+		"movq	%0, %%rcx;"
+		"movq	%1, %%rdx;"
+		"movl	%2, %%ebx;"
+		"shrl	$1, %%ebx;"
+		"je	.ss16_ed;"
+	".ss16_lp:"
+		"movl	(%%rdx), %%eax;"
+		"cmpl	$0x000008000, %%eax;"
+		"jl	.ss16_min;"
+		"movw	$0x7fff, %%ax;"
+		"jmp	.ss16_set;"
+	".ss16_min:"
+		"cmpl	$0x0ffff8000, %%eax;"
+		"jg	.ss16_set;"
+		"movw	$0x8001, %%ax;"
+	".ss16_set:"
+		"leal	4(%%rdx), %%edx;"
+		"movw	%%ax, (%%rcx);"
+		"decl	%%ebx;"
+		"leal	2(%%rcx), %%ecx;"
+		"jne	.ss16_lp;"
+	".ss16_ed:"
+		: /* output */
+		: "m" (dst), "m" (src), "m" (size)
+		: "ebx");
 }
 
-void
-snddrv_play(void)
+void PARTSCALL
+_saturation_s16x(SINT16 *dst, const SINT32 *src, UINT size)
 {
 
-	if (pthread_create(&ptid, NULL, buffer_play, NULL) != 0) {
-		fprintf(stderr, "audio_play: can't create thread.\n");
-	}
+	asm volatile (
+		"movq	%0, %%rcx;"
+		"movq	%1, %%rdx;"
+		"movl	%2, %%ebx;"
+		"shrl	$2, %%ebx;"
+		"je	.ss16x_ed;"
+	".ss16x_lp:"
+		"movl	(%%rdx), %%eax;"
+		"cmpl	$0x000008000, %%eax;"
+		"jl	.ss16xl_min;"
+		"movw	$0x7fff, %%ax;"
+		"jmp	.ss16xl_set;"
+	".ss16xl_min:"
+		"cmpl	$0x0ffff8000, %%eax;"
+		"jg	.ss16xl_set;"
+		"movw	$0x8001, %%ax;"
+	".ss16xl_set:"
+		"movw	%%ax, 2(%%rcx);"
+		"movl	4(%%rdx), %%eax;"
+		"cmpl	$0x000008000, %%eax;"
+		"jl	.ss16xr_min;"
+		"movw	$0x7fff, %%ax;"
+		"jmp	.ss16xr_set;"
+	".ss16xr_min:"
+		"cmpl	$0x0ffff8000, %%eax;"
+		"jg	.ss16xr_set;"
+		"mov	$0x8001, %%ax;"
+	".ss16xr_set:"
+		"movw	%%ax, (%%rcx);"
+		"leal	8(%%rdx), %%edx;"
+		"decl	%%ebx;"
+		"leal	4(%%rcx), %%ecx;"
+		"jne	.ss16x_lp;"
+	".ss16x_ed:"
+		: /* output */
+		: "m" (dst), "m" (src), "m" (size)
+		: "ebx");
 }
 
-void
-snddrv_stop(void)
+void PARTSCALL
+saturation_s16mmx(SINT16 *dst, const SINT32 *src, UINT size)
 {
 
-	is_proc = FALSE;
+	asm volatile (
+		"movq	%0, %%rcx;"
+		"movq	%1, %%rdx;"
+		"movl	%2, %%eax;"
+		"shrl	$3, %%eax;"
+		"je	.ss16m_ed;"
+		"pxor	%%mm0, %%mm0;"
+	".ss16m_lp:"
+		"movq	(%%rdx), %%mm1;"
+		"movq	8(%%rdx), %%mm2;"
+		"packssdw %%mm2, %%mm1;"
+		"leaq	16(%%rdx), %%rdx;"
+		"movq	%%mm1, (%%rcx);"
+		"leaq	8(%%rcx), %%rcx;"
+		"dec	%%eax;"
+		"jne	.ss16m_lp;"
+		"emms;"
+	".ss16m_ed:"
+		: /* output */
+		: "m" (dst), "m" (src), "m" (size));
 }
-
-#endif	/* USE_NETBSDAUDIO || USE_OSSAUDIO || USE_ESDAUDIO */
-
-#if defined(__GNUC__) && (defined(i386) || defined(__i386__))
+#elif defined(GCC_CPU_ARCH_IA32)
 void PARTSCALL
 _saturation_s16(SINT16 *dst, const SINT32 *src, UINT size)
 {
@@ -752,6 +827,231 @@ saturation_s16mmx(SINT16 *dst, const SIN
 		: /* output */
 		: "m" (dst), "m" (src), "m" (size));
 }
-#endif	/* __GNUC__ && (i386 || __i386__) */
+#endif	/* GCC_CPU_ARCH_AMD64 */
+
+#if defined(USE_SDLAUDIO) || defined(USE_SDLMIXER)
+
+#include <SDL.h>
+
+static void sdlaudio_lock(void);
+static void sdlaudio_unlock(void);
+static void sdlaudio_play(void);
+static void sdlaudio_stop(void);
+static void sdlaudio_callback(void *, unsigned char *, int);
+
+#if !defined(USE_SDLMIXER)
+
+static BOOL
+sdlaudio_init(UINT rate, UINT samples)
+{
+	static SDL_AudioSpec fmt;
+	int rv;
+
+	fmt.freq = rate;
+	fmt.format = AUDIO_S16SYS;
+	fmt.channels = 2;
+	fmt.samples = samples;
+	fmt.callback = sdlaudio_callback;
+	fmt.userdata = (void *)(samples * 2 * sizeof(SINT16));
+
+	rv = SDL_InitSubSystem(SDL_INIT_AUDIO);
+	if (rv < 0) {
+		g_printerr("sdlaudio_init: SDL_InitSubSystem(): %s\n",
+		    SDL_GetError());
+		return FAILURE;
+	}
+
+	audio_fd = SDL_OpenAudio(&fmt, NULL);
+	if (audio_fd < 0) {
+		g_printerr("sdlaudio_init: SDL_OpenAudio(): %s\n",
+		    SDL_GetError());
+		SDL_QuitSubSystem(SDL_INIT_AUDIO);
+		return FAILURE;
+	}
+
+	return SUCCESS;
+}
+
+static BOOL
+sdlaudio_term(void)
+{
+
+	SDL_PauseAudio(1);
+	SDL_CloseAudio();
+
+	return SUCCESS;
+}
+
+static BOOL
+sdlaudio_setup(void)
+{
+
+	snddrv.drvinit = sdlaudio_init;
+	snddrv.drvterm = sdlaudio_term;
+	snddrv.drvlock = sdlaudio_lock;
+	snddrv.drvunlock = sdlaudio_unlock;
+	snddrv.sndplay = sdlaudio_play;
+	snddrv.sndstop = sdlaudio_stop;
+	snddrv.pcmload = nosound_pcmload;
+	snddrv.pcmdestroy = nosound_pcmdestroy;
+	snddrv.pcmplay = nosound_pcmplay;
+	snddrv.pcmstop = nosound_pcmstop;
+	snddrv.pcmvolume = nosound_pcmvolume;
+
+	return SUCCESS;
+}
+
+#else	/* USE_SDLMIXER */
+
+#include <SDL_mixer.h>
+
+static BOOL
+sdlmixer_init(UINT rate, UINT samples)
+{
+	int rv;
+
+	rv = SDL_InitSubSystem(SDL_INIT_AUDIO);
+	if (rv < 0) {
+		g_printerr("sdlmixer_init: SDL_InitSubSystem(): %s\n",
+		    SDL_GetError());
+		goto failure;
+	}
+
+	rv = Mix_OpenAudio(rate, AUDIO_S16SYS, 2, samples);
+	if (rv < 0) {
+		g_printerr("sdlmixer_init: Mix_OpenAudio(): %s\n",
+		    Mix_GetError());
+		goto failure1;
+	}
+
+	rv = Mix_AllocateChannels(SOUND_MAXPCM);
+	if (rv < 0) {
+		g_printerr("sdlmixer_init: Mix_AllocateChannels(): %s\n",
+		    Mix_GetError());
+		goto failure1;
+	}
+
+	Mix_HookMusic(sdlaudio_callback, (void*)(samples * 2 * sizeof(SINT16)));
+
+	return SUCCESS;
+
+failure1:
+	Mix_CloseAudio();
+failure:
+	return FAILURE;
+}
+
+static BOOL
+sdlmixer_term(void)
+{
+
+	SDL_PauseAudio(1);
+	Mix_CloseAudio();
+
+	return SUCCESS;
+}
+
+static void *
+sdlmixer_pcmload(UINT num, const char *path)
+{
+
+	return Mix_LoadWAV(path);
+}
+
+static void
+sdlmixer_pcmdestroy(void *cookie, UINT num)
+{
+	Mix_Chunk *chunk = cookie;
+
+	Mix_FreeChunk(chunk);
+}
+
+static void
+sdlmixer_pcmplay(void *cookie, UINT num, BOOL loop)
+{
+	Mix_Chunk *chunk = cookie;
+
+	Mix_PlayChannel(num, chunk, loop ? -1 : 1);
+}
+
+static void
+sdlmixer_pcmstop(void *cookie, UINT num)
+{
+
+	Mix_HaltChannel(num);
+}
+
+static void
+sdlmixer_pcmvolume(void *cookie, UINT num, int volume)
+{
+
+	Mix_Volume(num, (MIX_MAX_VOLUME * volume) / 100);
+}
+
+static BOOL
+sdlaudio_setup(void)
+{
+
+	snddrv.drvinit = sdlmixer_init;
+	snddrv.drvterm = sdlmixer_term;
+	snddrv.drvlock = sdlaudio_lock;
+	snddrv.drvunlock = sdlaudio_unlock;
+	snddrv.sndplay = sdlaudio_play;
+	snddrv.sndstop = sdlaudio_stop;
+	snddrv.pcmload = sdlmixer_pcmload;
+	snddrv.pcmdestroy = sdlmixer_pcmdestroy;
+	snddrv.pcmplay = sdlmixer_pcmplay;
+	snddrv.pcmstop = sdlmixer_pcmstop;
+	snddrv.pcmvolume = sdlmixer_pcmvolume;
+
+	return SUCCESS;
+}
+
+#endif	/* !USE_SDLMIXER */
+
+static void
+sdlaudio_lock(void)
+{
+
+	SDL_LockAudio();
+}
+
+static void
+sdlaudio_unlock(void)
+{
+
+	SDL_UnlockAudio();
+}
+
+static void
+sdlaudio_play(void)
+{
+
+	SDL_PauseAudio(0);
+}
+
+static void
+sdlaudio_stop(void)
+{
+
+	SDL_PauseAudio(1);
+}
+
+static void
+sdlaudio_callback(void *userdata, unsigned char *stream, int len)
+{
+	UINT samples = (UINT)userdata;
+	int nextbuf = sound_nextbuf;
+
+	if (sound_event != NULL)
+		memset(sound_event, 0, samples);
+	sound_nextbuf = (sound_nextbuf + 1) % NSOUNDBUFFER;
+	sound_event = sound_buffer[sound_nextbuf];
+
+	SDL_MixAudio(stream, (const void *)sound_buffer[nextbuf], len,
+	    SDL_MIX_MAXVOLUME);
+}
+
+#endif	/* USE_SDLAUDIO || USE_SDLMIXER */
 
 #endif	/* !NOSOUND */