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