X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fsound.c;h=61644cda859874bddb68ce813da558ddb0174aa6;hp=144dd1ad5dccc26ee07e419f34b81fb7cd168ece;hb=884db54d739f5838243315f390d28634cb99a7d9;hpb=caed1f8c1a80db15b94da8a59bba3e95f7bd06db

diff --git a/src/libgame/sound.c b/src/libgame/sound.c
index 144dd1ad..61644cda 100644
--- a/src/libgame/sound.c
+++ b/src/libgame/sound.c
@@ -27,11 +27,17 @@
 static SoundInfo **Sound = NULL;
 static MusicInfo **Music = NULL;
 static int num_sounds = 0, num_music = 0;
+static char **sound_name;
 
 
 /* ========================================================================= */
 /* 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 =
@@ -40,37 +46,35 @@ static struct SoundControl emptySoundControl =
 };
 
 #if defined(PLATFORM_UNIX)
-static int stereo_volume[PSND_MAX_LEFT2RIGHT+1];
-static char premix_first_buffer[SND_BLOCKSIZE];
+static int stereo_volume[PSND_MAX_LEFT2RIGHT + 1];
+static short premix_first_buffer[SND_BLOCKSIZE];
 #if defined(AUDIO_STREAMING_DSP)
-static short premix_second_buffer[SND_BLOCKSIZE];
 static short premix_left_buffer[SND_BLOCKSIZE];
 static short premix_right_buffer[SND_BLOCKSIZE];
 static long premix_last_buffer[SND_BLOCKSIZE];
 #endif
-static short playing_buffer[SND_BLOCKSIZE];
+static byte playing_buffer[SND_BLOCKSIZE];
 #endif
 
 /* 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 unsigned char linear_to_ulaw(int);
 static int ulaw_to_linear(unsigned char);
-#endif
-
-#if defined(AUDIO_LINUX_IOCTL)
-static boolean InitAudioDevice_Linux();
-#elif defined(PLATFORM_NETBSD)
-static boolean InitAudioDevice_NetBSD();
-#elif defined(PLATFORM_HPUX)
-static boolean InitAudioDevice_HPUX();
 #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(SoundInfo *);
+
 #if defined(PLATFORM_UNIX)
 static int OpenAudioDevice(char *audio_device_name)
 {
@@ -210,7 +214,7 @@ void SoundServer(void)
       (int)sqrt((float)(PSND_MAX_LEFT2RIGHT * PSND_MAX_LEFT2RIGHT - i * i));
 
 #if defined(PLATFORM_HPUX)
-  InitAudioDevice_HPUX();
+  InitAudioDevice_HPUX(&afmt);
 #endif
 
   FD_ZERO(&sound_fdset); 
@@ -278,12 +282,18 @@ void SoundServer(void)
       if (snd_ctrl.reload_sounds)
       {
 	artwork.sounds_set_current = set_name;
+	ReloadCustomSounds();
+#if 0
 	audio.func_reload_sounds();
+#endif
       }
       else
       {
 	artwork.music_set_current = set_name;
+	ReloadCustomMusic();
+#if 0
 	audio.func_reload_music();
+#endif
       }
 
       free(set_name);
@@ -343,26 +353,13 @@ void SoundServer(void)
 
     if (playing_sounds || snd_ctrl.active)
     {
-      struct timeval delay = { 0, 0 };
-      byte *sample_ptr;
-      long sample_size;
-      static int max_sample_size = 0;
-      static int fragment_size = DEFAULT_AUDIO_FRAGMENT_SIZE;
-      int sample_rate = DEFAULT_AUDIO_SAMPLE_RATE;
-      static boolean stereo = TRUE;
-
       if (playing_sounds ||
 	  (audio.device_fd = OpenAudioDevice(audio.device_name)) >= 0)
       {
+	struct timeval delay = { 0, 0 };
+
 	if (!playing_sounds)	/* we just opened the audio device */
-	{
-#if defined(AUDIO_LINUX_IOCTL)
-	  stereo = InitAudioDevice_Linux(fragment_size, sample_rate);
-#elif defined(PLATFORM_NETBSD)
-	  stereo = InitAudioDevice_NetBSD(fragment_size, sample_rate);
-#endif
-	  max_sample_size = fragment_size / ((stereo ? 2 : 1) * sizeof(short));
-	}
+	  InitAudioDevice_DSP(&afmt);
 
 	if (snd_ctrl.active)	/* new sound has arrived */
 	  SoundServer_InsertNewSound(snd_ctrl);
@@ -371,40 +368,69 @@ void SoundServer(void)
 	       select(audio.soundserver_pipe[0] + 1,
 		      &sound_fdset, NULL, NULL, &delay) < 1)
 	{	
+	  int max_sample_size;
+	  int fragment_size = afmt.fragment_size;
+	  int sample_bytes = (afmt.format & AUDIO_FORMAT_U8 ? 1 : 2);
+	  boolean stereo = afmt.stereo;
+
 	  FD_SET(audio.soundserver_pipe[0], &sound_fdset);
 
+	  max_sample_size = fragment_size / ((stereo ? 2 : 1) * sample_bytes);
+
 	  /* first clear the last premixing buffer */
-	  memset(premix_last_buffer, 0, fragment_size * sizeof(short));
+	  memset(premix_last_buffer, 0,
+		 max_sample_size * (stereo ? 2 : 1) * sizeof(long));
 
 	  for(i=0; i<MAX_SOUNDS_PLAYING; i++)
 	  {
+	    void *sample_ptr;
+	    int sample_len;
+	    int sample_pos;
+	    int sample_size;
 	    int j;
 
 	    if (!playlist[i].active)
 	      continue;
 
-	    /* get pointer and size of the actual sound sample */
-	    sample_ptr = playlist[i].data_ptr + playlist[i].playingpos;
-	    sample_size = MIN(max_sample_size,
-			      playlist[i].data_len - playlist[i].playingpos);
+	    /* 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;
 
-	    /* fill the first mixing buffer with original sample */
-	    memcpy(premix_first_buffer, sample_ptr, sample_size);
+	    /* copy original sample to first mixing buffer */
+	    if (playlist[i].format == AUDIO_FORMAT_U8)
+	      for (j=0; j<sample_size; j++)
+		premix_first_buffer[j] =
+		  ((short)(((byte *)sample_ptr)[sample_pos + j] ^ 0x80)) << 8;
+	    else	/* AUDIO_FORMAT_S16 */
+	      for (j=0; j<sample_size; j++)
+		premix_first_buffer[j] =
+		  ((short *)sample_ptr)[sample_pos + j];
 
 	    /* are we about to restart a looping sound? */
 	    if (playlist[i].loop && sample_size < max_sample_size)
 	    {
-	      playlist[i].playingpos = max_sample_size - sample_size;
-	      memcpy(premix_first_buffer + sample_size,
-		     playlist[i].data_ptr, max_sample_size - sample_size);
-	      sample_size = max_sample_size;
+	      while (sample_size < max_sample_size)
+	      {
+		int restarted_sample_size =
+		  MIN(max_sample_size - sample_size, sample_len);
+
+		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];
+
+		playlist[i].playingpos = restarted_sample_size;
+		sample_size += restarted_sample_size;
+	      }
 	    }
 
-	    /* expand sample from 8 to 16 bit */
-	    for(j=0; j<sample_size; j++)
-	      premix_second_buffer[j] = premix_first_buffer[j] << 8;
-
 	    /* decrease volume if sound is fading out */
 	    if (playlist[i].fade_sound &&
 		playlist[i].volume >= SOUND_FADING_VOLUME_THRESHOLD)
@@ -413,8 +439,8 @@ void SoundServer(void)
 	    /* adjust volume of actual sound sample */
 	    if (playlist[i].volume != PSND_MAX_VOLUME)
 	      for(j=0; j<sample_size; j++)
-		premix_second_buffer[j] =
-		  (playlist[i].volume * (int)premix_second_buffer[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 */
@@ -427,10 +453,10 @@ void SoundServer(void)
 	      for(j=0; j<sample_size; j++)
 	      {
 		premix_left_buffer[j] =
-		  (left_volume * premix_second_buffer[j])
+		  (left_volume * premix_first_buffer[j])
 		    >> PSND_MAX_LEFT2RIGHT_BITS;
 		premix_right_buffer[j] =
-		  (right_volume * premix_second_buffer[j])
+		  (right_volume * premix_first_buffer[j])
 		    >> PSND_MAX_LEFT2RIGHT_BITS;
 
 		premix_last_buffer[2 * j + 0] += premix_left_buffer[j];
@@ -440,7 +466,7 @@ void SoundServer(void)
 	    else
 	    {
 	      for(j=0; j<sample_size; j++)
-		premix_last_buffer[j] += premix_second_buffer[j];
+		premix_last_buffer[j] += premix_first_buffer[j];
 	    }
 
 	    /* delete completed sound entries from the playlist */
@@ -461,15 +487,32 @@ void SoundServer(void)
 	    }
 	  }
 
-	  /* put last mixing buffer to final playing buffer */
-	  for(i=0; i<fragment_size; 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)
-	      playing_buffer[i] = -32767;
+	      premix_last_buffer[i] = -65535;
 	    else if (premix_last_buffer[i] > 65535)
-	      playing_buffer[i] = 32767;
-	    else
-	      playing_buffer[i] = (short)(premix_last_buffer[i] >> 1);
+	      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 */
@@ -702,6 +745,7 @@ static void SoundServer_InsertNewSound(struct SoundControl snd_ctrl)
 
       snd_ctrl.data_ptr = snd_info->data_ptr;
       snd_ctrl.data_len = snd_info->data_len;
+      snd_ctrl.format   = snd_info->format;
 
       playlist[i] = snd_ctrl;
       playing_sounds++;
@@ -793,17 +837,31 @@ static void SoundServer_StopAllSounds()
 /* ------------------------------------------------------------------------- */
 
 #if defined(AUDIO_LINUX_IOCTL)
-static boolean InitAudioDevice_Linux(int fragment_size, int sample_rate)
+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;
-  unsigned int audio_format = 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 */
-  for (fragment_spec=0; (1 << fragment_spec) < fragment_size; fragment_spec++);
+  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
@@ -819,27 +877,28 @@ static boolean InitAudioDevice_Linux(int fragment_size, int sample_rate)
     Error(ERR_EXIT_SOUND_SERVER,
 	  "cannot set fragment size of /dev/dsp -- no sounds");
 
-  audio_format = AFMT_S16_LE;
-  if (ioctl(audio.device_fd, SNDCTL_DSP_SETFMT, &audio_format) < 0)
+  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)
-  {
-#ifdef DEBUG
-    static boolean reported = FALSE;
+    afmt->stereo = FALSE;
 
-    if (!reported)
-    {
-      Error(ERR_RETURN, "cannot get stereo sound on /dev/dsp");
-      reported = TRUE;
-    }
-#endif
-    stereo = FALSE;
-  }
-
-  if (ioctl(audio.device_fd, SNDCTL_DSP_SPEED, &sample_rate) < 0)
+  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");
 
@@ -847,16 +906,14 @@ static boolean InitAudioDevice_Linux(int fragment_size, int sample_rate)
   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 != fragment_size)
+  if (fragment_size_query != afmt->fragment_size)
     Error(ERR_EXIT_SOUND_SERVER,
 	  "cannot set fragment size of /dev/dsp -- no sounds");
-
-  return (boolean)stereo;
 }
 #endif	/* AUDIO_LINUX_IOCTL */
 
 #if defined(PLATFORM_NETBSD)
-static boolean InitAudioDevice_NetBSD(int fragment_size, int sample_rate)
+static void InitAudioDevice_NetBSD(struct AudioFormatInfo *afmt)
 {
   audio_info_t a_info;
   boolean stereo = TRUE;
@@ -868,23 +925,25 @@ static boolean InitAudioDevice_NetBSD(int fragment_size, int sample_rate)
   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;
-    stereo = FALSE;
+
+    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");
   }
-
-  return stereo;
 }
 #endif /* PLATFORM_NETBSD */
 
 #if defined(PLATFORM_HPUX)
-static boolean InitAudioDevice_HPUX()
+static void InitAudioDevice_HPUX(struct AudioFormatInfo *afmt)
 {
   struct audio_describe ainfo;
   int audio_ctl;
@@ -902,12 +961,27 @@ static boolean InitAudioDevice_HPUX()
   ioctl(audio_ctl, AUDIO_SET_CHANNELS, 1);
   ioctl(audio_ctl, AUDIO_SET_SAMPLE_RATE, 8000);
 
-  close(audio_ctl);
+  afmt->format = AUDIO_FORMAT_U8;
+  afmt->stereo = FALSE;
+  afmt->sample_rate = 8000;
 
-  return TRUE;	/* to provide common interface for InitAudioDevice_...() */
+  close(audio_ctl);
 }
 #endif /* PLATFORM_HPUX */
 
+#if defined(PLATFORM_UNIX)
+static void InitAudioDevice_DSP(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);
+#endif
+}
+#endif /* PLATFORM_UNIX */
+
 #if defined(PLATFORM_UNIX) && !defined(AUDIO_STREAMING_DSP)
 
 /* these two are stolen from "sox"... :) */
@@ -1037,6 +1111,10 @@ static SoundInfo *Load_WAV(char *filename)
   if (!audio.sound_available)
     return NULL;
 
+#if 1
+  printf("loading WAV file '%s'\n", filename);
+#endif
+
   snd_info = checked_calloc(sizeof(SoundInfo));
 
 #if defined(TARGET_SDL)
@@ -1130,8 +1208,7 @@ static SoundInfo *Load_WAV(char *filename)
     return NULL;
   }
 
-  for (i=0; i<snd_info->data_len; i++)
-    ((byte *)snd_info->data_ptr)[i] ^= 0x80;
+  snd_info->format = AUDIO_FORMAT_U8;
 
 #endif	/* PLATFORM_UNIX */
 
@@ -1141,22 +1218,37 @@ static SoundInfo *Load_WAV(char *filename)
   return snd_info;
 }
 
-SoundInfo *LoadCustomSound(char *basename)
+static void LoadCustomSound(SoundInfo **snd_info, char *basename)
 {
   char *filename = getCustomSoundFilename(basename);
 
-  if (filename == NULL)
+  if (filename == NULL)		/* (should never happen) */
   {
     Error(ERR_WARN, "cannot find sound file '%s'", basename);
-    return FALSE;
+    return;
   }
 
-  return Load_WAV(filename);
+  if (*snd_info && strcmp(filename, (*snd_info)->source_filename) == 0)
+  {
+    /* 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. */
+
+    return;
+  }
+
+  if (*snd_info)
+    FreeSound(*snd_info);
+
+  *snd_info = Load_WAV(filename);
 }
 
-void InitSoundList(int num_list_entries)
+void InitSoundList(char *sound_name_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_name = sound_name_list;
   num_sounds = num_list_entries;
 }
 
@@ -1165,10 +1257,7 @@ void LoadSoundToList(char *basename, int list_pos)
   if (Sound == NULL || list_pos >= num_sounds)
     return;
 
-  if (Sound[list_pos])
-    FreeSound(Sound[list_pos]);
-
-  Sound[list_pos] = LoadCustomSound(basename);
+  LoadCustomSound(&Sound[list_pos], basename);
 }
 
 static MusicInfo *Load_MOD(char *filename)
@@ -1315,6 +1404,7 @@ void PlaySoundExt(int nr, int volume, int stereo, boolean loop_type)
   snd_ctrl.active	= TRUE;
 
 #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
@@ -1444,6 +1534,31 @@ void StopSoundExt(int nr, int method)
 #endif
 }
 
+static void ReloadCustomSounds()
+{
+  int i;
+
+#if 1
+  printf("DEBUG: reloading sounds '%s' ...\n", artwork.sounds_set_current);
+#endif
+
+  LoadSoundsInfo();
+
+  for(i=0; i<num_sounds; i++)
+    LoadSoundToList(sound_name[i], i);
+}
+
+static void ReloadCustomMusic()
+{
+#if 1
+  printf("DEBUG: reloading music '%s' ...\n", artwork.music_set_current);
+#endif
+
+  FreeAllMusic();
+
+  LoadCustomMusic();
+}
+
 static void InitReloadSoundsOrMusic(char *set_name, int type)
 {
 #if defined(PLATFORM_UNIX) && !defined(TARGET_SDL)