src/sound/sound.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Sound/Sound.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * Low-level sound code
  16  *
  17  * $Log$
  18  * Revision 1.10  2005/03/29 02:18:47  taylor
  19  * Various 64-bit platform fixes
  20  * Fix compiler errors with MAKE_FS1 and fix gr_set_bitmap() too
  21  * Make sure that turrets can fire at asteroids for FS1 (needed for a couple missions)
  22  * Streaming audio support (big thanks to Pierre Willenbrock!!)
  23  * Removed dependance on strings.tbl for FS1 since we don't actually need it now
  24  *
  25  * Revision 1.9  2002/06/22 16:34:40  relnev
  26  * removed file
  27  *
  28  * Revision 1.8  2002/06/17 06:33:11  relnev
  29  * ryan's struct patch for gcc 2.95
  30  *
  31  * Revision 1.7  2002/06/09 04:41:27  relnev
  32  * added copyright header
  33  *
  34  * Revision 1.6  2002/06/05 08:05:29  relnev
  35  * stub/warning removal.
  36  *
  37  * reworked the sound code.
  38  *
  39  * Revision 1.5  2002/06/02 21:11:12  cemason
  40  * Few changes
  41  *
  42  * Revision 1.4  2002/05/27 01:06:01  theoddone33
  43  * sound.cpp works
  44  *
  45  * Revision 1.3  2002/05/27 00:40:47  theoddone33
  46  * Fix net_addr vs net_addr_t
  47  *
  48  * Revision 1.2  2002/05/07 03:16:52  theoddone33
  49  * The Great Newline Fix
  50  *
  51  * Revision 1.1.1.1  2002/05/03 03:28:10  root
  52  * Initial import.
  53  *
  54  *
  55  * 9     9/12/99 8:09p Dave
  56  * Fixed problem where skip-training button would cause mission messages
  57  * not to get paged out for the current mission.
  58  *
  59  * 8     8/27/99 6:38p Alanl
  60  * crush the blasted repeating messages bug
  61  *
  62  * 7     8/22/99 11:06p Alanl
  63  * don't convert priority in snd_play_3d
  64  *
  65  * 6     8/04/99 9:48p Alanl
  66  * fix bug with setting 3D properties on a 2D sound buffer
  67  *
  68  * 5     6/18/99 5:16p Dave
  69  * Added real beam weapon lighting. Fixed beam weapon sounds. Added MOTD
  70  * dialog to PXO screen.
  71  *
  72  * 4     5/23/99 8:11p Alanl
  73  * Added support for EAX
  74  *
  75  * 3     1/29/99 12:47a Dave
  76  * Put in sounds for beam weapon. A bunch of interface screens (tech
  77  * database stuff).
  78  *
  79  * 2     10/07/98 10:54a Dave
  80  * Initial checkin.
  81  *
  82  * 1     10/07/98 10:51a Dave
  83  *
  84  * 77    6/13/98 6:02p Hoffoss
  85  * Externalized all new (or forgot to be added) strings to all the code.
  86  *
  87  * 76    5/23/98 9:27p Lawrance
  88  * Change ACM failure message to use a message box, not a Warning()
  89  *
  90  * 75    5/15/98 3:36p John
  91  * Fixed bug with new graphics window code and standalone server.  Made
  92  * hwndApp not be a global anymore.
  93  *
  94  * 74    5/12/98 5:39p Lawrance
  95  * Increase MAX_SOUNDS to 175.. to account for missions with lots of voice
  96  *
  97  * 73    5/12/98 2:43p Lawrance
  98  * Make snd_time_remaining() work for arbitrary format
  99  *
 100  * 72    5/11/98 2:02p Andsager
 101  * doh!
 102  *
 103  * 71    5/11/98 1:56p Andsager
 104  * increase min_range in snd_play_3d when range_factor is not 1.0
 105  *
 106  * 70    5/10/98 3:49p Sandeep
 107  * Fix problem with having the audio streaming while trying to close down
 108  * sound
 109  *
 110  * 69    5/09/98 10:48p Lawrance
 111  * Default voice volume to 0.7
 112  *
 113  * 68    5/05/98 4:49p Lawrance
 114  * Put in code to authenticate A3D, improve A3D support
 115  *
 116  * 67    4/25/98 12:01p Lawrance
 117  * try to init sound for 5 seconds... to overcome conflicts with launch
 118  * app sounds
 119  *
 120  * 66    4/20/98 12:03a Lawrance
 121  * Allow prioritizing of CTRL3D buffers
 122  *
 123  * 65    4/19/98 9:30p Lawrance
 124  * Use Aureal_enabled flag
 125  *
 126  * 64    4/18/98 9:12p Lawrance
 127  * Added Aureal support.
 128  *
 129  * 63    4/14/98 3:29p John
 130  * took out mprintf
 131  *
 132  * 62    4/13/98 5:04p Lawrance
 133  * Write functions to determine how many milliseconds are left in a sound
 134  *
 135  * 61    4/09/98 5:53p Lawrance
 136  * Make DirectSound init more robust
 137  *
 138  * 60    4/01/98 9:21p John
 139  * Made NDEBUG, optimized build with no warnings or errors.
 140  *
 141  * 59    3/29/98 12:56a Lawrance
 142  * preload the warp in and explosions sounds before a mission.
 143  *
 144  * 58    3/25/98 6:10p Lawrance
 145  * Work on DirectSound3D
 146  *
 147  * 57    3/24/98 4:28p Lawrance
 148  * Make DirectSound3D support more robust
 149  *
 150  * 56    3/23/98 10:32a Lawrance
 151  * Add functions for extracting raw sound data
 152  *
 153  * 55    3/21/98 3:34p Lawrance
 154  * Allow 3d sounds to have their ranges modified dynamically
 155  *
 156  * 54    3/19/98 5:36p Lawrance
 157  * Add some sound debug functions to see how many sounds are playing, and
 158  * to start/stop random looping sounds.
 159  *
 160  * 53    3/17/98 5:55p Lawrance
 161  * Support object-linked sounds for asteroids.
 162  *
 163  * 52    2/20/98 8:32p Lawrance
 164  * Add radius parm to sound_play_3d()
 165  *
 166  * 51    2/18/98 5:49p Lawrance
 167  * Even if the ADPCM codec is unavailable, allow game to continue.
 168  *
 169  * 50    2/15/98 4:43p Lawrance
 170  * work on real-time voice
 171  *
 172  * 49    2/06/98 7:30p John
 173  * Added code to monitor the number of channels of sound actually playing.
 174  *
 175  * 48    2/05/98 9:21p John
 176  * Some new Direct3D code.   Added code to monitor a ton of stuff in the
 177  * game.
 178  *
 179  * 47    1/31/98 5:57p Lawrance
 180  * remove debug code that was stopping any sounds from playing
 181  *
 182  * 46    1/31/98 5:48p Lawrance
 183  * Start on real-time voice recording
 184  *
 185  * 45    1/19/98 11:37p Lawrance
 186  * Fixing Optimization build warnings
 187  *
 188  * 44    1/13/98 5:36p Lawrance
 189  * Reduce default sound volume to 0.9.
 190  *
 191  * 43    1/11/98 11:14p Lawrance
 192  * Preload sounds that we expect will get played.
 193  *
 194  * 42    1/10/98 1:14p John
 195  * Added explanation to debug console commands
 196  *
 197  * 41    1/07/98 11:08a Lawrance
 198  * pass priority to snd_play_raw()
 199  *
 200  * 40    12/21/97 4:33p John
 201  * Made debug console functions a class that registers itself
 202  * automatically, so you don't need to add the function to
 203  * debugfunctions.cpp.
 204  *
 205  * 39    12/05/97 5:19p Lawrance
 206  * re-do sound priorities to make more general and extensible
 207  *
 208  * 38    12/04/97 10:21a Lawrance
 209  * if a 3D sound has priority, only play if above a minimum volume level
 210  *
 211  * 37    11/20/97 5:36p Dave
 212  * Hooked in a bunch of main hall changes (including sound). Made it
 213  * possible to reposition (rewind/ffwd)
 214  * sound buffer pointers. Fixed animation direction change framerate
 215  * problem.
 216  *
 217  * 36    11/20/97 1:06a Lawrance
 218  * Add Master_voice_volume, make voices play back at correctly scaled
 219  * volumes
 220  *
 221  * 35    11/12/97 4:40p Dave
 222  * Put in multiplayer campaign support parsing, loading and saving. Made
 223  * command-line variables better named. Changed some things on the initial
 224  * pilot select screen.
 225  *
 226  * 34    10/14/97 11:33p Lawrance
 227  * get RSX implemented
 228  *
 229  * 33    10/13/97 7:41p Lawrance
 230  * store duration of sound
 231  *
 232  * 32    10/06/97 4:12p Lawrance
 233  * fix volume bug with 3d sounds
 234  *
 235  * 31    10/01/97 5:55p Lawrance
 236  * change call to snd_play_3d() to allow for arbitrary listening position
 237  *
 238  * 30    9/09/97 3:39p Sandeep
 239  * warning level 4 bugs
 240  *
 241  * 29    9/03/97 5:03p Lawrance
 242  * add support for -nosound command line parm
 243  *
 244  * 28    7/31/97 11:16a Dan
 245  * Add some Asserts() to check validity of vectors send to DirectSound3D
 246  *
 247  * 27    7/28/97 11:39a Lawrance
 248  * allow individual volume scaling on 3D buffers
 249  *
 250  * 26    7/17/97 9:53a Lawrance
 251  * if a sound is supposed to use DirectSound3D, ensure it does when
 252  * reloading it
 253  *
 254  * 25    7/17/97 9:32a John
 255  * made all directX header files name start with a v
 256  *
 257  * 24    7/15/97 11:15a Lawrance
 258  * limit the max instances of simultaneous sound effects, implement
 259  * priorities to force critical sounds
 260  *
 261  * 23    7/13/97 5:52p Lawrance
 262  * allow snd_set_volume() to set volume at any level
 263  *
 264  * 22    6/13/97 4:44p Lawrance
 265  * added another sound hook in ship selection
 266  *
 267  * 21    6/09/97 11:50p Lawrance
 268  * integrating DirectSound3D
 269  *
 270  * 20    6/05/97 11:25a Lawrance
 271  * use sound signatures to ensure correct sound is loaded
 272  *
 273  * 19    6/05/97 1:36a Lawrance
 274  * using a new interface to play sounds
 275  *
 276  * 18    6/05/97 1:08a Lawrance
 277  * new sound play interface
 278  *
 279  * 17    6/03/97 9:23a Lawrance
 280  * fix bug that caused when sound not found
 281  *
 282  * 16    6/02/97 1:45p Lawrance
 283  * implementing hardware mixing
 284  *
 285  * 15    5/29/97 4:01p Lawrance
 286  * don't fail sound init if dsound3d fails init
 287  *
 288  * 14    5/29/97 3:32p Lawrance
 289  * added call to snd_do_frame()
 290  *
 291  * 13    5/29/97 12:04p Lawrance
 292  * split off acm, direct sound, and direct sound 3d portions to separate
 293  * files
 294  *
 295  * 12    5/21/97 3:55p Lawrance
 296  * when reclaiming sound channels, never stop a looping sound
 297  *
 298  * 11    5/19/97 4:32p Lawrance
 299  * remove misleading nprintf
 300  *
 301  * 10    5/15/97 9:05a Lawrance
 302  * If no sound channels, take away the lowest volume sound (if that volume
 303  * is less than requested sound fx volume)
 304  *
 305  * 9     5/12/97 10:32a Lawrance
 306  * take out nprintf
 307  *
 308  * 8     5/09/97 4:51p Lawrance
 309  * improve pan sound
 310  *
 311  * 7     5/09/97 4:34p Lawrance
 312  * improve comments
 313  *
 314  * 6     5/07/97 3:29p Lawrance
 315  * make volume conversion use a lookup table, fix errors in volume
 316  * conversion
 317  *
 318  * 5     5/07/97 11:33a Lawrance
 319  * improve snd_chg_loop_status()
 320  *
 321  * 4     5/06/97 9:36a Lawrance
 322  * added support for min and max distances for 3d sounds
 323  *
 324  * 3     5/02/97 4:36p Lawrance
 325  * send correct volume scaling when playing a 3D sound
 326  *
 327  * 2     4/28/97 5:13p John
 328  * more moving sound/movie code out of osapi.
 329  *
 330  * $NoKeywords: $
 331  */
 332
 333 #include "pstypes.h"
 334 #include "3dinternal.h"
 335 #include "sound.h"
 336 #include "audiostr.h"
 337 #include "object.h"
 338 #include "cmdline.h"
 339 #include "osapi.h"
 340
 341 #include "gamesnd.h"
 342 #include "alphacolors.h"
 343
 344 #include "oal.h"
 345 #include "oal_capture.h"
 346 #include "oal_efx.h"
 347 #include "acm.h"
 348
 349
 350 #define SND_F_USED                      (1<<0)          // Sounds[] element is used
 351
 352 typedef struct sound    {
 353         int                             sid;                    // software id
 354         char                            filename[MAX_FILENAME_LEN];
 355         int                             sig;
 356         int                             flags;
 357         sound_info              info;
 358         int                             uncompressed_size;              // size (in bytes) of sound (uncompressed)
 359         int                             duration;
 360 } sound;
 361
 362 sound   Sounds[MAX_SOUNDS];
 363
 364 int Sound_enabled = 0;                          // global flag to turn sound on/off
 365 int Snd_sram;                                                           // mem (in bytes) used up by storing sounds in system memory
 366 float Master_sound_volume = 1.0f;       // range is 0 -> 1, used for non-music sound fx
 367 float Master_voice_volume = 0.7f;       // range is 0 -> 1, used for all voice playback
 368
 369 // min volume to play a sound after all volume processing (range is 0.0 -> 1.0)
 370 #define MIN_SOUND_VOLUME                                0.05f
 371
 372 static int snd_next_sig = 1;
 373
 374
 375 void snd_clear()
 376 {
 377         int i;
 378
 379         // flag all Sounds[] as free
 380         for (i=0; i<MAX_SOUNDS; i++ )   {
 381                 Sounds[i].flags &=  ~SND_F_USED;
 382                 Sounds[i].sid = -1;
 383         }
 384
 385         // reset how much storage sounds are taking up in memory
 386         Snd_sram = 0;
 387 }
 388
 389 // ---------------------------------------------------------------------------------------
 390 // Initialize the game sound system
 391 //
 392 // Initialize the game sound system.  Depending on what sound library is being used,
 393 // call the appropriate low-level initiailizations
 394 //
 395 // returns:     1               => init success
 396 //              0               => init failed
 397 //
 398 int snd_init()
 399 {
 400         int rval = 0;
 401
 402         if ( Cmdline_freespace_no_sound )
 403                 return 0;
 404
 405         if (Sound_enabled) {
 406                 nprintf(( "Sound", "SOUND => Sound is already initialized!\n" ));
 407                 return 1;
 408         }
 409
 410         snd_clear();
 411
 412         // Init OpenAL
 413         rval = oal_init();
 414
 415         if (rval < 0) {
 416                 nprintf(( "Sound", "SOUND => Direct Sound init unsuccessful, continuing without sound.\n" ));
 417                 return 0;
 418         }
 419
 420         // Init the audio streaming stuff
 421         audiostream_init();
 422
 423         Sound_enabled = 1;
 424
 425         return 1;
 426 }
 427
 428
 429 void snd_spew_info()
 430 {
 431         int idx;
 432         char txt[512] = "";
 433         CFILE *out = cfopen("sounds.txt", "wt", CFILE_NORMAL, CF_TYPE_DATA);
 434         if(out == NULL){
 435                 return;
 436         }
 437
 438         cfwrite_string("Sounds loaded :\n", out);
 439
 440         // spew info for all sounds
 441         for(idx=0; idx<MAX_SOUNDS; idx++){
 442                 if(!(Sounds[idx].flags & SND_F_USED)){
 443                         continue;
 444                 }
 445
 446                 SDL_snprintf(txt, SDL_arraysize(txt), "%s (%ds)\n", Sounds[idx].filename, Sounds[idx].info.duration);
 447                 cfwrite_string(txt, out);
 448         }
 449
 450         // close the outfile
 451         if(out != NULL){
 452                 cfclose(out);
 453                 out = NULL;
 454         }
 455 }
 456
 457 int Sound_spew = 0;
 458 DCF(show_sounds, "")
 459 {
 460         Sound_spew = !Sound_spew;
 461         if(Sound_spew){
 462                 dc_printf("Sound debug info ON");
 463         } else {
 464                 dc_printf("Sound debug info OFF");
 465         }
 466 }
 467 void snd_spew_debug_info()
 468 {
 469         int game_sounds = 0;
 470         int message_sounds = 0;
 471         int interface_sounds = 0;
 472         int done = 0;
 473         int s_idx;
 474
 475         if(!Sound_spew){
 476                 return;
 477         }
 478
 479         // count up game, interface and message sounds
 480         for(int idx=0; idx<MAX_SOUNDS; idx++){
 481                 if(!(Sounds[idx].flags & SND_F_USED)){
 482                         continue;
 483                 }
 484
 485                 done = 0;
 486
 487                 // what kind of sound is this
 488                 for(s_idx=0; s_idx<MAX_GAME_SOUNDS; s_idx++){
 489                         if(!SDL_strcasecmp(Snds[s_idx].filename, Sounds[idx].filename)){
 490                                 game_sounds++;
 491                                 done = 1;
 492                         }
 493                 }
 494
 495                 if(!done){
 496                         for(s_idx=0; s_idx<MAX_GAME_SOUNDS; s_idx++){
 497                                 if(!SDL_strcasecmp(Snds_iface[s_idx].filename, Sounds[idx].filename)){
 498                                         interface_sounds++;
 499                                         done = 1;
 500                                 }
 501                         }
 502                 }
 503
 504                 if(!done){
 505                         message_sounds++;
 506                 }
 507         }
 508
 509         // spew info
 510         gr_set_color_fast(&Color_normal);
 511         gr_printf(30, 100, "Game sounds : %d\n", game_sounds);
 512         gr_printf(30, 110, "Interface sounds : %d\n", interface_sounds);
 513         gr_printf(30, 120, "Message sounds : %d\n", message_sounds);
 514         gr_printf(30, 130, "Total sounds : %d\n", game_sounds + interface_sounds + message_sounds);
 515 }
 516
 517 // ---------------------------------------------------------------------------------------
 518 // snd_load()
 519 //
 520 // Load a sound into memory and prepare it for playback.  The sound will reside in memory as
 521 // a single instance, and can be played multiple times simultaneously.  Through the magic of
 522 // DirectSound, only 1 copy of the sound is used.
 523 //
 524 // parameters:          gs                                                      => file of sound to load
 525 //                                              allow_hardware_load     => whether to try to allocate in hardware
 526 //
 527 // returns:                     success => index of sound in Sounds[] array
 528 //                                              failure => -1
 529 //
 530 //int snd_load( char *filename, int hardware, int use_ds3d, int *sig)
 531 int snd_load(game_snd *gs)
 532 {
 533         int                             n, rc;
 534         sound_info              *si;
 535         sound                           *snd;
 536         WAVE_chunk              *header = NULL;
 537
 538         if ( !Sound_enabled ) {
 539                 return -1;
 540         }
 541
 542         if ( gs == NULL || gs->filename[0] == 0 )
 543                 return -1;
 544
 545         for (n=0; n<MAX_SOUNDS; n++ )   {
 546                 if (!(Sounds[n].flags & SND_F_USED))
 547                         break;
 548                 else if ( !SDL_strcasecmp( Sounds[n].filename, gs->filename )) {
 549                         gs->sig = Sounds[n].sig;
 550                         return n;
 551                 }
 552         }
 553
 554         if ( n == MAX_SOUNDS ) {
 555 #ifndef NDEBUG
 556                 // spew sound info
 557                 snd_spew_info();
 558 #endif
 559
 560                 Int3();
 561                 return -1;
 562         }
 563
 564         snd = &Sounds[n];
 565
 566         si = &snd->info;
 567
 568         if ( oal_parse_wave(gs->filename, &si->data, &si->size, &header) == -1 )
 569                 return -1;
 570
 571         si->format                              = header->code;                         // 16-bit flag (wFormatTag)
 572         si->n_channels                  = header->num_channels;         // 16-bit channel count (nChannels)
 573         si->sample_rate                 = header->sample_rate;          // 32-bit sample rate (nSamplesPerSec)
 574         si->avg_bytes_per_sec   = header->bytes_per_second;     // 32-bit average bytes per second (nAvgBytesPerSec)
 575         si->n_block_align               = header->block_align;          // 16-bit block alignment (nBlockAlign)
 576         si->bits                                = header->bits_per_sample;      // Read 16-bit bits per sample
 577
 578         snd->duration = fl2i(1000.0f * (si->size / (si->bits/8.0f)) / si->sample_rate);
 579
 580         nprintf(("SOUND", "SOUND ==> duration = %dms (%d %d %d)\n", snd->duration,
 581                                 si->size, si->bits, si->sample_rate));
 582
 583         rc = oal_load_buffer(&snd->sid, &snd->uncompressed_size, header, si, gs->flags);
 584
 585         if (header->extra_data != NULL) {
 586                 free(header->extra_data);
 587         }
 588
 589         free(header);
 590         free(si->data); // don't want to keep this around
 591
 592         if ( rc == -1 )
 593                 return -1;
 594
 595         SDL_strlcpy( snd->filename, gs->filename, SDL_arraysize(snd->filename) );
 596         snd->flags = SND_F_USED;
 597
 598         snd->sig = snd_next_sig++;
 599         if (snd_next_sig < 0 ) snd_next_sig = 1;
 600         gs->id_sig = snd->sig;
 601         gs->id = n;
 602
 603         nprintf(("Sound", "Loaded %s\n", gs->filename));
 604
 605         return n;
 606 }
 607
 608 // ---------------------------------------------------------------------------------------
 609 // snd_unload()
 610 //
 611 // Unload a sound from memory.  This will release the storage, and the sound must be re-loaded via
 612 // sound_load() before it can be played again.
 613 //
 614 int snd_unload( int n )
 615 {
 616         if ( !Sound_enabled ) {
 617                 return 0;
 618         }
 619
 620         if ( (n < 0) || ( n >= MAX_SOUNDS) )
 621                 return 0;
 622
 623         if ( !(Sounds[n].flags & SND_F_USED) )
 624                 return 0;
 625
 626         oal_unload_buffer(Sounds[n].sid);
 627
 628         if ( Sounds[n].sid != -1 ) {
 629                 Snd_sram -= Sounds[n].uncompressed_size;
 630         }
 631
 632         Sounds[n].flags &= ~SND_F_USED;
 633
 634         return 1;
 635 }
 636
 637 // ---------------------------------------------------------------------------------------
 638 // snd_unload_all()
 639 //
 640 // Unload all sounds from memory.  This will release the storage, and the sound must be re-loaded via
 641 // sound_load() before it can be played again.
 642 //
 643 void snd_unload_all()
 644 {
 645         if ( !Sound_enabled ) {
 646                 return;
 647         }
 648
 649         int i;
 650         for (i=0; i<MAX_SOUNDS; i++ )   {
 651                 if ( Sounds[i].flags & SND_F_USED )
 652                         snd_unload(i);
 653         }
 654 }
 655
 656 // ---------------------------------------------------------------------------------------
 657 // snd_close()
 658 //
 659 // This is the companion function to snd_init()... it closes down the game sound system.
 660 //
 661 void snd_close(void)
 662 {
 663         if ( !Sound_enabled ) {
 664                 return;
 665         }
 666
 667         snd_stop_all();
 668         snd_unload_all();               // free the sound data stored in secondary buffers
 669
 670         oal_capture_close();    // Close Capture
 671
 672         oal_close();
 673 }
 674
 675 // ---------------------------------------------------------------------------------------
 676 //      snd_play_raw()
 677 //
 678 // Allow a sound to be played directly from the index in Sounds[].  This bypasses the
 679 // normal game sound management system.
 680 //
 681 // returns:             -1              =>              sound could not be played
 682 //                                      n               =>              handle for instance of sound
 683 //
 684 int snd_play_raw( int soundnum, float pan, float vol_scale, int priority )
 685 {
 686         game_snd gs;
 687         int             rval;
 688
 689         if ( !Sound_enabled ) {
 690                 return -1;
 691         }
 692
 693         gs.id = soundnum;
 694         gs.id_sig = Sounds[soundnum].sig;
 695         gs.filename[0] = 0;
 696         gs.default_volume = 1.0f;
 697 //      gs.flags = GAME_SND_VOICE | GAME_SND_USE_DS3D;
 698         gs.flags = GAME_SND_VOICE;
 699
 700         rval = snd_play(&gs, 0.0f, vol_scale, priority, true);
 701         return rval;
 702 }
 703
 704 MONITOR( NumSoundsStarted );
 705 MONITOR( NumSoundsLoaded );
 706
 707 // ---------------------------------------------------------------------------------------
 708 //      snd_play()
 709 //
 710 //      NOTE: vol_scale parameter is the multiplicative scaling applied to the default volume
 711 //       (vol_scale is a default parameter with a default value of 1.0f)
 712 //
 713 // input:       gs                              =>      game-level sound description
 714 //                              pan                     =>      -1 (full left) to 1.0 (full right), this is a default parm
 715 //                              vol_scale       =>      factor to scale default volume by (applied before global sound volume applied)
 716 //                              priority                => SND_PRIORITY_MUST_PLAY
 717 //                                                                      SND_PRIORITY_SINGLE_INSTANCE            (default value)
 718 //                                                                      SND_PRIORITY_DOUBLE_INSTANCE
 719 //                                                                      SND_PRIORITY_TRIPLE_INSTANCE
 720 //
 721 // returns:             -1              =>              sound could not be played
 722 //                                      n               =>              handle for instance of sound
 723 //
 724 int snd_play( game_snd *gs, float pan, float vol_scale, int priority, bool is_voice_msg )
 725 {
 726         float volume;
 727         sound   *snd;
 728         int flags = 0;
 729
 730         int handle = -1;
 731
 732         if (!Sound_enabled)
 733                 return -1;
 734
 735         SDL_assert( gs != NULL );
 736
 737         MONITOR_INC( NumSoundsStarted, 1 );
 738
 739         if ( gs->id == -1 ) {
 740                 gs->id = snd_load(gs);
 741                 MONITOR_INC( NumSoundsLoaded, 1);
 742         } else if ( gs->id_sig != Sounds[gs->id].sig ) {
 743                 gs->id = snd_load(gs);
 744         }
 745
 746         if ( gs->id == -1 )
 747                 return -1;
 748
 749         volume = gs->default_volume * vol_scale;
 750         if ( gs->flags&GAME_SND_VOICE ) {
 751                 volume *= Master_voice_volume;
 752         } else {
 753                 volume *= Master_sound_volume;
 754         }
 755         if ( volume > 1.0f )
 756                 volume = 1.0f;
 757
 758         snd = &Sounds[gs->id];
 759
 760         if ( !(snd->flags & SND_F_USED) )
 761                 return -1;
 762
 763         if (is_voice_msg) {
 764                 flags |= SND_FLAG_VOICE;
 765         }
 766
 767         if ( volume > MIN_SOUND_VOLUME ) {
 768                 handle = oal_play( snd->sid, gs->id_sig, priority, volume, pan, flags);
 769         }
 770
 771         return handle;
 772 }
 773
 774 MONITOR( Num3DSoundsStarted );
 775 MONITOR( Num3DSoundsLoaded );
 776
 777 // ---------------------------------------------------------------------------------------
 778 // snd_play_3d()
 779 //
 780 //      NOTE: vol_scale parameter is the multiplicative scaling applied to the default volume
 781 //       (vol_scale is a default parameter with a default value of 1.0f)
 782 //
 783 // input:       gs                              =>      game-level sound description
 784 //                              source_pos      =>      global pos of where the sound is
 785 //                              listen_pos      =>      global pos of where listener is
 786 //                              radius          =>      optional parameter, this specifes distance at which to apply min/max distances
 787 //                              source_vel      =>      velocity of the source playing the sound (used for DirectSound3D only)
 788 //                              looping         =>      flag to indicate the sound should loop (default value 0)
 789 //                              vol_scale       =>      factor to scale the static volume by (applied before attenuation)
 790 //                              priority                => SND_PRIORITY_MUST_PLAY
 791 //                                                                      SND_PRIORITY_SINGLE_INSTANCE    (default value)
 792 //                                                                      SND_PRIORITY_DOUBLE_INSTANCE
 793 //                                                                      SND_PRIORITY_TRIPLE_INSTANCE
 794 //                              sound_fvec              => forward vector of where sound is emitting from (RSX use only)
 795 //                              range_factor    =>      factor N, which increases distance sound is heard by N times (default value 1)
 796 //
 797 // returns:             -1              =>              sound could not be played
 798 //                                      n               =>              handle for instance of sound
 799 //
 800 int snd_play_3d(game_snd *gs, vector *source_pos, vector *listen_pos, float radius, vector *source_vel, int looping, float vol_scale, int priority, vector *sound_fvec, float range_factor, int force )
 801 {
 802         int             handle, min_range, max_range;
 803         vector  vector_to_sound;
 804         sound           *snd;
 805         float           volume, distance, max_volume;
 806
 807         if ( !Sound_enabled )
 808                 return -1;
 809
 810         SDL_assert(gs != NULL);
 811
 812         MONITOR_INC( Num3DSoundsStarted, 1 );
 813
 814         if ( gs->id == -1 ) {
 815                 gs->id = snd_load(gs);
 816                 MONITOR_INC( Num3DSoundsLoaded, 1 );
 817         }else if ( gs->id_sig != Sounds[gs->id].sig ) {
 818                 gs->id = snd_load(gs);
 819         }
 820
 821         if ( gs->id == -1 )
 822                 return -1;
 823
 824         snd = &Sounds[gs->id];
 825
 826         if ( !(snd->flags & SND_F_USED) )
 827                 return -1;
 828
 829         min_range = fl2i( (gs->min + radius) * range_factor);
 830         max_range = fl2i( (gs->max + radius) * range_factor + 0.5f);
 831
 832         // prevent sounds from playing past the max distance.
 833         distance = vm_vec_normalized_dir_quick( &vector_to_sound, source_pos, listen_pos );
 834         max_volume = gs->default_volume * vol_scale;
 835         if ( (distance > max_range) && !force){
 836                 return -1;
 837         }
 838
 839         if ( distance <= min_range ) {
 840                 volume = max_volume;
 841         }
 842         else {
 843                 volume = max_volume - max_volume*(distance/max_range);
 844         }
 845
 846         if ( volume > 1.0f ){
 847                 volume = 1.0f;
 848         }
 849
 850         if ( priority == SND_PRIORITY_MUST_PLAY ) {
 851                 if ( volume < 0.3 ) {
 852                         priority = SND_PRIORITY_DOUBLE_INSTANCE;
 853                 }
 854         }
 855
 856         volume *= Master_sound_volume;
 857         if ( (volume < MIN_SOUND_VOLUME) && !force) {
 858                 return -1;
 859         }
 860
 861         handle = oal_play_3d( snd->sid, gs->id_sig, source_pos, source_vel, min_range, max_range, looping, max_volume*Master_sound_volume, volume, priority);
 862
 863         return handle;
 864 }
 865
 866 // update the given 3d sound with a new position
 867 void snd_update_3d_pos(int soundnum, game_snd *gs, vector *new_pos)
 868 {
 869         float vol, pan;
 870
 871         if ( !Sound_enabled ) {
 872                 return;
 873         }
 874
 875         if (soundnum < 0)
 876                 return;
 877
 878         int channel = oal_get_channel(soundnum);
 879
 880         if ( channel == -1 ) {
 881                 nprintf(( "Sound", "WARNING: Trying to update position for a non-playing sound.\n" ));
 882                 return;
 883         }
 884
 885         // oal_update_source returns non-zero if sound is 2D
 886         if ( oal_update_source(channel, -1, -1, new_pos, NULL) ) {
 887                 // get new volume and pan vals
 888                 snd_get_3d_vol_and_pan(gs, new_pos, &vol, &pan);
 889
 890                 // set volume
 891                 snd_set_volume(soundnum, vol);
 892
 893                 // set pan
 894                 snd_set_pan(soundnum, pan);
 895         }
 896 }
 897
 898 // ---------------------------------------------------------------------------------------
 899 // snd_get_3d_vol_and_pan()
 900 //
 901 // Based on the 3D position the player and the object, calculate
 902 // the correct volume and pan.
 903 //
 904 // parameters:          gs                      => pointer to sound description
 905 //                                              pos             => 3D position used to calc volume and pan
 906 //                                              vol             => output parameter for the volume
 907 //                                              pan             => output parameter for the pan
 908 //                                              radius  =>      optional parameter (default value 0) which indicates sound attenuation
 909 //                                                                              should occur from this radius
 910 //
 911 // returns:                     -1                      => could not determine vol or pan
 912 //                                              0                       => success
 913 //
 914 //      NOTE: the volume is not scaled by the Master_sound_volume, since this always occurs
 915 //                      when snd_play() or snd_play_looping() is called
 916 //
 917 int snd_get_3d_vol_and_pan(game_snd *gs, vector *pos, float* vol, float *pan, float radius)
 918 {
 919         vector  vector_to_sound;
 920         float           distance, max_volume;
 921         sound           *snd;
 922
 923         *vol = 0.0f;
 924         *pan = 0.0f;
 925
 926         if ( !Sound_enabled ) {
 927                 return -1;
 928         }
 929
 930         SDL_assert(gs != NULL);
 931
 932         if ( gs->id == -1 ) {
 933                 gs->id = snd_load(gs);
 934         }
 935
 936         snd = &Sounds[gs->id];
 937         if ( !(snd->flags & SND_F_USED) )
 938                 return -1;
 939
 940         distance = vm_vec_normalized_dir_quick( &vector_to_sound, pos, &View_position );
 941         distance -= radius;
 942
 943         max_volume = gs->default_volume;
 944         if ( distance <= gs->min ) {
 945                 *vol = max_volume;
 946         }
 947         else {
 948                 *vol = max_volume - (distance - gs->min) * max_volume / (gs->max - gs->min);
 949         }
 950
 951         if ( *vol > 1.0f )
 952                 *vol = 1.0f;
 953
 954         if ( *vol > MIN_SOUND_VOLUME ) {
 955                 if ( distance <= 0 )
 956                         *pan = 0.0f;
 957                 else
 958                         *pan = vm_vec_dot(&View_matrix.v.rvec,&vector_to_sound);
 959         }
 960
 961         return 0;
 962 }
 963
 964 // ---------------------------------------------------------------------------------------
 965 // volume 0 to 1.0.  Returns the handle of the sound. -1 if failed.
 966 // If startloop or stoploop are not -1, then then are used.
 967 //
 968 //      NOTE: vol_scale parameter is the multiplicative scaling applied to the default volume
 969 //       (vol_scale is a default parameter with a default value of 1.0f)
 970 //
 971 // input:       gs                              =>      game-level sound description
 972 //                              source_pos      =>      global pos of where the sound is
 973 //                              listen_pos      =>      global pos of where listener is
 974 //                              source_vel      =>      velocity of the source playing the sound (used for DirectSound3D only)
 975 //                              looping         =>      flag to indicate the sound should loop (default value 0)
 976 //                              vol_scale       =>      factor to scale the static volume by (applied before attenuation)
 977 //                              priority                => SND_PRIORITY_MUST_PLAY                       (default value)
 978 //                                                                      SND_PRIORITY_SINGLE_INSTANCE
 979 //                                                                      SND_PRIORITY_DOUBLE_INSTANCE
 980 //                                                                      SND_PRIORITY_TRIPLE_INSTANCE
 981 //
 982 // returns:             -1              =>              sound could not be played
 983 //                                      n               =>              handle for instance of sound
 984 //
 985 int snd_play_looping( game_snd *gs, float pan, float vol_scale, int priority, int force )
 986 {
 987         float volume;
 988         int     handle = -1;
 989         sound   *snd;
 990
 991         if (!Sound_enabled)
 992                 return -1;
 993
 994         SDL_assert( gs != NULL );
 995
 996         if ( gs->id == -1 ) {
 997                 gs->id = snd_load(gs);
 998         }
 999         else if ( gs->id_sig != Sounds[gs->id].sig ) {
1000                 gs->id = snd_load(gs);
1001         }
1002
1003         if ( gs->id == -1 )
1004                 return -1;
1005
1006         snd = &Sounds[gs->id];
1007
1008         if ( !(snd->flags & SND_F_USED) )
1009                 return -1;
1010
1011         volume = gs->default_volume * vol_scale;
1012         volume *= Master_sound_volume;
1013
1014         if ( volume > 1.0f )
1015                 volume = 1.0f;
1016
1017
1018         if ( (volume > MIN_SOUND_VOLUME) || force) {
1019                 handle = oal_play( snd->sid, gs->id_sig, priority, volume, pan, SND_FLAG_LOOPING);
1020         }
1021
1022         return handle;
1023 }
1024
1025 // ---------------------------------------------------------------------------------------
1026 // snd_stop()
1027 //
1028 // Stop a sound from playing.
1029 //
1030 // parameters:          sig => handle to sound, what is returned from snd_play()
1031 //
1032 void snd_stop( int sig )
1033 {
1034         int channel;
1035
1036         if ( !Sound_enabled ) {
1037                 return;
1038         }
1039
1040         if (sig < 0) {
1041                 return;
1042         }
1043
1044         channel = oal_get_channel(sig);
1045         if ( channel == -1 )
1046                 return;
1047
1048         oal_stop_channel(channel);
1049 }
1050
1051 // ---------------------------------------------------------------------------------------
1052 // snd_set_volume()
1053 //
1054 // Set the volume of a currently playing sound
1055 //
1056 // parameters:          sig             => handle to sound, what is returned from snd_play()
1057 //                                              volume  => volume of sound (range: 0.0 -> 1.0)
1058 //
1059 void snd_set_volume( int sig, float volume )
1060 {
1061         int     channel;
1062         float   new_volume;
1063
1064         if ( !Sound_enabled ) {
1065                 return;
1066         }
1067
1068         if (sig < 0) {
1069                 return;
1070         }
1071
1072         channel = oal_get_channel(sig);
1073         if ( channel == -1 ) {
1074                 nprintf(( "Sound", "WARNING: Trying to set volume for a non-playing sound.\n" ));
1075                 return;
1076         }
1077
1078         new_volume = volume * Master_sound_volume;
1079         oal_set_volume( channel, new_volume );
1080 }
1081
1082 // ---------------------------------------------------------------------------------------
1083 // snd_set_pan()
1084 //
1085 // Set the pan of a currently playing sound
1086 //
1087 // parameters:          sig     => handle to sound, what is returned from snd_play()
1088 //                                              pan     => pan of sound (range: -1.0 -> 1.0)
1089 //
1090 void snd_set_pan( int sig, float pan )
1091 {
1092         int channel;
1093
1094         if ( !Sound_enabled ) {
1095                 return;
1096         }
1097
1098         if (sig < 0) {
1099                 return;
1100         }
1101
1102         channel = oal_get_channel(sig);
1103         if ( channel == -1 ) {
1104                 nprintf(( "Sound", "WARNING: Trying to set pan for a non-playing sound.\n" ));
1105                 return;
1106         }
1107
1108         oal_set_pan( channel, pan );
1109 }
1110
1111 // ---------------------------------------------------------------------------------------
1112 // snd_get_pitch()
1113 //
1114 // Return the pitch of a currently playing sound
1115 //
1116 // returns:                     pitch of sound ( range: > 0)
1117 //
1118 // parameters:          sig     => handle to sound, what is returned from snd_play()
1119 //
1120 float snd_get_pitch(int sig)
1121 {
1122         int channel;
1123         float pitch;
1124
1125         if ( !Sound_enabled ) {
1126                 return 1.0f;
1127         }
1128
1129         if (sig < 0) {
1130                 return 1.0f;
1131         }
1132
1133         channel = oal_get_channel(sig);
1134         if ( channel == -1 ) {
1135                 nprintf(( "Sound", "WARNING: Trying to get pitch for a non-playing sound.\n" ));
1136                 return 1.0f;
1137         }
1138
1139         pitch = oal_get_pitch(channel);
1140
1141         return pitch;
1142 }
1143
1144 // ---------------------------------------------------------------------------------------
1145 // snd_set_pitch()
1146 //
1147 // Set the pitch of a currently playing sound
1148 //
1149 // parameters:          sig             => handle to sound, what is returned from snd_play()
1150 //                                              pan             => pitch of sound (range: 100 to 100000)
1151 //
1152 void snd_set_pitch( int sig, float pitch )
1153 {
1154         int channel;
1155
1156         if ( !Sound_enabled ) {
1157                 return;
1158         }
1159
1160         if (sig < 0) {
1161                 return;
1162         }
1163
1164         channel = oal_get_channel(sig);
1165         if ( channel == -1 ) {
1166                 nprintf(( "Sound", "WARNING: Trying to set pitch for a non-playing sound.\n" ));
1167                 return;
1168         }
1169
1170         oal_set_pitch(channel, pitch);
1171 }
1172
1173 // ---------------------------------------------------------------------------------------
1174 // snd_is_playing()
1175 //
1176 // Determine if a sound is playing
1177 //
1178 // returns:                     1                               => sound is currently playing
1179 //                                              0                               => sound is not playing
1180 //
1181 // parameters:          sig     => signature of sound, what is returned from snd_play()
1182 //
1183 int snd_is_playing( int sig )
1184 {
1185         int     channel;
1186
1187         if ( !Sound_enabled ) {
1188                 return 0;
1189         }
1190
1191         if (sig < 0) {
1192                 return 0;
1193         }
1194
1195         channel = oal_get_channel(sig);
1196         if ( channel == -1 )
1197                 return 0;
1198
1199         return oal_is_channel_playing(channel);
1200 }
1201
1202
1203 // ---------------------------------------------------------------------------------------
1204 // snd_chg_loop_status()
1205 //
1206 // Change whether a currently playing song is looping or not
1207 //
1208 // parameters:          sig                     => handle to sound, what is returned from snd_play()
1209 //                                              loop                    => whether to start (1) or stop (0) looping
1210 //
1211 void snd_chg_loop_status(int sig, int loop)
1212 {
1213         int channel;
1214
1215         if ( !Sound_enabled ) {
1216                 return;
1217         }
1218
1219         if (sig < 0) {
1220                 return;
1221         }
1222
1223         channel = oal_get_channel(sig);
1224         if ( channel == -1 ) {
1225                 nprintf(( "Sound", "WARNING: Trying to change loop status of a non-playing sound!\n" ));
1226                 return;
1227         }
1228
1229         oal_chg_loop_status(channel, loop);
1230 }
1231
1232 // ---------------------------------------------------------------------------------------
1233 // snd_stop_all()
1234 //
1235 // Stop all playing sound channels (including looping sounds)
1236 //
1237 // NOTE: This stops all sounds that are playing from Channels[] sound buffers.  It doesn't
1238 //                      stop every secondary sound buffer in existance
1239 //
1240 void snd_stop_all()
1241 {
1242         if ( !Sound_enabled ) {
1243                 return;
1244         }
1245
1246         oal_stop_channel_all();
1247 }
1248
1249 // ---------------------------------------------------------------------------------------
1250 // snd_is_inited()
1251 //
1252 //
1253 int snd_is_inited()
1254 {
1255         if ( !Sound_enabled ) {
1256                 return 0;
1257         }
1258
1259         return 1;
1260 }
1261
1262 // return the time in ms for the duration of the sound
1263 int snd_get_duration(int snd_id)
1264 {
1265         if ( snd_id < 0 )
1266                 return 0;
1267
1268         return Sounds[snd_id].duration;
1269 }
1270
1271
1272 MONITOR( SoundChannels );
1273
1274 // update the position of the listener for the specific 3D sound API we're
1275 // using
1276 void snd_update_listener(vector *pos, vector *vel, matrix *orient)
1277 {
1278         MONITOR_INC( SoundChannels, oal_get_number_channels() );
1279         oal_update_listener(pos, vel, orient);
1280 }
1281
1282 void snd_update_source(int snd_handle, int min, int max, vector *pos, vector *vel)
1283 {
1284         if ( !Sound_enabled ) {
1285                 return;
1286         }
1287
1288         if (snd_handle < 0) {
1289                 return;
1290         }
1291
1292         oal_update_source(oal_get_channel(snd_handle), min, max, pos, vel);
1293 }
1294
1295 // this could probably be optimized a bit
1296 void snd_rewind(int snd_handle, game_snd *gs, float seconds)
1297 {
1298         float current_time,desired_time;
1299         float bps;
1300         int current_offset, desired_offset;
1301         sound_info *snd;
1302         int channel;
1303
1304         if ( !Sound_enabled ) {
1305                 return;
1306         }
1307
1308         if (snd_handle < 0) {
1309                 return;
1310         }
1311
1312         channel = oal_get_channel(snd_handle);
1313
1314         // invalid snd handle, or sound not playing
1315         if (channel < 0) {
1316                 return;
1317         }
1318
1319         snd = &Sounds[gs->id].info;
1320
1321         current_offset = oal_get_play_position(channel);        // current offset into the sound
1322         bps = (float)snd->sample_rate * (float)snd->bits;                                                       // data rate
1323         current_time = (float)current_offset/bps;                                                                               // how many seconds we're into the sound
1324
1325         // don't rewind if it'll put us before the beginning of the sound
1326         if(current_time - seconds < 0.0f)
1327                 return;
1328
1329         desired_time = current_time - seconds;                                                                                  // where we want to be
1330         desired_offset = fl2i(desired_time * bps);                                                              // the target
1331
1332         oal_set_play_position(channel, desired_offset);
1333 }
1334
1335 // this could probably be optimized a bit
1336 void snd_ffwd(int snd_handle, game_snd *gs, float seconds)
1337 {
1338         float current_time,desired_time;
1339         float bps;
1340         int current_offset,desired_offset;
1341         sound_info *snd;
1342         int channel;
1343
1344         if ( !Sound_enabled ) {
1345                 return;
1346         }
1347
1348         if (snd_handle < 0) {
1349                 return;
1350         }
1351
1352         channel = oal_get_channel(snd_handle);
1353
1354         // invalid snd handle, or sound not playing
1355         if (channel < 0) {
1356                 return;
1357         }
1358
1359         snd = &Sounds[gs->id].info;
1360
1361         current_offset = oal_get_play_position(channel);        // current offset into the sound
1362         bps = (float)snd->sample_rate * (float)snd->bits;                                                       // data rate
1363         current_time = (float)current_offset/bps;                                                                               // how many seconds we're into the sound
1364
1365         // don't rewind if it'll put us past the end of the sound
1366         if(current_time + seconds > (float)snd->duration)
1367                 return;
1368
1369         desired_time = current_time + seconds;                                                                                  // where we want to be
1370         desired_offset = fl2i(desired_time * bps);                                                              // the target
1371
1372         oal_set_play_position(channel, desired_offset);
1373 }
1374
1375 // this could probably be optimized a bit
1376 void snd_set_pos(int snd_handle, game_snd *gs, float val,int as_pct)
1377 {
1378         sound_info *snd;
1379         int channel;
1380
1381         if ( !Sound_enabled ) {
1382                 return;
1383         }
1384
1385         if (snd_handle < 0) {
1386                 return;
1387         }
1388
1389         channel = oal_get_channel(snd_handle);
1390
1391         // invalid snd handle, or sound not playing
1392         if (channel < 0) {
1393                 return;
1394         }
1395
1396         snd = &Sounds[gs->id].info;
1397
1398         // set position as an absolute from 0 to 1
1399         if (as_pct) {
1400                 SDL_assert((val >= 0.0) && (val <= 1.0));
1401                 oal_set_play_position(channel, fl2i((float)snd->size * val));
1402         }
1403         // set the position as an absolute # of seconds from the beginning of the sound
1404         else {
1405                 float bps;
1406                 SDL_assert(val <= (float)snd->duration/1000.0f);
1407                 bps = (float)snd->sample_rate * (float)snd->bits;                                                       // data rate
1408                 oal_set_play_position(channel, fl2i(bps * val));
1409         }
1410 }
1411
1412 // Return the number of sounds currently playing
1413 int snd_num_playing()
1414 {
1415         if ( !Sound_enabled ) {
1416                 return 0;
1417         }
1418
1419         return oal_get_number_channels();
1420 }
1421
1422 // Stop the first channel found that is playing a sound
1423 void snd_stop_any_sound()
1424 {
1425         int i;
1426
1427         if ( !Sound_enabled ) {
1428                 return;
1429         }
1430
1431         for ( i = 0; i < 16; i++ ) {
1432                 if ( oal_is_channel_playing(i) ) {
1433                         oal_stop_channel(i);
1434                         break;
1435                 }
1436         }
1437 }
1438
1439 // Return the raw sound data for a loaded sound
1440 //
1441 // input:       handle  =>      index into Sounds[] array
1442 //                              data            =>      allocated mem to hold sound
1443 //
1444 // exit:                0       =>      success
1445 //                              !0      =>      fail
1446 int snd_get_data(int handle, char *data)
1447 {
1448         if ( !Sound_enabled ) {
1449                 return -1;
1450         }
1451
1452         SDL_assert(handle >= 0 && handle < MAX_SOUNDS);
1453
1454         sound *snd = &Sounds[handle];
1455         uint size;
1456         WAVE_chunk *header = NULL;
1457         ubyte *u_data = (ubyte*)data;
1458
1459         if ( oal_parse_wave(snd->filename, &u_data, &size, &header) == -1 ) {
1460                 return -1;
1461         }
1462
1463         if (header->extra_data != NULL) {
1464                 free(header->extra_data);
1465         }
1466
1467         free(header);
1468
1469         return 0;
1470 }
1471
1472 // return the size of the sound data associated with the sound handle
1473 int snd_size(int handle, int *size)
1474 {
1475         if ( !Sound_enabled ) {
1476                 return -1;
1477         }
1478
1479         SDL_assert(handle >= 0 && handle < MAX_SOUNDS);
1480
1481         if ( oal_get_buffer_size(Sounds[handle].sid, size) ) {
1482                 return -1;
1483         }
1484
1485         return 0;
1486 }
1487
1488 // retrieve the bits per sample and frequency for a given sound
1489 void snd_get_format(int handle, int *bits_per_sample, int *frequency)
1490 {
1491         SDL_assert(handle >= 0 && handle < MAX_SOUNDS);
1492         *bits_per_sample = Sounds[handle].info.bits;
1493         *frequency = Sounds[handle].info.sample_rate;
1494 }
1495
1496 // return the time for the sound to play in milliseconds
1497 int snd_time_remaining(int handle, int bits_per_sample, int frequency)
1498 {
1499         int channel, time_remaining = 0;
1500         int current_offset, max_offset = 0;
1501
1502         if ( !Sound_enabled ) {
1503                 return 0;
1504         }
1505
1506         if (handle < 0) {
1507                 return 0;
1508         }
1509
1510         channel = oal_get_channel(handle);
1511
1512         if (channel < 0) {
1513                 return 0;
1514         }
1515
1516         current_offset = oal_get_play_position(channel);
1517         max_offset = oal_get_channel_size(channel);
1518
1519         if (current_offset < max_offset) {
1520                 int bytes_remaining = max_offset - current_offset;
1521                 int samples_remaining = bytes_remaining / fl2i(bits_per_sample/8.0f);
1522                 time_remaining = fl2i(1000 * samples_remaining/frequency + 0.5f);
1523         }
1524
1525 //      mprintf(("time_remaining: %d\n", time_remaining));
1526         return time_remaining;
1527 }
1528
1529
1530 // snd_env_ interface
1531
1532 static unsigned int Sound_env_id;
1533 static float Sound_env_volume;
1534 static float Sound_env_damping;
1535 static float Sound_env_decay;
1536
1537 // Set the sound environment
1538 //
1539 int sound_env_set(sound_env *se)
1540 {
1541         if ( !oal_efx_set_all(se->id, se->volume, se->damping, se->decay) ) {
1542                 Sound_env_id = se->id;
1543                 Sound_env_volume = se->volume;
1544                 Sound_env_damping = se->damping;
1545                 Sound_env_decay = se->decay;
1546                 return 0;
1547         } else {
1548                 return -1;
1549         }
1550 }
1551
1552 // Get the sound environment
1553 //
1554 int sound_env_get(sound_env *se)
1555 {
1556         EAX_REVERBPROPERTIES er;
1557
1558         if (oal_efx_get_all(&er, -1) == 0) {
1559                 se->id = er.environment;
1560                 se->volume = er.fVolume;
1561                 se->decay = er.fDecayTime_sec;
1562                 se->damping = er.fDamping;
1563                 return 0;
1564         } else {
1565                 return -1;
1566         }
1567 }
1568
1569 // Turn off the sound environment
1570 //
1571 int sound_env_disable()
1572 {
1573         sound_env se;
1574         se.id = SND_ENV_GENERIC;
1575         se.volume = 0.0f;
1576         se.damping = 0.0f;
1577         se.decay = 0.0f;
1578         sound_env_set(&se);
1579         return 0;
1580 }
1581
1582 // Return 1 if EAX can used to set the sound environment, otherwise return 0
1583 //
1584 int sound_env_supported()
1585 {
1586         return oal_efx_is_inited();
1587 }
1588
1589 // Called once per game frame
1590 //
1591 void snd_do_frame()
1592 {
1593         oal_do_frame();
1594 }