[ros-diffs] [tkreuzer] 41121: MmGrowKernelStack: go back to the ASSERT and add a fixed check

Author: tkreuzer
Date: Tue May 26 02:38:00 2009
New Revision: 41121

URL: http://svn.reactos.org/svn/reactos?rev=41121&view=rev
Log:
MmGrowKernelStack: go back to the ASSERT and add a fixed check

Added:
    trunk/reactos/dll/win32/msacm32/msacm32.drv/   (with props)
    trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.rbuild   (with props)
    trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.spec   (with props)
    trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.c   (with props)
    trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.rc   (with props)
Removed:
    trunk/reactos/dll/win32/winmm/wavemap/
Modified:
    trunk/reactos/boot/bootdata/packages/reactos.dff
    trunk/reactos/dll/win32/msacm32/msacm32.rbuild
    trunk/reactos/dll/win32/winmm/winmm.rbuild

Modified: trunk/reactos/boot/bootdata/packages/reactos.dff
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/bootdata/packages/rea…
==============================================================================
--- trunk/reactos/boot/bootdata/packages/reactos.dff [iso-8859-1] (original)
+++ trunk/reactos/boot/bootdata/packages/reactos.dff [iso-8859-1] Tue May 26 02:38:00
2009
@@ -319,6 +319,7 @@
 dll\win32\mpr\mpr.dll                               1
 dll\win32\mprapi\mprapi.dll                         1
 dll\win32\msacm32\msacm32.dll                       1
+dll\win32\msacm32\msacm32.drv\msacm32.drv           1
 dll\win32\msadp32.acm\msadp32.acm                   1
 dll\win32\msafd\msafd.dll                           1
 dll\win32\mscat32\mscat32.dll                       1
@@ -455,7 +456,6 @@
 dll\win32\xinput1_3\xinput1_3.dll                   1
 dll\win32\xinput9_1_0\xinput9_1_0.dll               1
 dll\win32\winmm\midimap\midimap.dll                 1
-dll\win32\winmm\wavemap\msacm32.drv                 1   optional
 dll\win32\wdmaud.drv\wdmaud.drv                     1
 
 ; Shell Extensions

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/
------------------------------------------------------------------------------
--- bugtraq:logregex (added)
+++ bugtraq:logregex Tue May 26 02:38:00 2009
@@ -1,0 +1,2 @@
+([Ii]ssue|[Bb]ug)s? #?(\d+)(,? ?#?(\d+))*(,? ?(and |or )?#?(\d+))?
+(\d+)

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/
------------------------------------------------------------------------------
    bugtraq:message = See issue #%BUGID% for more details.

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/
------------------------------------------------------------------------------
    bugtraq:url = http://www.reactos.org/bugzilla/show_bug.cgi?id=%BUGID%

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/
------------------------------------------------------------------------------
    tsvn:logminsize = 10

Added: trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msacm32/msacm32.…
==============================================================================
--- trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.rbuild (added)
+++ trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.rbuild [iso-8859-1] Tue May 26
02:38:00 2009
@@ -1,0 +1,13 @@
+<module name="msacm32.drv" type="win32dll"
entrypoint="0" extension=".drv"
baseaddress="${BASEADDRESS_WAVEMAP}" installbase="system32"
installname="msacm32.drv" unicode="yes">
+	<importlibrary definition="msacm32.drv.spec" />
+	<include base="msacm32.drv">.</include>
+	<include base="ReactOS">include/reactos/wine</include>
+	<library>wine</library>
+	<library>msacm32</library>
+	<library>ntdll</library>
+	<library>kernel32</library>
+	<library>user32</library>
+	<library>winmm</library>
+	<file>wavemap.c</file>
+	<file>wavemap.rc</file>
+</module>

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.rbuild
------------------------------------------------------------------------------
    svn:eol-style = native

Added: trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.spec
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msacm32/msacm32.…
==============================================================================
--- trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.spec (added)
+++ trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.spec [iso-8859-1] Tue May 26
02:38:00 2009
@@ -1,0 +1,3 @@
+@ stdcall -private DriverProc(long long long long long) WAVEMAP_DriverProc
+@ stdcall -private widMessage(long long long long long) WAVEMAP_widMessage
+@ stdcall -private wodMessage(long long long long long) WAVEMAP_wodMessage

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/msacm32.drv.spec
------------------------------------------------------------------------------
    svn:eol-style = native

Added: trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msacm32/msacm32.…
==============================================================================
--- trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.c (added)
+++ trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.c [iso-8859-1] Tue May 26 02:38:00
2009
@@ -1,0 +1,1242 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/*
+ * Wine Wave mapper driver
+ *
+ * Copyright 	1999,2001 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* TODOs
+ *	+ better protection against evilish dwUser parameters
+ *	+ use asynchronous ACM conversion
+ *	+ don't use callback functions when none is required in open
+ *	+ the buffer sizes may not be accurate, so there may be some
+ *	  remaining bytes in src and dst buffers after ACM conversions...
+ *		those should be taken care of...
+ */
+
+#include <stdarg.h>
+#include <string.h>
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "mmddk.h"
+#include "mmreg.h"
+#include "msacm.h"
+#include "wine/unicode.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wavemap);
+
+typedef	struct tagWAVEMAPDATA {
+    struct tagWAVEMAPDATA*	self;
+    union {
+        struct {
+            HWAVEOUT	hOuterWave;
+            HWAVEOUT	hInnerWave;
+        } out;
+        struct {
+            HWAVEIN	hOuterWave;
+            HWAVEIN	hInnerWave;
+        } in;
+    } u;
+    HACMSTREAM	hAcmStream;
+    /* needed data to filter callbacks. Only needed when hAcmStream is not 0 */
+    DWORD_PTR	dwCallback;
+    DWORD_PTR	dwClientInstance;
+    DWORD	dwFlags;
+    /* ratio to compute position from a PCM playback to any format */
+    DWORD       avgSpeedOuter;
+    DWORD       avgSpeedInner;
+    /* channel size of inner and outer */
+    DWORD       nSamplesPerSecOuter;
+    DWORD       nSamplesPerSecInner;
+} WAVEMAPDATA;
+
+static	BOOL	WAVEMAP_IsData(const WAVEMAPDATA* wm)
+{
+    return (!IsBadReadPtr(wm, sizeof(WAVEMAPDATA)) && wm->self == wm);
+}
+
+/*======================================================================*
+ *                  WAVE OUT part                                       *
+ *======================================================================*/
+
+static void CALLBACK wodCallback(HWAVEOUT hWave, UINT uMsg, DWORD_PTR dwInstance,
+                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+    WAVEMAPDATA*	wom = (WAVEMAPDATA*)dwInstance;
+
+    TRACE("(%p %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1,
dwParam2);
+
+    if (!WAVEMAP_IsData(wom)) {
+	ERR("Bad data\n");
+	return;
+    }
+
+    if (uMsg != WOM_OPEN && hWave != wom->u.out.hInnerWave)
+	ERR("Shouldn't happen (%p %p)\n", hWave, wom->u.out.hInnerWave);
+
+    switch (uMsg) {
+    case WOM_OPEN:
+    case WOM_CLOSE:
+	/* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
+	break;
+    case WOM_DONE:
+	if (wom->hAcmStream) {
+	    LPWAVEHDR		lpWaveHdrDst = (LPWAVEHDR)dwParam1;
+	    PACMSTREAMHEADER	ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrDst -
sizeof(ACMSTREAMHEADER));
+	    LPWAVEHDR		lpWaveHdrSrc = (LPWAVEHDR)ash->dwUser;
+
+	    lpWaveHdrSrc->dwFlags &= ~WHDR_INQUEUE;
+	    lpWaveHdrSrc->dwFlags |= WHDR_DONE;
+            dwParam1 = (DWORD_PTR)lpWaveHdrSrc;
+	}
+	break;
+    default:
+	ERR("Unknown msg %u\n", uMsg);
+    }
+
+    DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags),
(HDRVR)wom->u.out.hOuterWave,
+		   uMsg, wom->dwClientInstance, dwParam1, dwParam2);
+}
+
+/******************************************************************
+ *		wodOpenHelper
+ *
+ *
+ */
+static	DWORD	wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
+			      LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
+			      DWORD dwFlags)
+{
+    DWORD	ret;
+
+    TRACE("(%p %04x %p %p %08x)\n", wom, idx, lpDesc, lpwfx, dwFlags);
+
+    /* destination is always PCM, so the formulas below apply */
+    lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
+    lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
+    if (dwFlags & WAVE_FORMAT_QUERY) {
+	ret = acmStreamOpen(NULL, 0, lpDesc->lpFormat, lpwfx, NULL, 0L, 0L,
ACM_STREAMOPENF_QUERY);
+    } else {
+	ret = acmStreamOpen(&wom->hAcmStream, 0, lpDesc->lpFormat, lpwfx, NULL, 0L,
0L, 0L);
+    }
+    if (ret == MMSYSERR_NOERROR) {
+        ret = waveOutOpen(&wom->u.out.hInnerWave, idx, lpwfx,
+                          (DWORD_PTR)wodCallback, (DWORD_PTR)wom,
+                          (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
+	if (ret != MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY)) {
+	    acmStreamClose(wom->hAcmStream, 0);
+	    wom->hAcmStream = 0;
+	}
+    }
+    TRACE("ret = %08x\n", ret);
+    return ret;
+}
+
+static	DWORD	wodOpen(DWORD_PTR *lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+{
+    UINT 		ndlo, ndhi;
+    UINT		i;
+    WAVEMAPDATA*	wom = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
+    DWORD               res;
+
+    TRACE("(%p %p %08x)\n", lpdwUser, lpDesc, dwFlags);
+
+    if (!wom) {
+        WARN("no memory\n");
+	return MMSYSERR_NOMEM;
+    }
+
+    ndhi = waveOutGetNumDevs();
+    if (dwFlags & WAVE_MAPPED) {
+	if (lpDesc->uMappedDeviceID >= ndhi) {
+            WARN("invalid parameter: dwFlags WAVE_MAPPED\n");
+            HeapFree(GetProcessHeap(), 0, wom);
+            return MMSYSERR_INVALPARAM;
+        }
+	ndlo = lpDesc->uMappedDeviceID;
+	ndhi = ndlo + 1;
+	dwFlags &= ~WAVE_MAPPED;
+    } else {
+	ndlo = 0;
+    }
+    wom->self = wom;
+    wom->dwCallback = lpDesc->dwCallback;
+    wom->dwFlags = dwFlags;
+    wom->dwClientInstance = lpDesc->dwInstance;
+    wom->u.out.hOuterWave = (HWAVEOUT)lpDesc->hWave;
+    wom->avgSpeedOuter = wom->avgSpeedInner =
lpDesc->lpFormat->nAvgBytesPerSec;
+    wom->nSamplesPerSecOuter = wom->nSamplesPerSecInner =
lpDesc->lpFormat->nSamplesPerSec;
+
+    for (i = ndlo; i < ndhi; i++) {
+	/* if no ACM stuff is involved, no need to handle callbacks at this
+	 * level, this will be done transparently
+	 */
+        if (waveOutOpen(&wom->u.out.hInnerWave, i, lpDesc->lpFormat,
+                        (DWORD_PTR)wodCallback, (DWORD_PTR)wom,
+                        (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION |
WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
+	    wom->hAcmStream = 0;
+	    goto found;
+	}
+    }
+
+    if ((dwFlags & WAVE_FORMAT_DIRECT) == 0) {
+        WAVEFORMATEX	wfx;
+
+        wfx.wFormatTag = WAVE_FORMAT_PCM;
+        wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case
*/
+        /* try some ACM stuff */
+
+#define	TRY(sps,bps)    wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
+                        switch (res=wodOpenHelper(wom, i, lpDesc, &wfx, dwFlags |
WAVE_FORMAT_DIRECT)) { \
+                            case MMSYSERR_NOERROR: wom->avgSpeedInner =
wfx.nAvgBytesPerSec; wom->nSamplesPerSecInner = wfx.nSamplesPerSec; goto found; \
+                            case WAVERR_BADFORMAT: break; \
+                            default: goto error; \
+                        }
+
+        if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
+            /* Format changed so keep sample rate and number of channels 
+             * the same and just change the bit depth
+             */
+            for (i = ndlo; i < ndhi; i++) {
+                wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
+                wfx.nChannels = lpDesc->lpFormat->nChannels;
+                TRY(wfx.nSamplesPerSec, 16);
+                TRY(wfx.nSamplesPerSec, 8);
+            }
+        } else {
+            /* Our resampling algorithm is quite primitive so first try
+             * to just change the bit depth and number of channels
+             */
+            for (i = ndlo; i < ndhi; i++) {
+                wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
+                wfx.nChannels = lpDesc->lpFormat->nChannels;
+                TRY(wfx.nSamplesPerSec, 16);
+                TRY(wfx.nSamplesPerSec, 8);
+                wfx.nChannels ^= 3;
+                TRY(wfx.nSamplesPerSec, 16);
+                TRY(wfx.nSamplesPerSec, 8);
+            }
+
+            for (i = ndlo; i < ndhi; i++) {
+                /* first try with same stereo/mono option as source */
+                wfx.nChannels = lpDesc->lpFormat->nChannels;
+                TRY(96000, 16);
+                TRY(48000, 16);
+                TRY(44100, 16);
+                TRY(22050, 16);
+                TRY(11025, 16);
+
+                /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way
around) */
+                wfx.nChannels ^= 3;
+                TRY(96000, 16);
+                TRY(48000, 16);
+                TRY(44100, 16);
+                TRY(22050, 16);
+                TRY(11025, 16);
+
+                /* first try with same stereo/mono option as source */
+                wfx.nChannels = lpDesc->lpFormat->nChannels;
+                TRY(96000, 8);
+                TRY(48000, 8);
+                TRY(44100, 8);
+                TRY(22050, 8);
+                TRY(11025, 8);
+
+                /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way
around) */
+                wfx.nChannels ^= 3;
+                TRY(96000, 8);
+                TRY(48000, 8);
+                TRY(44100, 8);
+                TRY(22050, 8);
+                TRY(11025, 8);
+            }
+        }
+#undef TRY
+    }
+
+    HeapFree(GetProcessHeap(), 0, wom);
+    WARN("ret = WAVERR_BADFORMAT\n");
+    return WAVERR_BADFORMAT;
+
+found:
+    if (dwFlags & WAVE_FORMAT_QUERY) {
+	*lpdwUser = 0L;
+	HeapFree(GetProcessHeap(), 0, wom);
+    } else {
+        *lpdwUser = (DWORD_PTR)wom;
+    }
+    return MMSYSERR_NOERROR;
+error:
+    HeapFree(GetProcessHeap(), 0, wom);
+    if (res==ACMERR_NOTPOSSIBLE) {
+        WARN("ret = WAVERR_BADFORMAT\n");
+        return WAVERR_BADFORMAT;
+    }
+    WARN("ret = 0x%08x\n", res);
+    return res;
+}
+
+static	DWORD	wodClose(WAVEMAPDATA* wom)
+{
+    DWORD ret;
+
+    TRACE("(%p)\n", wom);
+
+    ret = waveOutClose(wom->u.out.hInnerWave);
+    if (ret == MMSYSERR_NOERROR) {
+	if (wom->hAcmStream) {
+	    ret = acmStreamClose(wom->hAcmStream, 0);
+	}
+	if (ret == MMSYSERR_NOERROR) {
+	    HeapFree(GetProcessHeap(), 0, wom);
+	}
+    }
+    return ret;
+}
+
+static	DWORD	wodWrite(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
+{
+    PACMSTREAMHEADER	ash;
+    LPWAVEHDR		lpWaveHdrDst;
+
+    TRACE("(%p %p %08x)\n", wom, lpWaveHdrSrc, dwParam2);
+
+    if (!wom->hAcmStream) {
+	return waveOutWrite(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
+    }
+
+    lpWaveHdrSrc->dwFlags |= WHDR_INQUEUE;
+    ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
+    /* acmStreamConvert will actually check that the new size is less than initial size
*/
+    ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
+    if (acmStreamConvert(wom->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
+        WARN("acmStreamConvert failed\n");
+	return MMSYSERR_ERROR;
+    }
+
+    lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+    if (ash->cbSrcLength > ash->cbSrcLengthUsed)
+        FIXME("Not all src buffer has been written, expect bogus sound\n");
+    else if (ash->cbSrcLength < ash->cbSrcLengthUsed)
+        ERR("CoDec has read more data than it is allowed to\n");
+
+    if (ash->cbDstLengthUsed == 0) {
+        /* something went wrong in decoding */
+        FIXME("Got 0 length\n");
+        return MMSYSERR_ERROR;
+    }
+    lpWaveHdrDst->dwBufferLength = ash->cbDstLengthUsed;
+    return waveOutWrite(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
+}
+
+static	DWORD	wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
+{
+    PACMSTREAMHEADER	ash;
+    DWORD		size;
+    DWORD		dwRet;
+    LPWAVEHDR		lpWaveHdrDst;
+
+    TRACE("(%p %p %08x)\n", wom, lpWaveHdrSrc, dwParam2);
+
+    if (!wom->hAcmStream)
+	return waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
+
+    if (acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size,
ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR) {
+        WARN("acmStreamSize failed\n");
+	return MMSYSERR_ERROR;
+    }
+
+    ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) +
size);
+    if (ash == NULL) {
+        WARN("no memory\n");
+	return MMSYSERR_NOMEM;
+    }
+
+    ash->cbStruct = sizeof(*ash);
+    ash->fdwStatus = 0L;
+    ash->dwUser = (DWORD_PTR)lpWaveHdrSrc;
+    ash->pbSrc = (LPBYTE)lpWaveHdrSrc->lpData;
+    ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
+    /* ash->cbSrcLengthUsed */
+    ash->dwSrcUser = lpWaveHdrSrc->dwUser; /* FIXME ? */
+    ash->pbDst = (LPBYTE)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
+    ash->cbDstLength = size;
+    /* ash->cbDstLengthUsed */
+    ash->dwDstUser = 0; /* FIXME ? */
+    dwRet = acmStreamPrepareHeader(wom->hAcmStream, ash, 0L);
+    if (dwRet != MMSYSERR_NOERROR) {
+        WARN("acmStreamPrepareHeader failed\n");
+	goto errCleanUp;
+    }
+
+    lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+    lpWaveHdrDst->lpData = (LPSTR)ash->pbDst;
+    lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */
+    lpWaveHdrDst->dwFlags = 0;
+    lpWaveHdrDst->dwLoops = 0;
+    dwRet = waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst,
sizeof(*lpWaveHdrDst));
+    if (dwRet != MMSYSERR_NOERROR) {
+        WARN("waveOutPrepareHeader failed\n");
+	goto errCleanUp;
+    }
+
+    lpWaveHdrSrc->reserved = (DWORD_PTR)ash;
+    lpWaveHdrSrc->dwFlags = WHDR_PREPARED;
+    TRACE("=> (0)\n");
+    return MMSYSERR_NOERROR;
+errCleanUp:
+    TRACE("=> (%d)\n", dwRet);
+    HeapFree(GetProcessHeap(), 0, ash);
+    return dwRet;
+}
+
+static	DWORD	wodUnprepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
+{
+    PACMSTREAMHEADER	ash;
+    LPWAVEHDR		lpWaveHdrDst;
+    DWORD		dwRet1, dwRet2;
+
+    TRACE("(%p %p %08x)\n", wom, lpWaveHdrSrc, dwParam2);
+
+    if (!wom->hAcmStream) {
+	return waveOutUnprepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);
+    }
+    ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
+    dwRet1 = acmStreamUnprepareHeader(wom->hAcmStream, ash, 0L);
+
+    lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+    dwRet2 = waveOutUnprepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst,
sizeof(*lpWaveHdrDst));
+
+    HeapFree(GetProcessHeap(), 0, ash);
+
+    lpWaveHdrSrc->dwFlags &= ~WHDR_PREPARED;
+    return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
+}
+
+static	DWORD	wodGetPosition(WAVEMAPDATA* wom, LPMMTIME lpTime, DWORD dwParam2)
+{
+    DWORD       val;
+    MMTIME      timepos;
+    TRACE("(%p %p %08x)\n", wom, lpTime, dwParam2);
+
+    timepos = *lpTime;
+
+    /* For TIME_MS, we're going to recalculate using TIME_BYTES */
+    if (lpTime->wType == TIME_MS)
+        timepos.wType = TIME_BYTES;
+
+    /* This can change timepos.wType if the requested type is not supported */
+    val = waveOutGetPosition(wom->u.out.hInnerWave, &timepos, dwParam2);
+
+    if (timepos.wType == TIME_BYTES)
+    {
+        DWORD dwInnerSamplesPerOuter = wom->nSamplesPerSecInner /
wom->nSamplesPerSecOuter;
+        if (dwInnerSamplesPerOuter > 0)
+        {
+            DWORD dwInnerBytesPerSample = wom->avgSpeedInner /
wom->nSamplesPerSecInner;
+            DWORD dwInnerBytesPerOuterSample = dwInnerBytesPerSample *
dwInnerSamplesPerOuter;
+            DWORD remainder = 0;
+
+            /* If we are up sampling (going from lower sample rate to higher),
+            **   we need to make a special accommodation for times when we've
+            **   written a partial output sample.  This happens frequently
+            **   to us because we use msacm to do our up sampling, and it
+            **   will up sample on an unaligned basis.
+            ** For example, if you convert a 2 byte wide 8,000 'outer'
+            **   buffer to a 2 byte wide 48,000 inner device, you would
+            **   expect 2 bytes of input to produce 12 bytes of output.
+            **   Instead, msacm will produce 8 bytes of output.
+            **   But reporting our position as 1 byte of output is
+            **   nonsensical; the output buffer position needs to be
+            **   aligned on outer sample size, and aggressively rounded up.
+            */
+            remainder = timepos.u.cb % dwInnerBytesPerOuterSample;
+            if (remainder > 0)
+            {
+                timepos.u.cb -= remainder;
+                timepos.u.cb += dwInnerBytesPerOuterSample;
+            }
+        }
+
+        lpTime->u.cb = MulDiv(timepos.u.cb, wom->avgSpeedOuter,
wom->avgSpeedInner);
+
+        /* Once we have the TIME_BYTES right, we can easily convert to TIME_MS */
+        if (lpTime->wType == TIME_MS)
+            lpTime->u.ms = MulDiv(lpTime->u.cb, 1000, wom->avgSpeedOuter);
+        else
+            lpTime->wType = TIME_BYTES;
+    }
+    else if (lpTime->wType == TIME_SAMPLES && timepos.wType == TIME_SAMPLES)
+        lpTime->u.sample = MulDiv(timepos.u.sample, wom->nSamplesPerSecOuter,
wom->nSamplesPerSecInner);
+    else
+        /* other time types don't require conversion */
+        lpTime->u = timepos.u;
+
+    return val;
+}
+
+static	DWORD	wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSW lpWaveCaps,
DWORD dwParam2)
+{
+    static const WCHAR name[] = {'W','i','n','e','
','w','a','v','e','
','o','u','t','
','m','a','p','p','e','r',0};
+
+    TRACE("(%04x %p %p %08x)\n",wDevID, wom, lpWaveCaps, dwParam2);
+
+    /* if opened low driver, forward message */
+    if (WAVEMAP_IsData(wom))
+        return waveOutGetDevCapsW((UINT_PTR)wom->u.out.hInnerWave, lpWaveCaps,
dwParam2);
+    /* else if no drivers, nothing to map so return bad device */
+    if (waveOutGetNumDevs() == 0) {
+        WARN("bad device id\n");
+        return MMSYSERR_BADDEVICEID;
+    }
+    /* otherwise, return caps of mapper itself */
+    if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
+	WAVEOUTCAPSW woc;
+	woc.wMid = 0x00FF;
+	woc.wPid = 0x0001;
+	woc.vDriverVersion = 0x0332;
+	lstrcpyW(woc.szPname, name);
+	woc.dwFormats =
+            WAVE_FORMAT_96M08 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16
|
+            WAVE_FORMAT_48M08 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16
|
+	    WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
+	    WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
+	    WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
+	woc.wChannels = 2;
+	woc.dwSupport = WAVECAPS_VOLUME | WAVECAPS_LRVOLUME;
+        memcpy(lpWaveCaps, &woc, min(dwParam2, sizeof(woc)));
+
+	return MMSYSERR_NOERROR;
+    }
+    ERR("This shouldn't happen\n");
+    return MMSYSERR_ERROR;
+}
+
+static	DWORD	wodGetVolume(UINT wDevID, WAVEMAPDATA* wom, LPDWORD lpVol)
+{
+    TRACE("(%04x %p %p)\n",wDevID, wom, lpVol);
+
+    if (WAVEMAP_IsData(wom))
+	return waveOutGetVolume(wom->u.out.hInnerWave, lpVol);
+    return MMSYSERR_NOERROR;
+}
+
+static	DWORD	wodSetVolume(UINT wDevID, WAVEMAPDATA* wom, DWORD vol)
+{
+    TRACE("(%04x %p %08x)\n",wDevID, wom, vol);
+
+    if (WAVEMAP_IsData(wom))
+	return waveOutSetVolume(wom->u.out.hInnerWave, vol);
+    return MMSYSERR_NOERROR;
+}
+
+static	DWORD	wodPause(WAVEMAPDATA* wom)
+{
+    TRACE("(%p)\n",wom);
+
+    return waveOutPause(wom->u.out.hInnerWave);
+}
+
+static	DWORD	wodRestart(WAVEMAPDATA* wom)
+{
+    TRACE("(%p)\n",wom);
+
+    return waveOutRestart(wom->u.out.hInnerWave);
+}
+
+static	DWORD	wodReset(WAVEMAPDATA* wom)
+{
+    TRACE("(%p)\n",wom);
+
+    return waveOutReset(wom->u.out.hInnerWave);
+}
+
+static	DWORD	wodBreakLoop(WAVEMAPDATA* wom)
+{
+    TRACE("(%p)\n",wom);
+
+    return waveOutBreakLoop(wom->u.out.hInnerWave);
+}
+
+static  DWORD	wodMapperStatus(WAVEMAPDATA* wom, DWORD flags, LPVOID ptr)
+{
+    UINT	id;
+    DWORD	ret = MMSYSERR_NOTSUPPORTED;
+
+    TRACE("(%p %08x %p)\n",wom, flags, ptr);
+
+    switch (flags) {
+    case WAVEOUT_MAPPER_STATUS_DEVICE:
+	ret = waveOutGetID(wom->u.out.hInnerWave, &id);
+	*(LPDWORD)ptr = id;
+	break;
+    case WAVEOUT_MAPPER_STATUS_MAPPED:
+	FIXME("Unsupported flag=%d\n", flags);
+	*(LPDWORD)ptr = 0; /* FIXME ?? */
+	break;
+    case WAVEOUT_MAPPER_STATUS_FORMAT:
+	FIXME("Unsupported flag=%d\n", flags);
+	/* ptr points to a WAVEFORMATEX struct - before or after streaming ? */
+	*(LPDWORD)ptr = 0;
+	break;
+    default:
+	FIXME("Unsupported flag=%d\n", flags);
+	*(LPDWORD)ptr = 0;
+	break;
+    }
+    return ret;
+}
+
+static  DWORD   wodMapperReconfigure(WAVEMAPDATA* wom, DWORD dwParam1, DWORD dwParam2)
+{
+    FIXME("(%p %08x %08x) stub!\n", wom, dwParam1, dwParam2);
+
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				wodMessage (MSACM.@)
+ */
+DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
+                                DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+    TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
+	  wDevID, wMsg, dwUser, dwParam1, dwParam2);
+
+    switch (wMsg) {
+    case DRVM_INIT:
+    case DRVM_EXIT:
+    case DRVM_ENABLE:
+    case DRVM_DISABLE:
+	/* FIXME: Pretend this is supported */
+	return 0;
+    case WODM_OPEN:	 	return wodOpen		((DWORD_PTR*)dwUser,     
(LPWAVEOPENDESC)dwParam1,dwParam2);
+    case WODM_CLOSE:	 	return wodClose		((WAVEMAPDATA*)dwUser);
+    case WODM_WRITE:	 	return wodWrite		((WAVEMAPDATA*)dwUser,
(LPWAVEHDR)dwParam1,	dwParam2);
+    case WODM_PAUSE:	 	return wodPause		((WAVEMAPDATA*)dwUser);
+    case WODM_GETPOS:	 	return wodGetPosition	((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1,
	dwParam2);
+    case WODM_BREAKLOOP: 	return wodBreakLoop	((WAVEMAPDATA*)dwUser);
+    case WODM_PREPARE:	 	return wodPrepare	((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,
	dwParam2);
+    case WODM_UNPREPARE: 	return wodUnprepare	((WAVEMAPDATA*)dwUser, (LPWAVEHDR)dwParam1,
	dwParam2);
+    case WODM_GETDEVCAPS:	return wodGetDevCaps	(wDevID, (WAVEMAPDATA*)dwUser,
(LPWAVEOUTCAPSW)dwParam1,dwParam2);
+    case WODM_GETNUMDEVS:	return 1;
+    case WODM_GETPITCH:	 	return MMSYSERR_NOTSUPPORTED;
+    case WODM_SETPITCH:	 	return MMSYSERR_NOTSUPPORTED;
+    case WODM_GETPLAYBACKRATE:	return MMSYSERR_NOTSUPPORTED;
+    case WODM_SETPLAYBACKRATE:	return MMSYSERR_NOTSUPPORTED;
+    case WODM_GETVOLUME:	return wodGetVolume	(wDevID, (WAVEMAPDATA*)dwUser,
(LPDWORD)dwParam1);
+    case WODM_SETVOLUME:	return wodSetVolume	(wDevID, (WAVEMAPDATA*)dwUser, dwParam1);
+    case WODM_RESTART:		return wodRestart	((WAVEMAPDATA*)dwUser);
+    case WODM_RESET:		return wodReset		((WAVEMAPDATA*)dwUser);
+    case WODM_MAPPER_STATUS:	return wodMapperStatus  ((WAVEMAPDATA*)dwUser, dwParam1,
(LPVOID)dwParam2);
+    case DRVM_MAPPER_RECONFIGURE: return wodMapperReconfigure((WAVEMAPDATA*)dwUser,
dwParam1, dwParam2);
+    /* known but not supported */
+    case DRV_QUERYDEVICEINTERFACESIZE:
+    case DRV_QUERYDEVICEINTERFACE:
+        return MMSYSERR_NOTSUPPORTED;
+    default:
+	FIXME("unknown message %d!\n", wMsg);
+    }
+    return MMSYSERR_NOTSUPPORTED;
+}
+
+/*======================================================================*
+ *                  WAVE IN part                                        *
+ *======================================================================*/
+
+static void CALLBACK widCallback(HWAVEIN hWave, UINT uMsg, DWORD_PTR dwInstance,
+                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+    WAVEMAPDATA* wim = (WAVEMAPDATA*)dwInstance;
+
+    TRACE("(%p %u %lx %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1,
dwParam2);
+
+    if (!WAVEMAP_IsData(wim)) {
+	ERR("Bad data\n");
+	return;
+    }
+
+    if (hWave != wim->u.in.hInnerWave && uMsg != WIM_OPEN)
+	ERR("Shouldn't happen (%p %p)\n", hWave, wim->u.in.hInnerWave);
+
+    switch (uMsg) {
+    case WIM_OPEN:
+    case WIM_CLOSE:
+	/* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
+	break;
+    case WIM_DATA:
+	if (wim->hAcmStream) {
+	    LPWAVEHDR		lpWaveHdrSrc = (LPWAVEHDR)dwParam1;
+	    PACMSTREAMHEADER	ash = (PACMSTREAMHEADER)((LPSTR)lpWaveHdrSrc -
sizeof(ACMSTREAMHEADER));
+	    LPWAVEHDR		lpWaveHdrDst = (LPWAVEHDR)ash->dwUser;
+
+	    /* convert data just gotten from waveIn into requested format */
+	    if (acmStreamConvert(wim->hAcmStream, ash, 0L) != MMSYSERR_NOERROR) {
+		ERR("ACM conversion failed\n");
+		return;
+	    } else {
+		TRACE("Converted %d bytes into %d\n", ash->cbSrcLengthUsed,
ash->cbDstLengthUsed);
+	    }
+	    /* and setup the wavehdr to return accordingly */
+	    lpWaveHdrDst->dwFlags &= ~WHDR_INQUEUE;
+	    lpWaveHdrDst->dwFlags |= WHDR_DONE;
+	    lpWaveHdrDst->dwBytesRecorded = ash->cbDstLengthUsed;
+            dwParam1 = (DWORD_PTR)lpWaveHdrDst;
+	}
+	break;
+    default:
+	ERR("Unknown msg %u\n", uMsg);
+    }
+
+    DriverCallback(wim->dwCallback, HIWORD(wim->dwFlags),
(HDRVR)wim->u.in.hOuterWave,
+		   uMsg, wim->dwClientInstance, dwParam1, dwParam2);
+}
+
+static	DWORD	widOpenHelper(WAVEMAPDATA* wim, UINT idx,
+			      LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
+			      DWORD dwFlags)
+{
+    DWORD	ret;
+
+    TRACE("(%p %04x %p %p %08x)\n", wim, idx, lpDesc, lpwfx, dwFlags);
+
+    /* source is always PCM, so the formulas below apply */
+    lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
+    lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
+    if (dwFlags & WAVE_FORMAT_QUERY) {
+	ret = acmStreamOpen(NULL, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L,
ACM_STREAMOPENF_QUERY);
+    } else {
+	ret = acmStreamOpen(&wim->hAcmStream, 0, lpwfx, lpDesc->lpFormat, NULL, 0L,
0L, 0L);
+    }
+    if (ret == MMSYSERR_NOERROR) {
+        ret = waveInOpen(&wim->u.in.hInnerWave, idx, lpwfx,
+                         (DWORD_PTR)widCallback, (DWORD_PTR)wim,
+                         (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
+	if (ret != MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY)) {
+	    acmStreamClose(wim->hAcmStream, 0);
+	    wim->hAcmStream = 0;
+	}
+    }
+    TRACE("ret = %08x\n", ret);
+    return ret;
+}
+
+static	DWORD	widOpen(DWORD_PTR *lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+{
+    UINT 		ndlo, ndhi;
+    UINT		i;
+    WAVEMAPDATA*	wim = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
+    DWORD               res;
+
+    TRACE("(%p %p %08x)\n", lpdwUser, lpDesc, dwFlags);
+
+    if (!wim) {
+        WARN("no memory\n");
+	return MMSYSERR_NOMEM;
+    }
+
+    wim->self = wim;
+    wim->dwCallback = lpDesc->dwCallback;
+    wim->dwFlags = dwFlags;
+    wim->dwClientInstance = lpDesc->dwInstance;
+    wim->u.in.hOuterWave = (HWAVEIN)lpDesc->hWave;
+
+    ndhi = waveInGetNumDevs();
+    if (dwFlags & WAVE_MAPPED) {
+	if (lpDesc->uMappedDeviceID >= ndhi) return MMSYSERR_INVALPARAM;
+	ndlo = lpDesc->uMappedDeviceID;
+	ndhi = ndlo + 1;
+	dwFlags &= ~WAVE_MAPPED;
+    } else {
+	ndlo = 0;
+    }
+
+    wim->avgSpeedOuter = wim->avgSpeedInner =
lpDesc->lpFormat->nAvgBytesPerSec;
+    wim->nSamplesPerSecOuter = wim->nSamplesPerSecInner =
lpDesc->lpFormat->nSamplesPerSec;
+
+    for (i = ndlo; i < ndhi; i++) {
+        if (waveInOpen(&wim->u.in.hInnerWave, i, lpDesc->lpFormat,
+                       (DWORD_PTR)widCallback, (DWORD_PTR)wim,
+                       (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION |
WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
+	    wim->hAcmStream = 0;
+	    goto found;
+	}
+    }
+
+    if ((dwFlags & WAVE_FORMAT_DIRECT) == 0)
+    {
+        WAVEFORMATEX	wfx;
+
+        wfx.wFormatTag = WAVE_FORMAT_PCM;
+        wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case
*/
+        /* try some ACM stuff */
+
+#define	TRY(sps,bps)    wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
+                        switch (res=widOpenHelper(wim, i, lpDesc, &wfx, dwFlags |
WAVE_FORMAT_DIRECT)) { \
+                        case MMSYSERR_NOERROR: wim->avgSpeedInner =
wfx.nAvgBytesPerSec; wim->nSamplesPerSecInner = wfx.nSamplesPerSec; goto found; \
+                        case WAVERR_BADFORMAT: break; \
+                        default: goto error; \
+                        }
+
+        for (i = ndlo; i < ndhi; i++) {
+	    wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
+            /* first try with same stereo/mono option as source */
+            wfx.nChannels = lpDesc->lpFormat->nChannels;
+			TRY(wfx.nSamplesPerSec, 16);
+			TRY(wfx.nSamplesPerSec, 8);
+			wfx.nChannels ^= 3;
+			TRY(wfx.nSamplesPerSec, 16);
+			TRY(wfx.nSamplesPerSec, 8);
+	}
+
+        for (i = ndlo; i < ndhi; i++) {
+	    wfx.nSamplesPerSec=lpDesc->lpFormat->nSamplesPerSec;
+            /* first try with same stereo/mono option as source */
+            wfx.nChannels = lpDesc->lpFormat->nChannels;
+            TRY(96000, 16);
+            TRY(48000, 16);
+            TRY(44100, 16);
+            TRY(22050, 16);
+            TRY(11025, 16);
+
+            /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way
around) */
+            wfx.nChannels ^= 3;
+            TRY(96000, 16);
+            TRY(48000, 16);
+            TRY(44100, 16);
+            TRY(22050, 16);
+            TRY(11025, 16);
+
+            /* first try with same stereo/mono option as source */
+            wfx.nChannels = lpDesc->lpFormat->nChannels;
+            TRY(96000, 8);
+            TRY(48000, 8);
+            TRY(44100, 8);
+            TRY(22050, 8);
+            TRY(11025, 8);
+
+            /* 2^3 => 1, 1^3 => 2, so if stereo, try mono (and the other way
around) */
+            wfx.nChannels ^= 3;
+            TRY(96000, 8);
+            TRY(48000, 8);
+            TRY(44100, 8);
+            TRY(22050, 8);
+            TRY(11025, 8);
+        }
+#undef TRY
+    }
+
+    HeapFree(GetProcessHeap(), 0, wim);
+    WARN("ret = WAVERR_BADFORMAT\n");
+    return WAVERR_BADFORMAT;
+found:
+    if (dwFlags & WAVE_FORMAT_QUERY) {
+	*lpdwUser = 0L;
+	HeapFree(GetProcessHeap(), 0, wim);
+    } else {
+        *lpdwUser = (DWORD_PTR)wim;
+    }
+    TRACE("Ok (stream=%p)\n", wim->hAcmStream);
+    return MMSYSERR_NOERROR;
+error:
+    HeapFree(GetProcessHeap(), 0, wim);
+    if (res==ACMERR_NOTPOSSIBLE) {
+        WARN("ret = WAVERR_BADFORMAT\n");
+        return WAVERR_BADFORMAT;
+    }
+    WARN("ret = 0x%08x\n", res);
+    return res;
+}
+
+static	DWORD	widClose(WAVEMAPDATA* wim)
+{
+    DWORD ret;
+
+    TRACE("(%p)\n", wim);
+
+    ret = waveInClose(wim->u.in.hInnerWave);
+    if (ret == MMSYSERR_NOERROR) {
+	if (wim->hAcmStream) {
+	    ret = acmStreamClose(wim->hAcmStream, 0);
+	}
+	if (ret == MMSYSERR_NOERROR) {
+	    HeapFree(GetProcessHeap(), 0, wim);
+	}
+    }
+    return ret;
+}
+
+static	DWORD	widAddBuffer(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
+{
+    PACMSTREAMHEADER	ash;
+    LPWAVEHDR		lpWaveHdrSrc;
+
+    TRACE("(%p %p %08x)\n", wim, lpWaveHdrDst, dwParam2);
+
+    if (!wim->hAcmStream) {
+	return waveInAddBuffer(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
+    }
+
+    lpWaveHdrDst->dwFlags |= WHDR_INQUEUE;
+    ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
+
+    lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+    return waveInAddBuffer(wim->u.in.hInnerWave, lpWaveHdrSrc,
sizeof(*lpWaveHdrSrc));
+}
+
+static	DWORD	widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
+{
+    PACMSTREAMHEADER	ash;
+    DWORD		size;
+    DWORD		dwRet;
+    LPWAVEHDR		lpWaveHdrSrc;
+
+    TRACE("(%p %p %08x)\n", wim, lpWaveHdrDst, dwParam2);
+
+    if (!wim->hAcmStream) {
+	return waveInPrepareHeader(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
+    }
+    if (acmStreamSize(wim->hAcmStream, lpWaveHdrDst->dwBufferLength, &size,
+		      ACM_STREAMSIZEF_DESTINATION) != MMSYSERR_NOERROR) {
+        WARN("acmStreamSize failed\n");
+	return MMSYSERR_ERROR;
+    }
+
+    ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) +
size);
+    if (ash == NULL) {
+        WARN("no memory\n");
+	return MMSYSERR_NOMEM;
+    }
+
+    ash->cbStruct = sizeof(*ash);
+    ash->fdwStatus = 0L;
+    ash->dwUser = (DWORD_PTR)lpWaveHdrDst;
+    ash->pbSrc = (LPBYTE)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
+    ash->cbSrcLength = size;
+    /* ash->cbSrcLengthUsed */
+    ash->dwSrcUser = 0L; /* FIXME ? */
+    ash->pbDst = (LPBYTE)lpWaveHdrDst->lpData;
+    ash->cbDstLength = lpWaveHdrDst->dwBufferLength;
+    /* ash->cbDstLengthUsed */
+    ash->dwDstUser = lpWaveHdrDst->dwUser; /* FIXME ? */
+    dwRet = acmStreamPrepareHeader(wim->hAcmStream, ash, 0L);
+    if (dwRet != MMSYSERR_NOERROR) {
+        WARN("acmStreamPrepareHeader failed\n");
+	goto errCleanUp;
+    }
+
+    lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+    lpWaveHdrSrc->lpData = (LPSTR)ash->pbSrc;
+    lpWaveHdrSrc->dwBufferLength = size; /* conversion is not done yet */
+    lpWaveHdrSrc->dwFlags = 0;
+    lpWaveHdrSrc->dwLoops = 0;
+    dwRet = waveInPrepareHeader(wim->u.in.hInnerWave, lpWaveHdrSrc,
sizeof(*lpWaveHdrSrc));
+    if (dwRet != MMSYSERR_NOERROR) {
+        WARN("waveInPrepareHeader failed\n");
+	goto errCleanUp;
+    }
+
+    lpWaveHdrDst->reserved = (DWORD_PTR)ash;
+    lpWaveHdrDst->dwFlags = WHDR_PREPARED;
+    TRACE("=> (0)\n");
+    return MMSYSERR_NOERROR;
+errCleanUp:
+    TRACE("=> (%d)\n", dwRet);
+    HeapFree(GetProcessHeap(), 0, ash);
+    return dwRet;
+}
+
+static	DWORD	widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
+{
+    PACMSTREAMHEADER	ash;
+    LPWAVEHDR		lpWaveHdrSrc;
+    DWORD		dwRet1, dwRet2;
+
+    TRACE("(%p %p %08x)\n", wim, lpWaveHdrDst, dwParam2);
+
+    if (!wim->hAcmStream) {
+	return waveInUnprepareHeader(wim->u.in.hInnerWave, lpWaveHdrDst, dwParam2);
+    }
+    ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
+    dwRet1 = acmStreamUnprepareHeader(wim->hAcmStream, ash, 0L);
+
+    lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+    dwRet2 = waveInUnprepareHeader(wim->u.in.hInnerWave, lpWaveHdrSrc,
sizeof(*lpWaveHdrSrc));
+
+    HeapFree(GetProcessHeap(), 0, ash);
+
+    lpWaveHdrDst->dwFlags &= ~WHDR_PREPARED;
+    return (dwRet1 == MMSYSERR_NOERROR) ? dwRet2 : dwRet1;
+}
+
+static	DWORD	widGetPosition(WAVEMAPDATA* wim, LPMMTIME lpTime, DWORD dwParam2)
+{
+    DWORD       val;
+    MMTIME      timepos;
+    TRACE("(%p %p %08x)\n", wim, lpTime, dwParam2);
+
+    timepos = *lpTime;
+
+    /* For TIME_MS, we're going to recalculate using TIME_BYTES */
+    if (lpTime->wType == TIME_MS)
+        timepos.wType = TIME_BYTES;
+
+    /* This can change timepos.wType if the requested type is not supported */
+    val = waveInGetPosition(wim->u.in.hInnerWave, &timepos, dwParam2);
+
+    if (timepos.wType == TIME_BYTES)
+    {
+        DWORD dwInnerSamplesPerOuter = wim->nSamplesPerSecInner /
wim->nSamplesPerSecOuter;
+        if (dwInnerSamplesPerOuter > 0)
+        {
+            DWORD dwInnerBytesPerSample = wim->avgSpeedInner /
wim->nSamplesPerSecInner;
+            DWORD dwInnerBytesPerOuterSample = dwInnerBytesPerSample *
dwInnerSamplesPerOuter;
+            DWORD remainder = 0;
+
+            /* If we are up sampling (going from lower sample rate to higher),
+            **   we need to make a special accommodation for times when we've
+            **   written a partial output sample.  This happens frequently
+            **   to us because we use msacm to do our up sampling, and it
+            **   will up sample on an unaligned basis.
+            ** For example, if you convert a 2 byte wide 8,000 'outer'
+            **   buffer to a 2 byte wide 48,000 inner device, you would
+            **   expect 2 bytes of input to produce 12 bytes of output.
+            **   Instead, msacm will produce 8 bytes of output.
+            **   But reporting our position as 1 byte of output is
+            **   nonsensical; the output buffer position needs to be
+            **   aligned on outer sample size, and aggressively rounded up.
+            */
+            remainder = timepos.u.cb % dwInnerBytesPerOuterSample;
+            if (remainder > 0)
+            {
+                timepos.u.cb -= remainder;
+                timepos.u.cb += dwInnerBytesPerOuterSample;
+            }
+        }
+
+        lpTime->u.cb = MulDiv(timepos.u.cb, wim->avgSpeedOuter,
wim->avgSpeedInner);
+
+        /* Once we have the TIME_BYTES right, we can easily convert to TIME_MS */
+        if (lpTime->wType == TIME_MS)
+            lpTime->u.ms = MulDiv(lpTime->u.cb, 1000, wim->avgSpeedOuter);
+        else
+            lpTime->wType = TIME_BYTES;
+    }
+    else if (lpTime->wType == TIME_SAMPLES && timepos.wType == TIME_SAMPLES)
+        lpTime->u.sample = MulDiv(timepos.u.sample, wim->nSamplesPerSecOuter,
wim->nSamplesPerSecInner);
+    else
+        /* other time types don't require conversion */
+        lpTime->u = timepos.u;
+
+    return val;
+}
+
+static	DWORD	widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSW lpWaveCaps, DWORD
dwParam2)
+{
+    TRACE("(%04x, %p %p %08x)\n", wDevID, wim, lpWaveCaps, dwParam2);
+
+    /* if opened low driver, forward message */
+    if (WAVEMAP_IsData(wim))
+        return waveInGetDevCapsW((UINT_PTR)wim->u.in.hInnerWave, lpWaveCaps,
dwParam2);
+    /* else if no drivers, nothing to map so return bad device */
+    if (waveInGetNumDevs() == 0) {
+        WARN("bad device id\n");
+        return MMSYSERR_BADDEVICEID;
+    }
+    /* otherwise, return caps of mapper itself */
+    if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
+        WAVEINCAPSW wic;
+        static const WCHAR init[] =
{'W','i','n','e','
','w','a','v','e','
','i','n','
','m','a','p','p','e','r',0};
+	wic.wMid = 0x00FF;
+	wic.wPid = 0x0001;
+	wic.vDriverVersion = 0x0001;
+	strcpyW(wic.szPname, init);
+	wic.dwFormats =
+            WAVE_FORMAT_96M08 | WAVE_FORMAT_96S08 | WAVE_FORMAT_96M16 | WAVE_FORMAT_96S16
|
+            WAVE_FORMAT_48M08 | WAVE_FORMAT_48S08 | WAVE_FORMAT_48M16 | WAVE_FORMAT_48S16
|
+	    WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16 |
+	    WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
+	    WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16;
+	wic.wChannels = 2;
+        memcpy(lpWaveCaps, &wic, min(dwParam2, sizeof(wic)));
+
+	return MMSYSERR_NOERROR;
+    }
+    ERR("This shouldn't happen\n");
+    return MMSYSERR_ERROR;
+}
+
+static	DWORD	widStop(WAVEMAPDATA* wim)
+{
+    TRACE("(%p)\n", wim);
+
+    return waveInStop(wim->u.in.hInnerWave);
+}
+
+static	DWORD	widStart(WAVEMAPDATA* wim)
+{
+    TRACE("(%p)\n", wim);
+
+    return waveInStart(wim->u.in.hInnerWave);
+}
+
+static	DWORD	widReset(WAVEMAPDATA* wim)
+{
+    TRACE("(%p)\n", wim);
+
+    return waveInReset(wim->u.in.hInnerWave);
+}
+
+static  DWORD	widMapperStatus(WAVEMAPDATA* wim, DWORD flags, LPVOID ptr)
+{
+    UINT	id;
+    DWORD	ret = MMSYSERR_NOTSUPPORTED;
+
+    TRACE("(%p %08x %p)\n", wim, flags, ptr);
+
+    switch (flags) {
+    case WAVEIN_MAPPER_STATUS_DEVICE:
+	ret = waveInGetID(wim->u.in.hInnerWave, &id);
+	*(LPDWORD)ptr = id;
+	break;
+    case WAVEIN_MAPPER_STATUS_MAPPED:
+	FIXME("Unsupported yet flag=%d\n", flags);
+	*(LPDWORD)ptr = 0; /* FIXME ?? */
+	break;
+    case WAVEIN_MAPPER_STATUS_FORMAT:
+	FIXME("Unsupported flag=%d\n", flags);
+	/* ptr points to a WAVEFORMATEX struct  - before or after streaming ? */
+	*(LPDWORD)ptr = 0; /* FIXME ?? */
+	break;
+    default:
+	FIXME("Unsupported flag=%d\n", flags);
+	*(LPDWORD)ptr = 0;
+	break;
+    }
+    return ret;
+}
+
+static  DWORD   widMapperReconfigure(WAVEMAPDATA* wim, DWORD dwParam1, DWORD dwParam2)
+{
+    FIXME("(%p %08x %08x) stub!\n", wim, dwParam1, dwParam2);
+
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				widMessage (MSACM.@)
+ */
+DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD_PTR dwUser,
+                                DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+    TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
+	  wDevID, wMsg, dwUser, dwParam1, dwParam2);
+
+    switch (wMsg) {
+    case DRVM_INIT:
+    case DRVM_EXIT:
+    case DRVM_ENABLE:
+    case DRVM_DISABLE:
+	/* FIXME: Pretend this is supported */
+	return 0;
+
+    case WIDM_OPEN:		return widOpen          ((DWORD_PTR*)dwUser,    
(LPWAVEOPENDESC)dwParam1, dwParam2);
+    case WIDM_CLOSE:		return widClose         ((WAVEMAPDATA*)dwUser);
+
+    case WIDM_ADDBUFFER:	return widAddBuffer     ((WAVEMAPDATA*)dwUser,
(LPWAVEHDR)dwParam1, 	dwParam2);
+    case WIDM_PREPARE:		return widPrepare       ((WAVEMAPDATA*)dwUser,
(LPWAVEHDR)dwParam1, 	dwParam2);
+    case WIDM_UNPREPARE:	return widUnprepare     ((WAVEMAPDATA*)dwUser,
(LPWAVEHDR)dwParam1, 	dwParam2);
+    case WIDM_GETDEVCAPS:	return widGetDevCaps    (wDevID, (WAVEMAPDATA*)dwUser,
(LPWAVEINCAPSW)dwParam1, dwParam2);
+    case WIDM_GETNUMDEVS:	return 1;
+    case WIDM_GETPOS:		return widGetPosition   ((WAVEMAPDATA*)dwUser, (LPMMTIME)dwParam1,
	dwParam2);
+    case WIDM_RESET:		return widReset         ((WAVEMAPDATA*)dwUser);
+    case WIDM_START:		return widStart         ((WAVEMAPDATA*)dwUser);
+    case WIDM_STOP:		return widStop          ((WAVEMAPDATA*)dwUser);
+    case WIDM_MAPPER_STATUS:	return widMapperStatus  ((WAVEMAPDATA*)dwUser, dwParam1,
(LPVOID)dwParam2);
+    case DRVM_MAPPER_RECONFIGURE: return widMapperReconfigure((WAVEMAPDATA*)dwUser,
dwParam1, dwParam2);
+    /* known but not supported */
+    case DRV_QUERYDEVICEINTERFACESIZE:
+    case DRV_QUERYDEVICEINTERFACE:
+        return MMSYSERR_NOTSUPPORTED;
+    default:
+	FIXME("unknown message %u!\n", wMsg);
+    }
+    return MMSYSERR_NOTSUPPORTED;
+}
+
+/*======================================================================*
+ *                  Driver part                                         *
+ *======================================================================*/
+
+static	struct WINE_WAVEMAP* oss = NULL;
+
+/**************************************************************************
+ * 				WAVEMAP_drvOpen			[internal]
+ */
+static LRESULT WAVEMAP_drvOpen(LPSTR str)
+{
+    TRACE("(%p)\n", str);
+
+    if (oss)
+	return 0;
+
+    /* I know, this is ugly, but who cares... */
+    oss = (struct WINE_WAVEMAP*)1;
+    return 1;
+}
+
+/**************************************************************************
+ * 				WAVEMAP_drvClose		[internal]
+ */
+static LRESULT WAVEMAP_drvClose(DWORD_PTR dwDevID)
+{
+    TRACE("(%08lx)\n", dwDevID);
+
+    if (oss) {
+	oss = NULL;
+	return 1;
+    }
+    return 0;
+}
+
+/**************************************************************************
+ * 				DriverProc (MSACM.@)
+ */
+LRESULT CALLBACK WAVEMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
+                                    LPARAM dwParam1, LPARAM dwParam2)
+{
+    TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
+	  dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+
+    switch(wMsg) {
+    case DRV_LOAD:		return 1;
+    case DRV_FREE:		return 1;
+    case DRV_OPEN:		return WAVEMAP_drvOpen((LPSTR)dwParam1);
+    case DRV_CLOSE:		return WAVEMAP_drvClose(dwDevID);
+    case DRV_ENABLE:		return 1;
+    case DRV_DISABLE:		return 1;
+    case DRV_QUERYCONFIGURE:	return 1;
+    case DRV_CONFIGURE:		MessageBoxA(0, "WAVEMAP MultiMedia Driver !",
"Wave mapper Driver", MB_OK);	return 1;
+    case DRV_INSTALL:		return DRVCNF_RESTART;
+    case DRV_REMOVE:		return DRVCNF_RESTART;
+    default:
+	return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+    }
+}

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.c
------------------------------------------------------------------------------
    svn:eol-style = native

Added: trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.rc
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msacm32/msacm32.…
==============================================================================
--- trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.rc (added)
+++ trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.rc [iso-8859-1] Tue May 26
02:38:00 2009
@@ -1,0 +1,7 @@
+/* $Id: wavemap.rc 11297 2004-10-16 20:27:43Z gvg $ */
+
+#define REACTOS_VERSION_DLL
+#define REACTOS_STR_FILE_DESCRIPTION	"ReactOS/WINE Wave Mapper\0"
+#define REACTOS_STR_INTERNAL_NAME	"wavemap\0"
+#define REACTOS_STR_ORIGINAL_FILENAME	"wavemap.drv\0"
+#include <reactos/version.rc>

Propchange: trunk/reactos/dll/win32/msacm32/msacm32.drv/wavemap.rc
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: trunk/reactos/dll/win32/msacm32/msacm32.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msacm32/msacm32.…
==============================================================================
--- trunk/reactos/dll/win32/msacm32/msacm32.rbuild [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msacm32/msacm32.rbuild [iso-8859-1] Tue May 26 02:38:00 2009
@@ -16,3 +16,6 @@
 	<file>pcmconverter.c</file>
 	<file>stream.c</file>
 </module>
+<directory name="msacm32.drv">
+	<xi:include href="msacm32.drv/msacm32.drv.rbuild" />
+</directory>

Modified: trunk/reactos/dll/win32/winmm/winmm.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winmm/winmm.rbui…
==============================================================================
--- trunk/reactos/dll/win32/winmm/winmm.rbuild [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winmm/winmm.rbuild [iso-8859-1] Tue May 26 02:38:00 2009
@@ -3,9 +3,6 @@
 <group xmlns:xi="http://www.w3.org/2001/XInclude">
 <directory name="midimap">
 	<xi:include href="midimap/midimap.rbuild" />
-</directory>
-<directory name="wavemap">
-	<xi:include href="wavemap/wavemap.rbuild" />
 </directory>
 <module name="winmm" type="win32dll"
baseaddress="${BASEADDRESS_WINMM}" installbase="system32"
installname="winmm.dll" crt="msvcrt">
 	<importlibrary definition="winmm.spec" />