wave mapper fixes
eric pouech
eric.pouech at wanadoo.fr
Fri Apr 13 15:36:54 CDT 2001
this patch shall fix:
- the notification issues reported by James Hatheway a while ago
- I also added the ACM conversion while recording (however, it hasn't
been
heavily tested)
A+
--
---------------
Eric Pouech (http://perso.wanadoo.fr/eric.pouech/)
"The future will be better tomorrow", Vice President Dan Quayle
-------------- next part --------------
Name: wavemap
ChangeLog: fixed callback parameters (bogus hWave); added acm conversion for waveIn
GenDate: 2001/04/13 20:26:33 UTC
ModifiedFiles: dlls/winmm/wavemap/wavemap.c
AddedFiles:
===================================================================
RCS file: /usr/share/cvs/cvsroot/wine/wine/dlls/winmm/wavemap/wavemap.c,v
retrieving revision 1.11
diff -u -u -r1.11 wavemap.c
--- dlls/winmm/wavemap/wavemap.c 2001/01/26 20:43:45 1.11
+++ dlls/winmm/wavemap/wavemap.c 2001/04/13 20:26:01
@@ -2,13 +2,16 @@
/*
* Wine Wave mapper driver
*
- * Copyright 1999 Eric Pouech
+ * Copyright 1999,2001 Eric Pouech
*/
/* TODOs
- * + implement wavein as waveout has been implemented
* + 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 <string.h>
@@ -24,7 +27,8 @@
typedef struct tagWAVEMAPDATA {
struct tagWAVEMAPDATA* self;
- HWAVE hWave;
+ HWAVE hOuterWave;
+ HWAVE hInnerWave;
HACMSTREAM hAcmStream;
/* needed data to filter callbacks. Only needed when hAcmStream is not 0 */
DWORD dwCallback;
@@ -41,20 +45,28 @@
* WAVE OUT part *
*======================================================================*/
-static void CALLBACK WAVEMAP_DstCallback(HDRVR hDev, UINT uMsg, DWORD dwInstance,
- DWORD dwParam1, DWORD dwParam2)
+static void CALLBACK wodCallback(HWAVE hWave, UINT uMsg, DWORD dwInstance,
+ DWORD dwParam1, DWORD dwParam2)
{
WAVEMAPDATA* wom = (WAVEMAPDATA*)dwInstance;
- TRACE("(0x%x %u %ld %lx %lx);\n", hDev, uMsg, dwInstance, dwParam1, dwParam2);
+ TRACE("(0x%x %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
+ if (!WAVEMAP_IsData(wom)) {
+ ERR("Bad data\n");
+ return;
+ }
+
+ if (hWave != wom->hInnerWave && uMsg != WOM_OPEN)
+ ERR("Shouldn't happen (%08x %08x)\n", hWave, wom->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;
@@ -68,7 +80,7 @@
ERR("Unknown msg %u\n", uMsg);
}
- DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags), hDev, uMsg,
+ DriverCallback(wom->dwCallback, HIWORD(wom->dwFlags), wom->hOuterWave, uMsg,
wom->dwClientInstance, dwParam1, dwParam2);
}
@@ -85,7 +97,7 @@
(dwFlags & WAVE_FORMAT_QUERY) ? ACM_STREAMOPENF_QUERY : 0L);
if (ret != MMSYSERR_NOERROR)
return ret;
- return waveOutOpen(&wom->hWave, idx, lpwfx, (DWORD)WAVEMAP_DstCallback,
+ return waveOutOpen(&wom->hInnerWave, idx, lpwfx, (DWORD)wodCallback,
(DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
}
@@ -102,13 +114,17 @@
return MMSYSERR_NOMEM;
wom->self = wom;
+ wom->dwCallback = lpDesc->dwCallback;
+ wom->dwFlags = dwFlags;
+ wom->dwClientInstance = lpDesc->dwInstance;
+ wom->hOuterWave = lpDesc->hWave;
for (i = 0; i < nd; i++) {
/* if no ACM stuff is involved, no need to handle callbacks at this
* level, this will be done transparently
*/
- if (waveOutOpen(&wom->hWave, i, lpDesc->lpFormat, lpDesc->dwCallback,
- lpDesc->dwInstance, dwFlags) == MMSYSERR_NOERROR) {
+ if (waveOutOpen(&wom->hInnerWave, i, lpDesc->lpFormat, (DWORD)wodCallback,
+ (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION) == MMSYSERR_NOERROR) {
wom->hAcmStream = 0;
goto found;
}
@@ -118,10 +134,6 @@
wfx.cbSize = 0; /* normally, this field is not used for PCM format, just in case */
/* try some ACM stuff */
- wom->dwCallback = lpDesc->dwCallback;
- wom->dwFlags = dwFlags;
- wom->dwClientInstance = lpDesc->dwInstance;
-
#define TRY(sps,bps) wfx.nSamplesPerSec = (sps); wfx.wBitsPerSample = (bps); \
if (wodOpenHelper(wom, i, lpDesc, &wfx, dwFlags) == MMSYSERR_NOERROR) goto found;
@@ -144,11 +156,9 @@
return MMSYSERR_ALLOCATED;
found:
if (dwFlags & WAVE_FORMAT_QUERY) {
- lpDesc->hWave = 0;
*lpdwUser = 0L;
HeapFree(GetProcessHeap(), 0, wom);
} else {
- lpDesc->hWave = wom->hWave;
*lpdwUser = (DWORD)wom;
}
return MMSYSERR_NOERROR;
@@ -156,7 +166,7 @@
static DWORD wodClose(WAVEMAPDATA* wom)
{
- DWORD ret = waveOutClose(wom->hWave);
+ DWORD ret = waveOutClose(wom->hInnerWave);
if (ret == MMSYSERR_NOERROR) {
if (wom->hAcmStream) {
@@ -175,7 +185,7 @@
LPWAVEHDR lpWaveHdrDst;
if (!wom->hAcmStream) {
- return waveOutWrite(wom->hWave, lpWaveHdrSrc, dwParam2);
+ return waveOutWrite(wom->hInnerWave, lpWaveHdrSrc, dwParam2);
}
lpWaveHdrSrc->dwFlags |= WHDR_INQUEUE;
@@ -185,7 +195,7 @@
lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
lpWaveHdrDst->dwBufferLength = ash->cbDstLengthUsed;
- return waveOutWrite(wom->hWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
+ return waveOutWrite(wom->hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
}
static DWORD wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2)
@@ -196,7 +206,7 @@
LPWAVEHDR lpWaveHdrDst;
if (!wom->hAcmStream) {
- return waveOutPrepareHeader(wom->hWave, lpWaveHdrSrc, dwParam2);
+ return waveOutPrepareHeader(wom->hInnerWave, lpWaveHdrSrc, dwParam2);
}
if (acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size, ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR)
return MMSYSERR_ERROR;
@@ -225,7 +235,7 @@
lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */
lpWaveHdrDst->dwFlags = 0;
lpWaveHdrDst->dwLoops = 0;
- dwRet = waveOutPrepareHeader(wom->hWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
+ dwRet = waveOutPrepareHeader(wom->hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
if (dwRet != MMSYSERR_NOERROR)
goto errCleanUp;
@@ -246,13 +256,13 @@
DWORD dwRet1, dwRet2;
if (!wom->hAcmStream) {
- return waveOutUnprepareHeader(wom->hWave, lpWaveHdrSrc, dwParam2);
+ return waveOutUnprepareHeader(wom->hInnerWave, lpWaveHdrSrc, dwParam2);
}
ash = (PACMSTREAMHEADER)lpWaveHdrSrc->reserved;
dwRet1 = acmStreamUnprepareHeader(wom->hAcmStream, ash, 0L);
lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
- dwRet2 = waveOutUnprepareHeader(wom->hWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
+ dwRet2 = waveOutUnprepareHeader(wom->hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));
HeapFree(GetProcessHeap(), 0, ash);
@@ -262,14 +272,16 @@
static DWORD wodGetPosition(WAVEMAPDATA* wom, LPMMTIME lpTime, DWORD dwParam2)
{
- return waveOutGetPosition(wom->hWave, lpTime, dwParam2);
+ if (wom->hAcmStream)
+ FIXME("No position conversion done for PCM => non-PCM, returning PCM position\n");
+ return waveOutGetPosition(wom->hInnerWave, lpTime, dwParam2);
}
static DWORD wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSA lpWaveCaps, DWORD dwParam2)
{
/* if opened low driver, forward message */
if (WAVEMAP_IsData(wom))
- return waveOutGetDevCapsA(wom->hWave, lpWaveCaps, dwParam2);
+ return waveOutGetDevCapsA(wom->hInnerWave, lpWaveCaps, dwParam2);
/* otherwise, return caps of mapper itself */
if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
lpWaveCaps->wMid = 0x00FF;
@@ -292,35 +304,35 @@
static DWORD wodGetVolume(UINT wDevID, WAVEMAPDATA* wom, LPDWORD lpVol)
{
if (WAVEMAP_IsData(wom))
- return waveOutGetVolume(wom->hWave, lpVol);
+ return waveOutGetVolume(wom->hInnerWave, lpVol);
return MMSYSERR_NOERROR;
}
static DWORD wodSetVolume(UINT wDevID, WAVEMAPDATA* wom, DWORD vol)
{
if (WAVEMAP_IsData(wom))
- return waveOutSetVolume(wom->hWave, vol);
+ return waveOutSetVolume(wom->hInnerWave, vol);
return MMSYSERR_NOERROR;
}
static DWORD wodPause(WAVEMAPDATA* wom)
{
- return waveOutPause(wom->hWave);
+ return waveOutPause(wom->hInnerWave);
}
static DWORD wodRestart(WAVEMAPDATA* wom)
{
- return waveOutRestart(wom->hWave);
+ return waveOutRestart(wom->hInnerWave);
}
static DWORD wodReset(WAVEMAPDATA* wom)
{
- return waveOutReset(wom->hWave);
+ return waveOutReset(wom->hInnerWave);
}
static DWORD wodBreakLoop(WAVEMAPDATA* wom)
{
- return waveOutBreakLoop(wom->hWave);
+ return waveOutBreakLoop(wom->hInnerWave);
}
static DWORD wodMapperStatus(WAVEMAPDATA* wom, DWORD flags, LPVOID ptr)
@@ -330,7 +342,7 @@
switch (flags) {
case WAVEOUT_MAPPER_STATUS_DEVICE:
- ret = waveOutGetID(wom->hWave, &id);
+ ret = waveOutGetID(wom->hInnerWave, &id);
*(LPDWORD)ptr = id;
break;
case WAVEOUT_MAPPER_STATUS_MAPPED:
@@ -395,61 +407,246 @@
* WAVE IN part *
*======================================================================*/
+static void CALLBACK widCallback(HWAVE hWave, UINT uMsg, DWORD dwInstance,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ WAVEMAPDATA* wim = (WAVEMAPDATA*)dwInstance;
+
+ TRACE("(0x%x %u %ld %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
+
+ if (!WAVEMAP_IsData(wim)) {
+ ERR("Bad date\n");
+ return;
+ }
+
+ if (hWave != wim->hInnerWave && uMsg != WIM_OPEN)
+ ERR("Shouldn't happen (%08x %08x)\n", hWave, wim->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 %ld bytes into %ld\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)lpWaveHdrDst;
+ }
+ break;
+ default:
+ ERR("Unknown msg %u\n", uMsg);
+ }
+
+ DriverCallback(wim->dwCallback, HIWORD(wim->dwFlags), wim->hOuterWave, uMsg,
+ wim->dwClientInstance, dwParam1, dwParam2);
+}
+
+static DWORD widOpenHelper(WAVEMAPDATA* wim, UINT idx,
+ LPWAVEOPENDESC lpDesc, LPWAVEFORMATEX lpwfx,
+ DWORD dwFlags)
+{
+ DWORD ret;
+
+ /* source is always PCM, so the formulas below apply */
+ lpwfx->nBlockAlign = (lpwfx->nChannels * lpwfx->wBitsPerSample) / 8;
+ lpwfx->nAvgBytesPerSec = lpwfx->nSamplesPerSec * lpwfx->nBlockAlign;
+ ret = acmStreamOpen(&wim->hAcmStream, 0, lpwfx, lpDesc->lpFormat, NULL, 0L, 0L,
+ (dwFlags & WAVE_FORMAT_QUERY) ? ACM_STREAMOPENF_QUERY : 0L);
+ if (ret != MMSYSERR_NOERROR)
+ return ret;
+ return waveInOpen(&wim->hInnerWave, idx, lpwfx, (DWORD)widCallback,
+ (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
+}
+
static DWORD widOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
{
UINT nd = waveInGetNumDevs();
UINT i;
WAVEMAPDATA* wim = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEMAPDATA));
+ WAVEFORMATEX wfx;
TRACE("(%p %p %08lx\n", lpdwUser, lpDesc, dwFlags);
- wim->self = wim;
+ if (!wim)
+ return MMSYSERR_NOMEM;
+ wim->self = wim;
+ wim->dwCallback = lpDesc->dwCallback;
+ wim->dwFlags = dwFlags;
+ wim->dwClientInstance = lpDesc->dwInstance;
+ wim->hOuterWave = lpDesc->hWave;
+
for (i = 0; i < nd; i++) {
- if (waveInOpen(&wim->hWave, i, lpDesc->lpFormat, lpDesc->dwCallback,
- lpDesc->dwInstance, dwFlags) == MMSYSERR_NOERROR) {
- lpDesc->hWave = wim->hWave;
- *lpdwUser = (DWORD)wim;
- return MMSYSERR_NOERROR;
+ if (waveInOpen(&wim->hInnerWave, i, lpDesc->lpFormat, (DWORD)widCallback,
+ (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION) == MMSYSERR_NOERROR) {
+ wim->hAcmStream = 0;
+ goto found;
}
}
+ 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); \
+ if (widOpenHelper(wim, i, lpDesc, &wfx, dwFlags) == MMSYSERR_NOERROR) goto found;
+
+ for (i = 0; i < nd; i++) {
+ /* first try with same stereo/mono option as source */
+ wfx.nChannels = lpDesc->lpFormat->nChannels;
+ 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(44100, 8);
+ TRY(22050, 8);
+ TRY(11025, 8);
+ }
+#undef TRY
+
HeapFree(GetProcessHeap(), 0, wim);
return MMSYSERR_ALLOCATED;
+found:
+ if (dwFlags & WAVE_FORMAT_QUERY) {
+ *lpdwUser = 0L;
+ HeapFree(GetProcessHeap(), 0, wim);
+ } else {
+ *lpdwUser = (DWORD)wim;
+ }
+ return MMSYSERR_NOERROR;
}
static DWORD widClose(WAVEMAPDATA* wim)
{
- DWORD ret = waveInClose(wim->hWave);
- if (ret == MMSYSERR_NOERROR)
- HeapFree(GetProcessHeap(), 0, wim);
+ DWORD ret = waveInClose(wim->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 lpWaveHdr, DWORD dwParam2)
+static DWORD widAddBuffer(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
{
- return waveInAddBuffer(wim->hWave, lpWaveHdr, dwParam2);
+ PACMSTREAMHEADER ash;
+ LPWAVEHDR lpWaveHdrSrc;
+
+ if (!wim->hAcmStream) {
+ return waveInAddBuffer(wim->hInnerWave, lpWaveHdrDst, dwParam2);
+ }
+
+ lpWaveHdrDst->dwFlags |= WHDR_INQUEUE;
+ ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
+
+ lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+ return waveInAddBuffer(wim->hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
}
-static DWORD widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdr, DWORD dwParam2)
+static DWORD widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
{
- return waveInPrepareHeader(wim->hWave, lpWaveHdr, dwParam2);
+ PACMSTREAMHEADER ash;
+ DWORD size;
+ DWORD dwRet;
+ LPWAVEHDR lpWaveHdrSrc;
+
+ if (!wim->hAcmStream) {
+ return waveInPrepareHeader(wim->hInnerWave, lpWaveHdrDst, dwParam2);
+ }
+ if (acmStreamSize(wim->hAcmStream, lpWaveHdrDst->dwBufferLength, &size,
+ ACM_STREAMSIZEF_DESTINATION) != MMSYSERR_NOERROR)
+ return MMSYSERR_ERROR;
+
+ ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);
+ if (ash == NULL)
+ return MMSYSERR_NOMEM;
+
+ ash->cbStruct = sizeof(*ash);
+ ash->fdwStatus = 0L;
+ ash->dwUser = (DWORD)lpWaveHdrDst;
+ ash->pbSrc = (LPSTR)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
+ ash->cbSrcLength = size;
+ /* ash->cbSrcLengthUsed */
+ ash->dwSrcUser = 0L; /* FIXME ? */
+ ash->pbDst = lpWaveHdrDst->lpData;
+ ash->cbDstLength = lpWaveHdrDst->dwBufferLength;
+ /* ash->cbDstLengthUsed */
+ ash->dwDstUser = lpWaveHdrDst->dwUser; /* FIXME ? */
+ dwRet = acmStreamPrepareHeader(wim->hAcmStream, ash, 0L);
+ if (dwRet != MMSYSERR_NOERROR)
+ goto errCleanUp;
+
+ lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+ lpWaveHdrSrc->lpData = ash->pbSrc;
+ lpWaveHdrSrc->dwBufferLength = size; /* conversion is not done yet */
+ lpWaveHdrSrc->dwFlags = 0;
+ lpWaveHdrSrc->dwLoops = 0;
+ dwRet = waveInPrepareHeader(wim->hInnerWave, lpWaveHdrSrc, sizeof(*lpWaveHdrSrc));
+ if (dwRet != MMSYSERR_NOERROR)
+ goto errCleanUp;
+
+ lpWaveHdrDst->reserved = (DWORD)ash;
+ lpWaveHdrDst->dwFlags = WHDR_PREPARED;
+ TRACE("=> (0)\n");
+ return MMSYSERR_NOERROR;
+errCleanUp:
+ TRACE("=> (%ld)\n", dwRet);
+ HeapFree(GetProcessHeap(), 0, ash);
+ return dwRet;
}
-static DWORD widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdr, DWORD dwParam2)
+static DWORD widUnprepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2)
{
- return waveInUnprepareHeader(wim->hWave, lpWaveHdr, dwParam2);
+ PACMSTREAMHEADER ash;
+ LPWAVEHDR lpWaveHdrSrc;
+ DWORD dwRet1, dwRet2;
+
+ if (!wim->hAcmStream) {
+ return waveInUnprepareHeader(wim->hInnerWave, lpWaveHdrDst, dwParam2);
+ }
+ ash = (PACMSTREAMHEADER)lpWaveHdrDst->reserved;
+ dwRet1 = acmStreamUnprepareHeader(wim->hAcmStream, ash, 0L);
+
+ lpWaveHdrSrc = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));
+ dwRet2 = waveInUnprepareHeader(wim->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)
{
- return waveInGetPosition(wim->hWave, lpTime, dwParam2);
+ if (wim->hAcmStream)
+ FIXME("No position conversion done for PCM => non-PCM, returning PCM position\n");
+ return waveInGetPosition(wim->hInnerWave, lpTime, dwParam2);
}
static DWORD widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSA lpWaveCaps, DWORD dwParam2)
{
/* if opened low driver, forward message */
if (WAVEMAP_IsData(wim))
- return waveInGetDevCapsA(wim->hWave, lpWaveCaps, dwParam2);
+ return waveInGetDevCapsA(wim->hInnerWave, lpWaveCaps, dwParam2);
/* otherwise, return caps of mapper itself */
if (wDevID == (UINT)-1 || wDevID == (UINT16)-1) {
lpWaveCaps->wMid = 0x00FF;
@@ -469,17 +666,17 @@
static DWORD widStop(WAVEMAPDATA* wim)
{
- return waveInStop(wim->hWave);
+ return waveInStop(wim->hInnerWave);
}
static DWORD widStart(WAVEMAPDATA* wim)
{
- return waveInStart(wim->hWave);
+ return waveInStart(wim->hInnerWave);
}
static DWORD widReset(WAVEMAPDATA* wim)
{
- return waveInReset(wim->hWave);
+ return waveInReset(wim->hInnerWave);
}
static DWORD widMapperStatus(WAVEMAPDATA* wim, DWORD flags, LPVOID ptr)
@@ -489,7 +686,7 @@
switch (flags) {
case WAVEIN_MAPPER_STATUS_DEVICE:
- ret = waveInGetID(wim->hWave, &id);
+ ret = waveInGetID(wim->hInnerWave, &id);
*(LPDWORD)ptr = id;
break;
case WAVEIN_MAPPER_STATUS_MAPPED:
@@ -582,8 +779,8 @@
LONG CALLBACK WAVEMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
-/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
-/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
+ TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",
+ dwDevID, hDriv, wMsg, dwParam1, dwParam2);
switch(wMsg) {
case DRV_LOAD: return 1;
More information about the wine-patches
mailing list