stashmaster
authorMaarten Lankhorst <m.b.lankhorst@gmail.com>
Thu, 18 Dec 2008 20:12:54 +0000 (18 21:12 +0100)
committerMaarten Lankhorst <m.b.lankhorst@gmail.com>
Sat, 27 Dec 2008 20:18:38 +0000 (27 21:18 +0100)
dlls/msacm32.drv/wavemap.c
dlls/winmm/lolvldrv.c
dlls/winmm/winemm.h
dlls/winmm/winmm.c
include/mmddk.h
include/mmsystem.h
include/msacm.h

index 96f4626..2467970 100644 (file)
@@ -104,7 +104,7 @@ static void CALLBACK wodCallback(HWAVEOUT hWave, UINT uMsg, DWORD_PTR dwInstance
 
            lpWaveHdrSrc->dwFlags &= ~WHDR_INQUEUE;
            lpWaveHdrSrc->dwFlags |= WHDR_DONE;
-           dwParam1 = (DWORD)lpWaveHdrSrc;
+           dwParam1 = (DWORD_PTR)lpWaveHdrSrc;
        }
        break;
     default:
@@ -137,8 +137,8 @@ static      DWORD   wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
        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)wodCallback,
-                         (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
+       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;
@@ -148,7 +148,7 @@ static      DWORD   wodOpenHelper(WAVEMAPDATA* wom, UINT idx,
     return ret;
 }
 
-static DWORD   wodOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+static DWORD   wodOpen(DWORD_PTR *lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
 {
     UINT               ndlo, ndhi;
     UINT               i;
@@ -187,8 +187,8 @@ static      DWORD   wodOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
        /* 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)wodCallback,
-                       (DWORD)wom, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
+       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;
        }
@@ -278,7 +278,7 @@ found:
        *lpdwUser = 0L;
        HeapFree(GetProcessHeap(), 0, wom);
     } else {
-       *lpdwUser = (DWORD)wom;
+       *lpdwUser = (DWORD_PTR)wom;
     }
     return MMSYSERR_NOERROR;
 error:
@@ -369,7 +369,7 @@ static      DWORD   wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2
 
     ash->cbStruct = sizeof(*ash);
     ash->fdwStatus = 0L;
-    ash->dwUser = (DWORD)lpWaveHdrSrc;
+    ash->dwUser = (DWORD_PTR)lpWaveHdrSrc;
     ash->pbSrc = (LPBYTE)lpWaveHdrSrc->lpData;
     ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;
     /* ash->cbSrcLengthUsed */
@@ -395,7 +395,7 @@ static      DWORD   wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2
        goto errCleanUp;
     }
 
-    lpWaveHdrSrc->reserved = (DWORD)ash;
+    lpWaveHdrSrc->reserved = (DWORD_PTR)ash;
     lpWaveHdrSrc->dwFlags = WHDR_PREPARED;
     TRACE("=> (0)\n");
     return MMSYSERR_NOERROR;
@@ -498,7 +498,7 @@ static      DWORD   wodGetDevCaps(UINT wDevID, WAVEMAPDATA* wom, LPWAVEOUTCAPSW lpWaveC
 
     /* if opened low driver, forward message */
     if (WAVEMAP_IsData(wom))
-       return waveOutGetDevCapsW((UINT)wom->u.out.hInnerWave, lpWaveCaps, dwParam2);
+       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");
@@ -612,10 +612,10 @@ static  DWORD   wodMapperReconfigure(WAVEMAPDATA* wom, DWORD dwParam1, DWORD dwP
 /**************************************************************************
  *                             wodMessage (MSACM.@)
  */
-DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
-                               DWORD dwParam1, DWORD dwParam2)
+DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
+                               DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 {
-    TRACE("(%u, %04X, %08X, %08X, %08X);\n",
+    TRACE("(%u, %04X, %08lx, %08lx, %08lx);\n",
          wDevID, wMsg, dwUser, dwParam1, dwParam2);
 
     switch (wMsg) {
@@ -625,7 +625,7 @@ DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
     case DRVM_DISABLE:
        /* FIXME: Pretend this is supported */
        return 0;
-    case WODM_OPEN:            return wodOpen          ((LPDWORD)dwUser,      (LPWAVEOPENDESC)dwParam1,dwParam2);
+    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);
@@ -659,12 +659,12 @@ DWORD WINAPI WAVEMAP_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
  *                  WAVE IN part                                        *
  *======================================================================*/
 
-static void    CALLBACK widCallback(HWAVEIN hWave, UINT uMsg, DWORD dwInstance,
-                                    DWORD dwParam1, DWORD dwParam2)
+static void    CALLBACK widCallback(HWAVEIN hWave, UINT uMsg, DWORD_PTR dwInstance,
+                                    DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 {
     WAVEMAPDATA*       wim = (WAVEMAPDATA*)dwInstance;
 
-    TRACE("(%p %u %d %x %x);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
+    TRACE("(%p %u %lx %lx %lx);\n", hWave, uMsg, dwInstance, dwParam1, dwParam2);
 
     if (!WAVEMAP_IsData(wim)) {
        ERR("Bad data\n");
@@ -696,7 +696,7 @@ static void CALLBACK widCallback(HWAVEIN hWave, UINT uMsg, DWORD dwInstance,
            lpWaveHdrDst->dwFlags &= ~WHDR_INQUEUE;
            lpWaveHdrDst->dwFlags |= WHDR_DONE;
            lpWaveHdrDst->dwBytesRecorded = ash->cbDstLengthUsed;
-           dwParam1 = (DWORD)lpWaveHdrDst;
+           dwParam1 = (DWORD_PTR)lpWaveHdrDst;
        }
        break;
     default:
@@ -724,8 +724,8 @@ static      DWORD   widOpenHelper(WAVEMAPDATA* wim, UINT idx,
        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)widCallback,
-                        (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION);
+       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;
@@ -769,8 +769,8 @@ static      DWORD   widOpen(LPDWORD lpdwUser, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
     wim->nSamplesPerSecOuter = wim->nSamplesPerSecInner = lpDesc->lpFormat->nSamplesPerSec;
 
     for (i = ndlo; i < ndhi; i++) {
-       if (waveInOpen(&wim->u.in.hInnerWave, i, lpDesc->lpFormat, (DWORD)widCallback,
-                       (DWORD)wim, (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT) == MMSYSERR_NOERROR) {
+       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;
        }
@@ -847,9 +847,9 @@ found:
        *lpdwUser = 0L;
        HeapFree(GetProcessHeap(), 0, wim);
     } else {
-       *lpdwUser = (DWORD)wim;
+       *lpdwUser = (DWORD_PTR)wim;
     }
-    TRACE("Ok (stream=%08x)\n", (DWORD)wim->hAcmStream);
+    TRACE("Ok (stream=%p)\n", wim->hAcmStream);
     return MMSYSERR_NOERROR;
 error:
     HeapFree(GetProcessHeap(), 0, wim);
@@ -923,7 +923,7 @@ static      DWORD   widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2
 
     ash->cbStruct = sizeof(*ash);
     ash->fdwStatus = 0L;
-    ash->dwUser = (DWORD)lpWaveHdrDst;
+    ash->dwUser = (DWORD_PTR)lpWaveHdrDst;
     ash->pbSrc = (LPBYTE)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);
     ash->cbSrcLength = size;
     /* ash->cbSrcLengthUsed */
@@ -949,7 +949,7 @@ static      DWORD   widPrepare(WAVEMAPDATA* wim, LPWAVEHDR lpWaveHdrDst, DWORD dwParam2
        goto errCleanUp;
     }
 
-    lpWaveHdrDst->reserved = (DWORD)ash;
+    lpWaveHdrDst->reserved = (DWORD_PTR)ash;
     lpWaveHdrDst->dwFlags = WHDR_PREPARED;
     TRACE("=> (0)\n");
     return MMSYSERR_NOERROR;
@@ -1050,7 +1050,7 @@ static    DWORD   widGetDevCaps(UINT wDevID, WAVEMAPDATA* wim, LPWAVEINCAPSW lpWaveCa
 
     /* if opened low driver, forward message */
     if (WAVEMAP_IsData(wim))
-       return waveInGetDevCapsW((UINT)wim->u.in.hInnerWave, lpWaveCaps, dwParam2);
+       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");
@@ -1139,10 +1139,10 @@ static  DWORD   widMapperReconfigure(WAVEMAPDATA* wim, DWORD dwParam1, DWORD dwP
 /**************************************************************************
  *                             widMessage (MSACM.@)
  */
-DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
-                               DWORD dwParam1, DWORD dwParam2)
+DWORD WINAPI WAVEMAP_widMessage(WORD wDevID, WORD wMsg, DWORD_PTR dwUser,
+                               DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 {
-    TRACE("(%u, %04X, %08X, %08X, %08X);\n",
+    TRACE("(%u, %04X, %08lx, %08lx, %08lx);\n",
          wDevID, wMsg, dwUser, dwParam1, dwParam2);
 
     switch (wMsg) {
index 88e3ce4..bd9345d 100644 (file)
@@ -125,7 +125,7 @@ DWORD  MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
     WINMM_MapType              map;
     int                                devID;
 
-    TRACE("(%s %u %u 0x%08x 0x%08lx 0x%08lx %c)\n",
+    TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx %c)\n",
          llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
          mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N');
 
@@ -159,7 +159,7 @@ DWORD  MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
        assert(part->u.fnMessage32);
 
        if (bFrom32) {
-           TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
+           TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
                  mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
             ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
            TRACE("=> %s\n", WINMM_ErrorToString(ret));
@@ -175,7 +175,7 @@ DWORD  MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
                break;
            case WINMM_MAP_OK:
            case WINMM_MAP_OKMEM:
-               TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
+               TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
                      mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
                ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance,
                                          dwParam1, dwParam2);
@@ -204,7 +204,7 @@ DWORD  MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
                break;
            case WINMM_MAP_OK:
            case WINMM_MAP_OKMEM:
-               TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
+               TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
                      mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
                ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, 
                                          mld->uDeviceID, wMsg, mld->dwDriverInstance, 
@@ -219,7 +219,7 @@ DWORD  MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
                break;
            }
        } else {
-           TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
+           TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
                  mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
             ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, 
                                      mld->uDeviceID, wMsg, mld->dwDriverInstance, 
@@ -301,14 +301,14 @@ void      MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
 /**************************************************************************
  *                             MMDRV_Open                      [internal]
  */
-DWORD  MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags)
+DWORD  MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwFlags)
 {
     DWORD              dwRet = MMSYSERR_BADDEVICEID;
-    DWORD              dwInstance;
+    DWORD_PTR          dwInstance;
     WINE_LLTYPE*       llType = &llTypes[mld->type];
-    TRACE("(%p, %04x, 0x%08x, 0x%08x)\n", mld, wMsg, dwParam1, dwFlags);
+    TRACE("(%p, %04x, 0x%08lx, 0x%08lx)\n", mld, wMsg, dwParam1, dwFlags);
 
-    mld->dwDriverInstance = (DWORD)&dwInstance;
+    mld->dwDriverInstance = (DWORD_PTR)&dwInstance;
 
     if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) {
        TRACE("MAPPER mode requested !\n");
index dcd2290..72d8478 100644 (file)
@@ -95,7 +95,7 @@ typedef struct tagWINE_MLD {
        UINT                    uDeviceID;
        UINT                    type;
        UINT                    mmdIndex;               /* index to low-level driver in MMDrvs table */
-       DWORD                   dwDriverInstance;       /* this value is driver related, as opposed to
+       DWORD_PTR               dwDriverInstance;       /* this value is driver related, as opposed to
                                                         * opendesc.dwInstance which is client (callback) related */
        WORD                    bFrom32;
        WORD                    dwFlags;
@@ -191,7 +191,7 @@ UINT                MMDRV_GetNum(UINT);
 LPWINE_MLD     MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
                             DWORD_PTR* dwCallback, DWORD_PTR* dwInstance, BOOL bFrom32);
 void           MMDRV_Free(HANDLE hndl, LPWINE_MLD mld);
-DWORD          MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2);
+DWORD          MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
 DWORD          MMDRV_Close(LPWINE_MLD mld, UINT wMsg);
 LPWINE_MLD     MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID);
 LPWINE_MLD     MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstTyped);
index d9bd190..f2d378c 100644 (file)
@@ -365,7 +365,7 @@ UINT  MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
     wmld->uDeviceID = uDeviceID;
     mod.hmx = (HMIXEROBJ)hMix;
 
-    dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD)&mod, CALLBACK_FUNCTION);
+    dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD_PTR)&mod, CALLBACK_FUNCTION);
 
     if (dwRet != MMSYSERR_NOERROR) {
        MMDRV_Free(hMix, wmld);
@@ -771,7 +771,7 @@ UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
 
     TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
 
-    if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
+    if ((wmld = MMDRV_Get((HANDLE)(DWORD_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
        return MMSYSERR_INVALHANDLE;
     return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
 }
@@ -785,7 +785,7 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
 
     TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
 
-    if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
+    if ((wmld = MMDRV_Get((HANDLE)(DWORD_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
        return MMSYSERR_INVALHANDLE;
     return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
 }
@@ -797,7 +797,7 @@ UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PT
 {
     LPWINE_MLD         wmld;
 
-    if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
+    if ((wmld = MMDRV_Get((HANDLE)(DWORD_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
        return MMSYSERR_INVALHANDLE;
 
     return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
@@ -957,7 +957,7 @@ UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
 
     lpwm->mld.uDeviceID = uDeviceID;
 
-    dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD)&lpwm->mod, dwFlags);
+    dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags);
 
     if (dwRet != MMSYSERR_NOERROR) {
        MMDRV_Free(hMidiOut, (LPWINE_MLD)lpwm);
@@ -1258,7 +1258,7 @@ UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
     lpwm->mod.dwInstance = dwInstance;
 
     lpwm->mld.uDeviceID = uDeviceID;
-    dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD)&lpwm->mod, dwFlags);
+    dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags);
 
     if (dwRet != MMSYSERR_NOERROR) {
        MMDRV_Free(hMidiIn, &lpwm->mld);
@@ -1540,7 +1540,7 @@ static    BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
 
            DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
                           (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
-                          lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
+                          lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0L);
        }
        lpMidiStrm->lpMidiHdr = 0;
        SetEvent(lpMidiStrm->hEvent);
@@ -1605,7 +1605,7 @@ static    BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
 #endif
        if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
            ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
-           ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
+           ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD_PTR)lpMidiStrm) {
            FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
                  (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
                  ((LPMIDIEVENT)lpData)->dwStreamID);
@@ -1614,7 +1614,7 @@ static    BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
 
            DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
                           (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
-                          lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
+                          lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0L);
            break;
        }
 
@@ -1749,7 +1749,7 @@ static    DWORD   CALLBACK        MMSYSTEM_MidiStream_Player(LPVOID pmt)
            lpMidiStrm->lpMidiHdr = lpMidiHdr->lpNext;
            DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
                           (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
-                          lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
+                          lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0L);
            lpData = 0;
        }
     }
@@ -1824,7 +1824,7 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi
     lpMidiStrm->dwTimeDiv = 480;       /* 480 is 120 quarter notes per minute *//* FIXME ??*/
     lpMidiStrm->dwPositionMS = 0;
 
-    mosm.dwStreamID = (DWORD)lpMidiStrm;
+    mosm.dwStreamID = (DWORD_PTR)lpMidiStrm;
     /* FIXME: the correct value is not allocated yet for MAPPER */
     mosm.wDeviceID  = *lpuDeviceID;
     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm, bFrom32);
@@ -1834,7 +1834,7 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi
 
     lpwm->mld.uDeviceID = *lpuDeviceID;
 
-    ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD)&lpwm->mod, fdwOpen);
+    ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD_PTR)&lpwm->mod, fdwOpen);
     lpMidiStrm->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
     lpMidiStrm->wFlags = HIWORD(fdwOpen);
 
@@ -2096,7 +2096,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
     wod.dwInstance = dwInstance;
     wod.dnDevNode = 0L;
 
-    TRACE("cb=%08x\n", wod.dwCallback);
+    ERR("cb=%08lx\n", wod.dwCallback);
 
     for (;;) {
         if (dwFlags & WAVE_MAPPED) {
@@ -2108,7 +2108,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
         wmld->uDeviceID = uDeviceID;
     
         dwRet = MMDRV_Open(wmld, (uType == MMDRV_WAVEOUT) ? WODM_OPEN : WIDM_OPEN, 
-                           (DWORD)&wod, dwFlags);
+                           (DWORD_PTR)&wod, dwFlags);
 
         TRACE("dwRet = %s\n", WINMM_ErrorToString(dwRet));
         if (dwRet != WAVERR_BADFORMAT ||
index c2ed4fc..a121e48 100644 (file)
@@ -389,8 +389,8 @@ typedef struct {
 typedef struct {
        HWAVE                   hWave;
        LPWAVEFORMATEX          lpFormat;
-       DWORD                   dwCallback;
-       DWORD                   dwInstance;
+       DWORD_PTR               dwCallback;
+       DWORD_PTR               dwInstance;
        UINT                    uMappedDeviceID;
         DWORD                  dnDevNode;
 } WAVEOPENDESC, *LPWAVEOPENDESC;
index bb13cfd..26a3c98 100644 (file)
@@ -313,11 +313,11 @@ typedef struct wavehdr_tag {
     LPSTR       lpData;
     DWORD       dwBufferLength;
     DWORD       dwBytesRecorded;
-    DWORD       dwUser;
+    DWORD_PTR   dwUser;
     DWORD       dwFlags;
     DWORD       dwLoops;
     struct wavehdr_tag *lpNext;
-    DWORD       reserved;
+    DWORD_PTR   reserved;
 } WAVEHDR, *PWAVEHDR, *NPWAVEHDR, *LPWAVEHDR;
 
 #define WHDR_DONE       0x00000001
index 8a2c8e7..f7807c4 100644 (file)
@@ -541,7 +541,7 @@ typedef struct _ACMSTREAMHEADER
 {
   DWORD  cbStruct;
   DWORD  fdwStatus;
-  DWORD  dwUser;
+  DWORD_PTR dwUser;
   LPBYTE pbSrc;
   DWORD  cbSrcLength;
   DWORD  cbSrcLengthUsed;