winquake.h is gone, absorbed into the respective files which used it, also cleaned...
[divverent/darkplaces.git] / 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->channels = 2;
198         shm->samplebits = 16;
199         i = COM_CheckParm ("-sndspeed"); // LordHavoc: -sndspeed option
200         if (i && i != (com_argc - 1))
201                 shm->speed = atoi(com_argv[i+1]);
202         else
203                 shm->speed = 44100;
204
205         memset (&format, 0, sizeof(format));
206         format.wFormatTag = WAVE_FORMAT_PCM;
207     format.nChannels = shm->channels;
208     format.wBitsPerSample = shm->samplebits;
209     format.nSamplesPerSec = shm->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_SafePrintf ("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_SafePrintf ("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_SafePrintf ("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_SafePrintf ("DirectSoundCreate failure\n"
248                                                         "  hardware already in use\n");
249                         return SIS_NOTAVAIL;
250                 }
251         }
252
253         dscaps.dwSize = sizeof(dscaps);
254
255         if (DS_OK != pDS->lpVtbl->GetCaps (pDS, &dscaps))
256         {
257                 Con_SafePrintf ("Couldn't get DS caps\n");
258         }
259
260         if (dscaps.dwFlags & DSCAPS_EMULDRIVER)
261         {
262                 Con_SafePrintf ("No DirectSound driver installed\n");
263                 FreeSound ();
264                 return SIS_FAILURE;
265         }
266
267         if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_EXCLUSIVE))
268         {
269                 Con_SafePrintf ("Set coop level failed\n");
270                 FreeSound ();
271                 return SIS_FAILURE;
272         }
273
274 // get access to the primary buffer, if possible, so we can set the
275 // sound hardware format
276         memset (&dsbuf, 0, sizeof(dsbuf));
277         dsbuf.dwSize = sizeof(DSBUFFERDESC);
278         dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER;
279         dsbuf.dwBufferBytes = 0;
280         dsbuf.lpwfxFormat = NULL;
281
282         memset(&dsbcaps, 0, sizeof(dsbcaps));
283         dsbcaps.dwSize = sizeof(dsbcaps);
284         primary_format_set = false;
285
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                                 if (snd_firsttime)
295                                         Con_SafePrintf ("Set primary sound buffer format: no\n");
296                         }
297                         else
298                         {
299                                 if (snd_firsttime)
300                                         Con_SafePrintf ("Set primary sound buffer format: yes\n");
301
302                                 primary_format_set = true;
303                         }
304                 }
305         }
306
307         if (!primary_format_set || !COM_CheckParm ("-primarysound"))
308         {
309         // create the secondary buffer we'll actually work with
310                 memset (&dsbuf, 0, sizeof(dsbuf));
311                 dsbuf.dwSize = sizeof(DSBUFFERDESC);
312                 dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY | DSBCAPS_LOCSOFTWARE;
313                 dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE;
314                 dsbuf.lpwfxFormat = &format;
315
316                 memset(&dsbcaps, 0, sizeof(dsbcaps));
317                 dsbcaps.dwSize = sizeof(dsbcaps);
318
319                 if (DS_OK != pDS->lpVtbl->CreateSoundBuffer(pDS, &dsbuf, &pDSBuf, NULL))
320                 {
321                         Con_SafePrintf ("DS:CreateSoundBuffer Failed");
322                         FreeSound ();
323                         return SIS_FAILURE;
324                 }
325
326                 shm->channels = format.nChannels;
327                 shm->samplebits = format.wBitsPerSample;
328                 shm->speed = format.nSamplesPerSec;
329
330                 if (DS_OK != pDSBuf->lpVtbl->GetCaps (pDSBuf, &dsbcaps))
331                 {
332                         Con_SafePrintf ("DS:GetCaps failed\n");
333                         FreeSound ();
334                         return SIS_FAILURE;
335                 }
336
337                 if (snd_firsttime)
338                         Con_SafePrintf ("Using secondary sound buffer\n");
339         }
340         else
341         {
342                 if (DS_OK != pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_WRITEPRIMARY))
343                 {
344                         Con_SafePrintf ("Set coop level failed\n");
345                         FreeSound ();
346                         return SIS_FAILURE;
347                 }
348
349                 if (DS_OK != pDSPBuf->lpVtbl->GetCaps (pDSPBuf, &dsbcaps))
350                 {
351                         Con_Printf ("DS:GetCaps failed\n");
352                         return SIS_FAILURE;
353                 }
354
355                 pDSBuf = pDSPBuf;
356                 Con_SafePrintf ("Using primary sound buffer\n");
357         }
358
359         // Make sure mixer is active
360         pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
361
362         if (snd_firsttime)
363                 Con_SafePrintf("   %d channel(s)\n"
364                                "   %d bits/sample\n"
365                                            "   %d samples/sec\n",
366                                            shm->channels, shm->samplebits, shm->speed);
367
368         gSndBufSize = dsbcaps.dwBufferBytes;
369
370 // initialize the buffer
371         reps = 0;
372
373         while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, (LPVOID*)&lpData, &dwSize, NULL, NULL, 0)) != DS_OK)
374         {
375                 if (hresult != DSERR_BUFFERLOST)
376                 {
377                         Con_SafePrintf ("SNDDMA_InitDirect: DS::Lock Sound Buffer Failed\n");
378                         FreeSound ();
379                         return SIS_FAILURE;
380                 }
381
382                 if (++reps > 10000)
383                 {
384                         Con_SafePrintf ("SNDDMA_InitDirect: DS: couldn't restore buffer\n");
385                         FreeSound ();
386                         return SIS_FAILURE;
387                 }
388
389         }
390
391         memset(lpData, 0, dwSize);
392
393         pDSBuf->lpVtbl->Unlock(pDSBuf, lpData, dwSize, NULL, 0);
394
395         /* we don't want anyone to access the buffer directly w/o locking it first. */
396         lpData = NULL;
397
398         pDSBuf->lpVtbl->Stop(pDSBuf);
399         pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &mmstarttime.u.sample, &dwWrite);
400         pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
401
402         shm->samples = gSndBufSize/(shm->samplebits/8);
403         shm->samplepos = 0;
404         shm->buffer = (unsigned char *) lpData;
405         sample16 = (shm->samplebits/8) - 1;
406
407         dsound_init = true;
408
409         return SIS_SUCCESS;
410 }
411
412
413 /*
414 ==================
415 SNDDM_InitWav
416
417 Crappy windows multimedia base
418 ==================
419 */
420 qboolean SNDDMA_InitWav (void)
421 {
422         WAVEFORMATEX  format;
423         int                             i;
424         HRESULT                 hr;
425
426         snd_sent = 0;
427         snd_completed = 0;
428
429         memset((void *)shm, 0, sizeof(*shm));
430         shm->channels = 2;
431         shm->samplebits = 16;
432         i = COM_CheckParm ("-sndspeed"); // LordHavoc: -sndspeed option
433         if (i && i != (com_argc - 1))
434                 shm->speed = atoi(com_argv[i+1]);
435         else
436                 shm->speed = 44100;
437
438         memset (&format, 0, sizeof(format));
439         format.wFormatTag = WAVE_FORMAT_PCM;
440         format.nChannels = shm->channels;
441         format.wBitsPerSample = shm->samplebits;
442         format.nSamplesPerSec = shm->speed;
443         format.nBlockAlign = format.nChannels
444                 *format.wBitsPerSample / 8;
445         format.cbSize = 0;
446         format.nAvgBytesPerSec = format.nSamplesPerSec
447                 *format.nBlockAlign;
448
449         /* Open a waveform device for output using window callback. */
450         while ((hr = waveOutOpen((LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,
451                                         &format,
452                                         0, 0L, CALLBACK_NULL)) != MMSYSERR_NOERROR)
453         {
454                 if (hr != MMSYSERR_ALLOCATED)
455                 {
456                         Con_SafePrintf ("waveOutOpen failed\n");
457                         return false;
458                 }
459
460                 if (MessageBox (NULL,
461                                                 "The sound hardware is in use by another app.\n\n"
462                                             "Select Retry to try to start sound again or Cancel to run Quake with no sound.",
463                                                 "Sound not available",
464                                                 MB_RETRYCANCEL | MB_SETFOREGROUND | MB_ICONEXCLAMATION) != IDRETRY)
465                 {
466                         Con_SafePrintf ("waveOutOpen failure;\n"
467                                                         "  hardware already in use\n");
468                         return false;
469                 }
470         }
471
472         /*
473          * Allocate and lock memory for the waveform data. The memory
474          * for waveform data must be globally allocated with
475          * GMEM_MOVEABLE and GMEM_SHARE flags.
476
477         */
478         gSndBufSize = WAV_BUFFERS*WAV_BUFFER_SIZE;
479         hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, gSndBufSize);
480         if (!hData)
481         {
482                 Con_SafePrintf ("Sound: Out of memory.\n");
483                 FreeSound ();
484                 return false;
485         }
486         lpData = GlobalLock(hData);
487         if (!lpData)
488         {
489                 Con_SafePrintf ("Sound: Failed to lock.\n");
490                 FreeSound ();
491                 return false;
492         }
493         memset (lpData, 0, gSndBufSize);
494
495         /*
496          * Allocate and lock memory for the header. This memory must
497          * also be globally allocated with GMEM_MOVEABLE and
498          * GMEM_SHARE flags.
499          */
500         hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
501                 (DWORD) sizeof(WAVEHDR) * WAV_BUFFERS);
502
503         if (hWaveHdr == NULL)
504         {
505                 Con_SafePrintf ("Sound: Failed to Alloc header.\n");
506                 FreeSound ();
507                 return false;
508         }
509
510         lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
511
512         if (lpWaveHdr == NULL)
513         {
514                 Con_SafePrintf ("Sound: Failed to lock header.\n");
515                 FreeSound ();
516                 return false;
517         }
518
519         memset (lpWaveHdr, 0, sizeof(WAVEHDR) * WAV_BUFFERS);
520
521         /* After allocation, set up and prepare headers. */
522         for (i=0 ; i<WAV_BUFFERS ; i++)
523         {
524                 lpWaveHdr[i].dwBufferLength = WAV_BUFFER_SIZE;
525                 lpWaveHdr[i].lpData = lpData + i*WAV_BUFFER_SIZE;
526
527                 if (waveOutPrepareHeader(hWaveOut, lpWaveHdr+i, sizeof(WAVEHDR)) !=
528                                 MMSYSERR_NOERROR)
529                 {
530                         Con_SafePrintf ("Sound: failed to prepare wave headers\n");
531                         FreeSound ();
532                         return false;
533                 }
534         }
535
536         shm->samples = gSndBufSize/(shm->samplebits/8);
537         shm->samplepos = 0;
538         shm->buffer = (unsigned char *) lpData;
539         sample16 = (shm->samplebits/8) - 1;
540
541         wav_init = true;
542
543         return true;
544 }
545
546 /*
547 ==================
548 SNDDMA_Init
549
550 Try to find a sound device to mix for.
551 Returns false if nothing is found.
552 ==================
553 */
554
555 qboolean SNDDMA_Init(void)
556 {
557         sndinitstat     stat;
558
559         if (COM_CheckParm ("-wavonly"))
560                 wavonly = true;
561
562         dsound_init = wav_init = 0;
563
564         stat = SIS_FAILURE;     // assume DirectSound won't initialize
565
566         /* Init DirectSound */
567         if (!wavonly)
568         {
569                 if (snd_firsttime || snd_isdirect)
570                 {
571                         stat = SNDDMA_InitDirect ();;
572
573                         if (stat == SIS_SUCCESS)
574                         {
575                                 snd_isdirect = true;
576
577                                 if (snd_firsttime)
578                                         Con_SafePrintf ("DirectSound initialized\n");
579                         }
580                         else
581                         {
582                                 snd_isdirect = false;
583                                 Con_SafePrintf ("DirectSound failed to init\n");
584                         }
585                 }
586         }
587
588 // if DirectSound didn't succeed in initializing, try to initialize
589 // waveOut sound, unless DirectSound failed because the hardware is
590 // already allocated (in which case the user has already chosen not
591 // to have sound)
592         if (!dsound_init && (stat != SIS_NOTAVAIL))
593         {
594                 if (snd_firsttime || snd_iswave)
595                 {
596
597                         snd_iswave = SNDDMA_InitWav ();
598
599                         if (snd_iswave)
600                         {
601                                 if (snd_firsttime)
602                                         Con_SafePrintf ("Wave sound initialized\n");
603                         }
604                         else
605                         {
606                                 Con_SafePrintf ("Wave sound failed to init\n");
607                         }
608                 }
609         }
610
611         snd_firsttime = false;
612
613         if (!dsound_init && !wav_init)
614                 return 0;
615
616         return 1;
617 }
618
619 /*
620 ==============
621 SNDDMA_GetDMAPos
622
623 return the current sample position (in mono samples read)
624 inside the recirculating dma buffer, so the mixing code will know
625 how many sample are required to fill it up.
626 ===============
627 */
628 int SNDDMA_GetDMAPos(void)
629 {
630         MMTIME  mmtime;
631         int             s;
632         DWORD   dwWrite;
633
634         if (dsound_init)
635         {
636                 mmtime.wType = TIME_SAMPLES;
637                 pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &mmtime.u.sample, &dwWrite);
638                 s = mmtime.u.sample - mmstarttime.u.sample;
639         }
640         else if (wav_init)
641         {
642                 s = snd_sent * WAV_BUFFER_SIZE;
643         }
644         else
645                 s = 0;
646
647
648         s >>= sample16;
649
650         s &= (shm->samples-1);
651
652         return s;
653 }
654
655 /*
656 ==============
657 SNDDMA_Submit
658
659 Send sound to device if buffer isn't really the dma buffer
660 ===============
661 */
662 void SNDDMA_Submit(void)
663 {
664         LPWAVEHDR       h;
665         int                     wResult;
666
667         if (!wav_init)
668                 return;
669
670         //
671         // find which sound blocks have completed
672         //
673         while (1)
674         {
675                 if ( snd_completed == snd_sent )
676                 {
677                         Con_DPrintf ("Sound overrun\n");
678                         break;
679                 }
680
681                 if ( ! (lpWaveHdr[ snd_completed & WAV_MASK].dwFlags & WHDR_DONE) )
682                 {
683                         break;
684                 }
685
686                 snd_completed++;        // this buffer has been played
687         }
688
689         //
690         // submit two new sound blocks
691         //
692         while (((snd_sent - snd_completed) >> sample16) < 4)
693         {
694                 h = lpWaveHdr + ( snd_sent&WAV_MASK );
695
696                 snd_sent++;
697                 /*
698                  * Now the data block can be sent to the output device. The
699                  * waveOutWrite function returns immediately and waveform
700                  * data is sent to the output device in the background.
701                  */
702                 wResult = waveOutWrite(hWaveOut, h, sizeof(WAVEHDR));
703
704                 if (wResult != MMSYSERR_NOERROR)
705                 {
706                         Con_SafePrintf ("Failed to write block to device\n");
707                         FreeSound ();
708                         return;
709                 }
710         }
711 }
712
713 /*
714 ==============
715 SNDDMA_Shutdown
716
717 Reset the sound device for exiting
718 ===============
719 */
720 void SNDDMA_Shutdown(void)
721 {
722         FreeSound ();
723 }
724
725 DWORD dsound_dwSize;
726 DWORD dsound_dwSize2;
727 DWORD *dsound_pbuf;
728 DWORD *dsound_pbuf2;
729 void *S_LockBuffer(void)
730 {
731         int reps;
732         HRESULT hresult;
733
734         if (pDSBuf)
735         {
736                 reps = 0;
737
738                 while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, (LPVOID*)&dsound_pbuf, &dsound_dwSize, (LPVOID*)&dsound_pbuf2, &dsound_dwSize2, 0)) != DS_OK)
739                 {
740                         if (hresult != DSERR_BUFFERLOST)
741                         {
742                                 Con_Printf ("S_LockBuffer: DS::Lock Sound Buffer Failed\n");
743                                 S_Shutdown ();
744                                 S_Startup ();
745                                 return NULL;
746                         }
747
748                         if (++reps > 10000)
749                         {
750                                 Con_Printf ("S_LockBuffer: DS: couldn't restore buffer\n");
751                                 S_Shutdown ();
752                                 S_Startup ();
753                                 return NULL;
754                         }
755                 }
756                 return dsound_pbuf;
757         }
758         else
759                 return shm->buffer;
760 }
761
762 void S_UnlockBuffer(void)
763 {
764         if (pDSBuf)
765                 pDSBuf->lpVtbl->Unlock(pDSBuf, dsound_pbuf, dsound_dwSize, dsound_pbuf2, dsound_dwSize2);
766 }
767