src/snd-sdl.c

   1 /*
   2  * File: snd-sdl.c
   3  * Purpose: SDL sound support
   4  *
   5  * Copyright (c) 2004-2007 Brendon Oliver, Andrew Sidwell.
   6  * A large chunk of this file was taken and modified from main-ros.
   7  *
   8  * This work is free software; you can redistribute it and/or modify it
   9  * under the terms of either:
  10  *
  11  * a) the GNU General Public License as published by the Free Software
  12  *    Foundation, version 2, or
  13  *
  14  * b) the "Angband licence":
  15  *    This software may be copied and distributed for educational, research,
  16  *    and not for profit purposes provided that this copyright and statement
  17  *    are included in all such copies.  Other copyrights may also apply.
  18  */
  19 #include "angband.h"
  20
  21
  22 #ifdef SOUND_SDL
  23
  24
  25 #include "SDL.h"
  26 #include "SDL_mixer.h"
  27
  28
  29 /* Don't cache audio */
  30 static bool no_cache_audio = FALSE;
  31
  32 /* Path to sound files */
  33 static const char *ANGBAND_DIR_XTRA_SOUND;
  34
  35
  36
  37 /* Arbitary limit on number of samples per event */
  38 #define MAX_SAMPLES      8
  39
  40 /* Struct representing all data about an event sample */
  41 typedef struct
  42 {
  43         int num;                        /* Number of samples for this event */
  44         Mix_Chunk *wavs[MAX_SAMPLES];   /* Sample array */
  45         const char *paths[MAX_SAMPLES]; /* Relative pathnames for samples */
  46 } sample_list;
  47
  48
  49 /*
  50  * Just need an array of SampInfos
  51  */
  52 static sample_list samples[MSG_MAX];
  53
  54
  55 /*
  56  * Shut down the sound system and free resources.
  57  */
  58 static void close_audio(void)
  59 {
  60         size_t i;
  61         int j;
  62
  63         /* Free all the sample data*/
  64         for (i = 0; i < MSG_MAX; i++)
  65         {
  66                 sample_list *smp = &samples[i];
  67
  68                 /* Nuke all samples */
  69                 for (j = 0; j < smp->num; j++)
  70                 {
  71                         Mix_FreeChunk(smp->wavs[j]);
  72                         string_free(smp->paths[j]);
  73                 }
  74         }
  75
  76         /* Close the audio */
  77         Mix_CloseAudio();
  78
  79         /* XXX This may conflict with the SDL port */
  80         SDL_Quit();
  81 }
  82
  83
  84 /*
  85  * Initialise SDL and open the mixer
  86  */
  87 static bool open_audio(void)
  88 {
  89         int audio_rate;
  90         Uint16 audio_format;
  91         int audio_channels;
  92
  93         /* Initialize variables */
  94         audio_rate = 22050;
  95         audio_format = AUDIO_S16;
  96         audio_channels = 2;
  97
  98         /* Initialize the SDL library */
  99         if (SDL_Init(SDL_INIT_AUDIO) < 0)
 100         {
 101                 plog_fmt("Couldn't initialize SDL: %s", SDL_GetError());
 102                 return FALSE;
 103         }
 104
 105         /* Try to open the audio */
 106         if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, 4096) < 0)
 107         {
 108                 plog_fmt("Couldn't open mixer: %s", SDL_GetError());
 109                 return FALSE;
 110         }
 111
 112         /* Success */
 113         return TRUE;
 114 }
 115
 116
 117
 118 /*
 119  * Read sound.cfg and map events to sounds; then load all the sounds into
 120  * memory to avoid I/O latency later.
 121  */
 122 static bool sound_sdl_init(bool no_cache)
 123 {
 124         char path[2048];
 125         char buffer[2048];
 126         FILE *fff;
 127
 128
 129         /* Initialise the mixer  */
 130         if (!open_audio())
 131             return FALSE;
 132
 133
 134         /* Build the "sound" path */
 135         path_build(path, sizeof(path), ANGBAND_DIR_XTRA, "sound");
 136         ANGBAND_DIR_XTRA_SOUND = string_make(path);
 137
 138         /* Find and open the config file */
 139         path_build(path, sizeof(path), ANGBAND_DIR_XTRA_SOUND, "sound.cfg");
 140         fff = my_fopen(path, "r");
 141
 142         /* Handle errors */
 143         if (!fff)
 144         {
 145                 plog_fmt("Failed to open sound config (%s):\n    %s",
 146                           path, strerror(errno));
 147                 return FALSE;
 148         }
 149
 150         /* Parse the file */
 151         /* Lines are always of the form "name = sample [sample ...]" */
 152         while (my_fgets(fff, buffer, sizeof(buffer)) == 0)
 153         {
 154                 char *msg_name;
 155                 char *sample_list;
 156                 char *search;
 157                 char *cur_token;
 158                 char *next_token;
 159                 int event;
 160
 161                 /* Skip anything not beginning with an alphabetic character */
 162                 if (!buffer[0] || !isalpha((unsigned char)buffer[0])) continue;
 163
 164                 /* Split the line into two: message name, and the rest */
 165                 search = strchr(buffer, ' ');
 166         sample_list = strchr(search + 1, ' ');
 167                 if (!search) continue;
 168         if (!sample_list) continue;
 169
 170                 /* Set the message name, and terminate at first space */
 171                 msg_name = buffer;
 172                 search[0] = '\0';
 173
 174
 175                 /* Make sure this is a valid event name */
 176                 for (event = MSG_MAX - 1; event >= 0; event--)
 177                 {
 178                         if (strcmp(msg_name, angband_sound_name[event]) == 0)
 179                             break;
 180                 }
 181         if (event < 0) continue;
 182
 183                 /* Advance the sample list pointer so it's at the beginning of text */
 184                 sample_list++;
 185                 if (!sample_list[0]) continue;
 186
 187                 /* Terminate the current token */
 188                 cur_token = sample_list;
 189                 search = strchr(cur_token, ' ');
 190                 if (search)
 191                 {
 192                         search[0] = '\0';
 193                         next_token = search + 1;
 194                 }
 195                 else
 196                 {
 197                         next_token = NULL;
 198                 }
 199
 200         /*
 201          * Now we find all the sample names and add them one by one
 202          */
 203         while (cur_token)
 204         {
 205             int num = samples[event].num;
 206
 207                         /* Don't allow too many samples */
 208                         if (num >= MAX_SAMPLES) break;
 209
 210                         /* Build the path to the sample */
 211                         path_build(path, sizeof(path), ANGBAND_DIR_XTRA_SOUND, cur_token);
 212                         if (!my_fexists(path)) goto next_token;
 213
 214                         /* Don't load now if we're not caching */
 215                         if (no_cache)
 216                         {
 217                                 /* Just save the path for later */
 218                                 samples[event].paths[num] = string_make(path);
 219                         }
 220                         else
 221                         {
 222                                 /* Load the file now */
 223                                 samples[event].wavs[num] = Mix_LoadWAV(path);
 224                                 if (!samples[event].wavs[num])
 225                                 {
 226                                         plog_fmt("%s: %s", SDL_GetError(), strerror(errno));
 227                                         goto next_token;
 228                                 }
 229                         }
 230
 231                         /* Imcrement the sample count */
 232                         samples[event].num++;
 233
 234                 next_token:
 235
 236                         /* Figure out next token */
 237                         cur_token = next_token;
 238                         if (next_token)
 239                         {
 240                                 /* Try to find a space */
 241                                 search = strchr(cur_token, ' ');
 242
 243                                 /* If we can find one, terminate, and set new "next" */
 244                                 if (search)
 245                                 {
 246                                         search[0] = '\0';
 247                                         next_token = search + 1;
 248                                 }
 249                                 else
 250                                 {
 251                                         /* Otherwise prevent infinite looping */
 252                                         next_token = NULL;
 253                                 }
 254                         }
 255                 }
 256         }
 257
 258         /* Close the file */
 259         my_fclose(fff);
 260
 261
 262         /* Success */
 263         return TRUE;
 264 }
 265
 266 /*
 267  * Play a sound of type "event".
 268  */
 269 static void play_sound(int event)
 270 {
 271         Mix_Chunk *wave = NULL;
 272         int s;
 273
 274         /* Paranoia */
 275         if (event < 0 || event >= MSG_MAX) return;
 276
 277         /* Check there are samples for this event */
 278         if (!samples[event].num) return;
 279
 280         /* Choose a random event */
 281         s = rand_int(samples[event].num);
 282         wave = samples[event].wavs[s];
 283
 284         /* Try loading it, if it's not cached */
 285         if (!wave)
 286         {
 287                 /* Verify it exists */
 288                 const char *filename = samples[event].paths[s];
 289                 if (!my_fexists(filename)) return;
 290
 291                 /* Load */
 292                 wave = Mix_LoadWAV(filename);
 293         }
 294
 295         /* Check to see if we have a wave again */
 296         if (!wave)
 297         {
 298                 plog("SDL sound load failed.");
 299                 return;
 300         }
 301
 302         /* Actually play the thing */
 303         Mix_PlayChannel(-1, wave, 0);
 304 }
 305
 306
 307 /*
 308  * Init the SDL sound "module".
 309  */
 310 errr init_sound_sdl(int argc, char **argv)
 311 {
 312         int i;
 313
 314         /* Parse args */
 315         for (i = 1; i < argc; i++)
 316         {
 317                 if (prefix(argv[i], "-c"))
 318                 {
 319                         no_cache_audio = TRUE;
 320                         plog("Audio cache disabled.");
 321                         continue;
 322                 }
 323         }
 324
 325         /* Load sound preferences if requested */
 326         if (!sound_sdl_init(no_cache_audio))
 327         {
 328                 plog("Failed to load sound config");
 329
 330                 /* Failure */
 331                 return (1);
 332         }
 333
 334         /* Enable sound */
 335         sound_hook = play_sound;
 336         atexit(close_audio);
 337
 338         /* Success */
 339         return (0);
 340 }
 341
 342
 343 #endif /* SOUND_SDL */