Ticket #122: sdl-mixer.patch

File sdl-mixer.patch, 21.5 KB (added by takkaria, 12 years ago)

Initial patch, still needs some cleanup (and ideally a new parser)

  • src/util.c

     
    13571357} 
    13581358 
    13591359 
     1360 
    13601361/* 
    13611362 * Hack -- Make a (relevant?) sound 
    13621363 */ 
     
    13651366        /* No sound */ 
    13661367        if (!use_sound) return; 
    13671368 
    1368         /* Make a sound (if allowed) */ 
    1369         Term_xtra(TERM_XTRA_SOUND, val); 
     1369        /* Make a noise */ 
     1370        if (sound_hook) 
     1371                sound_hook(val); 
    13701372} 
    13711373 
    13721374 
  • src/Makefile.std

     
    4545 
    4646 
    4747 
     48## Support SDL_mixer for sound 
     49#SOUND_sdl = -DSOUND_SDL $(shell sdl-config --cflags) $(shell sdl-config --libs) -lSDL_mixer 
     50 
     51 
     52 
    4853# Basic compiler stuff 
    4954CC = gcc 
    5055CFLAGS = -Wall -O2 -Wno-unused-parameter 
     
    7277 
    7378 
    7479# Extract CFLAGS and LIBS from the system definitions 
    75 MODULES = $(SYS_x11) $(SYS_gcu) $(SYS_xaw) $(SYS_gtk) $(SYS_sdl) 
     80MODULES = $(SYS_x11) $(SYS_gcu) $(SYS_xaw) $(SYS_gtk) $(SYS_sdl) $(SOUND_sdl) 
    7681CFLAGS += $(patsubst -l%,,$(MODULES)) $(INCLUDES) 
    7782LIBS += $(patsubst -D%,,$(patsubst -I%,, $(MODULES))) 
    7883 
     
    8893 
    8994# Object definitions 
    9095X11OBJS = maid-x11.o main-x11.o main-xaw.o main-gtk.o 
    91 MAINOBJS = main.o main-gcu.o main-sdl.o $(X11OBJS) 
     96MAINOBJS = main.o main-gcu.o main-sdl.o snd-sdl.o $(X11OBJS) 
    9297OBJS = $(BASEOBJS) $(MAINOBJS) 
    9398 
    9499 
  • src/main-xxx.c

     
    326326                        return (0); 
    327327                } 
    328328 
    329                 case TERM_XTRA_SOUND: 
    330                 { 
    331                         /* 
    332                          * Make a sound XXX XXX XXX 
    333                          * 
    334                          * This action should produce sound number "v", where the 
    335                          * "name" of that sound is "sound_names[v]".  This method 
    336                          * is still under construction. 
    337                          * 
    338                          * This action is optional, and not very important. 
    339                          */ 
    340  
    341                         return (0); 
    342                 } 
    343  
    344329                case TERM_XTRA_BORED: 
    345330                { 
    346331                        /* 
     
    708693} 
    709694 
    710695 
     696 
    711697/* 
     698 * Make a sound. 
     699 * 
     700 * This action should produce sound number "v", where the 
     701 * "name" of that sound is "sound_names[v]". 
     702 * 
     703 * This action is optional, and not very important. 
     704 */ 
     705static void xxx_sound(int v) 
     706{ 
     707        return; 
     708} 
     709 
     710 
     711/* 
    712712 * Init some stuff 
    713713 * 
    714714 * This function is used to keep the "path" variable off the stack. 
     
    725725 
    726726        /* Prepare the filepaths */ 
    727727        init_file_paths(path); 
     728 
     729 
     730#ifdef USE_SOUND 
     731 
     732        /* Set up sound hook */ 
     733        sound_hook = xxx_sound; 
     734 
     735#endif /* USE_SOUND */ 
    728736} 
    729737 
    730738 
  • src/z-term.h

     
    285285 * The "TERM_XTRA_EVENT" action uses "v" to "wait" for an event 
    286286 * The "TERM_XTRA_SHAPE" action uses "v" to "show" the cursor 
    287287 * The "TERM_XTRA_FROSH" action uses "v" for the index of the row 
    288  * The "TERM_XTRA_SOUND" action uses "v" for the index of a sound 
    289288 * The "TERM_XTRA_ALIVE" action uses "v" to "activate" (or "close") 
    290289 * The "TERM_XTRA_LEVEL" action uses "v" to "resume" (or "suspend") 
    291290 * The "TERM_XTRA_DELAY" action uses "v" as a "millisecond" value 
     
    299298#define TERM_XTRA_FROSH 5       /* Flush one row (optional) */ 
    300299#define TERM_XTRA_FRESH 6       /* Flush all rows (optional) */ 
    301300#define TERM_XTRA_NOISE 7       /* Make a noise (optional) */ 
    302 #define TERM_XTRA_SOUND 8       /* Make a sound (optional) */ 
    303301#define TERM_XTRA_BORED 9       /* Handle stuff when bored (optional) */ 
    304302#define TERM_XTRA_REACT 10      /* React to global changes (optional) */ 
    305303#define TERM_XTRA_ALIVE 11      /* Change the "hard" level (optional) */ 
  • src/variable.c

     
    848848 
    849849 
    850850/* 
     851 * Sound hook (for playing FX). 
     852 */ 
     853void (*sound_hook)(int sound); 
     854 
     855 
     856/* 
    851857 * For autoinscriptions. 
    852858 */ 
    853859autoinscription* inscriptions = 0; 
  • src/main-crb.c

     
    13011301 */ 
    13021302static SInt16 sound_volume = SOUND_VOLUME_MAX; 
    13031303 
     1304 
     1305 
    13041306/* 
    13051307 * QuickTime sound, by Ron Anderson 
    13061308 * 
     
    14081410 
    14091411        /* Stop QuickTime */ 
    14101412        ExitMovies(); 
     1413 
     1414        /* Register the sound hook */ 
     1415        sound_hook = play_sound; 
    14111416} 
    14121417 
    14131418/* 
     
    14891494 * time code) and provides a sort of cache for sound data. 
    14901495 * 
    14911496 * Globals referenced: channel_initialised, channels[], samples[], 
    1492  *   sample_refs[]. 
     1497 *   sample_refs[], sound_volume. 
    14931498 * Globals updated: channel_initialised, channels[], sample_refs[]. 
    14941499 */ 
    14951500 
    1496 static void play_sound(int num, SInt16 vol) 
     1501static void play_sound(int num) 
    14971502{ 
    14981503        OSErr err; 
    14991504        int prev_num; 
     
    15051510        static SInt16 channel_occupants[MAX_CHANNELS]; 
    15061511        static SndCommand volume_cmd, quiet_cmd; 
    15071512 
     1513        SInt16 vol = sound_volume; 
     1514 
    15081515        /* Initialise sound channels */ 
    15091516        if (!channel_initialised) 
    15101517        { 
     
    15941601        if (next_chan >= MAX_CHANNELS) next_chan = 0; 
    15951602} 
    15961603 
     1604 
     1605 
    15971606/*** Support for the "z-term.c" package ***/ 
    15981607 
    15991608/* 
     
    17151724                        return (0); 
    17161725                } 
    17171726 
    1718                 /* Make a sound */ 
    1719                 case TERM_XTRA_SOUND: 
    1720                 { 
    1721                         /* Play sound */ 
    1722                         play_sound(v, sound_volume); 
    1723  
    1724                         /* Success */ 
    1725                         return (0); 
    1726                 } 
    1727  
    17281727                /* Process random events */ 
    17291728                case TERM_XTRA_BORED: 
    17301729                { 
  • src/Makefile.src

     
    1212HEADERS = $(HDRS) $(INCS) 
    1313 
    1414ZFILES = z-file z-form z-rand z-term z-type z-util z-virt 
    15 MAINFILES = main maid-x11 \ 
    16         $(addprefix main-,crb gcu gtk ros sdl win x11 xaw) 
     15MAINFILES = main maid-x11 main-crb main-gcu main-gtk main-ros main-sdl \ 
     16            main-win main-x11 main-xaw snd-sdl 
    1717 
    1818ANGFILES = \ 
    1919        birth \ 
  • src/cmd3.c

     
    493493                        /* No */ 
    494494                        if (result == 0) 
    495495                                return; 
    496   
     496 
    497497                        /* Squelch */ 
    498498                        else if (result == 2) 
    499499                        { 
     
    616616                floor_item_describe(0 - item); 
    617617                floor_item_optimize(0 - item); 
    618618        } 
     619 
     620        /* We have destroyed a floor item, and the floor is not empty */ 
     621        if ((item < 0) && (cave_o_idx[p_ptr->py][p_ptr->px])) 
     622        { 
     623                /* Automatically repeat this command (unless disturbed) */ 
     624                p_ptr->command_cmd = 'k'; 
     625                p_ptr->command_rep = 2; 
     626        } 
    619627} 
    620628 
    621629 
  • 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#include <SDL/SDL.h> 
     25#include <SDL/SDL_mixer.h> 
     26 
     27 
     28/* enable sound FX */ 
     29static bool enable_sound = FALSE; 
     30 
     31/* Don't cache audio */ 
     32static bool no_cache_audio = FALSE; 
     33 
     34 
     35/* Maximum number of samples per event */ 
     36#define SAMPLE_MAX              8 
     37 
     38 
     39/* path to location of sound files */ 
     40static cptr ANGBAND_DIR_XTRA_SOUND; 
     41 
     42/* An array of sound file names */ 
     43static cptr sound_file[MSG_MAX][SAMPLE_MAX]; 
     44 
     45 
     46/*----------------------------------- 
     47 * Pinched from main-acn.c: 
     48 * 
     49 * The Lib/xtra/sound/sound.cfg file is used to map sample names onto 
     50 * event names. 
     51 * 
     52 * Since textual names are used in the .cfg file, we need to have a lookup 
     53 * table to translate them into numbers.  At present we use the 
     54 * angband_sound_name array defined in variable.c 
     55 * 
     56 * Since there can be multiple sounds for each event we need to use a 
     57 * list to store them. 
     58 * 
     59 */ 
     60 
     61/* Arbitary limit on sample names */ 
     62#define MAX_SAMPNAME_LEN 64 
     63 
     64/* Linked list representing a sample */ 
     65typedef struct samp_node 
     66{ 
     67        char sample_name[MAX_SAMPNAME_LEN+1]; /* Sample name */ 
     68        Mix_Chunk *sample_wav;                /* sample loaded by SDL */ 
     69        char *sample_path;                    /* full path of sample */ 
     70        struct samp_node *next;               /* -> next node */ 
     71} SampNode; 
     72 
     73typedef struct samp_info 
     74{ 
     75        int samples;         /* # samples for this event */ 
     76        SampNode *samplist;  /* list of sample names */ 
     77} SampInfo; 
     78 
     79 
     80/* 
     81 * Just need an array of SampInfos 
     82 */ 
     83static SampInfo sample[MSG_MAX]; 
     84 
     85 
     86/* 
     87 * Shut down the sound system and free resources. 
     88 */ 
     89static void close_audio(void) 
     90{ 
     91        size_t i; 
     92        SampNode *l; 
     93 
     94        /* Free all the samples */ 
     95        for (i = 0; i < MSG_MAX; i++) 
     96        { 
     97                /* Follow the linked list */ 
     98                for (l = sample[i].samplist; l; l = l->next) 
     99                { 
     100                        Mix_FreeChunk(l->sample_wav); 
     101                        l->sample_wav = NULL; 
     102                } 
     103 
     104        } 
     105 
     106        /* Deallocate the sample lists */ 
     107        for (i = 0; i < MSG_MAX; i++) 
     108        { 
     109                SampNode *si = sample[i].samplist; 
     110 
     111                sample[i].samples = 0; 
     112                sample[i].samplist = NULL; 
     113 
     114                while (si) 
     115                { 
     116                        SampNode *ns = si->next; 
     117                        FREE(si); 
     118                        si = ns; 
     119                } 
     120        } 
     121 
     122        /* Close the audio if requested */ 
     123        if (audio_enabled) 
     124                Mix_CloseAudio(); 
     125 
     126        /* XXX This may conflict with the SDL port */ 
     127        atexit(SDL_Quit); 
     128} 
     129 
     130 
     131/* 
     132 * Initialise SDL and open the mixer 
     133 */ 
     134static void open_audio(void) 
     135{ 
     136        int audio_rate; 
     137        Uint16 audio_format; 
     138        int audio_channels; 
     139         
     140        /* Initialize variables */ 
     141        audio_rate = 22050; 
     142        audio_format = AUDIO_S16; 
     143        audio_channels = 2; 
     144 
     145        /* Initialize the SDL library */ 
     146        if (SDL_Init(SDL_INIT_AUDIO) < 0) 
     147        { 
     148                plog_fmt("Couldn't initialize SDL: %s",SDL_GetError()); 
     149                return; 
     150        } 
     151 
     152        /* Try to open the audio */ 
     153        if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, 4096) < 0) 
     154        { 
     155                plog_fmt("Couldn't open mixer: %s", SDL_GetError()); 
     156 
     157                /* Disable audio */ 
     158                audio_enabled = FALSE; 
     159                close_audio(); 
     160 
     161                return; 
     162        } 
     163 
     164#ifdef DEBUG_SDL_SOUND 
     165        Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels); 
     166 
     167        plog_fmt("Opened audio at %d Hz %d bit %s", audio_rate, 
     168                (audio_format & 0xFF), (audio_channels > 1) ? "stereo" : "mono"); 
     169#endif /* DEBUG_SDL_SOUND */ 
     170} 
     171 
     172 
     173 
     174 
     175/* 
     176 * Read sound.cfg and map events to sounds; then load all the sounds into 
     177 * memory to avoid I/O latency later. 
     178 */ 
     179errr load_sound_prefs(bool no_cache) 
     180{ 
     181        char path[1024]; 
     182        char filename[1024]; 
     183        char buffer[2048]; 
     184        char wav_path[2048]; 
     185        int i; 
     186        int max_sampname_len = MAX_SAMPNAME_LEN;         
     187        FILE *sound_cfg; 
     188        Mix_Chunk *wave = NULL;          
     189 
     190        /* Build the "sound" path */ 
     191        path_build(path, 1024, ANGBAND_DIR_XTRA, "sound"); 
     192        ANGBAND_DIR_XTRA_SOUND = string_make(path); 
     193 
     194        /* Find the config file */ 
     195        path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA_SOUND, "sound.cfg"); 
     196 
     197#ifdef DEBUG_SDL_SOUND 
     198        plog_fmt("trying sound config '%s'", filename);          
     199#endif  /* DEBUG_SDL_SOUND */ 
     200 
     201 
     202        /* See if the file exists; if not, bail */ 
     203        if (!my_fexists(filename)) 
     204                return 0; 
     205 
     206        /* Use sound */ 
     207        use_sound = FALSE; 
     208 
     209         
     210        /* Read in the config file: */   
     211        sound_cfg = my_fopen(filename, "r"); 
     212 
     213        /* Handle errors */ 
     214        if (!sound_cfg) 
     215        { 
     216                plog_fmt("Failed to open sound config (%s):\n    %s",  
     217                          filename, strerror(errno)); 
     218                return 0; 
     219        } 
     220 
     221        /* Initialise the sample array */ 
     222        for (i = 0; i < MSG_MAX; i++) 
     223        { 
     224                sample[i].samples = 0; 
     225                sample[i].samplist = NULL; 
     226        } 
     227 
     228 
     229        /* Init the mixer now */ 
     230        open_audio(); 
     231 
     232        /* Parse the file */ 
     233        while (my_fgets(buffer, sizeof(buffer), sound_cfg )) 
     234        { 
     235                char *sample_name; 
     236                char *first_space; 
     237                int event_number; 
     238                 
     239                /* Skip comments and lines that begin with whitespace */ 
     240                if (buffer[0] == '#' || isspace(buffer[0])) continue; 
     241 
     242                /* Hack: skip any line beginning '[' (section marker) */ 
     243                if (buffer[0] == '[' ) continue; 
     244 
     245        /* Place a NULL after the event name and find the first sample name */ 
     246        sample_name = buffer; 
     247        while ( *sample_name && !isspace(*sample_name) ) 
     248            sample_name++; 
     249 
     250        /* Bad line? */ 
     251        if ( *sample_name == 0 ) { continue; }      /* just ignore it */ 
     252 
     253        /* Terminate the sample name */ 
     254        *sample_name++ = 0; 
     255 
     256        /* Look up the event name to get the event number */ 
     257        for ( event_number=MSG_MAX-1; event_number>=0; event_number-- ) 
     258            if ( !strcmp(buffer,angband_sound_name[event_number]) ) 
     259                break; 
     260 
     261        /* No match -> just ignore the line */ 
     262 
     263        if ( event_number<0 ) 
     264        { 
     265            plog_fmt("** Ignoring unknown sound event '%s'",buffer); 
     266            continue; 
     267        } 
     268 
     269        /* Find the = */ 
     270        while ( *sample_name && *sample_name != '=' ) 
     271            sample_name++; 
     272 
     273        /* Bad line? */ 
     274        if ( *sample_name == 0 ) { continue; }  /* just ignore it */ 
     275 
     276        /* Skip the '=' */ 
     277        sample_name++; 
     278 
     279 
     280        /* 
     281         * Now we find all the sample names and add them to the 
     282         * appropriate list in the sample mapping array 
     283         */ 
     284        while ( *sample_name ) 
     285        { 
     286            char *s; 
     287            SampNode *sn; 
     288 
     289            /* Find the start of the next word */ 
     290            while ( isspace(*sample_name) && *sample_name ) 
     291                sample_name++; 
     292 
     293            /* End of line? */ 
     294            if ( !*sample_name ) { break; } 
     295 
     296                        /* Find the end of the sample name */ 
     297                        s = sample_name;                                        /* start of the name */ 
     298                        while ( ! isspace(*sample_name) && *sample_name ) 
     299                                sample_name++; 
     300 
     301                        /* Allocate a node in the sample list for the event */ 
     302                        sn = ralloc(sizeof(SampNode)) 
     303 
     304                        /* Link the node to the list */ 
     305                        sn->next = sample[event_number].samplist; 
     306                        sample[event_number].samplist = sn; 
     307 
     308                        /* Imcrement the sample count for that event */ 
     309                        sample[event_number].samples++; 
     310 
     311                        for (i = 0; !isspace(s[i]) && s[i]; i++) 
     312                                sn->sample_name[i] = s[i]; 
     313 
     314 
     315                        /* 
     316                         * The sample name '*' is special and means "no new sound" 
     317                         * so don't store a filename for these mappings. 
     318                         */ 
     319                        if (i == 1 && sn->sample_name[0] == '*') 
     320                                i = 0; 
     321 
     322                        sn->sample_name[i] = 0; 
     323 
     324                        /* Build the path to the sample */ 
     325                        path_build(wav_path, sizeof(wav_path), ANGBAND_DIR_XTRA_SOUND, sn->sample_name); 
     326 
     327                        /* Make sure the nominated .wav file actually exists */ 
     328                        if (!my_fexists(wav_path)) 
     329                        { 
     330                            plog_fmt("** Ignoring sample '%s' (file not found)", sn->sample_name); 
     331                                continue; 
     332                        } 
     333 
     334                        sn->sample_path = wav_path; 
     335 
     336#ifdef DEBUG_SDL_SOUND 
     337                        plog_fmt("sound.cfg load: sample_path is '%s'", sn->sample_path); 
     338#endif  /* DEBUG_SDL_SOUND */ 
     339 
     340                        if (!no_cache) 
     341                        { 
     342                                /* load the .wav immediately via SDL mixer */ 
     343                                sn->sample_wav = Mix_LoadWAV(sn->sample_path); 
     344 
     345                                if (!sn->sample_wav) 
     346                                        plog_fmt("%s: %s", SDL_GetError(), strerror(errno)); 
     347                        } 
     348                } 
     349        } 
     350 
     351        /* Close the file */ 
     352        my_fclose(sound_cfg); 
     353 
     354#ifdef DEBUG_SDL_SOUND 
     355 
     356        { 
     357 
     358        /* Dump the event -> sample map for debugging: */ 
     359        int idx; 
     360        SampNode *l; 
     361         
     362        for (idx = 0; i < MSG_MAX; idx++) 
     363        { 
     364                plog_fmt("Event '%s' (%d sounds)", angband_sound_name[idx], sample[idx].samples); 
     365                 
     366                for (l = sample[idx].samplist; l; l=l->next) 
     367                        plog_fmt("\t%s", l->sample_name); 
     368        } 
     369 
     370        } 
     371 
     372#endif /* DEBUG_SDL_SOUND */ 
     373 
     374        return 1; 
     375} 
     376 
     377/* 
     378 * Play a sound of type "event". 
     379 */ 
     380void play_sound(int event) 
     381{ 
     382        char wav_path[2048]; 
     383        Mix_Chunk *wave = NULL; 
     384        int s; 
     385        SampNode *sn; 
     386         
     387        /* Paranoia */ 
     388        /* XXX Horrible! */ 
     389        if (!use_sound || !sound_enabled) 
     390                return; 
     391 
     392        /* Paranoia */ 
     393        if (event < 0 || event >= MSG_MAX) 
     394                return; 
     395 
     396        /* Check there are samples for this event */ 
     397        if (!sample[event].samples) 
     398                return; 
     399 
     400        /* Choose a random event */ 
     401        s = rand_int(sample[event].samples); 
     402        sn = sample[event].samplist; 
     403        while (s--) 
     404                sn = sn->next; 
     405 
     406        /* First try an already-lodead copy */ 
     407        wave = sn->sample_wav; 
     408 
     409        /* Assume it wasn't cached and try loading it */ 
     410        if (!wave) 
     411        { 
     412                /* Build and verify */ 
     413                path_build(wav_path, sizeof(wav_path), ANGBAND_DIR_XTRA_SOUND, sn->sample_name); 
     414                if (!my_fexists(wav_path)) 
     415                        return; 
     416 
     417                /* Load */ 
     418                wave = Mix_LoadWAV(wav_path); 
     419        } 
     420 
     421        /* Check to see if we have a wave again */ 
     422        if (!wave) 
     423        { 
     424                plog("SDL sound load failed."); 
     425                return; 
     426        } 
     427 
     428        /* Actually play the thing */ 
     429        Mix_PlayChannel(-1, wave, 0); 
     430} 
     431 
     432 
     433/* 
     434 * Init the SDL sound "module". 
     435 */ 
     436errr init_sound_sdl(int argc, char **argv) 
     437{ 
     438        int i; 
     439 
     440        /* Parse args */ 
     441        for (i = 1; i < argc; i++) 
     442        { 
     443                if (prefix(argv[i], "-c")) 
     444                { 
     445                        no_cache_audio = TRUE; 
     446                        plog("Audio cache disabled."); 
     447                        continue; 
     448                } 
     449        } 
     450 
     451        /* Load sound preferences if requested */ 
     452        if (!load_sound_prefs(no_cache_audio)) 
     453        { 
     454                plog("Failed to load sound config"); 
     455 
     456                /* Failure */ 
     457                return (1); 
     458        } 
     459 
     460        /* Enable sound */ 
     461        enable_sound = TRUE; 
     462        sound_hook = play_sound; 
     463 
     464        /* Success */ 
     465        return (0); 
     466} 
     467 
     468 
     469#endif /* SOUND_SDL */ 
  • src/main-win.c

     
    21112111                        return (Term_xtra_win_noise()); 
    21122112                } 
    21132113 
    2114                 /* Make a special sound */ 
    2115                 case TERM_XTRA_SOUND: 
    2116                 { 
    2117                         return (Term_xtra_win_sound(v)); 
    2118                 } 
    2119  
    21202114                /* Process random events */ 
    21212115                case TERM_XTRA_BORED: 
    21222116                { 
     
    51005094        } 
    51015095#endif /* USE_SAVER */ 
    51025096 
     5097#if USE_SOUND 
     5098 
     5099        /* Set the sound hook */ 
     5100        sound_hook = Term_xtra_win_sound(v); 
     5101 
     5102#endif /* USE_SOUND */ 
     5103 
    51035104        /* Did the user double click on a save file? */ 
    51045105        check_for_save_file(lpCmdLine); 
    51055106 
  • src/main.c

     
    5151}; 
    5252 
    5353 
     54#ifdef USE_SOUND 
     55 
    5456/* 
     57 * List of sound modules in the order they should be tried. 
     58 */ 
     59static const struct module sound_modules[] = 
     60{ 
     61#ifdef SDL_SOUND 
     62        { "sdl", "SDL_mixer sound module", init_sound_sdl }, 
     63#endif /* SDL_SOUND */ 
     64 
     65        { "dummy", "Dummy module", NULL }, 
     66}; 
     67 
     68#endif 
     69 
     70 
     71/* 
    5572 * A hook for "quit()". 
    5673 * 
    5774 * Close down, then fall back into "quit()". 
     
    436453                                /* Dump usage information */ 
    437454                                puts("Usage: angband [options] [-- subopts]"); 
    438455                                puts("  -n       Start a new character"); 
     456                                puts("  -w       Resurrect dead character"); 
    439457                                puts("  -f       Request fiddle (verbose) mode"); 
    440                                 puts("  -w       Request wizard mode"); 
    441458                                puts("  -v       Request sound mode"); 
    442459                                puts("  -g       Request graphics mode"); 
    443460                                puts("  -o       Request original keyset (default)"); 
     
    494511        /* Make sure we have a display! */ 
    495512        if (!done) quit("Unable to prepare any 'display module'!"); 
    496513 
     514 
     515#ifdef USE_SOUND 
     516 
     517        /* Turn on sound support */ 
     518        if (arg_sound) 
     519        { 
     520                /* Try the modules in the order specified by sound_modules[] */ 
     521                for (i = 0; i < (int)N_ELEMENTS(sound_modules) - 1; i++) 
     522                { 
     523                        if (0 == sound_modules[i].init(argc, argv)) 
     524                                break; 
     525                } 
     526        } 
     527 
     528#endif 
     529 
     530 
    497531        /* Catch nasty signals */ 
    498532        signals_init(); 
    499533 
  • src/main-ros.c

     
    35123512                        return 0; 
    35133513                } 
    35143514 
    3515                 /* Play a sound :) */ 
    3516                 case TERM_XTRA_SOUND: 
    3517                 { 
    3518                         if (enable_sound) play_sound(v); 
    3519  
    3520                         return 0; 
    3521                 } 
    3522  
    35233515/* 
    35243516 * This is used by ToME2, and presumably will never be picked up by other 
    35253517 * variants, so it should be safe to #ifdef out like so: 
     
    70777069 
    70787070 
    70797071 
    7080  
    70817072static void initialise_sound(void) 
    70827073{ 
    70837074        /* Load the configuration file */ 
    70847075        Hourglass_On(); 
    70857076        read_sound_config(); 
    70867077        check_playit(); 
     7078 
     7079        /* Set the sound hook */ 
     7080        sound_hook = play_sound; 
     7081 
    70877082        Hourglass_Off(); 
    70887083} 
    70897084 
     
    71107105static void play_sound(int event) 
    71117106{ 
    71127107        /* Paranoia */ 
    7113         if (!sound_initd) 
    7114         { 
     7108        if (!sound_initd || !enable_sound) 
    71157109                return; 
    7116         } 
    71177110 
    71187111        /* Paranoia */ 
    71197112        if (event < 0 || event >= SOUND_MAX) 
  • src/main.h

     
    1313 
    1414#include "angband.h" 
    1515 
     16extern errr init_sound_sdl(int argc, char **argv); 
     17 
     18 
    1619extern errr init_lfb(int argc, char **argv); 
    1720extern errr init_gtk(int argc, char **argv); 
    1821extern errr init_xaw(int argc, char **argv); 
  • src/externs.h

     
    247247extern int text_out_wrap; 
    248248extern int text_out_indent; 
    249249extern bool use_transparency; 
     250extern void (*sound_hook)(int); 
    250251extern autoinscription *inscriptions; 
    251252extern u16b inscriptions_count; 
    252253 
  • configure.ac

     
    8686        [enable_sdl=$enableval], 
    8787        [enable_sdl=no]) 
    8888 
     89dnl Sound modules 
     90AC_ARG_ENABLE(sdl_mixer, 
     91        [  --disable-sdl-mixer                  Disables SDL mixer sound support], 
     92        [disable_sdl_mixer=$disable_sdl_mixer], 
     93        [disable_sdl_mixer=no]) 
     94 
     95 
    8996dnl curses checking 
    9097if test "$enable_curses" = "yes"; then 
    9198        AC_CHECK_LIB(curses  , initscr, found_curses=yes,found_curses=no) 
     
    168175        fi 
    169176fi 
    170177 
     178dnl SDL mixer checking 
     179 
     180if test "$disable_sdl_mixer" != "yes"; then 
     181        AC_CHECK_LIB(SDL_mixer, Mix_OpenAudio, found_sdl_mixer=yes, found_sdl_mixer=no) 
     182 
     183        if test "$found_sdl_mixer" = "yes"; then 
     184                AC_DEFINE(SDL_SOUND, 1, [Enabled SDL_mixer sound support]) 
     185                LDFLAGS="${LDFLAGS} -lSDL_mixer" 
     186        else 
     187                AC_DEFINE(SDL_SOUND, 0, [Disabled SDL_mixer sound support]) 
     188        fi 
     189fi 
     190 
     191 
    171192dnl Check for headers. 
    172193dnl AC_HEADER_STDBOOL -- not yet 
    173194AC_HEADER_TIME