mm split

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



this second patch unifies the constant used for error codes reporting
mapping functions success/failures
this is a noop too

A+
Index: lolvldrv.c
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/winmm/lolvldrv.c,v
retrieving revision 1.34
diff -u -r1.34 lolvldrv.c
--- lolvldrv.c	15 Oct 2002 21:00:05 -0000	1.34
+++ lolvldrv.c	22 Oct 2002 19:14:52 -0000
@@ -55,15 +55,7 @@
     WINE_MM_DRIVER_PART		parts[MMDRV_MAX];/* Information for all known types */
 } WINE_MM_DRIVER, *LPWINE_MM_DRIVER;
 
-typedef enum {
-    MMDRV_MAP_NOMEM, 	/* ko, memory problem */
-    MMDRV_MAP_MSGERROR, /* ko, unknown message */
-    MMDRV_MAP_OK, 	/* ok, no memory allocated. to be sent to the proc. */
-    MMDRV_MAP_OKMEM, 	/* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
-    MMDRV_MAP_PASS	/* not handled (no memory allocated) to be sent to the driver */
-} MMDRV_MapType;
-
-typedef	MMDRV_MapType	(*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2);
+typedef	WINMM_MapType	(*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2);
 
 /* each known type of driver has an instance of this structure */
 typedef struct tagWINE_LLTYPE {
@@ -213,31 +205,31 @@
 /**************************************************************************
  * 				MMDRV_Aux_Map16To32A		[internal]
  */
-static	MMDRV_MapType	MMDRV_Aux_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Aux_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_Aux_UnMap16To32A		[internal]
  */
-static	MMDRV_MapType	MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_Aux_Map32ATo16		[internal]
  */
-static	MMDRV_MapType	MMDRV_Aux_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Aux_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_Aux_UnMap32ATo16		[internal]
  */
-static	MMDRV_MapType	MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
 #if 0
  case AUXDM_GETDEVCAPS:
@@ -248,7 +240,7 @@
     lpCaps->wTechnology = ac16.wTechnology;
     lpCaps->dwSupport = ac16.dwSupport;
 #endif
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
@@ -269,15 +261,15 @@
 /**************************************************************************
  * 				xMMDRV_Mixer_Map16To32A		[internal]
  */
-static	MMDRV_MapType	MMDRV_Mixer_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Mixer_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_Mixer_UnMap16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
 #if 0
     MIXERCAPSA	micA;
@@ -293,23 +285,23 @@
     }
     return ret;
 #endif
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_Mixer_Map32ATo16		[internal]
  */
-static	MMDRV_MapType	MMDRV_Mixer_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Mixer_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_Mixer_UnMap32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
@@ -330,33 +322,33 @@
 /**************************************************************************
  * 				MMDRV_MidiIn_Map16To32A		[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiIn_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiIn_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_MidiIn_UnMap16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_MidiIn_Map32ATo16		[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiIn_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiIn_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 				MMDRV_MidiIn_UnMap32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    return MMDRV_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
@@ -418,16 +410,16 @@
 /**************************************************************************
  * 				MMDRV_MidiOut_Map16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiOut_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiOut_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case MODM_GETNUMDEVS:
     case MODM_DATA:
     case MODM_RESET:
     case MODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case MODM_OPEN:
@@ -447,9 +439,9 @@
 		*lpParam1 = (DWORD)moc32;
 		*lpParam2 = sizeof(MIDIOUTCAPSA);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -475,9 +467,9 @@
 		*lpParam1 = (DWORD)mh32;
 		*lpParam2 = sizeof(MIDIHDR);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -495,7 +487,7 @@
 		    mh32->dwBufferLength, mh16->dwBufferLength);
 	    } else
                 mh32->dwBufferLength = mh16->dwBufferLength;
-	    ret = MMDRV_MAP_OKMEM;
+	    ret = WINMM_MAP_OKMEM;
 	}
 	break;
 
@@ -511,16 +503,16 @@
 /**************************************************************************
  * 				MMDRV_MidiOut_UnMap16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case MODM_GETNUMDEVS:
     case MODM_DATA:
     case MODM_RESET:
     case MODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case MODM_OPEN:
@@ -544,7 +536,7 @@
 	    moc16->wChannelMask		= moc32->wChannelMask;
 	    moc16->dwSupport		= moc32->dwSupport;
 	    HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case MODM_PREPARE:
@@ -566,7 +558,7 @@
 		HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
 		mh16->lpNext = 0;
 	    }
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
 
@@ -582,9 +574,9 @@
 /**************************************************************************
  * 				MMDRV_MidiOut_Map32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiOut_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiOut_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case MODM_CLOSE:
@@ -592,7 +584,7 @@
     case MODM_DATA:
     case MODM_RESET:
     case MODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
     case MODM_GETDEVCAPS:
 	{
@@ -601,9 +593,9 @@
 
 	    if (ptr) {
 		*(LPMIDIOUTCAPSA*)ptr = moc32;
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	    *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSA);
 	    *lpParam2 = sizeof(MIDIOUTCAPS16);
@@ -638,9 +630,9 @@
 		      mh32->dwBufferLength, (DWORD)mh32->lpData);
 		*lpParam2 = sizeof(MIDIHDR);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -667,7 +659,7 @@
 		    mh16->dwBufferLength, mh32->dwBufferLength);
 	    } else
                 mh16->dwBufferLength = mh32->dwBufferLength;
-	    ret = MMDRV_MAP_OKMEM;
+	    ret = WINMM_MAP_OKMEM;
 	}
 	break;
     case MODM_OPEN:
@@ -703,9 +695,9 @@
 		*lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
 		*lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -722,9 +714,9 @@
 /**************************************************************************
  * 				MMDRV_MidiOut_UnMap32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case MODM_CLOSE:
@@ -732,7 +724,7 @@
     case MODM_DATA:
     case MODM_RESET:
     case MODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
     case MODM_GETDEVCAPS:
 	{
@@ -751,7 +743,7 @@
 	    moc32->dwSupport		= moc16->dwSupport;
             UnMapLS( *lpParam1 );
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case MODM_PREPARE:
@@ -772,7 +764,7 @@
                 HeapFree( GetProcessHeap(), 0, ptr );
 		mh32->lpNext = 0;
 	    }
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case MODM_OPEN:
@@ -783,7 +775,7 @@
 	    **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
 
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case MODM_GETVOLUME:
@@ -847,16 +839,16 @@
 /**************************************************************************
  * 				MMDRV_WaveIn_Map16To32A		[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveIn_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveIn_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case WIDM_GETNUMDEVS:
     case WIDM_RESET:
     case WIDM_START:
     case WIDM_STOP:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
     case WIDM_OPEN:
     case WIDM_CLOSE:
@@ -873,9 +865,9 @@
 		*lpParam1 = (DWORD)wic32;
 		*lpParam2 = sizeof(WAVEINCAPSA);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -892,9 +884,9 @@
 		*lpParam1 = (DWORD)mmt32;
 		*lpParam2 = sizeof(MMTIME);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -918,9 +910,9 @@
 		*lpParam1 = (DWORD)wh32;
 		*lpParam2 = sizeof(WAVEHDR);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -938,13 +930,13 @@
 		    wh32->dwBufferLength, wh16->dwBufferLength);
 	    } else
                 wh32->dwBufferLength = wh16->dwBufferLength;
-	    ret = MMDRV_MAP_OKMEM;
+	    ret = WINMM_MAP_OKMEM;
 	}
 	break;
     case WIDM_MAPPER_STATUS:
 	/* just a single DWORD */
 	*lpParam2 = (DWORD)MapSL(*lpParam2);
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
     default:
 	FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
@@ -956,9 +948,9 @@
 /**************************************************************************
  * 				MMDRV_WaveIn_UnMap16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case WIDM_GETNUMDEVS:
@@ -966,7 +958,7 @@
     case WIDM_START:
     case WIDM_STOP:
     case WIDM_MAPPER_STATUS:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
     case WIDM_OPEN:
     case WIDM_CLOSE:
@@ -984,7 +976,7 @@
 	    wic16->dwFormats = wic32->dwFormats;
 	    wic16->wChannels = wic32->wChannels;
 	    HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WIDM_GETPOS:
@@ -994,7 +986,7 @@
 
 	    MMSYSTEM_MMTIME32to16(mmt16, mmt32);
 	    HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WIDM_ADDBUFFER:
@@ -1015,7 +1007,7 @@
 		HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
 		wh16->lpNext = 0;
 	    }
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     default:
@@ -1028,9 +1020,9 @@
 /**************************************************************************
  * 				MMDRV_WaveIn_Map32ATo16		[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveIn_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveIn_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case WIDM_CLOSE:
@@ -1038,7 +1030,7 @@
     case WIDM_RESET:
     case WIDM_START:
     case WIDM_STOP:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case WIDM_OPEN:
@@ -1082,9 +1074,9 @@
 		*lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
 		*lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1115,9 +1107,9 @@
 		*lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
 		*lpParam2 = sizeof(WAVEHDR);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1146,7 +1138,7 @@
 		    wh16->dwBufferLength, wh32->dwBufferLength);
 	    } else
                 wh16->dwBufferLength = wh32->dwBufferLength;
-	    ret = MMDRV_MAP_OKMEM;
+	    ret = WINMM_MAP_OKMEM;
 	}
 	break;
    case WIDM_GETDEVCAPS:
@@ -1156,9 +1148,9 @@
 
 	    if (ptr) {
 		*(LPWAVEINCAPSA*)ptr = wic32;
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	    *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSA);
 	    *lpParam2 = sizeof(WAVEINCAPS16);
@@ -1173,9 +1165,9 @@
 	    if (ptr) {
 		*(LPMMTIME*)ptr = mmt32;
 		mmt16->wType = mmt32->wType;
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	    *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
 	    *lpParam2 = sizeof(MMTIME16);
@@ -1185,7 +1177,7 @@
  	{
             LPDWORD p32 = (LPDWORD)*lpParam2;
             *lpParam2 = MapLS(p32);
-            ret = MMDRV_MAP_OKMEM;
+            ret = WINMM_MAP_OKMEM;
 	}
 	break;
     default:
@@ -1198,9 +1190,9 @@
 /**************************************************************************
  * 				MMDRV_WaveIn_UnMap32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case WIDM_CLOSE:
@@ -1208,7 +1200,7 @@
     case WIDM_RESET:
     case WIDM_START:
     case WIDM_STOP:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case WIDM_OPEN:
@@ -1221,7 +1213,7 @@
 	    wod32->uMappedDeviceID = wod16->uMappedDeviceID;
 	    **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
 
@@ -1244,7 +1236,7 @@
                 HeapFree( GetProcessHeap(), 0, ptr );
 		wh32->lpNext = 0;
 	    }
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
      case WIDM_GETDEVCAPS:
@@ -1261,7 +1253,7 @@
 	    wic32->wChannels = wic16->wChannels;
             UnMapLS( *lpParam1 );
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WIDM_GETPOS:
@@ -1273,13 +1265,13 @@
 	    MMSYSTEM_MMTIME16to32(mmt32, mmt16);
             UnMapLS( *lpParam1 );
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case DRVM_MAPPER_STATUS:
 	{
             UnMapLS( *lpParam2 );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     default:
@@ -1336,9 +1328,9 @@
 /**************************************************************************
  * 				MMDRV_WaveOut_Map16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveOut_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveOut_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     /* nothing to do */
@@ -1351,7 +1343,7 @@
     case WODM_SETPITCH:
     case WODM_SETPLAYBACKRATE:
     case WODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case WODM_GETPITCH:
@@ -1372,9 +1364,9 @@
 		*lpParam1 = (DWORD)woc32;
 		*lpParam2 = sizeof(WAVEOUTCAPSA);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1391,9 +1383,9 @@
 		*lpParam1 = (DWORD)mmt32;
 		*lpParam2 = sizeof(MMTIME);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1417,9 +1409,9 @@
 		*lpParam1 = (DWORD)wh32;
 		*lpParam2 = sizeof(WAVEHDR);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1437,12 +1429,12 @@
 		    wh32->dwBufferLength, wh16->dwBufferLength);
 	    } else
                 wh32->dwBufferLength = wh16->dwBufferLength;
-	    ret = MMDRV_MAP_OKMEM;
+	    ret = WINMM_MAP_OKMEM;
 	}
 	break;
     case WODM_MAPPER_STATUS:
 	*lpParam2 = (DWORD)MapSL(*lpParam2);
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
     default:
 	FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
@@ -1454,9 +1446,9 @@
 /**************************************************************************
  * 				MMDRV_WaveOut_UnMap16To32A	[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret = MMDRV_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     /* nothing to do */
@@ -1470,7 +1462,7 @@
     case WODM_SETPLAYBACKRATE:
     case WODM_SETVOLUME:
     case WODM_MAPPER_STATUS:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case WODM_GETPITCH:
@@ -1493,7 +1485,7 @@
 	    woc16->wChannels = woc32->wChannels;
 	    woc16->dwSupport = woc32->dwSupport;
 	    HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WODM_GETPOS:
@@ -1503,7 +1495,7 @@
 
 	    MMSYSTEM_MMTIME32to16(mmt16, mmt32);
 	    HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WODM_PREPARE:
@@ -1524,7 +1516,7 @@
 		HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
 		wh16->lpNext = 0;
 	    }
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     default:
@@ -1537,9 +1529,9 @@
 /**************************************************************************
  * 				MMDRV_WaveOut_Map32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveOut_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveOut_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret;
+    WINMM_MapType	ret;
 
     switch (wMsg) {
 	/* nothing to do */
@@ -1552,7 +1544,7 @@
     case WODM_SETPITCH:
     case WODM_SETPLAYBACKRATE:
     case WODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case WODM_GETDEVCAPS:
@@ -1563,9 +1555,9 @@
 
 	    if (ptr) {
 		*(LPWAVEOUTCAPSA*)ptr = woc32;
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	    *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSA);
 	    *lpParam2 = sizeof(WAVEOUTCAPS16);
@@ -1573,11 +1565,11 @@
 	break;
     case WODM_GETPITCH:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     case WODM_GETPLAYBACKRATE:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     case WODM_GETPOS:
 	{
@@ -1588,9 +1580,9 @@
 	    if (ptr) {
 		*(LPMMTIME*)ptr = mmt32;
 		mmt16->wType = mmt32->wType;
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	    *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
 	    *lpParam2 = sizeof(MMTIME16);
@@ -1598,7 +1590,7 @@
 	break;
     case WODM_GETVOLUME:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     case WODM_OPEN:
 	{
@@ -1641,9 +1633,9 @@
 		*lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
 		*lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1674,9 +1666,9 @@
 		*lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
 		*lpParam2 = sizeof(WAVEHDR);
 
-		ret = MMDRV_MAP_OKMEM;
+		ret = WINMM_MAP_OKMEM;
 	    } else {
-		ret = MMDRV_MAP_NOMEM;
+		ret = WINMM_MAP_NOMEM;
 	    }
 	}
 	break;
@@ -1705,19 +1697,19 @@
 		    wh16->dwBufferLength, wh32->dwBufferLength);
 	    } else
                 wh16->dwBufferLength = wh32->dwBufferLength;
-	    ret = MMDRV_MAP_OKMEM;
+	    ret = WINMM_MAP_OKMEM;
 	}
 	break;
     case DRVM_MAPPER_STATUS:
  	{
             LPDWORD p32 = (LPDWORD)*lpParam2;
             *lpParam2 = MapLS(p32);
-            ret = MMDRV_MAP_OKMEM;
+            ret = WINMM_MAP_OKMEM;
 	}
 	break;
     default:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     }
     return ret;
@@ -1726,9 +1718,9 @@
 /**************************************************************************
  * 				MMDRV_WaveOut_UnMap32ATo16	[internal]
  */
-static	MMDRV_MapType	MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static	WINMM_MapType	MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 {
-    MMDRV_MapType	ret;
+    WINMM_MapType	ret;
 
     switch (wMsg) {
 	/* nothing to do */
@@ -1741,7 +1733,7 @@
     case WODM_SETPITCH:
     case WODM_SETPLAYBACKRATE:
     case WODM_SETVOLUME:
-	ret = MMDRV_MAP_OK;
+	ret = WINMM_MAP_OK;
 	break;
 
     case WODM_GETDEVCAPS:
@@ -1759,16 +1751,16 @@
 	    woc32->dwSupport = woc16->dwSupport;
             UnMapLS( *lpParam1 );
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WODM_GETPITCH:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     case WODM_GETPLAYBACKRATE:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     case WODM_GETPOS:
 	{
@@ -1779,7 +1771,7 @@
 	    MMSYSTEM_MMTIME16to32(mmt32, mmt16);
             UnMapLS( *lpParam1 );
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WODM_OPEN:
@@ -1792,7 +1784,7 @@
 	    **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
             UnMapLS( *lpParam1 );
             HeapFree( GetProcessHeap(), 0, ptr );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WODM_PREPARE:
@@ -1814,22 +1806,22 @@
                 HeapFree( GetProcessHeap(), 0, ptr );
 		wh32->lpNext = 0;
 	    }
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     case WODM_GETVOLUME:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     case DRVM_MAPPER_STATUS:
 	{
             UnMapLS( *lpParam2 );
-	    ret = MMDRV_MAP_OK;
+	    ret = WINMM_MAP_OK;
 	}
 	break;
     default:
 	FIXME("NIY: no conversion yet\n");
-	ret = MMDRV_MAP_MSGERROR;
+	ret = WINMM_MAP_MSGERROR;
 	break;
     }
     return ret;
@@ -1910,7 +1902,7 @@
     DWORD			ret;
     WINE_MM_DRIVER_PART*	part;
     WINE_LLTYPE*		llType = &llTypes[mld->type];
-    MMDRV_MapType		map;
+    WINMM_MapType		map;
     int				devID;
 
     TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx %c)!\n",
@@ -1954,26 +1946,25 @@
 	} else {
 	    map = llType->Map16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
 	    switch (map) {
-	    case MMDRV_MAP_NOMEM:
+	    case WINMM_MAP_NOMEM:
 		ret = MMSYSERR_NOMEM;
 		break;
-	    case MMDRV_MAP_MSGERROR:
+	    case WINMM_MAP_MSGERROR:
 		FIXME("NIY: no conversion yet 16->32 (%u)\n", wMsg);
 		ret = MMSYSERR_ERROR;
 		break;
-	    case MMDRV_MAP_OK:
-	    case MMDRV_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		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("=> %lu\n", ret);
-		if (map == MMDRV_MAP_OKMEM)
+		if (map == WINMM_MAP_OKMEM)
 		    llType->UnMap16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
 		break;
 	    default:
-	    case MMDRV_MAP_PASS:
-		FIXME("NIY: pass used ?\n");
+		FIXME("NIY ?\n");
 		ret = MMSYSERR_NOTSUPPORTED;
 		break;
 	    }
@@ -1984,26 +1975,25 @@
 	if (bFrom32) {
 	    map = llType->Map32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
 	    switch (map) {
-	    case MMDRV_MAP_NOMEM:
+	    case WINMM_MAP_NOMEM:
 		ret = MMSYSERR_NOMEM;
 		break;
-	    case MMDRV_MAP_MSGERROR:
+	    case WINMM_MAP_MSGERROR:
 		FIXME("NIY: no conversion yet 32->16 (%u)\n", wMsg);
 		ret = MMSYSERR_ERROR;
 		break;
-	    case MMDRV_MAP_OK:
-	    case MMDRV_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		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 = MMDRV_CallTo16_word_wwlll((FARPROC16)part->u.fnMessage16, mld->uDeviceID,
 						wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
 		TRACE("=> %lu\n", ret);
-		if (map == MMDRV_MAP_OKMEM)
+		if (map == WINMM_MAP_OKMEM)
 		    llType->UnMap32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
 		break;
 	    default:
-	    case MMDRV_MAP_PASS:
-		FIXME("NIY: pass used ?\n");
+		FIXME("NIY\n");
 		ret = MMSYSERR_NOTSUPPORTED;
 		break;
 	    }
Index: mci.c
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/winmm/mci.c,v
retrieving revision 1.34
diff -u -r1.34 mci.c
--- mci.c	10 Oct 2002 23:28:22 -0000	1.34
+++ mci.c	22 Oct 2002 19:14:43 -0000
@@ -45,17 +45,10 @@
 static	int			MCI_InstalledCount;
 static	LPSTR			MCI_lpInstallNames = NULL;
 
-typedef enum {
-    MCI_MAP_NOMEM, 	/* ko, memory problem */
-    MCI_MAP_MSGERROR, 	/* ko, unknown message */
-    MCI_MAP_OK, 	/* ok, no memory allocated. to be sent to the proc. */
-    MCI_MAP_OKMEM, 	/* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
-} MCI_MapType;
-
-static	MCI_MapType	MCI_MapMsg16To32A  (WORD uDevType, WORD wMsg,                DWORD* lParam);
-static	MCI_MapType	MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg,                DWORD  lParam);
-static	MCI_MapType	MCI_MapMsg32ATo16  (WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam);
-static	MCI_MapType	MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD  lParam);
+static	WINMM_MapType	MCI_MapMsg16To32A  (WORD uDevType, WORD wMsg,                DWORD* lParam);
+static	WINMM_MapType	MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg,                DWORD  lParam);
+static	WINMM_MapType	MCI_MapMsg32ATo16  (WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam);
+static	WINMM_MapType	MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD  lParam);
 
 /* First MCI valid device ID (0 means error) */
 #define MCI_MAGIC 0x0001
@@ -466,20 +456,20 @@
     if ((wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp))) {
 	wmd->bIs32 = TRUE;
     } else {
-	MCI_MapType 	res;
+	WINMM_MapType 	res;
 
 	switch (res = MCI_MapMsg32ATo16(0, DRV_OPEN, 0, &lp)) {
-	case MCI_MAP_MSGERROR:
+	case WINMM_MAP_MSGERROR:
 	    TRACE("Not handled yet (DRV_OPEN)\n");
 	    break;
-	case MCI_MAP_NOMEM:
+	case WINMM_MAP_NOMEM:
 	    TRACE("Problem mapping msg=DRV_OPEN from 32a to 16\n");
 	    break;
-	case MCI_MAP_OK:
-	case MCI_MAP_OKMEM:
+	case WINMM_MAP_OK:
+	case WINMM_MAP_OKMEM:
 	    if ((wmd->hDriver = OpenDriverA(drvTyp, "mci", lp)))
 		wmd->bIs32 = FALSE;
-	    if (res == MCI_MAP_OKMEM)
+	    if (res == WINMM_MAP_OKMEM)
 		MCI_UnMapMsg32ATo16(0, DRV_OPEN, 0, lp);
 	    break;
 	}
@@ -1162,10 +1148,10 @@
 /**************************************************************************
  * 			MCI_MapMsg16To32A			[internal]
  */
-static	MCI_MapType	MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
+static	WINMM_MapType	MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
 {
     if (*lParam == 0)
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     /* FIXME: to add also (with seg/linear modifications to do):
      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
@@ -1204,7 +1190,7 @@
     case MCI_UPDATE:
     case MCI_WHERE:
 	*lParam = (DWORD)MapSL(*lParam);
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     case MCI_WINDOW:
 	/* in fact, I would also need the dwFlags... to see
 	 * which members of lParam are effectively used
@@ -1222,11 +1208,11 @@
 		mbp32->nVirtKey = mbp16->nVirtKey;
 		mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (DWORD)mbp32;
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
     case MCI_ESCAPE:
 	{
             LPMCI_VD_ESCAPE_PARMSA	mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
@@ -1236,11 +1222,11 @@
 		mvep32a->dwCallback       = mvep16->dwCallback;
 		mvep32a->lpstrCommand     = MapSL(mvep16->lpstrCommand);
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (DWORD)mvep32a;
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
     case MCI_INFO:
 	{
             LPMCI_INFO_PARMSA	mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
@@ -1254,11 +1240,11 @@
 		mip32a->lpstrReturn = MapSL(mip16->lpstrReturn);
 		mip32a->dwRetSize   = mip16->dwRetSize;
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (DWORD)mip32a;
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
     case MCI_OPEN:
     case MCI_OPEN_DRIVER:
 	{
@@ -1283,11 +1269,11 @@
 		 */
 		memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (DWORD)mop32a;
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
     case MCI_SYSINFO:
 	{
             LPMCI_SYSINFO_PARMSA	msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
@@ -1300,11 +1286,11 @@
 		msip32a->dwNumber         = msip16->dwNumber;
 		msip32a->wDeviceType      = msip16->wDeviceType;
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (DWORD)msip32a;
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
     case DRV_LOAD:
     case DRV_ENABLE:
     case DRV_OPEN:
@@ -1319,18 +1305,18 @@
     case DRV_EXITAPPLICATION:
     case DRV_POWER:
 	FIXME("This is a hack\n");
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 
     default:
 	WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
     }
-    return MCI_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /**************************************************************************
  * 			MCI_UnMapMsg16To32A			[internal]
  */
-static	MCI_MapType	MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
+static	WINMM_MapType	MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
 {
     switch (wMsg) {
 	/* case MCI_CAPTURE */
@@ -1365,18 +1351,18 @@
     case MCI_UNFREEZE:
     case MCI_UPDATE:
     case MCI_WHERE:
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 
     case MCI_WINDOW:
 	/* FIXME ?? see Map function */
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 
     case MCI_BREAK:
     case MCI_ESCAPE:
     case MCI_INFO:
     case MCI_SYSINFO:
 	HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     case MCI_OPEN:
     case MCI_OPEN_DRIVER:
 	if (lParam) {
@@ -1387,7 +1373,7 @@
 	    if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
 		FIXME("bad free line=%d\n", __LINE__);
 	}
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     case DRV_LOAD:
     case DRV_ENABLE:
     case DRV_OPEN:
@@ -1402,11 +1388,11 @@
     case DRV_EXITAPPLICATION:
     case DRV_POWER:
 	FIXME("This is a hack\n");
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     default:
 	FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
     }
-    return MCI_MAP_MSGERROR;
+    return WINMM_MAP_MSGERROR;
 }
 
 /*
@@ -1430,13 +1416,13 @@
  * above)
  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
  */
-static	MCI_MapType	MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
+static	WINMM_MapType	MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
 {
     void*	lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
     LPBYTE	p16, p32;
 
     if (!lp) {
-	return MCI_MAP_NOMEM;
+	return WINMM_MAP_NOMEM;
     }
     p32 = (LPBYTE)(*ptr);
     if (keep) {
@@ -1497,7 +1483,7 @@
 	if (size16 != 0) /* DEBUG only */
 	    FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
     }
-    return MCI_MAP_OKMEM;
+    return WINMM_MAP_OKMEM;
 }
 
 /**************************************************************************
@@ -1505,7 +1491,7 @@
  *
  * Helper for MCI_UnMapMsg32ATo16.
  */
-static	MCI_MapType	MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
+static	WINMM_MapType	MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
 {
     if (ptr) {
 	void*		msg16 = MapSL((SEGPTR)ptr);
@@ -1569,7 +1555,7 @@
 
         HeapFree( GetProcessHeap(), 0, alloc );
     }
-    return MCI_MAP_OK;
+    return WINMM_MAP_OK;
 }
 
 /**************************************************************************
@@ -1577,14 +1563,14 @@
  *
  * Map a 32-A bit MCI message to a 16 bit MCI message.
  */
-static	MCI_MapType	MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
+static	WINMM_MapType	MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
 {
     int		size;
     BOOLEAN     keep = FALSE;
     DWORD	map = 0;
 
     if (*lParam == 0)
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 
     /* FIXME: to add also (with seg/linear modifications to do):
      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
@@ -1604,7 +1590,7 @@
     case MCI_CUE:
 	switch (uDevType) {
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	size = sizeof(MCI_DGV_CUE_PARMS);	break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_CUE_PARMS);	break;*/	FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_CUE_PARMS);	break;*/	FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	default:			size = sizeof(MCI_GENERIC_PARMS);	break;
 	}
 	break;
@@ -1648,11 +1634,11 @@
 		    ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
 		}
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
             *lParam = MapLS(mip16);
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
 	/* case MCI_MARK: */
 	/* case MCI_MONITOR: */
     case MCI_OPEN:
@@ -1705,11 +1691,11 @@
 		 */
 		memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
 	/* case MCI_PASTE:*/
     case MCI_PAUSE:
 	size = sizeof(MCI_GENERIC_PARMS);
@@ -1730,7 +1716,7 @@
     case MCI_RECORD:
 	switch (uDevType) {
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	size = sizeof(MCI_DGV_RECORD_PARMS16);	map = 0x0F1111FB;	break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_RECORD_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_RECORD_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	default:			size = sizeof(MCI_RECORD_PARMS);	break;
 	}
 	break;
@@ -1739,14 +1725,14 @@
 	break;
     case MCI_SEEK:
 	switch (uDevType) {
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SEEK_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SEEK_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	default:			size = sizeof(MCI_SEEK_PARMS);		break;
 	}
 	break;
     case MCI_SET:
 	switch (uDevType) {
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	size = sizeof(MCI_DGV_SET_PARMS);	break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SET_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SET_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	case MCI_DEVTYPE_SEQUENCER:	size = sizeof(MCI_SEQ_SET_PARMS);	break;
         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
 	 * so not doing anything should work...
@@ -1758,7 +1744,7 @@
     case MCI_SETAUDIO:
 	switch (uDevType) {
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;	break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SETAUDIO_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SETAUDIO_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	default:			size = sizeof(MCI_GENERIC_PARMS);	break;
 	}
 	break;
@@ -1776,14 +1762,14 @@
 	 * Assuming solution 2: provided by MCI driver, so zeroing on entry
 	 */
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	size = sizeof(MCI_DGV_STATUS_PARMS16);	map = 0x0B6FF;		break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_STATUS_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_STATUS_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	default:			size = sizeof(MCI_STATUS_PARMS);	break;
 	}
 	break;
     case MCI_STEP:
 	switch (uDevType) {
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	size = sizeof(MCI_DGV_STEP_PARMS);	break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_STEP_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_STEP_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	case MCI_DEVTYPE_VIDEODISC:	size = sizeof(MCI_VD_STEP_PARMS);	break;
 	default:			size = sizeof(MCI_GENERIC_PARMS);	break;
 	}
@@ -1808,11 +1794,11 @@
 		msip16->dwNumber         = msip32a->dwNumber;
 		msip16->wDeviceType      = msip32a->wDeviceType;
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
 	/* case MCI_UNDO: */
     case MCI_UNFREEZE:
 	switch (uDevType) {
@@ -1855,11 +1841,11 @@
 		modp16->lpstrParams = MapLS( modp32a->lpstrParams );
 		/* other fields are gonna be filled by the driver, don't copy them */
  	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	    *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
     case DRV_LOAD:
     case DRV_ENABLE:
     case DRV_CLOSE:
@@ -1872,11 +1858,11 @@
     case DRV_EXITSESSION:
     case DRV_EXITAPPLICATION:
     case DRV_POWER:
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 
     default:
 	WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
-	return MCI_MAP_MSGERROR;
+	return WINMM_MAP_MSGERROR;
     }
     return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
 }
@@ -1884,7 +1870,7 @@
 /**************************************************************************
  * 			MCI_UnMapMsg32ATo16			[internal]
  */
-static	MCI_MapType	MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
+static	WINMM_MapType	MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
 {
     int		size = 0;
     BOOLEAN     kept = FALSE;	/* there is no need to compute size when kept is FALSE */
@@ -1919,7 +1905,7 @@
             UnMapLS( mip16->lpstrReturn );
             HeapFree( GetProcessHeap(), 0, mip16 );
 	}
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 	/* case MCI_MARK: */
 	/* case MCI_MONITOR: */
     case MCI_OPEN:
@@ -1937,7 +1923,7 @@
                 UnMapLS( mop16->lpstrAlias );
             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
 	}
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
 	/* case MCI_PASTE:*/
     case MCI_PAUSE:
 	break;
@@ -1958,7 +1944,7 @@
     case MCI_SETAUDIO:
 	switch (uDevType) {
 	case MCI_DEVTYPE_DIGITAL_VIDEO:	map = 0x0000077FF;	break;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SETAUDIO_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_SETAUDIO_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	}
 	break;
 	/* case MCI_SETTIMECODE:*/
@@ -1983,11 +1969,11 @@
 		}
                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	}
-	return MCI_MAP_OKMEM;
-	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_STATUS_PARMS);	break;*/FIXME("NIY vcr\n");	return MCI_MAP_NOMEM;
+	return WINMM_MAP_OKMEM;
+	case MCI_DEVTYPE_VCR:		/*size = sizeof(MCI_VCR_STATUS_PARMS);	break;*/FIXME("NIY vcr\n");	return WINMM_MAP_NOMEM;
 	default:			size = sizeof(MCI_STATUS_PARMS);	break;
 	}
 	break;
@@ -2006,10 +1992,10 @@
                 UnMapLS( msip16->lpstrReturn );
                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
 	    } else {
-		return MCI_MAP_NOMEM;
+		return WINMM_MAP_NOMEM;
 	    }
 	}
-	return MCI_MAP_OKMEM;
+	return WINMM_MAP_OKMEM;
 	/* case MCI_UNDO: */
     case MCI_UNFREEZE:
 	break;
@@ -2042,7 +2028,7 @@
             UnMapLS( modp16->lpstrParams );
             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
 	}
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     case DRV_LOAD:
     case DRV_ENABLE:
     case DRV_CLOSE:
@@ -2056,10 +2042,10 @@
     case DRV_EXITAPPLICATION:
     case DRV_POWER:
 	FIXME("This is a hack\n");
-	return MCI_MAP_OK;
+	return WINMM_MAP_OK;
     default:
 	FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
-	return MCI_MAP_MSGERROR;
+	return WINMM_MAP_MSGERROR;
     }
     return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
 }
@@ -2076,21 +2062,21 @@
 	if (wmd->bIs32) {
 	    dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
 	} else {
-	    MCI_MapType	res;
+	    WINMM_MapType	res;
 
 	    switch (res = MCI_MapMsg32ATo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
-	    case MCI_MAP_MSGERROR:
+	    case WINMM_MAP_MSGERROR:
 		TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
 		dwRet = MCIERR_DRIVER_INTERNAL;
 		break;
-	    case MCI_MAP_NOMEM:
+	    case WINMM_MAP_NOMEM:
 		TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg));
 		dwRet = MCIERR_OUT_OF_MEMORY;
 		break;
-	    case MCI_MAP_OK:
-	    case MCI_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
-		if (res == MCI_MAP_OKMEM)
+		if (res == WINMM_MAP_OKMEM)
 		    MCI_UnMapMsg32ATo16(wmd->wType, wMsg, dwParam1, dwParam2);
 		break;
 	    }
@@ -2111,21 +2097,21 @@
 	dwRet = MCIERR_INVALID_DEVICE_ID;
 
 	if (wmd->bIs32) {
-	    MCI_MapType		res;
+	    WINMM_MapType		res;
 
 	    switch (res = MCI_MapMsg16To32A(wmd->wType, wMsg, &dwParam2)) {
-	    case MCI_MAP_MSGERROR:
+	    case WINMM_MAP_MSGERROR:
 		TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
 		dwRet = MCIERR_DRIVER_INTERNAL;
 		break;
-	    case MCI_MAP_NOMEM:
+	    case WINMM_MAP_NOMEM:
 		TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg));
 		dwRet = MCIERR_OUT_OF_MEMORY;
 		break;
-	    case MCI_MAP_OK:
-	    case MCI_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
-		if (res == MCI_MAP_OKMEM)
+		if (res == WINMM_MAP_OKMEM)
 		    MCI_UnMapMsg16To32A(wmd->wType, wMsg, dwParam2);
 		break;
 	    }
@@ -2446,8 +2429,8 @@
 	    dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
 	} else {
 	    switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
-	    case MCI_MAP_OK:
-	    case MCI_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
 		MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
 		break;
@@ -2460,8 +2443,8 @@
 	    dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 	} else {
 	    switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
-	    case MCI_MAP_OK:
-	    case MCI_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 		MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
 		break;
@@ -2474,8 +2457,8 @@
 	    dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
 	} else {
 	    switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
-	    case MCI_MAP_OK:
-	    case MCI_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
 		MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
 		break;
@@ -2488,8 +2471,8 @@
 	    dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
 	} else {
 	    switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
-	    case MCI_MAP_OK:
-	    case MCI_MAP_OKMEM:
+	    case WINMM_MAP_OK:
+	    case WINMM_MAP_OKMEM:
 		dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
 		MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
 		break;

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux