cleanup of BD style game elements in level editor
[rocksndiamonds.git] / src / libgame / sound.c
1 // ============================================================================
2 // Artsoft Retro-Game Library
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // sound.c
10 // ============================================================================
11
12 #include <sys/types.h>
13 #include <sys/time.h>
14 #include <string.h>
15 #include <unistd.h>
16 #include <fcntl.h>
17 #include <dirent.h>
18 #include <signal.h>
19 #include <math.h>
20 #include <errno.h>
21
22 #include "platform.h"
23 #include "system.h"
24 #include "sound.h"
25 #include "misc.h"
26 #include "setup.h"
27 #include "text.h"
28
29
30 // expiration time (in milliseconds) for sound loops
31 #define SOUND_LOOP_EXPIRATION_TIME      200
32
33 // one second fading interval == 1000 ticks (milliseconds)
34 #define SOUND_FADING_INTERVAL           1000
35
36 #define SND_TYPE_NONE                   0
37 #define SND_TYPE_WAV                    1
38
39 #define MUS_TYPE_NONE                   0
40 #define MUS_TYPE_WAV                    1
41 #define MUS_TYPE_MOD                    2
42
43 #define DEVICENAME_DSP                  "/dev/dsp"
44 #define DEVICENAME_SOUND_DSP            "/dev/sound/dsp"
45 #define DEVICENAME_AUDIO                "/dev/audio"
46 #define DEVICENAME_AUDIOCTL             "/dev/audioCtl"
47
48 #define SOUND_VOLUME_LEFT(x)            (stereo_volume[x])
49 #define SOUND_VOLUME_RIGHT(x)           (stereo_volume[SOUND_MAX_LEFT2RIGHT-x])
50
51 #define SAME_SOUND_NR(x, y)             ((x).nr == (y).nr)
52 #define SAME_SOUND_DATA(x, y)           ((x).data_ptr == (y).data_ptr)
53
54 #define SOUND_VOLUME_FROM_PERCENT(v, p) ((p) < 0   ? SOUND_MIN_VOLUME : \
55                                          (p) > 100 ? (v) :              \
56                                          (p) * (v) / 100)
57
58 #define SOUND_VOLUME_SIMPLE(v) SOUND_VOLUME_FROM_PERCENT(v, setup.volume_simple)
59 #define SOUND_VOLUME_LOOPS(v)  SOUND_VOLUME_FROM_PERCENT(v, setup.volume_loops)
60 #define SOUND_VOLUME_MUSIC(v)  SOUND_VOLUME_FROM_PERCENT(v, setup.volume_music)
61
62 #define SETUP_SOUND_VOLUME(v, s)        ((s) & SND_CTRL_MUSIC ?         \
63                                          SOUND_VOLUME_MUSIC(v) :        \
64                                          (s) & SND_CTRL_LOOP ?          \
65                                          SOUND_VOLUME_LOOPS(v) :        \
66                                          SOUND_VOLUME_SIMPLE(v))
67
68 struct AudioFormatInfo
69 {
70   boolean stereo;               // availability of stereo sound
71   int format;                   // size and endianess of sample data
72   int sample_rate;              // sample frequency
73   int fragment_size;            // audio device fragment size in bytes
74 };
75
76 struct SampleInfo
77 {
78   char *source_filename;
79   int num_references;
80
81   int type;
82   int format;
83   void *data_ptr;               // pointer to first sample (8 or 16 bit)
84   int data_len;                 // number of samples, NOT number of bytes
85   int num_channels;             // mono: 1 channel, stereo: 2 channels
86 };
87 typedef struct SampleInfo SoundInfo;
88 typedef struct SampleInfo MusicInfo;
89
90 struct SoundControl
91 {
92   boolean active;
93
94   int nr;
95   int volume;
96   int stereo_position;
97
98   int state;
99
100   unsigned int playing_starttime;
101   unsigned int playing_pos;
102
103   int type;
104   int format;
105   void *data_ptr;               // pointer to first sample (8 or 16 bit)
106   int data_len;         // number of samples, NOT number of bytes
107   int num_channels;             // mono: 1 channel, stereo: 2 channels
108 };
109 typedef struct SoundControl SoundControl;
110
111 static struct ArtworkListInfo *sound_info = NULL;
112 static struct ArtworkListInfo *music_info = NULL;
113
114 static MusicInfo **Music_NoConf = NULL;
115
116 static int num_music_noconf = 0;
117 static int stereo_volume[SOUND_MAX_LEFT2RIGHT + 1];
118
119 static char *currently_playing_music_filename = NULL;
120
121
122 // ============================================================================
123 // THE STUFF BELOW IS ONLY USED BY THE SOUND SERVER CHILD PROCESS
124
125 static struct SoundControl mixer[NUM_MIXER_CHANNELS];
126 static int mixer_active_channels = 0;
127 static boolean expire_loop_sounds = FALSE;
128
129 static void ReloadCustomSounds(void);
130 static void ReloadCustomMusic(void);
131 static void FreeSound(void *);
132 static void FreeMusic(void *);
133 static void FreeAllMusic_NoConf(void);
134 static void Mixer_StopMusicChannel(void);
135
136 static SoundInfo *getSoundInfoEntryFromSoundID(int);
137 static MusicInfo *getMusicInfoEntryFromMusicID(int);
138
139
140 // ----------------------------------------------------------------------------
141 // mixer functions
142 // ----------------------------------------------------------------------------
143
144 static void Mixer_ChannelFinished(int channel)
145 {
146   if (!mixer[channel].active)
147     return;
148
149   mixer[channel].active = FALSE;
150   mixer_active_channels--;
151 }
152
153 void Mixer_InitChannels(void)
154 {
155   int i;
156
157   for (i = 0; i < audio.num_channels; i++)
158     mixer[i].active = FALSE;
159   mixer_active_channels = 0;
160
161   Mix_ChannelFinished(Mixer_ChannelFinished);
162 }
163
164 static void Mixer_ResetChannelExpiration(int channel)
165 {
166   mixer[channel].playing_starttime = Counter();
167
168   if (expire_loop_sounds &&
169       IS_LOOP(mixer[channel]) && !IS_MUSIC(mixer[channel]))
170     Mix_ExpireChannel(channel, SOUND_LOOP_EXPIRATION_TIME);
171 }
172
173 static boolean Mixer_ChannelExpired(int channel)
174 {
175   if (!mixer[channel].active)
176     return TRUE;
177
178   if (expire_loop_sounds &&
179       IS_LOOP(mixer[channel]) && !IS_MUSIC(mixer[channel]) &&
180       DelayReachedExt2(&mixer[channel].playing_starttime,
181                        SOUND_LOOP_EXPIRATION_TIME, Counter()))
182     return TRUE;
183
184   if (!Mix_Playing(channel))
185     return TRUE;
186
187   return FALSE;
188 }
189
190 static boolean Mixer_AllocateChannel(int channel)
191 {
192   return TRUE;
193 }
194
195 static void Mixer_SetChannelProperties(int channel)
196 {
197   Mix_Volume(channel, mixer[channel].volume);
198   Mix_SetPanning(channel,
199                  SOUND_VOLUME_LEFT(mixer[channel].stereo_position),
200                  SOUND_VOLUME_RIGHT(mixer[channel].stereo_position));
201 }
202
203 static void Mixer_StartChannel(int channel)
204 {
205   Mix_PlayChannel(channel, mixer[channel].data_ptr,
206                   IS_LOOP(mixer[channel]) ? -1 : 0);
207 }
208
209 static void Mixer_PlayChannel(int channel)
210 {
211   // start with inactive channel in case something goes wrong
212   mixer[channel].active = FALSE;
213
214   if (mixer[channel].type != MUS_TYPE_WAV)
215     return;
216
217   if (!Mixer_AllocateChannel(channel))
218     return;
219
220   Mixer_SetChannelProperties(channel);
221   Mixer_StartChannel(channel);
222
223   Mixer_ResetChannelExpiration(channel);
224
225   mixer[channel].playing_pos = 0;
226   mixer[channel].active = TRUE;
227   mixer_active_channels++;
228 }
229
230 static void Mixer_PlayMusicChannel(void)
231 {
232   Mixer_PlayChannel(audio.music_channel);
233
234   if (mixer[audio.music_channel].type != MUS_TYPE_WAV)
235   {
236     int loops = (IS_LOOP(mixer[audio.music_channel]) ? -1 : 1);
237
238     // stopping music channel before playing next track seems to be needed to
239     // prevent audio problems that may occur when playing MP3 files on Windows
240     Mixer_StopMusicChannel();
241
242     // use short fade-in to prevent "plop" sound for certain music files
243     // (this may happen when switching on music while playing the game)
244     Mix_VolumeMusic(mixer[audio.music_channel].volume);
245     Mix_FadeInMusic(mixer[audio.music_channel].data_ptr, loops, 100);
246
247 #if defined(PLATFORM_WINDOWS)
248     // playing MIDI music is broken since Windows Vista, as it sets the volume
249     // for MIDI music also for all other sounds and music, which cannot be set
250     // back to normal unless playing MIDI music again with that desired volume
251     // (more details: https://www.artsoft.org/forum/viewtopic.php?f=7&t=2253)
252     // => workaround: always play MIDI music with maximum volume
253     if (Mix_GetMusicType(NULL) == MUS_MID)
254       Mix_VolumeMusic(SOUND_MAX_VOLUME);
255 #endif
256   }
257 }
258
259 static void Mixer_StopChannel(int channel)
260 {
261   Mix_HaltChannel(channel);
262 }
263
264 static void Mixer_StopMusicChannel(void)
265 {
266   Mixer_StopChannel(audio.music_channel);
267
268   Mix_HaltMusic();
269
270   setString(&currently_playing_music_filename, NULL);
271 }
272
273 static void Mixer_FadeChannel(int channel)
274 {
275   if (!mixer[channel].active)
276     return;
277
278   mixer[channel].state |= SND_CTRL_FADE;
279
280   Mix_FadeOutChannel(channel, SOUND_FADING_INTERVAL);
281 }
282
283 static void Mixer_FadeMusicChannel(void)
284 {
285   Mixer_FadeChannel(audio.music_channel);
286
287   Mix_FadeOutMusic(SOUND_FADING_INTERVAL);
288
289 #if defined(PLATFORM_WINDOWS)
290   // playing MIDI music is broken since Windows Vista, as it sets the volume
291   // for MIDI music also for all other sounds and music, which cannot be set
292   // back to normal unless playing MIDI music again with that desired volume
293   // (more details: https://www.artsoft.org/forum/viewtopic.php?f=7&t=2253)
294   // => workaround: never fade MIDI music to lower volume, but just stop it
295   if (Mix_GetMusicType(NULL) == MUS_MID)
296     Mixer_StopMusicChannel();
297 #endif
298
299   setString(&currently_playing_music_filename, NULL);
300 }
301
302 static void Mixer_UnFadeChannel(int channel)
303 {
304   if (!mixer[channel].active || !IS_FADING(mixer[channel]))
305     return;
306
307   mixer[channel].state &= ~SND_CTRL_FADE;
308   mixer[channel].volume = SOUND_MAX_VOLUME;
309
310   Mix_ExpireChannel(channel, -1);
311   Mix_Volume(channel, mixer[channel].volume);
312 }
313
314 static void Mixer_InsertSound(SoundControl snd_ctrl)
315 {
316   SoundInfo *snd_info;
317   int i, k;
318
319   if (IS_MUSIC(snd_ctrl))
320     snd_info = getMusicInfoEntryFromMusicID(snd_ctrl.nr);
321   else
322     snd_info = getSoundInfoEntryFromSoundID(snd_ctrl.nr);
323
324   if (snd_info == NULL)
325     return;
326
327   // copy sound sample and format information
328   snd_ctrl.type         = snd_info->type;
329   snd_ctrl.format       = snd_info->format;
330   snd_ctrl.data_ptr     = snd_info->data_ptr;
331   snd_ctrl.data_len     = snd_info->data_len;
332   snd_ctrl.num_channels = snd_info->num_channels;
333
334   // play music samples on a dedicated music channel
335   if (IS_MUSIC(snd_ctrl))
336   {
337     Mixer_StopMusicChannel();
338
339     mixer[audio.music_channel] = snd_ctrl;
340     Mixer_PlayMusicChannel();
341
342     setString(&currently_playing_music_filename,
343               getBaseNamePtr(snd_info->source_filename));
344
345     return;
346   }
347
348   // check if (and how often) this sound sample is already playing
349   for (k = 0, i = audio.first_sound_channel; i < audio.num_channels; i++)
350     if (mixer[i].active && SAME_SOUND_DATA(mixer[i], snd_ctrl))
351       k++;
352
353   // reset expiration delay for already playing loop sounds
354   if (k > 0 && IS_LOOP(snd_ctrl))
355   {
356     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
357     {
358       if (mixer[i].active && SAME_SOUND_DATA(mixer[i], snd_ctrl))
359       {
360         if (IS_FADING(mixer[i]))
361           Mixer_UnFadeChannel(i);
362
363         // restore settings like volume and stereo position
364         mixer[i].volume = snd_ctrl.volume;
365         mixer[i].stereo_position = snd_ctrl.stereo_position;
366
367         Mixer_SetChannelProperties(i);
368         Mixer_ResetChannelExpiration(i);
369       }
370     }
371
372     return;
373   }
374
375   // don't play sound more than n times simultaneously (with n == 2 for now)
376   if (k >= 2)
377   {
378     unsigned int playing_current = Counter();
379     int longest = 0, longest_nr = audio.first_sound_channel;
380
381     // look for oldest equal sound
382     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
383     {
384       int playing_time = playing_current - mixer[i].playing_starttime;
385       int actual;
386
387       if (!mixer[i].active || !SAME_SOUND_NR(mixer[i], snd_ctrl))
388         continue;
389
390       actual = 1000 * playing_time / mixer[i].data_len;
391
392       if (actual >= longest)
393       {
394         longest = actual;
395         longest_nr = i;
396       }
397     }
398
399     Mixer_StopChannel(longest_nr);
400   }
401
402   /* If all (non-music) channels are active, stop the channel that has
403      played its sound sample most completely (in percent of the sample
404      length). As we cannot currently get the actual playing position
405      of the channel's sound sample when compiling with the SDL mixer
406      library, we use the current playing time (in milliseconds) instead. */
407
408 #if DEBUG
409   // channel allocation sanity check -- should not be needed
410   if (mixer_active_channels ==
411       audio.num_channels - (mixer[audio.music_channel].active ? 0 : 1))
412   {
413     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
414     {
415       if (!mixer[i].active)
416       {
417         Debug("audio", "Mixer_InsertSound: Channel %d inactive", i);
418         Debug("audio", "Mixer_InsertSound: This should never happen!");
419
420         mixer_active_channels--;
421       }
422     }
423   }
424 #endif
425
426   if (mixer_active_channels ==
427       audio.num_channels - (mixer[audio.music_channel].active ? 0 : 1))
428   {
429     unsigned int playing_current = Counter();
430     int longest = 0, longest_nr = audio.first_sound_channel;
431
432     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
433     {
434       int playing_time = playing_current - mixer[i].playing_starttime;
435       int actual = 1000 * playing_time / mixer[i].data_len;
436
437       if (!IS_LOOP(mixer[i]) && actual > longest)
438       {
439         longest = actual;
440         longest_nr = i;
441       }
442     }
443
444     Mixer_StopChannel(longest_nr);
445   }
446
447   // add the new sound to the mixer
448   for (i = audio.first_sound_channel; i < audio.num_channels; i++)
449   {
450     if (!mixer[i].active)
451     {
452       mixer[i] = snd_ctrl;
453       Mixer_PlayChannel(i);
454
455       break;
456     }
457   }
458 }
459
460 static void HandleSoundRequest(SoundControl snd_ctrl)
461 {
462   int i;
463
464   // deactivate channels that have expired since the last request
465   for (i = 0; i < audio.num_channels; i++)
466     if (mixer[i].active && Mixer_ChannelExpired(i))
467       Mixer_StopChannel(i);
468
469   if (IS_RELOADING(snd_ctrl))           // load new sound or music files
470   {
471     Mixer_StopMusicChannel();
472     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
473       Mixer_StopChannel(i);
474
475     if (snd_ctrl.state & SND_CTRL_RELOAD_SOUNDS)
476       ReloadCustomSounds();
477     else
478       ReloadCustomMusic();
479   }
480   else if (IS_FADING(snd_ctrl))         // fade out existing sound or music
481   {
482     if (IS_MUSIC(snd_ctrl))
483     {
484       Mixer_FadeMusicChannel();
485       return;
486     }
487
488     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
489       if (SAME_SOUND_NR(mixer[i], snd_ctrl) || ALL_SOUNDS(snd_ctrl))
490         Mixer_FadeChannel(i);
491   }
492   else if (IS_STOPPING(snd_ctrl))       // stop existing sound or music
493   {
494     if (IS_MUSIC(snd_ctrl))
495     {
496       Mixer_StopMusicChannel();
497       return;
498     }
499
500     for (i = audio.first_sound_channel; i < audio.num_channels; i++)
501       if (SAME_SOUND_NR(mixer[i], snd_ctrl) || ALL_SOUNDS(snd_ctrl))
502         Mixer_StopChannel(i);
503   }
504   else if (SET_EXPIRE_LOOPS(snd_ctrl))  // set loop expiration on or off
505   {
506     expire_loop_sounds = snd_ctrl.active;
507   }
508   else if (snd_ctrl.active)             // add new sound to mixer
509   {
510     Mixer_InsertSound(snd_ctrl);
511   }
512 }
513
514 void StartMixer(void)
515 {
516   int i;
517
518   if (!audio.sound_available)
519     return;
520
521   // initialize stereo position conversion information
522   for (i = 0; i <= SOUND_MAX_LEFT2RIGHT; i++)
523     stereo_volume[i] =
524       (int)sqrt((float)(SOUND_MAX_LEFT2RIGHT * SOUND_MAX_LEFT2RIGHT - i * i));
525 }
526
527 boolean isSoundPlaying(int nr)
528 {
529   int i;
530
531   for (i = audio.first_sound_channel; i < audio.num_channels; i++)
532     if (mixer[i].active && mixer[i].nr == nr)
533       return TRUE;
534
535   return FALSE;
536 }
537
538
539 // THE STUFF ABOVE IS ONLY USED BY THE SOUND SERVER CHILD PROCESS
540 // ============================================================================
541 // THE STUFF BELOW IS ONLY USED BY THE MAIN PROCESS
542
543 #define CHUNK_ID_LEN            4       // IFF style chunk id length
544 #define WAV_HEADER_SIZE         16      // size of WAV file header
545
546 static void *Load_WAV(char *filename)
547 {
548   SoundInfo *snd_info;
549
550   if (!audio.sound_available)
551     return NULL;
552
553   snd_info = checked_calloc(sizeof(SoundInfo));
554
555   if ((snd_info->data_ptr = Mix_LoadWAV(filename)) == NULL)
556   {
557     Warn("cannot read sound file '%s': %s", filename, Mix_GetError());
558
559     free(snd_info);
560
561     return NULL;
562   }
563
564   snd_info->data_len = ((Mix_Chunk *)snd_info->data_ptr)->alen;
565
566   snd_info->type = SND_TYPE_WAV;
567   snd_info->source_filename = getStringCopy(filename);
568
569   return snd_info;
570 }
571
572 static void *Load_MOD(char *filename)
573 {
574   MusicInfo *mod_info;
575
576   if (!audio.sound_available)
577     return NULL;
578
579   mod_info = checked_calloc(sizeof(MusicInfo));
580
581   if ((mod_info->data_ptr = Mix_LoadMUS(filename)) == NULL)
582   {
583     Warn("cannot read music file '%s': %s", filename, Mix_GetError());
584
585     free(mod_info);
586
587     return NULL;
588   }
589
590   mod_info->type = MUS_TYPE_MOD;
591   mod_info->source_filename = getStringCopy(filename);
592
593   return mod_info;
594 }
595
596 static void *Load_WAV_or_MOD(char *filename)
597 {
598   if (FileIsMusic(filename))
599     return Load_MOD(filename);
600   else if (FileIsSound(filename))
601     return Load_WAV(filename);
602   else
603     return NULL;
604 }
605
606 static int compareMusicInfo(const void *object1, const void *object2)
607 {
608   const MusicInfo *mi1 = *((MusicInfo **)object1);
609   const MusicInfo *mi2 = *((MusicInfo **)object2);
610
611   return strcmp(mi1->source_filename, mi2->source_filename);
612 }
613
614 static void LoadCustomMusic_NoConf(void)
615 {
616   static boolean draw_init_text = TRUE;         // only draw at startup
617   static char *last_music_directory = NULL;
618   char *music_directory = getCustomMusicDirectory_NoConf();
619   Directory *dir;
620   DirectoryEntry *dir_entry;
621   int num_music = getMusicListSize();
622
623   if (!audio.sound_available)
624     return;
625
626   if (last_music_directory != NULL &&
627       strEqual(last_music_directory, music_directory))
628     return;     // old and new music directory are the same
629
630   if (last_music_directory != NULL)
631     free(last_music_directory);
632   last_music_directory = getStringCopy(music_directory);
633
634   FreeAllMusic_NoConf();
635
636   if (music_directory == NULL)
637   {
638     Warn("cannot find music directory with unconfigured music");
639
640     return;
641   }
642   else if ((dir = openDirectory(music_directory)) == NULL)
643   {
644     Warn("cannot read music directory '%s'", music_directory);
645
646     return;
647   }
648
649   if (draw_init_text)
650     DrawInitTextHead("Loading music");
651
652   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
653   {
654     char *basename = dir_entry->basename;
655     MusicInfo *mus_info = NULL;
656     boolean music_already_used = FALSE;
657     int i;
658
659     // skip all music files that are configured in music config file
660     for (i = 0; i < num_music; i++)
661     {
662       struct FileInfo *music = getMusicListEntry(i);
663
664       if (strEqual(basename, music->filename))
665       {
666         music_already_used = TRUE;
667         break;
668       }
669     }
670
671     if (music_already_used)
672       continue;
673
674     if (draw_init_text)
675       DrawInitTextItem(basename);
676
677     if (FileIsMusic(dir_entry->filename))
678       mus_info = Load_WAV_or_MOD(dir_entry->filename);
679
680     if (mus_info)
681     {
682       num_music_noconf++;
683       Music_NoConf = checked_realloc(Music_NoConf,
684                                      num_music_noconf * sizeof(MusicInfo *));
685       Music_NoConf[num_music_noconf - 1] = mus_info;
686     }
687   }
688
689   closeDirectory(dir);
690
691   // sort music files by filename
692   qsort(Music_NoConf, num_music_noconf, sizeof(MusicInfo *), compareMusicInfo);
693
694   draw_init_text = FALSE;
695 }
696
697 int getSoundListSize(void)
698 {
699   return (sound_info->num_file_list_entries +
700           sound_info->num_dynamic_file_list_entries);
701 }
702
703 int getMusicListSize(void)
704 {
705   return (music_info->num_file_list_entries +
706           music_info->num_dynamic_file_list_entries);
707 }
708
709 int getMusicListSize_NoConf(void)
710 {
711   return num_music_noconf;
712 }
713
714 struct FileInfo *getSoundListEntry(int pos)
715 {
716   int num_sounds = getSoundListSize();
717   int num_list_entries = sound_info->num_file_list_entries;
718   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
719
720   if (pos < 0 || pos >= num_sounds)     // invalid sound
721     return NULL;
722
723   return (pos < num_list_entries ? &sound_info->file_list[list_pos] :
724           &sound_info->dynamic_file_list[list_pos]);
725 }
726
727 struct FileInfo *getMusicListEntry(int pos)
728 {
729   int num_music = getMusicListSize();
730   int num_list_entries = music_info->num_file_list_entries;
731   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
732
733   if (pos < 0 || pos >= num_music)      // invalid music
734     return NULL;
735
736   return (pos < num_list_entries ? &music_info->file_list[list_pos] :
737           &music_info->dynamic_file_list[list_pos]);
738 }
739
740 static SoundInfo *getSoundInfoEntryFromSoundID(int pos)
741 {
742   int num_sounds = getSoundListSize();
743   int num_list_entries = sound_info->num_file_list_entries;
744   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
745   SoundInfo **snd_info =
746     (SoundInfo **)(pos < num_list_entries ? sound_info->artwork_list :
747                    sound_info->dynamic_artwork_list);
748
749   if (pos < 0 || pos >= num_sounds)     // invalid sound
750     return NULL;
751
752   return snd_info[list_pos];
753 }
754
755 static MusicInfo *getMusicInfoEntryFromMusicID(int pos)
756 {
757   int num_music = getMusicListSize();
758   int num_list_entries = music_info->num_file_list_entries;
759   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
760   MusicInfo **mus_info =
761     (MusicInfo **)(pos < num_list_entries ? music_info->artwork_list :
762                    music_info->dynamic_artwork_list);
763
764   if (pos >= num_music)                 // invalid music
765     return NULL;
766
767   if (pos < 0)                          // undefined music
768   {
769     if (num_music_noconf == 0)          // no fallback music available
770       return NULL;
771
772     pos = UNMAP_NOCONF_MUSIC(pos) % num_music_noconf;
773
774     return Music_NoConf[pos];
775   }
776
777   return mus_info[list_pos];
778 }
779
780 char *getSoundInfoEntryFilename(int pos)
781 {
782   SoundInfo *snd_info = getSoundInfoEntryFromSoundID(pos);
783
784   if (snd_info == NULL)
785     return NULL;
786
787   return getBaseNamePtr(snd_info->source_filename);
788 }
789
790 char *getMusicInfoEntryFilename(int pos)
791 {
792   MusicInfo *mus_info = getMusicInfoEntryFromMusicID(pos);
793
794   if (mus_info == NULL)
795     return NULL;
796
797   return getBaseNamePtr(mus_info->source_filename);
798 }
799
800 char *getCurrentlyPlayingMusicFilename(void)
801 {
802   return currently_playing_music_filename;
803 }
804
805 int getSoundListPropertyMappingSize(void)
806 {
807   return sound_info->num_property_mapping_entries;
808 }
809
810 int getMusicListPropertyMappingSize(void)
811 {
812   return music_info->num_property_mapping_entries;
813 }
814
815 struct PropertyMapping *getSoundListPropertyMapping(void)
816 {
817   return sound_info->property_mapping;
818 }
819
820 struct PropertyMapping *getMusicListPropertyMapping(void)
821 {
822   return music_info->property_mapping;
823 }
824
825 void InitSoundList(struct ConfigInfo *config_list, int num_file_list_entries,
826                    struct ConfigTypeInfo *config_suffix_list,
827                    char **base_prefixes, char **ext1_suffixes,
828                    char **ext2_suffixes, char **ext3_suffixes,
829                    char **ignore_tokens)
830 {
831   int i;
832
833   sound_info = checked_calloc(sizeof(struct ArtworkListInfo));
834   sound_info->type = ARTWORK_TYPE_SOUNDS;
835
836   // ---------- initialize file list and suffix lists ----------
837
838   sound_info->num_file_list_entries = num_file_list_entries;
839   sound_info->num_dynamic_file_list_entries = 0;
840
841   sound_info->file_list =
842     getFileListFromConfigList(config_list, config_suffix_list, ignore_tokens,
843                               num_file_list_entries);
844   sound_info->dynamic_file_list = NULL;
845
846   sound_info->num_suffix_list_entries = 0;
847   for (i = 0; config_suffix_list[i].token != NULL; i++)
848     sound_info->num_suffix_list_entries++;
849
850   sound_info->suffix_list = config_suffix_list;
851
852   // ---------- initialize base prefix and suffixes lists ----------
853
854   sound_info->num_base_prefixes = 0;
855   for (i = 0; base_prefixes[i] != NULL; i++)
856     sound_info->num_base_prefixes++;
857
858   sound_info->num_ext1_suffixes = 0;
859   for (i = 0; ext1_suffixes[i] != NULL; i++)
860     sound_info->num_ext1_suffixes++;
861
862   sound_info->num_ext2_suffixes = 0;
863   for (i = 0; ext2_suffixes[i] != NULL; i++)
864     sound_info->num_ext2_suffixes++;
865
866   sound_info->num_ext3_suffixes = 0;
867   for (i = 0; ext3_suffixes[i] != NULL; i++)
868     sound_info->num_ext3_suffixes++;
869
870   sound_info->num_ignore_tokens = 0;
871   for (i = 0; ignore_tokens[i] != NULL; i++)
872     sound_info->num_ignore_tokens++;
873
874   sound_info->base_prefixes = base_prefixes;
875   sound_info->ext1_suffixes = ext1_suffixes;
876   sound_info->ext2_suffixes = ext2_suffixes;
877   sound_info->ext3_suffixes = ext3_suffixes;
878   sound_info->ignore_tokens = ignore_tokens;
879
880   sound_info->num_property_mapping_entries = 0;
881
882   sound_info->property_mapping = NULL;
883
884   // ---------- initialize artwork reference and content lists ----------
885
886   sound_info->sizeof_artwork_list_entry = sizeof(SoundInfo *);
887
888   sound_info->artwork_list =
889     checked_calloc(num_file_list_entries * sizeof(SoundInfo *));
890   sound_info->dynamic_artwork_list = NULL;
891
892   sound_info->content_list = NULL;
893
894   // ---------- initialize artwork loading/freeing functions ----------
895
896   sound_info->load_artwork = Load_WAV;
897   sound_info->free_artwork = FreeSound;
898 }
899
900 void InitMusicList(struct ConfigInfo *config_list, int num_file_list_entries,
901                    struct ConfigTypeInfo *config_suffix_list,
902                    char **base_prefixes, char **ext1_suffixes,
903                    char **ext2_suffixes, char **ext3_suffixes,
904                    char **ignore_tokens)
905 {
906   int i;
907
908   music_info = checked_calloc(sizeof(struct ArtworkListInfo));
909   music_info->type = ARTWORK_TYPE_MUSIC;
910
911   // ---------- initialize file list and suffix lists ----------
912
913   music_info->num_file_list_entries = num_file_list_entries;
914   music_info->num_dynamic_file_list_entries = 0;
915
916   music_info->file_list =
917     getFileListFromConfigList(config_list, config_suffix_list, ignore_tokens,
918                               num_file_list_entries);
919   music_info->dynamic_file_list = NULL;
920
921   music_info->num_suffix_list_entries = 0;
922   for (i = 0; config_suffix_list[i].token != NULL; i++)
923     music_info->num_suffix_list_entries++;
924
925   music_info->suffix_list = config_suffix_list;
926
927   // ---------- initialize base prefix and suffixes lists ----------
928
929   music_info->num_base_prefixes = 0;
930   for (i = 0; base_prefixes[i] != NULL; i++)
931     music_info->num_base_prefixes++;
932
933   music_info->num_ext1_suffixes = 0;
934   for (i = 0; ext1_suffixes[i] != NULL; i++)
935     music_info->num_ext1_suffixes++;
936
937   music_info->num_ext2_suffixes = 0;
938   for (i = 0; ext2_suffixes[i] != NULL; i++)
939     music_info->num_ext2_suffixes++;
940
941   music_info->num_ext3_suffixes = 0;
942   for (i = 0; ext3_suffixes[i] != NULL; i++)
943     music_info->num_ext3_suffixes++;
944
945   music_info->num_ignore_tokens = 0;
946   for (i = 0; ignore_tokens[i] != NULL; i++)
947     music_info->num_ignore_tokens++;
948
949   music_info->base_prefixes = base_prefixes;
950   music_info->ext1_suffixes = ext1_suffixes;
951   music_info->ext2_suffixes = ext2_suffixes;
952   music_info->ext3_suffixes = ext3_suffixes;
953   music_info->ignore_tokens = ignore_tokens;
954
955   music_info->num_property_mapping_entries = 0;
956
957   music_info->property_mapping = NULL;
958
959   // ---------- initialize artwork reference and content lists ----------
960
961   music_info->sizeof_artwork_list_entry = sizeof(MusicInfo *);
962
963   music_info->artwork_list =
964     checked_calloc(num_file_list_entries * sizeof(MusicInfo *));
965   music_info->dynamic_artwork_list = NULL;
966
967   music_info->content_list = NULL;
968
969   // ---------- initialize artwork loading/freeing functions ----------
970
971   music_info->load_artwork = Load_WAV_or_MOD;
972   music_info->free_artwork = FreeMusic;
973 }
974
975 void PlayMusic(int nr)
976 {
977   if (!audio.music_available)
978     return;
979
980   PlaySoundMusic(nr);
981 }
982
983 void PlayMusicLoop(int nr)
984 {
985   if (!audio.music_available)
986     return;
987
988   PlaySoundMusicLoop(nr);
989 }
990
991 void PlaySound(int nr)
992 {
993   if (!setup.sound_simple)
994     return;
995
996   PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_SOUND);
997 }
998
999 void PlaySoundStereo(int nr, int stereo_position)
1000 {
1001   if (!setup.sound_simple)
1002     return;
1003
1004   PlaySoundExt(nr, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_SOUND);
1005 }
1006
1007 void PlaySoundLoop(int nr)
1008 {
1009   if (!setup.sound_loops)
1010     return;
1011
1012   PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_LOOP);
1013 }
1014
1015 void PlaySoundMusic(int nr)
1016 {
1017   if (!setup.sound_music)
1018     return;
1019
1020   PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_MUSIC);
1021 }
1022
1023 void PlaySoundMusicLoop(int nr)
1024 {
1025   if (!setup.sound_music)
1026     return;
1027
1028   PlaySoundExt(nr, SOUND_MAX_VOLUME, SOUND_MIDDLE, SND_CTRL_PLAY_MUSIC_LOOP);
1029 }
1030
1031 void PlaySoundExt(int nr, int volume, int stereo_position, int state)
1032 {
1033   SoundControl snd_ctrl;
1034
1035   if (!audio.sound_available ||
1036       !audio.sound_enabled ||
1037       audio.sound_deactivated)
1038     return;
1039
1040   volume = SETUP_SOUND_VOLUME(volume, state);
1041
1042   if (volume < SOUND_MIN_VOLUME)
1043     volume = SOUND_MIN_VOLUME;
1044   else if (volume > SOUND_MAX_VOLUME)
1045     volume = SOUND_MAX_VOLUME;
1046
1047   if (stereo_position < SOUND_MAX_LEFT)
1048     stereo_position = SOUND_MAX_LEFT;
1049   else if (stereo_position > SOUND_MAX_RIGHT)
1050     stereo_position = SOUND_MAX_RIGHT;
1051
1052   clear_mem(&snd_ctrl, sizeof(SoundControl));   // to make valgrind happy
1053
1054   snd_ctrl.active = TRUE;
1055   snd_ctrl.nr = nr;
1056   snd_ctrl.volume = volume;
1057   snd_ctrl.stereo_position = stereo_position;
1058   snd_ctrl.state = state;
1059
1060   HandleSoundRequest(snd_ctrl);
1061 }
1062
1063 void FadeMusic(void)
1064 {
1065   if (!audio.music_available)
1066     return;
1067
1068   StopSoundExt(-1, SND_CTRL_FADE_MUSIC);
1069 }
1070
1071 void FadeSound(int nr)
1072 {
1073   StopSoundExt(nr, SND_CTRL_FADE_SOUND);
1074 }
1075
1076 void FadeSounds(void)
1077 {
1078   StopSoundExt(-1, SND_CTRL_FADE_ALL);
1079 }
1080
1081 void FadeSoundsAndMusic(void)
1082 {
1083   FadeSounds();
1084   FadeMusic();
1085 }
1086
1087 void StopMusic(void)
1088 {
1089   if (!audio.music_available)
1090     return;
1091
1092   StopSoundExt(-1, SND_CTRL_STOP_MUSIC);
1093 }
1094
1095 void StopSound(int nr)
1096 {
1097   StopSoundExt(nr, SND_CTRL_STOP_SOUND);
1098 }
1099
1100 void StopSounds(void)
1101 {
1102   StopMusic();
1103   StopSoundExt(-1, SND_CTRL_STOP_ALL);
1104 }
1105
1106 void StopSoundExt(int nr, int state)
1107 {
1108   SoundControl snd_ctrl;
1109
1110   if (!audio.sound_available)
1111     return;
1112
1113   clear_mem(&snd_ctrl, sizeof(SoundControl));   // to make valgrind happy
1114
1115   snd_ctrl.active = FALSE;
1116   snd_ctrl.nr = nr;
1117   snd_ctrl.state = state;
1118
1119   HandleSoundRequest(snd_ctrl);
1120 }
1121
1122 void ExpireSoundLoops(boolean active)
1123 {
1124   SoundControl snd_ctrl;
1125
1126   if (!audio.sound_available)
1127     return;
1128
1129   clear_mem(&snd_ctrl, sizeof(SoundControl));   // to make valgrind happy
1130
1131   snd_ctrl.active = active;
1132   snd_ctrl.state = SND_CTRL_EXPIRE_LOOPS;
1133
1134   HandleSoundRequest(snd_ctrl);
1135 }
1136
1137 static void ReloadCustomSounds(void)
1138 {
1139   LoadArtworkConfig(sound_info);
1140   ReloadCustomArtworkList(sound_info);
1141 }
1142
1143 static void ReloadCustomMusic(void)
1144 {
1145   LoadArtworkConfig(music_info);
1146   ReloadCustomArtworkList(music_info);
1147
1148   // load all music files from directory not defined in "musicinfo.conf"
1149   LoadCustomMusic_NoConf();
1150 }
1151
1152 void InitReloadCustomSounds(void)
1153 {
1154   if (!audio.sound_available)
1155     return;
1156
1157   ReloadCustomSounds();
1158 }
1159
1160 void InitReloadCustomMusic(void)
1161 {
1162   if (!audio.music_available)
1163     return;
1164
1165   ReloadCustomMusic();
1166 }
1167
1168 void FreeSound(void *ptr)
1169 {
1170   SoundInfo *sound = (SoundInfo *)ptr;
1171
1172   if (sound == NULL)
1173     return;
1174
1175   if (sound->data_ptr)
1176   {
1177     Mix_FreeChunk(sound->data_ptr);
1178   }
1179
1180   checked_free(sound->source_filename);
1181
1182   free(sound);
1183 }
1184
1185 void FreeMusic(void *ptr)
1186 {
1187   MusicInfo *music = (MusicInfo *)ptr;
1188
1189   if (music == NULL)
1190     return;
1191
1192   if (music->data_ptr)
1193   {
1194     if (music->type == MUS_TYPE_MOD)
1195       Mix_FreeMusic(music->data_ptr);
1196     else
1197       Mix_FreeChunk(music->data_ptr);
1198   }
1199
1200   free(music);
1201 }
1202
1203 static void FreeAllMusic_NoConf(void)
1204 {
1205   int i;
1206
1207   if (Music_NoConf == NULL)
1208     return;
1209
1210   for (i = 0; i < num_music_noconf; i++)
1211     FreeMusic(Music_NoConf[i]);
1212
1213   free(Music_NoConf);
1214
1215   Music_NoConf = NULL;
1216   num_music_noconf = 0;
1217 }
1218
1219 void FreeAllSounds(void)
1220 {
1221   FreeCustomArtworkLists(sound_info);
1222 }
1223
1224 void FreeAllMusic(void)
1225 {
1226   FreeCustomArtworkLists(music_info);
1227   FreeAllMusic_NoConf();
1228 }
1229
1230 // THE STUFF ABOVE IS ONLY USED BY THE MAIN PROCESS
1231 // ============================================================================