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