snd_win.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 #include "quakedef.h"
  21 #include "snd_main.h"
  22 #include <windows.h>
  23 #include <dsound.h>
  24
  25 extern HWND mainwindow;
  26
  27 #define iDirectSoundCreate(a,b,c)       pDirectSoundCreate(a,b,c)
  28
  29 HRESULT (WINAPI *pDirectSoundCreate)(GUID FAR *lpGUID, LPDIRECTSOUND FAR *lplpDS, IUnknown FAR *pUnkOuter);
  30
  31 // Wave output: 64KB in 64 buffers of 1KB
  32 // (64KB is > 1 sec at 16-bit 22050 Hz mono, and is 1/3 sec at 16-bit 44100 Hz stereo)
  33 #define WAV_BUFFERS                             64
  34 #define WAV_MASK                                (WAV_BUFFERS - 1)
  35 #define WAV_BUFFER_SIZE                 1024
  36
  37 // DirectSound output: 64KB in 1 buffer
  38 #define SECONDARY_BUFFER_SIZE   (64 * 1024)
  39
  40 typedef enum {SIS_SUCCESS, SIS_FAILURE, SIS_NOTAVAIL} sndinitstat;
  41
  42 static qboolean wavonly;
  43 static qboolean dsound_init;
  44 static qboolean wav_init;
  45 static qboolean primary_format_set;
  46
  47 static int      snd_sent, snd_completed;
  48
  49 static int prev_painted;
  50 static unsigned int paintpot;
  51
  52
  53 /*
  54  * Global variables. Must be visible to window-procedure function
  55  *  so it can unlock and free the data block after it has been played.
  56  */
  57
  58 HANDLE          hData;
  59 HPSTR           lpData, lpData2;
  60
  61 HGLOBAL         hWaveHdr;
  62 LPWAVEHDR       lpWaveHdr;
  63
  64 HWAVEOUT    hWaveOut;
  65
  66 WAVEOUTCAPS     wavecaps;
  67
  68 DWORD   gSndBufSize;
  69
  70 DWORD   dwStartTime;
  71
  72 LPDIRECTSOUND pDS;
  73 LPDIRECTSOUNDBUFFER pDSBuf, pDSPBuf;
  74
  75 HINSTANCE hInstDS;
  76
  77 qboolean SNDDMA_InitWav (void);
  78 sndinitstat SNDDMA_InitDirect (void);
  79
  80 /*
  81 ==================
  82 S_BlockSound
  83 ==================
  84 */
  85 void S_BlockSound (void)
  86 {
  87         // DirectSound takes care of blocking itself
  88         if (wav_init)
  89         {
  90                 snd_blocked++;
  91
  92                 if (snd_blocked == 1)
  93                         waveOutReset (hWaveOut);
  94         }
  95 }
  96
  97
  98 /*
  99 ==================
 100 S_UnblockSound
 101 ==================
 102 */
 103 void S_UnblockSound (void)
 104 {
 105         // DirectSound takes care of blocking itself
 106         if (wav_init)
 107                 snd_blocked--;
 108 }
 109
 110
 111 /*
 112 ==================
 113 FreeSound
 114 ==================
 115 */
 116 void FreeSound (void)
 117 {
 118         int             i;
 119
 120         if (pDSBuf)
 121         {
 122                 pDSBuf->lpVtbl->Stop(pDSBuf);
 123                 pDSBuf->lpVtbl->Release(pDSBuf);
 124         }
 125
 126         // only release primary buffer if it's not also the mixing buffer we just released
 127         if (pDSPBuf && (pDSBuf != pDSPBuf))
 128         {
 129                 pDSPBuf->lpVtbl->Release(pDSPBuf);
 130         }
 131
 132         if (pDS)
 133         {
 134                 pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_NORMAL);
 135                 pDS->lpVtbl->Release(pDS);
 136         }
 137
 138         if (hWaveOut)
 139         {
 140                 waveOutReset (hWaveOut);
 141
 142                 if (lpWaveHdr)
 143                 {
 144                         for (i=0 ; i< WAV_BUFFERS ; i++)
 145                                 waveOutUnprepareHeader (hWaveOut, lpWaveHdr+i, sizeof(WAVEHDR));
 146                 }
 147
 148                 waveOutClose (hWaveOut);
 149
 150                 if (hWaveHdr)
 151                 {
 152                         GlobalUnlock(hWaveHdr);
 153                         GlobalFree(hWaveHdr);
 154                 }
 155
 156                 if (hData)
 157                 {
 158                         GlobalUnlock(hData);
 159                         GlobalFree(hData);
 160                 }
 161
 162         }
 163
 164         pDS = NULL;
 165         pDSBuf = NULL;
 166         pDSPBuf = NULL;
 167         hWaveOut = 0;
 168         hData = 0;
 169         hWaveHdr = 0;
 170         lpData = NULL;
 171         lpWaveHdr = NULL;
 172         dsound_init = false;
 173         wav_init = false;
 174 }
 175
 176
 177 /*
 178 ==================
 179 SNDDMA_InitDirect
 180
 181 Direct-Sound support
 182 ==================
 183 */
 184 sndinitstat SNDDMA_InitDirect (void)
 185 {
 186         DSBUFFERDESC    dsbuf;
 187         DSBCAPS                 dsbcaps;
 188         DWORD                   dwSize;
 189         DSCAPS                  dscaps;
 190         WAVEFORMATEX    format, pformat;
 191         HRESULT                 hresult;
 192         int                             reps;
 193         int i;
 194
 195         memset((void *)shm, 0, sizeof(*shm));
 196         shm->format.channels = 2;
 197         shm->format.width = 2;
 198 // COMMANDLINEOPTION: Windows Sound: -sndspeed <hz> chooses 44100 hz, 22100 hz, or 11025 hz sound output rate
 199         i = COM_CheckParm ("-sndspeed");
 200         if (i && i != (com_argc - 1))
 201                 shm->format.speed = atoi(com_argv[i+1]);
 202         else
 203                 shm->format.speed = 44100;
 204
 205         memset (&format, 0, sizeof(format));
 206         format.wFormatTag = WAVE_FORMAT_PCM;
 207     format.nChannels = shm->format.channels;
 208     format.wBitsPerSample = shm->format.width * 8;
 209     format.nSamplesPerSec = shm->format.speed;
 210     format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8;
 211     format.cbSize = 0;
 212     format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
 213
 214         if (!hInstDS)
 215         {
 216                 hInstDS = LoadLibrary("dsound.dll");
 217
 218                 if (hInstDS == NULL)
 219                 {
 220                         Con_Print("Couldn't load dsound.dll\n");
 221                         return SIS_FAILURE;
 222                 }
 223
 224                 pDirectSoundCreate = (void *)GetProcAddress(hInstDS,"DirectSoundCreate");
 225
 226                 if (!pDirectSoundCreate)
 227                 {
 228                         Con_Print("Couldn't get DS proc addr\n");
 229                         return SIS_FAILURE;
 230                 }
 231         }
 232
 233         while ((hresult = iDirectSoundCreate(NULL, &pDS, NULL)) != DS_OK)
 234         {
 235                 if (hresult != DSERR_ALLOCATED)
 236                 {
 237                         Con_Print("DirectSound create failed\n");
 238                         return SIS_FAILURE;
 239                 }
 240
 241                 if (MessageBox (NULL,
 242                                                 "The sound hardware is in use by another app.\n\n"
 243                                             "Select Retry to try to start sound again or Cancel to run Quake with no sound.",
 244                                                 "Sound not available",
 245                                                 MB_RETRYCANCEL | MB_SETFOREGROUND | MB_ICONEXCLAMATION) != IDRETRY)
 246                 {
 247                         Con_Print("DirectSoundCreate failure\n  hardware already in use\n");
 248                         return SIS_NOTAVAIL;
 249                 }
 250         }
 251
 252         dscaps.dwSize = sizeof(dscaps);
 253
 254         if (DS_OK != pDS->lpVtbl->GetCaps (pDS, &dscaps))
 255         {
 256                 Con_Print("Couldn't get DS caps\n");
 257         }
 258
 259         if (dscaps.dwFlags & DSCAPS_EMULDRIVER)
 260         {
 261                 Con_Print("No DirectSound driver installed\n");
 262                 FreeSound ();
 263                 return SIS_FAILURE;
 264         }
 265
 266         if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_EXCLUSIVE))
 267         {
 268                 Con_Print("Set coop level failed\n");
 269                 FreeSound ();
 270                 return SIS_FAILURE;
 271         }
 272
 273         // get access to the primary buffer, if possible, so we can set the
 274         // sound hardware format
 275         memset (&dsbuf, 0, sizeof(dsbuf));
 276         dsbuf.dwSize = sizeof(DSBUFFERDESC);
 277         dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER;
 278         dsbuf.dwBufferBytes = 0;
 279         dsbuf.lpwfxFormat = NULL;
 280
 281         memset(&dsbcaps, 0, sizeof(dsbcaps));
 282         dsbcaps.dwSize = sizeof(dsbcaps);
 283         primary_format_set = false;
 284
 285 // COMMANDLINEOPTION: Windows DirectSound: -snoforceformat uses the format that DirectSound returns, rather than forcing it
 286         if (!COM_CheckParm ("-snoforceformat"))
 287         {
 288                 if (DS_OK == pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSPBuf, NULL))
 289                 {
 290                         pformat = format;
 291
 292                         if (DS_OK != pDSPBuf->lpVtbl->SetFormat (pDSPBuf, &pformat))
 293                         {
 294                                 Con_Print("Set primary sound buffer format: no\n");
 295                         }
 296                         else
 297                         {
 298                                 Con_Print("Set primary sound buffer format: yes\n");
 299
 300                                 primary_format_set = true;
 301                         }
 302                 }
 303         }
 304
 305 // COMMANDLINEOPTION: Windows DirectSound: -primarysound locks the sound hardware for exclusive use
 306         if (!primary_format_set || !COM_CheckParm ("-primarysound"))
 307         {
 308                 // create the secondary buffer we'll actually work with
 309                 memset (&dsbuf, 0, sizeof(dsbuf));
 310                 dsbuf.dwSize = sizeof(DSBUFFERDESC);
 311                 dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY | DSBCAPS_LOCSOFTWARE;
 312                 dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE;
 313                 dsbuf.lpwfxFormat = &format;
 314
 315                 memset(&dsbcaps, 0, sizeof(dsbcaps));
 316                 dsbcaps.dwSize = sizeof(dsbcaps);
 317
 318                 if (DS_OK != pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSBuf, NULL))
 319                 {
 320                         Con_Print("DS:CreateSoundBuffer Failed\n");
 321                         FreeSound ();
 322                         return SIS_FAILURE;
 323                 }
 324
 325                 shm->format.channels = format.nChannels;
 326                 shm->format.width = format.wBitsPerSample / 8;
 327                 shm->format.speed = format.nSamplesPerSec;
 328
 329                 if (DS_OK != pDSBuf->lpVtbl->GetCaps (pDSBuf, &dsbcaps))
 330                 {
 331                         Con_Print("DS:GetCaps failed\n");
 332                         FreeSound ();
 333                         return SIS_FAILURE;
 334                 }
 335
 336                 Con_Print("Using secondary sound buffer\n");
 337         }
 338         else
 339         {
 340                 if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_WRITEPRIMARY))
 341                 {
 342                         Con_Print("Set coop level failed\n");
 343                         FreeSound ();
 344                         return SIS_FAILURE;
 345                 }
 346
 347                 if (DS_OK != pDSPBuf->lpVtbl->GetCaps (pDSPBuf, &dsbcaps))
 348                 {
 349                         Con_Print("DS:GetCaps failed\n");
 350                         return SIS_FAILURE;
 351                 }
 352
 353                 pDSBuf = pDSPBuf;
 354                 Con_Print("Using primary sound buffer\n");
 355         }
 356
 357         // Make sure mixer is active
 358         pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
 359
 360         Con_Printf("   %d channel(s)\n"
 361                        "   %d bits/sample\n"
 362                                    "   %d samples/sec\n",
 363                                    shm->format.channels, shm->format.width * 8, shm->format.speed);
 364
 365         gSndBufSize = dsbcaps.dwBufferBytes;
 366
 367         // initialize the buffer
 368         reps = 0;
 369
 370         while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, (LPVOID*)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK)
 371         {
 372                 if (hresult != DSERR_BUFFERLOST)
 373                 {
 374                         Con_Print("SNDDMA_InitDirect: DS::Lock Sound Buffer Failed\n");
 375                         FreeSound ();
 376                         return SIS_FAILURE;
 377                 }
 378
 379                 if (++reps > 10000)
 380                 {
 381                         Con_Print("SNDDMA_InitDirect: DS: couldn't restore buffer\n");
 382                         FreeSound ();
 383                         return SIS_FAILURE;
 384                 }
 385
 386         }
 387
 388         memset(lpData, 0, dwSize);
 389
 390         pDSBuf->lpVtbl->Unlock(pDSBuf, lpData, dwSize, NULL, 0);
 391
 392         // we don't want anyone to access the buffer directly w/o locking it first.
 393         lpData = NULL;
 394
 395         pDSBuf->lpVtbl->Stop(pDSBuf);
 396         pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &dwStartTime, NULL);
 397         pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
 398
 399         shm->samples = gSndBufSize / shm->format.width;
 400         shm->samplepos = 0;
 401         shm->buffer = (unsigned char *) lpData;
 402
 403         dsound_init = true;
 404
 405         return SIS_SUCCESS;
 406 }
 407
 408
 409 /*
 410 ==================
 411 SNDDM_InitWav
 412
 413 Crappy windows multimedia base
 414 ==================
 415 */
 416 qboolean SNDDMA_InitWav (void)
 417 {
 418         WAVEFORMATEX  format;
 419         int                             i;
 420         HRESULT                 hr;
 421
 422         snd_sent = 0;
 423         snd_completed = 0;
 424
 425         memset((void *)shm, 0, sizeof(*shm));
 426         shm->format.channels = 2;
 427         shm->format.width = 2;
 428 // COMMANDLINEOPTION: Windows Sound: -sndspeed <hz> chooses 44100 hz, 22100 hz, or 11025 hz sound output rate
 429         i = COM_CheckParm ("-sndspeed");
 430         if (i && i != (com_argc - 1))
 431                 shm->format.speed = atoi(com_argv[i+1]);
 432         else
 433                 shm->format.speed = 44100;
 434
 435         memset (&format, 0, sizeof(format));
 436         format.wFormatTag = WAVE_FORMAT_PCM;
 437         format.nChannels = shm->format.channels;
 438         format.wBitsPerSample = shm->format.width * 8;
 439         format.nSamplesPerSec = shm->format.speed;
 440         format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8;
 441         format.cbSize = 0;
 442         format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
 443
 444         // Open a waveform device for output using window callback
 445         while ((hr = waveOutOpen((LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,
 446                                         &format,
 447                                         0, 0L, CALLBACK_NULL)) != MMSYSERR_NOERROR)
 448         {
 449                 if (hr != MMSYSERR_ALLOCATED)
 450                 {
 451                         Con_Print("waveOutOpen failed\n");
 452                         return false;
 453                 }
 454
 455                 if (MessageBox (NULL,
 456                                                 "The sound hardware is in use by another app.\n\n"
 457                                             "Select Retry to try to start sound again or Cancel to run Quake with no sound.",
 458                                                 "Sound not available",
 459                                                 MB_RETRYCANCEL | MB_SETFOREGROUND | MB_ICONEXCLAMATION) != IDRETRY)
 460                 {
 461                         Con_Print("waveOutOpen failure;\n  hardware already in use\n");
 462                         return false;
 463                 }
 464         }
 465
 466         /*
 467          * Allocate and lock memory for the waveform data. The memory
 468          * for waveform data must be globally allocated with
 469          * GMEM_MOVEABLE and GMEM_SHARE flags.
 470          */
 471         gSndBufSize = WAV_BUFFERS*WAV_BUFFER_SIZE;
 472         hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, gSndBufSize);
 473         if (!hData)
 474         {
 475                 Con_Print("Sound: Out of memory.\n");
 476                 FreeSound ();
 477                 return false;
 478         }
 479         lpData = GlobalLock(hData);
 480         if (!lpData)
 481         {
 482                 Con_Print("Sound: Failed to lock.\n");
 483                 FreeSound ();
 484                 return false;
 485         }
 486         memset (lpData, 0, gSndBufSize);
 487
 488         /*
 489          * Allocate and lock memory for the header. This memory must
 490          * also be globally allocated with GMEM_MOVEABLE and
 491          * GMEM_SHARE flags.
 492          */
 493         hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
 494                 (DWORD) sizeof(WAVEHDR) * WAV_BUFFERS);
 495
 496         if (hWaveHdr == NULL)
 497         {
 498                 Con_Print("Sound: Failed to Alloc header.\n");
 499                 FreeSound ();
 500                 return false;
 501         }
 502
 503         lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
 504
 505         if (lpWaveHdr == NULL)
 506         {
 507                 Con_Print("Sound: Failed to lock header.\n");
 508                 FreeSound ();
 509                 return false;
 510         }
 511
 512         memset (lpWaveHdr, 0, sizeof(WAVEHDR) * WAV_BUFFERS);
 513
 514         // After allocation, set up and prepare headers
 515         for (i=0 ; i<WAV_BUFFERS ; i++)
 516         {
 517                 lpWaveHdr[i].dwBufferLength = WAV_BUFFER_SIZE;
 518                 lpWaveHdr[i].lpData = lpData + i*WAV_BUFFER_SIZE;
 519
 520                 if (waveOutPrepareHeader(hWaveOut, lpWaveHdr+i, sizeof(WAVEHDR)) !=
 521                                 MMSYSERR_NOERROR)
 522                 {
 523                         Con_Print("Sound: failed to prepare wave headers\n");
 524                         FreeSound ();
 525                         return false;
 526                 }
 527         }
 528
 529         shm->samples = gSndBufSize / shm->format.width;
 530         shm->samplepos = 0;
 531         shm->buffer = (unsigned char *) lpData;
 532
 533         prev_painted = 0;
 534         paintpot = 0;
 535
 536         wav_init = true;
 537
 538         return true;
 539 }
 540
 541 /*
 542 ==================
 543 SNDDMA_Init
 544
 545 Try to find a sound device to mix for.
 546 Returns false if nothing is found.
 547 ==================
 548 */
 549 qboolean SNDDMA_Init(void)
 550 {
 551         sndinitstat     stat;
 552
 553 // COMMANDLINEOPTION: Windows Sound: -wavonly uses wave sound instead of DirectSound
 554         if (COM_CheckParm ("-wavonly"))
 555                 wavonly = true;
 556
 557         dsound_init = false;
 558         wav_init = false;
 559
 560         stat = SIS_FAILURE;     // assume DirectSound won't initialize
 561
 562         // Init DirectSound
 563         if (!wavonly)
 564         {
 565                 stat = SNDDMA_InitDirect ();
 566
 567                 if (stat == SIS_SUCCESS)
 568                         Con_Print("DirectSound initialized\n");
 569                 else
 570                         Con_Print("DirectSound failed to init\n");
 571         }
 572
 573         // if DirectSound didn't succeed in initializing, try to initialize
 574         // waveOut sound, unless DirectSound failed because the hardware is
 575         // already allocated (in which case the user has already chosen not
 576         // to have sound)
 577         if (!dsound_init && (stat != SIS_NOTAVAIL))
 578         {
 579                 if (SNDDMA_InitWav ())
 580                         Con_Print("Wave sound initialized\n");
 581                 else
 582                         Con_Print("Wave sound failed to init\n");
 583         }
 584
 585         if (!dsound_init && !wav_init)
 586                 return false;
 587
 588         return true;
 589 }
 590
 591 /*
 592 ==============
 593 SNDDMA_GetDMAPos
 594
 595 return the current sample position (in mono samples read)
 596 inside the recirculating dma buffer, so the mixing code will know
 597 how many sample are required to fill it up.
 598 ===============
 599 */
 600 int SNDDMA_GetDMAPos(void)
 601 {
 602         DWORD dwTime, s;
 603
 604         if (dsound_init)
 605         {
 606                 pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &dwTime, NULL);
 607                 s = dwTime - dwStartTime;
 608         }
 609         else if (wav_init)
 610         {
 611                 // Find which sound blocks have completed
 612                 for (;;)
 613                 {
 614                         if (snd_completed == snd_sent)
 615                         {
 616                                 Con_DPrint("Sound overrun\n");
 617                                 break;
 618                         }
 619
 620                         if (!(lpWaveHdr[snd_completed & WAV_MASK].dwFlags & WHDR_DONE))
 621                                 break;
 622
 623                         snd_completed++;        // this buffer has been played
 624                 }
 625
 626                 s = snd_completed * WAV_BUFFER_SIZE;
 627         }
 628         else
 629                 return 0;
 630
 631         return (s >> (shm->format.width - 1)) & (shm->samples - 1);
 632 }
 633
 634 /*
 635 ==============
 636 SNDDMA_Submit
 637
 638 Send sound to device if buffer isn't really the dma buffer
 639 ===============
 640 */
 641 void SNDDMA_Submit(void)
 642 {
 643         LPWAVEHDR       h;
 644         int                     wResult;
 645
 646         // DirectSound doesn't need this
 647         if (!wav_init)
 648                 return;
 649
 650         paintpot += (paintedtime - prev_painted) * shm->format.channels * shm->format.width;
 651         if (paintpot > WAV_BUFFERS * WAV_BUFFER_SIZE)
 652                 paintpot = WAV_BUFFERS * WAV_BUFFER_SIZE;
 653         prev_painted = paintedtime;
 654
 655         // submit new sound blocks
 656         while (paintpot > WAV_BUFFER_SIZE)
 657         {
 658                 h = lpWaveHdr + (snd_sent & WAV_MASK);
 659
 660                 snd_sent++;
 661                 /*
 662                  * Now the data block can be sent to the output device. The
 663                  * waveOutWrite function returns immediately and waveform
 664                  * data is sent to the output device in the background.
 665                  */
 666                 wResult = waveOutWrite(hWaveOut, h, sizeof(WAVEHDR));
 667
 668                 if (wResult != MMSYSERR_NOERROR)
 669                 {
 670                         Con_Print("Failed to write block to device\n");
 671                         FreeSound ();
 672                         return;
 673                 }
 674
 675                 paintpot -= WAV_BUFFER_SIZE;
 676         }
 677 }
 678
 679 /*
 680 ==============
 681 SNDDMA_Shutdown
 682
 683 Reset the sound device for exiting
 684 ===============
 685 */
 686 void SNDDMA_Shutdown(void)
 687 {
 688         FreeSound ();
 689 }
 690
 691
 692 static DWORD dsound_dwSize;
 693 static DWORD dsound_dwSize2;
 694 static DWORD *dsound_pbuf;
 695 static DWORD *dsound_pbuf2;
 696
 697 void *S_LockBuffer(void)
 698 {
 699         int reps;
 700         HRESULT hresult;
 701         DWORD   dwStatus;
 702
 703         if (pDSBuf)
 704         {
 705                 // if the buffer was lost or stopped, restore it and/or restart it
 706                 if (pDSBuf->lpVtbl->GetStatus (pDSBuf, &dwStatus) != DS_OK)
 707                         Con_Print("Couldn't get sound buffer status\n");
 708
 709                 if (dwStatus & DSBSTATUS_BUFFERLOST)
 710                         pDSBuf->lpVtbl->Restore (pDSBuf);
 711
 712                 if (!(dwStatus & DSBSTATUS_PLAYING))
 713                         pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
 714
 715                 reps = 0;
 716
 717                 while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, (LPVOID*)&dsound_pbuf, &dsound_dwSize, (LPVOID*)&dsound_pbuf2, &dsound_dwSize2, 0)) != DS_OK)
 718                 {
 719                         if (hresult != DSERR_BUFFERLOST)
 720                         {
 721                                 Con_Print("S_LockBuffer: DS: Lock Sound Buffer Failed\n");
 722                                 S_Shutdown ();
 723                                 S_Startup ();
 724                                 return NULL;
 725                         }
 726
 727                         if (++reps > 10000)
 728                         {
 729                                 Con_Print("S_LockBuffer: DS: couldn't restore buffer\n");
 730                                 S_Shutdown ();
 731                                 S_Startup ();
 732                                 return NULL;
 733                         }
 734                 }
 735                 return dsound_pbuf;
 736         }
 737         else if (wav_init)
 738                 return shm->buffer;
 739         else
 740                 return NULL;
 741 }
 742
 743 void S_UnlockBuffer(void)
 744 {
 745         if (pDSBuf)
 746                 pDSBuf->lpVtbl->Unlock(pDSBuf, dsound_pbuf, dsound_dwSize, dsound_pbuf2, dsound_dwSize2);
 747 }
 748