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