X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsound.c;h=d451e6ecf58616a0f5403a815059974bcb917a98;hb=6d37ddaaf9915af0f483f4fc04d07b98e99e091e;hp=20a1978ee4465d7e108d96c84a90a2cc8bacb9ec;hpb=19db00ff98326cb4b92cea42080d7094e0842243;p=rocksndiamonds.git

diff --git a/src/libgame/sound.c b/src/libgame/sound.c
index 20a1978e..d451e6ec 100644
--- a/src/libgame/sound.c
+++ b/src/libgame/sound.c
@@ -24,6 +24,26 @@
 #include "setup.h"
 
 
+#define IS_PARENT_PROCESS(pid)		((pid) > 0)
+#define IS_CHILD_PROCESS(pid)		((pid) == 0)
+
+struct ListNode
+{
+  char *key;
+  void *content;
+  struct ListNode *next;
+};
+typedef struct ListNode ListNode;
+
+static ListNode *newListNode(void);
+static void addNodeToList(ListNode **, char *, void *);
+static void deleteNodeFromList(ListNode **, char *, void (*function)(void *));
+static ListNode *getNodeFromKey(ListNode *, char *);
+static int getNumNodes(ListNode *);
+
+
+static struct SoundEffectInfo *sound_effect;
+static ListNode *SoundFileList = NULL;
 static SoundInfo **Sound = NULL;
 static MusicInfo **Music = NULL;
 static int num_sounds = 0, num_music = 0;
@@ -32,62 +52,50 @@ static int num_sounds = 0, num_music = 0;
 /* ========================================================================= */
 /* 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[MAX_SOUNDS_PLAYING];
-static struct SoundControl emptySoundControl =
-{
-  -1,0,0, FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE, 0,0, 0,NULL
-};
-
-#if defined(PLATFORM_UNIX)
-static int stereo_volume[PSND_MAX_LEFT2RIGHT + 1];
-static short premix_first_buffer[SND_BLOCKSIZE];
-#if defined(AUDIO_STREAMING_DSP)
-static short premix_left_buffer[SND_BLOCKSIZE];
-static short premix_right_buffer[SND_BLOCKSIZE];
-static long premix_last_buffer[SND_BLOCKSIZE];
-#endif
-static byte playing_buffer[SND_BLOCKSIZE];
-#endif
+static struct AudioFormatInfo afmt;
+static struct SoundControl mixer[NUM_MIXER_CHANNELS];
+static int mixer_active_channels = 0;
 
 /* forward declaration of internal functions */
-#if defined(AUDIO_STREAMING_DSP)
-static void SoundServer_InsertNewSound(struct SoundControl);
-static void InitAudioDevice_DSP(struct AudioFormatInfo *);
-#elif defined(PLATFORM_HPUX)
-static void InitAudioDevice_HPUX(struct AudioFormatInfo *);
-#elif defined(PLATFORM_UNIX)
+static void InitAudioDevice(struct AudioFormatInfo *);
+static void Mixer_Main(void);
+
+#if defined(PLATFORM_UNIX) && !defined(AUDIO_STREAMING_DSP)
 static unsigned char linear_to_ulaw(int);
 static int ulaw_to_linear(unsigned char);
-#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)
 static int OpenAudioDevice(char *audio_device_name)
 {
-  int audio_fd;
+  int audio_device_fd;
 
   /* check if desired audio device is accessible */
   if (access(audio_device_name, W_OK) != 0)
     return -1;
 
   /* try to open audio device in non-blocking mode */
-  if ((audio_fd = open(audio_device_name, O_WRONLY | O_NONBLOCK)) < 0)
-    return audio_fd;
+  if ((audio_device_fd = open(audio_device_name, O_WRONLY | O_NONBLOCK)) < 0)
+    return audio_device_fd;
 
   /* re-open audio device in blocking mode */
-  close(audio_fd);
-  audio_fd = open(audio_device_name, O_WRONLY);
+  close(audio_device_fd);
+  audio_device_fd = open(audio_device_name, O_WRONLY);
+
+  return audio_device_fd;
+}
+
+static void CloseAudioDevice(int *audio_device_fd)
+{
+  if (*audio_device_fd == 0)
+    return;
 
-  return audio_fd;
+  close(*audio_device_fd);
+  *audio_device_fd = -1;
 }
 
 static boolean TestAudioDevices(void)
@@ -97,21 +105,21 @@ static boolean TestAudioDevices(void)
     DEVICENAME_DSP,
     DEVICENAME_AUDIO
   };
-  int audio_fd = -1;
+  int audio_device_fd = -1;
   int i;
 
   /* look for available audio devices, starting with preferred ones */
   for (i=0; i<sizeof(audio_device_name)/sizeof(char *); i++)
-    if ((audio_fd = OpenAudioDevice(audio_device_name[i])) >= 0)
+    if ((audio_device_fd = OpenAudioDevice(audio_device_name[i])) >= 0)
       break;
 
-  if (audio_fd < 0)
+  if (audio_device_fd < 0)
   {
     Error(ERR_WARN, "cannot open audio device -- no sound");
     return FALSE;
   }
 
-  close(audio_fd);
+  close(audio_device_fd);
 
   audio.device_name = audio_device_name[i];
 
@@ -121,27 +129,22 @@ static boolean TestAudioDevices(void)
 #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;
 }
@@ -159,6 +162,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)
@@ -166,675 +173,823 @@ 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);
+}
+
+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 (IS_PARENT_PROCESS(audio.mixer_pid))
+    return;
+
+  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)
+{
+  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;
+
+  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.mixer_pipe[1], &snd_ctrl,
+	    sizeof(snd_ctrl)) < 0 ||
+      write(audio.mixer_pipe[1], set_name,
+	    snd_ctrl.data_len) < 0 ||
+      write(audio.mixer_pipe[1], leveldir_current,
+	    sizeof(TreeInfo)) < 0 ||
+      write(audio.mixer_pipe[1], ti,
+	    sizeof(TreeInfo)) < 0 ||
+      write(audio.mixer_pipe[1], &str_size1,
+	    sizeof(unsigned long)) < 0 ||
+      write(audio.mixer_pipe[1], &str_size2,
+	    sizeof(unsigned long)) < 0 ||
+      write(audio.mixer_pipe[1], &str_size3,
+	    sizeof(unsigned long)) < 0 ||
+      write(audio.mixer_pipe[1], leveldir_current->fullpath,
+	    str_size1) < 0 ||
+      write(audio.mixer_pipe[1], ti->basepath,
+	    str_size2) < 0 ||
+      write(audio.mixer_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;
+  }
+}
+
+static void ReadReloadInfoFromPipe(SoundControl *snd_ctrl)
+{
+  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;
+
+  if (set_name)
+    free(set_name);
+
+  set_name = checked_malloc(snd_ctrl->data_len);
+
+  if (leveldir_current == NULL)
+    leveldir_current = checked_calloc(sizeof(TreeInfo));
+  if (ti == NULL)
+    ti = *ti_ptr = checked_calloc(sizeof(TreeInfo));
+  if (leveldir_current->fullpath != NULL)
+    free(leveldir_current->fullpath);
+  if (ti->basepath != NULL)
+    free(ti->basepath);
+  if (ti->fullpath != NULL)
+    free(ti->fullpath);
+
+  if (read(audio.mixer_pipe[0], set_name,
+	   snd_ctrl->data_len) != snd_ctrl->data_len ||
+      read(audio.mixer_pipe[0], leveldir_current,
+	   sizeof(TreeInfo)) != sizeof(TreeInfo) ||
+      read(audio.mixer_pipe[0], ti,
+	   sizeof(TreeInfo)) != sizeof(TreeInfo) ||
+      read(audio.mixer_pipe[0], &str_size1,
+	   sizeof(unsigned long)) != sizeof(unsigned long) ||
+      read(audio.mixer_pipe[0], &str_size2,
+	   sizeof(unsigned long)) != sizeof(unsigned long) ||
+      read(audio.mixer_pipe[0], &str_size3,
+	   sizeof(unsigned long)) != sizeof(unsigned long))
+    Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
+
+  leveldir_current->fullpath = checked_calloc(str_size1);
+  ti->basepath = checked_calloc(str_size2);
+  ti->fullpath = checked_calloc(str_size3);
+
+  if (read(audio.mixer_pipe[0], leveldir_current->fullpath,
+	   str_size1) != str_size1 ||
+      read(audio.mixer_pipe[0], ti->basepath,
+	   str_size2) != str_size2 ||
+      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;
+  else
+    artwork.music_set_current = set_name;
 }
 #endif	/* PLATFORM_UNIX */
 
-void InitPlaylist(void)
+void Mixer_InitChannels()
 {
   int i;
 
-  for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-    playlist[i] = emptySoundControl;
-  playing_sounds = 0;
+  for(i=0; i<audio.num_channels; i++)
+    mixer[i].active = FALSE;
+  mixer_active_channels = 0;
 }
 
-void StartSoundserver(void)
+static void Mixer_PlayChannel(int channel)
 {
-  if (!audio.sound_available)
+  /* start with inactive channel in case something goes wrong */
+  mixer[channel].active = FALSE;
+
+  if (IS_MUSIC_MODULE(mixer[channel]))
     return;
 
-#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
-  if (!ForkAudioProcess())
-    audio.sound_available = FALSE;
+  mixer[channel].playingpos = 0;
+  mixer[channel].playingtime = 0;
+
+#if defined(TARGET_SDL)
+  Mix_Volume(channel, SOUND_MAX_VOLUME);
+  Mix_PlayChannel(channel, mixer[channel].data_ptr,
+		  IS_LOOP(mixer[channel]) ? -1 : 0);
+#elif defined(PLATFORM_MSDOS)
+  mixer[channel].voice = allocate_voice((SAMPLE *)mixer[channel].data_ptr);
+  if (mixer[channel].voice < 0)
+    return;
+
+  if (IS_LOOP(mixer[channel]))
+    voice_set_playmode(mixer[channel].voice, PLAYMODE_LOOP);
+
+  voice_set_volume(mixer[channel].voice, mixer[channel].volume);
+  voice_set_pan(mixer[channel].voice, mixer[channel].stereo);
+  voice_start(mixer[channel].voice);       
 #endif
+
+  mixer[channel].active = TRUE;
+  mixer_active_channels++;
 }
 
-#if defined(PLATFORM_UNIX)
-void SoundServer(void)
+static void Mixer_PlayMusicChannel()
 {
-  int i;
+  Mixer_PlayChannel(audio.music_channel);
 
-  struct SoundControl snd_ctrl;
-  fd_set sound_fdset;
+#if defined(TARGET_SDL)
+  if (IS_MUSIC_MODULE(mixer[audio.music_channel]))
+  {
+    /* 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
+}
 
-  close(audio.soundserver_pipe[1]);	/* no writing into pipe needed */
+static void Mixer_StopChannel(int channel)
+{
+  if (!mixer_active_channels || !mixer[channel].active)
+    return;
 
-  InitPlaylist();
+#if defined(TARGET_SDL)
+  Mix_HaltChannel(channel);
+#elif defined(PLATFORM_MSDOS)
+  voice_set_volume(mixer[channel].voice, 0);
+  deallocate_voice(mixer[channel].voice);
+#endif
 
-  stereo_volume[PSND_MAX_LEFT2RIGHT] = 0;
-  for(i=0; i<PSND_MAX_LEFT2RIGHT; i++)
-    stereo_volume[i] =
-      (int)sqrt((float)(PSND_MAX_LEFT2RIGHT * PSND_MAX_LEFT2RIGHT - i * i));
+  mixer[channel].active = FALSE;
+  mixer_active_channels--;
+}
 
-#if defined(PLATFORM_HPUX)
-  InitAudioDevice_HPUX(&afmt);
+static void Mixer_StopMusicChannel()
+{
+  Mixer_StopChannel(audio.music_channel);
+
+#if defined(TARGET_SDL)
+  Mix_HaltMusic();
 #endif
+}
 
-  FD_ZERO(&sound_fdset); 
-  FD_SET(audio.soundserver_pipe[0], &sound_fdset);
+static void Mixer_FadeChannel(int channel)
+{
+  mixer[channel].state |= SND_CTRL_FADE;
 
-  while(1)	/* wait for sound playing commands from client */
-  {
-    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");
+#if defined(TARGET_SDL)
+  Mix_FadeOutChannel(channel, SOUND_FADING_INTERVAL);
+#elif defined(PLATFORM_MSDOS)
+  if (voice_check(mixer[channel].voice))
+    voice_ramp_volume(mixer[channel].voice, SOUND_FADING_INTERVAL, 0);
+  mixer[channel].state &= ~SND_CTRL_IS_LOOP;
+#endif
+}
 
-    if (snd_ctrl.reload_sounds || snd_ctrl.reload_music)
-    {
-      char *set_name = checked_malloc(snd_ctrl.data_len);
-      TreeInfo **ti_ptr =
-	(snd_ctrl.reload_sounds ? &artwork.snd_current : &artwork.mus_current);
-      TreeInfo *ti = *ti_ptr;
-      unsigned long str_size1, str_size2, str_size3;
-
-      if (leveldir_current == NULL)
-	leveldir_current = checked_calloc(sizeof(TreeInfo));
-      if (ti == NULL)
-	ti = *ti_ptr = checked_calloc(sizeof(TreeInfo));
-      if (leveldir_current->fullpath != NULL)
-	free(leveldir_current->fullpath);
-      if (ti->basepath != NULL)
-	free(ti->basepath);
-      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,
-	       sizeof(TreeInfo)) != sizeof(TreeInfo) ||
-	  read(audio.soundserver_pipe[0], ti,
-	       sizeof(TreeInfo)) != sizeof(TreeInfo) ||
-	  read(audio.soundserver_pipe[0], &str_size1,
-	       sizeof(unsigned long)) != sizeof(unsigned long) ||
-	  read(audio.soundserver_pipe[0], &str_size2,
-	       sizeof(unsigned long)) != sizeof(unsigned long) ||
-	  read(audio.soundserver_pipe[0], &str_size3,
-	       sizeof(unsigned long)) != sizeof(unsigned long))
-	Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
-
-      leveldir_current->fullpath = checked_calloc(str_size1);
-      ti->basepath = checked_calloc(str_size2);
-      ti->fullpath = checked_calloc(str_size3);
-
-      if (read(audio.soundserver_pipe[0], leveldir_current->fullpath,
-	       str_size1) != str_size1 ||
-	  read(audio.soundserver_pipe[0], ti->basepath,
-	       str_size2) != str_size2 ||
-	  read(audio.soundserver_pipe[0], ti->fullpath,
-	       str_size3) != str_size3)
-	Error(ERR_EXIT_SOUND_SERVER, "broken pipe -- no sounds");
-
-      InitPlaylist();
-
-      close(audio.device_fd);
-
-      if (snd_ctrl.reload_sounds)
-      {
-	artwork.sounds_set_current = set_name;
-	audio.func_reload_sounds();
-      }
-      else
-      {
-	artwork.music_set_current = set_name;
-	audio.func_reload_music();
-      }
+static void Mixer_FadeMusicChannel()
+{
+  Mixer_FadeChannel(audio.music_channel);
+
+#if defined(TARGET_SDL)
+  Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
+#endif
+}
 
-      free(set_name);
+static void Mixer_InsertSound(SoundControl snd_ctrl)
+{
+  SoundInfo *snd_info;
+  int i, k;
 
-      continue;
-    }
+#if 0
+  printf("NEW SOUND %d HAS ARRIVED [%d]\n", snd_ctrl.nr, num_sounds);
+#endif
 
-#if defined(AUDIO_STREAMING_DSP)
+  if (IS_MUSIC(snd_ctrl))
+    snd_ctrl.nr = snd_ctrl.nr % num_music;
+  else if (snd_ctrl.nr >= num_sounds)
+    return;
+
+  snd_info = (IS_MUSIC(snd_ctrl) ? Music[snd_ctrl.nr] : Sound[snd_ctrl.nr]);
+  if (snd_info == NULL)
+    return;
+
+  /* copy sound sample and format information */
+  snd_ctrl.data_ptr = snd_info->data_ptr;
+  snd_ctrl.data_len = snd_info->data_len;
+  snd_ctrl.format   = snd_info->format;
+
+  if (IS_MUSIC(snd_ctrl))
+  {
+    mixer[audio.music_channel] = snd_ctrl;
+
+    Mixer_PlayChannel(audio.music_channel);
+
+    return;
+  }
 
-    if (snd_ctrl.fade_sound)
+#if 0
+  printf("-> %d\n", mixer_active_channels);
+#endif
+
+  if (mixer_active_channels == audio.num_channels)
+  {
+    for (i=0; i<audio.num_channels; i++)
     {
-      if (!playing_sounds)
-	continue;
+      if (mixer[i].data_ptr == NULL)
+      {
+#if 1
+	printf("THIS SHOULD NEVER HAPPEN! [%d]\n", i);
+#endif
 
-      if (snd_ctrl.music)
-	playlist[audio.music_channel].fade_sound = TRUE;
-      else
-	for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-	  if (snd_ctrl.stop_all_sounds ||
-	      (i != audio.music_channel && playlist[i].nr == snd_ctrl.nr))
-	    playlist[i].fade_sound = TRUE;
+	Mixer_StopChannel(i);
+      }
     }
-    else if (snd_ctrl.stop_all_sounds)
-    {
-      if (!playing_sounds)
-	continue;
+  }
 
-      for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-	playlist[i] = emptySoundControl;
-      playing_sounds = 0;
+  /* if mixer is full, remove oldest sound */
+  if (mixer_active_channels == audio.num_channels)
+  {
+    int longest = 0, longest_nr = audio.first_sound_channel;
 
-      close(audio.device_fd);
-    }
-    else if (snd_ctrl.stop_sound)
+    for (i=audio.first_sound_channel; i<audio.num_channels; i++)
     {
-      if (!playing_sounds)
-	continue;
+#if !defined(PLATFORM_MSDOS)
+      int actual = 100 * mixer[i].playingpos / mixer[i].data_len;
+#else
+      int actual = mixer[i].playingpos;
+#endif
 
-      if (snd_ctrl.music)
+      if (!IS_LOOP(mixer[i]) && actual > longest)
       {
-	playlist[audio.music_channel] = emptySoundControl;
-	playing_sounds--;
+	longest = actual;
+	longest_nr = i;
       }
+    }
 
-      for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-      {
-	if (i != audio.music_channel && playlist[i].nr == snd_ctrl.nr)
-	{
-	  playlist[i] = emptySoundControl;
-	  playing_sounds--;
-	}
-      }
+    Mixer_StopChannel(longest_nr);
+  }
 
-      if (!playing_sounds)
-	close(audio.device_fd);
-    }
+  /* check if sound is already being played (and how often) */
+  for (k=0, i=audio.first_sound_channel; i<audio.num_channels; i++)
+    if (mixer[i].nr == snd_ctrl.nr)
+      k++;
 
-    if (playing_sounds || snd_ctrl.active)
+  /* restart loop sounds only if they are just fading out */
+  if (k >= 1 && IS_LOOP(snd_ctrl))
+  {
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
     {
-      if (playing_sounds ||
-	  (audio.device_fd = OpenAudioDevice(audio.device_name)) >= 0)
+      if (mixer[i].nr == snd_ctrl.nr && IS_FADING(mixer[i]))
       {
-	struct timeval delay = { 0, 0 };
-
-	if (!playing_sounds)	/* we just opened the audio device */
-	  InitAudioDevice_DSP(&afmt);
-
-	if (snd_ctrl.active)	/* new sound has arrived */
-	  SoundServer_InsertNewSound(snd_ctrl);
+	mixer[i].state &= ~SND_CTRL_FADE;
+	mixer[i].volume = PSND_MAX_VOLUME;
+#if defined(PLATFORM_MSDOS)
+        mixer[i].state |= SND_CTRL_LOOP;
+        voice_stop_volumeramp(mixer[i].voice);
+        voice_ramp_volume(mixer[i].voice, mixer[i].volume, 1000);
+#endif
+      }
+    }
 
-	while (playing_sounds &&
-	       select(audio.soundserver_pipe[0] + 1,
-		      &sound_fdset, NULL, NULL, &delay) < 1)
-	{	
-	  void *sample_ptr;
-	  int sample_size;
-	  int max_sample_size;
-	  int fragment_size = afmt.fragment_size;
-	  int sample_bytes = (afmt.format & AUDIO_FORMAT_U8 ? 1 : 2);
-	  boolean stereo = afmt.stereo;
+    return;
+  }
 
-	  FD_SET(audio.soundserver_pipe[0], &sound_fdset);
+  /* don't play sound more than n times simultaneously (with n == 2 for now) */
+  if (k >= 2)
+  {
+    int longest = 0, longest_nr = audio.first_sound_channel;
 
-	  max_sample_size = fragment_size / ((stereo ? 2 : 1) * sample_bytes);
+    /* look for oldest equal sound */
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
+    {
+      int actual;
 
-	  /* first clear the last premixing buffer */
-	  memset(premix_last_buffer, 0,
-		 max_sample_size * (stereo ? 2 : 1) * sizeof(long));
+      if (!mixer[i].active || mixer[i].nr != snd_ctrl.nr)
+	continue;
 
-	  for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-	  {
-	    int j;
+#if !defined(PLATFORM_MSDOS)
+      actual = 100 * mixer[i].playingpos / mixer[i].data_len;
+#else
+      actual = mixer[i].playingpos;
+#endif
+      if (actual >= longest)
+      {
+	longest = actual;
+	longest_nr = i;
+      }
+    }
 
-	    if (!playlist[i].active)
-	      continue;
+    Mixer_StopChannel(longest_nr);
+  }
 
-	    /* get pointer and size of the actual sound sample */
-	    if (playlist[i].format == AUDIO_FORMAT_U8)
-	      sample_ptr =
-		(byte *)playlist[i].data_ptr + playlist[i].playingpos;
-	    else
-	      sample_ptr =
-		(short *)playlist[i].data_ptr + playlist[i].playingpos;
+  /* add new sound to mixer */
+  for(i=0; i<audio.num_channels; i++)
+  {
+#if 0
+    printf("CHECKING CHANNEL %d FOR SOUND %d ...\n", i, snd_ctrl.nr);
+#endif
 
-	    sample_size = MIN(max_sample_size,
-			      playlist[i].data_len - playlist[i].playingpos);
-	    playlist[i].playingpos += sample_size;
+    /*
+    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
 
-	    /* fill the first mixing buffer with original sample */
 #if 1
-	    if (playlist[i].format == AUDIO_FORMAT_U8)
-	      for (j=0; j<sample_size; j++)
-		premix_first_buffer[j] =
-		  ((short)(((byte *)sample_ptr)[j] ^ 0x80)) << 8;
-	    else
-	      for (j=0; j<sample_size; j++)
-		premix_first_buffer[j] = ((short *)sample_ptr)[j];
-#else
-	    memcpy(premix_first_buffer, sample_ptr,
-		   sample_size * (playlist[i].format == AUDIO_FORMAT_U8 ?
-				  sizeof(byte) : sizeof(short)));
+      if (snd_info->data_len == 0)
+      {
+	printf("THIS SHOULD NEVER HAPPEN! [snd_info->data_len == 0]\n");
+      }
 #endif
 
-	    /* are we about to restart a looping sound? */
-	    if (playlist[i].loop && sample_size < max_sample_size)
-	    {
 #if 1
-	      while (sample_size < max_sample_size)
-	      {
-		int restarted_sample_size =
-		  MIN(max_sample_size - sample_size, playlist[i].data_len);
-
-		if (playlist[i].format == AUDIO_FORMAT_U8)
-		  for (j=0; j<restarted_sample_size; j++)
-		    premix_first_buffer[sample_size + j] =
-		      ((short)(((byte *)playlist[i].data_ptr)[j] ^ 0x80)) << 8;
-		else
-		  for (j=0; j<restarted_sample_size; j++)
-		    premix_first_buffer[sample_size + j] =
-		      ((short *)playlist[i].data_ptr)[j];
-
-		playlist[i].playingpos = restarted_sample_size;
-		sample_size += restarted_sample_size;
-	      }
-#else
-	      playlist[i].playingpos = max_sample_size - sample_size;
-	      memcpy(premix_first_buffer + sample_size * sizeof(short),
-		     playlist[i].data_ptr,
-		     (max_sample_size - sample_size) * sizeof(short));
-	      sample_size = max_sample_size;
+      if (IS_MUSIC(snd_ctrl) && i == audio.music_channel && mixer[i].active)
+      {
+	printf("THIS SHOULD NEVER HAPPEN! [adding music twice]\n");
+
+#if 1
+	Mixer_StopChannel(i);
 #endif
-	    }
-
-	    /* decrease volume if sound is fading out */
-	    if (playlist[i].fade_sound &&
-		playlist[i].volume >= SOUND_FADING_VOLUME_THRESHOLD)
-	      playlist[i].volume -= SOUND_FADING_VOLUME_STEP;
-
-	    /* 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;
-
-	    /* fill the last mixing buffer with stereo or mono sound */
-	    if (stereo)
-	    {
-	      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];
-
-	      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;
-
-		premix_last_buffer[2 * j + 0] += premix_left_buffer[j];
-		premix_last_buffer[2 * j + 1] += premix_right_buffer[j];
-	      }
-	    }
-	    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 (playlist[i].loop)
-		playlist[i].playingpos = 0;
-	      else
-	      {
-		playlist[i] = emptySoundControl;
-		playing_sounds--;
-	      }
-	    }
-	    else if (playlist[i].volume <= SOUND_FADING_VOLUME_THRESHOLD)
-	    {
-	      playlist[i] = emptySoundControl;
-	      playing_sounds--;
-	    }
-	  }
-
-	  /* 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;
-
-	    /* shift to 16 bit value */
-	    premix_last_buffer[i] >>= 1;
-
-	    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 */
-	    {
-	      playing_buffer[2 * i + 0] = premix_last_buffer[i] >> 8;
-	      playing_buffer[2 * i + 1] = premix_last_buffer[i] & 0xff;
-	    }
-	  }
-
-	  /* finally play the sound fragment */
-	  write(audio.device_fd, playing_buffer, fragment_size);
-	}
-
-	/* if no sounds playing, free device for other sound programs */
-	if (!playing_sounds)
-	  close(audio.device_fd);
       }
-    }
+#endif
 
-#else /* !AUDIO_STREAMING_DSP */
+#if 0
+      snd_ctrl.data_ptr = snd_info->data_ptr;
+      snd_ctrl.data_len = snd_info->data_len;
+      snd_ctrl.format   = snd_info->format;
+#endif
 
-    if (snd_ctrl.active && !snd_ctrl.loop)
-    {
-      struct timeval delay = { 0, 0 };
-      byte *sample_ptr;
-      long sample_size, max_sample_size = SND_BLOCKSIZE;
-      long sample_rate = 8000;	/* standard "/dev/audio" sampling rate */
-      int wait_percent = 90;	/* wait 90% of the real playing time */
-      int i;
+      mixer[i] = snd_ctrl;
 
-      if ((audio.device_fd = OpenAudioDevice(audio.device_name)) >= 0)
-      {
-	playing_sounds = 1;
-
-	while (playing_sounds &&
-	       select(audio.soundserver_pipe[0] + 1,
-		      &sound_fdset, NULL, NULL, &delay) < 1)
-	{	
-	  FD_SET(audio.soundserver_pipe[0], &sound_fdset);
-
-	  /* get pointer and size of the actual sound sample */
-	  sample_ptr = snd_ctrl.data_ptr + snd_ctrl.playingpos;
-	  sample_size =
-	    MIN(max_sample_size, snd_ctrl.data_len - snd_ctrl.playingpos);
-	  snd_ctrl.playingpos += sample_size;
-
-	  /* fill the first mixing buffer with original sample */
-	  memcpy(premix_first_buffer,sample_ptr,sample_size);
-
-	  /* adjust volume of actual sound sample */
-	  if (snd_ctrl.volume != PSND_MAX_VOLUME)
-	    for(i=0;i<sample_size;i++)
-	      premix_first_buffer[i] =
-		(snd_ctrl.volume * (int)premix_first_buffer[i])
-		  >> PSND_MAX_VOLUME_BITS;
-
-	  for(i=0;i<sample_size;i++)
-	    playing_buffer[i] =
-	      linear_to_ulaw(((int)premix_first_buffer[i]) << 8);
-
-	  if (snd_ctrl.playingpos >= snd_ctrl.data_len)
-	    playing_sounds = 0;
-
-	  /* finally play the sound fragment */
-	  write(audio.device_fd,playing_buffer,sample_size);
-
-	  delay.tv_sec = 0;
-	  delay.tv_usec = ((sample_size*10*wait_percent)/(sample_rate))*1000;
-	}
-	close(audio.device_fd);
-      }
+      Mixer_PlayChannel(i);
+
+      break;
     }
-#endif /* !AUDIO_STREAMING_DSP */
   }
 }
-#endif /* PLATFORM_UNIX */
 
-#if defined(PLATFORM_MSDOS)
-static void sound_handler(struct SoundControl snd_ctrl)
+static void HandleSoundRequest(SoundControl snd_ctrl)
 {
   int i;
 
-  if (snd_ctrl.fade_sound)
+#if defined(AUDIO_UNIX_NATIVE)
+  if (IS_PARENT_PROCESS(audio.mixer_pid))
   {
-    if (!playing_sounds)
-      return;
+    SendSoundControlToMixerProcess(&snd_ctrl);
+    return;
+  }
+#elif defined(TARGET_ALLEGRO)
+  for (i=0; i<audio.num_channels; i++)
+  {
+    if (!mixer[i].active || IS_LOOP(mixer[i]))
+      continue;
 
-    for (i=0; i<MAX_SOUNDS_PLAYING; 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].loop = PSND_NO_LOOP;
-      }
+    mixer[i].playingpos = voice_get_position(mixer[i].voice);
+    mixer[i].volume = voice_get_volume(mixer[i].voice);
+
+    if (mixer[i].playingpos == -1 || mixer[i].volume == 0)
+      Mixer_StopChannel(i);
   }
-  else if (snd_ctrl.stop_all_sounds)
+#endif /* TARGET_ALLEGRO */
+
+  if (IS_RELOADING(snd_ctrl))		/* load new sound or music files */
   {
-    if (!playing_sounds)
-      return;
-    SoundServer_StopAllSounds();
+    ReadReloadInfoFromPipe(&snd_ctrl);
+    Mixer_InitChannels();
+    CloseAudioDevice(&audio.device_fd);
+
+    if (snd_ctrl.state & SND_CTRL_RELOAD_SOUNDS)
+      ReloadCustomSounds();
+    else
+      ReloadCustomMusic();
   }
-  else if (snd_ctrl.stop_sound)
+  else if (IS_FADING(snd_ctrl))		/* fade out existing sound or music */
   {
-    if (!playing_sounds)
+    if (!mixer_active_channels)
       return;
-    SoundServer_StopSound(snd_ctrl);
-  }
 
-  for (i=0; i<MAX_SOUNDS_PLAYING; i++)
+    if (IS_MUSIC(snd_ctrl))
+    {
+      Mixer_FadeChannel(audio.music_channel);
+      return;
+    }
+
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
+      if (mixer[i].nr == snd_ctrl.nr || ALL_SOUNDS(snd_ctrl))
+	Mixer_FadeChannel(i);
+  }
+  else if (IS_STOPPING(snd_ctrl))	/* stop existing sound or music */
   {
-    if (!playlist[i].active || playlist[i].loop)
-      continue;
+    if (!mixer_active_channels)
+      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)
+    if (IS_MUSIC(snd_ctrl))
     {
-      deallocate_voice(playlist[i].voice);
-      playlist[i] = emptySoundControl;
-      playing_sounds--;
+      Mixer_StopChannel(audio.music_channel);
+      return;
     }
+
+    for(i=audio.first_sound_channel; i<audio.num_channels; i++)
+      if (mixer[i].nr == snd_ctrl.nr || ALL_SOUNDS(snd_ctrl))
+	Mixer_StopChannel(i);
+
+    if (!mixer_active_channels)
+      CloseAudioDevice(&audio.device_fd);
+  }
+  else if (snd_ctrl.active)		/* add new sound to mixer */
+  {
+    Mixer_InsertSound(snd_ctrl);
   }
+}
 
-  if (snd_ctrl.active)
-    SoundServer_InsertNewSound(snd_ctrl);
+void StartMixer(void)
+{
+  if (!audio.sound_available)
+    return;
+
+#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
+  if (!ForkAudioProcess())
+    audio.sound_available = FALSE;
+#endif
 }
-#endif /* PLATFORM_MSDOS */
 
-#if !defined(PLATFORM_WIN32)
-static void SoundServer_InsertNewSound(struct SoundControl snd_ctrl)
+#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
+
+static void CopySampleToMixingBuffer(SoundControl *snd_ctrl,
+				     int sample_pos, int sample_size,
+				     short *buffer_ptr)
 {
-  int i, k;
+  void *sample_ptr = snd_ctrl->data_ptr;
+  int i;
 
-  if (snd_ctrl.music)
-    snd_ctrl.nr = snd_ctrl.nr % num_music;
+  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 playlist is full, remove oldest sound */
-  if (playing_sounds == MAX_SOUNDS_PLAYING)
+#if defined(AUDIO_STREAMING_DSP)
+static void Mixer_Main_DSP()
+{
+  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];
+  boolean stereo;
+  int fragment_size;
+  int sample_bytes;
+  int max_sample_size;
+  int i, j;
+
+  if (!stereo_volume_calculated)
   {
-    int longest = 0, longest_nr = 0;
+    for(i=0; i<=PSND_MAX_LEFT2RIGHT; i++)
+      stereo_volume[i] =
+	(int)sqrt((float)(PSND_MAX_LEFT2RIGHT * PSND_MAX_LEFT2RIGHT - i * i));
 
-    for (i=0; i<MAX_SOUNDS_PLAYING; i++)
-    {
-#if !defined(PLATFORM_MSDOS)
-      int actual = 100 * playlist[i].playingpos / playlist[i].data_len;
-#else
-      int actual = playlist[i].playingpos;
-#endif
+    stereo_volume_calculated = TRUE;
+  }
+
+  if (!mixer_active_channels)
+    return;
+
+  if (audio.device_fd < 0)
+  {
+    if ((audio.device_fd = OpenAudioDevice(audio.device_name)) < 0)
+      return;
+
+    InitAudioDevice(&afmt);
+  }
 
-      if (i != audio.music_channel && !playlist[i].loop && actual > longest)
+  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);
+
+  /* first clear the last premixing buffer */
+  memset(premix_last_buffer, 0,
+	 max_sample_size * (stereo ? 2 : 1) * sizeof(long));
+
+  for(i=0; i<audio.num_channels; i++)
+  {
+    void *sample_ptr;
+    int sample_len;
+    int sample_pos;
+    int sample_size;
+
+    if (!mixer[i].active)
+      continue;
+
+    /* 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].playingpos;
+    sample_size = MIN(max_sample_size, sample_len - sample_pos);
+    mixer[i].playingpos += sample_size;
+
+    /* copy original sample to first mixing buffer */
+    CopySampleToMixingBuffer(&mixer[i], sample_pos, sample_size,
+			     premix_first_buffer);
+
+    /* are we about to restart a looping sound? */
+    if (IS_LOOP(mixer[i]) && sample_size < max_sample_size)
+    {
+      while (sample_size < max_sample_size)
       {
-	longest = actual;
-	longest_nr = i;
+	int restarted_sample_size =
+	  MIN(max_sample_size - sample_size, sample_len);
+
+	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];
+
+	mixer[i].playingpos = 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--;
-  }
 
-  /* check if sound is already being played (and how often) */
-  for (k=0,i=0; i<MAX_SOUNDS_PLAYING; i++)
-    if (i != audio.music_channel && playlist[i].nr == snd_ctrl.nr)
-      k++;
+    /* 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;
 
-  /* restart loop sounds only if they are just fading out */
-  if (k >= 1 && snd_ctrl.loop)
-  {
-    for(i=0; i<MAX_SOUNDS_PLAYING; i++)
+    /* adjust volume of actual sound sample */
+    if (mixer[i].volume != PSND_MAX_VOLUME)
+      for(j=0; j<sample_size; j++)
+	premix_first_buffer[j] =
+	  (mixer[i].volume * (long)premix_first_buffer[j])
+	    >> PSND_MAX_VOLUME_BITS;
+
+    /* fill the last mixing buffer with stereo or mono sound */
+    if (stereo)
     {
-      if (i != audio.music_channel && playlist[i].nr == snd_ctrl.nr &&
-	  playlist[i].fade_sound)
+      int middle_pos = PSND_MAX_LEFT2RIGHT / 2;
+      int left_volume = stereo_volume[middle_pos + mixer[i].stereo];
+      int right_volume= stereo_volume[middle_pos - mixer[i].stereo];
+
+      for(j=0; j<sample_size; j++)
       {
-	playlist[i].fade_sound = FALSE;
-	playlist[i].volume = PSND_MAX_VOLUME;
-#if defined(PLATFORM_MSDOS)
-        playlist[i].loop = PSND_LOOP;
-        voice_stop_volumeramp(playlist[i].voice);
-        voice_ramp_volume(playlist[i].voice, playlist[i].volume, 1000);
-#endif
+	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;
+
+	premix_last_buffer[2 * j + 0] += premix_left_buffer[j];
+	premix_last_buffer[2 * j + 1] += premix_right_buffer[j];
       }
     }
+    else
+    {
+      for(j=0; j<sample_size; j++)
+	premix_last_buffer[j] += premix_first_buffer[j];
+    }
+
+    /* delete completed sound entries from the mixer */
+    if (mixer[i].playingpos >= mixer[i].data_len)
+    {
+      if (IS_LOOP(mixer[i]))
+	mixer[i].playingpos = 0;
+      else
+	Mixer_StopChannel(i);
+    }
+    else if (mixer[i].volume <= SOUND_FADING_VOLUME_THRESHOLD)
+      Mixer_StopChannel(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;
+
+    /* shift to 16 bit value */
+    premix_last_buffer[i] >>= 1;
+
+    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 */
+    {
+      playing_buffer[2 * i + 0] = premix_last_buffer[i] >> 8;
+      playing_buffer[2 * i + 1] = premix_last_buffer[i] & 0xff;
+    }
+  }
+
+  /* finally play the sound fragment */
+  write(audio.device_fd, playing_buffer, fragment_size);
+
+  if (!mixer_active_channels)
+    CloseAudioDevice(&audio.device_fd);
+}
+
+#else /* !AUDIO_STREAMING_DSP */
+
+static int Mixer_Main_SimpleAudio(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 = mixer[i].data_ptr;
+  sample_len = mixer[i].data_len;
+  sample_pos = mixer[i].playingpos;
+  sample_size = MIN(max_sample_size, sample_len - sample_pos);
+  mixer[i].playingpos += sample_size;
+
+  /* copy original sample to first mixing buffer */
+  CopySampleToMixingBuffer(&mixer[i], sample_pos, sample_size,
+			   premix_first_buffer);
+
+  /* adjust volume of actual sound sample */
+  if (mixer[i].volume != PSND_MAX_VOLUME)
+    for(j=0; j<sample_size; j++)
+      premix_first_buffer[j] =
+	(mixer[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]);
+#endif
+
+  /* delete completed sound entries from the mixer */
+  if (mixer[i].playingpos >= mixer[i].data_len)
+    Mixer_StopChannel(i);
+
+  for(i=0; i<sample_size; i++)
+    playing_buffer[i] = (premix_first_buffer[i] >> 8) ^ 0x80;
+
+  /* finally play the sound fragment */
+  write(audio.device_fd, playing_buffer, sample_size);
 
-    return;
-  }
+  return sample_size;
+}
+#endif /* !AUDIO_STREAMING_DSP */
 
-  /* don't play sound more than n times simultaneously (with n == 2 for now) */
-  if (k >= 2)
-  {
-    int longest = 0, longest_nr = 0;
+void Mixer_Main()
+{
+  SoundControl snd_ctrl;
+  fd_set mixer_fdset;
 
-    /* look for oldest equal sound */
-    for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-    {
-      int actual;
+  close(audio.mixer_pipe[1]);	/* no writing into pipe needed */
 
-      if (!playlist[i].active ||
-	  i == audio.music_channel ||
-	  playlist[i].nr != snd_ctrl.nr)
-	continue;
+  Mixer_InitChannels();
 
-#if !defined(PLATFORM_MSDOS)
-      actual = 100 * playlist[i].playingpos / playlist[i].data_len;
-#else
-      actual = playlist[i].playingpos;
+#if defined(PLATFORM_HPUX)
+  InitAudioDevice(&afmt);
 #endif
-      if (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--;
-  }
+  FD_ZERO(&mixer_fdset); 
+  FD_SET(audio.mixer_pipe[0], &mixer_fdset);
 
-  /* add new sound to playlist */
-  for(i=0; i<MAX_SOUNDS_PLAYING; i++)
+  while(1)	/* wait for sound playing commands from client */
   {
-    if (!playlist[i].active ||
-	(snd_ctrl.music && i == audio.music_channel))
-    {
-      SoundInfo *snd_info =
-	(snd_ctrl.music ? Music[snd_ctrl.nr] : Sound[snd_ctrl.nr]);
+    struct timeval delay = { 0, 0 };
 
-      snd_ctrl.data_ptr = snd_info->data_ptr;
-      snd_ctrl.data_len = snd_info->data_len;
-      snd_ctrl.format   = snd_info->format;
+    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;
 
-      playlist[i] = snd_ctrl;
-      playing_sounds++;
+    ReadSoundControlFromMainProcess(&snd_ctrl);
 
-#if defined(PLATFORM_MSDOS)
-      playlist[i].voice = allocate_voice((SAMPLE *)playlist[i].data_ptr);
+    HandleSoundRequest(snd_ctrl);
+
+#if defined(AUDIO_STREAMING_DSP)
 
-      if (snd_ctrl.loop)
-        voice_set_playmode(playlist[i].voice, PLAYMODE_LOOP);
+    while (mixer_active_channels &&
+	   select(audio.mixer_pipe[0] + 1,
+		  &mixer_fdset, NULL, NULL, &delay) < 1)
+    {
+      FD_SET(audio.mixer_pipe[0], &mixer_fdset);
 
-      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;
+      Mixer_Main_DSP();
     }
-  }
-}
-#endif /* !PLATFORM_WIN32 */
-
-/*
-void SoundServer_FadeSound(int nr)
-{
-  int i;
 
-  if (!playing_sounds)
-    return;
+#else /* !AUDIO_STREAMING_DSP */
 
-  for(i=0;i<MAX_SOUNDS_PLAYING;i++)
-    if (snd_ctrl.stop_all_sounds || playlist[i].nr == snd_ctrl.nr)
-      playlist[i].fade_sound = TRUE;
-}
-*/
+    if (!snd_ctrl.active || IS_LOOP(snd_ctrl) ||
+	(audio.device_fd = OpenAudioDevice(audio.device_name)) < 0)
+      continue;
 
-#if !defined(PLATFORM_WIN32)
-#if defined(PLATFORM_MSDOS)
-static void SoundServer_StopSound(struct SoundControl snd_ctrl)
-{
-  int nr = snd_ctrl.nr;
-  int i;
+    InitAudioDevice(&afmt);
 
-  if (!playing_sounds)
-    return;
+    delay.tv_sec = 0;
+    delay.tv_usec = 0;
 
-  for(i=0; i<MAX_SOUNDS_PLAYING; i++)
-  {
-    if ((i == audio.music_channel && snd_ctrl.music) ||
-	(i != audio.music_channel && playlist[i].nr == nr))
+    while (mixer_active_channels &&
+	   select(audio.mixer_pipe[0] + 1,
+		  &mixer_fdset, NULL, NULL, &delay) < 1)
     {
-#if defined(PLATFORM_MSDOS)
-      voice_set_volume(playlist[i].voice, 0);
-      deallocate_voice(playlist[i].voice);
-#endif
-      playlist[i] = emptySoundControl;
-      playing_sounds--;
+      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;
     }
-  }
 
-#if !defined(PLATFORM_MSDOS)
-  if (!playing_sounds)
-    close(audio.device_fd);
-#endif
-}
+    CloseAudioDevice(&audio.device_fd);
 
-static void SoundServer_StopAllSounds()
-{
-  int i;
+    Mixer_InitChannels();	/* remove all sounds from mixer */
 
-  for(i=0;i<MAX_SOUNDS_PLAYING;i++)
-  {
-#if defined(PLATFORM_MSDOS)
-    voice_set_volume(playlist[i].voice, 0);
-    deallocate_voice(playlist[i].voice);
-#endif
-    playlist[i]=emptySoundControl;
+#endif /* !AUDIO_STREAMING_DSP */
   }
-  playing_sounds = 0;
-
-#if !defined(PLATFORM_MSDOS)
-  close(audio.device_fd);
-#endif
 }
-#endif /* PLATFORM_MSDOS */
-#endif /* !PLATFORM_WIN32 */
+#endif /* PLATFORM_UNIX */
 
 
 /* ------------------------------------------------------------------------- */
@@ -975,14 +1130,21 @@ static void InitAudioDevice_HPUX(struct AudioFormatInfo *afmt)
 #endif /* PLATFORM_HPUX */
 
 #if defined(PLATFORM_UNIX)
-static void InitAudioDevice_DSP(struct AudioFormatInfo *afmt)
+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
 }
 #endif /* PLATFORM_UNIX */
@@ -1109,7 +1271,6 @@ static SoundInfo *Load_WAV(char *filename)
   byte sound_header_buffer[WAV_HEADER_SIZE];
   char chunk_name[CHUNK_ID_LEN + 1];
   int chunk_size;
-  short *data_ptr;
   FILE *file;
   int i;
 #endif
@@ -1117,6 +1278,10 @@ static SoundInfo *Load_WAV(char *filename)
   if (!audio.sound_available)
     return NULL;
 
+#if 0
+  printf("loading WAV file '%s'\n", filename);
+#endif
+
   snd_info = checked_calloc(sizeof(SoundInfo));
 
 #if defined(TARGET_SDL)
@@ -1210,49 +1375,105 @@ static SoundInfo *Load_WAV(char *filename)
     return NULL;
   }
 
-  if (0)
+  snd_info->format = AUDIO_FORMAT_U8;
+
+#endif	/* PLATFORM_UNIX */
+
+  snd_info->type = SND_TYPE_WAV;
+  snd_info->source_filename = getStringCopy(filename);
+
+  return snd_info;
+}
+
+static void deleteSoundEntry(SoundInfo **snd_info)
+{
+  if (*snd_info)
   {
-    /* convert unsigned 8 bit sample data to signed 16 bit sample data */
+    char *filename = (*snd_info)->source_filename;
 
-    data_ptr = checked_malloc(snd_info->data_len * sizeof(short));
+#if 0
+    printf("[decrementing reference counter of sound '%s']\n", filename);
+#endif
 
-    for (i=0; i<snd_info->data_len; i++)
-      data_ptr[i] = ((short)(((byte *)snd_info->data_ptr)[i] ^ 0x80)) << 8;
+    if (--(*snd_info)->num_references <= 0)
+    {
+#if 0
+      printf("[deleting sound '%s']\n", filename);
+#endif
 
-    free(snd_info->data_ptr);
-    snd_info->data_ptr = data_ptr;
+      /*
+      FreeSound(*snd_info);
+      */
+      deleteNodeFromList(&SoundFileList, filename, FreeSound);
+    }
 
-    snd_info->format = AUDIO_FORMAT_S16;
+    *snd_info = NULL;
   }
-  else
+}
+
+static void replaceSoundEntry(SoundInfo **snd_info, char *filename)
+{
+  ListNode *node;
+
+  /* check if the old and the new sound file are the same */
+  if (*snd_info && strcmp((*snd_info)->source_filename, filename) == 0)
   {
-    snd_info->format = AUDIO_FORMAT_U8;
+    /* The old and new sound are the same (have the same filename and path).
+       This usually means that this sound does not exist in this sound set
+       and a fallback to the existing sound is done. */
+
+#if 0
+    printf("[sound '%s' already exists (same list entry)]\n", filename);
+#endif
+
+    return;
   }
 
-#endif	/* PLATFORM_UNIX */
+  /* delete existing sound file entry */
+  deleteSoundEntry(snd_info);
 
-  snd_info->type = SND_TYPE_WAV;
-  snd_info->source_filename = getStringCopy(filename);
+  /* check if the new sound file already exists in the list of sounds */
+  if ((node = getNodeFromKey(SoundFileList, filename)) != NULL)
+  {
+#if 0
+      printf("[sound '%s' already exists (other list entry)]\n", filename);
+#endif
 
-  return snd_info;
+      *snd_info = (SoundInfo *)node->content;
+      (*snd_info)->num_references++;
+  }
+  else if ((*snd_info = Load_WAV(filename)) != NULL)	/* load new sound */
+  {
+    (*snd_info)->num_references = 1;
+    addNodeToList(&SoundFileList, (*snd_info)->source_filename, *snd_info);
+  }
 }
 
-SoundInfo *LoadCustomSound(char *basename)
+static void LoadCustomSound(SoundInfo **snd_info, char *basename)
 {
   char *filename = getCustomSoundFilename(basename);
 
+  if (strcmp(basename, SND_FILE_UNDEFINED) == 0)
+  {
+    deleteSoundEntry(snd_info);
+    return;
+  }
+
   if (filename == NULL)
   {
     Error(ERR_WARN, "cannot find sound file '%s'", basename);
-    return FALSE;
+    return;
   }
 
-  return Load_WAV(filename);
+  replaceSoundEntry(snd_info, filename);
 }
 
-void InitSoundList(int num_list_entries)
+void InitSoundList(struct SoundEffectInfo *sounds_list, int num_list_entries)
 {
-  Sound = checked_calloc(num_list_entries * sizeof(SoundInfo *));
+  if (Sound == NULL)
+    Sound = checked_calloc(num_list_entries * sizeof(SoundInfo *));
+
+  sound_effect = sounds_list;
   num_sounds = num_list_entries;
 }
 
@@ -1261,10 +1482,17 @@ void LoadSoundToList(char *basename, int list_pos)
   if (Sound == NULL || list_pos >= num_sounds)
     return;
 
-  if (Sound[list_pos])
-    FreeSound(Sound[list_pos]);
+#if 0
+  printf("loading sound '%s' ...  [%d]\n",
+	 basename, getNumNodes(SoundFileList));
+#endif
+
+  LoadCustomSound(&Sound[list_pos], basename);
 
-  Sound[list_pos] = LoadCustomSound(basename);
+#if 0
+  printf("loading sound '%s' done [%d]\n",
+	 basename, getNumNodes(SoundFileList));
+#endif
 }
 
 static MusicInfo *Load_MOD(char *filename)
@@ -1366,27 +1594,27 @@ void PlayMusic(int nr)
 
 void PlaySound(int nr)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, PSND_NO_LOOP);
+  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_SOUND);
 }
 
 void PlaySoundStereo(int nr, int stereo)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, stereo, PSND_NO_LOOP);
+  PlaySoundExt(nr, PSND_MAX_VOLUME, stereo, SND_CTRL_PLAY_SOUND);
 }
 
 void PlaySoundLoop(int nr)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, PSND_LOOP);
+  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_LOOP);
 }
 
 void PlaySoundMusic(int nr)
 {
-  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, PSND_MUSIC);
+  PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_MUSIC);
 }
 
-void PlaySoundExt(int nr, int volume, int stereo, boolean loop_type)
+void PlaySoundExt(int nr, int volume, int stereo, int state)
 {
-  struct SoundControl snd_ctrl = emptySoundControl;
+  SoundControl snd_ctrl;
 
   if (!audio.sound_available ||
       !audio.sound_enabled ||
@@ -1403,35 +1631,13 @@ void PlaySoundExt(int nr, int volume, int stereo, boolean loop_type)
   else if (stereo > PSND_MAX_RIGHT)
     stereo = PSND_MAX_RIGHT;
 
-  snd_ctrl.nr		= nr;
-  snd_ctrl.volume	= volume;
-  snd_ctrl.stereo	= stereo;
-  snd_ctrl.loop		= (loop_type != PSND_NO_LOOP);
-  snd_ctrl.music	= (loop_type == PSND_MUSIC);
-  snd_ctrl.active	= TRUE;
+  snd_ctrl.active = TRUE;
+  snd_ctrl.nr     = nr;
+  snd_ctrl.volume = volume;
+  snd_ctrl.stereo = stereo;
+  snd_ctrl.state  = state;
 
-#if 0
-  /* now only used internally in sound server child process */
-  snd_ctrl.data_ptr	= Sound[nr].data_ptr;
-  snd_ctrl.data_len	= Sound[nr].data_len;
-#endif
-
-#if defined(TARGET_SDL)
-  Mix_Volume(-1, SOUND_MAX_VOLUME);
-  Mix_PlayChannel(-1, Sound[nr]->data_ptr, (loop_type ? -1 : 0));
-#elif defined(PLATFORM_UNIX)
-  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;
-  }
-#elif defined(PLATFORM_MSDOS)
-  sound_handler(snd_ctrl);
-#endif
+  HandleSoundRequest(snd_ctrl);
 }
 
 void FadeMusic(void)
@@ -1443,19 +1649,19 @@ void FadeMusic(void)
   Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
   Mix_FadeOutChannel(audio.music_channel, SOUND_FADING_INTERVAL);
 #else
-  StopSoundExt(-1, SSND_FADE_MUSIC);
+  StopSoundExt(-1, SND_CTRL_FADE_MUSIC);
 #endif
 }
 
 void FadeSound(int nr)
 {
-  StopSoundExt(nr, SSND_FADE_SOUND);
+  StopSoundExt(nr, SND_CTRL_FADE_SOUND);
 }
 
 void FadeSounds()
 {
   FadeMusic();
-  StopSoundExt(-1, SSND_FADE_ALL);
+  StopSoundExt(-1, SND_CTRL_FADE_ALL);
 }
 
 void StopMusic(void)
@@ -1467,150 +1673,214 @@ void StopMusic(void)
   Mix_HaltMusic();
   Mix_HaltChannel(audio.music_channel);
 #else
-  StopSoundExt(-1, SSND_STOP_MUSIC);
+  StopSoundExt(-1, SND_CTRL_STOP_MUSIC);
 #endif
 }
 
 void StopSound(int nr)
 {
-  StopSoundExt(nr, SSND_STOP_SOUND);
+  StopSoundExt(nr, SND_CTRL_STOP_SOUND);
 }
 
 void StopSounds()
 {
-  StopSoundExt(-1, SSND_STOP_ALL);
+  StopMusic();
+  StopSoundExt(-1, SND_CTRL_STOP_ALL);
 }
 
-void StopSoundExt(int nr, int method)
+void StopSoundExt(int nr, int state)
 {
-  struct SoundControl snd_ctrl = emptySoundControl;
+  SoundControl snd_ctrl;
 
   if (!audio.sound_available)
     return;
 
-  if (method & SSND_FADING)
-    snd_ctrl.fade_sound = TRUE;
+  snd_ctrl.active = FALSE;
+  snd_ctrl.nr     = nr;
+  snd_ctrl.state  = state;
 
-  if (method & SSND_ALL)
-    snd_ctrl.stop_all_sounds = TRUE;
-  else
-  {
-    snd_ctrl.stop_sound = TRUE;
-    snd_ctrl.nr = nr;
-  }
+  HandleSoundRequest(snd_ctrl);
+}
+
+ListNode *newListNode()
+{
+  return checked_calloc(sizeof(ListNode));
+}
 
-  if (method & SSND_MUSIC)
-    snd_ctrl.music = TRUE;
+void addNodeToList(ListNode **node_first, char *key, void *content)
+{
+  ListNode *node_new = newListNode();
 
-#if defined(TARGET_SDL)
+#if 0
+  printf("LIST: adding node with key '%s'\n", key);
+#endif
+
+  node_new->key = getStringCopy(key);
+  node_new->content = content;
+  node_new->next = *node_first;
+  *node_first = node_new;
+}
+
+void deleteNodeFromList(ListNode **node_first, char *key,
+			void (*destructor_function)(void *))
+{
+  if (node_first == NULL || *node_first == NULL)
+    return;
+
+#if 0
+  printf("[CHECKING LIST KEY '%s' == '%s']\n",
+	 (*node_first)->key, key);
+#endif
 
-  if (method & SSND_FADING)
+  if (strcmp((*node_first)->key, key) == 0)
   {
-    int i;
+#if 0
+    printf("[DELETING LIST ENTRY]\n");
+#endif
 
-    for (i=0; i<audio.channels; i++)
-      if (i != audio.music_channel || snd_ctrl.music)
-	Mix_FadeOutChannel(i, SOUND_FADING_INTERVAL);
-    if (snd_ctrl.music)
-      Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
+    free((*node_first)->key);
+    if (destructor_function)
+      destructor_function((*node_first)->content);
+    *node_first = (*node_first)->next;
   }
   else
-  {
-    int i;
+    deleteNodeFromList(&(*node_first)->next, key, destructor_function);
+}
 
-    for (i=0; i<audio.channels; i++)
-      if (i != audio.music_channel || snd_ctrl.music)
-	Mix_HaltChannel(i);
-    if (snd_ctrl.music)
-      Mix_HaltMusic();
-  }
+ListNode *getNodeFromKey(ListNode *node_first, char *key)
+{
+  if (node_first == NULL)
+    return NULL;
 
-#elif !defined(PLATFORM_MSDOS)
+  if (strcmp(node_first->key, key) == 0)
+    return node_first;
+  else
+    return getNodeFromKey(node_first->next, key);
+}
 
-  if (audio.soundserver_pid == 0)	/* we are child process */
-    return;
+int getNumNodes(ListNode *node_first)
+{
+  return (node_first ? 1 + getNumNodes(node_first->next) : 0);
+}
+
+void dumpList(ListNode *node_first)
+{
+  ListNode *node = node_first;
 
-  if (write(audio.soundserver_pipe[1], &snd_ctrl, sizeof(snd_ctrl)) < 0)
+  while (node)
   {
-    Error(ERR_WARN, "cannot pipe to child process -- no sounds");
-    audio.sound_available = audio.sound_enabled = FALSE;
-    return;
+    printf("['%s' (%d)]\n", node->key,
+	   ((SoundInfo *)node->content)->num_references);
+    node = node->next;
   }
-#else
-  sound_handler(snd_ctrl);
-#endif
+
+  printf("[%d nodes]\n", getNumNodes(node_first));
 }
 
-static void InitReloadSoundsOrMusic(char *set_name, int type)
+static void LoadSoundsInfo()
 {
-#if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)
-  struct SoundControl snd_ctrl = emptySoundControl;
-  TreeInfo *ti =
-    (type == SND_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
+  char *filename = getCustomSoundConfigFilename();
+  struct SetupFileList *setup_file_list;
+  int i;
 
-  if (!audio.sound_available)
-    return;
+  /* always start with reliable default values */
+  for (i=0; i<num_sounds; i++)
+    sound_effect[i].filename = NULL;
 
-#if defined(TARGET_SDL) || defined(TARGET_ALLEGRO)
-  if (type == SND_RELOAD_SOUNDS)
-    audio.func_reload_sounds();
-  else
-    audio.func_reload_music();
-#elif defined(PLATFORM_UNIX)
-  if (audio.soundserver_pid == 0)	/* we are child process */
+  if (filename == NULL)
     return;
 
-  if (leveldir_current == NULL)		/* should never happen */
-    Error(ERR_EXIT, "leveldir_current == NULL");
+  if ((setup_file_list = loadSetupFileList(filename)))
+  {
+    for (i=0; i<num_sounds; i++)
+      sound_effect[i].filename =
+	getStringCopy(getTokenValue(setup_file_list, sound_effect[i].text));
 
-  snd_ctrl.reload_sounds = (type == SND_RELOAD_SOUNDS);
-  snd_ctrl.reload_music  = (type == SND_RELOAD_MUSIC);
-  snd_ctrl.data_len = strlen(set_name) + 1;
+    freeSetupFileList(setup_file_list);
 
-  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)
+#if 1
+    for (i=0; i<num_sounds; i++)
+    {
+      printf("'%s' ", sound_effect[i].text);
+      if (sound_effect[i].filename)
+	printf("-> '%s'\n", sound_effect[i].filename);
+      else
+	printf("-> UNDEFINED [-> '%s']\n", sound_effect[i].default_filename);
+    }
+#endif
+  }
+}
+
+static void ReloadCustomSounds()
+{
+  int i;
+
+#if 0
+  printf("DEBUG: reloading sounds '%s' ...\n", artwork.sounds_set_current);
+#endif
+
+  LoadSoundsInfo();
+
+#if 0
+  printf("DEBUG: reloading %d sounds ...\n", num_sounds);
+#endif
+
+  for(i=0; i<num_sounds; i++)
   {
-    Error(ERR_WARN, "cannot pipe to child process -- no sounds");
-    audio.sound_available = audio.sound_enabled = FALSE;
-    return;
+    if (sound_effect[i].filename)
+      LoadSoundToList(sound_effect[i].filename, i);
+    else
+      LoadSoundToList(sound_effect[i].default_filename, i);
   }
+
+  /*
+  printf("list size == %d\n", getNumNodes(SoundFileList));
+  */
+
+#if 0
+  dumpList(SoundFileList);
+#endif
+}
+
+static void ReloadCustomMusic()
+{
+#if 0
+  printf("DEBUG: reloading music '%s' ...\n", artwork.music_set_current);
 #endif
+
+  FreeAllMusic();
+
+  LoadCustomMusic();
 }
 
 void InitReloadSounds(char *set_name)
 {
-  InitReloadSoundsOrMusic(set_name, SND_RELOAD_SOUNDS);
+  if (!audio.sound_available)
+    return;
+
+#if defined(TARGET_SDL) || defined(TARGET_ALLEGRO)
+  ReloadCustomSounds();
+#elif defined(PLATFORM_UNIX)
+  WriteReloadInfoToPipe(set_name, SND_CTRL_RELOAD_SOUNDS);
+#endif
 }
 
 void InitReloadMusic(char *set_name)
 {
-  InitReloadSoundsOrMusic(set_name, SND_RELOAD_MUSIC);
+  if (!audio.music_available)
+    return;
+
+#if defined(TARGET_SDL) || defined(TARGET_ALLEGRO)
+  ReloadCustomMusic();
+#elif defined(PLATFORM_UNIX)
+  WriteReloadInfoToPipe(set_name, SND_CTRL_RELOAD_MUSIC);
+#endif
 }
 
-void FreeSound(SoundInfo *sound)
+void FreeSound(void *ptr)
 {
+  SoundInfo *sound = (SoundInfo *)ptr;
+
   if (sound == NULL)
     return;
 
@@ -1625,6 +1895,9 @@ void FreeSound(SoundInfo *sound)
 #endif
   }
 
+  if (sound->source_filename)
+    free(sound->source_filename);
+
   free(sound);
 }
 
@@ -1657,8 +1930,17 @@ void FreeAllSounds()
   if (Sound == NULL)
     return;
 
+  printf("%s: FREEING SOUNDS ...\n",
+	 IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+
   for(i=0; i<num_sounds; i++)
+    deleteSoundEntry(&Sound[i]);
+  /*
     FreeSound(Sound[i]);
+  */
+
+  printf("%s: FREEING SOUNDS -- DONE\n",
+	 IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
 
   free(Sound);