Started putting all 16 bit code in separate files.
This commit is contained in:
Eric Pouech
Alexandre Julliard
parent
a821a8f419
commit
57e6ba7009
|
|
@ -16,10 +16,12 @@ C_SRCS = \
|
|||
lolvldrv.c \
|
||||
mci.c \
|
||||
mmio.c \
|
||||
mmsystem.c \
|
||||
time.c
|
||||
playsound.c \
|
||||
time.c \
|
||||
winmm.c
|
||||
|
||||
C_SRCS16 = \
|
||||
mmsystem.c \
|
||||
sound16.c
|
||||
|
||||
RC_SRCS = winmm_res.rc
|
||||
|
|
|
|||
|
|
@ -2318,14 +2318,14 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
|
|||
TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
|
||||
|
||||
if (dwParam & MCI_NOTIFY)
|
||||
mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
|
||||
mciDriverNotify(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
|
||||
|
||||
return 0;
|
||||
errCleanUp:
|
||||
if (wmd) MCI_UnLoadMciDriver(iData, wmd);
|
||||
|
||||
if (dwParam & MCI_NOTIFY)
|
||||
mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
|
||||
mciDriverNotify(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
|
||||
return dwRet;
|
||||
}
|
||||
|
||||
|
|
@ -2366,8 +2366,8 @@ static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms
|
|||
MCI_UnLoadMciDriver(iData, wmd);
|
||||
|
||||
if (dwParam & MCI_NOTIFY)
|
||||
mciDriverNotify16(lpParms->dwCallback, wDevID,
|
||||
(dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
|
||||
mciDriverNotify(lpParms->dwCallback, wDevID,
|
||||
(dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
|
||||
|
||||
return dwRet;
|
||||
}
|
||||
|
|
@ -2490,8 +2490,8 @@ static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
|
|||
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
|
||||
|
||||
if (dwFlags & MCI_NOTIFY)
|
||||
mciDriverNotify16(lpParms->dwCallback, wDevID,
|
||||
(dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
|
||||
mciDriverNotify(lpParms->dwCallback, wDevID,
|
||||
(dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
|
||||
|
||||
return dwRet;
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,571 @@
|
|||
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
|
||||
|
||||
/*
|
||||
* MMSYTEM functions
|
||||
*
|
||||
* Copyright 1993 Martin Ayotte
|
||||
* 1998-2002 Eric Pouech
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "mmsystem.h"
|
||||
#include "winbase.h"
|
||||
#include "wingdi.h"
|
||||
#include "winuser.h"
|
||||
#include "heap.h"
|
||||
#include "winreg.h"
|
||||
#include "winemm.h"
|
||||
|
||||
#include "wine/debug.h"
|
||||
|
||||
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
|
||||
|
||||
static HMMIO get_mmioFromFile(LPCWSTR lpszName)
|
||||
{
|
||||
HMMIO ret;
|
||||
WCHAR buf[256];
|
||||
LPWSTR dummy;
|
||||
|
||||
ret = mmioOpenW((LPWSTR)lpszName, NULL,
|
||||
MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
|
||||
if (ret != 0) return ret;
|
||||
if (SearchPathW(NULL, lpszName, NULL, sizeof(buf)/sizeof(buf[0]), buf, &dummy))
|
||||
{
|
||||
return mmioOpenW(buf, NULL,
|
||||
MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HMMIO get_mmioFromProfile(UINT uFlags, LPCWSTR lpszName)
|
||||
{
|
||||
WCHAR str[128];
|
||||
LPWSTR ptr;
|
||||
HMMIO hmmio;
|
||||
HKEY hRegSnd, hRegApp, hScheme, hSnd;
|
||||
DWORD err, type, count;
|
||||
|
||||
static WCHAR wszSounds[] = {'S','o','u','n','d','s',0};
|
||||
static WCHAR wszDefault[] = {'D','e','f','a','u','l','t',0};
|
||||
static WCHAR wszKey[] = {'A','p','p','E','v','e','n','t','s','\\',
|
||||
'S','c','h','e','m','e','s','\\',
|
||||
'A','p','p','s',0};
|
||||
static WCHAR wszDotDefault[] = {'.','D','e','f','a','u','l','t',0};
|
||||
static WCHAR wszNull[] = {0};
|
||||
|
||||
TRACE("searching in SystemSound list for %s\n", debugstr_w(lpszName));
|
||||
GetProfileStringW(wszSounds, (LPWSTR)lpszName, wszNull, str, sizeof(str)/sizeof(str[0]));
|
||||
if (lstrlenW(str) == 0)
|
||||
{
|
||||
if (uFlags & SND_NODEFAULT) goto next;
|
||||
GetProfileStringW(wszSounds, wszDefault, wszNull, str, sizeof(str)/sizeof(str[0]));
|
||||
if (lstrlenW(str) == 0) goto next;
|
||||
}
|
||||
for (ptr = str; *ptr && *ptr != ','; ptr++);
|
||||
if (*ptr) *ptr = 0;
|
||||
hmmio = mmioOpenW(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
|
||||
if (hmmio != 0) return hmmio;
|
||||
next:
|
||||
/* we look up the registry under
|
||||
* HKCU\AppEvents\Schemes\Apps\.Default
|
||||
* HKCU\AppEvents\Schemes\Apps\<AppName>
|
||||
*/
|
||||
if (RegOpenKeyW(HKEY_CURRENT_USER, wszKey, &hRegSnd) != 0) goto none;
|
||||
if (uFlags & SND_APPLICATION)
|
||||
{
|
||||
err = 1; /* error */
|
||||
if (GetModuleFileNameW(0, str, sizeof(str)/sizeof(str[0])))
|
||||
{
|
||||
for (ptr = str + lstrlenW(str) - 1; ptr >= str; ptr--)
|
||||
{
|
||||
if (*ptr == '.') *ptr = 0;
|
||||
if (*ptr == '\\')
|
||||
{
|
||||
err = RegOpenKeyW(hRegSnd, str, &hRegApp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
err = RegOpenKeyW(hRegSnd, wszDotDefault, &hRegApp);
|
||||
}
|
||||
RegCloseKey(hRegSnd);
|
||||
if (err != 0) goto none;
|
||||
err = RegOpenKeyW(hRegApp, lpszName, &hScheme);
|
||||
RegCloseKey(hRegApp);
|
||||
if (err != 0) goto none;
|
||||
err = RegOpenKeyW(hScheme, wszDotDefault, &hSnd);
|
||||
RegCloseKey(hScheme);
|
||||
if (err != 0) goto none;
|
||||
count = sizeof(str)/sizeof(str[0]);
|
||||
err = RegQueryValueExW(hSnd, NULL, 0, &type, (LPBYTE)str, &count);
|
||||
RegCloseKey(hSnd);
|
||||
if (err != 0 || !*str) goto none;
|
||||
hmmio = mmioOpenW(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
|
||||
if (hmmio) return hmmio;
|
||||
none:
|
||||
WARN("can't find SystemSound='%s' !\n", debugstr_w(lpszName));
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct playsound_data
|
||||
{
|
||||
HANDLE hEvent;
|
||||
DWORD dwEventCount;
|
||||
};
|
||||
|
||||
static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg,
|
||||
DWORD dwInstance,
|
||||
DWORD dwParam1, DWORD dwParam2)
|
||||
{
|
||||
struct playsound_data* s = (struct playsound_data*)dwInstance;
|
||||
|
||||
switch (uMsg) {
|
||||
case WOM_OPEN:
|
||||
case WOM_CLOSE:
|
||||
break;
|
||||
case WOM_DONE:
|
||||
InterlockedIncrement(&s->dwEventCount);
|
||||
TRACE("Returning waveHdr=%lx\n", dwParam1);
|
||||
SetEvent(s->hEvent);
|
||||
break;
|
||||
default:
|
||||
ERR("Unknown uMsg=%d\n", uMsg);
|
||||
}
|
||||
}
|
||||
|
||||
static void PlaySound_WaitDone(struct playsound_data* s)
|
||||
{
|
||||
for (;;) {
|
||||
ResetEvent(s->hEvent);
|
||||
if (InterlockedDecrement(&s->dwEventCount) >= 0) break;
|
||||
InterlockedIncrement(&s->dwEventCount);
|
||||
|
||||
WaitForSingleObject(s->hEvent, INFINITE);
|
||||
}
|
||||
}
|
||||
|
||||
static BOOL PlaySound_IsString(DWORD fdwSound, const void* psz)
|
||||
{
|
||||
/* SND_RESOURCE is 0x40004 while
|
||||
* SND_MEMORY is 0x00004
|
||||
*/
|
||||
switch (fdwSound & (SND_RESOURCE|SND_ALIAS|SND_FILENAME))
|
||||
{
|
||||
case SND_RESOURCE: return HIWORD(psz) != 0; /* by name or by ID ? */
|
||||
case SND_MEMORY: return FALSE;
|
||||
case SND_ALIAS: /* what about ALIAS_ID ??? */
|
||||
case SND_FILENAME:
|
||||
case 0: return TRUE;
|
||||
default: FIXME("WTF\n"); return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
static void PlaySound_Free(WINE_PLAYSOUND* wps)
|
||||
{
|
||||
LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
|
||||
WINE_PLAYSOUND** p;
|
||||
|
||||
EnterCriticalSection(&iData->cs);
|
||||
for (p = &iData->lpPlaySound; *p && *p != wps; p = &((*p)->lpNext));
|
||||
if (*p) *p = (*p)->lpNext;
|
||||
if (iData->lpPlaySound == NULL) SetEvent(iData->psLastEvent);
|
||||
LeaveCriticalSection(&iData->cs);
|
||||
if (wps->bAlloc) HeapFree(GetProcessHeap(), 0, (void*)wps->pszSound);
|
||||
HeapFree(GetProcessHeap(), 0, wps);
|
||||
}
|
||||
|
||||
static WINE_PLAYSOUND* PlaySound_Alloc(const void* pszSound, HMODULE hmod,
|
||||
DWORD fdwSound, BOOL bUnicode)
|
||||
{
|
||||
WINE_PLAYSOUND* wps;
|
||||
|
||||
wps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wps));
|
||||
if (!wps) return NULL;
|
||||
|
||||
wps->hMod = hmod;
|
||||
wps->fdwSound = fdwSound;
|
||||
if (PlaySound_IsString(fdwSound, pszSound))
|
||||
{
|
||||
if (bUnicode)
|
||||
{
|
||||
if (fdwSound & SND_ASYNC)
|
||||
{
|
||||
wps->pszSound = HeapAlloc(GetProcessHeap(), 0,
|
||||
(lstrlenW(pszSound)+1) * sizeof(WCHAR));
|
||||
if (!wps->pszSound) goto oom_error;
|
||||
lstrcpyW((LPWSTR)wps->pszSound, pszSound);
|
||||
wps->bAlloc = TRUE;
|
||||
}
|
||||
else
|
||||
wps->pszSound = pszSound;
|
||||
}
|
||||
else
|
||||
{
|
||||
wps->pszSound = HEAP_strdupAtoW(GetProcessHeap(), 0, pszSound);
|
||||
if (!wps->pszSound) goto oom_error;
|
||||
wps->bAlloc = TRUE;
|
||||
}
|
||||
}
|
||||
else
|
||||
wps->pszSound = pszSound;
|
||||
|
||||
return wps;
|
||||
oom_error:
|
||||
PlaySound_Free(wps);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static DWORD WINAPI proc_PlaySound(LPVOID arg)
|
||||
{
|
||||
WINE_PLAYSOUND* wps = (WINE_PLAYSOUND*)arg;
|
||||
LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
|
||||
BOOL bRet = FALSE;
|
||||
HMMIO hmmio = 0;
|
||||
MMCKINFO ckMainRIFF;
|
||||
MMCKINFO mmckInfo;
|
||||
LPWAVEFORMATEX lpWaveFormat = NULL;
|
||||
HWAVEOUT hWave = 0;
|
||||
LPWAVEHDR waveHdr = NULL;
|
||||
INT count, bufsize, left, index;
|
||||
struct playsound_data s;
|
||||
void* data;
|
||||
|
||||
s.hEvent = 0;
|
||||
|
||||
TRACE("SoundName='%s' !\n", debugstr_w(wps->pszSound));
|
||||
|
||||
/* if resource, grab it */
|
||||
if ((wps->fdwSound & SND_RESOURCE) == SND_RESOURCE) {
|
||||
static WCHAR wszWave[] = {'W','A','V','E',0};
|
||||
HRSRC hRes;
|
||||
HGLOBAL hGlob;
|
||||
|
||||
if ((hRes = FindResourceW(wps->hMod, wps->pszSound, wszWave)) == 0 ||
|
||||
(hGlob = LoadResource(wps->hMod, hRes)) == 0)
|
||||
goto errCleanUp;
|
||||
if ((data = LockResource(hGlob)) == NULL) {
|
||||
FreeResource(hGlob);
|
||||
goto errCleanUp;
|
||||
}
|
||||
FreeResource(hGlob);
|
||||
} else
|
||||
data = (void*)wps->pszSound;
|
||||
|
||||
/* construct an MMIO stream (either in memory, or from a file */
|
||||
if (wps->fdwSound & SND_MEMORY)
|
||||
{ /* NOTE: SND_RESOURCE has the SND_MEMORY bit set */
|
||||
MMIOINFO mminfo;
|
||||
|
||||
memset(&mminfo, 0, sizeof(mminfo));
|
||||
mminfo.fccIOProc = FOURCC_MEM;
|
||||
mminfo.pchBuffer = (LPSTR)data;
|
||||
mminfo.cchBuffer = -1; /* FIXME: when a resource, could grab real size */
|
||||
TRACE("Memory sound %p\n", data);
|
||||
hmmio = mmioOpenW(NULL, &mminfo, MMIO_READ);
|
||||
}
|
||||
else if (wps->fdwSound & SND_ALIAS)
|
||||
{
|
||||
hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound);
|
||||
}
|
||||
else if (wps->fdwSound & SND_FILENAME)
|
||||
{
|
||||
hmmio = get_mmioFromFile(wps->pszSound);
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((hmmio = get_mmioFromProfile(wps->fdwSound | SND_NODEFAULT, wps->pszSound)) == 0)
|
||||
{
|
||||
if ((hmmio = get_mmioFromFile(wps->pszSound)) == 0)
|
||||
{
|
||||
hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (hmmio == 0) goto errCleanUp;
|
||||
|
||||
if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0))
|
||||
goto errCleanUp;
|
||||
|
||||
TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
|
||||
(LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
|
||||
|
||||
if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
|
||||
(ckMainRIFF.fccType != mmioFOURCC('W', 'A', 'V', 'E')))
|
||||
goto errCleanUp;
|
||||
|
||||
mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
|
||||
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
|
||||
goto errCleanUp;
|
||||
|
||||
TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
|
||||
(LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
|
||||
|
||||
lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
|
||||
if (mmioRead(hmmio, (HPSTR)lpWaveFormat, mmckInfo.cksize) < sizeof(WAVEFORMAT))
|
||||
goto errCleanUp;
|
||||
|
||||
TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag);
|
||||
TRACE("nChannels=%d \n", lpWaveFormat->nChannels);
|
||||
TRACE("nSamplesPerSec=%ld\n", lpWaveFormat->nSamplesPerSec);
|
||||
TRACE("nAvgBytesPerSec=%ld\n", lpWaveFormat->nAvgBytesPerSec);
|
||||
TRACE("nBlockAlign=%d \n", lpWaveFormat->nBlockAlign);
|
||||
TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample);
|
||||
|
||||
/* move to end of 'fmt ' chunk */
|
||||
mmioAscend(hmmio, &mmckInfo, 0);
|
||||
|
||||
mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
|
||||
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
|
||||
goto errCleanUp;
|
||||
|
||||
TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
|
||||
(LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
|
||||
|
||||
s.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
|
||||
if (waveOutOpen(&hWave, WAVE_MAPPER, lpWaveFormat, (DWORD)PlaySound_Callback,
|
||||
(DWORD)&s, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
|
||||
goto errCleanUp;
|
||||
|
||||
/* make it so that 3 buffers per second are needed */
|
||||
bufsize = (((lpWaveFormat->nAvgBytesPerSec / 3) - 1) / lpWaveFormat->nBlockAlign + 1) *
|
||||
lpWaveFormat->nBlockAlign;
|
||||
waveHdr = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR) + 2 * bufsize);
|
||||
waveHdr[0].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR);
|
||||
waveHdr[1].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR) + bufsize;
|
||||
waveHdr[0].dwUser = waveHdr[1].dwUser = 0L;
|
||||
waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L;
|
||||
waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L;
|
||||
waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize;
|
||||
if (waveOutPrepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
|
||||
waveOutPrepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR))) {
|
||||
goto errCleanUp;
|
||||
}
|
||||
|
||||
s.dwEventCount = 1L; /* for first buffer */
|
||||
|
||||
do {
|
||||
index = 0;
|
||||
left = mmckInfo.cksize;
|
||||
|
||||
mmioSeek(hmmio, mmckInfo.dwDataOffset, SEEK_SET);
|
||||
while (left)
|
||||
{
|
||||
if (WaitForSingleObject(iData->psStopEvent, 0) == WAIT_OBJECT_0)
|
||||
{
|
||||
wps->bLoop = FALSE;
|
||||
break;
|
||||
}
|
||||
count = mmioRead(hmmio, waveHdr[index].lpData, min(bufsize, left));
|
||||
if (count < 1) break;
|
||||
left -= count;
|
||||
waveHdr[index].dwBufferLength = count;
|
||||
waveHdr[index].dwFlags &= ~WHDR_DONE;
|
||||
if (waveOutWrite(hWave, &waveHdr[index], sizeof(WAVEHDR)) == MMSYSERR_NOERROR) {
|
||||
index ^= 1;
|
||||
PlaySound_WaitDone(&s);
|
||||
}
|
||||
else FIXME("Couldn't play header\n");
|
||||
}
|
||||
bRet = TRUE;
|
||||
} while (wps->bLoop);
|
||||
|
||||
PlaySound_WaitDone(&s); /* for last buffer */
|
||||
waveOutReset(hWave);
|
||||
|
||||
waveOutUnprepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR));
|
||||
waveOutUnprepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR));
|
||||
|
||||
errCleanUp:
|
||||
TRACE("Done playing='%s' => %s!\n", debugstr_w(wps->pszSound), bRet ? "ok" : "ko");
|
||||
CloseHandle(s.hEvent);
|
||||
if (waveHdr) HeapFree(GetProcessHeap(), 0, waveHdr);
|
||||
if (lpWaveFormat) HeapFree(GetProcessHeap(), 0, lpWaveFormat);
|
||||
if (hWave) while (waveOutClose(hWave) == WAVERR_STILLPLAYING) Sleep(100);
|
||||
if (hmmio) mmioClose(hmmio, 0);
|
||||
|
||||
PlaySound_Free(wps);
|
||||
|
||||
return bRet;
|
||||
}
|
||||
|
||||
BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSound, BOOL bUnicode)
|
||||
{
|
||||
WINE_PLAYSOUND* wps = NULL;
|
||||
LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
|
||||
|
||||
TRACE("pszSound='%p' hmod=%04X fdwSound=%08lX\n",
|
||||
pszSound, hmod, fdwSound);
|
||||
|
||||
/* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP !
|
||||
* there could be one if several sounds can be played at once...
|
||||
*/
|
||||
if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && iData->lpPlaySound != NULL)
|
||||
return FALSE;
|
||||
|
||||
/* alloc internal structure, if we need to play something */
|
||||
if (pszSound && !(fdwSound & SND_PURGE))
|
||||
{
|
||||
if (!(wps = PlaySound_Alloc(pszSound, hmod, fdwSound, bUnicode)))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
EnterCriticalSection(&iData->cs);
|
||||
/* since several threads can enter PlaySound in parallel, we're not
|
||||
* sure, at this point, that another thread didn't start a new playsound
|
||||
*/
|
||||
while (iData->lpPlaySound != NULL)
|
||||
{
|
||||
ResetEvent(iData->psLastEvent);
|
||||
/* FIXME: doc says we have to stop all instances of pszSound if it's non
|
||||
* NULL... as of today, we stop all playing instances */
|
||||
SetEvent(iData->psStopEvent);
|
||||
|
||||
LeaveCriticalSection(&iData->cs);
|
||||
WaitForSingleObject(iData->psLastEvent, INFINITE);
|
||||
EnterCriticalSection(&iData->cs);
|
||||
|
||||
ResetEvent(iData->psStopEvent);
|
||||
}
|
||||
|
||||
if (wps) wps->lpNext = iData->lpPlaySound;
|
||||
iData->lpPlaySound = wps;
|
||||
LeaveCriticalSection(&iData->cs);
|
||||
|
||||
if (!pszSound || (fdwSound & SND_PURGE)) return TRUE;
|
||||
|
||||
if (fdwSound & SND_ASYNC)
|
||||
{
|
||||
DWORD id;
|
||||
wps->bLoop = (fdwSound & SND_LOOP) ? TRUE : FALSE;
|
||||
if (CreateThread(NULL, 0, proc_PlaySound, wps, 0, &id) != 0)
|
||||
return TRUE;
|
||||
}
|
||||
else return proc_PlaySound(wps);
|
||||
|
||||
/* error cases */
|
||||
PlaySound_Free(wps);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* PlaySoundA [WINMM.@]
|
||||
*/
|
||||
BOOL WINAPI PlaySoundA(LPCSTR pszSoundA, HMODULE hmod, DWORD fdwSound)
|
||||
{
|
||||
return MULTIMEDIA_PlaySound(pszSoundA, hmod, fdwSound, FALSE);
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* PlaySoundW [WINMM.@]
|
||||
*/
|
||||
BOOL WINAPI PlaySoundW(LPCWSTR pszSoundW, HMODULE hmod, DWORD fdwSound)
|
||||
{
|
||||
return MULTIMEDIA_PlaySound(pszSoundW, hmod, fdwSound, TRUE);
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* sndPlaySoundA [WINMM.@]
|
||||
*/
|
||||
BOOL WINAPI sndPlaySoundA(LPCSTR pszSoundA, UINT uFlags)
|
||||
{
|
||||
uFlags &= SND_ASYNC|SND_LOOP|SND_MEMORY|SND_NODEFAULT|SND_NOSTOP|SND_SYNC;
|
||||
return MULTIMEDIA_PlaySound(pszSoundA, 0, uFlags, FALSE);
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* sndPlaySoundW [WINMM.@]
|
||||
*/
|
||||
BOOL WINAPI sndPlaySoundW(LPCWSTR pszSound, UINT uFlags)
|
||||
{
|
||||
uFlags &= SND_ASYNC|SND_LOOP|SND_MEMORY|SND_NODEFAULT|SND_NOSTOP|SND_SYNC;
|
||||
return MULTIMEDIA_PlaySound(pszSound, 0, uFlags, TRUE);
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* mmsystemGetVersion [WINMM.@]
|
||||
*/
|
||||
UINT WINAPI mmsystemGetVersion(void)
|
||||
{
|
||||
TRACE("3.10 (Win95?)\n");
|
||||
return 0x030a;
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* DriverCallback [WINMM.@]
|
||||
*/
|
||||
BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
|
||||
UINT wMsg, DWORD dwUser, DWORD dwParam1,
|
||||
DWORD dwParam2)
|
||||
{
|
||||
TRACE("(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
|
||||
dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
|
||||
|
||||
switch (uFlags & DCB_TYPEMASK) {
|
||||
case DCB_NULL:
|
||||
TRACE("Null !\n");
|
||||
if (dwCallBack)
|
||||
WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
|
||||
break;
|
||||
case DCB_WINDOW:
|
||||
TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
|
||||
PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
|
||||
break;
|
||||
case DCB_TASK: /* aka DCB_THREAD */
|
||||
TRACE("Task(%04lx) !\n", dwCallBack);
|
||||
PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
|
||||
break;
|
||||
case DCB_FUNCTION:
|
||||
TRACE("Function (32 bit) !\n");
|
||||
((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
|
||||
break;
|
||||
case DCB_EVENT:
|
||||
TRACE("Event(%08lx) !\n", dwCallBack);
|
||||
SetEvent((HANDLE)dwCallBack);
|
||||
break;
|
||||
case 6: /* I would dub it DCB_MMTHREADSIGNAL */
|
||||
/* this is an undocumented DCB_ value used for mmThreads
|
||||
* loword of dwCallBack contains the handle of the lpMMThd block
|
||||
* which dwSignalCount has to be incremented
|
||||
*/
|
||||
{
|
||||
WINE_MMTHREAD* lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
|
||||
|
||||
TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
|
||||
/* same as mmThreadSignal16 */
|
||||
InterlockedIncrement(&lpMMThd->dwSignalCount);
|
||||
SetEvent(lpMMThd->hEvent);
|
||||
/* some other stuff on lpMMThd->hVxD */
|
||||
}
|
||||
break;
|
||||
#if 0
|
||||
case 4:
|
||||
/* this is an undocumented DCB_ value for... I don't know */
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
|
||||
return FALSE;
|
||||
}
|
||||
TRACE("Done\n");
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -221,8 +221,22 @@ void CALLBACK WINE_mmThreadEntryPoint(DWORD _pmt);
|
|||
void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16);
|
||||
void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32);
|
||||
|
||||
UINT MMSYSTEM_mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
|
||||
DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32);
|
||||
UINT MMSYSTEM_midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback,
|
||||
DWORD dwInstance, DWORD dwFlags, BOOL bFrom32);
|
||||
UINT MMSYSTEM_midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD dwCallback,
|
||||
DWORD dwInstance, DWORD dwFlags, BOOL bFrom32);
|
||||
MMRESULT MMSYSTEM_MidiStream_Open(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
|
||||
DWORD cMidi, DWORD dwCallback,
|
||||
DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32);
|
||||
UINT MMSYSTEM_waveOpen(HANDLE* lphndl, UINT uDeviceID, UINT uType,
|
||||
const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
|
||||
DWORD dwInstance, DWORD dwFlags, BOOL bFrom32);
|
||||
|
||||
BOOL MULTIMEDIA_MciInit(void);
|
||||
LPWINE_MM_IDATA MULTIMEDIA_GetIData(void);
|
||||
BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSound, BOOL bUnicode);
|
||||
|
||||
LPWINE_MM_IDATA TIME_MMTimeStart(void);
|
||||
void TIME_MMTimeStop(void);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue