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