All driver functions are now properly separated.

dlls/winmm/driver.c

@@ -25,16 +25,20 @@
 #include <string.h>
 #include "heap.h"
 #include "windef.h"
+#include "wingdi.h"
+#include "winuser.h"
 #include "mmddk.h"
 #include "winemm.h"
-#include "wine/winbase16.h"
 #include "wine/debug.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(driver);
 
-static LPWINE_DRIVER	lpDrvItemList = NULL;
+static LPWINE_DRIVER   lpDrvItemList  /* = NULL */;
 
-WINE_MMTHREAD* (*pFnGetMMThread16)(HANDLE16 h) /* = NULL */;
+WINE_MMTHREAD*  (*pFnGetMMThread16)(HANDLE16 h) /* = NULL */;
+LPWINE_DRIVER   (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */;
+LRESULT         (*pFnCloseDriver16)(HDRVR16,LPARAM,LPARAM) /* = NULL */;
+LRESULT         (*pFnSendMessage16)(HDRVR16,UINT,LPARAM,LPARAM) /* = NULL */;
 
 /**************************************************************************
  *			DRIVER_GetNumberOfModuleRefs		[internal]
@@ -77,26 +81,23 @@ LPWINE_DRIVER	DRIVER_FindFromHDrvr(HDRVR hDrvr)
  *				DRIVER_SendMessage		[internal]
  */
 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
-					LPARAM lParam1, LPARAM lParam2)
+                                         LPARAM lParam1, LPARAM lParam2)
 {
+    LRESULT		ret = 0;
+
     if (lpDrv->dwFlags & WINE_GDF_16BIT) {
-	LRESULT		ret;
-	int		map = 0;
-	TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
-	      lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
-
-	if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
-	    ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
-	    if (map == 1)
-		DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
-	} else {
-	    ret = 0;
-	}
-	return ret;
+        /* no need to check mmsystem presence: the driver must have been opened as a 16 bit one,
+         */
+        if (pFnSendMessage16)
+            ret = pFnSendMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
+    } else {
+        TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n", 
+              lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
+        ret = lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
+        TRACE("After  call32 proc=%p drvrID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx => %08lx\n", 
+              lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2, ret);
     }
-    TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n",
-	  lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
-    return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
+    return ret;
 }
 
 /**************************************************************************
@@ -275,40 +276,6 @@ LPWINE_DRIVER	DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
 }
 
 /**************************************************************************
- *				DRIVER_TryOpenDriver16		[internal]
- *
- * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
- */
-static	LPWINE_DRIVER	DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
-{
-    LPWINE_DRIVER 	lpDrv = NULL;
-    LPCSTR		cause = 0;
-
-    TRACE("(%s, %08lX);\n", debugstr_a(sn), lParam2);
-
-    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
-    if (lpDrv == NULL) {cause = "OOM"; goto exit;}
-
-    /* FIXME: shall we do some black magic here on sn ?
-     *	drivers32 => drivers
-     *	mci32 => mci
-     * ...
-     */
-    lpDrv->d.d16.hDriver16 = OpenDriver16(fn, sn, lParam2);
-    if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
-    lpDrv->dwFlags = WINE_GDF_16BIT;
-
-    if (!DRIVER_AddToList(lpDrv, 0, lParam2)) {cause = "load failed"; goto exit;}
-
-    TRACE("=> %p\n", lpDrv);
-    return lpDrv;
- exit:
-    HeapFree(GetProcessHeap(), 0, lpDrv);
-    TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
-    return NULL;
-}
-
-/**************************************************************************
  *				OpenDriverA		        [WINMM.@]
  *				DrvOpenA			[WINMM.@]
  * (0,1,DRV_LOAD  ,0       ,0)
@@ -334,8 +301,20 @@ HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lPara
 	(lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 	goto the_end;
 
-    if (!(lpDrv = DRIVER_TryOpenDriver16(lpDriverName, lpSectionName, lParam2)))
-	TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
+    /* now we will try a 16 bit driver (and add all the glue to make it work... which
+     * is located in our mmsystem implementation)
+     * so ensure, we can load our mmsystem, otherwise just fail
+     */
+    WINMM_CheckForMMSystem();
+    if (pFnOpenDriver16 &&
+        (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam2)))
+    {
+        if (DRIVER_AddToList(lpDrv, 0, lParam2)) goto the_end;
+        HeapFree(GetProcessHeap(), 0, lpDrv);
+    }
+    TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
+    return 0;
+
  the_end:
     if (lpDrv)	TRACE("=> %08lx\n", (DWORD)lpDrv);
     return (HDRVR)lpDrv;
@@ -369,7 +348,10 @@ LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
     {
 	if (lpDrv->dwFlags & WINE_GDF_16BIT)
-	    CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
+        {
+            if (pFnCloseDriver16)
+                pFnCloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
+        }
 	else
         {
 	    DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
@@ -464,3 +446,64 @@ LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
         return 0;
     }
 }
+
+/**************************************************************************
+ * 				DriverCallback			[WINMM.@]
+ */
+BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
+			   UINT wMsg, DWORD dwUser, DWORD dwParam1,
+			   DWORD dwParam2)
+{
+    TRACE("(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
+	  dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
+
+    switch (uFlags & DCB_TYPEMASK) {
+    case DCB_NULL:
+	TRACE("Null !\n");
+	if (dwCallBack)
+	    WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
+	break;
+    case DCB_WINDOW:
+	TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
+	PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
+	break;
+    case DCB_TASK: /* aka DCB_THREAD */
+	TRACE("Task(%04lx) !\n", dwCallBack);
+	PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
+	break;
+    case DCB_FUNCTION:
+	TRACE("Function (32 bit) !\n");
+	((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
+	break;
+    case DCB_EVENT:
+	TRACE("Event(%08lx) !\n", dwCallBack);
+	SetEvent((HANDLE)dwCallBack);
+	break;
+    case 6: /* I would dub it DCB_MMTHREADSIGNAL */
+	/* this is an undocumented DCB_ value used for mmThreads
+	 * loword of dwCallBack contains the handle of the lpMMThd block
+	 * which dwSignalCount has to be incremented
+	 */     
+        if (pFnGetMMThread16)
+	{
+	    WINE_MMTHREAD*	lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
+
+	    TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
+	    /* same as mmThreadSignal16 */
+	    InterlockedIncrement(&lpMMThd->dwSignalCount);
+	    SetEvent(lpMMThd->hEvent);
+	    /* some other stuff on lpMMThd->hVxD */
+	}
+	break;
+#if 0
+    case 4:
+	/* this is an undocumented DCB_ value for... I don't know */
+	break;
+#endif
+    default:
+	WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
+	return FALSE;
+    }
+    TRACE("Done\n");
+    return TRUE;
+}

dlls/winmm/mmsystem.c

@@ -50,6 +50,9 @@ extern LONG CALLBACK MMSYSTEM_CallTo16_long_lwll (LPMMIOPROC16,LONG,WORD,LONG,LO
 /* ### stop build ### */
 
 static WINE_MMTHREAD*   WINMM_GetmmThread(HANDLE16);
+static LPWINE_DRIVER    DRIVER_OpenDriver16(LPCSTR, LPCSTR, LPARAM);
+static LRESULT          DRIVER_CloseDriver16(HDRVR16, LPARAM, LPARAM);
+static LRESULT          DRIVER_SendMessage16(HDRVR16, UINT, LPARAM, LPARAM);
 static LRESULT          MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM);
 
 /* ###################################################
@@ -81,11 +84,17 @@ BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
 	WINMM_IData->hWinMM16Instance = hinstDLL;
         /* hook in our 16 bit function pointers */
         pFnGetMMThread16  = WINMM_GetmmThread;
+        pFnOpenDriver16   = DRIVER_OpenDriver16;
+        pFnCloseDriver16  = DRIVER_CloseDriver16;
+        pFnSendMessage16  = DRIVER_SendMessage16;
         pFnMmioCallback16 = MMIO_Callback16;
 	break;
     case DLL_PROCESS_DETACH:
 	WINMM_IData->hWinMM16Instance = 0;
         pFnGetMMThread16  = NULL;
+        pFnOpenDriver16   = NULL;
+        pFnCloseDriver16  = NULL;
+        pFnSendMessage16  = NULL;
         pFnMmioCallback16 = NULL;
 	break;
     case DLL_THREAD_ATTACH:
@@ -2183,11 +2192,11 @@ void WINAPI WMMMidiRunOnce16(void)
  */
 
 /**************************************************************************
- *                              DRIVER_MapMsg32To16             [internal]
+ *				DRIVER_MapMsg32To16		[internal]
  *
  * Map a 32 bit driver message to a 16 bit driver message.
  */
-WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
+static WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
 {
     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 
@@ -2201,63 +2210,63 @@ WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
     case DRV_EXITSESSION:
     case DRV_EXITAPPLICATION:
     case DRV_POWER:
-    case DRV_CLOSE:     /* should be 0/0 */
-    case DRV_OPEN:      /* pass through */
-        /* lParam1 and lParam2 are not used */
-        ret = WINMM_MAP_OK;
-        break;
+    case DRV_CLOSE:	/* should be 0/0 */
+    case DRV_OPEN:	/* pass through */
+	/* lParam1 and lParam2 are not used */
+	ret = WINMM_MAP_OK;
+	break;
     case DRV_CONFIGURE:
     case DRV_INSTALL:
-        /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
-         * lParam2 is a pointer to DRVCONFIGINFO
-         */
-        if (*lParam2) {
+	/* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
+	 * lParam2 is a pointer to DRVCONFIGINFO
+	 */
+	if (*lParam2) {
             LPDRVCONFIGINFO16 dci16 = HeapAlloc( GetProcessHeap(), 0, sizeof(*dci16) );
-            LPDRVCONFIGINFO     dci32 = (LPDRVCONFIGINFO)(*lParam2);
+            LPDRVCONFIGINFO	dci32 = (LPDRVCONFIGINFO)(*lParam2);
 
-            if (dci16) {
-                LPSTR str1;
+	    if (dci16) {
+		LPSTR str1;
 
-                dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
+		dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
 
-                if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL)
+		if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL)
                 {
-                    dci16->lpszDCISectionName = MapLS( str1 );
-                } else {
-                    return WINMM_MAP_NOMEM;
-                }
-                if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL)
+		    dci16->lpszDCISectionName = MapLS( str1 );
+		} else {
+		    return WINMM_MAP_NOMEM;
+		}
+		if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL)
                 {
-                    dci16->lpszDCIAliasName = MapLS( str1 );
-                } else {
-                    return WINMM_MAP_NOMEM;
-                }
-            } else {
-                return WINMM_MAP_NOMEM;
-            }
-            *lParam2 = MapLS( dci16 );
-            ret = WINMM_MAP_OKMEM;
-        } else {
-            ret = WINMM_MAP_OK;
-        }
-        break;
+		    dci16->lpszDCIAliasName = MapLS( str1 );
+		} else {
+		    return WINMM_MAP_NOMEM;
+		}
+	    } else {
+		return WINMM_MAP_NOMEM;
+	    }
+	    *lParam2 = MapLS( dci16 );
+	    ret = WINMM_MAP_OKMEM;
+	} else {
+	    ret = WINMM_MAP_OK;
+	}
+	break;
     default:
-        if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
-           FIXME("Unknown message 0x%04x\n", wMsg);
-        }
-        ret = WINMM_MAP_OK;
+	if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
+	   FIXME("Unknown message 0x%04x\n", wMsg);
+	}
+	ret = WINMM_MAP_OK;
     }
     return ret;
 }
 
 /**************************************************************************
- *                              DRIVER_UnMapMsg32To16           [internal]
+ *				DRIVER_UnMapMsg32To16		[internal]
  *
  * UnMap a 32 bit driver message to a 16 bit driver message.
  */
-WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
+static WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
 {
-    WINMM_MapType       ret = WINMM_MAP_MSGERROR;
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
 
     switch (wMsg) {
     case DRV_LOAD:
@@ -2271,31 +2280,99 @@ WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
     case DRV_POWER:
     case DRV_OPEN:
     case DRV_CLOSE:
-        /* lParam1 and lParam2 are not used */
-        break;
+	/* lParam1 and lParam2 are not used */
+	break;
     case DRV_CONFIGURE:
     case DRV_INSTALL:
-        /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
-        if (lParam2) {
-            LPDRVCONFIGINFO16   dci16 = MapSL(lParam2);
+	/* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
+	if (lParam2) {
+	    LPDRVCONFIGINFO16	dci16 = MapSL(lParam2);
             HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCISectionName) );
             HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCIAliasName) );
             UnMapLS( lParam2 );
             UnMapLS( dci16->lpszDCISectionName );
             UnMapLS( dci16->lpszDCIAliasName );
             HeapFree( GetProcessHeap(), 0, dci16 );
-        }
-        ret = WINMM_MAP_OK;
-        break;
+	}
+	ret = WINMM_MAP_OK;
+	break;
+    default:
+	if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
+	    FIXME("Unknown message 0x%04x\n", wMsg);
+	}
+	ret = WINMM_MAP_OK;
+    }
+    return ret;
+}
+
+/**************************************************************************
+ *				DRIVER_TryOpenDriver16		[internal]
+ *
+ * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
+ */
+static	LPWINE_DRIVER	DRIVER_OpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
+{
+    LPWINE_DRIVER 	lpDrv = NULL;
+    LPCSTR		cause = 0;
+
+    TRACE("(%s, %08lX);\n", debugstr_a(sn), lParam2);
+
+    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
+    if (lpDrv == NULL) {cause = "OOM"; goto exit;}
+
+    /* FIXME: shall we do some black magic here on sn ?
+     *	drivers32 => drivers
+     *	mci32 => mci
+     * ...
+     */
+    lpDrv->d.d16.hDriver16 = OpenDriver16(fn, sn, lParam2);
+    if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
+    lpDrv->dwFlags = WINE_GDF_16BIT;
+
+    TRACE("=> %p\n", lpDrv);
+    return lpDrv;
+ exit:
+    HeapFree(GetProcessHeap(), 0, lpDrv);
+    TRACE("Unable to load 16 bit module %s: %s\n", debugstr_a(fn), cause);
+    return NULL;
+}
+
+/******************************************************************
+ *		DRIVER_SendMessage16
+ *
+ *
+ */
+static LRESULT  DRIVER_SendMessage16(HDRVR16 hDrv16, UINT msg, 
+                                     LPARAM lParam1, LPARAM lParam2)
+{
+    LRESULT             ret = 0;
+    WINMM_MapType	map;
+
+    TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
+          hDrv16, msg, lParam1, lParam2);
+
+    switch (map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) {
+    case WINMM_MAP_OKMEM:
+    case WINMM_MAP_OK:
+        ret = SendDriverMessage16(hDrv16, msg, lParam1, lParam2);
+        if (map == WINMM_MAP_OKMEM)
+            DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
     default:
-        if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
-            FIXME("Unknown message 0x%04x\n", wMsg);
-        }
-        ret = WINMM_MAP_OK;
+        break;
     }
     return ret;
 }
 
+/******************************************************************
+ *		DRIVER_CloseDriver16
+ *
+ *
+ */
+static LRESULT DRIVER_CloseDriver16(HDRVR16 hDrv16, LPARAM lParam1, LPARAM lParam2)
+{
+    return CloseDriver16(hDrv16, lParam1, lParam2);
+}
+
 /**************************************************************************
  * 				DrvOpen	       		[MMSYSTEM.1100]
  */

dlls/winmm/playsound.c

@@ -505,63 +505,3 @@ UINT WINAPI mmsystemGetVersion(void)
     TRACE("3.10 (Win95?)\n");
     return 0x030a;
 }
-
-/**************************************************************************
- * 				DriverCallback			[WINMM.@]
- */
-BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
-			   UINT wMsg, DWORD dwUser, DWORD dwParam1,
-			   DWORD dwParam2)
-{
-    TRACE("(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
-	  dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
-
-    switch (uFlags & DCB_TYPEMASK) {
-    case DCB_NULL:
-	TRACE("Null !\n");
-	if (dwCallBack)
-	    WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
-	break;
-    case DCB_WINDOW:
-	TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
-	PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
-	break;
-    case DCB_TASK: /* aka DCB_THREAD */
-	TRACE("Task(%04lx) !\n", dwCallBack);
-	PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
-	break;
-    case DCB_FUNCTION:
-	TRACE("Function (32 bit) !\n");
-	((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
-	break;
-    case DCB_EVENT:
-	TRACE("Event(%08lx) !\n", dwCallBack);
-	SetEvent((HANDLE)dwCallBack);
-	break;
-    case 6: /* I would dub it DCB_MMTHREADSIGNAL */
-	/* this is an undocumented DCB_ value used for mmThreads
-	 * loword of dwCallBack contains the handle of the lpMMThd block
-	 * which dwSignalCount has to be incremented
-	 */
-	{
-	    WINE_MMTHREAD*	lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
-
-	    TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
-	    /* same as mmThreadSignal16 */
-	    InterlockedIncrement(&lpMMThd->dwSignalCount);
-	    SetEvent(lpMMThd->hEvent);
-	    /* some other stuff on lpMMThd->hVxD */
-	}
-	break;
-#if 0
-    case 4:
-	/* this is an undocumented DCB_ value for... I don't know */
-	break;
-#endif
-    default:
-	WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
-	return FALSE;
-    }
-    TRACE("Done\n");
-    return TRUE;
-}

dlls/winmm/winemm.h

@@ -290,8 +290,6 @@ void    	TIME_MMTimeStart(void);
 void		TIME_MMTimeStop(void);
 
 /* temporary definitions */
-WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2);
-WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2);
 WINMM_MapType	MCI_MapMsg16To32A  (WORD uDevType, WORD wMsg,                DWORD* lParam);
 WINMM_MapType	MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg,                DWORD  lParam);
 WINMM_MapType	MCI_MapMsg32ATo16  (WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam);
@@ -343,6 +341,9 @@ extern LPWINE_MM_IDATA  WINMM_IData;
  * NULL otherwise
  */
 extern LRESULT          (*pFnMmioCallback16)(SEGPTR,LPMMIOINFO,UINT,LPARAM,LPARAM);
+extern  LPWINE_DRIVER   (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM);
+extern  LRESULT         (*pFnCloseDriver16)(HDRVR16,LPARAM,LPARAM);
+extern  LRESULT         (*pFnSendMessage16)(HDRVR16,UINT,LPARAM,LPARAM);
 extern WINE_MMTHREAD*   (*pFnGetMMThread16)(HANDLE16);
 
 /* HANDLE16 -> HANDLE conversions */