X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsound.c;h=cd34b284473e3126a0191fc3074f7005793fd0e0;hb=c9433eab5c4317ed4f89164b386a7d33562e29be;hp=fbdbd87d9716fb569440219ccecac4bdaf861388;hpb=2eeb33b85d7394bd58f51bdc430894f97f8ee6f5;p=rocksndiamonds.git

diff --git a/src/libgame/sound.c b/src/libgame/sound.c
index fbdbd87d..cd34b284 100644
--- a/src/libgame/sound.c
+++ b/src/libgame/sound.c
@@ -1,7 +1,7 @@
 /***********************************************************
 * Artsoft Retro-Game Library                               *
 *----------------------------------------------------------*
-* (c) 1994-2001 Artsoft Entertainment                      *
+* (c) 1994-2002 Artsoft Entertainment                      *
 *               Holger Schemel                             *
 *               Detmolder Strasse 189                      *
 *               33604 Bielefeld                            *
@@ -11,18 +11,145 @@
 * sound.c                                                  *
 ***********************************************************/
 
-#include <string.h>
+#include <sys/types.h>
 #include <sys/time.h>
+#include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <signal.h>
+#include <math.h>
+
+#include "platform.h"
+
+#if defined(PLATFORM_LINUX)
+#include <sys/ioctl.h>
+#include <linux/soundcard.h>
+#elif defined(PLATFORM_FREEBSD)
+#include <machine/soundcard.h>
+#elif defined(PLATFORM_NETBSD)
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#elif defined(PLATFORM_HPUX)
+#include <sys/audio.h>
+#endif
 
 #include "system.h"
 #include "sound.h"
 #include "misc.h"
 #include "setup.h"
+#include "text.h"
+
+
+/* expiration time (in milliseconds) for sound loops */
+#define SOUND_LOOP_EXPIRATION_TIME	200
+
+/* one second fading interval == 1000 ticks (milliseconds) */
+#define SOUND_FADING_INTERVAL		1000
+
+#if defined(AUDIO_STREAMING_DSP)
+#define SOUND_FADING_VOLUME_STEP	(SOUND_MAX_VOLUME / 40)
+#define SOUND_FADING_VOLUME_THRESHOLD	(SOUND_FADING_VOLUME_STEP * 2)
+#endif
+
+#if !defined(PLATFORM_HPUX)
+#define SND_BLOCKSIZE			4096
+#else
+#define SND_BLOCKSIZE			32768
+#endif
+
+#define SND_TYPE_NONE			0
+#define SND_TYPE_WAV			1
+
+#define MUS_TYPE_NONE			0
+#define MUS_TYPE_WAV			1
+#define MUS_TYPE_MOD			2
+
+#define DEVICENAME_DSP			"/dev/dsp"
+#define DEVICENAME_AUDIO		"/dev/audio"
+#define DEVICENAME_AUDIOCTL		"/dev/audioCtl"
+
+#define SOUND_VOLUME_LEFT(x)		(stereo_volume[x])
+#define SOUND_VOLUME_RIGHT(x)		(stereo_volume[SOUND_MAX_LEFT2RIGHT-x])
+
+#define SAME_SOUND_NR(x,y)		((x).nr == (y).nr)
+#define SAME_SOUND_DATA(x,y)		((x).data_ptr == (y).data_ptr)
+
+#if 0
+struct SoundHeader_SUN
+{
+  unsigned long magic;
+  unsigned long hdr_size;
+  unsigned long data_size;
+  unsigned long encoding;
+  unsigned long sample_rate;
+  unsigned long channels;
+};
+
+struct SoundHeader_8SVX
+{
+  char magic_FORM[4];
+  unsigned long chunk_size;
+  char magic_8SVX[4];
+};
+#endif
+
+#if defined(AUDIO_UNIX_NATIVE)
+struct SoundHeader_WAV
+{
+  unsigned short compression_code;
+  unsigned short num_channels;
+  unsigned long  sample_rate;
+  unsigned long  bytes_per_second;
+  unsigned short block_align;
+  unsigned short bits_per_sample;
+};
+#endif
 
+struct AudioFormatInfo
+{
+  boolean stereo;		/* availability of stereo sound */
+  int format;			/* size and endianess of sample data */
+  int sample_rate;		/* sample frequency */
+  int fragment_size;		/* audio device fragment size in bytes */
+};
+
+struct SampleInfo
+{
+  char *source_filename;
+  int num_references;
+
+  int type;
+  int format;
+  void *data_ptr;		/* pointer to first sample (8 or 16 bit) */
+  long data_len;		/* number of samples, NOT number of bytes */
+};
+typedef struct SampleInfo SoundInfo;
+typedef struct SampleInfo MusicInfo;
+
+struct SoundControl
+{
+  boolean active;
+
+  int nr;
+  int volume;
+  int stereo_position;
+
+  int state;
+
+  unsigned long playing_starttime;
+  unsigned long playing_pos;
+
+  int type;
+  int format;
+  void *data_ptr;		/* pointer to first sample (8 or 16 bit) */
+  long data_len;		/* number of samples, NOT number of bytes */
+
+#if defined(TARGET_ALLEGRO)
+  int voice;
+#endif
+};
+typedef struct SoundControl SoundControl;
 
 struct ListNode
 {
@@ -44,47 +171,36 @@ static ListNode *SoundFileList = NULL;
 static SoundInfo **Sound = NULL;
 static MusicInfo **Music = NULL;
 static int num_sounds = 0, num_music = 0;
+static int stereo_volume[SOUND_MAX_LEFT2RIGHT + 1];
 
 
 /* ========================================================================= */
 /* THE STUFF BELOW IS ONLY USED BY THE SOUND SERVER CHILD PROCESS            */
 
-static struct AudioFormatInfo afmt =
-{
-  TRUE, 0, DEFAULT_AUDIO_SAMPLE_RATE, DEFAULT_AUDIO_FRAGMENT_SIZE
-};
-
-static int playing_sounds = 0;
-static struct SoundControl playlist[NUM_MIXER_CHANNELS];
-static struct SoundControl emptySoundControl =
-{
-#if 1
-  FALSE, -1, 0, 0, FALSE, 0, 0, 0, NULL
-#else
-  -1,0,0, FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE, 0,0, 0,NULL
-#endif
-};
+static struct SoundControl mixer[NUM_MIXER_CHANNELS];
+static int mixer_active_channels = 0;
 
-/* forward declaration of internal functions */
-static void SoundServer_InsertNewSound(struct SoundControl);
-static void InitAudioDevice(struct AudioFormatInfo *);
+#if defined(AUDIO_UNIX_NATIVE)
+static struct AudioFormatInfo afmt;
 
-#if defined(PLATFORM_UNIX)
+static void Mixer_Main(void);
 #if !defined(AUDIO_STREAMING_DSP)
 static unsigned char linear_to_ulaw(int);
 static int ulaw_to_linear(unsigned char);
 #endif
-#elif defined(PLATFORM_MSDOS)
-static void SoundServer_InsertNewSound(struct SoundControl);
-static void SoundServer_StopSound(struct SoundControl);
-static void SoundServer_StopAllSounds();
 #endif
 
 static void ReloadCustomSounds();
 static void ReloadCustomMusic();
 static void FreeSound(void *);
 
-#if defined(PLATFORM_UNIX)
+
+/* ------------------------------------------------------------------------- */
+/* functions for native (non-SDL) Unix audio/mixer support                   */
+/* ------------------------------------------------------------------------- */
+
+#if defined(AUDIO_UNIX_NATIVE)
+
 static int OpenAudioDevice(char *audio_device_name)
 {
   int audio_device_fd;
@@ -141,34 +257,27 @@ static boolean TestAudioDevices(void)
   return TRUE;
 }
 
-#if !defined(TARGET_SDL)
 static boolean ForkAudioProcess(void)
 {
-  if (pipe(audio.soundserver_pipe) < 0)
+  if (pipe(audio.mixer_pipe) < 0)
   {
     Error(ERR_WARN, "cannot create pipe -- no sounds");
     return FALSE;
   }
 
-  if ((audio.soundserver_pid = fork()) < 0)
+  if ((audio.mixer_pid = fork()) < 0)
   {       
     Error(ERR_WARN, "cannot create sound server process -- no sounds");
     return FALSE;
   }
 
-  if (audio.soundserver_pid == 0)	/* we are child process */
-  {
-    SoundServer();
-
-    /* never reached */
-    exit(0);
-  }
-  else					/* we are parent */
-    close(audio.soundserver_pipe[0]); /* no reading from pipe needed */
+  if (IS_CHILD_PROCESS(audio.mixer_pid))
+    Mixer_Main();			/* this function never returns */
+  else
+    close(audio.mixer_pipe[0]);		/* no reading from pipe needed */
 
   return TRUE;
 }
-#endif
 
 void UnixOpenAudio(void)
 {
@@ -182,6 +291,10 @@ void UnixOpenAudio(void)
   audio.music_available = TRUE;
   audio.loops_available = TRUE;
 #endif
+
+  audio.num_channels = NUM_MIXER_CHANNELS;
+  audio.music_channel = MUSIC_CHANNEL;
+  audio.first_sound_channel = FIRST_SOUND_CHANNEL;
 }
 
 void UnixCloseAudio(void)
@@ -189,61 +302,237 @@ void UnixCloseAudio(void)
   if (audio.device_fd)
     close(audio.device_fd);
 
-  if (audio.soundserver_pid > 0)	/* we are parent process */
-    kill(audio.soundserver_pid, SIGTERM);
+  if (IS_PARENT_PROCESS(audio.mixer_pid))
+    kill(audio.mixer_pid, SIGTERM);
 }
-#endif	/* PLATFORM_UNIX */
 
-void InitPlaylist(void)
+
+/* ------------------------------------------------------------------------- */
+/* functions for platform specific audio device initialization               */
+/* ------------------------------------------------------------------------- */
+
+#if defined(AUDIO_LINUX_IOCTL)
+static void InitAudioDevice_Linux(struct AudioFormatInfo *afmt)
 {
+  /* "ioctl()" expects pointer to 'int' value for stereo flag
+     (boolean is defined as 'char', which will not work here) */
+  unsigned int fragment_spec = 0;
+  int fragment_size_query;
+  int stereo = TRUE;
+  struct
+  {
+    int format_ioctl;
+    int format_result;
+  }
+  formats[] =
+  {
+    /* supported audio format in preferred order */
+    { AFMT_S16_LE,	AUDIO_FORMAT_S16 | AUDIO_FORMAT_LE },
+    { AFMT_S16_BE,	AUDIO_FORMAT_S16 | AUDIO_FORMAT_BE },
+    { AFMT_U8,		AUDIO_FORMAT_U8                    },
+    { -1,		-1 }
+  };
   int i;
 
-  for(i=0; i<NUM_MIXER_CHANNELS; i++)
-    playlist[i] = emptySoundControl;
-  playing_sounds = 0;
+  /* determine logarithm (log2) of the fragment size */
+  while ((1 << fragment_spec) < afmt->fragment_size)
+    fragment_spec++;
+
+  /* use two fragments (play one fragment, prepare the other);
+     one fragment would result in interrupted audio output, more
+     than two fragments would raise audio output latency to much */
+  fragment_spec |= 0x00020000;
+
+  /* Example for fragment specification:
+     - 2 buffers / 512 bytes (giving 1/16 second resolution for 8 kHz)
+     - (with stereo the effective buffer size will shrink to 256)
+     => fragment_size = 0x00020009 */
+
+  if (ioctl(audio.device_fd, SNDCTL_DSP_SETFRAGMENT, &fragment_spec) < 0)
+    Error(ERR_EXIT_SOUND_SERVER,
+	  "cannot set fragment size of /dev/dsp -- no sounds");
+
+  i = 0;
+  afmt->format = 0;
+  while (formats[i].format_result != -1)
+  {
+    unsigned int audio_format = formats[i].format_ioctl;
+    if (ioctl(audio.device_fd, SNDCTL_DSP_SETFMT, &audio_format) == 0)
+    {
+      afmt->format = formats[i].format_result;
+      break;
+    }
+  }
+
+  if (afmt->format == 0)	/* no supported audio format found */
+    Error(ERR_EXIT_SOUND_SERVER,
+	  "cannot set audio format of /dev/dsp -- no sounds");
+
+  /* try if we can use stereo sound */
+  afmt->stereo = TRUE;
+  if (ioctl(audio.device_fd, SNDCTL_DSP_STEREO, &stereo) < 0)
+    afmt->stereo = FALSE;
+
+  if (ioctl(audio.device_fd, SNDCTL_DSP_SPEED, &afmt->sample_rate) < 0)
+    Error(ERR_EXIT_SOUND_SERVER,
+	  "cannot set sample rate of /dev/dsp -- no sounds");
+
+  /* get the real fragmentation size; this should return 512 */
+  if (ioctl(audio.device_fd, SNDCTL_DSP_GETBLKSIZE, &fragment_size_query) < 0)
+    Error(ERR_EXIT_SOUND_SERVER,
+	  "cannot get fragment size of /dev/dsp -- no sounds");
+  if (fragment_size_query != afmt->fragment_size)
+    Error(ERR_EXIT_SOUND_SERVER,
+	  "cannot set fragment size of /dev/dsp -- no sounds");
 }
+#endif	/* AUDIO_LINUX_IOCTL */
 
-#if 1
-static void PlaylistRemoveSound(int pos)
+#if defined(PLATFORM_NETBSD)
+static void InitAudioDevice_NetBSD(struct AudioFormatInfo *afmt)
+{
+  audio_info_t a_info;
+  boolean stereo = TRUE;
+
+  AUDIO_INITINFO(&a_info);
+  a_info.play.encoding = AUDIO_ENCODING_LINEAR8;
+  a_info.play.precision = 8;
+  a_info.play.channels = 2;
+  a_info.play.sample_rate = sample_rate;
+  a_info.blocksize = fragment_size;
+
+  afmt->format = AUDIO_FORMAT_U8;
+  afmt->stereo = TRUE;
+
+  if (ioctl(audio.device_fd, AUDIO_SETINFO, &a_info) < 0)
+  {
+    /* try to disable stereo */
+    a_info.play.channels = 1;
+
+    afmt->stereo = FALSE;
+
+    if (ioctl(audio.device_fd, AUDIO_SETINFO, &a_info) < 0)
+      Error(ERR_EXIT_SOUND_SERVER,
+	    "cannot set sample rate of /dev/audio -- no sounds");
+  }
+}
+#endif /* PLATFORM_NETBSD */
+
+#if defined(PLATFORM_HPUX)
+static void InitAudioDevice_HPUX(struct AudioFormatInfo *afmt)
+{
+  struct audio_describe ainfo;
+  int audio_ctl;
+
+  audio_ctl = open("/dev/audioCtl", O_WRONLY | O_NDELAY);
+  if (audio_ctl == -1)
+    Error(ERR_EXIT_SOUND_SERVER, "cannot open /dev/audioCtl -- no sounds");
+
+  if (ioctl(audio_ctl, AUDIO_DESCRIBE, &ainfo) == -1)
+    Error(ERR_EXIT_SOUND_SERVER, "no audio info -- no sounds");
+
+  if (ioctl(audio_ctl, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_ULAW) == -1)
+    Error(ERR_EXIT_SOUND_SERVER, "ulaw audio not available -- no sounds");
+
+  ioctl(audio_ctl, AUDIO_SET_CHANNELS, 1);
+  ioctl(audio_ctl, AUDIO_SET_SAMPLE_RATE, 8000);
+
+  afmt->format = AUDIO_FORMAT_U8;
+  afmt->stereo = FALSE;
+  afmt->sample_rate = 8000;
+
+  close(audio_ctl);
+}
+#endif /* PLATFORM_HPUX */
+
+static void InitAudioDevice(struct AudioFormatInfo *afmt)
+{
+  afmt->stereo = TRUE;
+  afmt->format = AUDIO_FORMAT_UNKNOWN;
+  afmt->sample_rate = DEFAULT_AUDIO_SAMPLE_RATE;
+  afmt->fragment_size = DEFAULT_AUDIO_FRAGMENT_SIZE;
+
+#if defined(AUDIO_LINUX_IOCTL)
+  InitAudioDevice_Linux(afmt);
+#elif defined(PLATFORM_NETBSD)
+  InitAudioDevice_NetBSD(afmt);
+#elif defined(PLATFORM_HPUX)
+  InitAudioDevice_HPUX(afmt);
+#else
+  /* generic /dev/audio stuff might be placed here */
+#endif
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* functions for communication between main process and sound mixer process  */
+/* ------------------------------------------------------------------------- */
+
+static void SendSoundControlToMixerProcess(SoundControl *snd_ctrl)
+{
+  if (IS_CHILD_PROCESS(audio.mixer_pid))
+    return;
+
+  if (write(audio.mixer_pipe[1], snd_ctrl, sizeof(SoundControl)) < 0)
+  {
+    Error(ERR_WARN, "cannot pipe to child process -- no sounds");
+    audio.sound_available = audio.sound_enabled = FALSE;
+    return;
+  }
+}
+
+static void ReadSoundControlFromMainProcess(SoundControl *snd_ctrl)
 {
-  if (!playing_sounds || !playlist[pos].active)
+  if (IS_PARENT_PROCESS(audio.mixer_pid))
     return;
 
-  playlist[pos] = emptySoundControl;
-  playing_sounds--;
+  if (read(audio.mixer_pipe[0], snd_ctrl, sizeof(SoundControl))
+      != sizeof(SoundControl))
+    Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
 }
 
 static void WriteReloadInfoToPipe(char *set_name, int type)
 {
-  struct SoundControl snd_ctrl = emptySoundControl;
+  SoundControl snd_ctrl;
   TreeInfo *ti = (type == SND_CTRL_RELOAD_SOUNDS ? artwork.snd_current :
 		  artwork.mus_current);
   unsigned long str_size1 = strlen(leveldir_current->fullpath) + 1;
   unsigned long str_size2 = strlen(ti->basepath) + 1;
   unsigned long str_size3 = strlen(ti->fullpath) + 1;
+  boolean override_level_artwork = (type == SND_CTRL_RELOAD_SOUNDS ?
+				    setup.override_level_sounds :
+				    setup.override_level_music);
+
+  if (IS_CHILD_PROCESS(audio.mixer_pid))
+    return;
+
+  if (leveldir_current == NULL)		/* should never happen */
+    Error(ERR_EXIT, "leveldir_current == NULL");
 
+  snd_ctrl.active = FALSE;
   snd_ctrl.state = type;
   snd_ctrl.data_len = strlen(set_name) + 1;
 
-  if (write(audio.soundserver_pipe[1], &snd_ctrl,
+  if (write(audio.mixer_pipe[1], &snd_ctrl,
 	    sizeof(snd_ctrl)) < 0 ||
-      write(audio.soundserver_pipe[1], set_name,
+      write(audio.mixer_pipe[1], set_name,
 	    snd_ctrl.data_len) < 0 ||
-      write(audio.soundserver_pipe[1], leveldir_current,
+      write(audio.mixer_pipe[1], &override_level_artwork,
+	    sizeof(boolean)) < 0 ||
+      write(audio.mixer_pipe[1], leveldir_current,
 	    sizeof(TreeInfo)) < 0 ||
-      write(audio.soundserver_pipe[1], ti,
+      write(audio.mixer_pipe[1], ti,
 	    sizeof(TreeInfo)) < 0 ||
-      write(audio.soundserver_pipe[1], &str_size1,
+      write(audio.mixer_pipe[1], &str_size1,
 	    sizeof(unsigned long)) < 0 ||
-      write(audio.soundserver_pipe[1], &str_size2,
+      write(audio.mixer_pipe[1], &str_size2,
 	    sizeof(unsigned long)) < 0 ||
-      write(audio.soundserver_pipe[1], &str_size3,
+      write(audio.mixer_pipe[1], &str_size3,
 	    sizeof(unsigned long)) < 0 ||
-      write(audio.soundserver_pipe[1], leveldir_current->fullpath,
+      write(audio.mixer_pipe[1], leveldir_current->fullpath,
 	    str_size1) < 0 ||
-      write(audio.soundserver_pipe[1], ti->basepath,
+      write(audio.mixer_pipe[1], ti->basepath,
 	    str_size2) < 0 ||
-      write(audio.soundserver_pipe[1], ti->fullpath,
+      write(audio.mixer_pipe[1], ti->fullpath,
 	    str_size3) < 0)
   {
     Error(ERR_WARN, "cannot pipe to child process -- no sounds");
@@ -252,18 +541,21 @@ static void WriteReloadInfoToPipe(char *set_name, int type)
   }
 }
 
-static void ReadReloadInfoFromPipe(struct SoundControl snd_ctrl)
+static void ReadReloadInfoFromPipe(SoundControl *snd_ctrl)
 {
-  TreeInfo **ti_ptr = ((snd_ctrl.state & SND_CTRL_RELOAD_SOUNDS) ?
+  TreeInfo **ti_ptr = ((snd_ctrl->state & SND_CTRL_RELOAD_SOUNDS) ?
 		       &artwork.snd_current : &artwork.mus_current);
   TreeInfo *ti = *ti_ptr;
   unsigned long str_size1, str_size2, str_size3;
   static char *set_name = NULL;
+  boolean *override_level_artwork = (snd_ctrl->state & SND_CTRL_RELOAD_SOUNDS ?
+				     &setup.override_level_sounds :
+				     &setup.override_level_music);
 
   if (set_name)
     free(set_name);
 
-  set_name = checked_malloc(snd_ctrl.data_len);
+  set_name = checked_malloc(snd_ctrl->data_len);
 
   if (leveldir_current == NULL)
     leveldir_current = checked_calloc(sizeof(TreeInfo));
@@ -276,17 +568,19 @@ static void ReadReloadInfoFromPipe(struct SoundControl snd_ctrl)
   if (ti->fullpath != NULL)
     free(ti->fullpath);
 
-  if (read(audio.soundserver_pipe[0], set_name,
-	   snd_ctrl.data_len) != snd_ctrl.data_len ||
-      read(audio.soundserver_pipe[0], leveldir_current,
+  if (read(audio.mixer_pipe[0], set_name,
+	   snd_ctrl->data_len) != snd_ctrl->data_len ||
+      read(audio.mixer_pipe[0], override_level_artwork,
+	   sizeof(boolean)) != sizeof(boolean) ||
+      read(audio.mixer_pipe[0], leveldir_current,
 	   sizeof(TreeInfo)) != sizeof(TreeInfo) ||
-      read(audio.soundserver_pipe[0], ti,
+      read(audio.mixer_pipe[0], ti,
 	   sizeof(TreeInfo)) != sizeof(TreeInfo) ||
-      read(audio.soundserver_pipe[0], &str_size1,
+      read(audio.mixer_pipe[0], &str_size1,
 	   sizeof(unsigned long)) != sizeof(unsigned long) ||
-      read(audio.soundserver_pipe[0], &str_size2,
+      read(audio.mixer_pipe[0], &str_size2,
 	   sizeof(unsigned long)) != sizeof(unsigned long) ||
-      read(audio.soundserver_pipe[0], &str_size3,
+      read(audio.mixer_pipe[0], &str_size3,
 	   sizeof(unsigned long)) != sizeof(unsigned long))
     Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
 
@@ -294,877 +588,821 @@ static void ReadReloadInfoFromPipe(struct SoundControl snd_ctrl)
   ti->basepath = checked_calloc(str_size2);
   ti->fullpath = checked_calloc(str_size3);
 
-  if (read(audio.soundserver_pipe[0], leveldir_current->fullpath,
+  if (read(audio.mixer_pipe[0], leveldir_current->fullpath,
 	   str_size1) != str_size1 ||
-      read(audio.soundserver_pipe[0], ti->basepath,
+      read(audio.mixer_pipe[0], ti->basepath,
 	   str_size2) != str_size2 ||
-      read(audio.soundserver_pipe[0], ti->fullpath,
+      read(audio.mixer_pipe[0], ti->fullpath,
 	   str_size3) != str_size3)
     Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
 
-  if (snd_ctrl.state & SND_CTRL_RELOAD_SOUNDS)
-    artwork.sounds_set_current = set_name;
+  if (snd_ctrl->state & SND_CTRL_RELOAD_SOUNDS)
+    artwork.sounds_set_current_name = set_name;
   else
-    artwork.music_set_current = set_name;
+    artwork.music_set_current_name = set_name;
 }
 
-static void HandleSoundRequest(struct SoundControl snd_ctrl)
+#endif /* AUDIO_UNIX_NATIVE */
+
+
+/* ------------------------------------------------------------------------- */
+/* mixer functions                                                           */
+/* ------------------------------------------------------------------------- */
+
+void Mixer_InitChannels()
 {
   int i;
 
-  if (IS_RELOADING(snd_ctrl))		/* load new sound or music files */
-  {
-    ReadReloadInfoFromPipe(snd_ctrl);
-    InitPlaylist();
-    CloseAudioDevice(&audio.device_fd);
+  for(i=0; i<audio.num_channels; i++)
+    mixer[i].active = FALSE;
+  mixer_active_channels = 0;
+}
 
-    if (snd_ctrl.state & SND_CTRL_RELOAD_SOUNDS)
-      ReloadCustomSounds();
-    else
-      ReloadCustomMusic();
-  }
-  else if (IS_FADING(snd_ctrl))		/* fade out existing sound or music */
-  {
-    if (!playing_sounds)
-      return;
+static void Mixer_ResetChannelExpiration(int channel)
+{
+  mixer[channel].playing_starttime = Counter();
 
-    if (IS_MUSIC(snd_ctrl))
-    {
-      playlist[MUSIC_CHANNEL].state |= SND_CTRL_FADE;
-      return;
-    }
+#if defined(TARGET_SDL)
+  if (IS_LOOP(mixer[channel]) && !IS_MUSIC(mixer[channel]))
+    Mix_ExpireChannel(channel, SOUND_LOOP_EXPIRATION_TIME);
+#endif
+}
 
-    for(i=FIRST_SOUND_CHANNEL; i<NUM_MIXER_CHANNELS; i++)
-      if (playlist[i].nr == snd_ctrl.nr || ALL_SOUNDS(snd_ctrl))
-	playlist[i].state |= SND_CTRL_FADE;
-  }
-  else if (IS_STOPPING(snd_ctrl))	/* stop existing sound or music */
-  {
-    if (!playing_sounds)
-      return;
+static boolean Mixer_ChannelExpired(int channel)
+{
+  if (!mixer[channel].active)
+    return TRUE;
 
-    if (IS_MUSIC(snd_ctrl))
-    {
-      PlaylistRemoveSound(MUSIC_CHANNEL);
-      return;
-    }
+  if (IS_LOOP(mixer[channel]) && !IS_MUSIC(mixer[channel]) &&
+      DelayReached(&mixer[channel].playing_starttime,
+		   SOUND_LOOP_EXPIRATION_TIME))
+    return TRUE;
 
-    for(i=FIRST_SOUND_CHANNEL; i<NUM_MIXER_CHANNELS; i++)
-      if (playlist[i].nr == snd_ctrl.nr || ALL_SOUNDS(snd_ctrl))
-	PlaylistRemoveSound(i);
+#if defined(TARGET_SDL)
 
-    if (!playing_sounds)
-      CloseAudioDevice(&audio.device_fd);
-  }
-  else if (snd_ctrl.active)		/* add new sound to playlist */
-  {
-    SoundServer_InsertNewSound(snd_ctrl);
-  }
+  if (!Mix_Playing(channel))
+    return TRUE;
+
+#elif defined(TARGET_ALLEGRO)
+
+  mixer[channel].playing_pos = voice_get_position(mixer[channel].voice);
+  mixer[channel].volume = voice_get_volume(mixer[channel].voice);
+
+  /* sound sample has completed playing or was completely faded out */
+  if (mixer[channel].playing_pos == -1 || mixer[channel].volume == 0)
+    return TRUE;
+
+#endif /* TARGET_ALLEGRO */
+
+  return FALSE;
 }
+
+static boolean Mixer_AllocateChannel(int channel)
+{
+#if defined(TARGET_ALLEGRO)
+  mixer[channel].voice = allocate_voice((SAMPLE *)mixer[channel].data_ptr);
+  if (mixer[channel].voice < 0)
+    return FALSE;
 #endif
 
-void StartSoundserver(void)
+  return TRUE;
+}
+
+static void Mixer_SetChannelProperties(int channel)
 {
-  if (!audio.sound_available)
+#if defined(TARGET_SDL)
+  Mix_Volume(channel, mixer[channel].volume);
+  Mix_SetPanning(channel,
+		 SOUND_VOLUME_LEFT(mixer[channel].stereo_position),
+		 SOUND_VOLUME_RIGHT(mixer[channel].stereo_position));
+#elif defined(TARGET_ALLEGRO)
+  voice_set_volume(mixer[channel].voice, mixer[channel].volume);
+  voice_set_pan(mixer[channel].voice, mixer[channel].stereo_position);
+#endif
+}
+
+static void Mixer_StartChannel(int channel)
+{
+#if defined(TARGET_SDL)
+  Mix_PlayChannel(channel, mixer[channel].data_ptr,
+		  IS_LOOP(mixer[channel]) ? -1 : 0);
+#elif defined(TARGET_ALLEGRO)
+  if (IS_LOOP(mixer[channel]))
+    voice_set_playmode(mixer[channel].voice, PLAYMODE_LOOP);
+
+  voice_start(mixer[channel].voice);       
+#endif
+}
+
+static void Mixer_PlayChannel(int channel)
+{
+  /* start with inactive channel in case something goes wrong */
+  mixer[channel].active = FALSE;
+
+  if (mixer[channel].type != MUS_TYPE_WAV)
     return;
 
-#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
-  if (!ForkAudioProcess())
-    audio.sound_available = FALSE;
+  if (!Mixer_AllocateChannel(channel))
+    return;
+
+  Mixer_SetChannelProperties(channel);
+  Mixer_StartChannel(channel);
+
+  Mixer_ResetChannelExpiration(channel);
+
+  mixer[channel].playing_pos = 0;
+  mixer[channel].active = TRUE;
+  mixer_active_channels++;
+}
+
+static void Mixer_PlayMusicChannel()
+{
+  Mixer_PlayChannel(audio.music_channel);
+
+#if defined(TARGET_SDL)
+  if (mixer[audio.music_channel].type != MUS_TYPE_WAV)
+  {
+    /* Mix_VolumeMusic() must be called _after_ Mix_PlayMusic() --
+       this looks like a bug in the SDL_mixer library */
+    Mix_PlayMusic(mixer[audio.music_channel].data_ptr, -1);
+    Mix_VolumeMusic(SOUND_MAX_VOLUME);
+  }
 #endif
 }
 
-#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
+static void Mixer_StopChannel(int channel)
+{
+  if (!mixer[channel].active)
+    return;
 
-static void CopySampleToMixingBuffer(struct SoundControl *snd_ctrl,
-				     int sample_pos, int sample_size,
-				     short *buffer_ptr)
+#if defined(TARGET_SDL)
+  Mix_HaltChannel(channel);
+#elif defined(TARGET_ALLEGRO)
+  voice_set_volume(mixer[channel].voice, 0);
+  deallocate_voice(mixer[channel].voice);
+#endif
+
+  mixer[channel].active = FALSE;
+  mixer_active_channels--;
+}
+
+static void Mixer_StopMusicChannel()
 {
-  void *sample_ptr = snd_ctrl->data_ptr;
-  int i;
+  Mixer_StopChannel(audio.music_channel);
 
-  if (snd_ctrl->format == AUDIO_FORMAT_U8)
-    for (i=0; i<sample_size; i++)
-      *buffer_ptr++ =
-	((short)(((byte *)sample_ptr)[sample_pos + i] ^ 0x80)) << 8;
-  else	/* AUDIO_FORMAT_S16 */
-    for (i=0; i<sample_size; i++)
-      *buffer_ptr++ =
-	((short *)sample_ptr)[sample_pos + i];
+#if defined(TARGET_SDL)
+  Mix_HaltMusic();
+#endif
 }
 
-#if defined(AUDIO_STREAMING_DSP)
-static void SoundServer_Mixer()
+static void Mixer_FadeChannel(int channel)
 {
-  static int stereo_volume[PSND_MAX_LEFT2RIGHT + 1];
-  static boolean stereo_volume_calculated = FALSE;
-  static short premix_first_buffer[SND_BLOCKSIZE];
-  static short premix_left_buffer[SND_BLOCKSIZE];
-  static short premix_right_buffer[SND_BLOCKSIZE];
-  static long premix_last_buffer[SND_BLOCKSIZE];
-  static byte playing_buffer[SND_BLOCKSIZE];
-  int max_sample_size;
-  int fragment_size = afmt.fragment_size;
-  int sample_bytes = (afmt.format & AUDIO_FORMAT_U8 ? 1 : 2);
-  boolean stereo = afmt.stereo;
-  int i, j;
+  if (!mixer[channel].active)
+    return;
 
-  if (!stereo_volume_calculated)
-  {
-    for(i=0; i<=PSND_MAX_LEFT2RIGHT; i++)
-      stereo_volume[i] =
-	(int)sqrt((float)(PSND_MAX_LEFT2RIGHT * PSND_MAX_LEFT2RIGHT - i * i));
+  mixer[channel].state |= SND_CTRL_FADE;
 
-    stereo_volume_calculated = TRUE;
-  }
+#if defined(TARGET_SDL)
+  Mix_FadeOutChannel(channel, SOUND_FADING_INTERVAL);
+#elif defined(TARGET_ALLEGRO)
+  if (voice_check(mixer[channel].voice))
+    voice_ramp_volume(mixer[channel].voice, SOUND_FADING_INTERVAL, 0);
+#endif
+}
+
+static void Mixer_FadeMusicChannel()
+{
+  Mixer_FadeChannel(audio.music_channel);
+
+#if defined(TARGET_SDL)
+  Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
+#endif
+}
 
-  if (!playing_sounds)
+static void Mixer_UnFadeChannel(int channel)
+{
+  if (!mixer[channel].active || !IS_FADING(mixer[channel]))
     return;
 
-  if (audio.device_fd < 0)
+  mixer[channel].state &= ~SND_CTRL_FADE;
+  mixer[channel].volume = SOUND_MAX_VOLUME;
+
+#if defined(TARGET_SDL)
+  Mix_ExpireChannel(channel, -1);
+  Mix_Volume(channel, mixer[channel].volume);
+#elif defined(TARGET_ALLEGRO)
+  voice_stop_volumeramp(mixer[channel].voice);
+  voice_ramp_volume(mixer[channel].voice, SOUND_FADING_INTERVAL,
+		    mixer[channel].volume);
+#endif
+}
+
+static void Mixer_InsertSound(SoundControl snd_ctrl)
+{
+  SoundInfo *snd_info;
+  int i, k;
+
+#if 0
+  printf("NEW SOUND %d HAS ARRIVED [%d]\n", snd_ctrl.nr, num_sounds);
+#endif
+
+#if 0
+  printf("%d ACTIVE CHANNELS\n", mixer_active_channels);
+#endif
+
+  if (IS_MUSIC(snd_ctrl))
   {
-    if ((audio.device_fd = OpenAudioDevice(audio.device_name)) < 0)
+    if (num_music == 0)
       return;
 
-    InitAudioDevice(&afmt);
+    snd_ctrl.nr = snd_ctrl.nr % num_music;
   }
+  else if (snd_ctrl.nr >= num_sounds)
+    return;
 
-  max_sample_size = fragment_size / ((stereo ? 2 : 1) * sample_bytes);
+  snd_info = (IS_MUSIC(snd_ctrl) ? Music[snd_ctrl.nr] : Sound[snd_ctrl.nr]);
+  if (snd_info == NULL)
+    return;
 
-  /* first clear the last premixing buffer */
-  memset(premix_last_buffer, 0,
-	 max_sample_size * (stereo ? 2 : 1) * sizeof(long));
+  /* copy sound sample and format information */
+  snd_ctrl.type     = snd_info->type;
+  snd_ctrl.format   = snd_info->format;
+  snd_ctrl.data_ptr = snd_info->data_ptr;
+  snd_ctrl.data_len = snd_info->data_len;
 
-  for(i=0; i<NUM_MIXER_CHANNELS; i++)
+  /* play music samples on a dedicated music channel */
+  if (IS_MUSIC(snd_ctrl))
   {
-    void *sample_ptr;
-    int sample_len;
-    int sample_pos;
-    int sample_size;
+#if 0
+    printf("PLAY MUSIC WITH VOLUME/STEREO %d/%d\n",
+	   snd_ctrl.volume, snd_ctrl.stereo_position);
+#endif
 
-    if (!playlist[i].active)
-      continue;
+    mixer[audio.music_channel] = snd_ctrl;
+    Mixer_PlayMusicChannel();
 
-    /* pointer, lenght and actual playing position of sound sample */
-    sample_ptr = playlist[i].data_ptr;
-    sample_len = playlist[i].data_len;
-    sample_pos = playlist[i].playingpos;
-    sample_size = MIN(max_sample_size, sample_len - sample_pos);
-    playlist[i].playingpos += sample_size;
+    return;
+  }
 
-    /* copy original sample to first mixing buffer */
-    CopySampleToMixingBuffer(&playlist[i], sample_pos, sample_size,
-			     premix_first_buffer);
+  /* check if (and how often) this sound sample is already playing */
+  for (k=0, i=audio.first_sound_channel; i<audio.num_channels; i++)
+    if (mixer[i].active && SAME_SOUND_DATA(mixer[i], snd_ctrl))
+      k++;
 
-    /* are we about to restart a looping sound? */
-    if (IS_LOOP(playlist[i]) && sample_size < max_sample_size)
+#if 0
+  printf("SOUND %d [CURRENTLY PLAYING %d TIMES]\n", snd_ctrl.nr, k);
+#endif
+
+  /* reset expiration delay for already playing loop sounds */
+  if (k > 0 && IS_LOOP(snd_ctrl))
+  {
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
     {
-      while (sample_size < max_sample_size)
+      if (mixer[i].active && SAME_SOUND_DATA(mixer[i], snd_ctrl))
       {
-	int restarted_sample_size =
-	  MIN(max_sample_size - sample_size, sample_len);
+#if 0
+	printf("RESETTING EXPIRATION FOR SOUND %d\n", snd_ctrl.nr);
+#endif
 
-	if (playlist[i].format == AUDIO_FORMAT_U8)
-	  for (j=0; j<restarted_sample_size; j++)
-	    premix_first_buffer[sample_size + j] =
-	      ((short)(((byte *)sample_ptr)[j] ^ 0x80)) << 8;
-	else
-	  for (j=0; j<restarted_sample_size; j++)
-	    premix_first_buffer[sample_size + j] =
-	      ((short *)sample_ptr)[j];
+	if (IS_FADING(mixer[i]))
+	  Mixer_UnFadeChannel(i);
 
-	playlist[i].playingpos = restarted_sample_size;
-	sample_size += restarted_sample_size;
+	/* restore settings like volume and stereo position */
+	mixer[i].volume = snd_ctrl.volume;
+	mixer[i].stereo_position = snd_ctrl.stereo_position;
+
+	Mixer_SetChannelProperties(i);
+	Mixer_ResetChannelExpiration(i);
+
+#if 0
+	printf("RESETTING VOLUME/STEREO FOR SOUND %d TO %d/%d\n",
+	       snd_ctrl.nr, snd_ctrl.volume, snd_ctrl.stereo_position);
+#endif
       }
     }
 
-    /* decrease volume if sound is fading out */
-    if (IS_FADING(playlist[i]) &&
-	playlist[i].volume >= SOUND_FADING_VOLUME_THRESHOLD)
-      playlist[i].volume -= SOUND_FADING_VOLUME_STEP;
+    return;
+  }
 
-    /* adjust volume of actual sound sample */
-    if (playlist[i].volume != PSND_MAX_VOLUME)
-      for(j=0; j<sample_size; j++)
-	premix_first_buffer[j] =
-	  (playlist[i].volume * (long)premix_first_buffer[j])
-	    >> PSND_MAX_VOLUME_BITS;
+#if 0
+  printf("PLAYING NEW SOUND %d\n", snd_ctrl.nr);
+#endif
 
-    /* fill the last mixing buffer with stereo or mono sound */
-    if (stereo)
+  /* don't play sound more than n times simultaneously (with n == 2 for now) */
+  if (k >= 2)
+  {
+    unsigned long playing_current = Counter();
+    int longest = 0, longest_nr = audio.first_sound_channel;
+
+    /* look for oldest equal sound */
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
     {
-      int middle_pos = PSND_MAX_LEFT2RIGHT / 2;
-      int left_volume = stereo_volume[middle_pos + playlist[i].stereo];
-      int right_volume= stereo_volume[middle_pos - playlist[i].stereo];
+      int playing_time = playing_current - mixer[i].playing_starttime;
+      int actual;
 
-      for(j=0; j<sample_size; j++)
-      {
-	premix_left_buffer[j] =
-	  (left_volume * premix_first_buffer[j])
-	    >> PSND_MAX_LEFT2RIGHT_BITS;
-	premix_right_buffer[j] =
-	  (right_volume * premix_first_buffer[j])
-	    >> PSND_MAX_LEFT2RIGHT_BITS;
+      if (!mixer[i].active || !SAME_SOUND_NR(mixer[i], snd_ctrl))
+	continue;
 
-	premix_last_buffer[2 * j + 0] += premix_left_buffer[j];
-	premix_last_buffer[2 * j + 1] += premix_right_buffer[j];
+      actual = 1000 * playing_time / mixer[i].data_len;
+
+      if (actual >= longest)
+      {
+	longest = actual;
+	longest_nr = i;
       }
     }
-    else
-    {
-      for(j=0; j<sample_size; j++)
-	premix_last_buffer[j] += premix_first_buffer[j];
-    }
 
-    /* delete completed sound entries from the playlist */
-    if (playlist[i].playingpos >= playlist[i].data_len)
-    {
-      if (IS_LOOP(playlist[i]))
-	playlist[i].playingpos = 0;
-      else
-	PlaylistRemoveSound(i);
-    }
-    else if (playlist[i].volume <= SOUND_FADING_VOLUME_THRESHOLD)
-      PlaylistRemoveSound(i);
+    Mixer_StopChannel(longest_nr);
   }
 
-  /* prepare final playing buffer according to system audio format */
-  for(i=0; i<max_sample_size * (stereo ? 2 : 1); i++)
-  {
-    /* cut off at 17 bit value */
-    if (premix_last_buffer[i] < -65535)
-      premix_last_buffer[i] = -65535;
-    else if (premix_last_buffer[i] > 65535)
-      premix_last_buffer[i] = 65535;
+  /* If all (non-music) channels are active, stop the channel that has
+     played its sound sample most completely (in percent of the sample
+     length). As we cannot currently get the actual playing position
+     of the channel's sound sample when compiling with the SDL mixer
+     library, we use the current playing time (in milliseconds) instead. */
 
-    /* shift to 16 bit value */
-    premix_last_buffer[i] >>= 1;
+  if (mixer_active_channels ==
+      audio.num_channels - (mixer[audio.music_channel].active ? 0 : 1))
+  {
+    unsigned long playing_current = Counter();
+    int longest = 0, longest_nr = audio.first_sound_channel;
 
-    if (afmt.format & AUDIO_FORMAT_U8)
-    {
-      playing_buffer[i] = (premix_last_buffer[i] >> 8) ^ 0x80;
-    }
-    else if (afmt.format & AUDIO_FORMAT_LE)	/* 16 bit */
-    {
-      playing_buffer[2 * i + 0] = premix_last_buffer[i] & 0xff;
-      playing_buffer[2 * i + 1] = premix_last_buffer[i] >> 8;
-    }
-    else					/* big endian */
+    for (i=audio.first_sound_channel; i<audio.num_channels; i++)
     {
-      playing_buffer[2 * i + 0] = premix_last_buffer[i] >> 8;
-      playing_buffer[2 * i + 1] = premix_last_buffer[i] & 0xff;
+      int playing_time = playing_current - mixer[i].playing_starttime;
+      int actual = 1000 * playing_time / mixer[i].data_len;
+
+      if (!IS_LOOP(mixer[i]) && actual > longest)
+      {
+	longest = actual;
+	longest_nr = i;
+      }
     }
-  }
 
-  /* finally play the sound fragment */
-  write(audio.device_fd, playing_buffer, fragment_size);
+    Mixer_StopChannel(longest_nr);
+  }
 
-  if (!playing_sounds)
-    CloseAudioDevice(&audio.device_fd);
-}
+  /* add the new sound to the mixer */
+  for(i=0; i<audio.num_channels; i++)
+  {
+#if 0
+    printf("CHECKING CHANNEL %d FOR SOUND %d ...\n", i, snd_ctrl.nr);
+#endif
 
-#else /* !AUDIO_STREAMING_DSP */
+    /*
+    if (!mixer[i].active ||
+	(IS_MUSIC(snd_ctrl) && i == audio.music_channel))
+    */
+    if ((i == audio.music_channel && IS_MUSIC(snd_ctrl)) ||
+	(i != audio.music_channel && !mixer[i].active))
+    {
+#if 0
+      printf("ADDING NEW SOUND %d TO MIXER\n", snd_ctrl.nr);
+#endif
 
-static int SoundServer_SimpleAudio(struct SoundControl snd_ctrl)
-{
-  static short premix_first_buffer[SND_BLOCKSIZE];
-  static byte playing_buffer[SND_BLOCKSIZE];
-  int max_sample_size = SND_BLOCKSIZE;
-  void *sample_ptr;
-  int sample_len;
-  int sample_pos;
-  int sample_size;
-  int i, j;
-
-  i = 1;
-
-  /* pointer, lenght and actual playing position of sound sample */
-  sample_ptr = playlist[i].data_ptr;
-  sample_len = playlist[i].data_len;
-  sample_pos = playlist[i].playingpos;
-  sample_size = MIN(max_sample_size, sample_len - sample_pos);
-  playlist[i].playingpos += sample_size;
-
-  /* copy original sample to first mixing buffer */
-  CopySampleToMixingBuffer(&playlist[i], sample_pos, sample_size,
-			   premix_first_buffer);
-
-  /* adjust volume of actual sound sample */
-  if (playlist[i].volume != PSND_MAX_VOLUME)
-    for(j=0; j<sample_size; j++)
-      premix_first_buffer[j] =
-	(playlist[i].volume * (long)premix_first_buffer[j])
-	  >> PSND_MAX_VOLUME_BITS;
-
-  /* might be needed for u-law /dev/audio */
-#if 0
-  for(j=0; j<sample_size; j++)
-    playing_buffer[j] =
-      linear_to_ulaw(premix_first_buffer[j]);
+#if 1
+#if defined(AUDIO_UNIX_NATIVE)
+      if (snd_info->data_len == 0)
+      {
+	printf("THIS SHOULD NEVER HAPPEN! [snd_info->data_len == 0]\n");
+      }
+#endif
 #endif
 
-  /* delete completed sound entries from the playlist */
-  if (playlist[i].playingpos >= playlist[i].data_len)
-    PlaylistRemoveSound(i);
+#if 1
+      if (IS_MUSIC(snd_ctrl) && i == audio.music_channel && mixer[i].active)
+      {
+	printf("THIS SHOULD NEVER HAPPEN! [adding music twice]\n");
 
-  for(i=0; i<sample_size; i++)
-    playing_buffer[i] = (premix_first_buffer[i] >> 8) ^ 0x80;
+#if 1
+	Mixer_StopChannel(i);
+#endif
+      }
+#endif
 
-  /* finally play the sound fragment */
-  write(audio.device_fd, playing_buffer, sample_size);
+      mixer[i] = snd_ctrl;
+      Mixer_PlayChannel(i);
 
-  return sample_size;
+      break;
+    }
+  }
 }
-#endif /* !AUDIO_STREAMING_DSP */
 
-void SoundServer()
+static void HandleSoundRequest(SoundControl snd_ctrl)
 {
-  struct SoundControl snd_ctrl;
-  fd_set sound_fdset;
-
-  close(audio.soundserver_pipe[1]);	/* no writing into pipe needed */
-
-  InitPlaylist();
+  int i;
 
-#if defined(PLATFORM_HPUX)
-  InitAudioDevice(&afmt);
+#if defined(AUDIO_UNIX_NATIVE)
+  if (IS_PARENT_PROCESS(audio.mixer_pid))
+  {
+    SendSoundControlToMixerProcess(&snd_ctrl);
+    return;
+  }
 #endif
 
-  FD_ZERO(&sound_fdset); 
-  FD_SET(audio.soundserver_pipe[0], &sound_fdset);
+  /* deactivate channels that have expired since the last request */
+  for (i=0; i<audio.num_channels; i++)
+    if (mixer[i].active && Mixer_ChannelExpired(i))
+      Mixer_StopChannel(i);
 
-  while(1)	/* wait for sound playing commands from client */
+  if (IS_RELOADING(snd_ctrl))		/* load new sound or music files */
   {
-    struct timeval delay = { 0, 0 };
-
-    FD_SET(audio.soundserver_pipe[0], &sound_fdset);
-    select(audio.soundserver_pipe[0] + 1, &sound_fdset, NULL, NULL, NULL);
-    if (!FD_ISSET(audio.soundserver_pipe[0], &sound_fdset))
-      continue;
-    if (read(audio.soundserver_pipe[0], &snd_ctrl, sizeof(snd_ctrl))
-	!= sizeof(snd_ctrl))
-      Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
+    Mixer_StopMusicChannel();
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
+      Mixer_StopChannel(i);
 
-    HandleSoundRequest(snd_ctrl);
-
-#if defined(AUDIO_STREAMING_DSP)
+#if defined(AUDIO_UNIX_NATIVE)
+    CloseAudioDevice(&audio.device_fd);
+    ReadReloadInfoFromPipe(&snd_ctrl);
+#endif
 
-    while (playing_sounds && select(audio.soundserver_pipe[0] + 1,
-				    &sound_fdset, NULL, NULL, &delay) < 1)
+    if (snd_ctrl.state & SND_CTRL_RELOAD_SOUNDS)
+      ReloadCustomSounds();
+    else
+      ReloadCustomMusic();
+  }
+  else if (IS_FADING(snd_ctrl))		/* fade out existing sound or music */
+  {
+    if (IS_MUSIC(snd_ctrl))
     {
-      FD_SET(audio.soundserver_pipe[0], &sound_fdset);
-
-      SoundServer_Mixer();
+      Mixer_FadeMusicChannel();
+      return;
     }
 
-#else /* !AUDIO_STREAMING_DSP */
-
-    if (!snd_ctrl.active || IS_LOOP(snd_ctrl) ||
-	(audio.device_fd = OpenAudioDevice(audio.device_name)) < 0)
-      continue;
-
-    InitAudioDevice(&afmt);
-
-    delay.tv_sec = 0;
-    delay.tv_usec = 0;
-
-    while (playing_sounds && select(audio.soundserver_pipe[0] + 1,
-				    &sound_fdset, NULL, NULL, &delay) < 1)
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
+      if (SAME_SOUND_NR(mixer[i], snd_ctrl) || ALL_SOUNDS(snd_ctrl))
+	Mixer_FadeChannel(i);
+  }
+  else if (IS_STOPPING(snd_ctrl))	/* stop existing sound or music */
+  {
+    if (IS_MUSIC(snd_ctrl))
     {
-      int wait_percent = 90;	/* wait 90% of the real playing time */
-      int sample_size;
-
-      FD_SET(audio.soundserver_pipe[0], &sound_fdset);
-
-      sample_size = SoundServer_SimpleAudio(snd_ctrl);
-
-      delay.tv_sec = 0;
-      delay.tv_usec =
-	((sample_size * 10 * wait_percent) / afmt.sample_rate) * 1000;
+      Mixer_StopMusicChannel();
+      return;
     }
 
-    CloseAudioDevice(&audio.device_fd);
-
-    /* delete all sounds from playlist */
-    InitPlaylist();
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
+      if (SAME_SOUND_NR(mixer[i], snd_ctrl) || ALL_SOUNDS(snd_ctrl))
+	Mixer_StopChannel(i);
 
-#endif /* !AUDIO_STREAMING_DSP */
+#if defined(AUDIO_UNIX_NATIVE)
+    if (!mixer_active_channels)
+      CloseAudioDevice(&audio.device_fd);
+#endif
+  }
+  else if (snd_ctrl.active)		/* add new sound to mixer */
+  {
+    Mixer_InsertSound(snd_ctrl);
   }
 }
-#endif /* PLATFORM_UNIX */
 
-#if defined(PLATFORM_MSDOS)
-static void sound_handler(struct SoundControl snd_ctrl)
+void StartMixer(void)
 {
   int i;
 
-  if (snd_ctrl.fade_sound)
-  {
-    if (!playing_sounds)
-      return;
-
-    for (i=0; i<NUM_MIXER_CHANNELS; i++)
-      if ((snd_ctrl.stop_all_sounds ||
-	   (i != audio.music_channel && playlist[i].nr == snd_ctrl.nr) ||
-	   (i == audio.music_channel && snd_ctrl.music)) &&
-	  !playlist[i].fade_sound)
-      {
-	playlist[i].fade_sound = TRUE;
-	if (voice_check(playlist[i].voice))
-	  voice_ramp_volume(playlist[i].voice, 1000, 0);
-	playlist[i].state &= ~SND_CTRL_IS_LOOP;
-      }
-  }
-  else if (snd_ctrl.stop_all_sounds)
-  {
-    if (!playing_sounds)
-      return;
-    SoundServer_StopAllSounds();
-  }
-  else if (snd_ctrl.stop_sound)
-  {
-    if (!playing_sounds)
-      return;
-    SoundServer_StopSound(snd_ctrl);
-  }
+#if 0
+  SDL_version compile_version;
+  const SDL_version *link_version;
+  MIX_VERSION(&compile_version);
+  printf("compiled with SDL_mixer version: %d.%d.%d\n", 
+	 compile_version.major,
+	 compile_version.minor,
+	 compile_version.patch);
+  link_version = Mix_Linked_Version();
+  printf("running with SDL_mixer version: %d.%d.%d\n", 
+	 link_version->major,
+	 link_version->minor,
+	 link_version->patch);
+#endif
 
-  for (i=0; i<NUM_MIXER_CHANNELS; i++)
-  {
-    if (!playlist[i].active || playlist[i].loop)
-      continue;
+  if (!audio.sound_available)
+    return;
 
-    playlist[i].playingpos = voice_get_position(playlist[i].voice);
-    playlist[i].volume = voice_get_volume(playlist[i].voice);
-    if (playlist[i].playingpos == -1 || !playlist[i].volume)
-    {
-      deallocate_voice(playlist[i].voice);
-      playlist[i] = emptySoundControl;
-      playing_sounds--;
-    }
-  }
+  /* initialize stereo position conversion information */
+  for(i=0; i<=SOUND_MAX_LEFT2RIGHT; i++)
+    stereo_volume[i] =
+      (int)sqrt((float)(SOUND_MAX_LEFT2RIGHT * SOUND_MAX_LEFT2RIGHT - i * i));
 
-  if (snd_ctrl.active)
-    SoundServer_InsertNewSound(snd_ctrl);
+#if defined(AUDIO_UNIX_NATIVE)
+  if (!ForkAudioProcess())
+    audio.sound_available = FALSE;
+#endif
 }
-#endif /* PLATFORM_MSDOS */
 
-#if 0
-#if defined(TARGET_SDL)
-static void sound_handler_SDL(struct SoundControl snd_ctrl)
-{
-  /* copy sound_handler() here ... */
-}
-#endif /* TARGET_SDL */
-#endif
+#if defined(AUDIO_UNIX_NATIVE)
 
-#if !defined(PLATFORM_WIN32)
-static void SoundServer_InsertNewSound(struct SoundControl snd_ctrl)
+static void CopySampleToMixingBuffer(SoundControl *snd_ctrl,
+				     int sample_pos, int sample_size,
+				     short *buffer_ptr)
 {
-  SoundInfo *snd_info;
-  int i, k;
+  void *sample_ptr = snd_ctrl->data_ptr;
+  int i;
 
-#if 0
-  printf("NEW SOUND %d HAS ARRIVED [%d]\n", snd_ctrl.nr, num_sounds);
-#endif
+  if (snd_ctrl->format == AUDIO_FORMAT_U8)
+    for (i=0; i<sample_size; i++)
+      *buffer_ptr++ =
+	((short)(((byte *)sample_ptr)[sample_pos + i] ^ 0x80)) << 8;
+  else	/* AUDIO_FORMAT_S16 */
+    for (i=0; i<sample_size; i++)
+      *buffer_ptr++ =
+	((short *)sample_ptr)[sample_pos + i];
+}
 
-  if (IS_MUSIC(snd_ctrl))
-    snd_ctrl.nr = snd_ctrl.nr % num_music;
-  else if (snd_ctrl.nr >= num_sounds)
-    return;
+#if defined(AUDIO_STREAMING_DSP)
+static void Mixer_Main_DSP()
+{
+  static short premix_first_buffer[SND_BLOCKSIZE];
+  static short premix_left_buffer[SND_BLOCKSIZE];
+  static short premix_right_buffer[SND_BLOCKSIZE];
+  static long premix_last_buffer[SND_BLOCKSIZE];
+  static byte playing_buffer[SND_BLOCKSIZE];
+  boolean stereo;
+  int fragment_size;
+  int sample_bytes;
+  int max_sample_size;
+  int i, j;
 
-  snd_info = (IS_MUSIC(snd_ctrl) ? Music[snd_ctrl.nr] : Sound[snd_ctrl.nr]);
-  if (snd_info == NULL)
-  {
-#if 0
-    printf("sound/music %d undefined\n", snd_ctrl.nr);
-#endif
+  if (!mixer_active_channels)
     return;
-  }
 
-#if 0
-  printf("-> %d\n", playing_sounds);
-#endif
-
-  if (playing_sounds == NUM_MIXER_CHANNELS)
+  if (audio.device_fd < 0)
   {
-    for (i=0; i<NUM_MIXER_CHANNELS; i++)
-    {
-      if (playlist[i].data_ptr == NULL)
-      {
-#if 1
-	printf("THIS SHOULD NEVER HAPPEN! [%d]\n", i);
-#endif
+    if ((audio.device_fd = OpenAudioDevice(audio.device_name)) < 0)
+      return;
 
-	playlist[i] = emptySoundControl;
-	playing_sounds--;
-      }
-    }
+    InitAudioDevice(&afmt);
   }
 
-  /* if playlist is full, remove oldest sound */
-  if (playing_sounds == NUM_MIXER_CHANNELS)
-  {
-    int longest = 0, longest_nr = 0;
+  stereo = afmt.stereo;
+  fragment_size = afmt.fragment_size;
+  sample_bytes = (afmt.format & AUDIO_FORMAT_U8 ? 1 : 2);
+  max_sample_size = fragment_size / ((stereo ? 2 : 1) * sample_bytes);
 
-    for (i=FIRST_SOUND_CHANNEL; i<NUM_MIXER_CHANNELS; i++)
-    {
-#if !defined(PLATFORM_MSDOS)
-      int actual = 100 * playlist[i].playingpos / playlist[i].data_len;
-#else
-      int actual = playlist[i].playingpos;
-#endif
+  /* first clear the last premixing buffer */
+  memset(premix_last_buffer, 0,
+	 max_sample_size * (stereo ? 2 : 1) * sizeof(long));
 
-      if (!IS_LOOP(playlist[i]) && actual > longest)
-      {
-	longest = actual;
-	longest_nr = i;
-      }
-    }
-#if defined(PLATFORM_MSDOS)
-    voice_set_volume(playlist[longest_nr].voice, 0);
-    deallocate_voice(playlist[longest_nr].voice);
-#endif
-    playlist[longest_nr] = emptySoundControl;
-    playing_sounds--;
-  }
+  for(i=0; i<audio.num_channels; i++)
+  {
+    void *sample_ptr;
+    int sample_len;
+    int sample_pos;
+    int sample_size;
 
-  /* check if sound is already being played (and how often) */
-  for (k=0, i=FIRST_SOUND_CHANNEL; i<NUM_MIXER_CHANNELS; i++)
-    if (playlist[i].nr == snd_ctrl.nr)
-      k++;
+    if (!mixer[i].active)
+      continue;
 
-  /* restart loop sounds only if they are just fading out */
-  if (k >= 1 && IS_LOOP(snd_ctrl))
-  {
-    for(i=FIRST_SOUND_CHANNEL; i<NUM_MIXER_CHANNELS; i++)
+    if (Mixer_ChannelExpired(i))
     {
-      if (playlist[i].nr == snd_ctrl.nr && IS_FADING(playlist[i]))
-      {
-	playlist[i].state &= ~SND_CTRL_FADE;
-	playlist[i].volume = PSND_MAX_VOLUME;
-#if defined(PLATFORM_MSDOS)
-        playlist[i].state |= SND_CTRL_LOOP;
-        voice_stop_volumeramp(playlist[i].voice);
-        voice_ramp_volume(playlist[i].voice, playlist[i].volume, 1000);
-#endif
-      }
+      Mixer_StopChannel(i);
+      continue;
     }
 
-    return;
-  }
+    /* pointer, lenght and actual playing position of sound sample */
+    sample_ptr = mixer[i].data_ptr;
+    sample_len = mixer[i].data_len;
+    sample_pos = mixer[i].playing_pos;
+    sample_size = MIN(max_sample_size, sample_len - sample_pos);
+    mixer[i].playing_pos += sample_size;
 
-  /* don't play sound more than n times simultaneously (with n == 2 for now) */
-  if (k >= 2)
-  {
-    int longest = 0, longest_nr = 0;
+    /* copy original sample to first mixing buffer */
+    CopySampleToMixingBuffer(&mixer[i], sample_pos, sample_size,
+			     premix_first_buffer);
 
-    /* look for oldest equal sound */
-    for(i=FIRST_SOUND_CHANNEL; i<NUM_MIXER_CHANNELS; i++)
+    /* are we about to restart a looping sound? */
+    if (IS_LOOP(mixer[i]) && sample_size < max_sample_size)
     {
-      int actual;
+      while (sample_size < max_sample_size)
+      {
+	int restarted_sample_size =
+	  MIN(max_sample_size - sample_size, sample_len);
 
-      if (!playlist[i].active || playlist[i].nr != snd_ctrl.nr)
-	continue;
+	if (mixer[i].format == AUDIO_FORMAT_U8)
+	  for (j=0; j<restarted_sample_size; j++)
+	    premix_first_buffer[sample_size + j] =
+	      ((short)(((byte *)sample_ptr)[j] ^ 0x80)) << 8;
+	else
+	  for (j=0; j<restarted_sample_size; j++)
+	    premix_first_buffer[sample_size + j] =
+	      ((short *)sample_ptr)[j];
 
-#if !defined(PLATFORM_MSDOS)
-      actual = 100 * playlist[i].playingpos / playlist[i].data_len;
-#else
-      actual = playlist[i].playingpos;
-#endif
-      if (actual >= longest)
-      {
-	longest = actual;
-	longest_nr = i;
+	mixer[i].playing_pos = restarted_sample_size;
+	sample_size += restarted_sample_size;
       }
     }
 
-#if defined(PLATFORM_MSDOS)
-    voice_set_volume(playlist[longest_nr].voice, 0);
-    deallocate_voice(playlist[longest_nr].voice);
-#endif
-    playlist[longest_nr] = emptySoundControl;
-    playing_sounds--;
-  }
+    /* decrease volume if sound is fading out */
+    if (IS_FADING(mixer[i]) &&
+	mixer[i].volume >= SOUND_FADING_VOLUME_THRESHOLD)
+      mixer[i].volume -= SOUND_FADING_VOLUME_STEP;
 
-  /* add new sound to playlist */
-  for(i=0; i<NUM_MIXER_CHANNELS; i++)
-  {
-#if 0
-    printf("CHECKING CHANNEL %d FOR SOUND %d ...\n", i, snd_ctrl.nr);
-#endif
+    /* adjust volume of actual sound sample */
+    if (mixer[i].volume != SOUND_MAX_VOLUME)
+      for(j=0; j<sample_size; j++)
+	premix_first_buffer[j] =
+	  mixer[i].volume * (long)premix_first_buffer[j] / SOUND_MAX_VOLUME;
 
-    /*
-    if (!playlist[i].active ||
-	(IS_MUSIC(snd_ctrl) && i == MUSIC_CHANNEL))
-    */
-    if ((i == MUSIC_CHANNEL && IS_MUSIC(snd_ctrl)) ||
-	(i != MUSIC_CHANNEL && !playlist[i].active))
+    /* fill the last mixing buffer with stereo or mono sound */
+    if (stereo)
     {
-      snd_ctrl.data_ptr = snd_info->data_ptr;
-      snd_ctrl.data_len = snd_info->data_len;
-      snd_ctrl.format   = snd_info->format;
+      int left_volume  = SOUND_VOLUME_LEFT(mixer[i].stereo_position);
+      int right_volume = SOUND_VOLUME_RIGHT(mixer[i].stereo_position);
 
-#if 1
-      if (snd_info->data_len == 0)
-      {
-	printf("THIS SHOULD NEVER HAPPEN! [snd_info->data_len == 0]\n");
-      }
-#endif
-
-#if 1
-      if (IS_MUSIC(snd_ctrl) && i == MUSIC_CHANNEL && playlist[i].active)
+      for(j=0; j<sample_size; j++)
       {
-	printf("THIS SHOULD NEVER HAPPEN! [adding music twice]\n");
+	premix_left_buffer[j] =
+	  left_volume  * premix_first_buffer[j] / SOUND_MAX_LEFT2RIGHT;
+	premix_right_buffer[j] =
+	  right_volume * premix_first_buffer[j] / SOUND_MAX_LEFT2RIGHT;
 
-#if 1
-	playlist[i] = emptySoundControl;
-	playing_sounds--;
-#endif
+	premix_last_buffer[2 * j + 0] += premix_left_buffer[j];
+	premix_last_buffer[2 * j + 1] += premix_right_buffer[j];
       }
-#endif
-
-      playlist[i] = snd_ctrl;
-      playing_sounds++;
-
-#if 0
-      printf("NEW SOUND %d ADDED TO PLAYLIST\n", snd_ctrl.nr);
-#endif
-
-#if defined(PLATFORM_MSDOS)
-      playlist[i].voice = allocate_voice((SAMPLE *)playlist[i].data_ptr);
-
-      if (snd_ctrl.loop)
-        voice_set_playmode(playlist[i].voice, PLAYMODE_LOOP);
+    }
+    else
+    {
+      for(j=0; j<sample_size; j++)
+	premix_last_buffer[j] += premix_first_buffer[j];
+    }
 
-      voice_set_volume(playlist[i].voice, snd_ctrl.volume);
-      voice_set_pan(playlist[i].voice, snd_ctrl.stereo);
-      voice_start(playlist[i].voice);       
-#endif
-      break;
+    /* delete completed sound entries from the mixer */
+    if (mixer[i].playing_pos >= mixer[i].data_len)
+    {
+      if (IS_LOOP(mixer[i]))
+	mixer[i].playing_pos = 0;
+      else
+	Mixer_StopChannel(i);
     }
+    else if (mixer[i].volume <= SOUND_FADING_VOLUME_THRESHOLD)
+      Mixer_StopChannel(i);
   }
-}
-#endif /* !PLATFORM_WIN32 */
-
-/*
-void SoundServer_FadeSound(int nr)
-{
-  int i;
-
-  if (!playing_sounds)
-    return;
-
-  for(i=0;i<NUM_MIXER_CHANNELS;i++)
-    if (snd_ctrl.stop_all_sounds || playlist[i].nr == snd_ctrl.nr)
-      playlist[i].fade_sound = TRUE;
-}
-*/
 
-#if !defined(PLATFORM_WIN32)
-#if defined(PLATFORM_MSDOS)
-static void SoundServer_StopSound(struct SoundControl snd_ctrl)
-{
-  int nr = snd_ctrl.nr;
-  int i;
+  /* prepare final playing buffer according to system audio format */
+  for(i=0; i<max_sample_size * (stereo ? 2 : 1); i++)
+  {
+    /* cut off at 17 bit value */
+    if (premix_last_buffer[i] < -65535)
+      premix_last_buffer[i] = -65535;
+    else if (premix_last_buffer[i] > 65535)
+      premix_last_buffer[i] = 65535;
 
-  if (!playing_sounds)
-    return;
+    /* shift to 16 bit value */
+    premix_last_buffer[i] >>= 1;
 
-  for(i=0; i<NUM_MIXER_CHANNELS; i++)
-  {
-    if ((i == audio.music_channel && snd_ctrl.music) ||
-	(i != audio.music_channel && playlist[i].nr == nr))
+    if (afmt.format & AUDIO_FORMAT_U8)
     {
-#if defined(PLATFORM_MSDOS)
-      voice_set_volume(playlist[i].voice, 0);
-      deallocate_voice(playlist[i].voice);
-#endif
-      playlist[i] = emptySoundControl;
-      playing_sounds--;
+      playing_buffer[i] = (premix_last_buffer[i] >> 8) ^ 0x80;
+    }
+    else if (afmt.format & AUDIO_FORMAT_LE)	/* 16 bit */
+    {
+      playing_buffer[2 * i + 0] = premix_last_buffer[i] & 0xff;
+      playing_buffer[2 * i + 1] = premix_last_buffer[i] >> 8;
+    }
+    else					/* big endian */
+    {
+      playing_buffer[2 * i + 0] = premix_last_buffer[i] >> 8;
+      playing_buffer[2 * i + 1] = premix_last_buffer[i] & 0xff;
     }
   }
 
-#if !defined(PLATFORM_MSDOS)
-  if (!playing_sounds)
-    close(audio.device_fd);
-#endif
-}
-
-static void SoundServer_StopAllSounds()
-{
-  int i;
-
-  for(i=0; i<NUM_MIXER_CHANNELS; i++)
-  {
-#if defined(PLATFORM_MSDOS)
-    voice_set_volume(playlist[i].voice, 0);
-    deallocate_voice(playlist[i].voice);
-#endif
-    playlist[i] = emptySoundControl;
-  }
-  playing_sounds = 0;
+  /* finally play the sound fragment */
+  write(audio.device_fd, playing_buffer, fragment_size);
 
-#if !defined(PLATFORM_MSDOS)
-  close(audio.device_fd);
-#endif
+  if (!mixer_active_channels)
+    CloseAudioDevice(&audio.device_fd);
 }
-#endif /* PLATFORM_MSDOS */
-#endif /* !PLATFORM_WIN32 */
 
+#else /* !AUDIO_STREAMING_DSP */
 
-/* ------------------------------------------------------------------------- */
-/* platform dependant audio initialization code                              */
-/* ------------------------------------------------------------------------- */
-
-#if defined(AUDIO_LINUX_IOCTL)
-static void InitAudioDevice_Linux(struct AudioFormatInfo *afmt)
+static int Mixer_Main_SimpleAudio(SoundControl snd_ctrl)
 {
-  /* "ioctl()" expects pointer to 'int' value for stereo flag
-     (boolean is defined as 'char', which will not work here) */
-  unsigned int fragment_spec = 0;
-  int fragment_size_query;
-  int stereo = TRUE;
-  struct
-  {
-    int format_ioctl;
-    int format_result;
-  }
-  formats[] =
-  {
-    /* supported audio format in preferred order */
-    { AFMT_S16_LE,	AUDIO_FORMAT_S16 | AUDIO_FORMAT_LE },
-    { AFMT_S16_BE,	AUDIO_FORMAT_S16 | AUDIO_FORMAT_BE },
-    { AFMT_U8,		AUDIO_FORMAT_U8                    },
-    { -1,		-1 }
-  };
-  int i;
-
-  /* determine logarithm (log2) of the fragment size */
-  while ((1 << fragment_spec) < afmt->fragment_size)
-    fragment_spec++;
+  static short premix_first_buffer[SND_BLOCKSIZE];
+  static byte playing_buffer[SND_BLOCKSIZE];
+  int max_sample_size = SND_BLOCKSIZE;
+  void *sample_ptr;
+  int sample_len;
+  int sample_pos;
+  int sample_size;
+  int i, j;
 
-  /* use two fragments (play one fragment, prepare the other);
-     one fragment would result in interrupted audio output, more
-     than two fragments would raise audio output latency to much */
-  fragment_spec |= 0x00020000;
+  i = 1;
 
-  /* Example for fragment specification:
-     - 2 buffers / 512 bytes (giving 1/16 second resolution for 8 kHz)
-     - (with stereo the effective buffer size will shrink to 256)
-     => fragment_size = 0x00020009 */
+  /* pointer, lenght and actual playing position of sound sample */
+  sample_ptr = mixer[i].data_ptr;
+  sample_len = mixer[i].data_len;
+  sample_pos = mixer[i].playing_pos;
+  sample_size = MIN(max_sample_size, sample_len - sample_pos);
+  mixer[i].playing_pos += sample_size;
 
-  if (ioctl(audio.device_fd, SNDCTL_DSP_SETFRAGMENT, &fragment_spec) < 0)
-    Error(ERR_EXIT_SOUND_SERVER,
-	  "cannot set fragment size of /dev/dsp -- no sounds");
+  /* copy original sample to first mixing buffer */
+  CopySampleToMixingBuffer(&mixer[i], sample_pos, sample_size,
+			   premix_first_buffer);
 
-  i = 0;
-  afmt->format = 0;
-  while (formats[i].format_result != -1)
-  {
-    unsigned int audio_format = formats[i].format_ioctl;
-    if (ioctl(audio.device_fd, SNDCTL_DSP_SETFMT, &audio_format) == 0)
-    {
-      afmt->format = formats[i].format_result;
-      break;
-    }
-  }
+  /* adjust volume of actual sound sample */
+  if (mixer[i].volume != SOUND_MAX_VOLUME)
+    for(j=0; j<sample_size; j++)
+      premix_first_buffer[j] =
+	mixer[i].volume * (long)premix_first_buffer[j] / SOUND_MAX_VOLUME;
 
-  if (afmt->format == 0)	/* no supported audio format found */
-    Error(ERR_EXIT_SOUND_SERVER,
-	  "cannot set audio format of /dev/dsp -- no sounds");
+  /* might be needed for u-law /dev/audio */
+#if 1
+  for(j=0; j<sample_size; j++)
+    playing_buffer[j] =
+      linear_to_ulaw(premix_first_buffer[j]);
+#endif
 
-  /* try if we can use stereo sound */
-  afmt->stereo = TRUE;
-  if (ioctl(audio.device_fd, SNDCTL_DSP_STEREO, &stereo) < 0)
-    afmt->stereo = FALSE;
+  /* delete completed sound entries from the mixer */
+  if (mixer[i].playing_pos >= mixer[i].data_len)
+    Mixer_StopChannel(i);
 
-  if (ioctl(audio.device_fd, SNDCTL_DSP_SPEED, &afmt->sample_rate) < 0)
-    Error(ERR_EXIT_SOUND_SERVER,
-	  "cannot set sample rate of /dev/dsp -- no sounds");
+  for(i=0; i<sample_size; i++)
+    playing_buffer[i] = (premix_first_buffer[i] >> 8) ^ 0x80;
 
-  /* get the real fragmentation size; this should return 512 */
-  if (ioctl(audio.device_fd, SNDCTL_DSP_GETBLKSIZE, &fragment_size_query) < 0)
-    Error(ERR_EXIT_SOUND_SERVER,
-	  "cannot get fragment size of /dev/dsp -- no sounds");
-  if (fragment_size_query != afmt->fragment_size)
-    Error(ERR_EXIT_SOUND_SERVER,
-	  "cannot set fragment size of /dev/dsp -- no sounds");
+  /* finally play the sound fragment */
+  write(audio.device_fd, playing_buffer, sample_size);
+
+  return sample_size;
 }
-#endif	/* AUDIO_LINUX_IOCTL */
+#endif /* !AUDIO_STREAMING_DSP */
 
-#if defined(PLATFORM_NETBSD)
-static void InitAudioDevice_NetBSD(struct AudioFormatInfo *afmt)
+void Mixer_Main()
 {
-  audio_info_t a_info;
-  boolean stereo = TRUE;
+  SoundControl snd_ctrl;
+  fd_set mixer_fdset;
 
-  AUDIO_INITINFO(&a_info);
-  a_info.play.encoding = AUDIO_ENCODING_LINEAR8;
-  a_info.play.precision = 8;
-  a_info.play.channels = 2;
-  a_info.play.sample_rate = sample_rate;
-  a_info.blocksize = fragment_size;
+  close(audio.mixer_pipe[1]);	/* no writing into pipe needed */
 
-  afmt->format = AUDIO_FORMAT_U8;
-  afmt->stereo = TRUE;
+  Mixer_InitChannels();
 
-  if (ioctl(audio.device_fd, AUDIO_SETINFO, &a_info) < 0)
+#if defined(PLATFORM_HPUX)
+  InitAudioDevice(&afmt);
+#endif
+
+  FD_ZERO(&mixer_fdset); 
+  FD_SET(audio.mixer_pipe[0], &mixer_fdset);
+
+  while(1)	/* wait for sound playing commands from client */
   {
-    /* try to disable stereo */
-    a_info.play.channels = 1;
+    struct timeval delay = { 0, 0 };
 
-    afmt->stereo = FALSE;
+    FD_SET(audio.mixer_pipe[0], &mixer_fdset);
+    select(audio.mixer_pipe[0] + 1, &mixer_fdset, NULL, NULL, NULL);
+    if (!FD_ISSET(audio.mixer_pipe[0], &mixer_fdset))
+      continue;
 
-    if (ioctl(audio.device_fd, AUDIO_SETINFO, &a_info) < 0)
-      Error(ERR_EXIT_SOUND_SERVER,
-	    "cannot set sample rate of /dev/audio -- no sounds");
-  }
-}
-#endif /* PLATFORM_NETBSD */
+    ReadSoundControlFromMainProcess(&snd_ctrl);
 
-#if defined(PLATFORM_HPUX)
-static void InitAudioDevice_HPUX(struct AudioFormatInfo *afmt)
-{
-  struct audio_describe ainfo;
-  int audio_ctl;
+    HandleSoundRequest(snd_ctrl);
 
-  audio_ctl = open("/dev/audioCtl", O_WRONLY | O_NDELAY);
-  if (audio_ctl == -1)
-    Error(ERR_EXIT_SOUND_SERVER, "cannot open /dev/audioCtl -- no sounds");
+#if defined(AUDIO_STREAMING_DSP)
 
-  if (ioctl(audio_ctl, AUDIO_DESCRIBE, &ainfo) == -1)
-    Error(ERR_EXIT_SOUND_SERVER, "no audio info -- no sounds");
+    while (mixer_active_channels &&
+	   select(audio.mixer_pipe[0] + 1,
+		  &mixer_fdset, NULL, NULL, &delay) < 1)
+    {
+      FD_SET(audio.mixer_pipe[0], &mixer_fdset);
 
-  if (ioctl(audio_ctl, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_ULAW) == -1)
-    Error(ERR_EXIT_SOUND_SERVER, "ulaw audio not available -- no sounds");
+      Mixer_Main_DSP();
+    }
 
-  ioctl(audio_ctl, AUDIO_SET_CHANNELS, 1);
-  ioctl(audio_ctl, AUDIO_SET_SAMPLE_RATE, 8000);
+#else /* !AUDIO_STREAMING_DSP */
 
-  afmt->format = AUDIO_FORMAT_U8;
-  afmt->stereo = FALSE;
-  afmt->sample_rate = 8000;
+    if (!snd_ctrl.active || IS_LOOP(snd_ctrl) ||
+	(audio.device_fd = OpenAudioDevice(audio.device_name)) < 0)
+      continue;
 
-  close(audio_ctl);
-}
-#endif /* PLATFORM_HPUX */
+    InitAudioDevice(&afmt);
 
-#if defined(PLATFORM_UNIX)
-static void InitAudioDevice(struct AudioFormatInfo *afmt)
-{
-#if defined(AUDIO_LINUX_IOCTL)
-  InitAudioDevice_Linux(afmt);
-#elif defined(PLATFORM_NETBSD)
-  InitAudioDevice_NetBSD(afmt);
-#elif defined(PLATFORM_HPUX)
-  InitAudioDevice_HPUX(afmt);
-#else
-  /* generic /dev/audio stuff might be placed here */
-#endif
+    delay.tv_sec = 0;
+    delay.tv_usec = 0;
+
+    while (mixer_active_channels &&
+	   select(audio.mixer_pipe[0] + 1,
+		  &mixer_fdset, NULL, NULL, &delay) < 1)
+    {
+      int wait_percent = 90;	/* wait 90% of the real playing time */
+      int sample_size;
+
+      FD_SET(audio.mixer_pipe[0], &mixer_fdset);
+
+      sample_size = Mixer_Main_SimpleAudio(snd_ctrl);
+
+      delay.tv_sec = 0;
+      delay.tv_usec =
+	((sample_size * 10 * wait_percent) / afmt.sample_rate) * 1000;
+    }
+
+    CloseAudioDevice(&audio.device_fd);
+
+    Mixer_InitChannels();	/* remove all sounds from mixer */
+
+#endif /* !AUDIO_STREAMING_DSP */
+  }
 }
-#endif /* PLATFORM_UNIX */
+#endif /* AUDIO_UNIX_NATIVE */
 
-#if defined(PLATFORM_UNIX) && !defined(AUDIO_STREAMING_DSP)
+
+#if defined(AUDIO_UNIX_NATIVE) && !defined(AUDIO_STREAMING_DSP)
 
 /* these two are stolen from "sox"... :) */
 
@@ -1269,7 +1507,7 @@ static int ulaw_to_linear(unsigned char ulawbyte)
 
   return(sample);
 }
-#endif /* PLATFORM_UNIX && !AUDIO_STREAMING_DSP */
+#endif /* AUDIO_UNIX_NATIVE && !AUDIO_STREAMING_DSP */
 
 
 /* THE STUFF ABOVE IS ONLY USED BY THE SOUND SERVER CHILD PROCESS            */
@@ -1282,12 +1520,15 @@ static int ulaw_to_linear(unsigned char ulawbyte)
 static SoundInfo *Load_WAV(char *filename)
 {
   SoundInfo *snd_info;
-#if !defined(TARGET_SDL) && !defined(PLATFORM_MSDOS)
+#if defined(AUDIO_UNIX_NATIVE)
+  struct SoundHeader_WAV header;
+#if 0
   byte sound_header_buffer[WAV_HEADER_SIZE];
+  int i;
+#endif
   char chunk_name[CHUNK_ID_LEN + 1];
   int chunk_size;
   FILE *file;
-  int i;
 #endif
 
   if (!audio.sound_available)
@@ -1308,6 +1549,8 @@ static SoundInfo *Load_WAV(char *filename)
     return NULL;
   }
 
+  snd_info->data_len = ((Mix_Chunk *)snd_info->data_ptr)->alen;
+
 #elif defined(TARGET_ALLEGRO)
 
   if ((snd_info->data_ptr = load_sample(filename)) == NULL)
@@ -1317,7 +1560,9 @@ static SoundInfo *Load_WAV(char *filename)
     return NULL;
   }
 
-#else	/* PLATFORM_UNIX */
+  snd_info->data_len = ((SAMPLE *)snd_info->data_ptr)->len;
+
+#else /* AUDIO_UNIX_NATIVE */
 
   if ((file = fopen(filename, MODE_READ)) == NULL)
   {
@@ -1327,7 +1572,7 @@ static SoundInfo *Load_WAV(char *filename)
   }
 
   /* read chunk id "RIFF" */
-  getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_LITTLE_ENDIAN);
+  getFileChunkLE(file, chunk_name, &chunk_size);
   if (strcmp(chunk_name, "RIFF") != 0)
   {
     Error(ERR_WARN, "missing 'RIFF' chunk of sound file '%s'", filename);
@@ -1337,7 +1582,7 @@ static SoundInfo *Load_WAV(char *filename)
   }
 
   /* read "RIFF" type id "WAVE" */
-  getFileChunk(file, chunk_name, NULL, BYTE_ORDER_LITTLE_ENDIAN);
+  getFileChunkLE(file, chunk_name, NULL);
   if (strcmp(chunk_name, "WAVE") != 0)
   {
     Error(ERR_WARN, "missing 'WAVE' type ID of sound file '%s'", filename);
@@ -1346,16 +1591,69 @@ static SoundInfo *Load_WAV(char *filename)
     return NULL;
   }
 
-  while (getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_LITTLE_ENDIAN))
+  while (getFileChunkLE(file, chunk_name, &chunk_size))
   {
     if (strcmp(chunk_name, "fmt ") == 0)
     {
-      /* read header information */
-      for (i=0; i < MIN(chunk_size, WAV_HEADER_SIZE); i++)
-	sound_header_buffer[i] = fgetc(file);
+      if (chunk_size < WAV_HEADER_SIZE)
+      {
+	Error(ERR_WARN, "sound file '%s': chunk 'fmt ' too short", filename);
+	fclose(file);
+	free(snd_info);
+	return NULL;
+      }
+
+      header.compression_code = getFile16BitLE(file);
+      header.num_channels = getFile16BitLE(file);
+      header.sample_rate = getFile32BitLE(file);
+      header.bytes_per_second = getFile32BitLE(file);
+      header.block_align = getFile16BitLE(file);
+      header.bits_per_sample = getFile16BitLE(file);
 
       if (chunk_size > WAV_HEADER_SIZE)
 	ReadUnusedBytesFromFile(file, chunk_size - WAV_HEADER_SIZE);
+
+      if (header.compression_code != 1)
+      {
+	Error(ERR_WARN, "sound file '%s': compression code %d not supported",
+	      filename, header.compression_code);
+	fclose(file);
+	free(snd_info);
+	return NULL;
+      }
+
+      if (header.num_channels != 1)
+      {
+	Error(ERR_WARN, "sound file '%s': number of %d channels not supported",
+	      filename, header.num_channels);
+	fclose(file);
+	free(snd_info);
+	return NULL;
+      }
+
+      if (header.bits_per_sample != 8 && header.bits_per_sample != 16)
+      {
+	Error(ERR_WARN, "sound file '%s': %d bits per sample not supported",
+	      filename, header.bits_per_sample);
+	fclose(file);
+	free(snd_info);
+	return NULL;
+      }
+
+      /* warn, but accept wrong sample rate (may be only slightly different) */
+      if (header.sample_rate != DEFAULT_AUDIO_SAMPLE_RATE)
+	Error(ERR_WARN, "sound file '%s': wrong sample rate %d instead of %d",
+	      filename, header.sample_rate, DEFAULT_AUDIO_SAMPLE_RATE);
+
+#if 0
+      printf("WAV file: '%s'\n", filename);
+      printf("  Compression code: %d'\n", header.compression_code);
+      printf("  Number of channels: %d'\n", header.num_channels);
+      printf("  Sample rate: %ld'\n", header.sample_rate);
+      printf("  Average bytes per second: %ld'\n", header.bytes_per_second);
+      printf("  Block align: %d'\n", header.block_align);
+      printf("  Significant bits per sample: %d'\n", header.bits_per_sample);
+#endif
     }
     else if (strcmp(chunk_name, "data") == 0)
     {
@@ -1390,9 +1688,15 @@ static SoundInfo *Load_WAV(char *filename)
     return NULL;
   }
 
-  snd_info->format = AUDIO_FORMAT_U8;
+  if (header.bits_per_sample == 8)
+    snd_info->format = AUDIO_FORMAT_U8;
+  else					/* header.bits_per_sample == 16 */
+  {
+    snd_info->format = AUDIO_FORMAT_S16;
+    snd_info->data_len /= 2;		/* correct number of samples */
+  }
 
-#endif	/* PLATFORM_UNIX */
+#endif	/* AUDIO_UNIX_NATIVE */
 
   snd_info->type = SND_TYPE_WAV;
   snd_info->source_filename = getStringCopy(filename);
@@ -1468,6 +1772,10 @@ static void LoadCustomSound(SoundInfo **snd_info, char *basename)
 {
   char *filename = getCustomSoundFilename(basename);
 
+#if 0
+  printf("GOT CUSTOM SOUND FILE '%s'\n", filename);
+#endif
+
   if (strcmp(basename, SND_FILE_UNDEFINED) == 0)
   {
     deleteSoundEntry(snd_info);
@@ -1538,6 +1846,8 @@ static MusicInfo *Load_MOD(char *filename)
 
 void LoadCustomMusic(void)
 {
+  static boolean draw_init_text = TRUE;		/* only draw at startup */
+  static char *last_music_directory = NULL;
   char *music_directory = getCustomMusicDirectory();
   DIR *dir;
   struct dirent *dir_entry;
@@ -1545,6 +1855,14 @@ void LoadCustomMusic(void)
   if (!audio.sound_available)
     return;
 
+  if (last_music_directory != NULL &&
+      strcmp(last_music_directory, music_directory) == 0)
+    return;	/* old and new music directory are the same */
+
+  last_music_directory = music_directory;
+
+  FreeAllMusic();
+
   if ((dir = opendir(music_directory)) == NULL)
   {
     Error(ERR_WARN, "cannot read music directory '%s'", music_directory);
@@ -1552,12 +1870,18 @@ void LoadCustomMusic(void)
     return;
   }
 
+  if (draw_init_text)
+    DrawInitText("Loading music:", 120, FC_GREEN);
+
   while ((dir_entry = readdir(dir)) != NULL)	/* loop until last dir entry */
   {
     char *basename = dir_entry->d_name;
     char *filename = getPath2(music_directory, basename);
     MusicInfo *mus_info = NULL;
 
+    if (draw_init_text)
+      DrawInitText(basename, 150, FC_YELLOW);
+
     if (FileIsSound(basename))
       mus_info = Load_WAV(filename);
     else if (FileIsMusic(basename))
@@ -1575,6 +1899,8 @@ void LoadCustomMusic(void)
 
   closedir(dir);
 
+  draw_init_text = FALSE;
+
   if (num_music == 0)
     Error(ERR_WARN, "cannot find any valid music files in directory '%s'",
 	  music_directory);
@@ -1585,105 +1911,63 @@ void PlayMusic(int nr)
   if (!audio.music_available)
     return;
 
-#if defined(TARGET_SDL)
-
-  nr = nr % num_music;
-
-  if (Music[nr]->type == MUS_TYPE_MOD)
-  {
-    Mix_PlayMusic(Music[nr]->data_ptr, -1);
-    Mix_VolumeMusic(SOUND_MAX_VOLUME);	/* must be _after_ Mix_PlayMusic()! */
-  }
-  else				/* play WAV music loop */
-  {
-    Mix_Volume(audio.music_channel, SOUND_MAX_VOLUME);
-    Mix_PlayChannel(audio.music_channel, Music[nr]->data_ptr, -1);
-  }
-
-#else
-
   PlaySoundMusic(nr);
-
-#endif
 }
 
 void PlaySound(int nr)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_SOUND);
+  PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_SOUND);
 }
 
-void PlaySoundStereo(int nr, int stereo)
+void PlaySoundStereo(int nr, int stereo_position)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, stereo, SND_CTRL_PLAY_SOUND);
+  PlaySoundExt(nr, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_SOUND);
 }
 
 void PlaySoundLoop(int nr)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_LOOP);
+  PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_LOOP);
 }
 
 void PlaySoundMusic(int nr)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_MUSIC);
+  PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_MUSIC);
 }
 
-void PlaySoundExt(int nr, int volume, int stereo, int state)
+void PlaySoundExt(int nr, int volume, int stereo_position, int state)
 {
-  struct SoundControl snd_ctrl = emptySoundControl;
+  SoundControl snd_ctrl;
 
   if (!audio.sound_available ||
       !audio.sound_enabled ||
       audio.sound_deactivated)
     return;
 
-  if (volume < PSND_MIN_VOLUME)
-    volume = PSND_MIN_VOLUME;
-  else if (volume > PSND_MAX_VOLUME)
-    volume = PSND_MAX_VOLUME;
+  if (volume < SOUND_MIN_VOLUME)
+    volume = SOUND_MIN_VOLUME;
+  else if (volume > SOUND_MAX_VOLUME)
+    volume = SOUND_MAX_VOLUME;
 
-  if (stereo < PSND_MAX_LEFT)
-    stereo = PSND_MAX_LEFT;
-  else if (stereo > PSND_MAX_RIGHT)
-    stereo = PSND_MAX_RIGHT;
+  if (stereo_position < SOUND_MAX_LEFT)
+    stereo_position = SOUND_MAX_LEFT;
+  else if (stereo_position > SOUND_MAX_RIGHT)
+    stereo_position = SOUND_MAX_RIGHT;
 
   snd_ctrl.active = TRUE;
-  snd_ctrl.nr     = nr;
+  snd_ctrl.nr = nr;
   snd_ctrl.volume = volume;
-  snd_ctrl.stereo = stereo;
-  snd_ctrl.state  = state;
-
-#if defined(TARGET_SDL)
-  if (Sound[nr])
-  {
-    Mix_Volume(-1, SOUND_MAX_VOLUME);
-    Mix_PlayChannel(-1, Sound[nr]->data_ptr, (state & SND_CTRL_LOOP ? -1 : 0));
-  }
-#elif defined(PLATFORM_UNIX)
-  if (audio.soundserver_pid == 0)	/* we are child process */
-    return;
+  snd_ctrl.stereo_position = stereo_position;
+  snd_ctrl.state = state;
 
-  if (write(audio.soundserver_pipe[1], &snd_ctrl, sizeof(snd_ctrl)) < 0)
-  {
-    Error(ERR_WARN, "cannot pipe to child process -- no sounds");
-    audio.sound_available = audio.sound_enabled = FALSE;
-    return;
-  }
-#elif defined(PLATFORM_MSDOS)
-  sound_handler(snd_ctrl);
-#endif
+  HandleSoundRequest(snd_ctrl);
 }
 
 void FadeMusic(void)
 {
-  if (!audio.sound_available)
+  if (!audio.music_available)
     return;
 
-#if defined(TARGET_SDL)
-  Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
-  Mix_FadeOutChannel(audio.music_channel, SOUND_FADING_INTERVAL);
-#else
   StopSoundExt(-1, SND_CTRL_FADE_MUSIC);
-#endif
 }
 
 void FadeSound(int nr)
@@ -1699,15 +1983,10 @@ void FadeSounds()
 
 void StopMusic(void)
 {
-#if defined(TARGET_SDL)
-  if (!audio.sound_available)
+  if (!audio.music_available)
     return;
 
-  Mix_HaltMusic();
-  Mix_HaltChannel(audio.music_channel);
-#else
   StopSoundExt(-1, SND_CTRL_STOP_MUSIC);
-#endif
 }
 
 void StopSound(int nr)
@@ -1723,51 +2002,16 @@ void StopSounds()
 
 void StopSoundExt(int nr, int state)
 {
-  struct SoundControl snd_ctrl = emptySoundControl;
+  SoundControl snd_ctrl;
 
   if (!audio.sound_available)
     return;
 
-  snd_ctrl.nr    = nr;
+  snd_ctrl.active = FALSE;
+  snd_ctrl.nr = nr;
   snd_ctrl.state = state;
 
-#if defined(TARGET_SDL)
-
-  if (state & SND_CTRL_FADE)
-  {
-    int i;
-
-    for (i=0; i<audio.channels; i++)
-      if (i != audio.music_channel || snd_ctrl.music)
-	Mix_FadeOutChannel(i, SOUND_FADING_INTERVAL);
-    if (state & SND_CTRL_MUSIC)
-      Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
-  }
-  else
-  {
-    int i;
-
-    for (i=0; i<audio.channels; i++)
-      if (i != audio.music_channel || snd_ctrl.music)
-	Mix_HaltChannel(i);
-    if (state & SND_CTRL_MUSIC)
-      Mix_HaltMusic();
-  }
-
-#elif !defined(PLATFORM_MSDOS)
-
-  if (audio.soundserver_pid == 0)	/* we are child process */
-    return;
-
-  if (write(audio.soundserver_pipe[1], &snd_ctrl, sizeof(snd_ctrl)) < 0)
-  {
-    Error(ERR_WARN, "cannot pipe to child process -- no sounds");
-    audio.sound_available = audio.sound_enabled = FALSE;
-    return;
-  }
-#else /* PLATFORM_MSDOS */
-  sound_handler(snd_ctrl);
-#endif
+  HandleSoundRequest(snd_ctrl);
 }
 
 ListNode *newListNode()
@@ -1851,6 +2095,10 @@ static void LoadSoundsInfo()
   struct SetupFileList *setup_file_list;
   int i;
 
+#if 0
+  printf("GOT CUSTOM SOUND CONFIG FILE '%s'\n", filename);
+#endif
+
   /* always start with reliable default values */
   for (i=0; i<num_sounds; i++)
     sound_effect[i].filename = NULL;
@@ -1866,7 +2114,7 @@ static void LoadSoundsInfo()
 
     freeSetupFileList(setup_file_list);
 
-#if 1
+#if 0
     for (i=0; i<num_sounds; i++)
     {
       printf("'%s' ", sound_effect[i].text);
@@ -1881,26 +2129,35 @@ static void LoadSoundsInfo()
 
 static void ReloadCustomSounds()
 {
+  static boolean draw_init_text = TRUE;		/* only draw at startup */
   int i;
 
 #if 0
-  printf("DEBUG: reloading sounds '%s' ...\n", artwork.sounds_set_current);
+  printf("DEBUG: reloading sounds '%s' ...\n",artwork.sounds_set_current_name);
 #endif
 
   LoadSoundsInfo();
 
+  if (draw_init_text)
+    DrawInitText("Loading sounds:", 120, FC_GREEN);
+
 #if 0
   printf("DEBUG: reloading %d sounds ...\n", num_sounds);
 #endif
 
   for(i=0; i<num_sounds; i++)
   {
+    if (draw_init_text)
+      DrawInitText(sound_effect[i].text, 150, FC_YELLOW);
+
     if (sound_effect[i].filename)
       LoadSoundToList(sound_effect[i].filename, i);
     else
       LoadSoundToList(sound_effect[i].default_filename, i);
   }
 
+  draw_init_text = FALSE;
+
   /*
   printf("list size == %d\n", getNumNodes(SoundFileList));
   */
@@ -1913,87 +2170,39 @@ static void ReloadCustomSounds()
 static void ReloadCustomMusic()
 {
 #if 0
-  printf("DEBUG: reloading music '%s' ...\n", artwork.music_set_current);
+  printf("DEBUG: reloading music '%s' ...\n", artwork.music_set_current_name);
 #endif
 
+#if 0
+  /* this is done directly in LoadCustomMusic() now */
   FreeAllMusic();
+#endif
 
   LoadCustomMusic();
 }
 
-static void InitReloadSoundsOrMusic(char *set_name, int type)
+void InitReloadSounds(char *set_name)
 {
-#if 0
-#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
-  struct SoundControl snd_ctrl = emptySoundControl;
-  TreeInfo *ti = (state == SND_CTRL_RELOAD_SOUNDS ? artwork.snd_current :
-		  artwork.mus_current);
-  unsigned long str_size1 = strlen(leveldir_current->fullpath) + 1;
-  unsigned long str_size2 = strlen(ti->basepath) + 1;
-  unsigned long str_size3 = strlen(ti->fullpath) + 1;
-#endif
-#endif
-
   if (!audio.sound_available)
     return;
 
-#if defined(TARGET_SDL) || defined(TARGET_ALLEGRO)
-  if (type == SND_CTRL_RELOAD_SOUNDS)
-    ReloadCustomSounds();
-  else
-    ReloadCustomMusic();
-#elif defined(PLATFORM_UNIX)
-  if (audio.soundserver_pid == 0)	/* we are child process */
-    return;
-
-  if (leveldir_current == NULL)		/* should never happen */
-    Error(ERR_EXIT, "leveldir_current == NULL");
-
-#if 1
-  WriteReloadInfoToPipe(set_name, type);
+#if defined(AUDIO_UNIX_NATIVE)
+  WriteReloadInfoToPipe(set_name, SND_CTRL_RELOAD_SOUNDS);
 #else
-
-  snd_ctrl.state = type;
-  snd_ctrl.data_len = strlen(set_name) + 1;
-
-  if (write(audio.soundserver_pipe[1], &snd_ctrl,
-	    sizeof(snd_ctrl)) < 0 ||
-      write(audio.soundserver_pipe[1], set_name,
-	    snd_ctrl.data_len) < 0 ||
-      write(audio.soundserver_pipe[1], leveldir_current,
-	    sizeof(TreeInfo)) < 0 ||
-      write(audio.soundserver_pipe[1], ti,
-	    sizeof(TreeInfo)) < 0 ||
-      write(audio.soundserver_pipe[1], &str_size1,
-	    sizeof(unsigned long)) < 0 ||
-      write(audio.soundserver_pipe[1], &str_size2,
-	    sizeof(unsigned long)) < 0 ||
-      write(audio.soundserver_pipe[1], &str_size3,
-	    sizeof(unsigned long)) < 0 ||
-      write(audio.soundserver_pipe[1], leveldir_current->fullpath,
-	    str_size1) < 0 ||
-      write(audio.soundserver_pipe[1], ti->basepath,
-	    str_size2) < 0 ||
-      write(audio.soundserver_pipe[1], ti->fullpath,
-	    str_size3) < 0)
-  {
-    Error(ERR_WARN, "cannot pipe to child process -- no sounds");
-    audio.sound_available = audio.sound_enabled = FALSE;
-    return;
-  }
-#endif
-
+  ReloadCustomSounds();
 #endif
 }
 
-void InitReloadSounds(char *set_name)
-{
-  InitReloadSoundsOrMusic(set_name, SND_CTRL_RELOAD_SOUNDS);
-}
-
 void InitReloadMusic(char *set_name)
 {
-  InitReloadSoundsOrMusic(set_name, SND_CTRL_RELOAD_MUSIC);
+  if (!audio.music_available)
+    return;
+
+#if defined(AUDIO_UNIX_NATIVE)
+  WriteReloadInfoToPipe(set_name, SND_CTRL_RELOAD_MUSIC);
+#else
+  ReloadCustomMusic();
+#endif
 }
 
 void FreeSound(void *ptr)
@@ -2009,7 +2218,7 @@ void FreeSound(void *ptr)
     Mix_FreeChunk(sound->data_ptr);
 #elif defined(TARGET_ALLEGRO)
     destroy_sample(sound->data_ptr);
-#else	/* PLATFORM_UNIX */
+#else /* AUDIO_UNIX_NATIVE */
     free(sound->data_ptr);
 #endif
   }
@@ -2034,7 +2243,7 @@ void FreeMusic(MusicInfo *music)
       Mix_FreeChunk(music->data_ptr);
 #elif defined(TARGET_ALLEGRO)
     destroy_sample(music->data_ptr);
-#else	/* PLATFORM_UNIX */
+#else /* AUDIO_UNIX_NATIVE */
     free(music->data_ptr);
 #endif
   }
@@ -2049,8 +2258,10 @@ void FreeAllSounds()
   if (Sound == NULL)
     return;
 
+#if 0
   printf("%s: FREEING SOUNDS ...\n",
-	 audio.soundserver_pid == 0 ? "CHILD" : "PARENT");
+	 IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+#endif
 
   for(i=0; i<num_sounds; i++)
     deleteSoundEntry(&Sound[i]);
@@ -2058,8 +2269,10 @@ void FreeAllSounds()
     FreeSound(Sound[i]);
   */
 
+#if 0
   printf("%s: FREEING SOUNDS -- DONE\n",
-	 audio.soundserver_pid == 0 ? "CHILD" : "PARENT");
+	 IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+#endif
 
   free(Sound);