1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
6 * Copyright 1993 Martin Ayotte
7 * 1998-2002 Eric Pouech
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
36 #include "wine/debug.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(winmm
);
40 typedef struct tagWINE_PLAYSOUND
47 struct tagWINE_PLAYSOUND
* lpNext
;
50 static WINE_PLAYSOUND
*PlaySoundList
;
51 static BOOL bPlaySoundStop
;
53 static HMMIO
get_mmioFromFile(LPCWSTR lpszName
)
59 ret
= mmioOpenW((LPWSTR
)lpszName
, NULL
,
60 MMIO_ALLOCBUF
| MMIO_READ
| MMIO_DENYWRITE
);
61 if (ret
!= 0) return ret
;
62 if (SearchPathW(NULL
, lpszName
, NULL
, sizeof(buf
)/sizeof(buf
[0]), buf
, &dummy
))
64 return mmioOpenW(buf
, NULL
,
65 MMIO_ALLOCBUF
| MMIO_READ
| MMIO_DENYWRITE
);
70 static HMMIO
get_mmioFromProfile(UINT uFlags
, LPCWSTR lpszName
)
75 HKEY hRegSnd
, hRegApp
, hScheme
, hSnd
;
76 DWORD err
, type
, count
;
78 static const WCHAR wszSounds
[] = {'S','o','u','n','d','s',0};
79 static const WCHAR wszDefault
[] = {'D','e','f','a','u','l','t',0};
80 static const WCHAR wszKey
[] = {'A','p','p','E','v','e','n','t','s','\\',
81 'S','c','h','e','m','e','s','\\',
83 static const WCHAR wszDotDefault
[] = {'.','D','e','f','a','u','l','t',0};
84 static const WCHAR wszDotCurrent
[] = {'.','C','u','r','r','e','n','t',0};
85 static const WCHAR wszNull
[] = {0};
87 TRACE("searching in SystemSound list for %s\n", debugstr_w(lpszName
));
88 GetProfileStringW(wszSounds
, lpszName
, wszNull
, str
, sizeof(str
)/sizeof(str
[0]));
89 if (lstrlenW(str
) == 0)
91 if (uFlags
& SND_NODEFAULT
) goto next
;
92 GetProfileStringW(wszSounds
, wszDefault
, wszNull
, str
, sizeof(str
)/sizeof(str
[0]));
93 if (lstrlenW(str
) == 0) goto next
;
95 for (ptr
= str
; *ptr
&& *ptr
!= ','; ptr
++);
97 hmmio
= mmioOpenW(str
, NULL
, MMIO_ALLOCBUF
| MMIO_READ
| MMIO_DENYWRITE
);
98 if (hmmio
!= 0) return hmmio
;
100 /* we look up the registry under
101 * HKCU\AppEvents\Schemes\Apps\.Default
102 * HKCU\AppEvents\Schemes\Apps\<AppName>
104 if (RegOpenKeyW(HKEY_CURRENT_USER
, wszKey
, &hRegSnd
) != 0) goto none
;
105 if (uFlags
& SND_APPLICATION
)
110 len
= GetModuleFileNameW(0, str
, sizeof(str
)/sizeof(str
[0]));
111 if (len
> 0 && len
< sizeof(str
)/sizeof(str
[0]))
113 for (ptr
= str
+ lstrlenW(str
) - 1; ptr
>= str
; ptr
--)
115 if (*ptr
== '.') *ptr
= 0;
118 err
= RegOpenKeyW(hRegSnd
, ptr
+1, &hRegApp
);
126 err
= RegOpenKeyW(hRegSnd
, wszDotDefault
, &hRegApp
);
128 RegCloseKey(hRegSnd
);
129 if (err
!= 0) goto none
;
130 err
= RegOpenKeyW(hRegApp
, lpszName
, &hScheme
);
131 RegCloseKey(hRegApp
);
132 if (err
!= 0) goto none
;
133 /* what's the difference between .Current and .Default ? */
134 err
= RegOpenKeyW(hScheme
, wszDotDefault
, &hSnd
);
137 err
= RegOpenKeyW(hScheme
, wszDotCurrent
, &hSnd
);
138 RegCloseKey(hScheme
);
142 count
= sizeof(str
)/sizeof(str
[0]);
143 err
= RegQueryValueExW(hSnd
, NULL
, 0, &type
, (LPBYTE
)str
, &count
);
145 if (err
!= 0 || !*str
) goto none
;
146 hmmio
= mmioOpenW(str
, NULL
, MMIO_ALLOCBUF
| MMIO_READ
| MMIO_DENYWRITE
);
147 if (hmmio
) return hmmio
;
149 WARN("can't find SystemSound=%s !\n", debugstr_w(lpszName
));
153 struct playsound_data
159 static void CALLBACK
PlaySound_Callback(HWAVEOUT hwo
, UINT uMsg
,
160 DWORD_PTR dwInstance
,
161 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
163 struct playsound_data
* s
= (struct playsound_data
*)dwInstance
;
170 InterlockedIncrement(&s
->dwEventCount
);
171 TRACE("Returning waveHdr=%lx\n", dwParam1
);
175 ERR("Unknown uMsg=%d\n", uMsg
);
179 static void PlaySound_WaitDone(struct playsound_data
* s
)
182 if (InterlockedDecrement(&s
->dwEventCount
) >= 0) break;
183 InterlockedIncrement(&s
->dwEventCount
);
185 WaitForSingleObject(s
->hEvent
, INFINITE
);
189 static BOOL
PlaySound_IsString(DWORD fdwSound
, const void* psz
)
191 /* SND_RESOURCE is 0x40004 while
192 * SND_MEMORY is 0x00004
194 switch (fdwSound
& (SND_RESOURCE
|SND_ALIAS_ID
|SND_FILENAME
))
196 case SND_RESOURCE
: return HIWORD(psz
) != 0; /* by name or by ID ? */
198 case SND_MEMORY
: return FALSE
;
201 case SND_ALIAS
|SND_FILENAME
:
203 default: FIXME("WTF\n"); return FALSE
;
207 static void PlaySound_Free(WINE_PLAYSOUND
* wps
)
211 EnterCriticalSection(&WINMM_cs
);
212 for (p
= &PlaySoundList
; *p
&& *p
!= wps
; p
= &((*p
)->lpNext
));
213 if (*p
) *p
= (*p
)->lpNext
;
214 if (PlaySoundList
== NULL
) SetEvent(psLastEvent
);
215 LeaveCriticalSection(&WINMM_cs
);
216 if (wps
->bAlloc
) HeapFree(GetProcessHeap(), 0, (void*)wps
->pszSound
);
217 HeapFree(GetProcessHeap(), 0, wps
);
220 static WINE_PLAYSOUND
* PlaySound_Alloc(const void* pszSound
, HMODULE hmod
,
221 DWORD fdwSound
, BOOL bUnicode
)
225 wps
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*wps
));
226 if (!wps
) return NULL
;
229 wps
->fdwSound
= fdwSound
;
230 if (PlaySound_IsString(fdwSound
, pszSound
))
234 if (fdwSound
& SND_ASYNC
)
236 LPWSTR sound
= HeapAlloc(GetProcessHeap(), 0,
237 (lstrlenW(pszSound
)+1) * sizeof(WCHAR
));
238 if (!sound
) goto oom_error
;
239 wps
->pszSound
= lstrcpyW(sound
, pszSound
);
243 wps
->pszSound
= pszSound
;
247 UNICODE_STRING usBuffer
;
248 RtlCreateUnicodeStringFromAsciiz(&usBuffer
, pszSound
);
249 wps
->pszSound
= usBuffer
.Buffer
;
250 if (!wps
->pszSound
) goto oom_error
;
255 wps
->pszSound
= pszSound
;
259 if (wps
->bAlloc
) HeapFree(GetProcessHeap(), 0, (void*)wps
->pszSound
);
260 HeapFree(GetProcessHeap(), 0, wps
);
264 static DWORD WINAPI
proc_PlaySound(LPVOID arg
)
266 WINE_PLAYSOUND
* wps
= arg
;
271 LPWAVEFORMATEX lpWaveFormat
= NULL
;
273 LPWAVEHDR waveHdr
= NULL
;
274 INT count
, bufsize
, left
, index
;
275 struct playsound_data s
;
280 TRACE("SoundName=%s !\n", debugstr_w(wps
->pszSound
));
282 /* if resource, grab it */
283 if ((wps
->fdwSound
& SND_RESOURCE
) == SND_RESOURCE
) {
284 static const WCHAR wszWave
[] = {'W','A','V','E',0};
288 if ((hRes
= FindResourceW(wps
->hMod
, wps
->pszSound
, wszWave
)) == 0 ||
289 (hGlob
= LoadResource(wps
->hMod
, hRes
)) == 0)
291 if ((data
= LockResource(hGlob
)) == NULL
) {
297 data
= (void*)wps
->pszSound
;
299 /* construct an MMIO stream (either in memory, or from a file */
300 if (wps
->fdwSound
& SND_MEMORY
)
301 { /* NOTE: SND_RESOURCE has the SND_MEMORY bit set */
304 memset(&mminfo
, 0, sizeof(mminfo
));
305 mminfo
.fccIOProc
= FOURCC_MEM
;
306 mminfo
.pchBuffer
= data
;
307 mminfo
.cchBuffer
= -1; /* FIXME: when a resource, could grab real size */
308 TRACE("Memory sound %p\n", data
);
309 hmmio
= mmioOpenW(NULL
, &mminfo
, MMIO_READ
);
311 if (!hmmio
&& wps
->fdwSound
& SND_ALIAS
)
313 if ((wps
->fdwSound
& SND_ALIAS_ID
) == SND_ALIAS_ID
)
315 static const WCHAR wszSystemAsterisk
[] = {'S','y','s','t','e','m','A','s','t','e','r','i','s','k',0};
316 static const WCHAR wszSystemDefault
[] = {'S','y','s','t','e','m','D','e','f','a','u','l','t',0};
317 static const WCHAR wszSystemExclamation
[] = {'S','y','s','t','e','m','E','x','c','l','a','m','a','t','i','o','n',0};
318 static const WCHAR wszSystemExit
[] = {'S','y','s','t','e','m','E','x','i','t',0};
319 static const WCHAR wszSystemHand
[] = {'S','y','s','t','e','m','H','a','n','d',0};
320 static const WCHAR wszSystemQuestion
[] = {'S','y','s','t','e','m','Q','u','e','s','t','i','o','n',0};
321 static const WCHAR wszSystemStart
[] = {'S','y','s','t','e','m','S','t','a','r','t',0};
322 static const WCHAR wszSystemWelcome
[] = {'S','y','s','t','e','m','W','e','l','c','o','m','e',0};
324 wps
->fdwSound
&= ~(SND_ALIAS_ID
^ SND_ALIAS
);
325 if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMASTERISK
)
326 wps
->pszSound
= wszSystemAsterisk
;
327 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMDEFAULT
)
328 wps
->pszSound
= wszSystemDefault
;
329 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMEXCLAMATION
)
330 wps
->pszSound
= wszSystemExclamation
;
331 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMEXIT
)
332 wps
->pszSound
= wszSystemExit
;
333 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMHAND
)
334 wps
->pszSound
= wszSystemHand
;
335 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMQUESTION
)
336 wps
->pszSound
= wszSystemQuestion
;
337 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMSTART
)
338 wps
->pszSound
= wszSystemStart
;
339 else if (wps
->pszSound
== (LPCWSTR
)SND_ALIAS_SYSTEMWELCOME
)
340 wps
->pszSound
= wszSystemWelcome
;
341 else goto errCleanUp
;
343 hmmio
= get_mmioFromProfile(wps
->fdwSound
, wps
->pszSound
);
345 if (!hmmio
&& wps
->fdwSound
& SND_FILENAME
)
347 hmmio
= get_mmioFromFile(wps
->pszSound
);
349 if (!(wps
->fdwSound
& (SND_FILENAME
|SND_ALIAS
|SND_MEMORY
)))
351 if ((hmmio
= get_mmioFromProfile(wps
->fdwSound
| SND_NODEFAULT
, wps
->pszSound
)) == 0)
353 if ((hmmio
= get_mmioFromFile(wps
->pszSound
)) == 0)
355 hmmio
= get_mmioFromProfile(wps
->fdwSound
, wps
->pszSound
);
359 if (hmmio
== 0) goto errCleanUp
;
361 if (mmioDescend(hmmio
, &ckMainRIFF
, NULL
, 0))
364 TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08X\n",
365 (LPSTR
)&ckMainRIFF
.ckid
, (LPSTR
)&ckMainRIFF
.fccType
, ckMainRIFF
.cksize
);
367 if ((ckMainRIFF
.ckid
!= FOURCC_RIFF
) ||
368 (ckMainRIFF
.fccType
!= mmioFOURCC('W', 'A', 'V', 'E')))
371 mmckInfo
.ckid
= mmioFOURCC('f', 'm', 't', ' ');
372 if (mmioDescend(hmmio
, &mmckInfo
, &ckMainRIFF
, MMIO_FINDCHUNK
))
375 TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n",
376 (LPSTR
)&mmckInfo
.ckid
, mmckInfo
.fccType
, mmckInfo
.cksize
);
378 lpWaveFormat
= HeapAlloc(GetProcessHeap(), 0, mmckInfo
.cksize
);
381 if (mmioRead(hmmio
, (HPSTR
)lpWaveFormat
, mmckInfo
.cksize
) < sizeof(PCMWAVEFORMAT
))
384 TRACE("wFormatTag=%04X !\n", lpWaveFormat
->wFormatTag
);
385 TRACE("nChannels=%d\n", lpWaveFormat
->nChannels
);
386 TRACE("nSamplesPerSec=%d\n", lpWaveFormat
->nSamplesPerSec
);
387 TRACE("nAvgBytesPerSec=%d\n", lpWaveFormat
->nAvgBytesPerSec
);
388 TRACE("nBlockAlign=%d\n", lpWaveFormat
->nBlockAlign
);
389 TRACE("wBitsPerSample=%u !\n", lpWaveFormat
->wBitsPerSample
);
391 /* move to end of 'fmt ' chunk */
392 mmioAscend(hmmio
, &mmckInfo
, 0);
394 mmckInfo
.ckid
= mmioFOURCC('d', 'a', 't', 'a');
395 if (mmioDescend(hmmio
, &mmckInfo
, &ckMainRIFF
, MMIO_FINDCHUNK
))
398 TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n",
399 (LPSTR
)&mmckInfo
.ckid
, mmckInfo
.fccType
, mmckInfo
.cksize
);
401 s
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
405 if (waveOutOpen(&hWave
, WAVE_MAPPER
, lpWaveFormat
, (DWORD_PTR
)PlaySound_Callback
,
406 (DWORD_PTR
)&s
, CALLBACK_FUNCTION
) != MMSYSERR_NOERROR
)
409 /* make it so that 3 buffers per second are needed */
410 bufsize
= (((lpWaveFormat
->nAvgBytesPerSec
/ 3) - 1) / lpWaveFormat
->nBlockAlign
+ 1) *
411 lpWaveFormat
->nBlockAlign
;
412 waveHdr
= HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR
) + 2 * bufsize
);
415 waveHdr
[0].lpData
= (char*)waveHdr
+ 2 * sizeof(WAVEHDR
);
416 waveHdr
[1].lpData
= (char*)waveHdr
+ 2 * sizeof(WAVEHDR
) + bufsize
;
417 waveHdr
[0].dwUser
= waveHdr
[1].dwUser
= 0L;
418 waveHdr
[0].dwLoops
= waveHdr
[1].dwLoops
= 0L;
419 waveHdr
[0].dwFlags
= waveHdr
[1].dwFlags
= 0L;
420 waveHdr
[0].dwBufferLength
= waveHdr
[1].dwBufferLength
= bufsize
;
421 if (waveOutPrepareHeader(hWave
, &waveHdr
[0], sizeof(WAVEHDR
)) ||
422 waveOutPrepareHeader(hWave
, &waveHdr
[1], sizeof(WAVEHDR
))) {
426 s
.dwEventCount
= 1L; /* for first buffer */
430 left
= mmckInfo
.cksize
;
432 mmioSeek(hmmio
, mmckInfo
.dwDataOffset
, SEEK_SET
);
441 count
= mmioRead(hmmio
, waveHdr
[index
].lpData
, min(bufsize
, left
));
442 if (count
< 1) break;
444 waveHdr
[index
].dwBufferLength
= count
;
445 if (waveOutWrite(hWave
, &waveHdr
[index
], sizeof(WAVEHDR
)) == MMSYSERR_NOERROR
) {
447 PlaySound_WaitDone(&s
);
450 ERR("Aborting play loop, waveOutWrite error\n");
456 } while (wps
->bLoop
);
458 PlaySound_WaitDone(&s
); /* to balance first buffer */
461 waveOutUnprepareHeader(hWave
, &waveHdr
[0], sizeof(WAVEHDR
));
462 waveOutUnprepareHeader(hWave
, &waveHdr
[1], sizeof(WAVEHDR
));
465 TRACE("Done playing=%s => %s!\n", debugstr_w(wps
->pszSound
), bRet
? "ok" : "ko");
466 HeapFree(GetProcessHeap(), 0, lpWaveFormat
);
467 if (hWave
) while (waveOutClose(hWave
) == WAVERR_STILLPLAYING
) Sleep(100);
468 CloseHandle(s
.hEvent
);
469 HeapFree(GetProcessHeap(), 0, waveHdr
);
470 if (hmmio
) mmioClose(hmmio
, 0);
477 static BOOL
MULTIMEDIA_PlaySound(const void* pszSound
, HMODULE hmod
, DWORD fdwSound
, BOOL bUnicode
)
479 WINE_PLAYSOUND
* wps
= NULL
;
481 TRACE("pszSound='%p' hmod=%p fdwSound=%08X\n",
482 pszSound
, hmod
, fdwSound
);
484 /* SND_NOWAIT is ignored in w95/2k/xp. */
485 if ((fdwSound
& SND_NOSTOP
) && PlaySoundList
!= NULL
)
488 /* alloc internal structure, if we need to play something */
489 if (pszSound
&& !(fdwSound
& SND_PURGE
))
491 if (!(wps
= PlaySound_Alloc(pszSound
, hmod
, fdwSound
, bUnicode
)))
495 EnterCriticalSection(&WINMM_cs
);
496 /* since several threads can enter PlaySound in parallel, we're not
497 * sure, at this point, that another thread didn't start a new playsound
499 while (PlaySoundList
!= NULL
)
501 ResetEvent(psLastEvent
);
502 /* FIXME: doc says we have to stop all instances of pszSound if it's non
503 * NULL... as of today, we stop all playing instances */
504 bPlaySoundStop
= TRUE
;
506 LeaveCriticalSection(&WINMM_cs
);
507 WaitForSingleObject(psLastEvent
, INFINITE
);
508 EnterCriticalSection(&WINMM_cs
);
510 bPlaySoundStop
= FALSE
;
513 if (wps
) wps
->lpNext
= PlaySoundList
;
515 LeaveCriticalSection(&WINMM_cs
);
517 if (!wps
) return TRUE
;
519 if (fdwSound
& SND_ASYNC
)
522 wps
->bLoop
= (fdwSound
& SND_LOOP
) ? TRUE
: FALSE
;
523 if ((handle
= CreateThread(NULL
, 0, proc_PlaySound
, wps
, 0, NULL
)) != 0) {
524 SetThreadPriority(handle
, THREAD_PRIORITY_TIME_CRITICAL
);
529 else return proc_PlaySound(wps
);
536 /**************************************************************************
537 * PlaySoundA [WINMM.@]
539 BOOL WINAPI
PlaySoundA(LPCSTR pszSoundA
, HMODULE hmod
, DWORD fdwSound
)
541 return MULTIMEDIA_PlaySound(pszSoundA
, hmod
, fdwSound
, FALSE
);
544 /**************************************************************************
545 * PlaySoundW [WINMM.@]
547 BOOL WINAPI
PlaySoundW(LPCWSTR pszSoundW
, HMODULE hmod
, DWORD fdwSound
)
549 return MULTIMEDIA_PlaySound(pszSoundW
, hmod
, fdwSound
, TRUE
);
552 /**************************************************************************
553 * sndPlaySoundA [WINMM.@]
555 BOOL WINAPI
sndPlaySoundA(LPCSTR pszSoundA
, UINT uFlags
)
557 uFlags
&= SND_ASYNC
|SND_LOOP
|SND_MEMORY
|SND_NODEFAULT
|SND_NOSTOP
|SND_SYNC
;
558 return MULTIMEDIA_PlaySound(pszSoundA
, 0, uFlags
, FALSE
);
561 /**************************************************************************
562 * sndPlaySoundW [WINMM.@]
564 BOOL WINAPI
sndPlaySoundW(LPCWSTR pszSound
, UINT uFlags
)
566 uFlags
&= SND_ASYNC
|SND_LOOP
|SND_MEMORY
|SND_NODEFAULT
|SND_NOSTOP
|SND_SYNC
;
567 return MULTIMEDIA_PlaySound(pszSound
, 0, uFlags
, TRUE
);
570 /**************************************************************************
571 * mmsystemGetVersion [WINMM.@]
573 UINT WINAPI
mmsystemGetVersion(void)
575 TRACE("3.10 (Win95?)\n");