#include "setup.h"
+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;
/* ========================================================================= */
/* 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 =
};
#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(void *);
+
#if defined(PLATFORM_UNIX)
static int OpenAudioDevice(char *audio_device_name)
{
(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);
if (snd_ctrl.reload_sounds)
{
artwork.sounds_set_current = set_name;
- audio.func_reload_sounds();
+ ReloadCustomSounds();
}
else
{
artwork.music_set_current = set_name;
- audio.func_reload_music();
+ ReloadCustomMusic();
}
free(set_name);
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);
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;
+ }
}
-#if 0
- /* expand sample from 8 to 16 bit */
- for(j=0; j<sample_size; j++)
- premix_second_buffer[j] = premix_first_buffer[j] << 8;
-#endif
-
/* decrease volume if sound is fading out */
if (playlist[i].fade_sound &&
playlist[i].volume >= SOUND_FADING_VOLUME_THRESHOLD)
if (playlist[i].volume != PSND_MAX_VOLUME)
for(j=0; j<sample_size; j++)
premix_first_buffer[j] =
- (playlist[i].volume * (int)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 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 * (int)premix_first_buffer[j])
+ (left_volume * premix_first_buffer[j])
>> PSND_MAX_LEFT2RIGHT_BITS;
premix_right_buffer[j] =
- (right_volume * (int)premix_first_buffer[j])
+ (right_volume * premix_first_buffer[j])
>> PSND_MAX_LEFT2RIGHT_BITS;
premix_last_buffer[2 * j + 0] += premix_left_buffer[j];
else
{
for(j=0; j<sample_size; j++)
- premix_last_buffer[j] += (int)premix_first_buffer[j];
+ premix_last_buffer[j] += premix_first_buffer[j];
}
/* delete completed sound entries from the playlist */
}
}
- /* put last mixing buffer to final playing buffer */
-#if 0
- 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++)
{
- if (premix_last_buffer[i] < -255)
- playing_buffer[i] = 0;
- else if (premix_last_buffer[i] > 255)
- playing_buffer[i] = 255;
- else
- playing_buffer[i] = (premix_last_buffer[i] >> 1) ^ 0x80;
- }
-#else
- for(i=0; i<fragment_size; i++)
- {
- if (premix_last_buffer[i] < -255)
- playing_buffer[i] = -127;
- else if (premix_last_buffer[i] > 255)
- playing_buffer[i] = 127;
- else
- playing_buffer[i] = (premix_last_buffer[i] >> 1);
+ /* 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;
- playing_buffer[i] <<= 8;
+ 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;
+ }
}
-#endif
/* finally play the sound fragment */
write(audio.device_fd, playing_buffer, fragment_size);
if (snd_ctrl.music)
snd_ctrl.nr = snd_ctrl.nr % num_music;
+ else if (snd_ctrl.nr >= num_sounds)
+ return;
/* if playlist is full, remove oldest sound */
if (playing_sounds == MAX_SOUNDS_PLAYING)
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++;
/* ------------------------------------------------------------------------- */
#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
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");
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;
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;
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"... :) */
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)
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 */
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;
+ }
+
+ if (*snd_info)
+ {
+ char *filename_old = (*snd_info)->source_filename;
+
+ if (strcmp(filename, filename_old) == 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. */
+
+#if 1
+ printf("[sound '%s' already exists]\n", filename);
+#endif
+
+ return;
+ }
+
+ if (--(*snd_info)->num_references <= 0)
+ {
+#if 1
+ printf("[deleting sound '%s']\n", filename_old);
+#endif
+
+ /*
+ FreeSound(*snd_info);
+ */
+ deleteNodeFromList(&SoundFileList, filename_old, FreeSound);
+ }
}
- return Load_WAV(filename);
+ *snd_info = Load_WAV(filename);
+ (*snd_info)->num_references = 1;
+
+ addNodeToList(&SoundFileList, (*snd_info)->source_filename, *snd_info);
}
-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;
}
if (Sound == NULL || list_pos >= num_sounds)
return;
- if (Sound[list_pos])
- FreeSound(Sound[list_pos]);
+ printf("loading sound '%s' ... [%d]\n",
+ basename, getNumNodes(SoundFileList));
+
+ LoadCustomSound(&Sound[list_pos], basename);
- Sound[list_pos] = LoadCustomSound(basename);
+ printf("loading sound '%s' done [%d]\n",
+ basename, getNumNodes(SoundFileList));
}
static MusicInfo *Load_MOD(char *filename)
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
#endif
}
+ListNode *newListNode()
+{
+ return checked_calloc(sizeof(ListNode));
+}
+
+void addNodeToList(ListNode **node_first, char *key, void *content)
+{
+ ListNode *node_new = newListNode();
+
+#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;
+
+ printf("[CHECKING LIST KEY '%s' == '%s']\n",
+ (*node_first)->key, key);
+
+ if (strcmp((*node_first)->key, key) == 0)
+ {
+ printf("[DELETING LIST ENTRY]\n");
+
+ free((*node_first)->key);
+ if (destructor_function)
+ destructor_function((*node_first)->content);
+ *node_first = (*node_first)->next;
+ }
+ else
+ deleteNodeFromList(&(*node_first)->next, key, destructor_function);
+}
+
+ListNode *getNodeFromKey(ListNode *node_first, char *key)
+{
+ if (node_first == NULL)
+ return NULL;
+
+ if (strcmp(node_first->key, key) == 0)
+ return node_first;
+ else
+ return getNodeFromKey(node_first->next, key);
+}
+
+int getNumNodes(ListNode *node_first)
+{
+ return (node_first ? 1 + getNumNodes(node_first->next) : 0);
+}
+
+void dumpList(ListNode *node_first)
+{
+ ListNode *node = node_first;
+
+ while (node)
+ {
+ printf("['%s']\n", node->key);
+ node = node->next;
+ }
+
+ printf("[%d nodes]\n", getNumNodes(node_first));
+}
+
+static void LoadSoundsInfo()
+{
+ char *filename = getCustomSoundConfigFilename();
+ struct SetupFileList *setup_file_list;
+ int i;
+
+ /* always start with reliable default values */
+ for (i=0; i<num_sounds; i++)
+ sound_effect[i].filename = NULL;
+
+ if (filename == NULL)
+ return;
+
+ 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));
+
+ freeSetupFileList(setup_file_list);
+
+#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 1
+ printf("DEBUG: reloading sounds '%s' ...\n", artwork.sounds_set_current);
+#endif
+
+ LoadSoundsInfo();
+
+ for(i=0; i<num_sounds; i++)
+ {
+ 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));
+ */
+ dumpList(SoundFileList);
+}
+
+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)
InitReloadSoundsOrMusic(set_name, SND_RELOAD_MUSIC);
}
-void FreeSound(SoundInfo *sound)
+void FreeSound(void *ptr)
{
+ SoundInfo *sound = (SoundInfo *)ptr;
+
if (sound == NULL)
return;
#endif
}
+ if (sound->source_filename)
+ free(sound->source_filename);
+
free(sound);
}