snd_dma.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // snd_dma.c -- main control for any streaming sound output device
  21
  22 #include "quakedef.h"
  23
  24 #ifdef _WIN32
  25 #include <windows.h>
  26 #include <dsound.h>
  27 extern DWORD gSndBufSize;
  28 extern LPDIRECTSOUND pDS;
  29 extern LPDIRECTSOUNDBUFFER pDSBuf;
  30 #endif
  31
  32 #include "ogg.h"
  33
  34
  35 void S_Play(void);
  36 void S_PlayVol(void);
  37 void S_Play2(void);
  38 void S_SoundList(void);
  39 void S_Update_();
  40 void S_StopAllSounds(qboolean clear);
  41 void S_StopAllSoundsC(void);
  42
  43 // =======================================================================
  44 // Internal sound data & structures
  45 // =======================================================================
  46
  47 channel_t channels[MAX_CHANNELS];
  48 int total_channels;
  49
  50 int snd_blocked = 0;
  51 static qboolean snd_ambient = 1;
  52 cvar_t snd_initialized = { CVAR_READONLY, "snd_initialized", "0"};
  53
  54 // pointer should go away
  55 volatile dma_t *shm = 0;
  56 volatile dma_t sn;
  57
  58 vec3_t listener_vieworigin;
  59 vec3_t listener_viewforward;
  60 vec3_t listener_viewleft;
  61 vec3_t listener_viewup;
  62 vec_t sound_nominal_clip_dist=1000.0;
  63 mempool_t *snd_mempool;
  64
  65 // sample PAIRS
  66 int soundtime;
  67 int paintedtime;
  68
  69
  70 //LordHavoc: increased the client sound limit from 512 to 4096 for the Nehahra movie
  71 #define MAX_SFX 4096
  72 sfx_t *known_sfx; // allocated [MAX_SFX]
  73 int num_sfx;
  74
  75 sfx_t *ambient_sfx[NUM_AMBIENTS];
  76
  77 int sound_started = 0;
  78
  79 cvar_t bgmvolume = {CVAR_SAVE, "bgmvolume", "1"};
  80 cvar_t volume = {CVAR_SAVE, "volume", "0.7"};
  81 cvar_t snd_staticvolume = {CVAR_SAVE, "snd_staticvolume", "1"};
  82
  83 cvar_t nosound = {0, "nosound", "0"};
  84 cvar_t snd_precache = {0, "snd_precache", "1"};
  85 cvar_t bgmbuffer = {0, "bgmbuffer", "4096"};
  86 cvar_t ambient_level = {0, "ambient_level", "0.3"};
  87 cvar_t ambient_fade = {0, "ambient_fade", "100"};
  88 cvar_t snd_noextraupdate = {0, "snd_noextraupdate", "0"};
  89 cvar_t snd_show = {0, "snd_show", "0"};
  90 cvar_t _snd_mixahead = {CVAR_SAVE, "_snd_mixahead", "0.1"};
  91 cvar_t snd_swapstereo = {CVAR_SAVE, "snd_swapstereo", "0"};
  92
  93
  94 // ====================================================================
  95 // User-setable variables
  96 // ====================================================================
  97
  98
  99 //
 100 // Fake dma is a synchronous faking of the DMA progress used for
 101 // isolating performance in the renderer.  The fakedma_updates is
 102 // number of times S_Update() is called per second.
 103 //
 104
 105 qboolean fakedma = false;
 106 int fakedma_updates = 15;
 107
 108
 109 void S_AmbientOff (void)
 110 {
 111         snd_ambient = false;
 112 }
 113
 114
 115 void S_AmbientOn (void)
 116 {
 117         snd_ambient = true;
 118 }
 119
 120
 121 void S_SoundInfo_f(void)
 122 {
 123         if (!sound_started || !shm)
 124         {
 125                 Con_Printf ("sound system not started\n");
 126                 return;
 127         }
 128
 129         Con_Printf("%5d stereo\n", shm->channels - 1);
 130         Con_Printf("%5d samples\n", shm->samples);
 131         Con_Printf("%5d samplepos\n", shm->samplepos);
 132         Con_Printf("%5d samplebits\n", shm->samplebits);
 133         Con_Printf("%5d speed\n", shm->speed);
 134         Con_Printf("0x%x dma buffer\n", shm->buffer);
 135         Con_Printf("%5d total_channels\n", total_channels);
 136 }
 137
 138 void S_UnloadSounds(void)
 139 {
 140         int i;
 141         for (i = 0;i < num_sfx;i++)
 142                 S_UnloadSound(known_sfx + i);
 143 }
 144
 145 void S_LoadSounds(void)
 146 {
 147         int i;
 148         for (i = 0;i < num_sfx;i++)
 149                 S_LoadSound(known_sfx + i, false);
 150 }
 151
 152 void S_Startup(void)
 153 {
 154         if (!snd_initialized.integer)
 155                 return;
 156
 157         shm = &sn;
 158         memset((void *)shm, 0, sizeof(*shm));
 159
 160 // create a piece of DMA memory
 161
 162         if (fakedma)
 163         {
 164                 shm->samplebits = 16;
 165                 shm->speed = 22050;
 166                 shm->channels = 2;
 167                 shm->samples = 32768;
 168                 shm->samplepos = 0;
 169                 shm->buffer = Mem_Alloc(snd_mempool, shm->channels * shm->samples * (shm->samplebits / 8));
 170         }
 171         else
 172         {
 173                 if (!SNDDMA_Init())
 174                 {
 175                         Con_Printf("S_Startup: SNDDMA_Init failed.\n");
 176                         sound_started = 0;
 177                         shm = NULL;
 178                         return;
 179                 }
 180         }
 181
 182         sound_started = 1;
 183
 184         Con_DPrintf("Sound sampling rate: %i\n", shm->speed);
 185
 186         //S_LoadSounds();
 187
 188         S_StopAllSounds(true);
 189 }
 190
 191 void S_Shutdown(void)
 192 {
 193         if (!sound_started)
 194                 return;
 195
 196         //S_UnloadSounds();
 197
 198         if (fakedma)
 199                 Mem_Free(shm->buffer);
 200         else
 201                 SNDDMA_Shutdown();
 202
 203         shm = NULL;
 204         sound_started = 0;
 205 }
 206
 207 void S_Restart_f(void)
 208 {
 209         S_Shutdown();
 210         S_Startup();
 211 }
 212
 213 /*
 214 ================
 215 S_Init
 216 ================
 217 */
 218 void S_Init(void)
 219 {
 220         Con_DPrintf("\nSound Initialization\n");
 221
 222         S_RawSamples_ClearQueue();
 223
 224         Cvar_RegisterVariable(&volume);
 225         Cvar_RegisterVariable(&bgmvolume);
 226         Cvar_RegisterVariable(&snd_staticvolume);
 227
 228         if (COM_CheckParm("-nosound") || COM_CheckParm("-safe"))
 229                 return;
 230
 231         snd_mempool = Mem_AllocPool("sound");
 232
 233         if (COM_CheckParm("-simsound"))
 234                 fakedma = true;
 235
 236         Cmd_AddCommand("play", S_Play);
 237         Cmd_AddCommand("play2", S_Play2);
 238         Cmd_AddCommand("playvol", S_PlayVol);
 239         Cmd_AddCommand("stopsound", S_StopAllSoundsC);
 240         Cmd_AddCommand("soundlist", S_SoundList);
 241         Cmd_AddCommand("soundinfo", S_SoundInfo_f);
 242         Cmd_AddCommand("snd_restart", S_Restart_f);
 243
 244         Cvar_RegisterVariable(&nosound);
 245         Cvar_RegisterVariable(&snd_precache);
 246         Cvar_RegisterVariable(&snd_initialized);
 247         Cvar_RegisterVariable(&bgmbuffer);
 248         Cvar_RegisterVariable(&ambient_level);
 249         Cvar_RegisterVariable(&ambient_fade);
 250         Cvar_RegisterVariable(&snd_noextraupdate);
 251         Cvar_RegisterVariable(&snd_show);
 252         Cvar_RegisterVariable(&_snd_mixahead);
 253         Cvar_RegisterVariable(&snd_swapstereo); // LordHavoc: for people with backwards sound wiring
 254
 255         Cvar_SetValueQuick(&snd_initialized, true);
 256
 257         known_sfx = Mem_Alloc(snd_mempool, MAX_SFX*sizeof(sfx_t));
 258         num_sfx = 0;
 259
 260         SND_InitScaletable ();
 261
 262         ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav", false);
 263         ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav", false);
 264
 265         total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;   // no statics
 266         memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));
 267
 268         OGG_OpenLibrary ();
 269 }
 270
 271
 272 // =======================================================================
 273 // Load a sound
 274 // =======================================================================
 275
 276 /*
 277 =========
 278 S_GetCached
 279
 280 =========
 281 */
 282 sfx_t *S_GetCached (const char *name)
 283 {
 284         int i;
 285
 286         if (!snd_initialized.integer)
 287                 return NULL;
 288
 289         if (!name)
 290                 Host_Error("S_IsCached: NULL\n");
 291
 292         if (strlen(name) >= MAX_QPATH)
 293                 Host_Error("Sound name too long: %s", name);
 294
 295         for(i = 0;i < num_sfx;i++)
 296                 if(!strcmp(known_sfx[i].name, name))
 297                         return &known_sfx[i];
 298
 299         return NULL;
 300 }
 301
 302 /*
 303 ==================
 304 S_FindName
 305
 306 ==================
 307 */
 308 sfx_t *S_FindName (char *name)
 309 {
 310         int i;
 311         sfx_t *sfx;
 312
 313         if (!snd_initialized.integer)
 314                 return NULL;
 315
 316         if (!name)
 317                 Host_Error("S_FindName: NULL\n");
 318
 319         if (strlen(name) >= MAX_QPATH)
 320                 Host_Error("Sound name too long: %s", name);
 321
 322 // see if already loaded
 323         for (i = 0;i < num_sfx;i++)
 324                 if (!strcmp(known_sfx[i].name, name))
 325                         return &known_sfx[i];
 326
 327         if (num_sfx == MAX_SFX)
 328                 Sys_Error("S_FindName: out of sfx_t");
 329
 330         sfx = &known_sfx[num_sfx++];
 331         memset(sfx, 0, sizeof(*sfx));
 332         snprintf(sfx->name, sizeof(sfx->name), "%s", name);
 333         return sfx;
 334 }
 335
 336
 337 /*
 338 ==================
 339 S_TouchSound
 340
 341 ==================
 342 */
 343 void S_TouchSound (char *name)
 344 {
 345         S_FindName(name);
 346         // TODO: set the "used" flag for this sound
 347 }
 348
 349
 350 /*
 351 ==================
 352 S_ClearUsed
 353
 354 ==================
 355 */
 356 void S_ClearUsed (void)
 357 {
 358         // TODO: reset the "used" flag of all precached sounds
 359 }
 360
 361
 362 /*
 363 ==================
 364 S_PurgeUnused
 365
 366 ==================
 367 */
 368 void S_PurgeUnused (void)
 369 {
 370         // TODO: free all precached sounds without the "used" flag
 371 }
 372
 373
 374 /*
 375 ==================
 376 S_PrecacheSound
 377
 378 ==================
 379 */
 380 sfx_t *S_PrecacheSound (char *name, int complain)
 381 {
 382         sfx_t *sfx;
 383
 384         if (!snd_initialized.integer)
 385                 return NULL;
 386
 387         sfx = S_FindName(name);
 388
 389         if (!nosound.integer && snd_precache.integer)
 390                 S_LoadSound(sfx, complain);
 391
 392         return sfx;
 393 }
 394
 395
 396 //=============================================================================
 397
 398 /*
 399 =================
 400 SND_PickChannel
 401 =================
 402 */
 403 channel_t *SND_PickChannel(int entnum, int entchannel)
 404 {
 405         int ch_idx;
 406         int first_to_die;
 407         int life_left;
 408
 409 // Check for replacement sound, or find the best one to replace
 410         first_to_die = -1;
 411         life_left = 0x7fffffff;
 412         for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++)
 413         {
 414                 if (entchannel != 0             // channel 0 never overrides
 415                 && channels[ch_idx].entnum == entnum
 416                 && (channels[ch_idx].entchannel == entchannel || entchannel == -1) )
 417                 {       // always override sound from same entity
 418                         first_to_die = ch_idx;
 419                         break;
 420                 }
 421
 422                 // don't let monster sounds override player sounds
 423                 if (channels[ch_idx].entnum == cl.viewentity && entnum != cl.viewentity && channels[ch_idx].sfx)
 424                         continue;
 425
 426                 if (channels[ch_idx].end - paintedtime < life_left)
 427                 {
 428                         life_left = channels[ch_idx].end - paintedtime;
 429                         first_to_die = ch_idx;
 430                 }
 431         }
 432
 433         if (first_to_die == -1)
 434                 return NULL;
 435
 436         if (channels[first_to_die].sfx)
 437                 channels[first_to_die].sfx = NULL;
 438
 439         return &channels[first_to_die];
 440 }
 441
 442 /*
 443 =================
 444 SND_Spatialize
 445 =================
 446 */
 447 void SND_Spatialize(channel_t *ch, int isstatic)
 448 {
 449         vec_t dist, scale, pan;
 450         vec3_t source_vec;
 451
 452         // anything coming from the view entity will always be full volume
 453         // LordHavoc: make sounds with ATTN_NONE have no spatialization
 454         if (ch->entnum == cl.viewentity || ch->dist_mult == 0)
 455         {
 456                 ch->leftvol = ch->master_vol;
 457                 ch->rightvol = ch->master_vol;
 458         }
 459         else
 460         {
 461                 // update sound origin if we know about the entity
 462                 if (ch->entnum > 0 && cls.state == ca_connected && cl_entities[ch->entnum].state_current.active)
 463                 {
 464                         //Con_Printf("-- entnum %i origin %f %f %f neworigin %f %f %f\n", ch->entnum, ch->origin[0], ch->origin[1], ch->origin[2], cl_entities[ch->entnum].state_current.origin[0], cl_entities[ch->entnum].state_current.origin[1], cl_entities[ch->entnum].state_current.origin[2]);
 465                         VectorCopy(cl_entities[ch->entnum].state_current.origin, ch->origin);
 466                         if (cl_entities[ch->entnum].state_current.modelindex && cl.model_precache[cl_entities[ch->entnum].state_current.modelindex]->soundfromcenter)
 467                                 VectorMAMAM(1.0f, ch->origin, 0.5f, cl.model_precache[cl_entities[ch->entnum].state_current.modelindex]->normalmins, 0.5f, cl.model_precache[cl_entities[ch->entnum].state_current.modelindex]->normalmaxs, ch->origin);
 468                 }
 469
 470                 // calculate stereo seperation and distance attenuation
 471                 VectorSubtract(ch->origin, listener_vieworigin, source_vec);
 472                 dist = VectorNormalizeLength(source_vec);
 473                 // distance
 474                 scale = ch->master_vol * (1.0 - (dist * ch->dist_mult));
 475                 // panning
 476                 pan = scale * DotProduct(listener_viewleft, source_vec);
 477                 // calculate the volumes
 478                 ch->leftvol = (int) (scale + pan);
 479                 ch->rightvol = (int) (scale - pan);
 480         }
 481
 482         // LordHavoc: allow adjusting volume of static sounds
 483         if (isstatic)
 484         {
 485                 ch->leftvol *= snd_staticvolume.value;
 486                 ch->rightvol *= snd_staticvolume.value;
 487         }
 488
 489         // clamp volumes
 490         ch->leftvol = bound(0, ch->leftvol, 255);
 491         ch->rightvol = bound(0, ch->rightvol, 255);
 492 }
 493
 494
 495 // =======================================================================
 496 // Start a sound effect
 497 // =======================================================================
 498
 499 void S_StartSound(int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol, float attenuation)
 500 {
 501         channel_t *target_chan, *check;
 502         sfxcache_t      *sc;
 503         int             vol;
 504         int             ch_idx;
 505         int             skip;
 506
 507         if (!sound_started || !sfx || !sfx->sfxcache || nosound.integer)
 508                 return;
 509
 510         vol = fvol*255;
 511
 512 // pick a channel to play on
 513         target_chan = SND_PickChannel(entnum, entchannel);
 514         if (!target_chan)
 515                 return;
 516
 517 // spatialize
 518         memset (target_chan, 0, sizeof(*target_chan));
 519         VectorCopy(origin, target_chan->origin);
 520         target_chan->dist_mult = attenuation / sound_nominal_clip_dist;
 521         target_chan->master_vol = vol;
 522         target_chan->entnum = entnum;
 523         target_chan->entchannel = entchannel;
 524         SND_Spatialize(target_chan, false);
 525
 526         // LordHavoc: spawn the sound anyway because the player might teleport to it
 527         //if (!target_chan->leftvol && !target_chan->rightvol)
 528         //      return;         // not audible at all
 529
 530 // new channel
 531         sc = S_LoadSound (sfx, true);
 532         if (!sc)
 533         {
 534                 target_chan->sfx = NULL;
 535                 return;         // couldn't load the sound's data
 536         }
 537
 538         target_chan->sfx = sfx;
 539         target_chan->pos = 0.0;
 540         target_chan->end = paintedtime + sc->length;
 541
 542 // if an identical sound has also been started this frame, offset the pos
 543 // a bit to keep it from just making the first one louder
 544         check = &channels[NUM_AMBIENTS];
 545         for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++, check++)
 546         {
 547                 if (check == target_chan)
 548                         continue;
 549                 if (check->sfx == sfx && !check->pos)
 550                 {
 551                         // LordHavoc: fixed skip calculations
 552                         skip = 0.1 * sc->speed;
 553                         if (skip > sc->length)
 554                                 skip = sc->length;
 555                         if (skip > 0)
 556                                 skip = rand() % skip;
 557                         target_chan->pos += skip;
 558                         target_chan->end -= skip;
 559                         break;
 560                 }
 561         }
 562 }
 563
 564 void S_StopSound(int entnum, int entchannel)
 565 {
 566         int i;
 567
 568         for (i=0 ; i<MAX_DYNAMIC_CHANNELS ; i++)
 569         {
 570                 if (channels[i].entnum == entnum
 571                         && channels[i].entchannel == entchannel)
 572                 {
 573                         channels[i].end = 0;
 574                         channels[i].sfx = NULL;
 575                         return;
 576                 }
 577         }
 578 }
 579
 580 void S_StopAllSounds(qboolean clear)
 581 {
 582         total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;   // no statics
 583         memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));
 584
 585         if (clear)
 586                 S_ClearBuffer();
 587 }
 588
 589 void S_StopAllSoundsC(void)
 590 {
 591         S_StopAllSounds(true);
 592 }
 593
 594 void S_ClearBuffer(void)
 595 {
 596         int             clear;
 597
 598         if (!sound_started || !shm)
 599                 return;
 600
 601         if (shm->samplebits == 8)
 602                 clear = 0x80;
 603         else
 604                 clear = 0;
 605
 606 #ifdef _WIN32
 607         if (pDSBuf)
 608         {
 609                 DWORD   dwSize;
 610                 DWORD   *pData;
 611                 int             reps;
 612                 HRESULT hresult;
 613
 614                 reps = 0;
 615
 616                 while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, (LPVOID*)&pData, &dwSize, NULL, NULL, 0)) != DS_OK)
 617                 {
 618                         if (hresult != DSERR_BUFFERLOST)
 619                         {
 620                                 Con_Printf ("S_ClearBuffer: DS::Lock Sound Buffer Failed\n");
 621                                 S_Shutdown ();
 622                                 return;
 623                         }
 624
 625                         if (++reps > 10000)
 626                         {
 627                                 Con_Printf ("S_ClearBuffer: DS: couldn't restore buffer\n");
 628                                 S_Shutdown ();
 629                                 return;
 630                         }
 631                 }
 632
 633                 memset(pData, clear, shm->samples * shm->samplebits/8);
 634
 635                 pDSBuf->lpVtbl->Unlock(pDSBuf, pData, dwSize, NULL, 0);
 636
 637         }
 638         else
 639 #endif
 640         if (shm->buffer)
 641         {
 642                 int             setsize = shm->samples * shm->samplebits / 8;
 643                 char    *buf = shm->buffer;
 644
 645                 while (setsize--)
 646                         *buf++ = clear;
 647
 648 // on i586/i686 optimized versions of glibc, glibc *wrongly* IMO,
 649 // reads the memory area before writing to it causing a seg fault
 650 // since the memory is PROT_WRITE only and not PROT_READ|PROT_WRITE
 651 //              memset(shm->buffer, clear, shm->samples * shm->samplebits/8);
 652         }
 653 }
 654
 655
 656 /*
 657 =================
 658 S_StaticSound
 659 =================
 660 */
 661 void S_StaticSound (sfx_t *sfx, vec3_t origin, float vol, float attenuation)
 662 {
 663         channel_t       *ss;
 664         sfxcache_t              *sc;
 665
 666         if (!sfx)
 667                 return;
 668
 669         if (total_channels == MAX_CHANNELS)
 670         {
 671                 Con_Printf ("total_channels == MAX_CHANNELS\n");
 672                 return;
 673         }
 674
 675         sc = S_LoadSound (sfx, true);
 676         if (!sc)
 677                 return;
 678
 679         if (sc->loopstart == -1)
 680                 Con_DPrintf("Quake compatibility warning: Static sound \"%s\" is not looped\n", sfx->name);
 681
 682         ss = &channels[total_channels++];
 683         memset(ss, 0, sizeof(*ss));
 684         ss->forceloop = true;
 685         ss->sfx = sfx;
 686         VectorCopy (origin, ss->origin);
 687         ss->master_vol = vol;
 688         ss->dist_mult = (attenuation/64) / sound_nominal_clip_dist;
 689         ss->end = paintedtime + sc->length;
 690
 691         SND_Spatialize (ss, true);
 692 }
 693
 694
 695 //=============================================================================
 696
 697 /*
 698 ===================
 699 S_UpdateAmbientSounds
 700 ===================
 701 */
 702 void S_UpdateAmbientSounds (void)
 703 {
 704         float           vol;
 705         int                     ambient_channel;
 706         channel_t       *chan;
 707         qbyte           ambientlevels[NUM_AMBIENTS];
 708
 709         // LordHavoc: kill ambient sounds until proven otherwise
 710         for (ambient_channel = 0 ; ambient_channel < NUM_AMBIENTS;ambient_channel++)
 711                 channels[ambient_channel].sfx = NULL;
 712
 713         if (!snd_ambient || ambient_level.value <= 0 || !cl.worldmodel || !cl.worldmodel->brush.AmbientSoundLevelsForPoint)
 714                 return;
 715
 716         cl.worldmodel->brush.AmbientSoundLevelsForPoint(cl.worldmodel, listener_vieworigin, ambientlevels, sizeof(ambientlevels));
 717
 718 // calc ambient sound levels
 719         for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++)
 720         {
 721                 if (ambient_sfx[ambient_channel] && ambient_sfx[ambient_channel]->silentlymissing)
 722                         continue;
 723                 chan = &channels[ambient_channel];
 724                 chan->forceloop = true;
 725                 chan->sfx = ambient_sfx[ambient_channel];
 726
 727                 vol = ambient_level.value * ambientlevels[ambient_channel];
 728                 if (vol < 8)
 729                         vol = 0;
 730
 731         // don't adjust volume too fast
 732                 if (chan->master_vol < vol)
 733                 {
 734                         chan->master_vol += host_realframetime * ambient_fade.value;
 735                         if (chan->master_vol > vol)
 736                                 chan->master_vol = vol;
 737                 }
 738                 else if (chan->master_vol > vol)
 739                 {
 740                         chan->master_vol -= host_realframetime * ambient_fade.value;
 741                         if (chan->master_vol < vol)
 742                                 chan->master_vol = vol;
 743                 }
 744
 745                 chan->leftvol = chan->rightvol = chan->master_vol;
 746         }
 747 }
 748
 749
 750 /*
 751 ============
 752 S_Update
 753
 754 Called once each time through the main loop
 755 ============
 756 */
 757 void S_Update(vec3_t origin, vec3_t forward, vec3_t left, vec3_t up)
 758 {
 759         int                     i, j;
 760         int                     total;
 761         channel_t       *ch;
 762         channel_t       *combine;
 763
 764         if (!snd_initialized.integer || (snd_blocked > 0))
 765                 return;
 766
 767         VectorCopy(origin, listener_vieworigin);
 768         VectorCopy(forward, listener_viewforward);
 769         VectorCopy(left, listener_viewleft);
 770         VectorCopy(up, listener_viewup);
 771
 772 // update general area ambient sound sources
 773         S_UpdateAmbientSounds ();
 774
 775         combine = NULL;
 776
 777 // update spatialization for static and dynamic sounds
 778         ch = channels+NUM_AMBIENTS;
 779         for (i=NUM_AMBIENTS ; i<total_channels; i++, ch++)
 780         {
 781                 if (!ch->sfx)
 782                         continue;
 783                 SND_Spatialize(ch, i >= MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS);         // respatialize channel
 784                 if (!ch->leftvol && !ch->rightvol)
 785                         continue;
 786
 787         // try to combine static sounds with a previous channel of the same
 788         // sound effect so we don't mix five torches every frame
 789
 790                 if (i > MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS)
 791                 {
 792                 // see if it can just use the last one
 793                         if (combine && combine->sfx == ch->sfx)
 794                         {
 795                                 combine->leftvol += ch->leftvol;
 796                                 combine->rightvol += ch->rightvol;
 797                                 ch->leftvol = ch->rightvol = 0;
 798                                 continue;
 799                         }
 800                 // search for one
 801                         combine = channels+MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;
 802                         for (j=MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS ; j<i; j++, combine++)
 803                                 if (combine->sfx == ch->sfx)
 804                                         break;
 805
 806                         if (j == total_channels)
 807                                 combine = NULL;
 808                         else
 809                         {
 810                                 if (combine != ch)
 811                                 {
 812                                         combine->leftvol += ch->leftvol;
 813                                         combine->rightvol += ch->rightvol;
 814                                         ch->leftvol = ch->rightvol = 0;
 815                                 }
 816                                 continue;
 817                         }
 818                 }
 819         }
 820
 821 //
 822 // debugging output
 823 //
 824         if (snd_show.integer)
 825         {
 826                 total = 0;
 827                 ch = channels;
 828                 for (i=0 ; i<total_channels; i++, ch++)
 829                         if (ch->sfx && (ch->leftvol || ch->rightvol) )
 830                                 total++;
 831
 832                 Con_Printf ("----(%i)----\n", total);
 833         }
 834
 835 // mix some sound
 836         S_Update_();
 837 }
 838
 839 void GetSoundtime(void)
 840 {
 841         int             samplepos;
 842         static  int             buffers;
 843         static  int             oldsamplepos;
 844         int             fullsamples;
 845
 846         fullsamples = shm->samples / shm->channels;
 847
 848 // it is possible to miscount buffers if it has wrapped twice between
 849 // calls to S_Update.  Oh well.
 850         samplepos = SNDDMA_GetDMAPos();
 851
 852         if (samplepos < oldsamplepos)
 853         {
 854                 buffers++;                                      // buffer wrapped
 855
 856                 if (paintedtime > 0x40000000)
 857                 {       // time to chop things off to avoid 32 bit limits
 858                         buffers = 0;
 859                         paintedtime = fullsamples;
 860                         S_StopAllSounds (true);
 861                 }
 862         }
 863         oldsamplepos = samplepos;
 864
 865         soundtime = buffers*fullsamples + samplepos/shm->channels;
 866 }
 867
 868 void IN_Accumulate (void);
 869
 870 void S_ExtraUpdate (void)
 871 {
 872
 873 #ifdef _WIN32
 874         IN_Accumulate ();
 875 #endif
 876
 877         if (snd_noextraupdate.integer)
 878                 return;         // don't pollute timings
 879         S_Update_();
 880 }
 881
 882 void S_Update_(void)
 883 {
 884         unsigned        endtime;
 885         int                             samps;
 886
 887         if (!sound_started || (snd_blocked > 0))
 888                 return;
 889
 890 // Updates DMA time
 891         GetSoundtime();
 892
 893 // check to make sure that we haven't overshot
 894         if (paintedtime < soundtime)
 895                 paintedtime = soundtime;
 896
 897 // mix ahead of current position
 898         endtime = soundtime + _snd_mixahead.value * shm->speed;
 899         samps = shm->samples >> (shm->channels-1);
 900         if (endtime > (unsigned int)(soundtime + samps))
 901                 endtime = soundtime + samps;
 902
 903 #ifdef _WIN32
 904 // if the buffer was lost or stopped, restore it and/or restart it
 905         {
 906                 DWORD   dwStatus;
 907
 908                 if (pDSBuf)
 909                 {
 910                         if (pDSBuf->lpVtbl->GetStatus (pDSBuf, &dwStatus) != DS_OK)
 911                                 Con_Printf ("Couldn't get sound buffer status\n");
 912
 913                         if (dwStatus & DSBSTATUS_BUFFERLOST)
 914                                 pDSBuf->lpVtbl->Restore (pDSBuf);
 915
 916                         if (!(dwStatus & DSBSTATUS_PLAYING))
 917                                 pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
 918                 }
 919         }
 920 #endif
 921
 922         S_PaintChannels (endtime);
 923
 924         SNDDMA_Submit ();
 925 }
 926
 927 /*
 928 ===============================================================================
 929
 930 console functions
 931
 932 ===============================================================================
 933 */
 934
 935 static void S_Play_Common(float fvol, float attenuation)
 936 {
 937         int     i;
 938         char name[256];
 939         sfx_t   *sfx;
 940
 941         i = 1;
 942         while (i<Cmd_Argc())
 943         {
 944                 if (!strrchr(Cmd_Argv(i), '.'))
 945                         snprintf(name, sizeof(name), "%s.wav", Cmd_Argv(i));
 946                 else
 947                         strlcpy(name, Cmd_Argv(i), sizeof(name));
 948                 sfx = S_PrecacheSound(name, true);
 949
 950                 // If we need to get the volume from the command line
 951                 if (fvol == -1.0f)
 952                 {
 953                         fvol = atof(Cmd_Argv(i+1));
 954                         i += 2;
 955                 }
 956                 else
 957                         i++;
 958
 959                 S_StartSound(-1, 0, sfx, listener_vieworigin, fvol, attenuation);
 960         }
 961 }
 962
 963 void S_Play(void)
 964 {
 965         S_Play_Common (1.0f, 1.0f);
 966 }
 967
 968 void S_Play2(void)
 969 {
 970         S_Play_Common (1.0f, 0.0f);
 971 }
 972
 973 void S_PlayVol(void)
 974 {
 975         S_Play_Common (-1.0f, 0.0f);
 976 }
 977
 978 void S_SoundList(void)
 979 {
 980         int             i;
 981         sfx_t   *sfx;
 982         sfxcache_t      *sc;
 983         int             size, total;
 984
 985         total = 0;
 986         for (sfx=known_sfx, i=0 ; i<num_sfx ; i++, sfx++)
 987         {
 988                 sc = sfx->sfxcache;
 989                 if (sc)
 990                 {
 991                         size = sc->length*sc->width*(sc->stereo+1);
 992                         total += size;
 993                         Con_Printf("%c(%2db) %6i : %s\n", sc->loopstart >= 0 ? 'L' : ' ',sc->width*8,  size, sfx->name);
 994                 }
 995         }
 996         Con_Printf("Total resident: %i\n", total);
 997 }
 998
 999
1000 void S_LocalSound (char *sound)
1001 {
1002         sfx_t   *sfx;
1003
1004         if (!snd_initialized.integer || nosound.integer)
1005                 return;
1006
1007         sfx = S_PrecacheSound (sound, true);
1008         if (!sfx)
1009         {
1010                 Con_Printf ("S_LocalSound: can't precache %s\n", sound);
1011                 return;
1012         }
1013         S_StartSound (cl.viewentity, -1, sfx, vec3_origin, 1, 1);
1014 }
1015
1016
1017 #define RAWSAMPLESBUFFER 32768
1018 short s_rawsamplesbuffer[RAWSAMPLESBUFFER * 2];
1019 int s_rawsamplesbuffer_start;
1020 int s_rawsamplesbuffer_count;
1021
1022 void S_RawSamples_Enqueue(short *samples, unsigned int length)
1023 {
1024         int b2, b3;
1025         //Con_Printf("S_RawSamples_Enqueue: %i samples\n", length);
1026         if (s_rawsamplesbuffer_count + length > RAWSAMPLESBUFFER)
1027                 return;
1028         b2 = (s_rawsamplesbuffer_start + s_rawsamplesbuffer_count) % RAWSAMPLESBUFFER;
1029         if (b2 + length > RAWSAMPLESBUFFER)
1030         {
1031                 b3 = (b2 + length) % RAWSAMPLESBUFFER;
1032                 memcpy(s_rawsamplesbuffer + b2 * 2, samples, (RAWSAMPLESBUFFER - b2) * sizeof(short[2]));
1033                 memcpy(s_rawsamplesbuffer, samples + (RAWSAMPLESBUFFER - b2) * 2, b3 * sizeof(short[2]));
1034         }
1035         else
1036                 memcpy(s_rawsamplesbuffer + b2 * 2, samples, length * sizeof(short[2]));
1037         s_rawsamplesbuffer_count += length;
1038 }
1039
1040 void S_RawSamples_Dequeue(int *samples, unsigned int length)
1041 {
1042         int b1, b2, l;
1043         int i;
1044         short *in;
1045         int *out;
1046         int count;
1047         l = length;
1048         if (l > s_rawsamplesbuffer_count)
1049                 l = s_rawsamplesbuffer_count;
1050         b1 = (s_rawsamplesbuffer_start) % RAWSAMPLESBUFFER;
1051         if (b1 + l > RAWSAMPLESBUFFER)
1052         {
1053                 b2 = (b1 + l) % RAWSAMPLESBUFFER;
1054                 //memcpy(samples, s_rawsamplesbuffer + b1 * 2, (RAWSAMPLESBUFFER - b1) * sizeof(short[2]));
1055                 //memcpy(samples + (RAWSAMPLESBUFFER - b1) * 2, s_rawsamplesbuffer, b2 * sizeof(short[2]));
1056                 for (out = samples, in = s_rawsamplesbuffer + b1 * 2, count = (RAWSAMPLESBUFFER - b1) * 2, i = 0;i < count;i++)
1057                         out[i] = in[i];
1058                 for (out = samples + (RAWSAMPLESBUFFER - b1) * 2, in = s_rawsamplesbuffer, count = b2 * 2, i = 0;i < count;i++)
1059                         out[i] = in[i];
1060                 //Con_Printf("S_RawSamples_Dequeue: buffer wrap %i %i\n", (RAWSAMPLESBUFFER - b1), b2);
1061         }
1062         else
1063         {
1064                 //memcpy(samples, s_rawsamplesbuffer + b1 * 2, l * sizeof(short[2]));
1065                 for (out = samples, in = s_rawsamplesbuffer + b1 * 2, count = l * 2, i = 0;i < count;i++)
1066                         out[i] = in[i];
1067                 //Con_Printf("S_RawSamples_Dequeue: normal      %i\n", l);
1068         }
1069         if (l < (int)length)
1070         {
1071                 memset(samples + l * 2, 0, (length - l) * sizeof(int[2]));
1072                 //Con_Printf("S_RawSamples_Dequeue: padding with %i samples\n", length - l);
1073         }
1074         s_rawsamplesbuffer_start = (s_rawsamplesbuffer_start + l) % RAWSAMPLESBUFFER;
1075         s_rawsamplesbuffer_count -= l;
1076 }
1077
1078 void S_RawSamples_ClearQueue(void)
1079 {
1080         s_rawsamplesbuffer_count = 0;
1081         s_rawsamplesbuffer_start = 0;
1082 }
1083
1084 int S_RawSamples_QueueWantsMore(void)
1085 {
1086         if (shm != NULL && s_rawsamplesbuffer_count < min(shm->speed >> 1, RAWSAMPLESBUFFER >> 1))
1087                 return RAWSAMPLESBUFFER - s_rawsamplesbuffer_count;
1088         else
1089                 return 0;
1090 }
1091
1092 void S_ResampleBuffer16Stereo(short *input, int inputlength, short *output, int outputlength)
1093 {
1094         if (inputlength != outputlength)
1095         {
1096                 int i, position, stopposition, step;
1097                 short *in, *out;
1098                 step = (float) inputlength * 256.0f / (float) outputlength;
1099                 position = 0;
1100                 stopposition = (inputlength - 1) << 8;
1101                 out = output;
1102                 for (i = 0;i < outputlength && position < stopposition;i++, position += step)
1103                 {
1104                         in = input + ((position >> 8) << 1);
1105                         out[0] = (((in[1] - in[0]) * (position & 255)) >> 8) + in[0];
1106                         out[1] = (((in[3] - in[2]) * (position & 255)) >> 8) + in[2];
1107                         out += 2;
1108                 }
1109                 stopposition = inputlength << 8;
1110                 for (i = 0;i < outputlength && position < stopposition;i++, position += step)
1111                 {
1112                         in = input + ((position >> 8) << 1);
1113                         out[0] = in[0];
1114                         out[1] = in[2];
1115                         out += 2;
1116                 }
1117         }
1118         else
1119                 memcpy(output, input, inputlength * sizeof(short[2]));
1120 }
1121
1122 int S_RawSamples_SampleRate(void)
1123 {
1124         return shm != NULL ? shm->speed : 0;
1125 }
1126