[WINMM]
authorTimo Kreuzer <timo.kreuzer@reactos.org>
Mon, 28 Jun 2010 20:58:30 +0000 (20:58 +0000)
committerTimo Kreuzer <timo.kreuzer@reactos.org>
Mon, 28 Jun 2010 20:58:30 +0000 (20:58 +0000)
Fix a number of 64bit issues, add some comments where the code is not 64 bit safe. This module should be synced with wine, but this still causes a problem with Flash videos on FF2 (likely another timer problem)

svn path=/trunk/; revision=47900

reactos/dll/win32/winmm/driver.c
reactos/dll/win32/winmm/mci.c
reactos/dll/win32/winmm/midimap/midimap.c
reactos/dll/win32/winmm/mmio.c
reactos/dll/win32/winmm/winmm.c

index adad9ff..5f2c0dc 100644 (file)
@@ -467,7 +467,7 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar
     return 0;
 
  the_end:
-    if (lpDrv) TRACE("=> %08lx\n", (DWORD)lpDrv);
+    if (lpDrv) TRACE("=> %p\n", lpDrv);
     return (HDRVR)lpDrv;
 }
 
index 53a834c..7f36ef5 100644 (file)
@@ -975,7 +975,7 @@ static      WORD            MCI_GetMessage(LPCWSTR lpCmd)
 /**************************************************************************
  *                             MCI_GetDWord                    [internal]
  */
-static BOOL            MCI_GetDWord(LPDWORD data, LPWSTR* ptr)
+static BOOL            MCI_GetDWord(DWORD_PTR *data, LPWSTR* ptr)
 {
     DWORD      val;
     LPWSTR     ret;
@@ -1028,7 +1028,7 @@ static    DWORD   MCI_GetString(LPWSTR* str, LPWSTR* args)
 /**************************************************************************
  *                             MCI_ParseOptArgs                [internal]
  */
-static DWORD   MCI_ParseOptArgs(LPDWORD data, int _offset, LPCWSTR lpCmd,
+static DWORD   MCI_ParseOptArgs(DWORD_PTR *data, int _offset, LPCWSTR lpCmd,
                                 LPWSTR args, LPDWORD dwFlags)
 {
     int                len, offset;
@@ -1151,7 +1151,7 @@ static    DWORD   MCI_ParseOptArgs(LPDWORD data, int _offset, LPCWSTR lpCmd,
  *                             MCI_HandleReturnValues  [internal]
  */
 static DWORD   MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType, 
-                                       LPDWORD data, LPWSTR lpstrRet, UINT uRetLen)
+                                       DWORD_PTR *data, LPWSTR lpstrRet, UINT uRetLen)
 {
     static const WCHAR wszLd  [] = {'%','l','d',0};
     static const WCHAR wszLd4 [] = {'%','l','d',' ','%','l','d',' ','%','l','d',' ','%','l','d',0};
@@ -1229,7 +1229,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
     LPWINE_MCIDRIVER   wmd = 0;
     DWORD              dwFlags = 0, dwRet = 0;
     int                        offset = 0;
-    DWORD              data[MCI_DATA_SIZE];
+    DWORD_PTR  data[MCI_DATA_SIZE];
     DWORD              retType;
     LPCWSTR            lpCmd = 0;
     LPWSTR             devAlias = NULL;
@@ -1282,15 +1282,15 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
            tmp = devType; devType = dev; dev = tmp;
 
            dwFlags |= MCI_OPEN_TYPE;
-           data[2] = (DWORD)devType;
+           data[2] = (DWORD_PTR)devType;
            devType = str_dup_upper(devType);
            dwFlags |= MCI_OPEN_ELEMENT;
-           data[3] = (DWORD)dev;
+           data[3] = (DWORD_PTR)dev;
        } else if (DRIVER_GetLibName(dev, wszMci, buf, sizeof(buf))) {
             /* this is the name of a mci driver's type */
            tmp = strchrW(dev, ' ');
            if (tmp) *tmp = '\0';
-           data[2] = (DWORD)dev;
+           data[2] = (DWORD_PTR)dev;
            devType = str_dup_upper(dev);
            if (tmp) *tmp = ' ';
            dwFlags |= MCI_OPEN_TYPE;
@@ -1309,7 +1309,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
                devType = str_dup_upper(buf);
            }
            dwFlags |= MCI_OPEN_ELEMENT;
-           data[3] = (DWORD)dev;
+           data[3] = (DWORD_PTR)dev;
        }
        if ((devAlias = strstrW(args, wszSAliasS))) {
             WCHAR*      tmp2;
@@ -1319,7 +1319,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
             tmp2 = HeapAlloc(GetProcessHeap(), 0, (tmp - devAlias + 1) * sizeof(WCHAR) );
             memcpy( tmp2, devAlias, (tmp - devAlias) * sizeof(WCHAR) );
             tmp2[tmp - devAlias] = 0;
-            data[4] = (DWORD)tmp2;
+            data[4] = (DWORD_PTR)tmp2;
            /* should be done in regular options parsing */
            /* dwFlags |= MCI_OPEN_ALIAS; */
        } else if (dev == 0) {
@@ -1378,7 +1378,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
     switch (retType = MCI_GetReturnType(lpCmd)) {
     case 0:            offset = 1;     break;
     case MCI_INTEGER:  offset = 2;     break;
-    case MCI_STRING:   data[1] = (DWORD)lpstrRet; data[2] = uRetLen; offset = 3; break;
+    case MCI_STRING:   data[1] = (DWORD_PTR)lpstrRet; data[2] = uRetLen; offset = 3; break;
     case MCI_RECT:     offset = 5;     break;
     default:   ERR("oops\n");
     }
@@ -1391,7 +1391,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
 
     /* set up call back */
     if (dwFlags & MCI_NOTIFY) {
-       data[0] = (DWORD)hwndCallback;
+       data[0] = (DWORD_PTR)hwndCallback;
     }
 
     /* FIXME: the command should get it's own notification window set up and
@@ -1676,7 +1676,7 @@ static    DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms
 
     TRACE("(%04x, %08X, %p)\n", wDevID, dwParam, lpParms);
 
-    if (wDevID == (UINT16)MCI_ALL_DEVICE_ID) {
+    if (wDevID == MCI_ALL_DEVICE_ID) {
        /* FIXME: shall I notify once after all is done, or for
         * each of the open drivers ? if the latest, which notif
         * to return when only one fails ?
index e2b27d1..d991635 100644 (file)
@@ -260,7 +260,7 @@ static BOOL MIDIMAP_LoadSettings(MIDIMAPDATA* mom)
     return ret;
 }
 
-static DWORD   modOpen(LPDWORD lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
+static DWORD   modOpen(DWORD_PTR *lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 {
     MIDIMAPDATA*       mom = HeapAlloc(GetProcessHeap(), 0, sizeof(MIDIMAPDATA));
 
@@ -270,7 +270,7 @@ static      DWORD   modOpen(LPDWORD lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 
     if (MIDIMAP_LoadSettings(mom))
     {
-       *lpdwUser = (DWORD)mom;
+       *lpdwUser = (DWORD_PTR)mom;
        mom->self = mom;
 
        return MMSYSERR_NOERROR;
@@ -306,7 +306,7 @@ static      DWORD   modClose(MIDIMAPDATA* mom)
     return ret;
 }
 
-static DWORD   modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
+static DWORD   modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 {
     WORD       chn;
     DWORD      ret = MMSYSERR_NOERROR;
@@ -330,7 +330,7 @@ static      DWORD   modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
     return ret;
 }
 
-static DWORD   modData(MIDIMAPDATA* mom, DWORD dwParam)
+static DWORD   modData(MIDIMAPDATA* mom, DWORD_PTR dwParam)
 {
     BYTE       lb = LOBYTE(LOWORD(dwParam));
     WORD       chn = lb & 0x0F;
@@ -393,7 +393,7 @@ static      DWORD   modData(MIDIMAPDATA* mom, DWORD dwParam)
     return ret;
 }
 
-static DWORD   modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
+static DWORD   modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 {
     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
     if (lpMidiHdr->dwFlags & (MHDR_ISSTRM|MHDR_PREPARED))
@@ -403,7 +403,7 @@ static      DWORD   modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
     return MMSYSERR_NOERROR;
 }
 
-static DWORD   modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
+static DWORD   modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 {
     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
     if ((lpMidiHdr->dwFlags & MHDR_ISSTRM) || !(lpMidiHdr->dwFlags & MHDR_PREPARED))
@@ -413,7 +413,7 @@ static      DWORD   modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
     return MMSYSERR_NOERROR;
 }
 
-static DWORD   modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSW lpMidiCaps, DWORD size)
+static DWORD   modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSW lpMidiCaps, DWORD_PTR size)
 {
     static const WCHAR name[] = {'W','i','n','e',' ','m','i','d','i',' ','m','a','p','p','e','r',0};
     lpMidiCaps->wMid = 0x00FF;
@@ -451,8 +451,8 @@ static      DWORD   modReset(MIDIMAPDATA* mom)
 /**************************************************************************
  *                             modMessage (MIDIMAP.@)
  */
-DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
-                               DWORD dwParam1, DWORD dwParam2)
+DWORD WINAPI MIDIMAP_modMessage(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);
@@ -492,7 +492,7 @@ DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
 /**************************************************************************
  *                             MIDIMAP_drvOpen                 [internal]
  */
-static DWORD   MIDIMAP_drvOpen(LPSTR str)
+static LRESULT MIDIMAP_drvOpen(LPSTR str)
 {
     MIDIOUTCAPSW       moc;
     unsigned           dev, i;
@@ -527,7 +527,7 @@ static      DWORD   MIDIMAP_drvOpen(LPSTR str)
 /**************************************************************************
  *                             MIDIMAP_drvClose                [internal]
  */
-static DWORD   MIDIMAP_drvClose(DWORD dwDevID)
+static LRESULT MIDIMAP_drvClose(DWORD_PTR dwDevID)
 {
     if (midiOutPorts)
     {
@@ -541,8 +541,8 @@ static      DWORD   MIDIMAP_drvClose(DWORD dwDevID)
 /**************************************************************************
  *                             DriverProc (MIDIMAP.@)
  */
-LONG CALLBACK  MIDIMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
-                                  DWORD dwParam1, DWORD dwParam2)
+LRESULT CALLBACK       MIDIMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
+                                  LPARAM dwParam1, LPARAM dwParam2)
 {
 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
 /* EPP           dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
index b774003..3ee2652 100644 (file)
@@ -665,8 +665,8 @@ static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags,
     refmminfo->wErrorRet = send_message(wm->ioProc, &wm->info, MMIOM_OPEN,
                                         (LPARAM)szFileName, 0, FALSE);
 
-    /* grab file size, when possible */
-    wm->dwFileSize = GetFileSize((HANDLE)wm->info.adwInfo[0], NULL);
+    /* grab file size, when possible (FIXME: not 64 bit safe) */
+    wm->dwFileSize = GetFileSize((HANDLE)(ULONG_PTR)wm->info.adwInfo[0], NULL);
 
     if (refmminfo->wErrorRet == 0)
        return wm->info.hmmio;
index 9eb9b7b..b46a808 100644 (file)
@@ -760,7 +760,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(UlongToHandle(uDeviceID), MMDRV_AUX, TRUE)) == NULL)
        return MMSYSERR_INVALHANDLE;
     return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L);
 }
@@ -774,7 +774,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(UlongToHandle(uDeviceID), MMDRV_AUX, TRUE)) == NULL)
        return MMSYSERR_INVALHANDLE;
     return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L);
 }
@@ -786,7 +786,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(UlongToHandle(uDeviceID), MMDRV_AUX, TRUE)) == NULL)
        return MMSYSERR_INVALHANDLE;
 
     return MMDRV_Message(wmld, uMessage, dw1, dw2);
@@ -929,7 +929,7 @@ static      LPWINE_MIDI     MIDI_OutAlloc(HMIDIOUT* lphMidiOut, DWORD_PTR* lpdwCallback,
 /**************************************************************************
  *                             midiOutOpen             [WINMM.@]
  */
-UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
+MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
                        DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
 {
     HMIDIOUT           hMidiOut;
@@ -1220,7 +1220,7 @@ UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSi
 /**************************************************************************
  *                             midiInOpen              [WINMM.@]
  */
-UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
+MMRESULT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
                       DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
 {
     HANDLE             hMidiIn;
@@ -1466,7 +1466,7 @@ static    BOOL    MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm, WINE_MIDIStream** lpMidi
        return FALSE;
     }
 
-    *lpMidiStrm = (WINE_MIDIStream*)lpwm->mod.rgIds.dwStreamID;
+    *lpMidiStrm = (WINE_MIDIStream*)(ULONG_PTR)lpwm->mod.rgIds.dwStreamID; // FIXME: not 64 bit safe
 
     return *lpMidiStrm != NULL;
 }
@@ -1581,7 +1581,8 @@ static    BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
 #endif
        if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
            ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
-           ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
+           /* FIXME: not 64 bit safe */
+           ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD_PTR)lpMidiStrm) {
            FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
                  (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
                  ((LPMIDIEVENT)lpData)->dwStreamID);
@@ -1800,7 +1801,7 @@ MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
     lpMidiStrm->dwTimeDiv = 480;       /* 480 is 120 quarter notes per minute *//* FIXME ??*/
     lpMidiStrm->dwPositionMS = 0;
 
-    mosm.dwStreamID = (DWORD)lpMidiStrm;
+    mosm.dwStreamID = (DWORD_PTR)lpMidiStrm; // FIXME: not 64 bit safe
     /* FIXME: the correct value is not allocated yet for MAPPER */
     mosm.wDeviceID  = *lpuDeviceID;
     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm);