#include <fcntl.h>
#include <dirent.h>
#include <signal.h>
+#include <math.h>
+
+#include "platform.h"
+
+#if defined(PLATFORM_LINUX)
+#include <sys/ioctl.h>
+#include <linux/soundcard.h>
+#elif defined(PLATFORM_FREEBSD)
+#include <machine/soundcard.h>
+#elif defined(PLATFORM_NETBSD)
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#elif defined(PLATFORM_HPUX)
+#include <sys/audio.h>
+#endif
#include "system.h"
#include "sound.h"
#include "misc.h"
#include "setup.h"
+#include "text.h"
+
+
+/* expiration time (in milliseconds) for sound loops */
+#define SOUND_LOOP_EXPIRATION_TIME 200
+
+/* one second fading interval == 1000 ticks (milliseconds) */
+#define SOUND_FADING_INTERVAL 1000
+
+#if defined(TARGET_SDL)
+#define SOUND_MAX_VOLUME SDL_MIX_MAXVOLUME
+#endif
+
+#if defined(AUDIO_STREAMING_DSP)
+#define SOUND_FADING_VOLUME_STEP (PSND_MAX_VOLUME / 40)
+#define SOUND_FADING_VOLUME_THRESHOLD (SOUND_FADING_VOLUME_STEP * 2)
+#endif
+
+#if !defined(PLATFORM_HPUX)
+#define SND_BLOCKSIZE 4096
+#else
+#define SND_BLOCKSIZE 32768
+#endif
+
+#define SND_TYPE_NONE 0
+#define SND_TYPE_WAV 1
+#define MUS_TYPE_NONE 0
+#define MUS_TYPE_WAV 1
+#define MUS_TYPE_MOD 2
-#define IS_PARENT_PROCESS(pid) ((pid) > 0)
-#define IS_CHILD_PROCESS(pid) ((pid) == 0)
+#define DEVICENAME_DSP "/dev/dsp"
+#define DEVICENAME_AUDIO "/dev/audio"
+#define DEVICENAME_AUDIOCTL "/dev/audioCtl"
+
+
+#if 0
+struct SoundHeader_SUN
+{
+ unsigned long magic;
+ unsigned long hdr_size;
+ unsigned long data_size;
+ unsigned long encoding;
+ unsigned long sample_rate;
+ unsigned long channels;
+};
+
+struct SoundHeader_8SVX
+{
+ char magic_FORM[4];
+ unsigned long chunk_size;
+ char magic_8SVX[4];
+};
+#endif
+
+struct AudioFormatInfo
+{
+ boolean stereo; /* availability of stereo sound */
+ int format; /* size and endianess of sample data */
+ int sample_rate; /* sample frequency */
+ int fragment_size; /* audio device fragment size in bytes */
+};
+
+struct SampleInfo
+{
+ char *source_filename;
+ int num_references;
+
+ int type;
+ int format;
+ long data_len;
+ void *data_ptr;
+};
+typedef struct SampleInfo SoundInfo;
+typedef struct SampleInfo MusicInfo;
+
+struct SoundControl
+{
+ boolean active;
+
+ int nr;
+ int volume;
+ int stereo_position;
+
+ int state;
+
+ unsigned long playing_starttime;
+ unsigned long playing_pos;
+
+ int type;
+ int format;
+ long data_len;
+ void *data_ptr;
+
+#if defined(PLATFORM_MSDOS)
+ int voice;
+#endif
+};
+typedef struct SoundControl SoundControl;
struct ListNode
{
mixer_active_channels = 0;
}
+static void Mixer_ResetChannelExpiration(int channel)
+{
+ mixer[channel].playing_starttime = Counter();
+
+#if defined(TARGET_SDL)
+ if (IS_LOOP(mixer[channel]) && !IS_MUSIC(mixer[channel]))
+ Mix_ExpireChannel(channel, SOUND_LOOP_EXPIRATION_TIME);
+#endif
+}
+
+static boolean Mixer_ChannelExpired(int channel)
+{
+ if (!mixer[channel].active)
+ return TRUE;
+
+ if (IS_LOOP(mixer[channel]) && !IS_MUSIC(mixer[channel]) &&
+ DelayReached(&mixer[channel].playing_starttime,
+ SOUND_LOOP_EXPIRATION_TIME))
+ return TRUE;
+
+#if defined(TARGET_SDL)
+
+ if (!Mix_Playing(channel))
+ return TRUE;
+
+#elif defined(TARGET_ALLEGRO)
+
+ mixer[channel].playing_pos = voice_get_position(mixer[channel].voice);
+ mixer[channel].volume = voice_get_volume(mixer[channel].voice);
+
+ /* sound sample has completed playing or was completely faded out */
+ if (mixer[channel].playing_pos == -1 || mixer[channel].volume == 0)
+ return TRUE;
+
+#endif /* TARGET_ALLEGRO */
+
+ return FALSE;
+}
+
static void Mixer_PlayChannel(int channel)
{
/* start with inactive channel in case something goes wrong */
if (mixer[channel].type != MUS_TYPE_WAV)
return;
- 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,
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_set_pan(mixer[channel].voice, mixer[channel].stereo_position);
voice_start(mixer[channel].voice);
#endif
+ Mixer_ResetChannelExpiration(channel);
+
+ mixer[channel].playing_pos = 0;
mixer[channel].active = TRUE;
mixer_active_channels++;
}
static void Mixer_StopChannel(int channel)
{
-#if 0
-#if defined(TARGET_SDL)
- printf("----------> %d [%d]\n", Mix_Playing(channel), Mix_Playing(0));
-#endif
-#endif
-
- if (!mixer_active_channels || !mixer[channel].active)
+ if (!mixer[channel].active)
return;
#if defined(TARGET_SDL)
static void Mixer_FadeChannel(int channel)
{
- if (!mixer_active_channels || !mixer[channel].active)
+ if (!mixer[channel].active)
return;
mixer[channel].state |= SND_CTRL_FADE;
#if defined(TARGET_SDL)
-
-#if 1
Mix_FadeOutChannel(channel, SOUND_FADING_INTERVAL);
-#else
- Mix_ExpireChannel(channel, SOUND_FADING_INTERVAL);
-#endif
-
#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
}
#endif
}
+static void Mixer_UnFadeChannel(int channel)
+{
+ if (!mixer[channel].active || !IS_FADING(mixer[channel]))
+ return;
+
+ mixer[channel].state &= ~SND_CTRL_FADE;
+ mixer[channel].volume = PSND_MAX_VOLUME;
+
+#if defined(TARGET_SDL)
+ Mix_ExpireChannel(channel, -1);
+ Mix_Volume(channel, SOUND_MAX_VOLUME);
+#elif defined(TARGET_ALLEGRO)
+ voice_stop_volumeramp(mixer[channel].voice);
+ voice_ramp_volume(mixer[channel].voice, SOUND_FADING_INTERVAL,
+ mixer[channel].volume);
+#endif
+}
+
static void Mixer_InsertSound(SoundControl snd_ctrl)
{
SoundInfo *snd_info;
printf("NEW SOUND %d HAS ARRIVED [%d]\n", snd_ctrl.nr, num_sounds);
#endif
+#if 0
+ printf("%d ACTIVE CHANNELS\n", mixer_active_channels);
+#endif
+
if (IS_MUSIC(snd_ctrl))
snd_ctrl.nr = snd_ctrl.nr % num_music;
else if (snd_ctrl.nr >= num_sounds)
return;
}
- if (mixer_active_channels == audio.num_channels)
- {
- for (i=0; i<audio.num_channels; i++)
- {
- if (mixer[i].data_ptr == NULL ||
- mixer[i].data_len == 0)
- {
-#if 1
- printf("THIS SHOULD NEVER HAPPEN! [%d]\n", i);
-#endif
-
- Mixer_StopChannel(i);
- }
- }
- }
-
-#if 0
- printf("%d ACTIVE CHANNELS\n", mixer_active_channels);
-#endif
-
- /* if all channels are active, remove oldest sound sample */
- if (mixer_active_channels == audio.num_channels)
- {
- int longest = 0, longest_nr = audio.first_sound_channel;
-
- for (i=audio.first_sound_channel; i<audio.num_channels; i++)
- {
- int actual = 100 * mixer[i].playingpos / mixer[i].data_len;
-
- if (!IS_LOOP(mixer[i]) && actual > longest)
- {
- longest = actual;
- longest_nr = i;
- }
- }
-
- Mixer_StopChannel(longest_nr);
- }
-
/* 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)
+ if (mixer[i].active && mixer[i].nr == snd_ctrl.nr)
k++;
- /* restart loop sounds only if they are just fading out */
- if (k >= 1 && IS_LOOP(snd_ctrl))
+#if 0
+ printf("SOUND %d [CURRENTLY PLAYING %d TIMES]\n", snd_ctrl.nr, k);
+#endif
+
+ /* reset expiration delay for already playing loop sounds */
+ if (k > 0 && IS_LOOP(snd_ctrl))
{
for(i=audio.first_sound_channel; i<audio.num_channels; i++)
{
- if (mixer[i].nr == snd_ctrl.nr && IS_FADING(mixer[i]))
+ if (mixer[i].active && mixer[i].nr == snd_ctrl.nr)
{
- 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);
+#if 0
+ printf("RESETTING EXPIRATION FOR SOUND %d\n", snd_ctrl.nr);
+#endif
+
+#if 1
+ Mixer_ResetChannelExpiration(i);
#endif
+ if (IS_FADING(mixer[i]))
+ Mixer_UnFadeChannel(i);
}
}
/* don't play sound more than n times simultaneously (with n == 2 for now) */
if (k >= 2)
{
+ unsigned long playing_current = Counter();
int longest = 0, longest_nr = audio.first_sound_channel;
/* look for oldest equal sound */
for(i=audio.first_sound_channel; i<audio.num_channels; i++)
{
+ int playing_time = playing_current - mixer[i].playing_starttime;
int actual;
if (!mixer[i].active || mixer[i].nr != snd_ctrl.nr)
continue;
- actual = 100 * mixer[i].playingpos / mixer[i].data_len;
+ actual = 1000 * playing_time / mixer[i].data_len;
if (actual >= longest)
{
Mixer_StopChannel(longest_nr);
}
- /* add new sound to mixer */
+ /* If all (non-music) channels are active, stop the channel that has
+ played its sound sample most completely (in percent of the sample
+ length). As we cannot currently get the actual playing position
+ of the channel's sound sample when compiling with the SDL mixer
+ library, we use the current playing time (in milliseconds) instead. */
+
+ if (mixer_active_channels ==
+ audio.num_channels - (mixer[audio.music_channel].active ? 0 : 1))
+ {
+ unsigned long playing_current = Counter();
+ int longest = 0, longest_nr = audio.first_sound_channel;
+
+ for (i=audio.first_sound_channel; i<audio.num_channels; i++)
+ {
+ int playing_time = playing_current - mixer[i].playing_starttime;
+ int actual = 1000 * playing_time / mixer[i].data_len;
+
+ if (!IS_LOOP(mixer[i]) && actual > longest)
+ {
+ longest = actual;
+ longest_nr = i;
+ }
+ }
+
+ Mixer_StopChannel(longest_nr);
+ }
+
+ /* add the new sound to the mixer */
for(i=0; i<audio.num_channels; i++)
{
#if 0
SendSoundControlToMixerProcess(&snd_ctrl);
return;
}
-#elif defined(TARGET_SDL)
- for (i=0; i<audio.num_channels; i++)
- if (!Mix_Playing(i))
- Mixer_StopChannel(i);
-#elif defined(TARGET_ALLEGRO)
- for (i=0; i<audio.num_channels; i++)
- {
- if (!mixer[i].active || IS_LOOP(mixer[i]))
- continue;
-
- mixer[i].playingpos = voice_get_position(mixer[i].voice);
- mixer[i].volume = voice_get_volume(mixer[i].voice);
+#endif
- if (mixer[i].playingpos == -1 || mixer[i].volume == 0)
+ /* deactivate channels that have expired since the last request */
+ for (i=0; i<audio.num_channels; i++)
+ if (mixer[i].active && Mixer_ChannelExpired(i))
Mixer_StopChannel(i);
- }
-#endif /* TARGET_ALLEGRO */
if (IS_RELOADING(snd_ctrl)) /* load new sound or music files */
{
}
else if (IS_FADING(snd_ctrl)) /* fade out existing sound or music */
{
- if (!mixer_active_channels)
- return;
-
if (IS_MUSIC(snd_ctrl))
{
Mixer_FadeMusicChannel();
}
else if (IS_STOPPING(snd_ctrl)) /* stop existing sound or music */
{
- if (!mixer_active_channels)
- return;
-
if (IS_MUSIC(snd_ctrl))
{
Mixer_StopMusicChannel();
if (!mixer[i].active)
continue;
+ if (Mixer_ChannelExpired(i))
+ {
+ Mixer_StopChannel(i);
+ 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_pos = mixer[i].playing_pos;
sample_size = MIN(max_sample_size, sample_len - sample_pos);
- mixer[i].playingpos += sample_size;
+ mixer[i].playing_pos += sample_size;
/* copy original sample to first mixing buffer */
CopySampleToMixingBuffer(&mixer[i], sample_pos, sample_size,
premix_first_buffer[sample_size + j] =
((short *)sample_ptr)[j];
- mixer[i].playingpos = restarted_sample_size;
+ mixer[i].playing_pos = restarted_sample_size;
sample_size += restarted_sample_size;
}
}
if (stereo)
{
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];
+ int left_volume = stereo_volume[middle_pos + mixer[i].stereo_position];
+ int right_volume= stereo_volume[middle_pos - mixer[i].stereo_position];
for(j=0; j<sample_size; j++)
{
}
/* delete completed sound entries from the mixer */
- if (mixer[i].playingpos >= mixer[i].data_len)
+ if (mixer[i].playing_pos >= mixer[i].data_len)
{
if (IS_LOOP(mixer[i]))
- mixer[i].playingpos = 0;
+ mixer[i].playing_pos = 0;
else
Mixer_StopChannel(i);
}
/* 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_pos = mixer[i].playing_pos;
sample_size = MIN(max_sample_size, sample_len - sample_pos);
- mixer[i].playingpos += sample_size;
+ mixer[i].playing_pos += sample_size;
/* copy original sample to first mixing buffer */
CopySampleToMixingBuffer(&mixer[i], sample_pos, sample_size,
#endif
/* delete completed sound entries from the mixer */
- if (mixer[i].playingpos >= mixer[i].data_len)
+ if (mixer[i].playing_pos >= mixer[i].data_len)
Mixer_StopChannel(i);
for(i=0; i<sample_size; i++)
{
char *filename = getCustomSoundFilename(basename);
+#if 0
+ printf("GOT CUSTOM SOUND FILE '%s'\n", filename);
+#endif
+
if (strcmp(basename, SND_FILE_UNDEFINED) == 0)
{
deleteSoundEntry(snd_info);
void LoadCustomMusic(void)
{
+ static boolean draw_init_text = TRUE; /* only draw at startup */
char *music_directory = getCustomMusicDirectory();
DIR *dir;
struct dirent *dir_entry;
return;
}
+ if (draw_init_text)
+ DrawInitText("Loading music:", 120, FC_GREEN);
+
while ((dir_entry = readdir(dir)) != NULL) /* loop until last dir entry */
{
char *basename = dir_entry->d_name;
char *filename = getPath2(music_directory, basename);
MusicInfo *mus_info = NULL;
+ if (draw_init_text)
+ DrawInitText(basename, 150, FC_YELLOW);
+
if (FileIsSound(basename))
mus_info = Load_WAV(filename);
else if (FileIsMusic(basename))
closedir(dir);
+ draw_init_text = FALSE;
+
if (num_music == 0)
Error(ERR_WARN, "cannot find any valid music files in directory '%s'",
music_directory);
PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_SOUND);
}
-void PlaySoundStereo(int nr, int stereo)
+void PlaySoundStereo(int nr, int stereo_position)
{
- PlaySoundExt(nr, PSND_MAX_VOLUME, stereo, SND_CTRL_PLAY_SOUND);
+ PlaySoundExt(nr, PSND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_SOUND);
}
void PlaySoundLoop(int nr)
PlaySoundExt(nr, PSND_MAX_VOLUME, PSND_MIDDLE, SND_CTRL_PLAY_MUSIC);
}
-void PlaySoundExt(int nr, int volume, int stereo, int state)
+void PlaySoundExt(int nr, int volume, int stereo_position, int state)
{
SoundControl snd_ctrl;
else if (volume > PSND_MAX_VOLUME)
volume = PSND_MAX_VOLUME;
- if (stereo < PSND_MAX_LEFT)
- stereo = PSND_MAX_LEFT;
- else if (stereo > PSND_MAX_RIGHT)
- stereo = PSND_MAX_RIGHT;
+ if (stereo_position < PSND_MAX_LEFT)
+ stereo_position = PSND_MAX_LEFT;
+ else if (stereo_position > PSND_MAX_RIGHT)
+ stereo_position = PSND_MAX_RIGHT;
snd_ctrl.active = TRUE;
- snd_ctrl.nr = nr;
+ snd_ctrl.nr = nr;
snd_ctrl.volume = volume;
- snd_ctrl.stereo = stereo;
- snd_ctrl.state = state;
+ snd_ctrl.stereo_position = stereo_position;
+ snd_ctrl.state = state;
HandleSoundRequest(snd_ctrl);
}
void FadeMusic(void)
{
- if (!audio.sound_available)
+ if (!audio.music_available)
return;
StopSoundExt(-1, SND_CTRL_FADE_MUSIC);
return;
snd_ctrl.active = FALSE;
- snd_ctrl.nr = nr;
- snd_ctrl.state = state;
+ snd_ctrl.nr = nr;
+ snd_ctrl.state = state;
HandleSoundRequest(snd_ctrl);
}
struct SetupFileList *setup_file_list;
int i;
+#if 0
+ printf("GOT CUSTOM SOUND CONFIG FILE '%s'\n", filename);
+#endif
+
/* always start with reliable default values */
for (i=0; i<num_sounds; i++)
sound_effect[i].filename = NULL;
freeSetupFileList(setup_file_list);
-#if 1
+#if 0
for (i=0; i<num_sounds; i++)
{
printf("'%s' ", sound_effect[i].text);
static void ReloadCustomSounds()
{
+ static boolean draw_init_text = TRUE; /* only draw at startup */
int i;
#if 0
LoadSoundsInfo();
+ if (draw_init_text)
+ DrawInitText("Loading sounds:", 120, FC_GREEN);
+
#if 0
printf("DEBUG: reloading %d sounds ...\n", num_sounds);
#endif
for(i=0; i<num_sounds; i++)
{
+ if (draw_init_text)
+ DrawInitText(sound_effect[i].text, 150, FC_YELLOW);
+
if (sound_effect[i].filename)
LoadSoundToList(sound_effect[i].filename, i);
else
LoadSoundToList(sound_effect[i].default_filename, i);
}
+ draw_init_text = FALSE;
+
/*
printf("list size == %d\n", getNumNodes(SoundFileList));
*/
if (Sound == NULL)
return;
+#if 0
printf("%s: FREEING SOUNDS ...\n",
IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+#endif
for(i=0; i<num_sounds; i++)
deleteSoundEntry(&Sound[i]);
FreeSound(Sound[i]);
*/
+#if 0
printf("%s: FREEING SOUNDS -- DONE\n",
IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+#endif
free(Sound);